Améliore ton jeu de données pour entraîner YOLO26 avec Albumentations
Lorsque tu développes des modèles de vision par ordinateur, la qualité et la diversité de tes données d’entraînement peuvent avoir une grande influence sur les performances de ton modèle. Albumentations offre un moyen rapide, flexible et efficace d’appliquer un large éventail de transformations d’image susceptibles d’améliorer la capacité de ton modèle à s’adapter aux situations réelles. La bibliothèque s’intègre à Ultralytics YOLO26 et peut t’aider à créer des jeux de données robustes pour la détection d’objets, la segmentation d’instances, la segmentation sémantique, l’estimation de la profondeur, l’estimation de pose et les tâches de boîtes englobantes orientées.
Albumentations ajoute des techniques comme les transformations géométriques et les ajustements de couleur à tes données d’entraînement YOLO26. Ce guide explique comment Albumentations s’intègre au pipeline d’augmentation des données d’Ultralytics et comment le personnaliser pour tes projets.
Albumentations pour l’augmentation d’images#
Albumentations est une bibliothèque open source d’augmentation d’images créée en juin 2018. Elle est conçue pour simplifier et accélérer le processus d’augmentation d’images en vision par ordinateur. Pensée pour offrir performance et flexibilité, elle prend en charge de nombreuses techniques d’augmentation, des transformations simples comme les rotations et les retournements aux ajustements plus complexes comme les modifications de luminosité et de contraste. Albumentations aide les développeurs à générer des jeux de données riches et variés pour des tâches telles que la classification d’images, la détection d’objets et la segmentation.
Tu peux facilement utiliser Albumentations pour appliquer des augmentations aux images, aux masques de segmentation, aux boîtes englobantes et aux points clés, tout en veillant à ce que tous les éléments de ton jeu de données soient transformés ensemble. La bibliothèque fonctionne avec des frameworks de deep learning populaires comme PyTorch et TensorFlow, ce qui la rend accessible pour un large éventail de projets.
Albumentations convient aussi bien aux petits jeux de données qu’aux tâches de vision par ordinateur à grande échelle. Son traitement rapide réduit le temps consacré à la préparation des données, tandis que des données d’entraînement plus variées peuvent améliorer les performances du modèle dans des applications réelles.
Principales fonctionnalités d’Albumentations#
Albumentations propose de nombreuses fonctionnalités utiles qui simplifient les augmentations d’images complexes pour un large éventail d’applications de vision par ordinateur. Voici quelques-unes de ses principales fonctionnalités :
- Large éventail de transformations : Albumentations propose plus de 70 transformations différentes, notamment des modifications géométriques (p. ex., rotation, retournement), des ajustements de couleur (p. ex., luminosité, contraste) et l’ajout de bruit (p. ex., bruit gaussien). Ces nombreuses options permettent de créer des jeux de données d’entraînement très diversifiés et robustes.
-
Optimisation des performances : conçue avec OpenCV et NumPy, Albumentations utilise des techniques d’optimisation avancées comme SIMD (Single Instruction, Multiple Data), qui traite plusieurs points de données simultanément pour accélérer le traitement. Elle traite rapidement les grands jeux de données, ce qui en fait l’une des options d’augmentation d’images les plus rapides.
-
Trois niveaux d’augmentation : Albumentations prend en charge trois niveaux d’augmentation : les transformations au niveau des pixels, les transformations spatiales et les transformations par mélange. Les transformations au niveau des pixels affectent uniquement les images d’entrée, sans modifier les masques, les boîtes englobantes ni les points clés. Les transformations spatiales modifient l’image et ses éléments, comme les masques et les boîtes englobantes. Les transformations par mélange combinent plusieurs images en une seule.

- Résultats des tests de performance : les benchmarks publiés par Albumentations montrent que sa vitesse est avantageuse par rapport à celle d’autres bibliothèques d’augmentation, en particulier sur les grands jeux de données.
Pourquoi utiliser Albumentations pour tes projets d’IA visuelle ?#
Pour l’augmentation d’images, Albumentations se distingue comme un outil fiable pour les tâches de vision par ordinateur. Voici quelques raisons essentielles d’envisager son utilisation dans tes projets d’IA visuelle :
-
API facile à utiliser : Albumentations fournit une API unique et simple pour appliquer un large éventail d’augmentations aux images, aux masques, aux boîtes englobantes et aux points clés. Elle est conçue pour s’adapter facilement à différents jeux de données, ce qui simplifie et accélère la préparation des données.
-
Tests rigoureux des bogues : les bogues dans le pipeline d’augmentation peuvent corrompre les données d’entrée sans avertissement ; ils passent souvent inaperçus, mais finissent par dégrader les performances du modèle. Albumentations répond à ce problème avec une suite de tests approfondie qui aide à détecter les bogues tôt dans le développement.
-
Extensibilité : Albumentations permet facilement d’ajouter de nouvelles augmentations et de les utiliser avec les transformations intégrées à l’aide d’une interface unique.
Comment utiliser Albumentations pour augmenter les données d’entraînement de YOLO26#
Albumentations s’intègre directement au mode d’entraînement d’Ultralytics et s’applique automatiquement lorsque le package Albumentations est installé.
Installation#
Pour utiliser Albumentations avec YOLO26, commence par vérifier que les packages nécessaires sont installés. Si Albumentations n’est pas installé, ses augmentations ne seront pas appliquées pendant l’entraînement. Une fois la bibliothèque installée, les transformations sont appliquées à la volée aux images d’entraînement.
# Install the required packages
pip install albumentations ultralyticsPour obtenir des instructions détaillées et connaître les bonnes pratiques liées à l’installation, consulte notre guide d’installation Ultralytics. Si tu rencontres des difficultés lors de l’installation des packages requis pour YOLO26, consulte notre guide des problèmes courants, qui propose des solutions et des conseils.
Les exemples de transformations personnalisées sur cette page nécessitent Albumentations 1.4.22 ou une version ultérieure, et donc Python 3.9 ou une version ultérieure.
Utilisation#
Une fois les packages nécessaires installés, tu peux commencer à utiliser Albumentations avec YOLO26. Lorsque tu entraînes YOLO26 avec Albumentations installé, un ensemble par défaut de transformations Albumentations est appliqué automatiquement.
from ultralytics import YOLO
# Charger un modèle préentraîné
model = YOLO("yolo26n.pt")
# Entraîner le modèle avec les augmentations par défaut
results = model.train(data="coco8.yaml", epochs=100, imgsz=640)Les sections suivantes décrivent les transformations Albumentations appliquées par défaut pendant l’entraînement.
Flou#
La transformation Blur d’Albumentations applique un simple effet de flou à l’image en faisant la moyenne des valeurs des pixels dans une petite zone carrée, ou noyau. Elle utilise la fonction OpenCV cv2.blur, qui contribue à réduire le bruit dans l’image, mais atténue aussi légèrement ses détails.
Voici les paramètres et les valeurs utilisés dans cette intégration :
-
blur_limit : ce paramètre définit la plage de taille de l’effet de flou. La plage par défaut est (3, 7), ce qui signifie que la taille du noyau de flou peut varier entre 3 et 7 pixels ; seules les valeurs impaires sont autorisées afin de centrer le flou.
-
p : probabilité d’appliquer le flou. Dans l’intégration, p=0.01 ; le flou a donc 1 % de chances d’être appliqué à chaque image. Cette faible probabilité permet d’introduire occasionnellement une légère variation pour aider le modèle à mieux généraliser sans trop flouter les images.
Flou médian#
La transformation MedianBlur d’Albumentations applique un flou médian à l’image, ce qui est particulièrement utile pour réduire le bruit tout en préservant les contours. Contrairement aux méthodes de flou classiques, MedianBlur utilise un filtre médian, particulièrement efficace pour éliminer le bruit impulsionnel tout en conservant la netteté des contours.
Voici les paramètres et les valeurs utilisés dans cette intégration :
-
blur_limit : ce paramètre définit la taille maximale du noyau de flou. Dans cette intégration, sa valeur par défaut correspond à une plage de (3, 7) ; la taille du noyau est donc choisie aléatoirement entre 3 et 7 pixels, seules les valeurs impaires étant autorisées pour garantir un alignement correct.
-
p : définit la probabilité d’appliquer le flou médian. Ici, p=0.01 ; la transformation a donc 1 % de chances d’être appliquée à chaque image. Cette faible probabilité garantit une utilisation parcimonieuse du flou médian et aide le modèle à généraliser en lui présentant occasionnellement des images moins bruitées dont les contours sont préservés.
L’image ci-dessous montre un exemple de cette augmentation appliquée à une image.
Niveaux de gris#
La transformation ToGray d’Albumentations convertit une image en niveaux de gris, la réduisant à un format à un seul canal, avec la possibilité de répliquer ce canal pour obtenir le nombre de canaux de sortie souhaité. Différentes méthodes permettent de calculer la luminosité en niveaux de gris, d’une simple moyenne à des techniques plus avancées offrant une perception réaliste du contraste et de la luminosité.
Voici les paramètres et les valeurs utilisés dans cette intégration :
-
num_output_channels : définit le nombre de canaux de l’image de sortie. Si cette valeur est supérieure à 1, le canal unique en niveaux de gris est répliqué pour créer une image multicanal en niveaux de gris. Par défaut, la valeur est 3 ; l’image en niveaux de gris comporte donc trois canaux identiques.
-
method : définit la méthode de conversion en niveaux de gris. La méthode par défaut, « weighted_average », applique une formule (0.299R + 0.587G + 0.114B) qui correspond étroitement à la perception humaine et produit un effet naturel en niveaux de gris. D’autres options, comme « from_lab », « desaturation », « average », « max » et « pca », offrent d’autres façons de créer des images en niveaux de gris selon les besoins en matière de vitesse, de luminosité ou de préservation des détails.
-
p : définit la fréquence d’application de la transformation en niveaux de gris. Avec p=0.01, chaque image a 1 % de chances d’être convertie en niveaux de gris ; le mélange d’images couleur et en niveaux de gris peut ainsi aider le modèle à mieux généraliser.
L’image ci-dessous montre un exemple de cette transformation en niveaux de gris.
Égalisation adaptative d’histogramme à contraste limité (CLAHE)#
La transformation CLAHE d’Albumentations applique l’égalisation adaptative d’histogramme à contraste limité (CLAHE), une technique qui améliore le contraste de l’image en égalisant l’histogramme dans des zones locales (tuiles) plutôt que sur toute l’image. CLAHE produit une amélioration équilibrée et évite l’amplification excessive du contraste qui peut résulter d’une égalisation d’histogramme classique, en particulier dans les zones dont le contraste initial est faible.
Voici les paramètres et les valeurs utilisés dans cette intégration :
-
clip_limit : contrôle la plage d’amélioration du contraste. Défini par défaut sur une plage de (1, 4), ce paramètre détermine le contraste maximal autorisé dans chaque tuile. Des valeurs plus élevées autorisent davantage de contraste, mais peuvent aussi introduire du bruit.
-
tile_grid_size : définit la taille de la grille de tuiles, généralement sous la forme (lignes, colonnes). La valeur par défaut est (8, 8), ce qui signifie que l’image est divisée en une grille de 8x8. Des tuiles plus petites permettent des ajustements plus localisés, tandis que des tuiles plus grandes produisent des effets plus proches d’une égalisation globale.
-
p : probabilité d’appliquer CLAHE. Ici, p=0.01 ; l’effet d’amélioration est donc appliqué dans seulement 1 % des cas, ce qui garantit que les ajustements du contraste restent ponctuels et apportent une variation occasionnelle aux images d’entraînement.
L’image ci-dessous montre un exemple de la transformation CLAHE appliquée.
Utiliser des transformations Albumentations personnalisées#
L’intégration Albumentations par défaut offre un ensemble solide d’augmentations, mais tu peux souhaiter personnaliser les transformations selon ton cas d’usage. Avec Ultralytics YOLO26, tu peux transmettre des transformations Albumentations personnalisées via l’API Python à l’aide du paramètre augmentations. Les exemples de cette section nécessitent Albumentations 1.4.22 ou une version ultérieure.
Comment définir des transformations personnalisées#
Tu peux définir ta propre liste de transformations Albumentations et la transmettre à la fonction d’entraînement. Cela remplace les transformations Albumentations par défaut tout en gardant actives toutes les autres augmentations YOLO (comme hsv_h, degrees, mosaic, etc.).
Voici un exemple avec des transformations plus avancées :
import albumentations as A
from ultralytics import YOLO
# Charger le modèle
model = YOLO("yolo26n.pt")
# Définir des transformations personnalisées avec diverses techniques d’augmentation
custom_transforms = [
# Variantes de flou
A.OneOf(
[
A.MotionBlur(blur_limit=7, p=1.0),
A.MedianBlur(blur_limit=7, p=1.0),
A.GaussianBlur(blur_limit=7, p=1.0),
],
p=0.3,
),
# Variantes de bruit
A.OneOf(
[
A.GaussNoise(std_range=(0.0124, 0.0277), p=1.0),
A.ISONoise(color_shift=(0.01, 0.05), intensity=(0.1, 0.5), p=1.0),
],
p=0.2,
),
# Ajustements de couleur et de contraste
A.CLAHE(clip_limit=4.0, tile_grid_size=(8, 8), p=0.5),
A.RandomBrightnessContrast(brightness_limit=0.3, contrast_limit=0.3, p=0.5),
A.HueSaturationValue(hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=20, p=0.5),
# Simuler des occultations
A.CoarseDropout(num_holes_range=(1, 8), hole_height_range=(8, 32), hole_width_range=(8, 32), fill=0, p=0.2),
]
# Entraîner avec des transformations personnalisées
results = model.train(
data="coco8.yaml",
epochs=100,
imgsz=640,
augmentations=custom_transforms,
)Points importants à prendre en compte#
Lorsque tu utilises des transformations Albumentations personnalisées, garde ces points à l’esprit :
- Configuration : Construis des objets de transformation personnalisés via l’API Python. Tu peux aussi transmettre des transformations sérialisées via la CLI ou des fichiers de configuration YAML, y compris lors de la reprise de l’entraînement.
- Remplacement des paramètres par défaut : Tes transformations personnalisées remplaceront entièrement les transformations Albumentations par défaut. Les autres augmentations YOLO restent actives.
- Gestion des annotations : Les transformations spatiales, y compris celles imbriquées dans
A.OneOfouA.Compose, déplacent les boîtes englobantes, les polygones, les points clés et les masques de profondeur ou sémantiques en même temps que l’image.A.RandomGridShufflene peut pas préserver la topologie des polygones ou des points clés et déclenche une erreur pour les échantillons de segmentation, de pose et OBB. - Performances : Certaines transformations sont coûteuses en calcul. Surveille la vitesse d’entraînement et ajuste-la en conséquence.
- Compatibilité avec les tâches : Les transformations Albumentations personnalisées fonctionnent avec l’entraînement pour la détection, la segmentation, la segmentation sémantique, la profondeur, la pose et OBB, mais pas avec la classification (qui utilise un pipeline d’augmentation différent).
Cas d’utilisation des transformations personnalisées#
Différentes applications tirent parti de stratégies d’augmentation différentes :
- Imagerie médicale : Utilise des déformations élastiques, des distorsions de grille et des motifs de bruit spécialisés
- Imagerie aérienne/satellite : Applique des transformations qui simulent différentes altitudes, conditions météorologiques et angles d’éclairage
- Scénarios de faible luminosité : Mets l’accent sur l’ajout de bruit et les ajustements de luminosité pour entraîner des modèles robustes dans des conditions d’éclairage difficiles
- Inspection industrielle : Ajoute des variations de texture et des défauts simulés pour les applications de contrôle qualité
Pour obtenir la liste complète des transformations disponibles et de leurs paramètres, consulte la documentation Albumentations.
Pour des exemples plus détaillés et des bonnes pratiques sur l’utilisation de transformations Albumentations personnalisées avec YOLO26, consulte le guide sur l’augmentation des données YOLO.
Poursuivre l’apprentissage d’Albumentations#
Si tu souhaites en savoir plus sur Albumentations, consulte les ressources suivantes pour trouver des instructions et des exemples plus détaillés :
-
Documentation Albumentations : La documentation officielle présente l’ensemble des transformations prises en charge et des techniques d’utilisation avancées.
-
Référence de l’API Ultralytics Albumentations : consulte les détails de la classe qui implémente cette intégration.
-
Dépôt GitHub d’Albumentations : Le dépôt comprend des exemples, des benchmarks et des discussions pour t’aider à personnaliser les augmentations.
Points essentiels à retenir#
Dans ce guide, nous avons exploré les principaux aspects d’Albumentations, une bibliothèque Python dédiée à l’augmentation d’images. Nous avons abordé son large éventail de transformations, ses performances optimisées et la manière de l’utiliser dans ton prochain projet YOLO26.
FAQ#
Albumentations s’intègre à YOLO26 et s’applique automatiquement pendant l’entraînement si le package est installé. Voici comment commencer :
# Installer les packages requis # !pip install albumentations ultralytics from ultralytics import YOLO # Charger et entraîner le modèle avec des augmentations automatiques model = YOLO("yolo26n.pt") model.train(data="coco8.yaml", epochs=100)L’intégration par défaut applique le flou, le flou médian, la conversion en niveaux de gris et CLAHE, chacun avec une faible probabilité de 1 %, afin d’apporter occasionnellement de la diversité sans dominer l’entraînement.
Albumentations se distingue pour plusieurs raisons :
- Performances : s’appuie sur OpenCV et NumPy avec une optimisation SIMD pour une vitesse élevée
- Flexibilité : Prend en charge plus de 70 transformations réparties entre les augmentations au niveau des pixels, de l’espace et du mélange
- Compatibilité : fonctionne avec des frameworks populaires comme PyTorch et TensorFlow
- Fiabilité : Une suite de tests complète prévient toute corruption silencieuse des données
- Facilité d’utilisation : Une API unifiée unique pour tous les types d’augmentation
Albumentations améliore diverses tâches de vision par ordinateur, notamment :
- Détection d’objets : Améliore la robustesse du modèle face aux variations d’éclairage, d’échelle et d’orientation
- Segmentation d’instances : Améliore la précision de prédiction des masques grâce à des transformations variées
- Estimation de pose : Aide les modèles à s’adapter à différents points de vue et conditions d’éclairage
- Détection de boîtes englobantes orientées : Ajoute des variations de couleur et de bruit aux images aériennes et aux images d’objets pivotés
Les diverses options d’augmentation de la bibliothèque en font un outil précieux pour les tâches de vision nécessitant des performances robustes du modèle. Dans Ultralytics YOLO26, l’entraînement en classification utilise son propre pipeline d’augmentation basé sur torchvision et n’applique pas les transformations Albumentations.
Commentaires19
Pose une question, partage tes résultats ou aide quelqu’un d’autre.
anushka-kore
Is there a way that we can define more custom albumentations transforms to be applied during model train? If yes, will they also change the bounding box coords accordingly if they are spatial transforms?
manuelescobar5036
The albumentations transforms are defined in the ultralytics/data/augment.py file. There you can find the following function that returns the transforms to be applied to the images, which includes the Albumentations transform.
Then, in the same file you can find the Albumentations class which defines the pipeline. In this pipeline you can add the new transforms that you want.
Bouding boxes are changed accordingly to their spatial transforms. This is done when you pass bbox_params to the Albumentations pipeline.
Glenn JocherUltralytics(modifié)@anushka-kore Yes. Pass your own Albumentations transforms to training with the
augmentationsargument (Python only):import albumentations as A from ultralytics import YOLO model = YOLO("yolo26n.pt") model.train(data="coco8.yaml", augmentations=[A.Blur(p=0.01), A.CLAHE(p=0.01)])Spatial transforms (rotation, flips, perspective, etc.) are applied together with the bounding boxes, which are updated automatically through Albumentations' bbox handling in YOLO format. Non-spatial transforms like color adjustments only change the image. See the Albumentations integration guide for details.
anushka-kore
Thanks a lot for the inputs @deox1994 and @glenn-jocher! I have made it work👍🏻
anushka-kore
Hey @glenn-jocher and @deox1994, I later realised that simply defining my list of custom transform in the augment.py file is not working. This is the part I changed in the augment.py file (original ones are commented out)-
T = [ #A.Blur(p=0.01), #A.MedianBlur(p=0.01), #A.ToGray(p=0.01), #A.CLAHE(p=0.01), A.RandomBrightnessContrast(p=0.2), #A.RandomGamma(p=0.0), #A.ImageCompression(quality_range=(75, 100), p=0.0), A.HorizontalFlip(p=0.5), A.VerticalFlip(p=0.5), A.Rotate(limit=30, p=0.5), A.GaussianBlur(p=0.2), A.GaussNoise(p=0.2), ]For your reference, this is the error I get, you could view the list of albumentation transforms I applied here as well- ..... Transferred 1009/1015 items from pretrained weights Freezing layer 'model.23.dfl.conv.weight' AMP: running Automatic Mixed Precision (AMP) checks... AMP: checks passed ✅ train: Scanning /home/xxx/dataset_MIP_clean/train/labels.cache... 831 images, 73 backgrounds, 0 corrupt: 100%|██████████| 831/831 [00:00<?, ?it/s] albumentations: RandomBrightnessContrast(p=0.2, brightness_by_max=True, brightness_limit=(-0.2, 0.2), contrast_limit=(-0.2, 0.2), ensure_safe_range=False), HorizontalFlip(p=0.5), VerticalFlip(p=0.5), Rotate(p=0.5, border_mode=0, crop_border=False, fill=0.0, fill_mask=0.0, interpolation=1, limit=(-30.0, 30.0), mask_interpolation=0, rotate_method='largest_box'), GaussianBlur(p=0.2, blur_limit=(0, 0), sigma_limit=(0.5, 3.0)), GaussNoise(p=0.2, mean_range=(0.0, 0.0), noise_scale_factor=1.0, per_channel=True, std_range=(0.2, 0.44)) val: Scanning /home/xxx/dataset_MIP_clean/val/labels.cache... 210 images, 13 backgrounds, 0 corrupt: 100%|██████████| 210/210 [00:00<?, ?it/s] Plotting labels to /home/xxx/yolov11_predictions/test4/labels.jpg... optimizer: 'optimizer=auto' found, ignoring 'lr0=0.01' and 'momentum=0.937' and determining best 'optimizer', 'lr0' and 'momentum' automatically... optimizer: AdamW(lr=0.000769, momentum=0.9) with parameter groups 167 weight(decay=0.0), 174 weight(decay=0.0005), 173 bias(decay=0.0) Image sizes 640 train, 640 val Using 8 dataloader workers Logging results to /home/xxx/yolov11_predictions/test4 Starting training for 200 epochs...
Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size 1/200 15.4G 5.502 51.38 2.745 17 640: 10%|▉ | 5/52 [00:02<00:22, 2.07it/s]Traceback (most recent call last): File "/home/xxx/yolo_train.py", line 149, in train_yolo(output_dir) File "/home/xxx/yolo_train.py", line 116, in train_yolo results = model.train( ^^^^^^^^^^^^ File "/home/xxx/env/lib/python3.12/site-packages/ultralytics/engine/model.py", line 791, in train self.trainer.train() File "/home/xxx/env/lib/python3.12/site-packages/ultralytics/engine/trainer.py", line 211, in train self._do_train(world_size) File "/home/xxx/env/lib/python3.12/site-packages/ultralytics/engine/trainer.py", line 366, in _do_train for i, batch in pbar: ^^^^ File "/home/xxx/env/lib/python3.12/site-packages/tqdm/std.py", line 1178, in iter for obj in iterable: ^^^^^^^^ File "/home/xxx/env/lib/python3.12/site-packages/ultralytics/data/build.py", line 59, in iter yield next(self.iterator) ^^^^^^^^^^^^^^^^^^^ File "/home/xxx/env/lib/python3.12/site-packages/torch/utils/data/dataloader.py", line 708, in next data = self._next_data() ^^^^^^^^^^^^^^^^^ File "/home/xxx/env/lib/python3.12/site-packages/torch/utils/data/dataloader.py", line 1455, in _next_data return self._process_data(data) ^^^^^^^^^^^^^^^^^^^^^^^^ File "/home/xxx/env/lib/python3.12/site-packages/torch/utils/data/dataloader.py", line 1505, in _process_data data.reraise() File "/home/xxx/env/lib/python3.12/site-packages/torch/_utils.py", line 733, in reraise raise exception RuntimeError: Caught RuntimeError in DataLoader worker process 5. Original Traceback (most recent call last): File "/home/xxx/env/lib/python3.12/site-packages/torch/utils/data/_utils/worker.py", line 349, in _worker_loop data = fetcher.fetch(index) # type: ignore[possibly-undefined] ^^^^^^^^^^^^^^^^^^^^ File "/home/xxx/env/lib/python3.12/site-packages/torch/utils/data/_utils/fetch.py", line 55, in fetch return self.collate_fn(data) ^^^^^^^^^^^^^^^^^^^^^ File "/home/xxx/env/lib/python3.12/site-packages/ultralytics/data/dataset.py", line 298, in collate_fn value = torch.cat(value, 0) ^^^^^^^^^^^^^^^^^^^ RuntimeError: Tensors must have same number of dimensions: got 1 and 2
All my transforms are correctly defined, and the spatial transforms (horizontalflip, verticalflip and rotate) exist in the spatial_transforms list. Could you please point where this is going wrong?
supriamir
Hi Glen,
I would like to optimize the hyperparameters using model.tune(). My goal is to identify the most important augmentations from Albumentations.
If I am not mistaken, the default hyperparameter optimization only includes a limited set of augmentation parameters, as described in the following link: https://docs.ultralytics.com/integrations/ray-tune/#tune-method-parameters
Could you advise how I can include and optimize additional Albumentations transforms beyond the default settings?
Glenn JocherUltralyticsYes, but not directly through the default
model.tune()search set: custom Albumentations are a Python-onlyaugmentationslist passed tomodel.train(), while the built-in tuner mutates the numericspace, so the usual workflow is to keep one fixedaugmentations=pipeline per tuning run and compare the best result across several candidate pipelines; if you want to search the pipeline itself, use a small custom Ray Tune wrapper aroundmodel.train()instead, and keep the standard YOLO augmentations fixed so you isolate the Albumentations effect—see the hyperparameter tuning guide and the Albumentations integration guide.
UltralyticsAssistantUltralytics
👋 Hello, thank you for your interest in Ultralytics 🚀! We recommend visiting the Docs for guidance—there you’ll find many Python and CLI usage examples, and answers to many common questions.
If this is a 🐛 Bug Report, please provide a minimum reproducible example to help us investigate.
If you have a custom training ❓ Question, please share as much relevant information as possible, including dataset image examples and training logs. Also, make sure to review our Tips for Best Training Results.
You’re welcome to join the Ultralytics community where it fits you best:
- For real-time chat, join us on Discord 🎧
- For in-depth discussions, visit Discourse
- For community sharing, check out our Subreddit
Upgrade
Upgrade to the latest
ultralyticspackage and all requirements in a Python>=3.8 environment with PyTorch>=1.8 to ensure you’re on the latest version:pip install -U ultralyticsEnvironments
YOLO can be run in any of the following up-to-date verified environments (with all dependencies like CUDA/CUDNN, Python, and PyTorch preinstalled):
- Notebooks with free GPU:
- Google Cloud Deep Learning VM. See GCP Quickstart Guide
- Amazon Deep Learning AMI. See AWS Quickstart Guide
- Docker Image. See Docker Quickstart Guide
Status
If this badge is green, all Ultralytics CI tests are currently passing. These tests confirm correct operation of all YOLO Modes and Tasks on macOS, Windows, and Ubuntu every 24 hours and on every commit.
This is an automated response 🤖. An Ultralytics engineer will assist you here soon!
Glenn JocherUltralytics欢迎来到 Ultralytics 中文文档的 Albumentations 集成讨论区!如果您对使用 Albumentations 来增强 YOLO11 训练数据有任何问题或想法,请在这里提出。
Albumentations 与 YOLO11 的集成非常简便,只需安装
albumentations包,就会在训练过程中自动应用多种图像增强技术,如模糊、中值模糊、灰度转换和 CLAHE,帮助您的模型更好地适应各种真实场景。您是否在特定项目中使用过 Albumentations?或者您对如何最佳配置这些增强技术有疑问?请随时在这里分享您的经验或提出问题,Ultralytics 团队将很乐意提供帮助!
UltralyticsAssistantUltralytics
👋 Hello, thank you for your interest in Ultralytics 🚀! We recommend visiting the Docs for guidance on integrations like Albumentations with YOLO11. You can also review many Python and CLI examples, and frequently asked questions may already be addressed there.
If this is a 🐛 Bug Report, please include a minimum reproducible example to help us investigate further.
If you have a custom training ❓ Question, please provide detailed info such as dataset image samples, training logs, and confirm you are following our Tips for Best Training Results.
Join the Ultralytics community wherever you prefer—real-time chat on Discord 🎧, in-depth discussions on Discourse, or knowledge-sharing on our Subreddit.
Upgrade
Upgrade to the latest
ultralyticspackage and all requirements in a Python>=3.8 environment with PyTorch>=1.8 to ensure your issue is not already fixed in the latest version:pip install -U ultralyticsEnvironments
YOLO may be run in any of the following verified and up-to-date environments (with all dependencies including CUDA/CUDNN, Python and PyTorch preinstalled):
- Notebooks with free GPU:
- Google Cloud Deep Learning VM. See GCP Quickstart Guide
- Amazon Deep Learning AMI. See AWS Quickstart Guide
- Docker Image. See Docker Quickstart Guide
Status
If this badge is green, all Ultralytics CI tests are currently passing. These tests verify correct operation of all YOLO Modes and Tasks on macOS, Windows, and Ubuntu every 24 hours and on every commit.
This is an automated response. An Ultralytics engineer will review and assist you soon!
Glenn JocherUltralyticsBonjour! N'hésitez pas à poser vos questions sur l'intégration d'Albumentations avec YOLO11 dans cette discussion. Cette intégration vous permet d'améliorer automatiquement votre jeu de données pendant l'entraînement avec diverses transformations comme le flou, le flou médian, la conversion en niveaux de gris et CLAHE.
L'avantage principal est sa simplicité d'utilisation - il suffit d'installer les packages requis et les augmentations sont appliquées automatiquement pendant l'entraînement:
pip install albumentations ultralyticsSi vous rencontrez des difficultés avec cette intégration ou si vous avez des questions sur l'augmentation de données pour améliorer les performances de vos modèles YOLO11, n'hésitez pas à les partager ici!
- Notebooks with free GPU:
manuelescobar5036(modifié)
Dear Ultralytics team,
I’m working on a project focused on detecting the behavior of workers in underground mines. The classes and the number of labels per class in the training set are as follows:
- Sitting → 2500
- Standing → 9000
- Operation → 700
- Lean Against → 4000
- Tumble → 400
Since the dataset is imbalanced, I would like to apply data augmentation to avoid overfitting and improve accuracy. While researching YOLO's data augmentation capabilities, a few questions came up:
- As far as I understand, YOLO currently supports two methods for performing data augmentation:
- Modifying individual hyperparameters such as hsv_h, hsv_s, hsv_v, degrees, translate, etc., in the ultralytics/cfg/default.yaml file (does not require the Albumentations Python Library).
- Using the Albumentations Python Library (previously installed).
Is this correct? If so, what are the differences between the two methods, and which one is currently recommended?
-
Considering both options from question 1, does YOLO apply data augmentation only to images from the classes with less labels, or to images from all classes? I ask because if I have an imbalanced dataset and YOLO applies data augmentation to images from all classes, the imbalance would remain, wouldn’t it?
-
If I choose to use an older YOLO model, such as yolov8n.yaml, and I have Albumentations installed, will Albumentations-based data augmentation be applied during training?
-
What other suggestions would you recommend for dealing with imbalanced classes?
safwene-bahroun
Hello @glenn-jocher , Do you can , please , answer to these questions , because the same questions and problem.
THANKS
Glenn JocherUltralytics@deox1994 Thanks for your detailed questions about data augmentation in YOLO for handling your imbalanced mining worker dataset. Let me address each point:
- Yes, you're correct about the two augmentation approaches:
- Built-in YOLO augmentations (hsv_h, translate, scale, etc.) which are always available
- Albumentations integration which activates automatically when the library is installed
The key difference is that built-in augmentations focus primarily on geometric and color transformations, while Albumentations adds more specialized transformations like blur, grayscale, and CLAHE with carefully tuned probabilities (typically 0.01 as shown in the reference code). Both work together complementarily rather than being exclusive options.
-
Both augmentation methods apply to all images regardless of class. To address your imbalance specifically, consider:
- Using a weighted loss function
- Implementing class-aware sampling during training
- Creating custom data pipeline that applies additional augmentations to underrepresented classes
-
Yes, if Albumentations is installed, it will be automatically applied when training YOLOv8 models too. The integration is part of the Ultralytics framework, not specific to YOLO11.
-
For handling imbalanced classes beyond augmentation:
- Apply weighted loss based on inverse class frequency
- Use focal loss which naturally handles class imbalance better
- Consider different evaluation metrics (precision/recall per class rather than just mAP)
- Experiment with undersampling majority classes or oversampling minority classes
You can find implementation details for these approaches in the data augment reference documentation.
- Yes, you're correct about the two augmentation approaches:
safwene-bahroun
Good morning ,@glenn-jocher, do you can help me ?
{ "total_images": 39152, "total_detections": 70910, "instances_per_class": { "Dress": 52999, "Skirt": 1259, "Handbag": 2495, "High heels": 3124, "Swimwear": 10079, "Miniskirt": 954 } } i will train this with yolo11n.pt and with albumentation the code : from ultralytics import YOLO import torch
def main(): # Load a pretrained YOLO model model = YOLO("yolo11n.pt") # Set device device = "cuda" if torch.cuda.is_available() else "cpu" print(f"Using device: {device}")
if device == "cuda": print(f"GPU name: {torch.cuda.get_device_name(0)}") # Debug: Print dataset configuration print("Training with dataset: OpenImagesV7-women.yaml") # Train the model with enhanced hyperparameters results = model.train( data="OpenImagesV7-woman.yaml", epochs=150, imgsz=640, device=device, batch=16, optimizer ="auto")
Dataset configuration
path: ../datasets/open-images-v7 train: c:\Users\GIGABYTE\datasets\open-images-v7\train val: C:/Users/GIGABYTE/datasets/open-images-v7/val
nc: 6 names: 0: Dress 1: High heels 2: Miniskirt 3: Skirt 4: Swimwear 5: Handbag
Hyperparameters for extreme imbalance
loss: cls_weight: [0.3, 0.5, 7.0, 5.0, 0.4, 0.6] # Calculated weights below box: 0.05 obj: 1.0 label_smoothing: 0.1
Strategic augmentation
augment:
For rare classes (Miniskirt, Skirt)
copy_paste: 0.7 # High frequency for rare classes paste_classes: [2, 3] # Only Miniskirt(class2)/Skirt(class3) paste_scale: [0.3, 0.7] # Realistic resizing of pasted objects
General augmentations (applied to all)
mosaic: 1.0 # Helps context learning mixup: 0.05 # Reduced to avoid label confusion fliplr: 0.5 hsv_h: 0.015 # Mild color variation degrees: 5.0 # Small rotation for fashion items
Training parameters
batch: 16 # Match GPU capacity accumulate: 4 # Simulates batch=64 epochs: 150 # Longer training for rare classes patience: 50 # Early stopping if no improveme
but i trained untill now :
Epoch GPU_mem box_loss cls_loss dfl_loss Instances Size 104/150 2.92G 1.026 0.9478 1.206 55 640: 100%|██████████| 2447/2447 [07:51<00:00, Class Images Instances Box(P R mAP50 mAP50-95): 100%|██████████| 32/32 [00:06 all 1016 1987 0.581 0.525 0.536 0.423Can you help me please to reach all metrics above 0.8
THANKS
hillsonghimire
Even when I turned off augment=False, albumentation-related operations were still performed in yolo11. How to completely turn it off/disable?
Glenn JocherUltralytics@hillsonghimire to completely disable Albumentations augmentations in YOLO11, uninstall the Albumentations package since its presence automatically enables the integration. Run
pip uninstall albumentationsand verify it's removed from your environment. This will prevent any Albumentations transformations from being applied regardless of other settings. For more details, see the Albumentations integration guide.
DP1701
Thanks for this explanation. But if I understand correctly, not all functions of Albuminations are directly supported, or am I misunderstanding?
The explanation says: The integration includes optimized augmentations like blur, median blur, grayscale conversion, and CLAHE with carefully tuned probabilities to enhance model performance.
So only blur, median blur, grayscale conversion and CLAHE are applied and the others cannot be individually selected and adjusted?
Glenn JocherUltralytics(modifié)The integration with Albumentations in YOLO11 automatically applies specific augmentations like blur, median blur, grayscale conversion, and CLAHE. While these are the default transformations used to enhance model performance, you can pass your own Albumentations transforms to
model.train()with theaugmentationsargument (Python only).