Problème
Adam garde pour chaque poids deux moyennes mobiles, du gradient (m) et du gradient au carré (v), ce qui donne à chaque poids sa propre taille de pas.
Partez de m = 0 et v = 0 pour chaque poids. Pour chaque pas t = 1, 2, 3, … avec le gradient g :
- m ← beta1 × m + (1 - beta1) × g
- v ← beta2 × v + (1 - beta2) × g²
- m̂ = m / (1 - beta1ᵗ) et v̂ = v / (1 - beta2ᵗ) (correction du biais)
- w ← w - learning_rate × m̂ / (√v̂ + epsilon)
Implémentez adam_steps(gradients, weights, learning_rate, beta1, beta2, epsilon) en appliquant une mise à jour par ligne de gradients, dans l'ordre.
Entrée
gradients : Une ligne par pas ; chaque ligne contient un gradient par poids.
weights : Les poids de départ.
learning_rate, beta1, beta2, epsilon : Les hyperparamètres d'Adam (valeurs courantes : 0.001, 0.9, 0.999 et 0.00000001).
Sortie
Renvoyez les poids après tous les pas.
Contraintes
0 ≤ pas ≤ 1 000, 1 ≤ poids ≤ 100
0 < learning_rate ≤ 1, 0 ≤ beta1, beta2 < 1, 0 < epsilon ≤ 0.001
-100 ≤ chaque valeur ≤ 100
Exemples
Entrée :
beta1 = 0.9
beta2 = 0.999
epsilon = 1.0e-08
weights = [1.0]
gradients = [
[2.0]
]
learning_rate = 0.1
Sortie attendue :
expected = [0.9]Entrée :
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;
Sortie attendue :
std::vector<double> expected = {0.9};Entrée :
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;
Sortie attendue :
double[] expected = new double[] {0.9};Explication
m = 0.1 × 2 = 0.2 et v = 0.001 × 4 = 0.004. La correction du biais donne m̂ = 0.2 / 0.1 = 2 et v̂ = 0.004 / 0.001 = 4, donc le pas vaut 0.1 × 2 / √4 = 0.1 : w = 0.9. À son premier pas, Adam déplace chaque poids d'environ le taux d'apprentissage, quelle que soit la taille du gradient.
Entrée :
beta1 = 0.9
beta2 = 0.999
epsilon = 1.0e-08
weights = [0.0, 0.0]
gradients = [
[100.0, 0.01]
]
learning_rate = 0.01
Sortie attendue :
expected = [-0.01, -0.01]Entrée :
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;
Sortie attendue :
std::vector<double> expected = {-0.01, -0.01};Entrée :
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;
Sortie attendue :
double[] expected = new double[] {-0.01, -0.01};Explication
Les gradients diffèrent d'un facteur 10 000, pourtant les deux poids bougent d'environ 0.01, jusqu'à [-0.01, -0.01] : Adam met chaque pas à l'échelle de la taille de son propre gradient.
Comment l'aborder
Essayez d'abord seul, puis ouvrez les indices un par un.
Indice 1
Suis deux moyennes mobiles par poids : une pour la direction du gradient et une pour sa taille au carré.
Indice 2
Applique la correction de biais avec le numéro de l’étape courante avant de diviser par le terme racine carrée.
Indice 3
Fais attention à epsilon dans le dénominateur, car il évite une division par zéro et modifie légèrement la mise à jour finale.
Complexité attendue
temps O(s × w), espace supplémentaire O(w)
Références
Ce défi a été adapté pour CodeUtility. Suivez l'énoncé et les contraintes ci-dessus.