Cinco palabras, cinco números

Cada término de esta lección se define por un número que se puede medir en la terminal. Si alguien los usa sin número, está hablando de otra cosa.

Modelo y pesos

Un modelo de lenguaje es una función enorme que recibe una secuencia de tokens y devuelve, para el siguiente token, una probabilidad por cada token posible del vocabulario. Se muestrea uno, se añade a la secuencia, y se repite. Eso es todo lo que hace. Todo lo demás —«razonar», «resumir», «extraer»— es ese bucle aplicado muchas veces.

Los pesos (o parámetros) son los números que definen esa función. Un modelo de 8B tiene ocho mil millones. En precisión completa (16 bits por parámetro) ocupan:

8 000 000 000 parámetros × 2 bytes = 16 GB

Ese cálculo es la primera herramienta de decisión del curso: parámetros × bytes por parámetro = memoria que hace falta solo para cargar el modelo, sin contar el contexto.

Cuantización

Cuantizar es guardar cada peso con menos bits. Los formatos más comunes en runtimes locales [VOLÁTIL — verificado: 2026-09]:

Criterio de selección (no un nombre de modelo): elija la cuantización más alta que quepa en la VRAM dejando espacio para el contexto; baje un escalón solo si la medición dice que la pérdida es aceptable para la tarea.

Contexto: la ventana

La ventana de contexto es la cantidad máxima de tokens que el modelo puede tener «a la vista» a la vez: instrucciones + documentos + conversación + su propia respuesta. Todo compite por ese espacio.

Y tiene un costo que casi nadie cuenta al comprar hardware: la caché de atención (KV cache) crece con el contexto y vive en la misma memoria que los pesos. Como orden de magnitud para un modelo 8B [VOLÁTIL — verificado: 2026-09]:

contexto de 8 000 tokens → ~1 GB adicional
contexto de 32 000 tokens → ~4 GB adicionales

Por eso «cabe en 8 GB» puede ser cierto para el modelo solo y falso para el modelo con un PDF de 40 páginas dentro. El módulo 1 lo convierte en fórmula.

Tokens

Un token es la unidad en que el modelo lee: no palabras, no letras, sino fragmentos decididos por un algoritmo de compresión estadística (BPE o similar) durante el entrenamiento. Consecuencias prácticas:

• El español gasta más tokens por palabra que el inglés, porque los tokenizadores se entrenan con mayoría de inglés. Regla de bolsillo: 1.000 palabras en español ≈ 1.400–1.800 tokens.
• Los números, los códigos de factura y las siglas se parten en muchos tokens: FV-2026-000123 puede ser 8 tokens.
• Cada modelo tiene su tokenizador. Contar con el de otro da cifras equivocadas.

Laboratorio 0.3 · contar tokens de documentos reales

Se usa la biblioteca tokenizers con el archivo tokenizer.json de cualquier modelo: así el laboratorio no depende de un modelo concreto. (Si ya tiene un runtime local, la mayoría expone su propio conteo; el principio es el mismo.)

cd ~/labs/el-tornillo && mkdir -p labs/00-03 && cd labs/00-03
python3 -m venv .venv && source .venv/bin/activate
pip install -q tokenizers
# tokenizer.json: descárguelo del repositorio del modelo que vaya a usar (Hugging Face) y
# póngalo aquí. Es un archivo de texto; no hacen falta los pesos.

# tokens.py — cuenta tokens de varios archivos con un tokenizer.json cualquiera
import sys, pathlib
from tokenizers import Tokenizer

tok = Tokenizer.from_file("tokenizer.json")
for ruta in sys.argv[1:]:
 texto = pathlib.Path(ruta).read_text(encoding="utf-8")
 n_tok = len(tok.encode(texto).ids)
 n_pal = len(texto.split())
 print(f"{ruta:40s} {n_pal:7d} palabras {n_tok:8d} tokens ratio {n_tok/max(n_pal,1):.2f}")

python tokens.py ../../README.md docs/politica-datos.md docs/contrato-proveedor.md

Lo que debe ver: tres líneas con el ratio tokens/palabra. En español bien redactado sale entre 1,4 y 1,8. Si sale 2,5 o más, el texto tiene muchos códigos, números o mayúsculas raras —y eso es lo que va a costar en contexto.

Entregable: labs/00-03/tokens.py y una tabla con los tokens de los tres documentos más largos del cliente. Commit: «Capa 0.3: presupuesto de tokens».

Qué se degrada en cada perfil

Cuándo NO usar esto

• No cuente tokens con el tokenizador de otro modelo para presupuestar contexto: las cifras pueden diferir un 30 %.
• No cuantice a Q2/Q3 para «que quepa» en un equipo que no da: mida primero; casi siempre es mejor un modelo más pequeño en Q8 que uno grande en Q2.
• No compre por parámetros. Un 70B en Q2 puede rendir peor que un 8B en Q8 y costar cuatro veces más de memoria.

Práctica

1. Calcule cuánta memoria ocupa un modelo de 14B en F16, Q8 y Q4 (sin contexto).
2. Un cliente tiene facturas de 3 páginas (~1.200 palabras). ¿Cuántos tokens aproximados gasta una sola factura? ¿Cuántas caben en una ventana de 8k dejando 1.500 para instrucciones y respuesta?
3. Explique en dos líneas por qué un runtime puede decir «modelo cargado» y aun así fallar al procesar un documento largo.

Referencias

1. llama.cpp — formato GGUF y tabla de cuantizaciones: https://github.com/ggml-org/llama.cpp (README y docs/). [VOLÁTIL — verificado: 2026-09]
2. Hugging Face — biblioteca tokenizers: https://huggingface.co/docs/tokenizers
3. Sennrich, R. et al. (2016). Neural Machine Translation of Rare Words with Subword Units. arXiv:1508.07909 — el BPE que usan los tokenizadores modernos.
4. Dettmers, T. et al. (2023). QLoRA: Efficient Finetuning of Quantized LLMs. arXiv:2305.14314 — la evidencia de que 4 bits conserva la mayor parte de la calidad en muchas tareas.