🤖 machine learning

CubicQuant: Parametric Non-Uniform Codebooks for High-Throughput LLM Inference with 1-8-Bit Weights

A CubicQuant introduz um formato escalar não uniforme paramétrico que mapeia códigos de magnitude uniformemente espaçados para níveis de reconstrução adaptativos por meio de uma curva cúbica monotônica, permitindo a inferência eficiente de LLMs de 1-8 bits com erro de reconstrução reduzido em comparação com a quantização inteira uniforme e de ponto flutuante finito, enquanto mantém a executabilidade direta em GPU.

Autores originais: Xuetian Gao

Publicado 2026-08-10

📖 9 min de leitura🧠 Leitura aprofundada

CC BY 4.0

Autores originais: Xuetian Gao

Artigo original sob licença CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ Esta é uma explicação gerada por IA do artigo abaixo. Não foi escrita nem endossada pelos autores. Para precisão técnica, consulte o artigo original. Ler aviso legal completo

Imagine que você está tentando encaixar uma biblioteca massiva de livros em uma mochila minúscula. No mundo da inteligência artificial, esses "livros" são os bilhões de números (chamados de pesos) que compõem um Grande Modelo de Linguagem (LLM) — o tipo de IA que escreve histórias, responde perguntas e conversa com você. Para fazer esses modelos de IA rodarem rápido em computadores, cientistas tentam encolher esses números, um processo chamado quantização. Pense nisso como comprimir uma foto de alta definição em um arquivo menor para que ela carregue rapidamente no seu celular.

No entanto, existe um equilíbrio delicado. Se você encolher os números demais ou de forma muito rígida, perderá detalhes importantes e a IA começará a cometer erros bobos. Se mantê-los muito grandes, o computador ficará sobrecarregado e rodará lentamente. Tradicionalmente, os cientistas usaram duas formas principais de encolher esses números: Quantização Uniforme, que é como usar uma régua com espaçamento perfeitamente igual (simples, mas rígida) e Ponto Flutuante, que é como uma régua flexível que estica em alguns lugares e encolhe em outros (mais flexível, mas mais difícil de usar). A grande questão sempre foi: Podemos ter um formato que seja tão flexível quanto a régua elástica, mas tão fácil de usar quanto a simples?

É aqui que um novo método chamado CubicQuant entra em cena. É como inventar uma régua mágica e metamorfa que pode se dobrar para se ajustar exatamente à forma dos dados que está medindo, mantendo-se ao mesmo tempo simples o suficiente para um computador ler instantaneamente. O pesquisador por trás deste artigo, Xuetian "Ellot" Gao, propõe um sistema que utiliza uma curva matemática especial (uma curva cúbica) para decidir como empacotar esses números. Em vez de forçar cada grupo de números em uma linha reta e rígida, o CubicQuant permite que as "marcas da régua" se aglomerem onde os dados são densos e se espalhem onde são esparsos, tudo isso mantendo os dados compactados de forma apertada em uma grade regular.

O artigo constata que esta abordagem funciona surpreendentemente bem. Quando testaram em diferentes tipos de distribuições de dados (como a curva de sino de uma distribuição normal ou os picos agudos de uma distribuição de Laplace), o CubicQuant reduziu o erro na reconstrução dos números originais em quantidades significativas — até 28,14% melhor do que os métodos padrão para certos tipos de dados. Também mostrou que este formato pode ser executado diretamente em placas gráficas modernas (GPUs) sem a necessidade de desempacotar tudo primeiro, o que é uma grande vitória para a velocidade. No entanto, o autor é cuidadoso ao notar que, embora os números pareçam ótimos em simulações e testes isolados, eles ainda não provaram que isso torna a IA "mais inteligente" ou mais rápida em uma aplicação real e completa, como conversar com um usuário. Os resultados são promissores e matematicamente sólidos, mas o teste final de se isso mudará o mundo da IA ainda está por vir.

A Magia da "Régua Metamorfa"

Para entender por que o CubicQuant é importante, vamos olhar como ele resolve o "Problema da Mochila" da IA.

Os Velhos Modos: Rígido vs. Bagunçado
Imagine que você tem um saco de bolinhas de gude de diferentes tamanhos. Você quer empacotá-las em uma caixa.

Quantização Uniforme é como usar uma caixa com prateleiras fixas e igualmente espaçadas. Se suas bolinhas forem todas do mesmo tamanho, isso é perfeito. Mas se você tiver uma mistura de pedregulhos minúsculos e pedregulhos gigantes, ou desperdiça espaço nas pedras grandes ou esmaga as pequenas. É simples e rápido, mas não se adapta à forma das suas coisas.
Codebooks Aprendidos (Learned Codebooks) são como contratar um embalador profissional que olha para cada bolinha de gude e molda uma prateleira personalizada para ela. Isso é incrivelmente eficiente, mas é lento, bagunçado e exige muitas notas extras (metadados) para lembrar onde tudo vai. É difícil para um computador ler rapidamente.

A Solução CubicQuant
O CubicQuant é o melhor dos dois mundos. Ele utiliza um codebook paramétrico não uniforme. Essa é uma maneira sofisticada de dizer que ele usa uma "régua metamorfa".

Em vez de prateleiras fixas, ele usa uma linha curva e suave (uma curva cúbica) para decidir onde as prateleiras ficam.
Esta curva é controlada por apenas dois parâmetros de forma e um fator de escala para cada pequeno grupo de pesos (um "grupo").
Pense nisso como uma régua flexível que pode dobrar. Se os dados estiverem amontoados perto do zero (como muitos números pequenos), a régua dobra para colocar mais "marcas" (níveis de reconstrução) bem ali. Se os dados estiverem espalhados nas caudas, a régua estica.
Crucialmente, essa dobra é controlada por uma fórmula simples. O computador não precisa de uma tabela de consulta gigante; ele apenas calcula a curva em tempo real. Isso mantém os dados compactados de forma apertada (como um fluxo de inteiros regular), mas permite que eles se adaptem às estatísticas locais do modelo de IA.

Como Funciona: A Estratégia de "Grupo"

O artigo explica que os pesos do modelo de IA são divididos em pequenos grupos (como grupos de 128 ou 256 números). Para cada grupo, o CubicQuant calcula:

Uma Escala: O quão grandes são os números neste grupo no geral.
Dois Coeficientes de Forma (a e b): Eles dizem à curva como dobrar. Um controla a inclinação inicial e o outro controla a curvatura.

Isso significa que, mesmo que todo o modelo tenha bilhões de números, o computador só precisa armazenar uma quantidade mínima de informação extra (metadados) para cada grupo para saber como "dobrar" a régua para aquele trecho específico. O artigo observa que, para um tamanho de grupo de 128, isso adiciona apenas 0,5 bits de overhead por peso (além da carga útil de 4 bits), tornando-o muito eficiente.

Os Resultados: Menores Erros, Mesma Velocidade

O pesquisador realizou experimentos para ver quão bem esta nova régua funciona em comparação com as antigas. Eles testaram em três tipos de distribuições de dados:

Uniforme: Dados espalhados uniformemente.
Gaussiana: A clássica "curva de sino" (a maioria das coisas é média, poucas são extremas).
Laplace: Uma distribuição com um pico agudo e caudas pesadas (muitos números pequenos, mas alguns outliers muito grandes).

As Descobertas:

Para Dados Uniformes: Como os dados já são uniformes, a régua flexível não ajuda muito. Ela tem o mesmo desempenho que a régua rígida.
Para Dados Gaussianos e Laplace: É aqui que o CubicQuant brilha. Como essas distribuições têm muitos números agrupados perto do zero e menos nas caudas, a régua flexível pode agrupar as "marcas" perto do zero para capturar os detalhes melhor.
- Em dados Gaussianos, ele reduziu o erro em 13,49% em comparação com o método padrão.
- Em dados Laplace, a melhoria foi ainda maior, em 28,14%.
- Também superou os melhores formatos de "ponto flutuante" (que já são bastante flexíveis) em 6,27% a 9,44%, dependendo da largura de bits.

O artigo enfatiza que estes são simulações e provas matemáticas de quão bem os números podem ser reconstruídos. Ele não afirma que isso torna a IA mais inteligente ou melhor em seguir instruções. A "qualidade" das respostas da IA (perplexidade, raciocínio, etc.) ainda é uma questão aberta.

Os "Dois Caminhos" para Rodar a IA

Um dos recursos mais legais do CubicQuant é que ele suporta duas maneiras diferentes de rodar a IA em um computador, e se ajusta perfeitamente a ambas:

Caminho Model-Dtype: O computador reconstrói os números exatamente como eles são (usando matemática de ponto flutuante). Isso é bom para a precisão.
Caminho Dynamic-A8: O computador mapeia os números para um formato padrão de inteiro de 8 bits (INT8) em tempo real. Isso é ótimo para a velocidade, porque os computadores modernos possuem hardware especial (Tensor Cores) que é super rápido ao realizar cálculos com inteiros de 8 bits.

O artigo mostra que o CubicQuant pode ser "ajustado" para funcionar bem para ambos os caminhos ao mesmo tempo. É como projetar uma chave que serve em duas fechaduras diferentes. O pesquisador descobriu que, para tarefas pequenas, o método padrão é mais rápido, mas conforme a tarefa fica maior (mais linhas de dados), o caminho Dynamic-A8 torna-se significativamente mais rápido (até 4,46x mais rápido em alguns testes em uma GPU NVIDIA H200).

O Que Ele Não Faz (A Lista do "Não")

É importante saber o que o CubicQuant não faz, de acordo com o artigo:

Não é uma solução mágica para a inteligência da IA. O artigo afirma explicitamente que eles não mediram se isso torna a IA mais inteligente ou melhor em seguir instruções. Essa é uma questão futura.
Não é um aumento de velocidade universal. Os ganhos de velocidade dependem fortemente da forma dos dados e do tipo de chip de computador. Para tarefas muito pequenas, o método padrão ainda pode ser mais rápido.
Não resolve o problema da "Ativação Persistente". O pesquisador tentou manter os números comprimidos na memória entre as etapas para economizar espaço, mas isso na verdade tornou as coisas mais lentas porque o computador gastava muito tempo gerenciando os dados. Por isso, eles descartaram isso por enquanto.

Conclusão

O CubicQuant é uma nova e inteligente maneira de empacotar pesos de IA que utiliza uma curva matemática simples para se adaptar à forma dos dados. Ele oferece um ponto ideal: é flexível o suficiente para capturar detalhes melhor do que os métodos rígidos, mas simples o suficiente para rodar rápido em computadores modernos. A matemática faz sentido, as simulações mostram grandes melhorias na precisão e os primeiros testes de velocidade em GPUs poderosas são promissores. Mas, como qualquer nova ferramenta, ele precisa de mais testes no mundo real para ver se realmente muda a forma como construímos e usamos a IA. Por enquanto, é um candidato muito forte para a próxima geração de modelos de IA eficientes.

Resumo Técnico: CubicQuant

Declaração do Problema

A inferência de Grandes Modelos de Linguagem (LLMs) requer o equilíbrio entre dois objetivos conflitantes: os níveis de reconstrução dos pesos quantizados devem se adaptar às variações das estatísticas locais dos pesos do modelo (que frequentemente seguem distribuições não uniformes como Gaussiana ou Laplace), mas a representação deve permanecer compacta e regular o suficiente para execução direta em hardware de alto rendimento (GPU).

Os métodos de quantização escalar existentes ocupam pontos distintos nesse espectro de compensação:

Quantização Inteira Uniforme: Oferece empacotamento denso e aritmética simples, mas restringe cada grupo a uma grade linear, falhando em capturar eficientemente distribuições de pesos não uniformes.
Ponto Flutuante de Baixo Bit (ex: FP8): Redistribui os níveis por meio de uma estrutura de expoente-mantissa fixa, favorecendo uma faixa dinâmica predeterminada, mas carecendo de flexibilidade para estatísticas de pesos específicas.
Codebooks Aprendidos (Learned Codebooks): Ganham flexibilidade ao aprender todos os níveis, mas sofrem com decodificação irregular, estruturas de metadados complexas e má conformidade com as rotas padrão de produto escalar de GPUs.

O desafio é criar um formato que retenha a regularidade dos códigos inteiros para execução eficiente em GPU, enquanto permite que os níveis de reconstrução se adaptem parametricamente às estatísticas locais dos pesos.

Metodologia: CubicQuant

O CubicQuant introduz um formato escalar não uniforme paramétrico que preserva um fluxo de código inteiro denso enquanto adapta os níveis de reconstrução independentemente dentro de cada grupo de pesos.

1. Representação

Payload: Os pesos são armazenados como códigos inteiros com sinal ( $k$ ) variando de $-M$ a $M$ (onde $M = 2^{B-1}-1$ para largura de bit $B$ ). O formato suporta payloads de 1 a 8 bits.
Função de Nível Paramétrica: Em vez de uma grade linear, os níveis de reconstrução são determinados por uma curva cúbica monotônica. Para uma magnitude normalizada $t = |k|/M$ $t = ∣ k ∣/ M$ , a função de reconstrução é:
$q(t) = t [a + t (b + ct)]$
onde $c = 1 - a - b$ $c = 1 - a - b$ .
- Parâmetros: Cada grupo armazena dois coeficientes de forma adimensionais ( $a, b$ ) e uma escala FP32 ( $s$ ).
- Restrições: A curva é restrita para ser monotônica ( $q'(t) > 0$ ) e satisfaz $q(0)=0$ e $q(1)=1$ . Isso garante o zero exato e os pontos finais exatos ( $\pm s$ ).
- Caso Especial: A quantização inteira simétrica uniforme é um caso especial exato desta família onde $a=1, b=0$ .

2. Metadados e Armazenamento

Agrupamento (Grouping): Os pesos são divididos em grupos de tamanho $G$ .
Metadados: Cada grupo armazena uma escala FP32 e dois coeficientes de forma FP16.
Largura Efetiva: O armazenamento total por peso é $B + 64/G$ bits. Este custo de metadados explícito contrasta com metadados ocultos em médias de nível de modelo ou tabelas de consulta complexas.

3. Objetivos de Ajuste (Fitting)

O artigo define duas estratégias principais de ajuste:

Objetivo de Referência Contínua: Minimiza o Erro Quadrático Médio (MSE) entre os pesos originais e os níveis de reconstrução contínuos da Cubic. Este é um estimador livre de dados (data-free) para pesos.
Objetivo de Portadora Consciente de Dinâmica-A8 (Dynamic-A8 Carrier-Aware): Para suportar a execução com ativações quantizadas em INT8 dinamicamente, o objetivo de ajuste é modificado para minimizar o erro conjunto tanto da reconstrução contínua quanto de sua projeção em uma grade portadora INT8 com sinal ( $r(k) = \text{round}(127 \cdot \text{sign}(k) \cdot q(|k|/M))$ ). Isso permite que um único checkpoint serializado sirva tanto aos caminhos de execução de model-dtype quanto de Dynamic-A8.

3. Execução em GPU

O CubicQuant evita a materialização de tensores de peso de precisão total. Em vez disso, emprega decodificação e computação fundidas (fused decode-and-compute):

Reconstrução Local ao Tile: Kernels de GPU carregam payloads empacotados e metadados de grupo, reconstroem níveis (via tabelas de consulta ou avaliação de Horner) e os consomem imediatamente em loops de produto escalar.
Caminhos Duplos:
- Caminho Model-Dtype: Reconstrói valores contínuos para ativações FP16/BF16.
- Caminho Dynamic-A8: Mapeia níveis reconstruídos para portadoras INT8 para produtos escalares inteiros, acumulando em INT32 antes do reescalonamento.
Seleção de Kernel: A implementação utiliza seleção de kernel dependente da forma e do dispositivo (ex: GEMV estreito vs. tiling denso) para otimizar o desempenho através de diferentes contagens de linhas e larguras de bit.

Principais Contribuições

Família de Codebooks Paramétricos: Uma família de codebooks escalares não uniformes, simétricos e por grupo, de dois parâmetros, que contém a quantização inteira com sinal uniforme como um caso especial exato.
Formato Empacotado: Um formato de checkpoint abrangendo pesos de 1 a 8 bits com escalonamento FP32 e um custo de armazenamento de forma fechada ( $B + 64/G$ bits/peso).
Procedimentos de Ajuste: Um procedimento de ajuste de referência por grupo e um objetivo consciente da portadora Dynamic-A8, ambos separáveis de estimadores de erro baseados em dados mais ricos.
Execução Direta em GPU: Implementação de kernels de peso empacotado para ativações de Model-Dtype e Dynamic-A8, com calibração dependente do dispositivo.
Evidência Analítica e Empírica: Derivação da distorção populacional sob distribuições Uniforme, Gaussiana e Laplace, juntamente com medições preliminares de kernel H200.

Resultados

Análise de Distorção Teórica

Distribuição Uniforme: A grade linear (Uniform INT) é o ótimo populacional. O CubicQuant iguala esse desempenho, confirmando que não degrada o desempenho para dados uniformes.
Distribuições Gaussiana e Laplace:
- O CubicQuant supera significativamente a quantização inteira uniforme clipada de forma ótima.
- Ele recupera 84,8%–96,1% da lacuna entre inteiros uniformes e o codebook Lloyd–Max livre ideal para distribuições Gaussianas (W4–W8).
- Ele recupera 91,4%–96,9% da lacuna para distribuições Laplace.
- Supera os melhores formatos de ponto flutuante enumerados (ex: E2M5) em todas as larguras de bit testadas para essas distribuições.

Experimentos de Grupo Finito

Em experimentos com $G=128$ e 15.360 amostras:

Desempenho W4: Em relação aos inteiros uniformes de 4 bits clipados de forma ótima, o CubicQuant reduziu o RMSE de reconstrução em:
- 3,90% em amostras Uniformes.
- 13,49% em amostras Gaussianas.
- 28,14% em amostras de Laplace.
Comparação com FP: Em relação ao melhor formato de ponto flutuante enumerado de 4 bits, as reduções foram de 3,90% (Uniforme), 9,44% (Gaussiana) e 6,27% (Laplace).
Mecanismo: Os ganhos em dados Uniformes surgem da adaptação às flutuações de amostras finitas dentro dos grupos, embora o ótimo populacional seja linear.

Desempenho de Kernel (H200)

Crossover Dependente de Carga de Trabalho: Medições preliminares em uma GPU H200 revelam um crossover entre a execução Model-Dtype (A16) e Dynamic-A8.
- Para GEMV estreito (pequenas contagens de linhas, $M=1$ ), a execução Model-Dtype é mais rápida devido aos menores custos de configuração.
- À medida que a contagem de linhas aumenta ( $M \ge 16$ ), o Dynamic-A8 torna-se favorável, com acelerações variando de 1,6x a 4,4x, dependendo da largura de bit e da forma.
Resultado Negativo: Um design experimental de "portadora de ativação persistente" (mantendo as ativações INT8 entre operadores) falhou em melhorar o desempenho devido aos custos de sincronização e redução superarem as economias de largura de banda.

Significância e Alegações

O artigo afirma estabelecer a promessa representacional e o caráter executável do formato CubicQuant.

Adaptabilidade sem Complexidade: O CubicQuant demonstra que uma curva paramétrica compacta pode recuperar grande parte da adaptabilidade de um codebook livre sem abandonar o fluxo de bits escalar regular necessário para a execução eficiente em GPU.
Compatibilidade de Caminho Duplo: O formato suporta com sucesso tanto a execução contínamente de Model-Dtype quanto a execução baseada em inteiros de Dynamic-A8 a partir de uma única representação serializada.
Escopo Modesto: O autor afirma explicitamente que o artigo não reivindica:
- Melhorias na qualidade do modelo downstream (perplexity, raciocínio, etc.) não foram medidas.
- Um aumento de velocidade universal de ponta a ponta; o desempenho depende da carga de trabalho.
- Aplicabilidade universal em todas as gerações de GPU (a evidência é limitada a Hopper/H200).
- Que o estimador de referência livre de dados é superior aos métodos baseados em ativação ou de segunda ordem; o formato é projetado para ser compatível com eles.

Em resumo, o CubicQuant oferece um meio-termo entre grades fixas e codebooks livres, fornecendo uma abordagem paramétrica, matematicamente fundamentada, para a quantização de pesos que é diretamente executável nas arquiteturas de GPU modernas.