Phase 02 - Lesson 14

Naive Bayes

This lesson includes a graded coding exercise that runs in your browser, unlocked with lifetime access.

A suposição "ingênua" está errada e funciona de qualquer maneira. Essa é a beleza disso.

Tipo: Construir Idioma: Python Pré-requisitos: Fase 2, Lições 01-07 (classificação, teorema Bayes') Tempo: ~75 minutos

Objetivos de aprendizagem

• Implementar Multinomial Naive Bayes do zero com suavização de Laplace para classificação de texto
• Explique por que a suposição ingênua de independência é matematicamente errada, mas produz classificações de classe corretas na prática
• Compare as variantes Multinomial, Bernoulli e Gaussiana Naive Bayes e selecione a correta para um determinado tipo de recurso
• Avalie Naive Bayes em relação à regressão logística em dados esparsos de alta dimensão e explique a compensação entre viés e variância no trabalho

O problema

Você precisa classificar o texto. E-mails em spam ou não-spam. As avaliações dos clientes são positivas ou negativas. Tickets de suporte em categorias. Você tem milhares de recursos (um por palavra) e dados de treinamento limitados.

A maioria dos classificadores engasga aqui. A regressão logística precisa de amostras suficientes para estimar milhares de pesos de forma confiável. As árvores de decisão se dividem em uma palavra por vez e se ajustam descontroladamente. KNN em 10.000 dimensões não tem sentido porque cada ponto está igualmente distante de todos os outros pontos.

Naive Bayes lida com isso. Ele faz uma suposição matematicamente errada (que cada recurso é independente de qualquer outro recurso fornecido na classe) e ainda supera modelos "mais inteligentes" na classificação de texto, especialmente com pequenos conjuntos de treinamento. Ele treina em uma única passagem pelos dados. Ele pode ser dimensionado para milhões de recursos. Produz estimativas de probabilidade (embora muitas vezes mal calibradas devido à suposição de independência).

Entender por que uma suposição errada leva a boas previsões ensina algo fundamental sobre aprendizado de máquina: o melhor modelo não é o mais correto, é aquele com a melhor compensação entre viés e variância para seus dados.

O Conceito

Bayes' Teorema (revisão rápida)

O teorema Bayes' inverte as probabilidades condicionais:

P(class | features) = P(features | class) * P(class) / P(features)

Queremos P(class | features) - a probabilidade de um documento pertencer a uma classe, dadas as palavras nele contidas. Podemos calcular isso a partir de:

• P(features | class) -- a probabilidade de ver essas palavras em documentos desta classe
• P(class) -- a probabilidade anterior da classe (quão comum é o spam em geral?)
• P(features) -- a evidência, a mesma para todas as classes, então podemos ignorá-la ao comparar

A classe com maior P(class | features) vence.

A suposição ingênua da independência

Computar P(features | class) requer exatamente estimar a probabilidade conjunta de todos os recursos juntos. Com um vocabulário de 10.000 palavras, você precisaria estimar uma distribuição de mais de 2^10.000 combinações possíveis. Impossível.

A suposição ingênua: todo recurso é condicionalmente independente, dada a classe.

P(w1, w2, ..., wn | class) = P(w1 | class) * P(w2 | class) * ... * P(wn | class)

Em vez de uma distribuição conjunta impossível, você estima n distribuições simples por recurso. Cada um precisa apenas de uma contagem.

Esta suposição está obviamente errada. As palavras “máquina” e “aprendizado” não são independentes em nenhum documento. Mas o classificador não precisa de estimativas de probabilidade corretas. Precisa de classificações corretas – qual classe tem a maior probabilidade. A suposição de independência introduz erros sistemáticos, mas esses erros afetam todas as classes de forma semelhante, de modo que a classificação permanece correta.

Por que ainda funciona

Três razões:

1. Classificação acima da calibração. A classificação só precisa que a classe com melhor classificação esteja correta. Mesmo que P(spam) = 0,99999 quando a probabilidade verdadeira for 0,7, o classificador ainda escolhe o spam corretamente. Não precisamos de probabilidades corretas. Precisamos do vencedor correto.

2. Viés alto, variância baixa. A suposição de independência é um forte a priori. Isso restringe fortemente o modelo, o que evita overfitting. Com dados de treinamento limitados, um modelo ligeiramente errado, mas estável, supera um modelo que é teoricamente correto, mas extremamente instável. Esta é a compensação entre viés e variância em ação.

3. A redundância de recursos é cancelada. Os recursos correlacionados fornecem evidências redundantes. O classificador conta duas vezes essa evidência, mas também conta duas vezes para a classe correta. Se “máquina” e “aprendizado” sempre aparecem juntos, ambos fornecem evidências para a classe “tecnologia”. NB conta-os duas vezes, mas conta-os duas vezes para a classe certa.

Uma quarta razão prática: Naive Bayes é extremamente rápido. O treinamento é uma única passagem pelas frequências de contagem de dados. A previsão é uma multiplicação de matrizes. Você pode treinar um milhão de documentos em segundos. Essa velocidade significa que você pode iterar mais rápido, testar mais conjuntos de recursos e executar mais experimentos do que com modelos mais lentos.

A matemática passo a passo

Vejamos um exemplo concreto. Suponha que temos duas classes: spam e não spam. Nosso vocabulário contém três palavras: “grátis”, “dinheiro”, “reunião”.

Dados de treinamento:

• E-mails de spam mencionam "grátis" 80 vezes, "dinheiro" 60 vezes, "reunião" 10 vezes (150 palavras no total)
• E-mails não spam mencionam "grátis" 5 vezes, "dinheiro" 10 vezes, "reunião" 100 vezes (115 palavras no total)
• 40% dos e-mails são spam, 60% não são spam

Com suavização de Laplace (alfa=1):

P(free | spam)    = (80 + 1) / (150 + 3) = 81/153 = 0.529
P(money | spam)   = (60 + 1) / (150 + 3) = 61/153 = 0.399
P(meeting | spam) = (10 + 1) / (150 + 3) = 11/153 = 0.072

P(free | not-spam)    = (5 + 1) / (115 + 3) = 6/118 = 0.051
P(money | not-spam)   = (10 + 1) / (115 + 3) = 11/118 = 0.093
P(meeting | not-spam) = (100 + 1) / (115 + 3) = 101/118 = 0.856

O novo e-mail contém: “grátis” (2 vezes), “dinheiro” (1 vez), “reunião” (0 vezes).

log P(spam | email) = log(0.4) + 2*log(0.529) + 1*log(0.399) + 0*log(0.072)
                    = -0.916 + 2*(-0.637) + (-0.919) + 0
                    = -3.109

log P(not-spam | email) = log(0.6) + 2*log(0.051) + 1*log(0.093) + 0*log(0.856)
                        = -0.511 + 2*(-2.976) + (-2.375) + 0
                        = -8.838

O spam vence por uma grande margem. A palavra “grátis” aparecendo duas vezes é uma forte evidência de spam. Observe que o não aparecimento de "reunião" contribui com zero para ambas as somas de log (0 * log(P)) - no Multinomial NB, palavras ausentes não têm efeito. É Bernoulli NB quem modela explicitamente a ausência de palavras.

Três variantes

Naive Bayes vem em três sabores. Cada modelo P(feature | class) diferentemente.

Multinomial Naive Bayes

Modela cada recurso como uma contagem. Melhor para dados de texto onde os recursos são frequências de palavras ou valores TF-IDF.

P(word_i | class) = (count of word_i in class + alpha) / (total words in class + alpha * vocab_size)

O alpha é a suavização de Laplace (explicada abaixo). Esta variante é o carro-chefe para classificação de texto.

Gaussiana Naive Bayes

Modela cada recurso como uma distribuição normal. Melhor para recursos contínuos.

P(x_i | class) = (1 / sqrt(2 * pi * var)) * exp(-(x_i - mean)^2 / (2 * var))

Cada classe obtém sua própria média e variação por recurso. Isso funciona bem quando os recursos realmente seguem uma curva em forma de sino dentro de cada classe.

Bernoulli Naive Bayes

Modela cada recurso como binário (presente ou ausente). Melhor para textos curtos ou vetores de recursos binários.

P(word_i | class) = (docs in class containing word_i + alpha) / (total docs in class + 2 * alpha)

Ao contrário do Multinomial, Bernoulli penaliza explicitamente a ausência de uma palavra. Se “grátis” normalmente aparece em spam, mas está ausente neste e-mail, Bernoulli conta isso como evidência contra spam.

Quando usar cada variante

Suavização Laplace

O que acontece quando uma palavra aparece nos dados de teste, mas nunca apareceu nos dados de treinamento de uma classe específica?

Sem suavização: P(word | class) = 0/N = 0. Um zero multiplicado por todo o produto dá P(class | features) = 0, independentemente de todas as outras evidências. Uma única palavra invisível destrói toda a previsão, não importa quantas outras evidências a apoiem.

A suavização de Laplace adiciona uma pequena contagem alpha (geralmente 1) a cada contagem de recursos:

P(word_i | class) = (count(word_i, class) + alpha) / (total_words_in_class + alpha * vocab_size)

Com alfa = 1, cada palavra obtém pelo menos uma pequena probabilidade. A palavra “descombobular” que aparece em um e-mail de teste não elimina mais a probabilidade de spam. A suavização tem uma interpretação bayesiana: equivale a colocar um Dirichlet uniforme antes das distribuições de palavras.

Alfa mais alto significa suavização mais forte (distribuições mais uniformes). Alfa inferior significa que o modelo confia mais nos dados. Alpha é um hiperparâmetro que você ajusta.

O efeito de alfa:

Computação Log-Espaço

Multiplicar centenas de probabilidades (cada uma menor que 1) causa estouro negativo de ponto flutuante. O produto torna-se zero em ponto flutuante, embora o valor verdadeiro seja um número positivo muito pequeno.

A solução: trabalhar no espaço de log. Em vez de multiplicar probabilidades, some seus logaritmos:

log P(class | x1, x2, ..., xn) = log P(class) + sum_i log P(xi | class)

Isso transforma a previsão em um produto escalar:

log_scores = X @ log_feature_probs.T + log_class_priors
prediction = argmax(log_scores)

Multiplicação de matrizes. É por isso que a previsão Naive Bayes é tão rápida – é a mesma operação que um modelo linear de camada única.

Naive Bayes vs Regressão Logística

Ambos são classificadores lineares para texto. A diferença está no que eles modelam.

Regra prática: comece com Naive Bayes. Se você tiver dados suficientes e platôs de NB, mude para a regressão logística.

Classificação Pipeline

flowchart LR
    A[Raw Text] --> B[Tokenize]
    B --> C[Build Vocabulary]
    C --> D[Count Word Frequencies]
    D --> E[Apply Smoothing]
    E --> F[Compute Log Probabilities]
    F --> G[Predict: argmax P class given words]

    style A fill:#f9f,stroke:#333
    style G fill:#9f9,stroke:#333

Na prática, trabalhamos no espaço de log para evitar underflow de ponto flutuante. Em vez de multiplicar muitas probabilidades pequenas, somamos seus logaritmos:

log P(class | features) = log P(class) + sum_i log P(feature_i | class)

Construa

O código em code/naive_bayes.py implementa MultinomialNB e GaussianNB do zero.

MultinomialNB

A implementação do zero:

1. fit(X, y): Para cada classe, conte a frequência de cada recurso. Adicione suavização de Laplace. Calcular probabilidades de log. Armazene os antecedentes das aulas (registro das frequências das aulas).

2. predict_log_proba(X): Para cada amostra, calcule o log P(class) + soma do log P(feature_i | class) para todas as classes. Esta é uma multiplicação de matrizes: X @ log_probs.T + log_priors.

3. predict(X): Retorna a classe com maior probabilidade de log.

class MultinomialNB:
    def __init__(self, alpha=1.0):
        self.alpha = alpha

    def fit(self, X, y):
        classes = np.unique(y)
        n_classes = len(classes)
        n_features = X.shape[1]

        self.classes_ = classes
        self.class_log_prior_ = np.zeros(n_classes)
        self.feature_log_prob_ = np.zeros((n_classes, n_features))

        for i, c in enumerate(classes):
            X_c = X[y == c]
            self.class_log_prior_[i] = np.log(X_c.shape[0] / X.shape[0])
            counts = X_c.sum(axis=0) + self.alpha
            self.feature_log_prob_[i] = np.log(counts / counts.sum())

        return self

O principal insight: após o ajuste, a previsão é apenas uma multiplicação de matrizes mais um viés. É por isso que Naive Bayes é tão rápido.

GaussianNB

Para recursos contínuos, estimamos a média e a variância por classe por recurso:

class GaussianNB:
    def __init__(self):
        pass

    def fit(self, X, y):
        classes = np.unique(y)
        self.classes_ = classes
        self.means_ = np.zeros((len(classes), X.shape[1]))
        self.vars_ = np.zeros((len(classes), X.shape[1]))
        self.priors_ = np.zeros(len(classes))

        for i, c in enumerate(classes):
            X_c = X[y == c]
            self.means_[i] = X_c.mean(axis=0)
            self.vars_[i] = X_c.var(axis=0) + 1e-9
            self.priors_[i] = X_c.shape[0] / X.shape[0]

        return self

A previsão usa o PDF gaussiano por recurso, multiplicado pelos recursos (adicionado no espaço de log).

Demonstração: Classificação de texto

O código gera dados sintéticos que simulam duas classes (artigos de tecnologia versus artigos de esportes). Cada classe tem uma distribuição de frequência de palavras diferente. MultinomialNB os classifica usando contagem de palavras.

Os dados sintéticos funcionam assim: criamos 200 “palavras” (colunas de recursos). As palavras de 0 a 39 têm alta frequência em artigos de tecnologia e baixa em esportes. As palavras 80-119 têm alta frequência em esportes e baixa em tecnologia. As palavras 40-79 têm frequência média em ambos. Isto cria um cenário realista onde algumas palavras são fortes indicadores de classe e outras são ruído.

Demonstração: recursos contínuos

O código gera dados semelhantes ao Iris (3 classes, 4 recursos, clusters gaussianos). GaussianNB classifica usando média e variância por classe. Cada classe tem um centro diferente (vetor médio) e uma dispersão (variância) diferente, imitando dados do mundo real onde as medições diferem sistematicamente entre categorias.

O código também demonstra:

• Comparação de suavização: Treinamento MultinomialNB com diferentes valores alfa para mostrar o efeito da força de suavização na precisão.
• Experimento de tamanho de treinamento: como a precisão do NB melhora à medida que os dados de treinamento aumentam de 20 para 1.600 amostras. O NB atinge uma precisão decente mesmo com poucas amostras – esta é sua principal vantagem.
• Matriz de confusão: Precisão por classe, recall e score F1 para mostrar onde NB comete erros.

Velocidade de previsão

Naive Bayes a previsão é uma multiplicação de matrizes. Para n amostras com d recursos e k classes:

• MultinomialNB: multiplicação de uma matriz (n x d) @ (d x k) = O(n * d * k)
• GaussianNB: n * k avaliações Gaussianas de PDF, cada uma sobre d recursos = O(n * d * k)

Ambos são lineares em todas as dimensões. Compare isso com KNN (que requer cálculo de distância para todos os pontos de treinamento) ou SVM com kernel RBF (que requer avaliação do kernel em relação a todos os vetores de suporte). NB é mais rápido em ordens de magnitude no momento da previsão.

Use-o

Com o sklearn, ambas as variantes são de uma linha:

from sklearn.naive_bayes import GaussianNB, MultinomialNB

gnb = GaussianNB()
gnb.fit(X_train, y_train)
print(f"GaussianNB accuracy: {gnb.score(X_test, y_test):.3f}")

mnb = MultinomialNB(alpha=1.0)
mnb.fit(X_train_counts, y_train)
print(f"MultinomialNB accuracy: {mnb.score(X_test_counts, y_test):.3f}")

Para classificação de texto com sklearn:

from sklearn.feature_extraction.text import CountVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.pipeline import Pipeline

text_clf = Pipeline([
    ("vectorizer", CountVectorizer()),
    ("classifier", MultinomialNB(alpha=1.0)),
])

text_clf.fit(train_texts, train_labels)
accuracy = text_clf.score(test_texts, test_labels)

O código em naive_bayes.py compara implementações do zero com sklearn nos mesmos dados para verificar a correção.

TF-IDF com Naive Bayes

A contagem bruta de palavras dá a cada palavra o mesmo peso por ocorrência. Mas palavras comuns como “o” e “é” aparecem frequentemente em todas as aulas – elas não contêm nenhuma informação. TF-IDF (Frequência de Termo - Frequência Inversa de Documento) reduz o peso de palavras comuns e aumenta o peso de palavras raras e discriminativas.

from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.naive_bayes import MultinomialNB
from sklearn.pipeline import Pipeline

text_clf = Pipeline([
    ("tfidf", TfidfVectorizer()),
    ("classifier", MultinomialNB(alpha=0.1)),
])

Os valores TF-IDF não são negativos, portanto funcionam com MultinomialNB. A combinação TF-IDF + MultinomialNB é uma das bases mais fortes para classificação de texto. Freqüentemente supera modelos mais complexos em conjuntos de dados com menos de 10.000 amostras de treinamento.

BernoulliNB para texto curto

Para textos curtos (tweets, SMS, mensagens de bate-papo), BernoulliNB pode superar MultinomialNB. Textos curtos têm baixa contagem de palavras, portanto, as informações de frequência das quais MultinomialNB depende são ruidosas. BernoulliNB só se preocupa com presença ou ausência, o que é mais confiável com textos curtos.

from sklearn.naive_bayes import BernoulliNB
from sklearn.feature_extraction.text import CountVectorizer

text_clf = Pipeline([
    ("vectorizer", CountVectorizer(binary=True)),
    ("classifier", BernoulliNB(alpha=1.0)),
])

O sinalizador binary=True em CountVectorizer converte todas as contagens em 0/1. Sem ele, BernoulliNB ainda funciona, mas está vendo contagens para as quais não foi projetado.

Calibrando Probabilidades NB

As probabilidades do NB estão mal calibradas. Quando NB diz P(spam) = 0,95, a verdadeira probabilidade pode ser 0,7. Se você precisar de estimativas de probabilidade confiáveis ​​(por exemplo, para definir um limite ou combinar com outros modelos), use o CalibratedClassifierCV do sklearn:

from sklearn.calibration import CalibratedClassifierCV

calibrated_nb = CalibratedClassifierCV(MultinomialNB(), cv=5, method="sigmoid")
calibrated_nb.fit(X_train, y_train)
proba = calibrated_nb.predict_proba(X_test)

Isso se ajusta a uma regressão logística sobre as pontuações brutas do NB usando validação cruzada. As probabilidades resultantes estão muito mais próximas das verdadeiras frequências da classe.

Dicas comuns

1. Valores de recursos negativos. MultinomialNB requer recursos não negativos. Se você tiver valores negativos (como TF-IDF com certas configurações ou recursos padronizados), use GaussianNB ou mude os recursos para positivos.

2. Recursos de variação zero. GaussianNB divide por variação. Se um recurso tiver variação zero para uma classe (todos os valores idênticos), o cálculo de probabilidade será interrompido. O código adiciona um pequeno termo de suavização (1e-9) a todas as variações para evitar isso.

3. Desequilíbrio de classe. Se 99% dos e-mails não são spam, o P(não-spam) = 0,99 anterior é tão forte que supera a evidência de probabilidade. Você pode definir as classes anteriores manualmente ou usar o parâmetro class_prior no sklearn.

4. Escalonamento de recursos. MultinomialNB não precisa de escalonamento (funciona em contagens). GaussianNB também não precisa de escalonamento (ele estima estatísticas por recurso). Esta é uma vantagem sobre a regressão logística e SVM, que são sensíveis às escalas de recursos.

Envie

Esta lição produz:

• outputs/skill-naive-bayes-chooser.md - uma habilidade de decisão para escolher a variante NB certa
• code/naive_bayes.py -- MultinomialNB e GaussianNB do zero, com comparação com sklearn

Quando Naive Bayes falha

NB falha quando a suposição de independência causa classificações incorretas (não apenas probabilidades incorretas). Isso acontece quando:

1. Fortes interações de recursos. Se a classe depender da combinação de dois recursos, mas não de nenhum deles sozinho (padrões do tipo XOR), o NB irá perdê-la completamente. Cada característica por si só não fornece nenhuma evidência e NB não pode combiná-las de forma não linear.

2. Recursos altamente correlacionados com evidências opostas. Se o recurso A diz "spam" e o recurso B diz "não-spam", mas A e B estão perfeitamente correlacionados (eles sempre concordam na realidade), NB verá evidências conflitantes onde não há nenhuma.

3. Conjuntos de treinamento muito grandes. Com dados suficientes, modelos discriminativos como a regressão logística aprendem o verdadeiro limite de decisão e superam o NB. A suposição de independência que ajudou com pequenos dados agora impede o modelo.

Na prática, estes modos de falha são raros para classificação de texto. As características do texto são numerosas, individualmente fracas e os erros da suposição de independência tendem a ser anulados. Para dados tabulares com poucos recursos fortemente correlacionados, considere primeiro a regressão logística ou modelos baseados em árvore.

Exercícios

1. Experimento de suavização. Treine MultinomialNB em dados de texto com valores alfa de 0,01, 0,1, 1,0, 10,0 e 100,0. Precisão do gráfico vs alfa. Onde o desempenho atinge o pico? Por que alfa muito alto dói?

2. Teste de independência de recursos. Faça um conjunto de dados de texto real. Escolha duas palavras que estejam obviamente correlacionadas (“máquina” e “aprendizado”). Calcule P(palavra1 | classe) * P(palavra2 | classe) e compare com P(palavra1 AND palavra2 | classe). Quão errada está a suposição de independência? Isso afeta a precisão da classificação?

3. Implementação de Bernoulli. Estenda o código com uma classe BernoulliNB. Converta saco de palavras em binário (presente/ausente) e compare a precisão com MultinomialNB em dados de texto. Quando Bernoulli vence?

4. NB vs Regressão Logística. Treine ambos em dados de texto. Comece com 100 amostras de treinamento e aumente para 10.000. Precisão do gráfico versus tamanho do conjunto de treinamento para ambos. Em que ponto a regressão logística ultrapassa Naive Bayes?

5. Filtro de spam. Crie um classificador de spam completo: tokenize o texto bruto do e-mail, construa vocabulário, crie recursos de conjunto de palavras, treine MultinomialNB, avalie com precisão e recuperação (não apenas precisão - por quê?).

Termos-chave

Leitura Adicional

• scikit-learn Naive Bayes docs - todas as três variantes com detalhes matemáticos
• McCallum e Nigam, Uma comparação de modelos de eventos para Naive Bayes Classificação de texto (1998) - a comparação clássica de Multinomial vs Bernoulli para texto
• Rennie et al., Tackling the Poor Assumptions of Naive Bayes Text Classifiers (2003) - melhorias no NB para texto
• Ng e Jordan, On Discriminative vs. Generative Classifiers (2001) - prova que NB converge mais rápido que LR com menos dados