Começar

Personalização avançada

Tanto a interface de linha de comando quanto a de Python do Ultralytics YOLO são abstrações de alto nível criadas sobre executores do mecanismo base. Este guia se concentra no mecanismo Trainer e explica como personalizá-lo para suas necessidades específicas.



Assista: Domine o Ultralytics YOLO: personalização avançada
Dica

Para exemplos práticos de personalizações comuns do treinador — métricas personalizadas, função de perda ponderada por classe, gravação do modelo, congelamento do backbone e taxas de aprendizado por camada — consulta o guia Personalizar o treinador.

BaseTrainer#

A classe BaseTrainer fornece uma rotina de treino genérica, adaptável a várias tarefas. Personaliza-a substituindo funções ou operações específicas e respeitando os formatos necessários. Por exemplo, integra o teu próprio modelo personalizado e carregador de dados substituindo estas funções:

  • get_model(cfg, weights): cria o modelo a treinar.
  • get_dataloader(dataset_path, batch_size, rank, mode): cria o carregador de dados.

Para mais detalhes e o código-fonte, consulta a referência de BaseTrainer.

DetectionTrainer#

Eis como usar e personalizar o DetectionTrainer do Ultralytics YOLO:

from ultralytics.models.yolo.detect import DetectionTrainer

trainer = DetectionTrainer(overrides={...})
trainer.train()
trained_model = trainer.best  # Obtém o melhor modelo

Personalizar o DetectionTrainer#

Para treinar um modelo de deteção personalizado que não seja compatível diretamente, sobrecarrega a funcionalidade existente 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()

Personaliza ainda mais o treinador modificando a função de perda ou adicionando um callback executado no fim de cada época, por exemplo, para registar ou carregar os pesos mais recentes. Aqui está um exemplo:

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 para registar os pesos do modelo
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)  # Adiciona aos callbacks existentes
trainer.train()

Para mais informações sobre eventos de acionamento de callbacks e pontos de entrada, consulta o Guia de callbacks.

Outros componentes do motor#

Personaliza outros componentes, como Validators e Predictors, da mesma forma. Para mais informações, consulta a documentação de Validadores e Preditores.

Usar YOLO com treinadores personalizados#

A classe de modelo YOLO fornece um wrapper de alto nível para classes de treinador. Podes tirar partido desta arquitetura para teres mais flexibilidade nos teus fluxos de trabalho de aprendizado de máquina:

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

# Cria um treinador personalizado
class MyCustomTrainer(DetectionTrainer):
    def get_model(self, cfg=None, weights=None, verbose=True):
        """Custom code implementation."""

# Inicializa o modelo YOLO
model = YOLO("yolo26n.pt")

# Treina com um treinador personalizado
results = model.train(trainer=MyCustomTrainer, data="coco8.yaml", epochs=3)

Esta abordagem permite-te manter a simplicidade da interface YOLO e, ao mesmo tempo, personalizar o processo de treino subjacente de acordo com os teus requisitos específicos.

Perguntas frequentes#

  • Personaliza o DetectionTrainer para tarefas específicas substituindo os seus métodos para adaptar o modelo e o carregador de dados personalizados. Começa por herdar de DetectionTrainer e redefinir métodos como get_model para implementar funcionalidades personalizadas. Aqui está um exemplo:

    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  # Obtém o melhor modelo
  • O BaseTrainer é a base das rotinas de treino e pode ser personalizado para várias tarefas através da substituição dos seus métodos genéricos. Os principais componentes incluem:

    • get_model(cfg, weights): cria o modelo a treinar.
    • get_dataloader(dataset_path, batch_size, rank, mode): cria o carregador de dados.
    • preprocess_batch(): processa previamente os lotes antes da passagem forward do modelo.
    • set_model_attributes(): define os atributos do modelo com base nas informações do conjunto de dados.
    • get_validator(): devolve um validador para a avaliação do modelo.

    Para mais detalhes sobre personalização e código-fonte, consulta a referência de BaseTrainer.

  • Adicione callbacks para monitorar e modificar o processo de treinamento em DetectionTrainer. Veja como adicionar um callback para registrar os pesos do modelo após cada época de treinamento:

    from ultralytics.models.yolo.detect import DetectionTrainer
    
    # Callback para registar os pesos do modelo
    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)  # Adiciona aos callbacks existentes
    trainer.train()

    Para mais detalhes sobre eventos de callbacks e pontos de entrada, consulta o Guia de callbacks.

  • Ultralytics YOLO oferece uma abstração de alto nível sobre seus executores do mecanismo, sendo ideal para desenvolvimento e personalização rápidos. Entre os principais benefícios estão:

    • Facilidade de uso: as interfaces de linha de comandos e Python simplificam tarefas complexas.
    • Desempenho: otimizado para deteção de objetos em tempo real e várias aplicações de IA para visão.
    • Personalização: pode ser ampliado com modelos, funções de perda e carregadores de dados personalizados.
    • Modularidade: os componentes podem ser modificados de forma independente sem afetar todo o pipeline.
    • Integração: funciona com frameworks e ferramentas populares do ecossistema de ML.

    Descobre mais sobre as capacidades do YOLO na página principal do Ultralytics YOLO.

  • Sim, DetectionTrainer pode ser personalizado para modelos não convencionais. Herde de DetectionTrainer e sobrescreva métodos para atender às necessidades específicas do seu modelo. Veja um exemplo simples:

    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()

    Para instruções e exemplos completos, consulta a referência de DetectionTrainer.

Comentários10

Faz uma pergunta, partilha os teus resultados ou ajuda alguém.

  1. UltralyticsAssistantGitHubUltralytics

    👋 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 ultralytics package, including all requirements, in a Python>=3.8 environment with PyTorch>=1.8 to ensure your issue is not already resolved:

    pip install -U ultralytics

    Environments

    YOLO can be run in any of the following up-to-date verified environments (with all dependencies, including CUDA/CUDNN, Python, and PyTorch preinstalled):

    Status

    Ultralytics CI

    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!

    1. Glenn JocherUltralytics

      @ablyzniuk to set a custom loss function, you can override the init_criterion method 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!

    2. ablyzniukGitHub

      @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)

    3. Glenn JocherUltralytics(editado)

      For custom training without modifying source code, subclass DetectionTrainer and 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.

    1. Paula DerrengerUltralytics

      Yes, 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 of DetectionTrainer. 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_dataloader method 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
  2. UttamToniGitHub

    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 the args.yaml file 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)
    
    1. Glenn JocherUltralytics(editado)

      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.yaml file created after training, you'd first need to read this YAML file into a Python dictionary, which you could then pass to overrides. 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 overrides dictionary 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 the overrides? 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!