Programação no Espaço de Pesos: A 3ª Alavanca para LLMs

Gradient descent nunca foi sagrado. Era um andaime: a única ferramenta geral que tínhamos para moldar bilhões de números que nenhum humano consegue ler, então construímos toda a religião do deep learning em torno dela. Uma equipe do MIT CSAIL acabou de chutar o andaime. Entregaram a um modelo de fronteira os pesos brutos de redes neurais treinadas e pediram, em linguagem natural, que ele explicasse, depurasse e reescrevesse esses pesos, sem loop de treino, sem gradientes, sem forward passes. Funcionou. Programação no espaço de pesos, raciocinar diretamente sobre parâmetros em vez de empurrá-los ladeira abaixo, saiu de experimento mental para demo, e acho que isso rebaixa discretamente o fine-tuning de “o jeito como adaptamos modelos” para uma opção entre três.

O resultado principal merece o hype que está recebendo. Pedido para melhorar o Qwen3.5-0.8B em matemática sem nenhuma atualização de gradiente, o modelo, o GPT-6 Astra, rastreou um loop patológico de raciocínio até uma única direção escrita em duas camadas MLP, subtraiu essa direção de 0,016% dos pesos e elevou a acurácia no MATH-500 de 7,9% para 48,1%. Mesmas configurações de amostragem, tudo igual. A correção ainda se transferiu para seguir instruções, triplicando o IFEval. Isso não é um ajuste de hiperparâmetro; é cirurgia. Mas antes de enterrar o gradient descent, vale ser preciso sobre o que foi de fato demonstrado, onde generaliza e onde já falha.

O que é, de fato, a programação no espaço de pesos

Por anos tivemos exatamente duas formas de mudar o que um modelo faz. O prompting muda a entrada; os pesos ficam congelados. O fine-tuning muda os pesos, mas às cegas: você mostra à paisagem de loss um lote de exemplos e deixa os gradientes empurrarem os parâmetros na direção que reduz o erro, com pouco controle sobre qual maquinaria interna é reconectada no caminho. A programação no espaço de pesos propõe uma terceira alavanca: descarte a função de loss por completo e deixe um sistema de raciocínio ler os pesos, formar uma hipótese sobre o que eles computam e editá-los para casar com uma especificação em linguagem natural.

A parte mais assustadora são os resultados de leitura. Os pesquisadores treinaram quatro políticas pequenas com PPO para jogar versões em grid-world de Breakout, Pong, Pac-Man e Freeway. Arquiteturas idênticas, mesmos canais de entrada, mesmos espaços de ação, então só os pesos podiam diferenciá-las. O Astra nomeou os quatro jogos corretamente sem receber a lista de candidatos. Fez o mesmo com modelos de difusão treinados para gerar círculos, quadrados e triângulos e, na versão difícil, identificou qual de três transformers em nível de caractere fora treinado em Python, inglês ou japonês romanizado, olhando só as camadas do meio, com embeddings e camadas de saída removidas e cada dimensão sem rótulo. No caminho, localizou todas as induction heads, os circuitos de cópia que permitem a um modelo repetir texto anterior, multiplicando matrizes de pesos. É uma técnica conhecida da literatura de interpretabilidade que ninguém havia mostrado a ele. Se você acompanhou o trabalho lento de interpretabilidade mecanística, ver um modelo de propósito geral fazer isso nativamente causa uma certa vertigem.

Depois, ele escreveu pesos. Dado um controlador de carro treinado com PPO preso em um mínimo local, a política dirigia reto na direção de uma rampa em vez de dar ré primeiro para ganhar velocidade, o Astra diagnosticou a falha a partir dos pesos mais um episódio gravado, e sua edição fez o carro ter sucesso em todos os 1.024 episódios de avaliação, após alterar 3,5% dos parâmetros. Pedido para escrever redes que jogam do zero, sem nenhum feedback do ambiente, ele produziu políticas que superaram redes treinadas com PPO por 100 milhões de passos. Leia de novo: sem interação, sem sinal de recompensa, apenas uma descrição em linguagem natural de um jogo compilada em pesos funcionais pelo raciocínio de um modelo de linguagem.

Como edições diretas de pesos funcionam em modelos reais

A correção no Qwen é o resultado que importa para quem trabalha com modelos, porque 0,8 bilhão de parâmetros é um modelo de verdade, do tipo que as equipes realmente fazem fine-tuning e colocam em produção. A falha é bem documentada: modelos pequenos de raciocínio caem em loops, repetindo o mesmo texto até atingir o limite de tokens sem nunca dar uma resposta. O próprio model card do Qwen alerta para isso, e nas execuções de teste dos pesquisadores, 85 das primeiras 96 respostas queimaram todo o contexto de 32.768 tokens dessa forma. O diagnóstico do Astra: as MLPs nas camadas 15 e 19 escreviam uma direção no residual stream que puxava o modelo de volta para a mesma trajetória generativa. A correção foi subtrair essa direção de 64 colunas de saída em cada uma dessas duas MLPs: 131.072 pesos no total, 0,016% do modelo.

A aritmética é quase ofensivamente simples, e esse é o ponto. Quando você sabe qual direção no espaço de ativações corresponde a “loopar para sempre”, remover essa direção é uma projeção: para cada vetor de pesos afetado, subtraia a componente que está ao longo da direção ruim. Qualquer pessoa consegue escrever isso em uma dúzia de linhas.

import numpy as np
def subtract_direction(W, v, columns):
"""Remove the component of each chosen column that lies along v."""
v = v / np.linalg.norm(v)
W[:, columns] -= np.outer(v, v @ W[:, columns])
return W
# The Qwen repair, schematically: for the MLP output projections of
# layers 15 and 19, subtract the "loop" direction from 64 columns each.
# 2 layers x 64 columns x 1024 rows = 131,072 edited weights.
W_down[15] = subtract_direction(W_down[15], loop_dir[15], cols[15])
W_down[19] = subtract_direction(W_down[19], loop_dir[19], cols[19])

A parte difícil nunca foi a subtração. É saber qual direção, em qual camada, dentro de um residual stream com milhares de dimensões. Essa é a parte para a qual antes precisávamos de gradient descent, porque gradientes são um procedimento de busca no espaço de pesos que não exige nenhuma compreensão. O Astra substituiu a busca por diagnóstico. É a diferença entre um eletricista que reconecta circuitos por tentativa e erro até a falha sumir e outro que lê o esquema e corta o fio certo. A mesma lógica explica por que o modelo encontrou as induction heads compondo matrizes de pesos: ele aplicou um método publicado de interpretabilidade que nunca lhe tinha sido mostrado, o que sugere transferência genuína de raciocínio em vez de receitas memorizadas.

Quando a edição direta de pesos supera o fine-tuning

Aqui está minha opinião, e vou defendê-la: para falhas estreitas e localizáveis em modelos pequenos e médios, a edição direta de pesos já é a ferramenta melhor, e não é nem perto. Considere a alternativa de fine-tuning para o bug do loop. Você montaria um dataset de traços de raciocínio sem loop, rodaria SFT ou RL e torceria para a pressão do loss remover o comportamento sem degradar todo o resto que o modelo sabe. Você queimaria horas de GPU subindo a colina em direção a um proxy, mais dados de matemática, em vez da intenção real, que é “pare de repetir a si mesmo”. A programação no espaço de pesos permite declarar a intenção. A edição tocou uma fração de centésimo por cento do modelo; um fine-tuning toca todo ele, e os danos colaterais aparecem depois como regressões estranhas que ninguém associa à rodada de treino.

Fine-tuning sobe a colina em direção a um proxy da sua intenção. A programação no espaço de pesos permite declarar a intenção.

O segundo caso é escapar de mínimos locais que métodos baseados em gradiente simplesmente não conseguem deixar. O PPO deixou o carro preso contra a rampa porque o reinforcement learning explora perturbando a política atual, e nenhuma pequena perturbação de “dirigir reto” descobre “dar ré por dois segundos antes”. Raciocínio não perturba. Ele pode pular para uma solução qualitativamente diferente porque opera sobre um modelo do problema, não sobre uma perturbação da resposta atual. Um bilhão de passos de PPO não encontrou o que uma passada de raciocínio encontrou. Isso não é uma diferença de eficiência, é uma diferença de categoria.

Terceiro, o ciclo de iteração colapsa. O fine-tuning tem uma cauda logística (curadoria de dados, rodadas de treino, varreduras de avaliação, checagens de regressão) que transforma “pequena mudança de comportamento” em um projeto de vários dias. Quem já rodou um modelo grande no próprio hardware sabe quanto do esforço é encanamento e não modelagem. Uma edição de pesos se parece mais com um hotfix de código: diagnostique, aplique o patch, rode as avaliações, reverta se estiver errado. Quando o diagnóstico está certo, você pula o pipeline de treino inteiro. As vitórias claras se concentram em quatro situações:

• A falha está diagnosticada, mas você não tem dados de treino que expressem a correção
• Você precisa de escopo cirúrgico: mudar um comportamento sem desviar o resto
• O modelo está preso em um mínimo local que a exploração aleatória não consegue escapar
• Você não pode bancar um pipeline de treino, nem em GPUs nem em tempo de calendário

Por que a programação no espaço de pesos é frágil

Agora a água fria, porque há bastante. O dado mais útil que vi não está no paper: está em um praticante que tentou o mesmo truque em um pequeno modelo de linguagem natural para bash e não ganhou nada no saldo. Editar 1.920 pesos corrigiu alguns erros de grep e quebrou outros comandos. Esse é o resultado esperado, e revela o problema profundo: os comportamentos em redes treinadas são emaranhados. A correção no Qwen funcionou porque o comportamento de loop por acaso vivia em uma direção compacta e removível. Muitos comportamentos não vivem. Eles estão espalhados em superposição, com as mesmas colunas carregando múltiplas features não relacionadas, então subtrair uma “direção” é como tentar tirar uma nota de um acorde. Você vai cortar as outras. Ninguém tem uma teoria para prever de antemão quais falhas são geometricamente compactas e quais estão espalhadas. Até termos essa teoria, cada edição de pesos é uma aposta.

As demos de leitura também merecem desconto. O raciocínio do Astra sobre as redes de jogos se apoiou em estatísticas de superfície (onde os pesos da primeira camada se concentram, quais logits de saída se separam), e a identificação de idioma foi, na prática, uma múltipla escolha de três opções em que uma delas, o japonês romanizado, tem uma distribuição de letras gritantemente incomum (sem q, l, v ou x). Reconhecimento de padrões impressionante? Com certeza. Evidência de compreensão nativa profunda do espaço de pesos? Menos claro. O resultado de difusão corta dos dois lados: o Astra desenhou todas as formas como contornos, quando os modelos de fato geram formas preenchidas. É um erro que prova que ele estava lendo geometria em vez de simular a rede, mas também mostra que sua “compreensão” pode estar estruturalmente errada de maneiras que ainda passam no teste.

Depois, há escala e procedência. Todo resultado limpo fica entre 17 mil e 7 milhões de pesos, com o Qwen de 0,8B como outlier, e até o experimento de leitura das camadas do meio precisou de até uma centena de execuções de análise em Python para chegar lá. Ninguém mostrou isso funcionando em um modelo de 70B, muito menos em um de fronteira, e a abordagem ingênua, colar os pesos em uma janela de contexto, morre bem antes disso. Uma pergunta incômoda também paira sobre tudo: de onde veio essa capacidade? LLMs suspeitamente bons em xadrez costumam ter devorado muita notação de xadrez no treino. Se o Astra foi treinado deliberadamente com dados de pesos, esses resultados dizem menos sobre compreensão emergente e mais sobre um currículo muito bom. Sinceramente, não sabemos.

Por fim, o salto no MATH-500 precisa de um asterisco. Esse benchmark está saturado por dados de treino há anos, e um modelo base com 7,9% quase certamente está falhando em loops e formatação, não em habilidade matemática. Isso significa que a edição desbloqueou uma capacidade latente em vez de criar habilidade. Ainda assim é valioso, porque desbloquear é uma vitória real. Mas é uma afirmação diferente de “a edição tornou o modelo melhor em matemática”, e se encaixa em um padrão conhecido em que benchmarks deixam de fora a maior parte do que é trabalho real.

Edições de pesos em produção: trate como hotfixes

Se você quer testar isso (e em modelos pequenos, deveria), trate as edições de pesos com a disciplina que aplicaria a um hot patch em um banco de dados rodando. Faça diff de tudo: registre exatamente quais tensores mudaram e em quanto, porque 0,016% é pequeno o bastante para que um bug silencioso no seu script de edição fique escondido para sempre. Avalie de forma ampla, não só o comportamento-alvo; o fix no Qwen melhorou por acaso o seguimento de instruções, mas o sinal desse efeito colateral foi sorte, e na próxima vez pode ir na direção oposta. Mantenha o checkpoint base intocável e versione cada edição como um patch reversível. E calibre a ambição: o ponto ótimo demonstrado são falhas pequenas e bem compreendidas, em modelos que você consegue avaliar por completo. Se a sua intuição é consertar um problema vago de “vibe” num modelo de 70B “removendo a direção ruim”, você está prestes a aprender sobre superposição do jeito difícil.

• Fixe o checkpoint base; guarde edições como diffs, nunca sobrescreva no lugar
• Rode avaliações amplas antes e depois, não só o benchmark-alvo
• Prefira falhas com assinatura nítida e reproduzível a vibes
• Reserve orçamento para reverter: assuma que alguma fração das edições vai quebrar algo

Minha posição honesta: hoje isso é um instrumento de interpretabilidade e um bisturi de depuração, não um pipeline de deploy. As equipes que extraírem valor primeiro não serão as que enviarão edições de pesos para produção. Serão as que usarem um modelo de fronteira para explicar o que seus modelos pequenos aprenderam, lendo checkpoints do mesmo jeito que já lemos traços de raciocínio, e então agindo sobre esse conhecimento com ferramentas comuns, chatas e confiáveis.

Gradientes não morreram: foram rebaixados

É aqui que minha afirmação inicial desmorona, e quero ser honesto sobre isso. Gradient descent faz algo que a programação no espaço de pesos não consegue: aprende a partir de dados em escala. Cada capacidade que o Astra usou para fazer essas edições foi, ela mesma, instalada por gradientes sobre um corpus de treino enorme. Raciocínio pode fazer cirurgia no que uma rede sabe; não consegue ensinar a uma rede a soma do texto humano. O futuro realista não é a substituição dos gradientes, e sim uma divisão de trabalho. Os gradientes preparam o concreto; a programação no espaço de pesos faz o acabamento fino. Por quarenta anos tratamos os pesos treinados como um artefato opaco, uma caixa-preta que só dava para dirigir de fora. A ideia genuinamente nova aqui é que a caixa está ficando legível, e quem a está lendo não somos nós. Se isso é tranquilizador ou alarmante provavelmente depende de quanto você confiava nos gradientes.