Cuantización

1. La analogía: de RAW a JPEG

Una cámara fotográfica moderna puede guardar las fotos en formato RAW: una imagen de 24 megapíxeles en RAW ocupa unos 25 MB porque guarda cada píxel con toda la información posible (14 o 16 bits por canal de color).

Cuando esa misma foto se convierte a JPEG, puede quedar en 3-4 MB — casi 8× más pequeña. Lo que hace JPEG es simplificar: los colores muy similares entre sí se representan como el mismo color. Se pierde algo de información, pero para un ojo humano la diferencia es imperceptible en la mayoría de situaciones.

Cuantizar un modelo de IA es exactamente eso: pasar de RAW (float32, 4 bytes por número) a JPEG (int8, int4: 1 byte o menos por número). Los pesos muy parecidos entre sí se representan con el mismo valor cuantizado. Se pierde un poco de precisión, pero el modelo sigue funcionando casi igual en la mayoría de casos.

2. Los formatos numéricos: de float32 a int4

Un número en un ordenador se representa con un número fijo de bits (dígitos binarios, que solo pueden ser 0 o 1). Cuántos bits uses determina cuántos valores distintos puedes representar y qué rango de números puedes expresar.

float32:  2³²  = 4.294.967.296 valores posibles ≈ 4.300 millones
float16:  2¹⁶  =        65.536 valores posibles
bfloat16: 2¹⁶  =        65.536 valores posibles (misma estructura, distinta distribución)
int8:     2⁸   =           256 valores posibles  (de -128 a +127)
int4:     2⁴   =            16 valores posibles  (de -8 a +7)

¿Por qué float32 puede representar ±3.4×10³⁸ con solo 4.300M de valores distintos?
→ No cubre todos los números entre -3.4×10³⁸ y +3.4×10³⁸ de forma uniforme.
→ Los bits de exponente controlan la "escala": puede representar números
  enormes O números minúsculos, pero no todos a la vez con alta precisión.
→ Cerca de cero, hay muchísima densidad (muchos valores distintos).
→ Cerca de los extremos, los valores están muy separados entre sí.

En redes neuronales los pesos suelen ser números pequeños (entre -3 y +3 aprox.),
por eso el rango enorme de float32 es "desperdiciado" en parte.

bfloat16 vs float16 — una diferencia importante

Ambos tienen 16 bits (2 bytes), pero los organizan de forma distinta:

• float16: 5 bits de exponente + 10 de mantisa → rango ±65.504. El problema: durante el entrenamiento, los gradientes pueden tener valores muy grandes o muy pequeños que overflow (se salen del rango) o underflow (se redondean a cero). Hay que usar "loss scaling" para compensar.
• bfloat16: 8 bits de exponente + 7 de mantisa → mismo rango enorme que float32 (±3.4×10³⁸). Sacrifica precisión pero no rango. Para entrenamiento de redes neuronales, mantener el rango es más importante que la precisión extra. Google lo diseñó específicamente para sus TPUs (de ahí "brain float").

3. Cómo se cuantiza un peso — zero_point y scale

La cuantización más usada en la práctica es la cuantización afín (también llamada cuantización lineal o asimétrica). Funciona así: tienes un grupo de pesos en float32 y quieres representarlos en int8 (256 valores). Para hacerlo necesitas dos números auxiliares:

• scale (escala): convierte el rango de int8 al rango de los pesos originales.
• zero_point (punto cero): el valor entero de int8 que corresponde al 0.0 original.

Supón que tienes estos 5 pesos en float32:
  pesos = [−1.20,  0.347,  0.89, −0.45,  1.10]

═══════ PASO 1: encontrar el rango ═══════
  w_min = −1.20   (el más pequeño)
  w_max =  1.10   (el más grande)
  rango_float = w_max − w_min = 1.10 − (−1.20) = 2.30

═══════ PASO 2: calcular scale ═══════
  int8 tiene 256 valores: de −128 a 127
  rango_int8 = 127 − (−128) = 255

  scale = rango_float / rango_int8
        = 2.30 / 255
        = 0.00902  ← "cada unidad entera de int8 equivale a 0.00902 en float"

═══════ PASO 3: calcular zero_point ═══════
  zero_point = round(−w_min / scale) + (−128)
             = round(1.20 / 0.00902) + (−128)
             = round(133.04) + (−128)
             = 133 + (−128)
             = 5   ← el entero 5 en int8 corresponde al 0.0 original

═══════ PASO 4: cuantizar cada peso ═══════
  q(w) = round(w / scale) + zero_point

  w = −1.20:  round(−1.20 / 0.00902) + 5 = round(−133.04) + 5 = −133 + 5 = −128  ✓ (límite)
  w =  0.347: round( 0.347 / 0.00902) + 5 = round(38.47) + 5   =  38 + 5  =  43
  w =  0.89:  round( 0.89  / 0.00902) + 5 = round(98.67) + 5   =  99 + 5  = 104
  w = −0.45:  round(−0.45  / 0.00902) + 5 = round(−49.89) + 5  = −50 + 5  = −45
  w =  1.10:  round( 1.10  / 0.00902) + 5 = round(121.95) + 5  = 122 + 5  = 127  ✓ (límite)

  Pesos originales:   [−1.20,   0.347,   0.89,  −0.45,   1.10]
  Pesos cuantizados:  [ −128,    43,      104,   −45,      127]

═══════ PASO 5: descompresión (para hacer cómputos) ═══════
  w_decomprimido = (q − zero_point) × scale

  q = 43:   (43 − 5) × 0.00902 = 38 × 0.00902 = 0.342  (original: 0.347 → error: 0.005)
  q = 104:  (104 − 5) × 0.00902 = 99 × 0.00902 = 0.893 (original: 0.89 → error: 0.003)
  q = −45:  (−45 − 5) × 0.00902 = −50 × 0.00902 = −0.451 (original: −0.45 → error: 0.001)

→ El error máximo es: scale/2 = 0.00902/2 = 0.0045
→ En relación al rango total (2.30): error relativo ≈ 0.2% — muy pequeño

Ese proceso se guarda junto a los pesos cuantizados: para cada grupo de pesos, se almacena el valor de scale y zero_point en float32. Cuando el modelo necesita usar los pesos, los descomprime al vuelo usando esa fórmula.

4. PTQ vs QAT — dos enfoques de cuantización

Hay dos momentos en los que se puede aplicar cuantización, y tienen propiedades muy distintas:

Para fine-tuning en la práctica, usaremos siempre PTQ (cuantización post-entrenamiento) con bitsandbytes. QAT se queda para equipos de investigación con acceso a clusters de GPU.

5. bitsandbytes en código: 8 bits y 4 bits

Cargar en 8 bits

from transformers import AutoModelForCausalLM, BitsAndBytesConfig
import torch

# Configuración para 8 bits (int8)
bnb_8bit = BitsAndBytesConfig(
    load_in_8bit=True,   # activar cuantización a 8 bits
)

# Cargar DistilGPT-2 en 8 bits
model_8bit = AutoModelForCausalLM.from_pretrained(
    "distilgpt2",
    quantization_config=bnb_8bit,
    device_map="auto",
)

# Inspeccionar el tipo de datos de los pesos
for name, param in list(model_8bit.named_parameters())[:3]:
    print(f"{name}: {param.dtype}, shape={list(param.shape)}")

Cargar en 4 bits con NF4

# Configuración 4 bits NF4 con doble cuantización
bnb_4bit = BitsAndBytesConfig(
    load_in_4bit=True,
    bnb_4bit_quant_type="nf4",
    bnb_4bit_compute_dtype=torch.bfloat16,
    bnb_4bit_use_double_quant=True,
)

model_4bit = AutoModelForCausalLM.from_pretrained(
    "distilgpt2",
    quantization_config=bnb_4bit,
    device_map="auto",
)

# Comparar tamaños en memoria
def model_size_gb(model):
    total = sum(p.numel() * p.element_size() for p in model.parameters())
    return total / (1024**3)

print(f"Modelo float32 original: ~0.32 GB (estimado)")
print(f"Modelo 8-bit:  {model_size_gb(model_8bit):.3f} GB")
print(f"Modelo 4-bit:  {model_size_gb(model_4bit):.3f} GB")

Hacer inferencia con un modelo cuantizado

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("distilgpt2")

def generar(model, prompt, max_new_tokens=20):
    inputs = tokenizer(f"{prompt}", return_tensors="pt").to(model.device)
    with torch.no_grad():
        output = model.generate(**inputs, max_new_tokens=max_new_tokens, do_sample=False)
    return tokenizer.decode(output[0], skip_special_tokens=True)

prompt = "The future of artificial intelligence is"
print("8-bit:", generar(model_8bit, prompt))
print("4-bit:", generar(model_4bit, prompt))

Ambas salidas son coherentes y sensatas. Las diferencias son mínimas — "it will be used" vs "we will use it". Con modelos más grandes y tareas más precisas las diferencias son igualmente pequeñas en la mayoría de casos.

6. ¿Cuánta calidad se pierde? Benchmark MMLU

MMLU (Massive Multitask Language Understanding) es un benchmark estándar que mide la capacidad de un modelo respondiendo preguntas de múltiple opción en 57 áreas del conocimiento: matemáticas, historia, medicina, derecho, etc. La puntuación va de 0% (todo mal) a 100% (todo bien). Una elección aleatoria en 4 opciones da 25%.

Estos son resultados reales de LLaMA-2-7B en MMLU con distintos niveles de cuantización:

🎮 Cuantizador visual — ve cómo se redondea un número

Introduce un peso float32 y observa cómo se cuantiza a int8 e int4, cuál es el error de redondeo y cuánto se reduce el almacenamiento.

8. Lo que aprendiste

En la próxima lección: Pruning y compresión estructural — otra técnica de compresión que en vez de reducir la precisión de los números, elimina directamente los pesos y neuronas que menos contribuyen al resultado.