🎭 Mask R-CNN – Le Guide Ultime

Mask R-CNN (Mask Region-based Convolutional Neural Network) est une architecture d'IA (publiée en 2017 par Kaiming He et al. chez Facebook AI Research - FAIR) qui a défini l'état de l'art (SOTA) en Segmentation d'Instance.

La Hiérarchie des Tâches (Qu'est-ce que "Instance" ?)

Il faut comprendre la différence entre les 3 tâches de segmentation :

En résumé : Mask R-CNN ne se contente pas de trouver les objets (Détection), il *dessine* le contour de *chaque* instance d'objet (Segmentation).

En détection/segmentation, il y a deux "philosophies" (frameworks) :

Mask R-CNN est le "roi" de l'approche "Two-Stage". Sa philosophie est : La précision (qualité) prime sur la vitesse (latence). On l'utilise quand on a besoin des *meilleurs* masques possibles, pas forcément en temps-réel.

Pour comprendre Mask R-CNN (2017), il faut comprendre son "père" : Faster R-CNN (2015). C'est une évolution de "plugins" successifs.

Conclusion : Mask R-CNN = Faster R-CNN + Mask Head + RoIAlign

L'architecture de Mask R-CNN est "Two-Stage" (deux étapes) et "Multi-Task" (multi-tâches).

Diagramme (Conceptuel)

(Input: Image)
     |
     ▼
+--------------------------------+
| 1. Backbone (Feature Extractor)|
| (ex: ResNet-50 + FPN)          |
+--------------------------------+
     |
     | (Feature Maps Multi-échelles)
     |
     +-----------> (Étape 1) -------------------+
     |                                          |
     ▼                                          |
+-----------------+                          (Features)
| 2. RPN          |                             |
| (Propose Régions)                            |
+-----------------+                             |
     |                                          |
     | (Propositions de RoI [BBox])             |
     |                                          |
     +-----------> (Étape 2) <------------------+
                   |
                   ▼
+--------------------------------+
| 3. RoIAlign (Plugin)           | (Alignement précis des features)
| (Combine RoIs + Features)      |
+--------------------------------+
                   | (Features "croppées" et alignées)
                   |
     +-------------+-------------+
     |             |             |
     ▼             ▼             ▼
+----------+  +----------+  +-------------+
| 4a. Tête |  | 4b. Tête |  | 4c. Tête    |
| (Classif.)  | (BBox Reg.) | (MASK (FCN))|
+----------+  +----------+  +-------------+
     |             |             |
     ▼             ▼             ▼
(Classe)       (BBox)        (Masque)

1. Le Backbone (Plugin) : ResNet + FPN

L'Encoder. Mask R-CNN utilise un "plugin" (backbone) standard pour extraire les features. Le papier originel utilisait ResNet-50 ou ResNet-101 (voir 1.4, ResNet).

Il utilise aussi un "plugin" FPN (Feature Pyramid Network) (le même que YOLOv3, voir 1.4, YOLOv3) pour obtenir des features *multi-échelles* (bonnes pour les petits *et* les grands objets).

2. Le RPN (Region Proposal Network)

C'est le "plugin" hérité de Faster R-CNN. Le RPN est un *mini-réseau* qui "glisse" sur les *feature maps* (du FPN) et "propose" ~1000 "Régions d'Intérêt" (RoI) qui ont une forte probabilité de contenir *un* objet (peu importe lequel).

Sortie du RPN : Une liste de "boîtes" (RoIs) candidates.

C'est la *vraie* innovation de Mask R-CNN. C'est le "plugin" qui a rendu la segmentation d'instance (précise) possible.

Le Problème : RoIPool (de Faster R-CNN)

RoIPool (l'ancien) prenait les RoIs (régions, ex: [10.5px, 20.2px, 30.8px, 40.1px]) et les "quantifiait" (arrondissait) à l'entier le plus proche (ex: [10, 20, 31, 40]) pour les "cropper" (découper) dans la feature map.
Conséquence : Un désalignement (misalignment). Pour une BBox, ce n'est pas grave. Pour un *masque* (pixel-level), c'est *désastreux*.

La Solution : RoIAlign

RoIAlign (le "nouveau" plugin) ne "quantifie" (n'arrondit) *jamais*.
Il garde les coordonnées *flottantes* (ex: 10.5, 20.2) et utilise l'Interpolation Bilinéaire (Bilinear Interpolation) pour "sampler" (échantillonner) les pixels de la feature map à ces positions exactes (sub-pixel).

Résultat : Les "features" extraites sont *parfaitement* alignées avec l'image d'entrée, permettant une prédiction de masque au pixel près.

Après RoIAlign, on obtient un "pool" de features (ex: 14x14x256) pour *chaque* RoI proposée.
Mask R-CNN envoie ces features à 3 "têtes" (heads) "plugins" en parallèle :

La Tête de Masque (Mask Head)

C'est le "plugin" M de Mask R-CNN.
C'est un "mini U-Net" (un FCN) qui prend les features (ex: 14x14x256) et utilise des ConvTranspose2d (Up-sampling) pour les "remonter" en un masque (ex: 28x28x80) (un masque de 28x28 pour chacune des 80 classes).

Mask R-CNN est un modèle "Multi-Task" (Multi-Tâches). Il n'apprend pas *une* chose, il apprend *plusieurs* choses en même temps. La "Loss" (fonction de coût) est une *somme* de toutes les "losses" (erreurs) de chaque "plugin" (tête).

Loss de l'Étape 1 (RPN)

• L_rpn_cls (Loss Classe RPN) : Cross-Entropy. Le RPN a-t-il bien classé "Objet" vs "Fond" ?
• L_rpn_box (Loss BBox RPN) : L1 Loss. Le RPN a-t-il bien prédit la BBox de l'objet ?

Loss de l'Étape 2 (Têtes)

• L_cls (Loss Classe Tête) : Cross-Entropy. La tête de classification a-t-elle bien classé "Chat" vs "Chien" ?
• L_box (Loss BBox Tête) : L1 Loss. La tête BBox a-t-elle bien *raffiné* la BBox ?
• L_mask (Loss Masque Tête) : Binary Cross-Entropy (BCE). La tête de masque a-t-elle bien prédit le masque (pixel par pixel) ?

Loss Totale

L_total = L_rpn_cls + L_rpn_box + L_cls + L_box + L_mask

Le réseau est entraîné "de bout en bout" (End-to-End) en optimisant cette "loss" totale (via backpropagation).

L'implémentation "historique" et la plus célèbre de Mask R-CNN (en dehors de celle de Facebook, Caffe2) est le "plugin" (repository) de Matterport.
Il est écrit en Python 3, Keras (TensorFlow 1.x). (Attention : Il est *très* difficile à faire tourner avec TF 2.x+).

Inférence (Matterport)

import mrcnn.model as modellib
from mrcnn import visualize

# 1. Charger la config (mode inférence)
class InferenceConfig(coco.CocoConfig):
    GPU_COUNT = 1
    IMAGES_PER_GPU = 1
config = InferenceConfig()

# 2. Créer le modèle (en mode inférence)
model = modellib.MaskRCNN(mode="inference", 
                        config=config,
                        model_dir="./logs")

# 3. Charger les poids (pré-entraînés sur COCO)
model.load_weights("mask_rcnn_coco.h5", by_name=True)

# 4. Inférence (Lancer la détection)
results = model.detect([image], verbose=1)

# 5. Parser les résultats (très simple)
r = results[0]
# r['rois'] -> (N, 4) BBoxes
# r['masks'] -> (H, W, N) Masques
# r['class_ids'] -> (N,) IDs
# r['scores'] -> (N,) Confiance

# 6. Visualiser (plugin 'visualize')
visualize.display_instances(image, r['rois'], r['masks'], 
                            r['class_ids'], class_names)

Aujourd'hui, l'implémentation "plugin" la plus simple et la plus maintenue est celle de Torchvision (l'addon "vision" de PyTorch).

Exemple (Inférence PyTorch)

import torch
import torchvision
from torchvision.models.detection import maskrcnn_resnet50_fpn
from PIL import Image
from torchvision import transforms as T

# 1. Charger le modèle pré-entraîné
model = maskrcnn_resnet50_fpn(pretrained=True)
model.eval() # Mode Inférence

# 2. Transforms (simples)
transform = T.Compose([T.ToTensor()])

# 3. Charger l'image
img = Image.open("mon_image.jpg")
img_tensor = transform(img)

# 4. Inférence
with torch.no_grad():
    # Note: [img_tensor] (batch de 1)
    prediction = model([img_tensor])

# 5. Parser les résultats (prediction[0])
# (Sont déjà des Tensors Torch)
boxes = prediction[0]['boxes']
labels = prediction[0]['labels']
scores = prediction[0]['scores']
masks = prediction[0]['masks']

U-Net et Mask R-CNN sont deux "plugins" (architectures) de segmentation, mais ils ne font pas la même chose.

Exemples de Projets

• Analyse Médicale : Isoler et compter *chaque* cellule ou noyau dans une image de microscopie (où U-Net fusionnerait tout).
• Robotique (Grasping) : Permet à un bras robotisé de voir *chaque* objet (ex: "Vis-1", "Vis-2") sur une table, de connaître sa forme (masque) et de le saisir.
• Analyse Satellite : Dénombrer et mesurer la surface de *chaque* bâtiment (Instance) dans une ville (vs U-Net qui donnerait juste un masque "bâtiment").