क्या पूरे दिन का प्रसंग दस मिनट के प्रसंग को मात देता है? फ़्लैश ध्यान और अनुक्रम-लंबाई प्रश्न

यह वह प्रश्न है जिसका उत्तर देने के लिए यह लेख मौजूद है: यदि एक ट्रांसफार्मर दस मिनट की विंडो के बजाय एक सेकंड के रिज़ॉल्यूशन पर पूरे ट्रेडिंग दिन में भाग ले सकता है, तो क्या यह बेहतर भविष्यवाणी करेगा?

कुछ समय पहले तक आप पूछ भी नहीं सकते थे. मानक ध्यान की जरूरत है $\mathcal{O}(N^2)$ मेमोरी, इसलिए फ्लोट16 में 12 हेड्स पर 23,400-कदम वाले दिन में अकेले स्कोर मैट्रिक्स के लिए लगभग 12.9 जीबी की आवश्यकता होती है - मॉडल मापदंडों से अधिक, और अधिकांश कार्ड से अधिक जो आपको देगा। इससे पहले कि कोई इसका परीक्षण कर पाता, प्रश्न को अंकगणित द्वारा बंद कर दिया गया।

फ्लैश अटेंशन (दाओ एट अल., 2022) इसे खोलता है। ध्यान का अनुमान लगाकर नहीं - यह सटीक समान परिणाम की गणना करता है - बल्कि आईओ-अवेयर होने के लिए गणना को पुनर्गठित करके, जीपीयू मेमोरी स्तरों के बीच ट्रैफ़िक को कम करता है। यह वास्तव में यहां दिलचस्प सामग्री है, और इस लेख का अधिकांश भाग इस पर खर्च किया गया है कि यह कैसे काम करता है: टाइलिंग, ऑनलाइन-सॉफ्टमैक्स पुनरावृत्ति, $\Theta(N^2 d^2 / M)$ आईओ बाउंड, और बैकवर्ड-पास पुनर्गणना।

लेकिन तंत्र समर्थकारी है, दावा नहीं। "लंबा संदर्भ बेहतर है" बाजारों और इस ब्लॉग की स्थिति के बारे में एक अनुभवजन्य कथन है - [टेम्पोरल फ्यूजन ट्रांसफॉर्मर्स] से (/en/blog/post/temporal-fusion-transformer-trading), जिसमें पाया गया कि वित्तीय श्रृंखला ओवरफिट और शॉर्ट-लुकबैक आवर्तक मॉडल पर वेनिला ट्रांसफार्मर उच्च आवृत्ति पर प्रतिस्पर्धी बने रहते हैं - दूसरे तरीके से कटौती करते हैं। तो लेख माप पर समाप्त होता है, तंत्र पर नहीं।

ध्यान स्मृति-बद्ध क्यों है

ध्यान गणना करता है $\text{softmax}(\mathbf{Q}\mathbf{K}^\top / \sqrt{d_k})\mathbf{V}$ - व्यापारिक संदर्भ में, आदिम स्वयं, [मल्टी-होरिजन पोर्टफोलियो पूर्वानुमान के लिए टेम्पोरल फ्यूजन ट्रांसफॉर्मर] में शामिल है।/en/blog/post/temporal-fusion-transformer-trading). पूरी समस्या उसी की एक पंक्ति है: मध्यवर्ती स्कोर मैट्रिक्स $\mathbf{S} = \mathbf{Q}\mathbf{K}^\top/\sqrt{d_k}$ है $N \times N$, इसे मेमोरी में लिखा जाता है, सॉफ्टमैक्स के लिए वापस पढ़ा जाता है, फिर से लिखा जाता है, और अंतिम मैटमुल के लिए फिर से पढ़ा जाता है - और इसे बैकप्रोपेगेशन के लिए रखा जाना चाहिए।

ध्यान की अंकगणितीय तीव्रता है $\approx \min(d, N)$, तो लगभग 64 फ्लॉप/बाइट पर $d = 64$ - A100 रिज बिंदु के बिल्कुल बाईं ओर। यह ढलान वाली बैंडविड्थ छत पर बैठता है, न कि सपाट कंप्यूट छत पर: GPU चलने में अधिक समय खर्च करता है $\mathbf{S}$ किसी भी चीज़ को गुणा करने की तुलना में चारों ओर। यह जिस रूफलाइन फ्रेमवर्क का उपयोग करता है - रिज बिंदु, ढलान बनाम सपाट छत, और यही कारण यह तय करता है कि जीपीयू खरीदने लायक है या नहीं - इसे [जब जीपीयू भुगतान करता है] में मापी गई संख्याओं के साथ बनाया गया है।/en/blog/post/when-gpu-pays-off-sweep-roofline).

एल्गोरिथ्म स्मृति पदानुक्रम का शोषण करता है

SRAM लगभग 10x बैंडविड्थ और 100x कम विलंबता है, क्षमता के हजारवें हिस्से पर। फ्लैश अटेंशन जो कुछ भी करता है वह उस व्यापार से होता है: क्षमता छोड़ें, बैंडविड्थ और विलंबता खरीदें। वही "हार्डवेयर खरीदने के बजाय एल्गोरिदम का पुनर्गठन करें" कदम, जिसे सीपीयू बैकटेस्ट पर मापा जाता है, [बैकटेस्ट स्पीड सीढ़ी] है/en/blog/post/backtest-engine-speed-ladder).

फ्लैश अटेंशन एल्गोरिदम

फ़्लैश अटेंशन SRAM में फ़िट होने के लिए टाइल्स आकार में ध्यान संसाधित करता है, और कभी भी पूर्ण रूप से कार्यान्वित नहीं होता है $N \times N$ एचबीएम में मैट्रिक्स बिल्कुल।

PARTITION $\mathbf{Q}$ में $T_r = \lceil N/B_r \rceil$ पंक्ति ब्लॉक और $\mathbf{K}, \mathbf{V}$ में $T_c = \lceil N/B_c \rceil$ कॉलम ब्लॉक, के साथ $B_r, B_c$ इसलिए चुना गया ताकि एक टाइल और उसके संचायक चिप पर फिट हो जाएं। प्रत्येक क्वेरी ब्लॉक के लिए, सभी कुंजी-मूल्य ब्लॉकों पर पुनरावृति करें:

For each query block Q_i:
    Initialize: O_i = 0, m_i = -inf, l_i = 0    # output, running max, running sum
    For each KV block (K_j, V_j):
        1. Load Q_i, K_j, V_j from HBM to SRAM
        2. Compute S_ij = Q_i @ K_j^T / sqrt(d)  # in SRAM
        3. Compute local max: m_ij = rowmax(S_ij)
        4. Compute P_ij = exp(S_ij - m_ij)        # in SRAM
        5. Compute local sum: l_ij = rowsum(P_ij)
        6. Update running statistics:
           m_new = max(m_i, m_ij)
           l_new = l_i * exp(m_i - m_new) + l_ij * exp(m_ij - m_new)
           O_i = O_i * (l_i * exp(m_i - m_new) / l_new)
                + P_ij @ V_j * (exp(m_ij - m_new) / l_new)
           m_i = m_new, l_i = l_new
    Write O_i to HBM

ऑनलाइन सॉफ्टमैक्स पुनरावृत्ति

वह तरकीब जो टाइलिंग को संभव बनाती है वह है ऑनलाइन सॉफ्टमैक्स। एक भोले सॉफ्टमैक्स को पंक्ति के ऊपर से दो पास की आवश्यकता होती है: एक अधिकतम (संख्यात्मक स्थिरता के लिए) खोजने के लिए, एक घातांक और सामान्यीकरण के लिए। एक पंक्ति में दो पास जिन्हें आप संग्रहीत करने से इनकार करते हैं, एक विरोधाभास है - इसलिए फ्लैश अटेंशन आंकड़े चलाता रहता है और जैसे-जैसे आगे बढ़ता है, पुन: स्केल करता रहता है।

ब्लॉक के बाद $1, \ldots, j$:

और आउटपुट संचायक को उसी कारक द्वारा ठीक किया जाता है:

हर बार जब कोई नया ब्लॉक रनिंग अधिकतम बढ़ाता है, तो पहले से संचित आउटपुट को पूर्वव्यापी रूप से पुन: स्केल किया जाता है $e^{m^{(j-1)} - m^{(j)}}$ - मानो नए मैक्स को शुरू से ही जाना गया हो। परिणाम बीजगणितीय रूप से दो-पास सॉफ्टमैक्स के समान है। सटीक अंकगणित में यह कोई अनुमान नहीं है; यह एक पुनर्संगठन है। (सीमित परिशुद्धता में यह एक अलग गोलाकार पथ है, जो मायने रखता है - नीचे सटीकता जांच देखें।)

आईओ जटिलता

यह जीत का औपचारिक बयान है. फ्लैश अटेंशन प्रदर्शन करता है

एचबीएम पहुँचता है, कहाँ $M$ SRAM आकार के विपरीत है $\Theta(Nd + N^2)$ मानक कार्यान्वयन के लिए. ध्यान दें कि $M$ डिनोमिनेटर में दिखाई देता है: ऑन-चिप स्क्रैचपैड जितना बड़ा होगा, राउंड-ट्रिप उतनी ही कम होगी, यही कारण है कि एल्गोरिदम को फ्लॉप गिनती के बजाय मेमोरी पदानुक्रम के संदर्भ में बताया गया है। ठेठ के लिए $d = 64$ और $M \approx 100$ केबी, अनुपात लगभग 5-10 गुना कम एक्सेस द्वारा फ्लैश अटेंशन का पक्ष लेता है।

बैकवर्ड पास: स्टोर के बजाय पुनर्गणना करें

ध्यान के माध्यम से बैकप्रोपेगेशन की सामान्य रूप से आवश्यकता होती है $\mathbf{P}$ मैट्रिक्स जिसे फॉरवर्ड पास ने रखने से इनकार कर दिया। फ्लैश अटेंशन टाइल्स की पुनर्गणना करता है $\mathbf{Q}, \mathbf{K}$ बैकवर्ड पास के दौरान, केवल आउटपुट संग्रहीत करना $\mathbf{O}$ और सॉफ्टमैक्स आँकड़े $(m, \ell)$ - दोनों $\mathcal{O}(N)$, नहीं $\mathcal{O}(N^2)$. यह स्मृति अवधि के लिए अनावश्यक अंकगणित की एक मामूली मात्रा का व्यापार करता है जो पूरी समस्या थी। यह ग्रेडिएंट चेकपॉइंटिंग के समान ही सौदा है, जिसे एक ही ऑपरेटर के अंदर टाइल ग्रैन्युलैरिटी पर लागू किया जाता है।

एफए2: समानता

फ्लैश अटेंशन 2 (दाओ, 2023) ने एल्गोरिदम रखा और शेड्यूलिंग तय की:

1. कम गैर-मैटमुल FLOPs। FA1 ने रीस्केलिंग, अधिकतम-खोज और घातांक पर वास्तविक समय बिताया - संचालन जो CUDA कोर पर चलते हैं, टेंसर कोर पर नहीं। FA2 आंतरिक लूप के अंत तक पुनर्स्केलिंग को स्थगित करता है।
2. अनुक्रम लंबाई पर समानता। FA1 केवल बैच और शीर्षों पर समानता रखता है। FA2 क्वेरी ब्लॉकों पर भी समानांतर चलता है। यह विशेष रूप से ट्रेडिंग मामले के लिए मायने रखता है, जहां आपके पास अक्सर प्रति संपत्ति एक बहुत लंबा अनुक्रम और 1-4 का बैच आकार होता है - बिल्कुल वही व्यवस्था जहां बैच-एंड-हेड समानता जीपीयू को भूखा रखती है।
3. ताना कार्य विभाजन। प्रत्येक ताना एक स्कोर गणना को विभाजित करने और ताना-बाना को कम करने, क्रॉस-ताना कटौती को हटाने के बजाय क्वेरी ब्लॉक का एक अलग उपसमूह लेता है।

रिपोर्ट किए गए परिणाम: A100 पर ~70% सैद्धांतिक शिखर FLOP बनाम FA1 के लिए ~35%।

FA3: हॉपर यांत्रिकी

फ्लैश अटेंशन 3 (दाओ, शाह, 2024) एच100 के लिए आर्किटेक्चर-विशिष्ट है:

1. अतुल्यकालिक ताना विशेषज्ञता। हॉपर का टेन्सर मेमोरी एक्सेलेरेटर (टीएमए) एचबीएम → एसआरएएम को अतुल्यकालिक रूप से स्थानांतरित करता है। एफए3 अगले केवी ब्लॉक के लिए टीएमए लोड जारी करने वाले निर्माताओं और मौजूदा ब्लॉक पर कंप्यूटिंग करने वाले उपभोक्ताओं में वारप्स को विभाजित करता है, इसलिए डेटा आंदोलन अंकगणित के पीछे छिप जाता है।
2. इंटरलीव्ड मैटमुल और सॉफ्टमैक्स। $\mathbf{Q}_i\mathbf{K}_j^\top$ एक ब्लॉक के लिए टेंसर कोर पर चलता है जबकि पिछले ब्लॉक के लिए सॉफ्टमैक्स CUDA कोर पर चलता है - दो अलग-अलग हार्डवेयर इकाइयां, समय-कटा हुआ के बजाय वास्तव में समवर्ती।
3. असंगत प्रसंस्करण के साथ FP8। H100 2x FP16 थ्रूपुट पर FP8 करता है। अनुभवहीन FP8 का ध्यान आउटलेर्स द्वारा नष्ट कर दिया जाता है; FA3 निर्देशांकों में बाहरी परिमाण को फैलाने के लिए ब्लॉक-वार परिमाणीकरण से पहले बेतरतीब ढंग से वैक्टर को घुमाता है, जो कि अनुभवहीन FP8 की तुलना में 2.6x कम संख्यात्मक त्रुटि पर रिपोर्ट किया गया है।

कॉज़ल मास्किंग वह जगह है जहां व्यापार को छूट मिलती है

समय श्रृंखला के लिए कॉज़ल मास्किंग अनिवार्य है - मॉडल को भविष्य में शामिल नहीं होना चाहिए - और टाइलिंग के तहत यह एक अतिरिक्त लागत नहीं है बल्कि एक बचत है। कोई भी टाइल जिसकी कुंजियाँ पूरी तरह से उसके प्रश्नों के सापेक्ष भविष्य में होती हैं, उसे एकमुश्त छोड़ दिया जाता है, कभी लोड नहीं किया जाता और कभी गणना नहीं की जाती, जिससे लगभग आधा काम कट जाता है। PyTorch में यह है is_causal=True; और कुछ भी आवश्यक नहीं है.

एकीकरण आठ पंक्तियों का है

आपके लिए आवश्यक लगभग कोई भी कोड फ़्लैश अटेंशन के बारे में नहीं है। फ़्यूज्ड कर्नेल के लिए स्पष्ट स्कोर-मैट्रिक्स पथ को स्वैप करें:

scores = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(d_head)
scores = scores.masked_fill(causal_mask, float("-inf"))
out = torch.matmul(torch.softmax(scores, dim=-1), v)

out = torch.nn.functional.scaled_dot_product_attention(
    q, k, v,
    dropout_p=self.dropout if self.training else 0.0,
    is_causal=True,
)

यही संपूर्ण परिवर्तन है. q, k, v आकार दिए गए हैं (batch, heads, seq, head_dim); कारणात्मक मुखौटा ख़त्म हो गया है क्योंकि कर्नेल इसका निर्माण करता है। संपूर्ण एनोटेटेड PyTorch ट्रेडिंग मॉडल के लिए - इनपुट प्रोजेक्शन, ब्लॉक और 3-क्लास अप/फ्लैट/डाउन हेड में इसे ड्रॉप करने के लिए - [DeepLOB] का उपयोग करें/en/blog/post/deeplob-deep-learning-order-book), और पूर्ण प्रशिक्षण पाइपलाइन के लिए देखें टेम्पोरल फ्यूजन ट्रांसफॉर्मर. उस मचान की चौथी प्रति यहां बनाने से कुछ नहीं मिलेगा।

आवश्यकताएँ: गणना क्षमता >= 8.0 (ए100, एच100, आरटीएक्स 3090+), अर्ध-सटीक इनपुट, पायटोरच >= 2.0। वास्तव में संलग्न तेज़ पथ को सत्यापित करें torch.backends.cuda.sdp_kernel निदान और torch.cuda.max_memory_allocated() - यदि कोई पूर्व शर्त विफल हो जाती है तो एसडीपीए चुपचाप गणित कर्नेल पर वापस आ जाता है, और एक मूक फ़ॉलबैक बिल्कुल एक कामकाजी मॉडल की तरह दिखता है जो केवल धीमा है।

माप: क्या लंबा संदर्भ भुगतान करता है?

उपरोक्त सभी बातें कहती हैं कि 32K या 128K संदर्भ अब किफायती है। यह इस बारे में कुछ नहीं कहता कि यह उपयोगी है या नहीं। ईमानदार प्रयोग:

उसी वास्तुकला को प्रशिक्षित करें $N \in \{512, 4096, 32768\}$ इस श्रृंखला में अन्यत्र उपयोग की जाने वाली बीटीसी श्रृंखला पर एसडीपीए-फ्लैश के साथ, पैरामीटर, ऑप्टिमाइज़र और लक्ष्य को स्थिर रखा जाता है, इसलिए अनुक्रम लंबाई ही एकमात्र चर है। दो बातें रिपोर्ट करें:

1. लागत. प्रति युग मापी गई दीवार-घड़ी और torch.cuda.max_memory_allocated() हरेक पर $N$.
2. लाभ. आउट-ऑफ़-सैंपल पूर्वानुमानित प्रदर्शन बनाम $N$, वॉक-फॉरवर्ड स्प्लिट पर।

इस आलेख के पहले के मसौदे में विश्लेषणात्मक रूप से प्राप्त अनुक्रम लंबाई के अनुसार स्मृति आंकड़ों की एक तालिका दी गई थी $\mathcal{O}(N)$ सक्रियण सूत्र. उन पंक्तियों को हटा दिया गया है: उन्हें कभी मापा नहीं गया था, और वे लेख के स्वयं के मेमोरी-बजट अंकगणित से असहमत थे। परिणाम तालिका में प्रस्तुत एक व्युत्पन्न संख्या एक मनगढ़ंत परिणाम है, और यह ब्लॉग उन्हें शिप नहीं करता है।

इस प्रयोग का दिलचस्प गुण यह है कि यह किसी भी दिशा में प्रकाशित किया जा सकता है। यदि आउट-ऑफ़-सैंपल प्रदर्शन नीरस रूप से बढ़ता है $N$, जो पूरे लंबे-संदर्भ कार्यक्रम को उचित ठहराता है। यदि यह कुछ हज़ार कदमों पर स्थिर हो जाता है, या ख़राब हो जाता है, तो यह एक मजबूत टुकड़ा है - [ईमानदार नकारात्मक] का साथी (/en/blog/post/honest-negative-no-robust-edge) - और इसका मतलब यह होगा कि मेमोरी वॉल कभी भी ट्रेडिंग ट्रांसफार्मर पर बाध्यकारी बाधा नहीं थी।

अधिक संदर्भ अधिक क्षमता है, इसलिए अधिक ओवरफिटिंग सतह

सपाट या नकारात्मक परिणाम की उम्मीद करने का एक विशेष कारण है। टेम्पोरल फ्यूजन ट्रांसफार्मर पहले से ही दस्तावेज हैं कि वेनिला ट्रांसफार्मर ने वित्तीय श्रृंखला ओवरफिट के लिए भोलेपन से आवेदन किया है - उनमें अस्थायी आगमनात्मक पूर्वाग्रहों की कमी है, और शॉर्ट-लुकबैक आवर्तक मॉडल उच्च आवृत्ति पर प्रतिस्पर्धी बने रहते हैं। संदर्भ को 512 से 32,768 चरणों तक विस्तारित करने से लंबाई के अनुपात में जानकारी नहीं जुड़ती; लगभग-कुशल मूल्य श्रृंखला का सीमांत 32,000वाँ अंतराल बहुत कम होता है। यह विश्वसनीय रूप से जो चीज़ जोड़ता है वह फिट होने वाली चीज़ों के मापदंडों का मूल्य है।

तो स्वीप ओवर $N$ इसे वैसे ही माना जाना चाहिए जैसे यह है: एक मॉडल-चयन खोज, उसी मशीनरी के साथ यह ब्लॉग हर दूसरी खोज पर लागू होता है। तीन अनुक्रमों की लंबाई जो कुछ भी भिन्न हो, एक परीक्षण गणना है, और विजेता को उस परीक्षण गणना और एक पीबीओ गेट के विरुद्ध गणना की गई डिफ्लेटेड शार्प रेशियो को पार करना होगा, न कि केवल अपने पड़ोसियों को हराना होगा। अन्यथा "लंबे संदर्भ की जीत" तीन शोर वाले रनों में से सर्वश्रेष्ठ को चुनने से अप्रभेद्य है।

एक सटीकता जांच, क्योंकि "सटीक" बहुत काम कर रहा है

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

ब्लॉग के पास पहले से ही सही उपकरण है। जीपीयू प्रिसिजन ट्रैप मानक स्थापित करता है: कम परिशुद्धता आपको चेतावनी नहीं देती है, यह प्रशंसनीय कचरा लौटाती है, और आप डाउनस्ट्रीम असतत मात्रा पर समता दैवज्ञ के साथ शुद्धता साबित करते हैं - व्यापार मायने रखता है - वक्रों पर नज़र डालकर नहीं। यहां लागू किया गया:

• बीएफ16 में एसडीपीए-फ्लैश के साथ और समान इनपुट पर एफपी64 संदर्भ कार्यान्वयन के साथ ध्यान की गणना करें; आउटपुट टेंसर पर अधिकतम सापेक्ष त्रुटि रिपोर्ट करें।
• इसे निर्णय के माध्यम से आगे बढ़ाएं: एक मॉडल के लिए जो ऊपर/फ्लैट/डाउन लेबल उत्सर्जित करता है, कुल निर्णयों के एक अंश के रूप में, दो पथों के बीच कितने लेबल फ़्लिप करते हैं, इसकी रिपोर्ट करें।

छोटी, सीमित, समझाने योग्य असहमति एक सही तेज़ रास्ते का हस्ताक्षर है। एक असीमित का मतलब है कि FP8 अनुशंसा इस मॉडल के लिए कभी भी सुरक्षित नहीं थी। जब तक इसे चलाया नहीं जाता तब तक कोई भी संख्या ज्ञात नहीं होती।

इसके लिए कब पहुंचना है

निर्णय के लिए संपीड़ित, जिसका आकार [जीपीयू निर्णय गाइड] के समान है(/en/blog/post/when-gpu-pays-off-sweep-roofline):

• CUDA GPU पर ~2K से अधिक टाइमस्टेप: हाँ, बिना शर्त। यह सटीक आउटपुट उत्पन्न करने वाला एक-पंक्ति परिवर्तन है, और जीत बढ़ती जाती है $N$. ऐसा कोई परिदृश्य नहीं है जहां आप भौतिकता चाहते हों $N \times N$ इसके बजाय पथ.
• ~512 टाइमस्टेप्स से नीचे, सीपीयू पर, या गैर-ध्यान आर्किटेक्चर (सीएनएन, एसएसएम जैसे माम्बा) के साथ: अप्रासंगिक। रिज के बाईं ओर, निश्चित ओवरहेड पूरी लागत है और ध्यान कभी भी आपकी बाधा नहीं था।
• उपरोक्त सीमाएँ लोककथाएँ हैं, माप नहीं - वे सामान्य साहित्य से आते हैं, और आपके अपने मॉडल और कार्ड पर क्रॉसओवर एक दस-लाइन बेंचमार्क है। गोल नंबरों पर भरोसा करने के बजाय इसे चलाएं।

निष्कर्ष

फ्लैश अटेंशन एक साफ और वास्तव में महत्वपूर्ण परिणाम है: मेमोरी पदानुक्रम का सम्मान करके और सॉफ्टमैक्स को फिर से जोड़कर, यह सटीक ध्यान की गणना करता है $\mathcal{O}(N)$ के स्थान पर स्मृति $\mathcal{O}(N^2)$, और यह $\Theta(N^2 d^2 / M)$ आईओ बाउंड स्पष्ट रूप से बताता है कि क्यों। ट्रेडिंग ट्रांसफार्मर में इसे अपनाना एक-पंक्ति परिवर्तन है जिसमें सटीक अंकगणित में कोई सटीकता लागत नहीं होती है और एक बड़ी मेमोरी जीत होती है।

यह जो नहीं करता है वह शीर्ष पर दिए गए प्रश्न का उत्तर है। यह "पूरे दिन का संदर्भ असंभव है" को "पूरे दिन का संदर्भ सस्ता है" में परिवर्तित करता है, जो प्रयोग की लागत में बदलाव है, न कि उसके परिणाम में। स्मृति दीवार का नीचे आना मापन के लिए एक निमंत्रण है, और माप ही इसे एक पेपर सारांश से एक निष्कर्ष में बदल देता है।

सन्दर्भ

1. दाओ, टी., फू, डी.वाई., एर्मन, एस., रुद्र, ए., रे, सी. "फ्लैशअटेंशन: आईओ-अवेयरनेस के साथ तेज और मेमोरी-कुशल सटीक ध्यान।" न्यूरआईपीएस (2022)। arXiv:2205.14135
2. दाओ, टी. "फ्लैशअटेंशन-2: बेहतर समानता और कार्य विभाजन के साथ तेज़ ध्यान।" आईसीएलआर (2024)। arXiv:2307.08691
3. दाओ, टी., शाह, जे. "फ्लैशअटेंशन-3: एसिंक्रोनी और लो-प्रिसिजन के साथ तेज और सटीक अटेंशन।" न्यूरआईपीएस (2024)। arXiv:2407.08608
4. वासवानी, ए., एट अल। "आपको केवल ध्यान देने की आवश्यकता है।" न्यूरआईपीएस (2017)।
5. मिलाकोव, एम., जिमेलशीन, एन. "सॉफ्टमैक्स के लिए ऑनलाइन नॉर्मलाइज़र गणना।" arXiv:1805.02867 (2018)।