🤖 machine learning

LegoLM: Structured Weight Sharing for Large Language Models

LegoLM é uma estrutura de compartilhamento de pesos estruturado que supera as falhas de incompatibilidade distributiva e dominância de outliers do compartilhamento global de pesos por meio de adaptações livres de dados, como codificação de bloco escalar, substituição seletiva por percentil e proteção de camada de fronteira, alcançando uma compressão quase sem perdas para grandes modelos de linguagem enquanto supera significativamente os métodos PTQ-8bit existentes.

Autores originais: Joseph Bingham

Publicado 2026-08-11

📖 7 min de leitura🧠 Leitura aprofundada

CC BY 4.0

Autores originais: Joseph Bingham

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 de conhecimento massiva e intrincada em uma mochila minúscula. Este é o combate diário dos "Large Language Models" (LLMs), os cérebros de computador superinteligentes que escrevem histórias, resolvem problemas matemáticos e conversam conosco. Esses cérebros são construídos a partir de bilhões de pequenos números chamados "pesos", que atuam como as sinapses em um cérebro humano, conectando ideias. Para fazer com que esses modelos funcionem em laptops ou celulares comuns, os cientistas precisam encolhê-los sem perder sua inteligência. Uma ideia popular para encolher esses modelos é o "compartilhamento de pesos" (weight sharing). Pense nisso como um grupo de amigos que todos concordam em usar exatamente a mesma camisa de um catálogo em vez de comprar suas próprias camisas exclusivas. Em vez de armazenar um número único para cada conexão no cérebro, você armazena apenas uma pequena lista de "camisas padrão" (centroides) e uma nota dizendo: "Ei, esta conexão usa a Camisa nº 5". É uma forma inteligente de economizar espaço, mas, até agora, aplicar isso a esses cérebros de IA gigantes tem sido um desastre.

O problema é que os cérebros de IA são bagunçados. Ao contrário de um filtro de imagem simples onde cada parte é igual, diferentes camadas de um cérebro de IA têm pesos que são de tamanhos drasticamente diferentes. Tentar forçar todos eles a usarem as mesmas "camisas padrão" é como tentar colocar um elefante gigante e um ratinho minúsculo no mesmo par de sapatos; o eleffo é esmagado e o rato flutua para longe. Este artigo apresenta um novo método chamado LegoLM que corrige essa ideia quebrada. Em vez de adotar uma abordagem de tamanho único, o LegoLM age como um alfaiate inteligente. Ele percebe que, na maioria das vezes, as camisas padrão funcionam bem, mas, de vez em quando, existem pesos "outliers" — números gigantes e estranhos que são tão diferentes que arruinariam todo o visual se fossem forçados a usar uma camisa padrão. O segredo do LegoLM é deixar esses poucos pesos estranhos exatamente como estão, intocados, enquanto comprime todo o resto. O resultado é um modelo que é espremido para uma fração do seu tamanho original, mas mantém quase toda a sua inteligência, funcionando melhor do que outros métodos que exigem dados caros para serem corrigidos.

As Duas Maneiras Como o Compartilhamento de Pesos Quebra

O autor deste artigo, Joseph Bingham, descobriu que o compartilhamento global de pesos falha por duas razões específicas e distintas. Eles as chamam de "modos de falha" (failure modes), e entender isso é a chave para compreender por que o LegoLM funciona.

Modo de Falha 1: O Descompasso de Escala (O Problema do "Tamanho de Sapato Errado")
Imagine que você tem uma coleção de pesos de diferentes camadas da IA. Algumas camadas são "barulhentas" (seus números são grandes) e outras são "silenciosas" (seus números são pequenos). Se você tentar agrupá-las todas e encontrar uma única "camisa" média para um bloco inteiro delas, você encontrará um problema matemático. O artigo prova que, se você tentar comprimir um bloco de pesos que possuem tamanhos diferentes, o erro cresce linearmente com o tamanho do bloco. É como tentar tirar a média do passo de um maratonista com o passo de uma criança; não importa quantos sapatos diferentes você adicione ao seu catálogo, você não consegue fazer um sapato servir perfeitamente em ambos se forçá-los a ter o mesmo tamanho. O artigo mostra que esse descompasso cria uma confusão tão severa que a capacidade do modelo de prever texto (medida como "perplexidade") explode para os milhões, fazendo a IA falar bobagens.

Modo de Falha 2: Dominância de Outliers (O Problema do "Gigante")
Este é o fracasso mais dramático. Mesmo que você use números únicos (blocos escalares) em vez de blocos, existem alguns pesos na IA que são simplesmente enormes em comparação ao restante. Estes são os "outliers". Se você tiver um código de, digamos, 8 camisas padrão, a maior camisa do catálogo pode ser tamanho XL. Mas e se houver um peso que é tamanho 10XL? Se você forçar esse peso 10XL a usar a camisa XL, a distorção é catastrófica. O artigo mostra que, à medida que os modelos ficam maiores (de 124 milhões para 7,2 bilhões de parâmetros), esses outliers tornam-se ainda mais perigosos. Em um modelo menor, substituir esses outliers pode deixar a IA levemente confusa. Mas em um modelo gigante como o Mistral-7B, substituir esses poucos pesos gigantes faz o modelo colapsar completamente, com uma queda de qualidade de mais de 1.134.279%. É como se remover uma única pedra angular de uma catedral massiva fizesse toda a estrutura desmoronar em pó.

A Solução LegoLM: Alfaiataria Inteligente

O LegoLM corrige esses problemas com três truques simples e livres de dados (data-free). Ele não precisa olhar para nenhum dado de treinamento ou retreinar o modelo; ele apenas rearranja os pesos.

Codificação Escalar (Scalar Encoding): Em vez de agrupar pesos em blocos (o que causa o descompasso de escala), o LegoLM trata cada peso como um indivíduo. Isso elimina o problema do "tamanho de sapato errado" porque cada peso é livre para escolher a camisa padrão mais próxima sem ser arrastado por seus vizinhos.
Substituição Seletiva por Percentil (Percentile-Selective Replacement): Este é o truque de mágica. O algoritmo observa todos os pesos e encontra aqueles que estão mais distantes de qualquer camisa padrão. Estes são os "outliers". Em vez de forçá-los a usar uma camisa, o LegoLM diz: "Você é especial demais; você fica exatamente como está". Ele preserva o 1% superior desses pesos estranhos em sua forma original de alta precisão. Os outros 99% são comprimidos no pequeno código de livros.
Proteção de Camadas de Fronteira (Boundary-Layer Protection): As primeiríssimas e as últimas camadas da IA são extras sensíveis. O LegoLM dá a elas um cuidado adicional, embora o artigo note que isso é menos crítico para os maiores modelos do que a proteção de outliers.

Os Resultados: Tamanho Pequeno, Cérebros Grandes

O autor testou o LegoLM em dois modelos: GPT-2 Small (124 milhões de parâmetros) e Mistral-7B (7,2 bilhões de parâmetros). Os resultados foram surpreendentes e impressionantes.

No Mistral-7B: Usando um código de 128 valores padrão e preservando apenas 1% dos pesos outliers, o LegoLM comprimiu o modelo em 4,41 vezes. O resultado? A qualidade do modelo caiu apenas 0,03%. Isso é essencialmente uma compressão "sem perdas" (lossless). Na verdade, ele teve um desempenho melhor do que um método popular chamado PTQ-8bit, que o comprimiu apenas 4 vezes e teve um erro ligeiramente maior.
O Resgate dos Outliers: A descoberta mais dramática foi sobre os outliers. Quando tentaram comprimir o Mistral-7B substituindo todos os pesos (mesmo os gigantes) por valores padrão, a qualidade do modelo despencou 1.134.279%. Mas ao salvar esse minúsculo 1% de outliers, eles resgataram o modelo, reduzindo o erro para um nível gerenciável de 14,24%, mesmo com uma compressão massiva de 9,74x.
A Escala Importa: O artigo descobriu que o "problema do outlier" piora à medida que os modelos ficam maiores. No pequeno GPT-2, substituir os outliers causou uma queda de 23%. No gigante Mistral-7B, causou uma queda de 1.134.279%. Isso sugere que modelos maiores dependem ainda mais desses poucos números estranhos para funcionar.

Por Que Isso Importa

O LegoLM é especial porque é livre de dados (data-free). A maioria dos outros métodos de compressão precisa alimentar o modelo com milhares de frases de exemplo para descobrir como encolhê-lo. O LegoLM apenas olha para os próprios pesos e faz o cálculo. Ele pode comprimir um modelo de 7 bilhões de parâmetros em menos de 30 minutos em uma única placa gráfica.

O artigo conclui que a chave para fazer o compartilhamento de pesos funcionar não é apenas ter um catálogo de camisas melhor; é saber quando não usar o catálogo. Ao identificar e proteger os poucos pesos "gigantes" que sustentam o modelo, o LegoLM nos permite encolher esses cérebros de IA massivos para dentro de mochilas sem que eles percam a sanidade. Ele transforma um método que era anteriormente quebrado para grandes modelos em uma ferramenta competitiva e eficiente para o futuro da IA.

Resumo Técnico: LegoLM – Compartilhamento Estruturado de Pesos para Grandes Modelos de Linguagem

Declaração do Problema

Grandes modelos de linguagem (LLMs) requerem compressão agressiva para implantação prática, pois mesmo modelos de precisão de 16 bits excedem a memória de GPUs de consumo. Embora métodos de compressão pós-treinamento como quantização, poda (pruning) e fatoração de baixo posto sejam estabelecidos, o compartilhamento de pesos — onde múltiplos pesos compartilham um único valor de centroide aprendido de um código global — historicamente falhou quando aplicado a LLMs. Trabalhos anteriores aplicaram com sucesso o compartilhamento de pesos a redes convolucionais, mas sua aplicação a transformers careceu de um estudo sistemático.

Este artigo identifica que o compartilhamento de pesos global falha para LLMs devido a dois modos de falha distintos e teoricamente fundamentados:

Desajuste Distribucional: Quando os pesos são agrupados em blocos vetoriais ( $d \ge 2$ ) e agrupados globalmente, o código deve servir a camadas com escalas de pesos heterogêneas (variando em até 3 $\times$ ). Um centroide treinado em uma distribuição agregada impõe uma penalidade de desajuste de escala que cresce linearmente com a dimensão do bloco $d$ , resultando em perplexidade na casa dos milhões, independentemente do tamanho do código.
Dominância de Outliers: Em blocos escalares ( $d=1$ ), embora o desajuste de escala seja eliminado, as distribuições de pesos de LLMs contêm escalares de magnitude extrema (outliers). Para tamanhos de código pequenos ( $K$ ), uma fração de pesos ( $\approx 1/K$ ) situa-se além do limite de decisão Lloyd-Max mais externo. Substituir esses outliers pelo centroide mais próximo causa uma perda de qualidade catastrófica que se acumula através das camadas. Crucialmente, este efeito escala superlinearmente com o tamanho do modelo; a substituição total degrada um modelo de 124M de parâmetros em ~23%, mas um modelo de 7.2B de parâmetros em mais de 1.000.000%.

Metodologia: O Framework LegoLM

O LegoLM é um framework de compressão estruturado e livre de dados (data-free) projetado para resolver ambos os modos de falha simultaneamente, sem acesso a dados de calibração ou gradientes. Ele emprega três adaptações principais:

Codificação de Bloco Escalar ( $d=1$ ): Para eliminar o componente de desajuste $d$ -linear, os pesos são tratados como blocos escalares em vez de blocos vetoriais. Isso permite que cada peso seja atribuído independentemente ao seu centroide mais próximo sem se comprometer com uma escala multidimensional fixa, reduzindo substancialmente o erro de reconstrução entre camadas.
Substituição Seletiva por Percentil: Para abordar a dominância de outliers, o método identifica pesos com o maior erro de quantização (distância ao centroide mais próximo) e os preserva integralmente (armazenando-os como fp16 em vez de substituí-los por um índice de centroide). Isso atua como um proxy livre de dados para detecção de outliers baseada em magnitude. O limiar é determinado por um percentil $p$ (ex: preservando o topo de 1% dos erros).
Proteção de Camadas de Fronteira: Os primeiros e últimos blocos do transformer são identificados como desproporcionalmente sensíveis. Para modelos menores, essas camadas são excluídas da compressão para evitar o acúmulo de erro, embora este mecanismo seja considerado menos crítico para modelos maiores em comparação com a substituição seletiva.

Cálculo da Taxa de Compressão:
A taxa de compressão (CR) contabiliza o armazenamento do código global, o fluxo de índices (comprimido via codificação Huffman para reduzir o overhead) e os pesos de outliers preservados. A fórmula é:
$CR = \frac{(N_c + N_s) \cdot 32}{n_r \cdot \lceil \log_2 K \rceil + n_k \cdot 32 + K \cdot 32 + N_s \cdot 32}$
Onde $N_c$ e $N_s$ são pesos em camadas elegíveis e ignoradas, respectivamente, $n_r$ são pesos substituídos e $n_k$ são pesos de outliers mantidos exatos.

Principais Contribuições

Modos de Falha Formais: O artigo fornece caracterizações teóricas (Proposição 1 e Teorema 3) e validação empírica para dois modos de falha de compartilhamento de pesos de LLM: desajuste distribucional entre camadas (blocos vetoriais) e dominância de outliers (blocos escalares).
O Framework LegoLM: Um novo método de compressão livre de dados que combina codificação escalar, preservação seletiva de outliers e proteção de fronteira. Inclui fórmulas exatas para taxas de compressão que consideram a substituição seletiva.
Mecanismo de Resgate Invariante de Escala: A descoberta de que a dominância de outliers cresce superlinearmente com a escala do modelo. Enquanto a substituição total falha catastroficamente em modelos de 7B, preservar apenas 1% dos pesos de outliers resgata o modelo para uma qualidade quase sem perdas. Este mecanismo de resgate é consistente através de uma faixa de parâmetros de 60 $\times$ (124M a 7.2B).
Ablação de Mecanismo: Um estudo de ablação controlado demonstrando que a substituição seletiva é o mecanismo dominante para compressão livre de dados. Adicionar a substituição seletiva ao K-means por camada alcança uma qualidade quase sem perdas (+0.05% PPL), aproximando-se do abordagem global do LegoLM dentro de 0.02 pontos percentuais. A estrutura de código global oferece eficiência prática (armazenando 128 centroides em vez de 4.096), mas com diferenças de qualidade negligenciáveis quando a substituição seletiva é aplicada.

Resultados Experimentais

O framework foi avaliado no GPT-2 Small (124M), GPT-2 Medium (354M) e Mistral-7B (7.2B) utilizando o conjunto de teste WikiText-2 e tarefas downstream (LAMBADA, HellaSwag).

Desempenho do Mistral-7B:
- Quase Sem Perdas: Com $K=128, p=99\%$ , o LegoLM alcança 4.41 $\times$ de compressão com apenas +0.03% de degradação de perplexidade (PPL). Isso supera o PTQ-8bit (4.00 $\times$ , +0.04% PPL) tanto em qualidade quanto em taxa de compressão.
- Alta Compressão: Com $K=8, p=99\%$ , alcança 9.74 $\times$ de compressão com +14.24% de degradação de PPL, superando o PTQ-4bit (8.00 $\times$ , +17.85% PPL).
- Acurácia Downstream: Com $K=64, p=99\%$ (5.12 $\times$ de compressão), o modelo preserva a acurácia downstream dentro do ruído de medição, igualando a acurácia do PTQ-8bit enquanto oferece 1.28 $\times$ mais compressão.
Comparação com Baselines:
- PTQ-8bit/4bit: O LegoLM iguala ou supera sua qualidade em taxas de compressão comparáveis ou superiores sem exigir dados de calibração ou computação de Hessiana.
- Compressão Profunda (K-means por camada): Sem a substituição seletiva, o K-means por camada falha catastroficamente no Mistral-7B (ex: +930.306% PPL em $K=256$ ). Com a substituição seletiva ( $p=99\%$ ), ele recupera para uma qualidade quase sem perdas (+0.05%), confirmando a centralidade da preservação de outliers.
- Poda e Fatoração: A poda de magnitude não estruturada e a fatoração baseada em SVD falham catastroficamente no Mistral-7B em altos níveis de compressão.
Sensibilidade de Escala:
- A substituição total ( $p=100\%$ ) em $K=128$ degrada o GPT-2 Small em +23%, o GPT-2 Medium em +79%, mas o Mistral-7B em +1.134.279%.
- A substituição seletiva ( $p=99\%$ ) mantém a qualidade quase idêntica em todas as escalas (+0.03% a +0.18% de degradação de PPL).
Transição de Fase: Uma transição abrupta em robustez ocorre entre $K=4$ (falha catastrófica) e $K=8$ (funcional). Em $K=8$ , preservar 1% de outliers é suficiente para resgatar o modelo, enquanto $K=4$ permanece quebrado mesmo com 5% de preservação.

Significância e Alegações

O artigo afirma que o LegoLM estabelece um novo paradigma para a compressão de LLMs livre de dados ao abordar sistematicamente as razões teóricas pelas quais o compartilhamento de pesos global falhou anteriormente. Sua principal significância reside em:

Eficiência Livre de Dados: Alcança resultados competitivos ou superiores aos métodos calibrados (como GPTQ) sem exigir dados de calibração, gradientes ou computações de Hessiana, tornando-o aplicável em cenhas onde os dados são proprietários ou indisponíveis.
Insight Teórico: Identifica a dominância de outliers como uma lei de escala onde o acúmulo de erro cresce superlinearmente com o tamanho do modelo, necessitando de estratégias específicas de preservação.
Viabilidade Prática: Demonstra que uma combinação simples de codificação escalar e preservação seletiva de outliers pode comprimir modelos de 7B parâmetros para ~4.5 $\times$ , com perda de qualidade negligível, e até ~10 $\times$ , com utilidade funcional, tudo em menos de 30 minutos em uma única GPU.

O autor posiciona a "lei de escala de dominância de outliers" e o mecanismo de "substituição seletiva" como contribuições independentes que podem beneficiar outras técnicas de compressão (quantização, poda) que atualmente tratam todos os pesos uniformemente.