Personnalisation avancée
Les interfaces en ligne de commande et Python d’Ultralytics YOLO sont toutes deux des abstractions de haut niveau construites sur des exécuteurs du moteur de base. Ce guide porte sur le moteur Trainer et explique comment le personnaliser selon tes besoins.
Regarder : Maîtriser Ultralytics YOLO : personnalisation avancée
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èlePersonnaliser 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
DetectionTrainerpour 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 deDetectionTraineret redéfinis des méthodes commeget_modelpour 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èleBaseTrainerest 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 journalise les poids du modèle après chaque époque 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 offre une abstraction de haut niveau de ses exécuteurs du moteur, ce qui le rend parfaitement adapté au 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 : possibilité d’étendre le système avec des modèles, des fonctions de perte et des chargeurs de données personnalisés.
- Modularité : tu peux modifier les composants indépendamment sans affecter l’ensemble du pipeline.
- Intégration : fonctionne avec les frameworks et outils populaires de l’écosystème ML.
Découvre les capacités de YOLO en explorant la page principale Ultralytics YOLO.
Oui, le
DetectionTrainerpeut être personnalisé pour les modèles non standard. Hérite deDetectionTraineret 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 obtenir des instructions et des exemples détaillés, consulte la référence
DetectionTrainer.
Commentaires10
Pose une question, partage tes résultats ou aide quelqu’un d’autre.
UltralyticsAssistantUltralytics
👋 Hello, thank you for your interest in Ultralytics 🚀! We recommend visiting the Docs for new users, where you can explore numerous Python and CLI usage examples. Many common questions may already be answered there, including step-by-step guides tailored for different tasks.
If this is a 🐛 Bug Report, please provide a minimum reproducible example to help us debug the issue.
If you have a custom training ❓ Question, please include as much information as possible, such as dataset image samples and training logs, and make sure you are following our Tips for Best Training Results.
Join the Ultralytics community where it suits you best! For real-time chat, head to Discord 🎧. Prefer in-depth discussions? Check out Discourse. Or explore threads on our Subreddit and connect with other users.
Upgrade
Upgrade to the latest
ultralyticspackage, including all requirements, in a Python>=3.8 environment with PyTorch>=1.8 to ensure your issue is not already resolved:pip install -U ultralyticsEnvironments
YOLO can be run in any of the following up-to-date verified environments (with all dependencies, including CUDA/CUDNN, Python, and PyTorch preinstalled):
- Notebooks with free GPU:
- Google Cloud Deep Learning VM. See GCP Quickstart Guide
- Amazon Deep Learning AMI. See AWS Quickstart Guide
- Docker Image. See Docker Quickstart Guide
Status
If this badge is green, all Ultralytics CI tests are currently passing. CI tests verify correct operation of all YOLO Modes and Tasks on macOS, Windows, and Ubuntu every 24 hours and on every commit.
This is an automated response 🤖. An Ultralytics engineer will also assist you soon!
- Notebooks with free GPU:
ablyzniuk
How to set a custom loss function?
ablyzniuk
Sorry, I missed it above. I saw it))) Delete this comment.
Glenn JocherUltralytics@ablyzniuk to set a custom loss function, you can override the
init_criterionmethod in your custom model class, as shown in the Advanced Customization documentation. This method allows you to define and initialize your loss function according to your requirements. Let me know if you need an example!ablyzniuk
@glen-jocher thank you) I will be glad and thankfull if you will give a detailed example of training default Ultralytics Yolo(5-11 versions) with custom trainer e.t.c. I think there must be much easier and convinient way opposite what I did (I edited source code and overrides DetectionTrainer methods after)
Glenn JocherUltralytics(modifié)For custom training without modifying source code, subclass
DetectionTrainerand override methods like this:from ultralytics.models.yolo.detect import DetectionTrainer from ultralytics.nn.tasks import DetectionModel class CustomModel(DetectionModel): def init_criterion(self): # Your custom loss initialization here pass class CustomTrainer(DetectionTrainer): def get_model(self, cfg=None, weights=None, verbose=True): return CustomModel(cfg, nc=self.data["nc"], verbose=verbose) # Replace with your model config trainer = CustomTrainer(overrides={'model': 'yolo26n.yaml', 'data': 'coco128.yaml', 'epochs': 100}) trainer.train()This maintains upgrade compatibility while allowing customization. The Advanced Customization Guide shows additional methods you can override.
ternaus
Is it possible to define custom DataLoader or Augmentation pipeline in DetectionTrainer?
Paula DerrengerUltralyticsYes, it's definitely possible to define custom DataLoader and Augmentation pipelines in DetectionTrainer! 🚀 To do so, you'd primarily override the
get_dataloader()method in a subclass ofDetectionTrainer. Here's a brief example on how you might go about customizing your DataLoader:from ultralytics.models.yolo.detect import DetectionTrainer class CustomTrainer(DetectionTrainer): def get_dataloader(self, ...): # Your custom DataLoader logic here ...For augmentations, you can integrate them within your custom DataLoader or modify datasets accordingly. If you need further customization or to include a custom Augmentation pipeline directly tied with the models' training loop, you could adjust or extend methods in the model itself or within the
get_dataloadermethod to apply augmentations.Don't forget to explore our Advanced Customization section and BaseTrainer Reference for more details on customizing training routines, models, and DataLoaders. 😄 Happy coding!
1
UttamToni
As mentioned in the advanced customization of ultralytics:
from ultralytics.models.yolo.detect import DetectionTrainer trainer = DetectionTrainer(overrides={...})
i am confuced that which file should i place in the curly brackets of
overrides={...}. Is theargs.yamlfile is allowed , which is created after the training step? I have used the args.yaml file which is created after training step but got this error:/usr/local/lib/python3.10/dist-packages/ultralytics/engine/trainer.py in __init__(self, cfg, overrides, _callbacks) 96 overrides (dict, optional): Configuration overrides. Defaults to None. 97 """ ---> 98 self.args = get_cfg(cfg, overrides) 99 self.check_resume(overrides) 100 self.device = select_device(self.args.device, self.args.batch) /usr/local/lib/python3.10/dist-packages/ultralytics/cfg/__init__.py in get_cfg(cfg, overrides) 207 overrides = cfg2dict(overrides) 208 if "save_dir" not in cfg: --> 209 overrides.pop("save_dir", None) # special override keys to ignore 210 check_dict_alignment(cfg, overrides) 211 cfg = {**cfg, **overrides} # merge cfg and overrides dicts (prefer overrides) TypeError: set.pop() takes no arguments (2 given)
Glenn JocherUltralytics(modifié)Hello! It seems like there’s been a little confusion regarding the
overrides={...}usage, and I appreciate you reaching out for clarification. 🙌To directly answer your question, the
overrides={...}parameter is designed to accept a dictionary of configuration overrides, not a file. It's intended to programmatically override specific configuration entries. For example:from ultralytics.models.yolo.detect import DetectionTrainer # Example override dictionary overrides = { "batch": 16, "imgsz": 640, } trainer = DetectionTrainer(overrides=overrides)If you're looking to use the configurations from an
args.yamlfile created after training, you'd first need to read this YAML file into a Python dictionary, which you could then pass tooverrides. Here's a quick way to do it:import yaml # Load your args.yaml content into a dictionary with open('path/to/your/args.yaml', 'r') as file: yaml_content = yaml.safe_load(file) # Now, pass the loaded dictionary to overrides trainer = DetectionTrainer(overrides=yaml_content)Regarding the error you're encountering, it appears there's a misunderstanding in how the
overridesdictionary is being used or possibly an issue with the implementation. If following the above pattern doesn't resolve your issue, could you please share more details about what you're trying to achieve with theoverrides? This way, I or someone from the community can offer more targeted advice. 😊Thank you for your patience, and looking forward to helping you get this sorted!