Augmentation de données avec Ultralytics YOLO#

Introduction#

Data augmentation est une technique essentielle en vision par ordinateur qui permet d'étendre artificiellement ton jeu de données d'entraînement en appliquant diverses transformations aux images existantes. Lors de l'entraînement de modèles de deep learning comme Ultralytics YOLO, l'augmentation de données aide à améliorer la robustesse du modèle, réduit le surapprentissage (overfitting) et renforce la généralisation à des scénarios du monde réel.

Pourquoi l'augmentation de données est importante#

L'augmentation de données sert plusieurs objectifs critiques lors de l'entraînement de modèles de vision par ordinateur :

• Jeu de données étendu : En créant des variations à partir d'images existantes, tu peux augmenter efficacement la taille de ton jeu de données d'entraînement sans collecter de nouvelles données.
• Généralisation améliorée : Les modèles apprennent à reconnaître des objets dans diverses conditions, les rendant plus robustes dans les applications réelles.
• Surapprentissage réduit : En introduisant de la variabilité dans les données d'entraînement, les modèles sont moins susceptibles de mémoriser les caractéristiques spécifiques des images.
• Performance améliorée : Les modèles entraînés avec une augmentation appropriée obtiennent généralement une meilleure précision sur les ensembles de validation et de test.

L'implémentation d'Ultralytics YOLO fournit une suite complète de techniques d'augmentation, chacune servant des objectifs spécifiques et contribuant aux performances du modèle de différentes manières. Ce guide explore les paramètres d'augmentation ci-dessous, t'aidant à comprendre quand et comment les utiliser efficacement dans tes projets.

Exemples de configurations#

Tu peux personnaliser chaque paramètre en utilisant l'API Python, l'interface de ligne de commande (CLI) ou un fichier de configuration. Voici ci-dessous des exemples sur la façon de configurer l'augmentation de données pour chaque méthode.

import albumentations as A

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")

# Training with custom augmentation parameters
model.train(data="coco8.yaml", epochs=100, hsv_h=0.03, hsv_s=0.6, hsv_v=0.5)

# Training with every configurable augmentation disabled (disabled values omitted for clarity)
model.train(
    data="coco8.yaml",
    epochs=100,
    hsv_h=0.0,
    hsv_s=0.0,
    hsv_v=0.0,
    translate=0.0,
    scale=0.0,
    fliplr=0.0,
    mosaic=0.0,
    erasing=0.0,
    auto_augment=None,
)

# Training with custom Albumentations transforms (Python API only)
custom_transforms = [
    A.Blur(blur_limit=7, p=0.5),
    A.CLAHE(clip_limit=4.0, p=0.5),
]
model.train(data="coco8.yaml", epochs=100, augmentations=custom_transforms)

Utilisation d'un fichier de configuration#

Tu peux définir tous les paramètres d'entraînement, y compris les augmentations, dans un fichier de configuration YAML (par exemple, train_custom.yaml). Le paramètre mode n'est requis que lors de l'utilisation de la CLI. Ce nouveau fichier YAML remplacera alors le fichier par défaut situé dans le paquet ultralytics.

# train_custom.yaml
# 'mode' is required only for CLI usage
mode: train
data: coco8.yaml
model: yolo26n.pt
epochs: 100
hsv_h: 0.03
hsv_s: 0.6
hsv_v: 0.5

Ensuite, lance l'entraînement avec l'API Python :

from ultralytics import YOLO

# Load a COCO-pretrained YOLO26n model
model = YOLO("yolo26n.pt")

# Train the model with custom configuration
model.train(cfg="train_custom.yaml")

Augmentations de l'espace colorimétrique#

Ajustement de la teinte (hsv_h)#

• Plage : 0.0 - 1.0
• Par défaut : 0.015
• Utilisation : Modifie les couleurs de l'image tout en préservant leurs relations. L'hyperparamètre hsv_h définit l'amplitude du décalage, l'ajustement final étant choisi aléatoirement entre -hsv_h et hsv_h. Par exemple, avec hsv_h=0.3, le décalage est sélectionné aléatoirement entre -0.3 et 0.3. Pour des valeurs supérieures à 0.5, le décalage de teinte boucle autour du cercle chromatique, ce qui explique pourquoi les augmentations se ressemblent entre 0.5 et -0.5.
• Objectif : Particulièrement utile pour les scénarios en extérieur où les conditions d'éclairage peuvent affecter radicalement l'apparence des objets. Par exemple, une banane peut paraître plus jaune sous un soleil éclatant mais plus verdâtre à l'intérieur.
• Implémentation d'Ultralytics : RandomHSV

-0.5	-0.25	0.0	0.25	0.5

Ajustement de la saturation (hsv_s)#

• Plage : 0.0 - 1.0
• Par défaut : 0.7
• Utilisation : Modifie l'intensité des couleurs dans l'image. L'hyperparamètre hsv_s définit l'amplitude du décalage, l'ajustement final étant choisi aléatoirement entre -hsv_s et hsv_s. Par exemple, avec hsv_s=0.7, l'intensité est sélectionnée aléatoirement entre -0.7 et 0.7.
• Objectif : Aide les modèles à gérer des conditions météorologiques et des réglages de caméra variables. Par exemple, un panneau de signalisation rouge peut paraître très vif un jour ensoleillé mais terne et délavé dans des conditions brumeuses.
• Implémentation d'Ultralytics : RandomHSV

-1.0	-0.5	0.0	0.5	1.0

Ajustement de la luminosité (hsv_v)#

• Plage : 0.0 - 1.0
• Par défaut : 0.4
• Utilisation : Modifie la luminosité de l'image. L'hyperparamètre hsv_v définit l'amplitude du décalage, l'ajustement final étant choisi aléatoirement entre -hsv_v et hsv_v. Par exemple, avec hsv_v=0.4, l'intensité est sélectionnée aléatoirement entre -0.4 et 0.4.
• Objectif : Essentiel pour entraîner des modèles qui doivent fonctionner dans différentes conditions d'éclairage. Par exemple, une pomme rouge peut paraître brillante au soleil mais beaucoup plus sombre à l'ombre.
• Implémentation d'Ultralytics : RandomHSV

-1.0	-0.5	0.0	0.5	1.0

Transformations géométriques#

Rotation (degrees)#

• Plage : de 0.0 à 180
• Par défaut : 0
• Utilisation : Fait pivoter les images de manière aléatoire dans la plage spécifiée. L'hyperparamètre degrees définit l'angle de rotation, l'ajustement final étant choisi aléatoirement entre -degrees et degrees. Par exemple, avec degrees=10.0, la rotation est sélectionnée aléatoirement entre -10.0 et 10.0.
• Objectif : Crucial pour les applications où les objets peuvent apparaître à différentes orientations. Par exemple, dans l'imagerie par drone aérien, les véhicules peuvent être orientés dans n'importe quelle direction, exigeant des modèles qu'ils reconnaissent les objets indépendamment de leur rotation.
• Implémentation d'Ultralytics : RandomPerspective

-180	-90	0.0	90	180

Translation (translate)#

• Plage : 0.0 - 1.0
• Par défaut : 0.1
• Utilisation : Déplace les images horizontalement et verticalement d'une fraction aléatoire de la taille de l'image. L'hyperparamètre translate définit l'amplitude du déplacement, l'ajustement final étant choisi aléatoirement deux fois (une fois pour chaque axe) dans la plage -translate et translate. Par exemple, avec translate=0.5, la translation est sélectionnée aléatoirement entre -0.5 et 0.5 sur l'axe des x, et une autre valeur aléatoire indépendante est sélectionnée dans la même plage sur l'axe des y.
• Objectif : Aide les modèles à apprendre à détecter les objets partiellement visibles et améliore la robustesse à la position des objets. Par exemple, dans les applications d'évaluation des dommages aux véhicules, les pièces de carrosserie peuvent apparaître entièrement ou partiellement dans le cadre selon la position et la distance du photographe, l'augmentation par translation apprendra au modèle à reconnaître ces caractéristiques indépendamment de leur intégralité ou de leur position.
• Implémentation d'Ultralytics : RandomPerspective
• Remarque : Par souci de simplicité, les translations appliquées ci-dessous sont les mêmes à chaque fois pour les axes x et y. Les valeurs -1.0 et 1.0 ne sont pas affichées car elles déplaceraient l'image complètement hors du cadre.

-0.5	-0.25	0.0	0.25	0.5

Échelle (scale)#

• Plage : 0.0 - 1.0 sous forme de nombre à virgule flottante, ou un tuple explicite (min, max)
• Par défaut : 0.5
• Utilisation : Redimensionne les images d'un facteur aléatoire dans la plage spécifiée. Sous forme de nombre à virgule flottante, l'hyperparamètre scale définit le gain de mise à l'échelle, le facteur final étant choisi aléatoirement entre 1-scale et 1+scale. Par exemple, avec scale=0.5, la mise à l'échelle est sélectionnée aléatoirement entre 0.5 et 1.5. Sous forme de tuple, scale définit directement cette plage, de sorte que scale=(0.5, 2.0) échantillonne le facteur entre 0.5 et 2.0.
• Objectif : Permet aux modèles de gérer des objets à différentes distances et tailles. Par exemple, dans les applications de conduite autonome, les véhicules peuvent apparaître à diverses distances de la caméra, exigeant que le modèle les reconnaisse quelle que soit leur taille.
• Implémentation d'Ultralytics : RandomPerspective
• Remarque :
  • La valeur -1.0 n'est pas affichée car elle ferait disparaître l'image, tandis que 1.0 entraîne simplement un zoom 2x.
  • Les valeurs affichées dans le tableau ci-dessous sont les deltas d'échelle réalisés, et non les valeurs que tu passes à l'hyperparamètre scale.
  • La forme en nombre à virgule flottante est validée pour la plage 0.0 - 1.0, et une valeur en dehors de celle-ci génère une erreur ValueError. Pour échantillonner un facteur au-delà d'un zoom 2x, passe plutôt la forme de tuple (min, max).
  • La forme de tuple s'applique uniquement aux tâches géométriques. L'entraînement de classification dérive sa propre plage de recadrage à partir du nombre à virgule flottante (1.0 - scale à 1.0), donc y passer un tuple génère une erreur TypeError.

-0.5	-0.25	0.0	0.25	0.5

Cisaillement (Shear) (shear)#

• Plage : de -180 à +180
• Par défaut : 0
• Utilisation : Introduit une transformation géométrique qui déforme l'image le long des axes x et y, déplaçant efficacement des parties de l'image dans une direction tout en maintenant des lignes parallèles. L'hyperparamètre shear définit l'angle de cisaillement, l'ajustement final étant choisi aléatoirement entre -shear et shear. Par exemple, avec shear=10.0, le cisaillement est sélectionné aléatoirement entre -10 et 10 sur l'axe des x, et une autre valeur aléatoire indépendante est sélectionnée dans la même plage sur l'axe des y.
• Objectif : Aide les modèles à se généraliser aux variations d'angles de vue causées par de légères inclinaisons ou des points de vue obliques. Par exemple, dans la surveillance du trafic, des objets comme les voitures et les panneaux de signalisation peuvent paraître inclinés en raison de placements de caméra non perpendiculaires. L'application d'une augmentation par cisaillement garantit que le modèle apprend à reconnaître les objets malgré de telles distorsions inclinées.
• Implémentation d'Ultralytics : RandomPerspective
• Remarque :
  • Les valeurs de shear peuvent rapidement déformer l'image, il est donc recommandé de commencer avec de petites valeurs et de les augmenter progressivement.
  • Contrairement aux transformations de perspective, le cisaillement n'introduit pas de profondeur ou de points de fuite mais déforme plutôt la forme des objets en changeant leurs angles tout en gardant les côtés opposés parallèles.

-10	-5	0.0	5	10

Perspective (perspective)#

• Plage : 0.0 - 0.001
• Par défaut : 0
• Utilisation : Applique une transformation de perspective complète le long des axes x et y, simulant l'apparence d'objets vus depuis différentes profondeurs ou angles. L'hyperparamètre perspective définit l'amplitude de la perspective, l'ajustement final étant choisi aléatoirement entre -perspective et perspective. Par exemple, avec perspective=0.001, la perspective est sélectionnée aléatoirement entre -0.001 et 0.001 sur l'axe des x, et une autre valeur aléatoire indépendante est sélectionnée dans la même plage sur l'axe des y.
• Objectif : L'augmentation de perspective est cruciale pour gérer les changements de point de vue extrêmes, surtout lorsque les objets paraissent raccourcis ou déformés par des changements de perspective. Par exemple, dans la détection d'objets par drone, les bâtiments, routes et véhicules peuvent sembler étirés ou compressés selon l'inclinaison et l'altitude du drone. En appliquant des transformations de perspective, les modèles apprennent à reconnaître les objets malgré ces distorsions, améliorant ainsi leur robustesse lors des déploiements en conditions réelles.
• Implémentation d'Ultralytics : RandomPerspective

-0.001	-0.0005	0.0	0.0005	0.001

Retournement vertical (Flip Up-Down) (flipud)#

• Plage : 0.0 - 1.0
• Par défaut : 0
• Utilisation : Effectue un retournement vertical en inversant l'image le long de l'axe des y. Cette transformation met toute l'image sens dessus dessous tout en préservant toutes les relations spatiales entre les objets. L'hyperparamètre flipud définit la probabilité d'appliquer la transformation, une valeur de flipud=1.0 garantissant que toutes les images sont retournées et une valeur de flipud=0.0 désactivant complètement la transformation. Par exemple, avec flipud=0.5, chaque image a 50 % de chances d'être retournée sens dessus dessous.
• Objectif : Utile dans les scénarios où les objets peuvent apparaître à l'envers. Par exemple, dans les systèmes de vision robotique, des objets sur des tapis roulants ou des bras robotiques peuvent être saisis et placés dans diverses orientations. Le retournement vertical aide le modèle à reconnaître les objets indépendamment de leur positionnement haut-bas.
• Implémentation d'Ultralytics : RandomFlip

flipud désactivé	flipud activé

Retournement horizontal (Flip Left-Right) (fliplr)#

• Plage : 0.0 - 1.0
• Par défaut : 0.5
• Utilisation : Effectue un retournement horizontal en miroir de l'image le long de l'axe des x. Cette transformation permute les côtés gauche et droit tout en maintenant la cohérence spatiale, ce qui aide le modèle à se généraliser aux objets apparaissant dans des orientations inversées. L'hyperparamètre fliplr définit la probabilité d'appliquer la transformation, une valeur de fliplr=1.0 garantissant que toutes les images sont retournées et une valeur de fliplr=0.0 désactivant complètement la transformation. Par exemple, avec fliplr=0.5, chaque image a 50 % de chances d'être retournée de gauche à droite.
• Objectif : Le retournement horizontal est largement utilisé dans la détection d'objets, l'estimation de pose et la reconnaissance faciale pour améliorer la robustesse face aux variations gauche-droite. Par exemple, dans la conduite autonome, les véhicules et les piétons peuvent apparaître de chaque côté de la route, et le retournement horizontal aide le modèle à les reconnaître aussi bien dans les deux orientations.
• Implémentation d'Ultralytics : RandomFlip

fliplr désactivé	fliplr activé

Échange des canaux BGR (bgr)#

• Plage : 0.0 - 1.0
• Par défaut : 0
• Utilisation : Échange les canaux de couleur d'une image de RVB à BGR, modifiant l'ordre dans lequel les couleurs sont représentées. L'hyperparamètre bgr définit la probabilité d'appliquer la transformation, bgr=1.0 garantissant que toutes les images subissent l'échange de canaux et bgr=0.0 le désactivant. Par exemple, avec bgr=0.5, chaque image a 50 % de chances d'être convertie de RVB à BGR.
• Objectif : Augmente la robustesse face aux différents ordres de canaux de couleur. Par exemple, lors de l'entraînement de modèles devant fonctionner avec divers systèmes de caméras et bibliothèques d'imagerie utilisant de manière incohérente les formats RGB et BGR, ou lors du déploiement de modèles dans des environnements où le format de couleur d'entrée peut différer de celui des données d'entraînement.
• Implémentation d'Ultralytics : Format

bgr désactivé	bgr activé

Mosaïque (Mosaic) (mosaic)#

• Plage : 0.0 - 1.0
• Par défaut : 1
• Utilisation : Combine quatre images d'entraînement en une seule. L'hyperparamètre mosaic définit la probabilité d'appliquer la transformation, mosaic=1.0 garantissant que toutes les images sont combinées et mosaic=0.0 désactivant la transformation. Par exemple, avec mosaic=0.5, chaque image a 50 % de chances d'être combinée avec trois autres images.
• Objectif : Très efficace pour améliorer la détection des petits objets et la compréhension du contexte. Par exemple, dans les projets de préservation de la vie sauvage où les animaux peuvent apparaître à diverses distances et échelles, l'augmentation mosaïque aide le modèle à apprendre à reconnaître la même espèce à travers différentes tailles, occlusions partielles et contextes environnementaux en créant artificiellement des échantillons d'entraînement diversifiés à partir de données limitées.
• Implémentation d'Ultralytics : Mosaic
• Remarque :
  • Même si l'augmentation mosaic rend le modèle plus robuste, elle peut aussi rendre le processus d'entraînement plus difficile.
  • L'augmentation mosaic peut être désactivée vers la fin de l'entraînement en définissant close_mosaic sur le nombre d'époques avant la fin où elle doit être arrêtée. Par exemple, si epochs est défini sur 200 et close_mosaic sur 20, l'augmentation mosaic sera désactivée après 180 époques. Si close_mosaic est défini sur 0, l'augmentation mosaic sera activée pendant tout le processus d'entraînement.
  • La fermeture de la mosaïque désactive également copy_paste, mixup et cutmix à la même époque. Les quatre sont désactivés ensemble, de sorte que les époques finales s'entraînent sans eux tandis que toutes les autres augmentations — les transformations géométriques, le HSV, les miroirs et Albumentations — continuent de s'exécuter. Note que copy_paste dans son mode par défaut flip fonctionne sur une seule image plutôt que d'en combiner plusieurs.
  • Le centre de la mosaïque générée est déterminé en utilisant des valeurs aléatoires, et peut se trouver à l'intérieur ou à l'extérieur de l'image.
  • L'implémentation actuelle de l'augmentation mosaic combine l'image actuelle avec 3 autres, tirées d'un tampon d'images récemment chargées, ou de n'importe où dans le jeu de données lorsque cache='ram'. Quoi qu'il en soit, elles sont échantillonnées avec remplacement, de sorte qu'une même image peut apparaître plus d'une fois dans une seule mosaïque.

mosaic désactivé	mosaic activé

Mixup (mixup)#

• Plage : 0.0 - 1.0
• Par défaut : 0
• Utilisation : Mélange deux images et leurs étiquettes avec une probabilité donnée. L'hyperparamètre mixup définit la probabilité d'appliquer la transformation, mixup=1.0 garantissant que toutes les images sont mélangées et mixup=0.0 désactivant la transformation. Par exemple, avec mixup=0.5, chaque image a 50 % de chances d'être mélangée avec une autre image.
• Objectif : Améliore la robustesse du modèle et réduit le surapprentissage. Par exemple, dans les systèmes de reconnaissance de produits en magasin, le mixup aide le modèle à apprendre des caractéristiques plus robustes en mélangeant des images de différents produits, lui apprenant à identifier des articles même lorsqu'ils sont partiellement visibles ou obscurcis par d'autres produits sur des étagères bondées.
• Implémentation d'Ultralytics : Mixup
• Remarque :
  • Le rapport mixup est une valeur aléatoire tirée d'une distribution bêta np.random.beta(32.0, 32.0), ce qui signifie que chaque image contribue à environ 50 %, avec de légères variations.

Première image, mixup désactivé	Deuxième image, mixup désactivé	mixup activé

CutMix (cutmix)#

• Plage : 0.0 - 1.0
• Par défaut : 0
• Utilisation : Découpe une région rectangulaire d'une image et la colle sur une autre image avec une probabilité donnée. L'hyperparamètre cutmix définit la probabilité d'appliquer la transformation, cutmix=1.0 garantissant que toutes les images subissent cette transformation et cutmix=0.0 la désactivant complètement. Par exemple, avec cutmix=0.5, chaque image a 50 % de chances de voir une région remplacée par un patch provenant d'une autre image.
• Objectif : Améliore les performances du modèle en créant des scénarios d'occlusion réalistes tout en maintenant l'intégrité des caractéristiques locales. Par exemple, dans les systèmes de conduite autonome, le cutmix aide le modèle à apprendre à reconnaître des véhicules ou des piétons même lorsqu'ils sont partiellement masqués par d'autres objets, améliorant ainsi la précision de la détection dans des environnements réels complexes avec des objets qui se chevauchent.
• Implémentation d'Ultralytics : CutMix
• Remarque :
  • La taille et la position de la zone découpée sont déterminées de manière aléatoire pour chaque application.
  • Contrairement au mixup qui mélange les valeurs de pixels globalement, cutmix maintient les intensités de pixels d'origine dans les régions découpées, préservant ainsi les caractéristiques locales.
  • Une région est collée dans l'image cible uniquement si elle ne chevauche aucune boîte englobante existante. De plus, seules les boîtes englobantes qui conservent une part suffisante de leur zone d'origine dans la région collée sont préservées.
  • Ce seuil de surface minimale de boîte englobante ne peut pas être modifié avec l'implémentation actuelle. Il est de 0.1 (10 %) pour les étiquettes de détection et de 0.01 (1 %) une fois que les étiquettes comportent des segments.

Première image, cutmix désactivé	Deuxième image, cutmix désactivé	cutmix activé

Augmentations spécifiques à la segmentation#

Copier-Coller (Copy-Paste) (copy_paste)#

• Plage : 0.0 - 1.0
• Par défaut : 0
• Utilisation : Fonctionne uniquement pour les tâches de segmentation, cette augmentation copie des objets à l'intérieur ou entre des images, contrôlée par copy_paste_mode. En mode flip, copy_paste est la fraction d'objets éligibles copiés : une image avec six objets éligibles gagne trois copies à copy_paste=0.5. En mode mixup, la même valeur contrôle également la probabilité que le copier-coller s'exécute. copy_paste=0.0 désactive la transformation.
• Objectif : Particulièrement utile pour les tâches de segmentation d'instance et les classes d'objets rares. Par exemple, dans la détection industrielle de défauts où certains types de défauts apparaissent rarement, l'augmentation copier-coller peut augmenter artificiellement l'occurrence de ces défauts rares en les copiant d'une image à l'autre, aidant ainsi le modèle à mieux apprendre ces cas sous-représentés sans nécessiter d'échantillons défectueux supplémentaires.
• Implémentation d'Ultralytics : CopyPaste
• Remarque :
  • Comme indiqué dans la vidéo ci-dessous, l'augmentation copy_paste peut être utilisée pour copier des objets d'une image à une autre.
  • Une fois qu'un objet est sélectionné pour être copié, son IoA (Intersection over Area) est calculé par rapport à tous les objets déjà présents dans l'image cible, indépendamment de copy_paste_mode. L'objet n'est collé que si toutes les valeurs d'IoA sont inférieures à 0.3 (30 %) ; il n'est pas collé si une valeur d'IoA est supérieure ou égale à 0.3.
  • Le seuil d'IoA ne peut pas être modifié avec l'implémentation actuelle et est défini sur 0.3 par défaut.

copy_paste désactivé	copy_paste activé avec copy_paste_mode=flip	Visualiser le processus copy_paste

Mode Copier-Coller (Copy-Paste Mode) (copy_paste_mode)#

• Options : 'flip', 'mixup'
• Par défaut : 'flip'
• Utilisation : Détermine la méthode utilisée pour l'augmentation copier-coller. S'il est défini sur 'flip', les objets proviennent de la même image, tandis que 'mixup' permet de copier des objets depuis différentes images.
• Objectif : Permet une flexibilité dans la manière dont les objets copiés sont intégrés dans les images cibles.
• Implémentation d'Ultralytics : CopyPaste
• Remarque :
  • Le principe de l'IoA est le même pour les deux options de copy_paste_mode, mais la manière dont les objets sont copiés diffère.
  • Selon la taille de l'image, les objets peuvent parfois être copiés partiellement ou entièrement en dehors du cadre.
  • En fonction de la qualité des annotations polygonales, les objets copiés peuvent présenter de légères variations de forme par rapport aux originaux.

Image de référence	Image choisie pour copy_paste	copy_paste activé avec copy_paste_mode=mixup

Augmentations spécifiques à la classification#

Augmentation automatique (Auto Augment) (auto_augment)#

• Options : 'randaugment', 'autoaugment', 'augmix', None
• Par défaut : 'randaugment'
• Utilisation : Applique des politiques d'augmentation automatisées pour la classification. L'option 'randaugment' utilise RandAugment, 'autoaugment' utilise AutoAugment et 'augmix' utilise AugMix. Définir sur None désactive l'augmentation automatisée.
• Objectif : Optimise automatiquement les stratégies d'augmentation pour les tâches de classification. Les différences sont les suivantes :
  • AutoAugment : Ce mode applique des politiques d'augmentation prédéfinies apprises à partir de jeux de données tels que ImageNet, CIFAR10 et SVHN. Les utilisateurs peuvent sélectionner ces politiques existantes mais ne peuvent pas en entraîner de nouvelles au sein de Torchvision. Pour découvrir des stratégies d'augmentation optimales pour des jeux de données spécifiques, des bibliothèques externes ou des implémentations personnalisées sont nécessaires. Référence au document de recherche AutoAugment.
  • RandAugment : Applique une sélection aléatoire de transformations avec une amplitude uniforme. Cette approche réduit le besoin d'une phase de recherche intensive, ce tout en améliorant la robustesse du modèle. Référence au document de recherche RandAugment.
  • AugMix : AugMix est une méthode d'augmentation de données qui améliore la robustesse du modèle en créant diverses variations d'images grâce à des combinaisons aléatoires de transformations simples. Référence au document de recherche AugMix.
• Implémentation d'Ultralytics : classify_augmentations()
• Remarque :
  • Essentiellement, la différence principale entre les trois méthodes réside dans la manière dont les politiques d'augmentation sont définies et appliquées.
  • Tu peux consulter cet article qui compare les trois méthodes en détail.

Effacement aléatoire (Random Erasing) (erasing)#

• Plage : 0.0 - 1.0
• Par défaut : 0.4
• Utilisation : Efface aléatoirement des portions de l'image lors de l'entraînement de classification. L'hyperparamètre erasing définit la probabilité d'appliquer la transformation, erasing=1.0 effaçant une région dans chaque image et erasing=0.0 désactivant la transformation. Par exemple, avec erasing=0.5, chaque image a 50 % de chances de voir une portion effacée.
• Objectif : Aide les modèles à apprendre des caractéristiques robustes et empêche une dépendance excessive à des régions spécifiques de l'image. Par exemple, dans les systèmes de reconnaissance faciale, l'effacement aléatoire aide les modèles à devenir plus robustes face à des occlusions partielles comme des lunettes de soleil, des masques ou d'autres objets qui pourraient couvrir partiellement les traits du visage. Cela améliore les performances en conditions réelles en forçant le modèle à identifier les individus en utilisant de multiples caractéristiques faciales plutôt que de dépendre uniquement de traits distinctifs qui pourraient être obscurcis.
• Implémentation d'Ultralytics : classify_augmentations()
• Remarque :
  • L'augmentation erasing s'accompagne d'hyperparamètres scale, ratio et value qui ne peuvent pas être modifiés avec l'implémentation actuelle. Leurs valeurs par défaut sont respectivement (0.02, 0.33), (0.3, 3.3) et 0, comme indiqué dans la documentation de PyTorch.

erasing désactivé	erasing activé (exemple 1)	erasing activé (exemple 2)	erasing activé (exemple 3)

Fonctionnalités d'augmentation avancées#

Transformations Albumentations personnalisées (augmentations)#

• Type : list de transformations Albumentations
• Par défaut : None
• Utilisation : Te permet de fournir des transformations Albumentations personnalisées pour l'augmentation des données via l'API Python. Ce paramètre accepte une liste d'objets de transformation Albumentations qui seront appliqués pendant l'entraînement au lieu des transformations Albumentations par défaut.
• Objectif : Fournit un contrôle précis sur les stratégies d'augmentation des données en exploitant la vaste bibliothèque de transformations Albumentations. Ceci est particulièrement utile lorsque tu as besoin d'augmentations spécialisées au-delà des options YOLO intégrées, telles que des déformations élastiques et des distorsions de grille pour l'imagerie médicale, des transformations adaptées aux perspectives aériennes et satellitaires, des bruits et des variations de luminosité simulant des conditions de faible luminosité, ou des variations de texture de type défaut pour l'inspection industrielle.
• Implémentation d'Ultralytics : Albumentations
• Remarque :
  • La construction des objets de transformation nécessite l'API Python. Ultralytics les sérialise avec A.to_dict() lors de l'enregistrement d'un point de contrôle, de sorte qu'une liste déjà sérialisée passe par un fichier de configuration YAML ou la CLI, ce qui permet à resume de les restaurer.
  • Les transformations personnalisées remplacent complètement l'ensemble Albumentations par défaut. Chaque augmentation configurée ailleurs sur cette page — mosaic, hsv_h, degrees et les autres — reste active et est appliquée indépendamment.
  • Sois prudent avec les transformations spatiales qui modifient la géométrie de l'image. Ultralytics ajuste automatiquement les boîtes englobantes, mais certaines transformations complexes peuvent nécessiter une configuration supplémentaire.
  • Albumentations propose plus de 70 transformations ; la documentation d'Albumentations les répertorie toutes. L'ajout de nombreuses transformations, ou de transformations coûteuses en calcul, ralentit l'entraînement, alors commence par un petit ensemble et surveille le temps par époque.
  • S'applique aux tâches detect, segment, semantic, depth, pose et obb. La classification est exclue, car elle utilise un pipeline d'augmentation séparé.

Les exemples ci-dessous nécessitent Albumentations 1.4.22 ou plus récent, et par conséquent Python 3.9 ou plus récent.

import albumentations as A

from ultralytics import YOLO

# Load a model
model = YOLO("yolo26n.pt")

# Define custom Albumentations transforms
custom_transforms = [
    A.Blur(blur_limit=7, p=0.5),
    A.GaussNoise(std_range=(0.0124, 0.0277), p=0.3),
    A.CLAHE(clip_limit=4.0, p=0.5),
    A.RandomBrightnessContrast(brightness_limit=0.2, contrast_limit=0.2, p=0.5),
    A.HueSaturationValue(hue_shift_limit=20, sat_shift_limit=30, val_shift_limit=20, p=0.5),
]

# Train with custom Albumentations transforms
model.train(
    data="coco8.yaml",
    epochs=100,
    augmentations=custom_transforms,  # Pass custom transforms
    imgsz=640,
)

FAQ#