Transformers

¿Qué es un Transformer?

Un Transformer es una arquitectura de red neuronal basada enteramente en mecanismos de atención, sin recurrencia ni convoluciones. Fue propuesta en 2017 por Vaswani et al. en el paper "Attention Is All You Need" y ha revolucionado prácticamente todos los campos del deep learning: procesamiento de lenguaje natural, visión por computador, generación de audio, series temporales, y más.

Pero para entender por qué el Transformer fue tan revolucionario, necesitamos entender lo que había antes: las RNNs, sus limitaciones, y cómo surgió la idea de la atención.

El camino hacia la atención: de las RNNs al Transformer

La historia del Transformer es la historia de cómo el deep learning aprendió a prestar atención. Antes de 2017, el paradigma dominante para procesar secuencias (texto, audio, series temporales) eran las Redes Neuronales Recurrentes (RNNs).

El problema de las RNNs

Las RNNs procesan la secuencia paso a paso, manteniendo un estado oculto \(h_t\) que se actualiza en cada timestep. Esto tiene dos problemas fundamentales:

Las LSTMs y GRUs mitigaron parcialmente el problema de vanishing gradients con gates, pero el cuello de botella y la falta de paralelismo seguían siendo fundamentales.

El nacimiento de la atención (Bahdanau, 2014)

La idea que cambió todo fue simple pero brillante: en lugar de comprimir toda la secuencia en un único vector, permitir que el decoder mire directamente a cada posición del encoder en cada paso de generación.

Bahdanau, Cho & Bengio (2014) propusieron un mecanismo de atención aditiva para modelos seq2seq de traducción automática. En cada paso del decoder \(t\), se calcula un score de atención \(e_{t,i}\) entre el estado del decoder \(s_t\) y cada estado del encoder \(h_i\):

Los pesos \(\alpha_{t,i}\) indican cuánta atención presta el decoder al token \(i\) cuando genera el token \(t\). El vector de contexto \(c_t\) es ahora diferente en cada paso: ya no hay cuello de botella.

Este paper fue un punto de inflexión. De repente, los modelos de traducción mejoraron drásticamente, y la idea de «atención» se convirtió en una herramienta fundamental en el toolkit del deep learning.

Atención multiplicativa (Luong, 2015)

Poco después, Luong et al. (2015) propusieron una variante más simple y eficiente: la atención multiplicativa (dot-product attention), que calcula la similitud directamente con un producto escalar:

La atención multiplicativa de Luong tiene la misma capacidad que la aditiva de Bahdanau, pero es más eficiente computacionalmente. La scaled dot-product attention del Transformer es una evolución directa de esta idea.

Self-Attention: el salto conceptual

Hasta 2016, la atención siempre era cross-attention: el decoder mira al encoder. Pero la pregunta clave que llevó al Transformer fue:

Esta idea — la self-attention o autoatención — fue la revolución. En lugar de procesar la secuencia paso a paso (RNN) o con filtros locales (CNN), cada token computa una representación que depende de toda la secuencia, ponderada por relevancia.

El paper "Attention Is All You Need" demostró que con self-attention apilada en varias capas, más normalización y conexiones residuales, se podía superar a las RNNs en traducción automática, y entrenar órdenes de magnitud más rápido gracias a la paralelización.

Historia del Transformer

El paper: "Attention Is All You Need"

El paper de Vaswani et al. (2017) es uno de los más citados en la historia de la IA (>130.000 citas). Propone una arquitectura radicalmente simple que prescinde de toda recurrencia y convolución:

Visión general de la arquitectura

El Transformer original es un modelo encoder-decoder. El encoder procesa la secuencia de entrada completa y genera representaciones contextuales. El decoder genera la secuencia de salida token a token, usando tanto su propia secuencia parcial (self-attention con máscara) como la salida del encoder (cross-attention).

Input Embeddings

El primer paso es convertir cada token (palabra, subpalabra, o carácter) en un vector denso de dimensión \(d_{\text{model}}\). Esto se hace con una capa de embedding aprendida:

En el paper original, \(d_{\text{model}} = 512\). Los embeddings se multiplican por \(\sqrt{d_{\text{model}}}\) para escalar su magnitud relativa al positional encoding:

Positional Encoding: ¿dónde está cada token?

Como el Transformer procesa toda la secuencia en paralelo (sin recurrencia), no tiene noción inherente de orden. Para que sepa que «El gato» es diferente de «gato El», se añade un positional encoding a cada embedding.

El paper original usa funciones sinusoidales con frecuencias diferentes para cada dimensión:

donde \(pos\) es la posición del token en la secuencia e \(i\) es la dimensión. Las dimensiones bajas varían rápidamente (alta frecuencia), las altas varían lentamente (baja frecuencia), creando un patrón único para cada posición.

El Encoder: apilar autoatención

El encoder consiste en \(N\) capas idénticas apiladas (N=6 en el original). Cada capa tiene exactamente dos subcapas:

Cada subcapa tiene una conexión residual y layer normalization:

El Decoder: generar token a token

El decoder también tiene \(N\) capas, pero cada capa tiene tres subcapas:

Capa de salida: Linear + Softmax

La salida del decoder pasa por una capa lineal que proyecta de \(d_{\text{model}}\) al tamaño del vocabulario \(V\), seguida de un softmax para obtener probabilidades:

Hiperparámetros del Transformer original

Comparado con los modelos actuales (GPT-4 tiene ~1.7T parámetros estimados, LLaMA 3 tiene hasta 405B), el Transformer original era sorprendentemente pequeño. La arquitectura ha escalado verticalmente, pero los principios fundamentales son exactamente los mismos.

Widget: explorador de Positional Encoding

Visualiza cómo varían las funciones sinusoidales del positional encoding según la posición y la dimensión. Observa cómo las frecuencias bajas (dimensiones altas) varían lentamente, creando patrones únicos para cada posición.

Scaled Dot-Product Attention

El bloque fundamental del Transformer es la Scaled Dot-Product Attention. Cada token genera tres vectores: una query (\(Q\)), una key (\(K\)) y un value (\(V\)), obtenidos multiplicando la entrada por matrices de pesos aprendidas:

La atención se calcula como:

¿Por qué dividir entre \(\sqrt{d_k}\)?

Cuando \(d_k\) es grande, los dot products \(q \cdot k\) crecen en magnitud, lo que empuja al softmax a regiones de gradientes muy pequeños (saturación). Dividir entre \(\sqrt{d_k}\) normaliza la varianza de los scores a 1, manteniendo los gradientes saludables:

Multi-Head Attention

En lugar de calcular una única función de atención, el Transformer usa múltiples cabezas (heads) que operan en paralelo. Cada head aprende a prestar atención a un tipo diferente de relación:

Con \(h = 8\) cabezas y \(d_{\text{model}} = 512\), cada head trabaja con vectores de dimensión \(d_k = d_v = 512 / 8 = 64\). Los resultados de las 8 heads se concatenan y se proyectan con \(W^O \in \mathbb{R}^{hd_v \times d_{\text{model}}}\).

Self-Attention: paso a paso con ejemplo

Veamos el cálculo completo de self-attention para la frase «El gato duerme» con \(d_k = 4\) (simplificado para visualización):

Cross-Attention: el puente encoder-decoder

En el decoder, además de la self-attention (masked), hay una capa de cross-attention donde:

• Queries (\(Q\)) vienen de la capa anterior del decoder.
• Keys (\(K\)) y Values (\(V\)) vienen de la salida del encoder.

Esto permite al decoder consultar la secuencia de entrada completa en cada paso de generación. Es el equivalente moderno del mecanismo de atención de Bahdanau, pero integrado en la arquitectura del Transformer sin RNNs.

Masked Self-Attention: no mirar al futuro

En el decoder, la self-attention debe ser causal: el token en la posición \(t\) solo puede atender a las posiciones \(1, 2, \ldots, t\). Esto se implementa sumando una máscara al score antes del softmax:

donde \(M_{ij} = 0\) si \(j \leq i\), y \(M_{ij} = -\infty\) si \(j > i\). Tras el softmax, \(e^{-\infty} = 0\), así que los tokens futuros tienen peso cero.

Complejidad computacional

La self-attention tiene complejidad \(O(n^2 \cdot d)\) donde \(n\) es la longitud de la secuencia y \(d\) es la dimensión. Esto es cuadrático en la longitud, lo que se vuelve problemático para secuencias muy largas.

Widget: explorador de Self-Attention

Escribe una frase y visualiza cómo la self-attention asigna pesos entre tokens. Ajusta la temperatura (escala del softmax) para ver su efecto: valores bajos → atención más uniforme, valores altos → atención más concentrada.

Función de pérdida: Cross-Entropy

El Transformer para traducción/generación se entrena con cross-entropy loss sobre el vocabulario de salida. En cada posición del decoder, el modelo predice una distribución de probabilidad sobre \(V\) tokens y la comparamos con el token correcto:

Optimizador: Adam con warmup

El Transformer usa Adam con un esquema de learning rate especial que combina un warmup lineal con un decay proporcional a la raíz cuadrada inversa del paso:

Con \(\text{warmup\_steps} = 4000\), el learning rate crece linealmente durante los primeros 4000 pasos y luego decrece proporcionalmente a \(1/\sqrt{\text{step}}\).

Teacher Forcing

Durante el entrenamiento, el decoder recibe como entrada la secuencia objetivo desplazada una posición a la derecha (shifted right), en lugar de sus propias predicciones anteriores. Esto se llama teacher forcing:

Implementación: Transformer simplificado

Veamos una implementación limpia del Transformer en PyTorch y TensorFlow. Incluye self-attention, multi-head attention, positional encoding, y el encoder completo.

import torch
import torch.nn as nn
import torch.nn.functional as F
import math

# ─── Positional Encoding (sinusoidal) ───
class PositionalEncoding(nn.Module):
    def __init__(self, d_model, max_len=5000, dropout=0.1):
        super().__init__()
        self.dropout = nn.Dropout(p=dropout)

        pe = torch.zeros(max_len, d_model)
        position = torch.arange(0, max_len, dtype=torch.float).unsqueeze(1)
        div_term = torch.exp(
            torch.arange(0, d_model, 2).float() * (-math.log(10000.0) / d_model)
        )
        pe[:, 0::2] = torch.sin(position * div_term)   # dimensiones pares
        pe[:, 1::2] = torch.cos(position * div_term)    # dimensiones impares
        pe = pe.unsqueeze(0)  # (1, max_len, d_model)
        self.register_buffer('pe', pe)

    def forward(self, x):
        # x: (batch, seq_len, d_model)
        x = x + self.pe[:, :x.size(1)]
        return self.dropout(x)

# ─── Scaled Dot-Product Attention ───
def scaled_dot_product_attention(Q, K, V, mask=None):
    """
    Q, K, V: (batch, heads, seq_len, d_k)
    mask: (batch, 1, 1, seq_len) or (1, 1, seq_len, seq_len) for causal
    """
    d_k = Q.size(-1)
    scores = torch.matmul(Q, K.transpose(-2, -1)) / math.sqrt(d_k)

    if mask is not None:
        scores = scores.masked_fill(mask == 0, float('-inf'))

    attn_weights = F.softmax(scores, dim=-1)
    output = torch.matmul(attn_weights, V)
    return output, attn_weights

# ─── Multi-Head Attention ───
class MultiHeadAttention(nn.Module):
    def __init__(self, d_model, num_heads):
        super().__init__()
        assert d_model % num_heads == 0
        self.d_k = d_model // num_heads
        self.num_heads = num_heads

        self.W_q = nn.Linear(d_model, d_model)
        self.W_k = nn.Linear(d_model, d_model)
        self.W_v = nn.Linear(d_model, d_model)
        self.W_o = nn.Linear(d_model, d_model)

    def forward(self, Q, K, V, mask=None):
        batch_size = Q.size(0)

        # Linear projections + reshape to (batch, heads, seq, d_k)
        Q = self.W_q(Q).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        K = self.W_k(K).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)
        V = self.W_v(V).view(batch_size, -1, self.num_heads, self.d_k).transpose(1, 2)

        # Attention
        attn_output, attn_weights = scaled_dot_product_attention(Q, K, V, mask)

        # Concat heads + linear
        attn_output = attn_output.transpose(1, 2).contiguous().view(
            batch_size, -1, self.num_heads * self.d_k
        )
        return self.W_o(attn_output), attn_weights

# ─── Feed-Forward Network ───
class FeedForward(nn.Module):
    def __init__(self, d_model, d_ff, dropout=0.1):
        super().__init__()
        self.linear1 = nn.Linear(d_model, d_ff)
        self.linear2 = nn.Linear(d_ff, d_model)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x):
        return self.linear2(self.dropout(F.relu(self.linear1(x))))

# ─── Encoder Layer ───
class EncoderLayer(nn.Module):
    def __init__(self, d_model, num_heads, d_ff, dropout=0.1):
        super().__init__()
        self.self_attn = MultiHeadAttention(d_model, num_heads)
        self.ffn = FeedForward(d_model, d_ff, dropout)
        self.norm1 = nn.LayerNorm(d_model)
        self.norm2 = nn.LayerNorm(d_model)
        self.dropout1 = nn.Dropout(dropout)
        self.dropout2 = nn.Dropout(dropout)

    def forward(self, x, mask=None):
        # Self-attention + residual + norm
        attn_out, _ = self.self_attn(x, x, x, mask)
        x = self.norm1(x + self.dropout1(attn_out))
        # FFN + residual + norm
        ffn_out = self.ffn(x)
        x = self.norm2(x + self.dropout2(ffn_out))
        return x

# ─── Encoder completo ───
class TransformerEncoder(nn.Module):
    def __init__(self, vocab_size, d_model=512, num_heads=8,
                 d_ff=2048, num_layers=6, dropout=0.1, max_len=5000):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, d_model)
        self.pos_encoding = PositionalEncoding(d_model, max_len, dropout)
        self.layers = nn.ModuleList([
            EncoderLayer(d_model, num_heads, d_ff, dropout)
            for _ in range(num_layers)
        ])
        self.d_model = d_model

    def forward(self, x, mask=None):
        # x: (batch, seq_len) of token ids
        x = self.embedding(x) * math.sqrt(self.d_model)
        x = self.pos_encoding(x)
        for layer in self.layers:
            x = layer(x, mask)
        return x

# ─── Uso ───
encoder = TransformerEncoder(vocab_size=32000)
tokens = torch.randint(0, 32000, (2, 50))  # batch=2, seq=50
output = encoder(tokens)
print(output.shape)  # torch.Size([2, 50, 512])

import tensorflow as tf
import numpy as np

# ─── Positional Encoding ───
def positional_encoding(max_len, d_model):
    positions = np.arange(max_len)[:, np.newaxis]
    dims = np.arange(d_model)[np.newaxis, :]
    angles = positions / np.power(10000, (2 * (dims // 2)) / d_model)
    angles[:, 0::2] = np.sin(angles[:, 0::2])
    angles[:, 1::2] = np.cos(angles[:, 1::2])
    return tf.cast(angles[np.newaxis, :, :], dtype=tf.float32)

# ─── Scaled Dot-Product Attention ───
def scaled_dot_product_attention(Q, K, V, mask=None):
    d_k = tf.cast(tf.shape(K)[-1], tf.float32)
    scores = tf.matmul(Q, K, transpose_b=True) / tf.math.sqrt(d_k)
    if mask is not None:
        scores += (mask * -1e9)
    weights = tf.nn.softmax(scores, axis=-1)
    return tf.matmul(weights, V), weights

# ─── Multi-Head Attention ───
class MultiHeadAttention(tf.keras.layers.Layer):
    def __init__(self, d_model, num_heads):
        super().__init__()
        self.num_heads = num_heads
        self.d_k = d_model // num_heads
        self.wq = tf.keras.layers.Dense(d_model)
        self.wk = tf.keras.layers.Dense(d_model)
        self.wv = tf.keras.layers.Dense(d_model)
        self.wo = tf.keras.layers.Dense(d_model)

    def split_heads(self, x, batch_size):
        x = tf.reshape(x, (batch_size, -1, self.num_heads, self.d_k))
        return tf.transpose(x, perm=[0, 2, 1, 3])

    def call(self, Q, K, V, mask=None):
        batch_size = tf.shape(Q)[0]
        Q = self.split_heads(self.wq(Q), batch_size)
        K = self.split_heads(self.wk(K), batch_size)
        V = self.split_heads(self.wv(V), batch_size)
        attn_out, attn_weights = scaled_dot_product_attention(Q, K, V, mask)
        attn_out = tf.transpose(attn_out, perm=[0, 2, 1, 3])
        attn_out = tf.reshape(attn_out, (batch_size, -1, self.num_heads * self.d_k))
        return self.wo(attn_out), attn_weights

# ─── Encoder Layer ───
class EncoderLayer(tf.keras.layers.Layer):
    def __init__(self, d_model, num_heads, d_ff, dropout_rate=0.1):
        super().__init__()
        self.mha = MultiHeadAttention(d_model, num_heads)
        self.ffn = tf.keras.Sequential([
            tf.keras.layers.Dense(d_ff, activation='relu'),
            tf.keras.layers.Dense(d_model)
        ])
        self.norm1 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
        self.norm2 = tf.keras.layers.LayerNormalization(epsilon=1e-6)
        self.dropout1 = tf.keras.layers.Dropout(dropout_rate)
        self.dropout2 = tf.keras.layers.Dropout(dropout_rate)

    def call(self, x, mask=None, training=False):
        attn_out, _ = self.mha(x, x, x, mask)
        x = self.norm1(x + self.dropout1(attn_out, training=training))
        ffn_out = self.ffn(x)
        x = self.norm2(x + self.dropout2(ffn_out, training=training))
        return x

# ─── Uso ───
encoder_layer = EncoderLayer(d_model=512, num_heads=8, d_ff=2048)
sample = tf.random.uniform((2, 50, 512))
output = encoder_layer(sample)
print(output.shape)  # (2, 50, 512)

Trucos de entrenamiento

Inferencia: generación autoregresiva

En inferencia, el decoder genera un token a la vez. En cada paso, toma toda la secuencia generada hasta el momento, pasa por el decoder, y predice el siguiente token:

El éxito del Transformer en NLP

La arquitectura Transformer transformó (literalmente) el procesamiento de lenguaje natural. La idea clave fue el pre-training a gran escala: entrenar un Transformer enorme con cantidades masivas de texto, y luego fine-tunear para tareas específicas. Esto dio lugar a dos paradigmas fundamentales:

Y existe un tercer paradigma que combina ambos:

BERT: Bidirectional Encoder Representations from Transformers

BERT (Devlin et al., 2018) fue el primer modelo que demostró el poder del pre-training bidireccional. Solo usa el encoder del Transformer.

GPT: Generative Pre-trained Transformer

GPT (Radford et al., 2018) toma el camino opuesto a BERT: usa solo el decoder del Transformer con masked self-attention (causal), entrenado para predecir el siguiente token.

BERT vs GPT: dos filosofías

T5: Text-to-Text Transfer Transformer

T5 (Raffel et al., 2019) unifica todas las tareas NLP bajo un mismo formato: text-to-text. Usa el Transformer completo (encoder-decoder) y trata cada tarea como una traducción entre textos:

LLMs: Large Language Models

Un Large Language Model (LLM) es un Transformer (generalmente decoder-only) entrenado con cantidades masivas de texto. A partir de cierta escala (~10B+ parámetros), emergen capacidades que no existían en modelos más pequeños:

Widget: visualizador de atención en traducción

Explora cómo funciona la cross-attention en un modelo de traducción. La matriz muestra cuánta atención presta cada token de salida (decoder) a cada token de entrada (encoder). Selecciona un par de frases y ajusta los parámetros.

Transformers más allá del NLP

Lo que empezó como una arquitectura para traducción de texto se ha convertido en la columna vertebral de toda la IA moderna. La idea clave —procesar secuencias con self-attention en paralelo— funciona igual de bien con píxeles, ondas de audio, series temporales o combinaciones multimodales.

Vision Transformers (ViT)

ViT (Dosovitskiy et al., 2020) fue la primera demostración contundente de que los Transformers pueden competir con las CNNs en visión. La idea es radical por su simplicidad:

Transformers para audio: Whisper

Whisper (Radford et al., 2022, OpenAI) es un Transformer encoder-decoder entrenado con 680.000 horas de audio (weakly supervised) que puede:

Transformers para series temporales

Las series temporales son secuencias — el dominio natural del Transformer. Varios modelos adaptan self-attention para capturar dependencias temporales complejas:

DiT: Diffusion Transformer

DiT (Peebles & Xie, 2023) reemplaza la U-Net de los modelos de difusión por un Transformer. La idea: en lugar de aplicar convoluciones para predecir el ruido, usar self-attention sobre parches del latent space.

Transformers multimodales

La misma arquitectura puede procesar múltiples modalidades simultáneamente: tokenizar cada modalidad, concatenar o intercalar, y dejar que self-attention aprenda las relaciones cross-modal.

Papers y recursos fundamentales