🤖 machine learning

FairyFuse: Multiplication-Free LLM Inference on CPUs via Fused Ternary Kernels

O artigo apresenta o FairyFuse, um sistema de inferência que acelera a execução de modelos de linguagem em CPUs ao utilizar pesos ternários e fusão de kernels para eliminar multiplicações de ponto flutuante, alcançando um aumento de 29,6 vezes na velocidade do kernel e 32,4 tokens por segundo com qualidade quase sem perdas.

Autores originais: Fei Zuo, Xiaoyan Xi, Quanyi Zeng, Feiyu Wang, Ho Fai Leung

Publicado 2026-04-24

📖 5 min de leitura🧠 Leitura aprofundada

CC0 1.0

Autores originais: Fei Zuo, Xiaoyan Xi, Quanyi Zeng, Feiyu Wang, Ho Fai Leung

Artigo original dedicado ao domínio público sob CC0 1.0 (http://creativecommons.org/publicdomain/zero/1.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ê tem um livro gigante (um modelo de Inteligência Artificial) que precisa ser lido por um assistente pessoal no seu computador. O problema é que esse livro é enorme e pesado demais para a memória do computador, e a "estrada" (a largura de banda de memória) que leva as páginas até o processador está sempre congestionada.

O artigo "FairyFuse" apresenta uma solução inteligente para ler esse livro em computadores comuns (sem placas de vídeo caras), tornando a leitura muito mais rápida e eficiente.

Aqui está a explicação passo a passo, usando analogias do dia a dia:

1. O Problema: O Trânsito na Estrada

Normalmente, para fazer cálculos, o computador precisa pegar números, multiplicá-los e somá-los. Imagine que cada multiplicação é como um caminhão pesado que precisa passar por uma ponte estreita (a memória).

O gargalo: Em computadores comuns, a "ponte" (memória) é o que mais trava o processo. O computador fica esperando os dados chegarem, e não consegue calcular rápido o suficiente.
A solução atual: As pessoas tentam diminuir o tamanho dos números (compressão), mas o computador ainda precisa "traduzir" esses números pequenos de volta para o formato grande para fazer a multiplicação. É como descompactar um pacote de roupas só para dobrá-las novamente antes de guardar. Ainda é lento.

2. A Ideia Maluca: Trocar Multiplicação por "Sim/Não"

Os autores do FairyFuse olharam para um tipo especial de "livro" (chamado Fairy2i) onde os números só podem ser 1, -1 ou 0.

A analogia: Em vez de ter que multiplicar "5 vezes 3", você só precisa decidir:
- Se o número é 1: "Adicione o valor" (Pegue a página).
- Se o número é -1: "Subtraia o valor" (Desfaça a página).
- Se o número é 0: "Não faça nada" (Pule a página).
O ganho: Isso elimina completamente a necessidade de "caminhões de multiplicação". Você só precisa de caminhões de "adição" e "subtração", que são muito mais leves e rápidos.

3. A Invenção: O "FairyFuse" (A Fusão Mágica)

Aqui está a parte genial. O modelo deles é complexo e, teoricamente, exigiria fazer 8 operações separadas para cada bloco de dados. Fazer 8 operações separadas seria como enviar 8 caminhões pequenos em viagens separadas, gastando muita gasolina (memória) e tempo.

O FairyFuse cria um "caminhão de carga máxima" (um loop de processamento único) que faz tudo de uma vez só:

Empacotamento: Eles colocam 16 números minúsculos (os 1, -1 e 0) dentro de um único "contêiner" (um bloco de dados de 32 bits). É como encaixar 16 cartas de baralho em um único envelope.
Decodificação Rápida: O processador usa um truque especial (instruções de hardware chamadas BMI2) para abrir o envelope e ver instantaneamente quais cartas são "Adicionar" e quais são "Subtrair".
Fusão: Em vez de fazer 8 viagens separadas, o sistema carrega os dados uma única vez e executa todas as 8 operações de adição/subtração ao mesmo tempo, sem parar para guardar dados na memória intermediária.

4. Por que isso é melhor no Computador e não na Placa de Vídeo?

Você pode pensar: "Por que não usar uma placa de vídeo (GPU) que é super rápida?"

A Analogia da GPU: As placas de vídeo são como um exército de 10.000 operários trabalhando em uma fábrica gigante com estradas super largas. Elas são tão rápidas que o tamanho do pacote (compressão) não importa muito; elas têm estrada de sobra.
A Analogia do CPU: O processador do seu computador é como um entregador único em uma cidade com vielas estreitas. Se você reduzir o tamanho da encomenda (comprimir os dados) e eliminar a necessidade de "pesar" a encomenda (multiplicação), o entregador consegue fazer o trabalho 30 vezes mais rápido.
O Resultado: O FairyFuse mostrou que, para essa técnica específica, o processador comum (CPU) é o lugar perfeito, superando até mesmo as placas de vídeo em eficiência para essa tarefa.

5. Os Resultados: O que isso significa para você?

Velocidade: Em um servidor comum da Intel, o sistema consegue gerar 32,4 palavras por segundo. Isso é mais rápido do que os métodos atuais de compressão (como o usado no llama.cpp).
Qualidade: A inteligência da máquina não caiu. Ela ainda entende o contexto e responde bem, quase tão bem quanto se estivesse usando o modelo original gigante e pesado.
Privacidade: Como isso roda em computadores comuns sem precisar de internet ou servidores na nuvem, você pode ter um assistente de IA super rápido e privado rodando no seu próprio computador, sem vazar seus dados.

Resumo em uma frase

O FairyFuse é como transformar um caminhão de carga lento e pesado em uma moto elétrica ágil: ele remove a parte mais pesada do trabalho (multiplicação), organiza a carga de forma super compacta e usa uma única viagem eficiente para entregar o resultado, permitindo que computadores comuns rodem inteligências artificiais gigantes com velocidade impressionante.

Resumo Técnico: FairyFuse

1. O Problema

A implantação de Grandes Modelos de Linguagem (LLMs) em plataformas baseadas apenas em CPU (como assistentes locais, servidores de borda e dispositivos móveis) enfrenta um gargalo crítico: a largura de banda de memória. Durante a geração autoregressiva de tokens, a operação dominante é o produto matriz-vetor (GEMV), onde o custo é determinado pela velocidade com que os pesos podem ser lidos da DRAM, e não pela capacidade de computação de ponto flutuante.

Embora a quantização de pesos (para 4 bits ou menos) reduza a pressão de memória, os sistemas de inferência existentes ainda desquantizam esses pesos para ponto flutuante e executam multiplicações tradicionais. Isso desperdiça o potencial de economia de largura de banda.

Soluções anteriores para pesos ternários (valores $\{-1, 0, +1\}$ ), como o Fairy2i, demonstraram que é possível obter qualidade comparável ao FP16, mas seus runtimes de referência ainda utilizam rotinas padrão de ponto flutuante, não explorando a estrutura ternária no nível de hardware. Outras abordagens, como T-MAC, substituem multiplicações por tabelas de consulta (LUT), o que introduz pressão de memória no cache e acessos indiretos, limitando o desempenho em unidades SIMD largas.

2. Metodologia e Design

O FairyFuse é um sistema de inferência projetado para executar modelos LLM com pesos ternários complexos (baseados no Fairy2i) em CPUs comerciais, eliminando completamente as multiplicações de ponto flutuante.

Principais Pilares Técnicos:

Aritmética Ternária sem Multiplicação:
- Os pesos são compactados em 2 bits (16 pesos por palavra de 32 bits).
- O produto peso-ativação é substituído por uma adição condicional, subtração ou operação nula.
- Decodificação: Utiliza a instrução de hardware pext_u32 (BMI2) para extrair máscaras de bits positivos e negativos em um único ciclo.
- Acumulação: Utiliza instruções AVX-512 com máscaras (_mm512_mask_add_ps e _mm512_mask_sub_ps) para somar ou subtrair os valores de ativação diretamente, sem multiplicação.
Kernel Fundido de GEMV "Widely-Linear" (Fused Widely-Linear Kernel):
- Modelos complexos (como o Fairy2i) decompõem cada camada linear em 8 sub-GEMVs reais acoplados. Uma implementação ingênia executaria 8 loops separados, causando sobrecarga de sincronização e recarga de dados.
- O FairyFuse funde esses 8 sub-GEMVs em um único loop paralelo row-wise AVX-512.
- Otimizações de Fusão (O1-O4):
  1. Reutilização de Máscara: Um par de máscaras decodificadas serve tanto para o caminho real quanto para o imaginário.
  2. Reutilização de Vetores de Entrada: Os vetores de ativação são carregados uma única vez e compartilhados entre todos os 8 sub-GEMVs.
  3. Troca de Sinal (Sign-Swap): O conjugado complexo é tratado como um alias com sinal invertido pré-computado, eliminando negações por lane.
  4. Acumuladores Residentes em Registradores: Todas as somas parciais permanecem nos registradores AVX-512 até a redução final, evitando tráfego intermediário para a DRAM.

3. Contribuições Principais

Primeiro Kernel GEMV Ternário em x86 sem Multiplicação: Implementação que usa apenas adições/subtrações mascaradas AVX-512 e extração de bits, sem instruções de multiplicação de ponto flutuante ou tabelas de consulta (LUT) no loop interno.
Fusão de Camadas Complexas: Consolidação eficiente das 8 sub-operações de camadas "widely-linear" complexas em um único loop SIMD, reduzindo a sobrecarga de memória e sincronização.
Análise de Arquitetura (CPU vs. GPU): Demonstração de que a compactação ternária é estruturalmente benéfica para CPUs (limitadas por largura de banda de DRAM), mas ineficaz para GPUs (com largura de banda de memória abundante e falta de instruções eficientes de extração de bits paralelas como pext).

4. Resultados Experimentais

Os testes foram realizados em um Intel Xeon 8558P (48 núcleos, ~200 GB/s de largura de banda) comparando o FairyFuse com o llama.cpp (formatos Q4_K_M e Q2_K) e FP16.

Desempenho de Kernel (GEMV):
- Aceleração de 29,6x em relação ao FP32 de um único thread e até 54,4x em 48 threads para matrizes grandes.
- O loop interno contém zero instruções de multiplicação de ponto flutuante.
Throughput de Ponta a Ponta:
- 32,4 tokens/segundo em um único socket Xeon.
- 1,24x mais rápido que o llama.cpp Q4_K_M (26,15 tok/s) e 1,61x mais rápido que o Q2_K.
- Supera o Q2_K em velocidade, apesar de ter um footprint de memória ligeiramente maior (3,3 GB vs 2,8 GB), devido à eliminação da latência de computação.
Qualidade do Modelo:
- Perplexidade (WikiText-2): 5,52 (vs. 5,47 do FP16 e 5,68 do Q4_K_M).
- Acurácia Média (Downstream): 66,0% (vs. 67,3% do FP16 e 65,1% do Q4_K_M).
- A qualidade é preservada de forma "quase sem perdas", validando a eficácia da quantização ternária complexa.
Análise Roofline:
- A compactação 16x aumenta a intensidade aritmética (AI) de 0,25 para 8,0 OP/byte.
- Isso move a operação do regime "limitado por memória" para o "pico de computação" na CPU, liberando o gargalo. Na GPU, a largura de banda excessiva torna essa compressão irrelevante, e a falta de instruções pext degrada o desempenho em 130x.

5. Significado e Conclusão

O FairyFuse demonstra que CPUs são o alvo natural para quantização extrema (2 bits/ternária) de LLMs, superando GPUs nesse cenário específico devido à combinação de largura de banda de memória limitada e instruções de bit-manipulação eficientes (BMI2/AVX-512).

Ao eliminar a necessidade de multiplicações e desquantização, o sistema permite a execução interativa de modelos de bilhões de parâmetros em hardware commodity, mantendo a privacidade e a baixa latência. Isso abre caminho para assistentes pessoais totalmente offline e seguros, sem depender de GPUs dedicadas, enquanto preserva a qualidade do modelo quase ao nível de precisão completa (FP16).

Limitações Futuras: O trabalho atual foca em uma única arquitetura de instrução (x86 AVX-512) e um modelo específico (LLaMA-2-7B). Extensões para ARM (NEON) e modelos maiores (70B+) são passos naturais, assim como a adaptação para processamento de prompts em lote (GEMM).