Leer Uitdaging: Het Trainen van de Perceptron

Sectie 1. Hoofdstuk 17

single

Veeg om het menu te tonen

Voordat je doorgaat met het trainen van de perceptron, houd er rekening mee dat deze gebruikmaakt van de binaire cross-entropy verliesfunctie die eerder is besproken. Het laatste belangrijke concept voordat backpropagation wordt geïmplementeerd, is de formule voor de afgeleide van deze verliesfunctie ten opzichte van de outputactivaties, $a^n$. Hieronder staan de formules voor de verliesfunctie en de afgeleide:

\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}

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

Om te controleren of de perceptron correct traint, print de fit()-methode ook het gemiddelde verlies bij elke epoch. Dit wordt berekend door het verlies te middelen over alle trainingsvoorbeelden in die epoch:

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))

Tot slot zijn de formules voor het berekenen van de gradiënten in elke laag als volgt:

\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}

Implementatiedetails om te onthouden

Bij het vertalen van deze formules naar Python-code voor de backward()-methode, houd rekening met de NumPy-operaties die in de vorige hoofdstukken zijn besproken:

De $\odot$ -operator geeft elementgewijze vermenigvuldiging aan, wat wordt uitgevoerd met de standaard *-operator in Python.
De $\cdot$ -operator geeft een dotproduct aan, geïmplementeerd met de functie np.dot().
De $T$ -superscript geeft een matrixtransponering aan, afgehandeld door het .T-attribuut.
Om $f'^l(z^l)$ te berekenen, kun je dynamisch de afgeleide van de activatiefunctie van de laag aanroepen met self.activation.derivative(self.outputs).

Hierdoor ziet de algemene structuur van de backward()-methode er als volgt uit:

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

Op vergelijkbare wijze, wanneer alles wordt samengevoegd in de fit()-methode, moet u eraan denken dat u door het netwerk achterwaarts moet itereren om de fout te propageren. De algemene structuur ziet er als volgt uit:

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

De voorbeeldtrainingsgegevens (X_train) samen met de bijbehorende labels (y_train) zijn opgeslagen als NumPy-arrays in het bestand utils.py. Daarnaast zijn instanties van de activatiefuncties daar ook gedefinieerd:

relu = ReLU()
sigmoid = Sigmoid()

Taak

Veeg om te beginnen met coderen

Je doel is om het trainingsproces voor een multilayer perceptron te voltooien door backpropagation te implementeren en de modelparameters bij te werken.

Volg deze stappen zorgvuldig:

Implementeer de backward()-methode in de Layer-klasse:

Bereken de volgende gradiënten:
- dz: afgeleide van het verlies ten opzichte van de pre-activatiewaarden, met behulp van de afgeleide van de activatiefunctie;
d_weights: gradiënt van het verlies ten opzichte van de gewichten, berekend als het dotproduct van dz en de getransponeerde invoervector;
d_biases: gradiënt van het verlies ten opzichte van de biases, gelijk aan dz;
da_prev: gradiënt van het verlies ten opzichte van de activaties van de vorige laag, verkregen door de getransponeerde gewichtenmatrix te vermenigvuldigen met dz.
Werk de gewichten en biases bij met behulp van de leersnelheid.

Maak de fit()-methode in de Perceptron-klasse af:
- Bereken de modeloutput door de forward()-methode aan te roepen;
- Bereken het verlies met behulp van de cross-entropyformule;

Bereken $da^n$ $d a^{n}$ — de afgeleide van het verlies ten opzichte van de outputactivaties;
- Loop achterwaarts door de lagen en voer backpropagation uit door de backward()-methode van elke laag aan te roepen.

Controleer het trainingsgedrag:

Als alles correct is geïmplementeerd, zou het verlies gestaag moeten afnemen bij elke epoch wanneer een leersnelheid van 0.01 wordt gebruikt.

Oplossing

Schakel over naar desktop voor praktijkervaringGa verder vanaf waar je bent met een van de onderstaande opties

Was alles duidelijk?

Bedankt voor je feedback!

Sectie 1. Hoofdstuk 17

single

Vraag AI

Vraag wat u wilt of probeer een van de voorgestelde vragen om onze chat te starten.