En el Módulo 8 armaste tu primera red en PyTorch: un par de capas, entrenamiento, y funcionó. Pero era una red poco profunda (pocas capas). La pregunta que abre el bloque avanzado del curso es directa: si con dos capas ya clasificas, ¿por qué el campo entero se llama deep learning — aprendizaje profundo? ¿Qué gana una red al tener diez, cincuenta o cien capas, y por qué apilarlas fue durante años un dolor de cabeza en vez de una solución obvia? Este módulo responde las dos cosas: qué regala la profundidad y qué la bloqueaba.

La tesis del módulo

La profundidad no es “más de lo mismo”: es una jerarquía. Las primeras capas aprenden rasgos simples; las profundas los combinan en conceptos cada vez más abstractos. Ese poder venía con una trampa — al apilar muchas capas, la señal de aprendizaje se desvanecía antes de llegar al fondo. El deep learning despegó cuando cuatro ideas destrabaron ese cuello de botella.

Qué regala la profundidad: la representación jerárquica

Representación jerárquica es la idea de que cada capa construye sobre lo que descubrió la anterior, de lo simple a lo complejo. No es teoría abstracta: ya la viste en acción en el Módulo 3 de generación de imágenes, donde una CNN (red convolucional) procesa una foto por etapas.

El patrón es el mismo en cualquier red profunda. Con una imagen de una cara:

Primeras capas — detectan lo elemental: bordes, manchas de color, cambios de brillo. Rasgos que aparecen en cualquier imagen.
Capas intermedias — combinan bordes en formas: un ojo, la curva de una nariz, la línea de una boca.
Capas profundas — combinan formas en conceptos: “esto es una cara”, “esta cara es de un gato”.

 capa 1        capa 2        capa 3       capa 4
 ┌───────┐     ┌───────┐     ┌──────┐     ┌──────┐
 │bordes │     │  ojo  │     │      │     │      │
 │  y    │ ──► │ nariz │ ──► │ cara │ ──► │"gato"│
 │colores│     │ boca  │     │      │     │      │
 └───────┘     └───────┘     └──────┘     └──────┘
  lo simple     combina       combina      el
                bordes        partes       concepto

La clave: nadie le dijo a la red qué es un borde ni qué es un ojo. Lo descubrió sola, capa por capa, porque tenía profundidad suficiente para construir la jerarquía. Una red poco profunda tiene que saltar de píxeles crudos a “gato” en un solo paso — y ese salto es demasiado grande. La profundidad lo parte en escalones aprendibles.

Esta es también la razón teórica: apilar capas hace la red exponencialmente más expresiva con menos neuronas totales que una sola capa gigante. Reusar rasgos simples en muchas combinaciones es más eficiente que memorizar cada combinación por separado.

El obstáculo: el vanishing gradient

Si la profundidad es tan buena, ¿por qué no fue obvia desde el principio? Porque apilar capas rompía el entrenamiento. Recuerda del Módulo 5 cómo aprende una red: el error se calcula al final y se propaga hacia atrás por backpropagation, capa por capa, usando la regla de la cadena — que multiplica gradientes.

Ahí está el problema. El gradiente es la señal que le dice a cada peso cuánto ajustarse. Cuando se propaga hacia atrás por muchas capas, se va multiplicando por números en cada paso:

Si esos números son menores que 1, el producto se encoge hacia cero. Para cuando la señal llega a las primeras capas, es prácticamente cero: esas capas no reciben instrucción de aprender. Esto es el vanishing gradient (gradiente que se desvanece): el gradiente se evapora antes de llegar al fondo de la red.
Si son mayores que 1, el producto explota hacia el infinito: los pesos dan saltos enormes y el entrenamiento se vuelve inestable. Esto es el exploding gradient (gradiente que explota).

       error atrás ──►  se multiplica en cada capa

 cap 10      cap 8       cap 5       cap 2       cap 1
 ┌─────┐     ┌─────┐     ┌─────┐     ┌─────┐     ┌─────┐
 │ 1.0 │ ──► │ 0.3 │ ──► │0.02 │ ──► │0.001│ ──► │ ~0  │
 └─────┘     └─────┘     └─────┘     └─────┘     └─────┘
  señal       se          casi        nada        cap 1
  fuerte      encoge       nada                    no aprende

Es un círculo vicioso perverso: mientras más profunda la red — más potencial de jerarquía —, peor el vanishing gradient. Las primeras capas, que deberían aprender los rasgos base de toda la jerarquía, eran justamente las que se quedaban sin señal. Por eso durante años las redes profundas entrenaban peor que las poco profundas, y el campo estuvo estancado.

Ojo con la intuición: el vanishing gradient no es un bug del código. Es una consecuencia matemática de multiplicar muchos números pequeños. No se “arregla” con más datos ni más épocas — se ataca cambiando cómo se construye y entrena la red.

Las cuatro soluciones que destrabaron el deep learning

Entre ~2010 y ~2015 se acumularon cuatro ideas que, juntas, hicieron entrenable lo que antes no lo era. No es una sola bala de plata: es un combo.

1. ReLU como función de activación. En el Módulo 2 viste que la sigmoide aplasta todo entre 0 y 1, y su derivada es diminuta casi siempre — combustible perfecto para el vanishing. ReLU (max(0, x)) tiene derivada exactamente 1 para las entradas positivas: no encoge el gradiente al pasar por ella. Cambiar sigmoide por ReLU fue el primer gran alivio.

2. Mejor inicialización de pesos. Si arrancas con pesos aleatorios mal escalados, los gradientes ya nacen encogidos o explotados. Esquemas como inicialización de He (para ReLU) o Xavier/Glorot eligen la escala inicial para que la señal mantenga tamaño parejo al atravesar cada capa. Un buen punto de partida evita el problema desde el inicio.

3. Batch normalization. El batch norm normaliza (re-centra y re-escala) las salidas de cada capa durante el entrenamiento, manteniéndolas en un rango sano. Eso estabiliza los gradientes, permite tasas de aprendizaje más altas y acelera todo. Es como recalibrar la señal en cada estación del camino para que no se degrade.

4. Residual connections — la que cambió el juego. Una residual connection (conexión residual, o skip connection) es un atajo: la entrada de un bloque se suma a su salida, saltándose las capas del medio.

            atajo: la entrada salta el bloque
        ┌──────────────────────────────┐
        │                              ▼
 x ──►──┴──► ┌────────┐ ──► F(x) ──► (suma) ──► x + F(x)
             │ capas  │
             └────────┘

En vez de pedirle a cada bloque que aprenda la transformación completa, le pides que aprenda solo el cambio (el “residuo”) sobre lo que ya llega. La ventaja para el gradiente es enorme: por el atajo, la señal de aprendizaje tiene una autopista directa hacia atrás que no se multiplica hasta desvanecerse. De golpe, redes de 50, 100 y hasta 1000 capas se volvieron entrenables.

Y aquí el puente que amarra el curso: esas residual connections son las mismas de ResNet (la red que popularizó la idea en visión) y las mismas que lleva por dentro cada bloque del Transformer. Cuando en ese módulo veas “add & norm” alrededor de la atención, ya sabes qué es: una conexión residual más una layer norm (la prima de la batch norm que normaliza dentro de cada token en vez de dentro del batch), exactamente estas dos ideas de aquí.

Poco profunda vs profunda

	Red poco profunda	Red profunda
Capas ocultas	1–2	decenas a cientos
Cómo representa	Un salto directo de entrada a salida	Jerarquía: rasgos simples → conceptos
Expresividad	Limitada; necesita muchas neuronas por capa	Alta con menos neuronas totales
Problema al escalar	Casi no aplica	Vanishing / exploding gradient
Qué la destrabó	—	ReLU, init, batch norm, residuals
Ejemplo real	Perceptrón, MLP pequeño	ResNet, Transformer, todo LLM

Errores comunes

Creer que “más profundo” es siempre mejor. Sin las cuatro soluciones, más capas entrenan peor. Y aun con ellas, para datos tabulares simples una red chica suele bastar y sobrar.
Confundir muchas neuronas con muchas capas. Ancho (neuronas por capa) y profundidad (número de capas) son cosas distintas. La jerarquía la da la profundidad, no el ancho.
Pensar que el vanishing gradient es un error de programación. Es matemática pura: multiplicar muchos números menores que 1. Se ataca con arquitectura, no con debugging.
Ver las residual connections como un truco menor. Son, probablemente, la idea de ingeniería que más habilitó el deep learning moderno — y están en casi toda arquitectura seria de hoy.

La frase para llevarse

“La profundidad le da a la red una jerarquía: bordes, luego partes, luego conceptos. El precio era que el gradiente se desvanecía en el camino — y el deep learning nació el día que aprendimos a darle una autopista de vuelta.”

Qué viene

Módulo 10: embeddings y representaciones aprendidas. Si las capas profundas aprenden representaciones útiles solas, ¿qué es exactamente una representación? Veremos la idea más transferible de todo el deep learning: cómo una red convierte categorías y palabras en vectores densos donde la cercanía significa similitud — el puente directo hacia los LLM.

Redes Neuronales — Módulo 9: por qué profundas — deep learning y sus obstáculos