En el Módulo 1 armamos una neurona; en el Módulo 2 le pusimos una función no-lineal y descubrimos que solo así la red puede escapar de la recta. Con esas dos piezas ya podemos construir la cosa completa: una red. Y el momento clave — el que Minsky y Papert nos dejaron pendiente — es que en cuanto apilas neuronas en capas con no-linealidad, XOR deja de ser un problema.

La tesis del módulo

Una red neuronal es una torre de capas de neuronas: los datos entran por abajo, cada capa los transforma, y salen por arriba convertidos en una respuesta. Con suficientes neuronas ocultas y una no-linealidad, esa torre puede aproximar prácticamente cualquier función. Ese es el poder — y la esencia — del deep learning.

Apilar neuronas: la anatomía de un MLP

Una neurona sola clasifica con una recta. Si pones varias neuronas en paralelo — todas mirando las mismas entradas pero con pesos distintos — tienes una capa. Y si conectas la salida de una capa a la entrada de la siguiente, tienes una red.

La forma más clásica se llama MLP (Multi-Layer Perceptron, “perceptrón multicapa”): varias capas de neuronas, cada neurona conectada a todas las de la capa anterior (por eso también se les dice capas densas o fully connected). Sus partes:

Capa de entrada: no calcula nada, solo recibe los datos crudos (los píxeles, los números). Su tamaño es cuántas features tiene tu dato.
Capas ocultas (hidden layers): las del medio. Se llaman “ocultas” porque no ves ni su entrada ni su salida directamente — trabajan por dentro. Aquí vive la capacidad de la red: cada capa oculta arma representaciones cada vez más abstractas de los datos.
Capa de salida: la última. Su tamaño y su activación dependen de la tarea: 1 neurona para regresión, N neuronas para clasificar en N clases.

   entrada      oculta 1     oculta 2     salida

    x1 ○─────────► ○───────────► ○
         ╲       ╱   ╲         ╱   ╲
    x2 ○───╳────╳─────╳───────╳─────► ○  y
         ╱       ╲   ╱         ╲   ╱
    x3 ○─────────► ○───────────► ○

    3 entradas    4 neuronas   4 neuronas  1 salida

    cada neurona conecta con TODAS las de
    la capa siguiente (capa densa)

El forward pass: los datos hacia adelante

Calcular la salida de la red es simplemente aplicar, capa por capa, la fórmula de la neurona que ya conoces. A ese recorrido — de la entrada hacia la salida — se le llama forward pass (“pasada hacia adelante”):

La entrada x llega a la primera capa oculta: h₁ = f(W₁x + b₁).
Su resultado h₁ alimenta la segunda: h₂ = f(W₂h₁ + b₂).
Y así hasta la salida: y = f(W₃h₂ + b₃).

Cada capa tiene su propia matriz de pesos W y su bias b; la f es la activación (ReLU en las ocultas, según el módulo 2). El forward pass es solo eso: multiplicar, sumar el bias, activar, y pasar a la siguiente. Sin drama. La magia no está en el forward — está en cómo se ajustan esos pesos, que es el módulo 4 en adelante.

Ojo: “feed-forward” significa que la información fluye en un solo sentido, hacia adelante, sin ciclos ni memoria. Cuando lleguemos a las secuencias (módulo 11) veremos redes que sí guardan estado; pero el MLP es puro flujo hacia adelante.

Por qué una red basta para casi todo

Aquí está el resultado que le da sustento teórico a todo el campo: el teorema de aproximación universal. En simple dice que una red con una sola capa oculta, si tiene suficientes neuronas y una activación no-lineal, puede aproximar cualquier función continua con la precisión que quieras.

La intuición: cada neurona aporta un “escalón” o “codo” a la curva de salida. Con pocas neuronas armas una aproximación tosca; con muchas, vas afinando la curva hasta que calza con la función objetivo tan bien como necesites. Es como aproximar una montaña con piezas de Lego: mientras más piezas, más fiel el contorno.

Dos advertencias sobre este teorema, que suena mágico pero no lo es tanto:

Dice que la red puede representar la función, no que la vaya a aprender sola. Encontrar los pesos correctos es otro problema (el del entrenamiento).
“Suficientes neuronas” en una sola capa puede significar una cantidad absurda. En la práctica es mucho más eficiente ir profundo (varias capas) que ancho (una capa gigante) — el porqué es el módulo 9.

Ancho, profundidad y capacidad

Configuración	Capas ocultas	Qué puede modelar
Perceptrón	0	Solo fronteras rectas (adiós XOR)
MLP chico	1 (pocas neuronas)	Curvas simples, XOR ya sí
MLP mediano	1–2 (decenas)	Patrones no triviales en tablas
MLP profundo	3+	Representaciones jerárquicas y abstractas

Más capas y más neuronas = más capacidad (poder de modelar cosas complejas). Pero ojo: más capacidad también significa más riesgo de memorizar en vez de aprender — ese es el overfitting del módulo 7.

Un MLP en PyTorch

nn.Sequential apila capas en orden: los datos pasan por cada una de arriba a abajo. Fíjate en el patrón Linear → ReLU → Linear → ReLU → Linear: capa densa, activación, capa densa, activación… La última Linear es la salida y no lleva ReLU.

import torch
import torch.nn as nn

# MLP: 3 entradas -> 4 ocultas -> 4 ocultas -> 1 salida
red = nn.Sequential(
    nn.Linear(3, 4),   # capa oculta 1: 3 entradas -> 4 neuronas
    nn.ReLU(),         # no-linealidad (módulo 2)
    nn.Linear(4, 4),   # capa oculta 2: 4 -> 4
    nn.ReLU(),
    nn.Linear(4, 1),   # capa de salida: 4 -> 1 (sin activación aquí)
)

x = torch.tensor([0.5, 0.3, 0.9])
y = red(x)             # esto es el forward pass completo
print(y)               # -> tensor con la salida de la red

Y así se ve resolviendo XOR de verdad — la red que el perceptrón no podía construir:

import torch
import torch.nn as nn

xor = nn.Sequential(
    nn.Linear(2, 4),   # 2 entradas -> 4 neuronas ocultas
    nn.ReLU(),         # SIN esta línea, XOR sería imposible
    nn.Linear(4, 1),   # -> 1 salida
)

# las 4 combinaciones de XOR
entradas = torch.tensor([[0., 0.], [0., 1.], [1., 0.], [1., 1.]])
print(xor(entradas))   # sin entrenar aún da ruido; el módulo 4 lo entrena

Errores comunes

Poner activación en la capa de salida por reflejo. La salida elige su activación según la tarea (o ninguna, en regresión); no se le mete ReLU automáticamente.
Creer que más capas siempre es mejor. Más profundidad da más capacidad, pero también más costo, más datos necesarios y más riesgo de overfitting. Se empieza chico.
Olvidar la ReLU entre capas. Sin la no-linealidad entre las Linear, la red vuelve a colapsar en una recta (módulo 2). Es el error más silencioso.
Leer el teorema universal como “una capa basta”. Puede aproximar, pero necesitaría un ancho descomunal; la profundidad es lo que lo hace práctico.
Confundir el forward pass con el aprendizaje. El forward solo calcula una respuesta con los pesos actuales; aprender es corregir esos pesos, y eso todavía no ocurre aquí.

La frase para llevarse

“Una neurona traza una recta; una torre de neuronas con no-linealidad traza cualquier cosa. Eso es una red feed-forward.”

Qué viene

Módulo 4: cómo aprende una red I. Hasta aquí la red da respuestas al azar, porque sus pesos son aleatorios. Ahora empieza lo bueno: definiremos qué significa “equivocarse” (la función de pérdida) y cómo bajar ese error paso a paso con el descenso de gradiente.

Redes Neuronales — Módulo 3: la red feed-forward — de una neurona a una red (MLP)