Personalización avanzada

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

Observa: Dominio de Ultralytics YOLO : Personalización avanzada

BaseTrainer

BaseTrainer contiene la rutina de entrenamiento genérica. Puede personalizarse para cualquier tarea mediante la sobreescritura de las funciones u operaciones necesarias, siempre que se sigan los formatos correctos. Por ejemplo, usted puede apoyar su propio modelo personalizado y dataloader simplemente anulando 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 Puede encontrar más detalles y el código fuente en BaseTrainer Referencia

DetecciónEntrenador

A continuación se explica cómo utilizar el YOLO11 DetectionTrainer y personalizarlo.

from ultralytics.models.yolo.detect import DetectionTrainer

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

Personalización del DetectionTrainer

Personalicemos el entrenador para entrenar un modelo de detección personalizado que no se admite directamente. Para ello, basta con sobrecargar 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:

• Personalizar el loss function.
• Añadir callback que carga el modelo a su Google Drive después de 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 la activación de eventos Callback y el punto de entrada, consulte nuestra Guía de Callbacks

Otros componentes del motor

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

PREGUNTAS FRECUENTES

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

Para personalizar el Ultralytics YOLO11 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 sus 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 callbackpuede consultar nuestra Guía de devoluciones de llamada.

¿Cuáles son los componentes clave de BaseTrainer en Ultralytics YOLO11 ?

En BaseTrainer en Ultralytics YOLO11 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 obtener más información sobre la personalización y el código fuente, consulte la página BaseTrainer Referencia.

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

Puede añadir callbacks para supervisar y modificar el proceso de formación en Ultralytics YOLO11 DetectionTrainer. Por ejemplo, así es como puedes añadir una llamada de retorno para registrar los pesos del modelo después de cada entrenamiento época:

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 obtener más información sobre los eventos de devolución de llamada y los puntos de entrada, consulte nuestra Guía de devoluciones de llamada.

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

Ultralytics YOLO11 ofrece una abstracción de alto nivel sobre potentes motores ejecutores, lo que lo hace ideal para el desarrollo y la personalización rápidos. Entre sus principales ventajas 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 diversas aplicaciones de IA de visión.
• Personalización: Fácilmente ampliable para modelos personalizados, funciones de pérdida y cargadores de datos.

Obtenga más información sobre las capacidades de YOLO11 visitando Ultralytics YOLO.

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

Sí, Ultralytics YOLO11 DetectionTrainer es muy flexible y puede adaptarse a modelos no estándar. Al heredar de DetectionTrainerpuede sobrecargar diferentes métodos para satisfacer las necesidades específicas de su 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, consulte la documentación de DetectionTrainer.

Creado hace 1 año ✏️ Actualizado hace 2 meses

Comentarios