Todos los desafíos
Fácil 0 resueltos 0% de aceptación

Descenso de gradiente con momentum

Aplica actualizaciones con momentum que conservan parte del paso anterior, para que el entrenamiento acelere en direcciones constantes.

Lo que aprenderás

  • Mantener una velocidad para cada peso
  • Acelerar el entrenamiento en direcciones constantes
  • Comparar momentum con el descenso de gradiente simple

Problema

Ver original (inglés)

El momentum hace que el descenso de gradiente ruede como una bola cuesta abajo: cada paso conserva parte del anterior.

Empieza con velocidad 0 para cada peso. Para cada paso t con vector de gradiente g (un valor por peso):

  1. v ← beta × v + g
  2. w ← w - learning_rate × v

Implementa momentum_steps(gradients, weights, learning_rate, beta) 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: El tamaño del paso.

beta: El coeficiente de momentum (0 da descenso de gradiente simple).

Salida

Devuelve los pesos después de todos los pasos.

Restricciones

0 ≤ pasos ≤ 1.000, 1 ≤ pesos ≤ 100

0 < learning_rate ≤ 1, 0 ≤ beta < 1

-100 ≤ cada valor ≤ 100

Ejemplos

Ejemplo 1
Entrada:
beta = 0.9
weights = [0.0]
gradients = [
    [1.0],
    [1.0],
    [1.0]
]
learning_rate = 0.1

Salida esperada:
expected = [-0.561]
Entrada:
double beta = 0.9;
std::vector<double> weights = {0.0};
std::vector<std::vector<double>> gradients = {
    {1.0},
    {1.0},
    {1.0}
};
double learning_rate = 0.1;

Salida esperada:
std::vector<double> expected = {-0.561};
Entrada:
double beta = 0.9;
double[] weights = new double[] {0.0};
double[][] gradients = new double[][] {
    new double[] {1.0},
    new double[] {1.0},
    new double[] {1.0}
};
double learning_rate = 0.1;

Salida esperada:
double[] expected = new double[] {-0.561};

Explicación

La velocidad crece 1 → 1.9 → 2.71 porque el gradiente sigue apuntando en la misma dirección, así que los pasos son 0.1, 0.19 y 0.271: w = -0.561.

Ejemplo 2
Entrada:
beta = 0.0
weights = [1.0, 1.0]
gradients = [
    [2.0, -4.0]
]
learning_rate = 0.5

Salida esperada:
expected = [0.0, 3.0]
Entrada:
double beta = 0.0;
std::vector<double> weights = {1.0, 1.0};
std::vector<std::vector<double>> gradients = {
    {2.0, -4.0}
};
double learning_rate = 0.5;

Salida esperada:
std::vector<double> expected = {0.0, 3.0};
Entrada:
double beta = 0.0;
double[] weights = new double[] {1.0, 1.0};
double[][] gradients = new double[][] {
    new double[] {2.0, -4.0}
};
double learning_rate = 0.5;

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

Explicación

Con beta = 0 es descenso de gradiente simple: w = [1 - 0.5 × 2, 1 - 0.5 × (-4)] = [0, 3].

Referencias

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

Aprende de otros

Soluciones de la comunidad

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