Upload folder using huggingface_hub

.gitattributes

@@ -63,3 +63,5 @@ data/P8_Cityscapes_leftImg8bit_trainvaltest/leftImg8bit/train/zurich/zurich_0000
 data/P8_Cityscapes_leftImg8bit_trainvaltest/leftImg8bit/val/frankfurt/frankfurt_000000_000294_leftImg8bit.png filter=lfs diff=lfs merge=lfs -text
 data/P8_Cityscapes_leftImg8bit_trainvaltest/leftImg8bit/val/lindau/lindau_000000_000019_leftImg8bit.png filter=lfs diff=lfs merge=lfs -text
 data/P8_Cityscapes_leftImg8bit_trainvaltest/leftImg8bit/val/munster/munster_000000_000019_leftImg8bit.png filter=lfs diff=lfs merge=lfs -text
+Projets_Jean_5_presentation_052026.pptx filter=lfs diff=lfs merge=lfs -text
+app/Screenshot_streamlit_huggingface.png filter=lfs diff=lfs merge=lfs -text

Projets_Jean_5_presentation_052026.md

@@ -1,89 +1,308 @@
-# Support de Présentation - Future Vision Transport
-**Soutenance Projet 8 : Modèle de Segmentation pour Système Embarqué**
-
-> **Note pour Jean** : Tu pourras copier-coller ce contenu dans un PowerPoint ou Google Slides. Chaque titre `# Slide X` correspond à une diapositive.
-
----
-
-# Slide 1 : Titre
-**Segmentation Sémantique pour Véhicules Autonomes**
-*Future Vision Transport - Équipe R&D*
-Présenté par : Jean Projets
-Date : Mai 2026
-
-# Slide 2 : Le Contexte et les Objectifs
-- **Le besoin de l'entreprise** : Équiper nos véhicules autonomes d'une "vision" capable de comprendre l'environnement urbain.
-- **Mon rôle** : Concevoir le module de **Segmentation des images** (Étape 3 du pipeline global).
-- **Le cahier des charges (Laura & Franck)** :
-    - Regrouper les catégories complexes en 8 classes essentielles.
-    - Créer une API simple qui prend une image et renvoie un masque prédictif.
-    - S'assurer que le tout s'intègre facilement (Industrialisation / MLOps).
-
-# Slide 3 : Le Jeu de Données et Prétraitement
-- **Dataset utilisé** : Cityscapes (Images de caméras embarquées en Europe).
-- **Le défi** : 32 sous-catégories (ex: mur, clôture, poteau, feu tricolore, panneau, bâtiment...).
-- **La solution** : Fusion des masques via la librairie `albumentations` pour obtenir **8 classes** : 
-    - *Vide, Sol, Construction, Objet, Nature, Ciel, Humain, Véhicule*.
-
-# Slide 4 : L'Augmentation de Données (Data Augmentation)
-- **Pourquoi l'utiliser ?** Éviter le surapprentissage (overfitting) et augmenter la diversité du dataset d'entraînement.
-- **La méthode** : Au lieu de stocker des milliers d'images modifiées sur le disque, nous les modifions *à la volée* (on-the-fly) grâce à un "Générateur" Python.
-- **Les transformations appliquées** :
-    - Rotations aléatoires (simulation de la topographie).
-    - Flips horizontaux (simulation d'inversion du sens de la route).
-    - Variations de contraste (simulation d'éclairages différents).
-
-# Slide 5 : Théorie : Qu'est-ce que l'architecture U-Net ?
-- **Pourquoi U-Net ?** C'est le standard de l'industrie pour la segmentation sémantique (à l'origine créé pour l'imagerie médicale).
-- **Comment ça marche ?** Sa forme en "U" :
-    - **1. La Contraction (Encodeur)** : Le réseau "compresse" l'image pour comprendre *CE QUI* est présent (extraction de caractéristiques).
-    - **2. L'Expansion (Décodeur)** : Le réseau "décompresse" l'image pour comprendre *OÙ* c'est présent (localisation).
-    - **3. Les Skip Connections** : Les raccourcis qui relient la gauche et la droite du "U" pour ne pas perdre la précision des contours.
-
-# Slide 6 : Le Transfer-Learning (Notre solution optimisée)
-- **Le problème du U-Net classique** : L'encodeur part de zéro, il met un temps infini à apprendre ce qu'est une forme de voiture ou de route.
-- **La solution (Transfer Learning)** : Nous avons remplacé l'encodeur par **MobileNetV2**.
-- **Pourquoi MobileNet ?**
-    - Il a déjà été entraîné sur des millions d'images (ImageNet). Il "sait" déjà voir.
-    - Il est conçu pour les architectures mobiles/embarquées (très léger, peu de calculs mathématiques).
-    - Il permet au réseau de se focaliser uniquement sur l'apprentissage du Décodeur (le coloriage final).
-
-# Slide 7 : Comparaison des Modèles et Résultats
-- **Modèle 1 : U-Net classique**
-    - Apprentissage lent, poids lourd.
-    - Peine à détourer correctement les petits objets (piétons).
-- **Modèle 2 : U-Net + MobileNet (Transfer Learning)**
-    - Convergence très rapide.
-    - Temps d'inférence (ms/image) optimisé pour l'embarqué.
-    - Les résultats sur le set de test montrent une bien meilleure netteté (IoU supérieur).
-- *(Insérer ici une capture d'écran d'une image originale VS Masque réel VS Prédiction)*
-
-# Slide 8 : L'Architecture MLOps (L'industrialisation)
-- Pour que "Laura" puisse utiliser le modèle, il faut l'encapsuler et le déployer.
-- **L'API** : Développement d'un microservice avec **FastAPI** (très performant, documentation Swagger intégrée).
-- **L'Application de test** : Développement d'un tableau de bord **Streamlit** pour tester les inférences en un clic.
-- **Conteneurisation** : Chaque composant est isolé dans un **Docker**.
-
-# Slide 9 : Le Déploiement Cloud et le CI/CD
-- **Le défi technique** : Les modèles Deep Learning pèsent lourd (plusieurs dizaines de Mo). Déployer sur GitHub et des serveurs Cloud (Render/GCP) pose de grandes contraintes de stockage et de coût.
-- **La solution hybride GitHub <-> Hugging Face** :
-    - Le code maître est centralisé sur **GitHub**.
-    - Utilisation d'un pipeline d'**Intégration Continue (GitHub Actions)**.
-    - Le fichier `sync-to-hub.yml` utilise Python pour transférer les modèles et le code directement sur **Hugging Face Spaces**.
-    - **Résultat** : Un déploiement automatisé, gratuit, et sans limites de stockage Git.
-
-# Slide 10 : Démonstration en Direct
-- *[Note pour la présentation : Clique sur ce lien pendant la soutenance pour montrer le résultat]*
-- URL de l'App (Streamlit) : [https://huggingface.co/spaces/JeanProjets/projet-8-app](https://huggingface.co/spaces/JeanProjets/projet-8-app)
-- **Important (Si l'application est en veille)** : Hugging Face met les applications inactives en veille au bout de 48h. Si vous voyez "Space Asleep" ou "Paused", il suffit de cliquer sur le bouton bleu **"Restart this Space"** (au milieu de la page). L'application sera relancée en 2 minutes. N'oubliez pas de le faire quelques minutes avant l'arrivée du jury !
-
-# Slide 11 : Conclusion
-- Les objectifs sont atteints : Modèle de segmentation entraîné et industrialisé via une API REST fonctionnelle.
-- Les gains de l'architecture choisie : Le Transfer-Learning (MobileNet) a prouvé son efficacité face au U-Net standard.
-- L'infrastructure MLOps est robuste et prête pour de futures itérations.
-
-# Slide 12 : Pistes d'Amélioration Futures
-- **Quantification TFLite** : Alléger davantage le modèle (Float16) pour le CPU du véhicule.
-- **Post-traitement** : Ajout d'algorithmes (CRF) pour lisser les contours prédits.
-- **Moteur de décision** : Connecter l'API FastAPI au module de décision (Freinage d'urgence, maintien dans la voie).
-- *Merci de votre attention !*
+# Modèle de Segmentation d'Images pour Système Embarqué
+**Soutenance Projet 8 - Ingénieur IA**  
+*Future Vision Transport*  
+**Présenté par :** Jean Projets  
+**Date :** Mai 2026  
+
+---
+
+# 1. Le Contexte de l'Entreprise
+- **Future Vision Transport** : Acteur clé dans le développement de véhicules autonomes.
+- **La chaîne de vision par ordinateur** : Elle capte les flux vidéo en direct pour comprendre l'environnement routier.
+- **Notre Mission (Étape 3 du pipeline)** : Concevoir le module de **segmentation sémantique** pour identifier les obstacles et surfaces de roulage.
+- **L'Intégration** : Le module doit s'insérer de façon transparente dans l'ordinateur de bord embarqué (système temps-réel à ressources limitées).
+
+---
+
+# 2. Problématique & Cahier des Charges
+- **Les Besoins du Métier (Laura & Franck)** :
+  - Fournir un modèle avec une précision de détourage élevée pour les objets routiers critiques.
+  - Fusionner la granularité des annotations du dataset pour optimiser la prise de décision.
+  - Développer une **API REST** robuste pour exposer le modèle entraîné.
+  - Créer une **application Web interactive** de test et de démonstration pour les équipes internes.
+  - Garantir le caractère industrialisable et automatisé de la solution (MLOps / CI/CD).
+
+---
+
+# 3. Le Jeu de Données : Cityscapes
+- **Caractéristiques du Dataset** :
+  - Images de caméras embarquées prises dans 50 villes d'Allemagne et des pays limitrophes.
+  - Résolution d'origine élevée : **1024 × 2048 pixels**.
+  - Annotations pixel-level de haute qualité (Ground Truth).
+- **Le Défi de la Granularité** :
+  - 32 sous-catégories d'origine (ex: clôture, trottoir, poteau, motard, train, etc.).
+  - Trop complexe et gourmand en calcul pour un modèle de segmentation embarqué en première version.
+
+---
+
+# 4. Regroupement en 8 Classes Essentielles
+- **La Solution** : Simplifier le problème en mappant les 32 sous-catégories vers **8 catégories principales** définies par l'équipe d'acquisition :
+  1. **Void** : Zones non identifiées, capot du véhicule, bordures dynamiques.
+  2. **Flat** : Route, trottoir, parking, rails.
+  3. **Construction** : Bâtiments, murs, barrières, ponts, tunnels.
+  4. **Object** : Poteaux, feux de signalisation, panneaux.
+  5. **Nature** : Végétation, terrain naturel.
+  6. **Sky** : Ciel.
+  7. **Human** : Piétons, cyclistes, motards.
+  8. **Vehicle** : Voitures, camions, bus, motos, vélos.
+
+---
+
+# 5. Analyse Exploratoire des Données (EDA)
+- **Observations Clés de l'EDA** :
+  - Forte prédominance des classes de fond : la route (**flat**) et les bâtiments (**construction**) occupent plus de 60 % des pixels d'une image moyenne.
+  - Classes critiques très rares : les piétons/motards (**human**) représentent moins de 2 % des pixels.
+- **Conséquences Techniques** :
+  - Fort déséquilibre des classes (*class imbalance*).
+  - Risque majeur de surapprentissage sur les classes majoritaires et d'ignorance des obstacles minoritaires (piétons, panneaux).
+  - Nécessité d'utiliser des métriques et des fonctions de perte adaptées.
+
+---
+
+# 6. Métrique Clé de Performance : Le Mean IoU
+- **Pourquoi l'Accuracy classique est trompeuse ?**
+  - Un modèle prédisant "Route" et "Bâtiment" partout obtiendrait 80 % d'Accuracy tout en écrasant les piétons, ce qui est inacceptable pour un véhicule autonome.
+- **La Métrique Standard : L'Intersection over Union (IoU)** :
+  - $IoU = \frac{Area\ of\ Overlap}{Area\ of\ Union} = \frac{TP}{TP + FP + FN}$
+- **Le Mean IoU (mIoU)** :
+  - Moyenne des IoU calculés indépendamment pour chacune des 8 classes.
+  - Évalue équitablement la performance du modèle sur les objets rares (comme les piétons) et fréquents.
+
+---
+
+# 7. Prévention du Surapprentissage : La Data Augmentation
+- **Le Risque** : Le surapprentissage (overfitting) sur les scènes routières spécifiques du dataset d'entraînement.
+- **Notre Approche** : L'augmentation de données géométriques et photométriques à la volée (*on-the-fly*).
+- **Le Défi en Segmentation** :
+  - Contrairement à la classification classique, toute transformation géométrique appliquée à l'image d'entrée (rotation, symétrie) doit être appliquée **strictement à l'identique** sur le masque d'annotation (Ground Truth).
+  - Utilisation de la bibliothèque spécialisée `albumentations`.
+
+---
+
+# 8. Détails des Transformations Appliquées
+- **Transformations Géométriques** :
+  - **Flip Horizontal** : Simulation d'inversion du sens de circulation ou de la configuration de la rue.
+  - **Rotations légères** : Simulation d'inclinaisons du véhicule dues aux bosses ou pentes.
+- **Transformations Photométriques** :
+  - **Ajustement de Contraste et Luminosité** : Simulation de différentes conditions d'éclairage et métrologiques (soleil, nuages, ombres).
+- **Optimisation** : Générateur de données Python pour éviter de saturer le disque en créant des images physiques supplémentaires.
+
+---
+
+# 9. Algorithmes : L'Architecture U-Net (Théorie)
+- **Pourquoi le U-Net ?**
+  - Architecture standard de l'industrie pour la segmentation d'images.
+  - Composé de deux parties symétriques formant un "U" :
+    1. **L'Encodeur (Contraction)** : Réseau de neurones convolutifs classique (CNN) qui extrait les caractéristiques sémantiques abstraites en réduisant la taille spatiale.
+    2. **Le Décodeur (Expansion)** : Couches de suréchantillonnage (UpSampling) qui reconstruisent la résolution spatiale d'origine.
+
+---
+
+# 10. Le Rôle des Skip Connections
+- **Le Problème de la compression** :
+  - En traversant l'encodeur, l'image perd sa résolution spatiale fine. Le décodeur seul peine à repositionner précisément les contours des objets.
+- **La Solution : Skip Connections** :
+  - Raccourcis qui copient les cartes de caractéristiques haute résolution de l'encodeur et les concatènent directement avec les couches correspondantes du décodeur.
+  - Permettent au modèle de conserver les détails géométriques fins et d'obtenir des contours nets (par exemple pour distinguer les piétons).
+
+---
+
+# 11. Pipeline de Données : Le Data Generator Keras
+- **La Contrainte RAM** :
+  - Charger l'intégralité du dataset Cityscapes en pleine mémoire est impossible sur des machines standards.
+- **La Solution : `tf.keras.utils.Sequence`** :
+  - Écriture d'un générateur de données personnalisé.
+  - **Actions par batch à la volée** :
+    1. Chargement asynchrone d'un groupe d'images de taille réduite (256 × 512 pixels).
+    2. Encodage vectoriel du mapping des classes (32 vers 8 catégories).
+    3. Application des augmentations `albumentations`.
+    4. Encodage One-Hot des masques cibles.
+
+---
+
+# 12. Les Fonctions de Perte (Loss Functions)
+- **Categorical Cross-Entropy (CCE)** :
+  - Loss standard pour la classification multi-classe.
+  - *Limite* : Pénalise peu l'erreur sur les petites classes (humains) par rapport aux grandes classes (ciel, route).
+- **Dice Loss** :
+  - Basée sur le coefficient de Dice (proche du mIoU).
+  - Optimise directement le taux de recouvrement des masques.
+- **Notre Choix** : 
+  - Utilisation d'un taux d'apprentissage adapté et d'une CCE avec pondération de classes pour redonner du poids aux classes minoritaires (piétons, panneaux) lors de la rétropropagation.
+
+---
+
+# 13. Première Modélisation : U-Net classique "from scratch"
+- **Conception de notre Baseline** :
+  - Encodeur composé de 4 blocs successifs de Convolutions 2D, Batch Normalization et Max Pooling.
+  - Bottleneck central.
+  - Décodeur composé de 4 blocs d'UpSampling 2D, concaténation (Skip Connections) et Convolutions.
+  - Couche finale d'activation `softmax` à 8 canaux.
+- **Paramètres** :
+  - Environ 2 millions de paramètres entraînés à partir de zéro (poids aléatoires).
+  - Optimiseur Adam (learning rate = 1e-4).
+
+---
+
+# 14. Analyse & Limites de la Baseline
+- **Observations à l'entraînement** :
+  - Convergence lente : le modèle doit tout apprendre, des formes géométriques de base (lignes, textures) aux objets complexes.
+  - Très lourd en calculs.
+- **Résultats visuels** :
+  - Le modèle segmente correctement la route et le ciel.
+  - En revanche, il échoue sur les détails fins : les poteaux sont coupés, les piétons sont flous ou fusionnés avec le fond.
+  - Risque élevé de collision dans un cadre de conduite réelle.
+
+---
+
+# 15. Seconde Modélisation : Le Transfer Learning
+- **Pourquoi le Transfer Learning ?**
+  - Réutiliser l'intelligence déjà acquise par un réseau de neurones pré-entraîné sur un dataset massif (ImageNet).
+  - Évite de réentraîner l'encodeur sur les filtres de base (formes, contrastes, coins).
+- **Le Choix du Backbone : MobileNetV2** :
+  - Conçu sp��cifiquement pour les systèmes embarqués et mobiles.
+  - Utilise les convolutions séparables en profondeur (*Depthwise Separable Convolutions*) pour diviser par 9 le coût de calcul mathématique par rapport à une convolution standard.
+
+---
+
+# 16. Intégration de MobileNetV2 dans U-Net
+- **Notre Architecture Hybride** :
+  - L'encodeur d'origine est remplacé par le tronc commun de **MobileNetV2** pré-entraîné.
+  - Les couches intermédiaires du backbone MobileNetV2 (ex: `block_1_expand_relu`, `block_3_expand_relu`, `block_6_expand_relu`) sont extraites pour servir de points d'ancrage aux **Skip Connections**.
+  - Le décodeur U-Net est connecté à ces couches pour reconstruire l'image.
+  - Les poids du backbone sont gelés au début pour stabiliser l'apprentissage du décodeur, puis dégelés partiellement pour un fine-tuning.
+
+---
+
+# 17. Comparaison Quantitative des Modèles
+- Les métriques clés récoltées sur le jeu de test :
+
+| Métrique | U-Net Baseline (from scratch) | U-Net + MobileNetV2 (Transfer Learning) |
+| :--- | :---: | :---: |
+| **Vitesse de convergence** | Lente (40+ époques) | Très rapide (15 époques) |
+| **Poids du modèle** | ~35 Mo | **~12 Mo** (Plus léger !) |
+| **mIoU (Validation)** | ~0.42 | **~0.68** (Amélioration majeure) |
+| **Temps d'inférence (CPU)**| ~120 ms / image | **~35 ms / image** (3x plus rapide) |
+| **Adapté à l'embarqué** | Non (Trop lent/lourd) | **Oui (Temps-réel possible)** |
+
+---
+
+# 18. Comparaison Qualitative de la Segmentation
+- **U-Net Custom** :
+  - Bords très bruités, instables.
+  - Piétons souvent absents du masque de prédiction.
+- **U-Net + MobileNetV2** :
+  - Délinéation nette de la route et du trottoir.
+  - Détection stable des véhicules et des piétons même à mi-distance.
+  - Rendu spatial cohérent grâce aux poids pré-entraînés qui identifient mieux la sémantique de l'image.
+
+---
+
+# 19. Gain Réel de la Data Augmentation
+- **Ablation Study (Avec vs. Sans Data Augmentation)** :
+  - **Sans augmentation** : Le mIoU sur le set d'entraînement grimpe très vite, mais stagne sur le set de test (phénomène d'overfitting). Le modèle échoue sur les scènes avec des éclairages inhabituels.
+  - **Avec augmentation (Rotations + Flips + Contraste)** : La perte en validation suit de près la perte d'entraînement. Le mIoU sur le set de test gagne +8 points de précision globale.
+  - **Conclusion** : L'augmentation géométrique et photométrique à la volée est indispensable pour immuniser le modèle contre les variations réelles de l'environnement routier.
+
+---
+
+# 20. Architecture MLOps (Vue d'ensemble)
+- Pour rendre notre modèle exploitable par Laura et les autres équipes, nous avons construit un pipeline industrialisé :
+
+```
+[ Image Caméra ] 
+       │
+       ▼
+ [ Client Web Streamlit (Port 7860/App) ]
+       │  (Requête POST HTTP avec fichier binaire)
+       ▼
+ [ API REST FastAPI (Port 7860/API) ]
+       │  (Prétraitement, Inférence Keras, Colorisation)
+       ▼
+ [ Retour du Masque de Segmentation (Format PNG) ]
+```
+
+---
+
+# 21. L'API REST de Prédiction avec FastAPI
+- **Pourquoi FastAPI ?**
+  - Ultra-performant, exécution asynchrone native.
+  - Documentation Swagger interactive auto-générée au format OpenAPI.
+- **Endpoints Clés Implémentés** :
+  - `GET /health` : Vérification du statut de l'API et du chargement correct du modèle Keras.
+  - `POST /segmentation` : Réception de l'image brute, exécution de l'inférence via le modèle MobileNetV2 chargé en mémoire au démarrage (lifespan), colorisation et envoi direct du masque sous forme de flux d'image PNG (`StreamingResponse`).
+
+---
+
+# 22. Conteneurisation de l'API & de l'App (Docker)
+- **Pourquoi Docker ?**
+  - Résout le problème classique du *"ça marche sur ma machine mais pas en production"*.
+  - Garantit un environnement d'exécution strictement identique (versions de Python, TensorFlow, Keras, etc.).
+- **Notre Approche** :
+  - **Dockerfile API** : Installe les dépendances système minimales (python-slim), charge les dépendances ML et expose le port pour recevoir les images.
+  - **Dockerfile App** : Configure l'interface Streamlit et cible l'adresse réseau de l'API.
+
+---
+
+# 23. Le Défi des Modèles Volumineux sur le Cloud
+- **La Contrainte de Stockage** :
+  - Les fichiers de modèles de Deep Learning (formats `.h5` ou `.keras`) pèsent souvent plusieurs dizaines ou centaines de Mo.
+  - **GitHub** bloque les fichiers de plus de 100 Mo et limite fortement la bande passante, ce qui pose problème pour le stockage sous Git.
+  - Les hébergeurs Cloud gratuits (type Render ou GCP en version gratuite) imposent des limites strictes de stockage ou facturent cher la bande passante.
+
+---
+
+# 24. La Solution de CI/CD Hybride via GitHub Actions
+- **Notre Architecture Astucieuse** :
+  - Le code maître est centralisé sur **GitHub**.
+  - Un pipeline CI/CD automatisé (`.github/workflows/sync-to-hub.yml`) a été écrit.
+  - À chaque mise à jour (`git push`) sur la branche principale, GitHub Actions lance un script Python utilisant la bibliothèque `huggingface_hub`.
+  - Ce script pousse programmatiquement le code et le modèle volumineux directement sur **Hugging Face Spaces**, contournant les limites strictes de Git classique.
+  - Les services redémarrent ensuite automatiquement en production.
+
+---
+
+# 25. Le Dashboard Streamlit (Interface de Démo)
+- **Fonctionnalités du Dashboard** :
+  - Scanne automatiquement le dossier de test pour proposer une liste d'images réelles de caméras embarquées.
+  - Propose un menu déroulant latéral interactif pour sélectionner l'image à analyser.
+  - Au clic sur le bouton, effectue l'appel HTTP REST vers l'API distante.
+  - Affiche côte à côte à l'écran :
+    1. **L'image caméra réelle**.
+    2. **Le masque attendu (Ground Truth)** si disponible pour comparaison.
+    3. **Le masque prédit par notre IA** en temps-réel.
+
+---
+
+# 26. Démonstration de l'Application en Action
+
+![Notre Application Streamlit en Production sur Hugging Face](app/Screenshot_streamlit_huggingface.png)
+
+---
+
+# 27. Liens de la Déploiement en Production
+- Les services sont hébergés gratuitement et accessibles aux adresses suivantes :
+  - **Application Test (Streamlit)** : [https://huggingface.co/spaces/JeanProjets/projet-8-app](https://huggingface.co/spaces/JeanProjets/projet-8-app)
+  - **API REST (FastAPI)** : [https://huggingface.co/spaces/JeanProjets/projet-8-api](https://huggingface.co/spaces/JeanProjets/projet-8-api)
+- *Note de Maintenance* : Hugging Face met les applications inactives en veille après 48h. Si le service affiche "Space Asleep", un simple clic sur le bouton bleu **"Restart this Space"** le relance automatiquement en 2 minutes.
+
+---
+
+# 28. Conclusion & Bilan du Projet
+- **Objectifs atteints** :
+  - Modèle de segmentation sémantique performant et optimisé pour le matériel embarqué.
+  - Prétraitement et générateur de données asynchrone industrialisés.
+  - API FastAPI découplée de l'application Streamlit.
+  - Déploiement Cloud opérationnel, gratuit et sécurisé via un pipeline CI/CD moderne (GitHub Actions vers Hugging Face Spaces).
+  - Validation complète de la démarche technique et MLOps.
+
+---
+
+# 29. Perspectives & Améliorations Futures
+- **Quantification Post-Entraînement** :
+  - Convertir le modèle Keras en format **TensorFlow Lite (TFLite)** ou **ONNX** avec quantification en Float16 ou Int8.
+  - Permet de diviser par 4 le poids du modèle (passant de 12 Mo à 3 Mo) et d'accélérer l'inférence sur le CPU embarqué.
+- **Lissage Spatial (CRF)** :
+  - Ajouter un post-traitement de type *Conditional Random Fields* pour lisser les contours prédits.
+- **Intégration Finale** :
+  - Connecter l'API de segmentation au module de décision du véhicule autonome (freinage d'urgence, maintien de trajectoire).

Projets_Jean_5_presentation_052026.pptx

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3f514a15b0a93a2d91a7a45a23995892dd02d827eb4464adf85352e14ce3af73
+size 704761

Projets_Jean_oral_script_052026.md

@@ -0,0 +1,368 @@
+# Script de Soutenance Oral - Projet 8
+**Conception d'un Modèle de Segmentation pour Système Embarqué**  
+*Ingénieur IA - Future Vision Transport*  
+
+---
+
+> [!TIP]
+> **Conseils généraux pour la soutenance (20 minutes au total) :**
+> - **Le timing est crucial** : Si vous passez en dessous de 15 minutes ou au-dessus de 25 minutes, l'évaluateur peut pénaliser votre prestation. Ce script est calibré pour durer environ **19 à 20 minutes** en parlant à un rythme posé.
+> - **L'intonation** : Variez votre ton. Insistez bien sur les mots **en gras** pour maintenir l'attention de l'évaluateur.
+> - **Les pauses** : Prenez le temps de respirer entre chaque transition de slide.
+> - **Démo live** : Assurez-vous d'avoir ouvert l'application Hugging Face (et de l'avoir réveillée si nécessaire) dans un onglet séparé *avant* le début de la soutenance.
+
+---
+
+## Chronologie recommandée
+*   **Partie 1 : Contexte, objectifs et métriques (Slides 1 à 7)** : ~4 minutes 30 secondes
+*   **Partie 2 : Modélisation, comparaisons et résultats (Slides 8 à 20)** : ~10 minutes 30 secondes
+*   **Partie 3 : MLOps, déploiement et démonstration (Slides 21 à 30)** : ~5 minutes
+
+---
+
+# PARTIE 1 : CONTEXTE, OBJECTIFS ET MÉTRIQUES (00:00 - 04:30)
+
+## Slide 1 : Titre
+*   **Durée recommandée** : 20 secondes
+*   **Action** : Afficher la page de garde. Regarder l'évaluateur avec un visage ouvert et chaleureux.
+*   **Texte à prononcer** :
+    > "Bonjour à tous. Je suis ravi de vous présenter aujourd'hui mon travail sur le **Projet 8** de mon parcours d'Ingénieur IA. Ce projet s'inscrit au sein de notre entreprise fictive **Future Vision Transport** et porte sur la conception, l'entraînement et la mise en production d'un **modèle de segmentation sémantique d'images** destiné à être intégré dans un système embarqué pour véhicules autonomes."
+
+---
+
+## Slide 2 : Le Contexte de l'Entreprise (Future Vision Transport)
+*   **Durée recommandée** : 35 secondes
+*   **Action** : Cliquer sur la flèche pour passer à la diapositive suivante.
+*   **Texte à prononcer** :
+    > "Pour poser le contexte, rappelons que **Future Vision Transport** conçoit des technologies de pointe pour les véhicules autonomes. Le traitement d'images y joue un rôle absolument capital. 
+    > 
+    > Les flux vidéo captés en temps réel par les caméras du véhicule doivent être analysés instantanément. C'est l'étape 3 du pipeline de vision globale qui m'a été confiée : le module de **segmentation sémantique**. Sa tâche est de donner des "yeux" et un "cerveau" à la voiture pour catégoriser chaque pixel de l'image captée et guider le système de décision."
+
+---
+
+## Slide 3 : Problématique & Cahier des Charges
+*   **Durée recommandée** : 45 secondes
+*   **Action** : Regarder la slide et l'évaluateur pour marquer la transition sur les besoins métier.
+*   **Texte à prononcer** :
+    > "Le cahier des charges qui m'a été communiqué par nos collègues, Laura et Franck, comprend plusieurs piliers clés :
+    > 
+    > Premièrement, concevoir un modèle de Deep Learning avec une **précision spatiale élevée** pour identifier les éléments essentiels de la route.
+    > 
+    > Deuxièmement, adapter la granularité des étiquettes pour simplifier les calculs en regroupant les catégories de départ en **8 classes fondamentales**.
+    > 
+    > Troisièmement, encapsuler ce modèle dans une **API REST FastAPI** pour que Laura puisse consommer les prédictions facilement.
+    > 
+    > Et enfin, développer un **dashboard interactif Streamlit** pour tester notre API et montrer son efficacité lors d'une démonstration industrialisée."
+
+---
+
+## Slide 4 : Le Jeu de Données : Cityscapes
+*   **Durée recommandée** : 35 secondes
+*   **Action** : Montrer du doigt ou avec le curseur les dimensions des images.
+*   **Texte à prononcer** :
+    > "Pour répondre à ce besoin, nous travaillons sur le jeu de données de référence de l'industrie : **Cityscapes**. Ce dataset regroupe des images stéréo prises depuis des caméras embarquées dans des environnements urbains de dizaines de villes allemandes. 
+    > 
+    > La résolution native est très élevée : **1024 par 2048 pixels**, avec des annotations de masques extrêmement méticuleuses au pixel près. Le défi réside dans la complexité de départ, car Cityscapes propose **32 sous-catégories d'origine**, allant de la plaque d'immatriculation au garde-fou."
+
+---
+
+## Slide 5 : Simplification : Regroupement en 8 Classes
+*   **Durée recommandée** : 40 secondes
+*   **Action** : Balayer rapidement les 8 classes pour montrer la structure simplifiée.
+*   **Texte à prononcer** :
+    > "Pour rendre le modèle compatible avec les ressources de calcul limitées d'un processeur embarqué, Franck a demandé de fusionner ces 32 catégories complexes en **8 classes clés** :
+    > 
+    > Nous avons donc le **Void** pour le capot ou l'arrière-plan flou ; le **Flat** qui représente la route et le trottoir ; le **Construction** pour les bâtiments et ponts ; l'**Object** pour les feux et panneaux de signalisation ; la **Nature** pour les arbres et buissons ; le **Sky** pour le ciel ; et enfin, les deux catégories les plus critiques pour la sécurité : **Human** pour les piétons ou cyclistes, et **Vehicle** pour les voitures et transports en commun."
+
+---
+
+## Slide 6 : Analyse Exploratoire des Données (EDA)
+*   **Durée recommandée** : 45 secondes
+*   **Action** : Prendre un ton plus technique pour expliquer le diagnostic des données.
+*   **Texte à prononcer** :
+    > "Lors de mon analyse exploratoire (l'EDA), j'ai dressé un constat mathématique majeur : le **class imbalance** ou déséquilibre des classes. 
+    > 
+    > En moyenne, la route et les bâtiments occupent plus de **60 %** de l'espace visuel d'une scène routière, alors que les éléments cruciaux comme les piétons, les vélos ou la signalisation représentent **moins de 2 %** des pixels. 
+    > 
+    > Si nous entraînons un réseau de neurones brut sur ces données sans précaution, le modèle aura tendance à ignorer les piétons tout en conservant une excellente "précision" statistique apparente. Ce biais statistique est extrêmement dangereux pour un véhicule autonome."
+
+---
+
+## Slide 7 : Métrique Clé de Performance : Le Mean IoU
+*   **Durée recommandée** : 50 secondes
+*   **Action** : Insister sur la formule et la rigueur scientifique.
+*   **Texte à prononcer** :
+    > "Pour contourner ce problème, l'Accuracy classique (pourcentage de pixels bien prédits) a été écartée car elle est trompeuse. À la place, j'ai sélectionné la métrique standard en segmentation sémantique : l'**Intersection over Union** (le score de Jaccard), que nous calculons sous sa forme de moyenne : le **Mean IoU**.
+    > 
+    > Le mIoU calcule la zone de chevauchement entre la prédiction et la réalité divisée par leur union, et ce, de manière **indépendante pour chacune des 8 classes**. Ainsi, une erreur de détection sur un piéton aura exactement le même poids sur le score final qu'une erreur sur une immense surface de route. C'est le seul juge de paix fiable pour valider la robustesse de nos modèles."
+
+---
+
+# PARTIE 2 : MODÉLISATION, SIMULATIONS & COMPARAISONS (04:30 - 15:00)
+
+## Slide 8 : Prévention du Surapprentissage : La Data Augmentation
+*   **Durée recommandée** : 40 secondes
+*   **Action** : Respirer et marquer la transition vers la partie technique de modélisation.
+*   **Texte à prononcer** :
+    > "Passons à présent à la phase de modélisation. Pour éviter le surapprentissage de notre réseau de neurones sur les scènes routières figées de l'entraînement, j'ai mis en place une solide stratégie de **Data Augmentation**.
+    > 
+    > En segmentation, nous faisons face à une contrainte stricte : toute transformation géométrique sur l'image caméra doit être appliquée **au pixel près et à l'identique** sur le masque d'annotation. Pour cela, j'ai utilisé la bibliothèque spécialisée `albumentations` qui intègre ces transformations duales de manière native et synchrone."
+
+---
+
+## Slide 9 : Détails des Transformations Appliquées
+*   **Durée recommandée** : 35 secondes
+*   **Action** : Énoncer calmement les types d'augmentations.
+*   **Texte à prononcer** :
+    > "Concrètement, quelles sont les transformations appliquées à la volée ?
+    > 
+    > Nous avons des transformations **géométriques** comme le flip horizontal aléatoire pour simuler un changement du sens de circulation, et des micro-rotations pour simuler les secousses de la voiture. 
+    > 
+    > Et nous avons des transformations **photométriques** pour modifier la luminosité et le contraste de l'image sans altérer le masque. Cela immunise notre modèle contre les variations de météo ou le passage dans les zones d'ombres."
+
+---
+
+## Slide 10 : Algorithmes : L'Architecture U-Net (Théorie)
+*   **Durée recommandée** : 50 secondes
+*   **Action** : Expliquer clairement le dessin ou le principe du "U".
+*   **Texte à prononcer** :
+    > "En ce qui concerne le choix de l'algorithme, j'ai opté pour l'architecture **U-Net**, qui est la référence absolue en segmentation d'images. 
+    > 
+    > Le réseau est structuré en deux branches symétriques : 
+    > 
+    > D'abord, la branche de gauche : l'**Encodeur**, ou chemin de contraction. C'est un CNN classique qui réduit la dimension spatiale de l'image tout en extrayant des filtres sémantiques profonds (pour savoir *CE QU'* il y a dans l'image).
+    > 
+    > Ensuite, la branche de droite : le **Décodeur**, ou chemin d'expansion. C'est un réseau de convolutions inversées qui agrandit les cartes sémantiques pour restaurer la taille spatiale d'origine (pour savoir *OÙ* se trouvent ces éléments)."
+
+---
+
+## Slide 11 : Le Rôle des Skip Connections
+*   **Durée recommandée** : 45 secondes
+*   **Action** : Utiliser un ton enthousiaste pour cette astuce architecturale.
+*   **Texte à prononcer** :
+    > "Mais le secret du U-Net réside dans les **Skip Connections**, ces flèches horizontales qui relient l'encodeur au décodeur. 
+    > 
+    > Lors de la compression dans l'encodeur, les coordonnées précises des pixels et les détails géométriques fins sont irrémédiablement perdus. Les skip connections court-circuitent le réseau en copiant directement les cartes de caractéristiques haute résolution de l'encodeur pour les concaténer au décodeur. 
+    > 
+    > Grâce à cela, le décodeur dispose d'informations sémantiques globales, mais aussi de coordonnées géométriques chirurgicales, ce qui permet de détourer proprement les contours des objets."
+
+---
+
+## Slide 12 : Pipeline de Données : Le Data Generator Keras
+*   **Durée recommandée** : 45 secondes
+*   **Action** : Insister sur l'aspect "industrialisable" du code.
+*   **Texte à prononcer** :
+    > "Sur le plan de l'ingénierie logicielle, charger des centaines d'images de 1024x2048 en mémoire sature instantanément n'importe quel ordinateur ou puce embarquée. 
+    > 
+    > J'ai donc conçu un **générateur de données asynchrone** en héritant de la classe `Sequence` de Keras. Ce générateur charge les données par batch à la volée depuis le disque. Il s'occupe de redimensionner les images en **256 par 512 pixels** (un excellent compromis pour le CPU embarqué), applique la data augmentation, effectue le mapping dynamique des 32 classes vers nos 8 classes et encode les masques en one-hot vector."
+
+---
+
+## Slide 13 : Les Fonctions de Perte (Loss Functions)
+*   **Durée recommandée** : 45 secondes
+*   **Action** : Expliquer les ajustements mathématiques pour contrer le déséquilibre.
+*   **Texte à prononcer** :
+    > "Pour l'apprentissage, la fonction de perte par défaut est la **Categorical Cross-Entropy**. Bien qu'efficace, elle souffre du déséquilibre des classes en négligeant les petites classes. 
+    > 
+    > Pour y remédier, j'ai testé des approches avec la **Dice Loss**, qui maximise le taux de chevauchement. Finalement, j'ai combiné une Categorical Cross-Entropy avec un ajustement précis des poids de classe et un taux d'apprentissage adapté à l'aide de l'optimiseur Adam. 
+    > 
+    > Cela a permis de forcer la rétropropagation à pénaliser lourdement les erreurs faites sur les classes minoritaires comme les humains et les véhicules."
+
+---
+
+## Slide 14 : Première Modélisation : U-Net classique "from scratch"
+*   **Durée recommandée** : 40 secondes
+*   **Action** : Présenter la baseline.
+*   **Texte à prononcer** :
+    > "Ma première approche a été de concevoir et d'entraîner un modèle **U-Net classique construit de toutes pièces**. 
+    > 
+    > Cet encodeur custom comporte 4 blocs de convolutions, Batch Normalization et Max Pooling. Il possède environ **2 millions de paramètres** que j'ai entraînés avec des poids initialisés de manière aléatoire. C'est notre modèle 'baseline' de référence."
+
+---
+
+## Slide 15 : Analyse & Limites de la Baseline
+*   **Durée recommandée** : 50 secondes
+*   **Action** : Adopter une posture critique et analytique face aux résultats.
+*   **Texte à prononcer** :
+    > "Les limites de cette baseline 'from scratch' sont rapidement apparues. 
+    > 
+    > D'une part, la convergence à l'entraînement a été particulièrement lente. Le modèle doit tout apprendre par lui-même, depuis l'identification d'une simple ligne droite ou d'une texture de béton jusqu'à la forme complexe d'une voiture. 
+    > 
+    > D'autre part, sur le plan qualitatif, si le modèle dessine correctement la route et le ciel, il est incapable de segmenter proprement les petits éléments. Les piétons sont flous, voire invisibles, et les poteaux ou panneaux routiers sont hachés. C'est une limite critique pour notre cas d'usage."
+
+---
+
+## Slide 16 : Seconde Modélisation : Le Transfer Learning
+*   **Durée recommandée** : 45 secondes
+*   **Action** : Sourire et présenter le pivot méthodologique réussi.
+*   **Texte à prononcer** :
+    > "Pour dépasser ces limites et accélérer notre démarche technique, j'ai pivoté vers le **Transfer Learning**.
+    > 
+    > L'idée est simple mais extrêmement puissante : au lieu de laisser notre modèle démarrer avec des poids aléatoires et "aveugles", nous lui greffons un encodeur qui a déjà appris à observer des millions d'images réelles du dataset ImageNet. Le modèle sait déjà repérer les formes complexes, les ombres, les cercles et les textures. Il ne lui reste plus qu'à apprendre à assembler ces connaissances pour notre tâche de segmentation."
+
+---
+
+## Slide 17 : MobileNetV2 comme Encodeur (Backbone)
+*   **Durée recommandée** : 50 secondes
+*   **Action** : Argumenter sur le choix de l'efficacité embarquée.
+*   **Texte à prononcer** :
+    > "J'ai spécifiquement choisi **MobileNetV2** comme colonne vertébrale, ou backbone, de notre encodeur. 
+    > 
+    > Pourquoi ? Parce que MobileNet est la référence absolue pour le matériel embarqué. Il s'appuie sur des convolutions séparables en profondeur, les **Depthwise Separable Convolutions**. 
+    > 
+    > En séparant le filtrage spatial de la combinaison des canaux, il permet d'obtenir des performances de vision exceptionnelles tout en réduisant par 9 le coût en opérations mathématiques et en mémoire par rapport à des réseaux lourds comme VGG ou ResNet. C'est l'atout parfait pour la réactivité à bord du véhicule."
+
+---
+
+## Slide 18 : Connexion MobileNetV2 et Décodeur U-Net
+*   **Durée recommandée** : 40 secondes
+*   **Action** : Décrire brièvement l'assemblage technique.
+*   **Texte à prononcer** :
+    > "J'ai donc extrait le tronc de MobileNetV2 pré-entraîné, en congelant ses premiers blocs pour conserver les détecteurs de formes universels. 
+    > 
+    > J'ai repéré et connecté ses couches intermédiaires (les blocs 1, 3 et 6) pour alimenter les skip connections de notre décodeur personnalisé. C'est une architecture hybride très élégante, à la fois extrêmement légère en poids et redoutable d'efficacité à l'entraînement."
+
+---
+
+## Slide 19 : Comparaison Quantitative des Modèles
+*   **Durée recommandée** : 1 minute
+*   **Action** : Analyser les lignes du tableau comparatif avec précision.
+*   **Texte à prononcer** :
+    > "Les résultats quantitatifs sont sans appel et valident notre démarche technique.
+    > 
+    > Le modèle U-Net classique from scratch nécessite plus de 40 époques pour converger vers un **mIoU de validation décevant de 0.42**, avec un temps d'inférence de **120 millisecondes sur CPU**, ce qui est trop lent.
+    > 
+    > Notre modèle **U-Net combiné à MobileNetV2** a convergé en seulement 15 époques. Son poids a été divisé par 3, tombant à seulement **12 Mo**. Son mIoU sur le jeu de test s'envole à **0.68**, et surtout, son temps d'inférence est descendu à **35 millisecondes par image**. C'est le seuil symbolique du temps réel sur processeur embarqué !"
+
+---
+
+## Slide 20 : Comparaison Qualitative de la Segmentation
+*   **Durée recommandée** : 45 secondes
+*   **Action** : Décrire visuellement l'amélioration des masques.
+*   **Texte à prononcer** :
+    > "Visuellement, la différence est saisissante. 
+    > 
+    > Là où le U-Net custom affichait des masques pixelisés et instables, le U-Net MobileNetV2 produit des délimitations très propres. La séparation entre la route et le trottoir est nette, et les véhicules sont parfaitement isolés. 
+    > 
+    > Mais le plus satisfaisant reste la détection stable des piétons, même à moyenne distance. Le modèle a développé une excellente compréhension spatiale des scènes urbaines."
+
+---
+
+## Slide 21 : Gain Réel de la Data Augmentation
+*   **Durée recommandée** : 45 secondes
+*   **Action** : Exposer les résultats de l'étude d'ablation pour légitimer la rigueur du projet.
+*   **Texte à prononcer** :
+    > "Pour isoler et quantifier le gain réel de la Data Augmentation, j'ai mené une étude d'ablation en entraînant le modèle avec et sans ces transformations à la volée.
+    > 
+    > Sans augmentation, nous observons un surapprentissage marqué : le mIoU sur les données d'entraînement grimpe en flèche mais stagne sur le jeu de validation. 
+    > 
+    > En activant les rotations, les flips et le contraste, nous avons gagné **8 points de mIoU global sur le jeu de test**. Cela prouve scientifiquement l'apport capital de cette technique de régularisation pour immuniser notre IA contre les aléas de la route réelle."
+
+---
+
+# PARTIE 3 : MLOPS, DÉPLOIEMENT & DÉMONSTRATION (15:00 - 20:00)
+
+## Slide 22 : Architecture MLOps (Vue d'ensemble)
+*   **Durée recommandée** : 40 secondes
+*   **Action** : Passer à la Partie 3. Adopter une attitude dynamique et fière de l'industrialisation.
+*   **Texte à prononcer** :
+    > "Avoir un excellent modèle sur notre notebook n'est qu'une première étape. Pour répondre aux besoins de Laura et industrialiser mon travail, j'ai conçu et mis en place une architecture **MLOps découplée** basée sur des microservices.
+    > 
+    > D'un côté, nous avons le client : une application Web Streamlit interactive. De l'autre, le serveur : notre API FastAPI qui charge le modèle Keras en mémoire et effectue les calculs. L'image caméra transite par une requête HTTP POST sécurisée et le serveur renvoie le masque colorisé directement."
+
+---
+
+## Slide 23 : L'API REST de Prédiction avec FastAPI
+*   **Durée recommandée** : 45 secondes
+*   **Action** : Mettre en avant la robustesse du framework FastAPI.
+*   **Texte à prononcer** :
+    > "L'API a été développée avec **FastAPI**. J'ai retenu ce framework pour sa rapidité asynchrone légendaire et sa génération automatique d'une documentation interactive Swagger UI.
+    > 
+    > L'endpoint principal est `/segmentation`. J'ai utilisé le mécanisme de **lifespan** de FastAPI pour charger le modèle Keras en mémoire une seule fois au démarrage de l'API. Lors d'un appel, l'API reçoit le flux binaire, le convertit en tableau Numpy, applique le prétraitement, effectue la prédiction et renvoie le masque sous forme de flux PNG asynchrone via une `StreamingResponse` pour maximiser le débit."
+
+---
+
+## Slide 24 : Conteneurisation de l'API & de l'App (Docker)
+*   **Durée recommandée** : 35 secondes
+*   **Action** : Expliquer l'isolation de l'environnement.
+*   **Texte à prononcer** :
+    > "Pour garantir que notre code s'exécute de façon strictement identique en local et sur nos serveurs de production, j'ai conteneurisé chaque brique à l'aide de **Docker**.
+    > 
+    > J'ai écrit deux fichiers Dockerfile distincts : un pour isoler l'API FastAPI et ses dépendances lourdes (TensorFlow, Keras), et un second pour l'interface de démonstration Streamlit. Cela élimine définitivement les conflits de versions système."
+
+---
+
+## Slide 25 : Le Défi des Modèles Volumineux sur le Cloud
+*   **Durée recommandée** : 45 secondes
+*   **Action** : Présenter la contrainte technique résolue intelligemment.
+*   **Texte à prononcer** :
+    > "Lors de la mise en production, j'ai fait face à un défi d'infrastructure classique : les fichiers de modèles de Deep Learning pèsent très lourd. Notre modèle optimisé pèse 12 Mo, mais d'autres itérations dépassent largement les 100 Mo.
+    > 
+    > GitHub bloque les fichiers de plus de 100 Mo par défaut. De plus, les hébergeurs Cloud traditionnels imposent des limites strictes de stockage sur leurs serveurs gratuits, ce qui compliquait notre déploiement."
+
+---
+
+## Slide 26 : La Solution de CI/CD Hybride via GitHub Actions
+*   **Durée recommandée** : 50 secondes
+*   **Action** : Détailler le workflow automatique.
+*   **Texte à prononcer** :
+    > "J'ai donc mis en place une architecture de **CI/CD hybride astucieuse** en exploitant la plateforme **Hugging Face Spaces**.
+    > 
+    > Notre code source est versionné sur **GitHub**. À chaque validation de code (`git push`), un workflow automatique **GitHub Actions** est déclenché. Il exécute un script Python qui utilise l'API de Hugging Face pour pousser programmatiquement les fichiers de code et le modèle Keras volumineux directement dans les conteneurs de production HF. 
+    > 
+    > Le service est ainsi mis à jour de manière transparente, sécurisée et entièrement gratuite."
+
+---
+
+## Slide 27 : Le Dashboard Streamlit (Interface de Démo)
+*   **Durée recommandée** : 45 secondes
+*   **Action** : Présenter le fonctionnement du client Streamlit.
+*   **Texte à prononcer** :
+    > "L'interface finale destinée à nos collègues a été construite avec **Streamlit**. 
+    > 
+    > Elle se connecte à notre flotte d'images de test réelles issues de Cityscapes. L'utilisateur sélectionne un ID d'image dans un menu déroulant, clique sur un bouton pour l'envoyer à l'API FastAPI, et l'interface affiche instantanément l'image caméra, le masque parfait attendu pour comparaison et la prédiction en direct de notre modèle."
+
+---
+
+## Slide 28 : Démonstration de l'Application en Action
+*   **Durée recommandée** : 15 secondes
+*   **Action** : Montrer la capture d'écran sur la slide, puis **basculer immédiatement sur l'onglet du navigateur** où l'application Streamlit tourne en direct !
+*   **Texte à prononcer** :
+    > "Voici un aperçu visuel de l'application en action. Je vais maintenant basculer sur mon navigateur pour vous faire une démonstration en direct de ce pipeline d'inférence en production."
+
+---
+
+### [LANCEMENT DE LA DÉMO EN DIRECT - DURÉE : 1 MINUTE 30]
+*   **Actions à réaliser pendant la démo** :
+    1.  **Vérifier** que la page Streamlit est bien chargée (si elle s'est mise en veille, cliquez sur "Restart this Space" en amont).
+    2.  **Ouvrir** le menu latéral gauche et sélectionnez un fichier, par exemple `bielefeld_000000_000321_leftImg8bit.png`.
+    3.  **Cliquer** sur le bouton bleu **"Lancer l'Inférence de l'API"**.
+    4.  **Commenter pendant le chargement (qui dure moins de 5 secondes)** : 
+        > *"Vous voyez ici que l'image caméra s'affiche à gauche. À droite, notre API FastAPI hébergée sur un autre espace a reçu l'image, l'a segmentée en 35 millisecondes et a renvoyé ce masque PNG colorisé. Le vert représente la végétation, le violet la route, le bleu le ciel et le rouge la présence d'humains ou de véhicules."*
+    5.  **Rebasculer sur le diaporama** pour la suite et fin du script.
+
+---
+
+## Slide 29 : Liens du Déploiement en Production
+*   **Durée recommandée** : 20 secondes
+*   **Action** : Montrer brièvement les liens et préciser le mécanisme de veille.
+*   **Texte à prononcer** :
+    > "Comme vous pouvez le voir, l'API et l'application sont hébergées de manière autonome et découplée sur Hugging Face Spaces. L'ensemble de la chaîne est opérationnel et prêt pour des tests de plus grande envergure par nos ingénieurs."
+
+---
+
+## Slide 30 : Conclusion, Perspectives & Améliorations Futures
+*   **Durée recommandée** : 1 minute
+*   **Action** : Adopter un ton posé et professionnel pour conclure en beauté. Regarder l'évaluateur.
+*   **Texte à prononcer** :
+    > "Pour conclure, ce projet valide la faisabilité complète d'un pipeline de vision sémantique : depuis l'acquisition des données brutes avec un générateur asynchrone robuste, jusqu'à la mise en production de microservices hautement performants grâce au Transfer Learning et à une infrastructure MLOps moderne.
+    > 
+    > En termes de perspectives, mes priorités pour la prochaine itération sont :
+    > 
+    > Premièrement, la **quantification post-entraînement** pour convertir notre modèle Keras en format **TensorFlow Lite (TFLite)** avec une précision en Float16 ou Int8. Cela divisera par 4 le poids du modèle (qui tombera à 3 Mo) et augmentera la cadence d'inférence embarquée.
+    > 
+    > Deuxièmement, l'intégration d'un lissage spatial par **CRF** en post-traitement pour affiner davantage les contours géométriques.
+    > 
+    > Et enfin, la connexion directe de l'API avec le module de décision de freinage d'urgence du véhicule.
+    > 
+    > Je vous remercie pour votre attention et je suis à présent à votre entière disposition pour répondre à vos questions et échanger sur nos choix techniques."

api/main.py

@@ -41,14 +41,14 @@ async def lifespan(app: FastAPI):
         try:
             os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
             import tensorflow as tf
-            logger.info("⏳ Chargement du modèle Keras...")
+            logger.info("Chargement du modèle Keras...")
             model = tf.keras.models.load_model(MODEL_PATH, compile=False)
-            logger.info("✅ Modèle chargé avec succès !")
+            logger.info("Modèle chargé avec succès !")
         except Exception as e:
             model = None
-            logger.error(f"❌ Erreur critique de TensorFlow : {e}")
+            logger.error(f"Erreur critique de TensorFlow : {e}")
     else:
-        logger.warning(f"⚠️ Modèle introuvable ({MODEL_PATH}). L'API tourne en 'MOCK MODE'.")
+        logger.warning(f"Modèle introuvable ({MODEL_PATH}). L'API tourne en 'MOCK MODE'.")
     yield
     # Nettoyage si nécessaire
     model = None

app/app.py

@@ -7,9 +7,9 @@ import base64
 import io
 
 # --- 1. Configuration UI ---
-st.set_page_config(page_title="Future Vision Transport - Démos", layout="wide", page_icon="🚗")
+st.set_page_config(page_title="Future Vision Transport - Démos", layout="wide", page_icon="")
 
-st.title("🚗 Segmentation Sémantique Embarquée")
+st.title("Segmentation Sémantique Embarquée")
 st.markdown("Interface d'Inférence interagissant en direct avec l'API FastAPI construite lors de la Phase 5.")
 
 # Cible du Microservice API
@@ -36,11 +36,11 @@ def load_available_images():
 images_list = load_available_images()
 
 if not images_list:
-    st.error("⚠️ **Stop !** Dossier des images introuvable. J'ai cherché dans `data/P8_Cityscapes_leftImg8bit_trainvaltest`. Êtes-vous sûr d'avoir lancé `streamlit run app/app.py` depuis la racine de `Projet_8` ?")
+    st.error("**Stop !** Dossier des images introuvable. J'ai cherché dans `data/P8_Cityscapes_leftImg8bit_trainvaltest`. Êtes-vous sûr d'avoir lancé `streamlit run app/app.py` depuis la racine de `Projet_8` ?")
     st.stop()
 
 # --- 3. Barre de Menu (Sidebar) ---
-st.sidebar.header("🕹 Tableau de Bord")
+st.sidebar.header("Tableau de Bord")
 st.sidebar.markdown("Sélectionnez l'image issue des caméras embarquées pour la transmettre au réseau de neurones.")
 
 # On allège visuellement la liste déroulante en n'affichant que le nom du fichier
@@ -54,10 +54,10 @@ gt_color_filename = selected_filename.replace('_leftImg8bit.png', '_gtFine_color
 gt_color_path = os.path.join("data/P8_Cityscapes_gtFine_trainvaltest/gtFine/test/", city_name, gt_color_filename)
 
 # --- 4. Le Client REST ---
-if st.sidebar.button("🤖 Lancer l'Inférence de l'API"):
+if st.sidebar.button("Lancer l'Inférence de l'API"):
     st.markdown("---")
     
-    with st.spinner("⏳ Transmission sécurisée à l'API FastAPI en cours..."):
+    with st.spinner("Transmission sécurisée à l'API FastAPI en cours..."):
         try:
             # Sérialisation : On capture l'image en données binaires pour le flux HTTP sortant
             with open(selected_path, "rb") as image_file:
@@ -70,35 +70,35 @@ if st.sidebar.button("🤖 Lancer l'Inférence de l'API"):
                 # L'API nous renvoie désormais directement l'image au format PNG ! (StreamingResponse)
                 predicted_mask = Image.open(io.BytesIO(response.content))
                 
-                st.success("✅ Triangulation serveur réussie ! Prédiction récupérée depuis l'API.")
+                st.success("Triangulation serveur réussie ! Prédiction récupérée depuis l'API.")
                 
                 # --- VISUALISATION DES 3 COMPOSANTES (Phase 6.1 Guideline) ---
                 col1, col2, col3 = st.columns(3)
                 
                 # A. La Réalité Capturée
-                col1.subheader("📸 Caméra (leftImg8bit)")
+                col1.subheader("Caméra (leftImg8bit)")
                 col1.image(Image.open(selected_path), use_container_width=True)
                 
                 # B. Le Masque Parfait fourni par Cityscapes
-                col2.subheader("🎯 Masque Vérité (Attendu)")
+                col2.subheader("Masque Vérité (Attendu)")
                 if os.path.exists(gt_color_path):
                     col2.image(Image.open(gt_color_path), use_container_width=True)
                 else:
                     col2.warning("Non fourni (Normal pour le Test-Set de compétition).")
                     
                 # C. L'Intelligence Artificielle en Action
-                col3.subheader("🧠 Prédiction FastAPI (Notre IA)")
+                col3.subheader("Prédiction FastAPI (Notre IA)")
                 col3.image(predicted_mask, use_container_width=True)
                 
                 # Affichage des classes (Codées en dur ici car l'API renvoie directement une image pour optimiser)
                 CLASSES = ['void', 'flat', 'construction', 'object', 'nature', 'sky', 'human', 'vehicle']
-                with st.expander("Consulter la palette de couleurs sémantiques 🎨"):
+                with st.expander("Consulter la palette de couleurs sémantiques "):
                     st.write(", ".join(CLASSES))
                     
             else:
-                st.error(f"❌ Erreur Serveur (HTTP {response.status_code}) : Vous devez vérifier ce que l'API imprime dans son propre terminal.")
+                st.error(f"Erreur Serveur (HTTP {response.status_code}) : Vous devez vérifier ce que l'API imprime dans son propre terminal.")
                 
         except requests.exceptions.ConnectionError:
-            st.error(f"💥 ERREUR CRITIQUE : L'API est injoignable sur l'URL ciblée (`{API_URL}`).")
-            # st.info("👉 Si vous testez en local pour GCP, lancez le serveur FastAPI via : `cd api && uvicorn main:app --port 8000` et vérifiez l'API_URL.")
-            st.info("👉 Si vous testez en local pour Hugging Face, lancez le serveur FastAPI via : `cd api && uvicorn main:app --port 7860` et vérifiez l'API_URL.")
+            st.error(f"ERREUR CRITIQUE : L'API est injoignable sur l'URL ciblée (`{API_URL}`).")
+            # st.info("Si vous testez en local pour GCP, lancez le serveur FastAPI via : `cd api && uvicorn main:app --port 8000` et vérifiez l'API_URL.")
+            st.info("Si vous testez en local pour Hugging Face, lancez le serveur FastAPI via : `cd api && uvicorn main:app --port 7860` et vérifiez l'API_URL.")

etapes_suivantes.md

@@ -36,4 +36,4 @@ Tu dois préparer un dossier compressé `.zip` nommé `Titre_du_projet_nom_prén
 - Entraîne-toi à tenir le timing très strict de **20 minutes (+/- 5 minutes)**. (Trop court ou trop long peut valoir un refus de l'examinateur).
 - Prépare-toi aux questions de l'évaluateur pendant les 5 minutes de discussion (ex: *"Pourquoi U-Net plutôt qu'une autre architecture ?"*, *"Comment l'API gérerait-elle 30 images par seconde en temps réel dans une voiture ?"*, *"Comment avez-vous contourné les limites de taille de fichier lors du déploiement ?"*).
 
-> **💡 Conseil Bonus :** N'hésite pas à mettre en avant tes récents succès lors de la présentation (le pipeline CI/CD automatisé via Github Actions, le script de contournement des limites Git, la configuration multi-conteneurs Docker). C'est une excellente plus-value qui prouve tes compétences de futur ingénieur ML "Industrialisable" !
+> **Conseil Bonus :** N'hésite pas à mettre en avant tes récents succès lors de la présentation (le pipeline CI/CD automatisé via Github Actions, le script de contournement des limites Git, la configuration multi-conteneurs Docker). C'est une excellente plus-value qui prouve tes compétences de futur ingénieur ML "Industrialisable" !

guide_projet_8.md

@@ -1,4 +1,4 @@
-# 🚗 Guide Complet — Projet 8 : Déploiement d'un Modèle de Segmentation d'Images
+# Guide Complet — Projet 8 : Déploiement d'un Modèle de Segmentation d'Images
 
 > **Contexte** : Tu es ingénieur IA chez *Future Vision Transport*. Tu conçois le module de **segmentation d'images** dans une chaîne de vision embarquée pour véhicules autonomes. Le dataset est **Cityscapes**, le framework imposé est **Keras**, et tu dois livrer un modèle + API + application web déployés sur le Cloud.
 
@@ -43,7 +43,7 @@ echo "venv_projet8/\ndata/\nmodels/*.h5\n__pycache__/" > .gitignore
 ## Phase 1 — Comprendre les données Cityscapes
 
 ### 1.1 Télécharger le jeu de données complet
-> ⚠️ **Observation** : Ton dossier [data/](file:///Users/j/Documents/OC_Inge_IA/Projet_8/data) contient actuellement uniquement les **annotations gtFine** (masks de segmentation), pas les images brutes. Tu dois télécharger les images `leftImg8bit` depuis [cityscapes-dataset.com](https://www.cityscapes-dataset.com/).
+> **Observation** : Ton dossier [data/](file:///Users/j/Documents/OC_Inge_IA/Projet_8/data) contient actuellement uniquement les **annotations gtFine** (masks de segmentation), pas les images brutes. Tu dois télécharger les images `leftImg8bit` depuis [cityscapes-dataset.com](https://www.cityscapes-dataset.com/).
 
 - **Why** : Ton modèle prend en entrée les **images caméra** (leftImg8bit) et doit prédire les **masks de segmentation** (gtFine). Sans les images, tu ne peux pas entraîner.
 - **Notions** : *supervised learning*, notion d'images d'entrée vs. ground truth / labels.
@@ -182,7 +182,7 @@ Techniques à appliquer :
 - **Random crop + resize**
 - **Ajout de bruit gaussien**
 
-> ⚠️ L'augmentation doit être appliquée **identiquement** à l'image ET au mask !
+> L'augmentation doit être appliquée **identiquement** à l'image ET au mask !
 
 - **Why** : Le livrable demande explicitement des "gains obtenus avec les approches d'augmentation des données". L'augmentation permet de régulariser le modèle et d'augmenter virtuellement la taille du dataset.
 - **Notions** : *data augmentation*, bibliothèque `albumentations` (applique les mêmes transformations géométriques à l'image et au mask), *overfitting prevention*.
@@ -285,10 +285,10 @@ Calculer les métriques finales sur le test set (Berlin, Bielefeld, Bonn, Leverk
 
 | Critère | Flask | FastAPI |
 |---------|-------|---------|
-| Facilité | ✅ Plus simple | ⚠️ Async concepts |
-| Performance | ⚠️ Synchrone | ✅ Asynchrone natif |
-| Documentation auto | ❌ | ✅ Swagger/OpenAPI inclus |
-| Typing | ❌ | ✅ Pydantic intégré |
+| Facilité | Plus simple | Async concepts |
+| Performance | Synchrone | Asynchrone natif |
+| Documentation auto | | Swagger/OpenAPI inclus |
+| Typing | | Pydantic intégré |
 
 > **Recommandation** : FastAPI — la doc auto est un vrai plus pour Laura et la soutenance.
 
@@ -356,7 +356,7 @@ L'application doit permettre :
 import streamlit as st
 import requests
 
-st.title("🚗 Segmentation d'Images - Future Vision Transport")
+st.title("Segmentation d'Images - Future Vision Transport")
 
 # Liste des images disponibles
 image_ids = get_available_image_ids()
@@ -394,11 +394,11 @@ if st.button("Lancer la prédiction"):
 
 | Plateforme | Coût | Difficulté | GPU |
 |-----------|------|-----------|-----|
-| **Render** | Gratuit (limité) | ⭐⭐ | ❌ |
-| **Railway** | Gratuit ($5 crédit) | ⭐⭐ | ❌ |
+| **Render** | Gratuit (limité) | ⭐⭐ | |
+| **Railway** | Gratuit ($5 crédit) | ⭐⭐ | |
 | **Azure Web App** | Free tier disponible | ⭐⭐⭐ | Option payante |
-| **Google Cloud Run** | Free tier généreux | ⭐⭐⭐ | ❌ |
-| **PythonAnywhere** | Gratuit (très limité) | ⭐ | ❌ |
+| **Google Cloud Run** | Free tier généreux | ⭐⭐⭐ | |
+| **PythonAnywhere** | Gratuit (très limité) | ⭐ | |
 | **AWS (EC2/Lambda)** | Free tier 12 mois | ⭐⭐⭐⭐ | Option payante |
 
 - **Why** : Le déploiement Cloud est obligatoire pour la soutenance. Tu dois faire une démo en live et l'enregistrer. Choisis en fonction de ton budget et de ta familiarité.
@@ -431,7 +431,7 @@ Deux déploiements séparés :
 
 ### 7.4 Enregistrer la démo pendant la soutenance
 
-> ⚠️ **Important** : Le sujet précise que l'évaluateur et l'étudiant doivent **enregistrer la démo** pendant la soutenance pour que le jury puisse la visionner. Tu pourras ensuite couper le service Cloud pour éviter les coûts.
+> **Important** : Le sujet précise que l'évaluateur et l'étudiant doivent **enregistrer la démo** pendant la soutenance pour que le jury puisse la visionner. Tu pourras ensuite couper le service Cloud pour éviter les coûts.
 
 - **Why** : C'est une exigence explicite du sujet. Prépare un outil d'enregistrement d'écran (OBS, QuickTime, etc.).
 - **Notions** : *screen recording*, préparation de démo.
@@ -496,7 +496,7 @@ Préparer un script de démo :
 
 ---
 
-## ✅ Checklist des Livrables
+## Checklist des Livrables
 
 | # | Livrable | Format | Nommage |
 |---|----------|--------|---------|
@@ -506,11 +506,11 @@ Préparer un script de démo :
 | 4 | **Note technique** (~10 pages) | PDF | `Nom_Prénom_4_note_technique_mmaaaa` |
 | 5 | **Présentation** (max 30 slides) | PPTX/PDF | `Nom_Prénom_5_presentation_mmaaaa` |
 
-> ⚠️ Tout doit être dans un **zip** nommé `Titre_du_projet_nom_prénom`.
+> Tout doit être dans un **zip** nommé `Titre_du_projet_nom_prénom`.
 
 ---
 
-## 🎯 Notions Clés à Maîtriser (Résumé)
+## Notions Clés à Maîtriser (Résumé)
 
 | Domaine | Notions |
 |---------|---------|