Primer módulo del Curso de Transformers. La meta del curso completo es entender por dentro los Transformers: la arquitectura que está detrás de todo LLM (modelo de lenguaje grande, la tecnología que mueve a ChatGPT, Claude y compañía), desde lo más básico hasta lo más avanzado. No vamos a usarlos como caja negra; vamos a abrirlos. Y para abrir cualquier red neuronal hay que empezar por un problema que suena tonto pero es fundamental: una red neuronal solo come números, no letras. Antes de que exista atención, capas o pesos, hay que traducir el texto a algo que la máquina pueda multiplicar. Eso es lo que resolvemos hoy.

La tesis del módulo

Un Transformer nunca ve texto: ve vectores de números. El puente entre “Hola, ¿cómo estás?” y la matemática interna del modelo son dos pasos: partir el texto en tokens (tokenización) y convertir cada token en un vector aprendido (embedding). Todo lo demás se construye sobre esos vectores.

Paso 1: partir el texto en tokens

Un token es la unidad mínima que el modelo procesa: un pedazo de texto que puede ser una palabra, un trozo de palabra o un signo. La tokenización es el proceso de cortar el texto en esos pedazos.

La pregunta es: ¿por dónde cortamos? Hay tres estrategias, y las dos obvias fallan:

Estrategia	Cómo corta	Problema
Por caracteres	`h` `o` `l` `a`	Vocabulario chico, pero secuencias larguísimas; el modelo tiene que reaprender qué es una palabra desde cero
Por palabras	`hola` `mundo`	Vocabulario infinito: nombres, typos, idiomas, palabras nuevas. ¿Y las que nunca vio?
Subword (BPE)	`token` `ización`	El equilibrio: pocas piezas reutilizables que arman cualquier palabra

La estrategia ganadora es subword (subpalabra): cortar en pedazos más chicos que una palabra pero más grandes que una letra. El algoritmo más famoso para hacerlo es BPE (Byte Pair Encoding, “codificación por pares de bytes”): empieza con caracteres sueltos y, mirando un corpus enorme, va fusionando los pares que más se repiten hasta armar un vocabulario fijo (típicamente entre 30.000 y 200.000 tokens).

El resultado tiene una propiedad elegante: las palabras comunes quedan como un solo token, y las raras se arman con piezas. Por eso la palabra “tokenización” no es un token: se parte en varios.

# Ejemplo ilustrativo con un tokenizer BPE (estilo GPT).
# Los IDs exactos dependen del vocabulario de cada modelo.
texto = "La tokenización parte el texto."

tokens = ["La", " token", "ización", " parte",
          " el", " texto", "."]
ids    = [1543, 5169,  66278,     1595,
         665,   2201,   13]  # cada token ID indexa el vocabulario

# "token" es común  -> 1 token
# "ización" es raro -> pieza aparte
# el espacio inicial suele ir PEGADO al token (" token", no "token")

Ojo: el espacio importa. En la mayoría de los tokenizers modernos, " token" (con espacio delante) y "token" (sin espacio) son tokens distintos. Por eso a veces un modelo trata distinto una palabra según si abre frase o va en medio.

Cada token del vocabulario tiene un número único: su token ID. Ese ID no significa nada por sí mismo (es solo un índice, como el número de página de un diccionario). El texto, después de este paso, es una lista de enteros:


  "La tokenización parte"
          │
          ▼   tokenización (BPE)
  ┌────────────────────────────────────┐
  │  La   token   ización   parte  ... │
  └────────────────────────────────────┘
          │
          ▼   buscar cada token en el vocabulario
  ┌────────────────────────────────────┐
  │  1543  5169   66278   1595     ... │
  └────────────────────────────────────┘
        (esto ya son números, pero sin significado)

Paso 2: darle significado a cada token con embeddings

Un token ID es solo un índice: el 5169 no está “más cerca” del 5170 que del 90000. Necesitamos convertir ese índice en algo que capture significado. Ahí entra el embedding (incrustación): un vector de números —una lista de, digamos, 768 valores— que representa a ese token en un espacio donde la posición sí significa algo.

¿De dónde salen esos vectores? De la matriz de embeddings: una tabla gigante de tamaño vocab × d_model, donde vocab es cuántos tokens hay en el vocabulario y d_model es el largo de cada vector (la “dimensión del modelo”, por ejemplo 768 o 4096). Cada fila es el vector de un token. Convertir un ID en su vector es literalmente ir a buscar esa fila:

import numpy as np

vocab_size = 100000  # cuántos tokens distintos hay (el ID 66278 debe caber)
d_model    = 768     # largo de cada vector de embedding

# La matriz de embeddings: una fila por token.
# Arranca aleatoria y se APRENDE durante el entrenamiento.
E = np.random.randn(vocab_size, d_model) * 0.02

ids = [1543, 5169, 66278, 1595]   # salida del tokenizer

# Buscar la fila de cada ID = "embedding lookup".
# No hay multiplicación: es indexar la tabla.
vectores = E[ids]                 # forma (4, 768)

print(vectores.shape)  # (4, 768): 4 tokens, cada uno un vector de 768

La palabra clave es aprendido: la matriz E empieza con números aleatorios y se va ajustando durante el entrenamiento. Al final, los tokens con significados parecidos terminan con vectores parecidos —quedan cerca en el espacio—. “perro” y “gato” apuntan a zonas vecinas; “perro” y “cebolla”, lejos. Esa geometría del significado es la que exploramos a fondo en Embeddings y RAG.


  token ID 5169
       │
       ▼   embedding lookup (fila 5169 de E)
  ┌────────────────────────────────────────┐
  │ 0.12  -0.98  0.44  ... 0.07 (768 nums) │
  └────────────────────────────────────────┘

  en el espacio de embeddings:

     gato ●   ● perro          ● cebolla
       (significados cercanos     (lejos)
        quedan cerca)

El panorama completo del pipeline

Juntando los dos pasos, este es el camino que recorre cualquier texto antes de entrar al primer bloque del Transformer:


  TEXTO
    │
    ▼   tokenización (BPE)
  tokens
    │
    ▼   vocabulario
  token IDs
    │
    ▼   matriz de embeddings (vocab × d_model)
  vectores
    │
    ▼
  al Transformer

Etapa	Qué es	Ejemplo
Texto	La cadena cruda	`"La tokenización"`
Tokens	Pedazos subword	`La`, `token`, `ización`
Token IDs	Índices del vocabulario	`1543`, `5169`, `66278`
Embeddings	Vectores aprendidos	`[0.12, -0.98, ...]` por token

Lo que todavía falta: el orden

Hay un detalle incómodo que arrastramos hasta el módulo 4. Fíjate: convertimos cada token en un vector, pero esos vectores forman un conjunto, no una secuencia. Nada en el embedding dice si “perro” iba primero o tercero.

Y el orden importa muchísimo: “el perro mordió al hombre” y “el hombre mordió al perro” tienen exactamente los mismos tokens, exactamente los mismos embeddings, y significan cosas opuestas. El mecanismo que veremos pronto (la atención) por sí solo es ciego al orden. La solución se llama positional encoding (codificación posicional): sumarle a cada embedding una señal que indica su posición. Pero eso lo armamos en el módulo 4, cuando tengamos el bloque completo. Por ahora, quédate con la incomodidad.

Cuidado: no confundas token con palabra. Un texto de 100 palabras en español suele dar bastante más de 100 tokens. Esto importa en la práctica: los límites de contexto y los costos de las APIs se miden en tokens, no en palabras.

Errores comunes

Creer que un token es una palabra. Es una pieza subword. “tokenización” son varios tokens; los emojis y los nombres raros, aún más.
Pensar que el token ID tiene significado numérico. El 5169 no es “mayor” ni “parecido” al 5170. Es un índice puro; el significado vive en el embedding, no en el ID.
Confundir la matriz de embeddings con algo fijo. Arranca aleatoria y se aprende. Es uno de los grandes bloques de parámetros del modelo (vocab × d_model números).
Olvidar el espacio. " token" y "token" suelen ser tokens distintos; por eso pegar mal los espacios en un prompt puede cambiar la tokenización.
Suponer que los embeddings ya entienden el orden. No: son un conjunto sin posición. El orden se inyecta aparte (módulo 4).

La frase para llevarse

“Un Transformer no lee palabras: lee coordenadas. Tokenizar es cortar el texto en piezas; hacer embedding es ubicar cada pieza en un mapa donde la cercanía es significado.”

Qué viene

Módulo 2: el mecanismo de atención, desde cero. El corazón de todo el curso. Ya tenemos los vectores; ahora cada token va a mirar a los demás para entender su contexto —cómo “banco” se desambigua según sus vecinas— usando las tres piezas clave: Query, Key y Value.

Transformers — Módulo 1: del texto a números — tokenización y embeddings