llm-circuit-finder

Ho replicato il metodo RYS di Ng e ho scoperto che duplicare 3 strati specifici in Qwen2.5-32B migliora il ragionamento del 17% e duplicare gli strati 12-14 in Devstral-24B migliora la deduzione logica da 0.22→0.76 su BBH — nessun addestramento, nessun cambiamento di pesi, solo reindirizzamento degli stati nascosti attraverso lo stesso circuito due volte. Strumenti inclusi. Due GPU AMD, una serata.

llm-circuit-finder

Duplica 3 strati. Nessun addestramento. La deduzione logica passa da ~0,22 → 0,76.

Questo toolkit trova e sfrutta i "circuiti di ragionamento" nascosti all'interno dei modelli transformer. L'idea: certi blocchi contigui di strati agiscono come unità cognitive indivisibili. Duplicarli nel forward pass — stessi pesi, nessun addestramento, nessun merging — e il modello diventa misurabilmente più intelligente su capacità specifiche.

Basato sul metodo RYS di David Ng e ampliato con nuove scoperte. Tutto ciò che è qui è stato scoperto su due GPU consumer AMD (RX 7900 XT + RX 6950 XT) in una serata.

Risultati

Devstral-Small-2-24B: Strati 12, 13, 14 duplicati una volta

Ho eseguito i test completi su un'istanza H200 su Vast.ai e ho confrontato devstral base con il modello sottoposto a chirurgia; i risultati sono i seguenti: L'intervento sta facendo qualcosa di reale e specifico: potenzia il ragionamento matematico e causale, ma a scapito della capacità di seguire le istruzioni e della generazione di codice. Il modello pensa più a fondo ma segue le direttive con meno precisione.

Nella cartella "results" puoi vedere i risultati in eval_base e eval_surgery. Ho anche aggiunto al repository vastai_rys_eval.sh, lo script utilizzato per eseguire l'intero pacchetto su Vast.ai. Istanza Vast.ai creata con

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: Strati 7, 8, 9 duplicati una volta

Misurato con suite di probe personalizzate (derivate da BBH + stile EQ-Bench + GSM8K):

Cosa sta succedendo

I transformer si organizzano durante l'addestramento in circuiti funzionali — unità di elaborazione multi-strato che eseguono operazioni cognitive complete. Questi circuiti sono indivisibili: duplicare un singolo strato non fa quasi nulla, ma duplicare il blocco giusto di 3-4 strati dà al modello un secondo passaggio attraverso la sua pipeline di ragionamento.

Modelli diversi hanno circuiti diversi in posti diversi:

• Devstral-24B (40 strati): circuito di ragionamento agli strati 12-14
• Qwen2.5-32B (64 strati): circuito di ragionamento agli strati 7-9

I confini sono netti. Spostare il blocco di uno strato in una direzione o nell'altra e il miglioramento scompare o si inverte.

La scoperta delle "modalità"

Diversi modelli di duplicazione creano profili cognitivi distinti a partire dagli stessi pesi:

Stessi pesi su disco. Stessa VRAM per il modello base. Semplicemente routing diverso.

Avvio rapido

Trova circuiti nel tuo modello

pip install gguf requests tqdm

python sweep.py \
    --model /path/to/model.gguf \
    --llama-server /path/to/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

Applica un circuito noto

# Duplica gli strati 12-14 in Devstral (il risultato validato sopra)
python layer_path.py model.gguf improved.gguf \
    -p "0..14,12,13,14,15..39" -v

# Duplica gli strati 7-9 in Qwen2.5-32B
python layer_path.py model.gguf improved.gguf \
    -p "0..9,7,8,9,10..63" -v

# Sperimenta: triplo passaggio, intercalato, salta strati, qualsiasi cosa vuoi
python layer_path.py model.gguf experiment.gguf \
    -p "0..16,13,14,15,16,13,14,15,16,17..39" -v

Convalida con benchmark consolidati

# Avvia il server con il modello modificato
llama-server -m improved.gguf --port 8089 -ngl 99 --device Vulkan1,Vulkan2

# Esegui 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

# Confronta le esecuzioni
python compare_eval.py ./eval_base ./eval_improved

File

Come funziona lo sweep

1. Per ogni configurazione di strati (i, j):

   • La chirurgia GGUF crea un modello in cui gli strati i..j-1 sono fisicamente duplicati
   • Il nuovo forward pass: layers 0..j-1 → layers i..j-1 di nuovo → layers j..N-1
   • llama-server carica il modello modificato
   • Vengono eseguite tre suite di sonde: matematica, EQ, ragionamento (derivato da BBH)
   • I punteggi vengono confrontati con il baseline, i risultati stampati in tempo reale
   • Il server viene fermato, il GGUF modificato cancellato, si passa alla configurazione successiva

2. La strategia di ricerca:

   • Passo 1: Blocchi grandi (8 strati), passo ampio → individuare la zona calda
   • Passo 2: Blocchi piccoli (3-5 strati), passo 1 all'interno della zona calda → trovare i confini esatti
   • Passo 3: Provare configurazioni multi-passaggio, intercalate e composte

I GGUF modificati vengono scritti su tmpfs (/dev/shm) e cancellati dopo ogni test. I pesi del modello base rimangono su disco.

Requisiti

• Linux con llama.cpp compilato (CPU, CUDA, Vulkan o Metal)
• Python 3.10+ con gguf, requests, tqdm
• VRAM/RAM sufficiente per eseguire il modello + alcuni strati duplicati aggiuntivi
• Opzionale: lm-eval per la convalida dei benchmark, matplotlib per i grafici a mappa di calore

Domande frequenti

Questo utilizza più VRAM? Sì, gli strati duplicati sono copie fisiche nel GGUF. Per 3 strati aggiuntivi su un modello da 24B, aspettati circa 1,5 GiB in più. Una patch di forward-pass di llama.cpp (che usi puntatori anziché copie) eliminerebbe questo problema — contributi benvenuti.

Questo rallenta l'inferenza? Sì, proporzionalmente al numero di strati extra. 3 strati extra su un modello a 40 strati = ~7,5% più lento. Il miglioramento nel ragionamento ne vale la pena.

Funzionerà sul mio modello? Probabilmente. Abbiamo testato sull'architettura Mistral (Devstral) e sull'architettura Qwen2. Il lavoro originale di Ng era su Qwen2-72B. I circuiti esistono in tutti i modelli transformer — la domanda è dove si trovano e quanto sono grandi. Esegui lo sweep e scoprilo.

Perché non fare fine-tuning invece? Questo è ortogonale al fine-tuning. Puoi fare entrambi. Anzi, i modelli RYS di Ng sono stati successivamente sottoposti a fine-tuning da altri e hanno raggiunto la vetta della classifica HuggingFace. La duplicazione degli strati cambia l'architettura; il fine-tuning cambia i pesi. Impilali.

Crediti

• David Ng per il metodo RYS e l'intuizione che i transformer hanno una neuroanatomia funzionale
• llama.cpp per aver reso pratica l'inferenza locale
• lm-evaluation-harness per la convalida dei benchmark

Licenza

MIT