Personnalisation avancée
Les interfaces Ultralytics YOLO en ligne de commande et Python sont des abstractions de haut niveau construites sur des exécuteurs de moteur de base. Ce guide se concentre sur l'interface Trainer en expliquant comment l'adapter à vos besoins spécifiques.
Regarder : Mastering Ultralytics YOLO : Personnalisation avancée
Formateur de base
Le BaseTrainer fournit une routine d'entraînement générique adaptable à diverses tâches. Personnalisez-la en remplaçant des fonctions ou des opérations spécifiques tout en respectant les formats requis. Par exemple, intégrez votre propre modèle et votre propre chargeur de données en remplaçant ces fonctions :
get_model(cfg, weights): Construit le modèle à former.get_dataloader(): Construit le dataloader.
Pour plus de détails et le code source, voir la page BaseTrainer Référence.
Formateur en détection
Voici comment utiliser et personnaliser l'outil Ultralytics YOLO DetectionTrainer:
from ultralytics.models.yolo.detect import DetectionTrainer
trainer = DetectionTrainer(overrides={...})
trainer.train()
trained_model = trainer.best # Get the best model
Personnalisation du DetectionTrainer
Pour former un modèle de détection personnalisé qui n'est pas directement pris en charge, surchargez le modèle de détection existant. get_model fonctionnalité :
from ultralytics.models.yolo.detect import DetectionTrainer
class CustomTrainer(DetectionTrainer):
def get_model(self, cfg, weights):
"""Loads a custom detection model given configuration and weight files."""
...
trainer = CustomTrainer(overrides={...})
trainer.train()
Personnalisez 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, weights):
"""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, voir le Guide des rappels.
Autres composants du moteur
Personnaliser d'autres composants tels que Validators et Predictors de la même manière. Pour plus d'informations, reportez-vous à la documentation de Valideurs et Facteurs prédictifs.
Utiliser YOLO avec des formateurs personnalisés
Le YOLO fournit une enveloppe de haut niveau pour les classes Trainer. Vous pouvez tirer parti de cette architecture pour une plus grande flexibilité dans vos 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, weights):
"""Custom code implementation."""
...
# Initialize YOLO model
model = YOLO("yolo11n.pt")
# Train with custom trainer
results = model.train(trainer=MyCustomTrainer, data="coco8.yaml", epochs=3)
Cette approche vous permet de conserver la simplicité de l'interface YOLO tout en adaptant le processus de formation sous-jacent à vos besoins spécifiques.
FAQ
Comment puis-je personnaliser le Ultralytics YOLO DetectionTrainer pour des tâches spécifiques ?
Personnaliser le DetectionTrainer pour des tâches spécifiques en surchargeant ses méthodes pour les adapter à votre modèle personnalisé et à votre chargeur de données. Commencez par hériter de DetectionTrainer et redéfinir des méthodes telles que get_model pour mettre en œuvre des fonctionnalités personnalisées. En voici un exemple :
from ultralytics.models.yolo.detect import DetectionTrainer
class CustomTrainer(DetectionTrainer):
def get_model(self, cfg, weights):
"""Loads a custom detection model given configuration and weight files."""
...
trainer = CustomTrainer(overrides={...})
trainer.train()
trained_model = trainer.best # Get the best model
Pour une personnalisation plus poussée, telle que la modification de la fonction de perte ou l'ajout d'une fonction de rappel, reportez-vous au guide des fonctions de rappel.
Quels sont les éléments clés de BaseTrainer dans Ultralytics YOLO?
Le BaseTrainer sert de base à des routines de formation, personnalisables pour diverses tâches en remplaçant ses méthodes génériques. Les principaux composants sont les suivants
get_model(cfg, weights): Construit le modèle à former.get_dataloader(): Construit le dataloader.preprocess_batch(): Gère le prétraitement par lots avant la transmission du modèle.set_model_attributes(): Définit les attributs du modèle sur la base des informations du jeu de données.get_validator(): Renvoie un validateur pour l'évaluation du modèle.
Pour plus de détails sur la personnalisation et le code source, voir le document BaseTrainer Référence.
Comment puis-je ajouter un callback au Ultralytics YOLO DetectionTrainer ?
Ajouter des rappels pour surveiller et modifier le processus de formation en DetectionTrainer. Voici comment ajouter un rappel pour enregistrer les poids du modèle après chaque entraînement époque:
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, voir le Guide des rappels.
Pourquoi utiliser Ultralytics YOLO pour l'entraînement des modèles ?
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 et une personnalisation rapides. Les principaux avantages sont les suivants :
- Facilité d'utilisation: les interfaces en ligne de commande et Python simplifient les tâches complexes.
- Performance: Optimisé pour la détection d'objets en temps réel et diverses applications de vision artificielle.
- Personnalisation: Facilement extensible pour les modèles personnalisés, les fonctions de perte et les 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 cadres et outils les plus courants de l'écosystème ML.
Pour en savoir plus sur les capacités de YOLO, consultez la page principale de YOLO. Ultralytics YOLO d'Ultralytics.
Puis-je utiliser le Ultralytics YOLO DetectionTrainer pour des modèles non standard ?
Oui, le DetectionTrainer est très flexible et personnalisable pour les modèles non standard. Hériter de DetectionTrainer et les méthodes de surcharge pour répondre aux besoins de votre modèle spécifique. Voici un exemple simple :
from ultralytics.models.yolo.detect import DetectionTrainer
class CustomDetectionTrainer(DetectionTrainer):
def get_model(self, cfg, weights):
"""Loads a custom detection model."""
...
trainer = CustomDetectionTrainer(overrides={...})
trainer.train()
Pour des instructions et des exemples complets, consultez le DetectionTrainer Référence.
