Empezar

Callbacks

El marco Ultralytics admite retrollamadas, que sirven como puntos de entrada en etapas clave de los modos train, val, predict y export. Cada retrollamada acepta un objeto Trainer, Validator, Predictor o Exporter, según el tipo de operación.



Ver: Cómo usar las devoluciones de llamada de Ultralytics | Devoluciones de llamada para predecir, entrenar, validar y exportar | Ultralytics YOLO26 🚀

Ejemplos#

Devolver información adicional con la predicción#

Este ejemplo devuelve 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

    # Asegúrate de que image sea una lista
    image = image if isinstance(image, list) else [image]

    # Combina los resultados de la predicción con los fotogramas correspondientes
    predictor.results = zip(predictor.results, image)

# Crea una instancia del modelo YOLO
model = YOLO("yolo26n.pt")

# Añade el callback personalizado al modelo
model.add_callback("on_predict_batch_end", on_predict_batch_end)

# Itera por los resultados y los fotogramas
for result, frame in model.predict():  # o model.track()
    pass

Registrar hooks de PyTorch forward antes del entrenamiento#

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

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 DistributedDataParallel. No asocies un hook 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 el callback al cargar el punto de control. Si el mismo preprocesamiento debe ejecutarse durante la validación del entrenamiento, impleméntalo como un componente del modelo importable en lugar de como un hook en tiempo de ejecución. La recuperación de NaN reconstruye el EMA a partir del modelo de entrenamiento, por lo que un hook registrado de este modo se copia en el EMA y en los puntos de control guardados después de la recuperación; define la función del hook en un módulo importable si es necesario cargar los puntos de control en otro proceso.

El model.val() independiente copia el modelo cargado en cada llamada. La predicción crea y almacena en caché una copia en la primera llamada, por lo que debes registrar los hooks en model.model antes de la primera llamada a model.predict() o model.track(); los hooks añadidos después no llegan al predictor almacenado en caché. Vuelve a registrar los hooks 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 el callback on_model_save#

Este ejemplo muestra cómo recuperar detalles del entrenamiento, como la puntuación best_fitness, total_loss y otras métricas, después de guardar un punto de control mediante el callback 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)

Todos los callbacks#

A continuación se muestran todos los callbacks compatibles. Para obtener más información, consulta el código fuente de los callbacks.

Callbacks del entrenador#

CallbackDescripción
on_pretrain_routine_startSe activa al principio de la rutina de preentrenamiento, antes de cargar los datos y configurar el modelo.
on_pretrain_routine_endSe activa al final de la rutina de preentrenamiento, una vez completadas la carga de datos y la configuración del modelo.
on_train_startSe activa cuando comienza el entrenamiento, antes de que empiece la primera época.
on_train_epoch_startSe activa al inicio de cada época de entrenamiento, antes de que comience la iteración por lotes.
on_train_batch_startSe activa al inicio de cada lote de entrenamiento, antes de la pasada hacia delante.
optimizer_stepSe activa durante el paso del optimizador. Reservado para integraciones personalizadas; el bucle de entrenamiento predeterminado no lo llama.
on_before_zero_gradSe activa antes de poner a cero los gradientes. Reservado para integraciones personalizadas; el bucle de entrenamiento predeterminado no lo llama.
on_train_batch_endSe activa al final de cada lote de entrenamiento, después de la pasada hacia atrás. El paso del optimizador puede aplazarse debido a la acumulación de gradientes.
on_train_epoch_endSe activa al final de cada época de entrenamiento, después de procesar todos los lotes, pero antes de la validación. Es posible que las métricas de validación y el fitness aún no estén disponibles.
on_model_saveSe activa cuando se guarda el punto de control del modelo, después de la validación.
on_fit_epoch_endSe activa al final de cada época de ajuste (entrenamiento + validación), después de la validación y de guardar cualquier punto de control. Las métricas de validación están disponibles, y el fitness está disponible para la llamada de entrenamiento por época. Este callback también se llama durante la evaluación final del mejor modelo, cuando no se guarda ningún punto de control y puede que el fitness no esté presente.
on_train_endSe activa cuando finaliza el proceso de entrenamiento, después de la evaluación final del mejor modelo.
on_params_updateSe activa cuando se actualizan los parámetros del modelo. Reservado para integraciones personalizadas; el bucle de entrenamiento predeterminado no lo llama.
teardownSe activa cuando se está limpiando el proceso de entrenamiento.

Callbacks del validador#

CallbackDescripción
on_val_startSe activa cuando comienza la validación.
on_val_batch_startSe activa al inicio de cada lote de validación.
on_val_batch_endSe activa al final de cada lote de validación.
on_val_endSe activa cuando finaliza la validación.

Callbacks del predictor#

CallbackDescripción
on_predict_startSe activa cuando comienza el proceso de predicción.
on_predict_batch_startSe activa al inicio de cada lote de predicción.
on_predict_postprocess_endSe activa al final del posprocesamiento de la predicción.
on_predict_batch_endSe activa al final de cada lote de predicción.
on_predict_endSe activa cuando finaliza el proceso de predicción.

Callbacks del exportador#

CallbackDescripción
on_export_startSe activa cuando comienza el proceso de exportación.
on_export_endSe activa cuando finaliza el proceso de exportación.

Preguntas frecuentes#

  • Las retrollamadas de Ultralytics son puntos de entrada que se activan durante etapas clave de las operaciones del modelo, como el entrenamiento, la validación, la predicción y la exportación. Te permiten añadir funcionalidad personalizada en momentos concretos del proceso sin modificar la biblioteca. Cada retrollamada acepta un objeto Trainer, Validator, Predictor o Exporter, según el tipo de operación.

    Para usar un callback, define una función y añádela al modelo mediante 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 la rutina de entrenamiento de Ultralytics inyectando lógica en etapas específicas del proceso de entrenamiento. Ultralytics YOLO ofrece varios callbacks de entrenamiento, como on_train_start, on_train_end y on_train_batch_end, que te permiten añadir métricas, procesamiento o registros personalizados.

    Así puedes registrar la tasa de aprendizaje de cada grupo de parámetros del optimizador al final de cada época de entrenamiento:

    from ultralytics import YOLO
    
    def log_learning_rates(trainer):
        """Print the current learning rates after each training epoch."""
        print(f"Epoch {trainer.epoch + 1}: {trainer.lr}")
    
    model = YOLO("yolo26n.pt")
    model.add_callback("on_train_epoch_end", log_learning_rates)
    model.train(data="coco8.yaml", epochs=3)
    Consejo

    No necesitas un callback para congelar las estadísticas de BatchNorm al usar freeze: el entrenador pone automáticamente las capas BatchNorm de las capas congeladas en modo eval al inicio de cada época.

    Para obtener más información sobre el uso eficaz de los callbacks de entrenamiento, consulta la Guía de entrenamiento.

  • Las retrollamadas de validación te permiten añadir procesamiento personalizado, registro o cálculo de métricas a la evaluación del modelo. Retrollamadas como on_val_start, on_val_batch_end y on_val_end proporcionan puntos de entrada para incorporar lógica personalizada en cada etapa de la validación.

    Por ejemplo, para representar 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 al proceso de validación, consulta la Guía de validación.

  • Para asociar un callback personalizado al modo de predicción de Ultralytics YOLO, define una función callback y regístrala en el proceso de predicción. Entre los callbacks de predicción habituales se incluyen on_predict_start, on_predict_batch_end y on_predict_end. Estos permiten modificar los resultados de la predicción e integrar funcionalidades adicionales, como el registro de datos o la transformación de resultados.

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

    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 obtener información más completa sobre su uso, consulta la Guía de predicción, que incluye instrucciones detalladas y opciones de personalización adicionales.

  • Ultralytics YOLO admite diversas implementaciones prácticas de callbacks para mejorar y personalizar distintas fases, como el entrenamiento, la validación y la predicción. Algunos ejemplos prácticos son:

    • Registro de métricas personalizadas: Registra métricas adicionales en distintas etapas, por ejemplo, al final de las épocas de entrenamiento o validación.
    • Aumento de datos: implementa transformaciones o aumentos de datos personalizados durante la predicción o los lotes de entrenamiento.
    • Resultados intermedios: guarda resultados intermedios, como predicciones o fotogramas, para analizarlos o visualizarlos más adelante.

    Ejemplo: combinar fotogramas con resultados de predicción durante la predicción usando 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

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

Comentarios15

Haz una pregunta, comparte tus resultados o ayuda a otra persona.

  1. drbilal216GitHub

    Hi can i and how use callback to freeze initial layers for number of epochs and unfreeze after that, is there any builtin function for that? i used freeze builtin function but it freezes for all the epochs.

    1. drbilal216GitHub

      also, after certain epochs the change in model training is minimal can we use callback then to change lr, how and what parameter to change ?

    2. Glenn JocherUltralytics

      @drbilal216 yes, you can use callbacks to freeze/unfreeze layers dynamically during training. Here's how to freeze initial layers for specific epochs then unfreeze them:

      from ultralytics import YOLO
      
      def dynamic_freeze_callback(trainer):
          freeze_epochs = 10  # Freeze for first 10 epochs
          freeze_layers = 10  # Number of layers to freeze
          
          if trainer.epoch < freeze_epochs:
              # Freeze layers
              for i, (name, param) in enumerate(trainer.model.named_parameters()):
                  if i < freeze_layers:
                      param.requires_grad = False
          else:
              # Unfreeze all layers
              for param in trainer.model.parameters():
                  param.requires_grad = True
      
      model = YOLO("yolo11n.pt")
      model.add_callback("on_train_epoch_start", dynamic_freeze_callback)
      model.train(data="coco8.yaml", epochs=20)

      For dynamic learning rate adjustment when training plateaus, you can modify the scheduler within a callback:

      def dynamic_lr_callback(trainer):
          if trainer.epoch > 50 and trainer.epoch % 10 == 0:  # Every 10 epochs after epoch 50
              for param_group in trainer.optimizer.param_groups:
                  param_group['lr'] *= 0.9  # Reduce LR by 10%
      
      model.add_callback("on_train_epoch_end", dynamic_lr_callback)
      1
    3. drbilal216GitHub

      @glenn-jocher Thanks for the code! I'm working on a low-quality PPE dataset. With a custom YAML, I improved YOLOv12n accuracy by 3%, and got similar results on YOLOv11n with better FPS.

      The default Nano model lets me use pretrained=True, but custom architectures start from scratch. Still, I can reuse best.pt as pretrained weights on the same YAML later.

      I'm now exploring argument tuning and callbacks for further improvements. I also tried freezing/unfreezing layers mid-training but saw no gains.

      Lastly, I integrated Flash into YOLOv12, but I don’t see any sign that it’s being used during training (tested on Colab and A100 80GB-server).

  2. jnance34GitHub

    Hello,

    I'm trying to implement a custom on_pretrain_routine_end callback with a model.tune() call, but it appears that the Tuner class isn't adding my custom callback function to the Tuner.callbacks list. Here's some pseudo code of what I'm trying to do:

    def my_custom_callback(trainer):
        print("I'm in my custom callback function!")
    
    model = YOLO("model/yolo11n.pt")
    model.add_callback('on_pretrain_routine_end', my_custom_function)
    model.tune(...)
    # Expect to see "I'm in my custom callback function" for each trial run...

    For some reason my custom callback function isn't getting called for each training run of the Tuner. Am I missing a step here? I've taken a look at the source code but don't see anything obviously wrong...

    Thanks!

    -James

  3. ruslanraupoffGitHub

    When I'm using single device add_callback works well but multi gpu's not working any solution for this?

    1. Glenn JocherUltralytics

      @ruslanraupoff for multi-GPU training with callbacks, ensure your callback function is properly registered in all processes. When using DDP mode, callbacks need to be added before the training starts and should be compatible with distributed training environments. If you're experiencing issues, verify that your callback logic is thread-safe and doesn't rely on process-specific resources. For implementation details, refer to our callbacks documentation: https://docs.ultralytics.com/usage/callbacks

      1
  4. D3RK0GitHub

    Hi, in the documentation above, I see that predictor.batch is used, which I assume refers to the current batch of the predictor. Is there a similar trainer.batch for a trainer? I need it in order to apply data augmentation during the training of my YOLOv8 classifier.

    1. D3RK0GitHub

      I forgot to ask which (callback) event do I need to select?

    2. Glenn JocherUltralytics(editado)

      @D3RK0 trainer callbacks only receive the trainer object, so the current batch is not available there as trainer.batch. To apply custom augmentation to each training batch, subclass your trainer (e.g. ClassificationTrainer) and override preprocess_batch(self, batch), which receives every training batch before the forward pass.

    3. D3RK0GitHub(editado)

      @glenn-jocher Many thanks for your quick response!

      I am dealing with following problem though:

      Problem

      When I do trainer.batch, I get the following error:

      Traceback (most recent call last):
        File "C:\Program Files\JetBrains\PyCharm Community Edition 2022.3.3\plugins\python-ce\helpers\pydev\pydevd.py", line 1534, in _exec
          pydev_imports.execfile(file, globals, locals)  # execute the script
          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
        File "C:\Program Files\JetBrains\PyCharm Community Edition 2022.3.3\plugins\python-ce\helpers\pydev\_pydev_imps\_pydev_execfile.py", line 18, in execfile
          exec(compile(contents+"\n", file, 'exec'), glob, loc)
        File "C:\Users\derk_\Documents\Universiteit\IRP\Research_Project\main.py", line 397, in <module>
          main()
        File "C:\Users\derk_\Documents\Universiteit\IRP\Research_Project\main.py", line 377, in main
          model.train(mode="classify",
        File "C:\Users\derk_\anaconda3\envs\cobra\Lib\site-packages\ultralytics\engine\model.py", line 802, in train
          self.trainer.train()
        File "C:\Users\derk_\anaconda3\envs\cobra\Lib\site-packages\ultralytics\engine\trainer.py", line 207, in train
          self._do_train(world_size)
        File "C:\Users\derk_\anaconda3\envs\cobra\Lib\site-packages\ultralytics\engine\trainer.py", line 368, in _do_train
          self.run_callbacks("on_train_batch_start")
        File "C:\Users\derk_\anaconda3\envs\cobra\Lib\site-packages\ultralytics\engine\trainer.py", line 168, in run_callbacks
          callback(self)
        File "C:\Users\derk_\Documents\Universiteit\IRP\Research_Project\main.py", line 185, in batch_augmentation_callback
          batch = trainer.batch  # Access the current batch
                  ^^^^^^^^^^^^^
      AttributeError: 'ClassificationTrainer' object has no attribute 'batch'

      My code

      model = YOLO("yolov8m-cls.pt")
      
      model.add_callback("on_train_batch_start", batch_augmentation_callback)
      
      model.train(mode="classify",
                  data=data_file_dir,
                  epochs=args.n_epochs)
      
      # Where batch_augmentation_callback is my callback function
      def batch_augmentation_callback(trainer):
          batch = trainer.batch                                        # This code line causes the error reported above
          images, labels = batch['img'], batch['label']
          # More code below to create data augmentation

      Content of trainer object that is passed into batch_augmentation_callback (my callback function)

      • trainer = {ClassificationTrainer} <ultralytics.models.yolo.classify.train.ClassificationTrainer object at 0x0000016929FA5010>
      • accumulate = {int} 4
      • amp = {bool} False
      • args = {IterableSimpleNamespace} IterableSimpleNamespace(task='classify', mode='train', model='yolov8m-cls.pt', data='C:/Users/derk_/Documents/Universiteit/IRP...ugment='randaugment', erasing=0.4, crop_fraction=1.0, cfg=None, tracker='botsort.yaml', save_dir='C:\runs\classify\train53')
      • batch_size = {int} 16
      • best = {WindowsPath} WindowsPath('C:/runs/classify/train53/weights/best.pt')
      • best_fitness = {NoneType} None
      • callbacks = {defaultdict: 25} defaultdict(<class 'list'>, {'on_pretrain_routine_start': [<function on_pretrain_routine_start at 0x0000016929C79440>, <functi...C7A2A0>, <function on_export_start at 0x000001692A55C220>], 'on_export_end': [<function on_export_end at 0x0000016929C7A340>]})
      • csv = {WindowsPath} WindowsPath('C:/runs/classify/train53/results.csv')
      • data = {dict: 5} {'names': {0: '1', 1: '10', 2: '100', 3: '101', 4: '102', 5: '11', 6: '12', 7: '13', 8: '14', 9: '15', 10: '16', 11: '17', 12: '18', 13: '19', 14: '2', 15: '20', 16: '21', 17: '22', 18: '23', 19: '24', 20: '25', 21: '26', 22: '27', 23: '28', 24: '29', 25:
      • device = {device} device(type='cpu')
      • ema = {ModelEMA} <ultralytics.utils.torch_utils.ModelEMA object at 0x000001692AC80C90>
      • epoch = {int} 0
      • epoch_time = {NoneType} None
      • epoch_time_start = {float} 1731355033.8569636
      • epochs = {int} 1
      • fitness = {NoneType} None
      • hub_session = {NoneType} None
      • last = {WindowsPath} WindowsPath('C:/runs/classify/train53/weights/last.pt')
      • loss = {NoneType} None
      • loss_names = {list: 1} ['loss']
      • metrics = {dict: 3} {'metrics/accuracy_top1': 0, 'metrics/accuracy_top5': 0, 'val/loss': 0}
      • model = {ClassificationModel} ClassificationModel(\n (model): Sequential(\n (0): Conv(\n (conv): Conv2d(3, 48, kernel_size=(3, 3), stride=(2, 2), padd...1)\n (drop): Dropout(p=0.0, inplace=True)\n (linear): Linear(in_features=1280, out_features=102, bias=True)\n )\n )\n)
      • optimizer = {AdamW} AdamW (\nParameter Group 0\n amsgrad: False\n base_momentum: 0.85\n betas: (0.9499811807836418, 0.999)\n capturable: Fa... lr: 0.004018066447703833\n max_lr: 0.1\n max_momentum: 0.95\n maximize: False\n min_lr: 4e-07\n weight_decay: 0.0\n)
      • plot_idx = {list: 6} [0, 1, 2, -3465, -3464, -3463]
      • plots = {dict: 0} {}
      • resume = {bool} False
      • save_dir = {WindowsPath} WindowsPath('C:/runs/classify/train53')
      • save_period = {int} 1
      • scaler = {GradScaler} <torch.amp.grad_scaler.GradScaler object at 0x000001692921A0D0>
      • scheduler = {OneCycleLR} <torch.optim.lr_scheduler.OneCycleLR object at 0x000001692ACF5210>
      • start_epoch = {int} 0
      • stop = {bool} False
      • stopper = {EarlyStopping} <ultralytics.utils.torch_utils.EarlyStopping object at 0x000001692ACF7190>
      • stride = {int} 32
      • test_loader = {InfiniteDataLoader: 32} <ultralytics.data.build.InfiniteDataLoader object at 0x000001692AAD7B50>
      • testset = {WindowsPath} WindowsPath('C:/Users/derk_/Documents/Universiteit/IRP/Research_Project/Oxford-Flower-dataset/jpg/val')
      • tloss = {NoneType} None
      • train_loader = {InfiniteDataLoader: 385} <ultralytics.data.build.InfiniteDataLoader object at 0x00000169297FFDD0>
      • train_time_start = {float} 1731355033.8569636
      • trainset = {WindowsPath} WindowsPath('C:/Users/derk_/Documents/Universiteit/IRP/Research_Project/Oxford-Flower-dataset/jpg/train')
      • validator = {ClassificationValidator} <ultralytics.models.yolo.classify.val.ClassificationValidator object at 0x000001692AC80BD0>
      • wdir = {WindowsPath} WindowsPath('C:/runs/classify/train53/weights')

      Question

      If it is right that trainer.batch does not exist (in this case), which other object in trainer - as listed above in the content of trainer - can I extract the current batch?

    4. Glenn JocherUltralytics(editado)

      The trainer.batch attribute does not exist in the current implementation, and iterating trainer.train_loader inside a callback would draw a different batch rather than the current one. Instead, override preprocess_batch(self, batch) in a custom trainer subclass to modify each batch before it is used.

    5. D3RK0GitHub(editado)

      @glenn-jocher Many thanks for answering!

      Okay, I have been able to access the batches via trainer.train_loader and subsequently apply data augmentation to each batch. However, ...

      Problem

      ... assigning the batch back (see also the code below) to trainer.train_loader is not possible, as I get:

      trainer.train_loader[i] = batch ~~~~~~~~~~~~~~~~~~~~^^^ TypeError: 'InfiniteDataLoader' object does not support item assignment

      Code

      def batches_augmentation_callback(trainer):
          for i, batch in enumerate(trainer.train_loader):
              images, labels = batch['img'], batch['cls']
              cutmix_or_mixup = LoadOxfordFlowerDataset.data_augmentation(n_classes_in_batch=args.n_classes)
              images, labels = cutmix_or_mixup(images, labels)
              batch = {"img": images, "cls": labels}
              trainer.train_loader[i] = batch     # BUG: trainer.train_loader object does not support item assignment

      Question

      How can I return the augmented batch to the trainer object if assignment does not work?

    6. Glenn JocherUltralytics

      You cannot directly assign to trainer.train_loader. Instead, apply your augmentation within the loop and yield the modified batch back to the training process. Consider using a custom data loader or modifying the dataset directly for more complex augmentations.