Naive Bayes: Por qué funciona el supuesto de independencia ingenuo

Antes de que Sam regrese al modelo principal de potencial de venta de HomeMatch, tiene una tarea rápida aparte. La bandeja de entrada de clientes potenciales está saturada de envíos basura, y necesita un filtro rápido y económico para separar las consultas reales del spam. Es un problema más sencillo que predecir el potencial de venta a 30 días — y la herramienta adecuada resulta ser una de las más antiguas en el machine learning.

1. El dilema del filtro de spam: ¿Podemos ser demasiado inteligentes?

Piensa en tu bandeja de entrada de correo electrónico por un segundo. Todos los días, filtra cientos de mensajes sobre “Ganador”, “Efectivo” y “Verificación urgente de la cuenta”. ¿Cómo lo sabe? Puede que notes que ciertas palabras como ‘Ganador’ y ‘Efectivo’ suelen ir juntas en los correos no deseados.

Si quisiéramos construir un modelo ‘perfecto’, intentaríamos calcular la probabilidad de ver cada combinación posible de palabras. Pero aquí está el problema: las matemáticas explotan. Tomemos un pequeño vocabulario de solo 100 palabras — hay más combinaciones posibles de esas palabras que átomos en el universo observable. Esta es una versión de la ‘Maldición de la Dimensionalidad’ que Sam encontró en la Parte 8. A medida que añadimos más características (palabras), el espacio se vuelve demasiado vasto para mapearlo.

Veamos qué le pasa a la cantidad de cosas que tenemos que rastrear si intentamos ser ‘inteligentes’ y mirar pares de palabras en lugar de solo mirar palabras individuales.

vocab_size = 1000
individual_words = vocab_size
word_pairs = (vocab_size * (vocab_size - 1)) / 2

print(f"To track individual words, we need {individual_words} data points.")
print(f"To track every possible pair, we need {int(word_pairs)} data points.")

• vocab_size = 1000 establece un vocabulario modesto de 1,000 palabras — pequeño para los estándares del mundo real, pero ya lo suficientemente grande como para exponer la explosión combinatoria.
• individual_words = vocab_size es la cantidad de parámetros que un modelo Naive Bayes rastrearía — solo una probabilidad por palabra, por lo que serían 1,000 números en total.
• word_pairs = (vocab_size * (vocab_size - 1)) / 2 calcula el número de pares únicos no ordenados usando la fórmula “n sobre 2” — para 1,000 palabras eso son 499,500 pares, lo que significa que un modelo que rastree co-ocurrencias de palabras necesitaría aproximadamente 500× más datos para estimar todas esas probabilidades conjuntas.
• int(word_pairs) convierte el resultado de tipo flotante en un número entero para una impresión limpia — 499,500.0 se convierte en 499,500.
• Las sentencias print contrastan ambos enfoques — la cuestión es que rastrear palabras individuales (1,000 números) es trivial, mientras que rastrear cada par (casi 500,000 números) ya es poco práctico, y esto es solo para un vocabulario de 1,000 palabras.

Para un vocabulario estándar de 10,000 palabras, ese modelo ‘inteligente’ necesitaría aprender miles de millones de relaciones. Simplemente no tenemos suficientes datos para eso. Aquí está el atajo: simplemente ignora las conexiones entre palabras. Eso es exactamente lo que hace Naive Bayes.

2. La mentira ‘ingenua’ que le contamos a nuestros modelos

En el mundo real, las palabras dependen unas de otras. Piensa en ‘New’, y la siguiente palabra probablemente sea ‘York’ o ‘Jersey’. Naive Bayes toma un enfoque diferente. Trata cada característica como completamente independiente.

Esta es la parte más difícil de asimilar: estamos usando un supuesto ‘erróneo’ a propósito para facilitar las matemáticas. El ‘Naive’ (ingenuo) en el nombre viene de ignorar el contexto obvio del lenguaje humano. En lugar de buscar la frase exacta “Winner Cash Now”, hace tres preguntas separadas: ¿Qué tan probable es ‘Winner’? ¿Qué tan probable es ‘Cash’? ¿Qué tan probable es ‘Now’?

La diferencia aparece en el código. Asumiendo independencia, simplemente multiplicamos las probabilidades individuales.

# Probability of words appearing in Spam
p_winner = 0.6  # 60% of spam has 'winner'
p_cash = 0.5    # 50% of spam has 'cash'

# The 'Naive' way: just multiply them
p_naive = p_winner * p_cash

# The 'Real' way: we'd need to know how often they appear TOGETHER
p_together_actual = 0.45 

print(f"Naive Prediction: {p_naive:.2f}")
print(f"Actual Reality: {p_together_actual:.2f}")

• p_winner = 0.6 y p_cash = 0.5 son las probabilidades marginales: cada una es la probabilidad individual de ver esa palabra en un correo spam, estimada de forma independiente a partir de los datos de entrenamiento.
• p_naive = p_winner * p_cash aplica el supuesto de independencia ingenuo: si las dos palabras fueran realmente independientes, su probabilidad conjunta sería el producto de sus probabilidades individuales (0.6 × 0.5 = 0.30).
• p_together_actual = 0.45 es la probabilidad conjunta real: en la realidad, ‘winner’ y ‘cash’ aparecen juntas con más frecuencia de lo que predeciría la independencia (0.45 > 0.30), porque los correos spam tienden a usar ambas palabras juntas como parte de una plantilla de estafa.
• La brecha entre 0.30 y 0.45 ilustra el costo del supuesto ingenuo: el modelo subestima la coocurrencia real, pero como veremos, esto no necesariamente perjudica la decisión de clasificación final.

El modelo ingenuo sitúa la probabilidad en 0.30, mientras que la realidad es 0.45. El modelo está ‘equivocado’, pero como veremos, equivocarse en el número exacto no siempre significa equivocarse en la respuesta final.

3. Las matemáticas detrás de la magia (sin sufrir)

Piensa en el Teorema de Bayes como una receta para actualizar creencias. Dos ingredientes son importantes:

1. El a priori (Prior): Lo que sabíamos antes de los datos. (p. ej., “En general, 20% de mis correos son spam.”)
2. La verosimilitud (Likelihood): Qué tan bien encajan los datos en el perfil. (p. ej., “¿Qué tan comunes son estas palabras específicas en el spam?”)

Multiplica ambos y obtienes una puntuación. Hacemos esto tanto para ‘Spam’ como para ‘No Spam’ (Ham). La puntuación que sea más alta gana. La parte inferior de la fórmula de Bayes (la ‘Evidencia’) se descarta porque es la misma para ambos lados.

El Teorema de Bayes y el supuesto de independencia ingenua

El Teorema de Bayes actualiza nuestra creencia sobre una clase dadas las características observadas:

$P(\text{Spam} \mid \mathbf{w}) = \frac{P(\mathbf{w} \mid \text{Spam}) \cdot P(\text{Spam})}{P(\mathbf{w})}$

La parte “ingenua”: asumimos que todas las palabras son condicionalmente independientes dada la clase, por lo que la verosimilitud conjunta se factoriza:

$P(\mathbf{w} \mid \text{Spam}) = \prod_{i=1}^{n} P(w_i \mid \text{Spam})$

Dado que $P(\mathbf{w})$ es el mismo para todas las clases, lo omitimos y simplemente comparamos los numeradores:

$\text{score}(\text{Spam}) = P(\text{Spam}) \cdot \prod_{i=1}^{n} P(w_i \mid \text{Spam})$

Con el suavizado de Laplace (añadir-$\alpha$), la probabilidad de cada palabra se convierte en:

$P(w_i \mid \text{Spam}) = \frac{\text{count}(w_i, \text{Spam}) + \alpha}{\text{total}(\text{Spam}) + \alpha \cdot V}$

En lenguaje llano	Símbolo estadístico	Equivalente en Python
A priori (probabilidad de spam antes de ver ninguna palabra)	$P(\text{Spam})$	prior_spam en get_spam_score()
Verosimilitud (probabilidad de las palabras dado el spam)	$P(\mathbf{w} \mid \text{Spam})$	producto de los valores de word_probs
Verosimilitud ingenua (producto de las probabilidades individuales de las palabras)	$\prod_{i=1}^{n} P(w_i \mid \text{Spam})$	score *= word_probs.get(word, 0.01)
A posteriori (probabilidad de spam dadas las palabras)	$P(\text{Spam} \mid \mathbf{w})$	comparación de la puntuación de spam frente a la puntuación de ham
Evidencia (normalizador, igual para todas las clases)	$P(\mathbf{w})$	(omitida — se cancela en la comparación)
Parámetro de suavizado de Laplace	$\alpha$	alpha=1.0 en MultinomialNB(alpha=1.0)
Tamaño del vocabulario (número de palabras distintas)	$V$	len(vectorizer.vocabulary_)

Aquí hay una función sencilla de Python que calcula una ‘Puntuación de Spam’ usando esta lógica.

def get_spam_score(words, word_probs, prior_spam):
    score = prior_spam
    for word in words:
        # Multiply the score by the probability of each word
        score *= word_probs.get(word, 0.01)
    return score

# Let's test it
word_probs = {'winner': 0.8, 'cash': 0.7, 'hello': 0.1}
my_email = ['winner', 'cash']

print(f"Spam Score: {get_spam_score(my_email, word_probs, 0.2):.4f}")

• score = prior_spam inicializa la puntuación con la probabilidad a priori — esta es la parte de “lo que sabíamos antes de mirar los datos”; aquí es 0.2 (20% de los correos son spam).
• word_probs.get(word, 0.01) busca la probabilidad de cada palabra en el diccionario word_probs — el segundo argumento 0.01 es un valor predeterminado para las palabras que no están en el diccionario, actuando como una forma simple de suavizado (1% de probabilidad para palabras no vistas).
• score *= word_probs.get(word, 0.01) multiplica la puntuación en curso por la probabilidad de cada palabra — esto es el supuesto de independencia ingenua en acción: en lugar de calcular la probabilidad conjunta de ver tanto ‘winner’ como ‘cash’ juntos, simplemente multiplicamos sus probabilidades individuales.
• my_email = ['winner', 'cash'] es un correo tokenizado — la función recorre cada palabra y multiplica las probabilidades; con prior_spam=0.2, p(winner)=0.8, y p(cash)=0.7, la puntuación final es 0.2 × 0.8 × 0.7 = 0.1120.
• La puntuación devuelta (0.1120) no es una probabilidad verdadera — es una puntuación sin normalizar; lo que importa es si es más alta que la “puntuación de ham” correspondiente calculada de la misma manera con las probabilidades de ham.

La puntuación es 0.1120. Por sí sola, significa poco. Pero si la ‘Puntuación de Ham’ para las mismas palabras fuera 0.001, claramente es spam.

4. Por qué funciona: El secreto de los rankings ‘suficientemente buenos’

La idea clave: Naive Bayes es un estimador terrible pero un excelente clasificador.

Incluso si el supuesto de independencia hace que la probabilidad final sea técnicamente incorrecta — digamos, 99% cuando la probabilidad real está más cerca del 75% — no importa. Mientras el puntaje de ‘Spam’ se mantenga más alto que el de ‘Ham’, el modelo toma la decisión correcta. Piensa en un juez que fija una multa equivocada pero aún así condena a la persona correcta.

Pero hay una trampa: el Problema de Frecuencia Cero. Si tu modelo encuentra una palabra que nunca ha visto antes, la probabilidad de esa palabra se vuelve 0. Dado que estamos multiplicando todas estas probabilidades juntas, un solo cero elimina todo el puntaje. La solución es el Suavizado de Laplace — agregar una pequeña constante (usualmente 1) a cada conteo para que nada sea realmente cero.

from sklearn.naive_bayes import MultinomialNB
import numpy as np

# Imagine 1 feature: 'Secret Word'. 
# In our data, it appeared 0 times in Spam.
X = np.array([[0], [1], [2]]) 
y = np.array([0, 1, 1])

# Model with smoothing (alpha=1.0 is the default)
model = MultinomialNB(alpha=1.0)
model.fit(X, y)

# Even though '0' was never seen in class 1, the probability isn't zero
print(f"Probability of class 1 given 0: {model.predict_proba([[0]])[0][1]:.4f}")

• from sklearn.naive_bayes import MultinomialNB importa el clasificador Naive Bayes multinomial — esta variante está diseñada para datos de conteo (como frecuencias de palabras) y asume que las características se generan a partir de una distribución multinomial.
• X = np.array([[0], [1], [2]]) crea un pequeño conjunto de datos con 3 muestras y 1 característica — cada valor representa un conteo (por ejemplo, cuántas veces apareció una “palabra secreta” en ese documento).
• y = np.array([0, 1, 1]) etiqueta la primera muestra como clase 0 (ham) y las otras dos como clase 1 (spam) — nota que el valor ‘0’ (cero apariciones de la palabra) nunca se vio en la clase 1.
• MultinomialNB(alpha=1.0) crea el modelo con el parámetro de suavizado de Laplace α=1 — esto agrega 1 a cada conteo, por lo que incluso un valor de característica que nunca apareció en una clase obtiene una probabilidad distinta de cero.
• model.fit(X, y) estima las probabilidades a priori de las clases y las probabilidades de las características a partir de los datos de entrenamiento — con suavizado, la probabilidad de ver el valor ‘0’ en la clase 1 no es cero a pesar de nunca haberse observado.
• model.predict_proba([[0]])[0][1] predice la probabilidad de la clase 1 para una nueva muestra con valor 0 — la indexación [0][1] extrae la probabilidad de la primera muestra para la segunda clase (clase 1); el resultado es 0.5000 en lugar de 0, gracias al suavizado.

La probabilidad es 0.5000. Sin suavizado, esto habría fallado o devuelto una probabilidad de 0% — demasiado arriesgado para datos del mundo real.

5. Construyendo un clasificador real en 5 líneas de código

Pongamos esto en práctica usando Scikit-Learn. Usaremos CountVectorizer para convertir nuestro texto en una cuadrícula de números, contando cuántas veces aparece cada palabra. Luego lo pasamos a MultinomialNB.

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

emails = ["Get cash now", "Winner of the lottery", "Hello friend, how are you?", "Lunch tomorrow?"]
labels = [1, 1, 0, 0] # 1=Spam, 0=Ham

# 1. Transform text to numbers
vectorizer = CountVectorizer()
X = vectorizer.fit_transform(emails)

# 2. Train the model
clf = MultinomialNB().fit(X, labels)

# 3. Predict on a new email
test_email = ["win cash"]
X_test = vectorizer.transform(test_email)
prediction = clf.predict(X_test)
probs = clf.predict_proba(X_test)

print(f"Prediction: {'Spam' if prediction[0] == 1 else 'Ham'}")
print(f"Confidence: {probs[0][1]:.4f}")

• from sklearn.feature_extraction.text import CountVectorizer importa el vectorizador de texto — CountVectorizer tokeniza el texto en palabras individuales, construye un vocabulario a partir de los datos de entrenamiento, y convierte cada documento en un vector de conteos de palabras.
• emails = [...] define cuatro correos de ejemplo — dos spam (“Get cash now”, “Winner of the lottery”) y dos ham (“Hello friend…”, “Lunch tomorrow?”), con labels = [1, 1, 0, 0] codificando la verdad fundamental.
• vectorizer.fit_transform(emails) hace dos cosas en una sola llamada: fit construye el vocabulario a partir de los cuatro correos (aprendiendo qué palabras existen), luego transform convierte cada correo en un vector disperso de conteos de palabras — el resultado X es una matriz dispersa 4×N donde N es el tamaño del vocabulario.
• clf = MultinomialNB().fit(X, labels) entrena el clasificador Naive Bayes — estima la probabilidad a priori de cada clase (50/50 aquí ya que hay 2 spam y 2 ham) y las probabilidades de palabras para cada clase, todo con suavizado de Laplace por defecto (α=1).
• test_email = ["win cash"] es un nuevo correo a clasificar — nótese que “win” es una palabra diferente de “winner” en los datos de entrenamiento, por lo que el modelo encontrará un vocabulario parcialmente nuevo.
• vectorizer.transform(test_email) convierte el correo de prueba usando el vocabulario ya aprendido — usamos transform (no fit_transform) para evitar reaprender el vocabulario y causar fuga de datos; “win” puede mapear a un token nuevo o no visto.
• clf.predict(X_test) retorna la etiqueta de clase predicha (0 o 1) — prediction[0] extrae la predicción escalar.
• clf.predict_proba(X_test) retorna las estimaciones de probabilidad para cada clase — probs[0][1] extrae la probabilidad de la clase 1 (spam) para la primera muestra de prueba; el f-string la formatea a 4 lugares decimales.
• El operador ternario {'Spam' if prediction[0] == 1 else 'Ham'} mapea la etiqueta numérica de vuelta a una cadena legible para la sentencia print.

La confianza podría ser 0.85 o mayor. En términos simples, las frecuencias individuales de palabras hacen que el perfil de ‘Spam’ encaje mucho mejor que el perfil de ‘Ham’. Es rápido y ligero, y funciona incluso con muy pocos datos.

6. Cuándo usarlo (y cuándo salir corriendo)

Naive Bayes es el ‘Viejo Confiable’ del aprendizaje automático. Para la tarea secundaria de filtrado de spam de Sam, la cuestión es si recurrir a este modelo rápido y simple o desplegar uno de los clasificadores más pesados de entregas anteriores de la serie — SVMs, Random Forests o árboles potenciados por gradiente.

Úsalo cuando:

• Trabajas con texto (es un clásico por algo).
• Tienes un conjunto de datos pequeño donde modelos complejos podrían sobreajustarse.
• Necesitas un modelo increíblemente rápido de entrenar y predecir.

Evítalo cuando:

• La relación entre las características es el punto principal (como los píxeles en una imagen: un solo píxel marrón no significa ‘perro’, pero una forma específica de píxeles marrones sí).
• Tienes una cantidad masiva de datos y tiempo para entrenar algo más complejo como un Random Forest o una Red Neuronal.

Criterio	Naive Bayes	SVM (Parte 7)	Random Forest (Parte 6)	XGBoost / LightGBM (Parte 4)
Velocidad de entrenamiento	⚡ Instantáneo	Lento con grandes datos	Medio	Medio
Velocidad de predicción	⚡ Instantáneo	Rápido	Medio	Rápido
Datos necesarios	Muy pocos	Moderados	Moderados	Grandes
Maneja texto nativamente	✅ Sí (MultinomialNB)	❌ Necesita truco del kernel	❌ Necesita ingeniería	⚠️ Necesita codificación
Supuesto de independencia	Requerido	No necesario	No necesario	No necesario
Interpretabilidad	Alta (probabilidades de palabras)	Baja (espacio del kernel)	Media (importancia de características)	Media (importancia de características)
Mejor para Sam cuando	Tarea secundaria rápida como filtrado de spam	Modelo principal de vendibilidad con margen claro	Votación de ensemble en listados	Modelo final de producción de vendibilidad

Regla de oro para el flujo de trabajo HomeMatch de Sam: Naive Bayes es la elección correcta para el filtro de spam de leads entrantes porque es una tarea secundaria — rápido de construir, fácil de mantener, y el supuesto de independencia casi no importa cuando la señal (palabras de spam como “cash” y “winner”) es lo suficientemente fuerte. Para el modelo principal de vendibilidad, Sam debería apegarse a los modelos más pesados de partes anteriores, donde la precisión vale la complejidad adicional.

En esta parte, vimos que a veces ser ‘ingenuo’ (naive) da sus frutos. Ignora la compleja red de cómo interactúan las características, y obtienes un modelo que es rápido, robusto y sorprendentemente preciso.

Resumen:

• Independencia: Fingimos que las características no se afectan entre sí para simplificar las matemáticas.
• A priori vs. Verosimilitud: Combinamos lo que sabíamos antes con lo que muestran los datos ahora.
• Suavizado de Laplace: Agregamos un poco de datos ‘falsos’ para evitar trampas de probabilidad cero.
• Ranking sobre la precisión: No importa si la probabilidad está un poco desfasada, siempre y cuando la clase correcta gane la carrera.

Con el filtro de spam manejado de manera económica, Sam vuelve al modelo principal de vendibilidad de HomeMatch — y se topa con algo que las últimas entregas no cubrieron: sus características de vivienda en bruto ni siquiera están en escalas comparables. En la próxima parte de nuestra serie, veremos el Escalado de Características — un paso de preprocesamiento silencioso que puede romper modelos como KNN y SVMs si lo omites.

Comprueba tu comprensión

Las preguntas a continuación van desde el simple recuerdo hasta el diseño abierto, siguiendo aproximadamente la Taxonomía de Bloom.

Recordar ¿Cuál es el “Problema de Frecuencia Cero” y qué técnica lo soluciona?

Entender En tus propias palabras, explica la afirmación del artículo de que “Naive Bayes es un estimador terrible pero un clasificador excelente”—¿cuál es la diferencia entre calcular correctamente la probabilidad exacta y acertar en la clasificación?

Aplicar Usando la fórmula get_spam_score del artículo (score = prior * product of word probabilities), calcula la puntuación de spam para el correo electrónico ['winner', 'hello'] dado word_probs = {'winner': 0.8, 'cash': 0.7, 'hello': 0.1} y prior_spam = 0.2.

Analizar El artículo dice que la suposición de independencia da una probabilidad “ingenua” de 0.30 frente a la “real” de 0.45 para p(winner AND cash). Explica por qué esta brecha entre la probabilidad ingenua y la real no necesariamente invierte la decisión de Spam vs. Ham, a pesar de que el número en sí esté equivocado por 15 puntos porcentuales.

Evaluar El artículo recomienda evitar Naive Bayes cuando “la relación entre las características es el punto principal”, citando los píxeles de imagen como ejemplo. Critica esta guía específicamente para datos de texto: el texto también tiene fuertes relaciones entre características (orden de palabras, frases como “not good”). ¿Por qué Naive Bayes sigue funcionando razonablemente bien para texto de spam a pesar de ignorar esas relaciones, cuando fallaría estrepitosamente en imágenes?

Crear Diseña un experimento mental de suavizado de Laplace: usando el parámetro alpha del artículo, describe qué le pasaría a una palabra que apareció 0 veces en Spam y 0 veces en Ham (una palabra totalmente nueva) con alpha=1.0, frente a qué pasaría con alpha=0.001. ¿Qué configuración haría que el modelo fuera más cauteloso con las palabras raras, y por qué?

---

Artículos relacionados

• P08: Por qué tu modelo KNN falla en altas dimensiones — Entendiendo la maldición de la dimensionalidad — la parte anterior donde Sam descubrió que añadir demasiadas características hace que los modelos basados en distancias como KNN sean poco confiables, lo que motivó el cambio a un enfoque más simple y basado en probabilidades para la tarea secundaria de spam.
• P10: Escalado de características — Por qué tu modelo podría estar ignorando la mitad de tus datos — la siguiente parte donde Sam regresa al modelo principal de vendibilidad de HomeMatch y descubre que las características medidas en diferentes unidades necesitan estar en escalas comparables antes de que modelos como KNN y SVM puedan usarlas de manera efectiva.

Referencias y lecturas adicionales

• McCallum, A. & Nigam, K. (1998). “A Comparison of Event Models for Naive Bayes Text Classification.” AAAI-98 Workshop on Text Categorization, pp. 41–48. — la comparación fundamental de los modelos de eventos multinomial frente a Bernoulli para la clasificación de texto con Naive Bayes; estableció que el modelo multinomial (conteo de palabras) generalmente supera al modelo de Bernoulli (presencia/ausencia de palabras) en tareas de clasificación de texto como el filtrado de spam.
• scikit-learn: documentación de Naive Bayes — la documentación oficial que cubre GaussianNB, MultinomialNB, ComplementNB, BernoulliNB y CategoricalNB, incluyendo una guía para elegir la variante adecuada y ajustar el parámetro de suavizado alpha.
• Kaggle: Spaceship Titanic — una competencia de clasificación tabular donde Naive Bayes es una línea base razonable; un buen entorno de experimentación para probar cómo se comporta el supuesto de independencia en datos estructurados con tipos de características mixtos.

---