Ultralytics YOLO27 :
Get Started

Personnalisation avancée#

Les interfaces en 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 et explique comment le personnaliser selon tes besoins.



Regarder : Maîtriser Ultralytics YOLO : personnalisation avancée
Conseil

Pour des exemples pratiques de personnalisations courantes du trainer — métriques personnalisées, fonction de perte pondérée par classe, sauvegarde du modèle, gel du backbone et taux d’apprentissage par couche — consulte le guide Personnaliser le trainer.

BaseTrainer#

La classe BaseTrainer fournit une routine d’entraînement générique qui s’adapte à diverses tâches. Personnalise-la en redéfinissant 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 redéfinissant ces fonctions :

  • get_model(cfg, weights) : construit le modèle à entraîner.
  • get_dataloader(dataset_path, batch_size, rank, mode) : construit le chargeur de données.

Pour plus de détails et le code source, consulte la référence BaseTrainer.

DetectionTrainer#

Voici comment utiliser et personnaliser DetectionTrainer d’Ultralytics YOLO :

from ultralytics.models.yolo.detect import DetectionTrainer

trainer = DetectionTrainer(overrides={...})
trainer.train()
trained_model = trainer.best  # Obtenir le meilleur modèle

Personnaliser DetectionTrainer#

Pour entraîner un modèle de détection personnalisé qui n’est pas directement pris en charge, surcharge les fonctionnalités existantes 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 le trainer en modifiant la fonction de perte ou en ajoutant un callback exécuté à la fin de chaque epoch, par exemple pour enregistrer ou téléverser les derniers poids. Voici un exemple :

from ultralytics.models.yolo.detect import DetectionTrainer
from ultralytics.nn.tasks import DetectionModel

class MyCustomModel(DetectionModel):
    def init_criterion(self):
        """Initializes a custom loss function for the model."""

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 pour enregistrer les poids du modèle
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)  # S’ajoute aux callbacks existants
trainer.train()

Pour en savoir plus sur les événements qui déclenchent les callbacks et leurs points d’entrée, consulte le guide des callbacks.

Autres composants du moteur#

Personnalise de la même manière d’autres composants comme Validators et Predictors. Pour en savoir plus, consulte la documentation des validateurs et des prédicteurs.

Utiliser YOLO avec des trainers personnalisés#

La classe de modèle YOLO fournit une enveloppe de haut niveau pour les classes Trainer. Tu peux tirer parti de cette architecture pour gagner en flexibilité dans tes workflows de machine learning :

from ultralytics import YOLO
from ultralytics.models.yolo.detect import DetectionTrainer

# Créer un trainer personnalisé
class MyCustomTrainer(DetectionTrainer):
    def get_model(self, cfg=None, weights=None, verbose=True):
        """Custom code implementation."""

# Initialiser le modèle YOLO
model = YOLO("yolo26n.pt")

# Entraîner avec un trainer personnalisé
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 selon tes besoins spécifiques.

FAQ#

  • Personnalise DetectionTrainer pour des tâches spécifiques en redéfinissant ses méthodes afin de l’adapter à ton modèle et à ton chargeur de données 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  # Obtenir le meilleur modèle

    Pour personnaliser davantage le système, par exemple en modifiant la fonction de perte ou en ajoutant un callback, consulte le guide des callbacks.

  • BaseTrainer est la base des routines d’entraînement et peut être personnalisé pour diverses tâches en redéfinissant ses méthodes génériques. Parmi ses principaux composants figurent :

    • get_model(cfg, weights) : construit le modèle à entraîner.
    • get_dataloader(dataset_path, batch_size, rank, mode) : 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 à partir 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.

  • Ajoute des callbacks pour surveiller et modifier le processus d’entraînement dans DetectionTrainer. Voici comment ajouter un callback qui enregistre les poids du modèle après chaque epoch d’entraînement :

    from ultralytics.models.yolo.detect import DetectionTrainer

# Callback pour enregistrer les poids du modèle
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)  # S’ajoute aux callbacks existants
trainer.train()

    Pour en savoir plus sur les événements des callbacks et leurs points d’entrée, consulte le guide des callbacks.

  • Ultralytics YOLO fournit une abstraction de haut niveau reposant sur de puissants moteurs d’exécution, ce qui en fait une solution idéale pour le développement rapide et la personnalisation. Ses principaux avantages sont les suivants :

    • 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 d’IA pour la vision.
    • Personnalisation : facile à étendre pour les modèles personnalisés, les fonctions de perte et les chargeurs de données.
    • Modularité : tu peux modifier les composants indépendamment sans affecter l’ensemble du pipeline.
    • Intégration : fonctionne parfaitement avec les frameworks et outils courants de l’écosystème ML.

    Découvre les capacités de YOLO en explorant la page principale Ultralytics YOLO.

  • Oui, DetectionTrainer est très flexible et personnalisable pour les modèles non standard. Hérite de DetectionTrainer et surcharge des 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 obtenir des instructions et des exemples détaillés, consulte la référence DetectionTrainer.

Contributeurs
GLglenn-jocher14RAraimbekovm2RIRizwanMunawar2

Commentaires