llm-circuit-finder

J'ai reproduit la méthode RYS de Ng et découvert que dupliquer 3 couches spécifiques dans Qwen2.5-32B améliore le raisonnement de 17% et que dupliquer les couches 12-14 dans Devstral-24B améliore la déduction logique de 0,22 à 0,76 sur BBH — sans entraînement, sans modification des poids, simplement en redirigeant les états cachés deux fois à travers le même circuit. Outils inclus. Deux GPU AMD, une soirée.

llm-circuit-finder

Dupliquez 3 couches. Sans entraînement. La déduction logique passe de ~0,22 à 0,76.

Cette boîte à outils trouve et exploite les « circuits de raisonnement » cachés dans les modèles transformer. L'idée : certains blocs contigus de couches agissent comme des unités cognitives indivisibles. Dupliquez-les dans la passe avant — mêmes poids, sans entraînement, sans fusion — et le modèle devient mesurablement plus intelligent sur certaines capacités spécifiques.

Construit sur la méthode RYS de David Ng et étendu avec de nouvelles découvertes. Tout ce qui est présenté ici a été découvert sur deux GPU AMD grand public (RX 7900 XT + RX 6950 XT) en une soirée.

Résultats

Devstral-Small-2-24B : Couches 12, 13, 14 dupliquées une fois

J'ai exécuté les tests complets sur une instance H200 sur Vast.ai et comparé devstral de base avec le modèle chirurgical, et les résultats sont tombés : l'opération produit un effet réel et spécifique : elle améliore le raisonnement mathématique et causal mais au détriment du respect des instructions et de la génération de code. Le modèle réfléchit plus intensément mais suit les directives avec moins de précision.

Dans le dossier results, vous pouvez voir les résultats sous eval_base et eval_surgery. J'ai également ajouté au dépôt le script vastai_rys_eval.sh qui a été utilisé pour exécuter l'ensemble du dispositif sur Vast.ai. Instance Vast.ai créée avec :

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 : Couches 7, 8, 9 dupliquées une fois

Mesuré sur une suite de sondes personnalisée (dérivée de BBH + style EQ-Bench + GSM8K) :

Sonde	Base	+3 couches	Variation
Raisonnement (causal + logique + navigation)	76,5%	94,1%	+23%
EQ (intelligence émotionnelle)	92,1	93,6	+1,6%

Ce qui se passe

Les transformateurs s'organisent eux-mêmes pendant l'entraînement en circuits fonctionnels — des unités de traitement multi-couches qui réalisent des opérations cognitives complètes. Ces circuits sont indivisibles : dupliquer une seule couche ne fait presque rien, mais dupliquer le bloc approprié de 3 à 4 couches donne au modèle un second passage dans son pipeline de raisonnement.

Différents modèles ont des circuits différents à des endroits différents :

• Devstral-24B (40 couches) : circuit de raisonnement aux couches 12-14
• Qwen2.5-32B (64 couches) : circuit de raisonnement aux couches 7-9

Les limites sont nettes. Décaler le bloc d'une couche dans une direction ou l'autre et l'amélioration disparaît ou s'inverse.

La découverte des « modes »

Différents motifs de duplication créent des profils cognitifs distincts à partir des mêmes poids :

Motif	Maths	EQ	Caractère
Double passage 13-16	↑↑	↑	Spécialiste maths
Triple passage 13-16	↑	↑↑	Spécialiste EQ
Entrelacé 13,13,14,14,15,15,16	↑↑↑	↓	Mode maths pur
Quadruple passage 13-16	—	↑↑	Mode EQ, maths neutre

Mêmes poids sur le disque. Même VRAM pour le modèle de base. Juste un routage différent.

Démarrage rapide

Trouver des circuits dans votre modèle

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

Appliquer un circuit connu

# Dupliquer les couches 12-14 dans Devstral (le résultat validé ci-dessus)
python layer_path.py model.gguf improved.gguf \
    -p "0..14,12,13,14,15..39" -v

# Dupliquer les couches 7-9 dans Qwen2.5-32B
python layer_path.py model.gguf improved.gguf \
    -p "0..9,7,8,9,10..63" -v

# Faire des folies : triple passage, entrelacé, saut de couches, tout ce que vous voulez
python layer_path.py model.gguf experiment.gguf \
    -p "0..16,13,14,15,16,13,14,15,16,17..39" -v

Valider avec des benchmarks établis

# Démarrer le serveur avec le modèle modifié
llama-server -m improved.gguf --port 8089 -ngl 99 --device Vulkan1,Vulkan2

# Exécuter 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

# Comparer les exécutions
python compare_eval.py ./eval_base ./eval_improved

Fichiers

Fichier	Fonction
sweep.py	Harness de balayage principal — trouve les configurations de duplication de couches optimales
layer_path.py	Construit n'importe quel GGUF avec un chemin d'exécution de couches explicite
gguf_surgery.py	Duplication de couches GGUF de bas niveau (utilisé par sweep.py)
math_probe.py	Sonde d'arithmétique dure (score partiel de Ng)
eq_probe.py	Sonde d'intelligence émotionnelle (style EQ-Bench)
reasoning_probe.py	Problèmes de mots dérivés de BBH (causal, logique, navigation, math)
compare_eval.py	Compare les résultats de lm-evaluation-harness entre exécutions
visualize.py	Heatmaps textuelles et PNG des résultats de balayage

Comment fonctionne le balayage

1. Pour chaque configuration de couches (i, j) :
   • La chirurgie GGUF crée un modèle où les couches i..j-1 sont physiquement dupliquées
   • La nouvelle passe avant : layers 0..j-1 → layers i..j-1 à nouveau → layers j..N-1
   • llama-server charge le modèle modifié
   • Trois suites de sondes sont exécutées : math, EQ, raisonnement (dérivé de BBH)
   • Les scores sont comparés à la ligne de base, les résultats sont affichés en direct
   • Le serveur est tué, le GGUF modifié supprimé, configuration suivante