Personalización avanzada
Tanto la línea de comandos de Ultralytics YOLO como las interfaces de python son abstracciones de alto nivel construidas sobre ejecutores de motor base. Esta guía se centra en Trainer engine, explicando cómo personalizarlo para tus necesidades específicas.
Ver: Dominar Ultralytics YOLO: Personalización Avanzada
BaseTrainer
El BaseTrainer La clase proporciona una rutina de entrenamiento genérica adaptable para diversas tareas. Personalícela sobrescribiendo funciones u operaciones específicas, respetando los formatos requeridos. Por ejemplo, integre su propio modelo personalizado y cargador de datos sobrescribiendo estas funciones:
get_model(cfg, weights): Construye el modelo que se va a entrenar.get_dataloader(): Construye el cargador de datos (dataloader).
Para obtener más detalles y el código fuente, consulte el BaseTrainer Referencia.
DetectionTrainer
Aquí se muestra cómo usar 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 de DetectionTrainer
Para entrenar un modelo de detección personalizado que no sea directamente compatible, sobrecarga el 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()
Personalice aún más el entrenador modificando la función de pérdida o agregando una callback para cargar el modelo en Google Drive cada 10 épocas. Aquí hay 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 obtener más información sobre los eventos de activación de callback y los puntos de entrada, consulte la Guía de Callbacks.
Otros componentes del motor
Personalice otros componentes como Validators y Predictors de manera similar. Para obtener más información, consulte la documentación de Validadores y Predictores.
Usando YOLO con Entrenadores Personalizados
El YOLO La clase model proporciona un contenedor 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 simplicidad de la interfaz YOLO mientras personaliza el proceso de entrenamiento subyacente para que se adapte a sus requisitos específicos.
Preguntas frecuentes
¿Cómo puedo personalizar el Ultralytics YOLO DetectionTrainer para tareas específicas?
Personalizar el DetectionTrainer para tareas específicas, anulando sus métodos para adaptarlos a tu modelo y cargador de datos personalizados. Comienza por heredar de DetectionTrainer y redefina métodos como get_model para implementar funcionalidades personalizadas. Aquí hay 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 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 diversas tareas mediante la anulación 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 cargador de datos (dataloader).preprocess_batch(): Maneja el preprocesamiento por lotes antes del pase directo 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 detalles sobre la personalización y el código fuente, consulte el BaseTrainer Referencia.
¿Cómo puedo añadir una retrollamada al Ultralytics YOLO DetectionTrainer?
Añada callbacks para supervisar y modificar el proceso de entrenamiento en DetectionTrainer. Aquí se muestra cómo añadir una función callback 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 detalles sobre los eventos de callback y los puntos de entrada, consulte 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 motores, lo que lo hace ideal para un rápido desarrollo y personalización. Los beneficios clave incluyen:
- Facilidad de uso: Tanto la interfaz de línea de comandos como la de 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 extensible para modelos personalizados, funciones de pérdida y cargadores de datos.
- Modularidad: Los componentes se pueden modificar independientemente sin afectar a toda la canalización.
- Integración: Funciona a la perfección con marcos y herramientas populares en el ecosistema de ML.
Obtenga más información sobre las capacidades de YOLO explorando la página principal de Ultralytics YOLO.
¿Puedo usar Ultralytics YOLO DetectionTrainer para modelos no estándar?
Sí, el DetectionTrainer es altamente flexible y personalizable para modelos no estándar. Heredar de DetectionTrainer y sobrecargue los métodos para admitir las necesidades específicas de su modelo. Aquí tiene 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, revisa el DetectionTrainer Referencia.
