Personalización avanzada

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

BaseTrainer

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

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

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

DetectionTrainer

Aquí tienes cómo usar y personalizar 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 no soportado directamente, sobrecarga la funcionalidad get_model existente:

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

Personaliza aún más el entrenador modificando la función de pérdida o añadiendo un callback para subir el modelo a Google Drive cada 10 épocas. 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, 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 callbacks
trainer.train()

Para más información sobre eventos de activación de callbacks y puntos de entrada, consulta la Guía de Callbacks.

Otros componentes del motor

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

Uso de YOLO con entrenadores personalizados

La clase de modelo YOLO proporciona un envoltorio de alto nivel para las clases Trainer. Puedes aprovechar esta arquitectura para 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, weights):
        """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 YOLO mientras personalizas el proceso de entrenamiento subyacente para ajustarlo a tus requisitos específicos.

Preguntas frecuentes

¿Cómo personalizo el DetectionTrainer de Ultralytics YOLO para tareas específicas?

Personaliza el DetectionTrainer para tareas específicas sobrescribiendo sus métodos para adaptarlo a tu modelo y dataloader personalizados. Empieza heredando de DetectionTrainer y redefine 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, weights):
        """Loads a custom detection model given configuration and weight files."""
        ...

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

Para una mayor personalización, como cambiar la función de pérdida o añadir un callback, consulta la Guía de Callbacks.

¿Cuáles son los componentes clave del BaseTrainer en Ultralytics YOLO?

El BaseTrainer sirve como base para las rutinas de entrenamiento, personalizable para varias tareas sobrescribiendo 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 dataloader.
• preprocess_batch(): Maneja el preprocesamiento de lotes antes del paso hacia adelante del modelo.
• set_model_attributes(): Establece los atributos del modelo basados en la información del conjunto de datos.
• get_validator(): Devuelve un validador para la evaluación del modelo.

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

¿Cómo puedo añadir un callback al DetectionTrainer de Ultralytics YOLO?

Añade callbacks para monitorear y modificar el proceso de entrenamiento en DetectionTrainer. Aquí tienes cómo añadir un callback para registrar los pesos del modelo después de cada época 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 eventos de callback y puntos de entrada, consulta la Guía de Callbacks.

¿Por qué debería usar Ultralytics YOLO para el entrenamiento de modelos?

Ultralytics YOLO proporciona una abstracción de alto nivel sobre potentes ejecutores de motor, 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 tareas complejas.
• Rendimiento: Optimizado para la detección de objetos en tiempo real y varias aplicaciones de visión artificial.
• Personalización: Fácilmente extensible para modelos personalizados, funciones de pérdida y dataloaders.
• Modularidad: Los componentes pueden modificarse de forma independiente sin afectar a toda la tubería.
• Integración: Funciona a la perfección con marcos y herramientas populares en el ecosistema de ML.

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

¿Puedo usar el DetectionTrainer de Ultralytics YOLO para modelos no estándar?

Sí, el DetectionTrainer es altamente flexible y personalizable para modelos no estándar. Hereda de DetectionTrainer y sobrecarga los métodos para soportar las necesidades de tu modelo específico. Aquí tienes un ejemplo 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()

Para instrucciones completas y ejemplos, revisa la Referencia de DetectionTrainer.