Skip to content

Personnalisation avancée

Les interfaces Ultralytics YOLO en ligne de commande et Python sont simplement une abstraction de haut niveau sur les exécuteurs du moteur de base. Jetons un coup d'œil au moteur Trainer.



Regarde : Mastering Ultralytics YOLO: Advanced Customization

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, tant que les formats corrects sont respectés. Par exemple, tu peux prendre en charge ton propre modèle et ton propre chargeur de données en remplaçant 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

Here's how you can use the YOLO11 DetectionTrainer et de la personnaliser.

from ultralytics.models.yolo.detect import DetectionTrainer

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

Personnaliser le DetectionTrainer

Personnalisons le formateur pour former un modèle de détection personnalisé qui n'est pas pris en charge directement. Tu peux le faire en surchargeant simplement 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()

Tu réalises maintenant que tu dois personnaliser davantage le formateur pour :

  • Personnalise le loss function.
  • Ajouter callback qui télécharge le modèle sur ton disque Google tous les 10 ans. epochs Voici comment tu peux le faire :
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 rappels, consulte notre guide sur les rappels.

Autres composants du moteur

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

FAQ

How do I customize the Ultralytics YOLO11 DetectionTrainer for specific tasks?

To customize the Ultralytics YOLO11 DetectionTrainer pour une tâche spécifique, tu peux surcharger ses méthodes pour les adapter à ton modèle personnalisé et à ton chargeur de données. Commence par hériter de DetectionTrainer puis redéfinir des méthodes comme get_model pour mettre en œuvre tes 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 de la loss function ou l'ajout d'un callbacktu peux te référer à notre Guide des rappels.

What are the key components of the BaseTrainer in Ultralytics YOLO11?

Le BaseTrainer in Ultralytics YOLO11 serves as the foundation for training routines and can be customized for various tasks by overriding its generic methods. Key components include:

  • get_model(cfg, weights) pour construire le modèle à former.
  • get_dataloader() pour construire le chargeur de données.

Pour plus de détails sur la personnalisation et le code source, consulte le site de l'association. BaseTrainer Référence.

How can I add a callback to the Ultralytics YOLO11 DetectionTrainer?

You can add callbacks to monitor and modify the training process in Ultralytics YOLO11 DetectionTrainer. For instance, here's how you can add a callback to log model weights after every training epoch:

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, reporte-toi à notre guide sur les rappels.

Why should I use Ultralytics YOLO11 for model training?

Ultralytics YOLO11 offers a high-level abstraction on powerful engine executors, making it ideal for rapid development and customization. Key benefits include:

  • Facilité d'utilisation: les interfaces en ligne de commande et Python simplifient les tâches complexes.
  • Performance: Optimized for real-time object detection and various vision AI applications.
  • Customization: Easily extendable for custom models, loss functions, and dataloaders.

Learn more about YOLO11's capabilities by visiting Ultralytics YOLO.

Can I use the Ultralytics YOLO11 DetectionTrainer for non-standard models?

Yes, Ultralytics YOLO11 DetectionTrainer est très flexible et peut être personnalisé pour des modèles non standard. En héritant de DetectionTrainerTu peux surcharger différentes 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, weights):
        """Loads a custom detection model."""
        ...


trainer = CustomDetectionTrainer(overrides={...})
trainer.train()

Pour des instructions et des exemples plus complets, consulte la documentation de DetectionTrainer.

📅 Created 1 year ago ✏️ Updated 1 month ago

Commentaires