शुरुआती मूल बातें

अनुच्छेद 2 बताता है कि कैसे ध्यान, स्थिति और स्थिर प्रशिक्षण Generative Pre-Trained Transformer ब्लॉक के भीतर काम करते हैं।

केवल डिकोडर वाले Transformer ब्लॉक स्थिर, संदर्भ-जागरूक भाषा मॉडल बनाने के लिए प्रक्षेपण, ध्यान, कारण मास्किंग और फीड-फॉरवर्ड परतों का उपयोग करते हैं।

अनुच्छेद 2 बताता है कि कैसे ध्यान, स्थिति और स्थिर प्रशिक्षण Generative Pre-Trained Transformer ब्लॉक के भीतर काम करते हैं।

मुख्य जानकारी

  • डिकोडर-केवल ट्रांसफार्मर ब्लॉक मूल एन्कोडर-डेकोडर डिज़ाइन को प्रतिस्थापित करते हैंः स्टैक्ड ब्लॉक्स स्वयं ध्यान और फीड फॉरवर्ड परतों का उपयोग संदर्भित एम्बेडिंग से अगले टोकन की भविष्यवाणी करने के लिए करते हैं।
  • टोकन एम्बेडिंग को लर्नेड वेट्स के माध्यम से क्वेरी, कुंजी और वैल्यू मैट्रिक्स में प्रोजेक्ट किया जाता है; प्रश्न यह एन्कोड करते हैं कि कोई स्थिति क्या मांगती है, चाबियाँ वर्णन करती हैं कि वह क्या प्रदान करती है, और मान प्रतिनिधित्वों को अपडेट करने के लिए उपयोग की जाने वाली अर्थ संबंधी जानकारी ले जाते हैं।
  • ध्यान QKT के साथ समानता स्कोर की गणना करता है, ग्रेडिएंट को स्थिर करने के लिए उन्हें √d_head द्वारा मापता है और एक कारण मुखौटा लागू करता है जो भविष्य-टोकन ध्यान को अवरुद्ध कर देता है, ऑटोरेग्रेसिव पीढ़ी वैध रखता है।
  • लेख इस वास्तुकला को व्यावहारिक PyTorch-शैली के कार्यान्वयन से जोड़ता है, स्थिर प्रशिक्षण पर जोर देता है, मल्टी हेड समानांतरकरण और एम्बेडिंग के फीड फॉरवर्ड विस्तार / संकुचन।

मेटा विवरणः डिकोडर-केवल ट्रांसफार्मर ब्लॉक 128-आयामी एम्बेडिंग, चार सिर, मैट्रिक्स प्रक्षेपण, स्केल किए गए डॉट-उत्पाद ध्यान, कारण मास्क और पायटोर्च कोड का उपयोग करते हैं।

Article 2 explains how attention, position, and stable training operate inside a Generative Pre-Trained Transformer bloc

टैगः डिकोडर-केवल ट्रांसफार्मर, मल्टीहेडएटेन्शन, स्केल किए गए डॉट-उत्पाद ध्यान, पायटोर्च, कारण मास्किंग

विशेष रुप से प्रदर्शित छवि: (अंग्रेज़ी में) ">"</string> टोकन वेक्टरों का अमूर्त मैत्रीपूर्ण चित्रण ध्यान स्कोर बन जाता है, कोई पाठ नहीं, कोई लोगो नहीं, लोग नहीं।

जब सेमिनल 2017 पेपर Attention Is All You Need ने मूल ट्रांसफार्मर पेश किया, तो इसने एक डिकोडर के साथ एनकोडर को जोड़ा। Modern Large Language Models (एलएलएम) जैसे कि जीपीटी, लामा, मिस्ट्राल और डीपसेक ने एन्कोडर और क्रॉस-एटेंशन पथ को हटा दिया, जिससे क्रम में अगले टोकन की भविष्यवाणी करने के लिए एक सुव्यवस्थित डिकॉडर-केवल ट्रांसफॉर्मर आर्किटेक्चर बनाया गया। भाषा मॉडल बनाने या मूल्यांकन करने वाले पाठकों के लिए व्यावहारिक सवाल यह है कि शेष ब्लॉक टोकन वेक्टरों को संदर्भ-जागरूक आउटपुट में कैसे बदलते हैं, और पाइटोर्च उस प्रक्रिया को कैसे लागू कर सकता है?

एन्कोडर-डेकोडर डिजाइन से लेकर केवल डिकोडर वाले ब्लॉक तक

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

शिक्षण मॉडल में, एम्बेडिंग चौड़ाई d_model = 128 है। इसका मतलब है कि प्रत्येक टोकन के पास 128 आयामों के साथ एक वेक्टर प्रतिनिधित्व होता है, जो हमेशा एक शब्द या चरित्र नहीं होता है। मॉडल चार ध्यान सिर (हेड्स = 4) का उपयोग करता है, चार थ्रेड पर समानांतर सीखता है ताकि प्रत्येक सिर स्वतंत्र रूप से अपने वजन को सीख सके। उन विशेषताओं को सीखने के बाद, उन्हें संयुक्त किया जाता है और फीड-फॉरवर्ड नेटवर्क के माध्यम से पारित किया जा सकता है जो पहले विस्तारित होते हैं, फिर संकुचित हो जाते हैं, उसी आकार के आउटपुट में प्रतिनिधित्व करते हैं। बिंदु यह है कि सीक्वेंस में अन्य सभी टोकनों के सापेक्ष इसके संदर्भ की व्याख्या करने के लिए लर्निंग ब्लॉकों द्वारा एम्बेडेड पास करें। उत्पादन मॉडलों में, ये वास्तुशिल्प विकल्प काफी भिन्न होते हैं; यहां संख्याएं उदाहरण हैं, न कि एक सार्वभौमिक ठोस नुस्खा।

मैट्रिक्स प्रक्षेपण क्वेरी, कुंजी और मान बनाते हैं

एक मैट्रिक्स पंक्तियों और स्तंभों में व्यवस्थित डेटा है। LLM में, इनपुट डेटा मैट्रिस एक्स के आयाम (Context Length × d_model) हैं। उत्पादन कार्यभार के लिए, यह 32,000 × 512 हो सकता है, जहां 32,000 टोकन की संख्या में संदर्भ लंबाई है और 512 इनपुट एम्बेडिंग आकार है। मैट्रिक गुणा करने की आवश्यकता होती है कि पहले मैट्रिक्स के कॉलम दूसरे की पंक्ति से मेल खाते हों: (ए × बी) को (बी × सी) द्वारा गुणा करके आकार का एक नया मैटरिक्स प्राप्त होता है।

प्रत्येक एम्बेडिंग प्रतिनिधित्व एक्स के लिए, परत सीखी गई रैखिक प्रक्षेपणों को लागू करती हैः

Article 2 explains how attention, position, and stable training operate inside a Generative Pre-Trained Transformer bloc

Q = X · Wq
K = X · Wk
V = X · Wv

X इनपुट एम्बेडिंग मैट्रिक्स है, जिसे सीखे गए वेट मैट्रिस Wq, Wk और Wv से गुणा किया गया है। ये वजन यादृच्छिक रूप से शुरू किए जाते हैं, जैसे कि PyTorch के माध्यम से फ्रेमवर्क का उपयोग करते हुए torch.tensor ((requires_grad=True), और प्रशिक्षण के दौरान बैकप्रोपेगेशन द्वारा अनुकूलित होते हैं।

एक ठोस उदाहरण अनुक्रम लंबाई 4 और d_model = 4 का उपयोग करता है। मान लें कि X = [[1,0,1,2],[0,2,1,0],[1,1,0,1],[2,0,2,1]] और Wq = [[ 1,0,1,0]],[0,1,0,1),[1,-1,0,0], [0,1,1,-1] । पंक्ति से पंक्ति गुणा करने पर [2,1,3,-2], [1,1, 0,2], [1,2, 2, 0] और [4, -1, 3, -1 ] मिलता है। स्रोत तब एक अंतिम Q प्रदर्शित करता है जिसकी तीसरी पंक्ति [1, 2, 2, 1], इसलिए इस उदाहरण में पंक्ति गणना और अंतिम मैट्रिक्स के बीच असंगति होती है।

प्रारंभ में, सभी भार मैट्रिक्स शून्य के पास छोटे यादृच्छिक मान रखते हैं। प्रशिक्षण के दौरान, वे अलग-अलग विशेषताओं को कैप्चर करना सीखते हैं। परिवर्तित वैक्टर विभिन्न कार्यात्मक भूमिकाओं की सेवा करते हैंः क्वेरी (क्यू) पूछता है कि टोकन स्थिति क्या देख रही है, कुंजी (के) वर्णन करती है कि संदर्भ के लिए टोकन स्थान क्या प्रदान करता है, और मूल्य (वी) वास्तविक सिमेंटिक जानकारी का संयोजन करता है। प्रक्षेपण आकार [संदर्भ × डी_मॉडल] × [डी_मोडेल × ड_आउट] = [संप्रेक्ष्य × डी _ आउट] के रूप में कल्पना किया जा सकता है। उदाहरण के लिए, [32,000 × 512] × [512 × 4,096]] = [[६ × ७]] ।

स्केल्ड डॉट-प्रोडक्ट ध्यान कारण मास्क जोड़ता है

ध्यान तंत्र टोकन एम्बेडिंग को प्रदान किए गए संदर्भ विंडो में अपनी पारस्परिक समानताओं की गणना करने की अनुमति देता है। एक सिर के लिए, समीकरण हैः

ध्यान देना ((Q, K, V) = सॉफ्टमैक्स (((Q · केटी / √डी_हेड) + कारण मुखौटा)) · वी

सबसे पहले, Q और KT को गुणा किया जाता है। यदि Q का आकार (32,000 × 4,096) होता है, तो इसे की मैट्रिक्स केटी के ट्रांसपोज़ द्वारा गुणा किया जाएगा, जिसके आयाम (4,096 × 32,000) हैं। इस मैट्रिक्स गुणन के परिणामस्वरूप आकार का एक ध्यान स्कोर मैट्रिस बनता है ( 32,000 × 32,000), प्रत्येक जोड़ी पदों के बीच कच्चे संबंध स्कोर का मानचित्रण करता है।

Article 2 explains how attention, position, and stable training operate inside a Generative Pre-Trained Transformer bloc

दूसरा, स्कोर को √d_head से विभाजित किया जाता है। जैसे-जैसे हेड आयाम बड़ा होता जाता है, डॉट प्रोडक्ट्स परिमाण में बड़े होते जाते हैं। यह सॉफ्टमैक्स फ़ंक्शन को बेहद छोटे ढाल वाले क्षेत्रों में धकेल देता है। इन मानों को नीचे की ओर बढ़ाता है, बैकप्रोपेगेशन के दौरान प्रवाह को स्थिर करता है।

तीसरा, एक ऑटोरेग्रेसिव डिकोडर को भविष्य में नहीं देखना चाहिए। अगले शब्द की भविष्यवाणी करते समय, इसे केवल वर्तमान और पिछले टोकन तक पहुंच होनी चाहिए। इस शर्त को लागू करने के लिए, सॉफ़्टमैक्स फ़ंक्शन को लगाने से पहले स्केल किए गए स्कोर में एक कारण मास्क जोड़ा जाता है। यह मुखौटा सभी ऊपरी-त्रिकोणात्मक पदों को सेट करता है, जो भविष्य के टोकन का प्रतिनिधित्व करते हैं, नकारात्मक अनंत (-∞) पर। चूंकि e^(-∞) = 0, सॉफ्टमैक्स ऑपरेशन उन भावी टोकन को बिल्कुल 0 की संभावना प्रदान करता है।

एक छोटा सा उदाहरण अनुक्रम को दर्शाता है। कच्चे QKT स्कोर [12,4,8], [3,9,2], और [7,6,11] हैं. कारणिक मास्किंग के बाद, वे बन जाते हैं [12,-∞,-∞] , [3,9 -∞), और [ 7,6,11] । सॉफ्टमैक्स के बाद पंक्तियां बन जाती हैं [1.0, 0.0, 0.002,0.998,0.0, और [0.02,0.01,0.97. सॉफ्टमेक्स लागू करने से गारंटी मिलती है कि प्रत्येक पंक्ति में वजन की राशि ठीक 1.0 तक होती है, उन्हें वैध संभाव्यता वितरण में बदल देती है।

उदाहरण के लिए, टोकन पोजीशन 4 पर, मॉडल 1 से 4 तक स्थितियों को वजन 0.05, 0.15, 0.70, 0.10] असाइन कर सकता है। स्थिति 4 के लिए अंतिम आउटपुट वेक्टर की गणना उन ऐतिहासिक मूल्य वैक्टरों के भारित मिश्रण के रूप में की जाती हैः

आउटपुट_4 = 0.05·V1 + 0.15·V2 + 0.70·V3 + 0.10·V4

PyTorch में MultiHeadAttention और समूहबद्ध क्वेरी ध्यान लागू करना

स्रोत पूरे उद्योग में उपयोग किए जाने वाले चार प्रमुख ध्यान वेरिएंट के लिए एक PyTorch पथ प्रस्तुत करता है, फिर मल्टीहेडएटेंशन और ग्रुपडेडक्वेरीएटेंस को परिभाषित करता है। क्रमांकित चरणों में कार्यान्वयन का पालन किया जा सकता है।

  1. d_model और num_heads के साथ MultiHeadAttention के लिए एक torch.nn.Module बनाएँ। इस बात का दावा करें कि डी_मॉडेल % नुम_हेड्स == 0, संदेश के साथ डी_मोडल को संख्याओं द्वारा विभाज्य होना चाहिए, क्योंकि प्रत्येक सिर को डी_हेड = डी_मोडेल // संख्याएं प्राप्त होती हैं।
  2. बिना पूर्वाग्रह के चार nn.Linear प्रक्षेपण बनाएँ: W_q, W_k, W _ v और out_proj। मानक MultiHeadAttention में, मॉड्यूल प्रत्येक सिर के लिए अलग-अलग W_ q,W_k और W_v पथ आवंटित करता है।
  3. अग्रिम में, बैच आकार बी, अनुक्रम लंबाई टी और एम्बेडिंग आयाम सी को x.shape से अनपैक करें।
  4. W_q, W_k और W_v के माध्यम से प्रोजेक्ट x; फ्लैट चैनल आयाम को num_heads और d_head में पुनः आकार दें; फिर ट्रांसपोज़ करें ताकि हेड्स आयाम T से पहले आए। यह सभी बैचों और सिरों पर एक बार में तेज, समानांतर मैट्रिक्स गुणन की अनुमति देता है।
  5. गणना स्कोर = (q @ k.transpose(-2, -1)) / (self.d_head ** 0.5। एक कारण मुखौटा जोड़ा torch.triu ((torch.full (((T, T), फ्लोट ((('-inf'), device=x.device), विकर्ण = 1) के साथ बनाया गया है। निचले आधे भाग पर शून्य पिछले टोकन को बात करने की अनुमति देते हैं, जबकि-इनफ भविष्य के टोकन ब्लॉक करता है।
  6. F.softmax को मास्क्ड स्कोर पर लागू करें, प्रत्येक सिर के लिए संदर्भ वेक्टर प्राप्त करने के लिए परिणाम को v से गुणा करें, हेड्स और अनुक्रम की लंबाई को मूल क्रम में वापस ट्रांसपोज़ करें, आसन्न कॉल करें, टेंसर को B, T, C पर वापस देखें, और out_proj के माध्यम से संदर्भ पास करें।
  7. GroupedQueryAttention के लिए, d_model, num_query_heads और num_kv_groups को स्वीकार करें.
  8. W_q प्रोजेक्ट को num_query_heads * d_head पर बनाएँ, जबकि W_k और W_v प्रोजेक्ट को Num_kv_groups * d _ head. क्वेरी हेड्स की संख्या से मेल खाने के बजाय, यह मेमोरी पदचिह्न संपीड़ित करने के लिए कुंजी और मान सिरों को एक छोटी संख्या तक सीमित करता है।
  9. आगे, प्रोजेक्ट q, k और v का उपयोग करें फिर repeat_interleave ((queries_per_group, dim=1) को k तथा v पर प्रयोग करें ताकि साझा की एवं वैल्यू हेड्स को हेड आयाम में दोहराया जा सके और तेज़, समानांतर बैच मैट्रिक्स गुणन के लिए क्वेरी मैट्रिक्स के सटीक आकार से मेल खाए।

आम गलतियाँ

सबसे आम कार्यान्वयन त्रुटियां सीधे उपरोक्त नियमों से पता लगाती हैं। पहला, num_heads को सेट करना ताकि d_model num_head द्वारा विभाजित न हो तो हेड स्प्लिट टूट जाता है। दूसरा, कारण मुखौटा छोड़ना एक डिकोडर को भविष्य के टोकन पर ट्रेन करने देता है, जो अगले-टोकन की भविष्यवाणी को बर्बाद करता है। तीसरा, √d_head स्केलिंग को भूलने से सॉफ्टमैक्स स्कोर बहुत बड़े हो सकते हैं, ग्रेडिएंट प्रवाह कमजोर हो सकता है। चौथा, शिक्षण संख्याओं का इलाज करना d_model = 128, heads = 4, या उत्पादन उदाहरण 32,000 × 512 सार्वभौमिक विकल्पों के रूप में पाठक भ्रामक कर सकते हैं; उत्पादन वास्तुकला भिन्न होता है। पांचवां, GroupedQueryAttention में, साझा कुंजी और मान repeat_interleave करने में विफलता टेंसर सिर को क्वेरी सिर से मिलान होने से रोकती है।

Comments (0)

  1. No comments yet. Be the first to share what worked for you.

Leave a comment

Comments are reviewed before they appear. Your email address is not published.