Erste Schritte

Callbacks

Das Ultralytics-Framework unterstützt Callbacks, die als Einstiegspunkte in wichtigen Phasen der Modi train, val, predict und export dienen. Je nach Vorgang akzeptiert jeder Callback ein Objekt vom Typ Trainer, Validator, Predictor oder Exporter.



Ansehen: So verwendest du Ultralytics-Callbacks | Callbacks für Vorhersage, Training, Validierung und Export | Ultralytics YOLO26 🚀

Beispiele#

Zusätzliche Informationen bei der Vorhersage zurückgeben#

Dieses Beispiel gibt zusammen mit jedem Ergebnisobjekt auch das ursprüngliche Bild zurück:

from ultralytics import YOLO

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

    # Sicherstellen, dass image eine Liste ist
    image = image if isinstance(image, list) else [image]

    # Vorhersageergebnisse mit den entsprechenden Frames kombinieren
    predictor.results = zip(predictor.results, image)

# Eine YOLO-Modellinstanz erstellen
model = YOLO("yolo26n.pt")

# Den benutzerdefinierten Callback zum Modell hinzufügen
model.add_callback("on_predict_batch_end", on_predict_batch_end)

# Die Ergebnisse und Frames durchlaufen
for result, frame in model.predict():  # oder model.track()
    pass

PyTorch-Forward-Hooks vor dem Training registrieren#

model.train() erstellt anhand der Modellkonfiguration ein Trainingsmodell und überträgt die geladenen Gewichte darauf. PyTorch-Hooks, die vor diesem Aufruf direkt auf model.model registriert werden, sind Laufzeitstatus. Das neu erstellte Trainingsmodell übernimmt sie daher nicht. Registriere Trainings-Hooks in on_pretrain_routine_end, nachdem die Modelleinstellungen abgeschlossen sind:

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() verarbeitet sowohl das Training auf einem einzelnen Gerät als auch das Training mit DistributedDataParallel. Hänge keinen lokal definierten Hook an trainer.ema.ema, da Trainings-Checkpoints das EMA-Modell serialisieren und ein anderer Prozess den Callback beim Laden des Checkpoints möglicherweise nicht importieren kann. Wenn dieselbe Vorverarbeitung während der Trainingsvalidierung ausgeführt werden muss, implementiere sie stattdessen als importierbare Modellkomponente und nicht als Laufzeit-Hook. Bei der Wiederherstellung nach NaN-Werten wird das EMA-Modell aus dem Trainingsmodell neu erstellt. Ein auf diese Weise registrierter Hook wird daher in das EMA-Modell und nach einer Wiederherstellung in gespeicherte Checkpoints kopiert. Definiere die Hook-Funktion in einem importierbaren Modul, wenn Checkpoints in einem anderen Prozess geladen werden müssen.

Ein eigenständiges model.val() kopiert das geladene Modell bei jedem Aufruf. Bei der Vorhersage wird beim ersten Aufruf eine Kopie erstellt und zwischengespeichert. Registriere Hooks daher auf model.model, bevor du model.predict() oder model.track() zum ersten Mal aufrufst. Später hinzugefügte Hooks werden nicht an den zwischengespeicherten Predictor weitergegeben. Registriere Laufzeit-Hooks erneut, nachdem du in einem neuen Prozess einen Checkpoint geladen hast.

Mit dem Callback on_model_save auf Modellmetriken zugreifen#

Dieses Beispiel zeigt, wie du nach dem Speichern eines Checkpoints mit dem Callback on_model_save Trainingsdetails wie den best_fitness-Wert, total_loss und weitere Metriken abrufen kannst.

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)

Alle Callbacks#

Im Folgenden findest du alle unterstützten Callbacks. Weitere Informationen findest du im Quellcode der Callbacks.

Trainer-Callbacks#

CallbackBeschreibung
on_pretrain_routine_startWird zu Beginn der Vortrainingsroutine ausgelöst, vor dem Laden der Daten und der Modelleinstellungen.
on_pretrain_routine_endWird am Ende der Vortrainingsroutine ausgelöst, nachdem das Laden der Daten und die Modelleinstellungen abgeschlossen sind.
on_train_startWird zu Beginn des Trainings ausgelöst, bevor die erste Epoche beginnt.
on_train_epoch_startWird zu Beginn jeder Trainingsepoche ausgelöst, bevor die Batch-Iteration beginnt.
on_train_batch_startWird zu Beginn jedes Trainings-Batches ausgelöst, vor dem Forward-Pass.
optimizer_stepWird während des Optimizer-Schritts ausgelöst. Für benutzerdefinierte Integrationen vorgesehen; wird nicht von der standardmäßigen Trainingsschleife aufgerufen.
on_before_zero_gradWird ausgelöst, bevor die Gradienten auf null gesetzt werden. Für benutzerdefinierte Integrationen vorgesehen; wird nicht von der standardmäßigen Trainingsschleife aufgerufen.
on_train_batch_endWird am Ende jedes Trainings-Batches nach dem Backward-Pass ausgelöst. Aufgrund der Gradientenakkumulation kann der Optimizer-Schritt aufgeschoben werden.
on_train_epoch_endWird am Ende jeder Trainingsepoche ausgelöst, nachdem alle Batches verarbeitet wurden, aber vor der Validierung. Validierungsmetriken und Fitness sind möglicherweise noch nicht verfügbar.
on_model_saveWird ausgelöst, wenn der Modell-Checkpoint nach der Validierung gespeichert wird.
on_fit_epoch_endWird am Ende jeder Fit-Epoche (Training + Validierung) ausgelöst, nach der Validierung und dem Speichern eines Checkpoints, sofern dies erfolgt. Validierungsmetriken sind verfügbar, und der Fitnesswert steht beim Training pro Epoche zur Verfügung. Dieser Callback wird auch bei der abschließenden Auswertung des besten Modells aufgerufen. Dabei wird kein Checkpoint gespeichert und der Fitnesswert ist möglicherweise nicht vorhanden.
on_train_endWird ausgelöst, wenn der Trainingsprozess nach der abschließenden Auswertung des besten Modells endet.
on_params_updateWird ausgelöst, wenn Modellparameter aktualisiert werden. Für benutzerdefinierte Integrationen vorgesehen; wird nicht von der standardmäßigen Trainingsschleife aufgerufen.
teardownWird ausgelöst, wenn der Trainingsprozess bereinigt wird.

Validator-Callbacks#

CallbackBeschreibung
on_val_startWird ausgelöst, wenn die Validierung beginnt.
on_val_batch_startWird zu Beginn jedes Validierungs-Batches ausgelöst.
on_val_batch_endWird am Ende jedes Validierungs-Batches ausgelöst.
on_val_endWird ausgelöst, wenn die Validierung endet.

Predictor-Callbacks#

CallbackBeschreibung
on_predict_startWird ausgelöst, wenn der Vorhersageprozess beginnt.
on_predict_batch_startWird zu Beginn jedes Vorhersage-Batches ausgelöst.
on_predict_postprocess_endWird am Ende der Nachverarbeitung der Vorhersage ausgelöst.
on_predict_batch_endWird am Ende jedes Vorhersage-Batches ausgelöst.
on_predict_endWird ausgelöst, wenn der Vorhersageprozess endet.

Exporter-Callbacks#

CallbackBeschreibung
on_export_startWird ausgelöst, wenn der Export beginnt.
on_export_endWird ausgelöst, wenn der Export endet.

Häufig gestellte Fragen#

  • Ultralytics-Callbacks sind Einstiegspunkte, die in wichtigen Phasen von Modellvorgängen wie Training, Validierung, Vorhersage und Export ausgelöst werden. Damit kannst du an bestimmten Stellen des Ablaufs eigene Funktionen hinzufügen, ohne die Bibliothek zu ändern. Je nach Vorgang akzeptiert jeder Callback ein Objekt vom Typ Trainer, Validator, Predictor oder Exporter.

    Um einen Callback zu verwenden, definiere eine Funktion und füge sie dem Modell mit der Methode model.add_callback() hinzu. Hier ein Beispiel, wie du bei der Vorhersage zusätzliche Informationen zurückgibst:

    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
  • Passe deine Ultralytics-Trainingsroutine an, indem du an bestimmten Stellen des Trainingsprozesses eigene Logik einfügst. Ultralytics YOLO bietet verschiedene Trainings-Callbacks wie on_train_start, on_train_end und on_train_batch_end, mit denen du benutzerdefinierte Metriken, Verarbeitungsschritte oder Protokollierung hinzufügen kannst.

    So protokollierst du die Lernrate jeder Parametergruppe des Optimizers am Ende jeder Trainingsepoche:

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

    Du brauchst keinen Callback, um beim Verwenden von freeze die Statistiken von BatchNorm einzufrieren: Der Trainer versetzt die BatchNorm-Schichten eingefrorener Layer zu Beginn jeder Epoche automatisch in den Evaluierungsmodus.

    Weitere Informationen zur effektiven Verwendung von Trainings-Callbacks findest du im Trainingsleitfaden.

  • Mit Validierungs-Callbacks kannst du der Modellauswertung eigene Verarbeitungsschritte, Protokollierung oder Metrikberechnungen hinzufügen. Callbacks wie on_val_start, on_val_batch_end und on_val_end bieten Einstiegspunkte, um in jeder Phase der Validierung eigene Logik einzufügen.

    So kannst du beispielsweise alle Validierungs-Batches statt nur der ersten drei darstellen:

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

    Weitere Informationen zum Einbinden von Callbacks in deinen Validierungsprozess findest du im Validierungsleitfaden.

  • Um in Ultralytics YOLO einen benutzerdefinierten Callback für den Vorhersagemodus hinzuzufügen, definiere eine Callback-Funktion und registriere sie beim Vorhersageprozess. Zu den gängigen Vorhersage-Callbacks gehören on_predict_start, on_predict_batch_end und on_predict_end. Damit kannst du Vorhersageausgaben ändern und zusätzliche Funktionen wie die Datenprotokollierung oder die Umwandlung von Ergebnissen integrieren.

    Hier ein Beispiel für einen benutzerdefinierten Callback, der Vorhersagen abhängig davon speichert, ob ein Objekt einer bestimmten Klasse vorhanden ist:

    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

    Eine ausführlichere Anleitung mit detaillierten Anweisungen und weiteren Anpassungsmöglichkeiten findest du im Vorhersageleitfaden.

  • Ultralytics YOLO unterstützt verschiedene praktische Callback-Implementierungen, mit denen du unterschiedliche Phasen wie Training, Validierung und Vorhersage erweitern und anpassen kannst. Beispiele aus der Praxis:

    • Benutzerdefinierte Metriken protokollieren: Protokolliere zusätzliche Metriken in verschiedenen Phasen, zum Beispiel am Ende einer Trainings- oder Validierungsepoche.
    • Datenerweiterung: Führe während der Vorhersage oder der Trainings-Batches benutzerdefinierte Datentransformationen oder -erweiterungen durch.
    • Zwischenergebnisse: Speichere Zwischenergebnisse wie Vorhersagen oder Frames zur weiteren Analyse oder Visualisierung.

    Beispiel: Frames während der Vorhersage mit den Vorhersageergebnissen kombinieren, indem du on_predict_batch_end verwendest:

    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

    Weitere Möglichkeiten und Beispiele findest du im Quellcode der Callbacks.

Kommentare15

Stell eine Frage, teile deine Ergebnisse oder hilf jemand anderem.

  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(bearbeitet)

      @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(bearbeitet)

      @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(bearbeitet)

      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(bearbeitet)

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