Personnalisation avancée

Les interfaces de ligne de commande et Python d'Ultralytics YOLO sont des abstractions de haut niveau construites sur des moteurs d'exécution de base. Ce guide se concentre sur le moteur Trainer, 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 opérations spécifiques tout en respectant les formats requis. Par exemple, intègre ton propre modèle personnalisé et ton dataloader 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

Personnaliser le DetectionTrainer

Pour entraîner un modèle de détection personnalisé non pris en charge directement, surcharge la fonctionnalité existante 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 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=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 callback et les points d'entrée, consulte le guide des Callbacks.

Autres composants du moteur

Personnalise d'autres composants comme les Validators et Predictors de la même manière. Pour plus d'informations, réfère-toi à la documentation pour les Validators et Predictors.

Utiliser YOLO avec des entraîneurs personnalisés

La classe de modèle YOLO fournit un wrapper de haut niveau pour les classes Trainer. Tu peux exploiter cette architecture pour une plus grande flexibilité dans tes workflows de machine learning :

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 maintenir 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 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 personnalisé et à ton dataloader. 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 plus de personnalisation, comme changer la fonction de perte ou ajouter un callback, réfère-toi au guide des Callbacks.

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

Le BaseTrainer sert de fondation pour les routines d'entraînement, personnalisable 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 le passage en avant du modèle.
• set_model_attributes() : Définit les attributs du modèle en fonction des informations du dataset.
• get_validator() : Retourne 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 ajouter un callback au DetectionTrainer d'Ultralytics YOLO ?

Ajoute des callbacks pour surveiller et modifier le processus d'entraînement dans DetectionTrainer. Voici comment ajouter un callback pour enregistrer les poids du modèle après chaque epoch 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 callback et les points d'entrée, réfère-toi au guide des Callbacks.

Pourquoi utiliser Ultralytics YOLO pour l'entraînement de modèles ?

Ultralytics YOLO fournit une abstraction de haut niveau sur de puissants moteurs d'exécution, le rendant idéal pour le développement rapide et la personnalisation. Les avantages clés incluent :

• Facilité d'utilisation : Les interfaces de 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 visuelle.
• 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 Ultralytics YOLO.

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

Oui, le DetectionTrainer est hautement flexible et personnalisable pour des modèles non standard. Hérite de DetectionTrainer et 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, examine la référence DetectionTrainer.