Commencer

Rappels

Le framework Ultralytics prend en charge les callbacks, qui servent de points d’entrée aux étapes clés des modes train, val, predict et export. Chaque callback accepte un objet Trainer, Validator, Predictor ou Exporter, selon le type d’opération.



Regarder : Comment utiliser les callbacks Ultralytics | Callbacks de prédiction, d’entraînement, de validation et d’exportation | Ultralytics YOLO26 🚀

Exemples#

Renvoyer des informations supplémentaires avec la prédiction#

Cet exemple renvoie l’image d’origine avec chaque objet de résultat :

from ultralytics import YOLO

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

    # Vérifier que image est une liste
    image = image if isinstance(image, list) else [image]

    # Associer les résultats de prédiction aux frames correspondantes
    predictor.results = zip(predictor.results, image)

# Créer une instance du modèle YOLO
model = YOLO("yolo26n.pt")

# Ajouter le callback personnalisé au modèle
model.add_callback("on_predict_batch_end", on_predict_batch_end)

# Parcourir les résultats et les frames
for result, frame in model.predict():  # ou model.track()
    pass

Enregistrer des hooks forward PyTorch avant l’entraînement#

model.train() construit un modèle d’entraînement à partir de la configuration du modèle et y transfère les poids chargés. Les hooks PyTorch enregistrés directement sur model.model avant cet appel font partie de l’état d’exécution ; le modèle d’entraînement reconstruit ne les récupère donc pas. Enregistre les hooks d’entraînement dans on_pretrain_routine_end, une fois la configuration du modèle terminée :

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() gère l’entraînement sur un seul appareil et l’entraînement DistributedDataParallel. N’attache pas de hook défini localement à trainer.ema.ema, car les checkpoints d’entraînement sérialisent le modèle EMA et un autre processus risque de ne pas pouvoir importer le callback lors du chargement du checkpoint. Si le même prétraitement doit être exécuté pendant la validation de l’entraînement, implémente-le comme un composant de modèle importable plutôt que comme un hook d’exécution. La récupération après NaN reconstruit l’EMA à partir du modèle d’entraînement : un hook enregistré de cette manière est donc copié dans l’EMA et dans les checkpoints enregistrés après une récupération. Définis la fonction du hook dans un module importable si les checkpoints doivent être chargés dans un autre processus.

model.val() autonome copie le modèle chargé à chaque appel. La prédiction crée et met en cache une copie lors du premier appel ; enregistre donc les hooks sur model.model avant le premier appel à model.predict() ou model.track() : les hooks ajoutés ensuite ne sont pas transmis au prédicteur mis en cache. Enregistre de nouveau les hooks d’exécution après le chargement d’un checkpoint dans un nouveau processus.

Accéder aux métriques du modèle avec le callback on_model_save#

Cet exemple montre comment récupérer des détails sur l’entraînement, tels que le score best_fitness, la valeur total_loss et d’autres métriques, après l’enregistrement d’un checkpoint avec le 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)

Tous les callbacks#

Voici tous les callbacks pris en charge. Pour en savoir plus, consulte le code source des callbacks.

Callbacks de l’entraîneur#

CallbackDescription
on_pretrain_routine_startDéclenché au début de la routine de pré-entraînement, avant le chargement des données et la configuration du modèle.
on_pretrain_routine_endDéclenché à la fin de la routine de pré-entraînement, une fois le chargement des données et la configuration du modèle terminés.
on_train_startDéclenché au démarrage de l’entraînement, avant le début de la première époque.
on_train_epoch_startDéclenché au début de chaque époque d’entraînement, avant le début de l’itération sur les lots.
on_train_batch_startDéclenché au début de chaque lot d’entraînement, avant la passe avant.
optimizer_stepDéclenché pendant l’étape de l’optimiseur. Réservé aux intégrations personnalisées ; non appelé par la boucle d’entraînement par défaut.
on_before_zero_gradDéclenché avant la remise à zéro des gradients. Réservé aux intégrations personnalisées ; non appelé par la boucle d’entraînement par défaut.
on_train_batch_endDéclenché à la fin de chaque lot d’entraînement, après la passe arrière. L’étape de l’optimiseur peut être reportée en raison de l’accumulation des gradients.
on_train_epoch_endDéclenché à la fin de chaque époque d’entraînement, une fois tous les lots traités, mais avant la validation. Les métriques de validation et le score de fitness peuvent ne pas être encore disponibles.
on_model_saveDéclenché lors de l’enregistrement du checkpoint du modèle, après la validation.
on_fit_epoch_endDéclenché à la fin de chaque époque d’ajustement (entraînement + validation), après la validation et l’enregistrement éventuel d’un checkpoint. Les métriques de validation sont disponibles, ainsi que le score de fitness pour l’appel d’entraînement de l’époque. Ce callback est également appelé lors de l’évaluation finale du meilleur modèle, lorsqu’aucun checkpoint n’est enregistré et que le score de fitness peut être absent.
on_train_endDéclenché à la fin du processus d’entraînement, après l’évaluation finale du meilleur modèle.
on_params_updateDéclenché lors de la mise à jour des paramètres du modèle. Réservé aux intégrations personnalisées ; non appelé par la boucle d’entraînement par défaut.
teardownDéclenché lors du nettoyage du processus d’entraînement.

Callbacks du validateur#

CallbackDescription
on_val_startDéclenché au début de la validation.
on_val_batch_startDéclenché au début de chaque lot de validation.
on_val_batch_endDéclenché à la fin de chaque lot de validation.
on_val_endDéclenché à la fin de la validation.

Callbacks du prédicteur#

CallbackDescription
on_predict_startDéclenché au démarrage du processus de prédiction.
on_predict_batch_startDéclenché au début de chaque lot de prédiction.
on_predict_postprocess_endDéclenché à la fin du post-traitement des prédictions.
on_predict_batch_endDéclenché à la fin de chaque lot de prédiction.
on_predict_endDéclenché à la fin du processus de prédiction.

Callbacks de l’exportateur#

CallbackDescription
on_export_startDéclenché au démarrage du processus d’exportation.
on_export_endDéclenché à la fin du processus d’exportation.

FAQ#

  • Les callbacks Ultralytics sont des points d’entrée déclenchés aux étapes clés des opérations du modèle, comme l’entraînement, la validation, la prédiction et l’export. Ils te permettent d’ajouter des fonctionnalités personnalisées à des étapes précises du processus sans modifier la bibliothèque. Chaque callback accepte un objet Trainer, Validator, Predictor ou Exporter, selon le type d’opération.

    Pour utiliser un callback, définis une fonction et ajoute-la au modèle à l’aide de la méthode model.add_callback(). Voici un exemple qui renvoie des informations supplémentaires pendant la prédiction :

    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
  • Personnalise ta routine d’entraînement Ultralytics en injectant une logique à des étapes précises du processus d’entraînement. Ultralytics YOLO fournit différents callbacks d’entraînement, comme on_train_start, on_train_end et on_train_batch_end, qui te permettent d’ajouter des métriques, du traitement ou de la journalisation personnalisés.

    Voici comment enregistrer le taux d’apprentissage de chaque groupe de paramètres de l’optimiseur à la fin de chaque époque d’entraînement :

    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)
    Conseil

    Tu n’as pas besoin d’un callback pour geler les statistiques de BatchNorm avec freeze : l’entraîneur place automatiquement en mode eval les couches BatchNorm des couches gelées au début de chaque époque.

    Pour en savoir plus sur l’utilisation efficace des callbacks d’entraînement, consulte le Guide d’entraînement.

  • Les callbacks de validation te permettent d’ajouter du traitement personnalisé, de la journalisation ou le calcul de métriques à l’évaluation du modèle. Des callbacks comme on_val_start, on_val_batch_end et on_val_end offrent des points d’entrée pour insérer une logique personnalisée à chaque étape de la validation.

    Par exemple, voici comment tracer tous les lots de validation au lieu des trois premiers uniquement :

    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")

    Pour en savoir plus sur l’intégration de callbacks à ton processus de validation, consulte le Guide de validation.

  • Pour associer un callback personnalisé au mode prédiction d’Ultralytics YOLO, définis une fonction de callback et enregistre-la auprès du processus de prédiction. Parmi les callbacks de prédiction courants, on trouve on_predict_start, on_predict_batch_end et on_predict_end. Ils permettent de modifier les sorties de prédiction et d’intégrer des fonctionnalités supplémentaires, comme la journalisation des données ou la transformation des résultats.

    Voici un exemple dans lequel un callback personnalisé enregistre les prédictions selon la présence ou non d’un objet d’une classe donnée :

    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

    Pour une présentation plus complète de l’utilisation, consulte le Guide de prédiction, qui comprend des instructions détaillées et d’autres options de personnalisation.

  • Ultralytics YOLO prend en charge différentes utilisations pratiques des callbacks pour améliorer et personnaliser plusieurs phases, comme l’entraînement, la validation et la prédiction. En voici quelques exemples :

    • Journalisation de métriques personnalisées : consigne des métriques supplémentaires à différentes étapes, par exemple à la fin des époques d’entraînement ou de validation.
    • Augmentation des données : mets en œuvre des transformations ou des augmentations de données personnalisées pendant les lots de prédiction ou d’entraînement.
    • Résultats intermédiaires : enregistre des résultats intermédiaires, comme des prédictions ou des frames, pour les analyser ou les visualiser ultérieurement.

    Exemple : associer les frames aux résultats de prédiction pendant la prédiction avec 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

    Consulte le code source des callbacks pour découvrir d’autres options et exemples.

Commentaires15

Pose une question, partage tes résultats ou aide quelqu’un d’autre.

  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. Glenn JocherUltralytics(modifié)

      @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.

    2. D3RK0GitHub(modifié)

      @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?

    3. Glenn JocherUltralytics(modifié)

      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.

    4. D3RK0GitHub(modifié)

      @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?

    5. 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.