Personalizació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 las interfaces Trainer explicando cómo adaptarlo a sus necesidades específicas.
Observa: Dominio de Ultralytics YOLO : Personalización avanzada
BaseTrainer
En BaseTrainer proporciona una rutina de entrenamiento genérica adaptable a diversas tareas. Personalícela anulando funciones u operaciones específicas respetando los formatos requeridos. Por ejemplo, integre su propio modelo personalizado y cargador de datos anulando estas funciones:
get_model(cfg, weights): Construye el modelo a entrenar.get_dataloader(): Crea el cargador de datos.
Para obtener más información y el código fuente, consulte la página BaseTrainer Referencia.
DetecciónEntrenador
A continuación se explica cómo utilizar y personalizar Ultralytics YOLO DetectionTrainer:
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, sobrecargue 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()
Personaliza aún más el entrenador modificando la función de pérdida o añadiendo una llamada de retorno para cargar el modelo en Google Drive cada 10 épocas. He aquí 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, consulte la Guía de Callbacks.
Otros componentes del motor
Personalizar otros componentes como Validators y Predictors de forma similar. Para más información, consulte la documentación de Validadores y Predictores.
Uso de YOLO con entrenadores personalizados
En YOLO proporciona una envoltura de alto nivel para las clases Trainer. Puede aprovechar esta arquitectura para obtener una mayor flexibilidad en sus 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("yolo11n.pt")
# Train with custom trainer
results = model.train(trainer=MyCustomTrainer, data="coco8.yaml", epochs=3)
Este enfoque le permite mantener la sencillez de la interfaz de YOLO y, al mismo tiempo, personalizar el proceso de formación subyacente para adaptarlo a sus necesidades específicas.
PREGUNTAS FRECUENTES
¿Cómo personalizo Ultralytics YOLO DetectionTrainer para tareas específicas?
Personalizar el DetectionTrainer para tareas específicas sobreescribiendo sus métodos para adaptarlos a tu modelo y cargador de datos personalizados. Empieza por heredar de DetectionTrainer y redefinir métodos como get_model para implementar 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 the best model
Para una mayor personalización, como cambiar la función de pérdida o añadir una llamada de retorno, consulte la Guía de llamadas de retorno.
¿Cuáles son los componentes clave de BaseTrainer en Ultralytics YOLO?
En BaseTrainer sirve de base para las rutinas de entrenamiento, personalizables para diversas tareas anulando sus métodos genéricos. Los componentes clave son:
get_model(cfg, weights): Construye el modelo a entrenar.get_dataloader(): Crea el cargador de datos.preprocess_batch(): Gestiona el preprocesamiento por lotes antes del paso hacia delante 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 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 un callback al Ultralytics YOLO DetectionTrainer?
Añadir callbacks para supervisar y modificar el proceso de formación en DetectionTrainer. He aquí cómo 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 la Guía de devoluciones de llamada.
¿Por qué utilizar Ultralytics YOLO para el entrenamiento de modelos?
Ultralytics YOLO proporciona una abstracción de alto nivel sobre potentes motores ejecutores, lo que lo hace ideal para un rápido desarrollo y personalización. 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.
- Modularidad: Los componentes pueden modificarse de forma independiente sin afectar a toda la canalización.
- Integración: Funciona a la perfección con marcos y herramientas populares en el ecosistema ML.
Obtenga más información sobre las capacidades de YOLO explorando la página principal de Ultralytics YOLO de Ultralytics.
¿Puedo utilizar Ultralytics YOLO DetectionTrainer para modelos no estándar?
Sí, el DetectionTrainer es muy flexible y personalizable para modelos no estándar. Hereda de DetectionTrainer y métodos de sobrecarga 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 completos, consulte el DetectionTrainer Referencia.
