Énoncé du problème

Étant donnés :

• des images \(x_i\),
  
• des cibles \(y_i\) qui contiennent les boîtes englobantes et les étiquettes des objets

Exemples d’ImageNet (voir ici)

Boîtes englobantes données, dans les ensembles de données (la paramétrisation du prédicteur peut différer), par : \([x, y, w, h]\), \([x_{min},y_{min},x_{max},y_{max}]\), …

Ensembles de données : Coco, ImageNet, Open Images Dataset

Revue récente : (Zou, Chen, Shi, Guo, & Ye, 2023) , (Terven, Córdova-Esparza, & Romero-González, 2023)

Les dimensions à explorer

Cette tâche étant définie, les questions à aborder sont :

• quelles sont les métriques spécifiques utilisées pour mesurer les performances ? Précision de classification, qualité de régression des boîtes englobantes, vitesse

Métriques pour mesurer les performances

Les métriques devraient idéalement capturer :

• la qualité des boîtes englobantes
  
• la qualité de l’étiquette trouvée dans la boîte englobante

Étant donné les boîtes englobantes “vraies” :

Quantifier la qualité de ces prédictions

Un prédicteur devrait produire des boîtes englobantes étiquetées avec un score de confiance. Ils en produisent beaucoup.

Votre métrique devrait évaluer la fraction de boîtes englobantes que vous détectez correctement (TP) et la fraction de boîtes englobantes que vous détectez incorrectement (FP) ou manquez incorrectement (FN).

La métrique mAP Pascal/COCO

Les boîtes de VT qui ne sont pas prédites sont des Faux Négatifs (FN).

Exemples du dépôt de métriques de détection d’objets.

La métrique mAP Pascal/COCO

Si vous abaissez votre seuil de confiance, votre précision peut soit augmenter soit diminuer, votre rappel peut soit stagner soit augmenter.

Perte

Augmentations de données

L’augmentation de données aide à régulariser votre réseau : ce sont des transformations que vous appliquez sur les entrées pour lesquelles vous pouvez calculer l’effet sur la cible.

import albumentations as A
import albumentations.pytorch

transform = A.Compose([
    A.HorizontalFlip(p=0.5),
    A.RandomRotate90(p=0.5),
    A.MaskDropout((1, 1), image_fill_value=255, p=1),
    A.Blur(),
    A.RandomBrightnessContrast(p=0.2),
    A.RandomBrightnessContrast(p=0.2),
    A.pytorch.ToTensorV2()
], bbox_params=A.BBoxParams(format='coco'))


transformed = transform(images=images, bboxes=bboxes)

from torchvision.transforms import v2

transforms = v2.Compose(
    [
        v2.ToImage(),
        v2.RandomPhotometricDistort(p=1),
        v2.RandomZoomOut(fill={tv_tensors.Image: (123, 117, 104), "others": 0}),
        v2.RandomIoUCrop(),
        v2.RandomHorizontalFlip(p=1),
        v2.SanitizeBoundingBoxes(),
        v2.ToDtype(torch.float32, scale=True),
    ]
)

target = {
    "boxes": boxes,
    "labels": torch.arange(boxes.shape[0]),
    "this_is_ignored": ("arbitrary", {"structure": "!"})
}
out_img, out_target = transforms(images, targets)

Post-traitement : Non Maximum Suppression

Votre prédicteur produira beaucoup de boîtes englobantes. Plusieurs pourraient se chevaucher.

La suppression des non-maximums (NMS) supprime les boîtes avec des scores plus bas qui se chevauchent (IOU) avec d’autres boîtes ayant des scores plus élevés.

Une première étape : localisation d’objet

Supposons que vous ayez un seul objet à détecter, pouvez-vous le localiser dans l’image ?

Le domaine évolue à un rythme très rapide

Comme examiné dans [Zhou et al, 2023] :

Réseau de Neurones Convolutifs Basé sur les Régions : R-CNN

Comment pouvons-nous procéder avec plusieurs objets ? (Ross Girshick, Donahue, Darrell, & Malik, 2014) a proposé de :

• utiliser une recherche sélective pour proposer des boîtes englobantes
• classifier avec un SVM à partir des caractéristiques extraites par un DNN pré-entraîné.
  
• optimiser la localisation avec des adaptateurs linéaires de boîtes englobantes

Révolution dans la communauté de détection d’objets (vs caractéristiques “traditionnelles” de type HOG).

Inconvénient :

• algorithme externe (pas dans le graphe de calcul, non entraînable)
• une passe avant par proposition de boîte englobante (\(\sim 2K\) ou plus) \(\rightarrow\) l’entraînement et le test sont lents (\(47 s.\) par image avec VGG16)

Fast R-CNN

Introduit dans (R. Girshick, 2015). Idée :

• juste une passe avant
• recadrage des cartes de caractéristiques convolutionnelles (par exemple, \((1, 512, H/16, W/16)\) conv5 de VGG16)
• max-pooling du recadrage de taille variable en un vecteur de taille fixe (par exemple \(7 \times 7\)) avant les couches denses : ROI pooling

Inconvénients :

• algorithme externe pour les propositions de ROI : non entraînable et lent
• les ROI sont alignées sur la grille (voir ici) \(\rightarrow\) ROI align

Faster R-CNN : 2 étapes entraînées de bout en bout

Introduit dans (Ren, He, Girshick, & Sun, 2016). Le premier réseau entraînable de bout en bout. Introduction du Réseau de Proposition de Régions (RPN). Un RPN est un réseau Conv(\(3\times3\)) - Conv(\(1\times1\), k + 4k) glissant (voir ici). Il introduit également des boîtes d’ancrage de ratios d’aspect prédéfinis appris par quantification vectorielle.

Vérifiez le papier pour beaucoup de résultats quantitatifs. Les petits objets peuvent ne pas avoir beaucoup de caractéristiques.

En pratique

En pratique, torchvision fournit des modèles pré-entraînés pour la détection d’objets, par exemple des modèles Faster RCNN.

En pratique

from torchvision.models.detection import fasterrcnn_resnet50_fpn

model = fasterrcnn_resnet50_fpn(num_classes=...)

# Entraînement
model.train()
model(images, targets)

# Inférence
model.eval()
predictions = model(images)

targets = [
    {
        'boxes': FloatTensor[N1, 4],
        'labels': IntTensor[N1]},
    },
    {
        'boxes': FloatTensor[N2, 4],
        'labels': IntTensor[N2]},
    },
    ... 
]

predictions = [
    {
        'boxes': FloatTensor[N1, 4]
        'labels': IntTensor[N1],
        'scores' : FloatTensor[N1]
    },
    {
        'boxes': FloatTensor[N2, 4]
        'labels': IntTensor[N2],
        'scores' : FloatTensor[N2]
    },
    ....
]

Caractéristiques multi-échelles avec sémantique et localisation

• Dans les classificateurs profonds, les couches supérieures sont sémantiquement riches mais spatialement pauvres,

• Les réseaux de pyramides de caractéristiques (FPN) (Lin et al., 2017) ont introduit un chemin descendant pour propager la sémantique jusqu’aux premières couches,

• L’agrégation du chemin ascendant ajoute des raccourcis pour propager des frontières d’objets précises aux couches supérieures (Liu, Qi, Qin, Shi, & Jia, 2018)

(Liu et al., 2018) a également introduit le Pooling de Caractéristiques Adaptatif plutôt qu’une attribution arbitraire des propositions à un niveau de la pyramide comme dans (Lin et al., 2017).

You Only Look Once (Yolo v1,v2,v3)

Le premier détecteur en une étape. Introduit dans (Redmon, Divvala, Girshick, & Farhadi, 2016). Il produit :

• \(B\) boîtes englobantes \((x, y, w, h, conf)\) pour chaque cellule d’une grille \(S\times S\)
• les probabilités sur les \(K\) classes
• le volume de sortie est \((5\times B+K)\times(S\times S)\) dans YoloV1, puis \((5+K)\times B \times (S\times S)\) à partir de v2

Encodage de la boîte englobante :

Dans YoLo v3, le réseau est de type Réseau de Pyramide de Caractéristiques (FPN) avec un chemin de sous-échantillonnage et de sur-échantillonnage, avec des prédictions à 3 étapes.

You Only Look Once (Yolo v1,v2,v3)

La perte est multi-tâches avec :

• un terme pour la régression de la transformation des boîtes d’ancrage
• un terme pour détecter la présence d’un objet
• un terme pour l’étiquetage (potentiellement multiple) des boîtes

\[\begin{align*} \mathcal{L} &= \lambda_{coord} \sum_{i=0}^{S^2}\sum_{j=0}^{B} \mathbb{1}_{ij}^{obj} [(t_x-t_x^*)^2+(t_y-t_y^*)^2+(t_w-t_w^*)^2+(t_h-t_h^*)^2] \\ & -\sum_{i=0}^{S^2} \sum_{j=0}^{B} BCE(\mathbb{1}_{ij}^{obj}, \mbox{has_obj}_{ij}) \\ & -\sum_{i=0}^{S^2} \sum_{j=0}^{B} \sum_{k=0}^{K} BCE(\mbox{has_class}_{ijk}, p_{ijk}) \end{align*}\]

Famille Yolo

À partir de Yolov4, plusieurs auteurs publient des versions de Yolo…, voir (Terven et al., 2023)

• Yolov1 (2016), v2, v3 (2018) par J. Redmon et al. : principe + ancres + multi-échelle (FPN)

Yolov5 (2020)

• Publié en 2020 par Ultralytics
• Couche CSP (DarknetNet économique de Yolov3 (ResNet économique))
• Têtes couplées, basé sur les ancres
• FPN descendant
• PAN ascendant

Voir aussi cette page

Yolov8 (2023)

• Publié début 2023 par Ultralytics
• différentes versions à l’échelle disponibles (nano … extra-large)
• Couche CSP mise à jour : module C2f
• Têtes découplées, Sans ancre

En pratique

• Vous pourriez (éventuellement) implémenter vous-même Yolo 😖 ,

from ultralytics import YOLO

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

# Entraîner le modèle
train_results = model.train(
    data="coco8.yaml",  # chemin vers le YAML du dataset
    epochs=100,  # nombre d'époques d'entraînement
    imgsz=640,  # taille de l'image d'entraînement
    device="cpu",  # appareil sur lequel exécuter, c'est-à-dire device=0 ou device=0,1,2,3 ou device=cpu
)

# Évaluer les performances du modèle sur l'ensemble de validation
metrics = model.val()

# Effectuer une détection d'objets sur une image
results = model("chemin/vers/image.jpg")
results[0].show()

# Exporter le modèle au format ONNX
path = model.export(format="onnx")  # renvoie le chemin vers le modèle exporté

En pratique avec Ultralytics et SAHI

Tâche : détecter des bactéries, dans un flux, adhérant aux parois (en collaboration avec L. Klopffer, N. Louvet, S. Becker)

Utilisation d’ultralytics et de leurs callbacks wandb 😍 ; SAHI (pour l’inférence en tuiles). 😍

Code sur https://github.com/S1m0nB3ck3r/bacteria_tracker_yoloV8. Publication en cours d’examen.

En pratique avec Ultralytics et SAHI (suite)

Tâche : détecter des bactéries, dans un flux, adhérant aux parois (en collaboration avec L. Klopffer, N. Louvet, S. Becker)

Utilisation d’ultralytics et de leurs callbacks wandb 😍 ; SAHI (pour l’inférence en tuiles). 😍

Code sur https://github.com/S1m0nB3ck3r/bacteria_tracker_yoloV8. Publication en cours d’examen.

Énoncé du problème

Étant donné une image,

Segmentation sémantique : prédire la classe de chaque pixel individuel. On parle aussi de prédiction dense/étiquetage dense.

Image d’exemple de MS Coco

Segmentation d’instance : classifier tous les pixels appartenant aux mêmes objets dénombrables

Image d’exemple de MS Coco

Plus récemment, la segmentation panoptique fait référence à la segmentation d’instance pour les objets dénombrables (par exemple, personnes, animaux, outils) et à la segmentation sémantique pour les régions amorphes (herbe, ciel, route).

Métriques : voir Évaluation panoptique Coco

Quelques exemples de réseaux : PSP-Net, U-Net, Dilated Net, ParseNet, DeepLab, Mask RCNN, …

Faire glisser un classificateur

Introduit dans (Ciresan, Giusti, Gambardella, & Schmidhuber, 2012).

• La segmentation prédite est post-traitée avec un filtre médian
• La probabilité de sortie est calibrée pour compenser les différentes probabilités a priori d’être une membrane / de ne pas être une membrane.

Inconvénients :

• une passe avant par patch
• les patches qui se chevauchent ne partagent pas les calculs

(sur la calibration des réseaux de neurones profonds, voir aussi (Guo, Pleiss, Sun, & Weinberger, 2017))

Réseau entièrement convolutif (FCN)

Introduit dans (Long, Shelhamer, & Darrell, 2015). Premier réseau convolutif de bout en bout pour l’étiquetage dense avec des réseaux pré-entraînés.

Le sur-échantillonnage peut être :

• différenciable codé en dur : par exemple, plus proche voisin, bilinéaire, bicubique
• appris comme une convolution à pas fractionnaire (déconvolution),

Sur-échantillonnage appris : convolution à pas fractionnaire

Les approches traditionnelles impliquent une interpolation bilinéaire, bicubique, etc…

Pour le sur-échantillonnage de manière apprenante, nous pouvons utiliser une convolution à pas fractionnaire. C’est l’un des ingrédients derrière la Super-Résolution (Shi, Caballero, Huszár, et al., 2016).

Vous pouvez initialiser les noyaux de sur-échantillonnage avec un noyau d’interpolation bilinéaire. Pour avoir d’autres équivalences, voir (Shi, Caballero, Theis, et al., 2016). Voir ConvTranspose2d.

Cela peut introduire des artefacts, vérifiez (Odena, Dumoulin, & Olah, 2016). Certains préfèrent un sur-échantillonnage bilinéaire, suivi de convolutions.

Architectures Encodeur/Décodeur

Plusieurs modèles suivant les mêmes architectures : SegNet (somme), U-Net (concaténation). Architecture Encodeur-Décodeur introduite dans (Ronneberger, Fischer, & Brox, 2015)

Il y a :

• un chemin de contraction de l’image “vers le bas” vers des caractéristiques de haut niveau à une résolution spatiale grossière
• un chemin d’expansion de sur-échantillonnage qui intègre des caractéristiques de bas niveau pour un étiquetage pixel par pixel

DeepLab

Pour rassembler des informations contextuelles en élargissant les champs réceptifs, DeepLab emploie des convolutions “à trous” (dilatées) plutôt que du max pooling. DeepLabV1 (Chen, 2014), DeepLabV2 (Chen, Papandreou, Kokkinos, Murphy, & Yuille, 2017), DeepLabV3 (Chen, Papandreou, Schroff, & Adam, 2017), DeepLabV3+ (Chen, Zhu, Papandreou, Schroff, & Adam, 2018).

• Le max-pooling dans les backbones de classification induit une invariance à la translation \(\rightarrow\) convolutions à trous
• Comment gérer les objets à plusieurs échelles ? \(\rightarrow\) Pooling spatial à trous (ASPP)
• Dans DeepLabV3+, combiné avec des couches de décodage de sur-échantillonnage

En pratique

from torchvision.models.segmentation import deeplabv3_resnet50, DeepLabV3_ResNet50_Weights

model = deeplabv3_resnet50(
    DeepLabV3_ResNet50_Weights.DEFAULT,
    num_classes = 1
)

import segmentation_models_pytorch as smp

cin = 1
num_classes = 1
model = smp.DeepLabV3Plus(
    in_channels = cin, 
    classes = num_classes,
    encoder_name = "resnet18",
    encoder_weights = "imagenet"
)

Torchvision (v2) et albumentations prennent tous deux en charge l’augmentation sur les masques. Voir albumentations pour un exemple.

En pratique

Tâche Segmenter les matières non vivantes vs les organismes vivants dans les images ZooScan.

• Grandes images \(\approx 15000 \times 23000\) contenant des objets appartenant à \(89\) catégories. Non vivant (étiquette < 8) ou vivant.
• Utilisant soit :
  • un UNet avec un backbone pré-entraîné + décodeur aléatoire (labo)
  • un DeepLabv3+ pré-entraîné sur ImageNet
• Entraîné sur des patches chevauchants de \(512 \times 512\), perte focale, score F1 pour l’arrêt précoce

• 76K pour l’entraînement, 19K pour la validation
• Une époque en 10 minutes sur RTX 3090
• Retournement, Rotation, MaskDropout, Flou

En pratique

Tâche Segmenter les matières non vivantes vs les organismes vivants dans les images ZooScan.

Inférence sur un nouvel échantillon avec une inférence en tuiles. Nous aurions pu utiliser une inférence moyennée avec des tuiles chevauchantes.

Masque produit avec un seuil@0.5 qui peut être sous-optimal.

Mask-RCNN

Introduit dans (He, Gkioxari, Dollár, & Girshick, 2018) comme une extension de Faster RCNN. Il produit un masque binaire en plus des étiquettes de classe + régressions de boîtes englobantes.

Il traite la segmentation d’instance en prédisant un masque pour des propositions d’objets individualisés.

Propose d’utiliser ROI-Align (avec interpolation bilinéaire) plutôt que ROI-Pool.

Il n’y a pas de compétition entre les classes dans les masques. Différents objets peuvent utiliser différents noyaux pour calculer leurs masques.

Peut être étendu à la détection de points-clés, produisant un masque de profondeur \(K\) pour prédire les \(K\) articulations.

Yolo

Ultralytics Yolo segment adopte la même stratégie de prédiction d’un masque pour chaque boîte englobante.

from ultralytics import YOLO

# Charger un modèle
model = YOLO("yolo11n-seg.pt")

# Entraîner le modèle
train_results = model.train(data="coco8-seg.yaml", epochs=100, imgsz=640)

results = model("monimage.jpg")  # prédire sur une image

Démo en direct avec https://github.com/jeremyfix/deeplearning_demos et https://github.com/jeremyfix/onnx_models.

Transformers

Introduits dans (Vaswani et al., 2017), du TAL à la Vision par ViT (Dosovitskiy et al., 2021).

Propositions récentes pour :

• Détection d’objets : (Carion et al., 2020) a proposé un détecteur d’objets basé sur les transformers. Le décodeur produit un grand nombre prédéfini \(N\) de boîtes englobantes étiquetées.

En pratique, huggingface transformers implémente DETR. Regardez le papier, ce ne sont que quelques lignes de pytorch.