Cómo funciona la cuantización de LLMs
Contenido del curso
Jerson Hernán Uribe Montenegro
Andres David Martinez Torres
Tadeo Juarez
Miguel Angel Otero Otero
Gabriel Obregón
Luis Rebollo
Jose Daniel Barría Reyes
Renato Giron
Kevin Fiorentino
Diego Ortiz
Mateo Montoya Henao
Christian Gómez
MARIA TERESA PANIAGUA RIVERA
Edgar Villatoro Pérez
Isabel Yepes
Santiago Pineda Botero
Bueno, me costó un poco intentar cuantizar y de-cuantizar una matriz de pesos de ejemplo, pero con un poco de ayuda de la IA fue más entendible:
example_weights = [ [0.12, -0.47, 0.33, 0.08], [-0.25, 0.19, -0.41, 0.56], [0.72, -0.15, 0.05, -0.32] ]
n_bits = 8 max_int = 2**(n_bits - 1) - 1 def clamp(x, low, high): return max(low, min(high, x))
alpha = max(abs(w) for row in example_weights for w in row)
scale = alpha / max_int
quantized = [] for row in example_weights: q_row = [] for x in row: x_q = clamp(round(x / scale), -max_int, max_int) q_row.append(int(x_q)) quantized.append(q_row)
dequantized = [[x_q * scale for x_q in row] for row in quantized]
Al imprimir los resultados da algo como esto:
Yo utilicé un notebook en local para ejecutar el código. Cada fragmento que dejé es una celda.
Muy buen aporte
Me esforcé en ser lo mas entendible posible:
Que es Cuantización en Modelos de Machine Learning
Cuantización básicamente es transformar números de coma flotante a enteros, números de los vectores que el modelo maneja. El objetivo es mapear este numero amplio de valores de coma flotante en un rango mas limitado de valores enteros
Lo que ocurre en esa transformación es que desde el numero mas pequeño hasta el mas grande se divide en rangos, entonces cada numero decimal original se mapea a un valor entero, que es el representante de un rango
Pero técnicamente no estamos quitando decimas, sino que estamos quitando bits, los números son bits, lo que entiende la computadora son bits. Entonces en vez de manejar 32 bits para guardar la información del modelo, lo cortamos a 8 bits, esto cambia la precisión del modelo pero lo hace mas eficiente en cuanto a memoria.
Por eso es importante tener en cuanta que tan importante es la precisión de las respuestas de nuestro modelo, ya que si queremos usar un modelo de machine learning para conducción autónoma o para detectar alguna enfermedad si necesitamos muchísima precisión, pero si en cambio es para un proyecto x de universidad no necesitaríamos tanta precisión
Importancia de Modelos Cuantizados
Hoy en día la eficiencia que ofrecen los modelos cuantizados en dispositivos que no tienen tanto poder de computo es esencial. Vemos modelos cuantizados en drones, celulares, alexa’s, laptops humildes o robots incluso que con modelos no cuantizados o modelos desde la nube no tendrían el mismo rendimiento
import time def pausar_y_continuar(mensaje="Presiona Enter para continuar..."): """Función para pausar la ejecución y esperar al usuario.""" input(f"\n{mensaje}") print("-" * 60) def obtener_numeros_del_usuario(): """Pide al usuario que ingrese números y los valida.""" while True: entrada = input("➡️ Ingresa tus números separados por espacios (ej: 3.14 -2.5 100): ") try: # Intenta convertir cada elemento ingresado en un número flotante. numeros = [float(n) for n in entrada.split()] if not numeros: # Si la lista está vacía print("❌ Error: No ingresaste ningún número. Inténtalo de nuevo.") continue return numeros except ValueError: # Si la conversión falla, es porque hay un valor no numérico. print("❌ Error: Asegúrate de ingresar solo números separados por espacios.") def cuantizar_paso_a_paso(lista_numeros, tipo): """ Función interactiva que guía al usuario a través de la cuantización simétrica o asimétrica, explicando cada cálculo. """ if tipo == 'simetrico': print("\n" + "="*60) print("🔵 TUTORIAL: CUANTIZACIÓN SIMÉTRICA (a int8)") print("="*60) print("Este método centra el mapa en el cero. Ideal para datos balanceados.") pausar_y_continuar("Presiona Enter para encontrar el rango...") # --- PASO 1: CALCULAR RANGO --- max_absoluto = max(abs(n) for n in lista_numeros) print(f"PASO 1: Encontrar el valor más lejano del cero (máximo absoluto).") print(f" - El valor más lejano es: {max_absoluto:.4f}") print(f" - Por lo tanto, nuestro 'mapa' irá de {-max_absoluto:.4f} a +{max_absoluto:.4f}") pausar_y_continuar("Presiona Enter para calcular la Escala...") # --- PASO 2: CALCULAR ESCALA --- escala = max_absoluto / 127 if max_absoluto > 0 else 1 print(f"PASO 2: Calcular la Escala (S).") print(f" - Dividimos el rango real ({max_absoluto:.4f}) entre el rango de enteros (127).") print(f" - Fórmula: S = max_absoluto / 127") print(f" - ✅ Escala (S) = {escala:.6f}") # En la simétrica, el punto cero es siempre 0. punto_cero = 0 print(f"\n - En la cuantización simétrica, el Punto Cero (Z) siempre es 0.") pausar_y_continuar("Presiona Enter para ver la tabla de resultados finales...") else: # tipo == 'asimetrico' print("\n" + "="*60) print("🟢 TUTORIAL: CUANTIZACIÓN ASIMÉTRICA (a uint8)") print("="*60) print("Este método crea un mapa a medida para el rango exacto de tus datos.") pausar_y_continuar("Presiona Enter para encontrar el rango...") # --- PASO 1: CALCULAR RANGO --- min_real = min(lista_numeros) max_real = max(lista_numeros) print(f"PASO 1: Encontrar el valor mínimo y máximo exacto.") print(f" - Mínimo real: {min_real:.4f}") print(f" - Máximo real: {max_real:.4f}") pausar_y_continuar("Presiona Enter para calcular la Escala...") # --- PASO 2: CALCULAR ESCALA --- rango_real = max_real - min_real escala = rango_real / 255 if rango_real != 0 else 1 print(f"PASO 2: Calcular la Escala (S).") print(f" - Dividimos el tamaño del rango real ({rango_real:.4f}) entre el de enteros (255).") print(f" - Fórmula: S = (max_real - min_real) / 255") print(f" - ✅ Escala (S) = {escala:.6f}") pausar_y_continuar("Presiona Enter para calcular el Punto Cero...") # --- PASO 3: CALCULAR PUNTO CERO --- punto_cero = round(0 - min_real / escala) if escala != 0 else 0 print(f"PASO 3: Calcular el Punto Cero (Z).") print(f" - Este valor nos dice a qué entero corresponde el 0.0 del mundo real.") print(f" - Fórmula: Z = round(0 - min_real / S)") print(f" - ✅ Punto Cero (Z) = {punto_cero}") pausar_y_continuar("Presiona Enter para ver la tabla de resultados finales...") # --- PASO FINAL: MOSTRAR RESULTADOS --- print("PASO FINAL: Aplicar las fórmulas a cada número y mostrar los resultados.") _imprimir_tabla_resultados(lista_numeros, escala, punto_cero, tipo) def _imprimir_tabla_resultados(lista_numeros, escala, punto_cero, tipo): """Función auxiliar para no repetir el código de la tabla de resultados.""" print(f"\n{'Original':>12} → {'Cuantizado':>12} → {'Recuperado':>12} | {'Error':>10}") print("-"*60) errores = [] q_min, q_max = (-127, 127) if tipo == 'simetrico' else (0, 255) for num in lista_numeros: q = round(num / escala) + punto_cero q = max(q_min, min(q_max, int(q))) recuperado = (q - punto_cero) * escala error = abs(num - recuperado) errores.append(error) print(f"{num:>12.4f} → {q:>12} → {recuperado:>12.4f} | {error:>10.6f}") print("-"*60) print(f"{'Error promedio:':>47} | {sum(errores)/len(errores):>10.6f}") print(f"\n✅ Resumen de ahorro:") print(f" • Memoria original (float32): {len(lista_numeros) * 4} bytes") print(f" • Memoria cuantizada (int8): {len(lista_numeros)} bytes") print(f" • Ahorro de memoria: 75%") # ========== BUCLE PRINCIPAL INTERACTIVO ========== if __name__ == "__main__": while True: print("\n" + "#"*60) print("### TUTORIAL INTERACTIVO DE CUANTIZACIÓN DE NÚMEROS ###") print("#"*60) numeros = obtener_numeros_del_usuario() while True: print("\n¿Qué tipo de cuantización quieres ver paso a paso?") print(" 1. Simétrica (ideal para datos centrados en cero)") print(" 2. Asimétrica (se adapta a cualquier rango de datos)") print(" 3. Ambas (para comparar)") opcion = input("Elige una opción (1, 2, o 3): ").strip() if opcion in ['1', '2', '3']: break else: print("❌ Opción no válida. Por favor, elige 1, 2, o 3.") if opcion == '1': cuantizar_paso_a_paso(numeros, 'simetrico') elif opcion == '2': cuantizar_paso_a_paso(numeros, 'asimetrico') elif opcion == '3': cuantizar_paso_a_paso(numeros, 'simetrico') cuantizar_paso_a_paso(numeros, 'asimetrico') # Preguntar si quiere volver a empezar while True: repetir = input("\n¿Quieres probar con otros números? (s/n): ").lower().strip() if repetir in ['s', 'n']: break else: print("❌ Opción no válida. Por favor, ingresa 's' para sí o 'n' para no.") if repetir == 'n': print("\n¡Hasta la próxima!") break
🧠 CUANTIZACIÓN EN MACHINE LEARNING
🔍 ¿QUÉ ES?
Técnica que reduce el uso de memoria en modelos de IA al representar números con menor precisión.
🔧 Ejemplo: Modelos como LAMA 3.1 (8B parámetros a 16 bits → 16 GB) → Cuantizados a 8 bits → Menor uso de memoria
🖥️ ¿CÓMO SE REPRESENTAN LOS DATOS EN UNA COMPUTADORA?
⚠️ Números negativos → Representados con complemento a dos → Primer bit indica el signo (0 positivo, 1 negativo)
🔢 NÚMEROS ENTEROS VS COMA FLOTANTE
📍 Enteros → más simples, menos memoria 📍 Coma flotante (IEEE 754):
🧮 Total típico: 32 bits
🔄 ¿CÓMO FUNCIONA LA CUANTIZACIÓN?
Convierte números de coma flotante → enteros Objetivo: Reducir uso de memoria sin perder precisión clave
⚙️ TIPOS DE CUANTIZACIÓN
1️⃣ Cuantización Asimétrica
2️⃣ Cuantización Simétrica
🎯 CÓMO ELEGIR ALFA Y BETA
Métodos más comunes:
✅ Percentiles → Reduce impacto de outliers
✅ MSE (Mean Square Error) → Minimiza error cuadrático medio
✅ Cross Entropy → Ideal para LLMs, mantiene distribuciones
🧪 QUANTIZATION AWARE TRAINING (QAT)
🚀 Técnica de Google DeepMind
💡 Simula cuantización durante el entrenamiento
🎯 Beneficio: Modelo aprende con precisión reducida → Al final, rendimiento estable tras cuantización
🔧 Usa el algoritmo STE (Straight-Through Estimator) → Permite hacer backpropagation pese a operaciones no derivables
🧩 ¿QUÉ SE CUANTIZA EN UNA RED NEURONAL?
🔹 Pesos (W)
🔹 Bias (b)
🔹 Entradas (X) → cuantizadas on the fly
🔹 Salidas (Y) → más complejas, requieren técnicas especializadas
✅ CONCLUSIÓN
La cuantización es clave para usar modelos grandes en dispositivos con hardware limitado, manteniendo un buen rendimiento.
Les dejo mi implementacion en un notebook de colab, para el que le sirva de referencia:
Ojala hubieran puesto la fuente de las formulas. Me tomo un rato, aun usando ChatGPT. Use puros built-ins the python para entender mejor los calculos, y segui las formulas de la clase al pie de la letra. Use el array de las capturas para validar. No es perfecto pero me parecio un buen ejercicio, en vez de usar directamete las librerias de NumPy sin saber que hay detras.
Hasta 06:19 habla sobre la representación de los números en memoria
Lo importante de la quantización es quedarnos con que nos permite reducir un LLM de 16 GB a 8, 4, etc. Muy útil para correr modelos en local con menos memoria.
Y se supone que podemos ver esos números y fórmulas microscópicas en el vídeo?
Here’s a crisp breakdown of quantization in ML models—why it’s a game-changer and how it works! 🚀🔢
1. What is Quantization?
Quantization reduces the precision of numbers in a model (e.g., from 32-bit floats → 8-bit integers) to:
2. How It Works
float[-1.8, 2.1] → int8[-128, 127] using a scale factor.3. Types of Quantization
4. Real-World Impact
¡Qué buena pregunta, Christian! Ya bajamos la teoría a tierra, ahora vamos a la práctica.
A nivel técnico, no escribes las fórmulas desde cero cada vez que quieres cuantizar un modelo. Eso sería como construir un motor desde cero para conducir un auto. Usamos bibliotecas especializadas que ya hicieron el trabajo pesado de optimización (y que manejan la magia negra de las derivadas y los Straight-Through Estimators que vimos).
En el ecosistema actual, estas son las herramientas "reales":
bitsandbytes: Es el estándar de oro hoy. Se integra con transformers de Hugging Face. Te permite cargar modelos en 4-bit o 8-bit con solo una línea de código (load_in_4bit=True).AutoGPTQ / AutoAWQ: Se usan para técnicas de cuantización post-entrenamiento específicas que mantienen la precisión muy alta.llama.cpp: Si quieres ejecutar modelos en tu propia laptop (CPU o GPU) de forma ultra eficiente, este es el motor. Es lo que usan herramientas como Ollama.¿Cómo empezar?
No reinventes la rueda. Entra al Google Colab que te dejé en los recursos de la clase. Ahí verás cómo importar bitsandbytes y cargar un modelo cuantizado.
¿Te animas a intentar implementar la lógica de la cuantización simétrica simple en Python para una lista de números, como propone el reto de la clase, o prefieres saltar directo a ver cómo se cuantiza un modelo real con bitsandbytes?
Gracias
Ayuda visual by GPT 5.2
Usando 2 registros de 64 bits se pueden "emular" números de 128 bits por ejemplo, o usar 4 registros de 64 bits para tener números de 256 bits, etc. Obviamente esto implica mucho mas procesamiento, pues dependiendo de la arquitectura del procesador no hay operaciones nativas para números mayores que el máximo numero de bits del bus, por lo tanto hacer una multiplicación entre dos números de 256 bits en arquitecturas de 64 bits, tomara muchísimo mas tiempo, que hacer una operación con un tamaño de bits nativo de la arquitectura
La cuantización de la cuantización, también conocida como "cuantización en dos fases", se refiere a un proceso donde se aplican múltiples niveles de cuantización a los datos o parámetros. Aunque es un concepto menos común, puede ser útil en ciertos contextos donde se desean optimizar aún más los modelos. Esto puede implicar cuantizar un modelo de forma más agresiva después de una primera cuantización, permitiendo un balance entre precisión y reducción de tamaño. Sin embargo, es crucial evaluar el impacto en el rendimiento y la precisión final del modelo tras este proceso.