Alle Herausforderungen
Mittel 0 gelöst 0% Erfolgsquote

Perceptron Learning Algorithm

Train the original perceptron, which updates its weights only when it makes a mistake.

Das lernst du

  • Update weights only on mistakes
  • Train over several epochs
  • Learn how the first neural model worked

Problem

Übersetzung anzeigen

The perceptron (1958) is the first learning algorithm for an artificial neuron. It predicts with a step function and learns from its mistakes.

Start with all weights and the bias at 0. For each epoch, go through the samples in order, and for each sample x with label y (0 or 1):

  1. prediction = 1 if x · weights + bias > 0, otherwise 0
  2. error = y - prediction (so -1, 0 or 1)
  3. If error ≠ 0: weights[i] ← weights[i] + learning_rate × error × x[i] for every i, and bias ← bias + learning_rate × error

Implement train_perceptron(samples, labels, learning_rate, epochs).

Input

samples: m samples with n features each.

labels: The m labels, each 0 or 1.

learning_rate, epochs: The step size and the number of passes over the data.

Output

Return the final weights followed by the bias (n + 1 numbers).

Einschränkungen

1 ≤ m ≤ 100, 1 ≤ n ≤ 10, 1 ≤ epochs ≤ 100

0 < learning_rate ≤ 1

-10 ≤ each feature ≤ 10

Beispiele

Beispiel 1
Eingabe:
samples = [
    [0.0, 0.0],
    [0.0, 1.0],
    [1.0, 0.0],
    [1.0, 1.0]
]
labels = [0, 0, 0, 1]
learning_rate = 1.0
epochs = 1

Erwartete Ausgabe:
expected = [1.0, 1.0, 1.0]
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<long long> labels = {0, 0, 0, 1};
double learning_rate = 1.0;
long long epochs = 1;

Erwartete Ausgabe:
std::vector<double> expected = {1.0, 1.0, 1.0};
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}
};
long[] labels = new long[] {0, 0, 0, 1};
double learning_rate = 1.0;
long epochs = 1;

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

Erläuterung

[0, 0]: z = 0, predicts 0, correct. [0, 1] and [1, 0]: also predict 0, correct. [1, 1]: predicts 0 but the label is 1, so error = 1: weights become [1, 1] and the bias becomes 1. Result: [1, 1, 1].

Beispiel 2
Eingabe:
samples = [
    [0.0, 0.0],
    [0.0, 1.0],
    [1.0, 0.0],
    [1.0, 1.0]
]
labels = [0, 0, 0, 1]
learning_rate = 1.0
epochs = 10

Erwartete Ausgabe:
expected = [2.0, 1.0, -2.0]
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<long long> labels = {0, 0, 0, 1};
double learning_rate = 1.0;
long long epochs = 10;

Erwartete Ausgabe:
std::vector<double> expected = {2.0, 1.0, -2.0};
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}
};
long[] labels = new long[] {0, 0, 0, 1};
double learning_rate = 1.0;
long epochs = 10;

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

Erläuterung

After 10 epochs the perceptron has learned the AND gate: with weights [2, 1] and bias -2, only [1, 1] gives z > 0.

So gehst du vor

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

Hinweis 1

Process samples in order for each epoch, because earlier updates affect later predictions.

Hinweis 2

Only update when the predicted class differs from the label, and adjust both weights and bias together.

Hinweis 3

The prediction rule uses a strict sign test, so a score of zero counts as class 0.

Erwartete Komplexität

O(epochs × m × n) time, O(n) extra space

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.