L'entraînement d'un réseau de neurones implique un processus itératif au cours duquel le modèle s'améliore progressivement en ajustant ses poids et biais afin de minimiser la fonction de perte. Ce processus est appelé optimisation basée sur le gradient et suit un algorithme structuré.

Algorithme général

L'ensemble de données est d'abord transmis à travers le réseau plusieurs fois dans une boucle, chaque passage complet étant appelé époque. Au cours de chaque époque, les données sont mélangées afin d'éviter que le modèle n'apprenne des schémas basés sur l'ordre des exemples d'entraînement. Le mélange introduit une part de hasard, ce qui conduit à un modèle plus robuste.

Pour chaque exemple d'entraînement, le modèle effectue une propagation avant, où les entrées traversent le réseau, couche par couche, pour produire une sortie. Cette sortie est ensuite comparée à la valeur cible réelle afin de calculer la perte.

Ensuite, le modèle applique la rétropropagation et met à jour les poids et biais de chaque couche afin de réduire la perte.

Ce processus se répète pendant plusieurs époques, permettant au réseau d'affiner progressivement ses paramètres. Au fur et à mesure de l'entraînement, le réseau apprend à effectuer des prédictions de plus en plus précises. Cependant, un réglage minutieux des hyperparamètres tels que le taux d'apprentissage est essentiel pour garantir un entraînement stable et efficace.

Le taux d'apprentissage ($\alpha$) détermine la taille du pas lors de la mise à jour des poids. S'il est trop élevé, le modèle risque de dépasser les valeurs optimales et de ne pas converger. S'il est trop faible, l'entraînement devient lent et peut rester bloqué dans une solution sous-optimale. Le choix d'un taux d'apprentissage approprié équilibre la vitesse et la stabilité de l'entraînement. Les valeurs typiques varient de 0.001 à 0.1, selon le problème et la taille du réseau.

Le graphique ci-dessous montre comment un taux d'apprentissage adapté permet à la perte de diminuer régulièrement à un rythme optimal :

Enfin, la descente de gradient stochastique (SGD) joue un rôle essentiel dans l'efficacité de l'entraînement. Au lieu de calculer les mises à jour des poids après avoir traité l'ensemble du jeu de données, la SGD met à jour les paramètres après chaque exemple individuel. Cela rend l'entraînement plus rapide et introduit de légères variations dans les mises à jour, ce qui peut aider le modèle à échapper aux minima locaux et à atteindre une meilleure solution globale.

La méthode fit()

La méthode fit() dans la classe Perceptron est responsable de l'entraînement du modèle en utilisant la descente de gradient stochastique.

def fit(self, training_data, labels, epochs, learning_rate):
    # Iterating over multiple epochs
    for epoch in range(epochs):
        # Shuffling the data  
        indices = np.random.permutation(training_data.shape[0])
        training_data = training_data[indices]
        labels = labels[indices]
        # Iterating through each training example
        for i in range(training_data.shape[0]):
            inputs = training_data[i, :].reshape(-1, 1)
            target = labels[i, :].reshape(-1, 1)

            # Forward propagation
            output = ...

            # Computing the gradient of the loss function w.r.t. output
            da = ...

            # Backward propagation through all layers
            for layer in self.layers[::-1]:
                da = ...