Lernen Herausforderung: Training des Perzeptrons

Abschnitt 1. Kapitel 17

single

Swipe um das Menü anzuzeigen

Bevor Sie mit dem Training des Perzeptrons fortfahren, beachten Sie, dass die binäre Kreuzentropie-Verlustfunktion verwendet wird, die zuvor besprochen wurde. Das letzte zentrale Konzept vor der Implementierung der Backpropagation ist die Formel für die Ableitung dieser Verlustfunktion bezüglich der Ausgabeaktivierungen, $a^n$. Nachfolgend sind die Formeln für die Verlustfunktion und deren Ableitung aufgeführt:

\begin{aligned} L &= -(y \log(\hat{y}) + (1-y) \log(1 - \hat{y}))\\ da^n &= \frac {\hat{y} - y} {\hat{y}(1 - \hat{y})} \end{aligned}

wobei $a^n = \hat{y}$

Um zu überprüfen, ob das Perzeptron korrekt trainiert wird, gibt die Methode fit() auch den durchschnittlichen Verlust in jeder Epoche aus. Dieser wird berechnet, indem der Verlust über alle Trainingsbeispiele in dieser Epoche gemittelt wird:

for epoch in range(epochs):
    loss = 0

    for i in range(training_data.shape[0]):
        loss += -(target * np.log(output) + (1 - target) * np.log(1 - output))

average_loss = loss[0, 0] / training_data.shape[0]
print(f'Loss at epoch {epoch + 1}: {average_loss:.3f}')

L = -\frac1N \sum_{i=1}^N (y_i \log(\hat{y}_i) + (1 - y_i) \log(1 - \hat{y}_i))

Abschließend lauten die Formeln zur Berechnung der Gradienten in jeder Schicht wie folgt:

\begin{aligned} dz^l &= da^l \odot f'^l(z^l)\\ dW^l &= dz^l \cdot (a^{l-1})^T\\ db^l &= dz^l\\ da^{l-1} &= (W^l)^T \cdot dz^l \end{aligned}

Zu beachtende Implementierungsdetails

Beim Übertragen dieser Formeln in Python-Code für die Methode backward() beachten Sie die in den vorherigen Kapiteln besprochenen NumPy-Operationen:

Der Operator $\odot$ steht für elementweise Multiplikation, die mit dem Standard-Operator * in Python durchgeführt wird.
Der Operator $\cdot$ steht für das Skalarprodukt, das mit der Funktion np.dot() implementiert wird.
Der Exponent $T$ steht für die Matrixtransponierung, die mit dem Attribut .T ausgeführt wird.
Um $f'^l(z^l)$ zu berechnen, kann die Ableitung der Aktivierungsfunktion der Schicht dynamisch mit self.activation.derivative(self.outputs) aufgerufen werden.

Dadurch ergibt sich für die allgemeine Struktur der Methode backward() folgendes Muster:

def backward(self, da, learning_rate):
    dz = ... # using da and self.activation.derivative()
    d_weights = ... # using np.dot() and .T
    d_biases = ...
    da_prev = ...

    self.weights -= learning_rate * d_weights
    self.biases -= learning_rate * d_biases

    return da_prev

Ebenso gilt: Wenn alles in der fit()-Methode zusammengeführt wird, beachten Sie, dass Sie das Netzwerk rückwärts durchlaufen müssen, um den Fehler zu propagieren. Die allgemeine Struktur sieht folgendermaßen aus:

def fit(self, training_data, labels, epochs, learning_rate):
    # ... (Epoch loop and data shuffling) ...
            # Forward propagation
            output = ...

            # Computing the gradient of the loss function w.r.t. output (da^n)
            da = ...

            # Backward propagation through all layers
            for layer in self.layers[::-1]:
                da = ... # Call the backward() method of the layer

Die Beispiel-Trainingsdaten (X_train) sowie die zugehörigen Labels (y_train) sind als NumPy-Arrays in der Datei utils.py gespeichert. Zusätzlich sind dort auch Instanzen der Aktivierungsfunktionen definiert:

relu = ReLU()
sigmoid = Sigmoid()

Aufgabe

Wischen, um mit dem Codieren zu beginnen

Ziel ist es, den Trainingsprozess für einen mehrschichtigen Perzeptron durch Implementierung von Backpropagation und Aktualisierung der Modellparameter abzuschließen.

Gehen Sie dabei wie folgt vor:

Implementieren der Methode backward() in der Klasse Layer:

Berechnen Sie die folgenden Gradienten:
dz: Ableitung des Verlusts bezüglich der Voraktivierungswerte unter Verwendung der Ableitung der Aktivierungsfunktion;
d_weights: Gradient des Verlusts bezüglich der Gewichte, berechnet als das Skalarprodukt von dz und dem transponierten Eingabevektor;
d_biases: Gradient des Verlusts bezüglich der Biases, entspricht dz;
da_prev: Gradient des Verlusts bezüglich der Aktivierungen der vorherigen Schicht, erhalten durch Multiplikation der transponierten Gewichtsmatrix mit dz.
Aktualisieren Sie die Gewichte und Biases unter Verwendung der Lernrate.

Vervollständigen der Methode fit() in der Klasse Perceptron:

Berechnen Sie die Modellausgabe durch Aufruf der Methode forward();
- Berechnen Sie den Verlust mit der Kreuzentropie-Formel;
Berechnen Sie $da^n$ $d a^{n}$ — die Ableitung des Verlusts bezüglich der Ausgangsaktivierungen;
- Durchlaufen Sie die Schichten rückwärts und führen Sie Backpropagation durch, indem Sie die jeweilige backward()-Methode jeder Schicht aufrufen.

Überprüfen des Trainingsverhaltens:

Wenn alles korrekt implementiert ist, sollte der Verlust bei Verwendung einer Lernrate von 0.01 kontinuierlich abnehmen.

Lösung

Wechseln Sie zum Desktop, um in der realen Welt zu übenFahren Sie dort fort, wo Sie sind, indem Sie eine der folgenden Optionen verwenden

War alles klar?

Danke für Ihr Feedback!

Abschnitt 1. Kapitel 17

single

Fragen Sie AI

Fragen Sie alles oder probieren Sie eine der vorgeschlagenen Fragen, um unser Gespräch zu beginnen