Perzeptron bezeichnet den einfachsten Typ eines neuronalen Netzes, das aus nur einem Neuron besteht. Zur Bewältigung komplexerer Probleme wird ein Modell namens Mehrschicht-Perzeptron (MLP) verwendet. Ein Mehrschicht-Perzeptron enthält eine oder mehrere versteckte Schichten, die es dem Netzwerk ermöglichen, komplexe Muster in den Daten zu erlernen.

Die Struktur eines Mehrschicht-Perzeptrons umfasst:

1. Eingabeschicht: empfängt die Eingabedaten;
2. Versteckte Schichten: verarbeiten die Daten und extrahieren bedeutungsvolle Muster;
3. Ausgabeschicht: liefert die endgültige Vorhersage oder Klassifikation.

Jede Schicht besteht aus mehreren Neuronen, und die Ausgabe einer Schicht dient als Eingabe für die nächste Schicht.

Schicht-Gewichte und -Biases

Vor der Implementierung einer Schicht ist es wichtig zu verstehen, wie die Gewichte und Biases jedes Neurons darin gespeichert werden. Im vorherigen Kapitel wurde gezeigt, wie die Gewichte eines einzelnen Neurons als Vektor und dessen Bias als Skalar (Einzelwert) gespeichert werden.

Da eine Schicht aus mehreren Neuronen besteht, ist es naheliegend, die Gewichte als Matrix darzustellen, wobei jede Zeile den Gewichten eines bestimmten Neurons entspricht. Entsprechend können die Biases als Vektor dargestellt werden, dessen Länge der Anzahl der Neuronen entspricht.

Für eine Schicht mit $3$ Eingaben und $2$ Neuronen werden die Gewichte in einer $2 \times 3$ Matrix $W$ und die Biases in einem $2 \times 1$ Vektor $b$ gespeichert, die wie folgt aussehen:

Hierbei steht das Element $W_{ij}$ für das Gewicht des $j$-ten Eingabewerts zum $i$-ten Neuron, sodass die erste Zeile die Gewichte des ersten Neurons und die zweite Zeile die Gewichte des zweiten Neurons enthält. Das Element $b_i$ steht für den Bias des $i$-ten Neurons (zwei Neuronen – zwei Biases).

Vorwärtspropagation

Die Durchführung der Vorwärtspropagation für jede Schicht bedeutet, dass jede ihrer Neuronen aktiviert wird, indem die gewichtete Summe der Eingaben berechnet, der Bias addiert und die Aktivierungsfunktion angewendet wird.

Zuvor wurde für ein einzelnes Neuron die gewichtete Summe der Eingaben berechnet, indem das Skalarprodukt zwischen dem Eingabevektor und dem Gewichtungsvektor gebildet und der Bias addiert wurde.

Da jede Zeile der Gewichtungsmatrix den Gewichtungsvektor für ein bestimmtes Neuron enthält, muss nun lediglich ein Skalarprodukt zwischen jeder Zeile der Matrix und dem Eingabevektor durchgeführt werden. Glücklicherweise entspricht dies genau der Matrixmultiplikation:

Um die Bias-Werte zu den Ausgaben der jeweiligen Neuronen hinzuzufügen, sollte ebenfalls ein Bias-Vektor addiert werden:

Abschließend wird die Aktivierungsfunktion auf das Ergebnis angewendet — Sigmoid oder ReLU in unserem Fall. Die resultierende Formel für die Vorwärtspropagation in der Schicht lautet:

wobei $a$ der Vektor der Neuronenaktivierungen (Ausgaben) ist.

Layer-Klasse

Die grundlegenden Bausteine des Perzeptrons sind seine Schichten (Layers), daher ist es sinnvoll, eine eigene Layer-Klasse zu erstellen. Zu ihren Attributen gehören:

• inputs: ein Vektor von Eingaben (n_inputs ist die Anzahl der Eingaben);
• outputs: ein Vektor von Roh-Ausgabewerten (vor Anwendung der Aktivierungsfunktion) der Neuronen (n_neurons ist die Anzahl der Neuronen);
• weights: eine Gewichtungsmatrix;
• biases: ein Bias-Vektor;
• activation_function: die in der Schicht verwendete Aktivierungsfunktion.

Wie bei der Implementierung eines einzelnen Neurons werden weights und biases mit zufälligen Werten zwischen -1 und 1 aus einer gleichverteilten Zufallsverteilung initialisiert.

class Layer:
    def __init__(self, n_inputs, n_neurons, activation_function):
        self.inputs = np.zeros((n_inputs, 1))
        self.outputs = np.zeros((n_neurons, 1))
        self.weights = ...
        self.biases = ...
        self.activation = activation_function

Die Attribute inputs und outputs werden später bei der Backpropagation verwendet, daher ist es sinnvoll, sie als mit Nullen gefüllte NumPy-Arrays zu initialisieren.

Vorwärtspropagation kann in der Methode forward() implementiert werden, wobei die outputs auf Basis des inputs-Vektors mit NumPy gemäß der obigen Formel berechnet werden:

def forward(self, inputs):
    self.inputs = np.array(inputs).reshape(-1, 1)
    # Raw outputs
    self.outputs = ...
    # Applying the activation function
    return ...