शुरू से self-attention
आपने एक neuron और एक forward pass बनाया। अब आप वह एक विचार बनाएँगे जिसने सादे neural nets को transformers में बदला और, वहाँ से, हर chat सहायक के पीछे के LLMs में: self-attention। यह मुट्ठी भर matrix गुणा है, और आप पूरी चीज़ numpy में कर सकते हैं।
समझ
कल्पना करें कि वाक्य का हर शब्द दूसरे शब्दों से जानकारी इकट्ठा करना चाहता है। Self-attention हर स्थान को तीन vectors देता है:
- एक query (Q): यह स्थान क्या ढूँढ रहा है।
- एक key (K): हर स्थान क्या देता है, मिलान के लिए इस्तेमाल।
- एक value (V): हर स्थान की असली जानकारी।
एक स्थान अपनी query की तुलना हर key से करता है यह तय करने के लिए कि हर दूसरे स्थान को कितना सुनना है, फिर उन मात्राओं से values का एक भारित मिश्रण लेता है। मज़बूत मिलान -> बड़ा भार -> वह value ज़्यादा योगदान देता है। बस यही पूरा तरीका है: queries keys पर ध्यान देती हैं, और जवाब values का एक भारित मिश्रण है।
गणित: scaled dot-product attention
एक query और एक key के बीच का मिलान score उनका dot product है (एक ही ओर इशारा करने पर बड़ा)। सारी queries को एक matrix Q में और सारी keys को K में रखें, और एक साथ हर score Q @ K.T है। हम sqrt(d_k) (key आयाम) से भाग देते हैं ताकि vectors लंबे होने पर scores न फटें:
scores = Q @ K.T / np.sqrt(d_k)भाग ही क्यों दें? dot product आयाम के साथ बढ़ता है। अगर d_k 64 है और प्रविष्टियाँ लगभग 1 हैं, तो कच्चे scores 64 के पास आते हैं, और इतनी बड़ी संख्याएँ softmax को एक अकेली key पर धकेलती हैं और gradient सपाट कर देती हैं। sqrt(d_k) से भाग देना, यहाँ sqrt(64) = 8, scores को एक समझदार दायरे में वापस लाता है ताकि attention चिकना और train होने लायक रहे। नीचे आप जो छोटा d_k = 1 उदाहरण चलाते हैं उसमें भाजक बस 1 है, इसलिए आप इसे काटते नहीं देखेंगे, पर असली मॉडल आकारों पर यह ज़रूरी है।
scores की हर पंक्ति हर key के सामने एक query के scores रखती है। हम हर पंक्ति को आख़िरी अक्ष पर एक softmax से ऐसे भारों में बदलते हैं जो धनात्मक हों और जिनका योग 1 हो:
weights = softmax(scores, axis=-1) # each row sums to 1Softmax exponentiate और normalize करता है। भोले ढंग से करें तो बड़े score का np.exp inf तक उफ़नता है और भार nan निकलते हैं। इलाज मानक संख्या के हिसाब से स्थिर तरकीब है: exponentiate करने से पहले हर पंक्ति का अधिकतम घटाएँ। यह गणित में नतीजा नहीं बदलता (वही स्थिरांक ऊपर और नीचे कट जाता है), पर हर exponent को <= 0 रखता है:
def softmax(x):
x = x - x.max(axis=-1, keepdims=True) # stability: largest exponent is now 0
e = np.exp(x)
return e / e.sum(axis=-1, keepdims=True)आख़िर में, हर query का आउटपुट values पर लगाए उसके भार हैं, जो एक और matrix गुणा है:
output = weights @ Vसाथ रखें तो मशहूर सूत्र बस softmax(Q @ K.T / sqrt(d_k)) @ V है। अगर Q (n, d_k) है, K (m, d_k) है, और V (m, d_v) है, तो weights (n, m) है और output (n, d_v): हर query का एक आउटपुट vector, हर एक value पंक्तियों का मिश्रण।
यही पूरी transformer तरकीब है
एक असली transformer एक attention गणना पर नहीं रुकता। Multi-head attention इनमें से कई समानांतर चलाता है (हर head अपने Q, K, V projections सीखता है, इसलिए अलग heads अलग चीज़ों पर ध्यान देते हैं) और नतीजे जोड़ता है। फिर एक transformer block attention के साथ एक छोटा feed-forward network और एक residual connection रखता है, और एक मॉडल ऐसे दर्जनों blocks रखता है। पर उनमें से हर एक का धड़कता दिल ठीक वह फ़ंक्शन है जो आप लिखने वाले हैं: scores, स्थिर softmax, values का भारित योग। इसे बनाएँ और आप वह मूल क्रिया समझते हैं जिसे एक LLM prompt पर "ध्यान देते" समय दोहराता है।
एक ईमानदार चेतावनी: यहाँ Q, K और V आपको तय ऐरे के रूप में दिए गए हैं। एक असली मॉडल में वे दिए नहीं जाते, वे हर token के embedding को तीन सीखे भार matrices, W_q, W_k और W_v, से गुणा करके बनाए जाते हैं। वे matrices, और हर block के matrices, ठीक वही हैं जिन्हें training पिछले पाठ के gradient descent से बदलती है। इसलिए आप यहाँ जो बनाते हैं वह attention का तय केंद्र है जो हर transformer में एक जैसा है; सीखना उन projections में रहता है जो इसे खिलाते हैं।
attention को एक छोटे Q/K/V को आउटपुट में बदलते देखने और भार matrix print करने के लिए Run दबाएँ ताकि आप पढ़ सकें किसने किस पर ध्यान दिया।
numpy में scaled dot-product attention लागू करें। attention(Q, K, V) लिखें जो एक tuple (output, weights) लौटाए। scores = Q @ K.T / np.sqrt(d_k) निकालें जहाँ d_k Q का आख़िरी आयाम है; आख़िरी अक्ष पर एक संख्या के हिसाब से स्थिर softmax लगाएँ (np.exp से पहले हर पंक्ति का अधिकतम घटाएँ) ताकि ऐसे weights मिलें जिनकी पंक्तियों का योग 1 हो; फिर output = weights @ V। पहले output, फिर weights matrix लौटाएँ। फिर दिए ऐरे के लिए out, w = attention(Q, K, V) सेट करें।
इस पाठ में कोई समस्या दिखी? बताएँ · इस पाठ के बारे में पूछें
यह अभ्यास जल्द खुलेगा
इससे पहले वाला पाठ पूरा करें और यह खुल जाएगा। पूरा कोर्स मुफ़्त है, कोई खाता नहीं चाहिए, और आप यह पाठ अभी पढ़ सकते हैं।
यह ब्राउज़र learn.floati.life के लिए कुकी रोक रहा है, इसलिए यहाँ पूरे किए गए पाठ क्रम से नहीं खुल सकते। इस साइट के लिए कुकी की अनुमति दें और फिर से लोड करें।