Última lección del módulo, y la familia de modelos que domina los titulares. Las redes neuronales no traen una idea geométrica nueva como el margen de la SVM o las preguntas del árbol: traen un principio de composición — apilar muchas unidades de cálculo diminutas, cada una sospechosamente parecida a la regresión logística de 04-02, hasta poder aproximar prácticamente cualquier función. En esta lección desmontarás la neurona artificial pieza a pieza (retomando el perceptrón que la historia de 01-02 dejó plantado en 1958), harás un forward pass con números reales, entenderás backpropagation como el descenso de gradiente de 04-01 aplicado en cadena, y entrenarás un MLPClassifier sobre el churn de MercaFresh. Cerraremos con la comparativa de los siete algoritmos del módulo — tu mapa para elegir modelo — y la pregunta que abre el módulo 5.

1. La neurona artificial: pesos, sesgo y activación
2. Funciones de activación: sigmoide, tanh y ReLU
3. La arquitectura en capas
4. Forward pass: un ejemplo numérico completo
5. Backpropagation y descenso de gradiente (conceptual)
6. Implementación con scikit-learn: MLPClassifier sobre el churn
7. Cuándo aporta una red frente a los modelos anteriores
8. Comparativa final: los 7 algoritmos del módulo

Una neurona artificial hace tres cosas, en fila:

1. Combina sus entradas linealmente: $z = w_1 x_1 + w_2 x_2 + \dots + w_n x_n + b$ (los pesos $w_i$ ponderan cada entrada; el sesgo $b$ desplaza el resultado — es el intercepto de 04-01 con otro nombre).
2. Activa: pasa $z$ por una función no lineal $f$.
3. Emite la salida $a = f(z)$ hacia las neuronas siguientes.

¿Te suena? Una neurona con activación sigmoide es exactamente la regresión logística de 04-02: combinación lineal + sigmoide. El perceptrón de Rosenblatt (1958), que conociste en la historia de 01-02, era esto mismo con una activación escalón (0 o 1, sin matices) — y su limitación famosa era la de todos nuestros modelos lineales: solo fronteras rectas. La revolución no está en la neurona, sino en lo que pasa al conectarlas: la salida de unas es la entrada de otras, y la composición de muchas transformaciones no lineales sencillas puede curvar la frontera tanto como haga falta. Sin la no linealidad de la activación, por cierto, apilar capas sería inútil: una cadena de funciones lineales se colapsa en una sola función lineal.

La ReLU (Rectified Linear Unit) merece explicación por su aparente tosquedad: si la entrada es negativa, emite 0 (la neurona "calla"); si es positiva, la deja pasar tal cual. Esa simpleza es su virtud — su pendiente es 1 en toda la zona activa, así que el gradiente fluye sin desvanecerse por muchas capas que atraviese, el problema que lastró a sigmoide y tanh durante décadas. Para la capa de salida se mantienen la sigmoide (binaria) o softmax (multiclase, 04-02).

Las neuronas se organizan en capas: una de entrada (una neurona por feature — no calcula, solo reparte), una o más ocultas (extraen representaciones intermedias) y una de salida (emite la predicción). Cada neurona de una capa se conecta con todas las de la siguiente — de ahí el nombre técnico perceptrón multicapa (MLP) o red densa:

Intuición de qué aprende cada capa: las neuronas ocultas se especializan en detectar patrones intermedios — una podría activarse ante el perfil "silencio creciente" (recencia alta + tendencia baja), otra ante "cliente premium enfriándose" — y la capa de salida combina esos detectores como una regresión logística sobre features aprendidas. Ahí está la promesa profunda del modelo: la red hace su propia ingeniería de características (03-06), aprendiendo las combinaciones que a nosotros nos tocaba diseñar a mano. El número de capas y de neuronas por capa son hiperparámetros: más = más capacidad expresiva y más riesgo de sobreajuste (06-05).

El forward pass es el recorrido de un dato desde la entrada hasta la predicción. Red mínima: 2 entradas, 2 neuronas ocultas con ReLU, 1 salida sigmoide. Cliente con features escaladas: recencia = 1.0 (alta), tendencia = −0.5 (cayendo).

Capa oculta (pesos inventados pero verosímiles):

• Neurona h1 (pesos 1.2 y −1.0, sesgo −0.2), detectora de "cliente apagándose": $z_1 = 1.2(1.0) + (-1.0)(-0.5) - 0.2 = 1.2 + 0.5 - 0.2 = 1.5 \Rightarrow a_1 = \text{ReLU}(1.5) = 1.5$
• Neurona h2 (pesos −0.8 y 1.5, sesgo 0.1), detectora de "cliente reactivándose": $z_2 = -0.8(1.0) + 1.5(-0.5) + 0.1 = -0.8 - 0.75 + 0.1 = -1.45 \Rightarrow a_2 = \text{ReLU}(-1.45) = 0$

Capa de salida (pesos 1.1 y −1.3, sesgo −0.4):

$z_s = 1.1(1.5) + (-1.3)(0) - 0.4 = 1.25 \Rightarrow \sigma(1.25) = \frac{1}{1+e^{-1.25}} \approx 0.78$

Predicción: 78% de probabilidad de churn. Lee la historia que cuentan los números: el detector de apagado se activó con fuerza (1.5), el de reactivación calló por completo (la ReLU lo silenció), y la salida tradujo ese balance a probabilidad con la sigmoide de 04-02. Once números de parámetros, y ya se ve la mecánica que, a escala de miles de neuronas, reconoce caras o traduce idiomas.

¿De dónde salen los pesos? Del mismo bucle de 04-01: definir una función de coste (log-loss, como en 04-02) y bajar por su pendiente. La novedad es calcular esa pendiente cuando entre cada peso y el error hay varias capas de por medio. Ahí entra backpropagation (retropropagación):

1. Forward pass: con los pesos actuales, calcula la predicción y su error.
2. Backward pass: propaga el error hacia atrás, capa por capa, repartiendo a cada peso su cuota de responsabilidad (la regla de la cadena del cálculo, aplicada sistemáticamente): "la salida se pasó 0.3; h1 contribuyó tanto, luego los pesos de h1 deben corregirse tanto...".
3. Actualización: cada peso da un pasito contra su gradiente, con la tasa de aprendizaje de 04-01.
4. Repetir con más datos, muchas épocas (pasadas completas al dataset), hasta converger.

Diferencia crucial con 04-01 y 04-02: el paisaje de error de una red no es un cuenco — tiene valles múltiples, mesetas y barrancos. El descenso de gradiente ya no garantiza el mínimo global: entrenar dos veces con semillas distintas da redes distintas (por eso los pesos se inicializan al azar y random_state importa). En la práctica funciona notablemente bien, con variantes del descenso (Adam, la que sklearn usa por defecto) que adaptan el tamaño del paso por el camino.

Las redes exigen features escaladas (el descenso de gradiente sufre con escalas dispares — misma razón que en 04-02, agravada): una vez más, el preprocesador de 03-06 al rescate:

Lectura del código:

• hidden_layer_sizes=(16, 8): dos capas ocultas de 16 y 8 neuronas. Para tabular pequeño, empezar modesto: una o dos capas de 8–32 neuronas. Cada neurona añade pesos que ajustar y capacidad de memorizar.
• early_stopping=True: aparta internamente un 10% del train como validación y detiene el entrenamiento cuando esa validación deja de mejorar — el antídoto más simple contra el sobreajuste por exceso de épocas (la lógica completa, en 06-05).
• max_iter=2000: tope de épocas. Si sale un aviso de no convergencia, súbelo o revisa el escalado.
• El contador de parámetros pone las cosas en perspectiva: nuestra red pequeña ya maneja varios cientos de pesos, frente a la docena larga de la regresión logística. Más capacidad, más apetito de datos y más riesgo de memorizar — con 800 clientes, la ventaja sobre modelos simples puede ser nula o negativa, y eso también es una lección.

Sobre este mismo churn, es habitual que la red empate o gane por poco a la logística: nuestras features de 03-06 ya codifican a mano buena parte de la no linealidad útil (ratios, tendencia, interacción). Las redes brillan cuando esa ingeniería no está hecha o no es posible.

• Aporta: relaciones no lineales complejas con datos abundantes (decenas de miles de filas en adelante); problemas donde las features útiles son combinaciones que nadie sabe diseñar; datos no tabulares — imágenes, audio, texto secuencial — donde las arquitecturas especializadas no tienen rival.
• No aporta (o resta): datasets tabulares pequeños o medianos con buenas features, donde la logística, los árboles o sus ensembles (07-02, 07-03) rinden igual o mejor con una fracción del coste y del misterio; contextos que exigen explicar cada decisión (un MLP no produce reglas legibles ni odds ratios).

Lo que esta lección ha mostrado es la red mínima. Las arquitecturas que justifican el bombo — redes profundas con decenas de capas, convolucionales (CNN) para imágenes, recurrentes (RNN) para secuencias, transformers para el lenguaje — junto con las técnicas que las hacen entrenables, se tratan en la lección de deep learning (07-04). Todo lo esencial, sin embargo, ya lo tienes: son neuronas, capas, forward pass y backpropagation, a otra escala.

El mapa de decisión del módulo completo:

Cómo usar la tabla en un proyecto real tipo MercaFresh: empieza por la línea base interpretable (logística para clasificar, lineal para regresión); pon un árbol al lado por sus reglas y su tolerancia al preprocesamiento mínimo; si sospechas fronteras curvas y el dataset es manejable, prueba SVM RBF y una red pequeña; usa K-NN como sonda de la calidad de tus features y Naive Bayes cuando la velocidad o la escasez de datos manden. Y recuerda que las dos casillas más potentes en tabular — los ensembles de árboles y el boosting — llegan en 07-02 y 07-03 construidas sobre lo que ya sabes.

• Empezar el proyecto por la red neuronal. Es el modelo con más mandos, más apetito de datos y menos explicaciones. Gana derecho a existir solo si supera a la logística y al árbol en validación — la mayoría de las veces, en tabular, no lo hace.
• Entrenar sin escalar. El descenso de gradiente zigzaguea y no converge; el aviso de max_iter suele ser síntoma de esto, no de pocas épocas. El Pipeline con 03-06 lo previene.
• Ignorar la aleatoriedad de la inicialización. Dos entrenamientos con semillas distintas dan resultados distintos; fija random_state para reproducir y, si el resultado varía mucho entre semillas, desconfía: el modelo está al límite de sus datos.
• Interpretar neuronas ocultas como conceptos garantizados. "h1 detecta el apagado del cliente" es una lectura plausible a posteriori, no una propiedad verificada; las representaciones internas de una red real están repartidas y mezcladas.
• Consejo: cronometra y compara siempre contra la tabla del módulo. Un punto extra de accuracy puede costar 100 veces más entrenamiento, memoria y opacidad; que la decisión sea consciente — y con las métricas adecuadas, que es justo lo que viene en el módulo 6.

Ejercicio 1. Repite el forward pass del ejemplo numérico para un cliente sano: recencia = −0.8, tendencia = 1.2 (escaladas). Usa los mismos pesos. ¿Qué neurona oculta se activa ahora y qué probabilidad de churn sale?

Ejercicio 2. Con el Pipeline de la lección, entrena tres redes con hidden_layer_sizes = (2,), (16, 8) y (128, 64, 32), y compara accuracy en train y test. Relaciona el patrón con el número de parámetros y con lo visto en el ejercicio 2 de 04-03.

Ejercicio 3. Sin código: la capa de salida de nuestro MLP binario es una neurona con sigmoide sobre las activaciones ocultas. Explica en qué sentido exacto el MLP "es una regresión logística con features aprendidas", y qué implica eso sobre la frontera de decisión de la red en el espacio de las activaciones ocultas frente al espacio de las features originales.

Ejercicio 1

• h1: $z_1 = 1.2(-0.8) + (-1.0)(1.2) - 0.2 = -0.96 - 1.2 - 0.2 = -2.36 \Rightarrow a_1 = 0$ (ReLU silencia).
• h2: $z_2 = -0.8(-0.8) + 1.5(1.2) + 0.1 = 0.64 + 1.8 + 0.1 = 2.54 \Rightarrow a_2 = 2.54$.
• Salida: $z_s = 1.1(0) + (-1.3)(2.54) - 0.4 = -3.70 \Rightarrow \sigma(-3.70) \approx 0.024$.

Un 2.4% de churn: los detectores se han intercambiado los papeles — ahora calla el de "apagado" y grita el de "reactivación", cuyo peso de salida negativo (−1.3) empuja la probabilidad hacia abajo. La misma red, sin cambiar un peso, responde coherentemente a perfiles opuestos: eso es lo que compran las capas.

Ejercicio 2

Patrón esperado: (2,) se queda corta (pocos parámetros, train y test mediocres — underfitting); (16, 8) da el mejor test; (128, 64, 32) — miles de parámetros para 640 filas de train — dispara el train y estanca o empeora el test: memorización. Es exactamente la curva del ejercicio 2 de 04-03 con max_depth, y la de gamma en 04-04: cada familia de modelos tiene su mando de complejidad (profundidad, gamma, K, capas) y todos dibujan la misma U. Ese patrón universal tiene nombre y tratamiento: overfitting/underfitting, en 06-05.

Ejercicio 3

La neurona de salida calcula $\sigma(w \cdot \mathbf{a} + b)$ donde $\mathbf{a}$ son las activaciones ocultas: eso es literalmente la regresión logística de 04-02, con $\mathbf{a}$ en el papel de las features. La diferencia es que $\mathbf{a}$ no viene del ColumnTransformer: la aprendieron las capas ocultas durante el entrenamiento. Implicación geométrica: en el espacio de las activaciones, la frontera de la red es un hiperplano (la logística lo garantiza); pero como la transformación features→activaciones es no lineal, ese hiperplano visto desde el espacio original es una superficie curva arbitraria. Es la misma jugada que el kernel de la SVM (04-04) — separar linealmente en un espacio transformado — con una diferencia capital: el kernel fija la transformación de antemano; la red la aprende de los datos.

Has desmontado la red neuronal hasta sus piezas — neuronas que combinan, sesgan y activan; capas que componen detectores; forward pass que puedes calcular a mano; backpropagation repartiendo culpas hacia atrás para que el descenso de gradiente de 04-01 ajuste cada peso — y la has entrenado sobre el churn con el mismo Pipeline de siempre. Sabes situarla: máxima flexibilidad, máximo apetito de datos, mínima transparencia, y su versión profunda (CNN, RNN, transformers) esperándote en 07-04.

Con ella se cierra el módulo: siete algoritmos, siete ideas-fuerza, y una tabla comparativa que es tu mapa para elegir. Pero fíjate en lo que los siete exigían sin excepción: una columna y — la etiqueta que dice qué cliente abandonó, cuánto gastó. ¿Y cuando no existe? MercaFresh no tiene una columna que diga a qué segmento pertenece cada cliente, porque los segmentos son precisamente lo que quiere descubrir. Aprender estructura de datos sin etiquetas es el aprendizaje no supervisado, y el módulo 5 lo abre con su algoritmo emblema: K-means — cuyo nombre, ahora sí, ya no confundirás con el K-NN de esta semana.