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

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 :

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

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

2. La stratégie de recherche :

   • Passe 1 : Grands blocs (8 couches), grand pas → trouver la zone chaude
   • Passe 2 : Petits blocs (3-5 couches), pas de 1 dans la zone chaude → trouver les limites exactes
   • Passe 3 : Essayer des configurations multi-passes, entrelacées et composées

Les GGUF modifiés sont écrits sur tmpfs (/dev/shm) et supprimés après chaque test. Les poids du modèle de base restent sur le disque.

Prérequis

• Linux avec llama.cpp compilé (CPU, CUDA, Vulkan ou Metal)
• Python 3.10+ avec gguf, requests, tqdm
• Assez de VRAM/RAM pour exécuter le modèle + quelques couches dupliquées supplémentaires
• Optionnel : lm-eval pour la validation des benchmarks, matplotlib pour les graphiques heatmap

FAQ

Cela utilise-t-il plus de VRAM ? Oui, les couches dupliquées sont des copies physiques dans le GGUF. Pour 3 couches supplémentaires sur un modèle de 24B, attendez-vous à ~1,5 Go supplémentaires. Un patch de passe avant llama.cpp (utilisant des pointeurs au lieu de copies) éliminerait ce problème — les contributions sont les bienvenues.

Cela ralentit-il l'inférence ? Oui, proportionnellement au nombre de couches supplémentaires. 3 couches supplémentaires sur un modèle de 40 couches = ~7,5% plus lent. L'amélioration du raisonnement en vaut la peine.

Cela fonctionnera-t-il sur mon modèle ? Probablement. Nous avons testé sur l'architecture Mistral (Devstral) et sur l'architecture Qwen2. Le travail original de Ng portait sur Qwen2-72B. Les circuits existent dans tous les modèles transformer — la question est de savoir où ils se trouvent et quelle est leur taille. Lancez le balayage et découvrez-le.

Pourquoi ne pas plutôt affiner (fine-tuning) ? C'est orthogonal à l'affinage. Vous pouvez faire les deux. En fait, les modèles RYS de Ng ont ensuite été affinés par d'autres et ont atteint le sommet du classement HuggingFace. La duplication de couches modifie l'architecture ; l'affinage modifie les poids. Empilez-les.

Crédits

• David Ng pour la méthode RYS et l'idée que les transformateurs ont une neuroanatomie fonctionnelle
• llama.cpp pour avoir rendu l'inférence locale pratique
• lm-evaluation-harness pour la validation des benchmarks

Licence

MIT