Personnalisation avancée
Les interfaces en ligne de commande et python d'Ultralytics YOLO sont toutes deux des abstractions de haut niveau construites sur des exécuteurs de moteur de base. Ce guide se concentre sur le Trainer engine, expliquant comment le personnaliser pour vos besoins spécifiques.
Regarder : Maîtriser Ultralytics YOLO : Personnalisation avancée
BaseTrainer
L'argument BaseTrainer class 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 personnalisé et votre 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, voir le BaseTrainer Référence.
DetectionTrainer
Voici comment utiliser et personnaliser 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 entraîner un modèle de détection personnalisé qui n'est pas directement pris en charge, surchargez le modèle 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 callback pour télécharger le modèle sur Google Drive tous les 10 epochs. 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 callbacks et les points d'entrée, consultez le Guide des Callbacks.
Autres composants du moteur
Personnalisez d'autres composants tels que Validators et Predictors de la même manière. Pour plus d'informations, consultez la documentation de Validateurs et Prédicteurs.
Utilisation de YOLO avec des formateurs personnalisés
L'argument YOLO La classe de modèle fournit un wrapper de haut niveau pour les classes Trainer. Vous pouvez exploiter 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 personnalisant le processus de formation sous-jacent pour répondre à vos besoins spécifiques.
FAQ
Comment puis-je personnaliser le DetectionTrainer Ultralytics YOLO pour des tâches spécifiques ?
Personnaliser le DetectionTrainer pour des tâches spécifiques en redéfinissant ses méthodes afin de s'adapter à votre modèle personnalisé et à votre chargeur de données. Commencez par hériter de DetectionTrainer et redéfinissez des méthodes comme get_model pour implémenter des fonctionnalités personnalisées. 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 plus de personnalisation, comme la modification de la fonction de perte ou l'ajout d'un callback, consultez le Guide des Callbacks.
Quels sont les principaux composants du BaseTrainer dans Ultralytics YOLO ?
L'argument BaseTrainer sert de base aux routines d'entraînement, personnalisable pour diverses tâches en remplaçant ses méthodes génériques. Les composants clés comprennent :
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 par lots avant le passage direct du modèle.set_model_attributes(): Définit les attributs du modèle en fonction des informations de l'ensemble 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 BaseTrainer Référence.
Comment puis-je ajouter un callback au DetectionTrainer Ultralytics YOLO ?
Ajouter des rappels pour surveiller et modifier le processus de formation dans DetectionTrainer. Voici comment ajouter un callback 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, consultez le Guide des rappels.
Pourquoi devrais-je utiliser Ultralytics YOLO pour l'entraînement de 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 d'IA de vision.
- 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 frameworks et outils populaires de l'écosystème ML.
Découvrez les capacités de YOLO en explorant la page principale Ultralytics YOLO.
Puis-je utiliser Ultralytics YOLO DetectionTrainer pour des modèles non standard ?
Oui, le DetectionTrainer est hautement flexible et personnalisable pour les modèles non standard. Hériter de DetectionTrainer et surchargez les méthodes pour prendre en charge les besoins spécifiques de votre modèle. 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.
