Personalización avanzada

Tanto la interfaz de línea de comandos Ultralytics YOLO como Python son simplemente una abstracción de alto nivel sobre los ejecutores del motor base. Echemos un vistazo al motor Entrenador.

Observa: Dominio de Ultralytics YOLOv8 : Personalización avanzada

BaseTrainer

BaseTrainer contiene la rutina de entrenamiento genérica. Se puede personalizar para cualquier tarea sobreescribiendo las funciones u operaciones necesarias, siempre que se sigan los formatos correctos. Por ejemplo, puedes utilizar tu propio modelo y cargador de datos personalizados simplemente sobreescribiendo estas funciones:

• get_model(cfg, weights) - La función que construye el modelo a entrenar
• get_dataloader() - La función que construye el cargador de datos Puedes encontrar más detalles y el código fuente en BaseTrainer Referencia

DetecciónEntrenador

A continuación te explicamos cómo puedes utilizar la YOLOv8 DetectionTrainer y personalízalo.

from ultralytics.models.yolo.detect import DetectionTrainer

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

Personalizar el DetectionTrainer

Personalicemos el entrenador para entrenar un modelo de detección personalizado que no se admite directamente. Puedes hacerlo simplemente sobrecargando la función existente get_model funcionalidad:

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

Ahora te das cuenta de que necesitas personalizar más el entrenador para:

• Personaliza el loss function.
• Añade callback que sube modelos a tu Google Drive cada 10 epochs He aquí cómo puedes hacerlo:

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 callback
trainer.train()

Para saber más sobre los eventos desencadenantes de devolución de llamada y el punto de entrada, consulta nuestra Guía de Devoluciones de llamada

Otros componentes del motor

Hay otros componentes que se pueden personalizar de forma similar, como Validators y Predictors. Consulta la sección Referencia para obtener más información al respecto.

PREGUNTAS FRECUENTES

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

Para personalizar el Ultralytics YOLOv8 DetectionTrainer para una tarea específica, puedes sobrescribir sus métodos para adaptarlos a tu modelo y cargador de datos personalizados. Empieza por heredar de DetectionTrainer y luego redefinir métodos como get_model para implementar tus funcionalidades personalizadas. He aquí 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 best model

Para una mayor personalización, como cambiar el loss function o añadiendo un callbackpuedes consultar nuestra Guía de devoluciones de llamada.

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

En BaseTrainer en Ultralytics YOLOv8 sirve de base para las rutinas de entrenamiento y puede personalizarse para diversas tareas anulando sus métodos genéricos. Los componentes clave son:

• get_model(cfg, weights) para construir el modelo a entrenar.
• get_dataloader() para construir el cargador de datos.

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

¿Cómo puedo añadir una llamada de retorno al Ultralytics YOLOv8 DetectionTrainer?

Puedes añadir llamadas de retorno para controlar y modificar el proceso de entrenamiento en Ultralytics YOLOv8 DetectionTrainer. Por ejemplo, así es como puedes añadir una llamada de retorno 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 los eventos de devolución de llamada y los puntos de entrada, consulta nuestra Guía de Devoluciones de Llamada.

¿Por qué debería utilizar Ultralytics YOLOv8 para el entrenamiento de modelos?

Ultralytics YOLOv8 ofrece una abstracción de alto nivel sobre potentes motores ejecutores, lo que lo hace ideal para un desarrollo y una personalización rápidos. Entre sus principales ventajas se incluyen:

• Facilidad de uso: Tanto la interfaz de línea de comandos como Python simplifican las tareas complejas.
• Rendimiento: Optimizado para la detección de objetos en tiempo real y diversas aplicaciones de IA de visión.
• Personalización: Fácilmente ampliable para modelos personalizados, funciones de pérdida y cargadores de datos.

Obtén más información sobre las capacidades de YOLOv8 visitando Ultralytics YOLO.

¿Puedo utilizar el Ultralytics YOLOv8 DetectionTrainer para modelos no estándar?

Sí, Ultralytics YOLOv8 DetectionTrainer es muy flexible y puede adaptarse a modelos no estándar. Al heredar de DetectionTrainerpuedes sobrecargar distintos métodos para adaptarlos a las necesidades específicas de tu modelo. He aquí un ejemplo sencillo:

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 obtener instrucciones y ejemplos más completos, consulta la documentación de DetectionTrainer.

Comentarios