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

साइनसॉइडल पोज़िशनल एन्कोडिंग

वे साइन और कोसाइन पोज़िशन वेक्टर निकालें जिन्हें Transformer टोकन एम्बेडिंग में जोड़ते हैं।

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

  • साइन और कोसाइन पोज़िशन वेक्टर निकालना
  • हर आयाम के लिए अलग आवृत्ति उपयोग करना
  • समझना कि Transformer शब्दों का क्रम कैसे जानते हैं

समस्या

अटेंशन शब्दों के क्रम को नज़रअंदाज़ करता है, इसलिए मूल Transformer हर टोकन एम्बेडिंग में एक पोज़िशनल एन्कोडिंग जोड़ता है। d_model आकार वाले मॉडल में पोज़िशन pos और आयाम j (दोनों 0 से) के लिए:

  • 'सम j: PE[pos][j] = sin(pos / 10000^(j / d_model))'
  • 'विषम j: PE[pos][j] = cos(pos / 10000^((j - 1) / d_model))'

इसलिए आयाम 0 और 1 एक आवृत्ति साझा करते हैं, आयाम 2 और 3 अगली, और इसी तरह आगे।

positional_encoding(length, d_model) लागू करें।

इनपुट

length: पोज़िशन की संख्या (0 से length - 1)।

d_model: एम्बेडिंग का आकार।

आउटपुट

length × d_model मैट्रिक्स लौटाएँ।

सीमाएँ

1 ≤ length ≤ 200, 1 ≤ d_model ≤ 128

उदाहरण

उदाहरण 1
इनपुट:
length = 2
d_model = 4

अपेक्षित आउटपुट:
expected = [
    [0.0, 1.0, 0.0, 1.0],
    [0.841471, 0.540302, 0.01, 0.99995]
]
इनपुट:
long long length = 2;
long long d_model = 4;

अपेक्षित आउटपुट:
std::vector<std::vector<double>> expected = {
    {0.0, 1.0, 0.0, 1.0},
    {0.841471, 0.540302, 0.01, 0.99995}
};
इनपुट:
long length = 2;
long d_model = 4;

अपेक्षित आउटपुट:
double[][] expected = new double[][] {
    new double[] {0.0, 1.0, 0.0, 1.0},
    new double[] {0.841471, 0.540302, 0.01, 0.99995}
};

व्याख्या

पोज़िशन 0 हर जोड़ी के लिए sin(0) = 0 और cos(0) = 1 है: [0, 1, 0, 1]। पोज़िशन 1 आवृत्तियाँ 1 और 1 / 10000^(2/4) = 0.01 उपयोग करती है: [sin 1, cos 1, sin 0.01, cos 0.01] ≈ [0.841471, 0.540302, 0.01, 0.99995]।

उदाहरण 2
इनपुट:
length = 3
d_model = 1

अपेक्षित आउटपुट:
expected = [
    [0.0],
    [0.841471],
    [0.909297]
]
इनपुट:
long long length = 3;
long long d_model = 1;

अपेक्षित आउटपुट:
std::vector<std::vector<double>> expected = {
    {0.0},
    {0.841471},
    {0.909297}
};
इनपुट:
long length = 3;
long d_model = 1;

अपेक्षित आउटपुट:
double[][] expected = new double[][] {
    new double[] {0.0},
    new double[] {0.841471},
    new double[] {0.909297}
};

व्याख्या

केवल एक आयाम होने पर सिर्फ़ sin(pos) उपयोग होता है: [[0], [0.841471], [0.909297]]।

कैसे हल करें

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

संकेत 1

हर column एक frequency pair का है, और even तथा odd dimensions same angle की sine और cosine use करते हैं.

संकेत 2

Matrix बनाते समय positions और dimensions iterate करें, और angle को position और dimension pair से compute करें.

संकेत 3

Integer division और zero-based indexing का ध्यान रखें ताकि position 0 वाली पहली row expected starting pattern दे.

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

समय O(length * d_model), अतिरिक्त स्थान O(length * d_model)

संदर्भ

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

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

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

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

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

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