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):

Probe	Base	+3 strati	Variazione
Ragionamento (causale + logica + navigazione)	76,5%	94,1%	+23%
EQ (intelligenza emotiva)	92,1	93,6	+1,6%

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:

Pattern	Matematica	EQ	Carattere
Doppio passaggio 13-16	↑↑	↑	Specialista in matematica
Triplo passaggio 13-16	↑	↑↑	Specialista in EQ
Intercalato 13,13,14,14,15,15,16	↑↑↑	↓	Modalità puro ragionamento matematico
Quadruplo passaggio 13-16	—	↑↑	Modalità EQ, matematica neutrale

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

File	Cosa fa
sweep.py	Harness principale di sweep — trova le configurazioni ottimali di duplicazione degli strati
layer_path.py	Costruisce qualsiasi GGUF con un percorso di esecuzione esplicito degli strati
gguf_surgery.py	Duplicazione di strati GGUF a basso livello (usato da sweep.py)
math_probe.py	Sonda di aritmetica difficile (punteggio parziale di Ng)
eq_probe.py	Sonda di intelligenza emotiva (stile EQ-Bench)
reasoning_probe.py	Problemi di parole derivati da BBH (causale/logico/navigazione/matematica)
compare_eval.py	Confronta i risultati di lm-evaluation-harness tra diverse esecuzioni
visualize.py	Mappe di calore testuali e PNG dei risultati dello sweep

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