Apprendre Défi : Entraînement du Perceptron | Réseau de Neurones à Partir de Zéro

Avant de procéder à l'entraînement du perceptron, il est important de noter qu'il utilise la fonction de perte binaire par entropie croisée abordée précédemment. Le dernier concept clé avant d’implémenter la rétropropagation est la formule de la dérivée de cette fonction de perte par rapport aux activations de sortie, $a^n$ . Voici les formules de la fonction de perte et de sa dérivée :

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

où $a^n = \hat{y}$

Pour vérifier que le perceptron s'entraîne correctement, la méthode fit() affiche également la perte moyenne à chaque époque. Celle-ci est calculée en faisant la moyenne de la perte sur l'ensemble des exemples d'entraînement de cette époque :

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

Enfin, les formules pour le calcul des gradients sont les suivantes :

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

Les données d'entraînement d'exemple (X_train) ainsi que les étiquettes correspondantes (y_train) sont stockées sous forme de tableaux NumPy dans le fichier utils.py. De plus, les instances des fonctions d'activation y sont également définies :

relu = ReLU()
sigmoid = Sigmoid()

Tâche

Swipe to start coding

Votre objectif est de compléter le processus d'entraînement d'un perceptron multicouche en implémentant la rétropropagation et la mise à jour des paramètres du modèle.

Suivez attentivement ces étapes :

Implémentez la méthode backward() dans la classe Layer :

Calculez les gradients suivants :
- dz : dérivée de la perte par rapport aux valeurs de pré-activation, en utilisant la dérivée de la fonction d'activation ;
d_weights : gradient de la perte par rapport aux poids, calculé comme le produit scalaire de dz et du vecteur d'entrée transposé ;
d_biases : gradient de la perte par rapport aux biais, égal à dz ;
da_prev : gradient de la perte par rapport aux activations de la couche précédente, obtenu en multipliant la matrice de poids transposée par dz.
Mettez à jour les poids et les biais en utilisant le taux d'apprentissage.

Complétez la méthode fit() dans la classe Perceptron :

Calculez la sortie du modèle en appelant la méthode forward() ;
Calculez la perte en utilisant la formule de l'entropie croisée ;
Calculez $da^n$ — la dérivée de la perte par rapport aux activations de sortie ;
Parcourez les couches en sens inverse, en effectuant la rétropropagation en appelant la méthode backward() de chaque couche.

Vérifiez le comportement de l'entraînement :

Si tout est correctement implémenté, la perte doit diminuer régulièrement à chaque époque avec un taux d'apprentissage de 0.01.

Solution

Tout était clair ?

Merci pour vos commentaires !

Section 2. Chapitre 10

single

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Suggested prompts:

Can you explain how the derivative of the binary cross-entropy loss is used in backpropagation?

What is the purpose of printing the average loss at each epoch?

Can you clarify how the gradients are computed using the provided formulas?

Awesome!

Completion rate improved to 4

Glissez pour afficher le menu

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