Callback
Il framework Ultralytics supporta i callback, che fungono da punti di ingresso nelle fasi chiave delle modalità train, val, predict e export. A seconda del tipo di operazione, ogni callback accetta un oggetto Trainer, Validator, Predictor o Exporter.
Guarda: Come usare le callback di Ultralytics | Callback per predict, train, validate ed export | Ultralytics YOLO26 🚀
Esempi#
Restituire informazioni aggiuntive con la predizione#
Questo esempio restituisce il fotogramma originale insieme a ogni oggetto risultato:
from ultralytics import YOLO
def on_predict_batch_end(predictor):
"""Combine prediction results with corresponding frames."""
_, image, _ = predictor.batch
# Assicurati che image sia una lista
image = image if isinstance(image, list) else [image]
# Combina i risultati della predizione con i frame corrispondenti
predictor.results = zip(predictor.results, image)
# Crea un'istanza del modello YOLO
model = YOLO("yolo26n.pt")
# Aggiungi il callback personalizzato al modello
model.add_callback("on_predict_batch_end", on_predict_batch_end)
# Scorri i risultati e i frame
for result, frame in model.predict(): # oppure model.track()
passRegistrare gli hook forward di PyTorch prima dell'addestramento#
model.train() crea un modello di addestramento a partire dalla configurazione del modello e vi trasferisce i pesi caricati. Gli hook di PyTorch registrati direttamente su model.model prima di questa chiamata sono stato di runtime, quindi il modello di addestramento ricreato non li eredita. Registra gli hook di addestramento in on_pretrain_routine_end, dopo aver completato la configurazione del modello:
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() gestisce sia l'addestramento su un singolo dispositivo sia l'addestramento DistributedDataParallel. Non associare un hook definito localmente a trainer.ema.ema, perché i checkpoint di addestramento serializzano il modello EMA e un altro processo potrebbe non riuscire a importare il callback durante il caricamento del checkpoint. Se lo stesso pre-elaborazione deve essere eseguita durante la validazione dell'addestramento, implementala come componente del modello importabile anziché come hook di runtime. Il ripristino da NaN ricrea il modello EMA a partire dal modello di addestramento, quindi un hook registrato in questo modo viene copiato nel modello EMA e nei checkpoint salvati dopo un ripristino; definisci la funzione hook in un modulo importabile se i checkpoint devono essere caricati in un altro processo.
model.val() autonomo copia il modello caricato a ogni chiamata. La predizione crea e memorizza nella cache una copia alla prima chiamata, quindi registra gli hook su model.model prima della prima chiamata a model.predict() o model.track(); gli hook aggiunti in seguito non raggiungono il predittore memorizzato nella cache. Registra nuovamente gli hook di runtime dopo aver caricato un checkpoint in un nuovo processo.
Accedere alle metriche del modello usando il callback on_model_save#
Questo esempio mostra come recuperare i dettagli dell'addestramento, come il punteggio best_fitness, total_loss e altre metriche, dopo aver salvato un checkpoint usando il 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)Tutti i callback#
Di seguito sono riportati tutti i callback supportati. Per maggiori dettagli, consulta il codice sorgente dei callback.
Callback del trainer#
| Callback | Descrizione |
|---|---|
on_pretrain_routine_start | Attivato all'inizio della procedura di pre-addestramento, prima del caricamento dei dati e della configurazione del modello. |
on_pretrain_routine_end | Attivato al termine della procedura di pre-addestramento, dopo aver completato il caricamento dei dati e la configurazione del modello. |
on_train_start | Attivato all'avvio dell'addestramento, prima dell'inizio della prima epoca. |
on_train_epoch_start | Attivato all'inizio di ogni epoca di addestramento, prima che inizi l'iterazione sui batch. |
on_train_batch_start | Attivato all'inizio di ogni batch di addestramento, prima del passaggio in avanti. |
optimizer_step | Attivato durante il passaggio dell'ottimizzatore. Riservato alle integrazioni personalizzate; non viene chiamato dal ciclo di addestramento predefinito. |
on_before_zero_grad | Attivato prima dell'azzeramento dei gradienti. Riservato alle integrazioni personalizzate; non viene chiamato dal ciclo di addestramento predefinito. |
on_train_batch_end | Attivato al termine di ogni batch di addestramento, dopo il passaggio all'indietro. Il passaggio dell'ottimizzatore può essere rinviato a causa dell'accumulo dei gradienti. |
on_train_epoch_end | Attivato al termine di ogni epoca di addestramento, dopo l'elaborazione di tutti i batch ma prima della validazione. Le metriche di validazione e il punteggio di fitness potrebbero non essere ancora disponibili. |
on_model_save | Attivato quando viene salvato il checkpoint del modello, dopo la validazione. |
on_fit_epoch_end | Attivato al termine di ogni epoca di fit (train + val), dopo la validazione e l'eventuale salvataggio del checkpoint. Le metriche di validazione sono disponibili e il punteggio di fitness è disponibile per la chiamata di addestramento di ogni epoca. Questo callback viene chiamato anche durante la valutazione finale del modello migliore, quando non viene salvato alcun checkpoint e il punteggio di fitness potrebbe non essere presente. |
on_train_end | Attivato al termine del processo di addestramento, dopo la valutazione finale del modello migliore. |
on_params_update | Attivato quando vengono aggiornati i parametri del modello. Riservato alle integrazioni personalizzate; non viene chiamato dal ciclo di addestramento predefinito. |
teardown | Attivato durante la pulizia del processo di addestramento. |
Callback del validatore#
| Callback | Descrizione |
|---|---|
on_val_start | Attivato all'avvio della validazione. |
on_val_batch_start | Attivato all'inizio di ogni batch di validazione. |
on_val_batch_end | Attivato al termine di ogni batch di validazione. |
on_val_end | Attivato al termine della validazione. |
Callback del predittore#
| Callback | Descrizione |
|---|---|
on_predict_start | Attivato all'avvio del processo di predizione. |
on_predict_batch_start | Attivato all'inizio di ogni batch di predizione. |
on_predict_postprocess_end | Attivato al termine della post-elaborazione della predizione. |
on_predict_batch_end | Attivato al termine di ogni batch di predizione. |
on_predict_end | Attivato al termine del processo di predizione. |
Callback dell'esportatore#
| Callback | Descrizione |
|---|---|
on_export_start | Attivato all'avvio del processo di esportazione. |
on_export_end | Attivato al termine del processo di esportazione. |
Domande frequenti#
I callback Ultralytics sono punti di ingresso attivati durante le fasi chiave delle operazioni sui modelli, come addestramento, convalida, previsione ed esportazione. Ti consentono di aggiungere funzionalità personalizzate in punti specifici del processo senza modificare la libreria. A seconda del tipo di operazione, ogni callback accetta un oggetto
Trainer,Validator,PredictoroExporter.Per usare un callback, definisci una funzione e aggiungila al modello usando il metodo
model.add_callback(). Ecco un esempio di come restituire informazioni aggiuntive durante la predizione: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(): passPersonalizza la procedura di addestramento di Ultralytics inserendo la tua logica in fasi specifiche del processo di addestramento. Ultralytics YOLO offre diversi callback di addestramento, come
on_train_start,on_train_endeon_train_batch_end, che ti consentono di aggiungere metriche, elaborazioni o registrazioni personalizzate.Ecco come registrare il tasso di apprendimento di ogni gruppo di parametri dell'ottimizzatore al termine di ogni epoca di addestramento:
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)SuggerimentoNon ti serve un callback per congelare le statistiche di BatchNorm quando usi
freeze: il trainer imposta automaticamente in modalità eval i livelli BatchNorm dei livelli congelati all'inizio di ogni epoca.Per maggiori dettagli su come usare efficacemente i callback di addestramento, consulta la Guida all'addestramento.
I callback di convalida ti consentono di aggiungere elaborazioni personalizzate, registrazione dei log o calcolo delle metriche alla valutazione del modello. Callback come
on_val_start,on_val_batch_endeon_val_endoffrono punti di ingresso in cui inserire logica personalizzata in ogni fase della convalida.Ad esempio, per tracciare tutti i batch di validazione anziché solo i primi tre:
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")Per ulteriori informazioni su come integrare i callback nel processo di validazione, consulta la Guida alla validazione.
Per associare un callback personalizzato alla modalità di predizione in Ultralytics YOLO, definisci una funzione callback e registrala nel processo di predizione. Tra i callback di predizione più comuni ci sono
on_predict_start,on_predict_batch_endeon_predict_end. Questi consentono di modificare gli output della predizione e integrare funzionalità aggiuntive, come la registrazione dei dati o la trasformazione dei risultati.Ecco un esempio in cui un callback personalizzato salva le predizioni in base alla presenza di un oggetto appartenente a una determinata classe:
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: passPer un utilizzo più completo, consulta la Guida alla predizione, che include istruzioni dettagliate e ulteriori opzioni di personalizzazione.
Ultralytics YOLO supporta diverse applicazioni pratiche dei callback per migliorare e personalizzare fasi diverse, come l'addestramento, la validazione e la predizione. Ecco alcuni esempi pratici:
- Registrazione di metriche personalizzate: registra metriche aggiuntive in diverse fasi, ad esempio al termine delle epoche di addestramento o convalida.
- Aumento dei dati: implementa trasformazioni o aumenti dei dati personalizzati durante la predizione o i batch di addestramento.
- Risultati intermedi: salva risultati intermedi, come predizioni o frame, per ulteriori analisi o visualizzazioni.
Esempio: combinare i frame con i risultati della predizione durante la predizione 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(): passEsplora il codice sorgente dei callback per altre opzioni ed esempi.
Commenti15
Fai una domanda, condividi i tuoi risultati o aiuta qualcun altro.
drbilal216
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.
drbilal216
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 ?
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)1drbilal216
@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).
jnance34
Hello,
I'm trying to implement a custom
on_pretrain_routine_endcallback with amodel.tune()call, but it appears that the Tuner class isn't adding my custom callback function to theTuner.callbackslist. 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
RizwanMunawar
@jnance34 Hi! At the moment, callbacks are not supported for model.tone(...). You can find a complete list of all supported callbacks here: https://docs.ultralytics.com/usage/callbacks/#all-callbacks
ruslanraupoff
When I'm using single device add_callback works well but multi gpu's not working any solution for this?
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
D3RK0
Hi, in the documentation above, I see that
predictor.batchis used, which I assume refers to the current batch of the predictor. Is there a similartrainer.batchfor a trainer? I need it in order to apply data augmentation during the training of my YOLOv8 classifier.D3RK0
I forgot to ask which (callback) event do I need to select?
Glenn JocherUltralytics(modificato)@D3RK0 trainer callbacks only receive the
trainerobject, so the current batch is not available there astrainer.batch. To apply custom augmentation to each training batch, subclass your trainer (e.g.ClassificationTrainer) and overridepreprocess_batch(self, batch), which receives every training batch before the forward pass.D3RK0(modificato)
@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 augmentationContent of
trainerobject that is passed intobatch_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.batchdoes not exist (in this case), which other object in trainer - as listed above in the content of trainer - can I extract the current batch?
Glenn JocherUltralytics(modificato)The
trainer.batchattribute does not exist in the current implementation, and iteratingtrainer.train_loaderinside a callback would draw a different batch rather than the current one. Instead, overridepreprocess_batch(self, batch)in a custom trainer subclass to modify each batch before it is used.D3RK0(modificato)
@glenn-jocher Many thanks for answering!
Okay, I have been able to access the batches via
trainer.train_loaderand subsequently apply data augmentation to each batch. However, ...Problem
... assigning the batch back (see also the code below) to
trainer.train_loaderis not possible, as I get:trainer.train_loader[i] = batch ~~~~~~~~~~~~~~~~~~~~^^^ TypeError: 'InfiniteDataLoader' object does not support item assignmentCode
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 assignmentQuestion
How can I return the augmented batch to the
trainerobject if assignment does not work?
Glenn JocherUltralyticsYou 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.