Unidad 5. Redes Neuronales

El acceso a la presentación se obtiene mediante: https://canva.link/tuz5lfoavuroyji

Fundamentos en Ciencias de la Computación

Este documento expande y formaliza el contenido de la presentación de clase.

1. Introducción:

Como señala la presentación, casi toda la IA que usamos a diario —traductores, asistentes de voz, sistemas de recomendación, generadores de texto e imágenes— corre hoy sobre redes neuronales. La razón es histórica y empírica: a partir de 2012, con la disponibilidad de grandes volúmenes de datos y de hardware especializado (GPU), las redes profundas pasaron a superar de forma consistente a los métodos anteriores en visión, lenguaje y voz (Krizhevsky et al., 2012; LeCun et al., 2015).

Definición operativa. Una red neuronal artificial es una función parametrizada $f(\mathbf{x}; \boldsymbol{\phi})$ que transforma una entrada $\mathbf{x}$ en una salida $\mathbf{y}$, construida componiendo unidades simples (neuronas) organizadas en capas, y cuyos parámetros $\boldsymbol{\phi}$ se ajustan a partir de datos para minimizar un error (Prince, 2023).

La metáfora "neuronal" tiene valor histórico, pero conviene tomarla con cuidado: la inspiración biológica fue real en los orígenes (McCulloch & Pitts, 1943), pero las redes actuales son objetos matemáticos cuyo funcionamiento se entiende mejor desde el álgebra lineal y el cálculo que desde la neurociencia (Goodfellow et al., 2016).

2. El perceptrón: la neurona artificial

2.1 Contexto histórico

La idea de modelar una neurona como una unidad de cómputo nació en 1943, cuando Warren McCulloch y Walter Pitts propusieron un modelo lógico de la neurona: una unidad que recibe entradas binarias, las combina y produce una salida binaria si se supera un umbral (McCulloch & Pitts, 1943). Era un dispositivo de todo-o-nada, sin aprendizaje.

El salto decisivo lo dio Frank Rosenblatt en 1958 con el perceptrón, que agregó algo crucial: un procedimiento para aprender los pesos a partir de ejemplos (Rosenblatt, 1958). El perceptrón de Rosenblatt podía, automáticamente, ajustar la importancia de cada entrada para clasificar correctamente los datos de entrenamiento. Fue uno de los primeros modelos de aprendizaje automático de la historia.

2.2 Definición formal

Una neurona artificial recibe un vector de entradas $\mathbf{x} = (x_1, x_2, \dots, x_n)$, asigna a cada una un peso $w_i$ (cuánto importa esa entrada), las suma, le agrega un sesgo (bias) $b$, y pasa el resultado por una función de activación $f$:

$$ z = \sum_{i=1}^{n} w_i x_i + b = \mathbf{w}^\top \mathbf{x} + b \qquad\qquad y = f(z) $$

$z$ es la combinación lineal de las entradas (en el diagrama de la slide 3, la parte "$z$" de la neurona).
$f$ es la función de activación (la parte "$f$"), que decide la salida final.

El sesgo $b$ suele representarse como una entrada ficticia $x_0 = 1$ con su propio peso, lo que permite escribir todo como un único producto interno. Esto explica el nodo "$x_0 = 1$" del diagrama de la presentación: es un truco de notación, no una entrada real del problema.

Conexión con la notación del curso. En la slide 3 aparece $h_1 = a[\theta_{10} + \theta_{11}x]$. Acá $a[\cdot]$ es la función de activación, $\theta_{10}$ hace las veces del sesgo $b$ y $\theta_{11}$ es el peso de la entrada $x$. Es exactamente la misma idea con la notación de Prince (2023), donde los pesos de la primera capa se denotan con $\theta$.

2.3 Funciones de activación

La neurona "decide la salida". Sin una activación no lineal, una red de muchas capas colapsa en una única transformación lineal y pierde todo su poder (Goodfellow et al., 2016). Las más usadas son:

Función	Fórmula	Rango	Uso típico
Escalón (step)	$f(z)=1$ si $z\ge 0$, si no $0$	${0,1}$	Perceptrón histórico
Sigmoide	$\sigma(z)=\dfrac{1}{1+e^{-z}}$	$(0,1)$	Salida de probabilidad binaria
Tangente hiperbólica	$\tanh(z)$	$(-1,1)$	Capas ocultas (clásico)
ReLU	$\max(0, z)$	$[0,\infty)$	Estándar actual en capas ocultas

La ReLU (Rectified Linear Unit) es hoy la opción por defecto en capas ocultas porque es simple, barata de calcular y mitiga problemas de entrenamiento que tenían la sigmoide y la tanh (Glorot et al., 2011; Prince, 2023). Las "rampitas" que aparecen dentro de las neuronas en el diagrama de redes profundas de la slide 7 son, precisamente, el símbolo de una ReLU.

Atención — perceptrón vs. neurona moderna. El perceptrón original (Rosenblatt) usa una activación escalón, produce salidas binarias y se entrena con la regla del perceptrón (no con descenso por gradiente). La "neurona" que se usa hoy dentro de las redes profundas usa activaciones continuas y diferenciables (ReLU, sigmoide), porque el entrenamiento por gradiente exige derivar la función. Son parientes, pero no son lo mismo (Bishop, 2006; Goodfellow et al., 2016).

2.4 Ejemplo desarrollado: la compuerta AND

Supongamos dos entradas binarias $x_1, x_2 \in {0,1}$ y queremos que la neurona devuelva 1 solo cuando ambas valen 1 (función lógica AND). Con activación escalón, los parámetros $w_1 = 1$, $w_2 = 1$, $b = -1.5$ resuelven el problema:

$x_1$	$x_2$	$z = x_1 + x_2 - 1.5$	$f(z)$
0	0	$-1.5$	0
0	1	$-0.5$	0
1	0	$-0.5$	0
1	1	$\;\;0.5$	1

La neurona "se activa" solo en la última fila. Geométricamente, está trazando una recta que separa el punto $(1,1)$ del resto.

2.5 La limitación fundamental: el problema XOR

Acá aparece el vacío conceptual más importante de la sección, que la presentación no menciona. Un perceptrón simple solo puede resolver problemas linealmente separables: aquellos cuyas clases se pueden separar con una recta (o un hiperplano en más dimensiones).

La función lógica XOR (verdadero cuando las entradas difieren) no es linealmente separable: no existe ninguna recta que separe ${(0,1),(1,0)}$ de ${(0,0),(1,1)}$. Minsky y Papert (1969) demostraron formalmente esta limitación, y su libro Perceptrons contribuyó a un período de desencanto y reducción de fondos conocido como el primer "invierno de la IA" (Goodfellow et al., 2016).

La salida del problema fue apilar neuronas en capas: una red con una capa oculta sí puede resolver XOR. Esta es exactamente la motivación que conecta la sección del perceptrón con la siguiente.

3. De la neurona a la red

Una sola neurona traza una frontera lineal. La potencia aparece cuando apilamos muchas neuronas en capas, y conectamos las salidas de una capa con las entradas de la siguiente. Cada conexión tiene su propio peso, y el conjunto de todos los pesos y sesgos constituye los parámetros de la red que el entrenamiento ajustará.

La arquitectura básica tiene tres tipos de capas:

Capa de entrada (input layer): recibe los datos crudos $\mathbf{x}$. No hace cómputo, solo distribuye los valores.
Capas ocultas (hidden layers): cada neurona (o unidad oculta) calcula una combinación lineal de la capa previa y le aplica una activación. Se llaman "ocultas" porque sus valores no se observan ni en la entrada ni en la salida.
Capa de salida (output layer): produce la predicción final $\mathbf{y}$.

La intuición clave es la composición: cada capa transforma la representación de los datos en otra más útil para la tarea. Las primeras capas detectan rasgos simples y las posteriores combinan esos rasgos en conceptos más abstractos (LeCun et al., 2015). A esto se lo llama aprendizaje de representaciones, y es lo que distingue al deep learning de los métodos clásicos en los que las características se diseñaban manualmente.

4. Redes poco profundas (shallow networks)

4.1 Definición

Una red poco profunda es una red con una sola capa oculta (Prince, 2023). Es el caso más simple que ya supera las limitaciones del perceptrón. La presentación la formaliza, en la slide 5, con la ecuación:

$$ y = \phi_0 + \phi_1 h_1 + \phi_2 h_2 + \phi_3 h_3 $$

Esta fórmula muestra solo la mitad de la historia, así que conviene completarla. La salida $y$ es una combinación lineal de las unidades ocultas $h_j$, ponderadas por los pesos de salida $\phi_j$ (con $\phi_0$ el sesgo de salida). Pero, ¿de dónde salen las $h_j$? Cada unidad oculta es, a su vez, una neurona:

$$ h_j = a\big(\theta_{j0} + \theta_{j1}\, x\big) $$

donde $a(\cdot)$ es la función de activación (típicamente ReLU), $\theta_{j0}$ es el sesgo y $\theta_{j1}$ el peso de entrada de la unidad $j$. Sustituyendo, la red completa para una entrada escalar $x$ y tres unidades ocultas es:

$$ y = \phi_0 + \sum_{j=1}^{3} \phi_j \, a\big(\theta_{j0} + \theta_{j1}\, x\big) $$

Nota sobre la notación (slide 6). El diagrama distingue dos conjuntos de parámetros, siguiendo a Prince (2023): - $\theta_{j\bullet}$ (en naranja): pesos y sesgos que van de la entrada a la capa oculta. - $\phi_{j}$ (en gris): pesos y sesgos que van de la capa oculta a la salida.

Los nodos con "1" representan las entradas de sesgo. La parte b) del diagrama es la misma red, dibujada sin las conexiones de sesgo para mostrar solo el esqueleto. Esta convención de $\theta$ para la entrada y $\phi$ para la salida es específica del texto del curso; otros libros usan $W^{(1)}, W^{(2)}$ o $\mathbf{w}, \mathbf{v}$.

4.2 Por qué funcionan: el teorema de aproximación universal

Esta es la propiedad teórica que justifica todo lo anterior. El teorema de aproximación universal establece que una red con una sola capa oculta, suficientes unidades y una activación no lineal adecuada, puede aproximar cualquier función continua sobre un dominio acotado con la precisión que se quiera (Cybenko, 1989; Hornik, 1991).

En otras palabras: en teoría, no hace falta profundidad para representar funciones complejas; basta una capa oculta lo suficientemente ancha. Cada unidad oculta con ReLU aporta un "quiebre" en la función, y sumando muchos quiebres se aproxima cualquier curva (Prince, 2023).

Atención — qué dice y qué no dice el teorema. El teorema garantiza que existe una red que aproxima la función, pero no dice (a) cuántas unidades se necesitan —pueden ser exponencialmente muchas—, ni (b) que el entrenamiento vaya a encontrar esos pesos. Esta brecha entre "representable" y "aprendible" es justamente lo que motiva el uso de redes profundas, que veremos a continuación (Goodfellow et al., 2016).

4.3 Ejemplo intuitivo

Pensemos en aproximar una curva como $y = \sin(x)$ en el intervalo $[0, 2\pi]$. Con unidades ReLU, cada una "se enciende" a partir de cierto valor de $x$ y aporta una recta inclinada. Tres o cuatro unidades dan una aproximación poligonal grosera; con decenas de unidades la suma de todos esos tramos lineales se vuelve indistinguible de la curva suave. Aumentar el número de unidades ocultas aumenta la capacidad de la red para representar funciones más complejas (Prince, 2023).

5. Redes profundas (deep networks)

5.1 De una capa a muchas

Una red profunda apila varias capas ocultas, una tras otra (slide 7). La salida de cada capa es la entrada de la siguiente:

$$ \mathbf{h}_1 = a(\boldsymbol{\beta}_0 + \boldsymbol{\Omega}_0 \mathbf{x}), \quad \mathbf{h}_2 = a(\boldsymbol{\beta}_1 + \boldsymbol{\Omega}_1 \mathbf{h}_1), \quad \dots, \quad \mathbf{y} = \boldsymbol{\beta}_K + \boldsymbol{\Omega}_K \mathbf{h}_K $$

Acá se pasa a notación matricial, indispensable cuando hay muchas neuronas por capa:

$\boldsymbol{\Omega}_k$ es la matriz de pesos de la capa $k$. Su tamaño es (n.º de neuronas de la capa siguiente) × (n.º de neuronas de la capa actual).
$\boldsymbol{\beta}_k$ es el vector de sesgos de la capa $k$.
$a(\cdot)$ se aplica elemento a elemento.

Lectura del diagrama (slide 7). Las dimensiones $D_i = 3$, $D_1 = 4$, $D_2 = 2$, $D_3 = 3$, $D_o = 2$ indican cuántas neuronas tiene cada capa. Por eso $\boldsymbol{\Omega}_0 \in \mathbb{R}^{4\times 3}$ (mapea 3 entradas a 4 unidades de $\mathbf{h}_1$), $\boldsymbol{\Omega}_1 \in \mathbb{R}^{2\times 4}$, etc. Verificar estas dimensiones es un excelente ejercicio de álgebra lineal: el número de columnas de cada matriz debe coincidir con el número de neuronas de la capa que la alimenta.

5.2 ¿Por qué ir más profundo?

Si una red poco profunda ya es un aproximador universal, ¿para qué agregar capas?:

Eficiencia de la profundidad. Ciertas funciones que una red profunda representa con un número moderado de neuronas requerirían una cantidad exponencialmente mayor de neuronas en una red de una sola capa. La profundidad permite reutilizar y componer cálculos intermedios (Montúfar et al., 2014; Telgarsky, 2016).
Jerarquía de representaciones. Las capas tempranas aprenden rasgos simples (bordes, en una imagen) y las profundas los combinan en conceptos complejos (formas, objetos). Esta composición jerárquica refleja la estructura del mundo real (LeCun et al., 2015).
Resultados empíricos. Desde 2012, las arquitecturas profundas dominan los benchmarks de visión, lenguaje y voz (Krizhevsky et al., 2012).

El precio de la profundidad es un entrenamiento más difícil (gradientes que se desvanecen o explotan) y mayor riesgo de sobreajuste, problemas que se abordan con técnicas como la normalización, las conexiones residuales y la regularización (Goodfellow et al., 2016; Prince, 2023).

6. ¿Cómo aprende una red? El entrenamiento

Hasta acá describimos qué calcula una red, pero no cómo encuentra los valores de sus parámetros. Entrenar una red es, esencialmente, un problema de optimización: buscar los pesos y sesgos que hagan que las predicciones se parezcan lo más posible a las respuestas reales (Goodfellow et al., 2016). Ese proceso es un ciclo de cuatro pasos que se repite muchas veces sobre los datos:

Convención de notación. A lo largo de esta sección, $\hat{y}$ (con "sombrero") es lo que predice la red; $y$ (sin sombrero) es la respuesta correcta o etiqueta real. Es una convención estándar y conviene fijarla desde el inicio para no confundir predicción con verdad de referencia.

6.1 Paso 1 — Forward pass (predicción)

Se toma una entrada $\mathbf{x}$ y se la propaga por la red, capa por capa, hasta obtener la predicción $\hat{y}$. No hay nada nuevo acá: es simplemente evaluar la función $f(\mathbf{x}; \boldsymbol{\phi})$ con los parámetros que la red tiene en ese momento (al principio, inicializados al azar). Por eso las primeras predicciones son malas: la red todavía no aprendió nada.

6.2 Paso 2 — Función de pérdida (error)

Se mide cuánto se equivocó la red comparando $\hat{y}$ con el valor real $y$ mediante una función de pérdida (loss) $L$. La elección de $L$ depende de la tarea (Bishop, 2006):

Tarea	Pérdida típica	Fórmula (un ejemplo)
Regresión	Error cuadrático medio (MSE)	$L = (\hat{y}-y)^2$
Clasificación	Entropía cruzada	$L = -\sum_c y_c \log \hat{y}_c$

La pérdida promediada sobre el conjunto de entrenamiento define una superficie de error en el espacio de los parámetros. Aprender es, geométricamente, descender por esa superficie hasta un valle (un mínimo) (Goodfellow et al., 2016).

6.3 Paso 3 — Backpropagation (cálculo del gradiente)

Acá es donde más conviene ser preciso, porque es la fuente de confusión más común. La retropropagación no actualiza los pesos: calcula los gradientes. Es decir, computa la derivada parcial de la pérdida respecto de cada parámetro, $\partial L / \partial w_i$, que indica cuánto y en qué dirección cambia el error si modificamos ese peso (Rumelhart et al., 1986).

Su nombre viene de que aplica la regla de la cadena del cálculo de manera ordenada, propagando la información desde la salida hacia la entrada y reutilizando resultados intermedios. La contribución de Rumelhart, Hinton y Williams (1986) fue, precisamente, hacer este cálculo eficiente para redes grandes; sin él, entrenar redes profundas sería inviable.

Atención — distinción clave (pasos 3 y 4). En el diagrama aparecen como etapas separadas, y conviene no fundirlas: - Backpropagation = algoritmo que calcula los gradientes (cuánto aportó cada peso al error). - Descenso por gradiente = regla de optimización que usa esos gradientes para actualizar los pesos.

La retropropagación es solo el medio para obtener los gradientes; la optimización es lo que efectivamente mueve los parámetros (Goodfellow et al., 2016).

6.4 Paso 4 — Ajuste (descenso por gradiente)

Con los gradientes ya calculados, cada peso se corrige dando un pequeño paso en la dirección opuesta al gradiente —la dirección que reduce el error—:

$$ w_i \leftarrow w_i - \eta \, \frac{\partial L}{\partial w_i} $$

El factor $\eta$ es la tasa de aprendizaje (learning rate), un hiperparámetro crítico que controla el tamaño del paso:

Si $\eta$ es demasiado grande, los pasos sobrepasan el mínimo y el entrenamiento puede oscilar o divergir.
Si $\eta$ es demasiado chico, el aprendizaje es correcto pero lentísimo.

En la práctica no se calcula el gradiente sobre todo el conjunto de datos en cada paso (sería carísimo), sino sobre pequeños subconjuntos llamados mini-lotes (mini-batches). A esto se lo llama descenso por gradiente estocástico (SGD), y es la base sobre la que se construyen optimizadores más sofisticados como Adam, que adaptan la tasa de aprendizaje a lo largo del entrenamiento (Kingma & Ba, 2015; Goodfellow et al., 2016).

6.5 Repetir: épocas, iteraciones y lotes

El ciclo se repite muchas veces, y la flecha de retorno del diagrama vuelve al paso 1: con los pesos ya ajustados, la red vuelve a predecir, a medir el error y a corregirse. Cada vuelta, "se equivoca un poco menos" porque los parámetros se acercan a un mínimo de la pérdida. Conviene distinguir tres términos que suelen confundirse:

Iteración: una única actualización de pesos, hecha con un mini-lote.
Época (epoch): un recorrido completo por todo el conjunto de entrenamiento. Una época contiene muchas iteraciones.
Lote (batch): el subconjunto de datos usado en una iteración.

Nota — cuándo detenerse. Entrenar de más es contraproducente: la red puede empezar a memorizar los datos de entrenamiento en lugar de aprender patrones generalizables, fenómeno conocido como sobreajuste (overfitting). Por eso el entrenamiento suele detenerse cuando el error sobre un conjunto de validación deja de mejorar, una técnica llamada early stopping (Bishop, 2006; Prince, 2023).

7. Tipos de redes neuronales

Como bien dice la slide 9, no existe una sola arquitectura: se elige según el tipo de dato y el problema. La siguiente tabla resume la taxonomía antes de detallar cada familia.

Arquitectura	Dato ideal	Idea central	Aplicación típica
MLP / densa	Tabular	Capas totalmente conectadas	Clasificación/regresión sobre tablas
CNN	Imágenes, datos espaciales	Filtros locales que se comparten	Visión por computadora
RNN / LSTM	Secuencias	Memoria del estado anterior	Series temporales, texto, audio
Transformer	Secuencias (y más)	Autoatención global	LLMs, traducción, visión moderna

7.1 Feedforward / densas (MLP)

El perceptrón multicapa (Multi-Layer Perceptron, MLP) es la red "por defecto": la información fluye en una sola dirección —entrada → capas ocultas → salida— sin ciclos (por eso feedforward). Cada neurona está conectada con todas las de la capa siguiente, de ahí el término totalmente conectada (fully connected).

Son ideales para datos tabulares (filas y columnas, como una planilla) y aparecen como tramo final de arquitecturas más complejas, donde transforman las representaciones aprendidas en la predicción definitiva.

Lectura del diagrama (slide 10). Los números sobre las flechas (ihWeight, hoWeight) son los pesos entrada→oculta y oculta→salida; hBias y oBias son los sesgos. Los valores dentro de las neuronas (.4699, .5227, ...) son salidas tras aplicar una sigmoide —por eso caen entre 0 y 1—. Es un ejemplo numérico concreto de un forward pass.

Desventaja: en datos con estructura espacial (imágenes), una MLP ignora la vecindad de los píxeles y necesita una enormidad de parámetros, lo que motiva la siguiente arquitectura.

7.2 Convolucionales (CNN)

Las redes convolucionales (Convolutional Neural Networks, CNN) están pensadas para imágenes y datos con estructura espacial. En lugar de conectar todo con todo, aplican filtros (kernels) que recorren la entrada detectando patrones locales: en las capas tempranas, bordes; luego, formas; finalmente, objetos completos (LeCun et al., 1998; Krizhevsky et al., 2012).

Su gran ventaja es el uso compartido de parámetros (parameter sharing): el mismo filtro se aplica en toda la imagen, lo que reduce drásticamente el número de parámetros frente a una densa equivalente y aporta equivarianza a la traslación (un patrón se detecta sin importar dónde aparezca).

Nota sobre el diagrama (slide 11). La figura ilustra convoluciones en 1D con distintos hiperparámetros, no en 2D como sugiere el texto sobre imágenes. Los conceptos son los mismos y generalizan a 2D/3D. Vale aclarar la terminología: - Size (tamaño del kernel): cuántas posiciones cubre el filtro. - Stride (paso): de a cuántas posiciones se desplaza el filtro. Un stride mayor reduce el tamaño de la salida. - Dilation (dilatación): separación entre las posiciones que el filtro lee, para "ver" más lejos sin agrandar el kernel (Prince, 2023).

La presentación omite el pooling (submuestreo), operación habitual en CNN que reduce la resolución y aporta robustez; conviene mencionarlo como complemento.

7.3 Recurrentes (RNN / LSTM)

Las redes recurrentes (Recurrent Neural Networks, RNN) están pensadas para secuencias: texto, audio, series temporales. Su rasgo distintivo es la memoria: en cada paso, la red combina la entrada actual con un estado oculto que resume lo visto hasta el momento. Es la misma red aplicada repetidamente a cada elemento de la secuencia, pasando información de un paso al siguiente (Elman, 1990).

El problema es que las RNN simples olvidan la información lejana: durante el entrenamiento, los gradientes que viajan muchos pasos hacia atrás tienden a desvanecerse (o, menos común, a explotar), lo que impide aprender dependencias de largo plazo (Bengio et al., 1994). La slide no menciona este problema, que es justamente lo que motiva la siguiente variante.

Las LSTM (Long Short-Term Memory) resuelven esto con un mecanismo de compuertas (gates) que regulan qué información guardar, olvidar y emitir, manteniendo una "celda de memoria" estable a lo largo de muchos pasos (Hochreiter & Schmidhuber, 1997). Por eso "mejoran la memoria de largo plazo". Una variante más simple y muy usada es la GRU (Cho et al., 2014).

Lectura del diagrama (slide 12). Las cajas idénticas representan la misma red aplicada a cada palabra de la frase ("It takes great personal courage to..."); las flechas naranjas horizontales son el estado oculto que se transmite de un paso al siguiente. Las palabras entran como word embeddings (vectores que representan su significado).

7.4 Transformers (estado del arte)

Los Transformers son hoy la arquitectura dominante para secuencias —y crecientemente también para imágenes— y son la base de los grandes modelos de lenguaje (LLMs) (Vaswani et al., 2017).

Su innovación es el mecanismo de autoatención (self-attention): en lugar de leer la secuencia paso a paso como una RNN, miran todos los elementos a la vez y, para cada uno, calculan cuánto debe "prestar atención" a cada uno de los demás. Esto tiene dos consecuencias enormes:

Paralelismo. Al no procesar la secuencia en orden estricto, el cómputo se paraleliza masivamente en GPU, lo que permitió entrenar modelos enormes (Vaswani et al., 2017).
Dependencias de largo alcance. Cualquier elemento puede relacionarse directamente con cualquier otro, sin la degradación de memoria de las RNN.

Conceptos que la slide no nombra pero conviene conocer. - Consulta, clave y valor (query, key, value): cada elemento genera estos tres vectores; la atención compara consultas con claves para decidir cuánto de cada valor incorporar (Vaswani et al., 2017). - Codificación posicional (positional encoding): como el modelo no procesa en orden, hay que inyectar la posición de cada elemento explícitamente; de lo contrario, "el gato come" y "come el gato" serían indistinguibles. - Atención multi-cabeza (multi-head attention): se ejecutan varias atenciones en paralelo para captar distintos tipos de relación.

Lectura del diagrama (slide 13). Ilustra un Transformer en una tarea de predicción de tokens enmascarados (estilo BERT): algunas palabras se ocultan (<mask>) y el modelo predice cuál era, usando el contexto de toda la frase. La columna final ("Probability of masked token") es la distribución de probabilidad sobre el vocabulario, producida por una capa lineal + softmax. El bloque se repite $K$ veces (las "×K" capas apiladas).

8. Síntesis y conclusiones

El recorrido de esta unidad sigue una progresión lógica que vale la pena tener clara como mapa mental:

La unidad mínima es la neurona: una combinación lineal de entradas, un sesgo y una activación. Sola, solo traza fronteras lineales (limitación XOR).
Apilar neuronas en capas rompe esa limitación. Con una capa oculta ya se puede aproximar cualquier función (aproximación universal), aunque sin garantías sobre cuántas unidades hacen falta ni sobre poder entrenarla.
La profundidad aporta eficiencia y representaciones jerárquicas, al precio de un entrenamiento más delicado.
El aprendizaje es un ciclo de cuatro pasos —predecir, medir el error, calcular gradientes (backpropagation) y ajustar pesos (descenso por gradiente)— repetido a lo largo de muchas épocas.
No hay una arquitectura única: MLP para datos tabulares, CNN para lo espacial, RNN/LSTM para secuencias, y Transformers como estado del arte que desplazó a las recurrentes gracias a la autoatención.

La idea unificadora detrás de todo es el aprendizaje de representaciones: las redes no solo predicen, sino que aprenden, por sí mismas, qué características de los datos importan para la tarea. Esa capacidad —y la disponibilidad de datos y cómputo— explica por qué las redes neuronales pasaron de una curiosidad histórica a la tecnología que sostiene la IA contemporánea (LeCun et al., 2015; Prince, 2023).

Para seguir. Quien quiera profundizar de manera autocontenida y moderna encontrará en Prince (2023) —disponible de forma gratuita— el desarrollo formal de todo lo visto acá, con la misma notación de las diapositivas. Goodfellow et al. (2016) ofrece la referencia enciclopédica del campo, y Bishop (2006) el fundamento estadístico clásico.

9. Glosario

Término	Definición breve
Peso (weight)	Parámetro que mide la importancia de una conexión entre neuronas.
Sesgo (bias)	Término aditivo que desplaza la activación; permite que la neurona no pase por el origen.
Activación	Función no lineal aplicada a la suma ponderada; sin ella la red sería lineal.
Capa oculta	Capa intermedia cuyos valores no se observan en entrada ni salida.
Forward pass	Cálculo de la predicción propagando la entrada por la red.
Pérdida (loss)	Medida del error entre predicción $\hat y$ y valor real $y$.
Backpropagation	Algoritmo que calcula los gradientes de la pérdida vía regla de la cadena.
Descenso por gradiente	Regla de optimización que actualiza los pesos usando los gradientes.
Tasa de aprendizaje	Tamaño del paso en cada actualización de pesos.
Época (epoch)	Un recorrido completo por todo el conjunto de entrenamiento.
Sobreajuste (overfitting)	Cuando la red memoriza el entrenamiento y generaliza mal a datos nuevos.
Autoatención	Mecanismo que relaciona cada elemento de una secuencia con todos los demás.

10. Referencias

Bengio, Y., Simard, P., & Frasconi, P. (1994). Learning long-term dependencies with gradient descent is difficult. IEEE Transactions on Neural Networks, 5(2), 157–166. https://doi.org/10.1109/72.279181

Bishop, C. M. (2006). Pattern recognition and machine learning. Springer.

Cho, K., van Merriënboer, B., Gulcehre, C., Bahdanau, D., Bougares, F., Schwenk, H., & Bengio, Y. (2014). Learning phrase representations using RNN encoder–decoder for statistical machine translation. Proceedings of the 2014 Conference on Empirical Methods in Natural Language Processing (EMNLP), 1724–1734. https://doi.org/10.3115/v1/D14-1179

Cybenko, G. (1989). Approximation by superpositions of a sigmoidal function. Mathematics of Control, Signals and Systems, 2(4), 303–314. https://doi.org/10.1007/BF02551274

Elman, J. L. (1990). Finding structure in time. Cognitive Science, 14(2), 179–211. https://doi.org/10.1207/s15516709cog1402_1

Glorot, X., Bordes, A., & Bengio, Y. (2011). Deep sparse rectifier neural networks. Proceedings of the 14th International Conference on Artificial Intelligence and Statistics (AISTATS), 15, 315–323.

Goodfellow, I., Bengio, Y., & Courville, A. (2016). Deep learning. MIT Press.

Hochreiter, S., & Schmidhuber, J. (1997). Long short-term memory. Neural Computation, 9(8), 1735–1780. https://doi.org/10.1162/neco.1997.9.8.1735

Hornik, K. (1991). Approximation capabilities of multilayer feedforward networks. Neural Networks, 4(2), 251–257. https://doi.org/10.1016/0893-6080(91)90009-T

Kingma, D. P., & Ba, J. (2015). Adam: A method for stochastic optimization. Proceedings of the 3rd International Conference on Learning Representations (ICLR).

Krizhevsky, A., Sutskever, I., & Hinton, G. E. (2012). ImageNet classification with deep convolutional neural networks. Advances in Neural Information Processing Systems (NeurIPS), 25, 1097–1105.

LeCun, Y., Bengio, Y., & Hinton, G. (2015). Deep learning. Nature, 521(7553), 436–444. https://doi.org/10.1038/nature14539

LeCun, Y., Bottou, L., Bengio, Y., & Haffner, P. (1998). Gradient-based learning applied to document recognition. Proceedings of the IEEE, 86(11), 2278–2324. https://doi.org/10.1109/5.726791

McCulloch, W. S., & Pitts, W. (1943). A logical calculus of the ideas immanent in nervous activity. Bulletin of Mathematical Biophysics, 5(4), 115–133. https://doi.org/10.1007/BF02478259

Minsky, M., & Papert, S. (1969). Perceptrons: An introduction to computational geometry. MIT Press.

Montúfar, G., Pascanu, R., Cho, K., & Bengio, Y. (2014). On the number of linear regions of deep neural networks. Advances in Neural Information Processing Systems (NeurIPS), 27, 2924–2932.

Prince, S. J. D. (2023). Understanding deep learning. MIT Press. https://udlbook.github.io/udlbook/

Rosenblatt, F. (1958). The perceptron: A probabilistic model for information storage and organization in the brain. Psychological Review, 65(6), 386–408. https://doi.org/10.1037/h0042519

Rumelhart, D. E., Hinton, G. E., & Williams, R. J. (1986). Learning representations by back-propagating errors. Nature, 323(6088), 533–536. https://doi.org/10.1038/323533a0

Telgarsky, M. (2016). Benefits of depth in neural networks. Proceedings of the 29th Conference on Learning Theory (COLT), 49, 1517–1539.

Vaswani, A., Shazeer, N., Parmar, N., Uszkoreit, J., Jones, L., Gomez, A. N., Kaiser, Ł., & Polosukhin, I. (2017). Attention is all you need. Advances in Neural Information Processing Systems (NeurIPS), 30, 5998–6008.