Apprendre Défi : Entraînement du Perceptron

Section 1. Chapitre 17

single

Glissez pour afficher le menu

Avant de procéder à l'entraînement du perceptron, gardez à l'esprit qu'il utilise la fonction de perte binaire par entropie croisée évoqué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 l'é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 calculer les gradients à chaque couche 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}

Détails d’implémentation à retenir

Lors de la traduction de ces formules en code Python pour la méthode backward(), gardez à l’esprit les opérations NumPy abordées dans les chapitres précédents :

L’opérateur $\odot$ désigne la multiplication élément par élément, réalisée avec l’opérateur standard * en Python.
L’opérateur $\cdot$ désigne un produit scalaire, implémenté avec la fonction np.dot().
L’exposant $T$ indique la transposée d’une matrice, obtenue avec l’attribut .T.
Pour calculer $f'^l(z^l)$ , il est possible d’appeler dynamiquement la dérivée de la fonction d’activation de la couche via self.activation.derivative(self.outputs).

Cela donne à la méthode backward() la structure générale suivante :

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

De même, lors de l'intégration de tous les éléments dans la méthode fit(), il est important de se rappeler qu'il faut parcourir le réseau à l'envers pour propager l'erreur. La structure générale est la suivante :

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

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

Glissez pour commencer à coder

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émenter la méthode backward() dans la classe Layer :

Calculer 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.
Mettre à jour les poids et les biais en utilisant le taux d'apprentissage.

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

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

Vérifier 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

Passez à un bureau pour une pratique réelleContinuez d'où vous êtes en utilisant l'une des options ci-dessous

Tout était clair ?

Merci pour vos commentaires !

Section 1. Chapitre 17

single

Demandez à l'IA

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