Alle Herausforderungen
Einfach 0 gelöst 0% Erfolgsquote

Gradientenabstieg mit Momentum

Wende Momentum-Updates an, die einen Teil des vorherigen Schritts behalten, damit das Training in gleichbleibende Richtungen schneller wird.

Das lernst du

  • Für jedes Gewicht eine Geschwindigkeit führen
  • Das Training entlang stetiger Richtungen beschleunigen
  • Momentum mit einfachem Gradientenabstieg vergleichen

Problem

Momentum lässt den Gradientenabstieg wie eine Kugel bergab rollen: Jeder Schritt behält einen Teil des vorherigen.

Beginne mit einer Geschwindigkeit von 0 für jedes Gewicht. Für jeden Schritt t mit Gradientenvektor g (ein Wert pro Gewicht):

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

Implementiere momentum_steps(gradients, weights, learning_rate, beta) und wende pro Zeile von gradients ein Update an, in Reihenfolge.

Eingabe

gradients: Eine Zeile pro Schritt; jede Zeile hat einen Gradienten pro Gewicht.

weights: Die Startgewichte.

learning_rate: Die Schrittweite.

beta: Der Momentum-Koeffizient (0 bedeutet einfachen Gradientenabstieg).

Ausgabe

Gib die Gewichte nach allen Schritten zurück.

Einschränkungen

0 ≤ Schritte ≤ 1.000, 1 ≤ Gewichte ≤ 100

0 < learning_rate ≤ 1, 0 ≤ beta < 1

-100 ≤ jeder Wert ≤ 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

Die Geschwindigkeit wächst 1 → 1.9 → 2.71, weil der Gradient immer in dieselbe Richtung zeigt, also sind die Schritte 0.1, 0.19 und 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

Mit beta = 0 ist das einfacher Gradientenabstieg: 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

Halte einen Geschwindigkeitsvektor, der einen Teil des vorherigen Schritts und des aktuellen Gradienten aufsammelt.

Hinweis 2

Aktualisiere die Geschwindigkeit, bevor du die Gewichte anpasst, und verwende dieselbe Geschwindigkeit über alle Schritte hinweg.

Hinweis 3

Wenn beta null ist, sollte die Methode auf gewöhnlichen Gradient Descent zurückfallen, also prüfe dieses Verhalten genau.

Erwartete Komplexität

Zeit O(s × w), zusätzlicher Speicher O(w)

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.