Personnalisation avancée#

Les interfaces en ligne de commande et Python d'Ultralytics YOLO sont des abstractions de haut niveau basées 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.

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 et ton propre dataloader personnalisés en remplaçant ces fonctions :

• get_model(cfg, weights) : Construit le modèle à entraîner.
• get_dataloader() : Construit le dataloader.

Pour plus de détails et le code source, consulte 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 model

Personnalisation du DetectionTrainer#

Pour entraîner un modèle de détection personnalisé non pris en charge nativement, surcharge la fonctionnalité get_model existante :

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 le trainer en modifiant la fonction de perte ou en ajoutant un rappel pour envoyer le modèle sur Google Drive tous 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 les Validators et les Predictors de la même manière. Pour plus d'informations, réfère-toi à la documentation des Validators et des Predictors.

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 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#

Comment puis-je personnaliser le DetectionTrainer d'Ultralytics YOLO pour des tâches spécifiques ?#

Personnalise le DetectionTrainer pour des tâches spécifiques en remplaçant ses méthodes pour l'adapter à ton modèle et à ton dataloader personnalisés. Commence par hériter de DetectionTrainer et redéfinis 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=None, weights=None, verbose=True):
        """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, comme le changement de la fonction de perte ou l'ajout d'un rappel, réfère-toi au Guide des rappels.

Quels sont les composants clés du BaseTrainer dans Ultralytics YOLO ?#

Le BaseTrainer sert de fondation pour les 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 dataloader.
• preprocess_batch() : Gère le prétraitement des lots avant la passe avant (forward pass) 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 le code source, consulte la Référence BaseTrainer.

Comment puis-je ajouter un rappel au DetectionTrainer d'Ultralytics YOLO ?#

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.

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 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 de vision par ordinateur.
• Personnalisation : Facilement extensible pour des modèles personnalisés, des fonctions de perte et des dataloaders.
• 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 d'Ultralytics YOLO.

Puis-je utiliser le DetectionTrainer d'Ultralytics YOLO pour des modèles non standard ?#

Oui, le DetectionTrainer est extrêmement flexible et personnalisable pour les modèles non standard. Hérite de DetectionTrainer et surcharge les 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=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.