Problem
Das Perzeptron (1958) ist der erste Lernalgorithmus für ein künstliches Neuron. Es sagt mit einer Stufenfunktion voraus und lernt aus seinen Fehlern.
Beginne mit allen Gewichten und dem Bias bei 0. Gehe in jeder Epoche die Beispiele der Reihe nach durch, und für jedes Beispiel x mit Label y (0 oder 1):
- Vorhersage = 1, wenn x · weights + bias > 0, sonst 0
- error = y - Vorhersage (also -1, 0 oder 1)
- Wenn error ≠ 0: weights[i] ← weights[i] + learning_rate × error × x[i] für jedes i, und bias ← bias + learning_rate × error
Implementiere train_perceptron(samples, labels, learning_rate, epochs).
Eingabe
samples: m Beispiele mit je n Merkmalen.
labels: Die m Labels, jeweils 0 oder 1.
learning_rate, epochs: Die Schrittweite und die Anzahl der Durchläufe über die Daten.
Ausgabe
Gib die endgültigen Gewichte und danach den Bias zurück (n + 1 Zahlen).
Einschränkungen
1 ≤ m ≤ 100, 1 ≤ n ≤ 10, 1 ≤ epochs ≤ 100
0 < learning_rate ≤ 1
-10 ≤ jedes Merkmal ≤ 10
Beispiele
Eingabe:
epochs = 1
labels = [0, 0, 0, 1]
samples = [
[0.0, 0.0],
[0.0, 1.0],
[1.0, 0.0],
[1.0, 1.0]
]
learning_rate = 1.0
Erwartete Ausgabe:
expected = [1.0, 1.0, 1.0]Eingabe:
long long epochs = 1;
std::vector<long long> labels = {0, 0, 0, 1};
std::vector<std::vector<double>> samples = {
{0.0, 0.0},
{0.0, 1.0},
{1.0, 0.0},
{1.0, 1.0}
};
double learning_rate = 1.0;
Erwartete Ausgabe:
std::vector<double> expected = {1.0, 1.0, 1.0};Eingabe:
long epochs = 1;
long[] labels = new long[] {0, 0, 0, 1};
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 learning_rate = 1.0;
Erwartete Ausgabe:
double[] expected = new double[] {1.0, 1.0, 1.0};Erläuterung
[0, 0]: z = 0, sagt 0 voraus, richtig. [0, 1] und [1, 0]: sagen ebenfalls 0 voraus, richtig. [1, 1]: sagt 0 voraus, aber das Label ist 1, also error = 1: Die Gewichte werden zu [1, 1] und der Bias zu 1. Ergebnis: [1, 1, 1].
Eingabe:
epochs = 10
labels = [0, 0, 0, 1]
samples = [
[0.0, 0.0],
[0.0, 1.0],
[1.0, 0.0],
[1.0, 1.0]
]
learning_rate = 1.0
Erwartete Ausgabe:
expected = [2.0, 1.0, -2.0]Eingabe:
long long epochs = 10;
std::vector<long long> labels = {0, 0, 0, 1};
std::vector<std::vector<double>> samples = {
{0.0, 0.0},
{0.0, 1.0},
{1.0, 0.0},
{1.0, 1.0}
};
double learning_rate = 1.0;
Erwartete Ausgabe:
std::vector<double> expected = {2.0, 1.0, -2.0};Eingabe:
long epochs = 10;
long[] labels = new long[] {0, 0, 0, 1};
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 learning_rate = 1.0;
Erwartete Ausgabe:
double[] expected = new double[] {2.0, 1.0, -2.0};Erläuterung
Nach 10 Epochen hat das Perzeptron das UND-Gatter gelernt: Mit den Gewichten [2, 1] und dem Bias -2 ergibt nur [1, 1] ein z > 0.
So gehst du vor
Versuch es zuerst allein und öffne dann einen Hinweis nach dem anderen.
Hinweis 1
Verarbeite die Samples pro Epoche in Reihenfolge, weil frühere Updates spätere Vorhersagen beeinflussen.
Hinweis 2
Update nur, wenn die vorhergesagte Klasse vom Label abweicht, und passe Gewichte und Bias gemeinsam an.
Hinweis 3
Die Vorhersageregel nutzt einen strikten Vorzeichen-Test, also zählt ein Score von null als Klasse 0.
Erwartete Komplexität
Zeit O(epochs × m × n), zusätzlicher Speicher O(n)
Referenzen
Diese Aufgabe wurde für CodeUtility angepasst. Beachte die oben genannten Vorgaben und Einschränkungen.