मध्यम 0 हल किए गए 0% स्वीकृति

Sinusoidal Positional Encoding

Compute the sine and cosine position vectors Transformers add to token embeddings.

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

  • Compute sine and cosine position vectors
  • Use different frequencies per dimension
  • Understand how Transformers know word order

समस्या

अनुवाद दिखाएँ

Attention ignores word order, so the original Transformer adds a positional encoding to each token embedding. For position pos and dimension j (both starting at 0) in a model of size d_model:

  • even j: PE[pos][j] = sin(pos / 10000^(j / d_model))
  • odd j: PE[pos][j] = cos(pos / 10000^((j - 1) / d_model))

So dimensions 0 and 1 share one frequency, dimensions 2 and 3 the next, and so on.

Implement positional_encoding(length, d_model).

Input

length: The number of positions (0 to length - 1).

d_model: The embedding size.

Output

Return a length × d_model matrix.

सीमाएँ

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}
};

व्याख्या

Position 0 is sin(0) = 0 and cos(0) = 1 for every pair: [0, 1, 0, 1]. Position 1 uses frequencies 1 and 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}
};

व्याख्या

With one dimension only sin(pos) is used: [[0], [0.841471], [0.909297]].

कैसे हल करें

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

संकेत 1

Each column belongs to a frequency pair, with even and odd dimensions using sine and cosine of the same angle.

संकेत 2

Build the matrix by iterating positions and dimensions, computing the angle from the position and the dimension pair.

संकेत 3

Be careful with integer division and zero-based indexing so the first row at position 0 becomes the expected starting pattern.

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

O(length * d_model) time, O(length * d_model) extra space

संदर्भ

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

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

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

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

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

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