Cuantización de LLM: Modelo de 160GB en un Portátil

Cuantización de LLM: Ejecutar modelos de 160 GB en un portátil con pérdida mínima

Modelos como Qwen-3-Coder-Next con 80 mil millones de parámetros ocupan 159,4 GB de memoria. La cuantización reduce el tamaño del modelo a 4x y acelera la inferencia hasta 2x, con solo una caída del 5–10% en calidad. Esto hace posible ejecutar grandes LLMs en hardware de consumo sin sacrificar rendimiento.

Parámetros y su impacto en el tamaño del modelo

Los parámetros—pesos en una red neuronal—determinan el tamaño de memoria de un LLM. Cada parámetro se almacena como un número de punto flotante. La unidad más simple: entrada multiplicada por peso da salida. Modelos reales tienen cientos de capas con miles de nodos, lo que genera miles de millones de parámetros.

Por ejemplo, una red con 2 entradas, 3 capas de 4 nodos cada una y 2 salidas tiene 64 parámetros. Escalando a cientos de miles de nodos, obtenemos trillones de pesos. Los histogramas de modelos populares muestran que el 99% de los valores están cerca de cero, dentro del rango [-0.5, 0.5].

Representación numérica en memoria

Las computadoras almacenan float32: 1 bit de signo, 8 bits de exponente y 23 bits de mantisa. Rango ±3,4×10³⁸ con 7 dígitos significativos. La distribución es desigual—más densa cerca de cero, más escasa en extremos. Esto se adapta bien a LLMs, donde los pesos son pequeños.

Float16: 1+5+10 bits, precisión de 3–4 dígitos, rango ±65.504. Bfloat16 (1+8+7): amplio rango, 2–3 dígitos. Float8/Float4 son experimentales, con 3–4 bits de mantisa.

Aproximación de onda senoidal: float32 es suave; float4 es escalonada con errores notables.

Principios de la cuantización

La cuantización es una compresión con pérdida: mapear flotantes a un conjunto más pequeño de valores. Redondeo simple (redondeo al más cercano) de bfloat16 a float4 rompe el modelo: los pesos se vuelven cero, la salida es cero. ¿Por qué? El rango de float4 [-3,3] no coincide con pesos típicos [-0.89,0.16].

Cuantización simétrica

Escala los datos a rangos enteros. Fórmula: escala = max_abs / (2^(bits-1) - 1). Cuantiza: redondea(valor / escala), descuantiza: cuantizado * escala.

Ejemplo en JavaScript:

function quantize({ values, bits }) {
  const vmax = Math.max(...values.map(Math.abs));
  const qmax = 2 ** (bits - 1) - 1;
  const scale = vmax / qmax;
  return {
    values: values.map((v) => Math.round(v / scale)),
    scale,
  };
}

function dequantize({ values, scale }) {
  return values.map((v) => v * scale);
}

Para valores = [-0.89, 0.16, 0.08, -0.13, 0.16, -0.54], bits=4:

• cuantizados: [-7,1,1,-1,1,-4], escala≈0.127
• descuantizados: [-0.89,0.127,0.127,-0.127,0.127,-0.509]
• error promedio: 18%

Salida del modelo tras cuantización a 4 bits: desviación del 30% respecto al original, pero con 4x menos uso de memoria.

Cuantización asimétrica

Mejora la cuantización simétrica al manejar mínimo y máximo por separado. Rango [min, max] se mapea a [qmin, qmax]. Fórmula:

• offset = min
• escala = (max - min) / (qmax - qmin)
• cuantizado = redondea((valor - offset) / escala)

Esto usa eficientemente el espacio: para datos sesgados (más valores negativos), no se desperdicia el lado positivo. El error promedio baja a 5–10%.

Aplicar a tensores: cuantizar por canal o grupo (cuantización por grupo) para minimizar errores de activación.

Evaluación de calidad tras cuantización

Medir perplexidad en un conjunto de validación o métricas específicas de tareas (BLEU, ROUGE). Benchmarks:

• Qwen-3-Coder-Next 4-bit: +7% de perplexidad vs FP16
• Velocidad: x2 en GPU sin núcleos tensoriales

| Formato | Tamaño (GB) | Perplexidad | Velocidad (tokens/seg) |

|--------|-----------|------------|--------------------|

| FP16 | 159.4 | 1.00 | 1.0 |

| INT8 | 39.8 | 1.05 | 1.8 |

| INT4 | 19.9 | 1.09 | 2.1 |

Conclusiones clave

• La cuantización reduce el tamaño del modelo entre 4x y 8x sin reentrenamiento.
• Usa cuantización simétrica para datos simétricos; asimétrica para distribuciones sesgadas.
• La cuantización por grupo (grupos de 128 elementos) equilibra precisión y velocidad.
• Soportada de forma nativa en llama.cpp, bitsandbytes: INT4/INT8.
• Prueba en tareas downstream: programación, preguntas y respuestas.

— Editorial Team