Problema
O Adam mantém duas médias móveis por peso, do gradiente (m) e do gradiente ao quadrado (v), e as usa para dar a cada peso seu próprio tamanho de passo.
Comece com m = 0 e v = 0 para cada peso. Para cada passo t = 1, 2, 3, … com gradiente g:
- m ← beta1 × m + (1 - beta1) × g
- v ← beta2 × v + (1 - beta2) × g²
- m̂ = m / (1 - beta1ᵗ) e v̂ = v / (1 - beta2ᵗ) (correção de viés)
- w ← w - learning_rate × m̂ / (√v̂ + epsilon)
Implemente adam_steps(gradients, weights, learning_rate, beta1, beta2, epsilon) aplicando uma atualização por linha de gradients, em ordem.
Entrada
gradients: Uma linha por passo; cada linha tem um gradiente por peso.
weights: Os pesos iniciais.
learning_rate, beta1, beta2, epsilon: Os hiperparâmetros do Adam (os típicos são 0.001, 0.9, 0.999 e 0.00000001).
Saída
Retorne os pesos após todos os passos.
Restrições
0 ≤ passos ≤ 1.000, 1 ≤ pesos ≤ 100
0 < learning_rate ≤ 1, 0 ≤ beta1, beta2 < 1, 0 < epsilon ≤ 0.001
-100 ≤ cada valor ≤ 100
Exemplos
Entrada:
beta1 = 0.9
beta2 = 0.999
epsilon = 1.0e-08
weights = [1.0]
gradients = [
[2.0]
]
learning_rate = 0.1
Saída 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;
Saída 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;
Saída esperada:
double[] expected = new double[] {0.9};Explicação
m = 0.1 × 2 = 0.2 e v = 0.001 × 4 = 0.004. A correção de viés dá m̂ = 0.2 / 0.1 = 2 e v̂ = 0.004 / 0.001 = 4, então o passo é 0.1 × 2 / √4 = 0.1: w = 0.9. No primeiro passo, o Adam move cada peso aproximadamente pela taxa de aprendizado, qualquer que seja o tamanho do 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
Saída 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;
Saída 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;
Saída esperada:
double[] expected = new double[] {-0.01, -0.01};Explicação
Os gradientes diferem por um fator de 10.000, mas ambos os pesos se movem cerca de 0.01, até [-0.01, -0.01]: o Adam escala cada passo pelo tamanho do próprio gradiente.
Como abordar
Tente sozinho primeiro e depois abra uma dica de cada vez.
Dica 1
Acompanhe duas médias móveis por peso: uma para a direção do gradiente e outra para seu tamanho ao quadrado.
Dica 2
Aplique a correção de bias usando o número do passo atual antes de dividir pelo termo da raiz quadrada.
Dica 3
Preste atenção em epsilon no denominador, porque ele evita divisão por zero e altera levemente a atualização final.
Complexidade esperada
tempo O(s × w), espaço extra O(w)
Referências
Este desafio foi adaptado para o CodeUtility. Siga o enunciado e as restrições acima.