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:
- z = sample · weights + bias, y = 1 / (1 + e^(-z))
- delta = 2 × (y - target) × y × (1 - y)
- 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
Eingabe:
bias = 0.0
epochs = 1
samples = [
[1.0]
]
targets = [1.0]
weights = [0.0]
learning_rate = 1.0
Erwartete Ausgabe:
expected = [0.25, 0.25]Eingabe:
double bias = 0.0;
long long epochs = 1;
std::vector<std::vector<double>> samples = {
{1.0}
};
std::vector<double> targets = {1.0};
std::vector<double> weights = {0.0};
double learning_rate = 1.0;
Erwartete Ausgabe:
std::vector<double> expected = {0.25, 0.25};Eingabe:
double bias = 0.0;
long epochs = 1;
double[][] samples = new double[][] {
new double[] {1.0}
};
double[] targets = new double[] {1.0};
double[] weights = new double[] {0.0};
double learning_rate = 1.0;
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].
Eingabe:
bias = 0.0
epochs = 500
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]
learning_rate = 2.0
Erwartete Ausgabe:
expected = [6.346558, 6.339863, -9.592092]Eingabe:
double bias = 0.0;
long long epochs = 500;
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 learning_rate = 2.0;
Erwartete Ausgabe:
std::vector<double> expected = {6.346558, 6.339863, -9.592092};Eingabe:
double bias = 0.0;
long epochs = 500;
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 learning_rate = 2.0;
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.