¿Cómo puedo personalizar la rutina de entrenamiento de Ultralytics mediante devoluciones de llamada?

Personaliza tu rutina de entrenamiento de Ultralytics inyectando lógica en etapas específicas del proceso de entrenamiento. Ultralytics YOLO proporciona una variedad de devoluciones de llamada de entrenamiento, como on_train_start, on_train_end y on_train_batch_end, que te permiten añadir métricas, procesamiento o registro personalizados. A continuación se muestra cómo congelar las estadísticas de BatchNorm al congelar capas con devoluciones de llamada: Para obtener más detalles sobre cómo utilizar eficazmente las devoluciones de llamada de entrenamiento, consulta la Guía de entrenamiento.

¿Por qué debería usar devoluciones de llamada durante la validación en Ultralytics YOLO?

El uso de devoluciones de llamada durante la validación en Ultralytics YOLO mejora la evaluación del modelo al permitir procesamiento personalizado, registro o cálculo de métricas. Las devoluciones de llamada como on_val_start, on_val_batch_end y on_val_end proporcionan puntos de entrada para inyectar lógica personalizada, lo que garantiza procesos de validación detallados y exhaustivos. Por ejemplo, para trazar todos los lotes de validación en lugar de solo los primeros tres: Para obtener más información sobre cómo incorporar devoluciones de llamada en tu proceso de validación, consulta la Guía de validación.

¿Cómo adjunto una devolución de llamada personalizada para el modo de predicción en Ultralytics YOLO?

Para adjuntar una devolución de llamada personalizada para el modo de predicción en Ultralytics YOLO, define una función de devolución de llamada y regístrala en el proceso de predicción. Las devoluciones de llamada de predicción comunes incluyen on_predict_start, on_predict_batch_end y on_predict_end. Estas permiten modificar las salidas de predicción e integrar funcionalidades adicionales, como el registro de datos o la transformación de resultados. Aquí tienes un ejemplo en el que una devolución de llamada personalizada guarda las predicciones según la presencia de un objeto de una clase concreta: Para un uso más exhaustivo, consulta la Guía de predicción, que incluye instrucciones detalladas y opciones de personalización adicionales.

¿Cuáles son algunos ejemplos prácticos del uso de devoluciones de llamada en Ultralytics YOLO?

Ultralytics YOLO admite diversas implementaciones prácticas de devoluciones de llamada para mejorar y personalizar diferentes fases como el entrenamiento, la validación y la predicción. Algunos ejemplos prácticos incluyen: Registro de métricas personalizadas: Registra métricas adicionales en diferentes etapas, como al final de las épocas de entrenamiento o validación. Aumento de datos: Implementa transformaciones de datos personalizadas o aumentos durante los lotes de predicción o entrenamiento. Resultados intermedios: Guarda resultados intermedios, como predicciones o fotogramas, para su posterior análisis o visualización. Ejemplo: Combinar fotogramas con resultados de predicción durante la predicción utilizando on_predict_batch_end: Explora el código fuente de las devoluciones de llamada para ver más opciones y ejemplos.

Devoluciones de llamada#

El marco de Ultralytics admite devoluciones de llamada, que sirven como puntos de entrada en etapas estratégicas durante los modos train, val, export y predict. Cada devolución de llamada acepta un objeto Trainer, Validator o Predictor, según el tipo de operación. Todas las propiedades de estos objetos se detallan en las páginas de referencia de BaseTrainer, BaseValidator y BasePredictor.

Watch: How to use Ultralytics Callbacks | Predict, Train, Validate and Export Callbacks | Ultralytics YOLO🚀

Ejemplos#

Devolución de información adicional con la predicción#

En este ejemplo, demostramos cómo devolver el fotograma original junto con cada objeto de resultado:

from ultralytics import YOLO

def on_predict_batch_end(predictor):
    """Combine prediction results with corresponding frames."""
    _, image, _ = predictor.batch

    # Ensure that image is a list
    image = image if isinstance(image, list) else [image]

    # Combine the prediction results with the corresponding frames
    predictor.results = zip(predictor.results, image)

# Create a YOLO model instance
model = YOLO("yolo26n.pt")

# Add the custom callback to the model
model.add_callback("on_predict_batch_end", on_predict_batch_end)

# Iterate through the results and frames
for result, frame in model.predict():  # or model.track()
    pass

Registrar ganchos directos de PyTorch antes del entrenamiento#

model.train() construye un modelo de entrenamiento a partir de la configuración del modelo y transfiere los pesos cargados a él. Los ganchos de PyTorch registrados directamente en model.model antes de esta llamada son un estado en tiempo de ejecución, por lo que el modelo de entrenamiento reconstruido no los hereda. Registra los ganchos de entrenamiento en on_pretrain_routine_end, después de que la configuración del modelo se complete:

from ultralytics import YOLO
from ultralytics.utils.torch_utils import unwrap_model

def preprocess_input(module, inputs):
    """Center each input channel before the first model layer."""
    images = inputs[0]
    return (images - images.mean(dim=(-2, -1), keepdim=True),)

def register_forward_pre_hook(trainer):
    """Attach preprocessing to the active training model."""
    train_model = unwrap_model(trainer.model)
    train_model.model[0].register_forward_pre_hook(preprocess_input)

model = YOLO("yolo26n.pt")
model.add_callback("on_pretrain_routine_end", register_forward_pre_hook)
model.train(data="coco8.yaml", epochs=1)

unwrap_model() gestiona tanto el entrenamiento en un solo dispositivo como el entrenamiento con DistributedDataParallel. No adjuntes un gancho definido localmente a trainer.ema.ema, porque los puntos de control del entrenamiento serializan el modelo EMA y es posible que otro proceso no pueda importar la devolución de llamada al cargar el punto de control. Si el mismo preprocesamiento debe ejecutarse durante la validación del entrenamiento, impleméntalo como un componente de modelo importable en lugar de un gancho en tiempo de ejecución.

model.val() independiente copia el modelo cargado para cada llamada. La predicción crea y almacena en caché una copia en su primera llamada, así que registra los ganchos en model.model antes de la primera llamada a model.predict() o model.track(); los ganchos agregados posteriormente no llegan al predictor en caché. Vuelve a registrar los ganchos en tiempo de ejecución después de cargar un punto de control en un proceso nuevo.

Accede a las métricas del modelo mediante la devolución de llamada `on_model_save`#

Este ejemplo muestra cómo recuperar detalles de entrenamiento, como la puntuación best_fitness, total_loss y otras métricas después de guardar un punto de control utilizando la devolución de llamada on_model_save.

from ultralytics import YOLO

# Load a YOLO model
model = YOLO("yolo26n.pt")

def print_checkpoint_metrics(trainer):
    """Print trainer metrics and loss details after each checkpoint is saved."""
    print(
        f"Model details\n"
        f"Best fitness: {trainer.best_fitness}, "
        f"Loss names: {trainer.loss_names}, "  # List of loss names
        f"Metrics: {trainer.metrics}, "
        f"Total loss: {trainer.tloss}"  # Total loss value
    )

if __name__ == "__main__":
    # Add on_model_save callback.
    model.add_callback("on_model_save", print_checkpoint_metrics)

    # Run model training on custom dataset.
    results = model.train(data="coco8.yaml", epochs=3)

Todas las devoluciones de llamada#

A continuación se muestran todas las devoluciones de llamada compatibles. Para obtener más detalles, consulta el código fuente de las devoluciones de llamada.