🚗👁️ Segmentation d'Images pour pour le système embarqué d’une voiture autonome

🌐 Introduction

Ce projet s'inscrit dans le développement d'un système embarqué de vision par ordinateur pour véhicules autonomes chez Future Vision Transport. L'entreprise conçoit des systèmes permettant aux véhicules autonomes de percevoir leur environnement grâce à l'analyse d'images en temps réel.

En tant qu'ingénieur IA dans l'équipe R&D, notre mission est de développer le module de segmentation d'images (composant 3) qui s'intègre entre le module de traitement d'images (2) et le système de décision (4). Ce module doit être capable d'identifier et de segmenter précisément 8 catégories principales d'objets dans des images de caméras embarquées.

Cette note technique présente la conception et l'implémentation d'un modèle de segmentation d'images optimisé pour la compréhension des scènes urbaines. Le système développé s'intègre dans une chaîne complète comprenant l'acquisition d'images en temps réel, le traitement des images, la segmentation sémantique (notre contribution) et le système de décision final.

🎯 Objectifs

• Développer un modèle de segmentation d'images performant avec Keras/TensorFlow
• Concevoir et déployer une API REST avec FastAPI
• Créer une application web de démonstration avec Next.js
• Documenter le processus et les résultats de façon claire et professionnelle

🗓️ Plan de travail

1. Exploration et préparation des données

   • Analyse du jeu de données fourni par Franck (images et masques segmentés)
   • Prétraitement et augmentation des données
   • Création d'un générateur de données optimisé

2. Développement du modèle de segmentation

   • Étude des architectures de l'état de l'art (U-Net, DeepLabV3+, etc.)
   • Implémentation avec Keras
   • Entraînement et optimisation du modèle

3. Déploiement du modèle

   • Développement d'une API FastAPI
   • Création d'une application frontend Next.js
   • Déploiement sur Heroku et Vercel

4. Évaluation et documentation

   • Tests et validation des performances
   • Rédaction de la note technique
   • Préparation de la présentation

💾 Dépôt GitHub

• https://github.com/DavidScanu/oc-ai-engineer-p08-images-systeme-voiture-autonome

👋 À propos

Projet développé par David Scanu dans le cadre du parcours AI Engineer d'OpenClassrooms : Projet 8 - Traitez les images pour le système embarqué d'une voiture autonome.

👁️ 1. Développement du Modèle de Segmentation

Le notebook complet de conception du modèle de segmentation d'image est disponible sur Colab.

1.1 Contexte et Enjeux

La segmentation sémantique d'image dans le contexte automobile représente un défi technique majeur. Contrairement à la classification d'images qui attribue une étiquette à une image entière, la segmentation sémantique doit identifier et catégoriser chaque pixel de l'image. Pour un véhicule autonome, cette capacité est cruciale : il faut distinguer la route des trottoirs, identifier les véhicules, détecter les piétons, reconnaître la végétation, etc.

La segmentation sémantique consiste à étiqueter chaque pixel d’une image avec une classe correspondante à ce qui est représenté. On parle aussi de "prédiction dense", car chaque pixel doit être prédit. Elle génère une image, sur laquelle chaque pixel est classifié.

Les contraintes de notre projet sont multiples :

• Performance temps réel : Le système doit traiter les images à une fréquence suffisante pour la conduite
• Précision critique : Les erreurs de segmentation peuvent avoir des conséquences graves
• Ressources limitées : Le système embarqué dispose de capacités de calcul contraintes
• Robustesse : Le modèle doit fonctionner dans diverses conditions (météo, éclairage, types de routes)

1.2 Choix du Dataset et Préparation des Données

1.2.1 Le Dataset Cityscapes

Nous avons choisi le dataset Cityscapes, une référence dans le domaine de la segmentation urbaine. Ce dataset présente plusieurs avantages décisifs pour notre cas d'usage :

• 5 000 images avec annotations fines réparties en 2 975 images d'entraînement, 500 de validation et 1 525 de test
• Diversité géographique : 50 villes européennes différentes
• Conditions variées : Plusieurs saisons, conditions météorologiques bonnes à moyennes
• Richesse des annotations : 30 classes détaillées avec des annotations polygonales précises
• Réalisme : Images capturées depuis des véhicules en circulation réelle

1.2.2 Stratégie de Regroupement des Classes

L'une des décisions techniques les plus importantes a été le regroupement des 30+ classes originales de Cityscapes en 8 catégories pertinentes pour la navigation autonome. Cette simplification répond à plusieurs objectifs :

1. Pertinence fonctionnelle : Regrouper les éléments ayant la même importance pour la décision de navigation
2. Performance computationnelle : Réduire la complexité du modèle
3. Robustesse : Éviter la sur-spécialisation sur des classes très spécifiques

Notre mapping final :

class_groups = {
    'flat': ['road', 'sidewalk', 'parking', 'rail track'],
    'human': ['person', 'rider'], 
    'vehicle': ['car', 'truck', 'bus', 'motorcycle', 'bicycle', ...],
    'construction': ['building', 'wall', 'fence', 'bridge', ...],
    'object': ['pole', 'traffic sign', 'traffic light', ...],
    'nature': ['vegetation', 'terrain'],
    'sky': ['sky'],
    'void': ['unlabeled', 'out of roi', ...]
}

Cette approche nous permet de maintenir une granularité suffisante pour la prise de décision tout en gardant un modèle tractable.

1.2.3 Pipeline de Préparation des Données

Notre pipeline de préparation des données intègre plusieurs étapes :

Redimensionnement intelligent : Les images Cityscapes originales (2048×1024) sont redimensionnées à 224×224, un compromis entre qualité visuelle et performance computationnelle. Cette taille est également optimale pour l'utilisation de MobileNetV2 pré-entraîné.

Stratégie de validation : Pour éviter le data leakage, nous avons adopté une approche rigoureuse :

• Division du dataset 'train' original en 80% entraînement / 20% validation
• Utilisation du dataset 'val' original comme dataset de test final : cette approche garantit que notre évaluation finale est réalisée sur des données jamais vues
• Les masques du dataset 'test' étaient indisponibles (complètement noirs) : nous n'avons pas utilisé ce dossier

Augmentation de données : Nous avons implémenté des techniques d'augmentation adaptées à la segmentation :

1. Flip horizontal aléatoire (50% de probabilité)

   • Appliqué de manière synchronisée sur l'image et le masque

2. Variation de luminosité aléatoire

   • Appliquée uniquement sur l'image (pas sur le masque)
   • Amplitude : ±0.1
   • Avec clipping pour maintenir les valeurs dans [0,1]

def augment_data(image, mask):
    # Flip horizontal synchronisé image/masque
    if tf.random.uniform(()) > 0.5:
        image = tf.image.flip_left_right(image)
        mask = tf.image.flip_left_right(mask)

    # Variation de luminosité (image seulement)
    image = tf.image.random_brightness(image, 0.1)
    return image, mask

1.3 Architecture du Modèle : MobileNetV2-UNet

Nous avons développé une architecture qui combine la puissance de MobileNetV2 (un réseau léger et efficace) avec la structure en forme de U de l'architecture U-Net pour réaliser une segmentation d'images.

1.3.1 Structure Générale en forme de U

Notre modèle hybride combine la puissance de MobileNetV2 pour l'extraction de caractéristiques avec la capacité de U-Net à reconstruire des segmentations précises.

• Forme en U : L'architecture suit une forme en "U" avec une partie descendante (encodeur) et une partie ascendante (décodeur).
• Objectif : Attribuer une classe à chaque pixel de l'image (segmentation).

Partie Encodeur (Descendante)

• Backbone MobileNetV2 : Utilisation de MobileNetV2 comme encodeur léger et optimisé pour les appareils mobiles.
• Gel des poids : Avec base_model.trainable = False, les poids pré-entraînés sur ImageNet sont conservés, ce qui accélère l'entraînement et limite le surapprentissage.
• Extraction multi-échelle : Les caractéristiques sont extraites à différents niveaux de résolution pour les connexions de saut :
  • skip1 : 112×112
  • skip2 : 56×56
  • skip3 : 28×28
  • skip4 : 14×14
  • bottleneck : 7×7 (le niveau le plus profond du U-Net)

L'encodeur extrait des caractéristiques à cinq niveaux de résolution différents. Cette extraction multi-échelle est cruciale : les premières couches capturent des détails fins (textures, contours) tandis que les couches profondes encodent des informations sémantiques de haut niveau.

Stratégie de Transfer Learning : Nous avons opté pour une approche de "frozen encoder" dans notre configuration baseline.

Cette décision présente plusieurs avantages :

• Entraînement plus rapide (moins de paramètres à optimiser)
• Stabilité accrue (les caractéristiques ImageNet sont déjà robustes)
• Réduction du risque de sur-apprentissage
• Possibilité d'entraînement avec des ressources limitées

Partie Décodeur (Ascendante)

• Reconstruction progressive : À chaque étape, la résolution est doublée à l'aide de convolutions transposées :
  • 7×7 → 14×14
  • 14×14 → 28×28
  • 28×28 → 56×56
  • 56×56 → 112×112
  • 112×112 → 224×224
• Connexions de saut (Skip connections) : Chaque niveau du décodeur est enrichi par les caractéristiques du niveau correspondant de l’encodeur pour préserver les détails spatiaux.
• Traitement post-upsampling : Chaque étape comprend :
  • Convolution transposée
  • BatchNormalization
  • Activation ReLU
  • Concaténation avec les features de l’encodeur
  • Convolution 3×3 pour affiner

1.3.2 Construction et Entraînement du Modèle

• Modèle U-Net personnalisé basé sur MobileNetV2, avec :
  • Paramètres ajustables : nombre de classes, taille d'entrée, taux d'apprentissage, backbone gelé ou non.
  • Sortie : carte de segmentation pixel-par-pixel via une convolution 1×1 suivie d'une activation softmax.
  • Compilation : Optimiseur Adam, perte SparseCategoricalCrossentropy, et métrique SparseCategoricalAccuracy.

Le choix de SparseCategoricalCrossentropy est adapté car nos masques contiennent directement les indices des classes (format sparse) plutôt que des vecteurs one-hot.

def create_segmentation_model(num_classes=8, input_size=(224, 224, 3),
                            learning_rate=0.0001, base_trainable=False):
    """
    Create a segmentation model with configurable parameters
    """
    # Input tensor
    inputs = keras.layers.Input(shape=input_size)

    # Create MobileNetV2 base model
    base_model = keras.applications.MobileNetV2(
        input_shape=input_size,
        include_top=False,
        weights='imagenet'
    )

    # Configuration de l'entraînement du modèle de base
    base_model.trainable = base_trainable

    # Create encoder using MobileNetV2
    # Get outputs at different levels for skip connections
    skip1 = base_model.get_layer('block_1_expand_relu').output      # 112x112
    skip2 = base_model.get_layer('block_3_expand_relu').output      # 56x56
    skip3 = base_model.get_layer('block_6_expand_relu').output      # 28x28
    skip4 = base_model.get_layer('block_13_expand_relu').output     # 14x14

    # Get bottleneck
    bottleneck = base_model.get_layer('block_16_project').output    # 7x7

    # Use Model API to create encoder model
    encoder = keras.Model(inputs=base_model.input, outputs=[skip1, skip2, skip3, skip4, bottleneck])

    # Encoder part - use the encoder model
    x = inputs
    skips = encoder(x)

    # Bottleneck
    x = skips[4]  # Use the bottleneck from encoder

    # Decoder part - upsampling and skip connections
    # First upsampling: 7x7 -> 14x14
    x = keras.layers.Conv2DTranspose(256, 3, strides=2, padding='same')(x)
    x = keras.layers.BatchNormalization()(x)
    x = keras.layers.Activation('relu')(x)
    x = keras.layers.Concatenate()([x, skips[3]])
    x = keras.layers.Conv2D(256, 3, padding='same', activation='relu')(x)

    # Second upsampling: 14x14 -> 28x28
    x = keras.layers.Conv2DTranspose(128, 3, strides=2, padding='same')(x)
    x = keras.layers.BatchNormalization()(x)
    x = keras.layers.Activation('relu')(x)
    x = keras.layers.Concatenate()([x, skips[2]])
    x = keras.layers.Conv2D(128, 3, padding='same', activation='relu')(x)

    # Third upsampling: 28x28 -> 56x56
    x = keras.layers.Conv2DTranspose(64, 3, strides=2, padding='same')(x)
    x = keras.layers.BatchNormalization()(x)
    x = keras.layers.Activation('relu')(x)
    x = keras.layers.Concatenate()([x, skips[1]])
    x = keras.layers.Conv2D(64, 3, padding='same', activation='relu')(x)

    # Fourth upsampling: 56x56 -> 112x112
    x = keras.layers.Conv2DTranspose(32, 3, strides=2, padding='same')(x)
    x = keras.layers.BatchNormalization()(x)
    x = keras.layers.Activation('relu')(x)
    x = keras.layers.Concatenate()([x, skips[0]])
    x = keras.layers.Conv2D(32, 3, padding='same', activation='relu')(x)

    # Final upsampling: 112x112 -> 224x224
    x = keras.layers.Conv2DTranspose(16, 3, strides=2, padding='same')(x)
    x = keras.layers.BatchNormalization()(x)
    x = keras.layers.Activation('relu')(x)
    x = keras.layers.Conv2D(16, 3, padding='same', activation='relu')(x)

    # Output layer
    outputs = keras.layers.Conv2D(num_classes, 1, padding='same', activation='softmax')(x)

    # Create model
    model = keras.Model(inputs=inputs, outputs=outputs, name="MobileNetV2-UNet")

    # Compile model avec learning rate configurable
    model.compile(
        optimizer=keras.optimizers.Adam(learning_rate=learning_rate),
        loss=keras.losses.SparseCategoricalCrossentropy(),
        metrics=[
            keras.metrics.SparseCategoricalAccuracy(),
            # keras.metrics.MeanIoU(num_classes=num_classes)
        ]
    )

    return model

Détails des Paramètres

• Total des paramètres : 5,418,600
  • Entraînables : 3,575,624 (décodeur et tête de segmentation)
  • Non-entraînables : 1,842,976 (backbone gelé)
• Si base_trainable=True, tous les paramètres deviennent entraînables, offrant plus de flexibilité au prix d'un entraînement plus long.

1.3.3 Justification du choix architectural

Le choix de l'architecture MobileNetV2-UNet résulte d'une analyse approfondie des contraintes de notre projet embarqué, combinant les avantages complémentaires de deux architectures éprouvées :

Pourquoi U-Net ?

• Architecture de référence pour la segmentation sémantique avec structure encoder-decoder
• Connexions résiduelles (skip connections) préservant les détails spatiaux fins lors de la reconstruction
• Adaptée à la reconstruction de résolution complète depuis des caractéristiques compressées

Pourquoi MobileNetV2 ?

• Conception spécifique pour les applications mobiles et embarquées avec ressources limitées
• Optimisations avancées via les "depthwise separable convolutions" pour un rapport performance/efficacité optimal
• Transfer learning efficace grâce aux poids pré-entraînés sur ImageNet
• Vitesse d'exécution compatible avec les contraintes temps réel du véhicule autonome

Cette architecture hybride MobileNetV2-UNet présente des bénéfices uniques pour notre cas d'usage :

• Efficacité computationnelle : Optimisée pour les environnements à ressources contraintes
• Robustesse par transfer learning : Exploitation des représentations ImageNet pour une convergence rapide
• Adaptabilité multi-tâches : Architecture générique applicable à diverses tâches de segmentation urbaine
• Préservation de l'information : Maintien des détails spatiaux critiques pour la précision de segmentation

Cette combinaison offre le meilleur compromis entre précision de segmentation et efficacité embarquée, essentiel pour un système de vision automobile en temps réel.

1.4 Entraînement et Optimisation

1.4.1 Stratégie d'Entraînement

Notre approche d'entraînement intègre plusieurs techniques d'optimisation :

Callbacks Avancés

callbacks = [
    keras.callbacks.ReduceLROnPlateau(
        monitor='val_loss', factor=0.2, patience=2, min_lr=1e-6
    ),
    keras.callbacks.EarlyStopping(
        monitor='val_sparse_categorical_accuracy', 
        patience=5, restore_best_weights=True
    ),
    keras.callbacks.ModelCheckpoint(
        filepath='best_model.keras',
        save_best_only=True, mode='max'
    )
]

• ReduceLROnPlateau : Réduction adaptative du taux d'apprentissage
• EarlyStopping : Arrêt anticipé pour éviter le sur-apprentissage
• ModelCheckpoint : Sauvegarde du meilleur modèle

Gestion des expériences de Machine Learning avec MLflow

Nous avons intégré MLflow pour le suivi des expériences, permettant :

• Versioning des modèles et configurations
• Traçabilité complète des hyperparamètres
• Comparaison objective des performances
• Reproductibilité des résultats

1.4.2 Configuration Baseline

Notre configuration baseline établit un point de référence solide :

EXPERIMENT_CONFIG = {
    "exp_name": "exp_001_baseline",
    "description": "Baseline MobileNetV2-UNet avec frozen encoder",
    "params": {
        "learning_rate": 0.0001,
        "batch_size": 8, 
        "epochs": 20,
        "base_model_trainable": False,
        "validation_split": 0.2,
        "augmentation": True
    }
}

Cette configuration privilégie la stabilité et la reproductibilité, servant de fondation pour les expérimentations futures.

1.4.3 Analyse de l'Entraînement du Modèle

L'entraînement de notre modèle MobileNetV2-UNet s'est déroulé sur 18 époques avec une convergence satisfaisante. Les graphiques d'évolution révèlent un comportement d'apprentissage sain et typique d'un modèle bien configuré.

Évolution de la Perte : La courbe de loss montre une décroissance rapide et régulière depuis des valeurs initiales élevées (≈1.4) vers une stabilisation autour de 0.25 pour l'entraînement et 0.4 pour la validation. Cette convergence rapide durant les 5 premières époques témoigne de l'efficacité du transfer learning avec MobileNetV2 pré-entraîné sur ImageNet. L'écart modéré entre les courbes train et validation (≈0.15) indique un niveau de sur-apprentissage acceptable, sans divergence critique.

Progression de l'Accuracy : L'évolution de la précision confirme l'apprentissage efficace avec une montée rapide de 55% à plus de 85% en quelques époques, puis une stabilisation progressive vers 91% pour l'entraînement et 87% pour la validation. Cette convergence vers un plateau élevé démontre que le modèle a atteint sa capacité d'apprentissage optimale avec la configuration actuelle (encoder gelé). L'écart final de 4% entre train et validation reste dans une fourchette acceptable pour un modèle de production, suggérant une bonne généralisation sur des données non vues.

Cette dynamique d'entraînement valide notre approche conservative avec encoder gelé, offrant un modèle stable et performant en un temps d'entraînement réduit, parfaitement adapté aux contraintes de développement rapide d'un système embarqué.

1.5 Évaluation et Métriques

1.5.1 Métriques de Performance

L'évaluation de modèles de segmentation nécessite des métriques spécialisées. Nous utilisons principalement :

Intersection over Union (IoU)

Mesure le chevauchement entre la prédiction et la vérité terrain.

IoU = Intersection / Union

Cette métrique est particulièrement pertinente car elle pénalise à la fois les faux positifs et les faux négatifs.

Mean IoU (mIoU)

Moyenne des IoU de toutes les classes, offrant une vue d'ensemble des performances.

Précision Pixel-wise

Pourcentage de pixels correctement classifiés, métrique intuitive mais pouvant être biaisée par les classes majoritaires.

1.5.2 Résultats de la Configuration Baseline

Notre modèle baseline atteint des performances encourageantes :

• Précision globale : 87.95%
• Mean IoU : 63.25%
• Perte finale : 0.4123

Analyse par Classe :

Matrice de confusion

La matrice de confusion constitue un outil d'évaluation pour les modèles de classification, particulièrement crucial en segmentation sémantique où chaque pixel doit être correctement assigné à sa classe.

Dans le contexte de la classification et de la segmentation sémantique, chaque prédiction peut être catégorisée selon quatre types fondamentaux qui déterminent la qualité du modèle :

• Vrai positif (VP) : Le modèle détecte correctement la présence d'une classe là où elle existe réellement
• Vrai négatif (VN) : Le modèle rejette correctement une classe là où elle n'existe pas
• Faux positif (FP) : Le modèle génère une fausse alerte en détectant une classe absente (surestimation)
• Faux négatif (FN) : Le modèle manque une classe présente, échouant à la détecter (sous-estimation)

Pour un système de vision automobile, cette analyse est importante car elle révèle quelles confusions pourraient compromettre la sécurité (ex: confondre un piéton avec un objet statique).

Notre matrice révèle des performances globalement satisfaisantes avec des motifs d'erreur et des forces marquées :

Excellentes Performances sur les Classes Dominantes :

• Flat : 9,3M pixels correctement identifiés sur 9,5M (98% de précision)
• Construction : 4,7M pixels sur 5,1M bien classifiés (91% de précision)
• Nature : 3,6M pixels sur 4M correctement segmentés (90% de précision)

Confusions Logiques et Acceptables :

• Void dispersé : La classe "void" se confond naturellement avec toutes les autres (525K avec "flat", 317K avec "construction"), comportement attendu pour cette catégorie "fourre-tout"
• Human-Construction : 93K pixels humains confondus avec construction, reflétant la difficulté à distinguer personnes et bâtiments dans certains contextes urbains
• Vehicle-Flat : 61K pixels véhicules confondus avec surfaces planes, erreur compréhensible pour les véhicules partiellement occultés

Points d'Attention Identifiés :

• Object sous-performant : Seulement 35K pixels correctement identifiés sur 514K, confirmant la difficulté sur les objets fins (panneaux, poteaux)
• Sky bien isolé : 706K pixels sur 737K correctement classifiés (96%), excellente performance sur cette classe homogène

Cette matrice confirme que notre modèle excelle sur les éléments structurants essentiels à la navigation tout en révélant des axes d'amélioration précis pour les itérations futures.

1.5.3 Analyse des Performances

Points Forts :

• Excellente détection des surfaces planes (routes, ciel)
• Bonne segmentation des grandes structures (bâtiments, végétation)

Points d'Amélioration :

• Détection des objets fins (poteaux, panneaux) perfectible
• Segmentation des humains variable (due à leur taille et variabilité)
• Besoin d'optimisation pour les petits objets

1.6 Pipeline de Prédiction

Pour valider les performances de notre modèle en conditions réelles, nous avons développé un pipeline de prédiction complet permettant de traiter aussi bien des images du dataset de test que des images externes. Ce pipeline intègre toutes les étapes nécessaires depuis le chargement du modèle jusqu'à l'analyse statistique des résultats.

def predict_single_image(model, config, image_path=None, image_array=None, img_size=(224, 224)):
    """Réalise une prédiction complète avec préprocessing et post-analyse"""

    # Chargement et préprocessing adaptatif
    if image_path is not None:
        image_pil = Image.open(image_path).convert('RGB')
        image_array = np.array(image_pil)

    # Pipeline de normalisation identique à l'entraînement
    image_resized = tf.image.resize(image_array, img_size, method='bilinear')
    image_normalized = tf.cast(image_resized, tf.float32) / 255.0
    image_batch = tf.expand_dims(image_normalized, axis=0)

    # Prédiction et conversion en masque de classes
    predictions = model.predict(image_batch, verbose=0)
    pred_mask = tf.argmax(predictions, axis=-1)[0].numpy()

    # Analyse statistique automatique par classe
    unique_classes, counts = np.unique(pred_mask, return_counts=True)
    total_pixels = pred_mask.size

    class_stats = []
    for class_id, count in zip(unique_classes, counts):
        class_name = config['group_names'][class_id]
        percentage = (count / total_pixels) * 100
        class_stats.append({
            'class_id': int(class_id),
            'class_name': class_name,
            'pixel_count': int(count),
            'percentage': percentage
        })

    return {
        'prediction_mask': pred_mask,
        'class_statistics': class_stats,
        'predictions_raw': predictions[0]
    }

1.6.1. Résultats de prédiction

Les résultats de prédiction se présentent sous plusieurs formes complémentaires qui permettent une analyse multi-niveaux :

Masque de Segmentation (pixels) : Le résultat principal est un masque 224×224 où chaque pixel contient l'ID de la classe prédite (0-7). Cette représentation permet une analyse spatiale précise de la scène.

Distribution Statistique des Classes : Pour chaque prédiction, nous générons automatiquement un tableau statistique détaillant la répartition des classes :

📊 Classes détectées:
           flat:    19536 pixels ( 38.9%)  # Routes et surfaces de circulation
   construction:    14510 pixels ( 28.9%)  # Bâtiments et infrastructures  
         nature:     8285 pixels ( 16.5%)  # Végétation et terrain naturel
           void:     5459 pixels ( 10.9%)  # Zones non classifiées
        vehicle:     1630 pixels (  3.2%)  # Véhicules en circulation
          human:      594 pixels (  1.2%)  # Piétons et cyclistes
            sky:       98 pixels (  0.2%)  # Ciel visible
         object:       64 pixels (  0.1%)  # Signalisation et mobilier urbain

Visualisation Tripartite : Notre système génère systématiquement trois vues : l'image originale, la vérité terrain (quand disponible), et la prédiction colorisée selon notre palette de couleurs spécifique au domaine automobile.

4.3 Analyse Qualitative des Performances

L'évaluation sur des images réelles révèle des performances encourageantes avec des points forts et des axes d'amélioration clairement identifiés :

Excellente Détection des Structures Dominantes : Notre modèle démontre une capacité remarquable à identifier les éléments structurants de la scène urbaine. La segmentation des surfaces planes (routes, trottoirs) atteint 38.9% de couverture dans l'exemple analysé, avec des contours nets et une classification cohérente. Les bâtiments et constructions (28.9%) sont également très bien délimités, ce qui est crucial pour la navigation autonome.

Robustesse sur la végétation et l'environnement : La détection de la végétation (16.5%) montre une bonne capacité de généralisation du modèle. Les arbres, buissons et espaces verts sont correctement identifiés malgré leur variabilité de texture et de forme, témoignant de l'efficacité du transfer learning depuis ImageNet.

Défis sur les objets de petite taille : L'analyse révèle des difficultés attendues sur les éléments fins et de petite taille. Les objets de signalisation ne représentent que 0.1% des pixels détectés, ce qui correspond à la fois à leur faible représentation spatiale réelle et aux limitations du modèle sur ces éléments critiques. Cette faiblesse est compensée partiellement par d'autres systèmes du véhicule autonome (radar, lidar).

Gestion Intelligente des Zones Ambiguës : La catégorie "void" (10.9%) capture efficacement les zones d'incertitude et les éléments non classifiables, évitant les fausses classifications qui pourraient être dangereuses. Cette approche conservative est préférable dans un contexte automobile.

Performance Temporelle et Efficacité : Le modèle traite une image 224×224 en temps quasi-réel, compatible avec les exigences de fréquence d'un système embarqué. La réduction de résolution depuis les 2048×1024 originales vers 224×224 représente un compromis acceptable entre précision et performance computationnelle.

Cette analyse confirme que notre architecture MobileNetV2-UNet offre un équilibre optimal pour les contraintes d'un système de vision embarqué, avec des performances robustes sur les éléments critiques pour la prise de décision de navigation tout en maintenant une efficacité computationnelle compatible avec les ressources limitées d'un véhicule autonome.

1.7 Innovations et Optimisations Futures

1.7.1 Pistes d'Amélioration Identifiées

Entraînement Progressif
Stratégie en deux phases :

1. Phase 1 : Encoder gelé (configuration actuelle)
2. Phase 2 : Fine-tuning avec encoder dégelé et taux d'apprentissage réduit

Augmentation de données avancée

• Simulation de conditions météorologiques (pluie, brouillard)
• Variations d'éclairage plus poussées
• Transformations géométriques adaptées au contexte automobile

Architecture Hybride
Exploration de techniques comme :

• Attention mechanisms pour améliorer la détection des petits objets
• Multi-scale training pour robustesse aux variations d'échelle
• Ensembling de modèles pour améliorer la robustesse

1.8 Conclusion de la partie modélisation

Le développement de notre modèle de segmentation MobileNetV2-UNet représente un équilibre réussi entre performance et efficacité computationnelle. Avec un Mean IoU de 63.25 % et une précision globale de 87.95 %, notre modèle baseline fournit une base solide pour le système de vision du véhicule autonome.

L'architecture choisie démontre sa pertinence pour les contraintes embarquées, et les résultats détaillés par classe révèlent des performances cohérentes avec les attentes pour un modèle de première génération. Les pistes d'amélioration identifiées offrent un roadmap clair pour les développements futurs.

La mise en place d'un pipeline MLOps avec MLflow et notre organisation modulaire garantissent la reproductibilité et facilitent l'itération continue sur les performances du modèle.

2. Développement de l'API FastAPI

[Cette section sera développée dans la suite du document]

3. Développement de l'Interface Frontend Next.js

[Cette section sera développée dans la suite du document]

Note : Cette note technique sera complétée avec les sections API et Frontend lors de leur développement. La partie modélisation présentée ici constitue le cœur technique de notre système de segmentation sémantique.