💬 NLP

Depth Registers Unlock W4A4 on SwiGLU: A Reader/Generator Decomposition

Este artigo demonstra que a decomposição leitor-gerador em modelos SwiGLU, combinada com uma intervenção de treinamento chamada "Depth Registers", mitiga drasticamente a degradação de perplexidade causada pela quantização W4A4 ao controlar especificamente a magnitude dos "leitores" de ativação, embora não elimine completamente a lacuna de desempenho em relação ao modelo FP16.

Autores originais: Ziyang Liu

Publicado 2026-04-21

📖 4 min de leitura☕ Leitura rápida

CC BY 4.0

Autores originais: Ziyang Liu

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 elefante (um modelo de inteligência artificial gigante e complexo) dentro de um caixote de correio pequeno (a memória limitada de um chip de computador comum).

O papel que você apresentou é como um manual de engenharia que descobriu exatamente onde o elefante está esmagando a caixa e como consertar isso sem cortar as pernas do elefante.

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

1. O Problema: O "Esmagamento" da Informação

Os modelos de IA modernos (como os que usam a arquitetura "SwiGLU") são muito precisos quando usam números grandes e detalhados (como medir com uma régua de milímetros). Mas, para rodar rápido em celulares ou computadores baratos, precisamos usar números pequenos e arredondados (como medir com uma régua de centímetros).

O que aconteceu: Quando os pesquisadores tentaram fazer essa "troca de régua" (chamada de quantização W4A4) de forma simples, o modelo ficou completamente burro. A confusão dele saltou de um nível "perfeito" (23.6) para um nível "alucinado" (1727). Era como se o elefante tivesse entrado no caixote, mas saído como um amontoado de ossos.

2. A Descoberta: Quem é o "Vilão"?

A grande sacada do paper é que eles não olharam para o modelo como um bloco único. Eles dividiram o cérebro do modelo em dois tipos de funcionários:

Os Leitores (Readers): São os funcionários que recebem os dados brutos do mundo exterior (o que o usuário digita). Eles são "leais" e seguem as regras.
Os Geradores (Generators): São os funcionários que fazem cálculos internos complexos, misturando informações entre si.

A Analogia da Cozinha:
Imagine uma cozinha de restaurante.

Os Leitores são os garçons que trazem os pedidos da mesa. Se o gerente (o modelo) controlar o tamanho dos pedidos, os garçons ficam tranquilos.
Os Geradores são os chefs que misturam os ingredientes. O problema é que, na arquitetura SwiGLU, os chefs fazem uma "mistura explosiva" (um produto bilinear). Se um ingrediente tiver um pouco de "pimenta" (um número grande), e o outro também, a mistura explode e queima a cozinha, mesmo que os ingredientes individuais pareçam normais.

O paper descobriu que o caos todo vem dos "Chefs" (os Geradores), especificamente de uma parte chamada w2. Os "Garçons" (Leitores) estavam sendo culpados injustamente.

3. A Solução Proposta: "Caixas de Segurança" (Depth Registers)

O pesquisador criou uma técnica chamada DR+sink.

A Analogia: Imagine que o modelo tem um corredor de dados. Normalmente, se um número muito grande (um "gigante") passa por lá, ele derruba tudo.
O Truque: O pesquisador construiu um quarto especial (um registro) ao lado do corredor. Ele treinou o modelo para dizer: "Ei, se aparecer um número gigante, jogue-o imediatamente nesse quarto especial e não deixe ele tocar no corredor principal."
O Resultado: Isso limpou o corredor principal. Os "Garçons" (Leitores) agora trabalham em um ambiente calmo. A inteligência do modelo voltou a funcionar, caindo de 1727 para 119 de confusão.

4. O Grande Mistério Resolvido: Por que não ficou perfeito?

Mesmo com os "Garçons" salvos, ainda havia uma pequena confusão restante (de 119 para 39.9, e depois para perto de 23.6).

O paper fez um teste final: eles tentaram usar outras técnicas modernas (como girar os dados ou rotacionar os números) para consertar os "Chefs" (os Geradores).

A Conclusão: Nada funcionou totalmente. A "mistura explosiva" dos chefs é tão forte que girar os dados não ajuda. É como tentar apagar um incêndio girando a água: a água (os dados) continua quente, só muda de direção.
A Lição: O problema final não está no corredor (residual), mas sim na própria receita da mistura dos chefs. Para resolver isso de vez, talvez seja preciso usar uma "régua" diferente (precisão mista) apenas para essa parte específica da cozinha.

Resumo em uma frase

O papel descobriu que, ao tentar comprimir modelos de IA, a culpa não é de quem recebe os dados, mas sim de quem os mistura internamente; eles criaram um "sistema de drenagem" para limpar os dados antes da mistura, salvando 90% do problema, mas provaram que a parte final da mistura é tão complexa que técnicas de "giro" não conseguem consertá-la sozinhas.

Por que isso importa?
Isso nos diz exatamente onde focar nossos esforços para fazer IAs rodarem em celulares e laptops sem perder a inteligência, evitando tentar consertar o que já está funcionando e atacando diretamente a parte que realmente quebra.

Título: Depth Registers Unlock W4A4 on SwiGLU: Uma Decomposição Leitor/Gerador

Autor: Ziyang Liu (Pesquisador Independente)
Contexto: Quantização Pós-Treinamento (PTQ) de 4 bits para pesos e ativações (W4A4) em modelos de linguagem baseados em SwiGLU.

1. O Problema

A quantização pós-treinamento W4A4 (4 bits para pesos e 4 bits para ativações) é uma rota promissora para reduzir o custo de inferência e memória em GPUs comerciais. No entanto, modelos modernos baseados em SwiGLU (como LLaMA, Mistral, Qwen) sofrem um colapso catastrófico de desempenho quando submetidos a uma quantização "ingênua" (Round-to-Nearest, RTN).

O Fenômeno: Em um modelo controlado de 300M parâmetros treinado em 5B tokens, a perplexidade (PPL) de validação salta de 23.6 (FP16) para 1727 (W4A4 ingênuo), representando uma perda de 1 a 3 ordens de magnitude.
A Lacuna: Métodos existentes (SmoothQuant, QuaRot, AWQ) recuperam parte do desempenho, mas não isolam claramente quais partes da arquitetura são responsáveis pela maior parte do erro. Estudos observacionais anteriores identificaram "outliers" (valores extremos), mas não decomporam o dano por local de ativação de entrada.

2. Metodologia e Proposta Teórica

O artigo propõe uma decomposição operadora-nível das cinco camadas lineares treináveis em um bloco SwiGLU, dividindo-as em duas categorias baseadas na origem de suas ativações de entrada:

A. A Decomposição: Leitores vs. Geradores

Leitores (Readers): Recebem o fluxo residual (após a normalização RMSNorm).
- Camadas: qkv (atenção), w1 e w3 (FFN).
- Propriedade: Suas magnitudes são diretamente limitadas por qualquer intervenção que controle a magnitude do fluxo residual.
Geradores (Generators): Recebem quantidades geradas internamente pelo bloco.
- Camadas: o_proj (saída da atenção) e w2 (produto bilinear do SwiGLU).
- Propriedade:
  - o_proj: Limitado apenas de forma frouxa pelo fluxo residual e pelos pesos de atenção.
  - w2: Sua entrada é o produto elemento a elemento de duas saídas de leitores (silu(w1) ⊙ w3). Teoricamente, mesmo que os fatores sejam limitados, o produto bilinear pode gerar uma cauda pesada (outliers) que não é suprimida por intervenções no eixo residual.

B. A Intervenção de Treinamento: Depth Registers + Sink (DR+sink)

Para testar essa hipótese, o autor propõe uma intervenção durante o treinamento (não pós-treinamento):

Mecanismo: Divide o eixo do canal residual em uma região "semântica" e uma região de "registradores" (registers).
Função de Perda (Hinge Loss): Aplica uma penalidade de hinge para forçar a magnitude máxima dos registradores a permanecer abaixo de um limite fixo ( $\tau = 3.0$ ).
Objetivo: Os registradores atuam como um "dreno" (sink) para absorver a massa de magnitude dos outliers, mantendo os canais semânticos calibrados.
Controles: O experimento é feito em três checkpoints com PPL FP16 e capacidade zero-shot idênticos, variando apenas a configuração dos registradores.

3. Resultados Principais

Os experimentos foram realizados em um modelo de 300M parâmetros, 20 camadas, treinado em 5B tokens (FineWeb-Edu).

A. Redução Dramática da Perplexidade

Baseline (W4A4 Ingênuo): PPL de 1727.
Com DR+sink: PPL cai para 119 (redução de ~14x).
Combinado com SmoothQuant: O PPL cai ainda mais para 39.9.
Comparação: O gap residual de ~2 PPL em relação ao FP16 (23.6) é atribuído quase inteiramente ao componente w2 (Gerador).

B. Evidências Operadoras (Kurtosis e Dano)

Colapso da Kurtosis dos Leitores: A intervenção DR+sink reduz a curtose (medida de cauda pesada) das entradas dos leitores (qkv, w1, w3) de valores extremos (ex: 35.9) para quase Gaussianos (~2.85).
Estabilidade dos Geradores: A curtose dos geradores (o_proj, w2) permanece essencialmente inalterada (ex: w2 permanece em ~1860-1921), confirmando que intervenções no eixo residual não afetam a cauda do produto bilinear.
Análise de "Skip-Ablation" (Remoção):
- Manter apenas os Leitores em FP16 (quantizando o resto) reduz o PPL para ~31 em todos os checkpoints.
- Manter apenas os Geradores em FP16 não ajuda significativamente.
- O dano residual após salvar os leitores é plano (~0.28 nats) e dominado pelo w2.

C. Validação com Métodos Pós-Treinamento (QuaRot)

QuaRot (Per-Linear): Uma rotação ortogonal independente por linha substitui quase perfeitamente o DR+sink no eixo dos leitores (PPL ~25.4), confirmando que o problema dos leitores é de alinhamento/escala.
QuaRot (Full): Adiciona rotação online na entrada do w2 (dentro do FFN). O resultado não fecha o gap (PPL ~26.0), confirmando a previsão teórica de que rotações ortogonais não conseguem suprimir a cauda pesada inerente ao produto bilinear do SwiGLU.

4. Contribuições Chave

Decomposição Teórica: Estabelece formalmente a distinção entre "Leitores" (limitados pelo residual) e "Geradores" (especialmente o produto bilinear w2), explicando por que intervenções no eixo residual falham em corrigir o w2.
Probe de Treinamento (DR+sink): Apresenta um método que isola experimentalmente o dano dos leitores, reduzindo o PPL de 1727 para 119 sem usar calibração pós-treinamento ou rotações complexas.
Métrica de Dano Condicional: Introduz uma métrica de "Excesso NLL" para quantificar o dano específico de cada subconjunto de camadas, mostrando que o w2 é o principal responsável pelo erro residual.
Limitação de Rotação Ortogonal: Demonstra empiricamente que rotações ortogonais (como no QuaRot) não são suficientes para resolver a cauda pesada do produto bilinear SwiGLU, sugerindo que soluções futuras podem exigir precisão mista no w2 ou quantização durante o treinamento (QAT).

5. Significado e Conclusão

O trabalho oferece uma explicação mecanicista clara para a dificuldade de quantizar modelos SwiGLU em W4A4. A conclusão central é que o dano não é uniforme:

A maior parte do erro vem de outliers nos Leitores, que podem ser corrigidos por intervenções no eixo residual (como DR+sink ou rotação per-linear).
O erro residual inevitável (~2 PPL) vem do produto bilinear no w2, que amplifica outliers de forma não linear e não é suprimido por rotações ortogonais simples.

Isso sugere que, para atingir a quantização W4A4 perfeita em modelos SwiGLU, não basta apenas rotacionar ou escalar; é necessário tratar especificamente a camada de saída do FFN (w2), possivelmente mantendo-a em precisão superior ou utilizando técnicas de treinamento específicas para controlar o produto bilinear.

Nota de Limitação: Os resultados são específicos para um modelo de 300M parâmetros e 5B tokens (single-seed). O autor recomenda replicação em modelos maiores (7B-70B) para confirmar a generalização.