Ida e volta da quantização int8
A missão
Problema
A quantização guarda os pesos de um modelo como inteiros pequenos mais uma escala em float. Implemente a quantização int8 simétrica para uma lista de pesos: a escala é o maior peso em valor absoluto dividido por 127, cada peso vira round(w / scale) limitado ao intervalo de -127 a 127, e a desquantização multiplica de volta pela escala. Retorne os códigos inteiros, a escala arredondada para 6 casas decimais e o maior erro absoluto entre um peso e o seu valor desquantizado, também arredondado para 6 casas decimais. Se todos os pesos forem 0, use uma escala de 1,0.
Exemplos
Input: [0.4, -2.54, 0.013, 1.0]
Output: ([20, -127, 1, 50], 0.02, 0.007)
Por quê: a escala é 2,54 / 127 = 0,02, então 0,013 cai em 1 passo e volta como 0,02
Input: [0.01, 0.02, -0.03, 10.0]
Output: ([0, 0, 0, 127], 0.07874, 0.03)
Por quê: um único outlier estica a escala, e todo peso pequeno colapsa para 0
Input: [0.0, 0.0]
Output: ([0, 0], 1.0, 0.0)
Por quê: edge case: uma lista só de zeros não tem um maior peso para dividir, então uma escala de 1,0 evita a divisão por zero
Dicas
0 / 3
A quantização simétrica leva o maior peso em valor absoluto para 127 e o 0 para 0, então um único número, a escala, descreve o mapeamento inteiro.
Calcule scale = max(abs(w)) / 127 e depois code = round(w / scale), limitado a -127..127. Trate o caso de todos os pesos zero antes de dividir.
Desquantize com code × scale e compare com o peso original. O erro de qualquer peso é no máximo meio passo, scale / 2.
- Tempo-alvo
- O(n)
- Espaço-alvo
- O(n)
Solução
A quantização int8 troca precisão por memória: cada peso encolhe de 4 bytes para 1, e o único armazenamento extra é uma escala em float por tensor. A escala leva o maior peso em valor absoluto para 127, então todos os outros pesos são expressos em passos desse tamanho, e o arredondamento pode deslocá-los no máximo meio passo. O segundo exemplo mostra a fraqueza de uma única escala por tensor: um outlier de 10,0 faz o passo ficar em torno de 0,079, e todo peso pequeno é arredondado para 0; é por isso que os esquemas usados na prática têm uma escala por canal ou por bloco, ou mantêm os outliers em precisão maior. Limitar os códigos ao intervalo protege contra valores logo fora dele. O tempo é O(n) e o espaço é O(n) para os 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)Travou na ideia, e não no código? Quantização explica isso.