Entraîne ton premier modèle

Exemple détaillé : entraîner le détecteur de pilules#

La boîte de dialogue « Entraîner un nouveau modèle » de la plateforme Ultralytics demande les mêmes choix que le code ci-dessous — modèle de base, jeu de données, époques et taille d’image — puis les exécute sur des GPU cloud ou génère la commande locale correspondante. Ces paramètres permettent de terminer l’entraînement en environ une minute sur le CPU d’un ordinateur portable :

from ultralytics import YOLO

model = YOLO("yolo26n.pt")  # préentraîné sur COCO
results = model.train(data="my_dataset/data.yaml", epochs=10, imgsz=320, name="pills_v1")
print(results.save_dir)

La CLI et Python sont équivalents. epochs=10 et imgsz=320 raccourcissent les exécutions sur CPU ; avec un GPU, supprime les deux et accepte les valeurs par défaut (epochs=100, imgsz=640), car davantage d’époques et de pixels sont presque toujours bénéfiques. Le mode Train exécute cette boucle à ta place :

Lire le journal ligne par ligne#

Sortie réelle, réduite aux deux premières et aux deux dernières époques :

optimizer: AdamW(lr=0.002, momentum=0.9) with parameter groups ...
Using 92 train, 23 val images for fraction=1.0 at imgsz=320
      Epoch    GPU_mem   box_loss   cls_loss    l1_loss  Instances       Size
       1/10         0G      1.818      3.899   0.008805        206        320: 100% 6/6 3.3s
                   all         23        399      0.957      0.805      0.927      0.548
       2/10         0G      1.434      3.291   0.006285        208        320: 100% 6/6 4.4s
                   all         23        399      0.953      0.911      0.964      0.592
       ...
       9/10         0G      1.121      1.103   0.005143        194        320: 100% 6/6 5.0s
                   all         23        399      0.949      0.957      0.975      0.656
      10/10         0G      1.174      1.125   0.005068        212        320: 100% 6/6 5.1s
                   all         23        399       0.97      0.957      0.977      0.659
10 epochs completed in 0.015 hours.

• optimizer: AdamW(lr=0.002 ...) : la valeur par défaut optimizer=auto a choisi l’optimiseur et le taux d’apprentissage à ta place.
• Using 92 train, 23 val images : vérifie que ces valeurs correspondent à ton jeu de données. Un nombre plus petit signifie que des images ont été ignorées.
• GPU_mem 0G : l’entraînement se fait sur le CPU. Sur un GPU, tu verrais ici la mémoire utilisée ; 0G sur une machine équipée d’un GPU signifie qu’il n’est pas utilisé.
• Première ligne de chaque époque : les trois pertes pour la partition d’entraînement, ainsi que le nombre d’objets annotés dans le dernier lot (Instances) et la taille des images.
• Ligne all de chaque époque : précision, rappel, mAP50 et mAP50-95 sur la partition de validation. C’est cette ligne qu’il faut surveiller.

Ici, le mAP50-95 est passé de la valeur de référence 0,0002 à 0,548 après une époque, puis à 0,659 après dix. La précision a baissé à 0,80 à l’époque 4, puis s’est rétablie : les résultats d’une seule époque sont bruités sur 23 images de validation ; juge la tendance, pas une seule ligne. Règles de décision pendant une exécution :

• Les pertes diminuent et le mAP augmente : laisse l’entraînement continuer.
• Les pertes sont stables dès l’époque 1 : arrête avec Ctrl+C et vérifie les annotations et le YAML.
• La précision est bien supérieure au rappel : le modèle est prudent et manque des objets. Le rappel est bien supérieur à la précision : il détecte des choses qui n’existent pas.
• Le mAP reste stable pendant de nombreuses époques : davantage d’époques n’aideront pas ; modifie les données ou imgsz.

Les trois pertes sont les composantes de la fonction de perte de YOLO26 ; le guide des métriques de performance explique chaque métrique en détail.

Trouver les fichiers générés par l’exécution#

Tout se trouve dans runs/detect/pills_v1/ :

Ouvre train_batch0.jpg avant toute autre chose. Si les boîtes ne se superposent pas aux objets, les annotations sont incorrectes et aucun nombre d’époques ne corrigera le problème.

Modifie d’abord ces arguments#

model.train(data="my_dataset/data.yaml", epochs=200, imgsz=1024, batch=-1, patience=20, name="pills_v1_1024")

La valeur par défaut 100 de patience signifie qu’une exécution de 100 époques ne s’arrête jamais de façon anticipée. Une valeur plus stricte met fin à une exécution qui stagne, au moment indiqué par les courbes ci-dessus ; best.pt est conservé dans tous les cas.

Avec plusieurs GPU, passe une liste comme device=[0, 1, 2, 3] : Ultralytics lance l’entraînement distribué en parallèle sur les données (DDP) à ta place, batch correspond au total pour tous les GPU, et l’entraînement utilise par défaut la précision mixte (amp=True). Quand ton ordinateur portable ne suffit plus, le même jeu de données et les mêmes arguments peuvent être exécutés sur des GPU cloud via la plateforme Ultralytics, comme expliqué dans Entraîner, lire et affiner des exécutions.

Éviter ces erreurs#

Le guide des conseils d’entraînement des modèles présente les autres arguments, et le guide du réglage des hyperparamètres traite des balayages du taux d’apprentissage et de l’optimiseur génétique. Le guide d’affinage traite du gel des couches.