मॉडल के अंदर: इंटरप्रिटेबिलिटीएडवांस्डपाठ 3146 मिनट का पाठ

Circuits: किसी व्यवहार को ट्रैक करना

अलग-अलग रन के बीच activations को बदलकर यह पता लगाएं कि मॉडल के कौन-से हिस्से किसी व्यवहार की वजह बनते हैं। Induction heads इसका एक क्लासिक उदाहरण हैं।

✦ ट्यूटर से पूछें🧪 लैब · 35 min📝 पाठ का टेस्ट
पाठ वीडियो में

60 सेकंड में

Circuits: किसी व्यवहार को ट्रैक करना

अलग-अलग रन के बीच activations को बदलकर यह पता लगाएं कि मॉडल के कौन-से हिस्से किसी व्यवहार की वजह बनते हैं। Induction heads इसका एक क्लासिक उदाहरण हैं।

1/4
आसान शब्दों में
त्योहारों वाली रोशनी की एक लड़ी काम करना बंद कर देती है। आप एक चालू लड़ी से एक-एक करके बल्ब बदलते हैं। जब रोशनी वापस आ जाती है, तो आपको पता चल जाता है कि कौन-सा बल्ब काम का था। Activation patching मॉडल के अंदर यही काम करता है।
एक circuit मॉडल के कुछ हिस्सों (heads, MLP neurons या features) और उनके बीच के कनेक्शनों का एक छोटा सेट होता है, जो मिलकर कोई एक व्यवहार पैदा करते हैं। Circuits खोजने के लिए causal सबूत चाहिए होते हैं: यह नहीं कि "यह हिस्सा सक्रिय है", बल्कि यह कि "इस हिस्से को बदलने से व्यवहार बदल जाता है"।

Activation patching

  1. 1

    Clean run

    एक ऐसा prompt चलाएं जहां मॉडल वह व्यवहार दिखाता है, उदाहरण के लिए "The Taj Mahal is in the city of" को "Agra" के साथ पूरा करता है। सभी activations को सेव कर लें।
  2. 2

    Corrupted run

    एक ऐसा ही मिलता-जुलता prompt चलाएं जो इसे बदल दे, उदाहरण के लिए किसी दूसरे स्मारक के साथ। इससे जवाब बदल जाता है।
  3. 3

    Patch

    corrupted prompt को फिर से चलाएं, लेकिन किसी एक कंपोनेंट के activation को clean run वाली उसकी वैल्यू से बदल दें।
  4. 4

    मापें

    वह पैच clean और corrupted आउटपुट के बीच के अंतर को कितना ठीक (restore) करता है?
  5. 5

    दोहराएं

    हर कंपोनेंट के लिए ऐसा करें। जो अंतर को काफी हद तक ठीक कर देते हैं, वे circuit के दावेदार होते हैं।
Patching एक intervention है, इसलिए यह उस सवाल का जवाब देता है जो probes नहीं दे सकते: क्या मॉडल यहाँ इस हिस्से का इस्तेमाल करता है? इससे जुड़ा एक तरीका ablation है: किसी कंपोनेंट को शून्य या उसकी औसत वैल्यू पर सेट कर दें और देखें कि क्या खराब होता है।

एक टॉय नेटवर्क की patching करना

Activation patching on a two-layer toypython
import numpy as np

rng = np.random.default_rng(1)
W1 = rng.normal(size=(8, 6))        # input (6) -> hidden (8)
w2 = rng.normal(size=8)             # hidden (8) -> one output score

def run(x, patch=None):
    h = np.maximum(0, W1 @ x)       # hidden activations
    if patch is not None:           # patch = (unit index, value to force)
        i, v = patch
        h = h.copy()
        h[i] = v
    return w2 @ h, h

clean = rng.normal(size=6)          # e.g. a prompt where the model answers well
corrupt = clean.copy()
corrupt[2] += 3.0                   # change one "token" of the input

y_clean, h_clean = run(clean)
y_corrupt, _ = run(corrupt)
print(f"clean output {y_clean:.2f}, corrupted output {y_corrupt:.2f}")

# Patch one hidden unit at a time from the clean run into the corrupted run.
for i in range(8):
    y_patched, _ = run(corrupt, patch=(i, h_clean[i]))
    recovered = round((y_patched - y_corrupt) / (y_clean - y_corrupt), 3) + 0.0
    print(f"unit {i}: recovers {recovered:6.1%} of the gap")
ज्यादातर यूनिट्स कुछ भी ठीक नहीं कर पातीं, क्योंकि corruption ने उन्हें बदला ही नहीं था। कुछ ही यूनिट्स पूरे अंतर की वजह होती हैं। एक असली transformer में आप हर पोज़ीशन पर heads, MLP layers या SAE features को पैच करते हैं, और उनके प्रभाव हमेशा सीधे जुड़ने वाले नहीं होते, क्योंकि हिस्से आपस में बातचीत करते हैं।

एक क्लासिक उदाहरण: induction heads

भाषा में अक्सर चीजें दोहराई जाती हैं। अगर पहले "Ravi Shankar" आया था, तो अगली बार "Ravi" के बाद "Shankar" आना एक अच्छा अनुमान है। Induction heads ऐसे attention heads होते हैं जो यही काम करते हैं: जब मौजूदा token A हो, तो पीछे जाकर पहले आए A को ढूंढते हैं, और उसके बाद आए token को कॉपी कर लेते हैं।
  • उन्हें आमतौर पर दो हिस्सों वाले circuit के रूप में समझाया जाता है। पहले वाला एक previous-token head हर पोज़ीशन में यह लिखता है कि "मुझसे पहले वाला token A था"। फिर बाद का induction head ऐसी पोज़ीशन्स खोजता है जिनका पिछला token मौजूदा token से मेल खाता हो, और वहां जो है उसे कॉपी कर लेता है।
  • शोधकर्ताओं को छोटे से लेकर बड़े तक, कई transformer मॉडलों में ऐसे heads मिले हैं।
  • ट्रेनिंग के अध्ययनों में, वे काफी अचानक उभरते हुए दिखते हैं, लगभग उसी समय जब मॉडल prompt में पहले आए संदर्भ का बेहतर इस्तेमाल करने लगता है। यह उन्हें in-context learning से जोड़ता है, हालांकि माना जाता है कि पूरी कहानी सिर्फ यही नहीं है।
नोट
Induction heads एक क्लासिक उदाहरण इसलिए बन गए क्योंकि इसके सबूत एक साथ कई दिशाओं से मिले: attention patterns, patching और ablations, और ट्रेनिंग के दौरान उनकी टाइमिंग। सिर्फ एक तरह का सबूत काफी कमजोर होता।
सावधान रहें
किसी एक मॉडल में किसी खास छोटे काम के लिए पाए गए circuits शायद दूसरी जगह काम न करें। बड़े मॉडलों में अक्सर बैकअप कंपोनेंट होते हैं जो किसी एक के हटने पर उसका काम संभाल लेते हैं। एक साफ-सुथरा डायग्राम असल की उलझी हुई गणना का एक सरल रूप भर होता है।
इसे आज़माएं। किसी दोहराए गए मनगढ़ंत नाम के साथ एक prompt लिखें, उदाहरण के लिए "Zorvik Pallan met Mira. Later, Zorvik"। एक induction head इसके बाद किस शब्द का अनुमान लगाएगा? एक मनगढ़ंत नाम एक अच्छा टेस्ट क्यों है?

और देखें और पढ़ें

लैब

एक टॉय नेटवर्क पर patching के नतीजे, और इसका टेस्ट कि जब दो यूनिट्स एक-दूसरे को बैकअप देती हैं तो क्या होता है।

~35 min

समस्या

इस पाठ के कोड ब्लॉक को अपने शुरुआती कोड की तरह इस्तेमाल करें (इसके लिए numpy चाहिए)।

  1. इसे चलाएं और उन यूनिट्स की सूची बनाएं जो ज्यादातर अंतर को ठीक करती हैं। क्या ठीक किए गए हिस्से मिलकर लगभग 100% होते हैं? इस टॉय नेटवर्क में ऐसा क्यों हो सकता है?
  2. corruption को बदलकर corrupt[4] += 3.0 करें। क्या अब अलग यूनिट्स असरदार हैं?
  3. Redundancy जोड़ें: W1 बनाने के बाद, सबसे महत्वपूर्ण यूनिट की पंक्ति को दूसरी पंक्ति में कॉपी करें (W1[j] = W1[i]) और w2[j] = w2[i] सेट करें। हर यूनिट को अकेले पैच करें, फिर दोनों को एक साथ पैच करें। आपको क्या दिखता है?
  4. बड़े मॉडलों में circuits खोजने के मामले में इसका क्या मतलब है, इस पर तीन वाक्य लिखें।

आपका काम तब पूरा होगा जब

कठिन सवाल

उत्तर देखने से पहले ख़ुद जवाब देने की कोशिश करें। अगर आप इनके जवाब दे सकते हैं, तो आप पाठ समझ गए हैं।

Q1आपका patching प्रयोग दिखाता है कि head 5.3 ज्यादातर व्यवहार को बहाल कर देता है। आपकी टीम का एक साथी निष्कर्ष निकालता है कि "head 5.3 ही circuit है।" आपको और क्या जांचना चाहिए?दिखाएं

क्या यह नतीजा सिर्फ एक नहीं, बल्कि कई prompt जोड़ों पर भी सही बैठता है; क्या अन्य कंपोनेंट्स को एक साथ पैच करने पर वे असर डालते हैं (आपसी बातचीत और बैकअप); head 5.3 किससे जानकारी पढ़ता है और किसमें लिखता है, ताकि आपको इसके इनपुट और यह पता चले कि बाद के कौन-से हिस्से इसके आउटपुट का इस्तेमाल करते हैं; क्या इसे ablate करने से नए prompts पर व्यवहार प्रभावित होता है; और क्या यह प्रभाव आपके द्वारा चुने गए corrupted prompt पर निर्भर करता है। एक circuit एक रास्ता होता है, न कि कोई अकेला हिस्सा।

Q2Patching में corrupted prompt का चुनाव इतना महत्वपूर्ण क्यों होता है?दिखाएं

Patching दोनों रनों के बीच के अंतर के प्रभाव को मापती है। यदि corrupted prompt केवल स्मारक का नाम बदलता है, तो आपको वे कंपोनेंट्स मिलते हैं जो उस तथ्य को ले जाते हैं। यदि यह व्याकरण या लंबाई को भी बदलता है, तो आपको उनके लिए भी कंपोनेंट्स मिल जाएंगे, और पूरी कहानी उलझ जाएगी। अलग-अलग corruptions अलग-अलग सवालों के जवाब देते हैं, इसलिए आपको उन्हें उस दावे से मेल खाते हुए चुनना होगा जिसका आप टेस्ट करना चाहते हैं।

जारी रखने के लिए कृपया साइन इन करें।

अक्सर पूछे जाने वाले सवाल

Patching और ablation में क्या अंतर है?

Ablation किसी कंपोनेंट के सिग्नल को हटा देता है (उसे शून्य या उसके औसत पर सेट कर देता है) और देखता है कि क्या खराब होता है। Patching किसी दूसरे, ध्यान से चुने गए रन से activation को बदलकर ले आती है। Patching ज्यादा सटीक होती है, क्योंकि रनों के बीच का एकमात्र अंतर वही चीज़ होती है जो आपने prompt में बदली थी।

Clean और corrupted prompts का इतना मिलता-जुलता होना क्यों ज़रूरी है?

ताकि आउटपुट में अंतर सिर्फ एक नियंत्रित बदलाव की वजह से आए। अगर prompts की लंबाई या कई शब्दों में अंतर होगा, तो कई कंपोनेंट बिना किसी वजह के बदल जाएंगे, और नतीजों को समझना मुश्किल हो जाएगा।

क्या हर कंपोनेंट को पैच करना बहुत धीमा नहीं होगा?

यह धीमा हो सकता है, क्योंकि हर पैच के लिए एक forward pass की ज़रूरत होती है। शोधकर्ता कंपोनेंट्स को शॉर्टलिस्ट करने के लिए gradients पर आधारित तेज़ अनुमानों का इस्तेमाल करते हैं, और फिर असली patching से ज़रूरी कंपोनेंट्स की पुष्टि करते हैं। अनुमान गलत हो सकते हैं, इसलिए पुष्टि करना ज़रूरी होता है।

क्या मैं अपने छोटे GPT में induction heads ढूंढ सकता हूँ?

अक्सर हाँ, बशर्ते उसमें कम से कम दो layers हों और उसे दोहराव वाले टेक्स्ट पर ट्रेन किया गया हो। उसे दो बार दोहराए गए tokens का एक रैंडम सीक्वेंस दें, और ऐसे heads खोजें जो दूसरी कॉपी में, पहले मिले मैच के ठीक बाद वाले token पर ध्यान देते हों। फिर उन्हें ablate करें और देखें कि क्या दोहराए गए हिस्से का अनुमान लगाना खराब हो जाता है।

पाठ का टेस्ट

5 सवाल। पास होने और इस पाठ को पूरा करने के लिए 3 सही होने चाहिए (60%)।

टेस्ट देने और अपनी प्रोग्रेस सेव करने के लिए साइन इन करें