सभी चुनौतियाँ
मध्यम 0 हल किए गए 0% स्वीकृति

कॉज़ल (मास्क्ड) सेल्फ़-अटेंशन

GPT मॉडल का मास्क्ड अटेंशन लागू करें, जिसमें हर टोकन केवल ख़ुद को और पिछले टोकन को देख सकता है।

आप क्या सीखेंगे

  • कॉज़ल मास्क से भविष्य के टोकन छिपाना
  • केवल अनुमत स्थितियों पर सॉफ़्टमैक्स लगाना
  • समझना कि भाषा मॉडल टेक्स्ट कैसे बनाते हैं

समस्या

भाषा मॉडल को भविष्य के शब्द नहीं देखने चाहिए। कॉज़ल अटेंशन भविष्य को मास्क कर देता है: क्वेरी पंक्ति i केवल की पंक्तियों 0 से i पर ध्यान दे सकती है।

हर पंक्ति i के लिए (queries, keys और values सभी में n पंक्तियाँ हैं):

  1. हर अनुमत की j ≤ i को स्कोर दें: score = (queries[i] · keys[j]) / √d, जहाँ d keys के कॉलम की संख्या है।
  2. केवल इन अनुमत स्कोर पर softmax लगाएँ (e^x निकालने से पहले सबसे बड़ा घटाएँ)।
  3. आउटपुट पंक्ति i = j ≤ i पर Σ weight_j × values[j]।

causal_attention(queries, keys, values) लागू करें।

इनपुट

queries, keys: d संख्याओं वाली n पंक्तियाँ।

values: v संख्याओं वाली n पंक्तियाँ।

आउटपुट

n × v आउटपुट मैट्रिक्स लौटाएँ।

सीमाएँ

1 ≤ n ≤ 50, 1 ≤ d, v ≤ 32

-10 ≤ हर मान ≤ 10

उदाहरण

उदाहरण 1
इनपुट:
queries = [
    [0.0],
    [0.0],
    [0.0]
]
keys = [
    [1.0],
    [2.0],
    [3.0]
]
values = [
    [3.0],
    [6.0],
    [9.0]
]

अपेक्षित आउटपुट:
expected = [
    [3.0],
    [4.5],
    [6.0]
]
इनपुट:
std::vector<std::vector<double>> queries = {
    {0.0},
    {0.0},
    {0.0}
};
std::vector<std::vector<double>> keys = {
    {1.0},
    {2.0},
    {3.0}
};
std::vector<std::vector<double>> values = {
    {3.0},
    {6.0},
    {9.0}
};

अपेक्षित आउटपुट:
std::vector<std::vector<double>> expected = {
    {3.0},
    {4.5},
    {6.0}
};
इनपुट:
double[][] queries = new double[][] {
    new double[] {0.0},
    new double[] {0.0},
    new double[] {0.0}
};
double[][] keys = new double[][] {
    new double[] {1.0},
    new double[] {2.0},
    new double[] {3.0}
};
double[][] values = new double[][] {
    new double[] {3.0},
    new double[] {6.0},
    new double[] {9.0}
};

अपेक्षित आउटपुट:
double[][] expected = new double[][] {
    new double[] {3.0},
    new double[] {4.5},
    new double[] {6.0}
};

व्याख्या

सभी स्कोर 0 हैं, इसलिए हर पंक्ति उन मानों का औसत लेती है जो उसे दिखते हैं: पंक्ति 0 केवल 3 देखती है, पंक्ति 1 3 और 6 का औसत (4.5) लेती है, पंक्ति 2 तीनों का औसत (6) लेती है।

उदाहरण 2
इनपुट:
queries = [
    [1.0, 0.0],
    [1.0, 0.0]
]
keys = [
    [1.0, 0.0],
    [1.0, 0.0]
]
values = [
    [1.0, 2.0],
    [3.0, 4.0]
]

अपेक्षित आउटपुट:
expected = [
    [1.0, 2.0],
    [2.0, 3.0]
]
इनपुट:
std::vector<std::vector<double>> queries = {
    {1.0, 0.0},
    {1.0, 0.0}
};
std::vector<std::vector<double>> keys = {
    {1.0, 0.0},
    {1.0, 0.0}
};
std::vector<std::vector<double>> values = {
    {1.0, 2.0},
    {3.0, 4.0}
};

अपेक्षित आउटपुट:
std::vector<std::vector<double>> expected = {
    {1.0, 2.0},
    {2.0, 3.0}
};
इनपुट:
double[][] queries = new double[][] {
    new double[] {1.0, 0.0},
    new double[] {1.0, 0.0}
};
double[][] keys = new double[][] {
    new double[] {1.0, 0.0},
    new double[] {1.0, 0.0}
};
double[][] values = new double[][] {
    new double[] {1.0, 2.0},
    new double[] {3.0, 4.0}
};

अपेक्षित आउटपुट:
double[][] expected = new double[][] {
    new double[] {1.0, 2.0},
    new double[] {2.0, 3.0}
};

व्याख्या

पंक्ति 0 केवल ख़ुद को देखती है और values[0] = [1, 2] की नकल करती है। पंक्ति 1 दोनों की को बराबर स्कोर देती है और उनका औसत लेती है: [2, 3]।

कैसे हल करें

पहले खुद कोशिश करें, फिर एक-एक करके संकेत खोलें।

संकेत 1

हर output row सिर्फ current row और उससे पहले वाली rows के keys और values use कर सकती है.

संकेत 2

Dot products compute करें, उन्हें key dimension के square root से scale करें, फिर सिर्फ allowed rows पर stable softmax apply करें.

संकेत 3

हर query row के लिए अलग से normalize करना याद रखें, और पहली row को सिर्फ एक allowed key के साथ handle करें.

अपेक्षित जटिलता

समय O(n^2 * (d + v)), अतिरिक्त स्थान O(n * v)

संदर्भ

यह चुनौती CodeUtility के लिए अनुकूलित की गई है। ऊपर दिए गए स्टेटमेंट और सीमाओं का पालन करें।

हर कोडर का सबसे अच्छा पास हुआ समाधान। तेज़, कम मेमोरी वाले और बेहतर रेटिंग वाले समाधान ऊपर रहते हैं।

अभी कोई पास हुआ समाधान नहीं है। इसे हल करें और पहला स्थान पाएँ।

दूसरों से सीखें

समुदाय समाधान

अभी तक कोई प्रकाशित समाधान नहीं। पहला साझा करने के लिए इस चुनौती को हल करें।