Phase 02 - Lesson 14

Naive Bayes

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

La suposición "ingenua" es incorrecta y funciona de todos modos. Esa es la belleza de esto.

Tipo: Construcción Idioma: Python Requisitos previos: Fase 2, Lecciones 01-07 (clasificación, teorema Bayes') Tiempo: ~75 minutos

Objetivos de aprendizaje

• Implementar Multinomial Naive Bayes desde cero con suavizado de Laplace para clasificación de texto
• Explicar por qué el ingenuo supuesto de independencia es matemáticamente incorrecto pero produce clasificaciones de clases correctas en la práctica.
• Compare las variantes multinomial, Bernoulli y gaussiana Naive Bayes y seleccione la correcta para un tipo de característica determinado
• Evalúe Naive Bayes frente a la regresión logística en datos dispersos de alta dimensión y explique la compensación entre sesgo y varianza en funcionamiento.

El problema

Necesitas clasificar el texto. Correos electrónicos como spam o no spam. Comentarios de los clientes en positivos o negativos. Tickets de soporte en categorías. Tienes miles de funciones (una por palabra) y datos de entrenamiento limitados.

La mayoría de los clasificadores se ahogan aquí. La regresión logística necesita suficientes muestras para estimar miles de pesos de manera confiable. Los árboles de decisión se dividen en una palabra a la vez y se sobreajustan enormemente. KNN en 10.000 dimensiones no tiene sentido porque cada punto está igualmente lejos de todos los demás puntos.

Naive Bayes maneja esto. Hace una suposición matemáticamente incorrecta (que cada característica es independiente de cualquier otra característica dada la clase) y aún supera a los modelos "más inteligentes" en clasificación de texto, especialmente con conjuntos de entrenamiento pequeños. Se entrena en un solo paso a través de los datos. Se adapta a millones de funciones. Produce estimaciones de probabilidad (aunque a menudo mal calibradas debido al supuesto de independencia).

Comprender por qué una suposición errónea conduce a buenas predicciones le enseña algo fundamental sobre el machine learning: el mejor modelo no es el más correcto, sino el que tiene la mejor compensación entre sesgo y varianza para sus datos.

El concepto

Teorema de Bayes' (revisión rápida)

El teorema de Bayes' invierte las probabilidades condicionales:

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

Queremos P(class | features): la probabilidad de que un documento pertenezca a una clase dadas las palabras que contiene. Podemos calcular esto a partir de:

• P(features | class) -- la probabilidad de ver estas palabras en documentos de esta clase
• P(class) -- la probabilidad previa de la clase (¿qué tan común es el spam en general?)
• P(features) -- la evidencia, la misma para todas las clases, por lo que podemos ignorarla al comparar

La clase con el P(class | features) más alto gana.

La ingenua suposición de la independencia

Calcular P(features | class) exactamente requiere estimar la probabilidad conjunta de todas las características juntas. Con un vocabulario de 10.000 palabras, necesitarías estimar una distribución de más de 2^10.000 combinaciones posibles. Imposible.

La suposición ingenua: cada característica es condicionalmente independiente dada la clase.

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

En lugar de una distribución conjunta imposible, se estiman n distribuciones simples por característica. Cada uno necesita sólo un recuento.

Esta suposición es obviamente errónea. Las palabras "máquina" y "aprendizaje" no son independientes en ningún documento. Pero el clasificador no necesita estimaciones de probabilidad correctas. Necesita clasificaciones correctas: qué clase tiene la mayor probabilidad. El supuesto de independencia introduce errores sistemáticos, pero esos errores afectan a todas las clases de manera similar, por lo que la clasificación sigue siendo correcta.

Por qué todavía funciona

Tres razones:

1. Clasificación sobre calibración. La clasificación solo necesita que la clase mejor clasificada sea correcta. Incluso si P(spam) = 0,99999 cuando la probabilidad real es 0,7, el clasificador sigue seleccionando el spam correctamente. No necesitamos probabilidades correctas. Necesitamos el ganador correcto.

2. Alto sesgo, baja varianza. El supuesto de independencia es un fuerte precedente. Restringe fuertemente el modelo, lo que evita el sobreajuste. Con datos de entrenamiento limitados, un modelo que es ligeramente incorrecto pero estable supera a un modelo que es teóricamente correcto pero tremendamente inestable. Ésta es la compensación sesgo-varianza en acción.

3. La redundancia de funciones se cancela. Las funciones correlacionadas proporcionan evidencia redundante. El clasificador cuenta dos veces esta evidencia, pero también la cuenta dos veces para la clase correcta. Si "máquina" y "aprendizaje" siempre aparecen juntos, ambos proporcionan evidencia para la clase "tecnología". NB los cuenta dos veces, pero los cuenta dos veces para la clase correcta.

Una cuarta razón práctica: Naive Bayes es extremadamente rápido. El entrenamiento es un solo paso a través de las frecuencias de conteo de datos. La predicción es una multiplicación de matrices. Puedes entrenar con un millón de documentos en segundos. Esta velocidad significa que puede iterar más rápido, probar más conjuntos de funciones y ejecutar más experimentos que con modelos más lentos.

Las Matemáticas Paso a Paso

Sigamos un ejemplo concreto. Supongamos que tenemos dos clases: spam y no spam. Nuestro vocabulario tiene tres palabras: "gratis", "dinero", "reunión".

Datos de entrenamiento:

• Los correos electrónicos no deseados mencionan "gratis" 80 veces, "dinero" 60 veces y "reunión" 10 veces (150 palabras en total).
• Los correos electrónicos que no son spam mencionan "gratis" 5 veces, "dinero" 10 veces y "reunión" 100 veces (115 palabras en total).
• El 40% de los correos electrónicos son spam, el 60% no son spam.

Con suavizado 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

El nuevo correo electrónico contiene: "gratis" (2 veces), "dinero" (1 vez), "reunión" (0 veces).

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

El spam gana por un amplio margen. La palabra "gratis" que aparece dos veces es una fuerte evidencia de spam. Tenga en cuenta que la "reunión" que no aparece contribuye con cero a ambas sumas logarítmicas (0 * log(P)); en Multinomial NB, las palabras ausentes no tienen ningún efecto. Es Bernoulli NB quien modela explícitamente la ausencia de palabras.

Tres variantes

Naive Bayes viene en tres sabores. Cada uno modela P(feature | class) de manera diferente.

Multinomial Naive Bayes

Modela cada característica como un recuento. Lo mejor para datos de texto donde las características son frecuencias de palabras o valores TF-IDF.

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

El alpha es el suavizado de Laplace (explicado a continuación). Esta variante es el caballo de batalla para la clasificación de textos.

Gaussiano Naive Bayes

Modela cada característica como una distribución normal. Lo mejor para funciones continuas.

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

Cada clase tiene su propia media y varianza por característica. Esto funciona bien cuando las características realmente siguen una curva de campana dentro de cada clase.

Bernoulli Naive Bayes

Modela cada característica como binaria (presente o ausente). Lo mejor para textos cortos o vectores de características binarias.

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

A diferencia de Multinomial, Bernoulli penaliza explícitamente la ausencia de una palabra. Si "gratis" suele aparecer en el spam pero no aparece en este correo electrónico, Bernoulli lo considera prueba contra el spam.

Cuándo utilizar cada variante

Suavizado de Laplace

¿Qué sucede cuando una palabra aparece en los datos de la prueba pero nunca apareció en los datos de entrenamiento de una clase en particular?

Sin alisar: P(word | class) = 0/N = 0. Un cero multiplicado por todo el producto da P(class | features) = 0, independientemente de cualquier otra evidencia. Una sola palabra invisible destruye toda la predicción, sin importar cuánta evidencia la respalde.

El suavizado de Laplace agrega un pequeño recuento alpha (normalmente 1) a cada recuento de funciones:

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

Con alfa=1, cada palabra tiene al menos una pequeña probabilidad. La palabra "discombobulate" que aparece en un correo electrónico de prueba ya no elimina la probabilidad de spam. El suavizado tiene una interpretación bayesiana: equivale a colocar un Dirichlet uniforme antes de las distribuciones de palabras.

Un alfa más alto significa un suavizado más fuerte (distribuciones más uniformes). Un alfa más bajo significa que el modelo confía más en los datos. Alfa es un hiperparámetro que usted ajusta.

El efecto de alfa:

Cálculo del espacio de registro

Multiplicar cientos de probabilidades (cada una menor que 1) provoca un desbordamiento insuficiente de punto flotante. El producto se vuelve cero en coma flotante aunque el valor real sea un número positivo muy pequeño.

La solución: trabajar en el espacio de registro. En lugar de multiplicar probabilidades, suma sus logaritmos:

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

Esto convierte la predicción en un producto escalar:

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

Multiplicación de matrices. Por eso la predicción Naive Bayes es tan rápida: es la misma operación que un modelo lineal de una sola capa.

Naive Bayes vs Regresión Logística

Ambos son clasificadores lineales de texto. La diferencia está en lo que modelan.

Regla general: comience con Naive Bayes. Si tiene suficientes datos y mesetas de NB, cambie a la regresión logística.

Clasificación 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

En la práctica, trabajamos en el espacio de registro para evitar el desbordamiento de punto flotante. En lugar de multiplicar muchas probabilidades pequeñas, sumamos sus logaritmos:

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

Constrúyelo

El código en code/naive_bayes.py implementa tanto MultinomialNB como GaussianNB desde cero.

MultinomialNB

La implementación desde cero:

1. fit(X, y): Para cada clase, cuente la frecuencia de cada característica. Añadir alisado de Laplace. Calcule las probabilidades de registro. Almacenar clases anteriores (registro de frecuencias de clases).

2. predict_log_proba(X): Para cada muestra, calcule el log P(clase) + la suma del log P(feature_i | clase) para todas las clases. Esta es una multiplicación de matrices: X @ log_probs.T + log_priors.

3. predecir(X): Devuelve la clase con mayor probabilidad logarítmica.

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

La idea clave: después del ajuste, la predicción es simplemente una multiplicación de matrices más un sesgo. Por eso Naive Bayes es tan rápido.

GaussianNB

Para características continuas, estimamos la media y la varianza por clase por característica:

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

La predicción utiliza el PDF gaussiano por característica, multiplicado entre las características (agregado en el espacio de registro).

Demostración: clasificación de texto

El código genera datos sintéticos de una bolsa de palabras que simulan dos clases (artículos tecnológicos frente a artículos deportivos). Cada clase tiene una distribución de frecuencia de palabras diferente. MultinomialNB los clasifica usando recuentos de palabras.

Los datos sintéticos funcionan así: creamos 200 "palabras" (columnas de funciones). Las palabras del 0 al 39 tienen alta frecuencia en artículos de tecnología y baja en deportes. Las palabras 80-119 tienen alta frecuencia en deportes y poca en tecnología. Las palabras 40-79 tienen una frecuencia media en ambos. Esto crea un escenario realista en el que algunas palabras son fuertes indicadores de clase y otras son ruido.

Demostración: funciones continuas

El código genera datos similares a Iris (3 clases, 4 características, grupos gaussianos). GaussianNB clasifica utilizando la media y la varianza por clase. Cada clase tiene un centro diferente (vector medio) y una dispersión (varianza) diferente, imitando datos del mundo real donde las mediciones difieren sistemáticamente entre categorías.

El código también demuestra:

• Comparación de suavizado: Entrenamiento MultinomialNB con diferentes valores alfa para mostrar el efecto de la fuerza de suavizado en la precisión.
• Experimento de tamaño de entrenamiento: Cómo mejora la precisión de NB a medida que los datos de entrenamiento aumentan de 20 a 1600 muestras. NB alcanza una precisión decente incluso con muy pocas muestras; esta es su principal ventaja.
• Matriz de confusión: Precisión por clase, recuperación y score F1 para mostrar dónde comete errores NB.

Velocidad de predicción

Naive Bayes la predicción es una multiplicación de matrices. Para n muestras con d características y k clases:

• MultinomialNB: una matriz multiplicada (n x d) @ (d x k) = O(n * d * k)
• GaussianNB: n * k evaluaciones PDF gaussianas, cada una sobre d características = O(n * d * k)

Ambos son lineales en todas las dimensiones. Compare esto con KNN (que requiere cálculo de distancia a todos los puntos de entrenamiento) o SVM con el kernel RBF (que requiere la evaluación del kernel contra todos los vectores de soporte). NB es más rápido en órdenes de magnitud en el momento de la predicción.

Úsalo

Con sklearn, ambas variantes son ingeniosas:

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 clasificación de texto con 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)

El código en naive_bayes.py compara implementaciones desde cero con sklearn con los mismos datos para verificar la corrección.

TF-IDF con Naive Bayes

El recuento de palabras sin procesar le da a cada palabra el mismo peso por aparición. Pero palabras comunes como "el" y "es" aparecen con frecuencia en todas las clases y no contienen inentrenamiento. TF-IDF (Frecuencia de términos - Frecuencia de documentos inversa) reduce el peso de las palabras comunes y aumenta el peso de las palabras raras y 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)),
])

Los valores TF-IDF no son negativos, por lo que funcionan con MultinomialNB. La combinación de TF-IDF + MultinomialNB es una de las bases más sólidas para la clasificación de texto. Con frecuencia supera a modelos más complejos en conjuntos de datos con menos de 10.000 muestras de entrenamiento.

BernoulliNB para texto corto

Para textos cortos (tweets, SMS, mensajes de chat), BernoulliNB puede superar a MultinomialNB. Los textos cortos tienen un número bajo de palabras, por lo que la inentrenamiento de frecuencia en la que se basa MultinomialNB es ruidosa. BernoulliNB solo se preocupa por la presencia o ausencia, lo cual es más confiable con texto breve.

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)),
])

El indicador binary=True en CountVectorizer convierte todos los recuentos a 0/1. Sin él, BernoulliNB todavía funciona, pero registra recuentos para los que no fue diseñado.

Calibración de probabilidades NB

NB Las probabilidades están mal calibradas. Cuando NB dice P(spam) = 0,95, la probabilidad real podría ser 0,7. Si necesita estimaciones de probabilidad confiables (por ejemplo, para establecer un umbral o combinarlos con otros modelos), use CalibratedClassifierCV de 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)

Esto se ajusta a una regresión logística además de las puntuaciones brutas de NB mediante validación cruzada. Las probabilidades resultantes están mucho más cerca de las verdaderas frecuencias de clase.

Errores comunes

1. Valores de características negativos. MultinomialNB requiere características no negativas. Si tiene valores negativos (como TF-IDF con ciertas configuraciones o características estandarizadas), use GaussianNB en su lugar o cambie las características para que sean positivas.

2. Características de variación cero. GaussianNB divide por variación. Si una característica tiene una varianza cero para una clase (todos los valores son idénticos), el cálculo de probabilidad falla. El código agrega un pequeño término de suavizado (1e-9) a todas las variaciones para evitar esto.

3. Desequilibrio de clases. Si el 99% de los correos electrónicos no son spam, el P(no spam) = 0,99 anterior es tan fuerte que supera la evidencia de probabilidad. Puede configurar las clases anteriores manualmente o usar el parámetro class_prior en sklearn.

4. Escalado de funciones. MultinomialNB no necesita escalado (funciona con recuentos). GaussianNB tampoco necesita escalamiento (estima estadísticas por función). Esta es una ventaja sobre la regresión logística y SVM, que son sensibles a las escalas de características.

Envíalo

Esta lección produce:

• outputs/skill-naive-bayes-chooser.md -- una habilidad de decisión para elegir la variante NB correcta
• code/naive_bayes.py -- MultinomialNB y GaussianNB desde cero, con comparación de sklearn

Cuando Naive Bayes falla

NB falla cuando el supuesto de independencia provoca clasificaciones incorrectas (no sólo probabilidades incorrectas). Esto sucede cuando:

1. Fuertes interacciones entre características. Si la clase depende de la combinación de dos características pero no de ninguna de ellas sola (patrones tipo XOR), NB la perderá por completo. Cada característica por sí sola no proporciona evidencia y NB no puede combinarlas de manera no lineal.

2. Características altamente correlacionadas con evidencia contraria. Si la característica A dice "spam" y la característica B dice "no spam", pero A y B están perfectamente correlacionados (en realidad siempre coinciden), NB verá evidencia contradictoria donde no la hay.

3. Conjuntos de entrenamiento muy grandes. Con suficientes datos, los modelos discriminativos como la regresión logística aprenden el verdadero límite de decisión y superan a NB. El supuesto de independencia que ayudó con los datos pequeños ahora frena el modelo.

En la práctica, estos modos de falla son raros en la clasificación de textos. Las características del texto son numerosas, individualmente débiles y los errores del supuesto de independencia tienden a anularse. Para datos tabulares con pocas características fuertemente correlacionadas, considere primero la regresión logística o los modelos basados ​​en árboles.

Ejercicios

1. Experimento de suavizado. Entrene MultinomialNB con datos de texto con valores alfa de 0,01, 0,1, 1,0, 10,0 y 100,0. Precisión del gráfico frente a alfa. ¿Dónde alcanza su punto máximo el rendimiento? ¿Por qué duele un alfa muy alto?

2. Prueba de independencia de funciones. Tome un conjunto de datos de texto real. Elija dos palabras que estén obviamente correlacionadas ("máquina" y "aprendizaje"). Calcule P (palabra1 | clase) * P (palabra2 | clase) y compárelo con P (palabra1 Y palabra2 | clase). ¿Qué tan equivocado es el supuesto de independencia? ¿Afecta la precisión de la clasificación?

3. Implementación de Bernoulli. Amplíe el código con una clase BernoulliNB. Convierta una bolsa de palabras a binario (presente/ausente) y compare la precisión con MultinomialNB en datos de texto. ¿Cuándo gana Bernoulli?

4. NB versus regresión logística. Entrene ambos con datos de texto. Comience con 100 muestras de entrenamiento y aumente a 10 000. Trazar la precisión frente al tamaño del conjunto de entrenamiento para ambos. ¿En qué punto la regresión logística supera a Naive Bayes?

5. Filtro de spam. Cree un clasificador de spam completo: tokenice el texto sin formato del correo electrónico, desarrolle vocabulario, cree funciones de bolsa de palabras, entrene MultinomialNB, evalúe con precisión y recuerde (no solo precisión, ¿por qué?).

Términos clave

Lectura adicional

• scikit-learn Naive Bayes docs -- las tres variantes con detalles matemáticos
• McCallum y Nigam, Una comparación de modelos de eventos para Naive Bayes Clasificación de texto (1998) -- la comparación clásica de Multinomial vs Bernoulli para texto
• Rennie et al., Tackling the Poor Assumptions of Naive Bayes Text Classifiers (2003) -- mejoras en NB para texto
• Ng y Jordan, On Discriminative vs. Generative Classifiers (2001) -- demuestra que NB converge más rápido que LR con menos datos