Geri çağrılar
Ultralytics çerçevesi, train, val, predict ve export modlarının önemli aşamalarında giriş noktaları sağlayan geri çağırımları destekler. Her geri çağırım, işlem türüne bağlı olarak bir Trainer, Validator, Predictor veya Exporter nesnesi kabul eder.
İzle: Ultralytics Callbacks Nasıl Kullanılır | Predict, Train, Validate ve Export Callbacks | Ultralytics YOLO26 🚀
Örnekler#
Tahminle Birlikte Ek Bilgi Döndürme#
Bu örnek, her sonuç nesnesiyle birlikte özgün kareyi de döndürür:
from ultralytics import YOLO
def on_predict_batch_end(predictor):
"""Combine prediction results with corresponding frames."""
_, image, _ = predictor.batch
# Görüntünün bir liste olduğundan emin ol
image = image if isinstance(image, list) else [image]
# Tahmin sonuçlarını ilgili karelerle birleştir
predictor.results = zip(predictor.results, image)
# Bir YOLO model örneği oluştur
model = YOLO("yolo26n.pt")
# Özel geri çağrıyı modele ekle
model.add_callback("on_predict_batch_end", on_predict_batch_end)
# Sonuçlar ve kareler üzerinde yinele
for result, frame in model.predict(): # veya model.track()
passEğitimden Önce PyTorch İleri Geçiş Kancalarını Kaydetme#
model.train(), model yapılandırmasından bir eğitim modeli oluşturur ve yüklenen ağırlıkları bu modele aktarır. Bu çağrıdan önce doğrudan model.model üzerine kaydedilen PyTorch kancaları çalışma zamanı durumudur; bu nedenle yeniden oluşturulan eğitim modeli bunları devralmaz. Model kurulumu tamamlandıktan sonra on_pretrain_routine_end içine eğitim kancalarını kaydet:
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(), hem tek cihazlı hem de DistributedDataParallel eğitimini yönetir. Yerel olarak tanımlanmış bir kancayı trainer.ema.ema üzerine ekleme; çünkü eğitim kontrol noktaları EMA modelini serileştirir ve kontrol noktası yüklenirken başka bir işlem geri çağrıyı içe aktaramayabilir. Aynı ön işleme eğitim doğrulaması sırasında da çalışmalıysa çalışma zamanı kancası yerine içe aktarılabilir bir model bileşeni olarak uygula. NaN kurtarma, EMA'yı eğitim modelinden yeniden oluşturur; dolayısıyla bu şekilde kaydedilen bir kanca EMA'ya kopyalanır ve kurtarma sonrasında kaydedilen kontrol noktalarına eklenir. Kontrol noktalarının başka bir işlemde yüklenmesi gerekiyorsa kanca işlevini içe aktarılabilir bir modülde tanımla.
Bağımsız model.val(), her çağrı için yüklenen modelin bir kopyasını oluşturur. Tahmin, ilk çağrısında bir kopya oluşturup önbelleğe alır; bu nedenle kancaları ilk model.predict() veya model.track() çağrısından önce model.model üzerine kaydet. Daha sonra eklenen kancalar önbelleğe alınmış tahminciye ulaşmaz. Yeni bir işlemde kontrol noktası yükledikten sonra çalışma zamanı kancalarını yeniden kaydet.
Model metriklerine on_model_save geri çağrısını kullanarak eriş#
Bu örnek, on_model_save geri çağrısı kullanılarak bir kontrol noktası kaydedildikten sonra best_fitness puanı, total_loss ve diğer metrikler gibi eğitim ayrıntılarının nasıl alınacağını gösterir.
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)Tüm Geri Çağrılar#
Aşağıda desteklenen tüm geri çağrılar listelenmiştir. Daha fazla ayrıntı için geri çağrıların kaynak koduna bak.
Eğitici Geri Çağrıları#
| Geri çağrı | Açıklama |
|---|---|
on_pretrain_routine_start | Veri yükleme ve model kurulumu başlamadan önce, eğitim öncesi yordamın başında tetiklenir. |
on_pretrain_routine_end | Veri yükleme ve model kurulumu tamamlandıktan sonra, eğitim öncesi yordamın sonunda tetiklenir. |
on_train_start | Eğitim başladığında, ilk epoch başlamadan önce tetiklenir. |
on_train_epoch_start | Her eğitim epoch'u başladığında, yığın yinelemesi başlamadan önce tetiklenir. |
on_train_batch_start | Her eğitim batch'inin başında, ileri geçişten önce tetiklenir. |
optimizer_step | Optimizasyon adımı sırasında tetiklenir. Özel entegrasyonlar için ayrılmıştır; varsayılan eğitim döngüsü tarafından çağrılmaz. |
on_before_zero_grad | Gradyanlar sıfırlanmadan önce tetiklenir. Özel entegrasyonlar için ayrılmıştır; varsayılan eğitim döngüsü tarafından çağrılmaz. |
on_train_batch_end | Geri yayılım geçişinden sonra, her eğitim batch'inin sonunda tetiklenir. Gradyan biriktirme nedeniyle optimizasyon adımı ertelenebilir. |
on_train_epoch_end | Tüm batch'ler işlendikten sonra, her eğitim epoch'unun sonunda ancak doğrulamadan önce tetiklenir. Doğrulama metrikleri ve uygunluk puanı henüz kullanılabilir olmayabilir. |
on_model_save | Model kontrol noktası doğrulamadan sonra kaydedildiğinde tetiklenir. |
on_fit_epoch_end | Her fit epoch'unun (eğitim + doğrulama) sonunda, doğrulama ve kontrol noktası kaydetme işlemleri sonrasında tetiklenir. Doğrulama metrikleri kullanılabilir durumdadır ve her epoch'un eğitim çağrısı için uygunluk puanı kullanılabilir. Bu geri çağrı, en iyi modelin son değerlendirmesi sırasında da çağrılır; bu aşamada kontrol noktası kaydedilmez ve uygunluk puanı bulunmayabilir. |
on_train_end | En iyi modelin son değerlendirmesinden sonra eğitim süreci sona erdiğinde tetiklenir. |
on_params_update | Model parametreleri güncellendiğinde tetiklenir. Özel entegrasyonlar için ayrılmıştır; varsayılan eğitim döngüsü tarafından çağrılmaz. |
teardown | Eğitim süreci temizlenirken tetiklenir. |
Doğrulayıcı Geri Çağrıları#
| Geri çağrı | Açıklama |
|---|---|
on_val_start | Doğrulama başladığında tetiklenir. |
on_val_batch_start | Her doğrulama batch'inin başında tetiklenir. |
on_val_batch_end | Her doğrulama batch'inin sonunda tetiklenir. |
on_val_end | Doğrulama sona erdiğinde tetiklenir. |
Tahminci Geri Çağrıları#
| Geri çağrı | Açıklama |
|---|---|
on_predict_start | Tahmin süreci başladığında tetiklenir. |
on_predict_batch_start | Her tahmin batch'inin başında tetiklenir. |
on_predict_postprocess_end | Tahmin son işleme aşamasının sonunda tetiklenir. |
on_predict_batch_end | Her tahmin batch'inin sonunda tetiklenir. |
on_predict_end | Tahmin süreci sona erdiğinde tetiklenir. |
Dışa Aktarıcı Geri Çağrıları#
| Geri çağrı | Açıklama |
|---|---|
on_export_start | Dışa aktarma süreci başladığında tetiklenir. |
on_export_end | Dışa aktarma süreci sona erdiğinde tetiklenir. |
Sık Sorulan Sorular#
Ultralytics geri çağırımları; eğitim, doğrulama, tahmin ve dışa aktarma gibi model işlemlerinin önemli aşamalarında tetiklenen giriş noktalarıdır. Kitaplığı değiştirmeden sürecin belirli noktalarına özel işlevler eklemene olanak tanırlar. Her geri çağırım, işlem türüne bağlı olarak bir
Trainer,Validator,PredictorveyaExporternesnesi kabul eder.Bir geri çağrı kullanmak için bir işlev tanımla ve
model.add_callback()yöntemini kullanarak bu işlevi modele ekle. Tahmin sırasında ek bilgi döndürmeye ilişkin bir örnek: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(): passEğitim sürecinin belirli aşamalarına mantık ekleyerek Ultralytics eğitim yordamını özelleştir. Ultralytics YOLO, özel metrikler, işleme veya günlük kaydı eklemene olanak tanıyan
on_train_start,on_train_endveon_train_batch_endgibi çeşitli eğitim geri çağrıları sunar.Her eğitim epoch'unun sonunda her optimizasyon parametre grubunun öğrenme oranını şu şekilde günlüğe kaydedebilirsin:
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)İpucufreezekullanırken BatchNorm istatistiklerini dondurmak için geri çağrıya ihtiyacın yok: eğitici, dondurulmuş katmanların BatchNorm katmanlarını her epoch'un başında otomatik olarak değerlendirme moduna alır.Eğitim geri çağrılarını etkili biçimde kullanma hakkında daha fazla ayrıntı için Eğitim Kılavuzu sayfasına bak.
Doğrulama geri çağırımları, model değerlendirmesine özel işleme, günlük kaydı veya metrik hesaplama eklemene olanak tanır.
on_val_start,on_val_batch_endveon_val_endgibi geri çağırımlar, doğrulamanın her aşamasına özel mantık eklemek için giriş noktaları sağlar.Örneğin, yalnızca ilk üç doğrulama batch'ini değil tüm doğrulama batch'lerini çizmek için:
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")Doğrulama sürecine geri çağrıları ekleme hakkında daha fazla bilgi için Doğrulama Kılavuzu sayfasına bak.
Ultralytics YOLO'da tahmin modu için özel bir geri çağrı eklemek üzere bir geri çağrı işlevi tanımla ve tahmin sürecine kaydet. Yaygın tahmin geri çağrıları arasında
on_predict_start,on_predict_batch_endveon_predict_endbulunur. Bunlar, tahmin çıktılarını değiştirmene ve veri günlüğe kaydı veya sonuç dönüşümü gibi ek işlevleri entegre etmene olanak tanır.Belirli bir sınıfa ait bir nesnenin bulunup bulunmadığına göre tahminleri kaydeden özel bir geri çağrı örneği:
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: passDaha kapsamlı kullanım için ayrıntılı yönergeler ve ek özelleştirme seçenekleri içeren Tahmin Kılavuzu sayfasına bak.
Ultralytics YOLO, eğitim, doğrulama ve tahmin gibi farklı aşamaları geliştirmek ve özelleştirmek için geri çağrıların çeşitli pratik uygulamalarını destekler. Bazı pratik örnekler:
- Özel Metrikleri Günlüğe Kaydetme: Eğitim veya doğrulama epoch'larının sonunda olduğu gibi farklı aşamalarda ek metrikleri günlüğe kaydet.
- Veri Artırma: Tahmin veya eğitim batch'leri sırasında özel veri dönüşümleri ya da artırmaları uygula.
- Ara Sonuçlar: Daha ileri analiz veya görselleştirme için tahminler ya da kareler gibi ara sonuçları kaydet.
Örnek: Tahmin sırasında
on_predict_batch_endkullanarak kareleri tahmin sonuçlarıyla birleştirme: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(): passDaha fazla seçenek ve örnek için geri çağrı kaynak kodunu incele.
Yorumlar15
Bir soru sor, sonuçlarını paylaş veya başka birine yardım et.
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(düzenlendi)@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(düzenlendi)
@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(düzenlendi)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(düzenlendi)
@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.