llm-circuit-finder

Eu repliquei o método RYS de Ng e descobri que duplicar 3 camadas específicas no Qwen2.5-32B melhora o raciocínio em 17% e duplicar as camadas 12-14 no Devstral-24B melhora a dedução lógica de 0,22→0,76 no BBH — sem treinamento, sem alterações de peso, apenas roteando estados ocultos através do mesmo circuito duas vezes. Ferramentas incluídas. Duas GPUs AMD, uma noite.

llm-circuit-finder

Duplique 3 camadas. Sem treinamento. Dedução lógica vai de ~0,22 → 0,76.

Este kit de ferramentas encontra e explora "circuitos de raciocínio" escondidos dentro de modelos transformer. A ideia: certos blocos contíguos de camadas atuam como unidades cognitivas indivisíveis. Duplique-os no forward pass — mesmos pesos, sem treinamento, sem merge — e o modelo fica mensuravelmente mais inteligente em capacidades específicas.

Construído sobre o método RYS de David Ng e estendido com novas descobertas. Tudo aqui foi descoberto em duas GPUs AMD de consumo (RX 7900 XT + RX 6950 XT) em uma noite.

Resultados

Devstral-Small-2-24B: Camadas 12, 13, 14 duplicadas uma vez

Executei os testes completos em uma instância H200 no Vast.ai e comparei o devstral base contra o modelo cirúrgico, e os resultados são: A cirurgia está fazendo algo real e específico: está melhorando o raciocínio matemático e o raciocínio causal, mas ao custo de seguir instruções e gerar código. O modelo pensa mais, mas segue direções com menos precisão.

Na pasta results você pode ver os resultados em eval_base e eval_surgery. Também adicionei ao repositório o vastai_rys_eval.sh, que é o script usado para rodar o pacote completo no Vast.ai. instância vastai criada com

vastai create instance somenumberhere --image vastai/base-image:cuda-12.8.1-cudnn-devel-ubuntu22.04 --disk 80 --direct --ssh

=================================================================================
lm_eval Results Comparison
=================================================================================
Metric                                              base  rys_12_15 Δ(last-first)
---------------------------------------------------------------------------------
bbh/causal_judgement [exact_match]                0.5775     0.6364     +0.0588

bbh/date_understanding [exact_match]              0.9440     0.9000     -0.0440

bbh/logical_deduction_five_objects [exact_match]     0.7440     0.7320     -0.0120

bbh/navigate [exact_match]                        0.9600     0.9440     -0.0160

gsm8k_cot [flexible-extract]                      0.8650     0.8787     +0.0136
gsm8k_cot [strict-match]                          0.8408     0.8704     +0.0296

ifeval [inst_level_loose_acc]                     0.7446     0.7206     -0.0240
ifeval [inst_level_strict_acc]                    0.6990     0.6595     -0.0396
ifeval [prompt_level_loose_acc]                   0.6728     0.6488     -0.0240
ifeval [prompt_level_strict_acc]                  0.6229     0.5767     -0.0462

mbpp [pass_at_1]                                  0.7000     0.6700     -0.0300
=================================================================================

Average (all metrics)                             0.7610     0.7488     -0.0122

Qwen2.5-Coder-32B: Camadas 7, 8, 9 duplicadas uma vez

Medido em conjunto personalizado de sondas (derivado de BBH + estilo EQ-Bench + GSM8K):

O que está acontecendo

Os transformers se organizam durante o treinamento em circuitos funcionais — unidades de processamento multicamadas que realizam operações cognitivas completas. Esses circuitos são indivisíveis: duplicar uma única camada quase não faz nada, mas duplicar o bloco certo de 3-4 camadas dá ao modelo uma segunda passagem pelo seu pipeline de raciocínio.

Diferentes modelos têm circuitos diferentes em lugares diferentes:

• Devstral-24B (40 camadas): circuito de raciocínio nas camadas 12-14
• Qwen2.5-32B (64 camadas): circuito de raciocínio nas camadas 7-9

Os limites são nítidos. Mude o bloco em uma camada para qualquer direção e a melhoria desaparece ou se inverte.

A descoberta dos "modos"

Diferentes padrões de duplicação criam perfis cognitivos distintos a partir dos mesmos pesos:

Mesmos pesos no disco. Mesma VRAM para o modelo base. Apenas roteamento diferente.

Início rápido

Encontre circuitos no seu modelo

pip install gguf requests tqdm

python sweep.py \
    --model /caminho/para/modelo.gguf \
    --llama-server /caminho/para/llama-server \
    --tmpdir /dev/shm/rys \
    --results pass.jsonl \
    --block-sizes 3 4 5 \
    --stride 1 \
    --start-min 10 --start-max 20 \
    --skip-baseline \
    --port 8099 \
    --server-args --device Vulkan1,Vulkan2

Aplique um circuito conhecido

# Duplicar camadas 12-14 no Devstral (o resultado validado acima)
python layer_path.py model.gguf improved.gguf \
    -p "0..14,12,13,14,15..39" -v

# Duplicar camadas 7-9 no Qwen2.5-32B
python layer_path.py model.gguf improved.gguf \
    -p "0..9,7,8,9,10..63" -v

# Solte a imaginação: tripla passagem, intercalado, pule camadas, o que quiser
python layer_path.py model.gguf experiment.gguf \
    -p "0..16,13,14,15,16,13,14,15,16,17..39" -v

Valide com benchmarks estabelecidos

# Inicie o servidor com o modelo modificado
llama-server -m improved.gguf --port 8089 -ngl 99 --device Vulkan1,Vulkan2

# Execute o lm-evaluation-harness
lm_eval --model local-chat-completions \
    --model_args model=test,base_url=http://localhost:8089/v1/chat/completions,num_concurrent=1,max_retries=3,tokenized_requests=False \
    --tasks gsm8k_cot,ifeval,mbpp,bbh_cot_fewshot_logical_deduction_five_objects \
    --apply_chat_template --limit 50 \
    --output_path ./eval_results

# Compare execuções
python compare_eval.py ./eval_base ./eval_improved

Arquivos

Como funciona a varredura

1. Para cada configuração de camada (i, j):

   • A cirurgia GGUF cria um modelo onde as camadas i..j-1 são fisicamente duplicadas
   • O novo forward pass: layers 0..j-1 → layers i..j-1 again → layers j..N-1
   • O llama-server carrega o modelo modificado
   • Três conjuntos de sondas são executados: matemática, EQ, raciocínio (derivado do BBH)
   • As pontuações são comparadas com a linha de base, resultados exibidos ao vivo
   • Servidor encerrado, GGUF modificado excluído, próxima configuração

2. A estratégia de busca:

   • Passo 1: Blocos grandes (8 camadas), stride largo → encontre a zona quente
   • Passo 2: Blocos pequenos (3-5 camadas), stride 1 dentro da zona quente → encontre limites exatos
   • Passo 3: Tente configurações multi-passagem, intercaladas e compostas

Os GGUFs modificados são escritos em tmpfs (/dev/shm) e excluídos após cada teste. Os pesos do modelo base permanecem no disco.

Requisitos

• Linux com llama.cpp compilado (CPU, CUDA, Vulkan ou Metal)
• Python 3.10+ com gguf, requests, tqdm
• VRAM/RAM suficiente para executar o modelo + algumas camadas duplicadas extras
• Opcional: lm-eval para validação de benchmark, matplotlib para gráficos de mapa de calor

FAQ

Isso usa mais VRAM? Sim, as camadas duplicadas são cópias físicas no GGUF. Para 3 camadas extras em um modelo de 24B, espere ~1,5 GiB adicionais. Um patch de forward-pass do llama.cpp (usando ponteiros em vez de cópias) eliminaria isso — contribuições são bem-vindas.

Isso diminui a inferência? Sim, proporcionalmente ao número de camadas extras. 3 camadas extras em um modelo de 40 camadas = ~7,5% mais lento. A melhoria no raciocínio vale a pena.

Isso funcionará no meu modelo? Provavelmente. Testamos na arquitetura Mistral (Devstral) e na arquitetura Qwen2. O trabalho original de Ng foi no Qwen2-72B. Os circuitos existem em todos os modelos transformer — a questão é onde eles estão e qual o tamanho. Execute a varredura e descubra.

Por que não fazer fine-tuning? Isso é ortogonal ao fine-tuning. Você pode fazer ambos. Na verdade, os modelos RYS de Ng foram posteriormente fine-tunados por outros e lideraram o ranking do HuggingFace. A duplicação de camadas muda a arquitetura; o fine-tuning muda os pesos. Empilhe-os.

Créditos

• David Ng pelo método RYS e pela percepção de que transformers têm neuroanatomia funcional
• llama.cpp por tornar a inferência local prática
• lm-evaluation-harness pela validação de benchmark

Licença

MIT