Personnalisation avancée
Les interfaces Ultralytics YOLO en ligne de commande et Python sont simplement une abstraction de haut niveau sur les exécuteurs du moteur de base. Jetons un coup d'œil au moteur Trainer.
Regarde : Mastering Ultralytics YOLOv8 : Personnalisation avancée
Formateur de base
BaseTrainer contient la routine de formation générique. Elle peut être personnalisée pour n'importe quelle tâche en remplaçant les fonctions ou les opérations requises, tant que les formats corrects sont respectés. Par exemple, tu peux prendre en charge ton propre modèle et ton propre chargeur de données en remplaçant simplement ces fonctions :
get_model(cfg, weights)
- La fonction qui construit le modèle à entraîner.get_dataloader()
- La fonction qui construit le dataloader Plus de détails et le code source peuvent être trouvés dansBaseTrainer
Référence
Formateur en détection
Voici comment tu peux utiliser le YOLOv8 DetectionTrainer
et de la personnaliser.
from ultralytics.models.yolo.detect import DetectionTrainer
trainer = DetectionTrainer(overrides={...})
trainer.train()
trained_model = trainer.best # get best model
Personnaliser le DetectionTrainer
Personnalisons le formateur pour former un modèle de détection personnalisé qui n'est pas pris en charge directement. Tu peux le faire en surchargeant simplement la fonction existante, la fonction 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()
Tu réalises maintenant que tu dois personnaliser davantage le formateur pour :
- Personnalise le
loss function
. - Ajouter
callback
qui télécharge le modèle sur ton disque Google tous les 10 ans.epochs
Voici comment tu peux le faire :
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 callback
trainer.train()
Pour en savoir plus sur les événements déclencheurs et le point d'entrée des rappels, consulte notre guide sur les rappels.
Autres composants du moteur
Il existe d'autres composants qui peuvent être personnalisés de la même manière, comme par exemple Validators
et Predictors
. Voir la section Référence pour plus d'informations à ce sujet.
FAQ
Comment puis-je personnaliser le Ultralytics YOLOv8 DetectionTrainer pour des tâches spécifiques ?
Pour personnaliser le Ultralytics YOLOv8 DetectionTrainer
pour une tâche spécifique, tu peux surcharger ses méthodes pour les adapter à ton modèle personnalisé et à ton chargeur de données. Commence par hériter de DetectionTrainer
puis redéfinir des méthodes comme get_model
pour mettre en œuvre tes 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 best model
Pour une personnalisation plus poussée, comme la modification de la loss function
ou l'ajout d'un callback
tu peux te référer à notre Guide des rappels.
Quels sont les principaux éléments du BaseTrainer sur Ultralytics YOLOv8 ?
Le BaseTrainer
dans Ultralytics YOLOv8 sert de base aux routines d'entraînement et peut être personnalisé pour diverses tâches en remplaçant ses méthodes génériques. Les principaux composants sont les suivants :
get_model(cfg, weights)
pour construire le modèle à former.get_dataloader()
pour construire le chargeur de données.
Pour plus de détails sur la personnalisation et le code source, consulte le site de l'association. BaseTrainer
Référence.
Comment puis-je ajouter un rappel au Ultralytics YOLOv8 DetectionTrainer ?
Tu peux ajouter des rappels pour surveiller et modifier le processus de formation dans Ultralytics YOLOv8 DetectionTrainer
. Par exemple, voici comment tu peux ajouter un rappel pour enregistrer les poids du modèle après chaque période d'apprentissage :
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, reporte-toi à notre guide sur les rappels.
Pourquoi devrais-je utiliser Ultralytics YOLOv8 pour l'entraînement des modèles ?
Ultralytics YOLOv8 offre 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.
Pour en savoir plus sur les capacités de YOLOv8, consulte le site suivant Ultralytics YOLO.
Puis-je utiliser le Ultralytics YOLOv8 DetectionTrainer pour des modèles non standard ?
Oui, Ultralytics YOLOv8 DetectionTrainer
est très flexible et peut être personnalisé pour des modèles non standard. En héritant de DetectionTrainer
Tu peux surcharger différentes méthodes pour répondre aux besoins de ton 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 plus complets, consulte la documentation de DetectionTrainer.
Créé le 2023-11-12, Mis à jour le 2024-07-04
Auteurs : glenn-jocher (7), RizwanMunawar (1), AyushExel (1), Laughing-q (1)