O que é quantização de modelo? LLMs menores e mais rápidos

Se alguma vez existisse um exemplo notável de técnica contra-intuitiva, seria a quantização de redes neurais. A quantização reduz a precisão dos pesos e outros tensores em modelos de redes neurais, muitas vezes drasticamente. Não é nenhuma surpresa que reduzir a precisão dos pesos e outros parâmetros de, digamos, números flutuantes de 32 bits para números inteiros de 8 bits, faz com que o modelo seja executado mais rapidamente e permite que ele seja executado em processadores menos potentes com muito menos memória. A descoberta surpreendente e contra-intuitiva é que a quantização pode ser feita preservando em grande parte a precisão do modelo.

Por que precisamos de quantização? Os atuais modelos de grandes linguagens (LLMs) são enormes. Os melhores modelos precisam ser executados em um cluster de GPUs de classe de servidor; Já se foi o tempo em que era possível executar um modelo de última geração localmente em uma GPU e obter resultados rápidos. A quantização não apenas torna possível executar um LLM em uma única GPU, mas também permite executá-lo em uma CPU ou em um dispositivo de ponta.

Quantização pós-treinamento

A quantização pós-treinamento é uma técnica de conversão que pode reduzir o tamanho do modelo e, ao mesmo tempo, melhorar a latência da CPU e do acelerador de hardware, com pouca degradação na precisão do modelo.

– Documentação do TensorFlow Lite

Dado o quão maduro o TensorFlow Lite é comparado, digamos, ao modelo Gen AI du jour (provavelmente o Codestral da Mistral AI, que foi lançado no dia em que escrevi isto), vale a pena observar como o TensorFlow Lite implementa a quantização. Em primeiro lugar, o TensorFlow Lite implementa três opções de quantização:

Técnica	Benefícios	Hardware
Quantização de faixa dinâmica	4x menor, aceleração de 2x a 3x	CPU
Quantização inteira completa	4x menor, 3x+ aceleração	CPU, Edge TPU, microcontroladores
Quantização Float16	2x menor, aceleração de GPU	CPU, GPU

Na árvore de decisão que acompanha esta tabela, os documentadores do TensorFlow Lite descrevem as considerações para a escolha de uma técnica de quantização. Vale a pena ler a lógica. Resumindo, o melhor método de pós-quantização para o seu caso de uso dependerá do suporte do seu hardware para operações de número inteiro ou de ponto flutuante e se você pode fornecer um conjunto de dados representativo para calibração.

Quantização de faixa dinâmica

Em seguida, eles explicam por que a quantização de faixa dinâmica é o ponto de partida usual: ela fornece uso reduzido de memória e computação mais rápida sem exigir que você forneça um conjunto de dados representativo para calibração. A quantização de faixa dinâmica quantiza estaticamente apenas os pesos de ponto flutuante para inteiro em conversão time, que fornece 8 bits de precisão. Além disso, os operadores de “faixa dinâmica” quantizam dinamicamente as ativações com base em sua faixa de até 8 bits e realizam cálculos com pesos e ativações de 8 bits. As saídas ainda são armazenadas como valores de ponto flutuante.

Quantização inteira completa

A quantização inteira completa pode acelerar ainda mais as coisas do que a quantização de faixa dinâmica, mas você precisa fornecer um conjunto de dados representativo para calibração (normalmente algumas centenas de amostras) e executar alguns ciclos de inferência para poder capturar a faixa de todos os valores de ponto flutuante. tensores no modelo. Isso inclui não apenas pesos e tendências do modelo, mas também entradas do modelo, ativações (saídas de camadas intermediárias) e saídas do modelo. A quantização completa de inteiros é essencialmente obrigatória em dispositivos somente inteiros, como microcontroladores de 8 bits, e aceleradores somente inteiros, como o Coral Edge TPU.

Flutuador16 quantização

A quantização Float16 reduz o tamanho do modelo em até metade, uma vez que todos os pesos tornam-se metade do seu tamanho original e causa perda mínima de precisão. Ele também oferece suporte a alguns “delegados” (ou seja, aceleradores no dispositivo, como GPU) que podem operar diretamente em dados float16. Por outro lado, a quantização float16 não reduz a latência tanto quanto a quantização para matemática de ponto fixo. Além disso, um modelo quantizado float16 “desquantizará” os valores de peso para float32 quando executado em uma CPU, o que é um ótimo motivo para usar um delegado de GPU, junto com o aumento de velocidade com o uso da GPU.

Quantização e precisão do modelo

Como seria de esperar, a precisão pode ser um problema ao quantizar um modelo. Você pode avaliar a precisão de um modelo quantizado em relação ao modelo original e decidir se o modelo quantizado é suficientemente preciso para seus propósitos. Por exemplo, o TensorFlow Lite oferece três executáveis ​​para verificar a precisão dos modelos quantizados. Você também pode considerar o MQBench, um benchmark e estrutura para avaliar algoritmos de quantização em implantações de hardware do mundo real que usam PyTorch.

Se a degradação na precisão da quantização pós-treinamento for muito alta, então uma alternativa é usar o treinamento consciente da quantização.

Treinamento consciente de quantização

O treinamento com reconhecimento de quantização (QAT) modela os efeitos da quantização durante o treinamento ou ajuste fino e produz um modelo com pesos float32 que podem então ser quantizados em pesos inteiros e ativações. O modelo quantizado resultante é geralmente mais preciso do que um modelo produzido por quantização pós-treinamento (PTQ) sem levar em conta a quantização durante o treinamento.

Uma maneira rápida de entender como e por que o QAT funciona é observar quando intervalos de ativação são calculados. Para quantização dinâmica pós-treinamento, o intervalo para cada ativação é calculado dinamicamente em tempo de execução. Para quantização estática pós-treinamento (chamada de quantização inteira completa acima), o intervalo para cada ativação é calculado antecipadamente no momento da quantização, usando observadores para registrar os valores das ativações. Para treinamento consciente de quantização, o intervalo para cada ativação é calculado no momento do treinamento, seguindo a mesma ideia da quantização estática pós-treinamento. A diferença é que no QAT são usados ​​operadores de “quantização falsa” em vez de observadores, não apenas para registrar valores, mas também para simular o erro induzido pela quantização, para que o modelo possa se adaptar a ele.

LLMs de 1 bit

O ponto final óbvio da tendência de quantização é um redução ao absurdo: quantização de 1 bit. Surpreendentemente, os modelos quantizados de 1 bit (introduzidos no artigo da BitNet) realmente funcionam, e os modelos de 1,58 bits (explicaremos essa fração de bit momentaneamente) são ainda melhores. Ambos os tipos de modelos foram desenvolvidos por um grupo da Microsoft Research e da Academia Chinesa de Ciências.

Primeiro, modelos quantizados de 1 bit. Para que você não tenha uma ideia errada, não, os modelos de transformadores de 1 bit BitNet não reduzem todos os tensores do modelo para 1 bit, quer queira quer não. Os pesos, e apenas os pesos, são binarizados para -1 ou 1, após centralização para média zero, e então os pesos binarizados são escalonados para reduzir o erro introduzido pela binarização.

As ativações são quantizadas para bprecisão de -bit (o artigo original usava precisão de 8 bits) após algum dimensionamento e recorte. O modelo é modificado para usar camadas BitLinear em vez de camadas nn.Linear, e uma função LayerNorm é aplicada à entrada de cada camada BitLinear. Em outras palavras, muito trabalho é feito para tornar os modelos quantizados de 1 bit competitivos com os modelos originais em precisão, ao mesmo tempo que são muito menores e mais rápidos.

Agora, sobre esse número de 1,58 bits. O papel A era dos LLMs de 1 bit: Todos os modelos de linguagem grande estão em 1,58 bits introduz uma variante LLM de 1 bit, chamada BitNet b1.58, na qual cada peso do LLM é ternário {-1, 0, 1}. Os autores dizem que são 1,58 bits, mas não mostram o cálculo.

De acordo com o artigo, BitNet b1.58 “corresponde ao Transformer LLM de precisão total (ou seja, FP16 ou BF16) com o mesmo tamanho de modelo e tokens de treinamento em termos de perplexidade e desempenho de tarefa final, ao mesmo tempo que é significativamente mais econômico em termos de latência, memória, rendimento e consumo de energia.” Os autores prosseguem dizendo que “isso permite um novo paradigma de computação e abre a porta para projetar hardware específico otimizado para LLMs de 1 bit”.

A arquitetura do BitNet b1.58 começa com BitNet, mas usa uma função de quantização diferente para chegar à representação de peso ternária e usa escala de ativação para o intervalo (−Qb,Qb) por token em vez do intervalo (0,Qb). Para ser mais compatível com modelos do tipo LLaMA, o BitNet b1.58 adiciona RMSNorm, SwiGLU e incorporação rotativa.

Os autores compararam o BitNet b1.58 com um FP16 LLaMA LLM reproduzido em vários tamanhos, treinado do zero no conjunto de dados RedPajama para 100 bilhões de tokens. A conclusão deles foi que “BitNet b1.58 começa a corresponder ao LLaMA LLM de precisão total no tamanho do modelo 3B em termos de perplexidade, sendo 2,71 vezes mais rápido e usando 3,55 vezes menos memória GPU. Em particular, o BitNet b1.58 com tamanho de modelo de 3,9B é 2,4 vezes mais rápido, consome 3,32 vezes menos memória, mas tem desempenho significativamente melhor que o LLaMA LLM 3B.”

LLMs menores e mais rápidos

Como vimos, a quantização pode ajudar a resolver alguns dos maiores problemas com grandes modelos de linguagem: os LLMs são muito grandes e muito lentos para serem executados em hardware normal, exigindo, em vez disso, clusters de GPUs na nuvem. Várias técnicas de quantização ajudam em diferentes graus, mas os emocionantes e inesperados modelos de “um bit” (ou seja, quantizações binárias de 1 bit e ternárias de 1,58 bits) estão começando a quebrar o impasse do aumento do tamanho dos modelos.