Ida y vuelta de cuantización int8
La misión
Problema
La cuantización guarda los pesos de un modelo como enteros pequeños más una sola escala de punto flotante. Implementa la cuantización int8 simétrica para una lista de pesos: la escala es el mayor peso en valor absoluto dividido por 127, cada peso se convierte en round(w / scale) acotado al rango de -127 a 127, y para descuantizar se vuelve a multiplicar por la escala. Devuelve los códigos enteros, la escala redondeada a 6 decimales y el mayor error absoluto entre un peso y su valor descuantizado, también redondeado a 6 decimales. Si todos los pesos son 0, usa una escala de 1.0.
Ejemplos
Input: [0.4, -2.54, 0.013, 1.0]
Output: ([20, -127, 1, 50], 0.02, 0.007)
Por qué: la escala es 2.54 / 127 = 0.02, así que 0.013 cae en 1 paso y vuelve como 0.02
Input: [0.01, 0.02, -0.03, 10.0]
Output: ([0, 0, 0, 127], 0.07874, 0.03)
Por qué: un solo valor atípico estira la escala, y todos los pesos pequeños se reducen a 0
Input: [0.0, 0.0]
Output: ([0, 0], 1.0, 0.0)
Por qué: caso límite: una lista de puros ceros no tiene un peso mayor por el que dividir, así que una escala de 1.0 evita dividir por cero
Pistas
0 / 3
La cuantización simétrica lleva el mayor peso en valor absoluto a 127 y el 0 al 0, así que un solo número, la escala, describe todo el mapeo.
Calcula scale = max(abs(w)) / 127 y luego code = round(w / scale), acotado a -127..127. Protege el caso de puros ceros antes de dividir.
Descuantiza con code × scale y compara con el peso original. El error de cualquier peso es como máximo medio paso, scale / 2.
- Tiempo objetivo
- O(n)
- Espacio objetivo
- O(n)
Solución
La cuantización int8 cambia precisión por memoria: cada peso pasa de 4 bytes a 1, y el único almacenamiento extra es una escala de punto flotante por tensor. La escala lleva el mayor peso en valor absoluto a 127, así que todos los demás pesos se expresan en pasos de ese tamaño y el redondeo puede moverlos como máximo medio paso. El segundo ejemplo muestra la debilidad de una sola escala por tensor: un valor atípico de 10.0 hace que el paso sea de unos 0.079, y todos los pesos pequeños se redondean a 0; por eso los esquemas prácticos usan una escala por canal o por bloque, o guardan los valores atípicos con más precisión. Acotar protege contra códigos que quedan apenas fuera del rango. El tiempo es O(n) y el espacio es O(n) por los códigos.
def quantize_int8(weights):
peak = max(abs(w) for w in weights)
scale = peak / 127 if peak else 1.0 # largest weight maps to 127
codes = [max(-127, min(127, round(w / scale))) for w in weights]
back = [c * scale for c in codes] # dequantize
err = max(abs(w - b) for w, b in zip(weights, back))
return codes, round(scale, 6), round(err, 6)
print(quantize_int8([0.4, -2.54, 0.013, 1.0])) # -> ([20, -127, 1, 50], 0.02, 0.007)
print(quantize_int8([0.01, 0.02, -0.03, 10.0])) # -> ([0, 0, 0, 127], 0.07874, 0.03)
print(quantize_int8([0.0, 0.0])) # -> ([0, 0], 1.0, 0.0)¿Lo que te frena es la idea y no el código? Cuantización lo explica.