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

Sparse autoencoders

मॉडल के activations से sparse features की एक बड़ी dictionary सीखें, ताकि हर activation को कुछ आसानी से समझ आने वाले टुकड़ों से समझाया जा सके।

✦ ट्यूटर से पूछें 🧪 लैब · 40 min 📝 पाठ का टेस्ट

स्पीड

पाठ वीडियो में

60 सेकंड में

Sparse autoencoders

1/4

आसान शब्दों में

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

अगर features superposition में भरी हुई दिशाएँ हैं, तो हमें एक ऐसा तरीका चाहिए जो बिना यह बताए कि क्या खोजना है, उन दिशाओं को ढूँढ ले। sparse autoencoder (SAE) ऐसा ही एक तरीका है। यह एक छोटा नेटवर्क है जिसे टेक्स्ट पर नहीं, बल्कि मॉडल के activations पर ट्रेन किया जाता है। यह लेयर के dimensions की तुलना में कहीं ज़्यादा दिशाओं की एक dictionary सीखता है, और हर activation को उनमें से केवल कुछ की मदद से समझाता है।

यह कैसे काम करता है

1
Activations इकट्ठा करें
मॉडल के ज़रिए बहुत सारा टेक्स्ट चलाएँ और, उदाहरण के लिए, किसी एक लेयर पर residual stream को सेव कर लें।
2
Encode करें
एक encoder मैट्रिक्स से गुणा करें और ReLU लागू करें। इससे कई feature values मिलती हैं, जिनमें से ज़्यादातर शून्य होती हैं।
3
Decode करें
Activation को दोबारा बनाने के लिए feature values से वज़न देकर decoder दिशाओं को जोड़ें।
4
Train करें
Reconstruction error और साथ ही एक sparsity penalty (अक्सर feature values पर L1 penalty) को कम से कम करें।
5
Interpret करें
हर feature के लिए, उन इनपुट्स को देखें जो इसे सबसे मज़बूती से fire करवाते हैं।

मुख्य ट्रेड-ऑफ

अगर sparsity penalty...	Reconstruction	Features	जोखिम
बहुत कमज़ोर हो	बहुत अच्छा	एक साथ कई active, हर एक आपस में मिला हुआ	वापस polysemantic खिचड़ी
संतुलित हो	अच्छा	कम active, अक्सर समझने योग्य	वह सही संतुलन जिसकी आपको तलाश होती है
बहुत ज़्यादा हो	खराब	बहुत कम active	SAE असली जानकारी को नज़रअंदाज़ कर देता है

हाथ से ट्रेन किया गया एक छोटा SAE

हम 16 dimensions में 32 छिपे हुए असली features से नकली activations बनाते हैं (इसलिए वे superposition में ही होने चाहिए), फिर 64 dictionary features वाला एक SAE ट्रेन करते हैं। चूँकि डेटा नकली है, हम यह जाँच सकते हैं कि क्या SAE ने असली features ढूँढ लिए। किसी असली मॉडल के साथ आप इसे इतनी आसानी से नहीं जाँच सकते।

Core SAE step (forward pass and loss)python

import numpy as np

def sae_forward(xb, W_enc, b_enc, W_dec, b_dec, l1):
    pre = (xb - b_dec) @ W_enc + b_enc
    f = np.maximum(0, pre)                     # sparse feature values
    x_hat = f @ W_dec + b_dec                  # rebuilt activation
    recon = np.mean(np.sum((x_hat - xb) ** 2, axis=1))
    sparsity = np.mean(np.sum(f, axis=1))      # L1 penalty
    return f, x_hat, recon + l1 * sparsity

हाथ से लिखे गए gradients के साथ पूरा training loop लैब में मौजूद है। इस खिलौना (toy) मॉडल पर यह आमतौर पर हर असली feature को फिर से ढूँढ लेता है। असली मॉडल बहुत ज़्यादा कठिन होते हैं।

Features को समझना

सबसे ज़्यादा सक्रिय (top activating) करने वाले उदाहरणों को देखें। कोई feature देवनागरी लिपि पर, फ़ोन नंबरों पर, या कोड कमेंट्स पर fire हो सकता है।
जाँचें कि feature क्या करता है: इसकी decoder दिशा को activations में जोड़ें और देखें कि मॉडल का आउटपुट कैसे बदलता है।
शोधकर्ता अक्सर टॉप उदाहरणों से एक पहला लेबल लिखने के लिए एक language model का उपयोग करते हैं, फिर नए टेक्स्ट पर उस लेबल का परीक्षण करते हैं। लेबल गलत हो सकते हैं, इसलिए टेस्ट करना ज़रूरी है।

ध्यान रखने योग्य सीमाएँ

Dead features: कुछ dictionary प्रविष्टियाँ किसी भी इनपुट पर कभी fire नहीं होतीं। वे क्षमता बर्बाद करती हैं। उन्हें दोबारा सक्रिय करने के लिए ट्रेनिंग ट्रिक्स मौजूद हैं।
सभी features नहीं मिलते: SAE कभी भी activations को पूरी तरह से दोबारा नहीं बना पाता। बची हुई त्रुटि (leftover error) में ऐसे महत्वपूर्ण features हो सकते हैं जो dictionary में छूट गए हों।
Features आपकी पसंद पर निर्भर करते हैं: एक बड़ी dictionary एक feature ("sport") को कई हिस्सों ("cricket", "football") में बाँट सकती है। कोई एक अकेली असली सूची नहीं होती।
लेबल केवल अनुमान हैं: एक feature जो "Mumbai" का लगता है, वह अन्य चीज़ों पर भी fire हो सकता है। टॉप उदाहरण गुमराह कर सकते हैं।
लागत: बड़े मॉडल्स पर SAEs को ट्रेन करने में बहुत सारा compute और डेटा लगता है।

नोट

शोधकर्ताओं ने कई language models पर SAEs को ट्रेन किया है और ऐसे कई features ढूँढे हैं जिन्हें इंसान आसानी से समझ सकते हैं, और कुछ ऐसे भी जो बढ़ाए या घटाए जाने पर मॉडल का व्यवहार बदल देते हैं। यह अब इस क्षेत्र के मुख्य टूल्स में से एक है। यह एक सक्रिय क्षेत्र भी है, और नए-नए प्रकार लगातार आ रहे हैं, इसलिए किसी एक वर्ज़न पर काम करने से पहले हाल के काम की जाँच ज़रूर कर लें।

इसे आज़माएँ। Dictionary लेयर से बड़ी क्यों होनी चाहिए? अपना उत्तर "superposition" शब्द का इस्तेमाल करके लिखें।

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

लैब

Numpy में शुरुआत से ट्रेन किया गया एक sparse autoencoder जो synthetic activations से छिपे हुए features को फिर से ढूँढ निकालता है।

~40 min

समस्या

शुरुआती कोड (starter) चलाएँ (इसके लिए numpy चाहिए, यह कुछ सेकंड में चलता है)। फिर:

रिकॉर्ड करें कि कितने असली features फिर से मिल पाए, कितने dictionary features dead हैं, और variance explained कितना है।
l1 को बदलकर 0.03 और 1.0 करें। दोनों के लिए, प्रति उदाहरण active features, variance explained और रिकवर हुए features रिकॉर्ड करें। इस trade-off को दो वाक्यों में समझाएँ।
m को बदलकर 16 करें (लेयर साइज़ के बराबर)। क्या यह अभी भी सभी 32 असली features को रिकवर करता है? क्यों नहीं?
SAE प्रति उदाहरण लगभग 3 features का उपयोग करता है, लेकिन डेटा में प्रति उदाहरण 2 से भी कम असली features चालू हैं। उच्च cosine वाली decoder पंक्तियों के जोड़ों को देखें और समझाएँ कि क्या हो रहा है।

प्रैक्टिस लैब

कोड में बदलाव करें और इसे रन करें। Python आपके ब्राउज़र में चलता है — हमारे सर्वर पर कुछ नहीं भेजा जाता।

रन करने के लिए Ctrl + Enter दबाएं

import numpy as np

rng = np.random.default_rng(0)
d, n_true, n = 16, 32, 20000

# Synthetic "activations": each is a sparse mix of 32 hidden true features in 16 dims.
true_dirs = rng.normal(size=(n_true, d))
true_dirs /= np.linalg.norm(true_dirs, axis=1, keepdims=True)
on = rng.random((n, n_true)) < 0.05                  # about 1-2 features on per example
X = (on * rng.random((n, n_true))) @ true_dirs

# Sparse autoencoder: 64 dictionary features, ReLU, L1 penalty on codes.
m, l1, lr = 64, 0.3, 0.3
W_enc = rng.normal(size=(d, m)) * 0.1
b_enc = np.zeros(m)
W_dec = W_enc.T.copy()                               # shape (m, d)
b_dec = np.zeros(d)

for step in range(5001):
    xb = X[rng.integers(0, n, 256)]
    pre = (xb - b_dec) @ W_enc + b_enc
    f = np.maximum(0, pre)                           # sparse codes
    x_hat = f @ W_dec + b_dec
    err = x_hat - xb

# Backpropagation, written out by hand.
    g_xhat = 2 * err / len(xb)
    g_Wdec = f.T @ g_xhat
    g_bdec = g_xhat.sum(axis=0)
    g_f = g_xhat @ W_dec.T + l1 / len(xb)
    g_pre = g_f * (pre > 0)
    g_Wenc = (xb - b_dec).T @ g_pre
    g_benc = g_pre.sum(axis=0)
    g_bdec -= (g_pre @ W_enc.T).sum(axis=0)

for p, g in ((W_enc, g_Wenc), (b_enc, g_benc), (W_dec, g_Wdec), (b_dec, g_bdec)):
        p -= lr * g
    W_dec /= np.linalg.norm(W_dec, axis=1, keepdims=True)   # keep decoder rows unit length

if step % 1000 == 0:
        mse = np.mean(np.sum(err**2, axis=1))
        active = np.mean(np.sum(f > 0, axis=1))
        print(f"step {step}: reconstruction error {mse:.4f}, active features {active:.1f}")

# How many true features did we recover? Compare decoder rows with the truth.
codes = np.maximum(0, (X - b_dec) @ W_enc + b_enc)
dead = np.sum(codes.max(axis=0) == 0)
best = (W_dec @ true_dirs.T).max(axis=0)             # best match for each true feature
print("true features recovered (cosine > 0.9):", np.sum(best > 0.9), "of", n_true)
print("dead dictionary features:", dead, "of", m)
x_hat = codes @ W_dec + b_dec
print("variance explained:", round(1 - np.var(X - x_hat) / np.var(X), 3))

आउटपुट

कोई आउटपुट नहीं। वैल्यूज़ देखने के लिए print(...) जोड़ें।

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

स्टार्टर कोड चलता है और तीन अंतिम संख्याएँ रिकॉर्ड की जाती हैं
l1 प्रयोग trade-off को दिखाता है: कमज़ोर penalty बेहतर reconstruction देती है लेकिन अधिक active और कम साफ-सुथरे features; मज़बूत penalty इसका उल्टा करती है
m = 16 के साथ, आप समझाते हैं कि 16 दिशाएँ 32 features में से प्रत्येक से मेल नहीं खा सकतीं, इसलिए features आपस में मिल जाते हैं
आप लगभग एक जैसी decoder पंक्तियाँ पाते हैं और समझाते हैं कि कई dictionary प्रविष्टियाँ एक ही असली feature को साझा कर सकती हैं

कठिन सवाल

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

Q1खिलौना (toy) डेटा पर आप रिकवर किए गए features की तुलना सच्चाई से कर सकते हैं। किसी असली मॉडल पर आप ऐसा नहीं कर सकते। इसके बजाय आप किसी SAE को परखने के लिए क्या इस्तेमाल करेंगे?दिखाएं

कई अप्रत्यक्ष जाँचें: यह activation का कितना हिस्सा reconstruct करता है, और जब आप असली activations को SAE के reconstruction से बदल देते हैं तो मॉडल का loss कितना खराब होता है; codes कितने sparse हैं; कितने features dead हैं; क्या features समझने योग्य (interpretable) हैं जब लोग या मॉडल्स उन पर लेबल लगाते हैं और वे लेबल नए टेक्स्ट पर fire होने की भविष्यवाणी करते हैं; और क्या किसी feature को बदलने से मॉडल का व्यवहार उम्मीद के मुताबिक बदलता है। इनमें से कोई भी अकेला तरीका अपने आप में परिपूर्ण नहीं है।

Q2एक बड़ी dictionary "cricket" को "batting", "bowling" और "IPL" features में क्यों बाँट सकती है, और यह features की एक असली सूची होने के विचार के बारे में क्या बताता है?दिखाएं

ज़्यादा entries के साथ, SAE बारीक पैटर्नों को अपनी अलग दिशा देकर अपने loss को कम कर सकता है, क्योंकि हर बारीक feature अभी भी sparse होता है और कुछ inputs को कम लागत में फिर से बना लेता है। इसलिए आपको मिलने वाले features, dictionary size और penalty पर निर्भर करते हैं। इससे पता चलता है कि features बारीकी के कई लेवल्स पर व्यवस्थित हो सकते हैं, और हो सकता है कि कोई एक ही सही लिस्ट न हो। dictionary एक काम का लेंस है, मॉडल का अपना ground truth नहीं।

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

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

क्या sparse autoencoder वैसा ही होता है जैसे compression के लिए इस्तेमाल होने वाले autoencoders?

नहीं, लगभग उल्टा। एक compression autoencoder डेटा को कम संख्याओं में सिकोड़ता है। एक sparse autoencoder इसे बहुत अधिक संख्याओं में फैलाता है, लेकिन उनमें से अधिकांश को शून्य होने के लिए मजबूर करता है। लक्ष्य पठनीयता (readability) है, compression नहीं।

Decoder दिशाओं को normalise क्यों करें?

इसके बिना, SAE L1 penalty को चकमा दे सकता है: feature values को बहुत छोटा और decoder दिशाओं को बहुत बड़ा बना दे, जिससे कम penalty के साथ वही reconstruction मिल जाता है। हर decoder दिशा की लंबाई 1 रखने से यह चाल रुक जाती है।

मुझे कैसे पता चलेगा कि कोई SAE feature असली है और कोई भ्रम (artefact) नहीं?

आप पूरी तरह सुनिश्चित नहीं हो सकते। अच्छे संकेत: यह इनपुट्स के एक स्पष्ट, सुसंगत सेट पर fire होता है; कुछ उदाहरणों से लिखा गया लेबल नए उदाहरणों पर fire होने की सटीक भविष्यवाणी करता है; और feature को बदलने से मॉडल का आउटपुट उसी तरह बदलता है जैसा अपेक्षित था। जो features इन तीनों को पास करते हैं वे अधिक भरोसेमंद होते हैं।

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

हाँ, और यह एक अच्छा अभ्यास है। अपने ट्रेनिंग टेक्स्ट पर एक लेयर पर residual stream को सेव करें, फिर उस पर लैब कोड को ट्रेन करें। हो सकता है कि छोटे GPT में कम साफ-सुथरे features हों, लेकिन आप इसका workflow सीख जाएँगे।

पाठ का टेस्ट

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

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

Sparse autoencoders

Sparse autoencoders

यह कैसे काम करता है

Activations इकट्ठा करें

Encode करें

Decode करें

Train करें

Interpret करें

मुख्य ट्रेड-ऑफ

हाथ से ट्रेन किया गया एक छोटा SAE

Features को समझना

ध्यान रखने योग्य सीमाएँ

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

समस्या

प्रैक्टिस लैब

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

कठिन सवाल

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