Augmentation des données avec Ultralytics YOLO#

Introduction#

L’augmentation des données est une technique essentielle en vision par ordinateur qui étoffe 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 sa capacité de généralisation aux situations réelles.

Pourquoi l’augmentation des données est importante#

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

• Jeu de données étoffé : 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 diverses 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 risquent moins de mémoriser les caractéristiques propres à certaines images.
• Performances améliorées : les modèles entraînés avec une augmentation adaptée obtiennent généralement une meilleure précision sur les jeux de validation et de test.

L’implémentation d’Ultralytics YOLO propose un ensemble complet de techniques d’augmentation, chacune ayant une fonction précise et contribuant différemment aux performances du modèle. Ce guide présente les paramètres d’augmentation ci-dessous pour t’aider à comprendre quand et comment les utiliser efficacement dans tes projets.

Exemples de configuration#

Tu peux personnaliser chaque paramètre avec l’API Python, l’interface en ligne de commande (CLI) ou un fichier de configuration. Voici des exemples de configuration de l’augmentation des données avec chaque méthode.

import albumentations as A

from ultralytics import YOLO

# Charger un modèle
model = YOLO("yolo26n.pt")

# Entraînement avec des paramètres d’augmentation personnalisés
model.train(data="coco8.yaml", epochs=100, hsv_h=0.03, hsv_s=0.6, hsv_v=0.5)

# Entraînement avec toutes les augmentations configurables désactivées (valeurs désactivées omises par souci de clarté)
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,
)

# Entraînement avec des transformations Albumentations personnalisées (API Python uniquement)
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 uniquement requis lorsque tu utilises la CLI. Ce nouveau fichier YAML remplacera alors le fichier par défaut situé dans le package 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

# Charger un modèle YOLO26n préentraîné sur COCO
model = YOLO("yolo26n.pt")

# Entraîner le modèle avec une configuration personnalisée
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 : modifie les couleurs de l’image tout en préservant leurs relations. L’hyperparamètre hsv_h définit l’amplitude du décalage, et l’ajustement final est choisi aléatoirement entre -hsv_h et hsv_h. Par exemple, avec hsv_h=0.3, le décalage est choisi aléatoirement dans la plage -0.3 à 0.3. Au-delà de 0.5, le décalage de teinte boucle sur le cercle chromatique ; c’est pourquoi les augmentations semblent identiques entre 0.5 et -0.5.
• Objectif : particulièrement utile dans les situations en extérieur, où les conditions d’éclairage peuvent modifier considérablement l’apparence des objets. Par exemple, une banane peut sembler plus jaune en plein soleil, 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, et l’ajustement final est choisi aléatoirement entre -hsv_s et hsv_s. Par exemple, avec hsv_s=0.7, l’intensité est choisie aléatoirement dans la plage -0.7 à 0.7.
• Objectif : aide les modèles à gérer les variations des conditions météorologiques et des réglages de caméra. Par exemple, un panneau de signalisation rouge peut être très vif par temps ensoleillé, 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, et l’ajustement final est choisi aléatoirement entre -hsv_v et hsv_v. Par exemple, avec hsv_v=0.4, l’intensité est choisie aléatoirement dans la plage -0.4 à 0.4.
• Objectif : indispensable pour entraîner des modèles qui doivent fonctionner dans différentes conditions d’éclairage. Par exemple, une pomme rouge peut sembler vive en plein 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 : 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, et l’ajustement final est choisi aléatoirement entre -degrees et degrees. Par exemple, avec degrees=10.0, la rotation est choisie aléatoirement dans la plage -10.0 à 10.0.
• Objectif : essentiel pour les applications où les objets peuvent apparaître dans différentes orientations. Par exemple, dans les 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, et l’ajustement final est choisi aléatoirement deux fois (une fois par axe) dans la plage -translate à translate. Par exemple, avec translate=0.5, la translation sur l’axe x est choisie aléatoirement dans la plage -0.5 à 0.5, et une autre valeur aléatoire indépendante est sélectionnée dans la même plage pour l’axe y.
• Objectif : aide les modèles à apprendre à détecter les objets partiellement visibles et améliore leur robustesse face aux variations de position des objets. Par exemple, dans les applications d’évaluation des dommages aux véhicules, des parties de voiture peuvent ê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 indépendamment de leur intégrité ou de leur position.
• Implémentation d’Ultralytics : RandomPerspective
• Remarque : par souci de simplicité, les translations appliquées ci-dessous sont identiques à chaque fois sur les deux 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 nombre flottant, ou tuple explicite (min, max)
• Valeur par défaut : 0.5
• Utilisation : redimensionne les images selon un facteur aléatoire dans la plage spécifiée. Sous forme de nombre flottant, l’hyperparamètre scale définit le facteur d’échelle, et le facteur final est choisi aléatoirement entre 1-scale et 1+scale. Par exemple, avec scale=0.5, la mise à l’échelle est choisie aléatoirement dans la plage 0.5 à 1.5. Sous forme de tuple, scale définit directement cette plage ; scale=(0.5, 2.0) échantillonne donc le facteur entre 0.5 et 2.0.
• Objectif : permet aux modèles de gérer des objets de différentes tailles et situés à diverses distances. 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 x2.
  • Les valeurs affichées dans le tableau ci-dessous correspondent aux variations d’échelle obtenues, et non aux valeurs que tu transmets à l’hyperparamètre scale.
  • La forme flottante est validée dans la plage 0.0 - 1.0, et toute valeur en dehors de cette plage déclenche une ValueError. Pour échantillonner un facteur supérieur à un zoom x2, 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 de la valeur flottante (1.0 - scale à 1.0), donc transmettre un tuple dans ce cas déclenche une TypeError.

-0.5	-0.25	0.0	0.25	0.5

Cisaillement (shear)#

• Plage : -180 à +180
• Valeur par défaut : 0
• Utilisation : applique une transformation géométrique qui incline l’image selon les axes x et y, en décalant certaines parties de l’image dans une direction tout en préservant le parallélisme des lignes. L’hyperparamètre shear définit l’angle de cisaillement, et l’ajustement final est choisi aléatoirement entre -shear et shear. Par exemple, avec shear=10.0, le cisaillement est choisi aléatoirement dans la plage -10 à 10 sur l’axe x, et 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 dues à 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 si les caméras ne sont pas placées perpendiculairement. L’augmentation par cisaillement garantit que le modèle apprend à 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 maintenant parallèles les côtés opposés.

-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 sous différents angles ou à différentes profondeurs. L’hyperparamètre perspective définit l’amplitude de la perspective, et l’ajustement final est choisi aléatoirement entre -perspective et perspective. Par exemple, avec perspective=0.001, la perspective est choisie aléatoirement dans la plage -0.001 à 0.001 sur l’axe x, et 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 essentielle 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, en 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 et gagnent en robustesse lors de leur déploiement en conditions réelles.
• Implémentation d’Ultralytics : RandomPerspective

-0.001	-0.0005	0.0	0.0005	0.001

Retournement vertical (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 toute l’image 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 situations où les objets peuvent apparaître à l’envers. Par exemple, dans les systèmes de vision robotique, les objets posés sur des convoyeurs ou des bras robotiques peuvent être saisis et placés dans différentes orientations. Le retournement vertical aide le modèle à reconnaître les objets quelle que soit leur orientation de haut en bas.
• Implémentation d’Ultralytics : RandomFlip

flipud désactivé	flipud activé

Retournement horizontal (fliplr)#

• Plage : 0.0 - 1.0
• Valeur par défaut : 0.5
• Utilisation : effectue un retournement horizontal en reflétant l’image selon l’axe x. Cette transformation inverse les côtés gauche et droit tout en préservant la cohérence spatiale, ce qui aide le modèle à généraliser aux objets présentant une orientation 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 face aux variations gauche-droite. Par exemple, en conduite autonome, des véhicules et des 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é

Permutation des canaux BGR (bgr)#

• Plage : 0.0 - 1.0
• Valeur par défaut : 0
• Utilisation : permute les canaux de couleur d’une image de RGB à BGR, ce qui modifie l’ordre de représentation des couleurs. L’hyperparamètre bgr définit la probabilité d’appliquer la transformation : bgr=1.0 garantit que toutes les images subissent cette permutation, tandis que bgr=0.0 la désactive. Par exemple, avec bgr=0.5, chaque image a 50 % de chances d’être convertie de RGB en BGR.
• Objectif : améliore la robustesse face aux différents ordres des canaux de couleur. Par exemple, lors de l’entraînement de modèles destinés à fonctionner avec divers 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 à 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 dans différentes tailles, avec des occultations partielles et dans divers contextes environnementaux, en créant artificiellement des exemples 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 aussi compliquer le processus d’entraînement.
  • 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 sa désactivation. 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 se déroulent donc sans elles, tandis que toutes les autres augmentations — transformations géométriques, HSV, retournements et Albumentations — restent actives. Note que copy_paste, dans son mode flip par défaut, opère 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, extraites d’un tampon d’images récemment chargées ou de n’importe quel endroit du jeu de données lorsque cache='ram'. Dans les deux cas, les images sont échantillonnées avec remise ; une même image peut donc apparaître plusieurs fois dans une mosaïque.

mosaic désactivé	mosaic activé

Mixup (mixup)#

• Plage : 0.0 - 1.0
• Valeur par défaut : 0
• Utilisation : mélange deux images et leurs annotations selon la probabilité définie. 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 à 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, MixUp aide le modèle à apprendre des caractéristiques plus robustes en mélangeant des images de différents produits ; le modèle apprend ainsi à 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 issue d’une distribution bêta np.random.beta(32.0, 32.0) ; chaque image contribue donc à 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 dans une image et la colle sur une autre avec 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 et cutmix=0.0 la désactive complètement. Par exemple, avec cutmix=0.5, chaque image a 50 % de chances qu’une région soit remplacée par un extrait d’une autre image.
• Objectif : améliore les performances du modèle en créant des situations d’occlusion 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 à reconnaître les véhicules ou les piétons même lorsqu’ils sont partiellement masqués par d’autres objets, ce qui améliore 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 mélange globalement les valeurs des pixels, cutmix préserve les intensités des pixels d’origine dans les régions découpées, conservant 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 suffisamment de leur surface d’origine dans la région collée sont préservées.
  • Ce seuil minimal de surface des boîtes englobantes 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 comportent 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, selon le paramètre copy_paste_mode. En mode flip, copy_paste correspond à la fraction des objets admissibles copiés : une image contenant six objets admissibles reçoit 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. Le modèle apprend ainsi mieux à reconnaître 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 permet de copier des objets d’une image à une autre.
  • Une fois qu’un objet est sélectionné pour être copié, son IoA est calculée 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 l’une des valeurs 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 Copy-Paste (copy_paste_mode)#

• Options : 'flip', 'mixup'
• Valeur par défaut : 'flip'
• Utilisation : détermine la méthode utilisée pour l’augmentation Copy-Paste. Si la valeur est 'flip', les objets proviennent de la même image, tandis que 'mixup' permet de copier des objets depuis d’autres images.
• Objectif : permet de choisir comment 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 méthode de copie des objets diffère.
  • Selon la taille de l’image, il arrive que des objets soient copiés partiellement ou entièrement en dehors du cadre.
  • Selon la qualité des annotations polygonales, la forme des objets copiés peut légèrement différer de celle des objets d’origine.

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. La valeur None désactive l’augmentation automatisée.
• Objectif : optimise automatiquement les stratégies d’augmentation pour les tâches de classification. Voici les différences :
  • AutoAugment : ce mode applique des politiques d’augmentation prédéfinies, apprises à partir de jeux de données comme ImageNet, CIFAR10 et SVHN. Tu peux sélectionner ces politiques existantes, mais pas en entraîner de nouvelles dans Torchvision. Pour trouver les stratégies d’augmentation optimales pour des jeux de données spécifiques, il faut utiliser des bibliothèques externes ou des implémentations personnalisées. Consulte l’article sur AutoAugment.
  • RandAugment : applique une sélection aléatoire de transformations d’amplitude uniforme. Cette approche réduit le besoin d’une longue phase de recherche, ce qui la rend plus efficace sur le plan du calcul tout en renforçant la robustesse du modèle. Consulte l’article sur RandAugment.
  • AugMix : AugMix est une méthode d’augmentation des données qui renforce la robustesse du modèle en créant diverses variations d’images à partir de combinaisons aléatoires de transformations simples. Consulte l’article sur AugMix.
• Implémentation d’Ultralytics : classify_augmentations()
• Remarque :
  • En résumé, la principale différence entre les trois méthodes tient à la façon 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 (erasing)#

• Plage : 0.0 - 1.0
• Valeur par défaut : 0.4
• Utilisation : efface aléatoirement des parties de l’image pendant l’entraînement de classification. L’hyperparamètre erasing définit la probabilité d’appliquer la transformation ; erasing=1.0 efface une région de chaque image et erasing=0.0 désactive la transformation. Par exemple, avec erasing=0.5, chaque image a 50 % de chances qu’une partie soit effacée.
• Objectif : aide les modèles à apprendre des caractéristiques robustes et évite qu’ils ne s’appuient trop sur certaines régions de l’image. Par exemple, dans les systèmes de reconnaissance faciale, l’effacement aléatoire aide les modèles à mieux gérer les occultations partielles causées par des lunettes de soleil, des masques ou d’autres objets pouvant masquer une partie du visage. Les performances en conditions réelles s’améliorent, car le modèle doit identifier les personnes à partir de plusieurs caractéristiques faciales plutôt que de dépendre uniquement de traits distinctifs susceptibles d’être masqués.
• Implémentation d’Ultralytics : classify_augmentations()
• Remarque :
  • L’augmentation erasing est associée aux 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
• Valeur par défaut : None
• Utilisation : te 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 : permet de contrôler finement les stratégies d’augmentation des données en tirant parti de la vaste bibliothèque de transformations Albumentations. C’est particulièrement utile lorsque tu as besoin d’augmentations spécialisées qui ne sont pas proposées parmi les options YOLO intégrées : déformations élastiques et distorsions en grille pour l’imagerie médicale, transformations adaptées aux prises de vue aériennes et satellites, variations de bruit et de luminosité simulant les conditions de faible éclairage, ou textures imitant 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. Lors de l’enregistrement d’un point de contrôle, Ultralytics les sérialise avec A.to_dict() ; une liste déjà sérialisée peut donc être enregistrée puis relue à partir d’un fichier de configuration YAML ou de la CLI, ce qui permet à resume de la restaurer.
  • Les transformations personnalisées remplacent entièrement l’ensemble Albumentations par défaut. Toutes les augmentations configurées ailleurs sur cette page — mosaic, hsv_h, degrees et les autres — restent actives et sont appliquées 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 avec l’image ; A.RandomGridShuffle ne 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.
  • 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

# Charger un modèle
model = YOLO("yolo26n.pt")

# Définir des transformations Albumentations personnalisées
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),
]

# Entraîner avec des transformations Albumentations personnalisées
model.train(
    data="coco8.yaml",
    epochs=100,
    augmentations=custom_transforms,  # Transmettre des transformations personnalisées
    imgsz=640,
)

FAQ#