Personnalisation avancée#
Les interfaces en 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 classe, sauvegarde de modèle, gel du backbone et taux d'apprentissage par couche — consulte le guide Personnaliser l'entraîneur.
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 pour consulter le code source, reporte-toi à la Référence BaseTrainer.
DetectionTrainer#
Voici comment utiliser et personnaliser le DetectionTrainer d'Ultralytics YOLO :
from ultralytics.models.yolo.detect import DetectionTrainer
trainer = DetectionTrainer(overrides={...})
trainer.train()
trained_model = trainer.best # Get the best modelPersonnalisation de DetectionTrainer#
Pour entraîner un modèle de détection personnalisé non pris en charge directement, surcharge la fonctionnalité existante de 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 de 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 des Validateurs et des Prédicteurs.
Utilisation de YOLO avec des entraîneurs personnalisés#
La classe de modèle YOLO fournit un wrapper de haut niveau pour les classes d'entraîneurs. Tu peux exploiter cette architecture pour obtenir une plus grande flexibilité dans tes flux de travail en 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 fondation 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 jeu de données.get_validator(): Renvoie un validateur pour l'évaluation du modèle.
Pour plus de détails sur la personnalisation et pour consulter le code source, reporte-toi à 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 par-dessus de puissants exécuteurs de moteur, ce qui le rend idéal pour le développement rapide et la personnalisation. 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 de vision par ordinateur.
- 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 d'apprentissage automatique.
Apprends-en plus sur les capacités de YOLO en explorant la page principale d'Ultralytics YOLO.
Oui, le
DetectionTrainerest extrêmement flexible et personnalisable pour des 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 complètes et des exemples, 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, telle que la modification de la fonction de perte ou l'ajout d'un rappel, reporte-toi au Guide des rappels.