Callbacks#

Los callbacks de Ultralytics son puntos de entrada especializados que se activan durante etapas clave de las operaciones del modelo, como el entrenamiento, la validación, la exportación y la predicción. Estos callbacks permiten añadir funcionalidad personalizada en puntos específicos del proceso, posibilitando mejoras y modificaciones en el flujo de trabajo. Cada callback acepta un objeto Trainer, Validator o Predictor, según el tipo de operación. Para conocer las propiedades detalladas de estos objetos, consulta la sección de Referencia.

Para utilizar un callback, define una función y añádela al modelo utilizando el método model.add_callback(). Aquí tienes un ejemplo de cómo devolver información adicional durante la predicción:

from ultralytics import YOLO

def on_predict_batch_end(predictor):
    """Handle prediction batch end by combining results with corresponding frames; modifies predictor results."""
    _, image, _, _ = predictor.batch
    image = image if isinstance(image, list) else [image]
    predictor.results = zip(predictor.results, image)

model = YOLO("yolo26n.pt")
model.add_callback("on_predict_batch_end", on_predict_batch_end)
for result, frame in model.predict():
    pass

Personaliza tu rutina de entrenamiento de Ultralytics inyectando lógica en etapas específicas del proceso de entrenamiento. Ultralytics YOLO ofrece una variedad de callbacks 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.

Aquí te mostramos cómo congelar las estadísticas de BatchNorm al congelar capas con callbacks:

from ultralytics import YOLO

# Add a callback to put the frozen layers in eval mode to prevent BN values from changing
def put_in_eval_mode(trainer):
    n_layers = trainer.args.freeze
    if not isinstance(n_layers, int):
        return

    for i, (name, module) in enumerate(trainer.model.named_modules()):
        if name.endswith("bn") and int(name.split(".")[1]) < n_layers:
            module.eval()
            module.track_running_stats = False

model = YOLO("yolo26n.pt")
model.add_callback("on_train_epoch_start", put_in_eval_mode)
model.train(data="coco.yaml", epochs=10)

Para obtener más detalles sobre cómo utilizar eficazmente los callbacks de entrenamiento, consulta la Guía de entrenamiento.

El uso de callbacks durante la validación en Ultralytics YOLO mejora la evaluación del modelo al permitir procesamiento personalizado, registro de datos o cálculo de métricas. Callbacks como on_val_start, on_val_batch_end y on_val_end proporcionan puntos de entrada para inyectar lógica personalizada, garantizando procesos de validación detallados y exhaustivos.

Por ejemplo, para graficar todos los lotes de validación en lugar de solo los tres primeros:

import inspect

from ultralytics import YOLO

def plot_samples(validator):
    frame = inspect.currentframe().f_back.f_back
    v = frame.f_locals
    validator.plot_val_samples(v["batch"], v["batch_i"])
    validator.plot_predictions(v["batch"], v["preds"], v["batch_i"])

model = YOLO("yolo26n.pt")
model.add_callback("on_val_batch_end", plot_samples)
model.val(data="coco.yaml")

Para obtener más información sobre cómo incorporar callbacks en tu proceso de validación, consulta la Guía de validación.

Para adjuntar un callback personalizado para el modo de predicción en Ultralytics YOLO, define una función de callback y regístrala en el proceso de predicción. Los callbacks de predicción comunes incluyen on_predict_start, on_predict_batch_end y on_predict_end. Estos permiten la modificación de las salidas de predicción y la integración de funcionalidades adicionales, como el registro de datos o la transformación de resultados.

Aquí tienes un ejemplo donde un callback personalizado guarda predicciones según si está presente un objeto de una clase particular:

from ultralytics import YOLO

model = YOLO("yolo26n.pt")

class_id = 2

def save_on_object(predictor):
    r = predictor.results[0]
    if class_id in r.boxes.cls:
        predictor.args.save = True
    else:
        predictor.args.save = False

model.add_callback("on_predict_postprocess_end", save_on_object)
results_stream = model("pedestrians.mp4", stream=True, save=True)

for result in results_stream:
    pass

Para un uso más exhaustivo, consulta la Guía de predicción, que incluye instrucciones detalladas y opciones de personalización adicionales.

Ultralytics YOLO admite varias implementaciones prácticas de callbacks 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 o aumentos de datos personalizados durante lotes de predicción o entrenamiento.
• Resultados intermedios: Guarda resultados intermedios, como predicciones o frames, para su posterior análisis o visualización.

Ejemplo: Combinación de fotogramas con resultados de predicción durante la predicción utilizando on_predict_batch_end:

from ultralytics import YOLO

def on_predict_batch_end(predictor):
    """Combine prediction results with frames."""
    _, image, _, _ = predictor.batch
    image = image if isinstance(image, list) else [image]
    predictor.results = zip(predictor.results, image)

model = YOLO("yolo26n.pt")
model.add_callback("on_predict_batch_end", on_predict_batch_end)
for result, frame in model.predict():
    pass

Explora el código fuente de los callbacks para ver más opciones y ejemplos.