YOLO Vision 2026:

Personalización avanzada#

Tanto la interfaz de comandos como la de Python de Ultralytics YOLO son abstracciones de alto nivel construidas sobre ejecutores de motores base. Esta guía se centra en el motor Trainer, explicando cómo personalizarlo para tus necesidades específicas.



Watch: Mastering Ultralytics YOLO: Advanced Customization
Consejo

Para ver ejemplos prácticos de personalizaciones comunes de entrenadores —métricas personalizadas, pérdida ponderada por clases, guardado de modelos, congelación de capas base y tasas de aprendizaje por capa—, consulta la guía de Customizing Trainer.

BaseTrainer#

La clase BaseTrainer proporciona una rutina de entrenamiento genérica adaptable a varias tareas. Personalízala sobrescribiendo funciones u operaciones específicas mientras cumples con los formatos requeridos. Por ejemplo, integra tu propio modelo y cargador de datos personalizados sobrescribiendo estas funciones:

  • get_model(cfg, weights): Construye el modelo que se va a entrenar.
  • get_dataloader(): Construye el cargador de datos.

Para más detalles y código fuente, consulta la BaseTrainer Reference.

DetectionTrainer#

Así es como se usa y personaliza el DetectionTrainer de Ultralytics YOLO:

from ultralytics.models.yolo.detect import DetectionTrainer

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

Personalización del DetectionTrainer#

Para entrenar un modelo de detección personalizado que no esté directamente soportado, sobrecarga 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 loss function o añadiendo un callback para subir el modelo a Google Drive cada 10 epochs. 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 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=None, weights=None, verbose=True):
        """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 callbacks
trainer.train()

Para más información sobre los eventos de activación de devoluciones de llamada y puntos de entrada, consulta la Callbacks Guide.

Otros componentes del motor#

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

Uso de YOLO con entrenadores personalizados#

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

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

# Create a custom trainer
class MyCustomTrainer(DetectionTrainer):
    def get_model(self, cfg=None, weights=None, verbose=True):
        """Custom code implementation."""

# Initialize YOLO model
model = YOLO("yolo26n.pt")

# Train with custom trainer
results = model.train(trainer=MyCustomTrainer, data="coco8.yaml", epochs=3)

Este enfoque te permite mantener la simplicidad de la interfaz de YOLO mientras personalizas el proceso de entrenamiento subyacente para adaptarlo a tus requisitos específicos.

FAQ#

  • Personaliza el DetectionTrainer para tareas específicas sobrescribiendo sus métodos para adaptarlos 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  # Get the best model

    Para mayor personalización, como cambiar la loss function o añadir un callback, consulta la Callbacks Guide.

  • El BaseTrainer sirve como base para las rutinas de entrenamiento, personalizable para varias tareas mediante la sobrescritura de sus métodos genéricos. Los componentes clave incluyen:

    • get_model(cfg, weights): Construye el modelo que se va a entrenar.
    • get_dataloader(): Construye el cargador de datos.
    • preprocess_batch(): Gestiona el preprocesamiento de lotes antes de la pasada hacia adelante del modelo.
    • set_model_attributes(): Establece los atributos del modelo basándose en la información del conjunto de datos.
    • get_validator(): Devuelve un validador para la evaluación del modelo.

    Para más detalles sobre la personalización y el código fuente, consulta la BaseTrainer Reference.

  • Añade devoluciones de llamada para monitorizar y modificar el proceso de entrenamiento en DetectionTrainer. Así es como se añade un callback para registrar los pesos del modelo después de cada epoch de entrenamiento:

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

    Para más detalles sobre los eventos de devolución de llamada y los puntos de entrada, consulta la Callbacks Guide.

  • Ultralytics YOLO proporciona una abstracción de alto nivel sobre potentes ejecutores de motores, lo que lo hace ideal para el desarrollo rápido y la personalización. Los beneficios clave incluyen:

    • Facilidad de uso: Tanto la interfaz de línea de comandos como la de Python simplifican las tareas complejas.
    • Rendimiento: Optimizado para object detection en tiempo real y diversas aplicaciones de visión por IA.
    • Personalización: Fácilmente ampliable para modelos personalizados, loss functions y cargadores de datos.
    • Modularidad: Los componentes se pueden modificar de forma independiente sin afectar a todo el pipeline.
    • Integración: Funciona perfectamente con frameworks y herramientas populares del ecosistema de ML.

    Aprende más sobre las capacidades de YOLO explorando la página principal de Ultralytics YOLO.

  • Sí, el DetectionTrainer es altamente flexible y personalizable para modelos no estándar. Hereda de DetectionTrainer y sobrecarga los métodos para admitir 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 instrucciones completas y ejemplos, revisa la DetectionTrainer Reference.

Colaboradores
GLglenn-jocher13RAraimbekovm2RIRizwanMunawar2

Comentarios