Capítulo 2: Historia - De las RNN a los Transformers

Introducción

El camino hacia los modelos de lenguaje grandes modernos abarca décadas de investigación en redes neuronales y procesamiento de lenguaje natural. Comprender esta historia nos ayuda a apreciar por qué la arquitectura Transformer fue un avance tan importante.

La era pre-neuronal (1950s-2000s)

Sistemas basados en reglas

Los primeros sistemas de PLN dependían de reglas hechas a mano:

IF input contains "weather" AND "tomorrow"
THEN search weather database for tomorrow
RETURN formatted weather response

Limitaciones:

• No podían manejar la variabilidad del lenguaje
• Requerían una ingeniería manual extensa
• Mala capacidad de generalización

Modelos estadísticos de lenguaje

El enfoque estadístico modelaba el lenguaje como distribuciones de probabilidad:

$$P(w_1, w_2, ..., w_n) = \prod_{i=1}^{n} P(w_i | w_1, ..., w_{i-1})$$

Modelos N-grama:

# Bigram model example
bigram_counts = {
    ("the", "cat"): 100,
    ("the", "dog"): 80,
    ("cat", "sat"): 50,
}

# P("cat" | "the") = count("the cat") / count("the")

Limitaciones:

• Escasez de datos para contextos largos
• Sin comprensión semántica
• Vocabulario fijo

La revolución neuronal (2000s-2017)

Modelos neuronales de lenguaje feed-forward (2003)

Bengio et al. introdujeron los modelos neuronales de lenguaje:

[w_{t-3}] [w_{t-2}] [w_{t-1}]
    ↓         ↓         ↓
[Embedding] [Embedding] [Embedding]
         ↘     ↓     ↙
        [Hidden Layer]
              ↓
        [Softmax Output]
              ↓
           P(w_t)

Innovación clave: Representaciones distribuidas aprendidas (embeddings)

Redes Neuronales Recurrentes (RNN)

Las RNN introdujeron el concepto de memoria mediante recurrencia:

class SimpleRNN:
    def forward(self, x, h_prev):
        """
        x: current input
        h_prev: previous hidden state
        """
        h_new = tanh(W_xh @ x + W_hh @ h_prev + b)
        return h_new

Arquitectura:

h_0 → [RNN] → h_1 → [RNN] → h_2 → [RNN] → h_3
        ↑            ↑            ↑
       x_1          x_2          x_3

Problemas:

• Gradientes que desaparecen: Las señales se debilitan en secuencias largas
• Procesamiento secuencial: No se puede paralelizar el entrenamiento

Long Short-Term Memory (LSTM) - 1997

Hochreiter & Schmidhuber diseñaron las LSTM para abordar los gradientes que desaparecen:

class LSTMCell:
    def forward(self, x, h_prev, c_prev):
        # Forget gate
        f = sigmoid(W_f @ [h_prev, x] + b_f)
        
        # Input gate
        i = sigmoid(W_i @ [h_prev, x] + b_i)
        
        # Candidate values
        c_tilde = tanh(W_c @ [h_prev, x] + b_c)
        
        # Update cell state
        c = f * c_prev + i * c_tilde
        
        # Output gate
        o = sigmoid(W_o @ [h_prev, x] + b_o)
        h = o * tanh(c)
        
        return h, c

Componentes clave:

Puerta	Propósito
Forget Gate	Qué eliminar de la memoria
Input Gate	Qué nueva información almacenar
Output Gate	Qué extraer de la memoria

Sequence-to-Sequence (2014)

Sutskever et al. introdujeron arquitecturas encoder-decoder:

Encoder:                    Decoder:
"Hello world" → [LSTM] → Context Vector → [LSTM] → "Bonjour monde"

Limitación: Cuello de botella por el vector de contexto único

Mecanismo de atención (2014-2015)

Bahdanau et al. introdujeron la atención para abordar el cuello de botella:

$$\text{Attention}(Q, K, V) = \text{softmax}\left(\frac{QK^T}{\sqrt{d_k}}\right)V$$

def attention(query, keys, values):
    """
    query: what we're looking for
    keys: what each position offers
    values: actual content at each position
    """
    scores = query @ keys.T / sqrt(d_k)
    weights = softmax(scores)
    output = weights @ values
    return output

Idea clave: Permitir que el modelo aprenda qué partes de la entrada son relevantes para cada salida.

La revolución Transformer (2017)

"Attention Is All You Need"

Vaswani et al. propusieron eliminar la recurrencia por completo:

Key Paper

"Attention Is All You Need" (2017)

• Autores: Vaswani, Shazeer, Parmar, Uszkoreit, Jones, Gomez, Kaiser, Polosukhin
• Introdujo la arquitectura Transformer
• Permitió una paralelización masiva
• Base de todos los LLM modernos

Resumen de la arquitectura Transformer

Input Tokens
     ↓
[Embedding + Positional Encoding]
     ↓
┌─────────────────────────────┐
│   Multi-Head Attention      │
│         ↓                   │
│   Add & Normalize           │
│         ↓                   │
│   Feed-Forward Network      │
│         ↓                   │
│   Add & Normalize           │
└─────────────────────────────┘ × N layers
     ↓
Output Probabilities

Por qué ganaron los Transformers

Característica	RNN/LSTM	Transformer
Paralelización	Secuencial	Totalmente paralela
Dependencias de largo alcance	Difícil	Atención directa
Velocidad de entrenamiento	Lenta	Rápida
Escalabilidad	Limitada	Excelente

La era GPT (2018-presente)

GPT-1 (2018)

El primer "Generative Pre-trained Transformer" de OpenAI:

• 117M parámetros
• Paradigma de preentrenamiento + ajuste fino
• Arquitectura solo decodificador

# GPT-1 architecture (simplified)
class GPT1:
    def __init__(self):
        self.layers = 12
        self.heads = 12
        self.d_model = 768
        self.vocab_size = 40478

BERT (2018)

Enfoque bidireccional de Google:

• 340M parámetros (BERT-Large)
• Arquitectura solo codificador
• Modelado de lenguaje enmascarado

# BERT pre-training objective
def masked_lm_loss(input_ids, model):
    # Randomly mask 15% of tokens
    masked_input = mask_tokens(input_ids, mask_prob=0.15)
    
    # Predict original tokens
    predictions = model(masked_input)
    
    # Loss only on masked positions
    return cross_entropy(predictions[masked_positions], 
                        input_ids[masked_positions])

GPT-2 (2019)

Escalando y demostrando capacidades emergentes:

• 1.5B parámetros
• Rendimiento zero-shot en tareas
• Inicialmente retenido por preocupaciones de mal uso

GPT-3 (2020)

La escala que lo cambió todo:

• 175B parámetros
• Aprendizaje en contexto
• Prompting de pocos ejemplos (few-shot)

# GPT-3 scale
gpt3_config = {
    "n_params": 175_000_000_000,
    "n_layers": 96,
    "d_model": 12288,
    "n_heads": 96,
    "context_length": 2048,
}

La era moderna (2022-presente)

Modelo	Año	Parámetros	Innovación clave
ChatGPT	2022	~175B	RLHF para alineamiento
GPT-4	2023	~1.8T*	Multimodal, MoE*
Claude 2/3	2023-24	Desconocido	Constitutional AI
Llama 2	2023	7B-70B	Pesos abiertos
Mistral	2023	7B	Arquitectura eficiente

*Estimado/no confirmado

Visualización de la línea de tiempo

Por qué importa la historia

Comprender esta evolución nos ayuda a:

1. Apreciar las decisiones de diseño en las arquitecturas modernas
2. Reconocer patrones que llevan a avances
3. Anticipar direcciones futuras basadas en tendencias
4. Depurar y mejorar los sistemas actuales

Puntos clave

Summary

1. Las RNN introdujeron el modelado de secuencias pero no podían paralelizarse
2. Las LSTM resolvieron los gradientes que desaparecen pero siguieron siendo secuenciales
3. La atención permitió enfocarse en entradas relevantes
4. Los Transformers eliminaron la recurrencia, permitiendo una escala masiva
5. La escala resultó ser un ingrediente clave para la aparición de capacidades

Mirando hacia adelante

En el próximo capítulo, exploraremos el panorama actual de los modelos de lenguaje grandes, revisando los principales actores, sus modelos y el debate en curso entre enfoques open-source y propietarios.

---

← Capítulo 1: ¿Qué son los LLM?

Capítulo 3: Panorama de los LLM →