Augmentation des données avec Ultralytics YOLO#

Introduction#

L’augmentation des données est une technique essentielle en vision par ordinateur qui élargit artificiellement ton jeu de données d’entraînement en appliquant diverses transformations aux images existantes. Lors de l’entraînement de modèles d’apprentissage profond comme Ultralytics YOLO, l’augmentation des données contribue à améliorer la robustesse du modèle, à réduire le surapprentissage et à renforcer la généralisation à des scénarios réels.

Pourquoi l’augmentation des données est importante#

L’augmentation des données remplit plusieurs fonctions essentielles lors de l’entraînement de modèles de vision par ordinateur :

• Jeu de données étendu : En créant des variantes des images existantes, tu peux augmenter efficacement la taille de ton jeu de données d’entraînement sans collecter de nouvelles données.
• Meilleure généralisation : Les modèles apprennent à reconnaître les objets dans différentes conditions, ce qui les rend plus robustes dans les applications réelles.
• Réduction du surapprentissage : En introduisant de la variabilité dans les données d’entraînement, les modèles sont moins susceptibles de mémoriser des caractéristiques spécifiques des images.
• Performances améliorées : Les modèles entraînés avec une augmentation appropriée obtiennent généralement une meilleure précision sur les jeux de validation et de test.

L’implémentation d’Ultralytics YOLO fournit une suite complète de techniques d’augmentation, chacune répondant à des objectifs précis et contribuant de différentes manières aux performances du modèle. Ce guide présente les paramètres d’augmentation ci-dessous et t’aide à comprendre quand et comment les utiliser efficacement dans tes projets.

Exemples de configuration#

Tu peux personnaliser chaque paramètre à l’aide de l’API Python, de l’interface de ligne de commande (CLI) ou d’un fichier de configuration. Tu trouveras ci-dessous des exemples de configuration de l’augmentation des 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)

Utiliser 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 est requis uniquement lors de l’utilisation de la CLI. Ce nouveau fichier YAML remplacera ensuite 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

Lance ensuite 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
• Valeur par défaut : 0.015
• Utilisation : Décale les couleurs de l’image tout en préservant leurs relations. L’hyperparamètre hsv_h définit l’amplitude du décalage, le réglage 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 dans l’intervalle -0.3 à 0.3. Pour les valeurs supérieures à 0.5, le décalage de teinte fait le tour de la roue chromatique, c’est pourquoi les augmentations semblent identiques entre 0.5 et -0.5.
• Objectif : Particulièrement utile pour les scénarios extérieurs, où les conditions d’éclairage peuvent modifier considérablement l’apparence des objets. Par exemple, une banane peut sembler plus jaune sous un soleil intense, 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
• Valeur par défaut : 0.7
• Utilisation : Modifie l’intensité des couleurs de l’image. L’hyperparamètre hsv_s définit l’amplitude du décalage, le réglage 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 dans l’intervalle -0.7 à 0.7.
• Objectif : Aide les modèles à gérer différentes conditions météorologiques et configurations de caméra. Par exemple, un panneau de signalisation rouge peut sembler très vif par une journée ensoleillée, mais terne et délavé dans le brouillard.
• 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
• Valeur par défaut : 0.4
• Utilisation : Modifie la luminosité de l’image. L’hyperparamètre hsv_v définit l’amplitude du décalage, le réglage 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 dans l’intervalle -0.4 à 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 sembler lumineuse 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
• Valeur par défaut : 0
• Utilisation : Fait pivoter les images aléatoirement dans la plage spécifiée. L’hyperparamètre degrees définit l’angle de rotation, le réglage final étant choisi aléatoirement entre -degrees et degrees. Par exemple, avec degrees=10.0, la rotation est sélectionnée aléatoirement dans l’intervalle -10.0 à 10.0.
• Objectif : Cruciale pour les applications où les objets peuvent apparaître selon différentes orientations. Par exemple, sur des images aériennes prises par drone, les véhicules peuvent être orientés dans n’importe quelle direction ; les modèles doivent donc reconnaître les objets quelle que soit leur rotation.
• Implémentation d’Ultralytics : RandomPerspective

-180	-90	0.0	90	180

Translation (translate)#

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

-0.5	-0.25	0.0	0.25	0.5

Échelle (scale)#

• Plage : 0.0 - 1.0 sous forme de flottant, ou tuple (min, max) explicite
• Valeur par défaut : 0.5
• Utilisation : Redimensionne les images selon un facteur aléatoire dans la plage spécifiée. Sous forme de flottant, l’hyperparamètre scale définit le gain d’é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 dans l’intervalle 0.5 à 1.5. Sous forme de tuple, scale définit directement cette plage, et scale=(0.5, 2.0) échantillonne le facteur entre 0.5 et 2.0.
• Objectif : Permet aux modèles de gérer des objets situés à différentes distances et de différentes tailles. Par exemple, dans les applications de conduite autonome, les véhicules peuvent apparaître à différentes distances de la caméra ; le modèle doit donc les reconnaître 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 produit simplement un zoom de 2x.
  • Les valeurs affichées dans le tableau ci-dessous sont les deltas d’échelle obtenus, et non les valeurs transmises à l’hyperparamètre scale.
  • La forme flottante est validée dans la plage 0.0 - 1.0, et une valeur située en dehors de cette plage déclenche une ValueError. Pour échantillonner un facteur au-delà d’un zoom de 2x, utilise plutôt la forme tuple (min, max).
  • La forme tuple s’applique uniquement aux tâches géométriques. L’entraînement de classification déduit sa propre plage de recadrage à partir du flottant (de 1.0 - scale à 1.0) ; transmettre un tuple dans ce cas déclenche donc une TypeError.

-0.5	-0.25	0.0	0.25	0.5

Cisaillement (shear)#

• Plage : de -180 à +180
• Valeur par défaut : 0
• Utilisation : Introduit une transformation géométrique qui incline l’image selon les axes x et y, décalant ainsi certaines parties de l’image dans une direction tout en conservant les lignes parallèles. L’hyperparamètre shear définit l’angle de cisaillement, le réglage final étant choisi aléatoirement entre -shear et shear. Par exemple, avec shear=10.0, le cisaillement est sélectionné aléatoirement dans l’intervalle -10 à 10 sur l’axe x, puis une autre valeur aléatoire indépendante est sélectionnée dans la même plage sur l’axe y.
• Objectif : Aide les modèles à généraliser aux variations d’angle 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 routiers peuvent sembler inclinés lorsque les caméras ne sont pas perpendiculaires. L’augmentation par cisaillement permet au modèle d’apprendre à reconnaître les objets malgré ces déformations.
• Implémentation d’Ultralytics : RandomPerspective
• Remarque :
  • Les valeurs de shear peuvent rapidement déformer l’image ; il est donc recommandé de commencer par de petites valeurs et de les augmenter progressivement.
  • Contrairement aux transformations de perspective, le cisaillement n’introduit ni profondeur ni points de fuite ; il déforme plutôt la forme des objets en modifiant leurs angles tout en gardant leurs côtés opposés parallèles.

-10	-5	0.0	5	10

Perspective (perspective)#

• Plage : 0.0 - 0.001
• Valeur par défaut : 0
• Utilisation : Applique une transformation de perspective complète selon les axes x et y, simulant l’apparence des objets vus depuis différentes profondeurs ou différents angles. L’hyperparamètre perspective définit l’amplitude de la perspective, le réglage final étant choisi aléatoirement entre -perspective et perspective. Par exemple, avec perspective=0.001, la perspective est sélectionnée aléatoirement dans l’intervalle -0.001 à 0.001 sur l’axe x, puis une autre valeur aléatoire indépendante est sélectionnée dans la même plage sur l’axe y.
• Objectif : L’augmentation de perspective est cruciale pour gérer les changements extrêmes de point de vue, notamment lorsque les objets semblent raccourcis ou déformés par les variations de perspective. Par exemple, dans la détection d’objets par drone, les bâtiments, les routes et les véhicules peuvent sembler étirés ou comprimé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 déformations, ce qui améliore leur robustesse dans les déploiements réels.
• Implémentation d’Ultralytics : RandomPerspective

-0.001	-0.0005	0.0	0.0005	0.001

Retournement haut-bas (flipud)#

• Plage : 0.0 - 1.0
• Valeur par défaut : 0
• Utilisation : Effectue un retournement vertical en inversant l’image selon l’axe y. Cette transformation retourne l’image entière tête-bêche, tout en préservant les relations spatiales entre les objets. L’hyperparamètre flipud définit la probabilité d’appliquer la transformation ; une valeur de flipud=1.0 garantit que toutes les images sont retournées, tandis qu’une valeur de flipud=0.0 désactive complètement la transformation. Par exemple, avec flipud=0.5, chaque image a 50 % de chances d’être retournée tête-bêche.
• 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 placés sur des tapis roulants ou des bras robotisés peuvent être saisis et déposés selon différentes orientations. Le retournement vertical aide le modèle à reconnaître les objets quelle que soit leur orientation haut-bas.
• Implémentation d’Ultralytics : RandomFlip

flipud désactivé	flipud activé

Retournement gauche-droite (fliplr)#

• Plage : 0.0 - 1.0
• Valeur par défaut : 0.5
• Utilisation : Effectue un retournement horizontal en faisant pivoter l’image selon l’axe x. Cette transformation échange les côtés gauche et droit tout en maintenant la cohérence spatiale, ce qui aide le modèle à généraliser aux objets apparaissant dans des orientations en miroir. L’hyperparamètre fliplr définit la probabilité d’appliquer la transformation ; une valeur de fliplr=1.0 garantit que toutes les images sont retournées, tandis qu’une valeur de fliplr=0.0 désactive 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é en détection d’objets, en estimation de pose et en reconnaissance faciale pour améliorer la robustesse 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 ; 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
• Valeur par défaut : 0
• Utilisation : Échange les canaux de couleur d’une image de RGB vers 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 garantit que toutes les images subissent l’échange des canaux, tandis que bgr=0.0 le désactive. Par exemple, avec bgr=0.5, chaque image a 50 % de chances d’être convertie de RGB en BGR.
• Objectif : Accroît la robustesse aux différents ordres de canaux de couleur. Par exemple, lors de l’entraînement de modèles devant fonctionner avec différents systèmes de caméra et bibliothèques d’imagerie où les formats RGB et BGR peuvent être utilisés de manière incohérente, 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)#

• Plage : 0.0 - 1.0
• Valeur 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 garantit que toutes les images sont combinées, tandis que mosaic=0.0 désactive 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 conservation de la faune, où les animaux peuvent apparaître à différentes distances et échelles, l’augmentation par mosaïque aide le modèle à apprendre à reconnaître une même espèce selon différentes tailles, occultations partielles et contextes environnementaux en créant artificiellement des échantillons d’entraînement varié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 également 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 restantes avant la fin, moment où elle doit être désactivé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 augmentations sont désactivées ensemble : les dernières époques s’effectuent donc sans elles, tandis que toutes les autres augmentations — transformations géométriques, HSV, retournements et Albumentations — continuent de s’exécuter. Note que copy_paste, dans son mode par défaut flip, agit sur une seule image plutôt que d’en combiner plusieurs.
  • Le centre de la mosaïque générée est déterminé à l’aide de 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 courante avec trois autres images, tirées d’un tampon d’images récemment chargées ou de n’importe quel emplacement du jeu de données lorsque cache='ram'. Dans les deux cas, l’échantillonnage se fait avec remise ; une même image peut donc apparaître plusieurs fois dans une seule mosaïque.

mosaic désactivé	mosaic activé

Mixup (mixup)#

• Plage : 0.0 - 1.0
• Valeur par défaut : 0
• Utilisation : Fusionne deux images et leurs annotations selon une probabilité donnée. L’hyperparamètre mixup définit la probabilité d’appliquer la transformation ; mixup=1.0 garantit que toutes les images sont mélangées, tandis que mixup=0.0 désactive 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 vendus au détail, Mixup aide le modèle à apprendre des caractéristiques plus robustes en fusionnant des images de différents produits, afin qu’il puisse identifier les articles même lorsqu’ils sont partiellement visibles ou masqués par d’autres produits sur des rayons encombrés.
• Implémentation d’Ultralytics : Mixup
• Remarque :
  • Le ratio mixup est une valeur aléatoire tirée d’une loi bêta np.random.beta(32.0, 32.0), ce qui signifie que chaque image contribue à hauteur d’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
• Valeur par défaut : 0
• Utilisation : Découpe une région rectangulaire d’une image et la colle sur une autre image selon une probabilité donnée. L’hyperparamètre cutmix définit la probabilité d’appliquer la transformation ; cutmix=1.0 garantit que toutes les images subissent cette transformation, tandis que cutmix=0.0 la désactive complètement. Par exemple, avec cutmix=0.5, chaque image a 50 % de chances de voir une région remplacée par un fragment provenant d’une autre image.
• Objectif : Améliore les performances du modèle en créant des scénarios d’occultation réalistes tout en préservant l’intégrité des caractéristiques locales. Par exemple, dans les systèmes de conduite autonome, CutMix aide le modèle à apprendre à reconnaître les véhicules ou les piétons même lorsqu’ils sont partiellement masqués par d’autres objets, améliorant ainsi la précision de détection dans des environnements réels complexes où les objets se chevauchent.
• Implémentation d’Ultralytics : CutMix
• Remarque :
  • La taille et la position de la région découpée sont déterminées aléatoirement à chaque application.
  • Contrairement à Mixup, qui fusionne globalement les valeurs des pixels, cutmix conserve les intensités de pixels d’origine dans les régions découpées et préserve ainsi les caractéristiques locales.
  • Une région est collée dans l’image cible uniquement si elle ne chevauche aucune BBox existante. De plus, seules les BBox qui conservent une partie suffisante de leur surface d’origine dans la région collée sont conservées.
  • Ce seuil minimal de surface de BBox ne peut pas être modifié avec l’implémentation actuelle. Il est de 0.1 (10 %) pour les annotations de détection et de 0.01 (1 %) lorsque les annotations contiennent des segments.

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

Augmentations Copy-Paste#

Copy-Paste (copy_paste)#

• Plage : 0.0 - 1.0
• Valeur par défaut : 0
• Utilisation : Nécessite des annotations polygonales et s’applique donc aux tâches de segmentation et OBB ; cette augmentation copie des objets à l’intérieur d’une image ou entre plusieurs images, sous le contrôle de copy_paste_mode. En mode flip, copy_paste correspond à la fraction d’objets éligibles copiés : une image contenant six objets éligibles gagne trois copies avec copy_paste=0.5. En mode mixup, la même valeur contrôle également la probabilité d’exécution de Copy-Paste. copy_paste=0.0 désactive la transformation.
• Objectif : Particulièrement utile pour les tâches de segmentation d’instances et les classes d’objets rares. Par exemple, dans la détection de défauts industriels, où certains types de défauts apparaissent rarement, l’augmentation Copy-Paste peut accroître artificiellement la fréquence de ces défauts rares en les copiant d’une image à une autre, afin d’aider 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 le montre la vidéo ci-dessous, l'augmentation copy_paste peut être utilisée pour copier des objets d'une image vers une autre.
  • Une fois qu'un objet est sélectionné pour être copié, son IoA est calculé par rapport à tous les objets déjà présents dans l'image cible, quelle que soit la valeur de copy_paste_mode. L'objet est collé uniquement 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 par défaut sur 0.3.

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

Mode copier-coller (copy_paste_mode)#

• Options : 'flip', 'mixup'
• Valeur par défaut : 'flip'
• Utilisation : détermine la méthode utilisée pour l'augmentation par copier-coller. Si la valeur est définie sur 'flip', les objets proviennent de la même image, tandis que 'mixup' permet de copier des objets depuis différentes images.
• Objectif : offre davantage de flexibilité dans la manière dont les objets copiés sont intégrés aux images cibles.
• Implémentation d’Ultralytics : CopyPaste
• Remarque :
  • Le principe de l'IoA est le même pour les deux options 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.
  • Selon 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#

Auto Augment (auto_augment)#

• Options : 'randaugment', 'autoaugment', 'augmix', None
• Valeur 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 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 qu'ImageNet, CIFAR10 et SVHN. Les utilisateurs peuvent sélectionner ces politiques existantes, mais ne peuvent pas en entraîner de nouvelles dans 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 seraient nécessaires. Consulte l'article sur AutoAugment.
  • RandAugment : applique une sélection aléatoire de transformations avec une amplitude uniforme. Cette approche réduit la nécessité d'une phase de recherche approfondie, ce qui la rend plus efficace sur le plan des calculs tout en améliorant la robustesse du modèle. Consulte l'article sur RandAugment.
  • AugMix : AugMix est une méthode d'augmentation des 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. Consulte l'article sur AugMix.
• Implémentation d'Ultralytics : classify_augmentations()
• Remarque :
  • En substance, la principale différence 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 en détail les trois méthodes.

Effacement aléatoire (erasing)#

• Plage : 0.0 - 1.0
• Valeur par défaut : 0.4
• Utilisation : efface aléatoirement des portions de l'image pendant l'entraînement pour la classification. L'hyperparamètre erasing définit la probabilité d'appliquer la transformation ; erasing=1.0 efface une région dans chaque image, tandis que erasing=0.0 désactive 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 évite qu'ils ne dépendent excessivement de régions spécifiques de l'image. Par exemple, dans les systèmes de reconnaissance faciale, l'effacement aléatoire aide les modèles à mieux résister aux occultations partielles comme les lunettes de soleil, les masques ou d'autres objets susceptibles de recouvrir partiellement les traits du visage. Cela améliore les performances en conditions réelles en forçant le modèle à identifier les individus à partir de plusieurs caractéristiques faciales, plutôt que de dépendre uniquement de traits distinctifs qui pourraient être masqués.
• Implémentation d'Ultralytics : classify_augmentations()
• Remarque :
  • L'augmentation erasing utilise les 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 avancées d'augmentation#

Transformations Albumentations personnalisées (augmentations)#

• Type : list de transformations Albumentations
• Valeur par défaut : None
• Utilisation : permet de fournir des transformations Albumentations personnalisées pour l'augmentation des données à l'aide de l'API Python. Ce paramètre accepte une liste d'objets de transformation Albumentations qui seront appliqués pendant l'entraînement à la place des transformations Albumentations par défaut.
• Objectif : offre un contrôle précis des stratégies d'augmentation des données en tirant parti de la vaste bibliothèque de transformations Albumentations. Cela est particulièrement utile lorsque tu as besoin d'augmentations spécialisées au-delà des options YOLO intégrées, comme des déformations élastiques et des distorsions en grille pour l'imagerie médicale, des transformations adaptées aux prises de vue aériennes et satellitaires, des variations de bruit et de luminosité simulant des conditions de faible éclairage, ou des variations de texture semblables à des défauts pour l'inspection industrielle.
• Implémentation d'Ultralytics : Albumentations
• Remarque :
  • La création des objets de transformation nécessite l'API Python. Ultralytics les sérialise avec A.to_dict() lors de l'enregistrement d'un checkpoint, de sorte qu'une liste déjà sérialisée peut effectuer un aller-retour via 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 toutes les autres — reste active et est appliquée indépendamment.
  • Les transformations spatiales qui modifient la géométrie de l'image, y compris celles imbriquées dans A.OneOf ou A.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.RandomGridShuffle ne peut pas préserver la topologie des polygones ou des points clés et génère une erreur sur les échantillons de segmentation, de pose et d'OBB.
  • Albumentations propose plus de 70 transformations ; la documentation Albumentations les répertorie toutes. Ajouter de nombreuses transformations, ou des transformations coûteuses en calcul, ralentit l'entraînement ; commence donc par un petit ensemble et surveille la durée des époques.
  • S'applique aux tâches detect, segment, semantic, depth, pose et obb. La classification est exclue, car elle utilise un pipeline d'augmentation distinct.

Les exemples ci-dessous nécessitent Albumentations 1.4.22 ou une version ultérieure, et donc Python 3.9 ou une version ultérieure.

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#