Notación y Vocabulario

Antes de sumergirnos en las matemáticas, establezcamos un vocabulario común. En el aprendizaje automático y las redes neuronales, encontrarás frecuentemente:

• Escalares: Números únicos (por ejemplo, $x = 5$)
• Vectores: Listas ordenadas de números, denotadas como $\mathbf{v} = [v_1, v_2, \dots, v_n]$
• Matrices: Arreglos 2D de números, denotados como $\mathbf{A}$
• Funciones: Mapeos de entradas a salidas, $f: \mathbb{R}^n \to \mathbb{R}^m$
• Parámetros: Valores que aprendemos durante el entrenamiento (pesos, sesgos)

Esta notación se convierte en nuestro lenguaje compartido para describir cálculos en redes neuronales.

Álgebra Lineal: Vectores y Matrices

El álgebra lineal es el caballo de batalla del aprendizaje automático. Cada cálculo en una red neuronal puede expresarse como operaciones sobre vectores y matrices.

Los vectores representan puntos de datos. Por ejemplo, una imagen con 784 píxeles puede representarse como un vector $\mathbf{x} \in \mathbb{R}^{784}$.

Las matrices representan transformaciones. Una matriz de pesos $\mathbf{W} \in \mathbb{R}^{m \times n}$ transforma una entrada $n$-dimensional en una salida $m$-dimensional.

Operaciones clave:

1. Suma de vectores: $\mathbf{u} + \mathbf{v} = [u_1+v_1, u_2+v_2, \dots]$
2. Multiplicación por escalar: $c\mathbf{v} = [cv_1, cv_2, \dots]$
3. Producto punto: $\mathbf{u} \cdot \mathbf{v} = \sum_i u_i v_i$
4. Multiplicación de matrices: $(\mathbf{A}\mathbf{B})_{ij} = \sum_k A_{ik} B_{kj}$

El producto punto es particularmente importante—mide la similitud entre vectores y es la operación fundamental en las redes neuronales.

Por qué importa: Las redes neuronales transforman datos a través de secuencias de transformaciones lineales (multiplicaciones de matrices). Comprender estas operaciones nos ayuda a entender qué está aprendiendo la red.

Probabilidad Básica: Variables Aleatorias y Distribuciones

Las redes neuronales operan en un mundo de incertidumbre. La teoría de la probabilidad nos proporciona herramientas para modelar y razonar sobre esta incertidumbre.

Variables aleatorias: Variables cuyos valores dependen de resultados aleatorios. Por ejemplo, $X$ podría representar los valores de píxeles en una imagen, que varían aleatoriamente según el contenido de la imagen.

Distribuciones: Funciones que describen la probabilidad de diferentes resultados:

• Distribución de Bernoulli: $P(X=1) = p, P(X=0) = 1-p$ (resultados binarios)
• Distribución gaussiana (normal): $f(x) = \frac{1}{\sigma\sqrt{2\pi}} e^{-\frac{(x-\mu)^2}{2\sigma^2}}$ (curva de campana)

Conceptos clave:

1. Valor esperado: $\mathbb{E}[X] = \sum_x x \cdot P(X=x)$ (el valor promedio)
2. Varianza: $\text{Var}(X) = \mathbb{E}[(X-\mathbb{E}[X])^2]$ (dispersión de la distribución)
3. Independencia: Dos eventos son independientes si $P(A \cap B) = P(A)P(B)$

Por qué importa: Muchas salidas de redes neuronales son probabilísticas (por ejemplo, probabilidades de clasificación). También usamos la probabilidad para medir la incertidumbre, regularizar modelos y generar salidas diversas.

Derivadas y Gradientes

Para entrenar redes neuronales, necesitamos optimizar funciones. Las derivadas nos dicen cómo cambian las funciones.

Derivada: La tasa de cambio de una función en un punto: $f'(x) = \lim_{h \to 0} \frac{f(x+h) - f(x)}{h}$

Para una función $f(x) = x^2$, la derivada es $f'(x) = 2x$. Esto nos dice que en $x=3$, la función está aumentando a una tasa de 6.

Gradiente: La generalización de las derivadas a funciones multivariables. Para $f: \mathbb{R}^n \to \mathbb{R}$, el gradiente es:

$\nabla f(\mathbf{x}) = \left[\frac{\partial f}{\partial x_1}, \frac{\partial f}{\partial x_2}, \dots, \frac{\partial f}{\partial x_n}\right]$

El gradiente apunta en la dirección de mayor ascenso—esto es crucial para la optimización.

Ejemplo: Para $f(x, y) = x^2 + y^2$, $\nabla f = [2x, 2y]$. En el punto $(1, 2)$, el gradiente es $[2, 4]$, apuntando en la dirección de mayor aumento.

Regla de la cadena: Cuando las funciones están compuestas, podemos calcular derivadas usando:

$\frac{d}{dx} f(g(x)) = f'(g(x)) \cdot g'(x)$

Esta regla es la columna vertebral matemática de la retropropagación, que cubriremos en la Fase 3.

Por qué importa: Las redes neuronales aprenden ajustando parámetros para minimizar una función de pérdida. El gradiente nos dice en qué dirección ajustar cada parámetro para reducir la pérdida.

Funciones de Pérdida Comunes

Error cuadrático medio (MSE - Mean Squared Error): Para problemas de regresión

$\mathcal{L}_{\text{MSE}} = \frac{1}{n} \sum_{i=1}^n (y_i - \hat{y}_i)^2$

Donde $y_i$ es el valor verdadero y $\hat{y}_i$ es el valor predicho. La diferencia se eleva al cuadrado para penalizar más fuertemente los errores grandes.

Pérdida de entropía cruzada (CE - Cross-Entropy): Para problemas de clasificación

$\mathcal{L}_{\text{CE}} = -\sum_{i=1}^C y_i \log(\hat{y}_i)$

Donde $C$ es el número de clases, $y_i$ es la etiqueta verdadera (codificada en one-hot) y $\hat{y}_i$ es la probabilidad predicha. Esta pérdida penaliza fuertemente las predicciones incorrectas con confianza.

Ejemplo: Si estamos clasificando imágenes como “gato”, “perro” o “pájaro”, y la etiqueta verdadera es “gato” ($y = [1, 0, 0]$), una predicción de $\hat{y} = [0.9, 0.05, 0.05]$ tendría una pérdida baja, mientras que $\hat{y} = [0.1, 0.8, 0.1]$ tendría una pérdida alta.

Por qué importa: La función de pérdida es nuestro objetivo. Todo en el entrenamiento se trata de minimizar esta función. Una buena función de pérdida refleja con precisión lo que nos importa en el mundo real.

Intuición

Imagina que estás en una montaña en niebla espesa. Quieres llegar al punto más bajo (el valle), pero no puedes ver el terreno. ¿Qué haces?

1. Siente el suelo a tu alrededor para determinar en qué dirección la pendiente desciende
2. Da un paso en esa dirección
3. Repite hasta llegar al fondo

Esto es el descenso de gradiente: el paisaje de pérdida es nuestra montaña, el gradiente apunta cuesta abajo, y cada paso es una actualización de parámetros.

El Algoritmo

Para un vector de parámetros $\boldsymbol{\theta}$ (todos los pesos y sesgos en la red):

1. Calcular gradiente:

$\nabla_{\boldsymbol{\theta}} \mathcal{L}(\boldsymbol{\theta})$

2. Actualizar parámetros:

$\boldsymbol{\theta}_{\text{nuevo}} = \boldsymbol{\theta} - \eta \cdot \nabla_{\boldsymbol{\theta}} \mathcal{L}(\boldsymbol{\theta})$

3. Repetir hasta la convergencia

La tasa de aprendizaje $\eta$ (eta) controla el tamaño del paso:

• Muy pequeña: El aprendizaje es muy lento
• Muy grande: Podríamos pasar por alto o divergir

Ejemplo: Caso Unidimensional

Sea $L(\theta) = (\theta - 3)^2$. Queremos encontrar $\theta$ que minimice esto.

El gradiente es: $\frac{dL}{d\theta} = 2(\theta - 3)$

Comenzando en $\theta = 0$ con tasa de aprendizaje $\eta = 0.1$:

• Paso 1: Gradiente $= 2(0 - 3) = -6$, actualización: $\theta_{\text{nuevo}} = 0 - 0.1(-6) = 0.6$
• Paso 2: Gradiente $= 2(0.6 - 3) = -4.8$, actualización: $\theta_{\text{nuevo}} = 0.6 - 0.1(-4.8) = 1.08$
• Paso 3: Gradiente $= 2(1.08 - 3) = -3.84$, actualización: $\theta_{\text{nuevo}} = 1.08 - 0.1(-3.84) = 1.468$

¡Nos estamos moviendo hacia $\theta = 3$, el verdadero mínimo!

Descenso de Gradiente Estocástico (SGD)

En la práctica, usamos descenso de gradiente estocástico (Stochastic Gradient Descent, SGD): en lugar de calcular el gradiente sobre todos los datos de entrenamiento, usamos un pequeño lote (mini-batch).

$\nabla_{\boldsymbol{\theta}} \mathcal{L}(\boldsymbol{\theta}) \approx \frac{1}{|B|} \sum_{i \in B} \nabla_{\boldsymbol{\theta}} \mathcal{L}_i(\boldsymbol{\theta})$

Donde $B$ es un lote aleatorio de ejemplos de entrenamiento.

¿Por qué SGD?

• Computacionalmente eficiente (no se necesitan todos los datos para cada actualización)
• Las actualizaciones con ruido ayudan a escapar de mínimos locales
• Funciona mejor con conjuntos de datos grandes

Optimizadores Avanzados

El entrenamiento moderno rara vez usa SGD puro. Las variantes populares incluyen:

• Momentum: Acumula gradientes pasados para acelerarse a través de regiones planas
• Adam: Combina momentum con tasas de aprendizaje adaptativas
• RMSprop: Adapta tasas de aprendizaje por parámetro

Estos se construyen sobre el mismo principio de descenso de gradiente pero usan el gradiente de manera más inteligente.

Los Gradientes Guían el Aprendizaje

Cada componente de gradiente $\frac{\partial \mathcal{L}}{\partial \theta_i}$ nos dice:

• Cuánto cambiaría la pérdida si aumentáramos $\theta_i$ por una pequeña cantidad
• En qué dirección mover $\theta_i$ para reducir la pérdida

Un gradiente positivo grande significa “disminuir este parámetro para reducir la pérdida”, mientras que un gradiente negativo grande significa “aumentar este parámetro para reducir la pérdida”.

Gradientes Desvanecientes y Explotantes

Dos problemas comunes en redes profundas:

Gradientes desvanecientes: En redes muy profundas, los gradientes pueden volverse extremadamente pequeños, haciendo que las primeras capas aprendan muy lentamente. Este fue un gran desafío en las primeras redes neuronales.

Gradientes explotantes: Los gradientes pueden volverse extremadamente grandes, causando que los parámetros cambien drásticamente y que el entrenamiento se vuelva inestable.

Las soluciones incluyen:

• Inicialización cuidadosa (por ejemplo, inicialización de Xavier, He)
• Funciones de activación con gradientes bien comportados (las veremos en la Fase 3)
• Recorte de gradientes (gradient clipping)
• Conexiones residuales (conexiones de omisión)

Flujo de Gradiente a Través de la Red

En una red profunda, los gradientes fluyen hacia atrás desde la salida hasta la entrada:

1
Entrada → [Capa 1] → [Capa 2] → ... → [Salida]
2
               ↑           ↑           ↑
3
            Gradiente   Gradiente   Gradiente (comienza aquí)

Si los gradientes se desvanecen temprano, las primeras capas (que a menudo aprenden características fundamentales) no reciben señales de entrenamiento útiles. Si los gradientes explotan, el entrenamiento se vuelve inestable.

Por qué importa: Entender el flujo de gradientes nos ayuda a diseñar mejores arquitecturas. Los avances modernos como las redes residuales fueron motivados específicamente para mejorar el flujo de gradientes.

Estructura

Un perceptrón toma $n$ entradas y produce una salida:

1
Entradas: x₁, x₂, ..., xₙ
2
        ↓   ↓       ↓
3
Pesos: w₁, w₂, ..., wₙ
4
        ↓   ↓       ↓
5
        Suma: z = w₁x₁ + w₂x₂ + ... + wₙxₙ + b
6
                               ↓
7
                          Activación: a = σ(z)
8
                               ↓
9
                            Salida: y = a

Matemáticamente:

$z = \sum_{i=1}^n w_i x_i + b = \mathbf{w} \cdot \mathbf{x} + b$

$y = \sigma(z)$

Donde:

• $\mathbf{w}$ es el vector de pesos
• $b$ es el sesgo (bias, permite desplazar la función de activación)
• $\sigma$ es una función de activación
• $z$ se llama “pre-activación”

Intuición Geométrica

El cálculo $z = \mathbf{w} \cdot \mathbf{x} + b$ es un hiperplano en $\mathbb{R}^n$. El perceptrón decide en qué lado de este hiperplano cae la entrada.

Para entradas 2D $(x_1, x_2)$:

• El límite de decisión es la línea $w_1 x_1 + w_2 x_2 + b = 0$
• Los puntos por encima de la línea tienen $z > 0$, por debajo tienen $z < 0$

Limitaciones de los Perceptrones Individuales

Un solo perceptrón solo puede aprender funciones linealmente separables. No puede resolver el problema XOR, que requiere un límite de decisión no lineal.

Solución: Apilar múltiples perceptrones para crear un perceptrón multicapa (MLP - Multi-Layer Perceptron).

Arquitectura

1
Capa de Entrada    Capa Oculta 1    Capa Oculta 2    Capa de Salida
2
  [x₁] ──────►    [h₁₁] ──────►    [h₂₁] ──────►    [y₁]
3
  [x₂] ──────►    [h₁₂] ──────►    [h₂₂] ──────►    [y₂]
4
  [x₃] ──────►    [h₁₃] ──────►    [h₂₃] ──────►    [y₃]
5
                  ...                 ...

Cada capa transforma la representación: $\mathbf{h}^{(l)} = \sigma(\mathbf{W}^{(l)} \mathbf{h}^{(l-1)} + \mathbf{b}^{(l)})$

Donde $\mathbf{h}^{(0)} = \mathbf{x}$ (entrada) y $\mathbf{h}^{(L)} = \mathbf{y}$ (salida).

¿Por qué múltiples capas?: Cada capa aprende características cada vez más abstractas. En el reconocimiento de imágenes, las primeras capas podrían detectar bordes, las capas medias detectan formas, y las capas posteriores detectan objetos.

Teorema de Aproximación Universal

Un resultado teórico notable: Una red de avance con una sola capa oculta y activación no lineal puede aproximar cualquier función continua con precisión arbitraria (dadas suficientes neuronas).

Esto significa que las redes neuronales son aproximadores de funciones increíblemente flexibles—pueden aprender prácticamente cualquier mapeo de entradas a salidas dada suficiente capacidad.

Sigmoide

$\sigma(z) = \frac{1}{1 + e^{-z}}$

Propiedades:

• Salida en $(0, 1)$ (interpretable como probabilidad)
• Gradiente suave: $\sigma'(z) = \sigma(z)(1 - \sigma(z))$
• Históricamente popular pero sufre de gradientes desvanecientes

Caso de uso: Salida de clasificación binaria

ReLU (Unidad Lineal Rectificada)

$\text{ReLU}(z) = \max(0, z)$

Propiedades:

• Simple: $f(z) = 0$ si $z < 0$, si no $f(z) = z$
• Activación dispersa (muchas neuronas producen cero)
• Evita el gradiente desvaneciente (el gradiente es 1 para entradas positivas)
• Computacionalmente eficiente

Caso de uso: Capas ocultas en la mayoría de las redes modernas

Por qué ReLU Ganó

La simplicidad de ReLU y la falta de problemas de gradiente desvaneciente la convirtieron en la opción predeterminada para capas ocultas. Variantes como Leaky ReLU y ELU abordan el problema de “ReLU muerto” (neuronas que nunca se activan).

La Regla de la Cadena en Acción

Para una red simple con una capa oculta:

$\mathcal{L} = \mathcal{L}(y, \hat{y}) = \mathcal{L}(y, \sigma(\mathbf{W}^{(2)} \sigma(\mathbf{W}^{(1)} \mathbf{x} + \mathbf{b}^{(1)}) + \mathbf{b}^{(2)}))$

Para encontrar $\frac{\partial \mathcal{L}}{\partial \mathbf{W}^{(1)}}$, encadenamos a través del cálculo:

$\frac{\partial \mathcal{L}}{\partial \mathbf{W}^{(1)}} = \underbrace{\frac{\partial \mathcal{L}}{\partial \hat{y}}}_{\text{Capa de salida}} \cdot \underbrace{\frac{\partial \hat{y}}{\partial \mathbf{z}^{(2)}}}_{\text{Activación de salida}} \cdot \underbrace{\frac{\partial \mathbf{z}^{(2)}}{\partial \mathbf{h}^{(1)}}}_{\text{Oculta a salida}} \cdot \underbrace{\frac{\partial \mathbf{h}^{(1)}}{\partial \mathbf{z}^{(1)}}}_{\text{Activación oculta}} \cdot \underbrace{\frac{\partial \mathbf{z}^{(1)}}{\partial \mathbf{W}^{(1)}}}_{\text{Entrada a oculta}}$

Algoritmo Simplificado de Retropropagación

1. Paso hacia adelante: Almacenar todos los valores intermedios ($\mathbf{z}^{(l)}$, $\mathbf{h}^{(l)}$)
2. Gradiente de salida: Calcular $\delta^{(L)} = \frac{\partial \mathcal{L}}{\partial \mathbf{z}^{(L)}}$
3. Paso hacia atrás: Para cada capa $l = L-1$ a $1$: $\delta^{(l)} = \frac{\partial \mathcal{L}}{\partial \mathbf{z}^{(l)}} = \frac{\partial \mathcal{L}}{\partial \mathbf{z}^{(l+1)}} \cdot \frac{\partial \mathbf{z}^{(l+1)}}{\partial \mathbf{h}^{(l)}} \cdot \frac{\partial \mathbf{h}^{(l)}}{\partial \mathbf{z}^{(l)}}$
4. Gradientes de parámetros: $\frac{\partial \mathcal{L}}{\partial \mathbf{W}^{(l)}} = \delta^{(l)} (\mathbf{h}^{(l-1)})^T$ $\frac{\partial \mathcal{L}}{\partial \mathbf{b}^{(l)}} = \delta^{(l)}$

Eficiencia Computacional

La clave de la retropropagación es que calculamos gradientes en tiempo $O(N)$ donde $N$ es el número de parámetros, en lugar de $O(N^2)$ para la diferenciación numérica ingenua. Esto hace factible el entrenamiento de redes grandes.

Ejemplo: Calculando un Gradiente

Para una sola neurona con entrada $x$, peso $w$, sesgo $b$, activación sigmoide y pérdida MSE:

1. Hacia adelante: $z = wx + b$, $a = \sigma(z)$, $\mathcal{L} = \frac{1}{2}(a - y)^2$
2. Hacia atrás: $\frac{\partial \mathcal{L}}{\partial a} = a - y$ $\frac{\partial a}{\partial z} = a(1 - a)$ $\frac{\partial z}{\partial w} = x$ $\frac{\partial \mathcal{L}}{\partial w} = \frac{\partial \mathcal{L}}{\partial a} \cdot \frac{\partial a}{\partial z} \cdot \frac{\partial z}{\partial w} = (a - y) \cdot a(1 - a) \cdot x$

Esto nos dice exactamente cómo ajustar $w$ para reducir la pérdida.

De One-Hot a Vectores Densos

Codificación one-hot: Representar cada palabra como un vector disperso donde solo una posición es 1.

1
"gato"   = [1, 0, 0, 0, ...]
2
"perro"  = [0, 1, 0, 0, ...]
3
"pájaro" = [0, 0, 1, 0, ...]

Problemas: Alta dimensionalidad, noción de similitud, ninguna relación entre palabras.

Word embeddings: Aprender vectores densos de baja dimensionalidad donde la similitud semántica corresponde a similitud geométrica.

1
"gato"   ≈ [0.2, -0.5, 0.8, 0.1, ...]
2
"perro"  ≈ [0.3, -0.4, 0.7, 0.2, ...]
3
"pájaro" ≈ [0.9, 0.3, -0.2, 0.5, ...]

Ahora “gato” y “perro” tienen vectores similares (están semánticamente relacionados), mientras que “pájaro” es diferente.

Por Qué Funcionan los Embeddings

Las palabras que aparecen en contextos similares deberían tener significados similares. Al aprender a predecir palabras del contexto (o viceversa), capturamos automáticamente relaciones semánticas.

Propiedad famosa: La aritmética vectorial captura relaciones:

1
rey - hombre + mujer ≈ reina

¡La dirección de “hombre” a “mujer” es similar a la dirección de “rey” a “reina”!

Entrenando Embeddings

Word2Vec: Dos enfoques:

1. Skip-gram: Predecir palabras de contexto de la palabra objetivo
2. CBOW: Predecir palabra objetivo del contexto

GloVe: Factorizar matriz de co-ocurrencia de palabras

Enfoque moderno: Aprender embeddings como parte del entrenamiento del modelo en lugar de pre-entrenar por separado.

Más Allá de las Palabras

Los embeddings se extienden más allá de las palabras:

• Embeddings de caracteres: Para información de subpalabras
• Embeddings posicionales: Para el orden de secuencias
• Embeddings de oraciones: Para documentos completos
• Embeddings multimodales: Para imágenes, audio, etc.

El Problema de las Representaciones Fijas

Antes de la atención, los modelos de secuencia (como las RNNs) comprimían una secuencia de entrada completa en un solo vector de tamaño fijo:

1
Entrada: "The cat sat on the mat"
2
↓ (codificar oración completa)
3
Vector fijo: [0.1, -0.3, 0.7, ...]
4
↓ (decodificar)
5
Salida: "El gato se sentó en la alfombra"

Problema: Toda la información debe comprimirse en un vector, lo que se convierte en un cuello de botella para secuencias largas.

La Solución de Atención

En lugar de usar un vector fijo, permitir que cada paso de salida mire diferentes partes de la entrada, ponderado por relevancia.

1
Al generar "El"   → Enfocarse en "The"
2
Al generar "gato" → Enfocarse en "cat"
3
Al generar "se"   → Enfocarse en "sat"

Matemáticamente, para la posición de salida $i$, calculamos una suma ponderada de representaciones de entrada:

$\mathbf{c}_i = \sum_{j} \alpha_{ij} \mathbf{h}_j$

Donde $\alpha_{ij}$ es el peso de atención de la posición de salida $i$ a la posición de entrada $j$.

Calculando Pesos de Atención

¿Cómo calculamos $\alpha_{ij}$? Usamos una función de compatibilidad que mide qué tan bien la posición de entrada $j$ se relaciona con la posición de salida $i$.

Atención de producto punto:

$e_{ij} = \mathbf{q}_i \cdot \mathbf{k}_j$

$\alpha_{ij} = \frac{\exp(e_{ij})}{\sum_k \exp(e_{ik})}$

Donde:

• $\mathbf{q}_i$ es el vector de query (lo que estamos buscando)
• $\mathbf{k}_j$ es el vector de key (lo que la entrada ofrece)
• $\mathbf{h}_j$ es el vector de value (el contenido real)

El softmax asegura que los pesos sumen 1 (distribución de probabilidad).

Intuición: Analogía de Base de Datos

Piénsalo como una consulta de base de datos:

• Query (Q): Lo que estás buscando
• Key (K): Cómo están indexados los elementos
• Value (V): El contenido real

1
Base de datos:
2
  Key: "nombre", Value: "Ana"
3
  Key: "edad", Value: 30
4
  Key: "ciudad", Value: "CDMX"
5

6
Query: "nombre"
7
→ Coincidencia: Key "nombre" coincide con Query "nombre"
8
→ Retornar: Value "Ana"

En Redes Neuronales

Cada posición de entrada tiene su propia K y V. Cada posición de salida tiene su propia Q. Calculamos la similitud entre Q y todas las K, luego ponderamos las V por estas similitudes.

Q, K, V en Código

1
def scaled_dot_product_attention(Q, K, V):
2
    """
3
    Args:
4
        Q: (batch_size, seq_len, d_k)
5
        K: (batch_size, seq_len, d_k)
6
        V: (batch_size, seq_len, d_v)
7
    Returns:
8
        output: (batch_size, seq_len, d_v)
9
        attention_weights: (batch_size, seq_len, seq_len)
10
    """
11
    # Calcular puntuaciones de similitud
12
    scores = Q @ K.transpose(-2, -1)  # (batch_size, seq_len, seq_len)
13

14
    # Escalar para prevenir valores de softmax extremadamente grandes
15
    scores = scores / np.sqrt(K.shape[-1])
16

17
    # Aplicar softmax para obtener pesos de atención
18
    attention_weights = softmax(scores, axis=-1)
19

20
    # Ponderar valores por pesos de atención
21
    output = attention_weights @ V
22

23
    return output, attention_weights

Pasos clave:

1. Calcular Q·K para obtener puntuaciones de similitud
2. Escalar por $\sqrt{d_k}$ (estabiliza gradientes)
3. Aplicar softmax para obtener distribución de probabilidad
4. Suma ponderada de V

Atención Multi-Cabezal

En lugar de un conjunto de Q, K, V, usamos múltiples “cabezas” que aprenden diferentes relaciones:

1
class MultiHeadAttention:
2
    def __init__(self, d_model, num_heads):
3
        self.d_model = d_model
4
        self.num_heads = num_heads
5
        self.d_k = d_model // num_heads
6

7
        # Matrices de proyección aprendibles
8
        self.W_Q = initialize_weights((d_model, d_model))
9
        self.W_K = initialize_weights((d_model, d_model))
10
        self.W_V = initialize_weights((d_model, d_model))
11
        self.W_O = initialize_weights((d_model, d_model))
12

13
    def forward(self, x):
14
        batch_size, seq_len, _ = x.shape
15

16
        # Proyectar a Q, K, V para cada cabeza
17
        Q = x @ self.W_Q  # (batch, seq_len, d_model)
18
        K = x @ self.W_K
19
        V = x @ self.W_V
20

21
        # Dividir en cabezas y remodelar
22
        Q = Q.reshape(batch_size, seq_len, self.num_heads, self.d_k)
23
        K = K.reshape(batch_size, seq_len, self.num_heads, self.d_k)
24
        V = V.reshape(batch_size, seq_len, self.num_heads, self.d_k)
25

26
        # Transponer a (batch, num_heads, seq_len, d_k)
27
        Q = Q.transpose(1, 2)
28
        K = K.transpose(1, 2)
29
        V = V.transpose(1, 2)
30

31
        # Calcular atención para cada cabeza
32
        scores = Q @ K.transpose(-2, -1) / np.sqrt(self.d_k)
33
        attention_weights = softmax(scores, axis=-1)
34
        attended = attention_weights @ V
35

36
        # Concatenar cabezas y proyectar
37
        attended = attended.transpose(1, 2).reshape(batch_size, seq_len, self.d_model)
38
        output = attended @ self.W_O
39

40
        return output, attention_weights

Cada cabeza puede enfocarse en diferentes tipos de relaciones:

• La cabeza 1 podría enfocarse en la estructura sintáctica
• La cabeza 2 podría enfocarse en la similitud semántica
• La cabeza 3 podría enfocarse en las relaciones posicionales

Innovaciones Clave

1. Auto-atención: En lugar de atención entre codificador y decodificador, cada posición atiende a todas las demás posiciones en la misma secuencia.

1
Para cada palabra "gato", calcular pesos de atención con todas las palabras:
2
"gato" atiende a: "The"(0.1), "gato"(0.6), "sat"(0.2), "on"(0.05), "the"(0.03), "mat"(0.02)

2. Codificación posicional: Dado que la atención no captura inherentemente el orden, agregamos información de posición:

$PE_{(pos, 2i)} = \sin(pos / 10000^{2i/d_{model}})$

$PE_{(pos, 2i+1)} = \cos(pos / 10000^{2i/d_{model}})$

Estas codificaciones sinusoidales permiten al modelo aprender posiciones relativas.

3. Paralelización: A diferencia de las RNNs que procesan secuencialmente, los transformers procesan todas las posiciones simultáneamente, permitiendo una paralelización masiva en GPUs.

Arquitectura del Transformer

1
Embedding de Entrada + Codificación Posicional
2
            ↓
3
     ┌─────────────────┐
4
     │  Pila de Codificador  │
5
     │  (N veces)      │
6
     │                 │
7
     │  ┌───────────┐  │
8
     │  │ Multi-Head│  │
9
     │  │ Attention │  │
10
     │  └───────────┘  │
11
     │        ↓         │
12
     │  ┌───────────┐  │
13
     │  │ Feed-     │  │
14
     │  │ Forward   │  │
15
     │  └───────────┘  │
16
     └─────────────────┘
17
            ↓
18
     ┌─────────────────┐
19
     │  Pila de Decodificador  │
20
     │  (N veces)      │
21
     │                 │
22
     │  ┌───────────┐  │
23
     │  │ Masked    │  │
24
     │  │ Multi-Head│  │
25
     │  │ Attention │  │
26
     │  └───────────┘  │
27
     │        ↓         │
28
     │  ┌───────────┐  │
29
     │  │ Cross     │  │
30
     │  │ Attention│  │
31
     │  └───────────┘  │
32
     │        ↓         │
33
     │  ┌───────────┐  │
34
     │  │ Feed-     │  │
35
     │  │ Forward   │  │
36
     │  └───────────┘  │
37
     └─────────────────┘
38
            ↓
39
         Salida

Codificador: Procesa la secuencia de entrada y produce representaciones contextuales

Decodificador: Genera la secuencia de salida, atendiendo tanto a la salida del codificador como a los tokens generados previamente

Atención enmascarada: Evita que el decodificador “vea el futuro” durante el entrenamiento (autoregresivo)

Por Qué Funcionan Tan Bien los Transformers

1. Dependencias de largo alcance: La atención conecta directamente cualquier dos posiciones, sin importar qué tan lejos estén
2. Paralelización: Procesar secuencias completas a la vez, permitiendo entrenamiento en conjuntos de datos masivos
3. Interpretabilidad: Los pesos de atención muestran en qué se enfoca el modelo
4. Escalabilidad: El rendimiento continúa mejorando con más datos y cómputo

De Transformers a LLMs

Los modelos de lenguaje grandes modernos son esencialmente:

• Transformers solo-decodificador (para generación de texto autoregresiva)
• Entrenados en conjuntos de datos de texto masivos
• Escalados con más parámetros, más datos y más cómputo

La arquitectura que hemos discutido es esencialmente la misma que GPT, BERT y LLaMA—solo escalada.