llm-circuit-finder

मैंने Ng की RYS विधि को दोहराया और पाया कि Qwen2.5-32B में 3 विशिष्ट परतों की नकल करने से तर्कशक्ति में 17% का सुधार होता है और Devstral-24B में परतों 12-14 की नकल करने से BBH पर तार्किक निगमन 0.22→0.76 तक बढ़ जाता है — कोई प्रशिक्षण नहीं, कोई भार परिवर्तन नहीं, बस उसी सर्किट के माध्यम से छिपी स्थितियों को दो बार रूट करना। उपकरण शामिल हैं। दो AMD GPU, एक शाम।

llm-circuit-finder

3 परतों की नकल करें। कोई प्रशिक्षण नहीं। तार्किक निगमन ~0.22 → 0.76 हो जाता है।

यह टूलकिट ट्रांसफॉर्मर मॉडल के अंदर छिपे "तर्क सर्किट" को ढूंढता और उनका दोहन करता है। मूल विचार: परतों के कुछ सन्निकट खंड अविभाज्य संज्ञानात्मक इकाइयों के रूप में कार्य करते हैं। उन्हें फॉरवर्ड पास में डुप्लिकेट करें — समान भार, कोई प्रशिक्षण नहीं, कोई विलय नहीं — और मॉडल विशिष्ट क्षमताओं पर मापनीय रूप से अधिक चतुर हो जाता है।

David Ng की RYS विधि पर निर्मित और नए निष्कर्षों के साथ विस्तारित। यहां सब कुछ एक शाम में दो AMD उपभोक्ता GPU (RX 7900 XT + RX 6950 XT) पर खोजा गया था।

परिणाम

Devstral-Small-2-24B: परतें 12, 13, 14 एक बार डुप्लिकेट की गईं

मैंने Vast.ai पर एक H200 उदाहरण पर पूर्ण परीक्षण चलाए और devstral बेस की तुलना सर्जरी मॉडल से की, और परिणाम यह हैं: तो सर्जरी कुछ वास्तविक और विशिष्ट कर रही है: यह गणितीय तर्क और कारण तर्क को बढ़ा रही है लेकिन निर्देश-पालन और कोड निर्माण की कीमत पर। मॉडल अधिक सोचता है लेकिन निर्देशों का कम सटीकता से पालन करता है।

परिणाम फ़ोल्डर में आप eval_base और eval_surgery के अंतर्गत परिणाम देख सकते हैं। मैंने रिपॉजिटरी में vastai_rys_eval.sh भी जोड़ा है जो Vast.ai में पूरा वाकामोल चलाने के लिए उपयोग किया जाने वाला स्क्रिप्ट है। vastai उदाहरण इस प्रकार बनाया गया:

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

=================================================================================
lm_eval परिणाम तुलना
=================================================================================
मीट्रिक                                              base  rys_12_15 Δ(अंतिम-प्रथम)
---------------------------------------------------------------------------------
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
=================================================================================

औसत (सभी मीट्रिक)                             0.7610     0.7488     -0.0122

Qwen2.5-Coder-32B: परतें 7, 8, 9 एक बार डुप्लिकेट की गईं

कस्टम प्रोब सूट (BBH-व्युत्पन्न + EQ-Bench-शैली + GSM8K) पर मापा गया:

क्या हो रहा है

ट्रांसफॉर्मर प्रशिक्षण के दौरान खुद को कार्यात्मक सर्किट में व्यवस्थित करते हैं — बहु-परत प्रसंस्करण इकाइयाँ जो पूर्ण संज्ञानात्मक संचालन करती हैं। ये सर्किट अविभाज्य हैं: एक एकल परत की नकल करने से लगभग कुछ नहीं होता, लेकिन सही खंड (3-4 परतें) की नकल करने से मॉडल को अपनी तर्क पाइपलाइन के माध्यम से दूसरा पास मिलता है।

विभिन्न मॉडलों में अलग-अलग स्थानों पर अलग-अलग सर्किट होते हैं:

• Devstral-24B (40 परतें): परतों 12-14 पर तर्क सर्किट
• Qwen2.5-32B (64 परतें): परतों 7-9 पर तर्क सर्किट

सीमाएँ तीक्ष्ण हैं। खंड को एक परत किसी भी दिशा में स्थानांतरित करने पर सुधार गायब हो जाता है या उलट जाता है।

"मोड" की खोज

विभिन्न डुप्लिकेशन पैटर्न समान भार से अलग संज्ञानात्मक प्रोफ़ाइल बनाते हैं:

डिस्क पर समान भार। बेस मॉडल के लिए समान VRAM। बस अलग रूटिंग।

त्वरित आरंभ

अपने मॉडल में सर्किट खोजें

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

ज्ञात सर्किट लागू करें

# Devstral में परतें 12-14 डुप्लिकेट करें (ऊपर मान्य परिणाम)
python layer_path.py model.gguf improved.gguf \
    -p "0..14,12,13,14,15..39" -v

# Qwen2.5-32B में परतें 7-9 डुप्लिकेट करें
python layer_path.py model.gguf improved.gguf \
    -p "0..9,7,8,9,10..63" -v

# वाइल्ड हो जाएं: ट्रिपल-पास, इंटरलीव्ड, परतें छोड़ें, जो चाहें
python layer_path.py model.gguf experiment.gguf \
    -p "0..16,13,14,15,16,13,14,15,16,17..39" -v

स्थापित बेंचमार्क के साथ मान्य करें

# संशोधित मॉडल के साथ सर्वर प्रारंभ करें
llama-server -m improved.gguf --port 8089 -ngl 99 --device Vulkan1,Vulkan2

# 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

# रनों की तुलना करें
python compare_eval.py ./eval_base ./eval_improved

फ़ाइलें

स्वीप कैसे काम करता है

1. प्रत्येक परत कॉन्फ़िगरेशन (i, j) के लिए:

   • GGUF सर्जरी एक मॉडल बनाती है जहाँ परतें i..j-1 भौतिक रूप से डुप्लिकेट की जाती हैं
   • नया फॉरवर्ड पास: layers 0..j-1 → layers i..j-1 again → layers j..N-1
   • llama-server संशोधित मॉडल लोड करता है
   • तीन प्रोब सूट चलते हैं: math, EQ, reasoning (BBH-व्युत्पन्न)
   • स्कोर बेसलाइन से तुलना की जाती है, परिणाम लाइव प्रिंट होते हैं
   • सर्वर को मार दिया जाता है, संशोधित GGUF हटा दिया जाता है, अगला कॉन्फ़िग

2. खोज रणनीति:

   • पास 1: बड़े खंड (8 परतें), चौड़ी स्ट्राइड → हॉट ज़ोन खोजें
   • पास 2: छोटे खंड (3-5 परतें), हॉट ज़ोन के भीतर स्ट्राइड 1 → सटीक सीमाएँ खोजें
   • पास 3: मल्टी-पास, इंटरलीव्ड और कंपाउंड कॉन्फ़िग आज़माएँ

संशोधित GGUF को tmpfs (/dev/shm) पर लिखा जाता है और प्रत्येक परीक्षण के बाद हटा दिया जाता है। बेस मॉडल भार डिस्क पर रहता है।

आवश्यकताएँ

• Linux जिसमें llama.cpp बना हुआ है (CPU, CUDA, Vulkan, या Metal)
• Python 3.10+ जिसमें gguf, requests, tqdm स्थापित हों
• मॉडल + कुछ अतिरिक्त डुप्लिकेट परतों को चलाने के लिए पर्याप्त VRAM/RAM
• वैकल्पिक: बेंचमार्क सत्यापन के लिए lm-eval, हीटमैप प्लॉट के लिए matplotlib

FAQ

क्या यह अधिक VRAM का उपयोग करता है? हाँ, डुप्लिकेट की गई परतें GGUF में भौतिक प्रतियाँ हैं। 24B मॉडल पर 3 अतिरिक्त परतों के लिए, लगभग ~1.5 GiB अतिरिक्त की अपेक्षा करें। एक llama.cpp फॉरवर्ड-पास पैच (प्रतियों के बजाय पॉइंटर्स का उपयोग करके) इसे समाप्त कर देगा — योगदान का स्वागत है।

क्या यह अनुमान को धीमा करता है? हाँ, अतिरिक्त परतों की संख्या के अनुपात में। 40-परत वाले मॉडल पर 3 अतिरिक्त परतें = ~7.5% धीमी। तर्क सुधार इसके लायक है।

क्या यह मेरे मॉडल पर काम करेगा? संभवतः। हमने Mistral-आर्किटेक्चर (Devstral) और Qwen2 आर्किटेक्चर पर परीक्षण किया है। Ng का मूल कार्य Qwen2-72B पर था। सर्किट सभी ट्रांसफॉर्मर मॉडलों में मौजूद हैं — सवाल यह है कि वे कहाँ हैं और वे कितने बड़े हैं। स्वीप चलाएँ और पता लगाएँ।

फाइन-ट्यूनिंग क्यों नहीं करते? यह फाइन-ट्यूनिंग के लिए ऑर्थोगोनल है। आप दोनों कर सकते हैं। वास्तव में, Ng के RYS मॉडल को बाद में दूसरों द्वारा फाइन-ट्यून किया गया और HuggingFace लीडरबोर्ड में शीर्ष पर रहा। परत डुप्लिकेशन आर्किटेक्चर बदलता है; फाइन-ट्यूनिंग भार बदलती है। उन्हें स्टैक करें।

श्रेय

• David Ng RYS विधि और इस अंतर्दृष्टि के लिए कि ट्रांसफॉर्मर में कार्यात्मक न्यूरोएनाटॉमी होती है
• llama.cpp स्थानीय अनुमान को व्यावहारिक बनाने के लिए
• lm-evaluation-harness बेंचमार्क सत्यापन के लिए

लाइसेंस

MIT