Problema
Adam mantiene due medie mobili per ogni peso, del gradiente (m) e del gradiente al quadrato (v), e le usa per dare a ogni peso la propria dimensione del passo.
Parti da m = 0 e v = 0 per ogni peso. Per ogni passo t = 1, 2, 3, … con gradiente g:
- m ← beta1 × m + (1 - beta1) × g
- v ← beta2 × v + (1 - beta2) × g²
- m̂ = m / (1 - beta1ᵗ) e v̂ = v / (1 - beta2ᵗ) (correzione del bias)
- w ← w - learning_rate × m̂ / (√v̂ + epsilon)
Implementa adam_steps(gradients, weights, learning_rate, beta1, beta2, epsilon) applicando un aggiornamento per riga di gradients, in ordine.
Input
gradients: Una riga per passo; ogni riga ha un gradiente per peso.
weights: I pesi iniziali.
learning_rate, beta1, beta2, epsilon: Gli iperparametri di Adam (quelli tipici sono 0.001, 0.9, 0.999 e 0.00000001).
Output
Restituisci i pesi dopo tutti i passi.
Vincoli
0 ≤ passi ≤ 1.000, 1 ≤ pesi ≤ 100
0 < learning_rate ≤ 1, 0 ≤ beta1, beta2 < 1, 0 < epsilon ≤ 0.001
-100 ≤ ogni valore ≤ 100
Esempi
Input:
beta1 = 0.9
beta2 = 0.999
epsilon = 1.0e-08
weights = [1.0]
gradients = [
[2.0]
]
learning_rate = 0.1
Output atteso:
expected = [0.9]Input:
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;
Output atteso:
std::vector<double> expected = {0.9};Input:
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;
Output atteso:
double[] expected = new double[] {0.9};Spiegazione
m = 0.1 × 2 = 0.2 e v = 0.001 × 4 = 0.004. La correzione del bias dà m̂ = 0.2 / 0.1 = 2 e v̂ = 0.004 / 0.001 = 4, quindi il passo è 0.1 × 2 / √4 = 0.1: w = 0.9. Al primo passo Adam sposta ogni peso di circa il learning rate, qualunque sia la grandezza del gradiente.
Input:
beta1 = 0.9
beta2 = 0.999
epsilon = 1.0e-08
weights = [0.0, 0.0]
gradients = [
[100.0, 0.01]
]
learning_rate = 0.01
Output atteso:
expected = [-0.01, -0.01]Input:
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;
Output atteso:
std::vector<double> expected = {-0.01, -0.01};Input:
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;
Output atteso:
double[] expected = new double[] {-0.01, -0.01};Spiegazione
I gradienti differiscono di un fattore 10.000, eppure entrambi i pesi si spostano di circa 0.01, fino a [-0.01, -0.01]: Adam scala ogni passo in base alla grandezza del proprio gradiente.
Riferimenti
Questa sfida è adattata per CodeUtility. Segui la traccia e i vincoli sopra.