Empezar

Personalización avanzada

Tanto la interfaz de línea de comandos como la de Python de Ultralytics YOLO son abstracciones de alto nivel basadas en ejecutores del motor base. Esta guía se centra en el motor Trainer y explica cómo personalizarlo según tus necesidades.



Ver: Domina Ultralytics YOLO: personalización avanzada
Consejo

Para ver ejemplos prácticos de personalizaciones habituales del entrenador —métricas personalizadas, pérdida ponderada por clase, guardado de modelos, congelación del backbone y tasas de aprendizaje por capa—, consulta la guía Personalización del entrenador.

BaseTrainer#

La clase BaseTrainer proporciona una rutina de entrenamiento genérica que se adapta a distintas tareas. Personalízala sobrescribiendo funciones u operaciones específicas y respetando los formatos requeridos. Por ejemplo, integra tu propio modelo y cargador de datos sobrescribiendo estas funciones:

  • get_model(cfg, weights): crea el modelo que se va a entrenar.
  • get_dataloader(dataset_path, batch_size, rank, mode): crea el cargador de datos.

Para obtener más información y consultar el código fuente, visita la referencia de BaseTrainer.

DetectionTrainer#

Así se usa y personaliza DetectionTrainer de Ultralytics YOLO:

from ultralytics.models.yolo.detect import DetectionTrainer

trainer = DetectionTrainer(overrides={...})
trainer.train()
trained_model = trainer.best  # Obtén el mejor modelo

Personalización de DetectionTrainer#

Para entrenar un modelo de detección personalizado que no sea compatible directamente, amplía la funcionalidad 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 aún más el entrenador modificando la función de pérdida o añadiendo una devolución de llamada que se ejecute al final de cada época, por ejemplo, para registrar o subir los pesos más recientes. Aquí tienes un ejemplo:

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

# Devolución de llamada para registrar los pesos del 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)  # Se añade a las devoluciones de llamada existentes
trainer.train()

Para obtener más información sobre los eventos que activan las devoluciones de llamada y sus puntos de entrada, consulta la guía de devoluciones de llamada.

Otros componentes del motor#

Personaliza otros componentes, como Validators y Predictors, de forma similar. Para obtener más información, consulta la documentación de validadores y predictores.

Uso de YOLO con entrenadores personalizados#

La clase de modelo YOLO proporciona una envoltura de alto nivel para las clases Trainer. Puedes aprovechar esta arquitectura para lograr una mayor flexibilidad en tus flujos de trabajo de aprendizaje automático:

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

# Crea un entrenador personalizado
class MyCustomTrainer(DetectionTrainer):
    def get_model(self, cfg=None, weights=None, verbose=True):
        """Custom code implementation."""

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

# Entrena con un entrenador personalizado
results = model.train(trainer=MyCustomTrainer, data="coco8.yaml", epochs=3)

Este enfoque te permite mantener la sencillez de la interfaz de YOLO y, al mismo tiempo, personalizar el proceso de entrenamiento subyacente según tus necesidades específicas.

Preguntas frecuentes#

  • Personaliza DetectionTrainer para tareas específicas sobrescribiendo sus métodos y adaptándolos a tu modelo y cargador de datos personalizados. Empieza heredando de DetectionTrainer y redefiniendo métodos como get_model para implementar funcionalidades personalizadas. Aquí tienes un ejemplo:

    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én el mejor modelo
  • BaseTrainer es la base de las rutinas de entrenamiento y se puede personalizar para distintas tareas sobrescribiendo sus métodos genéricos. Entre sus componentes principales se incluyen:

    • get_model(cfg, weights): crea el modelo que se va a entrenar.
    • get_dataloader(dataset_path, batch_size, rank, mode): crea el cargador de datos.
    • preprocess_batch(): gestiona el preprocesamiento de lotes antes de la pasada hacia delante del modelo.
    • set_model_attributes(): establece los atributos del modelo según la información del conjunto de datos.
    • get_validator(): devuelve un validador para evaluar el modelo.

    Para obtener más información sobre la personalización y consultar el código fuente, visita la referencia de BaseTrainer.

  • Añade retrollamadas para supervisar y modificar el proceso de entrenamiento en DetectionTrainer. A continuación se explica cómo añadir una retrollamada que registre los pesos del modelo después de cada época de entrenamiento:

    from ultralytics.models.yolo.detect import DetectionTrainer
    
    # Devolución de llamada para registrar los pesos del 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)  # Se añade a las devoluciones de llamada existentes
    trainer.train()

    Para obtener más información sobre los eventos y puntos de entrada de las devoluciones de llamada, consulta la guía de devoluciones de llamada.

  • Ultralytics YOLO ofrece una abstracción de alto nivel sobre sus ejecutores del motor, por lo que resulta muy adecuado para el desarrollo rápido y la personalización. Entre sus ventajas principales se incluyen:

    • Facilidad de uso: las interfaces de línea de comandos y Python simplifican las tareas complejas.
    • Rendimiento: optimizado para la detección de objetos en tiempo real y distintas aplicaciones de IA visual.
    • Personalización: Ampliable con modelos, funciones de pérdida y cargadores de datos personalizados.
    • Modularidad: puedes modificar los componentes de forma independiente sin afectar a todo el flujo de procesamiento.
    • Integración: Funciona con marcos y herramientas populares del ecosistema de ML.

    Descubre más sobre las capacidades de YOLO en la página principal de Ultralytics YOLO.

  • Sí, puedes personalizar DetectionTrainer para modelos no estándar. Hereda de DetectionTrainer y sobrescribe métodos para adaptarlo a las necesidades específicas de tu modelo. Aquí tienes un ejemplo sencillo:

    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 consultar instrucciones y ejemplos detallados, revisa la referencia de DetectionTrainer.

Comentarios10

Haz una pregunta, comparte tus resultados o ayuda a otra persona.

  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.

  2. ternausGitHub

    Is it possible to define custom DataLoader or Augmentation pipeline in DetectionTrainer?

    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
  3. 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!