🛰️ DeepLab v3+ – Le Guide Ultime

DeepLab est une famille de modèles de Segmentation Sémantique (SOTA, State-of-the-Art) développée par Google Brain (Liang-Chieh Chen et al.).

La Tâche (Segmentation Sémantique) : Le but n'est pas de dire "Il y a un chat" (Classification) ni "Ce chat est ici [BBox]" (Détection). Le but est de *classifier chaque pixel* de l'image.
Sortie : Un "masque" de la même taille que l'entrée, où Pixel (10, 20) = Classe 3 (Route), Pixel (10, 21) = Classe 5 (Bâtiment).

C'est l'architecture de référence pour la cartographie (Géo-Infos), l'imagerie médicale, et les voitures autonomes.

La Famille (Historique)

• DeepLab v1 (2014) : Introduit la "Atrous Convolution" (voir 1.3).
• DeepLab v2 (2017) : Introduit ASPP (Atrous Spatial Pyramid Pooling) (voir 1.4).
• DeepLab v3 (2017) : Améliore ASPP (ajoute BatchNorm, 1x1 Conv).
• DeepLab v3+ (2018) : L'architecture "moderne". Ajoute un "plugin" Decoder (style U-Net) à v3 (voir 1.5).

La segmentation sémantique fait face à un dilemme fondamental :

La Solution : Le "Plugin" Atrous

La solution de DeepLab est : "Et si on pouvait augmenter le *champ réceptif* (le "Quoi") *sans* utiliser de MaxPool (donc sans détruire le "Où") ?".
C'est le rôle de la Atrous (Dilated) Convolution (voir 1.3).

"Atrous" (à trous) est le "plugin" (l'innovation) clé de DeepLab. C'est une convolution "dilatée" (gonflée).

Elle ajoute un hyperparamètre : rate (taux de dilatation).

[x][x][x]
[x][x][x]
[x][x][x]

[x][.][x][.][x]
[.][.][.][.][.]
[x][.][x][.][x]
[.][.][.][.][.]
[x][.][x][.][x]

L'Impact (Le "Plugin" Magique)

L'Atrous Conv (rate=2) a le *même* coût de calcul (9 poids) qu'un Conv 3x3, mais il a le *champ réceptif* (la "vision") d'un Conv 5x5.

La Stratégie DeepLab :
1. Prendre un ResNet.
2. Supprimer les derniers MaxPool (qui détruisent l'info spatiale).
3. Remplacer les convolutions suivantes par des Atrous Convolutions (rate=2, rate=4...).

Résultat : Le réseau garde une haute résolution (ex: 56x56) mais son champ réceptif *continue de grandir* (grâce aux "trous"). Il obtient le "contexte" (Quoi) *sans* perdre la "localisation" (Où).

Le Problème (Géo-Infos) : Dans une image satellite, une "route" peut faire 50 pixels (zoom) ou 3 pixels (dézoom). Comment gérer cette "multi-échelle" ?

La Solution (Plugin v2) : ASPP (Atrous Spatial Pyramid Pooling).
Au lieu de choisir *un seul* rate (ex: rate=6), ASPP applique *plusieurs* "plugins" Atrous (avec différents rate) en parallèle (comme le Module Inception de GoogleNet, voir 1.4).

Diagramme (ASPP)

(Input: Feature Map, ex: 64x64x256)
     |
     +---- [ Conv 1x1 ] -------------------------+
     |                                           |
     +---- [ Atrous Conv 3x3 (rate=6) ] ---------+
     |                                           |
     +---- [ Atrous Conv 3x3 (rate=12) ] --------+
     |                                           |
     +---- [ Atrous Conv 3x3 (rate=18) ] --------+
     |                                           |
     +---- [ Global Average Pooling -> Conv 1x1] + (Contexte Global)
     |
     ▼
[ CONCAT ] (Concatène tous les filtres)
     |
     ▼
[ Conv 1x1 ] (Fusionne les features)
     |
     ▼
(Output: 64x64xN)

Résultat : La sortie "fusionnée" contient des informations sémantiques de *plusieurs* échelles (très local, moyen, très large) en même temps.

DeepLab v3 (2017) était "juste" un Encoder (ex: ResNet) + le "plugin" ASPP. Le résultat était "flou" (ex: 1/16e de la taille d'entrée).

DeepLab v3+ (2018) est l'architecture finale. Elle *combine* DeepLab v3 (pour le "Quoi") avec l'architecture "Encoder-Decoder" de U-Net (pour le "Où").

Diagramme (DeepLab v3+)

(Input: 512x512)
     |
     ▼
+---------------------+
| ENCODER (Backbone)  | (ex: ResNet-101 "Atrous")
| (Capture "Context") |
+---------------------+
     |
     | (Features "Basses" (Détails) 128x128)
     +----(Skip Connection)----+
     |
     ▼
+---------------------+
| ASPP (Plugin v3)    | (Capture "Multi-Scale Context")
| (Output: 32x32)     |
+---------------------+
     |
     | (Upsample 4x -> 128x128)
     ▼
+---------------------+
| DECODER             |
| (Plugin v3+)        |
|                     |
| 1. [ CONCAT ] <-----+ (Features "Basses")
| 2. [ Conv 3x3 ]     | (Raffine)
| 3. [ Upsample 4x ]  | (-> 512x512)
+---------------------+
     |
     ▼
(Output: Masque 512x512)

C'est le "meilleur des deux mondes" (U-Net + ResNet/ASPP) :
1. L'Encoder (ResNet+ASPP) fournit le contexte sémantique (le "Quoi").
2. Le Decoder (plugin v3+) utilise les "Skip Connections" (des *basses* couches du ResNet) pour récupérer les détails fins (le "Où") et affiner les bords du masque.

Le "Backbone" (extracteur de features) de DeepLab est un "plugin" interchangeable. Le papier v3+ a testé ResNet-101 et Xception.

Xception (Extreme Inception)

Xception (par Google, 2017) est le "successeur" de MobileNet (v1). Il pousse le "plugin" Depthwise Separable Convolution (voir 1.3, MobileNet) à l'extrême.

L'architecture DeepLab v3+ SOTA (actuelle) utilise un Xception (modifié) comme backbone, car il est (généralement) *plus rapide* et *plus précis* que le backbone ResNet-101 pour la segmentation.

DeepLab v3+ (et U-Net) est le "plugin" (architecture) de choix pour l'analyse d'images Géo-spatiales (Geo-infos) et de télédétection (Remote Sensing).

La "segmentation sémantique" est la tâche qui permet de transformer une image satellite (pixels) en *carte* (vecteurs).

Exemples de Projets

• Extraction de Bâtiments (Building Footprints) : (Projet de Google/Microsoft). Identifier *chaque pixel* qui est un "bâtiment".
• Extraction de Routes : Identifier *chaque pixel* qui est une "route" ou "autoroute".
• Analyse Agricole : Classifier les pixels (champs) en "Maïs", "Soja", "Forêt".
• Analyse Environnementale : Suivi de la déforestation (pixels "Forêt" vs "Sol nu"), zones inondables (pixels "Eau").

Pourquoi DeepLab est-il bon pour les Géo-Infos ?

1. Le "Plugin" ASPP (Multi-échelle) : Les images satellite ont des échelles *folles*. Une "maison" peut faire 5 pixels ou 500 pixels. L'ASPP (voir 1.4) est *conçu* pour gérer ça.
2. Le "Plugin" Decoder (v3+) : Pour tracer une route, les *bords* (contours) doivent être précis. Le Decoder (style U-Net) (voir 1.5) est très bon pour raffiner les contours.

Pour entraîner un DeepLab (Transfer Learning), on utilise des datasets "géo" (plugins de données) spécifiques.

Le Défi : Multi-spectral (vs RGB)

Un "plugin" (problème) majeur : Les images JPEG/PNG sont RGB (3 canaux).

Les images satellites (Géo-infos) sont Multi-spectrales. Elles ont 4, 8, ou 12 canaux (ex: RGB + Infra-rouge (NIR), SWIR...).

Implication : On ne peut *pas* utiliser un backbone ResNet (pré-entraîné sur ImageNet, 3 canaux) *directement*.
Solution (Plugin) : On modifie la *première couche* (Conv1) du ResNet (in_channels=3) pour accepter (ex:) 4 canaux (in_channels=4), et on entraîne (fine-tune) cette couche (ou on la pré-entraîne).

Un projet de segmentation géo-info (ex: routes) est un projet 80% "Data" (pré-processing) et 20% "Modèle" (DeepLab).

Les "Plugins" (Librairies) Géo-Python

Vous n'ouvrez pas une image satellite (.tiff) avec Pillow (PIL). Vous utilisez des "plugins" (librairies) Python spécialisés :

• GDAL / Rasterio : La "librairie" (plugin) n°1 pour *lire* les GéoTIFFs (images satellites). Elle gère les canaux (ex: 8 canaux), les projections (CRS), et les méta-données.
• GeoPandas / Shapely : La "librairie" (plugin) n°1 pour *lire* les "labels" (ex: routes.geojson, shapefile).

Workflow (Projet Routes)

1. Data (Labels) : Obtenir les vecteurs (GeoJSON) des routes (ex: OpenStreetMap).
2. Pré-processing (Le "plugin" GDAL) :
   a. "Rasteriser" les vecteurs (GeoJSON) en masques binaires (.png) (0=Fond, 1=Route).
   b. "Tiler" (découper) les immenses images satellites (ex: 10000x10000 px) en tuiles (ex: 512x512 px) que le GPU peut gérer.
3. Modèle : Un DeepLab v3+ (Backbone ResNet ou MobileNet).
4. Loss : Dice Loss (ou "Focal Loss") car "Route" (1%) est très déséquilibré vs "Fond" (99%).
5. Post-processing : "Vectoriser" (polygones) les masques .png prédits (via skimage ou gdal_polygonize) pour obtenir un .geojson propre.

L'implémentation "historique" (plugin) de DeepLab (par Google) était en Keras/TensorFlow.

Attention : tf.keras.applications.DeepLabV3Plus est *obsolète* et a été *retiré* de Keras 3 (TensorFlow 2.16+). On doit maintenant (généralement) utiliser le "Model Garden" de TF ou une implémentation manuelle (comme pour U-Net, voir 2.3 U-Net).

Inférence (Keras / TF Hub)

Le moyen le plus simple (plugin) est d'utiliser TensorFlow Hub (tfhub.dev).

import tensorflow as tf
import tensorflow_hub as hub
from PIL import Image
import numpy as np

# 1. Charger le modèle DeepLab v3 (plugin TF Hub)
#    (Modèle pré-entraîné sur PASCAL VOC)
MODEL_URL = "https://tfhub.dev/google/deeplab/v3/1"
model = hub.load(MODEL_URL)

# 2. Charger l'image (doit être (1, 513, 513, 3))
img = Image.open("image.jpg").resize((513, 513))
img_array = np.array(img) / 255.0
img_batch = np.expand_dims(img_array, axis=0)

# 3. Inférence
#    (La 'signature' (plugin) 'default' renvoie le masque)
results = model(tf.constant(img_batch))['default']

# 4. 'results' est un masque (1, 513, 513, N_CLASSES)
#    On doit prendre l'argmax pour savoir quelle classe a gagné
mask = tf.argmax(results, axis=-1)[0]

Le "plugin" torchvision (l'addon officiel de PyTorch pour la vision) fournit des modèles DeepLab v3 pré-entraînés (Backbone ResNet-50/101).

Exemple (Inférence PyTorch)

import torch
from torchvision import models, transforms
from PIL import Image

# 1. Charger DeepLab v3 (Backbone ResNet-101) pré-entraîné
model = models.segmentation.deeplabv3_resnet101(pretrained=True)
model.eval() # Mode Inférence

# 2. Définir les transforms (standard ImageNet)
preprocess = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize(mean=[0.485, 0.456, 0.406], 
                         std=[0.229, 0.224, 0.225]),
])

# 3. Charger & Pré-processer l'image
img = Image.open("image.jpg")
img_t = preprocess(img)
batch_t = torch.unsqueeze(img_t, 0) # (Ajoute la dimension batch)

# 4. Inférence
with torch.no_grad():
    output = model(batch_t)['out'] # (Output: [1, 21, H, W]) (21 classes COCO)

# 5. Interpréter (Prendre l'argmax sur les classes (dim=1))
mask = torch.argmax(output.squeeze(), dim=0).numpy()

# (mask est maintenant un array 2D (H, W) avec les IDs de classe)