Link to this sectionPersonalización avanzada#

Tanto la interfaz de línea de comandos de Ultralytics YOLO como la de Python 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.

Link to this sectionBaseTrainer#

La clase BaseTrainer proporciona una rutina de entrenamiento genérica adaptable para diversas tareas. Personalízala sobrescribiendo funciones u operaciones específicas mientras cumples con 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.

Link to this sectionDetectionTrainer#

Así es como puedes 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

Link to this sectionPersonalización del DetectionTrainer#

Para entrenar un modelo de detección personalizado que no esté soportado directamente, sobrecarga la funcionalidad existente 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 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=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 eventos de activación de callbacks y puntos de entrada, consulta la Guía de Callbacks.

Link to this sectionOtros 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.

Link to this sectionUso de YOLO con entrenadores personalizados#

La clase del modelo YOLO proporciona un envoltorio de alto nivel para las clases de entrenador. 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 YOLO mientras personalizas el proceso de entrenamiento subyacente para adaptarlo a tus necesidades específicas.

Link to this sectionPreguntas frecuentes#

Link to this section¿Cómo personalizo el DetectionTrainer de Ultralytics YOLO para tareas específicas?#

Personaliza el DetectionTrainer para tareas específicas sobrescribiendo sus métodos para adaptarlos 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=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 una mayor personalización, como cambiar la función de pérdida o añadir un callback, consulta la Guía de Callbacks.

Link to this section¿Cuáles son los componentes clave del BaseTrainer en Ultralytics YOLO?#

El BaseTrainer sirve como base para las rutinas de entrenamiento, siendo 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 dataloader.
• preprocess_batch(): Maneja el preprocesamiento de lotes antes del pase 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.

Link to this section¿Cómo puedo añadir un callback al DetectionTrainer de Ultralytics YOLO?#

Añade callbacks para supervisar 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 é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.

Link to this section¿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 línea de comandos como las interfaces de Python simplifican tareas complejas.
• Rendimiento: Optimizado para detección de objetos en tiempo real y diversas aplicaciones de visión artificial.
• Personalización: Fácilmente ampliable 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.

Link to this section¿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 dar soporte 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 obtener instrucciones y ejemplos completos, revisa la referencia de DetectionTrainer.