Loss Functions and Optimizers

1. La Fonction de Perte : Mesurer l'Erreur

Une fois que notre modèle a fait une prédiction, nous devons la comparer à la vérité terrain (le label réel) pour savoir s'il a bien travaillé. La fonction de perte, ou "loss function", est une fonction mathématique qui calcule un score unique représentant le "degré d'erreur" ou la "perte" pour cette prédiction. L'objectif de l'entraînement est de rendre ce score aussi bas que possible.

Cas d'étude : CrossEntropyLoss pour la Classification

Pour les tâches de classification (par exemple, décider si une image contient un chat, un chien ou un oiseau), la fonction de perte la plus courante est l'entropie croisée (CrossEntropyLoss).

Pour comprendre l'entropie croisée, il faut d'abord comprendre ce que le modèle produit. La dernière couche d'un modèle de classification produit généralement des scores bruts, non normalisés, appelés logits. Un logit plus élevé pour une classe suggère que le modèle est plus confiant en cette classe.

Pour transformer ces logits en probabilités (des nombres entre 0 et 1 qui somment à 1), on utilise une fonction d'activation appelée Softmax. L'entropie croisée compare ensuite la distribution de probabilité prédite par le modèle (après Softmax) à la distribution de probabilité réelle (où la classe correcte a une probabilité de 1 et les autres de 0).

La vidéo suivante explique très bien l'intuition mathématique derrière Softmax et l'entropie croisée.

En pratique, définir une fonction de perte dans PyTorch est très simple. On instancie simplement la classe correspondante.

import torch
import torch.nn as nn







# On instancie la fonction de perte
# On l'assigne souvent à une variable nommée 'criterion' ou 'loss_fn'
criterion = nn.CrossEntropyLoss()

C'est tout ! PyTorch s'occupera de tous les calculs en arrière-plan.

2. L'Optimiseur : Le Moteur de l'Apprentissage

Maintenant que nous avons une valeur de perte qui nous dit à quel point le modèle se trompe, nous avons besoin d'un moyen pour ajuster les paramètres du modèle (ses poids et ses biais) afin de réduire cette perte. C'est le rôle de l'optimiseur.

L'optimiseur utilise la magie du calcul de gradient (que nous avons abordée avec autograd) pour déterminer comment chaque paramètre a contribué à l'erreur. Ensuite, il modifie légèrement chaque paramètre dans la direction qui devrait diminuer l'erreur. Ce processus est répété des milliers de fois sur des lots de données, et c'est ainsi que le modèle "apprend".

La vidéo suivante donne une excellente vue d'ensemble intuitive des différents types d'optimiseurs et de la raison pour laquelle certains sont plus efficaces que d'autres.

L'optimiseur Adam

Comme mentionné dans la vidéo, Adam (Adaptive Moment Estimation) est l'optimiseur de choix pour la plupart des problèmes de deep learning aujourd'hui. Il est rapide, efficace et nécessite généralement moins de réglages manuels du taux d'apprentissage (learning rate) que d'autres optimiseurs comme le SGD.

En pratique, pour définir un optimiseur dans PyTorch, vous devez lui fournir deux choses :

1. Les paramètres du modèle qu'il doit optimiser (model.parameters()).
2. Un taux d'apprentissage (lr, pour "learning rate"), qui contrôle l'ampleur des ajustements à chaque étape.

Voici comment on l'instancie, en supposant que nous avons un modèle défini dans une variable net :

import torch.optim as optim







# Supposons que 'net' est une instance de notre classe de modèle
# net = MonModele(...) 







# On instancie l'optimiseur Adam
# On lui passe les paramètres du modèle et un taux d'apprentissage (ex: 0.001)
optimizer = optim.Adam(net.parameters(), lr=0.001)

Le site "AI in Arabic" propose un exemple de code clair qui rassemble la définition de la fonction de perte et de l'optimiseur.

Le processus d'optimisation

Une fois la fonction de perte et l'optimiseur définis, le processus d'une seule étape de mise à jour se déroule en trois temps, que nous verrons en détail dans la prochaine leçon :

1. optimizer.zero_grad(): Remettre à zéro les gradients calculés lors de l'étape précédente.
2. loss.backward(): Calculer les gradients de la perte par rapport à tous les paramètres du modèle (c'est la rétropropagation).
3. optimizer.step(): Mettre à jour les paramètres du modèle en utilisant les gradients qui viennent d'être calculés.

Conclusion

Nous avons maintenant assemblé toutes les pièces nécessaires pour entraîner un réseau de neurones ! Nous savons comment construire le modèle, lui fournir des données, mesurer son erreur et l'ajuster pour qu'il s'améliore.

Points clés à retenir :

• La fonction de perte (par exemple, nn.CrossEntropyLoss) quantifie l'erreur d'un modèle en comparant ses prédictions aux vraies valeurs.
• Pour la classification, nn.CrossEntropyLoss est le standard. Il est important de se rappeler qu'il inclut l'étape Softmax, donc votre modèle doit retourner des logits bruts.
• L'optimiseur (par exemple, optim.Adam) est l'algorithme qui met à jour les poids du modèle pour minimiser la perte.
• Adam est un excellent choix par défaut car il combine des techniques avancées comme le momentum et les taux d'apprentissage adaptatifs.
• L'initialisation est simple : criterion = nn.CrossEntropyLoss() et optimizer = optim.Adam(model.parameters(), lr=...).

Dans la prochaine leçon, nous allons enfin mettre tout cela en action. Nous allons écrire une boucle d'entraînement complète en PyTorch, en orchestrant la passe avant, le calcul de la perte, la passe arrière (rétropropagation) et l'étape de l'optimiseur pour entraîner un réseau de neurones sur un véritable jeu de données.