Problema
Adam mantiene dos medias móviles por peso, del gradiente (m) y del gradiente al cuadrado (v), y con ellas da a cada peso su propio tamaño de paso.
Empieza con m = 0 y v = 0 para cada peso. Para cada paso t = 1, 2, 3, … con gradiente g:
- m ← beta1 × m + (1 - beta1) × g
- v ← beta2 × v + (1 - beta2) × g²
- m̂ = m / (1 - beta1ᵗ) y v̂ = v / (1 - beta2ᵗ) (corrección de sesgo)
- w ← w - learning_rate × m̂ / (√v̂ + epsilon)
Implementa adam_steps(gradients, weights, learning_rate, beta1, beta2, epsilon) aplicando una actualización por fila de gradients, en orden.
Entrada
gradients: Una fila por paso; cada fila tiene un gradiente por peso.
weights: Los pesos iniciales.
learning_rate, beta1, beta2, epsilon: Los hiperparámetros de Adam (los habituales son 0.001, 0.9, 0.999 y 0.00000001).
Salida
Devuelve los pesos después de todos los pasos.
Restricciones
0 ≤ pasos ≤ 1.000, 1 ≤ pesos ≤ 100
0 < learning_rate ≤ 1, 0 ≤ beta1, beta2 < 1, 0 < epsilon ≤ 0.001
-100 ≤ cada valor ≤ 100
Ejemplos
Entrada:
beta1 = 0.9
beta2 = 0.999
epsilon = 1.0e-08
weights = [1.0]
gradients = [
[2.0]
]
learning_rate = 0.1
Salida esperada:
expected = [0.9]Entrada:
double beta1 = 0.9;
double beta2 = 0.999;
double epsilon = 1.0e-08;
std::vector<double> weights = {1.0};
std::vector<std::vector<double>> gradients = {
{2.0}
};
double learning_rate = 0.1;
Salida esperada:
std::vector<double> expected = {0.9};Entrada:
double beta1 = 0.9;
double beta2 = 0.999;
double epsilon = 1.0e-08;
double[] weights = new double[] {1.0};
double[][] gradients = new double[][] {
new double[] {2.0}
};
double learning_rate = 0.1;
Salida esperada:
double[] expected = new double[] {0.9};Explicación
m = 0.1 × 2 = 0.2 y v = 0.001 × 4 = 0.004. La corrección de sesgo da m̂ = 0.2 / 0.1 = 2 y v̂ = 0.004 / 0.001 = 4, así que el paso es 0.1 × 2 / √4 = 0.1: w = 0.9. En su primer paso, Adam mueve cada peso aproximadamente la tasa de aprendizaje, sin importar el tamaño del gradiente.
Entrada:
beta1 = 0.9
beta2 = 0.999
epsilon = 1.0e-08
weights = [0.0, 0.0]
gradients = [
[100.0, 0.01]
]
learning_rate = 0.01
Salida esperada:
expected = [-0.01, -0.01]Entrada:
double beta1 = 0.9;
double beta2 = 0.999;
double epsilon = 1.0e-08;
std::vector<double> weights = {0.0, 0.0};
std::vector<std::vector<double>> gradients = {
{100.0, 0.01}
};
double learning_rate = 0.01;
Salida esperada:
std::vector<double> expected = {-0.01, -0.01};Entrada:
double beta1 = 0.9;
double beta2 = 0.999;
double epsilon = 1.0e-08;
double[] weights = new double[] {0.0, 0.0};
double[][] gradients = new double[][] {
new double[] {100.0, 0.01}
};
double learning_rate = 0.01;
Salida esperada:
double[] expected = new double[] {-0.01, -0.01};Explicación
Los gradientes difieren en un factor de 10.000, pero ambos pesos se mueven unos 0.01, hasta [-0.01, -0.01]: Adam escala cada paso según el tamaño de su propio gradiente.
Cómo abordarlo
Inténtalo primero por tu cuenta y luego abre las pistas una a una.
Pista 1
Lleva dos promedios móviles por peso: uno para la dirección del gradiente y otro para su tamaño al cuadrado.
Pista 2
Aplica corrección de sesgo usando el número de paso actual antes de dividir por la raíz cuadrada.
Pista 3
Fíjate en epsilon en el denominador, porque evita la división por cero y cambia un poco la actualización final.
Complejidad esperada
tiempo O(s × w), espacio extra O(w)
Referencias
Este reto está adaptado para CodeUtility. Sigue el enunciado y las restricciones indicadas arriba.