Alle Herausforderungen
Mittel 0 gelöst 0% Erfolgsquote

Lineare Regression mit Gradientenabstieg

Lerne Steigung und Achsenabschnitt einer Geraden, indem du schrittweise den mittleren quadratischen Fehler hinabsteigst.

Das lernst du

  • Den mittleren quadratischen Fehler schrittweise minimieren
  • Gradienten für Steigung und Achsenabschnitt berechnen
  • Sehen, wie die Lernrate das Training beeinflusst

Problem

Statt einer Formel trainiere die Gerade y = w × x + b mit Batch-Gradientenabstieg auf dem mittleren quadratischen Fehler MSE = Σ(w × x + b - y)² / n.

Beginne mit w = 0 und b = 0. Verwende in jeder Epoche alle Punkte:

  1. errorᵢ = w × xᵢ + b - yᵢ
  2. dw = (2 / n) × Σ errorᵢ × xᵢ und db = (2 / n) × Σ errorᵢ
  3. w ← w - learning_rate × dw und b ← b - learning_rate × db (beide aus denselben Fehlern berechnet)

Implementiere train_linear_regression(xs, ys, learning_rate, epochs).

Eingabe

xs, ys: Die Datenpunkte (gleiche Länge).

learning_rate, epochs: Die Schrittweite und die Anzahl der Aktualisierungen.

Ausgabe

Gib nach dem Training [w, b] zurück.

Einschränkungen

1 ≤ Anzahl der Punkte ≤ 1.000, 0 ≤ epochs ≤ 10.000

0 < learning_rate ≤ 1

-100 ≤ jeder Wert ≤ 100

Beispiele

Beispiel 1
Eingabe:
xs = [1.0, 2.0]
ys = [2.0, 4.0]
learning_rate = 0.1
epochs = 1

Erwartete Ausgabe:
expected = [1.0, 0.6]
Eingabe:
std::vector<double> xs = {1.0, 2.0};
std::vector<double> ys = {2.0, 4.0};
double learning_rate = 0.1;
long long epochs = 1;

Erwartete Ausgabe:
std::vector<double> expected = {1.0, 0.6};
Eingabe:
double[] xs = new double[] {1.0, 2.0};
double[] ys = new double[] {2.0, 4.0};
double learning_rate = 0.1;
long epochs = 1;

Erwartete Ausgabe:
double[] expected = new double[] {1.0, 0.6};

Erläuterung

Mit w = b = 0 sind die Fehler -2 und -4. dw = (2 / 2) × (-2×1 - 4×2) = -10 und db = (2 / 2) × (-2 - 4) = -6, also w = 0 - 0.1 × (-10) = 1 und b = 0 - 0.1 × (-6) = 0.6. Ergebnis: [1, 0.6].

Beispiel 2
Eingabe:
xs = [1.0, 2.0, 3.0]
ys = [3.0, 5.0, 7.0]
learning_rate = 0.05
epochs = 2000

Erwartete Ausgabe:
expected = [2.0, 1.0]
Eingabe:
std::vector<double> xs = {1.0, 2.0, 3.0};
std::vector<double> ys = {3.0, 5.0, 7.0};
double learning_rate = 0.05;
long long epochs = 2000;

Erwartete Ausgabe:
std::vector<double> expected = {2.0, 1.0};
Eingabe:
double[] xs = new double[] {1.0, 2.0, 3.0};
double[] ys = new double[] {3.0, 5.0, 7.0};
double learning_rate = 0.05;
long epochs = 2000;

Erwartete Ausgabe:
double[] expected = new double[] {2.0, 1.0};

Erläuterung

Die Daten liegen auf y = 2x + 1. Nach 2.000 Epochen ist der Gradientenabstieg zu w = 2 und b = 1 konvergiert, dieselbe Antwort wie die Formel der kleinsten Quadrate.

So gehst du vor

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

Hinweis 1

Jede Epoche nutzt alle Punkte, um zu messen, wie falsch die aktuelle Gerade ist.

Hinweis 2

Sammle den Gradienten über alle Samples, bevor du beide Parameter gemeinsam updatest.

Hinweis 3

Achte darauf, keinen Parameter frühzeitig zu ändern, denn beide Updates müssen dieselben Fehler der aktuellen Epoche verwenden.

Erwartete Komplexität

Zeit O(epochs × n), zusätzlicher Speicher O(1)

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.