Personnalisation avancée#
Les interfaces de ligne de commande et Python d'Ultralytics YOLO sont des abstractions de haut niveau construites sur des exécuteurs de moteur de base. Ce guide se concentre sur le moteur Trainer, en expliquant comment le personnaliser pour tes besoins spécifiques.
Watch: Mastering Ultralytics YOLO: Advanced Customization
Pour des exemples pratiques de personnalisations courantes de l'entraîneur — métriques personnalisées, perte pondérée par les classes, sauvegarde de modèle, gel du backbone et taux d'apprentissage par couche —, consulte le guide Customizing Trainer.
BaseTrainer#
La classe BaseTrainer fournit une routine d'entraînement générique adaptable à diverses tâches. Personnalise-la en remplaçant des fonctions ou des opérations spécifiques tout en respectant les formats requis. Par exemple, intègre ton propre modèle personnalisé et ton propre chargeur de données en remplaçant ces fonctions :
get_model(cfg, weights): Construit le modèle à entraîner.get_dataloader(): Construit le chargeur de données.
Pour plus de détails et le code source, consulte la Référence BaseTrainer.
DetectionTrainer#
Voici comment utiliser et personnaliser l'Ultralytics YOLO DetectionTrainer :
from ultralytics.models.yolo.detect import DetectionTrainer
trainer = DetectionTrainer(overrides={...})
trainer.train()
trained_model = trainer.best # Get the best modelPersonnalisation du DetectionTrainer#
Pour entraîner un modèle de détection personnalisé non pris en charge nativement, surcharge la fonctionnalité existante get_model :
from ultralytics.models.yolo.detect import DetectionTrainer
class CustomTrainer(DetectionTrainer):
def get_model(self, cfg=None, weights=None, verbose=True):
"""Loads a custom detection model given configuration and weight files."""
trainer = CustomTrainer(overrides={...})
trainer.train()Personnalise davantage l'entraîneur en modifiant la fonction de perte ou en ajoutant un rappel pour télécharger le modèle sur Google Drive toutes les 10 époques. Voici un exemple :
from ultralytics.models.yolo.detect import DetectionTrainer
from ultralytics.nn.tasks import DetectionModel
class MyCustomModel(DetectionModel):
def init_criterion(self):
"""Initializes the loss function and adds a callback for uploading the model to Google Drive every 10 epochs."""
class CustomTrainer(DetectionTrainer):
def get_model(self, cfg=None, weights=None, verbose=True):
"""Returns a customized detection model instance configured with specified config and weights."""
return MyCustomModel(...)
# Callback to upload model weights
def log_model(trainer):
"""Logs the path of the last model weight used by the trainer."""
last_weight_path = trainer.last
print(last_weight_path)
trainer = CustomTrainer(overrides={...})
trainer.add_callback("on_train_epoch_end", log_model) # Adds to existing callbacks
trainer.train()Pour plus d'informations sur les événements de déclenchement des rappels et les points d'entrée, consulte le Guide des rappels.
Autres composants du moteur#
Personnalise d'autres composants comme Validators et Predictors de la même manière. Pour plus d'informations, réfère-toi à la documentation pour les Validateurs et les Prédicteurs.
Utilisation de YOLO avec des trainers personnalisés#
La classe de modèle YOLO fournit un wrapper de haut niveau pour les classes Trainer. Tu peux exploiter cette architecture pour plus de flexibilité dans tes flux de travail d'apprentissage automatique :
from ultralytics import YOLO
from ultralytics.models.yolo.detect import DetectionTrainer
# Create a custom trainer
class MyCustomTrainer(DetectionTrainer):
def get_model(self, cfg=None, weights=None, verbose=True):
"""Custom code implementation."""
# Initialize YOLO model
model = YOLO("yolo26n.pt")
# Train with custom trainer
results = model.train(trainer=MyCustomTrainer, data="coco8.yaml", epochs=3)Cette approche te permet de conserver la simplicité de l'interface YOLO tout en personnalisant le processus d'entraînement sous-jacent pour répondre à tes exigences spécifiques.
FAQ#
Le
BaseTrainersert de base aux routines d'entraînement, personnalisables pour diverses tâches en remplaçant ses méthodes génériques. Les composants clés incluent :get_model(cfg, weights): Construit le modèle à entraîner.get_dataloader(): Construit le chargeur de données.preprocess_batch(): Gère le prétraitement des lots avant la passe avant du modèle.set_model_attributes(): Définit les attributs du modèle en fonction des informations du dataset.get_validator(): Renvoie un validateur pour l'évaluation du modèle.
Pour plus de détails sur la personnalisation et le code source, consulte la Référence
BaseTrainer.Ajoute des rappels pour surveiller et modifier le processus d'entraînement dans
DetectionTrainer. Voici comment ajouter un rappel pour enregistrer les poids du modèle après chaque époque d'entraînement :from ultralytics.models.yolo.detect import DetectionTrainer # Callback to upload model weights def log_model(trainer): """Logs the path of the last model weight used by the trainer.""" last_weight_path = trainer.last print(last_weight_path) trainer = DetectionTrainer(overrides={...}) trainer.add_callback("on_train_epoch_end", log_model) # Adds to existing callbacks trainer.train()Pour plus de détails sur les événements de rappel et les points d'entrée, réfère-toi au Guide des rappels.
Ultralytics YOLO fournit une abstraction de haut niveau sur des exécuteurs de moteur puissants, ce qui le rend idéal pour un développement rapide et une personnalisation poussée. Les principaux avantages incluent :
- Facilité d'utilisation : Les interfaces en ligne de commande et Python simplifient les tâches complexes.
- Performances : Optimisé pour la détection d'objets en temps réel et diverses applications d'IA de vision.
- Personnalisation : Facilement extensible pour des modèles personnalisés, des fonctions de perte et des chargeurs de données.
- Modularité : Les composants peuvent être modifiés indépendamment sans affecter l'ensemble du pipeline.
- Intégration : Fonctionne de manière transparente avec les frameworks et outils populaires de l'écosystème ML.
Apprends-en plus sur les capacités de YOLO en explorant la page principale Ultralytics YOLO.
Oui, le
DetectionTrainerest hautement flexible et personnalisable pour les modèles non standard. Hérite deDetectionTraineret surcharge les méthodes pour répondre aux besoins spécifiques de ton modèle. Voici un exemple simple :from ultralytics.models.yolo.detect import DetectionTrainer class CustomDetectionTrainer(DetectionTrainer): def get_model(self, cfg=None, weights=None, verbose=True): """Loads a custom detection model.""" trainer = CustomDetectionTrainer(overrides={...}) trainer.train()Pour des instructions et des exemples complets, consulte la Référence
DetectionTrainer.
Personnalise le
DetectionTrainerpour des tâches spécifiques en remplaçant ses méthodes pour l'adapter à ton modèle personnalisé et à ton chargeur de données. Commence par hériter deDetectionTraineret redéfinis des méthodes commeget_modelpour implémenter des fonctionnalités personnalisées. Voici un exemple :Pour une personnalisation plus poussée, comme le changement de la fonction de perte ou l'ajout d'un rappel, réfère-toi au Guide des rappels.