Alle Herausforderungen
Einfach 0 gelöst 0% Erfolgsquote

Gradient Descent with Momentum

Apply momentum updates, which keep part of the previous step so training speeds up along consistent directions.

Das lernst du

  • Keep a velocity for each weight
  • Speed up training along steady directions
  • Compare momentum with plain gradient descent

Problem

Übersetzung anzeigen

Momentum makes gradient descent behave like a ball rolling downhill: each step keeps part of the previous one.

Start with a velocity of 0 for every weight. For each step t, with gradient vector g (one value per weight):

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

Implement momentum_steps(gradients, weights, learning_rate, beta), applying one update per row of gradients, in order.

Input

gradients: One row per step; each row has one gradient per weight.

weights: The starting weights.

learning_rate: The step size.

beta: The momentum coefficient (0 means plain gradient descent).

Output

Return the weights after all steps.

Einschränkungen

0 ≤ steps ≤ 1,000, 1 ≤ weights ≤ 100

0 < learning_rate ≤ 1, 0 ≤ beta < 1

-100 ≤ each value ≤ 100

Beispiele

Beispiel 1
Eingabe:
gradients = [
    [1.0],
    [1.0],
    [1.0]
]
weights = [0.0]
learning_rate = 0.1
beta = 0.9

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

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

Erwartete Ausgabe:
double[] expected = new double[] {-0.561};

Erläuterung

The velocity grows 1 → 1.9 → 2.71 because the gradient keeps pointing the same way, so the steps are 0.1, 0.19 and 0.271: w = -0.561.

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

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

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

Erwartete Ausgabe:
double[] expected = new double[] {0.0, 3.0};

Erläuterung

With beta = 0 this is plain gradient descent: w = [1 - 0.5 × 2, 1 - 0.5 × (-4)] = [0, 3].

So gehst du vor

Versuch es zuerst allein und öffne dann einen Hinweis nach dem anderen.

Hinweis 1

Keep a velocity vector that accumulates part of the previous step and the current gradient.

Hinweis 2

Update the velocity before adjusting the weights, and reuse the same velocity across all steps.

Hinweis 3

If beta is zero, the method should reduce to ordinary gradient descent, so check that behavior carefully.

Erwartete Komplexität

O(s × w) time, O(w) extra space

Referenzen

Diese Aufgabe wurde für CodeUtility angepasst. Beachte die oben genannten Vorgaben und Einschränkungen.

Die beste bestandene Lösung jedes Coders. Schnellere, sparsamere und besser bewertete Lösungen stehen weiter oben.

Noch keine bestandene Lösung. Löse sie und hol dir Platz eins.

Von anderen lernen

Community-Lösungen

Noch keine veröffentlichten Lösungen. Löse die Aufgabe und teile als Erster eine Lösung.