Alle Herausforderungen
Mittel 0 gelöst 0% Erfolgsquote

Ein Neuron mit Gradientenabstieg trainieren

Wiederhole Vorwärtsdurchlauf, Gradienten und Gewichtsaktualisierung, um einem Sigmoid-Neuron anhand von Beispielen etwas beizubringen.

Das lernst du

  • Vorwärtsdurchlauf, Gradienten und Updates wiederholen
  • Eine Lernrate einstellen
  • Zusehen, wie ein Neuron aus Beispielen lernt

Problem

Gradientenabstieg verbessert die Gewichte Schritt für Schritt, indem er sich gegen den Gradienten bewegt:

w ← w - learning_rate × dL/dw

Trainiere ein Sigmoid-Neuron mit stochastischem Gradientenabstieg. Gehe in jeder Epoche die Beispiele in der angegebenen Reihenfolge durch, und für jedes Beispiel:

  1. z = sample · weights + bias, y = 1 / (1 + e^(-z))
  2. delta = 2 × (y - target) × y × (1 - y)
  3. weights[i] ← weights[i] - learning_rate × delta × sample[i] (für jedes i), dann bias ← bias - learning_rate × delta

Implementiere train_neuron(samples, targets, weights, bias, learning_rate, epochs).

Eingabe

samples: m Trainingsbeispiele mit je n Werten.

targets: Die m korrekten Ausgaben (zwischen 0 und 1).

weights, bias: Die Startgewichte (n Werte) und der Start-Bias.

learning_rate, epochs: Die Schrittweite und wie viele Durchläufe über die Daten.

Ausgabe

Gib die trainierten Gewichte und danach den trainierten Bias zurück (n + 1 Zahlen).

Einschränkungen

1 ≤ m ≤ 50, 1 ≤ n ≤ 10, 1 ≤ epochs ≤ 1.000

0 < learning_rate ≤ 5

-5 ≤ jeder Wert ≤ 5

Beispiele

Beispiel 1
Eingabe:
samples = [
    [1.0]
]
targets = [1.0]
weights = [0.0]
bias = 0.0
learning_rate = 1.0
epochs = 1

Erwartete Ausgabe:
expected = [0.25, 0.25]
Eingabe:
std::vector<std::vector<double>> samples = {
    {1.0}
};
std::vector<double> targets = {1.0};
std::vector<double> weights = {0.0};
double bias = 0.0;
double learning_rate = 1.0;
long long epochs = 1;

Erwartete Ausgabe:
std::vector<double> expected = {0.25, 0.25};
Eingabe:
double[][] samples = new double[][] {
    new double[] {1.0}
};
double[] targets = new double[] {1.0};
double[] weights = new double[] {0.0};
double bias = 0.0;
double learning_rate = 1.0;
long epochs = 1;

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

Erläuterung

y = σ(0) = 0.5, delta = 2 × (0.5 - 1) × 0.25 = -0.25. Gewicht: 0 - 1 × (-0.25) × 1 = 0.25. Bias: 0 - 1 × (-0.25) = 0.25. Ergebnis: [0.25, 0.25].

Beispiel 2
Eingabe:
samples = [
    [0.0, 0.0],
    [0.0, 1.0],
    [1.0, 0.0],
    [1.0, 1.0]
]
targets = [0.0, 0.0, 0.0, 1.0]
weights = [0.0, 0.0]
bias = 0.0
learning_rate = 2.0
epochs = 500

Erwartete Ausgabe:
expected = [6.346558, 6.339863, -9.592092]
Eingabe:
std::vector<std::vector<double>> samples = {
    {0.0, 0.0},
    {0.0, 1.0},
    {1.0, 0.0},
    {1.0, 1.0}
};
std::vector<double> targets = {0.0, 0.0, 0.0, 1.0};
std::vector<double> weights = {0.0, 0.0};
double bias = 0.0;
double learning_rate = 2.0;
long long epochs = 500;

Erwartete Ausgabe:
std::vector<double> expected = {6.346558, 6.339863, -9.592092};
Eingabe:
double[][] samples = new double[][] {
    new double[] {0.0, 0.0},
    new double[] {0.0, 1.0},
    new double[] {1.0, 0.0},
    new double[] {1.0, 1.0}
};
double[] targets = new double[] {0.0, 0.0, 0.0, 1.0};
double[] weights = new double[] {0.0, 0.0};
double bias = 0.0;
double learning_rate = 2.0;
long epochs = 500;

Erwartete Ausgabe:
double[] expected = new double[] {6.346558, 6.339863, -9.592092};

Erläuterung

Das ist das logische UND-Gatter. Nach 500 Epochen sind beide Gewichte groß und positiv und der Bias stark negativ, sodass nur die Eingabe [1, 1] eine Ausgabe über 0.5 liefert.

So gehst du vor

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

Hinweis 1

Verarbeite die Trainingsbeispiele pro Epoche in Reihenfolge und aktualisiere die Gewichte sofort nach jedem Beispiel.

Hinweis 2

Berechne für jedes Beispiel den Sigmoid-Output und nutze dann seinen Gradienten, um Gewichte und Bias abwärts zu bewegen.

Hinweis 3

Weil die Updates online passieren, sehen spätere Beispiele in derselben Epoche die früheren Updates.

Erwartete Komplexität

Zeit O(epochs × m × 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.