🤖 machine learning

Targeted Recovery of Weight-Space Mechanisms From Neural Networks

Este artigo apresenta a Decomposição de Parâmetros Direcionada (tPD), um método escalável que isola circuitos computacionais específicos dentro de grandes redes neurais ao utilizar um componente abrangente de alto posto para lidar com dados não visados, permitindo assim a recuperação eficiente e a manipulação cirúrgica de mecanismos com custo computacional significativamente reduzido.

Autores originais: Antoine Vigouroux, Lee Sharkey

Publicado 2026-07-16

📖 8 min de leitura🧠 Leitura aprofundada

CC BY 4.0

Autores originais: Antoine Vigouroux, Lee Sharkey

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ê tem uma biblioteca mágica gigante onde cada livro foi escrito por um robô superinteligente que aprendeu a falar lendo quase tudo na internet. Esse robô, conhecido como um Grande Modelo de Linguagem (ou LLM), é incrivelmente bom em terminar suas frases, escrever código ou contar histórias. Mas aqui está o detalhe: ninguém realmente sabe como ele faz isso. É como uma caixa preta. Você insere uma pergunta e uma resposta perfeita sai, mas as engrenagens girando lá dentro são uma confusão de bilhões de minúsculos interruptores (chamados de parâmetros) que nenhum humano consegue ler facilmente.

Cientistas que estudam a "interpretabilidade mecânica" são como detetives tentando desmontar essa caixa preta para ver as engrenagens. Eles querem encontrar os pequenos circuitos específicos dentro do cérebro do robô que são responsáveis por tarefas específicas, como saber que "Paris" é a capital da "França" ou saber como escrever uma linha de CSS. Um método recente chamado "Decomposição de Parâmetros" tenta fazer isso decompondo o cérebro do robô em partes minúsculas de propósito único. No entanto, esse método é como tentar mapear cada rua de um país imenso apenas para encontrar a rota para sua padaria local — leva uma enorme quantidade de tempo, dinheiro e poder computacional. É tão caro que é atualmente impossível fazer isso para os robôs mais inteligentes e gigantes que existem.

É aqui que entra um novo artigo de Antoine Vigouroux e Lee Sharkey. Eles propõem um atalho inteligente chamado "Decomposição de Parâmetros Direcionada" (ou tPD). Em vez de tentar mapear todo o cérebro do robô de uma só vez, eles perguntam: "E se nós só nos importarmos com a forma como o robô lida com uma coisa específica, como um código CSS ou um truque matemático específico?" O método deles constrói uma rede de segurança gigante que captura tudo o que o robô faz fora dessa única coisa, permitindo que os cientistas foquem sua energia apenas nas engrenagens específicas que importam. Eles testaram isso em cérebros de robôs menores e descobriram que funciona tão bem quanto o método caro de mapeamento total, mas utiliza uma fração minúscula do poder computacional. Na verdade, eles foram capazes de remover cirurgicamente a memória do robô sobre comandos específicos (como "import numpy as") e até mesmo trocá-los para que o robô dissesse "import pandas as", tudo sem quebrar a capacidade do robô de fazer qualquer outra coisa. É uma forma de realizar uma cirurgia cerebral delicada em IA sem precisar de um hospital inteiro de equipamentos.

A Grande Ideia: A Rede de Segurança "Captura-Tudo"

Pense em uma rede neural (o cérebro do robô) como uma orquestra massiva. Cada instrumento (ou peso) desempenha um papel na criação da música. O modo antigo de entender essa orquestra era tentar escrever a partitura para cada instrumento tocando cada nota em todas as músicas possíveis. Esta é a "decomposição de modelo total" que os autores mencionam. É preciso, mas é como tentar transcrever uma sinfonia enquanto a banda está tocando mil músicas diferentes ao mesmo tempo. Leva uma eternidade e exige uma equipe enorme de músicos (computadores) para acompanhar.

Os autores perceberam que, se você só quer entender como a orquestra toca uma música específica (como um trecho de código CSS), você não precisa transcrever o concerto inteiro. Você só precisa saber quais instrumentos estão tocando essa música. Mas há um problema: se você ouvir apenas essa música, pode pensar que um instrumento está tocando uma nota quando, na verdade, ele está apenas emitindo um som devido ao eco da sala. Você não consegue dizer se um instrumento é realmente importante para aquela música ou se ele está apenas lá pelas outras músicas.

Para resolver isso, os autores inventaram um componente "captura-tudo". Imagine que você está gravando a orquestra. Você coloca um microfone nos instrumentos específicos que lhe interessam (o "alvo"), mas também coloca um cobertor gigante e super sensível de cancelamento de ruído sobre o resto do palco. Este cobertor (chamado de componente $\Delta$ ) captura todos os sons dos outros instrumentos que não fazem parte da sua música alvo.

Ao treinar o sistema com dois fluxos de dados ao mesmo tempo — a música específica que você quer estudar e uma mistura enorme de outras músicas aleatórias — o cobertor "captura-tudo" aprende a absorver tudo o que não é o alvo. Isso força os microfones específicos a captarem apenas os instrumentos que são verdadeiramente essenciais para a sua música alvo. Se um instrumento é usado apenas para as outras músicas, o cobertor o engole, e os microfones permanecem silenciosos. Isso significa que os cientistas podem encontrar os "circuitos" exatos para uma tarefa específica sem precisar mapear toda a orquestra.

O Que Eles Descobriram: Velocidade, Precisão e Cirurgia

A equipe testou essa ideia em alguns modelos de brinquedo (robôs simples e pequenos) e descobriu que funcionava perfeitamente. Quando pediram ao sistema para olhar apenas para três características específicas, ele encontrou exatamente os três mecanismos necessários, ignorando os outros 97. Foi como encontrar três chaves específicas em um chaveiro gigante sem ter que olhar para as outras 97 chaves. Não apenas encontraram as chaves certas, mas fizeram isso muito mais rápido — cerca de cinco vezes mais rápido que o método antigo — e precisaram de um computador muito menor para realizar o trabalho.

Eles então passaram para um modelo de linguagem real, um transformer de 4 blocos treinado em um conjunto de dados massivo chamado "The Pile". Eles queriam ver se conseguiam isolar os mecanismos que lidam com código CSS. Usando o método direcionado, conseguiram extrair um submodelo "apenas-CSS". Esse submodelo utilizou apenas cerca de 7% do poder de computação (FLOPs) do método de decomposição total.

Os resultados foram impressionantes. Quando rodaram o modelo apenas-CSS em código CSS, ele funcionava exatamente como o robô original. Mas quando tentaram fazê-lo falar inglês ou Python, ele desmoronava completamente, muitas vezes apenas repetindo a palavra "the" ou "count". Isso provou que eles haviam isolado com sucesso o "cérebro de CSS" do resto do robô. Ainda mais legal, eles descobriram subcomponentes específicos responsáveis por coisas como reconhecer indentação em código CSS, mas não em código Python. Quando desligaram esses componentes específicos, o rob em parou de entender a indentação de CSS, mas sua habilidade de escrever código Python permaneceu perfeitamente intacta.

O Teste Supremo: Cirurgia Cerebral em um Modelo de 12 Blocos

A parte mais emocionante do artigo aconteceu quando aplicaram isso a um modelo maior, um transformer de 12 blocos com 85 milhões de parâmetros de não-embedding. Eles focaram em uma tarefa muito específica: o hábito do robô de completar a frase "import numpy as" com "np" e "import pandas as" com "pd". Estes são comandos comuns em programação Python.

Usando o método direcionado, identificaram 248 subcomponentes específicos responsáveis por essas complementações. Em seguida, realizaram uma "cirurgia" digital.

Primeiro, eles ablaram (desligaram) os componentes específicos de "numpy". O resultado? O robô não conseguia mais completar "import numpy as" com "np". Era como se a memória dessa associação específica tivesse sido apagada. Mas aqui está a magia: a habilidade do robô de escrever todo o resto — texto em inglês, outros códigos, frases aleatórias — permaneceu completamente intocada. Ele não ficou confuso nem começou a cometer erros em outros lugares.

Depois, tentaram algo ainda mais ousado: reconfigurar (rewiring). Como cada componente possui uma direção de "entrada" e uma direção de "saída", eles trocaram as direções de saída dos componentes de "numpy" e "pandas". Eles essencialmente disseram à parte de "numpy" do cérebro para falar com a voz do "pandas", e vice-versa.

O resultado foi bizarro e perfeito. Quando você digitava "import numpy as", o robô agora completava com "pd". Quando você digitava "import pandas as", ele completava com "np". Ele não apenas cometeu um erro; ele genuinamente trocou o conhecimento. E, novamente, essa mudança foi incrivelmente específica. O comportamento do robô no restante da internet (mais de 100.000 tokens de dados gerais) permaneceu quase idêntico ao original. Os "efeitos colaterais" foram insignificantes.

Por Que Isso Importa (e o Que Não Importa)

Este artigo sugere que não precisamos esperar por supercomputadores para mapear todo o cérebro de uma IA gigante para entendê-la ou editá-la. Podemos dar zoom em comportamentos específicos, isolar as engrenagens que os fazem funcionar e até mesmo ajustá-los, tudo isso enquanto mantemos o resto da máquina funcionando suavemente.

No entanto, os autores são cuidadosos para não prometer demais. Eles observam que este método funciona melhor para tarefas específicas e bem definidas, como sequências memorizadas (como "import numpy") ou tipos de código específicos (como CSS). Eles admitem que editar "conhecimento de mundo" complexo (como fatos sobre história ou ciência) pode ser mais difícil porque o céreamente pode usar múltiplas formas redundantes para armazenar o mesmo fato. Se o robô tem duas engrenagens diferentes que fazem o mesmo trabalho, desligar uma pode não impedir o robô de realizar a tarefa, pois a outra engrenagem assumirá o controle. Eles também apontam que o modelo mais largo que utilizaram ainda era minúsculo comparado aos modelos de "fronteira" usados hoje, então podem surgir novos desafios ao escalar.

Mas, por enquanto, esta "Decomposição de Parâmetros Direcionada" é uma nova ferramenta poderosa. É como ter um bisturi em vez de um martelo. Em vez de tentar entender todo o robô de uma vez, agora podemos levantar suavemente a tampa, olhar exatamente para a parte de que estamos curiosos e talvez até dar um pequeno empurrão, tudo sem quebrar o resto da máquina.

Resumo Técnico: Recuperação Direcionada de Mecanismos de Espaço de Pesos de Redes Neurais

Declaração do Problema

A Decomposição de Parâmetros (PD) é uma técnica para engenharia reversa de redes neurais que decompõe matrizes de pesos em subcomponentes interpretáveis de rank-1 ( $U_c V_c^\top$ ) que implementam papéis funcionais únicos. Embora a PD tenha sido aplicada com sucesso a modelos de brinquedo (toy models) e escalonada para pequenos transformers (ex: um modelo de 4 blocos com 28M de parâmetros), escalar essa abordagem para LLMs de fronteira apresenta obstáculos significativos. A decomposição do modelo completo exige recursos computacionais vastos, tornando isso um empreendimento caro e arriscado. Além disso, sem uma verdade fundamental (ground truth) para guiar a engenharia de tais decomposições em larga escala, o panorama de otimização torna-se cada vez mais difícil de navegar. Os métodos existentes exigem que a decomposição reconstrua o comportamento do modelo em toda a sua distribuição de entrada, um requisito que pode ser desnecessário para objetivos específicos de interpretabilidade.

Metodologia: Decomposição de Parâmetros Direcionada (tPD)

Os autores propõem a Decomposição de Parâmetros Direcionada (tPD), uma variante da PD que identifica seletivamente mecanismos que processam um subconjunto específico de dados (os "dados alvo") em vez de toda a distribuição de entrada.

Mecanismo Central

A PD padrão treinada apenas em dados alvo produz uma solução subdeterminada: embora reconstrua as saídas alvo, os subcomponentes ficam não restringidos em direções ortogonais ao subespaço de ativação dos dados alvo. Isso leva a efeitos imprevisíveis ao ablar componentes em entradas não alvo.

Para resolver isso, a tPD treina em dois fluxos de dados paralelos:

Fluxo Alvo: Um conjunto menor de dados de entrada que o usuário deseja explicar (ex: prompts ou subtarefas específicas).
Fluxo Não Alvo: Dados amostrados da distribuição de treinamento original do modelo.

O modelo de decomposição aproxima a matriz de peso original $W$ como:
$W \approx W' = \sum_{i=1}^{C} m_i U_i V_i^\top + m_\Delta \left( W - \sum_{i=1}^{C} U_i V_i^\top \right)$
Onde:

$U_i V_i^\top$ são os subcomponentes esparsos de rank-1 destinados a capturar mecanismos ativos nos dados alvo.
$\Delta = W - \sum U_i V_i^\top$ é um componente de rank total, "pega-tudo" (catch-all) que captura todos os mecanismos não explicitamente decompostos (ou seja, aqueles inativos nos dados alvo).
$m_i$ e $m_\Delta$ são máscaras controladas por uma rede de importância causal auxiliar e otimização adversarial.

Dinâmica de Treinamento

Nos Dados Alvo: O componente $\Delta$ é ablado adversarialmente (máscaras definidas entre 0 e 100%) para maximizar a perda de reconstrução. Isso força o modelo a reconstruir as saídas alvo usando apenas o conjunto esparso de subcomponentes de rank-1.
Nos Dados Não Alvo: O componente $\Delta$ é totalmente habilitado ( $m_\Delta = 1$ ). Os subcomponentes de rank-1 são permitidos a ativar, mas não são obrigados a somar aos pesos originais.
Restrições Adversariais: Tanto os subcomponentes inativos quanto o componente $\Delta$ são ablados adversarialmente para garantir que as saídas do modelo permaneçam inalteradas para qualquer híbrido de matrizes originais e abladas. Isso impõe a fidelidade mecanística, garantindo que os subcomponentes identificados sejam causalmente importantes e que o componente $\Delta$ não interfira nos mecanismos alvo.
Importância-Minimalidade: A função de perda minimiza o número de subcomponentes ativos. Mecanismos ativos apenas em dados não alvo são empurrados para o componente $\Delta$ , enquanto mecanismos ativos em dados alvo são moldados para interferir minimamente nos dados não alvo.

Principais Contribuições

Estrutura de Decomposição Direcionada: Introdução da tPD, que desacopla a necessidade de decomposição de modelo completo da capacidade de extrair circuitos interpretáveis para tarefas específicas.
2.O Componente $\Delta$ : Uma adição arquitetônica inovadora que lida com dados não alvo, resolvendo o problema da subdeterminação inerente ao treinamento de PD em conjuntos de dados estreitos.
Eficiência: Demonstração de que a tPD reduz significativamente os requisitos computacionais (pegada de memória e passos de otimização) em comparação com a PD de dados completos.
Edição Mecanística: Demonstração de que a tPD permite intervenções cirúrgicas (ablação e reconfiguração/rewiring) em mecanismos específicos com efeitos colaterais negligenciáveis em entradas não relacionadas.

Resultados

1. Validação em Modelo de Brinquedo (TMCC)

No Modelo de Computação Comprimida de Brinquedo (TMCC), a tPD recuperou com sucesso os mecanismos de verdade fundamental para um subconjunto de 3 recursos de entrada de um total de 100.

Precisão: Identificou exatamente os três mecanismos que processam os recursos alvo sem ativação espúria em entradas não alvo.
Eficiência: O modelo de decomposição exigiu significativamente menos slots de subcomponentes (tão pouco quanto 5 vs. 100) e convergiu em ~500 passos comparado a ~2.500 passos para a PD de dados completos.

2. Consistência em Transformers

Validado em um transformer de 4 blocos treinado no The Pile:

Reprodutibilidade: Decomposições inicializadas a partir de diferentes sementes aleatórias convergiram para circuitos altamente similares (alta similaridade de cosseno nos vetores $U$ e $V$ ) ao visar prompts como "import numpy as" e "import pandas as".
Composicionalidade: As decomposições de conjuntos alvo aninhados (ex: {numpy, pandas} vs. {numpy} sozinho) foram coerentes, com a decomposição conjunta contendo a união dos componentes encontrados nas decomposições individuais.

3. Extração de Submodelo Apenas-CSS

Os autores extraíram um submodelo contendo apenas mecanismos que processam código CSS de um transformer de 4 blocos.

Eficiência de Recursos: Isso exigiu apenas ~7% dos FLOPs da decomposição de dados completos publicada.
Desempenho: O modelo "Apenas-CSS" (usando apenas os 1.638 subcomponentes identificados) igualou o desempenho do modelo original em dados de CSS (divergência KL ≈ 0,6) enquanto colapsou em outras linguagens (divergência KL ≥ 2), isolando efetivamente a computação específica de CSS.
Especificidade: Ablar subcomponentes específicos (ex: aqueles que lidam com indentação ou unidades em CSS) degradou o desempenho de CSS, mas deixou outras linguagens inalteradas, demonstrando alta especificidade mecanística.

4. Edição de Conhecimento em um Transformer de 12 Blocos

Aplicado a um transformer de 12 blocos (85M de parâmetros) para editar sequências memorizadas ("import numpy as" $\to$ "np" e "import pandas as" $\to$ "pd").

Ablação: Os autores identificaram 248 subcomponentes específicos para esses prompts. Ablar estes subcomponentes suprimiu completamente a capacidade do modelo de completar essas sequências, mantendo o comportamento em dados gerais do Pile (KL < $10^{-2}$ ).
Reconfiguração (Rewiring): Ao trocar as direções de saída (vetores $U$ ) de subcomponentes específicos, os autores reconfiguraram com sucesso o modelo para produzir "pd" para "import numpy as" e "np" para "import pandas as". Esta mudança foi altamente específica, com efeitos colaterais negligenciáveis em contextos não relacionados.
Comparação: Uma decomposição "naïve" (dados alvo apenas, sem $\Delta$ ) resultou em fortes efeitos colaterais em dados não alvo quando ablada, confirmando a necessidade da estrutura tPD.

Significância e Alegações

O artigo afirma que a tPD é uma ferramenta prática para interpretabilidade de escopo estreito, permitindo localização de circuitos, desaprendizado (unlearning) e edição em escalas onde a PD de dados completos é atualmente inviável. Sugere que a tPD pode servir como um precursor para a decomposição de dados completos, trazendo à tona fatos sobre modelos alvo que podem ancorar esforços de engenharia maiores.

Os autores permanecem modestos quanto ao escopo de suas alegações:

Granularidade: Subcomponentes de tPD processam a fatia do espaço de ativação abrangida pelos dados alvo e não são necessariamente idênticos aos subcomponentes de dados completos.
Complexidade: Os casos de edição demonstrados envolvem sequências curtas e específicas de tokens. Editar conhecimento de mundo complexo pode exigir uma engenharia mais elaborada.
Redundância: O artigo reconhece que, se um modelo utiliza mecanismos redundantes para uma tarefa, a tPD (assim como a PD de dados completos) pode recuperar apenas um subconjunto, potencialmente perdendo alguns mecanismos que são absorvidos pelo componente $\Delta$ .
Escala: Os maiores modelos testados (comparáveis ao GPT-2-small) ainda são pequenos para os padrões de fronteira; escalar a tPD ainda pode revelar desafios imprevistos.

Em resumo, a tPD oferece um caminho computacionalmente eficiente para realizar engenharia reversa de comportamentos específicos em redes neurais sem o custo proibitivo de decompor todo o modelo, desde que os dados alvo sejam escolhidos para capturar totalmente o comportamento de interesse.