Leer Uitdaging: Het Trainen van de Perceptron

Voordat u 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 verifiëren dat de perceptron correct wordt getraind, drukt de fit()-methode ook het gemiddelde verlies af 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))

Ten slotte zijn de formules voor het berekenen van de gradiënten 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}

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

relu = ReLU()
sigmoid = Sigmoid()

Taak

Swipe to start coding

Het 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

Was alles duidelijk?

Bedankt voor je feedback!

Sectie 2. Hoofdstuk 10

single

Vraag AI

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

Awesome!

Completion rate improved to 4

Veeg om het menu te tonen

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