Todos los desafíos
Intermedio 0 resueltos 0% de aceptación

Codificación posicional sinusoidal

Calcula los vectores de posición seno y coseno que los Transformers suman a los embeddings de los tokens.

Lo que aprenderás

  • Calcular vectores de posición con seno y coseno
  • Usar frecuencias distintas por dimensión
  • Entender cómo los Transformers conocen el orden de las palabras

Problema

Ver original (inglés)

La atención ignora el orden de las palabras, así que el Transformer original suma una codificación posicional al embedding de cada token. Para la posición pos y la dimensión j (ambas desde 0) en un modelo de tamaño d_model:

  • 'j par: PE[pos][j] = sin(pos / 10000^(j / d_model))'
  • 'j impar: PE[pos][j] = cos(pos / 10000^((j - 1) / d_model))'

Así, las dimensiones 0 y 1 comparten una frecuencia, las dimensiones 2 y 3 la siguiente, y así sucesivamente.

Implementa positional_encoding(length, d_model).

Entrada

length: El número de posiciones (de 0 a length - 1).

d_model: El tamaño del embedding.

Salida

Devuelve una matriz length × d_model.

Restricciones

1 ≤ length ≤ 200, 1 ≤ d_model ≤ 128

Ejemplos

Ejemplo 1
Entrada:
length = 2
d_model = 4

Salida esperada:
expected = [
    [0.0, 1.0, 0.0, 1.0],
    [0.841471, 0.540302, 0.01, 0.99995]
]
Entrada:
long long length = 2;
long long d_model = 4;

Salida esperada:
std::vector<std::vector<double>> expected = {
    {0.0, 1.0, 0.0, 1.0},
    {0.841471, 0.540302, 0.01, 0.99995}
};
Entrada:
long length = 2;
long d_model = 4;

Salida esperada:
double[][] expected = new double[][] {
    new double[] {0.0, 1.0, 0.0, 1.0},
    new double[] {0.841471, 0.540302, 0.01, 0.99995}
};

Explicación

La posición 0 es sin(0) = 0 y cos(0) = 1 para cada par: [0, 1, 0, 1]. La posición 1 usa las frecuencias 1 y 1 / 10000^(2/4) = 0.01: [sin 1, cos 1, sin 0.01, cos 0.01] ≈ [0.841471, 0.540302, 0.01, 0.99995].

Ejemplo 2
Entrada:
length = 3
d_model = 1

Salida esperada:
expected = [
    [0.0],
    [0.841471],
    [0.909297]
]
Entrada:
long long length = 3;
long long d_model = 1;

Salida esperada:
std::vector<std::vector<double>> expected = {
    {0.0},
    {0.841471},
    {0.909297}
};
Entrada:
long length = 3;
long d_model = 1;

Salida esperada:
double[][] expected = new double[][] {
    new double[] {0.0},
    new double[] {0.841471},
    new double[] {0.909297}
};

Explicación

Con una sola dimensión solo se usa sin(pos): [[0], [0.841471], [0.909297]].

Cómo abordarlo

Inténtalo primero por tu cuenta y luego abre las pistas una a una.

Pista 1

Cada columna corresponde a un par de frecuencias, con dimensiones pares e impares usando seno y coseno del mismo ángulo.

Pista 2

Construye la matriz iterando sobre posiciones y dimensiones, calculando el ángulo a partir de la posición y del par de dimensiones.

Pista 3

Ten cuidado con la división entera y con los índices desde cero para que la primera fila en la posición 0 tenga el patrón inicial esperado.

Complejidad esperada

tiempo O(length * d_model), espacio extra O(length * d_model)

Referencias

Este reto está adaptado para CodeUtility. Sigue el enunciado y las restricciones indicadas arriba.

Clasificación

Clasificación completa

La mejor solución aprobada de cada programador. Las más rápidas, ligeras y mejor valoradas van primero.

Aún no hay soluciones aprobadas. Resuélvelo y quédate el primer puesto.

Aprende de otros

Soluciones de la comunidad

Aún no hay soluciones publicadas. Resuelve este reto para compartir la primera.