Inteligencia Artificial 🌐 Traducción Especializada • 16 de September, 2026 • 10 min de lectura

Stanford CS229: Building Large Language Models (LLMs) — From Pretraining to SFT & RLHF

👤 Autor: Yann Dubois (Stanford AI Lab) & Stanford Online (CS229) 🔗 Ver publicación original ↗

🔍 Clic para ampliar

💡 Concepto del Artículo

**Instructor:** Yann Dubois (Stanford AI Lab, Autor Principal de Alpaca y AlpacaEval) **Institución Académica:** Universidad de Stanford — CS229: Machine Learning (Stanford Online) **Recurso Fuente:** [Reel Masterclass de Facebook](https://www.facebook.com/reel/3593912480749409) y [Clase Completa...

Stanford CS229: Cómo Construir Modelos de Lenguaje Masivos (LLMs) — De Preentrenamiento a SFT y RLHF

Instructor: Yann Dubois (Stanford AI Lab, Autor Principal de Alpaca y AlpacaEval)
Institución Académica: Universidad de Stanford — CS229: Machine Learning (Stanford Online)
Recurso Fuente: Reel Masterclass de Facebook y Clase Completa en Stanford Online
Duración: 1 Hora 44 Minutos (Masterclass Integral de Ingeniería de IA)

Resumen Ejecutivo: La Realidad de Ingeniería de los LLMs

Construir un Modelo de Lenguaje Masivo moderno (como Claude, ChatGPT, Gemini o Llama) no consiste simplemente en ejecutar un script abierto de Transformers. En la práctica, el desarrollo de LLMs es una disciplina de ingeniería integral basada en cinco pilares fundamentales: Arquitectura, Algoritmos y Funciones de Pérdida, Ingeniería y Curaduría de Datos, Evaluación y Benchmarking, y Sistemas Distribuidos de Cómputo.

En esta clase magistral en Stanford CS229, Yann Dubois —investigador doctoral en Stanford asesorado por Percy Liang y Tatsunori Hashimoto, y pionero de los proyectos Alpaca y AlpacaEval— deconstruye de principio a fin todo el pipeline requerido para transformar billones de tokens de texto bruto de internet en un asistente conversacional alineado, seguro y de nivel de producción.

flowchart LR
    A["Texto Bruto de Internet<br/>(15B+ Tokens)"] --> B["Pipeline de Datos<br/>Filtrado y Deduplicación"]
    B --> C["Preentrenamiento<br/>(Transformer Decoder)"]
    C --> D["Modelo Base<br/>(Completador de Texto)"]
    D --> E["Instruction Tuning<br/>(SFT con 50k Pares)"]
    E --> F["Alineamiento de Preferencias<br/>(RLHF / DPO)"]
    F --> G["Asistente Alineado<br/>(Nivel Claude / ChatGPT)"]

📺 Temario y Marcas de Tiempo de la Masterclass

00:00 - Introducción y Fundamentos de Modelado de Lenguaje: ¿Qué es un LLM? Formulación matemática, distribuciones de probabilidad sobre secuencias de tokens y la diferencia entre conocimiento sintáctico y conocimiento semántico del mundo.
05:15 - Generación Autoregresiva y el Objetivo del Siguiente Token: Modelado causal, formulación de pérdida de entropía cruzada (Cross-Entropy Loss) y dinámica de tokenización (BPE, SentencePiece).
16:00 - Evaluación de Preentrenamiento y Perplejidad: Métricas teóricas de información, bits por byte y la relación directa entre la minimización de pérdida y el surgimiento de habilidades avanzadas.
24:30 - Benchmarks Académicos y Trampas de Evaluación: MMLU, GSM8K, HumanEval, contaminación de datos y la Ley de Goodhart en pruebas estáticas.
38:40 - Curaduría de Datos y Leyes de Escalamiento: Filtrado de Common Crawl, deduplicación MinHash, clasificadores de calidad, fronteras óptimas de cómputo de Kaplan vs. Chinchilla ($D \approx 20N$) y regímenes de sobre-entrenamiento.
52:10 - Arquitectura del Modelo y Cuellos de Botella de Inferencia: Transformers Decoder-Only, anatomía de la caché KV, Multi-Query (MQA) y Grouped-Query Attention (GQA), e incrustaciones posicionales rotatorias (RoPE).
1:05:30 - Ingeniería de Sistemas y Entrenamiento Distribuido: Presupuesto de memoria VRAM en GPUs, Paralelismo 3D (Tensor, Pipeline, ZeRO/FSDP) y aritmética de precisión mixta (FP16, BF16, FP8).
1:18:00 - Post-Entrenamiento: Supervised Fine-Tuning (SFT): Por qué los modelos base no son asistentes; diseño de conjuntos de instrucciones y la metodología Stanford Alpaca.
1:28:45 - Alineamiento y Optimización de Preferencias: Modelado de recompensa Bradley-Terry, bucles PPO con penalización KL y la revolución de Direct Preference Optimization (DPO).

1. Definición Formal del Modelado de Lenguaje

Matemáticamente, un modelo de lenguaje es una distribución de probabilidad conjunta sobre secuencias arbitrarias de tokens $x = (x_1, x_2, \dots, x_L)$ pertenecientes a un vocabulario finito $V$:

$$P(x_1, x_2, \dots, x_L) = \prod_{i=1}^L P(x_i \mid x_1, \dots, x_{i-1})$$

El modelo descompone la probabilidad conjunta en el producto de probabilidades condicionales del siguiente token utilizando la regla de la cadena de probabilidades.

graph LR
    subgraph Contexto de Entrada
        T1["El"] --> T2["ratón"]
        T2 --> T3["comió"]
        T3 --> T4["el"]
    end
    T4 --> LLM["Transformer Decoder"]
    LLM --> Dist["Distribución Softmax sobre V"]
    Dist --> Target["P('queso' | Contexto) = 0.84<br/>P('teclado' | Contexto) = 0.0001"]

Conocimiento Sintáctico vs. Semántico

Yann Dubois utiliza el ejemplo clásico de Stanford para demostrar por qué asignar probabilidades precisas exige inteligencia real:
1. $P(\text{el, ratón, comió, el, queso}) = 0.02$ (Estructuralmente correcta y semánticamente plausible).
2. $P(\text{el, el, ratón, comió, queso}) = 0.0001$ (Error sintáctico: estructura gramatical no válida).
3. $P(\text{el, queso, comió, el, ratón}) = 0.001$ (Sintácticamente perfecta, pero semánticamente absurda; contradice el conocimiento empírico del mundo real).

Para que una red neuronal minimice su función de pérdida sobre billones de palabras, está obligada a aprender de forma implícita gramática formal, razonamiento causal y conocimiento enciclopédico de la realidad.

2. Tokenización: La Capa Oculta Fundamental

Los modelos de lenguaje no leen texto crudo ni caracteres directamente. Todo texto es convertido en números enteros discretos por un tokenizador.

Familia de Tokenizadores	Algoritmos	Tamaño Típico de Vocabulario	Ventajas y Desventajas
Byte-Pair Encoding (BPE)	GPT-4 (tiktoken), Llama	32.000 a 128.000 tokens	Muy eficiente en inglés; sensible a espacios en blanco; fragmenta números grandes.
SentencePiece (Unigram/BPE)	T5, Gemma, Mistral	32.000 a 256.000 tokens	Soporte nativo para Unicode; excelente tratamiento equitativo multilingüe.
Byte-Level Fallback	Implementaciones modernas	Ilimitado	Elimina por completo los errores de tokens fuera de vocabulario (OOV).

Consecuencias Técnicas de la Tokenización:

Dificultad Aritmética: Si una cifra como 12345 se fragmenta en tokens arbitrarios como [12, 345] mientras que 123 es un solo token [123], sumar y multiplicar se convierte en un laberinto de correlación de subcadenas en lugar de álgebra real.
El Impuesto Multilingüe: Los idiomas distintos del inglés (español, árabe, japonés) suelen necesitar entre 2 y 4 veces más tokens para codificar el mismo párrafo si el tokenizador se entrenó mayoritariamente con texto anglosajón, encareciendo y ralentizando drásticamente la inferencia.

3. Preentrenamiento: Curaduría de Datos y Leyes de Escalamiento

El límite superior de capacidad de cualquier modelo fundacional está delimitado estrictamente por la calidad y variedad de su corpus de preentrenamiento.

flowchart TD
    Raw["Extracción Web Bruta (Common Crawl)"] --> Dedupe["Deduplicación (MinHash / Subcadenas Exactas)"]
    Dedupe --> Quality["Filtros Heurísticos y Modelos Clasificadores"]
    Quality --> Repartition["Balanceo por Dominios (Código, Matemáticas, Libros)"]
    Repartition --> Tokenize["Tokenización Masiva (15 Billones de Tokens)"]
    Tokenize --> Cluster["Entrenamiento en Cluster de GPUs (H100 / Blackwell)"]

La Ley de Escalamiento de Chinchilla (Hoffmann et al., 2022)

Para un presupuesto de cómputo fijo de $C \approx 6ND$ operaciones de punto flotante (FLOPs), donde $N$ es la cantidad de parámetros y $D$ es el número de tokens:
* Relación Óptima de Cómputo: Los parámetros y los tokens deben escalar a la par ($D \approx 20N$).
* Sobre-entrenamiento Óptimo para Inferencia: En producción, un modelo se consulta miles de millones de veces. Por tanto, entrenar un modelo más compacto (como Llama 3 8B) con un volumen masivo de tokens ($15\text{T} \gg 20 \times 8\text{B}$) reduce drásticamente los costes de cómputo y latencia en el despliegue final.

4. Arquitectura del Modelo y Gestión de Caché KV

Los LLMs modernos adoptan de forma casi unánime la arquitectura Decoder-Only Transformer.

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

sequenceDiagram
    participant Paso as Paso de Generación t
    participant Cache as Memoria KV-Cache (VRAM)
    participant Kernel as Núcleo de Atención (FlashAttention)

    Paso->>Cache: Recupera proyecciones previas K, V (0 a t-1)
    Kernel->>Kernel: Calcula atención del nuevo token Q_t
    Kernel->>Cache: Almacena nuevos vectores K_t, V_t
    Kernel-->>Paso: Distribución de probabilidades del siguiente token

MHA vs. Grouped-Query Attention (GQA)

En Multi-Head Attention (MHA) estándar, cada cabezal de consulta posee su propio par de cabezales Key y Value, lo que agota la memoria VRAM en contextos largos ($128\text{k}+$ tokens).
* Grouped-Query Attention (GQA): Varios cabezales Query comparten un único cabezal Key-Value (por ejemplo, 8 queries por cada par KV). Esto reduce el tamaño de la caché KV en un factor de $8\times$ sin degradar la precisión, haciendo viables ventanas de contexto masivas en hardware estándar.

5. Post-Entrenamiento: De Completador a Asistente Conversacional

Un modelo base entrenado exclusivamente para predecir el siguiente token es un extraordinario completador de documentos, pero un pésimo asistente. Si se le solicita:

"Escribe un script en Python para calcular números primos."

Un modelo base podría responder continuando el texto de examen:

"Ejercicio 3.4: Escribe un script para ordenar un array."

Fase 1: Supervised Fine-Tuning (SFT)

El SFT entrena el modelo sobre pares conversacionales cuidadosamente seleccionados:

$$\mathcal{L}{SFT}(\theta) = -\sum{(x,y)} \sum_{t=1}^{|y|} \log P_\theta(y_t \mid x, y_{

Stanford CS229: Building Large Language Models (LLMs) — From Pretraining to SFT & RLHF

Instructor: Yann Dubois (Stanford AI Lab, Alpaca & AlpacaEval Lead Author)
Host Institution: Stanford University — CS229: Machine Learning (Stanford Online)
Source Resource: Facebook Masterclass Reel & Stanford Online Full Lecture
Duration: 1 Hour 44 Minutes (Complete Engineering Masterclass)

Executive Summary: The Engineering Reality of LLMs

Building a modern Large Language Model (such as Claude, ChatGPT, Gemini, or Llama) is frequently misunderstood as simply running an open-source Transformer script. In reality, modern LLM development is an end-to-end discipline spanning five foundational pillars: Architecture, Training Algorithms & Loss, Data Curation, Evaluation Benchmarks, and Distributed Systems Engineering.

In this Stanford CS229 masterclass, Yann Dubois—doctoral researcher at Stanford advised by Percy Liang and Tatsunori Hashimoto, and pioneer of the Alpaca and AlpacaEval projects—deconstructs the entire pipeline required to take an LLM from raw internet text to a helpful, aligned, production-grade conversational assistant.

flowchart LR
    A["Raw Internet Crawl<br/>(15T+ Tokens)"] --> B["Data Pipeline<br/>Filter & Deduplicate"]
    B --> C["Pretraining<br/>(Decoder Transformer)"]
    C --> D["Base Model<br/>(Document Completer)"]
    D --> E["Instruction Tuning<br/>(SFT on 50k Pairs)"]
    E --> F["Preference Alignment<br/>(RLHF / DPO)"]
    F --> G["Aligned Assistant<br/>(Claude / ChatGPT grade)"]

📺 Masterclass Curriculum & Video Timestamps

00:00 - Introduction & Foundations of Language Modeling: What is an LLM? Mathematical formulation, probability distributions over token sequences, and the distinction between syntactic and semantic world knowledge.
05:15 - Autoregressive Generation & The Next-Token Objective: Causal modeling, cross-entropy loss formulation, and tokenization dynamics (BPE, SentencePiece).
16:00 - Pretraining Evaluation & Perplexity: Information-theoretic metrics, bits-per-byte, and the relationship between loss minimization and downstream capability emergence.
24:30 - Academic Benchmarks & Evaluation Pitfalls: MMLU, GSM8K, HumanEval, data contamination, and Goodhart's Law in static benchmarks.
38:40 - Data Engineering & Scaling Laws: Common Crawl filtering, MinHash deduplication, quality classifiers, Kaplan vs. Chinchilla compute-optimal frontiers ($D \approx 20N$), and overtraining regimes.
52:10 - Model Architecture & Inference Bottlenecks: Decoder-only Transformers, KV-cache anatomy, Multi-Query (MQA) and Grouped-Query Attention (GQA), and RoPE embeddings.
1:05:30 - Systems Engineering & Distributed Training: GPU memory budgets, 3D Parallelism (Tensor, Pipeline, ZeRO/FSDP), and mixed precision (FP16, BF16, FP8).
1:18:00 - Post-Training: Supervised Fine-Tuning (SFT): Why base models are not chatbots; instruction dataset curation and the Stanford Alpaca methodology.
1:28:45 - Alignment & Preference Optimization: Bradley-Terry reward modeling, PPO loops with KL penalties, and Direct Preference Optimization (DPO).

1. Formal Definition of Language Modeling

Mathematically, a language model is a joint probability distribution over arbitrary sequences of tokens $x = (x_1, x_2, \dots, x_L)$ drawn from a finite vocabulary $V$:

$$P(x_1, x_2, \dots, x_L) = \prod_{i=1}^L P(x_i \mid x_1, \dots, x_{i-1})$$

The model decomposes the joint probability into a sequence of conditional next-token probabilities using the chain rule of probability.

graph LR
    subgraph Context Window
        T1["The"] --> T2["mouse"]
        T2 --> T3["ate"]
        T3 --> T4["the"]
    end
    T4 --> LLM["Transformer Decoder"]
    LLM --> Dist["Softmax Distribution over Vocabulary V"]
    Dist --> Target["P('cheese' | Context) = 0.84<br/>P('computer' | Context) = 0.001"]

Syntactic vs. Semantic Knowledge

Yann Dubois presents the canonical Stanford example to illustrate why assigning accurate probabilities requires true intelligence:
1. $P(\text{the, mouse, ate, the, cheese}) = 0.02$ (Grammatically valid and semantically true).
2. $P(\text{the, the, mouse, ate, cheese}) = 0.0001$ (Syntactic error: invalid grammar structure).
3. $P(\text{the, cheese, ate, the, mouse}) = 0.001$ (Syntactically perfect, but semantically improbable; violates world knowledge).

A model cannot minimize cross-entropy loss on massive corpora without simultaneously acquiring deep syntactic parsing rules, contextual reasoning, and factual world knowledge.

2. Tokenization: The Hidden Substrate

Language models do not process raw strings or Unicode characters directly. Text is converted into discrete integers via a tokenizer.

Tokenizer Family	Algorithms	Typical Vocabulary Size	Pros / Cons
Byte-Pair Encoding (BPE)	GPT-4 (tiktoken), Llama	32,000 to 128,000	Highly efficient for English; sensitive to whitespace; number token fragmentation.
SentencePiece (Unigram/BPE)	T5, Gemma, Mistral	32,000 to 256,000	Native Unicode support; consistent language agnostic tokenization.
Byte-level Fallback	Modern BPE implementations	Any	Eliminates out-of-vocabulary (OOV) tokens entirely.

Engineering Implications of Tokenization:

Arithmetic Weakness: If numbers like 12345 are tokenized as [12, 345] while 123 is [123], mathematical operations become erratic token-mapping problems rather than clean numeric logic.
Multilingual Tax: Non-English languages (Spanish, Arabic, Chinese) frequently require 2x to 4x more tokens per word if the tokenizer vocabulary is predominantly English-trained, dramatically increasing inference latency and cost.

3. Pretraining: Data Engineering & Scaling Laws

The quality of a base foundation model is strictly bounded by the quality and diversity of its pretraining dataset.

flowchart TD
    Raw["Raw Web Scrape (Common Crawl)"] --> Dedupe["Deduplication (MinHash / Exact Substring)"]
    Dedupe --> Quality["Heuristic & Model-Based Quality Filters"]
    Quality --> Repartition["Domain Balancing (Code, Math, Wikipedia, Books)"]
    Repartition --> Tokenize["BPE Tokenization (15 Trillion Tokens)"]
    Tokenize --> Cluster["GPU Cluster Training (H100 / Blackwell)"]

The Chinchilla Scaling Law (Hoffmann et al., 2022)

For a fixed compute budget $C \approx 6ND$ FLOPs (where $N$ is parameter count and $D$ is total training tokens):
* Compute-Optimal Ratio: Parameters and tokens should scale in roughly equal proportion ($D \approx 20N$).
* Inference-Optimal Overtraining: In production, models are queried billions of times. Therefore, training a smaller model (e.g., Llama 3 8B) on far more tokens ($15\text{T} \gg 20 \times 8\text{B}$) pays massive dividends in latency and deployment cost.

4. Model Architecture & KV-Cache Management

Modern LLMs universally employ the Decoder-Only Transformer architecture.

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

sequenceDiagram
    participant User as Generation Step t
    participant Memory as KV-Cache (VRAM)
    participant Engine as Attention Core (FlashAttention)

    User->>Memory: Read past K, V projections (0 to t-1)
    Engine->>Engine: Compute Q_t with cached K and V
    Engine->>Memory: Append new K_t, V_t
    Engine-->>User: Next Token Probability Logits

MHA vs. GQA (Grouped-Query Attention)

In standard Multi-Head Attention (MHA), each query head has an independent Key and Value head, consuming massive GPU memory for long context windows ($128\text{k}+$ tokens).
* Grouped-Query Attention (GQA): Multiple query heads share a single Key and Value head (e.g., 8 query heads per KV pair). This slashes KV-cache memory by $8\times$ with negligible loss in benchmark performance, making 128k context feasible on commercial hardware.

5. Post-Training: From Document Completer to Helpful Assistant

A base model trained on next-token prediction is an exceptional document completer, but a terrible assistant. If asked:

"Write a Python script to calculate Fibonacci numbers."

A base model may continue the document with:

"Exercise 4.2: Write a script to calculate Prime numbers."

Stage 1: Supervised Fine-Tuning (SFT)

SFT trains the model on curated prompt-response pairs:

$$\mathcal{L}{SFT}(\theta) = -\sum{(x,y)} \sum_{t=1}^{|y|} \log P_\theta(y_t \mid x, y_{