ट्रांसफ़ॉर्मर्स में मल्टी-हेड अटेंशन को समझना

सेल्फ-अटेंशन मैकेनिज़्म का परिचय

अटेंशन मैकेनिज़्म, या अधिक विशिष्ट रूप से, सेल्फ-अटेंशन मैकेनिज़्म, पहली बार 2017 में वासवानी आदि के प्रसिद्ध  “Attention is All You Need” पेपर में प्रस्तुत किया गया था। 

यही मैकेनिज़्म ट्रांसफ़ॉर्मर्स मॉडल को शक्ति देता है, जो बदले में हमारे पास मौजूद सबसे सक्षम मॉडलों—जैसे LLMs और VLMs—को आगे बढ़ाता है। 

तो हाँ, यह काफी महत्वपूर्ण है!

लेकिन बात यह है: बहुत से लोग (और मैं भी पहले उन्हीं में से एक था!) मानते हैं कि अटेंशन 2017 में आविष्कार हुआ।

ऐसा नहीं है।

मूल अटेंशन मैकेनिज़्म पहली बार 2015 में प्रस्तुत किया गया था, जब बहदानऊ आदि ने इसे मशीन अनुवाद के संदर्भ में पेश किया। उनका विचार यह था कि डिकोडर एक स्थिर कॉन्टेक्स्ट वेक्टर पर निर्भर रहने के बजाय, हर डिकोडिंग स्टेप में इनपुट वाक्य के अलग-अलग भागों पर ध्यान केंद्रित कर सके।

इस छोटे से बदलाव ने बड़ा असर डाला—और आगे चलकर सेल्फ-अटेंशन और अंततः मल्टी-हेड अटेंशन की नींव रखी।

लेकिन इस बिंदु पर आपके मन में एक प्रश्न आ सकता है:

“अटेंशन का वास्तव में मतलब क्या होता है?”

आइए इसे दो सरल वाक्यों से समझते हैं:

• “The cat sat on the mat.” → हमारा मॉडल sat से cat और mat—दोनों पर ध्यान केंद्रित कर सकता है।
• “She drank her tea because she was thirsty.” → drank से tea और thirsty पर ध्यान जाता है, जो कारण और क्रिया को जोड़ता है।

इन उदाहरणों से हम समझने लगते हैं कि अटेंशन क्या करने की कोशिश करता है। यह फोकस के बारे में है; मॉडल को यह तय करने में मदद करना कि जो शब्द वह प्रोसेस कर रहा है, उसके लिए और कौन-से शब्द प्रासंगिक हैं—अक्सर सामन्तिक अर्थ या व्याकरणिक संबंधों के आधार पर।

एक महत्वपूर्ण बात यह है कि अटेंशन वेट्स और स्कोर (इस पर आगे) निकालते समय सभी टोकन उपयोग होते हैं, न कि केवल कुछ विशिष्ट टोकन—जैसा कि ऊपर के आरेख में दिखता है। इसका मतलब यह भी है कि कुछ शब्दों के बीच अटेंशन अन्य की तुलना में अधिक मजबूत होगा, जिसे तीरों की मोटाई से दर्शाया गया है।

यही कारण है कि ट्रांसफ़ॉर्मर्स भाषा को इतनी अच्छी तरह समझते हैं; वे अटेंशन का उपयोग करके हर शब्द को हर दूसरे शब्द से गतिशील रूप से जोड़ते हैं।

बीच के चरण

अब हमने समझ लिया कि अटेंशन क्या है, लेकिन यह अभी स्पष्ट नहीं कि इसकी आंतरिक प्रोसेसिंग कैसे होती है।

यहीं पर क्वेरीज़, कीज़ और वैल्यूज़ (आम तौर पर Q, K और V) काम में आते हैं। इस लेख के शेष भाग में, हम अपने उदाहरण वाक्य—“the cat sat on the mat”—के साथ ही चलेंगे। 

सबसे पहले, जब कोई वाक्य ट्रांसफ़ॉर्मर में डाला जाता है, तो उसे तुरंत किसी टोकनाइज़र द्वारा टोकनाइज़ कर दिया जाता है; एक प्रसिद्ध टोकनाइज़र बाइट-पेयर एन्कोडिंग है। 

टोकनाइज़ेशन को हम पाठ को छोटे-छोटे यूनिट्स में तोड़ने के रूप में समझ सकते हैं। हमारे वाक्य के सारे शब्द छोटे हैं, इसलिए इस उदाहरण में मान लें कि प्रत्येक यूनिट एक शब्द के बराबर है। दृश्य रूप से, टोकनाइज़र से गुजरने के बाद वाक्य कुछ ऐसा दिखेगा:

कृपया ध्यान दें कि विराम चिह्न (पूर्ण विराम) भी एक टोकन में बदला गया है। सरलता के लिए, हम मान रहे हैं कि पूर्ण विराम एक अलग टोकन है। 

टोकनाइज़ेशन के बाद, हम प्रत्येक टोकन को उसके टोकन ID में बदलने के लिए टोकनाइज़र शब्दावली का उपयोग करते हैं। टोकनाइज़र शब्दावली को एक डेटाबेस/तालिका की तरह समझें, जिसमें मॉडल द्वारा पहचाने जा सकने वाले सभी टोकन और उनके टोकन ID संग्रहीत होते हैं।

इसके बाद, इन प्रत्येक यूनिक टोकन IDs को एम्बेडिंग मैट्रिक्स के माध्यम से उनके टोकन एम्बेडिंग पर मैप किया जाता है। यह ध्यान रखना महत्वपूर्ण है कि सभी टोकन एम्बेडिंग एक ही आयाम के वेक्टर होंगे; हमारे उदाहरण में हमने 512 मान लिया है।

अंतिम चरण है पोज़िशनल एम्बेडिंग जोड़ना ताकि मॉडल के पास प्रत्येक टोकन की स्थिति की जानकारी हो। इसके दो आम तरीके हैं:

1. साइनुसॉइडल एन्कोडिंग (मूल ट्रांसफ़ॉर्मर में प्रयुक्त)
2. सीखी गई पोज़िशन एम्बेडिंग्स (BERT, GPT में प्रयुक्त)

इन पोज़िशनल एम्बेडिंग्स की अंतर्निहित यांत्रिकी इस ट्यूटोरियल के दायरे से बाहर है। फिलहाल हमें बस इतना जानना है कि हमने इस फ़ॉर्मूले से अपने इनपुट वेक्टर प्राप्त कर लिए हैं:

इनपुट वेक्टर = टोकन एम्बेडिंग + पोज़िशनल एम्बेडिंग

क्वेरी, कीज़ और वैल्यूज़

अब हम अंततः Q, K, V वेक्टर पेश करने के लिए तैयार हैं। शुरू करने के लिए, ध्यान दें कि इनपुट के प्रत्येक शब्द के लिए हम तीन वेक्टर बनाते हैं:

• क्वेरी (Q) – यह दर्शाता है कि शब्द क्या ढूंढ रहा है
• की (K) – यह दर्शाता है कि शब्द दूसरों को क्या प्रस्तुत करता है
• वैल्यू (V) – यह उस वास्तविक जानकारी को वहन करता है जो शब्द के पास है

ये सीखे जा सकने वाले ट्रांसफ़ॉर्मेशन हैं और इनके अपनी-अपनी मैट्रिसेस भी होती हैं। गणितीय रूप से, ये ट्रांसफ़ॉर्मेशन इस प्रकार लिखे जाते हैं:

इससे प्रत्येक टोकन को तीन नए वेक्टरों द्वारा दर्शाया जा सकता है। मैंने इस प्रक्रिया को दर्शाने में सहायता के लिए नीचे एक आरेख बनाया है:

स्केल्ड डॉट-प्रोडक्ट की गणना

“Attention is all you need” पेपर में, एक गणितीय फ़ॉर्मूला दिया गया था जो दिखाता है कि नए वेक्टरों का उपयोग अटेंशन वेट्स निकालने के लिए कैसे किया जाता है। आइए इसे चरणबद्ध समझते हैं, मानते हुए कि हम “sat” पर हैं और उसके अटेंशन वेट्स निकाल रहे हैं:

शुरू में, हम “sat” का क्वेरी वेक्टर हर अन्य शब्द—खुद सहित—के की वेक्टरों से तुलना करने के लिए उपयोग करते हैं। परिणामस्वरूप हमें समानता स्कोर (ये स्केलर होते हैं) मिलते हैं जो बताते हैं कि प्रत्येक शब्द “sat” के लिए कितना प्रासंगिक है। औपचारिक रूप से इन्हें अटेंशन स्कोर्स कहा जाता है।

इन स्कोर्स को sqrt(d_k) से स्केल किया जाता है ताकि स्कोर बहुत बड़े न हो जाएँ और बैकप्रोपेगेशन के दौरान ग्रेडिएंट्स स्थिर रहें। इसके बाद इन स्केल्ड स्कोर्स को softmax से गुजारा जाता है, जिससे ये अटेंशन वेट्स में बदल जाते हैं। 

Softmax हमें एक प्रायिकता देता है जो मॉडल को बताता है कि प्रत्येक शब्द को कितना वेट देना है, और इसलिए किसी विशेष टोकन के लिए अटेंशन वेट्स का योग 1 होगा। 

अंत में, हम इन अटेंशन वेट्स का उपयोग करते हुए वैल्यू वेक्टरों का वेटेड सम लेते हैं। 

इससे हमें एक नया वेक्टर मिलता है जो “sat” को संदर्भ में दर्शाता है—सभी टोकनों की जानकारी से समृद्ध, लेकिन मुख्यतः cat, mat, और अन्य प्रासंगिक टोकनों से।

यह प्रक्रिया वाक्य के हर टोकन के लिए होती है। प्रत्येक टोकन हर दूसरे टोकन—और खुद—पर ध्यान देता है। इसलिए हम इसे सेल्फ-अटेंशन कहते हैं।

कृपया यह भी ध्यान दें कि हमने एक ही टोकन के लिए समृद्ध वेक्टर निकाला, पर व्यवहार में, हम यह काम एकसाथ कई—अगर सभी नहीं—टोकनों के लिए करते हैं, क्योंकि मैट्रिक्स मल्टिप्लिकेशन अत्यंत कुशल है। 

हम ऐसा कर सकते हैं क्योंकि आर्किटेक्चर पूर्णतः पैरेललाइज़ेबल है। रिकरेंट न्यूरल नेटवर्क (RNNs) जो क्रमिक रूप से प्रोसेस करते हैं, उनसे अलग, यह मैकेनिज़्म ट्रांसफ़ॉर्मर्स को सभी टोकनों को एक साथ प्रोसेस करने देता है, जिससे वे तेज़ और शक्तिशाली बनते हैं।

चीज़ों को विज़ुअलाइज़ करने में मदद के लिए ऊपर का आरेख देखें। आप देख सकते हैं कि इनपुट मैट्रिक्स X को क्रमशः क्वेरी, की और वैल्यू मैट्रिक्स में बदला जाता है, और फिर स्केल्ड डॉट-प्रोडक्ट अटेंशन फ़ॉर्मूला लागू करके हमारे इनपुट के सभी टोकनों के पूर्ण समृद्ध एम्बेडिंग वेक्टर—A—प्राप्त होते हैं।

PyTorch में स्केल्ड डॉट-प्रोडक्ट अटेंशन लागू करना

अब आइए PyTorch में वही कोड करें जिसकी हमने चर्चा की। आश्चर्यजनक रूप से, यह काफ़ी सरल है:

import torchimport torch.nn.functional as Fdef scaled_dot_product_attention(Q, K, V):    d_k = Q.size(-1)  # the dimension of the key vectors    scores = torch.matmul(Q, K.transpose(-2, -1)) / torch.sqrt(torch.tensor(d_k, dtype=torch.float32))    attn_weights = F.softmax(scores, dim=-1)    output = torch.matmul(attn_weights, V)    return output, attn_weightsसंचालित द्वारा

एक साधारण फ़ंक्शन लागू करके, हम ऊपर की चर्चा को दोहरा सकते हैं! मुख्य बिंदु ये हैं:

• Q, K और V टेन्सर्स होते हैं जिनका आकार [batch_size, seq_len, dim] होता है
• आउटपुट नए वेक्टरों का सेट है जहाँ प्रत्येक टोकन पूरे अनुक्रम के संदर्भ में दर्शाया जाता है
• अटेंशन स्कोर्स कच्ची, अननॉर्मलाइज़्ड समानताएँ होती हैं
• अटेंशन वेट्स softmax द्वारा नॉर्मलाइज़्ड होते हैं ताकि फोकस हो और इनका योग 1 बने

अटेंशन के अलग-अलग प्रकार

हालाँकि एक महत्वपूर्ण विवरण अभी शेष है। देखें, ट्रांसफ़ॉर्मर में केवल एक तरह का अटेंशन नहीं होता—वास्तव में तीन होते हैं:

1. एन्कोडर सेल्फ-अटेंशन
2. डिकोडर सेल्फ-अटेंशन
3. एन्कोडर–डिकोडर (क्रॉस) अटेंशन

इनमें से प्रत्येक की भूमिका थोड़ी अलग है, तो आइए इन्हें संक्षेप में देखें।

एन्कोडर सेल्फ-अटेंशन

यह वही है जिसे हमने अब तक खोजा है, जिसमें एन्कोडर में प्रत्येक टोकन उसी इनपुट अनुक्रम के हर अन्य टोकन पर ध्यान देता है, जैसे “the cat sat on the mat.” उदाहरण। 

यहाँ महत्वपूर्ण बात यह है कि कोई प्रतिबंध नहीं है, क्योंकि पूरा इनपुट पहले से ज्ञात है, जिससे मॉडल प्रत्येक टोकन के गहरे संदर्भात्मक निरूपण बना सकता है—क्या पहले और बाद में आता है, यह समझते हुए। 

कृपया यह भी ध्यान दें कि यह एन्कोडर में हो रहा है। 

डिकोडर सेल्फ-अटेंशन

यहाँ चीज़ें थोड़ी पेचीदा हो जाती हैं। चूँकि हम अब डिकोडर में हैं, हम नहीं चाहते कि प्रत्येक टोकन भविष्य देख सके—क्योंकि यह टेक्स्ट जनरेशन के दौरान चीटिंग होगा।

आइए एक और उदाहरण लें: “The dog barked very loudly.” जब मॉडल “barked” जेनरेट कर रहा हो (सरलता हेतु मान लें कि प्रत्येक शब्द एक टोकन है), तो उसे यह नहीं पता होना चाहिए कि अगला टोकन “very” है, अन्यथा मॉडल नए टोकन बनाना सीख ही नहीं पाएगा। 

इस समस्या को हल करने के लिए, हम एक कॉज़ल मास्क (कभी-कभी त्रिकोणीय मास्क भी कहा जाता है) लागू करते हैं, जो सुनिश्चित करता है कि प्रत्येक टोकन केवल खुद और अपने पहले के टोकनों पर ही ध्यान दे सके—आगे वालों पर कभी नहीं।

ऊपर के आरेख से हम देख सकते हैं कि भविष्य के अटेंशन स्कोर मास्किंग द्वारा हटा दिए जाते हैं, जिससे मॉडल नए, सटीक और अर्थपूर्ण टोकन बनाना सीख पाता है।

एन्कोडर–डिकोडर (क्रॉस) अटेंशन

एक बार डिकोडर जेनरेशन शुरू कर दे, तब भी उसे मूल इनपुट से जानकारी चाहिए (जिसका वह प्रत्युत्तर दे रहा है)। यही वह जगह है जहाँ क्रॉस अटेंशन आता है।

यहाँ, डिकोडर एन्कोडर के आउटपुट पर ध्यान देता है। इसलिए जहाँ डिकोडर सेल्फ-अटेंशन मास्क किया हुआ होता है, क्रॉस-अटेंशन मास्क नहीं होता, और डिकोडर को एक साथ सभी एन्कोडर टोकनों को देखने की अनुमति होती है।

जब मैं यह अवधारणा सीख रहा था, तो मुझे अनुवाद का उदाहरण बहुत पसंद आया। मान लें आप “Bonjour tout le monde” का अंग्रेज़ी में अनुवाद कर रहे हैं, तो डिकोडर को प्रत्येक अंग्रेज़ी शब्द चुनते समय सभी फ़्रेंच शब्दों को देखने में सक्षम होना चाहिए, है न? 

क्रॉस अटेंशन ठीक यही करता है। हालाँकि, हम यहाँ क्रॉस अटेंशन में अधिक गहराई में नहीं जाएँगे, क्योंकि यह इस लेख के दायरे में आवश्यक नहीं है।

मल्टी-हेड अटेंशन की आवश्यकता

अब हम समझते हैं कि सेल्फ-अटेंशन कैसे काम करता है। लेकिन अब आपके मन में यह प्रश्न आ सकता है:

यदि हमारे पास पहले से अटेंशन है, तो हमें इसके कई हेड्स की आवश्यकता क्यों है?

इसके लिए, मैं टॉर्च/फ्लैशलाइट वाली उपमा प्रस्तुत करना चाहूँगा, जिसने मुझे शुरुआत में अपनी अंतर्दृष्टि बनाने में मदद की।

एक सिंगल अटेंशन हेड को ऐसे सोचें जैसे एक टॉर्च जो वाक्य के महत्वपूर्ण हिस्सों पर रोशनी डालने की कोशिश कर रही है। लेकिन एक वाक्य को समझने के लिए कई तरह के रिश्तों को पकड़ना पड़ता है: कर्ता–क्रिया, कर्म–सर्वनाम, विशेषण–संज्ञा, दूरस्थ निर्भरताएँ, आदि।

क्या यह बेहतर नहीं होगा कि हर बार केवल एक संबंध के बजाय अधिक संबंधों को पकड़ सकें?

इसलिए समाधान है मॉडल को कई टॉर्च देना, प्रत्येक वाक्य के अलग-अलग हिस्सों पर फोकस करती हुई। यही है मल्टी-हेड अटेंशन।

एक सेट Q, K, V गिनने और एकल अटेंशन कैलकुलेशन चलाने के बजाय, हम एम्बेडिंग्स को छोटे हिस्सों में बाँटते हैं और कई स्वतंत्र अटेंशन हेड्स समांतर में चलाते हैं। 

जैसा कि ऊपर के आरेख में देखा जा सकता है, इनपुट एम्बेडिंग (सरलता के लिए यहाँ एक ही टोकन की) को n अलग-अलग हेड्स में समान रूप से बाँटा गया है। 

हमारे उदाहरण में, मान लें कि आयाम 512 था और हेड्स की संख्या 8, तो प्रत्येक अटेंशन हेड पैरेलल रूप से (512/8 = 64) आयाम प्रोसेस करेगा, अलग-अलग संबंधों को पकड़ने की कोशिश करते हुए। 

यह समझने के लिए कि ये हेड्स किस तरह के रिश्तों को प्रोसेस कर सकते हैं (मैं “कर सकते हैं” इसलिए कह रहा हूँ क्योंकि हम अब भी पूरी तरह नहीं समझते कि प्रत्येक हेड क्या देखता है), आइए एक सरल उदाहरण पर चलते हैं:

यह वाक्य लें:

“The quick brown fox jumps over the lazy dog.”

• एक हेड विशेषण–संज्ञा युग्म पर फोकस कर सकता है: “quick → fox”, “lazy → dog”
• दूसरा हेड कर्ता–क्रिया पर: “fox → jumps”
• और एक अन्य हेड दूरस्थ संबंधों को पकड़ सकता है: “jumps → over → dog”

मुख्य बात यह है कि ये सारे हेड्स एक साथ चलते हैं, और उनके आउटपुट्स को कंकैटिनेट कर के वापस प्रोजेक्ट किया जाता है मूल एम्बेडिंग साइज़ (हमारे केस में 512) पर। 

कोड के माध्यम से कई हेड्स का दृश्यांकन

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

!pip install transformers bertviz torchसंचालित द्वारा

सबसे पहले, ऊपर का कोड सेल चलाकर सभी आवश्यक पैकेज डाउनलोड करें।

from transformers import BertTokenizer, BertModelfrom bertviz import head_viewimport torchmodel_name = 'bert-base-uncased' # We will be using the Bert modelmodel = BertModel.from_pretrained(model_name, output_attentions=True)tokenizer = BertTokenizer.from_pretrained(model_name)model.eval() # As we are not training, we have set the model to evaluation mode so no updates are made# This is our input sentencesentence = "The quick brown fox jumps over the lazy dog."# Using the tokenizer to convert the sentence into tokensinputs = tokenizer(sentence, return_tensors='pt')input_ids = inputs['input_ids']# Forward pass with attentionswith torch.no_grad():    outputs = model(**inputs)    attentions = outputs.attentions  # Tuple of (num_layers, batch, num_heads, seq_len, seq_len)# Here we decode the tokens tokens = tokenizer.convert_ids_to_tokens(input_ids[0])head_view(attentions, tokens) # Visualizationसंचालित द्वारा

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

मल्टी-हेड अटेंशन लागू करना: श्रेष्ठ अभ्यास

इस खंड में, हम मल्टी-हेड अटेंशन मैकेनिज़्म के लिए स्यूडोकोड लिखेंगे। मान लें कि हमारा इनपुट X का आकार [batch, seq_len, d_model] है। 

फिर हम निम्न स्यूडोकोड के साथ आगे बढ़ सकते हैं: 

Q = X @ W_Q # Calculating the Query valuesK = X @ W_K # Calculating the Key valuesV = X @ W_V# Calculating the Value valuesQ_i, K_i, V_i = split_into_heads(Q, K, V, num_heads) # Now we split the Q,K,V into multiple different heads (by evenly splitting the dimensions)# Here we compute scaled dot-product attention for each headscores = (Q_i @ K_i.T) / sqrt(head_dim)scores += maskA_i = softmax(scores)A_i = dropout(A_i)Z_i = A_i @ V_iZ = concat_heads(Z_i) # We have to concatenate all of the Heads# This is our final linear projection matrixoutput = Z @ W_Ooutput = dropout(output)संचालित द्वारा

यह सब अब तक आपको परिचित लगना चाहिए, सिवाय शायद अंतिम लिनीयर प्रोजेक्शन मैट्रिक्स के। 

आइए इसे जल्दी से समझ लें। 

जब सारे अलग-अलग अटेंशन हेड्स अपना काम पूरा कर लेते हैं, तो उनके आउटपुट्स को फिर से एक ही वेक्टर में जोड़ दिया जाता है। लेकिन इस संयुक्त आउटपुट को अभी मूल मॉडल आयाम में ढालना होता है—यहीं अंतिम लिनीयर प्रोजेक्शन मैट्रिक्स काम आता है। यह सरलता से कंकैटिनेटेड आउटपुट को इनपुट एम्बेडिंग के समान आकार में मैप कर देता है ताकि इसे ट्रांसफ़ॉर्मर की अगली लेयर को पास किया जा सके।

आइए कुछ ऑप्टिमाइज़ेशन और श्रेष्ठ अभ्यासों पर भी बात करें:

1. पैरेललाइज़ेशन: चूँकि प्रत्येक हेड स्वतंत्र है, हम उन्हें समानांतर में गणना कर सकते हैं।
2. मैट्रिक्स मल्टिप्लिकेशन: हम सब कुछ लीनियर अल्जेब्रा ऑपरेशन्स (जैसे matmul) का उपयोग करके बैच करते हैं, जो अत्यधिक अनुकूलित हैं।
3. FlashAttention (उन्नत): यह एक नया तरीका है जो लो-लेवल CUDA तकनीकों का उपयोग करके मेमोरी ओवरहेड कम करता है और अटेंशन को तेज करता है—खासकर लंबे अनुक्रमों पर।

श्रेष्ठ अभ्यासों की दृष्टि से, जब हम अटेंशन लेयर कोड करते हैं, तो 3 मुख्य हाइपरपैरामीटर्स पर ध्यान देना चाहिए:

1. num_heads: कितने अटेंशन हेड्स समानांतर में चलाने हैं—सुनिश्चित करें कि यह d_model में ठीक से विभाज्य हो।
2. head_dim: प्रत्येक हेड का आयाम।
3. dropout_rate: ओवरफ़िटिंग से बचने के लिए।

निष्कर्ष

हमने इस लेख में बहुत कुछ कवर किया। हमने एक सरल विचार से शुरू किया: अटेंशन का मतलब फोकस है। फिर हमने देखा कि ट्रांसफ़ॉर्मर्स क्वेरी, की और वैल्यू का उपयोग करके कैसे हर शब्द को हर दूसरे शब्द से जोड़ते हुए इस फोकस का उपयोग करते हैं।

हमने देखा कि सेल्फ-अटेंशन (और संक्षेप में अन्य—जैसे कॉज़ल और क्रॉस अटेंशन) प्रत्येक टोकन को समृद्ध, संदर्भ-समझ रखने वाला निरूपण देता है। और फिर हमने इसे मल्टी-हेड अटेंशन तक बढ़ाया, जहाँ एक “टॉर्च” पर निर्भर रहने के बजाय, हम मॉडल को अनेक टॉर्च देते हैं—जो एक साथ वाक्य में अलग-अलग पैटर्न पकड़ते हैं।

यही वह चीज़ है जो ट्रांसफ़ॉर्मर्स को वास्तविक शक्ति देती है। वे केवल पढ़ते नहीं; वे पूरे अनुक्रम में निहित संरचना, अर्थ और संबंधों को समझते हैं। 

अब, इस लेख में हमने ट्रांसफ़ॉर्मर्स के एक पहलू को कवर किया है, लेकिन अभी और भी बहुत कुछ सीखना है, तो यह पूरा, विस्तृत कोर्स देखें: Transformer Models with PyTorch Course. 

यदि आप सीधे एप्लिकेशन पक्ष में कूदना चाहते हैं, तो मैं यह भी सिफारिश करूँगा: Developing Multi-Input Models For OCR प्रोजेक्ट या Working with HuggingFace कोर्स। अगर आप लेख पसंद करते हैं, तो यह सहज Complete Guide to Building a Transformer Model with PyTorch और मेरा Vision Transformers पर अन्य गाइड देखें।