Personnalisation avancée

Les interfaces Ultralytics YOLO (ligne de commande) et Python sont simplement une abstraction de haut niveau des exécuteurs du moteur de base. Examinons le moteur Trainer.

Regarder : Mastering Ultralytics YOLO : 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, à condition que les formats corrects soient respectés. Par exemple, vous pouvez prendre en charge votre propre modèle personnalisé et votre propre chargeur de données en surchargeant 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 dans BaseTrainer Référence

Formateur en détection

Voici comment vous pouvez utiliser le YOLO11 DetectionTrainer et la personnaliser.

from ultralytics.models.yolo.detect import DetectionTrainer

trainer = DetectionTrainer(overrides={...})
trainer.train()
trained_model = trainer.best  # get best model

Personnalisation du DetectionTrainer

Personnalisons le formateur pour former un modèle de détection personnalisé qui n'est pas prise en charge directement. Pour ce faire, il suffit de surcharger 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()

Vous vous rendez compte que vous devez personnaliser davantage le formateur :

• Personnaliser le loss function.
• Ajouter callback qui télécharge le modèle sur votre disque Google tous les 10 epochs Voici comment procéder :

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 callbacks, consultez notre guide sur les callbacks.

Autres composants du moteur

Il existe d'autres composants qui peuvent être personnalisés de la même manière, tels que Validators et Predictors. Voir la section Référence pour plus d'informations à ce sujet.

FAQ

Comment puis-je personnaliser le Ultralytics YOLO11 DetectionTrainer pour des tâches spécifiques ?

Pour personnaliser le Ultralytics YOLO11 DetectionTrainer pour une tâche spécifique, vous pouvez surcharger ses méthodes pour les adapter à votre modèle personnalisé et à votre chargeur de données. Commencez par hériter de DetectionTrainer puis redéfinir des méthodes comme get_model pour mettre en œuvre vos 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 du loss function ou l'ajout d'un callbackvous pouvez vous référer à notre Guide des rappels.

Quels sont les éléments clés du BaseTrainer dans Ultralytics YOLO11 ?

Le BaseTrainer dans Ultralytics YOLO11 sert de base aux routines de formation 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 dataloader.

Pour plus de détails sur la personnalisation et le code source, voir le document BaseTrainer Référence.

Comment puis-je ajouter un rappel au Ultralytics YOLO11 DetectionTrainer ?

Vous pouvez ajouter des rappels pour surveiller et modifier le processus de formation en Ultralytics YOLO11 DetectionTrainer. Par exemple, voici comment vous pouvez ajouter un rappel pour enregistrer les poids du modèle après chaque entraînement époque:

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, consultez notre guide sur les rappels.

Pourquoi utiliser Ultralytics YOLO11 pour l'apprentissage des modèles ?

Ultralytics YOLO11 offre une abstraction de haut niveau sur des exécuteurs de moteur puissants, ce qui en fait un outil 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 de vision artificielle.
• 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 YOLO11, consultez le site suivant Ultralytics YOLO.

Puis-je utiliser le Ultralytics YOLO11 DetectionTrainer pour des modèles non standard ?

Oui, Ultralytics YOLO11 DetectionTrainer est très flexible et peut être adapté à des modèles non standard. En héritant de DetectionTrainervous pouvez surcharger différentes méthodes pour répondre aux besoins de votre 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, consultez la documentation de DetectionTrainer.

📅C réé il y a 1 an ✏️ Mis à jour il y a 2 mois

Commentaires