Lucca Frachelle https://luccafrachelle.github.io/porfolio_academia/blog.html Estadística, matemática y aprendizaje automático. Investigación, docencia, blog y proyectos de Lucca Frachelle. https://luccafrachelle.github.io/porfolio_academia/assets/profile.jpg Lucca Frachelle https://luccafrachelle.github.io/porfolio_academia/blog.html quarto-1.10.18 Fri, 11 Sep 2026 00:00:00 GMT Intro a RLHF Lucca Frachelle https://luccafrachelle.github.io/porfolio_academia/posts/rlhf-instructgpt.html

Leer en PDF

Referencia principal: Ouyang et al. (2022). Lectura complementaria: RLHF Book (Nathan Lambert).

1 De language model a policy de RL

Un large language model no almacena respuestas prefabricadas. Parametriza una distribución de probabilidad sobre secuencias de tokens: dado un prompt , asigna probabilidades a posibles respuestas mediante , con en el orden de miles de millones de parámetros distribuidos en un Transformer. Durante el pre-entrenamiento, esos pesos se ajustan para maximizar la verosimilitud de texto observado en corpus masivos. El resultado es un modelo con amplio conocimiento lingüístico y factual en sentido estadístico, pero cuyo objetivo original — predecir el siguiente token del internet — no coincide con el de un asistente que siga instrucciones de forma útil y segura.

Las respuestas se generan de forma autoregresiva. En post-entrenamiento conviene escribir prompt y respuesta , con

En pre-entrenamiento, en cambio, no hay split prompt/respuesta: sobre una secuencia cruda del corpus se minimiza

equivalente a maximizar la verosimilitud de cada token condicionado a todo el contexto previo — que puede cruzar frases y documentos. En cada paso, el Transformer produce logits sobre el vocabulario y aplica un softmax; la arquitectura concreta (atención, capas, escala) importa menos, para nuestros propósitos, que el hecho de que es una policy paramétrica diferenciable cuyas acciones son tokens discretos.

Esquema next-token prediction

Predicción del siguiente token en pre-entrenamiento.

Diagrama Transformer

Arquitectura Transformer.

Desde la perspectiva del TAR, conviene leer el LLM como una policy sobre un espacio de acciones enorme. El estado en el paso es el contexto ; la acción es el token ; la trayectoria es la respuesta completa ; un episodio consiste en un prompt y la secuencia generada hasta el fin. A diferencia de un MDP clásico, no hay una dinámica de entorno independiente de la policy: el contexto solo crece porque el propio modelo va appendeando tokens. Tampoco hay, en la formulación de InstructGPT, un reward denso en cada paso intermedio: el Reward Model evalúa la respuesta terminada. La situación es la de un bandit contextual: se observa un contexto , se elige una acción de alta dimensión , y se recibe un escalar .

El post-entrenamiento no reemplaza el pre-entrenamiento sino que parte de él. Donde el pre-training optimizaba sobre texto crudo, InstructGPT optimiza una combinación del score de un Reward Model y una penalización que mide cuánto se aleja la policy del checkpoint de supervised fine-tuning. El pre-entrenamiento aporta la capacidad lingüística base; el post-entrenamiento reorienta el comportamiento hacia el de un asistente.

2 El pipeline de InstructGPT y sus datos

Ouyang et al. entrenan variantes de GPT-3 (1.3B, 6B y 175B parámetros) en tres etapas encadenadas: supervised fine-tuning (SFT), entrenamiento de un Reward Model (RM) sobre preferencias humanas, y fine-tuning por RL con PPO sobre ese RM. Salvo indicación contraria, cuando el paper habla de InstructGPT se refiere a la variante PPO-ptx, que mezcla gradientes de pretraining con los de PPO; volveremos sobre eso en la sección correspondiente.

SFT, RM, PPO

Pipeline InstructGPT (Fig. 2 del paper).

Los datos provienen de dos fuentes. Por un lado, unos cuarenta anotadores contratados escribieron instrucciones de distintos tipos — prompts simples, prompts con ejemplos few-shot, y casos de uso inspirados en la waitlist de la API de OpenAI. Por otro, se recolectaron prompts reales enviados por clientes a versiones tempranas de la API. La mayoría de las tareas son generativas (preguntas abiertas, diálogo, resumen, etc.); más del 96% del material está en inglés.

A partir de esos prompts se construyen tres conjuntos de entrenamiento, cada uno con un rol distinto en el pipeline. El dataset SFT contiene unas 13 mil demostraciones : el anotador escribe la respuesta que considera ideal. El dataset RM reúne unos 33 mil prompts para los cuales se generaron entre cuatro y nueve respuestas del modelo y los humanos produjeron un ranking completo. El dataset PPO aporta unos 31 mil prompts de la API sin etiquetas adicionales: solo sirven como contextos para rollouts durante el RL. Ninguno de estos conjuntos es público.

La recolección de preferencias merece detenerse un instante. Para cada prompt del dataset RM, el modelo genera completions distintas (con ) y el anotador las ordena de mejor a peor, obteniendo . Ese ranking único induce hasta comparaciones pareadas consistentes — si está por encima de en el ranking, se registra . En la práctica hay muchos más pares de comparación que prompts, lo cual enriquece el entrenamiento del RM aun con un volumen moderado de anotación humana.

Ranking de respuestas

Interfaz de ranking (Fig. 12).

3 Supervised fine-tuning

La primera etapa es la más directa. Sobre las demostraciones humanas se minimiza la negative log-likelihood de la respuesta demostrada, token a token:

Formalmente, es el mismo objetivo del language modeling aplicado a pares instrucción–respuesta. El gradiente incrementa la probabilidad de la trayectoria bajo . No hay señal relativa entre dos respuestas alternativas: el modelo aprende a imitar un ejemplo dado, no a preferir una respuesta sobre otra cuando ambas serían plausibles.

Eso tiene consecuencias claras. El SFT enseña al base model a adoptar el formato de asistente — responder a instrucciones en lugar de continuar texto arbitrariamente — y condiciona la distribución hacia un subespacio de respuestas razonables. Pero no resuelve el problema de la alineación fina: dos completions distintas pueden ser gramaticalmente correctas y una ser claramente superior para el usuario. Esa distinción requiere preferencias y, más adelante, RL.

En el paper hay dos corridas de SFT con propósitos distintos. Para las evaluaciones de baseline, entrenan durante 16 épocas con dropout 0.2 y learning rate cosine; curiosamente, la validation loss empeora tras la primera época, pero el checkpoint se selecciona por el score del RM en validación, no por la loss de SFT. Para inicializar el RL, en cambio, usan una corrida más corta de dos épocas con un 10% de datos de pretraining mezclados. Ese checkpoint es : sirve como punto de partida de la policy y, crucialmente, como ancla en la penalización KL de la etapa de PPO.

4 El Reward Model y el modelo Bradley-Terry

La segunda etapa traduce juicios humanos en una función de reward diferenciable . El paper sigue la receta de Stiennon et al. (2020), aplicada antes al resumen de textos, y la extiende a instrucciones generales. La pieza conceptual clave es el modelo Bradley-Terry (Bradley y Terry, 1952).

La idea parte de postular que, fijado un prompt , cada respuesta tiene una utilidad latente que resume cuán deseable es para un anotador representativo. Esa utilidad no se observa; lo que se observa son comparaciones. Bradley y Terry modelan la probabilidad de que un anotador prefiera sobre como una función que depende únicamente de la diferencia de utilidades:

donde es la función logística. Si supera ampliamente a , la preferencia por es casi segura; si las utilidades son similares, la elección se aproxima al azar. La forma logística no es arbitraria: emerge en modelos de elección discreta cuando las utilidades están perturbadas por ruido de tipo extreme value (la derivación clásica del logit).

InstructGPT parametriza con una red neuronal. Concretamente, toman un GPT-3 de 6B parámetros — un solo RM para todas las policies, porque la versión de 175B resultó inestable como función de valor durante el RL —, eliminan la capa de unembedding y la reemplazan por una proyección escalar. El modelo recibe el prompt y la respuesta concatenados y devuelve un número. Para una comparación observada , con el winner y el loser, la probabilidad modelada de la preferencia registrada es

Una propiedad importante del modelo es la invarianza a traslación: si se suma una constante a todos los scores, las probabilidades no cambian, porque solo importan las diferencias. Por eso, antes de pasar al RL, el paper normaliza el RM de modo que las demostraciones SFT tengan score medio cero. Eso fija la escala que de otro modo sería indeterminada.

Los rankings de respuestas se convierten en datos de entrenamiento agrupando, para cada prompt, todas las comparaciones con . El paper advierte que mezclar al azor pares provenientes del mismo prompt en distintos batches provoca overfit severo en una sola época, porque las comparaciones dentro de un ranking están fuertemente correlacionadas. Por ello entrenan con un elemento de batch por prompt que contiene el conjunto completo de comparaciones de ese prompt — hasta pares cuando el batch incluye 64 prompts.

La estimación es por máxima verosimilitud. Sea la distribución sobre tuplas inducida por los rankings. La log-verosimilitud del modelo Bradley-Terry es

y el entrenamiento minimiza su opuesto, que el paper escribe como la ecuación (1):

El factor promedia explícitamente sobre las comparaciones asociadas a cada tarea de anotación. Esta pérdida no es un clasificador binario genérico pegado sobre scores: es la verosimilitud de un modelo probabilístico de preferencias, y maximizarla ajusta para que el orden inducido por los scores coincida, en promedio, con el orden humano.

La intuición del gradiente ayuda a leer la ecuación. Para un par , sea . La derivada de respecto de es . Si el RM clasifica mal el par (), el gradiente es grande y empuja a separar los scores; si el par ya está bien clasificado (), el gradiente es casi nulo y no hace falta seguir amplificando la diferencia. El RM se entrena una sola época sobre unos 33 mil prompts; más épocas degradan la validación.

Preferencias y RM

Entrenamiento del reward model.

Hay que insistir en que es un proxy. Aprende a reproducir preferencias humanas en la distribución de entrenamiento, pero puede ser explotado por una policy de RL que optimice demasiado agresivamente su score. Respuestas verbosas, aduladoras o con patrones que el RM premia sin aportar utilidad real son un riesgo conocido (reward hacking). Eso motiva la tercera etapa: no basta con maximizar ; hace falta regularizar.

5 PPO, la penalización KL y PPO-ptx

Con y congelados, la tercera etapa fine-tunea una policy mediante PPO. Cada episodio del bandit consiste en muestrear un prompt del dataset PPO, generar una respuesta , evaluar el reward y terminar. El critic se inicializa desde el RM (misma arquitectura de 6B) y las ventajas se estiman con GAE, con clipping como en el PPO estándar del curso.

La variante PPO sin mezcla de pretraining () maximiza

El primer término empuja hacia respuestas con alto score del RM, es decir, hacia lo que los humanos habrían preferido en promedio. El segundo penaliza desviarse de . Como la probabilidad de una secuencia factoriza token a token, el log-ratio de la ecuación se descompone en una suma de contribuciones por paso; en la implementación del paper, esa penalización se aplica de forma token a token durante el rollout, lo que proporciona señal densa al critic aun cuando solo evalúa la respuesta completa. El coeficiente reportado es .

Maximizar únicamente sería peligroso. La policy podría colapsar hacia completions que maximizan el proxy humano pero tienen probabilidad casi nula bajo el modelo pre-entrenado — lenguaje incoherente, fuera de distribución o explícitamente diseñado para engañar al RM. La penalización KL mantiene cerca del manifold de lenguaje fluido aprendido en SFT. No es un detalle menor: sin ella, el RL sobre un RM imperfecto tiende a producir reward hacking.

Sin embargo, la KL por sí sola no resuelve otro problema. PPO puro mejora las preferencias humanas en la distribución de prompts de la API, pero empeora en benchmarks NLP estándar — SQuADv2, DROP, HellaSwag, traducción, entre otros. Ouyang et al. llaman a esta degradación alignment tax: al optimizar el proxy de alineación, la policy pierde parte de la capacidad lingüística general heredada del pretraining. Subir atenúa la regresión, pero también limita cuánto puede mejorar el score del RM; no hay un knob que resuelva ambos extremos a la vez.

La solución que adopta InstructGPT es PPO-ptx (pretraining mix). Además de los gradientes de PPO, mezclan en cada minibatch gradientes de language modeling sobre , la distribución de texto crudo con la que se pre-entrenó GPT-3. El objetivo completo es

con y aproximadamente ocho veces más ejemplos de pretraining que episodios de RL por minibatch. El término obliga al modelo a seguir siendo un buen language model de texto general mientras el RL lo alinea como asistente. En la práctica, PPO y PPO-ptx obtienen preferencias humanas similares en la API, pero solo PPO-ptx mitiga la regresión en tareas de lenguaje más amplias. Por eso el paper reserva el nombre InstructGPT para la variante con pretraining mix.

El entrenamiento RL corre 256 mil episodios sobre unos 31 mil prompts únicos, con batch de 512 y minibatches de 64. El RM y el critic permanecen fijos en 6B parámetros aunque la policy alcance 175B. PPO implementa, en el fondo, una estimación robusta del policy gradient

con ventajas de GAE y ratio clipped . La correspondencia con el TAR es directa: la policy del LLM es token a token; el reward del entorno es el score del RM (más la penalización KL por token); el critic sustituye al valor del MDP, inicializado desde el RM.

Visualización PPO

Loop PPO.

6 Resultados

Las evaluaciones humanas sobre la distribución de prompts de la API muestran una mejora progresiva en cada etapa del pipeline: GPT-3 base, GPT-3 con prompt cuidadoso, SFT, PPO y PPO-ptx. De forma llamativa, InstructGPT de 1.3B parámetros es preferido sobre GPT-3 de 175B en esa distribución; en comparaciones directas, la versión 175B de InstructGPT es elegida frente a GPT-3 175B en torno al 85% de las veces. Eso no implica que el modelo pequeño “sepa más”, sino que el post-entrenamiento optimizó directamente lo que los evaluadores valoran en un asistente.

Win rate vs 175B SFT

Evaluaciones humanas (Fig. 1).

Más allá de la preferencia global, los modelos PPO superan a GPT-3 en metadata recogida por los anotadores: siguen mejor las instrucciones explícitas, alucinan con menos frecuencia en tareas de dominio cerrado y producen respuestas más apropiadas en el rol de asistente.

Metadata API

Metadata (Fig. 4).

7 Cierre

InstructGPT condensa, en un pipeline de tres etapas, la lógica del RLHF aplicado a LLMs. El SFT enseña por imitación y fija la referencia . El Reward Model estima, vía Bradley-Terry, una función de utilidad cuyas diferencias reproducen las preferencias humanas — ecuación (1). PPO maximiza esa utilidad mientras penaliza la desviación de la referencia — ecuación (2a). PPO-ptx añade un término de language modeling sobre texto de pretraining para no sacrificar la capacidad lingüística general al pagar el alignment tax — ecuación (2b).

Desde el TAR, la lección operativa es que el LLM ya es la policy; el RM reemplaza la función de reward del entorno; PPO es el mismo algoritmo de trust region visto en el curso, adaptado a secuencias largas y rewards escasos. Lo específico de InstructGPT no es tanto el algoritmo base como la combinación de datos humanos moderados, un proxy de preferencias bien calibrado, regularización KL hacia el SFT, y la mezcla de pretraining que convierte un chatbot alineado en un asistente que sigue siendo, en buena medida, un language model general.

8 Referencias

Volver arriba ]]> RL LLMs https://luccafrachelle.github.io/porfolio_academia/posts/rlhf-instructgpt.html Fri, 11 Sep 2026 00:00:00 GMT Tokenización con BPE Lucca Frachelle https://luccafrachelle.github.io/porfolio_academia/posts/tokenizacion-bpe.html

Leer en PDF

1 Por qué existe el tokenizador

Un modelo de lenguaje no procesa texto. La primera capa de un Transformer es una tabla de embeddings: una matriz de vocab_size filas por n_embd columnas, donde cada fila es un vector aprendido. Lo que el modelo recibe es una secuencia de enteros que indexan esas filas.

Entonces, entre el texto que escribe una persona y el modelo hace falta una pieza que:

  1. convierta un str arbitrario en una secuencia de enteros de un conjunto finito y fijo (el vocabulario);
  2. pueda hacer el camino inverso sin pérdida, para que el modelo pueda responder en texto;
  3. use pocos enteros por texto, porque la ventana de contexto es finita y el costo computacional de la atención crece con el cuadrado de la longitud de la secuencia.

Esa pieza es el tokenizador. Es un módulo completamente separado del modelo: se entrena aparte, con su propio corpus y su propio algoritmo (nada de descenso por gradiente), y una vez congelado condiciona todo lo que el modelo puede o no puede hacer.

Antes de construir uno, veamos uno real trabajando. tiktoken es la biblioteca de OpenAI con los tokenizadores de sus modelos:

Código 
import tiktoken

enc = tiktoken.get_encoding("o200k_base")  # el tokenizador de GPT-4o

frase = "Los tokenizadores son la parte más subestimada de un LLM."
ids = enc.encode(frase)

print(f"{len(frase)} caracteres  ->  {len(ids)} tokens")
print(ids)
print([enc.decode([i]) for i in ids])
57 caracteres  ->  15 tokens
[16593, 6602, 170058, 2391, 557, 7441, 3932, 1543, 125938, 1194, 334, 537, 451, 19641, 13]
['Los', ' token', 'izadores', ' son', ' la', ' parte', ' más', ' sub', 'estim', 'ada', ' de', ' un', ' L', 'LM', '.']

Fijate en la última línea: los tokens no son palabras ni letras. Son fragmentos, y el espacio viaja pegado al inicio de la palabra que sigue. Eso tiene una consecuencia inmediata:

Código 
for s in ["hola", " hola", "Hola", " Hola", "HOLA"]:
    print(f"{s!r:>8}  ->  {enc.encode(s)}")
  'hola'  ->  [122845]
 ' hola'  ->  [171847]
  'Hola'  ->  [49864]
 ' Hola'  ->  [157464]
  'HOLA'  ->  [39, 87254]

Cinco formas de escribir la misma palabra, cinco secuencias de ids distintas. Para el modelo son entradas diferentes, y tiene que aprender por separado que significan casi lo mismo.

Y comparemos idiomas, con la misma oración:

Código 
oraciones = [
    ("inglés",  "The tokenizer is the most underestimated part of a language model."),
    ("español", "El tokenizador es la parte más subestimada de un modelo de lenguaje."),
]
for idioma, texto in oraciones:
    n = len(enc.encode(texto))
    print(f"{idioma:>8}: {n:>3} tokens para {len(texto):>3} caracteres "
          f"({len(texto)/n:.2f} caracteres por token)")
  inglés:  12 tokens para  66 caracteres (5.50 caracteres por token)
 español:  16 tokens para  68 caracteres (4.25 caracteres por token)

El español entra menos texto en la misma cantidad de tokens. No es un accidente: es consecuencia directa del corpus con el que se entrenó el tokenizador, y lo vamos a ver aparecer una y otra vez.

ImportantePreguntas que este apunte va a responder

Todas estas conductas de los LLMs, que parecen fallas del modelo, son en realidad consecuencias del tokenizador. Volvemos a la lista en la sección 13, cuando tengamos las herramientas para explicarlas:

  • ¿Por qué a un LLM le cuesta deletrear palabras o contar letras?
  • ¿Por qué falla al invertir un string, pero acierta si le pedís que lo haga letra por letra?
  • ¿Por qué se equivoca en aritmética con números largos?
  • ¿Por qué el español (y cualquier idioma que no sea inglés) “cuesta” más caro?
  • ¿Por qué es peor escribiendo Python que JavaScript?
  • ¿Por qué un espacio de más al final del prompt empeora la respuesta?
  • ¿Por qué existen palabras como SolidGoldMagikarp que rompen al modelo?
  • ¿Por qué conviene YAML antes que JSON para datos estructurados?

2 Primer intento: Unicode y code points

La idea más obvia es: usemos los caracteres como vocabulario. En Python, un str es una secuencia de code points Unicode, y ord da el número de cada uno:

Código 
saludo = "안녕하세요 👋 (hola en coreano)"

print(saludo)
print(len(saludo), "code points")
print([ord(c) for c in saludo])
안녕하세요 👋 (hola en coreano)
25 code points
[50504, 45397, 54616, 49464, 50836, 32, 128075, 32, 40, 104, 111, 108, 97, 32, 101, 110, 32, 99, 111, 114, 101, 97, 110, 111, 41]

El camino inverso es chr:

Código 
print(chr(50504), chr(128075), chr(241))
안 👋 ñ

Unicode es un estándar que asigna a cada carácter de (idealmente) todos los sistemas de escritura del mundo un número entero, llamado code point, que se escribe en hexadecimal con el prefijo U+. Cuántos hay:

Código 
import sys
import unicodedata
from collections import Counter


def mil(n):
    """Formatea con punto como separador de miles, como se escribe en español."""
    return f"{n:,}".replace(",", ".")


posibles = sys.maxunicode + 1
categorias = Counter(unicodedata.category(chr(cp)) for cp in range(posibles))

sin_asignar = categorias["Cn"]
privados = categorias["Co"]      # areas de uso privado, sin significado estandarizado
surrogates = categorias["Cs"]    # reservados para la mecánica de UTF-16
caracteres = posibles - sin_asignar - privados - surrogates

print(f"code points posibles:            {mil(posibles):>9}")
print(f"  sin asignar:                   {mil(sin_asignar):>9}")
print(f"  de uso privado:                {mil(privados):>9}")
print(f"  surrogates (UTF-16):           {mil(surrogates):>9}")
print(f"  caracteres de verdad:          {mil(caracteres):>9}")
code points posibles:            1.114.112
  sin asignar:                     824.718
  de uso privado:                  137.468
  surrogates (UTF-16):               2.048
  caracteres de verdad:            149.878

Y acá se cae el primer intento, por dos razones:

  • El vocabulario sería enorme. Casi 150.000 filas en la tabla de embeddings, y la enorme mayoría corresponden a caracteres que casi nunca aparecen en el corpus. Son parámetros que ocupan memoria y no se entrenan nunca.
  • El vocabulario sería inestable. Unicode publica una versión nueva cada año, con caracteres y emoji nuevos. El vocabulario de un modelo tiene que ser un artefacto fijo, no algo que cambia con la versión del estándar.

Hay un tercer problema, más de fondo: usar caracteres como tokens deja las secuencias muy largas. Un texto de 5.000 caracteres son 5.000 tokens, y la ventana de contexto se llena con muy poco.

3 Segundo intento: UTF-8 y bytes

Un code point es un número abstracto. Para guardarlo en un archivo o mandarlo por la red hay que codificarlo en bytes, y para eso existen UTF-8, UTF-16 y UTF-32.

Código 
print(list(saludo.encode("utf-8")))
print(len(saludo.encode("utf-8")), "bytes para", len(saludo), "code points")
[236, 149, 136, 235, 133, 149, 237, 149, 152, 236, 132, 184, 236, 154, 148, 32, 240, 159, 145, 139, 32, 40, 104, 111, 108, 97, 32, 101, 110, 32, 99, 111, 114, 101, 97, 110, 111, 41]
38 bytes para 25 code points

UTF-8 usa 1 a 4 bytes por code point, según el tamaño del número, con un sistema de prefijos binarios:

Bytes UTF-8 (binario) Bits del code point Rango
0xxxxxxx xxxxxxx U+0000 – U+007F
110xxxxx 10yyyyyy xxxxxyyyyyy U+0080 – U+07FF
1110xxxx 10yyyyyy 10zzzzzz xxxxyyyyyyzzzzzz U+0800 – U+FFFF
11110xxx 10yyyyyy 10zzzzzz 10wwwwww xxxyyyyyyzzzzzzwwwwww U+10000 – U+10FFFF

Los bits en negrita del principio de cada byte dicen qué papel cumple: 0 significa “byte ASCII suelto”, 110/1110/11110 significan “acá empieza una secuencia de 2, 3 o 4 bytes”, y 10 significa “soy continuación del byte anterior”. Se ve mejor en binario:

Código 
def mostrar_utf8(caracter):
    bs = caracter.encode("utf-8")
    print(f"{caracter!r}  U+{ord(caracter):04X}  ->  {len(bs)} byte(s)")
    for b in bs:
        print(f"       {b:>3}   0b{b:08b}")

for c in ["a", "ñ", "あ", "👋"]:
    mostrar_utf8(c)
'a'  U+0061  ->  1 byte(s)
        97   0b01100001
'ñ'  U+00F1  ->  2 byte(s)
       195   0b11000011
       177   0b10110001
'あ'  U+3042  ->  3 byte(s)
       227   0b11100011
       129   0b10000001
       130   0b10000010
'👋'  U+1F44B  ->  4 byte(s)
       240   0b11110000
       159   0b10011111
       145   0b10010001
       139   0b10001011

Ese diseño explica por qué UTF-8 ganó, y por qué es la elección natural para un tokenizador:

  • Es retrocompatible con ASCII. Los primeros 128 code points se codifican en un byte, con el mismo valor que en ASCII. Un archivo ASCII ya es un archivo UTF-8 válido.
  • Ningún byte de una secuencia multi-byte cae en el rango ASCII (todos son ≥ 128). Así que buscar un \n, una coma o un byte nulo byte a byte nunca da un falso positivo dentro de un carácter. Todo el software que ya trataba strings como bytes sigue funcionando.
  • Es auto-sincronizante. Mirando un byte cualquiera sabés si es un comienzo o una continuación, así que podés retroceder hasta el límite del carácter sin leer desde el inicio.

UTF-32, en cambio, gasta 4 bytes siempre (mucho desperdicio para texto en inglés), y UTF-16 gasta 2 como mínimo, introduce bytes nulos que rompen las convenciones de C y necesita el mecanismo de surrogate pairs para los code points altos.

TipPor qué esto importa para el tokenizador

Si trabajamos sobre bytes, el vocabulario base tiene exactamente 256 entradas, un número chico y fijo para siempre. Y nunca existe el token “desconocido”: cualquier texto en cualquier idioma, presente o futuro, se puede representar, porque cualquier texto es una secuencia de bytes.

Carguemos los dos corpus con los que vamos a trabajar todo el apunte:

Código 
from pathlib import Path

_datos = Path("datos")
if not (_datos / "unicode_article.txt").exists():
    _datos = Path("posts/datos")

texto_en = (_datos / "unicode_article.txt").read_text(encoding="utf-8")
texto_es = (_datos / "texto_es.txt").read_text(encoding="utf-8")

for nombre, t in [("inglés", texto_en), ("español", texto_es)]:
    bs = t.encode("utf-8")
    print(f"{nombre:>8}: {len(t):>6} caracteres   {len(bs):>6} bytes   "
          f"{len(bs)/len(t):.3f} bytes por carácter")
  inglés:  23328 caracteres    24597 bytes   1.054 bytes por carácter
 español:  23717 caracteres    24266 bytes   1.023 bytes por carácter

Los dos archivos tienen casi los mismos bytes a propósito, para que las comparaciones que vengan después sean de igual a igual. Que el texto en inglés tenga más bytes por carácter que el español puede sorprender, pero tiene explicación: el corpus en inglés es un artículo sobre Unicode y está lleno de emoji, banderas y texto Zalgo, que gastan 3 y 4 bytes por carácter. El “impuesto” que paga el español no aparece a nivel de bytes, sino más adelante, a nivel de tokens.

Y acá está el problema del segundo intento:

Código 
ids_en = list(texto_en.encode("utf-8"))

print(f"{len(texto_en)} caracteres  ->  {len(ids_en)} tokens (bytes)")
print(ids_en[:40], "...")
23328 caracteres  ->  24597 tokens (bytes)
[65, 32, 80, 114, 111, 103, 114, 97, 109, 109, 101, 114, 226, 128, 153, 115, 32, 73, 110, 116, 114, 111, 100, 117, 99, 116, 105, 111, 110, 32, 116, 111, 32, 85, 110, 105, 99, 111, 100, 101] ...

Vocabulario chiquito y sin excepciones, pero secuencias larguísimas: un token por byte. Con una ventana de 1.000 tokens no entra ni media página. Necesitamos comprimir, sin perder la propiedad de que todo se puede representar.

4 Byte Pair Encoding

La solución es un algoritmo de compresión viejo, de 1994, que Sennrich, Haddow y Birch trajeron a NLP en 2016. La idea, en una línea:

Buscar el par de símbolos consecutivos más frecuente, reemplazarlo por un símbolo nuevo, y repetir.

Cada repetición agrega una entrada al vocabulario y acorta la secuencia. Con 256 símbolos iniciales (los bytes) y unos miles de repeticiones se llega a un vocabulario que representa palabras enteras frecuentes con un solo token, y palabras raras con varios.

4.1 Paso 1: contar pares

Código 
def get_stats(ids, counts=None):
    """Cuenta cuántas veces aparece cada par de ids consecutivos.

    El argumento `counts` permite acumular sobre un diccionario existente, que nos va a
    hacer falta en la sección 8 para contar sobre varios trozos de texto.
    """
    counts = {} if counts is None else counts
    for par in zip(ids, ids[1:]):
        counts[par] = counts.get(par, 0) + 1
    return counts


stats = get_stats(ids_en)
print(len(stats), "pares distintos\n")

for (a, b), n in sorted(stats.items(), key=lambda kv: -kv[1])[:8]:
    texto = bytes([a, b]).decode("utf-8", errors="replace")
    print(f"({a:>3}, {b:>3}) = {texto!r:>6}   {n:>4} veces")
1381 pares distintos

(101,  32) =   'e '    646 veces
(105, 110) =   'in'    446 veces
(115,  32) =   's '    424 veces
( 32, 116) =   ' t'    405 veces
( 32,  97) =   ' a'    377 veces
(116, 104) =   'th'    337 veces
(101, 114) =   'er'    294 veces
( 99, 111) =   'co'    290 veces

zip(ids, ids[1:]) es el truco de siempre para recorrer pares consecutivos: ids[1:] es la misma lista corrida un lugar, así que zip los va emparejando.

El par más frecuente es (101, 32), que en ASCII es 'e' seguido de un espacio. Tiene sentido en un texto en inglés: es el final de the, more, code, are.

4.2 Paso 2: fusionar

Código 
def merge(ids, par, nuevo_id):
    """Reemplaza toda aparición consecutiva de `par` en `ids` por `nuevo_id`."""
    salida = []
    i = 0
    while i < len(ids):
        if i < len(ids) - 1 and ids[i] == par[0] and ids[i + 1] == par[1]:
            salida.append(nuevo_id)
            i += 2          # consumimos los dos ids del par
        else:
            salida.append(ids[i])
            i += 1
    return salida


print(merge([5, 6, 6, 7, 9, 1], (6, 7), 99))
[5, 6, 99, 9, 1]

La condición i < len(ids) - 1 evita mirar ids[i + 1] en la última posición. El recorrido es greedy de izquierda a derecha, lo que importa cuando el par se solapa consigo mismo:

Código 
print(merge([6, 6, 6], (6, 6), 99))
[99, 6]

Hay dos ocurrencias de (6, 6) en [6, 6, 6] pero se puede fusionar solo una: la de la izquierda gana. No es un problema, es simplemente la convención, y lo importante es que encode y decode usen la misma.

4.3 Paso 3: repetir

Ahora el bucle de entrenamiento. Un parámetro: vocab_size, el tamaño final del vocabulario. Como arrancamos con 256 bytes, la cantidad de fusiones es vocab_size - 256:

Código 
def entrenar_bpe(ids, vocab_size, verbose=False):
    """Entrena BPE sobre una lista de ids y devuelve (ids comprimidos, merges, vocab).

    `merges` mapea (id, id) -> id nuevo, en el orden en que se aprendieron.
    `vocab`  mapea id -> los bytes que representa.
    """
    assert vocab_size >= 256, "el vocabulario arranca en los 256 bytes"

    merges = {}
    vocab = {i: bytes([i]) for i in range(256)}
    ids = list(ids)                              # copia: no destruimos la entrada

    for i in range(vocab_size - 256):
        stats = get_stats(ids)
        if not stats:                            # quedó un solo id: no hay más pares
            break
        par = max(stats, key=stats.get)          # el par más frecuente
        nuevo_id = 256 + i                       # los ids nuevos arrancan después de los bytes
        ids = merge(ids, par, nuevo_id)
        merges[par] = nuevo_id
        vocab[nuevo_id] = vocab[par[0]] + vocab[par[1]]

        if verbose:
            legible = vocab[nuevo_id].decode("utf-8", errors="replace")
            print(f"{i + 1:>3}. {str(par):>12} -> {nuevo_id}   {legible!r:>8}   "
                  f"({stats[par]} apariciones)")

    return ids, merges, vocab


ids_bpe, merges, vocab = entrenar_bpe(ids_en, vocab_size=276, verbose=True)
  1.    (101, 32) -> 256       'e '   (646 apariciones)
  2.   (105, 110) -> 257       'in'   (446 apariciones)
  3.    (115, 32) -> 258       's '   (424 apariciones)
  4.   (116, 104) -> 259       'th'   (337 apariciones)
  5.   (101, 114) -> 260       'er'   (294 apariciones)
  6.    (99, 111) -> 261       'co'   (290 apariciones)
  7.    (116, 32) -> 262       't '   (285 apariciones)
  8.   (226, 128) -> 263        '�'   (254 apariciones)
  9.     (44, 32) -> 264       ', '   (243 apariciones)
 10.    (97, 110) -> 265       'an'   (229 apariciones)
 11.   (111, 114) -> 266       'or'   (214 apariciones)
 12.    (100, 32) -> 267       'd '   (213 apariciones)
 13.    (97, 114) -> 268       'ar'   (181 apariciones)
 14.   (101, 110) -> 269       'en'   (174 apariciones)
 15.   (257, 103) -> 270      'ing'   (166 apariciones)
 16.   (261, 100) -> 271      'cod'   (165 apariciones)
 17.    (121, 32) -> 272       'y '   (154 apariciones)
 18.     (46, 32) -> 273       '. '   (154 apariciones)
 19.    (97, 108) -> 274       'al'   (146 apariciones)
 20.   (259, 256) -> 275     'the '   (144 apariciones)

Vale la pena leer esa lista despacio, porque muestra el algoritmo pensando:

  • Las primeras fusiones son las de la sección 4.1: 'e ', 'in', 's ', 'th'.
  • La fusión 8, (226, 128), no es texto legible: son los dos primeros bytes de la secuencia UTF-8 de las comillas tipográficas “ ” ’, muy frecuentes en el artículo. BPE no sabe nada de caracteres; encuentra la regularidad igual.
  • La fusión 15 es (257, 103): el token 257 ('in') más 'g', o sea 'ing'. Fusiona un token aprendido con otro. Es la primera vez que el algoritmo construye sobre sí mismo, y es la razón de que con pocos miles de fusiones se llegue a palabras enteras.
  • La última, (259, 256), junta 'th' con 'e ': el token 'the ', palabra y espacio en un solo id.

Los ids nuevos arrancan en 256 porque los primeros 256 ya están tomados por los bytes. Y el vocabulario final es un árbol: cada token nuevo se define en términos de dos anteriores, hasta llegar a las hojas, que son bytes.

¿Cuánto comprimimos?

Código 
print(f"antes:    {len(ids_en):>6} tokens")
print(f"después:  {len(ids_bpe):>6} tokens")
print(f"ratio:    {len(ids_en) / len(ids_bpe):>6.2f}X")
antes:     24597 tokens
después:   19438 tokens
ratio:      1.27X

Un 1,27X con apenas 20 fusiones. La curva sigue subiendo con vocab_size, y la vamos a medir en la sección 12.

AdvertenciaEl corpus del tokenizador decide todo

merges sale de contar pares en un texto concreto. Entrenado en este artículo en inglés, el tokenizador va a ser eficiente en inglés y malo en español o en código. Los tokenizadores reales se entrenan sobre mezclas cuidadosamente elegidas de idiomas y lenguajes de programación, y esa mezcla —decidida antes de entrenar el modelo, y congelada para siempre— determina qué le va a salir barato y qué caro al LLM.

5 Decodificar: de ids a texto

Tenemos merges, que es lo que se aprende. Para decodificar hace falta vocab: qué bytes representa cada id. Se construye recorriendo merges:

Código 
def construir_vocab(merges):
    vocab = {i: bytes([i]) for i in range(256)}
    for (p0, p1), idx in merges.items():
        vocab[idx] = vocab[p0] + vocab[p1]
    return vocab


vocab = construir_vocab(merges)

for idx in [256, 270, 275]:
    print(f"{idx}: {vocab[idx]}")
256: b'e '
270: b'ing'
275: b'the '

Ese for depende de un detalle importante de Python: los diccionarios preservan el orden de inserción. El token 275 se define como vocab[259] + vocab[256], así que 259 y 256 ya tienen que estar en el diccionario cuando llegamos a él. Como merges se llenó en orden creciente de id, el recorrido funciona. Si iteráramos en otro orden, tendríamos un KeyError.

Con vocab, decodificar es concatenar bytes y decodificar UTF-8:

Código 
def decode(ids, vocab):
    bs = b"".join(vocab[i] for i in ids)
    return bs.decode("utf-8", errors="replace")


print(decode([275, 271, 270], vocab))       # 'the ' + 'cod' + 'ing'
the coding

5.1 Por qué errors="replace" no es opcional

Un detalle fácil de pasar por alto: no toda secuencia de ids corresponde a texto UTF-8 válido. El id 128 es el byte 0b10000000, que según la tabla de la sección 3 es un byte de continuación. Suelto, sin un byte de comienzo antes, es inválido:

Código 
try:
    bytes([128]).decode("utf-8")
except UnicodeDecodeError as error:
    print("UnicodeDecodeError:", error)
UnicodeDecodeError: 'utf-8' codec can't decode byte 0x80 in position 0: invalid start byte

Un tokenizador tiene que ser una función total: si el modelo genera el id 128, decode no puede explotar. Por eso errors="replace", que sustituye los bytes inválidos por el carácter de reemplazo U+FFFD:

Código 
print(repr(decode([128], vocab)))
'�'

Esto no es un caso hipotético. El LLM genera un token por vez, y si le pedís un emoji va a emitir varios tokens que juntos forman una secuencia UTF-8 de 4 bytes. Mientras la genera, los prefijos son inválidos. Por eso al usar un LLM en modo streaming a veces aparece un � que después se convierte en el carácter correcto: es exactamente este mecanismo.

6 Codificar: de texto a ids

Nos falta la dirección que más se usa. Podría parecer que basta con buscar en vocab los bytes más largos que coincidan, pero no: hay que reproducir exactamente el mismo proceso del entrenamiento, aplicando las fusiones en el orden en que se aprendieron.

Código 
def encode(texto, merges):
    ids = list(texto.encode("utf-8"))

    while len(ids) >= 2:
        stats = get_stats(ids)
        # De todos los pares presentes, el que se aprendió PRIMERO (menor id nuevo).
        # Los pares que no están en `merges` reciben infinito, así nunca ganan.
        par = min(stats, key=lambda p: merges.get(p, float("inf")))
        if par not in merges:
            break                              # no queda nada por fusionar
        ids = merge(ids, par, merges[par])

    return ids


print(encode("the code", merges))
[275, 271, 101]

Hay tres decisiones ahí que merecen explicación.

Por qué min y no max. En el entrenamiento usamos max sobre frecuencias. Acá usamos min sobre ids nuevos, que funcionan como un ranking: el id 256 fue la primera fusión aprendida, el 275 la última. Y hay que aplicarlas en ese orden porque las fusiones tardías se definen sobre las tempranas. El token 275 ('the ') es la fusión de 259 ('th') con 256 ('e '). Si fusionáramos primero por otro criterio, podríamos llegar a un estado donde el par (259, 256) nunca aparece, y produciríamos una tokenización que el entrenamiento nunca genera. Codificar es replay del entrenamiento, no búsqueda del mejor recubrimiento.

Por qué el break. min siempre devuelve algo, incluso si ningún par está en merges: en ese caso devuelve un par cualquiera con valor infinito. Sin el chequeo par not in merges, la línea siguiente daría KeyError, o peor, el bucle no terminaría nunca.

Por qué while len(ids) >= 2. Con menos de dos ids no hay pares, y min sobre un diccionario vacío levanta ValueError. Es el caso del string vacío y del carácter único:

Código 
print(encode("", merges), encode("a", merges))
[] [97]

6.1 Verificar que cierra

La propiedad que tiene que valer es que decodificar lo codificado devuelva el texto original:

Código 
print(decode(encode("hola mundo", merges), vocab) == "hola mundo")
print(decode(encode(texto_en, merges), vocab) == texto_en)
True
True

Y sobre texto que el tokenizador nunca vio al entrenar, que es el caso real:

Código 
validacion = (
    "Muchos caracteres comunes, incluidos los numerales y la puntuación, no se tratan "
    "como específicos de ningún sistema de escritura en particular. 안녕하세요 👋"
)
print(decode(encode(validacion, merges), vocab) == validacion)
True

Funciona con cualquier texto, y eso es consecuencia directa de trabajar sobre bytes: no hay caracteres fuera del alcance, así que no hace falta un token UNK.

NotaLa vuelta no vale al revés

decode(encode(t)) == t siempre. Pero encode(decode(ids)) == ids no: hay secuencias de ids que decodifican bien y que encode nunca produciría, porque no están en forma canónica.

Código 
ids_raros = [259, 256]                       # 'th' + 'e ', sin fusionar
texto_raro = decode(ids_raros, vocab)
print(f"{ids_raros} -> {texto_raro!r} -> {encode(texto_raro, merges)}")
[259, 256] -> 'the ' -> [275]

Los dos representan 'the ', pero solo el segundo es lo que sale del entrenamiento. El modelo solo vio la forma canónica, así que si le pasás la otra estás mandando una entrada que no aparece nunca en sus datos de entrenamiento.

7 El truco del regex: pre-tokenización

Ya tenemos un tokenizador BPE completo y funcionando. El problema es que si lo dejamos correr con un vocabulario grande, empieza a aprender tokens que no queremos. Entrenemos con 512 y busquemos los casos raros:

Código 
ids_512, merges_512, vocab_512 = entrenar_bpe(ids_en, vocab_size=512)


def mezcla_categorias(s):
    """¿Este token junta cosas de distinta naturaleza (letras, símbolos, espacios)?"""
    tiene_letra = any(c.isalpha() for c in s)
    tiene_simbolo = any(not c.isalpha() and not c.isspace() for c in s)
    espacio_interno = " " in s.strip()
    return (tiene_letra and tiene_simbolo) or espacio_interno


sospechosos = [
    (idx, vocab_512[idx].decode("utf-8", errors="replace"))
    for idx in range(256, 512)
]
sospechosos = [(idx, s) for idx, s in sospechosos if mezcla_categorias(s)]

print(f"{len(sospechosos)} de 256 tokens aprendidos mezclan categorías:\n")
print(", ".join(repr(s) for _, s in sospechosos[:24]))
26 de 256 tokens aprendidos mezclan categorías:

'code poin', 's, ', 'UTF-', 'U+', 'e, ', '’s ', 'code points ', 'es, ', '. Th', 'UTF-8', 'code point', '. I', '’t ', 'in the ', 'UTF-8 ', 'y, ', 's. ', 'UTF-16', '-b', 'as a ', ' U+', 'ing m', 'code point ', '-bit '

Mirá esos tokens. Cosas como 'e. ', ', ', 's, ', 'ing ': el algoritmo se comió la puntuación junto con las letras. Con un vocabulario de decenas de miles esto explota, y trae tres problemas concretos:

  • Duplicación del vocabulario. Van a existir tokens separados para 'dog', 'dog.', 'dog!', 'dog?', ' dog', ' Dog'. Cada uno es una fila distinta de la tabla de embeddings, y el modelo tiene que aprender en cada una, por separado, que se trata de un perro.
  • Se desperdicia capacidad. Cada token gastado en una variante de puntuación es un token que no se usó para algo útil, como un término técnico o una palabra en otro idioma.
  • Se destruye la estructura del código. En Python la indentación es sintaxis. Si BPE puede fusionar espacios libremente, cuatro espacios seguidos, ocho, doce y dieciséis terminan siendo tokens distintos, y los niveles de anidación se representan de formas incompatibles entre sí.

7.1 La solución de GPT-2: partir antes de contar

La solución que usa OpenAI desde GPT-2 es no correr BPE sobre el texto entero, sino:

  1. partir el texto en trozos con una expresión regular;
  2. correr BPE dentro de cada trozo por separado;
  3. concatenar los resultados.

La clave es el paso 2: si las estadísticas de pares nunca cruzan el límite entre trozos, entonces ningún token puede contener partes de dos trozos distintos. Es una restricción dura, impuesta a mano por el diseñador del tokenizador, no algo que el algoritmo aprenda.

Este es el patrón de GPT-2, tal como está en su código publicado:

Código 
import regex as re

GPT2_SPLIT_PATTERN = (
    r"""'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+"""
)

print(re.findall(GPT2_SPLIT_PATTERN, "Hola mundo, ¿cómo andás? Son 42 grados."))
['Hola', ' mundo', ',', ' ¿', 'cómo', ' andás', '?', ' Son', ' 42', ' grados', '.']

Primero, dos detalles de implementación:

  • Se importa regex, no el módulo re de la biblioteca estándar. regex es una extensión compatible que agrega, entre otras cosas, las clases Unicode \p{...}. Se importa como re por costumbre, lo que confunde bastante al leer el código original.
  • \p{L} significa “cualquier carácter que Unicode clasifique como letra”, en cualquier idioma: a, ñ, é, 안, α. Y \p{N} es “cualquier dígito”. Con [a-zA-Z] habría que enumerar los alfabetos del mundo a mano.

El patrón es una cadena de alternativas separadas por |. findall recorre el texto de izquierda a derecha y en cada posición prueba las alternativas en orden, quedándose con la primera que coincide:

Alternativa Qué captura Ejemplo
's, 't, 're, 've, 'm, 'll, 'd contracciones del inglés it's → it, 's
?\p{L}+ una o más letras, con un espacio opcional adelante hola mundo → hola, mundo
?\p{N}+ uno o más dígitos, con espacio opcional son 42 → son, 42
?[^\s\p{L}\p{N}]+ símbolos: todo lo que no sea espacio, letra ni dígito !!! , (
\s+(?!\S) espacios en blanco que no son seguidos por texto ver abajo
\s+ cualquier resto de espacios fin de string

La alternativa clave, y la más difícil de leer, es \s+(?!\S). (?!\S) es un negative lookahead: “siempre que lo que sigue no sea un carácter distinto de espacio”. Combinado con la codicia de \s+, el efecto es “tomá una corrida de espacios, pero dejá el último para la palabra que viene”:

Código 
for s in ["hola    mundo", "hola    ", "renglón\n\nsiguiente"]:
    print(f"{s!r:>22}  ->  {re.findall(GPT2_SPLIT_PATTERN, s)}")
       'hola    mundo'  ->  ['hola', '   ', ' mundo']
            'hola    '  ->  ['hola', '    ']
'renglón\n\nsiguiente'  ->  ['renglón', '\n', '\n', 'siguiente']

En el primer caso, los cuatro espacios se parten en ' ' (tres) más ' mundo'. Ese último espacio se va con la palabra porque, como vimos en la sección 1, la convención es que el espacio viaja pegado al inicio de la palabra siguiente. En el segundo caso no hay palabra que siga, así que los cuatro espacios quedan juntos.

Por qué existe esa convención: ' mundo' y 'mundo' no son el mismo token, pero como casi siempre una palabra viene después de un espacio, meter el espacio adentro del token es prácticamente gratis y ahorra un token por palabra. El precio lo pagamos en la sección 13.

7.2 Los agujeros del patrón de GPT-2

El propio código de GPT-2 tiene un comentario admitiendo el primero: las contracciones están escritas en minúscula y sin IGNORECASE.

Código 
for s in ["it's", "IT'S", "It'S"]:
    print(f"{s!r:>8}  ->  {re.findall(GPT2_SPLIT_PATTERN, s)}")
  "it's"  ->  ['it', "'s"]
  "IT'S"  ->  ['IT', "'", 'S']
  "It'S"  ->  ['It', "'", 'S']

En IT'S, el 'S no coincide con la alternativa de contracciones (que espera 's en minúscula), así que cae en la rama de símbolos y se parte distinto que la versión en minúscula. El modelo ve dos estructuras diferentes para la misma contracción.

El segundo agujero son los números: ?\p{N}+ no tiene límite de largo, así que un número de diez dígitos es un solo trozo y BPE puede aprender tokens con cualquier cantidad de dígitos adentro.

Código 
print(re.findall(GPT2_SPLIT_PATTERN, "el resultado fue 1234567890 exactamente"))
['el', ' resultado', ' fue', ' 1234567890', ' exactamente']

7.3 El patrón de GPT-4

GPT-4 (el encoding cl100k_base) corrige eso:

Código 
GPT4_SPLIT_PATTERN = (
    r"""'(?i:[sdmt]|ll|ve|re)|[^\r\n\p{L}\p{N}]?+\p{L}+|\p{N}{1,3}"""
    r"""| ?[^\s\p{L}\p{N}]++[\r\n]*|\s*[\r\n]|\s+(?!\S)|\s+"""
)

pruebas = [
    "IT'S",
    "el resultado fue 1234567890 exactamente",
    "¿cómo andás?",
    "hola    mundo",
    "def f():\n    return 1\n",
]

for s in pruebas:
    print(f"{s!r}")
    print(f"   GPT-2: {re.findall(GPT2_SPLIT_PATTERN, s)}")
    print(f"   GPT-4: {re.findall(GPT4_SPLIT_PATTERN, s)}\n")
"IT'S"
   GPT-2: ['IT', "'", 'S']
   GPT-4: ['IT', "'S"]

'el resultado fue 1234567890 exactamente'
   GPT-2: ['el', ' resultado', ' fue', ' 1234567890', ' exactamente']
   GPT-4: ['el', ' resultado', ' fue', ' ', '123', '456', '789', '0', ' exactamente']

'¿cómo andás?'
   GPT-2: ['¿', 'cómo', ' andás', '?']
   GPT-4: ['¿cómo', ' andás', '?']

'hola    mundo'
   GPT-2: ['hola', '   ', ' mundo']
   GPT-4: ['hola', '   ', ' mundo']

'def f():\n    return 1\n'
   GPT-2: ['def', ' f', '():', '\n   ', ' return', ' 1', '\n']
   GPT-4: ['def', ' f', '():\n', '   ', ' return', ' ', '1', '\n']

Los cuatro cambios, en orden de aparición:

  • '(?i:[sdmt]|ll|ve|re) — el (?i:...) hace la comparación insensible a mayúsculas solo en ese grupo. IT'S ahora se parte igual que it's.
  • [^\r\n\p{L}\p{N}]?+\p{L}+ — en lugar de “espacio opcional más letras”, ahora es “cualquier carácter que no sea salto de línea, letra ni dígito, opcional, más letras”. Así ¿cómo queda en un solo trozo, y también (hola o "palabra. El ?+ es possessive: una vez que consumió el carácter, no lo devuelve por backtracking.
  • \p{N}{1,3} — los números se parten en grupos de a lo sumo tres dígitos, y sin espacio adelante (fijate que ' 1' pasa a ser ' ' y '1'). Es la razón por la que 1234567890 se convierte en 123, 456, 789, 0, y tiene todo que ver con la aritmética de los LLMs (sección 13).
  • \s*[\r\n] — los saltos de línea se tratan aparte. Fijate en la última prueba: GPT-2 mete el salto de línea junto con la indentación que le sigue en un mismo trozo ('\n '), mientras GPT-4 lo pega a la puntuación anterior ('():\n') y deja la indentación como trozo propio (' ', ' return'). En GPT-2, cada nivel de anidación produce un trozo distinto que combina salto de línea con espacios; en GPT-4, la indentación se agrupa aparte y de forma consistente. Esa diferencia, sola, explica buena parte de por qué GPT-4 escribe Python bastante mejor que GPT-2.
NotaQué implica para el español

El patrón está diseñado alrededor del inglés. Las contracciones ('s, 'll, 've) no existen en español, así que esas alternativas son peso muerto; y ningún patrón contempla que en español los signos de apertura ¿ y ¡ abren, ni que las palabras llevan tilde. GPT-4 al menos logra pegar ¿ a la palabra que sigue gracias a [^\r\n\p{L}\p{N}]?+, algo que GPT-2 no hacía.

Pero el gasto real no está en el regex sino en el corpus de entrenamiento del tokenizador, que es mayoritariamente inglés: las palabras en español simplemente no aparecen lo suficiente como para ganarse un token propio, y quedan partidas en pedazos. Lo medimos en la sección 9.

8 Todo junto: RegexTokenizer

Ya tenemos todas las piezas. Falta empaquetarlas en algo reutilizable que aplique el regex antes de entrenar y antes de codificar:

Código 
class RegexTokenizer:
    """Tokenizador BPE con pre-tokenización por expresión regular."""

    def __init__(self, pattern=None):
        self.pattern = pattern or GPT4_SPLIT_PATTERN
        self._re = re.compile(self.pattern)
        self.merges = {}                                # (id, id) -> id nuevo
        self.vocab = {i: bytes([i]) for i in range(256)}  # id -> bytes

    def train(self, texto, vocab_size, verbose=False):
        # Un trozo por coincidencia del regex; BPE nunca cruza estos límites.
        trozos = [list(t.encode("utf-8")) for t in self._re.findall(texto)]

        for i in range(vocab_size - 256):
            # Contamos pares en todos los trozos, acumulando en el mismo diccionario.
            stats = {}
            for trozo in trozos:
                get_stats(trozo, stats)
            if not stats:
                break

            par = max(stats, key=stats.get)
            nuevo_id = 256 + i
            trozos = [merge(t, par, nuevo_id) for t in trozos]
            self.merges[par] = nuevo_id
            self.vocab[nuevo_id] = self.vocab[par[0]] + self.vocab[par[1]]

            if verbose:
                legible = self.vocab[nuevo_id].decode("utf-8", errors="replace")
                print(f"{nuevo_id}: {legible!r} ({stats[par]} apariciones)")

    def _encode_bytes(self, bs):
        """BPE sobre los bytes de un solo trozo. Es el `encode` de la sección 6."""
        ids = list(bs)
        while len(ids) >= 2:
            stats = get_stats(ids)
            par = min(stats, key=lambda p: self.merges.get(p, float("inf")))
            if par not in self.merges:
                break
            ids = merge(ids, par, self.merges[par])
        return ids

    def encode(self, texto):
        ids = []
        for trozo in self._re.findall(texto):
            ids.extend(self._encode_bytes(trozo.encode("utf-8")))
        return ids

    def decode(self, ids):
        bs = b"".join(self.vocab[i] for i in ids)
        return bs.decode("utf-8", errors="replace")

Dos cosas a notar. En train, el diccionario stats se comparte entre todos los trozos: por eso get_stats recibía ese segundo argumento opcional. Y en encode, el bucle de fusiones corre por trozo, no sobre el texto completo, que es la mitad de codificación que le corresponde a la restricción impuesta en el entrenamiento.

Entrenemos las dos variantes de patrón y comparémoslas contra la versión sin regex, todas con el mismo vocabulario de 512:

Código 
tok_gpt2 = RegexTokenizer(GPT2_SPLIT_PATTERN)
tok_gpt2.train(texto_en, vocab_size=512)

tok = RegexTokenizer(GPT4_SPLIT_PATTERN)
tok.train(texto_en, vocab_size=512)


def tokens_mezclados(vocab):
    return [
        vocab[idx].decode("utf-8", errors="replace")
        for idx in range(256, 512)
        if mezcla_categorias(vocab[idx].decode("utf-8", errors="replace"))
    ]


bytes_totales = len(ids_en)
variantes = [
    ("sin regex", len(ids_512), tokens_mezclados(vocab_512)),
    ("regex GPT-2", len(tok_gpt2.encode(texto_en)), tokens_mezclados(tok_gpt2.vocab)),
    ("regex GPT-4", len(tok.encode(texto_en)), tokens_mezclados(tok.vocab)),
]

print(f"bytes originales: {bytes_totales}\n")
for nombre, n_tokens, mezclados in variantes:
    print(f"{nombre:>12}: {n_tokens:>6} tokens  ({bytes_totales / n_tokens:.2f}X)  "
          f"{len(mezclados):>2} tokens que mezclan categorías")
bytes originales: 24597

   sin regex:  11442 tokens  (2.15X)  26 tokens que mezclan categorías
 regex GPT-2:  11699 tokens  (2.10X)   0 tokens que mezclan categorías
 regex GPT-4:  11694 tokens  (2.10X)   4 tokens que mezclan categorías

Dos lecturas de esa tabla.

La compresión baja. Con regex comprimimos menos, y era esperable: le prohibimos al algoritmo justamente las fusiones más rentables, las que cruzan categorías. Es el precio que se paga a cambio de un vocabulario más limpio, y es una decisión de diseño deliberada.

El regex hace lo que promete, con una excepción interesante. Con el patrón de GPT-2 no queda ni un token mezclado. Con el de GPT-4 quedan unos pocos:

Código 
print(tokens_mezclados(tok.vocab))
['’s', '-b', '’t', '-bit']

No es un error: es exactamente la rama [^\r\n\p{L}\p{N}]?+\p{L}+ que agregó GPT-4, la que permite pegar un símbolo delante de una palabra. Es la misma que hace que ¿cómo quede entero, y trae de arrastre el guion de -bit y el apóstrofo tipográfico de ’s. GPT-4 relajó a propósito la restricción de GPT-2 para manejar mejor los idiomas que no son inglés.

Y así se ven los tokens que aprendió el tokenizador con el patrón de GPT-4:

Código 
aprendidos = [tok.vocab[idx].decode("utf-8", errors="replace") for idx in range(256, 512)]
print(", ".join(repr(s) for s in aprendidos[:40]))
print("...")
print(", ".join(repr(s) for s in aprendidos[-20:]))
'in', ' t', ' a', 'er', 'co', ' th', '�', ' s', ' o', 'de', 're', 'it', ' co', ' the', 'ing', 'en', ' p', 'at', 'or', 'an', 'le', ' U', ' in', ' w', 'ar', ' b', 'es', 'ac', ' of', 'on', ' m', 'al', ' f', 'ed', ' c', 'is', 'nd', ' to', 'ts', 'ic'
...
' r', 'ight', 'age', ' do', ' not', 'nder', 'pe', 'quen', ' E', ' j', ' li', 'am', ' characters', ' which', '-bit', '–', ' +', 'composed', '̰', '̳'

Los primeros son bigramas del inglés; los últimos, palabras enteras con su espacio adelante. Se ve el algoritmo escalando de a poco de letras a palabras. Y el viaje redondo sigue valiendo:

Código 
print(tok.decode(tok.encode(texto_en)) == texto_en)
print(tok.decode(tok.encode(validacion)) == validacion)
True
True

9 Comparación contra el tokenizador de verdad

tiktoken trae los tokenizadores reales de los modelos de OpenAI. Son tres generaciones:

Código 
encodings = {
    "gpt2": tiktoken.get_encoding("gpt2"),                 # GPT-2, GPT-3
    "cl100k_base": tiktoken.get_encoding("cl100k_base"),   # GPT-3.5, GPT-4
    "o200k_base": tiktoken.get_encoding("o200k_base"),     # GPT-4o y posteriores
}

for nombre, e in encodings.items():
    print(f"{nombre:>12}: vocabulario de {mil(e.n_vocab)} tokens")
        gpt2: vocabulario de 50.257 tokens
 cl100k_base: vocabulario de 100.277 tokens
  o200k_base: vocabulario de 200.019 tokens

Y así rinden sobre nuestros dos corpus, que recordemos tienen prácticamente los mismos bytes:

Código 
print(f"{'encoding':>12} {'inglés':>10} {'español':>10} {'sobrecosto':>12}")
for nombre, e in encodings.items():
    n_en = len(e.encode(texto_en))
    n_es = len(e.encode(texto_es))
    print(f"{nombre:>12} {n_en:>10} {n_es:>10} {100 * (n_es / n_en - 1):>11.0f}%")

print()
print(f"{'nuestro (512)':>12} {len(tok.encode(texto_en)):>10} "
      f"{len(tok.encode(texto_es)):>10}")
    encoding     inglés    español   sobrecosto
        gpt2       7019       9104          30%
 cl100k_base       6564       7380          12%
  o200k_base       6447       6510           1%

nuestro (512)      11694      15583

Ahí está, medido, el impuesto del español: con el tokenizador de GPT-2, el mismo contenido en español consume un 30% más de tokens que en inglés. Eso significa 30% más de costo por API, 30% menos de texto en la ventana de contexto y 30% más de cómputo por la misma información. Con cl100k_base la brecha baja a 12%, y con o200k_base a casi nada: cada generación de tokenizadores mejoró la cobertura multilingüe, agrandando el vocabulario y balanceando mejor el corpus de entrenamiento.

Nota

Nuestro tokenizador de 512 tokens, entrenado sobre 24 KB de inglés, obviamente pierde por mucho. Lo interesante es que la diferencia es de escala, no de algoritmo: cl100k_base es el mismo código que escribimos, con 100.256 fusiones en lugar de 256 y un corpus de entrenamiento gigantesco.

9.1 Los bytes están permutados

Si intentamos leer las fusiones de GPT-4 nos topamos con dos sorpresas. La primera:

Código 
cl = encodings["cl100k_base"]
byte_shuffle = {i: cl._mergeable_ranks[bytes([i])] for i in range(256)}

print("¿el byte i tiene id i?", all(k == v for k, v in byte_shuffle.items()))
print("primeros:", list(byte_shuffle.items())[:6])
print("el espacio (byte 32) tiene id", byte_shuffle[32])
¿el byte i tiene id i? False
primeros: [(0, 188), (1, 189), (2, 190), (3, 191), (4, 192), (5, 193)]
el espacio (byte 32) tiene id 220

Los 256 bytes iniciales no están en el orden obvio: el byte 0 es el id 188, el espacio es el 220. Es una permutación arbitraria, heredada de una decisión de implementación de GPT-2, sin ningún significado. Cualquier implementación que quiera producir los mismos ids que OpenAI tiene que aplicar esta permutación al codificar y la inversa al decodificar.

9.2 Recuperar las fusiones

La segunda sorpresa: tiktoken no guarda merges. Guarda _mergeable_ranks, que mapea bytes → rango, sin decir de qué dos padres salió cada token. Pero se puede reconstruir: para un token cualquiera, sus dos padres son los que resultan de aplicarle BPE usando solo las fusiones anteriores a él.

Código 
def bpe(ranks, token, max_rank):
    """Aplica BPE a `token` usando solo fusiones de rango menor a `max_rank`."""
    partes = [bytes([b]) for b in token]
    while True:
        mejor_i, mejor_rango = None, None
        for i, (a, b) in enumerate(zip(partes, partes[1:])):
            rango = ranks.get(a + b)
            if rango is not None and (mejor_rango is None or rango < mejor_rango):
                mejor_i, mejor_rango = i, rango
        if mejor_rango is None or mejor_rango >= max_rank:
            break
        partes = (partes[:mejor_i]
                  + [partes[mejor_i] + partes[mejor_i + 1]]
                  + partes[mejor_i + 2:])
    return partes


def recuperar_merges(ranks):
    merges = {}
    for token, rango in ranks.items():
        if len(token) == 1:
            continue                      # los bytes sueltos no son fusiones
        p0, p1 = bpe(ranks, token, max_rank=rango)
        merges[(ranks[p0], ranks[p1])] = rango
    return merges


merges_gpt4 = recuperar_merges(cl._mergeable_ranks)
print(f"{mil(len(merges_gpt4))} fusiones recuperadas")
100.000 fusiones recuperadas

Y ahora sí podemos ver las primeras fusiones que aprendió GPT-4, que es una de las cosas más reveladoras de todo el apunte:

Código 
inverso = {rango: token for token, rango in cl._mergeable_ranks.items()}

for (a, b), rango in sorted(merges_gpt4.items(), key=lambda kv: kv[1])[:8]:
    print(f"{rango}:  {inverso[a]!r} + {inverso[b]!r}  =  {inverso[rango]!r}")
256:  b' ' + b' '  =  b'  '
257:  b'  ' + b'  '  =  b'    '
258:  b'i' + b'n'  =  b'in'
259:  b' ' + b't'  =  b' t'
260:  b'    ' + b'    '  =  b'        '
261:  b'e' + b'r'  =  b'er'
262:  b'  ' + b' '  =  b'   '
263:  b'o' + b'n'  =  b'on'

La primera fusión de GPT-4 es dos espacios. La segunda, cuatro espacios. La quinta, ocho. El tokenizador de GPT-4 dedica sus primerísimas fusiones —las más valiosas, las que se aplican antes que todo lo demás— a comprimir corridas de espacios. Es la huella de un corpus con muchísimo código fuente, y la contracara de aquel \s*[\r\n] que agregaron al patrón. Comparado con GPT-2, que gastaba un token por cada espacio de indentación, es una mejora enorme para programar.

10 Tokens especiales

Un tokenizador que solo hace BPE alcanza para representar texto, pero un LLM necesita además marcar estructura: dónde termina un documento, dónde empieza el turno del usuario, dónde va a ir el relleno en un autocompletado. Para eso existen los tokens especiales: ids que no salen de ninguna fusión y que no corresponden a ningún texto.

Código 
for nombre, e in encodings.items():
    print(f"{nombre}:")
    for token, idx in e._special_tokens.items():
        print(f"    {idx}  {token}")
gpt2:
    50256  <|endoftext|>
cl100k_base:
    100257  <|endoftext|>
    100258  <|fim_prefix|>
    100259  <|fim_middle|>
    100260  <|fim_suffix|>
    100276  <|endofprompt|>
o200k_base:
    199999  <|endoftext|>
    200018  <|endofprompt|>

<|endoftext|> es el más importante: es lo que se intercala entre documentos no relacionados al armar el corpus de entrenamiento. Sin él, el modelo aprendería que después de una receta de tortas viene el código fuente de Linux. Es la señal de “borrá el contexto, esto es otra cosa”.

Los <|fim_*|> son de fill in the middle: permiten pedirle al modelo que complete en el medio de un texto dándole el prefijo y el sufijo, que es exactamente lo que hace un autocompletado de código en un editor. Y los modelos de chat agregan más (<|im_start|>, <|im_end|>) para delimitar los turnos de la conversación: el “formato de chat” no es más que texto con tokens especiales adentro.

Dado que no salen de BPE, hay que manejarlos aparte: se busca el token especial en el texto, se lo saca, y a los pedazos que quedan se les aplica BPE normalmente. Agreguemos eso a nuestra clase:

Código 
class TokenizerConEspeciales(RegexTokenizer):

    def __init__(self, pattern=None):
        super().__init__(pattern)
        self.especiales = {}
        self.especiales_inv = {}

    def registrar_especiales(self, especiales):
        """`especiales` es un dict texto -> id. Los ids van por encima del vocabulario."""
        self.especiales = dict(especiales)
        self.especiales_inv = {idx: txt for txt, idx in especiales.items()}

    def encode(self, texto, permitir_especiales=True):
        if not permitir_especiales or not self.especiales:
            return super().encode(texto)

        # Partimos por los tokens especiales, conservándolos (el grupo de captura hace
        # que `split` los devuelva como elementos de la lista).
        patron = "(" + "|".join(re.escape(t) for t in self.especiales) + ")"

        ids = []
        for parte in re.split(patron, texto):
            if parte in self.especiales:
                ids.append(self.especiales[parte])
            elif parte:
                ids.extend(super().encode(parte))
        return ids

    def decode(self, ids):
        piezas = []
        for idx in ids:
            if idx in self.vocab:
                piezas.append(self.vocab[idx])
            elif idx in self.especiales_inv:
                piezas.append(self.especiales_inv[idx].encode("utf-8"))
            else:
                raise ValueError(f"id fuera del vocabulario: {idx}")
        return b"".join(piezas).decode("utf-8", errors="replace")


tok_esp = TokenizerConEspeciales()
tok_esp.merges = tok.merges          # reusamos lo aprendido en la sección 8
tok_esp.vocab = tok.vocab
tok_esp.registrar_especiales({"<|endoftext|>": 512, "<|usuario|>": 513})

mensaje = "<|usuario|>the code<|endoftext|>"
ids = tok_esp.encode(mensaje)

print(ids)
print(tok_esp.decode(ids))
[513, 325, 101, 298, 512]
<|usuario|>the code<|endoftext|>

Comparemos con lo que pasa si no los tratamos como especiales:

Código 
print(tok_esp.encode(mensaje, permitir_especiales=False))
[60, 124, 316, 117, 280, 105, 111, 124, 62, 325, 101, 298, 60, 124, 271, 100, 111, 102, 116, 364, 116, 124, 62]

Sin el tratamiento especial, <|usuario|> se convierte en una docena de tokens comunes: es texto como cualquier otro. Y ahí está el problema de seguridad: si tu aplicación pega la entrada del usuario en un prompt y sí habilita los tokens especiales, un usuario puede escribir literalmente <|im_end|> y cerrar su propio turno, haciéndose pasar por el sistema. Por eso tiktoken obliga a pedirlo explícitamente:

Código 
try:
    cl.encode("<|endoftext|> hola")
except ValueError as error:
    print(str(error)[:180], "...")

print(cl.encode("<|endoftext|> hola", allowed_special="all"))
Encountered text corresponding to disallowed special token '<|endoftext|>'.
If you want this text to be encoded as a special token, pass it to `allowed_special`, e.g. `allowed_spec ...
[100257, 305, 8083]

Por defecto levanta excepción; hay que decir allowed_special a propósito. La regla práctica es tratar el texto del usuario siempre con los especiales deshabilitados, y construir la estructura del prompt vos, desde el código.

11 SentencePiece: lo que usan Llama y Mistral

Fuera de OpenAI, la biblioteca más usada es SentencePiece (Llama, Mistral, Gemma). Hace BPE, igual que nosotros, pero con una diferencia de fondo:

tiktoken codifica el texto a UTF-8 y corre BPE sobre los bytes. SentencePiece corre BPE sobre los code points Unicode, y recién al final decide qué hacer con los caracteres raros.

Ese orden invertido explica toda la lista de opciones raras que hay que configurar:

  • character_coverage (típicamente 0.9995): qué proporción de los caracteres del corpus entran al vocabulario base. Los que quedan afuera son “caracteres raros”, y hay que decidir qué hacer con ellos.
  • byte_fallback: si está en True, los caracteres que quedaron afuera se descomponen en sus bytes UTF-8, que sí están en el vocabulario. Es el parche que hace que SentencePiece se comporte parecido a un tokenizador de bytes. Llama 2 lo usa.
  • unk_id: si byte_fallback está en False, los caracteres raros se mapean todos al token <unk>, y ahí la información se pierde: decode(encode(t)) != t. Nada de eso puede pasar en un tokenizador de bytes.
  • add_dummy_prefix: agrega un espacio al principio de todo texto, para que "hola" y " hola" se tokenicen igual. Es una decisión distinta a la de OpenAI, que prefiere que sean tokens diferentes.
  • La normalización Unicode (NFKC por defecto) puede modificar el texto antes de tokenizar.

También cambia la notación: SentencePiece representa el espacio con el carácter ▁ (U+2581), así que los tokens se ven como ▁hola, ▁mundo.

AdvertenciaEsta celda no se ejecuta

sentencepiece no tiene wheel para Python 3.13 y compilarlo requiere cmake, así que este bloque está marcado para no ejecutarse al renderizar. El código es correcto: si lo corrés en un entorno con la biblioteca instalada (Colab la trae), funciona tal cual.

Código 
import sentencepiece as spm

spm.SentencePieceTrainer.train(
    input="datos/texto_es.txt",
    model_prefix="tok_es",
    model_type="bpe",
    vocab_size=512,
    character_coverage=0.9995,
    byte_fallback=True,        # sin esto, los caracteres raros se pierden en <unk>
    add_dummy_prefix=True,
    normalization_rule_name="identity",   # sin normalización, para no alterar el texto
)

sp = spm.SentencePieceProcessor(model_file="tok_es.model")

print(sp.encode("hola mundo", out_type=str))
# -> ['▁hola', '▁mun', 'do']   (el ▁ es el espacio)
print(sp.encode("안녕하세요", out_type=str))
# con byte_fallback=True se parte en bytes UTF-8: ['<0xEC>', '<0x95>', ...]

El resumen práctico: SentencePiece tiene muchas más perillas, arrastra decisiones históricas y puede perder información. Trabajar sobre bytes desde el principio, como hicimos nosotros, evita todos esos problemas de raíz.

12 Cuánto vocabulario conviene

vocab_size es el único hiperparámetro real del tokenizador, y no se puede elegir mirando una sola cosa. Del lado de las ventajas, más vocabulario comprime más. Midámoslo: entrenemos hasta 2048 registrando cuántos tokens quedan después de cada fusión.

Código 
def curva_compresion(texto, vocab_max, pattern=None):
    """Entrena BPE registrando el largo de la secuencia después de cada fusión."""
    compilado = re.compile(pattern or GPT4_SPLIT_PATTERN)
    trozos = [list(t.encode("utf-8")) for t in compilado.findall(texto)]

    largo = lambda: sum(len(t) for t in trozos)
    curva = [(256, largo())]

    for i in range(vocab_max - 256):
        stats = {}
        for trozo in trozos:
            get_stats(trozo, stats)
        if not stats:
            break
        par = max(stats, key=stats.get)
        trozos = [merge(t, par, 256 + i) for t in trozos]
        curva.append((257 + i, largo()))

    return curva


curva_en = curva_compresion(texto_en, 2048)
curva_es = curva_compresion(texto_es, 2048)

for v, n in curva_en[::384] + [curva_en[-1]]:
    print(f"vocab {v:>5}:  {n:>6} tokens  ({len(ids_en) / n:.2f}X)")
vocab   256:   24597 tokens  (1.00X)
vocab   640:   10382 tokens  (2.37X)
vocab  1024:    8357 tokens  (2.94X)
vocab  1408:    7367 tokens  (3.34X)
vocab  1792:    6662 tokens  (3.69X)
vocab  2048:    6406 tokens  (3.84X)
Código 
import matplotlib.pyplot as plt

fig, ax = plt.subplots(figsize=(7, 4))

for curva, etiqueta, texto_fuente in [
    (curva_en, "inglés", texto_en),
    (curva_es, "español", texto_es),
]:
    bytes_totales = len(texto_fuente.encode("utf-8"))
    vs = [v for v, _ in curva]
    ratios = [bytes_totales / n for _, n in curva]
    ax.plot(vs, ratios, label=etiqueta)

ax.set_xlabel("tamaño del vocabulario")
ax.set_ylabel("compresión (bytes por token)")
ax.legend()
ax.grid(alpha=0.3)
plt.show()
Figura 1: Compresión en función del tamaño del vocabulario, para los dos corpus (24 KB cada uno). Las dos curvas se aplanan: cada fusión nueva rinde menos que la anterior.

La curva se aplana: las primeras fusiones capturan los pares realmente frecuentes y las últimas apenas rascan. Rendimientos decrecientes.

Y hay algo más en ese gráfico que conviene señalar: las dos curvas van prácticamente pegadas. Un tokenizador entrenado en español comprime español igual de bien que uno entrenado en inglés comprime inglés. El idioma no tiene nada de intrínsecamente caro; lo caro es usar un tokenizador entrenado en otro idioma. Es exactamente el sobrecosto que medimos en la sección 9.

Del otro lado del balance hay tres costos.

Cuesta parámetros. La tabla de embeddings tiene vocab_size × n_embd parámetros, y en la salida hace falta otra matriz del mismo tamaño para proyectar a logits:

Código 
n_embd = 768                       # el ancho de GPT-2 small
for v in [1_024, 50_257, 100_277, 200_019]:
    tabla = v * n_embd
    print(f"vocab {mil(v):>9}:  {tabla / 1e6:>5.1f}M parámetros por tabla "
          f"({100 * tabla / 124e6:>4.1f}% de los 124M de GPT-2 small)")
vocab     1.024:    0.8M parámetros por tabla ( 0.6% de los 124M de GPT-2 small)
vocab    50.257:   38.6M parámetros por tabla (31.1% de los 124M de GPT-2 small)
vocab   100.277:   77.0M parámetros por tabla (62.1% de los 124M de GPT-2 small)
vocab   200.019:  153.6M parámetros por tabla (123.9% de los 124M de GPT-2 small)

GPT-2 small tiene 124M parámetros en total, y con su vocabulario de 50.257 tokens son 38,6M —casi un tercio del modelo— los que se van en la tabla de embeddings. GPT-2 comparte esa matriz con la proyección de salida (weight tying), así que la paga una sola vez; los modelos que no lo hacen la pagan dos veces. En cualquier caso, duplicar el vocabulario no es gratis.

Cuesta cómputo en la salida. Cada paso de generación calcula un softmax sobre todo el vocabulario. Con 200.000 tokens es una operación considerable, que además hay que hacer una vez por token generado.

Los tokens raros quedan mal entrenados. Cuanto más grande el vocabulario, menos veces aparece cada token en el corpus. Un token que apareció tres veces en todo el entrenamiento tiene un embedding que es prácticamente su inicialización aleatoria. Volvemos a esto en la sección siguiente, con el caso de SolidGoldMagikarp.

TipExtender el vocabulario después

Se puede agregar tokens a un modelo ya entrenado: se agranda la tabla de embeddings, se inicializan las filas nuevas (idealmente con el promedio de los embeddings de los tokens que ese texto usaba antes) y se hace fine-tuning. Es lo habitual al adaptar un modelo a un idioma nuevo o a un dominio técnico, y también la base de técnicas de compresión de prompts, donde se entrenan tokens nuevos que resumen instrucciones enteras.

13 Las rarezas, ya explicadas

Volvamos a la lista de la sección 1. Ahora tenemos todo para responderla.

13.1 Por qué no sabe deletrear ni contar letras

Código 
o200 = encodings["o200k_base"]

for palabra in ["constitución", "ubiquitous", "DefaultCellStyle"]:
    trozos = [o200.decode([i]) for i in o200.encode(palabra)]
    print(f"{palabra:>18}  ->  {trozos}")
      constitución  ->  ['constit', 'ución']
        ubiquitous  ->  ['ub', 'iqu', 'it', 'ous']
  DefaultCellStyle  ->  ['Default', 'Cell', 'Style']

Si le preguntás cuántas letras t tiene constitución, el modelo no ve letras: ve dos tokens, 'constit' y 'ución'. Contar letras adentro de un token requiere que el modelo haya memorizado, durante el entrenamiento, la composición de cada token en caracteres. Algunos la aprenden parcialmente, y por eso a veces acierta. Pero no está mirando las letras: está recordando de memoria.

Por la misma razón, si le pedís que invierta un string falla, y si le pedís “primero separá las letras con guiones y después invertí la lista” acierta: al separarlas con guiones las convertís en tokens individuales, y recién ahí las puede manipular.

13.2 Por qué falla en aritmética

Código 
gpt2, o200 = encodings["gpt2"], encodings["o200k_base"]

for numero in ["1234", "1257", "9999999"]:
    print(f"{numero:>9}:  gpt2 {[gpt2.decode([i]) for i in gpt2.encode(numero)]}"
          f"   o200k {[o200.decode([i]) for i in o200.encode(numero)]}")
     1234:  gpt2 ['12', '34']   o200k ['123', '4']
     1257:  gpt2 ['12', '57']   o200k ['125', '7']
  9999999:  gpt2 ['9999', '999']   o200k ['999', '999', '9']

1234 se parte en 123 + 4, y 1257 en 125 + 7. La partición no tiene nada que ver con la estructura decimal del número: no separa unidades, decenas ni centenas, y dos números parecidos se parten distinto. Para sumar, el modelo tiene que aprender aritmética sobre representaciones fragmentadas de forma arbitraria. Que funcione tan bien como funciona es notable; que se equivoque con números largos, esperable.

13.3 Por qué el español cuesta más

Ya lo medimos en la sección 9: mismo contenido, 30% más de tokens con GPT-2. La causa es doble. Los caracteres con tilde ocupan dos bytes en UTF-8, así que arrancan costando el doble. Y sobre todo, las palabras en español aparecen mucho menos en el corpus del tokenizador, así que casi ninguna se ganó un token propio y quedan partidas en pedazos.

13.4 Por qué es peor escribiendo Python

Código 
codigo = "def f(x):\n    if x > 0:\n        return x\n    return -x\n"

for nombre, e in encodings.items():
    print(f"{nombre:>12}: {len(e.encode(codigo)):>3} tokens")

print()
print("gpt2  :", [gpt2.decode([i]) for i in gpt2.encode(codigo)][:14])
print("cl100k:", [cl.decode([i]) for i in cl.encode(codigo)][:14])
        gpt2:  32 tokens
 cl100k_base:  20 tokens
  o200k_base:  20 tokens

gpt2  : ['def', ' f', '(', 'x', '):', '\n', ' ', ' ', ' ', ' if', ' x', ' >', ' 0', ':']
cl100k: ['def', ' f', '(x', '):\n', '   ', ' if', ' x', ' >', ' ', '0', ':\n', '       ', ' return', ' x']

El mismo código: 32 tokens con GPT-2, 20 con GPT-4. Mirá los trozos: GPT-2 gasta un token por cada espacio de indentación, mientras GPT-4 agrupa la indentación en un solo token. En Python la indentación es sintaxis, así que GPT-2 desperdiciaba una parte enorme de su contexto en espacios, y encima tenía que aprender la estructura del código a partir de secuencias larguísimas de tokens idénticos. En JavaScript, donde los espacios son opcionales, el problema era mucho menor. De ahí la fama.

13.5 Por qué molesta un espacio al final del prompt

Código 
for s in ["hola", "hola ", "hola  "]:
    ids = o200.encode(s)
    print(f"{s!r:>9}  ->  {ids}  {[o200.decode([i]) for i in ids]}")
   'hola'  ->  [122845]  ['hola']
  'hola '  ->  [122845, 220]  ['hola', ' ']
 'hola  '  ->  [122845, 256]  ['hola', '  ']

'hola ' no es 'hola' más un espacio en el mismo token: es 'hola' seguido de un token de espacio suelto. Y como vimos en la sección 7, la convención es que los espacios viajan pegados a la palabra que sigue. Un espacio solo, huérfano, es una secuencia que casi no aparece en los datos de entrenamiento. El modelo queda parado en una parte rarísima de su distribución, y encima tiene que “adivinar” que la próxima palabra ya no debería empezar con espacio. De ahí que las APIs adviertan sobre los espacios finales en el prompt.

13.6 Por qué existen tokens que rompen el modelo

Código 
print("gpt2   ' SolidGoldMagikarp' ->", gpt2.encode(" SolidGoldMagikarp"))
print("cl100k ' SolidGoldMagikarp' ->", cl.encode(" SolidGoldMagikarp"))
gpt2   ' SolidGoldMagikarp' -> [43453]
cl100k ' SolidGoldMagikarp' -> [22925, 26509, 34015, 1609, 8035]

En GPT-2, ' SolidGoldMagikarp' es un solo token. Era el nombre de un usuario de Reddit muy activo, presente miles de veces en el corpus con el que se entrenó el tokenizador. Pero ese corpus no era el mismo con el que se entrenó el modelo: en los datos del modelo, ese token aparecía casi nunca. Resultado: una fila de la tabla de embeddings que quedó prácticamente en su inicialización aleatoria.

Cuando se le pedía a GPT-2 o GPT-3 repetir esa palabra, el modelo hacía cosas erráticas: insultaba, cambiaba de tema, alucinaba. Son los tokens no entrenados (undertrained tokens), y aparecen cuando el corpus del tokenizador y el del modelo no coinciden. En cl100k_base ya no existe: se parte en cinco tokens comunes.

13.7 Por qué conviene YAML antes que JSON

Código 
import json

datos = {"nombre": "Ana", "edad": 31, "ciudad": "Montevideo", "activo": True}

como_json = json.dumps(datos, indent=2, ensure_ascii=False)
como_yaml = "nombre: Ana\nedad: 31\nciudad: Montevideo\nactivo: true\n"

print(f"JSON: {len(o200.encode(como_json)):>3} tokens")
print(f"YAML: {len(o200.encode(como_yaml)):>3} tokens")
JSON:  31 tokens
YAML:  19 tokens

Los mismos datos, 60% más de tokens en JSON. Las llaves, los corchetes, las comillas y la indentación son todos tokens, y no aportan información. Cuando el contexto o el costo importan, la elección del formato es una decisión de ingeniería con impacto medible.

14 Para seguir

Lo que construimos son unas 60 líneas de Python, y es esencialmente el mismo algoritmo que corre adentro de GPT-4. Lo que cambia es la escala del corpus, el tamaño del vocabulario y una capa de ingeniería para que sea rápido.

Vale la pena quedarse con la idea de fondo: el tokenizador es una etapa separada del modelo, sin aprendizaje por gradiente, y congelada para siempre una vez que se empieza a entrenar. Todo lo que decida —qué idiomas comprime bien, cómo parte los números, si la indentación cuesta caro— se convierte en una restricción permanente del modelo. Es la parte menos glamorosa de un LLM y la que explica una fracción sorprendente de sus fallas.

Para practicar, el recorrido de Karpathy en minbpe cubre lo mismo de forma ejecutable y termina con ejercicios: entrenar un tokenizador propio, barrer vocab_size sobre otro corpus, y reproducir los ids de un tokenizador de referencia a partir de las fusiones.

14.1 Recursos

Volver arriba ]]> LLMs https://luccafrachelle.github.io/porfolio_academia/posts/tokenizacion-bpe.html Fri, 11 Sep 2026 00:00:00 GMT Double descent Lucca Frachelle https://luccafrachelle.github.io/porfolio_academia/posts/double_desent.html

Leer en PDF

Al aumentar la complejidad de un modelo, esperamos que el error de prueba primero baje y después suba: la conocida curva en U. El double descent introduce otro escenario. Cerca del umbral en el que el modelo puede ajustar exactamente los datos de entrenamiento, el error se dispara; con más parámetros, puede volver a bajar.

En un caso concreto — regresión polinómica en una dimensión, con una base de Legendre y soluciones de norma mínima — se puede conectar lo que aparece en las curvas con el álgebra del problema: la pseudoinversa y los valores singulares de la matriz de diseño.

1 Dos objetivos que chocan

Tenemos datos de entrenamiento . En el ejemplo central, cada es un escalar en ; en la discusión general conviene pensar como vector de covariables y como respuesta. Disponemos además de un conjunto de prueba para medir lo que importa en aplicaciones. En muchos modelos aparece, de forma explícita o implícita, el objetivo de interpolar el entrenamiento,

mientras que lo que realmente importa en aplicaciones es la generalización: que se parezca a en puntos nuevos. Esa tensión aparece en regresión lineal, en modelos basados en kernels, en redes neuronales cuando el entrenamiento minimiza el error cuadrático hasta casi cero, etc.

La historia clásica del sesgo–varianza sugiere que, al aumentar la complejidad, en algún momento el error de test empeora: la curva típica en la literatura pedagógica tiene forma de U o de tazón. El fenómeno de double descent muestra que, en ciertos regímenes (sobre todo con interpolación y reglas de elección de solución como la de norma mínima), la curva de error de test puede volver a bajar después de un pico dramático cerca del umbral donde el modelo pasa a poder interpolar. No es magia: es consecuencia de cómo se resuelve el problema lineal subyacente y de qué direcciones en el espacio de features quedan mal identificadas cuando la matriz de diseño está casi en rango deficiente.

2 Polinomios de Legendre como features (1D)

En el ejemplo numérico principal, vive en y usamos la base de polinomios de Legendre , ortogonal en con peso 1:

Por ejemplo , y . En lugar de tomamos

como vector de covariables. La matriz de diseño tiene una fila por observación de entrenamiento:

Eso reduce el mal condicionamiento típico de las potencias crudas cuando crece: las columnas de monomios en una malla fija suelen volverse casi colineales, lo que encarece numéricamente la inversión de . La base de Legendre no elimina por completo el mal condicionamiento en el límite , pero ordena el problema de un modo más estable para el experimento que mostramos abajo.

3 Experimento: función verdadera, ruido, nodos y umbral

La función “verdadera” del ejemplo es

y observamos con ruido gaussiano , independiente entre observaciones.

Dónde se evalúa la función. Los valores de no se toman en una malla equiespaciada en . Con una malla uniforme, la matriz de Legendre evaluada en muchos puntos cercanos puede acercarse peligrosamente al rango deficiente de modo “accidental”, y el umbral deja de coincidir tan limpiamente con el fenómeno de interpolación en la práctica numérica. Por eso fijamos los en nodos tipo Chebyshev en (transformación coseno de índices discretos), que reparten mejor los puntos hacia los extremos del intervalo y son el estándar en interpolación polinómica.

Train y test. Partimos la muestra en mitad entrenamiento y mitad prueba, pero antes permutamos los índices al azar. Si usáramos siempre “la primera mitad” como train, en una malla ordenada los puntos de entrenamiento podrían concentrarse en una parte del intervalo (por ejemplo solo ), la matriz sería atípica y las conclusiones visuales se confundirían con un artefacto de muestreo. La permutación hace que train y test vean soporte comparable en .

El umbral de interpolación es : tantas columnas (features) como filas (puntos de train) en . Para , en rango fila completo, existe una infinidad de que interpolan exactamente los del train; entre todas ellas se elige la de norma euclídea mínima, que es la que entrega la pseudo-inversa de Moore–Penrose en ese régimen.

El ajuste queda entonces:

con la forma cerrada si (rango columna completo) y si (rango fila completo, régimen interpolante).

La siguiente figura muestra el MSE en entrenamiento y en prueba frente a (escala logarítmica en ambos ejes). El patrón típico del double descent aparece de inmediato: error alto con pocos parámetros, un pico cerca de , y luego descenso o estabilización cuando supera claramente a . En el tramo marcamos además un que minimiza el MSE de test en esta realización fija del experimento (línea vertical punteada verde), para contrastarlo con el umbral (gris).

Código 
import numpy as np
import matplotlib.pyplot as plt

plt.rcParams.update({"figure.dpi": 120, "axes.grid": True, "grid.alpha": 0.2})

rng = np.random.default_rng(2026)
N, P_max, sigma = 100, 200, 0.2
k = np.arange(1, N + 1, dtype=float)
x = np.cos((2 * k - 1) / (2 * N) * np.pi)
y = 2 * x + np.cos(25 * x) + rng.normal(0, sigma, size=N)
perm = rng.permutation(N)
n = N // 2
train, test = np.sort(perm[:n]), np.sort(perm[n:])


def legendre_design(x, P):
    x = np.asarray(x)
    m = x.shape[0]
    L = np.empty((m, P), dtype=float)
    L[:, 0] = 1.0
    if P > 1:
        L[:, 1] = x
    for kk in range(2, P):
        n_ = kk
        L[:, kk] = ((2 * n_ - 1) / n_) * x * L[:, kk - 1] - ((n_ - 1) / n_) * L[:, kk - 2]
    return L


def fit_min_norm(L_tr, y_tr):
    beta, *_ = np.linalg.lstsq(L_tr, y_tr, rcond=None)
    return beta


def mse(a, b):
    return float(np.mean((a - b) ** 2))


L = legendre_design(x, P_max)
train_mse = np.empty(P_max)
test_mse = np.empty(P_max)
for P in range(1, P_max + 1):
    betaP = fit_min_norm(L[train, :P], y[train])
    train_mse[P - 1] = mse(y[train], L[train, :P] @ betaP)
    test_mse[P - 1] = mse(y[test], L[test, :P] @ betaP)

P_pre = np.arange(1, n, dtype=int)
P_best_pre = int(P_pre[np.argmin(test_mse[P_pre - 1])])
P_under = 10
P_thr = n
P_over = P_max
x_grid = np.linspace(-1, 1, 800)
y_true = 2 * x_grid + np.cos(25 * x_grid)


def predict_on_grid(P, xg):
    Ltr = legendre_design(x[train], P)
    betaP = fit_min_norm(Ltr, y[train])
    return legendre_design(xg, P) @ betaP


y_hat_under = predict_on_grid(P_under, x_grid)
y_hat_best_pre = predict_on_grid(P_best_pre, x_grid)
y_hat_thr = predict_on_grid(P_thr, x_grid)
y_hat_over = predict_on_grid(P_over, x_grid)

P_grid = np.arange(1, P_max + 1)
fig, ax = plt.subplots(figsize=(10, 4.6))
ax.set_xscale("log")
ax.set_yscale("log")
ax.plot(P_grid, test_mse, color="#1f77b4", linewidth=2.2, label="Test")
ax.plot(P_grid, train_mse, color="#ff7f0e", linewidth=2.0, label="Train")
ax.axvline(n, linestyle="--", color="gray", linewidth=1.2, label=f"$P=n={n}$")
ax.axvline(
    P_best_pre,
    linestyle=":",
    color="#2ca02c",
    linewidth=1.5,
    label=f"$P^\\star={P_best_pre}$ (mín. test, $P<n$)",
)
finite = np.isfinite(test_mse) & (test_mse > 0) & np.isfinite(train_mse) & (train_mse > 0)
lo = float(min(np.quantile(test_mse[finite], 0.02), np.quantile(train_mse[finite], 0.02))) * 0.8
hi = float(max(np.quantile(test_mse[finite], 0.98), np.quantile(train_mse[finite], 0.98))) * 1.2
ax.set_ylim(max(lo, 1e-10), hi)
ax.set_xlabel("Número de features $P$")
ax.set_ylabel("MSE")
ax.set_title("Double descent (Legendre, norma mínima)")
ax.legend(frameon=False, loc="upper right")
plt.tight_layout()
plt.show()
Figura 1: MSE en train y en test frente al número de features . Línea gris: ; verde: que minimiza el MSE de test con en esta muestra.

El train baja monótonamente cuando el modelo gana flexibilidad; el test no: cerca de el sistema está mal condicionado y pequeñas perturbaciones (ruido, geometría de los datos) se amplifican. Más allá del umbral, la elección de la solución de norma mínima vuelve a imponer una forma “suave” al coeficiente y el error de test puede recuperarse.

3.1 Qué muestran las curvas ajustadas

El panel siguiente usa siempre los mismos puntos de entrenamiento y cambia solo . Así se ve qué significa el gráfico anterior en términos de la función frente a la verdadera .

  1. Pocos parámetros ( pequeño): el modelo es rígido; la onda de alta frecuencia casi no entra y el ajuste queda suave pero sesgado respecto de la verdad.
  2. Mejor antes del umbral (): suele aparecer un compromiso razonable entre capturar estructura y no inflar varianza; la curva se acerca más a .
  3. Umbral (): el sistema cuadrado es delicado; direcciones con valores singulares muy pequeños amplifican el ruido y el ajuste puede oscilar de forma dramática entre los puntos de entrenamiento.
  4. Muchos parámetros con min-norm (): el modelo interpola el train pero la regularización implícita de la norma mínima tiende a producir predicciones más suaves fuera de los datos de entrenamiento que en el caso “en el borde” , lo que en este ejemplo puede reducir de nuevo el error de test.
Código 
fig, axes = plt.subplots(2, 2, figsize=(10, 7.5), sharex=True, sharey=True)
panels = [
    (axes[0, 0], y_hat_under, f"Pocos parámetros\n$P={P_under}$, $n={n}$"),
    (
        axes[0, 1],
        y_hat_best_pre,
        f"Mejor test ($P<n$)\n$P^\\star={P_best_pre}$, MSE test = {test_mse[P_best_pre - 1]:.4f}",
    ),
    (axes[1, 0], y_hat_thr, f"Umbral interpolación\n$P={P_thr}=n$"),
    (axes[1, 1], y_hat_over, f"Sobre-parametrización (min-norm)\n$P={P_over}$"),
]
for axp, yhat, title in panels:
    axp.scatter(x[train], y[train], s=16, color="black", alpha=0.65, label="Train")
    axp.plot(x_grid, y_true, color="#1f4e79", linewidth=2.0, label="Verdadera")
    axp.plot(x_grid, yhat, color="#D85A30", linewidth=2.0, label="Ajuste")
    axp.set_xlim(-1, 1)
    axp.set_ylim(-3, 3)
    axp.set_title(title, fontsize=10)
    axp.legend(frameon=False, fontsize=7, loc="upper right")
axes[1, 0].set_xlabel("$x$")
axes[1, 1].set_xlabel("$x$")
axes[0, 0].set_ylabel("$y$")
axes[1, 0].set_ylabel("$y$")
plt.suptitle("Intuición visual: misma muestra de entrenamiento", y=1.02, fontsize=12)
plt.tight_layout()
plt.show()
Figura 2: Misma muestra de entrenamiento; cuatro valores de : pocos parámetros, óptimo , umbral , y grande con solución de norma mínima.

Esa secuencia es la narrativa visual que acompaña la curva en forma de doble descenso: el pico en no es un artefacto del dibujo, sino que corresponde a ajustes casi singulares que explotan entre los datos, mientras que el régimen con norma mínima puede verse mucho más benigno a ojo.

4 Pseudo-inversa de Moore–Penrose (lenguaje unificado)

Para una matriz de diseño (aquí es el número de puntos de entrenamiento) y el vector de respuestas , la solución que unifica los dos regímenes (cuando los rangos son completos en el sentido habitual) es

donde es la pseudo-inversa de Moore–Penrose. En forma cerrada, fuera de los casos límite de rango deficiente, se recuerda como

En el régimen sobre-parametrizado interpolante ( y rango fila completo), es exactamente el vector de norma euclídea mínima entre todos los que satisfacen :

4.1 Cómo predecimos en un punto de test

Sea el vector de features del mismo tipo que las filas de (en nuestro ejemplo, valores de Legendre hasta orden ). Entonces

En la práctica, conviene obtener y las predicciones con métodos basados en la descomposición en valores singulares u otras factorizaciones estables, en lugar de invertir matrices de Gram de forma directa cuando o son grandes. Las fórmulas anteriores son la referencia algebraica que conecta el experimento con el análisis del error.

5 Modelo de referencia y error de predicción

Para analizar el error sin asumir que el mundo es lineal, introducimos notación: escribimos

donde representa los coeficientes del mejor predictor lineal en un sentido ideal y recoge todo lo que esa clase lineal no puede explicar (ruido, o componentes no lineales). El valor “ideal” en test es . En general no tiene que ser los coeficientes de un “mundo lineal verdadero”; es una convención analítica que permite separar la parte del error que se parece a varianza (sensible al ruido ) de la parte que se parece a sesgo (sensible a la incapacidad del predictor lineal de representar la verdad).

5.1 Descomposición en valores singulares

Escribimos la SVD de en la forma reducida que conviene al rango :

con , , y valores singulares estrictamente positivos . Las columnas de y de son ortonormales en sus espacios. La pseudo-inversa actúa sobre la parte de que cae en el espacio columna de mediante factores ; por eso los valores singulares pequeños son el corazón técnico del pico cerca de .

5.2 Caso (sub-parametrizado): derivación del error

Partimos de la fórmula del estimador de mínimos cuadrados (coincide con en rango columna completo). Sustituyendo ,

Por tanto el error en test respecto del mejor predictor lineal en la notación adoptada es

Sustituyendo y usando las identidades estándar para , se obtiene la forma modal

donde . Es decir, el error es una suma sobre modos del operador lineal que mapea el ruido (y el residual mal modelado) del espacio de las observaciones al espacio de predicción.

En la descomposición algebraica anterior, para solo aparece el canal que pasa por en la expresión cerrada del error respecto de ; el término de sesgo de parametrización es propio del régimen .

5.3 Caso (sobre-parametrizado, min-norm): derivación

Usamos la predicción y otra vez :

Recordando , el error es

El segundo sumando admite la misma reexpresión modal que en :

Así

Aparece un término extra que no está en el caso : el que lleva . En estadística se asocia al sesgo respecto de en el sentido siguiente: con , los datos solo identifican un subespacio de dimensión a lo sumo dentro de . La matriz es la proyección ortogonal sobre el subespacio fila de (equivalentemente, sobre el span de las columnas de en ). La componente de ortogonal a ese subespacio no puede recuperarse del entrenamiento; al comparar con completo, esa componente “faltante” genera error sistemático en test.

El segundo término (la suma en ) es análogo al de y es el que conecta con el pico del double descent cuando ciertos son muy pequeños.

5.4 Resumen compacto de las dos fórmulas

:

:

6 ¿Por qué explota el error?

En el caso , el error de predicción en test (y por tanto el error cuadrático en test) descompone la incertidumbre en modos singulares. Con la SVD y valores singulares no nulos , ya vimos

La ecuación Ecuación 1 es central: el error depende de una interacción entre tres cantidades (en el modo -ésimo):

  1. Cuánto “varían” las columnas de entrenamiento de en cada dirección. Más formalmente: los inversos de los valores singulares no nulos de la matriz de diseño , es decir .

  2. Cuánto y en qué direcciones varían las covariables de test en relación con el entrenamiento. Más formalmente: cómo se proyecta sobre los vectores singulares derechos de , es decir .

  3. En qué medida el mejor modelo posible dentro de la clase puede alinear la variación en con los objetivos . Más formalmente: cómo los residuos del mejor predictor lineal en la clase (lo que, desde la clase, son errores “insalvables”) se proyectan sobre los vectores singulares izquierdos de , es decir .

Usamos términos como “variar” y “varianza” para sugerir el vínculo con la noción estadística de varianza.1 El producto de esas tres cantidades determina cuánto aporta el modo singular al error de predicción.

6.1 Cuándo los tres factores se vuelven extremos

El double descent aparece cuando esos tres factores son simultáneamente desfavorables:

  • (i) En el entrenamiento hay varianza pequeña pero no nula en alguna dirección singular (equivalente: muy pequeño).
  • (ii) Desde la perspectiva de la clase de modelos, el residuo tiene gran proyección sobre ese modo: la relación entre descriptores de entrenamiento y respuestas es frágil en esa dirección.
  • (iii) El vector de test presenta variación importante a lo largo de ese mismo modo: es grande.

Si (i) y (ii) coinciden, los coeficientes efectivos a lo largo de ese modo suelen estar mal estimados. Si además (iii) entra por un con gran proyección, el modelo se ve obligado a extrapolar fuerte en una dirección poco vista en entrenamiento, donde además la relación predicción–respuesta era ya propensa a error: el error cuadrático en test puede explotar.

6.2 Por qué la explosión ocurre cerca del umbral de interpolación

El factor es el que se vuelve más peligroso al acercarse al umbral desde cualquier régimen de parametrización: los valores singulares casi nulos se vuelven más probables.

Una explicación probabilística profunda pasa por la ley de Marchenko–Pastur (matrices aleatorias): el menor valor singular no nulo tiende a situarse en un régimen crítico junto al borde de interpolación. Por ser técnica, aquí priorizamos la intuición geométrica: cuánta dispersión hemos observado en cada dirección ortogonal del espacio de covariables al ir añadiendo muestras (Figura 3).

Supongamos un único dato de entrenamiento . Mientras no sea el vector cero, ese punto define una dirección de variación no trivial: ganamos información sobre la dispersión de la distribución en esa dirección; en todas las ortogonales la varianza empírica es exactamente cero, y el ajuste lineal no puede usarlas. Con un segundo dato , de nuevo hay variación, pero parte de suele proyectarse sobre ; la dirección compartida acumula más evidencia, pero la segunda dirección ortogonal de variación queda peor identificada. Por eso, con dos muestras, el menor valor singular no nulo de la matriz de datos es en probabilidad más pequeño que con una sola.

A medida que crece y nos acercamos al umbral (en el panel de Figura 3, ), la probabilidad de que cada dato nuevo aporte varianza fuerte en una dirección nueva y ortogonal a todo lo observado cae. En el umbral, para que el -ésimo dato no añada un valor singular pequeño-pero-no-nulo harían falta a la vez: (1) existir una dimensión en la que ninguno de los datos anteriores hubiera variado, y (2) que el -ésimo dato varíe mucho solo en esa dimensión: es poco probable. Más allá del umbral, con más datos, la varianza en cada dimensión covariable se estima mejor y el menor valor singular no nulo se aleja de cero. Eso conecta el pico de error con el peor condicionamiento espectral de .

Seis paneles 3D: distribución verdadera y muestras crecientes; flechas de varianza principal.
Figura 3: Figura 4: intuición geométrica (). Distribución verdadera y muestras con ; ejes principales (azul, verde, rojo).
Dos paneles: MSE logarítmico y menor singular logarítmico vs número de muestras.
Figura 4: Figura 5: double descent en regresión lineal ordinaria (California Housing).

La Figura 4 muestra en datos reales que el pico de MSE de test y el mínimo del menor valor singular no nulo de ocurren juntos en el umbral: evidencia empírica del vínculo entre y el error.

7 Generalización en regresión lineal sobre-parametrizada

Puede sorprender que, en el régimen sobre-parametrizado, tres conjuntos de datos exhiban error cuadrático de test relativamente bajo (California Housing, Diabetes, Student–Teacher) mientras que uno (expectativa de vida de la OMS, WHO Life Expectancy) no. La clave es que, para , el error de predicción incluye un término de sesgo que no aparece cuando .

7.1 El término de sesgo y la “visibilidad” de las covariables

El objetivo del modelo lineal es correlacionar fluctuaciones en las covariables con fluctuaciones en la respuesta. Con más parámetros que datos (), en cada punto de el ajuste solo puede “ver” fluctuaciones en un subespacio de dimensión a lo sumo : las direcciones restantes son invisibles para el entrenamiento. Por eso se pierde información sobre la relación lineal óptima y crece el error de predicción en régimen sobre-parametrizado.

Sea la proyección ortogonal sobre el espacio fila de (en , el span de las filas de la matriz de diseño). Para un covariable de test definimos la representación interna inducida por el modelo lineal como la proyección

La parte del error atribuible al sesgo respecto de (la componente que ya aparecía al descomponer ) puede escribirse como

Es decir, el sesgo es el producto interno entre (1) el vector que va del dato de test a su proyección sobre el espacio “visible” por el entrenamiento, , y (2) los coeficientes ideales de la clase. Si es casi ortogonal a la componente “no vista”, el sesgo es pequeño; si alinea con direcciones mal identificadas por , el sesgo puede ser grande.

Lejos del umbral de interpolación, la varianza suele explicar poca parte de la discrepancia entre el modelo sobre-parametrizado y el ideal; buena parte de la discrepancia proviene entonces del sesgo (Ecuación 2). Esa misma expresión admite una lectura geométrica sorprendente: la regresión lineal sobre-parametrizada hace aprendizaje de representaciones —reemplaza por su proyección en el subespacio aprendido con los datos de entrenamiento.

Diagrama 3D: proyección del test al espacio fila y tres vectores beta estrella.
Figura 5: Geometría de la generalización en OLR sobre-parametrizada.

7.2 Sesgo al cuadrado en test en cuatro conjuntos de datos

Cuadrícula 2x2: sesgo al cuadrado vs ratio parámetros/muestras en cuatro datasets.
Figura 6: Sesgo al cuadrado en test para modelos sobre-parametrizados (cuatro conjuntos).

Intuitivamente, un modelo sobre-parametrizado generaliza bien cuando sus representaciones (las proyecciones ) retienen la información que necesita para predecir (Figura 5, Figura 6). Donde tiene componente fuerte en direcciones que el entrenamiento no puede ver, el término Ecuación 2 —y por tanto el error de test— se dispara aunque la varianza del estimador sea manejable.

8 Hacia las redes: lazy training, NTK y el prisma de la interpolación

Las cuentas anteriores son lineales a propósito: matriz de diseño (Legendre) y solución de norma mínima. Para trasladar el mismo lenguaje a redes no lineales se usa un régimen en que permanece en un entorno de la inicialización , de modo que admite una aproximación de orden uno en ; eso es el marco de lazy training / linealización. La exposición enlaza con la visión de interpolación y sobre-parametrización de Belkin (2021); las demostraciones que siguen son el caso linealizado finito (riguroso) y el puente al kernel tangente (límite de ancho y flujo de gradiente).

8.1 Linealización de Taylor y feature matrix

Sea de clase en . Fijamos y escribimos el desarrollo de Taylor con resto integral de orden uno:

con cuando . El modelo linealizado es

Definimos la matriz Jacobiana de entrenamiento

por filas , y los vectores , . Entonces

Con y (vector de residuos al punto linealizado), interpolar los datos en el modelo linealizado es

La matriz es el análogo matricial de apilar features: en Legendre, las filas eran ; aquí las filas son gradientes . El régimen lazy es aquel en que es tan pequeño (o el ancho tan grande) que a lo largo de la optimización; entonces el análisis de es el sustituto riguroso del modelo polinómico finito.

8.2 Neural Tangent Kernel: definición y matriz de Gram

Definición. El kernel tangente neuronal (NTK) en es la función positiva semidefinida

Sobre la muestra , la matriz dada por es la matriz de Gram de los vectores :

Observación (flujo de gradiente en el límite ancho). Jacot et al. (2018) prueban que, bajo inicialización aleatoria adecuada y ancho , converge a un límite determinista y, en el entrenamiento continuo de GD sobre pérdida cuadrática, la evolución de las predicciones en los datos queda gobernada por un kernel que coincide con ese límite (NTK fijo). En la práctica, “NTK estático” significa que no varía apreciablemente durante el entrenamiento, de modo que la dinámica es la de un modelo lineal en el espacio de funciones inducido por . El condicionamiento de (valores propios pequeños) es el paralelo espectral al mal condicionamiento de o de en el ejemplo de Legendre.

8.3 Proposición (GD lineal y norma mínima)

Trabajamos con el modelo linealizado y la pérdida cuadrática

Lema 1 (gradiente y subespacio). Se cumple . Por tanto, cada paso de GD,

satisface . Si , entonces para todo .

Demostración. La primera afirmación es la regla de la cadena; la segunda es definición de GD; la tercera, inducción sobre .

Lema 2 (complemento ortogonal fijo). Sea la proyección ortogonal sobre y sobre . Si , entonces para todo (la componente en permanece nula).

Demostración. para todo , luego . Con se obtiene .

Proposición. Supongamos (interpolación posible y de rango fila completo). Entonces existe una única solución de norma euclídea mínima tal que , dada por . Si el GD con paso suficientemente pequeño converge desde , su límite es .

Esquema de demostración. El conjunto es un subespacio afín paralelo a . Entre ellos, el de norma mínima es el único ortogonal a , es decir, en ; la fórmula de es estándar. El flujo de GD en problemas cuadráticos convexos converge al único mínimo global en cuando y está por debajo del inverso de la constante de Lipschitz de (típicamente ). Ese mínimo global coincide con el interpolador de norma mínima por Lema 2.

Corolario (RKHS). Si identificamos el espacio de funciones lineales en las features con el RKHS asociado al kernel , la solución de norma mínima en parámetros corresponde a la función de norma de RKHS mínima que interpola en los puntos de entrenamiento (en el subespacio generado por ), en analogía directa con el caso Legendre y la pseudo-inversa.

8.4 Condición de Polyak–Łojasiewicz y variantes

Definición (PL). Una función diferenciable satisface la condición PL con constante en un conjunto si

donde es el mínimo global de en (a veces se escribe la forma equivalente cuando ).

Proposición (convergencia lineal bajo PL). Si es -suave (gradiente Lipschitz) y satisface PL con constante , el GD con verifica

Demostración (esquema). Descenso estándar usando PL y suavitud; ver Polyak (1963) o Karimi et al. para la constante exacta.

En redes, no es convexa en ; la variante PL* o hipótesis de tipo PL en el régimen interpolante (Belkin (2021), §4) postula que, con sobre-parametrización suficiente, en una región que contiene trayectorias razonables de GD se tiene control del tipo PL hacia el conjunto de mínimos globales (error nulo en entrenamiento). La consecuencia conceptual: no hace falta convexidad global para explicar convergencia a interpolación; basta una geometría que impida estancarse en valles con pérdida estrictamente positiva cuando existen mínimos con .

8.5 Prisma de la interpolación y benign overfitting

Formalmente, la navaja de Occam clásica penaliza la cardinalidad de parámetros o la dimensión del modelo. En el régimen interpolante moderno, la complejidad se mide en otra métrica: norma en el RKHS (o norma de los parámetros en la capa lineal final bajo NTK) en lugar del recuento de parámetros.

Belkin (2021) enfatiza que, con muchos grados de libertad, un predictor puede interpolar datos ruidosos descomponiendo la solución en una parte “suave” (baja norma en el kernel efectivo) más correcciones de alta frecuencia que encajan el ruido pero tienen norma pequeña en la métrica adecuada; la señal puede preservarse en la componente suave. Por eso el error de test puede descender al aumentar la capacidad: hay más maneras de ser simultáneamente interpolante y de norma controlada en el espacio de funciones relevante —fenómeno distinto del sesgo–varianza con un solo mínimo.

Nota

Síntesis. Del mismo modo que en Legendre la pseudo-inversa selecciona, entre los con , el de norma mínima (con el origen del modelo linealizado), el NTK describe, en el límite de red ancha, un espacio de Hilbert de funciones donde el descenso de gradiente desde aproxima la interpolación de norma mínima en ese espacio: el puente entre el álgebra finita de y el comportamiento cualitativo del aprendizaje profundo.

9 Resumen

  • El double descent aparece aquí en regresión polinómica 1D con base de Legendre, ruido gaussiano , nodos de Chebyshev, reparto train/test aleatorio y solución de norma mínima (pseudo-inversa de Moore–Penrose en el régimen interpolante).
  • es el umbral donde el modelo lineal puede interpolar el entrenamiento; cerca de ese borde, valores singulares pequeños de amplifican componentes del ruido y del residual en la forma .
  • Para , además entra un término de sesgo respecto de asociado a la proyección : solo una parte de es identificable desde ecuaciones en incógnitas.
  • El pico y la recuperación del error de test se entienden con mayor nitidez en el lenguaje de la SVD y la pseudo-inversa que solo con una curva genérica “sesgo vs. varianza”.
Volver arriba

Referencias

Belkin, Mikhail. 2021. Fit without fear: remarkable mathematical phenomena of deep learning through the prism of interpolation. https://arxiv.org/abs/2105.14368.
Jacot, Arthur, Franck Gabriel, y Clément Hongler. 2018. «Neural tangent kernel: Convergence and generalization in neural networks». Advances in Neural Information Processing Systems 31.

Notas

  1. Si centráramos las columnas de para obtener y escribiéramos , entonces sería la matriz de covarianza empírica y su descomposición espectral : cada sería un eje ortogonal de variación y la varianza empírica en esa dirección. Sin centrar, es el momento de segundo orden empírico, no la covarianza; por eso hablar de “varianza” es un ligero abuso terminológico, pero la intuición correcta es la misma: cuánto “se mueven” las entradas de en cada dirección y si ese movimiento se correlaciona con a través del residuo. Centrar no es esencial para el fenómeno de double descent; omitir el centrado evita confundir al lector pedagógicamente.↩︎

]]> ML STATS https://luccafrachelle.github.io/porfolio_academia/posts/double_desent.html Wed, 01 Apr 2026 00:00:00 GMT UMAP y t-SNE Lucca Frachelle https://luccafrachelle.github.io/porfolio_academia/posts/umap-tsne.html

Leer en PDF

1 Introducción

En la era digital, el crecimiento exponencial en volumen y complejidad de los datos ha consolidado a la reducción de dimensionalidad como una técnica indispensable en el análisis de datos. Su objetivo es transformar datos de un espacio de alta dimensión a una representación de menor dimensión, preservando al máximo la información relevante y la estructura inherente. Esta tarea es crucial no solo para la visualización y la comprensión de patrones complejos, sino también para mejorar la eficiencia computacional de algoritmos de aprendizaje automático y para mitigar la “maldición de la dimensionalidad”.

1.1 Enfoques para la Reducción de Dimensionalidad

Existen dos enfoques principales para la reducción de dimensionalidad:

  1. Factorización de Matrices:
    • PCA (Análisis de Componentes Principales): Descompone la matriz de datos en componentes principales que maximizan la varianza.
    • SVD (Descomposición en Valores Singulares): Factoriza la matriz en un producto de matrices ortogonales y una diagonal.
    • NMF (Non-negative Matrix Factorization): Realiza una factorización con la restricción de que todos los elementos de las matrices deben ser no negativos.
    • Características:
      • Basado en álgebra lineal.
      • Optimiza criterios globales como la varianza o el error de reconstrucción.
      • Computacionalmente eficiente.
      • Menos sensible al ruido.
  2. Grafos de Vecindad:
    • t-SNE: Construye un grafo de similitud basado en distribuciones de probabilidad.
    • UMAP: Construye un grafo de vecindad difuso basado en fundamentos topológicos.
    • LLE (Local Linear Embedding): Preserva las relaciones de vecindad locales asumiendo que la variedad es localmente lineal.
    • Características:
      • Basado en teoría de grafos y topología.
      • Preserva la estructura local de los datos.
      • Especialmente útil para la visualización y el descubrimiento de clusters.
      • Puede ser computacionalmente más costoso.

1.2 Graph-based dimensionality reduction

La idea general de graph-based dimensionality reduction es la siguiente:

  1. Se construye un métrica de similitud entre los datos en el espacio de alta dimensión.
  2. Se busca reecontruir los datos en un espacio de baja dimensión , respetando la similitud entre los datos. Esto se hace mediante un algoritmo iteativo que busca optimizar la distancia entre los datos en el espacio de baja dimensión para que coincida con la métrica de similitud en el espacio de alta dimensión.

2 Fundamentos Teóricos

2.1 La Función Softmax

La función softmax es una herramienta matemática fundamental, ampliamente utilizada en el campo del aprendizaje automático, especialmente en redes neuronales. Su propósito es transformar un vector de números reales en una distribución de probabilidad, es decir, un vector de valores entre 0 y 1 cuya suma es 1.

La fórmula de Softmax para un vector es:

donde:

  • es el -ésimo elemento del vector de entrada.

  • es el número de elementos en el vector de entrada.

En el contexto de t-SNE, la función softmax se utiliza para convertir las distancias euclidianas en probabilidades de similitud entre puntos.

2.2 Divergencia de Kullback-Leibler (KL)

La Divergencia de Kullback-Leibler (KL) es una medida de la diferencia entre dos distribuciones de probabilidad. Aunque a menudo se usa para cuantificar la “distancia” entre distribuciones, no es una métrica en el sentido matemático estricto, ya que no es simétrica () y no satisface la desigualdad triangular.

En t-SNE, la divergencia KL es la función de costo que el algoritmo busca minimizar. Mide la discrepancia entre las distribuciones de probabilidad de similitud en el espacio de alta dimensión () y en el de baja dimensión (). El objetivo es ajustar para que sea lo más parecida posible a .

La fórmula de la divergencia KL de una distribución con respecto a una distribución de referencia es:

donde:

  • es la probabilidad del evento en la distribución .
  • es la probabilidad del evento en la distribución .
  • La suma se realiza sobre todos los eventos posibles.

¿Cómo funciona?

La divergencia KL puede interpretarse como la esperanza del logaritmo del cociente de probabilidades entre las dos distribuciones, donde la esperanza se toma sobre la distribución de referencia .

  • Si : El cociente estará cerca de 1, y . La contribución a la divergencia será mínima.
  • Si es grande y es pequeña: El cociente será grande, y su logaritmo será un número positivo grande. Esto penaliza fuertemente los casos en que subestima la probabilidad de un evento importante en .
  • Si es pequeña y es grande: El cociente será pequeño, y su logaritmo será un número negativo. Sin embargo, al estar ponderado por un pequeño, la contribución total al costo será también pequeña.
  • Si y : La divergencia se vuelve infinita. Esta es una propiedad crucial en t-SNE, ya que impone una penalización infinita si la representación de baja dimensión asigna una probabilidad cero a una relación que era posible en el espacio original.

Observar que KL no es simétrica, es decir, .

3 t-SNE: Teoría y Algoritmo

3.1 De SNE a t-SNE: Evolución del Algoritmo

3.1.1 Stochastic Neighbor Embedding (SNE)

SNE fue el predecesor de t-SNE, desarrollado por Hinton y Roweis en 2002. El algoritmo se basa en convertir distancias euclidianas entre puntos en probabilidades de similitud. El proceso es el siguiente:

La idea de SNE es poder representar un espacio de alta dimensionalidad en un espacio de baja dimensionalidad de manera que las relaciones de vecindad se preserven. Para ello se usa la función softmax para convertir las distancias euclidianas en probabilidades de similitud. El objetivo es que las probabilidades de similitud en el espacio de baja dimensionalidad sean similares a las del espacio de alta dimensionalidad.

  1. Probabilidades en el espacio de alta dimensión: Para cada par de puntos y en el espacio de alta dimensión, se calcula la probabilidad condicional de que elija a como su vecino:

    donde es la varianza de la distribución gaussiana centrada en . Esta varianza se ajusta para cada punto de manera que la distribución de probabilidades tenga una perplejidad fija.

  2. Probabilidades en el espacio de baja dimensión: De manera similar, para los puntos y en el espacio de baja dimensión:

    Aquí se usa una distribución gaussiana con varianza fija (1/2) para simplificar.

  3. Función de costo: SNE minimiza la suma de las divergencias KL entre las distribuciones y :

La función de costo es lo que el algoritmo intenta minimizar, con la idea de que las probabilidades en el espacio de baja dimensionalidad sean similares a las del espacio de alta dimensionalidad.

3.1.2 Limitaciones de SNE

SNE presentaba dos problemas principales:

  1. Asimetría en las probabilidades:
    • Las probabilidades condicionales y no son iguales
    • Esto puede llevar a resultados inconsistentes
    • La función de costo es asimétrica respecto a y
  2. El problema de hacinamiento (crowding problem):
    • En el espacio de baja dimensión, hay menos “espacio” disponible para que los puntos se separen y las probabilidades de vecindad sean similares a las del espacio de alta dimensionalidad.
    • Los puntos tienden a aglomerarse en el centro
    • La distribución gaussiana en baja dimensión no maneja bien este problema
    • Las colas de la gaussiana decaen muy rápido ()

3.1.3 La Solución: t-SNE

t-SNE resuelve estos problemas mediante :

  1. Probabilidades conjuntas simétricas:
    • Reemplaza las probabilidades condicionales por probabilidades conjuntas
    • Esto asegura que
    • La función de costo se vuelve simétrica
  2. Distribución t de Student en baja dimensión:
    • Reemplaza la distribución gaussiana por una t de Student con un grado de libertad
    • La fórmula para se convierte en:

La distribución t de Student tiene “colas pesadas” (heavy tails), lo que significa que: - Asigna una probabilidad significativa a valores lejos de la media - Permite que puntos moderadamente separados en alta dimensión se mapeen a distancias mayores en baja dimensión - Crea más “espacio” en el centro del mapa - Evita la aglomeración excesiva de puntos

La fórmula de la distribución t de Student con un grado de libertad es:

Esta función tiene colas que decaen como , lo que es más lento que la distribución gaussiana que decae como . Esta propiedad es clave para resolver el problema de hacinamiento.

3.1.4 Función de Costo de t-SNE

La función de costo de t-SNE es una divergencia KL entre las probabilidades conjuntas y :

3.1.5 Gradiente de la Función de Costo

El gradiente de la función de costo con respecto a es:

Este gradiente tiene una interpretación física intuitiva intuitiva: - Si : Los puntos y están más cerca en alta dimensión que en baja dimensión * Se crea una fuerza atractiva que los acerca - Si : Los puntos y están más lejos en alta dimensión que en baja dimensión * Se crea una fuerza repulsiva que los aleja * La fuerza se modera por el término

El término es crucial porque: - Modera la fuerza de repulsión entre puntos ya separados - Permite que los puntos se separen más fácilmente - Contribuye a la formación de clusters bien definidos

3.2 Algoritmo de Optimización

El algoritmo de t-SNE utiliza un algoritmo de descenso de gradiente para minimizar la función de costo. Se aplican técnicas como:

  • Momentum: Para acelerar la convergencia y evitar mínimos locales. La actualización de las coordenadas en cada iteración es: donde es la tasa de aprendizaje y es el término de momentum.
  • Ajuste del learning rate: Se suele usar un learning rate que se incrementa en las primeras iteraciones y luego se mantiene constante.
  • Inicialización: Los puntos se inicializan aleatoriamente de una distribución normal con una pequeña varianza.

3.3 Algoritmo de t-SNE

El algoritmo de t-SNE se puede describir de la siguiente manera:

Algoritmo 1: Versión Simple de t-Distributed Stochastic Neighbor Embedding.

Datos: conjunto de datos , parámetros de la función de costo: perplejidad , parámetros de optimización: número de iteraciones , tasa de aprendizaje , momento .

Resultado: representación de baja dimensión .

Inicio:

  1. calcular afinidades por pares con perplejidad (usando Ecuación 1)

  2. establecer

  3. muestrear solución inicial desde

  4. para hasta hacer

    1. calcular afinidades de baja dimensión (usando Ecuación 4)
    2. calcular gradiente (usando Ecuación 5)
    3. establecer

  5. Fin

La actualización de los puntos en cada iteración se realiza mediante la ecuación:

Donde:

  1. : Es la nueva posición de los puntos en la iteración
  2. : Es la posición actual de los puntos
  3. : Es la tasa de aprendizaje (learning rate)
  4. : Es el gradiente de la función de costo
  5. : Es el término de momento
  6. : Es el cambio en la posición del paso anterior

El movimiento de los puntos está determinado por dos componentes principales:

  1. Término del gradiente ():
    • Mueve los puntos en la dirección que minimiza la divergencia KL
    • Los puntos se mueven para preservar la estructura de vecindad
    • Si dos puntos están cerca en el espacio original, tenderán a moverse uno hacia el otro
    • Si dos puntos están lejos en el espacio original, tenderán a alejarse
  2. Término de momento ():
    • Ayuda a evitar mínimos locales
    • Mantiene cierta “inercia” del movimiento anterior
    • Ayuda a que la optimización sea más estable
    • El factor controla cuánto del movimiento anterior se mantiene

3.3.1 Variante con Inicialización PCA

Una variante común del algoritmo t-SNE utiliza PCA (Análisis de Componentes Principales) para inicializar los puntos en lugar de usar una distribución normal aleatoria. Esta variante tiene las siguientes características:

  1. Inicialización con PCA:
    • En lugar de , se usa
    • Esto proporciona una mejor posición inicial que preserva la estructura global de los datos
    • Puede acelerar la convergencia del algoritmo
    • Ayuda a evitar mínimos locales pobres

3.4 Ejemplo del algoritmo

A continuación, implementaremos t-SNE paso a paso para proyectar datos de a . Generaremos tres distribuciones normales con diferentes medias y varianzas, y seguiremos el proceso de optimización en diferentes iteraciones.

Este ejemplo muestra:

  • Generación de datos:
    • Tres clusters gaussianos en
    • Cada cluster tiene 100 puntos
    • Diferentes medias y varianzas para cada cluster

3.5 Extensiones y Variaciones

El artículo también discute extensiones como:

  • t-SNE para conjuntos de datos grandes: Se propone una técnica de random walks en grafos de vecindad para manejar grandes volúmenes de datos, donde solo un subconjunto de puntos se visualiza directamente, pero la estructura global influye en el embedding.
  • t-SNE con costos de incrustación tempranos (early exaggeration): Multiplicar los por un factor (ej. 4 o 12) en las primeras iteraciones para crear clústeres más compactos y evitar que se formen “mini-clústeres” que no se pueden separar más tarde. para las primeras iteraciones.

4 UMAP: Teoría y Algoritmo

UMAP (Uniform Manifold Approximation and Projection) es una técnica de reducción de dimensionalidad no lineal desarrollada por Leland McInnes, John Healy y James Melville. Su propósito central es proyectar datos de alta dimensión en un espacio de menor dimensión (comúnmente 2D o 3D) para visualización o como un paso de preprocesamiento en pipelines de aprendizaje automático.

A diferencia de técnicas como t-SNE, que se basan en probabilidades de similitud y optimización de la divergencia KL, UMAP se asienta sobre un marco teórico robusto derivado de la geometría riemanniana y la topología algebraica. Esta base le confiere propiedades distintivas en términos de velocidad, escalabilidad y una superior preservación de la estructura global de los datos.

4.1 Idea general

La potencia de UMAP radica en su suposición fundamental de que los datos de alta dimensión se encuentran aproximadamente sobre una variedad (manifold) riemanniana de baja dimensión. El objetivo principal del algoritmo es preservar la estructura topológica de esta variedad subyacente al proyectar los datos a un espacio de menor dimensionalidad. La teoría subyacente se expresa más fácilmente en el lenguaje de la topología y la teoría de categorías.

A un alto nivel, UMAP logra esto utilizando aproximaciones locales de la variedad. Estas aproximaciones se “parchean” o unen a través de representaciones de conjuntos simpliciales difusos (fuzzy simplicial sets) para construir una representación topológica coherente de los datos en alta dimensión. Posteriormente, se construye una representación topológica similar en el espacio de baja dimensión. El algoritmo optimiza entonces la disposición de los puntos en el espacio de baja dimensión para minimizar la entropía cruzada entre ambas representaciones topológicas.

La construcción de estas representaciones topológicas difusas se desglosa en dos problemas: 1. Aproximar la variedad sobre la que se asume que se encuentran los datos. 2. Construir una representación de conjunto simplicial difuso de la variedad aproximada.

En última instancia, UMAP se puede entender, desde una perspectiva computacional, como la construcción y operación sobre grafos ponderados, situándolo en la clase de algoritmos de aprendizaje basados en -vecinos (como Laplacian Eigenmaps, Isomap y t-SNE). Las diferencias entre estos algoritmos residen en los detalles de cómo se construye el grafo y cómo se calcula su disposición en baja dimensión.

4.1.1 Distribución Uniforme de Datos en una Variedad y Aproximación Geodésica

El primer paso crucial en UMAP es aproximar la variedad subyacente. Se asume que los datos están distribuidos uniformemente en esta variedad con respecto a una métrica riemanniana intrínseca a la misma, no necesariamente la métrica euclidiana del espacio ambiente. Aunque los datos reales rara vez se comportan así, UMAP aborda esto de manera ingeniosa: adapta la métrica localmente para que los datos parezcan uniformemente distribuidos.

Normalmente, para cada punto , UMAP normaliza las distancias a sus vecinos con respecto a la distancia a su -ésimo vecino más cercano, denotada . Esto se basa en el Lema 1 (discutido en el paper), que establece que, bajo ciertas condiciones de un manifold Riemanniano , en una bola con respecto a centrada en un punto , la distancia geodésica de a cualquier es proporcional a la distancia euclidiana en el espacio ambiente , escalada por el radio de la bola :

La implicación práctica es que, al crear una distancia personalizada para cada (normalizando por ), se asegura que la suposición de distribución uniforme en la variedad sea válida localmente. El “costo” es que se generan nociones de distancia locales e independientes para cada punto, que pueden no ser directamente compatibles entre sí. La tarea siguiente es fusionar estos “espacios métricos discretos” locales en una estructura global consistente.

4.1.2 Representación de la Variedad con Conjuntos Simpliciales Difusos

La forma en que UMAP unifica estas nociones locales es a través de los conjuntos simpliciales difusos.

  • Un simplex es una generalización de elementos geométricos básicos: un punto es un 0-simplex, una arista es un 1-simplex, un triángulo es un 2-simplex, etc. Un conjunto simplicial es una colección de estos simplices que se conectan entre sí para formar una representación discreta de una forma o espacio topológico.
  • El término “difuso” (fuzzy) significa que las conexiones entre los simplices no son binarias (existe/no existe), sino que tienen un grado de membresía o probabilidad (un valor en el intervalo ). Esto permite capturar la incertidumbre y la gradualidad en las relaciones de vecindad de los datos, lo que es crucial para manejar la complejidad de la alta dimensionalidad y permite la combinación de las métricas locales inconsistentes en una estructura global.

Computacionalmente, aunque la teoría habla de conjuntos simpliciales difusos completos, en la práctica UMAP trabaja con el “one skeleton” de estos conjuntos, lo que se traduce directamente en un grafo ponderado. En este grafo: * Cada punto de datos es un nodo. * Cada arista entre y tiene un peso que representa la “fuerza” o “probabilidad” de conexión entre ellos.

4.1.3 Tipos de símplex

4.2 De los Datos Discretos a una Cubierta Adaptativa

Consideremos un conjunto de datos en un espacio de alta dimensión. La hipótesis fundamental de UMAP es que estos datos son un muestreo de una variedad (manifold) subyacente de menor dimensionalidad. El primer paso computacional es construir una “cubierta” de esta variedad mediante conjuntos abiertos, que pueden ser visualizados como “bolas” alrededor de cada punto.

Observemos un conjunto de datos bidimensional de ejemplo, una “onda sinusoidal ruidosa”:

A diferencia de métodos que emplean un radio fijo para estos conjuntos abiertos, UMAP adapta el tamaño de cada conjunto abierto basándose en la densidad local de los datos.

4.2.1 Cubierta con Radios Fijos

Una cubierta con un radio globalmente fijo puede llevar a una representación imprecisa de la topología local de la variedad.

4.3 Adaptación de la Métrica: Densidad y Uniformidad Local

Para garantizar que todas las vecindades locales muestren una uniformidad de muestreo aparente, UMAP implementa una re-escalación adaptativa de la métrica en cada vecindad. Esto se conceptualiza como un ajuste del “volumen” efectivo de la vecindad de puntos alrededor de cada dato.

Este ajuste métrico se logra calculando un valor (sigma local) para cada punto . Este actúa como un factor de escala. Se determina iterativamente para satisfacer la siguiente condición:

Desglosemos los términos:

  • : El punto de datos focal bajo consideración.
  • : Los vecinos más cercanos a .
  • : La distancia euclidiana (o la métrica seleccionada) entre y cada vecino en el espacio de alta dimensión.
  • (rho): La distancia al primer vecino no cero de , es decir, la distancia más pequeña a cualquier otro punto.
  • (sigma): El parámetro de escala local calculado para cada . Un pequeño indica una compresión efectiva de las distancias (región densa), mientras que un grande indica un estiramiento (región dispersa).
  • : Un valor objetivo constante. Asegura que, en promedio, la suma de las probabilidades de conexión de los vecinos de sea , normalizando la “conectividad efectiva” de cada punto.

Impacto: Este procedimiento resulta en una distribución uniforme local simulada, garantizando que las vecindades de los puntos se comporten de manera consistente, independientemente de la densidad original de los datos.

4.3.1 Cubierta Adaptada por Densidad

4.4 La Métrica Adaptada: Visualizando la Uniformización Local

El ajuste dinámico de y produce una métrica localmente adaptada que hace que los puntos se “sientan” uniformemente distribuidos. Conceptualmente, esto puede visualizarse como una deformación del espacio alrededor de cada punto, donde las bolas de radios fijos se “estiran” o “comprimen” para lograr una densidad efectiva constante.

4.4.1 Espacio Métrico Adaptado

Este ajuste es fundamental para que el “Fuzzy Simplicial Set” final refleje con precisión la topología subyacente, independientemente de las variaciones de densidad intrínsecas del dataset original.

4.5 Fuzzy Simplicial Set

Una vez que los parámetros de escala local ( y ) han sido determinados para cada punto, UMAP calcula los “scores de similaridad” entre cada punto y sus vecinos . Estos scores representan la fuerza de conexión probabilística entre los puntos:

Aquí, es el score de similaridad (o “probabilidad de conexión”) de a . Un valor cercano a 1 indica una conexión fuerte.

Estos scores se utilizan para construir un grafo de conectividad ponderado global. Cada punto de datos se convierte en un nodo del grafo, y las conexiones entre y son aristas con un peso . Este grafo se conceptualiza como un Conjunto Simplicial Difuso (Fuzzy Simplicial Set).

4.5.1 Grafo de Conectividad

4.6 Unión Difusa

La característica “difusa” (fuzzy) de los Conjuntos Simpliciales radica en que las conexiones no son binarias (sí/no), sino que poseen un grado de pertenencia (un valor continuo entre 0 y 1). Para consolidar los scores y (ya que la similaridad de a puede diferir de a debido a sus y individuales), UMAP emplea la siguiente fórmula:

Análisis de la fórmula:

  • : El peso final de la arista entre y en el grafo de conectividad global.
  • : El score de similaridad calculado de a .
  • : El score de similaridad calculado de a .

Esta operación es una “unión difusa”. Es fundamental comprender que esta no es una operación de promediado. Promediar diluiría la información crucial inherente a una conexión fuerte. Si percibe a como un vecino muy cercano (alto ), o si percibe a como un vecino muy cercano (alto ), es deseable que esta fuerte conexión se mantenga en la representación topológica final. La unión difusa garantiza que la existencia de una conexión significativa en al menos una de las direcciones (ida o vuelta) contribuya de manera robusta al peso combinado. Conceptualmente, si está conectado a , o está conectado a , entonces y están considerados conectados en el grafo global.

Este grafo ponderado constituye la aproximación topológica de la variedad subyacente en el espacio de alta dimensión, capturando tanto las relaciones de proximidad como las características geométricas locales de una manera flexible y probabilística.

4.7 Grafo de Conectividad en Alta Dimensión

Como resultado de todos los pasos previos (adaptación métrica local, cálculo de scores de similaridad y unión difusa), el proceso de UMAP culmina en la construcción de un grafo de conectividad ponderado en el espacio de alta dimensión.

En este grafo:

  • Cada nodo representa un punto de dato original.
  • Cada arista entre dos nodos indica una relación de similaridad o conectividad entre esos puntos.
  • El peso de cada arista () cuantifica la fuerza de esa similaridad, calculada a través de la unión difusa.

Este grafo ponderado puede ser convenientemente representado como una matriz de similaridad dispersa. En esta matriz, las filas y columnas corresponden a los puntos de datos, y cada entrada contiene el peso de la arista que conecta el punto con el punto . Dado que UMAP se enfoca en los vecinos más cercanos, la mayoría de las entradas de esta matriz serán cero, de ahí su naturaleza dispersa.

4.7.1 Ejemplo Conceptual de Matriz de Similaridad

Punto
1.00 0.95 0.00 0.00 0.00
0.95 1.00 0.82 0.00 0.00
0.00 0.82 1.00 0.71 0.00
0.00 0.00 0.71 1.00 0.90
0.00 0.00 0.00 0.90 1.00

4.8 Representación en Baja Dimensión

Una vez que UMAP ha construido el Conjunto Simplicial Difuso (Fuzzy Simplicial Set) en el espacio de alta dimensión, que encapsula la estructura topológica y las similaridades probabilísticas (), el siguiente paso es encontrar una representación de estos datos en un espacio de menor dimensionalidad (e.g., o ).

El objetivo es generar una incrustación (donde es la dimensión objetivo, típicamente 2 o 3) que sea topológicamente similar al grafo de alta dimensión. Esto se logra formulando un problema de optimización para preservar las conectividades probabilísticas establecidas en el espacio original. La meta es que si dos puntos y tienen una alta probabilidad de conexión en alta dimensión, sus correspondientes incrustaciones y deben estar cerca en baja dimensión, y viceversa.

Para cuantificar la “similaridad” o “conectividad” entre los puntos y en el espacio de baja dimensión, UMAP emplea una función de kernel específica, elegida por sus propiedades deseables para la optimización y la visualización:

Analicemos los componentes de esta fórmula y su propósito:

  • : Representa la similaridad o probabilidad de conexión entre las proyecciones y en el espacio de baja dimensión. Este es el homólogo de pero definido en el espacio de salida.
  • : Es la distancia euclidiana entre y en el espacio de baja dimensión.
  • y : Son parámetros de UMAP derivados de los hiperparámetros min_dist y spread.
    • min_dist: Este parámetro controla la distancia mínima que los puntos pueden tener en el espacio de baja dimensión. Un min_dist pequeño (cercano a 0) permite que los puntos se agrupen densamente, mientras que un min_dist mayor los fuerza a separarse más, resultando en agrupaciones más difusas.
    • spread: Este parámetro controla la dispersión de los puntos, influenciando la escala a la que se interpretan las distancias. Un spread más alto permite que los puntos se dispersen más ampliamente.
    • Los valores de y se ajustan para que la curva de decaimiento de la conectividad en baja dimensión (min_dist y spread) se alinee lo mejor posible con la curva de decaimiento del espacio de alta dimensión ( y ), creando una correspondencia métrica.

4.9 Minimización de la Divergencia de Entropía Cruzada

El corazón de la incrustación de UMAP reside en la minimización de la “divergencia” entre el grafo de conectividad en alta dimensión () y el grafo en baja dimensión (). Esto se formula como la minimización de la divergencia de la sección cruzada de la entropía (Cross-Entropy), una medida estándar para la diferencia entre dos distribuciones de probabilidad.

La función objetivo que UMAP busca minimizar es:

Donde:

  • : La probabilidad de conexión entre y en el espacio de alta dimensión (un valor entre 0 y 1).
  • : La probabilidad de conexión entre y en el espacio de baja dimensión (calculada con el kernel de Cauchy).

Interpretación de los Términos de la Función de Pérdida y sus Gradientes:

  1. Término de Atracción (primer término):
    • Cuando es alto (los puntos están conectados en alta dimensión) y es bajo (están lejos en baja dimensión), este término se vuelve grande y positivo, generando una penalización significativa.
    • El gradiente de este término tiende a acercar los puntos y .
  2. Término de Repulsión (segundo término):
    • Cuando es bajo (los puntos no están conectados en alta dimensión) y es alto (están demasiado cerca en baja dimensión), este término también se vuelve grande, penalizando la proximidad.
    • El gradiente de este término tiende a alejar los puntos y .

La minimización de esta función de costo guía el proceso de ajuste de las posiciones de los puntos en el espacio de baja dimensión, buscando una configuración óptima que preserve la topología probabilística del espacio original.

4.10 Descenso de Gradiente Estocástico

La minimización de la función de pérdida se realiza mediante un proceso iterativo de Descenso de Gradiente Estocástico (Stochastic Gradient Descent - SGD).

Las etapas clave son:

  1. Inicialización del Embedding:
    • Para acelerar la convergencia y proporcionar un punto de partida razonable, los puntos en el espacio de baja dimensión se inicializan comúnmente utilizando una incrustación espectral (e.g., basada en los vectores propios del Laplaciano normalizado del grafo de conectividad de alta dimensión). Alternativamente, se puede usar una inicialización aleatoria.
  2. Muestreo de Aristas y No-Aristas:
    • En cada iteración del SGD, se selecciona aleatoriamente una arista (un par con ) de la matriz de similaridad en alta dimensión. Para este par, se aplica una fuerza de atracción a y .
    • Para la repulsión, UMAP emplea muestreo negativo. En lugar de considerar todos los pares no conectados (lo que sería computacionalmente inviable para grandes datasets, ), se muestrean aleatoriamente varios puntos que no están conectados a . Para estos pares , se aplica una fuerza de repulsión. La proporción de muestras negativas por muestra positiva es un parámetro configurable.
  3. Cálculo de Gradientes y Actualización de Posiciones:
    • Se calculan las derivadas parciales de la función de pérdida con respecto a las coordenadas de los puntos y .
    • Estas gradientes determinan la dirección y magnitud del ajuste de las posiciones de los puntos.
    • Las posiciones de los puntos se actualizan iterativamente: , donde es la tasa de aprendizaje.
  4. Annealing y Convergencia:
    • El proceso de optimización se ejecuta durante un número predefinido de épocas (n_epochs).
    • A menudo, las fuerzas repulsivas se ponderan más fuertemente al inicio de la optimización para asegurar que los puntos se dispersen adecuadamente y no queden atrapados en mínimos locales apretados. A medida que avanza la optimización, el equilibrio entre atracción y repulsión se ajusta para permitir que las agrupaciones se refinen.

4.11 Impacto de Parámetros Clave en la Embedificación

La calidad y la interpretación de la incrustación de UMAP están significativamente influenciadas por varios hiperparámetros, que afectan directamente la función de pérdida y el proceso de optimización:

  • n_neighbors (Número de vecinos): Este parámetro (usado en la fase de alta dimensión para construir el k-NN graph) tiene un impacto crucial en el balance entre la preservación de la estructura local y global en la incrustación final.
    • Valores pequeños: Enfatizan la estructura local, lo que puede llevar a una fragmentación de la incrustación y a la aparición de muchos clústeres pequeños y separados.
    • Valores grandes: Permiten que UMAP considere más la estructura global de los datos, lo que puede resultar en una vista más cohesiva, pero quizás menos detallada de las relaciones locales.
  • min_dist (Distancia Mínima): Directamente relacionado con el parámetro a del kernel de Cauchy.
    • Controla cuán cerca se pueden agrupar los puntos en la incrustación de baja dimensión.
    • min_dist pequeño (cercano a 0): Los puntos pueden agruparse de forma muy densa, lo que es útil para visualizar clústeres bien separados y compactos.
    • min_dist grande: Los puntos son forzados a estar más dispersos, lo que puede revelar una estructura más continua y fluida, o separar clústeres que de otra manera se solaparían visualmente.
  • spread (Dispersión): Directamente relacionado con el parámetro b del kernel de Cauchy.
    • Controla la dispersión general del embedding.
    • spread pequeño: Resulta en una incrustación más compacta.
    • spread grande: Permite que la incrustación se extienda más, útil para visualizar la jerarquía global.
  • n_epochs (Número de Épocas):
    • Define el número de iteraciones del algoritmo de optimización SGD.
    • Más épocas (n_epochs más alto) generalmente conducen a una incrustación más optimizada y estable, pero a costa de un mayor tiempo de cómputo.
    • Para datasets grandes o embeddings de alta calidad, un n_epochs elevado es recomendable.

Estos parámetros permiten al usuario ajustar el equilibrio entre la preservación de la estructura local y global, y la densidad visual de la incrustación resultante, adaptando UMAP a diversas necesidades de análisis y visualización.

4.12 Ventajas Clave de UMAP

UMAP se compara favorablemente con t-SNE y otros algoritmos de la misma clase (basados en grafos de -vecinos). Su principal ventaja es que sus elecciones algorítmicas, tanto en la construcción del grafo como en el diseño de la incrustación, tienen una justificación teórica clara derivada de sus axiomas sobre la variedad y la topología, lo que le permite ser:

  • Más Rápido y Escalable: Su optimización en grafos dispersos y el muestreo eficiente de no-vecinos lo hacen significativamente más rápido que t-SNE, siendo aplicable a datasets de millones de puntos con una complejidad computacional que se aproxima a .
  • Mejor Preservación de la Estructura Global: La naturaleza de su función objetivo y la forma en que maneja las distancias adaptativas le permiten mantener de manera más consistente las relaciones a gran escala entre los clusters, además de la estructura local.
  • Flexible y Controlable: Los parámetros min_dist y spread ofrecen un control intuitivo sobre la densidades y separación de los clusters en la visualización final.
  • Capacidad de Transformación: UMAP puede aprender una transformación desde el espacio de alta a baja dimensión, lo que permite proyectar nuevos datos en un embedding existente sin recalcularlo todo.

5 Comparativa t-SNE vs UMAP

Ambas t-SNE y UMAP son herramientas poderosas para la reducción de dimensionalidad no lineal y la visualización, buscando revelar la estructura intrínseca de los datos. Sin embargo, sus fundamentos matemáticos y sus enfoques computacionales les otorgan características y rendimientos distintivos.

Característica t-SNE UMAP
Fundamentos Teóricos Teoría de probabilidades, divergencia Kullback-Leibler. Busca preservar las probabilidades de similitud (vecindad). Topología algebraica, teoría de la geometría riemanniana, conjuntos simpliciales difusos. Busca preservar la estructura topológica (conectividad).
Concepto de Similitud Probabilidades de similitud (basadas en Gaussianas) en alta dimensión y (basadas en t-Student) en baja dimensión. Conectividad en un grafo ponderado (fuzzy simplicial set) que representa la proximidad. La noción de “vecino” es localmente adaptable.
Preservación de Estructura Excelente para la estructura local (clusters). Tiende a aglomerar puntos cercanos y separarlos bien. A menudo distorsiona la estructura global (las distancias entre clusters no son fiables). Excelente para estructura local Y global. Busca preservar tanto los clusters como las relaciones entre ellos. Es más probable que las distancias entre clusters tengan significado.
Función de Costo Divergencia Kullback-Leibler (KL) asimétrica: . Penaliza fuertemente la pérdida de vecinos cercanos. Inspirada en la entropía cruzada binaria, optimizada para la correspondencia de grafos: .
Distribución en Baja Dimensión Distribución t-Student con 1 grado de libertad (Cauchy). Sus colas pesadas resuelven el “problema de hacinamiento”. Función de conectividad personalizada $ (1 + a|y_i - y_j|{2b}){-1} $. Parametros min_dist y spread controlan su forma para influir en la dispersión.
Velocidad y Escalabilidad Generalmente lento. Su complejidad es (o con optimizaciones como la del árbol de Barnes-Hut). No es ideal para datasets con más de ~50,000 puntos. Significativamente más rápido. Su complejidad es para la construcción del grafo y luego para la optimización. Puede manejar datasets de millones de puntos.
Reproductibilidad Muy sensible a los parámetros (perplexity, learning_rate, init). Ejecuciones repetidas con diferentes random_state pueden producir visualizaciones notablemente diferentes. Generalmente más robusto a los cambios de parámetros y más consistente en la estructura global resultante entre ejecuciones.
Parámetros Clave perplexity (número de “vecinos efectivos”), learning_rate (tasa de aprendizaje). n_neighbors (número de vecinos para construir el grafo inicial), min_dist (separación mínima entre puntos proyectados), spread (escala de los clusters), metric (métrica de distancia).
Forma de los Clusters Tiende a producir clusters más densos y circulares, a veces con puntos aglomerados en el centro del mapa. Puede producir clusters con formas más diversas y una mejor separación visual, reflejando mejor la estructura intrínseca de los datos.
Aplicaciones Típicas Excelente para la visualización de datos de transcriptómica (ej. single-cell RNA-seq), imágenes, texto. Muy bueno para identificar subpoblaciones distintas. Ampliamente utilizado en biología (ej. single-cell), visualización de embeddings de procesamiento del lenguaje natural (NLP), análisis de imágenes grandes. A menudo es la opción preferida por su equilibrio entre velocidad y calidad del embedding.

6 Implementación en el dataset MNIST

En esta sección, aplicaremos tanto t-SNE como UMAP al dataset de dígitos de Scikit-learn y analizaremos los resultados, comparando las visualizaciones y las métricas de calidad de las proyecciones.

6.1 Representación de Imágenes como Matrices

Para procesar imágenes con algoritmos de machine learning, es fundamental entender cómo se representan numéricamente. Las imágenes, en esencia, son rejillas de píxeles, donde cada píxel tiene un valor numérico que representa su intensidad o color.

6.1.1 Imágenes en Escala de Grises

Una imagen en escala de grises se representa como una matriz 2D, donde cada elemento de la matriz corresponde a un píxel y su valor representa la intensidad del gris (típicamente entre 0 para negro y 255 para blanco, u otros rangos dependiendo del formato).

En nuestro ejemplo, el dataset de dígitos de Scikit-learn consta de imágenes de 8x8 píxeles en escala de grises. Cada imagen individual se puede visualizar como una matriz de 8x8:

6.1.2 Imágenes a Color (RGB)

Las imágenes a color, comúnmente en formato RGB (Rojo, Verde, Azul), se representan como tensores 3D. Tienen dimensiones de altura, ancho y canales de color. Para una imagen RGB, hay 3 canales:

Cada canal es una matriz 2D que representa la intensidad de ese color específico para cada píxel. La combinación de los valores en los tres canales para un píxel dado determina su color final.

6.1.3 Aplanamiento (Flattening) para Algoritmos Lineales

Algoritmos como t-SNE o PCA trabajan con vectores de características de una sola dimensión. Por lo tanto, es necesario “aplanar” la representación matricial o tensorial de cada imagen en un único vector largo.

Para una imagen de 8x8 como en el dataset de dígitos, la matriz 2D de 8x8 (64 píxeles) se aplana en un vector 1D de 64 elementos:

Para una imagen RGB de altura x ancho x 3 canales, el tensor 3D se aplana en un vector 1D de altura ancho 3 elementos. Por ejemplo, una imagen de 100x100 píxeles RGB se convertiría en un vector de elementos.

Este vector aplanado se convierte en la “muestra” o “instancia” de datos en el conjunto de datos de entrada para t-SNE, donde cada elemento del vector es una “característica” (un valor de píxel).

6.2 Visualización Tabular de los Datos (DataFrame)

Para comprender mejor la estructura de los datos aplanados antes de aplicar los algoritmos de reducción de dimensionalidad, podemos visualizarlos en un formato tabular, como un DataFrame de Pandas. Cada fila representará una imagen aplanada (una muestra), y cada columna representará un píxel específico (una característica).

0 1 2 3 4 5 6 7 8 9 ... 55 56 57 58 59 60 61 62 63 digito
0 0.0 0.0 5.0 13.0 9.0 1.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 6.0 13.0 10.0 0.0 0.0 0.0 0
1 0.0 0.0 0.0 12.0 13.0 5.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 11.0 16.0 10.0 0.0 0.0 1
2 0.0 0.0 0.0 4.0 15.0 12.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 3.0 11.0 16.0 9.0 0.0 2
3 0.0 0.0 7.0 15.0 13.0 1.0 0.0 0.0 0.0 8.0 ... 0.0 0.0 0.0 7.0 13.0 13.0 9.0 0.0 0.0 3
4 0.0 0.0 0.0 1.0 11.0 0.0 0.0 0.0 0.0 0.0 ... 0.0 0.0 0.0 0.0 2.0 16.0 4.0 0.0 0.0 4

5 rows × 65 columns

En este DataFrame, cada una de las primeras 64 columnas (pixel_0 a pixel_63) representan la intensidad aplanada de un píxel de la imagen de 8x8. La última columna (digito) contiene la etiqueta de la clase (el dígito que representa la imagen).

Esta vista nos permite ver los valores numéricos exactos que alimentan los algoritmos.

6.3 Visualización de Datos Originales

6.4 Implementación y Análisis de t-SNE

En esta subsección, aplicaremos t-SNE al dataset de dígitos y exploraremos el proceso de optimización y el efecto de sus hiperparámetros.

6.4.1 Proceso de Optimización de t-SNE

6.4.2 Análisis de la Convergencia de t-SNE

6.4.3 Efecto de los Hiperparámetros de t-SNE

6.5 Implementación y Análisis de UMAP en MNIST

En esta sección, aplicaremos UMAP al dataset de dígitos MNIST usando scikit-learn y analizaremos su comportamiento y parámetros.

7 Predicción con UMAP

Una de las ventajas significativas de UMAP, en contraste con t-SNE, es su capacidad para aprender una función de mapeo desde el espacio de alta dimensión al espacio de baja dimensión. Esto significa que, una vez que un modelo UMAP ha sido entrenado con un conjunto de datos, se puede utilizar para transformar nuevos datos (es decir, datos no vistos durante el entrenamiento) en el mismo espacio de baja dimensión sin necesidad de reentrenar el modelo completo.

Esta capacidad permite:

  • Evaluación realista: Permite evaluar el rendimiento de los modelos de aprendizaje automático en el espacio de baja dimensión utilizando datos no vistos, lo cual es fundamental para una evaluación imparcial.
  • Implementación en producción: Una vez entrenado, el modelo UMAP puede ser guardado y reutilizado para proyectar nuevos datos en tiempo real, lo que lo hace adecuado para sistemas de producción.

7.1 Proyección de Datos No Vistos en UMAP

La capacidad de UMAP para proyectar nuevos datos se deriva de su proceso de entrenamiento, donde no solo se reduce la dimensionalidad de los datos de entrada, sino que también se construye un grafo de vecindad y se aprende una función de transformación implícita. Cuando se invoca el método transform() en un nuevo conjunto de datos , UMAP realiza los siguientes pasos:

  1. Cálculo de Distancias a los Vecinos más Cercanos Aprendidos: Para cada nuevo punto , UMAP identifica sus vecinos más cercanos dentro del conjunto de datos de entrenamiento original . Se calculan las distancias a estos vecinos.

  2. Inferencia de Probabilidades de Conexión: Utilizando los parámetros y aprendidos de los vecinos del conjunto de entrenamiento, se infieren las probabilidades de conexión para el nuevo punto con sus vecinos más cercanos. Esto se asemeja al cálculo de en la fase de construcción del grafo: donde son los vecinos de en .

  3. Localización en el Espacio de Baja Dimensión: El nuevo punto se inserta en el espacio de baja dimensión de tal manera que sus probabilidades de conexión con los puntos de entrenamiento cercanos (ya incrustados) sean lo más similares posible a las probabilidades inferidas en alta dimensión. Esto se logra minimizando una función de costo similar a la utilizada en la fase de entrenamiento, pero manteniendo fijos los puntos del conjunto de entrenamiento . donde es la probabilidad de conexión en baja dimensión entre y , calculada con el kernel de Cauchy:

Este proceso es computacionalmente eficiente porque solo se optimiza la posición de los nuevos puntos, sin alterar el embedding ya existente del conjunto de entrenamiento. Esto permite una proyección consistente y escalable de datos no vistos.

7.2 Predicción de Dígitos con Árboles de Decisión

Para complementar el análisis de reducción de dimensionalidad, es útil demostrar cómo los datos proyectados o el dataset original pueden ser utilizados en tareas de clasificación.

7.2.1 Resultados

Se obverva que el modelo con UMAP tiene un mejor rendimiento que el modelo simple. Esto se debe a que UMAP al ser un algoritmo de reducción de dimensionalidad no lineal, es capaz de capturar las relaciones no lineales entre los datos, lo que es útil para la clasificación.

Volver arriba ]]> Dimensionality reduction Geometry https://luccafrachelle.github.io/porfolio_academia/posts/umap-tsne.html Mon, 01 Dec 2025 00:00:00 GMT GANs desde la teoría de juegos Lucca Frachelle https://luccafrachelle.github.io/porfolio_academia/posts/gans-teoria-juegos.html

Leer en PDF

1 Introducción

Las Redes Generativas Antagónicas (GANs) representan una clase de modelos generativos propuesta originalmente por Goodfellow et al. (2014). En años recientes, estos modelos han recibido una amplia atención debido a su potencial para modelar datos del mundo real complejos y de alta dimensión.

A diferencia de los enfoques tradicionales, las GANs no minimizan un único criterio de entrenamiento. Su objetivo es estimar la distribución de probabilidad de los datos reales mediante una técnica de aprendizaje adversarial que involucra dos redes neuronales entrenadas simultáneamente. Esta capacidad permite a las GANs generar nuevas muestras infinitamente realistas desde un espacio latente sin depender de suposiciones fuertes sobre la distribución de los datos Hong et al. (2019).

1.1 Arquitectura Básica y Dinámica del Juego

Una GAN se compone usualmente de dos agentes principales:

  1. El Generador (): Intenta crear muestras realistas que no puedan ser distinguidas de los datos genuinos.
  2. El Discriminador (): Intenta diferenciar entre muestras de datos reales y muestras falsas fabricadas por el generador.

La idea central se inspira en un juego minimax de suma cero de dos jugadores. En este juego, la utilidad total es constante (cero); la ganancia o pérdida de un jugador se equilibra exactamente con la pérdida o ganancia del otro. El diseño de las GANs busca alcanzar un Equilibrio de Nash, un estado donde ningún jugador puede incrementar su ganancia cambiando unilateralmente su estrategia Wang et al. (2017).

Figura 1: Arquitectura básica de una GAN y el flujo de entrenamiento adversarial.

1.2 Analogía: El Juego Maestro-Estudiante

Para comprender mejor este concepto abstracto, podemos visualizar este juego de dos jugadores como una interacción entre un estudiante de arte y su maestro:

  • El Estudiante (Generador): Juega el rol de un falsificador o aprendiz que intenta pintar cuadros. Su objetivo es crear obras tan indistinguibles que pasen por auténticas.
  • El Maestro (Discriminador): Actúa como un crítico de arte o experto. Su objetivo es enseñar al estudiante discriminando correctamente entre pinturas reales (obras maestras genuinas) y las falsificaciones del alumno.

Para tener éxito en este juego, el estudiante debe aprender a generar pinturas indistinguibles de las reales, y el maestro debe refinar su capacidad de detectar fraudes.

En términos más formales, las “estrategias” de los jugadores corresponden a los pesos de las redes neuronales:

  • : Elegir los mejores pesos para el Discriminador.
  • : Elegir los mejores pesos para el Generador.

Ambos jugadores intentan maximizar sus respectivos pagos ( y ) para alcanzar el punto de equilibrio.

Figura 2: Juego Estudiante - Maestro

1.3 Desafíos y Motivación del Enfoque Teórico

A pesar de su éxito significativo en aplicaciones que van desde la síntesis de imágenes hasta la ciberseguridad Alqahtani et al. (2021), la aplicación de GANs a ciertos problemas del mundo real se ha visto obstaculizada por desafíos fundamentales.

El problema más significativo es que las GANs son notoriamente difíciles de entrenar y sufren de problemas de inestabilidad, tales como:

  • Colapso de Modo (Mode Collapse): Donde el generador produce una variedad muy limitada de muestras.
  • No convergencia: El juego entra en ciclos y no se estabiliza.
  • Desvanecimiento de gradientes: El discriminador se vuelve demasiado bueno demasiado rápido, dejando de proveer información útil al generador.

Teóricamente, una GAN necesita converger a un Equilibrio de Nash durante el proceso de entrenamiento, pero tal convergencia ha demostrado ser un desafío algorítmico mayor Wang et al. (2019). Dado una GANs se puede ver como un juego de suma cero, explotar técnicas de teoria de juegos es esencial para mejorar la teoría subyacente y entender estos modelos.

Esta sección esta basada en: Mohebbi Moghaddam et al. (2023), Goodfellow et al. (2014) y Hong et al. (2019).

2 Juegos de Suma Cero y Equilibrio de Nash

2.1 Definición General de un Juego

Un juego en forma normal o estratégica se define formalmente como una tupla , donde:

  • es el conjunto finito de jugadores.
  • representa el espacio de estrategias disponibles para el jugador .
  • es la función de utilidad (o payoff) del jugador , que asigna un valor escalar a cada perfil de estrategia resultante Nisan et al. (2007).

Para el propósito de este trabajo, nos centraremos en juegos donde los espacios de estrategia pueden ser continuos (como en redes neuronales), pero fundamentaremos la teoría en juegos matriciales finitos.

2.2 Definiciones y Configuración del Juego Matricial

Para establecer la notación que utilizaremos en las demostraciones (ver Apéndices), consideramos un juego de dos jugadores, I y II.

2.2.1 Matrices de Pago

Definimos las interacciones mediante matrices que contienen las recompensas para cada combinación de acciones puras:

  • : Matriz de pagos para el Jugador I.
  • : Matriz de pagos para el Jugador II.

2.2.2 Estrategias: Puras y Mixtas

Distinguimos entre dos tipos de decisiones:

  1. Estrategias Puras: La elección determinista de una acción específica del conjunto finito disponible.
  2. Estrategias Mixtas: Una distribución de probabilidad sobre las acciones puras. Esto permite modelar la incertidumbre o la aleatorización en la toma de decisiones.
    • Para el Jugador I: .
    • Para el Jugador II: .

Donde denota el símplex estándar de dimensión , definido como el conjunto de vectores no negativos cuya suma es 1:

2.2.3 Espacio de Estrategias Conjuntas ()

El estado del juego está determinado por el par . El conjunto de todos los perfiles posibles es el producto cartesiano:

Es importante notar que, dado que cada símplex es un conjunto cerrado y acotado (compacto) y convexo, su producto hereda estas propiedades. es un conjunto cerrado, convexo y compacto en el espacio euclidiano(esta propiedad es clave para la demostración de la existencia de Equilibrios de Nash en el Apéndice A).

2.2.4 Pago Esperado

La utilidad en estrategias mixtas no es un valor determinista, sino una esperanza. Dada una estrategia conjunta , los pagos esperados se calculan mediante formas bilineales:

  • Pago a I: .
  • Pago a II: .

Esto representa el promedio ponderado de los pagos, donde cada resultado se multiplica por la probabilidad conjunta de que ocurra.

2.3 Juegos de Suma Cero

Un caso especial y fundamental para las GANs son los juegos estrictamente de suma cero. Aquí, los intereses son diametralmente opuestos: lo que gana uno es exactamente lo que pierde el otro.

Esto implica que . Por tanto, podemos describir el juego completo usando solo la matriz y una única Función de Valor :

Los objetivos de optimización se vuelven antagónicos sobre esta misma función:

  1. Jugador I (Maximizador): Busca para maximizar .

  2. Jugador II (Minimizador): Busca para maximizar , lo que equivale a minimizar .

El valor del juego en equilibrio se formaliza como el problema minimax:

2.4 El Equilibrio de Nash

Un perfil de estrategias constituye un Equilibrio de Nash (NE) si ningún jugador puede mejorar su utilidad desviándose unilateralmente.

Formalmente, es un NE si satisface simultáneamente:

(Nota: La segunda desigualdad es porque el Jugador II minimiza ).

La demostración de existencia de este equilibrio se detalla en el Apéndice A. Sin embargo, encontrarlo en espacios no convexos de alta dimensión (como en aprendizaje profundo) es un desafío algorítmico mayor Daskalakis et al. (2018).

2.4.1 Ejemplo 1: Dilema del Prisionero (Suma NO Cero)

Para ilustrar la diferencia, consideremos un juego donde . Dos prisioneros deciden si cooperar () o traicionar (). Matriz de pagos :

Aquí, la estrategia pura (D, D) es el único Equilibrio de Nash, demostrando que el equilibrio individual no siempre lleva al óptimo global cooperativo (C, C).

2.4.2 Ejemplo 2: Matching Pennies (Suma Cero)

Este ejemplo es análogo a la dinámica de las GANs. P1 gana si coinciden, P2 gana si difieren. para el Jugador 1 ():

Aquí no existe equilibrio en estrategias puras. Si P1 juega Cara, P2 cambia a Cruz, etc. El equilibrio solo existe en el interior del símplex (estrategias mixtas): .

2.5 El Teorema Minimax y Puntos Silla

En juegos de suma cero, el Equilibrio de Nash tiene una conexión profunda con el Teorema Minimax de von Neumann (ver Apéndice B para la demostración). Este teorema establece que el valor que el maximizador puede asegurar es igual al valor que el minimizador puede forzar.

Gracias a las propiedades de convexidad y compacidad de los espacios de estrategias mixtas (), el orden de los operadores es intercambiable:

2.5.1 El Punto Silla como Equilibrio

Geométricamente, extendiendo esto a funciones continuas generales (como en las GANs), un Equilibrio de Nash equivale a encontrar un punto silla.

Un perfil es un punto silla si es un máximo local para y un mínimo local para :

Implicación para GANs: El entrenamiento de GANs busca este punto donde la distribución generada coincide con . Sin embargo, los métodos de gradiente estándar (SGD) suelen fallar en converger a puntos silla en paisajes no convexos, presentando oscilaciones o ciclos Mescheder et al. (2017).

Esta sección esta basada en: Karlin y Peres (2017) y Nisan et al. (2007)

3 GANs

En este capítulo, formalizamos las Redes Generativas Antagónicas como un problema de optimización en un espacio de funciones de densidad de probabilidad, analizando las propiedades de convergencia teórica del juego minimax inducido.

3.1 Definición Formal del Modelo

Una Red Generativa Antagónica (GAN) puede definirse formalmente como una tupla , donde:

  1. Distribución de Datos (): Es la densidad de probabilidad desconocida definida sobre el espacio de datos que deseamos modelar.
  2. Generador ():
    • es un vector aleatorio latente muestreado de una distribución a priori fija (e.g., ).
    • es una función diferenciable (red neuronal) parametrizada por .
    • induce una distribución de probabilidad implícita en el espacio de datos (formalmente, es la medida pushforward de bajo , denotada como ).
  3. Discriminador ():
    • es una función diferenciable parametrizada por .
    • representa la probabilidad estimada de que provenga de en lugar de .
  4. Función de Medición (): Una función convexa que define la métrica de divergencia.

3.2 El Juego Inducido de Suma Cero

El entrenamiento de una GAN se modela como un juego de suma cero donde las estrategias puras son los vectores de parámetros y .

La función de utilidad (valor) del juego, , se define como la esperanza de la evaluación correcta del discriminador sobre ambas distribuciones:

En la formulación original de Goodfellow et al. (2014) (Vanilla GAN), utilizamos , lo que resulta en la función de pérdida de entropía cruzada binaria:

Nota: Variaciones como la Wasserstein GAN (WGAN) modifican (e.g., ) y eliminan la restricción sigmoide en , cambiando la naturaleza de la convergencia, aunque aquí nos centraremos en la formulación logarítmica clásica.

El objetivo global es encontrar el equilibrio minimax (Nash) dado por:

3.3 Análisis del Óptimo

Para analizar la convergencia teórica, asumimos temporalmente que y tienen capacidad infinita (espacio de funciones no paramétrico) y analizamos el óptimo en el espacio de funciones de densidad.

3.3.1 El Discriminador Óptimo

Consideremos el generador fijo. Queremos encontrar la función que maximiza . Reescribimos la función de valor en términos de integrales sobre el espacio de datos :

Haciendo un cambio de variable para la segunda integral, expresamos todo sobre el soporte de . Sea la densidad inducida por :

Proposición 1. Para un generador fijo, el discriminador óptimo está dado por la razón:

Demostración. El problema de maximización se puede resolver puntualmente para cada . Definimos la función para dados escalares : Derivando respecto a e igualando a cero: Sustituyendo y , y observando que la segunda derivada es negativa (máximo), obtenemos el resultado.

OBS: El discriminador óptimo no está definido fuera del soporte .

3.3.2 La función de costo del Generador

Sustituyendo el discriminador óptimo en la función de valor, reducimos el juego minimax a una minimización pura sobre . Llamamos a esta función reformulada :

Podemos relacionar esta expresión con la Divergencia de Kullback-Leibler () y la Divergencia de Jensen-Shannon (). Recordando que :

Esto es exactamente igual a:

Teorema (Mínimo Global). El mínimo global de la función de costo del generador se alcanza si y solo si la distribución generada coincide con la real (). En este punto, el valor del juego es .

Demostración:

La función objetivo derivada es:

  1. Cota Inferior: Por definición, la Divergencia de Jensen-Shannon es no negativa (). Por lo tanto, el valor mínimo posible de está acotado inferiormente por .

  2. Condición de Igualdad: La propiedad fundamental de la divergencia establece que si y solo si en casi todo punto.

    Esto implica que para minimizar , el generador debe satisfacer .

  3. Interpretación del Valor : Si , el discriminador óptimo es incapaz de distinguir las muestras, colapsando a la incertidumbre máxima: . Evaluando la función de costo original bajo esta condición:

Esto confirma que el equilibrio de Nash ocurre cuando el generador recupera perfectamente la distribución de datos y el discriminador opera como un clasificador aleatorio.

3.4 Algoritmo de Entrenamiento

En la práctica, no optimizamos en el espacio de funciones, sino mediante Descenso de Gradiente Estocástico en el espacio de parámetros .

Para un minibatch de tamaño y épocas, el procedimiento de Goodfellow et al. (2014) es:

  1. Muestrear ruidos de y datos de .
  2. Actualizar el discriminador por ascenso de gradiente:
  3. Actualizar el generador por descenso de gradiente:
Figura 3: Evolución de las distribuciones durante el entrenamiento.

3.5 Convergencia Teórica

Formalmente, bajo el análisis clásico de Goodfellow et al. (2014), la convergencia está garantizada si asumimos condiciones ideales:

  1. y tienen capacidad infinita (espacio de funciones no paramétrico).

  2. En cada paso iterativo del generador, se permite a alcanzar su óptimo global .

  3. se actualiza siguiendo el gradiente para minimizar el criterio .

Bajo estas hipótesis, se demuestra que la distribución generada converge a la distribución real , alcanzando el Equilibrio de Nash donde en todo el dominio.

Sin embargo, en la práctica, estas condiciones no se cumplen. Un problema crítico es el desvanecimiento de gradientes. A lo largo de los años, se han propuesto numerosas variantes de GANs (e.g., WGAN, LSGAN, etc.) para mitigar estos problemas y mejorar la estabilidad del entrenamiento Arjovsky et al. (2017) Mao et al. (2017). Sin embargo no van a ser cubiertas en este trabajo por motivos de extensión.

Esta sección esta basada en: Goodfellow et al. (2014), Hong et al. (2019), Farnia y Ozdaglar (2020) y Ermon et al. (2023)

4 Apéndices

4.1 Apéndice A: Demostración del Teorema de Nash (Existencia)

En este apéndice presentamos la demostración de la existencia de un Equilibrio de Nash en estrategias mixtas para juegos finitos de 2 jugadores. Ya que las GANs hay 2 jugadores,aunque el argumento se puede extender a jugadores facilmente,

4.1.1 A. Definiciones y Configuración del Juego

Consideramos un juego de suma general con dos jugadores, I (con acciones puras) y II (con acciones puras).

Matrices de Pago:

  • : Matriz de pagos para el Jugador I.
  • : Matriz de pagos para el Jugador II.

Estrategias Mixtas:

  • (Estrategia de I, donde es el símplex -dimensional estándar).
  • (Estrategia de II).

Espacio de Estrategias Conjuntas ():

El conjunto de todos los perfiles de estrategias posibles es el producto cartesiano de los espacios de estrategias individuales: Propiedad topológica clave: Dado que cada símplex es un conjunto cerrado, convexo y acotado, su producto también es un conjunto cerrado, convexo y acotado (compacto) en el espacio euclidiano.

Pago Esperado:

Los pagos esperados dada una estrategia conjunta son:

  • Pago a I: .
  • Pago a II: .

4.1.2 B. Definición de Equilibrio de Nash

Antes de proceder a la demostración, definimos formalmente el objeto de estudio. Un par de estrategias es un Equilibrio de Nash si ninguna desviación unilateral es rentable para ningún jugador.

Formalmente, es un equilibrio si y solo si:

Esto es equivalente a decir que es una mejor respuesta a y viceversa.

4.1.3 C. Construcción de la Función de Mapeo

Para probar la existencia de dicho equilibrio, utilizamos el Teorema del Punto Fijo de Brouwer:

Teorema (Brouwer): Si es un conjunto compacto y convexo, y es una función continua, entonces existe al menos un punto fijo tal que .

El objetivo es construir una función tal que sus puntos fijos coincidan con los Equilibrios de Nash.

4.1.3.1 Incentivos de Desviación

Para cada acción pura del Jugador I, definimos como la ganancia marginal positiva que obtendría el jugador al cambiar toda su masa de probabilidad a la acción pura frente a la estrategia actual del oponente:

Donde es el pago de jugar la acción pura . Nota: Si la acción da menos pago que el promedio actual, .

De manera simétrica, para el Jugador II y cada acción pura :

4.1.3.2 Definición del Mapeo

Definimos la función que transforma en un nuevo par . La intuición es que “empuja” la probabilidad hacia las acciones que tienen un incentivo de desviación positivo ( o ).

Definimos los factores de normalización y .

Las nuevas estrategias se calculan como:

Es fácil verificar que y , por lo que el mapeo está bien definido dentro de .

4.1.4 D. Propiedades y Demostración

4.1.4.1 Continuidad de

Las funciones de pago esperado son multilineales y, por tanto, continuas. La función es continua. Dado que el denominador es siempre (nunca cero), la composición resultante es una función continua.

4.1.4.2 Existencia del Punto Fijo

Dado que es compacto y convexo, y es continua, por el Teorema de Brouwer existe un punto tal que: Esto implica que y .

4.1.4.3 Verificación: El Punto Fijo es un Equilibrio de Nash

Debemos demostrar que en el punto fijo, los incentivos de desviación desaparecen ( y ).

Analicemos al Jugador I. En el punto fijo se cumple: Esto implica que es proporcional a escalado por .

Supongamos por contradicción que la estrategia actual no es un equilibrio, es decir, existe alguna mejora posible, lo que implica . Si , entonces debe existir al menos un tal que .

Consideremos la ganancia ponderada por la mejora. Sabemos que: Esto se debe a que si , entonces , anulando el término.

Sin embargo, usando la propiedad del punto fijo :

Llegamos a la contradicción: , lo cual implica que para todo .

Conclusión: Si para todo , entonces por definición: Esto significa que ninguna acción pura da un pago mayor al de la estrategia mixta actual. Por linealidad, ninguna estrategia mixta alternativa dará un pago mayor.

El mismo argumento aplica para el Jugador II (). Por lo tanto, el punto fijo satisface las condiciones del Equilibrio de Nash.

La prueba es una adaptación de la demostración que se hace en Karlin y Peres (2017). Gracias a Diego por prestarnos el libro :)

4.2 Apéndice B: Demostración del Teorema Minimax (Von Neumann)

El Teorema Minimax de Von Neumann es fundamental en la Teoría de Juegos de suma cero. Este teorema establece que el valor Maximin del Jugador I es igual al valor Minimax del Jugador II.

4.2.1 Teorema Minimax de Von Neumann

Sea una matriz de pagos de . El valor del juego satisface:

La demostración se basa en el Teorema del Hiperplano Separador de la geometría convexa, procediendo en dos partes.

4.2.2 Parte 1: La Desigualdad (Maximin Minimax)

La primera parte de la demostración es inmediata y se basa en la propiedad de que el máximo de un mínimo es siempre menor o igual al mínimo de un máximo para cualquier función continua sobre conjuntos compactos.

Formalmente, demostramos:

  1. Para cualquier par de estrategias y , se tiene trivialmente:
  2. Dado que la desigualdad se cumple para cualquier y , podemos tomar el máximo sobre en el lado izquierdo y el mínimo sobre en el lado derecho, manteniendo la desigualdad.

4.2.3 Parte 2: La Igualdad (Minimax Maximin)

El objetivo ahora es demostrar que el lado izquierdo debe ser al menos tan grande como el lado derecho, lo que fuerza la igualdad.

Se prueba por contradicción usando el Teorema del Hiperplano Separador.

4.2.3.1 A. Hipótesis de Contradicción

Asumimos que la igualdad no se cumple y que existe una brecha, es decir, que existe un número tal que:

Esto implica que el valor Minimax () es estrictamente mayor que .

4.2.3.2 B. Transformación del Juego

Definimos una nueva matriz de pagos con . Para este nuevo juego, el valor Minimax debe ser positivo:

4.2.3.3 C. Construcción del Conjunto Convexo

Definimos el conjunto , que representa todos los vectores que dominan los posibles vectores de ganancia del Jugador I en el juego :

  • El conjunto es cerrado y convexo.
  • Se comprueba que . Si , existiría un tal que , implicando que , lo cual contradice la positividad establecida en el paso B.
4.2.3.4 D. Aplicación del Teorema del Hiperplano Separador

Dado que es cerrado y convexo y no contiene el origen, el Teorema del Hiperplano Separador (Theorem 2.6.2) garantiza la existencia de un vector y una constante tal que:

Sustituyendo la definición de :

4.2.3.5 E. Identificación de la Estrategia
  1. Restricción en : Se demuestra que . Si algún componente , la elección de un adecuado anularía la desigualdad.
  2. Normalización: Ya que y , se define una estrategia mixta :
4.2.3.6 F. Conclusión por Contradicción

Al elegir y sustituir en la desigualdad del hiperplano, se obtiene:

Dividiendo por la suma positiva y volviendo al juego original ():

Esto implica que es estrictamente mayor que para todo . Por lo tanto, el Maximin del juego es mayor que :

Dado que esto es cierto para cualquier menor que el Minimax (según nuestra hipótesis inicial), la única conclusión posible es que el Maximin debe ser mayor o igual que el Minimax, forzando la igualdad:

La prueba es una adaptación de una presenteación sobre GANs de Matias Carrasco, gracias mati :)

Volver arriba

Referencias

Alqahtani, Hamed, Manolya Kavakli-Thorne, y G Kumar. 2021. «Applications of Generative Adversarial Networks (GANs): An Updated Review». Archives of Computational Methods in Engineering 28: 525-52.
Arjovsky, Martin, Soumith Chintala, y Léon Bottou. 2017. «Wasserstein gan». arXiv preprint arXiv:1701.07875.
Daskalakis, Constantinos, Andrew Ilyas, Vasilis Syrgkanis, y Haipeng Zeng. 2018. «Training GANs with Optimism». International Conference on Learning Representations.
Ermon, Stefano et al. 2023. CS236: Deep Generative Models. Stanford University; Course Website. https://deepgenerativemodels.github.io/.
Farnia, Farzan, y Asuman Ozdaglar. 2020. «GANs May Have No Nash Equilibria». International Conference on Machine Learning (ICML), 3010-20.
Goodfellow, Ian, Jean Pouget-Abadie, Mehdi Mirza, et al. 2014. «Generative adversarial nets». Advances in neural information processing systems 27.
Hong, Yongjun, Uiwon Hwang, Jaeyoon Yoo, y Sungroh Yoon. 2019. «Generative adversarial networks: An overview». IEEE Signal Processing Magazine 36 (5): 46-54.
Karlin, Anna R., y Yuval Peres. 2017. Game Theory, Alive. Vol. 101. Graduate Studies en Mathematics. American Mathematical Society.
Mao, Xudong, Qing Li, Haoran Xie, Raymond YK Lau, Zhen Wang, y Stephen Paul Smolley. 2017. «Least squares generative adversarial networks». Proceedings of the IEEE International Conference on Computer Vision (ICCV), 2794-802.
Mescheder, Lars, Sebastian Nowozin, y Andreas Geiger. 2017. «The numerics of gans». Advances in neural information processing systems 30.
Mohebbi Moghaddam, Monireh, Bahar Boroumand, Mohammad Jalali, et al. 2023. «Games of GANs: game-theoretical models for generative adversarial networks». Artificial Intelligence Review 56 (10): 9771-807.
Nisan, Noam, Tim Roughgarden, Eva Tardos, y Vijay V Vazirani. 2007. Algorithmic game theory. Cambridge University Press.
Wang, Kunfeng, Chao Gou, Yanjie Duan, Yilun Lin, Xinhu Zheng, y Fei-Yue Wang. 2017. «Generative adversarial networks: introduction and outlook». IEEE/CAA Journal of Automatica Sinica 4 (4): 588-98.
Wang, Zhengwei, Qi She, y Tomas E Ward. 2019. «Generative adversarial networks: A survey and taxonomy». arXiv preprint arXiv:1906.01529.
]]> AGT ML https://luccafrachelle.github.io/porfolio_academia/posts/gans-teoria-juegos.html Sat, 01 Nov 2025 00:00:00 GMT