Transformers y LLMs: Fundamentos Técnicos

La Revolución Transformer

El paper "Attention Is All You Need" (Vaswani et al., 2017) introdujo la arquitectura Transformer, que reemplazó las RNNs y LSTMs como el estándar para procesamiento de lenguaje natural.

¿Por Qué Importa Para un AI Engineer?

No necesitas entrenar transformers desde cero, pero sí necesitas entender cómo funcionan para:

• Elegir el modelo correcto para cada tarea
• Optimizar prompts basándote en cómo el modelo procesa texto
• Debuggear problemas de contexto, alucinaciones y truncamiento
• Entender trade-offs de latencia vs calidad

Arquitectura del Transformer

┌─────────────────────────────────────────┐
│              TRANSFORMER                 │
│                                          │
│   Input ──► Tokenizer ──► Embeddings    │
│                               │          │
│           ┌───────────────────┤          │
│           ▼                   │          │
│   ┌──────────────┐   ┌──────────────┐   │
│   │   Encoder    │   │   Decoder    │   │
│   │  (Atención   │   │  (Atención   │   │
│   │   bidirec.)  │──►│   causal)    │   │
│   └──────────────┘   └──────────────┘   │
│                               │          │
│                          Output          │
└─────────────────────────────────────────┘

Componentes Clave

1. Tokenización

Los LLMs no procesan texto directamente — procesan tokens (sub-palabras).

import tiktoken

enc = tiktoken.encoding_for_model("gpt-4o")
tokens = enc.encode("Hola, soy un AI Engineer")
print(tokens)       # [39, 10381, 11, 274, 2083, ...]
print(len(tokens))  # ~6 tokens

# Cada modelo tiene un límite de contexto
# GPT-4o:      128K tokens
# Claude 4:    200K tokens
# Gemini 3.1:  2M tokens

Implicaciones prácticas:

• El costo se calcula por token (input + output)
• El contexto tiene un límite — debes optimizar qué envías
• Diferentes idiomas tienen diferente eficiencia de tokenización

2. Self-Attention (Atención)

El mecanismo de atención permite que cada token "mire" a todos los demás tokens para entender contexto.

Fórmula: Attention(Q, K, V) = softmax(QK^T / √d_k) V

Donde:
- Q (Query):  "¿Qué estoy buscando?"
- K (Key):    "¿Qué información tengo?"
- V (Value):  "¿Qué contenido devuelvo?"
- d_k:        Dimensión de las keys (factor de escala)

Multi-Head Attention: Ejecuta múltiples "cabezas" de atención en paralelo, cada una enfocándose en diferentes aspectos (sintaxis, semántica, posición, etc.).

3. Embeddings Posicionales

Los transformers no tienen noción inherente de orden. Los embeddings posicionales codifican la posición de cada token en la secuencia.

# Ejemplo conceptual
embedding = token_embedding + position_embedding
# token_embedding:    significado semántico de la palabra
# position_embedding: posición en la secuencia

RoPE (Rotary Position Embedding): Usado en modelos modernos (Llama, etc.) para mejor extrapolación a secuencias largas.

Familias de Modelos

Modelos Encoder-Only (BERT y variantes)

Input ──► [Encoder] ──► Representaciones bidireccionales

• Uso: Clasificación, NER, similarity, embeddings
• Ejemplos: BERT, RoBERTa, DeBERTa
• Característica: Ven todo el contexto (izquierda y derecha)

Modelos Decoder-Only (GPT y variantes)

Input ──► [Decoder] ──► Generación token a token

• Uso: Generación de texto, chat, coding
• Ejemplos: GPT-4, Claude, Llama, Mistral
• Característica: Atención causal (solo ven tokens previos)
• Dominan el mercado actual de IA generativa

Modelos Encoder-Decoder (T5 y variantes)

Input ──► [Encoder] ──► [Decoder] ──► Output transformado

• Uso: Traducción, summarización, Q&A extractivo
• Ejemplos: T5, FLAN-T5, mBART

Parámetros y Escala

Mixture of Experts (MoE)

Arquitectura donde solo una fracción de los parámetros se activa para cada token:

Input ──► Router ──┬── Expert 1 (activo)
                   ├── Expert 2 
                   ├── Expert 3 (activo)
                   └── Expert N
                        │
              Solo 2 de N expertos activos
              ──► Menor latencia, mismo rendimiento

Inferencia: Cómo Genera Texto un LLM

# Proceso simplificado de generación AUTOREGRESIVA
# El modelo genera un token a la vez, lo añade al input, y repite
def generate(prompt, max_tokens, temperature=0.7):
    tokens = tokenize(prompt)
    
    for _ in range(max_tokens):
        # Forward pass: el modelo produce "logits" — puntuaciones sin normalizar
        # para cada token posible del vocabulario (~100K opciones)
        logits = model(tokens)
        
        # Dividir por temperature controla la aleatoriedad:
        # - temperature < 1: distribución más concentrada → más determinista
        # - temperature > 1: distribución más dispersa → más creativo
        probs = softmax(logits / temperature)
        
        # Nucleus sampling (top_p=0.9): solo considera tokens cuya probabilidad
        # acumulada no exceda 0.9, descartando tokens muy improbables
        next_token = sample(probs, top_p=0.9)
        
        tokens.append(next_token)
        
        # EOS_TOKEN = End Of Sequence, señal de que el modelo terminó su respuesta
        if next_token == EOS_TOKEN:
            break
    
    return detokenize(tokens)

Parámetros de Generación

Ventana de Contexto y Sus Límites

┌──────────────────────────────────────────┐
│          VENTANA DE CONTEXTO              │
│                                           │
│  [System] [User messages] [Retrieved     │
│   prompt    history        context]       │
│                                           │
│  ◄─────── input tokens ────────►          │
│                                           │
│  [Generated response]                     │
│  ◄── output tokens ──►                    │
│                                           │
│  Total = input + output ≤ context_window  │
└──────────────────────────────────────────┘

Lost in the Middle: Los LLMs tienden a prestar menos atención al contenido en el medio de contextos largos. Problema importante para RAG.

# Estrategia: poner información relevante al inicio y al final
context_parts = [most_relevant, ..., least_relevant, ..., second_most_relevant]

Evaluación de Modelos: Benchmarks

Para el AI Engineer: Los benchmarks son orientativos. Siempre evalúa con datos de tu dominio específico. Un modelo que lidera MMLU puede fallar en tu caso de uso particular.

🧠 Preguntas de Repaso

1. ¿Qué mecanismo permite a los Transformers procesar todas las posiciones de una secuencia en paralelo, a diferencia de las RNNs?

• A) Convoluciones 1D sobre la secuencia de tokens
• B) Self-Attention, donde cada token calcula relevancia con todos los demás usando Q, K, V
• C) Recurrencia bidireccional optimizada
• D) Pooling global sobre los embeddings de entrada

Respuesta: B) — Self-Attention permite que cada token "atienda" a todos los demás tokens en paralelo, calculando relevancia mediante queries, keys y values. Las RNNs procesaban tokens secuencialmente, creando un cuello de botella.

2. ¿Qué familia de modelos domina actualmente el mercado de IA generativa y cuál es su característica principal?

• A) Encoder-Only (BERT) — atención bidireccional
• B) Encoder-Decoder (T5) — traducción eficiente
• C) Decoder-Only (GPT-4, Claude, Llama) — atención causal, solo ven tokens previos
• D) Modelos híbridos CNN-Transformer — procesan imágenes y texto

Respuesta: C) — Los modelos Decoder-Only como GPT-4, Claude, Llama y Mistral dominan el mercado actual. Utilizan atención causal donde solo pueden ver tokens previos para generar texto token por token.

3. ¿Qué es el problema "Lost in the Middle" y por qué es importante para RAG?

• A) Los LLMs pierden contexto cuando el input es muy corto
• B) Los LLMs prestan menos atención al contenido en el medio de contextos largos
• C) Los tokens del medio se corrompen durante la tokenización
• D) Los embeddings pierden precisión en dimensiones intermedias

Respuesta: B) — Los LLMs tienden a prestar menos atención al contenido ubicado en el medio de contextos largos. Es crítico para RAG porque la información recuperada debe colocarse estratégicamente al inicio y al final del contexto.

4. Si configuras temperature=0 en la generación de un LLM, ¿qué comportamiento esperas?

• A) El modelo genera respuestas más creativas y variadas
• B) El modelo no genera ninguna respuesta
• C) El modelo produce respuestas determinísticas, eligiendo siempre el token más probable
• D) El modelo ignora el system prompt

Respuesta: C) — Con temperature=0 la distribución de probabilidad se concentra completamente en el token más probable, haciendo la generación determinística. Es ideal para tareas como generación de código donde se necesita consistencia.