Alle Herausforderungen
Mittel 0 gelöst 0% Erfolgsquote

Gradienten eines einzelnen Neurons

Nutze die Kettenregel, um herauszufinden, wie sich der Verlust mit jedem Gewicht und dem Bias eines Sigmoid-Neurons ändert.

Das lernst du

  • Die Kettenregel auf ein Neuron anwenden
  • Gradienten für jedes Gewicht und den Bias bestimmen
  • Verstehen, wie Lernsignale fließen

Problem

Um ein Neuron zu trainieren, müssen wir wissen, wie jedes Gewicht den Fehler beeinflusst. Für ein Trainingsbeispiel gilt:

  • z = inputs · weights + bias
  • y = sigmoid(z) = 1 / (1 + e^(-z))
  • Verlust L = (y - target)²

Nach der Kettenregel, mit delta = dL/dz = 2 × (y - target) × y × (1 - y):

  • dL/dw_i = delta × x_i
  • dL/dbias = delta

Implementiere neuron_gradients(inputs, weights, bias, target).

Eingabe

inputs, weights: Listen gleicher Länge n.

bias: Der Bias des Neurons.

target: Die korrekte Ausgabe für dieses Beispiel (zwischen 0 und 1).

Ausgabe

Gib eine Liste mit n + 1 Zahlen zurück: den Gradienten jedes Gewichts in Reihenfolge, dann den Gradienten des Bias.

Einschränkungen

1 ≤ n ≤ 100

-10 ≤ jede Eingabe, jedes Gewicht und der Bias ≤ 10

0 ≤ target ≤ 1

Beispiele

Beispiel 1
Eingabe:
inputs = [1.0, 2.0]
weights = [0.5, -0.25]
bias = 0.0
target = 1.0

Erwartete Ausgabe:
expected = [-0.25, -0.5, -0.25]
Eingabe:
std::vector<double> inputs = {1.0, 2.0};
std::vector<double> weights = {0.5, -0.25};
double bias = 0.0;
double target = 1.0;

Erwartete Ausgabe:
std::vector<double> expected = {-0.25, -0.5, -0.25};
Eingabe:
double[] inputs = new double[] {1.0, 2.0};
double[] weights = new double[] {0.5, -0.25};
double bias = 0.0;
double target = 1.0;

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

Erläuterung

z = 1×0.5 + 2×(-0.25) = 0, also y = 0.5. delta = 2 × (0.5 - 1) × 0.5 × 0.5 = -0.25. Gradienten: [-0.25×1, -0.25×2, -0.25] = [-0.25, -0.5, -0.25].

Beispiel 2
Eingabe:
inputs = [3.0]
weights = [0.0]
bias = 0.0
target = 0.0

Erwartete Ausgabe:
expected = [0.75, 0.25]
Eingabe:
std::vector<double> inputs = {3.0};
std::vector<double> weights = {0.0};
double bias = 0.0;
double target = 0.0;

Erwartete Ausgabe:
std::vector<double> expected = {0.75, 0.25};
Eingabe:
double[] inputs = new double[] {3.0};
double[] weights = new double[] {0.0};
double bias = 0.0;
double target = 0.0;

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

Erläuterung

z = 0 und y = 0.5. delta = 2 × (0.5 - 0) × 0.5 × 0.5 = 0.25, also sind die Gradienten [0.25×3, 0.25] = [0.75, 0.25]. Positive Gradienten bedeuten, dass das Gewicht sinken sollte.

So gehst du vor

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

Hinweis 1

Beginne mit dem Sigmoid-Output des Neurons und der Ableitung des Loss nach dem Pre-Aktivierungswert.

Hinweis 2

Der Gradient für jedes Gewicht ist derselbe Delta-Wert, skaliert mit der jeweiligen Eingabe, und für den Bias zählt nur das Delta.

Hinweis 3

Halte die Gewichtsgradienten in Eingabereihenfolge und hänge den Bias-Gradienten am Ende an.

Erwartete Komplexität

Zeit O(n), zusätzlicher Speicher O(n)

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.