Training from scratch

Cette page présente la mise en œuvre d’un entraînement complet d’un réseau CNN de petite taille comme si nous découvrions un nouveau problème et que nous cherchions à optimiser le réseau.

La méthode

Nous allons vous présenter une méthode en plusieurs étapes afin d’optimiser les performances d’un réseau. Un premier problème se pose rapidement : il existe de nombreux critères, et tous sont importants.

Pour clarifier les choses, pour chaque étape, on va :

• choisir 1 ou 2 critères principaux

Mais aussi !

• ignorer certains critères

• définir des critères éliminatoires

• lister des critères annexes

Cela représente toute la difficulté de l’apprentissage, c’est un art, pas une science exacte. Ainsi, parfois vous serez contrarié car :

• Une configuration qui vous semblait idéale en tout point va être disqualifiée par un seul critère

• Un critère qui était primordial à une étape devient accessoire à une autre, voir ignoré

• Lorsque deux situations sont similaires par rapport aux critères principaux, ce sont les critères annexes qui discriment !

• Lorsque qu’il faut faire un choix parmi des critères annexes, soyons honnête, la décision est empirique

Phase 1 : Setup

Les données

On peut dire que 80% des problèmes viennent de cette étape. À vérifier :

• labels corrects

• train / val bien séparés

• normalisation correcte

• Si peu d’images par classe => Data Augmentation à activer immédiatement

• pas d’augmentation sur le set de validation

Choix d’un optimiseur

Nous vous proposons :

• torch.optim.SGD( model.parameters(), lr=0.1, momentum=0.9, weight_decay=1e-4 )

• torch.optim.Adam( model.parameters(), lr=1e-3 )

Ne pas considérer qu’Adam est meilleur que SGD ! Ce sont deux très bons optimiseurs. Chacun a ses avantages, voici comment faire votre choix :

• Adam converge souvent plus vite, mais l’accuracy peut être moindre

• SGD généralise souvent mieux, accuracy meilleure, mais nécessite plus d’epochs

Si vous êtes sur CPU, Adam peut réduire le temps d’apprentissage. Il n’y a aucun critère à ce niveau, l’un ou l’autre conviennent.

Phase 2 : Optimisation du LR

>>> Toujours régler le LR avant le reste <<<

Il s’agit du paramètre le plus critique de l’optimisation. Nous allons tester plusieurs valeurs pour le learning rate et sélectionner la plus prometteuse.

• Critère éliminatoire : overshoot, underfitting, undertraining

• Critère principal : la loss/train

  • recherche d’une courbe de loss/train qui ↓

  • le plus vite sur les premières epochs (10-20 epochs)

  • sans oscillations (pas de dents de scie)

  • avec un plateau final équivalent à ses concurrentes (à qqe % près)

• Critère ignoré : overfitting (il y en aura)

• Critères annexes : meilleur d’accuracy/train, moins d’overconfidence, moins de gap sur le train…

Ainsi, on examine en priorité les courbes de loss/train car leurs pentes respectives sont directement liées au LR :

• Loss/train diverge : learning rate trop haut

• Loss/train chaotique mais convergente : learning rate légèrement trop élevé

• Loss/train ↓ : courbe à conserver

• Loss/train ↓ trop lentement ou atteint un plateau trop tôt : learning rate trop faible

A ce stade, nous rappelons que le surapprentissage est toléré car l’objectif principal reste l’efficacité de l’optimisation.

Pour un batch size classique de 32 ou 64, voici les valeurs de LR usuelles :

Pour SGD :

• Exploration initiale : [ 1e-1, 3e-2, 1e-2, 3e-3 ]

• Affinage : on prend la meilleure valeur et on affine 3e-2 → [ 2e-2, 3e-2, 5e-2]

Pour Adam, l’espace pertinent est beaucoup plus resserré que pour SGD :

• Exploration initiale : [3e-4, 1e-3, 3e-3 ]

• Affinage : pour 1e-3 → [ 5e-4, 1e-3, 2e-3], pour 3e-4 → [ 1e-4, 3e-4, 5e-4 ]

Phase 3 : Amélioration du modèle

Optimisation de l’architecture

La tendance est la suivante :

• réseau trop petit → underfit

• réseau trop grand → overfit

Bien que l’architecture choisie soit simple, nous avons déjà plusieurs options pour la faire évoluer. Vous pouvez en choisir 1 dans la liste :

• Nombre de blocs Conv2D : 2, 3 ou 4

• La largeur des features : 64/128/256 → 32-64-128 (plus léger) ou 48/96/192

• Retirer le downsampling (MaxPool) du premier bloc convolutionnel

• MLP bicouche en sortie : FC(256, 128) + ReLU + nn.Linear(128, num_classes)

Critères :

• Critère 1 : Pic de accuracy/validation

• Critère 2 : si critère 1 équivalent - loss/valid la plus faible mais avec un pic de accuracy/valid amélioré

• Critère 3 : En cas de performances comparables : stabilité des courbes

Régularisation

La régularisation vise à contraindre le modèle pour qu’il apprenne des règles plus simples, plus robustes, et mieux généralisables.

À introduire uniquement en présence de surapprentissage (overfit)

Options :

• Data augmentation (si non fait)

• Ajout de couches dropout après les couches FC

• label smoothing [0, 0, 1, 0, 0] → [0.01, 0.01, 0.96, 0.01, 0.01]

Critères :

• Critère 1 : Réduction du surapprentissage

• Critère 2 : Maintien du pic de validation accuracy

• Critère 3 : Stabilité et cohérence des courbes

Si la technique n’apporte pas de gain, on peut la retirer.

Test de BatchNorm

BatchNorm améliore la stabilité et la vitesse d’apprentissage. Elle est particulièrement utile si l’entraînement est instable, mais peut aussi apporter un gain même lorsque les courbes semblent propres.

• A insérer après les couches conv : Conv2D → BatchNorm → ReLU

Critères :

• Critère n°1 : stabilité de l’apprentissage

• Critère n°2 : à stabilité équivalente, vitesse de convergence

• Critère n°3 : validation accuracy (maintenue ou améliorée)

Si la technique n’apporte pas de gain, on peut la retirer.

Phase 4 : Micro-optimisation

Test d’un autre optimiseur - optionnel

Etape à considérer si tout le reste est sain : données propres, LR correct pour l’optimiseur courant, architecture raisonnable, entraînement stable.

Les autres options :

• SGD + momentum → meilleur à long terme

• Adam → plus rapide à converger

• AdamW → meilleure régularisation

Il faut donc refaire les 2 étapes d’optimisation du LR

Critères :

• Critère n°1 : meilleur pic de accuracy/validation

• Critère n°2 : stabilité et régularité des courbes

• Critère n°3 : vitesse de convergence

Options de l’optimiseur

Il peut être judicieux d’optimiser les options de l’optimiseur. Le faire plus tôt serait inapproprié.

Critères :

• Critère n°1 : Gain marginal en validation accuracy, quelques %

• Critère n°2 : Stabilité de l’apprentissage

• Critère n°3 : Cohérence entre loss et accuracy : loss ↓ et accuracy ↑

Scheduler

L’objectif d’un scheduler est de moduler le learning rate entre le début et la fin de l’apprentissage. Un scheduler ne corrige pas un mauvais learning rate initial : celui-ci doit être correctement réglé au préalable.

L’utilisation d’un scheduler permet souvent de gagner quelques points de performance, ce qui peut être décisif, par exemple, pour passer de 95% à 98% d’accuracy.

En contrepartie, l’entraînement est généralement plus long, car le nombre d’epochs doit être augmenté afin de tirer pleinement parti de la décroissance du learning rate.

Critères :

• Critère n°1 : amélioration du pic de validation accuracy

• Critère n°2 : améliorer convergence sur les dernières epochs

• Critère n°3 : coût en temps d’entraînement - nombre d’epochs supplémentaires

Phase 5 : Test (optionnel)

Après avoir terminé, si vous voulez respecter le protocole standard, il faut tester votre modèle et calculer l’accuracy sur le dataset de Test que nous n’avons jamais utilisé jusqu’à maintenant.