Link to this sectionComment affiner YOLO sur un jeu de données personnalisé#

Le Fine-tuning adapte un modèle pré-entraîné pour reconnaître de nouvelles classes en partant de poids appris plutôt que d'une initialisation aléatoire. Au lieu de s'entraîner à partir de zéro pendant des centaines d'époques, le fine-tuning tire parti des caractéristiques pré-entraînées de COCO et converge sur des données personnalisées en une fraction du temps.

Ce guide couvre l'affinage de YOLO26 sur des jeux de données personnalisés, de l'utilisation de base aux techniques avancées comme le gel de couches et l'entraînement en deux étapes.

Link to this sectionFine-tuning vs entraînement à partir de zéro#

Un modèle pré-entraîné a déjà appris des caractéristiques visuelles générales - détection de contours, reconnaissance de textures, compréhension de formes - à partir de millions d'images. L'apprentissage par transfert via le fine-tuning réutilise ces connaissances et apprend seulement au modèle à quoi ressemblent les nouvelles classes, ce qui explique pourquoi il converge plus rapidement et nécessite moins de données. L'entraînement à partir de zéro écarte tout cela et force le modèle à tout apprendre à partir des motifs au niveau des pixels, ce qui exige beaucoup plus de ressources.

Link to this sectionComment fonctionne le transfert de poids pré-entraînés#

Lorsqu'un modèle pré-entraîné est affiné sur un jeu de données avec un nombre différent de classes (par exemple, 80 classes COCO vers 5 classes personnalisées), Ultralytics effectue un transfert de poids conscient de la forme :

1. Le backbone et le neck sont entièrement transférés - ces couches extraient des caractéristiques visuelles générales et leurs formes sont indépendantes du nombre de classes.
2. La tête de détection est partiellement réinitialisée - les couches de sortie de classification (cv3, one2one_cv3) ont des formes liées au nombre de classes (80 contre 5), donc elles ne peuvent pas être transférées et sont initialisées de manière aléatoire. Les couches de régression de boîte (cv2, one2one_cv2) dans la tête ont des formes fixes quel que soit le nombre de classes, donc elles se transfèrent normalement.
3. La grande majorité des poids sont transférés lors du changement de nombre de classes. Par exemple, l'affinage de YOLO26n depuis COCO (80 classes) vers un jeu de données à 5 classes transfère 606 des 708 tenseurs de poids : seules les couches de classification dépendantes du nombre de classes sont réinitialisées, tandis que le backbone, le neck et les branches de régression de boîte restent intacts.

Pour les jeux de données ayant le même nombre de classes que le modèle pré-entraîné (par exemple, l'affinage de poids pré-entraînés sur COCO sur un autre jeu de données à 80 classes), 100 % des poids sont transférés, y compris la tête de détection.

Link to this sectionExemple de fine-tuning de base#

from ultralytics import YOLO

model = YOLO("yolo26n.pt")  # load pretrained model
model.train(data="custom.yaml", epochs=50, imgsz=640)

Link to this sectionChoisir une taille de modèle#

Les modèles plus grands ont plus de capacité mais aussi plus de paramètres à mettre à jour, ce qui peut augmenter le risque de surapprentissage lorsque les données d'entraînement sont limitées. Commencer par un modèle plus petit (YOLO26n ou YOLO26s) et passer à une taille supérieure seulement si les métriques de validation stagnent est une approche pratique. La taille optimale du modèle dépend de la complexité de la tâche, du nombre de classes, de la diversité du jeu de données et du matériel disponible pour le déploiement. Consulte la page complète du modèle YOLO26 pour les tailles disponibles et les benchmarks de performance.

Link to this sectionSélection de l'optimiseur et du taux d'apprentissage#

Le paramètre par défaut optimizer=auto sélectionne l'optimiseur et le taux d'apprentissage en fonction du nombre total d'itérations d'entraînement :

• < 10 000 itérations (petits jeux de données ou peu d'époques) : AdamW avec un taux d'apprentissage faible et calculé automatiquement
• > 10 000 itérations (grands jeux de données) : MuSGD (un optimiseur hybride Muon+SGD) avec lr=0.01

Pour la plupart des tâches de fine-tuning, le paramètre par défaut fonctionne bien sans aucun réglage manuel. Envisage de définir l'optimiseur explicitement lorsque :

• L'entraînement est instable (pics de perte ou divergence) : essaie optimizer=AdamW, lr0=0.001 pour une convergence plus stable
• Affinage d'un grand modèle sur un petit jeu de données : un taux d'apprentissage plus faible comme lr0=0.001 aide à préserver les caractéristiques pré-entraînées

Link to this sectionGeler les couches#

Le gel empêche des couches spécifiques d'être mises à jour pendant l'entraînement. Cela accélère l'entraînement et réduit le surapprentissage lorsque le jeu de données est petit par rapport à la capacité du modèle.

Le paramètre freeze accepte soit un entier, soit une liste. Un entier freeze=10 gèle les 10 premières couches (indices 0-9), ce qui couvre la majeure partie du backbone de YOLO26. Le backbone s'étend des couches 0 à 10, donc freeze=10 laisse le bloc C2PSA final (couche 10) entraînable ; utilise freeze=11 pour geler tout le backbone. Une liste peut contenir des indices de couches comme freeze=[0, 3, 5] pour un gel partiel du backbone, ou des noms de modules sous forme de chaînes comme freeze=["23.cv2", "23.one2one_cv2"] pour un contrôle précis sur des branches spécifiques au sein d'une couche (ici, les deux branches de régression de boîte de la tête de détection).

model.train(data="custom.yaml", epochs=50, freeze=10)

La profondeur de gel appropriée dépend de la similitude du domaine cible avec les données pré-entraînées et de la quantité de données d'entraînement disponibles :

La profondeur de gel peut aussi être traitée comme un hyperparamètre - essayer quelques valeurs (0, 5, 10) et comparer le mAP de validation est un moyen pratique de trouver le meilleur réglage pour un jeu de données spécifique.

Link to this sectionHyperparamètres clés pour le fine-tuning#

Le fine-tuning nécessite généralement moins d'ajustements d'hyperparamètres qu'un entraînement à partir de zéro. Les paramètres qui comptent le plus sont :

• epochs : Le fine-tuning converge plus rapidement qu'un entraînement à partir de zéro. Commence avec une valeur modérée et utilise patience pour arrêter tôt quand les métriques de validation stagnent.
• patience : La valeur par défaut de 100 est conçue pour de longues sessions d'entraînement. La réduire à 10-20 évite de perdre du temps sur des sessions qui ont déjà convergé.
• warmup_epochs : Le warmup par défaut (3 époques) augmente progressivement le taux d'apprentissage à partir de zéro, ce qui empêche les grandes mises à jour de gradient d'endommager les caractéristiques pré-entraînées lors des premières itérations. Il est recommandé de conserver la valeur par défaut même pour le fine-tuning.

Pour la liste complète des paramètres d'entraînement, consulte la référence de configuration de l'entraînement.

Link to this sectionFine-tuning en deux étapes#

Le fine-tuning en deux étapes divise l'entraînement en deux phases. La première étape gèle le backbone et n'entraîne que le neck et la tête, permettant aux couches de détection de s'adapter aux nouvelles classes sans perturber les caractéristiques pré-entraînées. La seconde étape dégèle toutes les couches et entraîne le modèle complet avec un taux d'apprentissage plus faible pour affiner le backbone pour le domaine cible.

Cette approche est particulièrement utile lorsque le domaine cible diffère considérablement de COCO (images médicales, imagerie aérienne, microscopie), où le backbone peut avoir besoin d'une adaptation mais où entraîner tout en même temps provoque une instabilité. Pour un dégel automatique avec une approche basée sur les rappels, voir Geler et dégeler le backbone.

from ultralytics import YOLO

# Stage 1: freeze backbone, train head and neck
model = YOLO("yolo26n.pt")
model.train(data="custom.yaml", epochs=20, freeze=10, name="stage1", exist_ok=True)

# Stage 2: unfreeze all, fine-tune with lower lr
model = YOLO("runs/detect/stage1/weights/best.pt")
model.train(data="custom.yaml", epochs=30, lr0=0.001, name="stage2", exist_ok=True)

Link to this sectionPièges courants#

Link to this sectionLe modèle ne produit aucune prédiction#

• Données d'entraînement insuffisantes : l'entraînement avec très peu d'échantillons est la cause la plus fréquente - le modèle ne peut pas apprendre ou généraliser à partir de trop peu de données. Assure-toi d'avoir suffisamment d'exemples diversifiés par classe avant d'enquêter sur d'autres causes.
• Vérifie les chemins du jeu de données : des chemins incorrects dans data.yaml produisent silencieusement zéro étiquette. Exécute yolo detect val model=yolo26n.pt data=custom.yaml avant l'entraînement pour confirmer que les étiquettes se chargent correctement.
• Seuil de confiance plus bas : si des prédictions existent mais sont filtrées, essaie conf=0.1 lors de l'inférence.
• Vérifie le nombre de classes : assure-toi que nc dans data.yaml correspond au nombre réel de classes dans les fichiers d'étiquettes.

Link to this sectionLe mAP de validation stagne tôt#

• Ajoute plus de données : le fine-tuning bénéficie considérablement de données d'entraînement supplémentaires, surtout d'exemples diversifiés avec des angles, éclairages et arrière-plans variés.
• Vérifie l'équilibre des classes : les classes sous-représentées auront un faible AP. Utilise cls_pw pour appliquer une pondération de classe basée sur l'inverse de la fréquence (commence avec cls_pw=0.25 pour un déséquilibre modéré, augmente à 1.0 pour un déséquilibre sévère).
• Réduis l'augmentation : pour les très petits jeux de données, une forte augmentation peut nuire plus qu'aider. Essaie mosaic=0.5 ou mosaic=0.0.
• Augmente la résolution : pour les jeux de données avec de petits objets, essaie imgsz=1280 pour préserver les détails.

Link to this sectionLa performance se dégrade sur les classes originales après le fine-tuning#

Ceci est connu sous le nom d'oubli catastrophique - le modèle perd des connaissances précédemment apprises lorsqu'il est affiné exclusivement sur de nouvelles données. L'oubli est pratiquement inévitable sans inclure des images du jeu de données original avec les nouvelles données. Pour atténuer cela :

• Fusionne les jeux de données : inclus des exemples des classes originales avec les nouvelles classes lors du fine-tuning. C'est le seul moyen fiable d'éviter l'oubli.
• Gèle le backbone et le neck : geler à la fois le backbone et le neck pour que seule la tête de détection s'entraîne aide pour les sessions de fine-tuning courtes avec un taux d'apprentissage très faible.
• Entraîne sur moins d'époques : plus le modèle s'entraîne exclusivement sur de nouvelles données, plus l'oubli augmente.

Link to this sectionFAQ#

Link to this sectionCombien d'images ai-je besoin pour affiner YOLO ?#

Il n'y a pas de minimum fixe - les résultats dépendent de la complexité de la tâche, du nombre de classes et de la similitude du domaine avec COCO. Des images plus diversifiées (éclairage, angles, arrière-plans variés) comptent plus que la quantité brute. Commence avec ce que tu as et augmente si les métriques de validation sont insuffisantes.

Link to this sectionComment puis-je affiner YOLO26 sur un jeu de données personnalisé ?#

Charge un fichier .pt pré-entraîné et appelle .train() avec le chemin vers un data.yaml personnalisé. Ultralytics gère automatiquement le transfert de poids, la réinitialisation de la tête de détection et la sélection de l'optimiseur. Consulte la section Fine-tuning de base pour l'exemple de code complet.

Link to this sectionPourquoi mon modèle YOLO affiné ne détecte-t-il rien ?#

Les causes les plus courantes sont des chemins incorrects dans data.yaml (ce qui produit silencieusement zéro étiquette), une inadéquation entre nc dans le YAML et les fichiers d'étiquettes réels, ou un seuil de confiance trop élevé. Consulte les Pièges courants pour une liste de dépannage complète.

Link to this sectionQuelles couches YOLO devrais-je geler pour le fine-tuning ?#

Cela dépend de la taille du jeu de données et de la similitude du domaine. Pour les petits jeux de données avec un domaine similaire à COCO, geler le backbone (freeze=10) empêche le surapprentissage. Pour des domaines très différents de COCO, laisser toutes les couches non gelées (freeze=None) permet au backbone de s'adapter. Consulte Geler les couches pour des recommandations détaillées.

Link to this sectionComment puis-je éviter l'oubli catastrophique lors de l'affinage de YOLO sur de nouvelles classes ?#

Inclus des exemples des classes originales dans les données d'entraînement avec les nouvelles classes. Si ce n'est pas possible, geler plus de couches (freeze=10 ou plus) et utiliser un taux d'apprentissage plus faible aide à préserver les connaissances pré-entraînées. Consulte La performance se dégrade sur les classes originales pour plus de détails.