Alle Herausforderungen
Mittel 0 gelöst 0% Erfolgsquote

Vorwärtsdurchlauf in einem zweischichtigen Netz

Leite Eingaben durch eine verborgene ReLU-Schicht und eine Sigmoid-Ausgabeschicht.

Das lernst du

  • Eine verborgene Schicht und eine Ausgabeschicht verketten
  • Die Ausgabe einer Schicht in die nächste geben
  • Eine komplette Netzvorhersage ausführen

Problem

Ein kleines neuronales Netz hat eine verborgene Schicht und eine Ausgabeschicht. Die Daten fließen nacheinander durch sie:

  1. Verborgene Schicht: h_j = ReLU(inputs · hidden_weights[j] + hidden_biases[j]), mit ReLU(z) = max(0, z)
  2. Ausgabeschicht: y_k = sigmoid(h · output_weights[k] + output_biases[k]), mit sigmoid(z) = 1 / (1 + e^(-z))

Implementiere forward_pass(inputs, hidden_weights, hidden_biases, output_weights, output_biases).

Eingabe

inputs: Die n Eingabewerte.

hidden_weights, hidden_biases: Die verborgene Schicht, eine Zeile und ein Bias pro verborgenem Neuron.

output_weights, output_biases: Die Ausgabeschicht, eine Zeile und ein Bias pro Ausgabe; jede Zeile hat ein Gewicht pro verborgenem Neuron.

Ausgabe

Gib die Liste der Netzausgaben y zurück.

Einschränkungen

1 ≤ Eingaben, verborgene Neuronen, Ausgaben ≤ 50

-10 ≤ jeder Wert ≤ 10

Beispiele

Beispiel 1
Eingabe:
inputs = [1.0, 0.5]
hidden_weights = [
    [1.0, -2.0],
    [0.5, 1.0]
]
hidden_biases = [0.0, 0.5]
output_weights = [
    [1.0, -1.0]
]
output_biases = [0.0]

Erwartete Ausgabe:
expected = [0.182426]
Eingabe:
std::vector<double> inputs = {1.0, 0.5};
std::vector<std::vector<double>> hidden_weights = {
    {1.0, -2.0},
    {0.5, 1.0}
};
std::vector<double> hidden_biases = {0.0, 0.5};
std::vector<std::vector<double>> output_weights = {
    {1.0, -1.0}
};
std::vector<double> output_biases = {0.0};

Erwartete Ausgabe:
std::vector<double> expected = {0.182426};
Eingabe:
double[] inputs = new double[] {1.0, 0.5};
double[][] hidden_weights = new double[][] {
    new double[] {1.0, -2.0},
    new double[] {0.5, 1.0}
};
double[] hidden_biases = new double[] {0.0, 0.5};
double[][] output_weights = new double[][] {
    new double[] {1.0, -1.0}
};
double[] output_biases = new double[] {0.0};

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

Erläuterung

Verborgen: ReLU(1×1 + 0.5×(-2) + 0) = ReLU(0) = 0 und ReLU(1×0.5 + 0.5×1 + 0.5) = 1.5. Ausgabe: sigmoid(0×1 + 1.5×(-1) + 0) = sigmoid(-1.5) ≈ 0.182426.

Beispiel 2
Eingabe:
inputs = [2.0]
hidden_weights = [
    [1.0],
    [-1.0]
]
hidden_biases = [0.0, 0.0]
output_weights = [
    [0.5, 0.5],
    [-0.5, 2.0]
]
output_biases = [-1.0, 0.0]

Erwartete Ausgabe:
expected = [0.5, 0.268941]
Eingabe:
std::vector<double> inputs = {2.0};
std::vector<std::vector<double>> hidden_weights = {
    {1.0},
    {-1.0}
};
std::vector<double> hidden_biases = {0.0, 0.0};
std::vector<std::vector<double>> output_weights = {
    {0.5, 0.5},
    {-0.5, 2.0}
};
std::vector<double> output_biases = {-1.0, 0.0};

Erwartete Ausgabe:
std::vector<double> expected = {0.5, 0.268941};
Eingabe:
double[] inputs = new double[] {2.0};
double[][] hidden_weights = new double[][] {
    new double[] {1.0},
    new double[] {-1.0}
};
double[] hidden_biases = new double[] {0.0, 0.0};
double[][] output_weights = new double[][] {
    new double[] {0.5, 0.5},
    new double[] {-0.5, 2.0}
};
double[] output_biases = new double[] {-1.0, 0.0};

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

Erläuterung

Verborgen: ReLU(2) = 2 und ReLU(-2) = 0. Ausgabe 1: sigmoid(2×0.5 + 0 - 1) = sigmoid(0) = 0.5. Ausgabe 2: sigmoid(2×(-0.5) + 0) = sigmoid(-1) ≈ 0.268941.

So gehst du vor

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

Hinweis 1

Berechne zuerst alle Hidden-Aktivierungen aus den Eingaben und verwende dann diese Hidden-Ausgaben für die letzte Schicht.

Hinweis 2

Jede Schicht besteht aus Dot-Produkten plus Biases, mit ReLU in der Hidden-Schicht und sigmoid am Output.

Hinweis 3

Mische die Originaleingaben nicht in die zweite Schicht; sie sieht nur die Ausgaben der Hidden-Schicht.

Erwartete Komplexität

Zeit O(hn + oh), zusätzlicher Speicher O(h + o)

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.