Upload folder using huggingface_hub

.gcloudignore

@@ -0,0 +1,5 @@
+.git
+.github
+.venv
+__pycache__
+notebooks/

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+app/Screenshot_streamlit_app.png filter=lfs diff=lfs merge=lfs -text
+mlflow.db filter=lfs diff=lfs merge=lfs -text
+models/best_unet_model.keras filter=lfs diff=lfs merge=lfs -text

Livrables.md

@@ -0,0 +1,46 @@
+# Livrables
+
+
+Les scripts développés sur un notebook permettant l’exécution du pipeline complet :
+Ce livrable vous servira à présenter le caractère “industrialisable” de votre travail en particulier le générateur de données.
+Une API (Flask ou FastAPI) déployée sur le Cloud (Azure, Heroku, PythonAnywhere ou toute autre solution), pour exposer votre modèle entraîné et qui recevra en entrée une image et retournera le mask prédit (les segments identifiés par votre modèle) :
+Ce livrable permettra à Laura d’utiliser facilement votre modèle.
+Une application (Flask, Streamlit) de présentation des résultats qui consomme l’API de prédiction, déployée sur le Cloud (Azure, Heroku, PythonAnywhere ou toute autre solution). Cette application sera l’interface pour tester l’API et intégrera les fonctionnalités suivantes :  affichage de la liste des id des images disponibles, lancement de la prédiction du mask pour l’id sélectionné par appel à l’API, et affichage de l’image réelle, du mask réel et du mask prédit :
+Ce livrable permettra d’illustrer votre travail auprès de vos collègues
+Une note technique de 10 pages environ contenant une présentation des différentes approches et une synthèse de l’état de l’art, la présentation plus détaillée du modèle et de l’architecture retenue, une synthèse des résultats obtenus (incluant les gains obtenus avec les approches d’augmentation des données) et une conclusion avec des pistes d’amélioration envisageables  :
+Ce livrable vous servira à présenter votre démarche technique à vos collègues.
+Un support de présentation (type Power Point) de votre démarche méthodologique (30 slides maximum) :
+Ce livrable vous permettra de présenter vos résultats à Laura.
+Déposez sur la plateforme, dans un dossier zip nommé “Titre_du_projet_nom_prénom”, votre livrable nommé comme suit : Nom_Prénom_n° du livrable_nom du livrable_date de démarrage du projet. Cela donnera : 
+
+Nom_Prénom_1_scripts_mmaaaa
+Nom_Prénom_2_API_mmaaaa
+Nom_Prénom_3_application_Flask_mmaaaa
+Nom_Prénom_4_note_technique_mmaaaa
+Nom_Prénom_5_presentation_mmaaaa
+Par exemple, votre premier livrable peut être nommé comme suit : Dupont_Jean_1_scripts_012024.
+
+ 
+
+# Soutenance:
+
+
+Pendant la soutenance, l’évaluateur ne jouera aucun rôle en particulier. Vous lui présenterez l’ensemble de votre travail. 
+
+Présentation (20 minutes) 
+Présentation du contexte, des objectifs, des principes de segmentation et des mesures de performance qui seront utilisées pour comparer les modèles (5 minutes)
+Présentation des différents modèles, simulations et comparaisons des modèles (10 minutes).
+Mise en production d’un modèle (5 minutes) :
+Architecture API et application Web et démarche de mise en production sur le Cloud choisi par l’étudiant
+démonstration de fonctionnement de l’application et de la prédiction de segmentation d’une image (mask).
+Discussion (5 minutes)
+L’évaluateur vous challengera sur vos choix. 
+Débriefing (5 minutes)
+À la fin de la soutenance, vous pourrez débriefer ensemble. 
+Votre présentation devrait durer 20 minutes (+/- 5 minutes).  Puisque le respect des durées des présentations est important en milieu professionnel, les présentations en dessous de 15 minutes ou au-dessus de 25 minutes peuvent être refusées. 
+
+Concernant la mise en production de l’API, plusieurs solutions s’offrent à vous, en particulier Azure webapp, AWS et Heroku. À vous de choisir la solution qui vous convient le mieux.
+
+Dans le cadre de l’utilisation de Heroku, étant devenu payant depuis fin novembre 2022, les coûts liés à votre projet seront à votre charge. Vous êtes donc libre de vous investir financièrement si vous le souhaitez, mais vous n’avez aucune obligation de le faire pour réaliser ce projet. 
+
+Quelque soit la solution Cloud choisie, l'étudiant et l'évaluateur veilleront à enregistrer pendant la soutenance la démo de l'application en production, ce qui permettra au jury de visionner cette démo, sans que l'étudiant n'ait à maintenir son application sur le Cloud. Maintenir l’application dans le Cloud pourrait en effet engendrer des coûts. 

Project_description.md

@@ -0,0 +1,31 @@
+# Projet_8
+
+Future Vision Transport est une entreprise qui conçoit des systèmes embarqués de vision par ordinateur pour les véhicules autonomes. 
+
+Vous êtes l’un des ingénieurs IA au sein de l’équipe R&D de cette entreprise. Votre équipe est composée d’ingénieurs aux profils variés. Chacun des membres de l’équipe est spécialisé sur une des parties du système embarqué de vision par ordinateur. 
+
+Voici les différentes parties du système :
+
+acquisition des images en temps réel
+traitement des images
+segmentation des images (c’est vous !)
+système de décision
+Vous travaillez sur la partie de segmentation des images (3) qui est alimentée par le bloc de traitement des images (2) et qui alimente le système de décision (4).
+
+Votre rôle est de concevoir un premier modèle de segmentation d’images qui devra s’intégrer facilement dans la chaîne complète du système embarqué.
+
+Lors d’une première phase de cadrage, vous avez récolté les avis de Franck et Laura, qui travaillent sur les parties avant et après votre intervention :
+
+Franck, en charge du traitement des images (2) :
+
+Le jeu de données que Franck utilise est disponible à ce lien, ou en téléchargement direct à ces liens : 1 ou 2, (images segmentées et annotées de caméras embarquées). On a uniquement besoin des 8 catégories principales (et non pas des 32 sous-catégories)
+Laura, en charge du système de décision (4)
+
+Souhaite une API simple à utiliser.
+L’API prend en entrée une image et renvoie la segmentation de l’image de l’algo.
+
+Pour récapituler, vous avez dressé un plan d’action, avec les points suivants :
+
+entraîner un modèle de segmentation des images sur les 8 catégories principales. Keras est le framework de travail commun à toute l’équipe. Attention aux contraintes de Franck !
+concevoir une API de prédiction (Flask ou FastAPI) qui sera utilisée par Laura et la déployer sur le Cloud (Azure, Heroku, PythonAnywhere ou toute autre solution). Cette API prend en entrée une image et renvoie le mask prédit (segments prédits de l’image).
+concevoir une application web (Flask, Streamlit) de présentation des résultats et la déployer sur le Cloud (Azure, Heroku, PythonAnywhere ou toute autre solution). Cette application sera l’interface pour tester l’API et afficher les images et masks.

README.md

@@ -1,11 +1,10 @@
 ---
-title: Projet 8 Api
-emoji: 🏃
-colorFrom: yellow
-colorTo: yellow
+title: Projet 8 API
+emoji: 🚀
+colorFrom: blue
+colorTo: indigo
 sdk: docker
 pinned: false
-short_description: Partie API de mon projet 8 contenant le modèle keras
+app_port: 7860
+dockerfile: api/Dockerfile
 ---
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

README_API.md

@@ -0,0 +1,61 @@
+Ce dossier, P7, est le projet 7 avant que je ne fasse le docker init. J'ai cloné le projet qui s'appelle maintenant Projet_7 dans lequel je fais le docker init.
+
+
+Build l'image Docker:
+
+docker build \
+-t predictionsentiments \
+-f Projet_7_API/Dockerfile Projet_7_API
+
+Runner l'image Docker:
+docker run -p 8000:8000 --name predictionsentiments_container predictionsentiments
+
+POur accéder à la documentation:
+http://0.0.0.0:8000/docs
+
+# AZURE PORTAL : Pour vérifier où mes images docker sont:
+container registries dans la barre de recherche Azure
+Services < dépôts 
+predictionsentimentsregistry est mon registry situé dans mes Dépôts Azure
+L'application est déployée via le 'app service'
+
+# MLflow
+Pour lancer MLFlow il faut taper 'mlflow server'
+Ensuite, aller à http://127.0.0.1:5000/
+
+
+# Lancer l'application
+cd Projet_8_API
+uvicorn main:app --host 0.0.0.0 --port 8000
+uvicorn main:app --host 0.0.0.0 --port 8000 --reload
+
+
+
+# Feeling classifier
+
+Pour lancer l'API
+
+fastapi dev main.py
+
+Ouvir http://127.0.0.1:8000/docs
+
+A faire:
+
+- Installer Docker Desktop
+- Faire un Dockerfile avec l'api dedans et qui marche
+- Creer un Github
+- Creer un Github workflow pour build l'image 
+- Creer un compte Azure, creer une azure app 
+- Deployer l'image de Github sur Azure app, 
+- Avoir l'API qui fonctionne sur Azure APP
+
+# Fonctionnement de main.py
+
+main.py :
+Le modèle est chargé dynamiquement au lancement de l'API via lifespan pour une meilleure gestion de la mémoire.
+Le point de terminaison /segmentation a été mis à jour : il convertit désormais l'image entrante, la redimensionne en 256x512, la normalise, fait la prédiction via notre modèle Keras, et génère un masque coloré basé sur les couleurs Cityscapes.
+L'image du masque est finalement renvoyée via StreamingResponse au format PNG, ce qui est le standard le plus optimisé pour les API d'images avec FastAPI.
+Un point de terminaison /health a été ajouté pour vérifier si l'API est saine et le modèle bien chargé.
+Attention : Comme mentionné dans le Walkthrough, bien que notre modèle soit léger, TensorFlow reste une librairie très lourde en RAM. S'il s'avère que l'API crashe par manque de mémoire sur Render (limite de 512 Mo), il faudra envisager de convertir notre modèle en format TFLite ou ONNX.
+
+Si un jour j'ai un serveur plus puissant et je souhaite changer de modèle il suffira de changer la variable MODEL_PATH = 'best_mobilenet_unet_model.keras' dans le main.py

api/Dockerfile

@@ -0,0 +1,28 @@
+FROM python:3.11-slim
+
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+ && rm -rf /var/lib/apt/lists/*
+
+COPY api/requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY api/ api/
+COPY models/ models/
+
+WORKDIR /app/api
+
+# --- Configuration du port (Décommenter selon le Cloud choisi) ---
+
+# Pour Google Cloud Run (ou local standard) :
+# EXPOSE 8000
+# CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
+
+# Pour Hugging Face Spaces (Port 7860 par défaut) :
+EXPOSE 7860
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

api/main.py

@@ -0,0 +1,104 @@
+import os
+import io
+import logging
+from contextlib import asynccontextmanager
+
+from fastapi import FastAPI, UploadFile, File
+from fastapi.responses import StreamingResponse
+from PIL import Image
+import numpy as np
+
+# Setup logger
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+)
+logger = logging.getLogger(__name__)
+
+# Note : Le code pour Azure Log Analytics peut être configuré ici
+# en utilisant azure-monitor-opentelemetry (si la clé de connexion est fournie via env)
+# try:
+#     from azure.monitor.opentelemetry import configure_azure_monitor
+#     if "APPLICATIONINSIGHTS_CONNECTION_STRING" in os.environ:
+#         configure_azure_monitor()
+# except ImportError:
+#     pass
+
+CLASSES = ['void', 'flat', 'construction', 'object', 'nature', 'sky', 'human', 'vehicle']
+COLORS = [
+    [0, 0, 0], [128, 64, 128], [70, 70, 70], [153, 153, 153],
+    [107, 142, 35], [70, 130, 180], [220, 20, 60], [0, 0, 142]
+]
+
+# Variables globales pour l'état de l'application
+model = None
+MODEL_PATH = os.path.join(os.path.dirname(__file__), '../models/best_unet_model.keras')
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    global model
+    if os.path.exists(MODEL_PATH):
+        try:
+            os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
+            import tensorflow as tf
+            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 !")
+        except Exception as e:
+            model = None
+            logger.error(f"❌ Erreur critique de TensorFlow : {e}")
+    else:
+        logger.warning(f"⚠️ Modèle introuvable ({MODEL_PATH}). L'API tourne en 'MOCK MODE'.")
+    yield
+    # Nettoyage si nécessaire
+    model = None
+
+app = FastAPI(
+    title="Cityscapes Segmentation API",
+    description="API de segmentation sémantique pour Future Vision Transport",
+    version="1.0",
+    lifespan=lifespan
+)
+
+@app.get("/")
+async def root():
+    return {"message": "Service back-end de prédiction Actif."}
+
+@app.get("/health")
+def health_check():
+    return {"status": "ok", "model_active": model is not None}
+
+@app.post("/segmentation")
+async def segmentation(file: UploadFile = File(...)):
+    # Lire l'image envoyée
+    image_bytes = await file.read()
+    image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
+
+    IMG_HEIGHT, IMG_WIDTH = 256, 512
+    img_resized = image.resize((IMG_WIDTH, IMG_HEIGHT))
+
+    if model is not None:
+        # Prétraitement de l'image
+        img_array = np.array(img_resized) / 255.0
+        img_batch = np.expand_dims(img_array, axis=0)
+        
+        # Prédiction
+        prediction = model.predict(img_batch, verbose=0)[0]
+        mask_classes = np.argmax(prediction, axis=-1).astype(np.uint8)
+    else:
+        # Mock Mode : générer un masque vide si aucun modèle n'est chargé
+        mask_classes = np.zeros((IMG_HEIGHT, IMG_WIDTH), dtype=np.uint8)
+
+    # Colorisation du masque
+    mask_colored = np.zeros((IMG_HEIGHT, IMG_WIDTH, 3), dtype=np.uint8)
+    for class_id, color in enumerate(COLORS):
+        mask_colored[mask_classes == class_id] = color
+
+    mask_img = Image.fromarray(mask_colored)
+    
+    # Convertir l'image en bytes pour la réponse
+    img_io = io.BytesIO()
+    mask_img.save(img_io, format="PNG")
+    img_io.seek(0)
+
+    return StreamingResponse(img_io, media_type="image/png")

api/requirements.txt

@@ -0,0 +1,7 @@
+fastapi==0.128.8
+uvicorn==0.39.0
+python-multipart==0.0.20
+tensorflow-cpu==2.14.0
+numpy
+pillow
+azure-monitor-opentelemetry

app/Dockerfile

@@ -0,0 +1,21 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+# On installe les requirements de l'application
+COPY app/requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# On copie le code de l'application et la donnée (images de test)
+COPY app/ app/
+COPY data/ data/
+
+# --- Configuration du port (Décommenter selon le Cloud choisi) ---
+
+# Pour Google Cloud Run (ou local standard) :
+# EXPOSE 8501
+# CMD ["streamlit", "run", "app/app.py", "--server.port", "8501", "--server.address", "0.0.0.0"]
+
+# Pour Hugging Face Spaces (Port 7860 par défaut) :
+EXPOSE 7860
+CMD ["streamlit", "run", "app/app.py", "--server.port", "7860", "--server.address", "0.0.0.0"]

app/app.py

@@ -0,0 +1,104 @@
+import streamlit as st
+import requests
+import glob
+import os
+from PIL import Image
+import base64
+import io
+
+# --- 1. Configuration UI ---
+st.set_page_config(page_title="Future Vision Transport - Démos", layout="wide", page_icon="🚗")
+
+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
+# --- Configuration du port local (Décommenter selon le Cloud choisi) ---
+# Si tu testes pour GCP (Port 8000) :
+# API_URL = os.getenv("API_URL", "http://localhost:8000")
+# Si tu testes pour Hugging Face (Port 7860) :
+API_URL = os.getenv("API_URL", "http://localhost:7860")
+
+# --- 2. Fonctions Méthodologiques ---
+@st.cache_data
+def load_available_images():
+    """ 
+    Scanne intelligemment le dossier de Test pour remonter toute la flotte d'images réelles (Phase 6.1).
+    Utilise le cache de Streamlit pour ne pas faire mouliner le disque dur à chaque clic !
+    """
+    img_dir = "data/P8_Cityscapes_leftImg8bit_trainvaltest/leftImg8bit/test/"
+    if not os.path.exists(img_dir):
+        return []
+        
+    image_paths = sorted(glob.glob(os.path.join(img_dir, "**/*_leftImg8bit.png"), recursive=True))
+    return image_paths
+
+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.stop()
+
+# --- 3. Barre de Menu (Sidebar) ---
+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
+images_names = [os.path.basename(p) for p in images_list]
+selected_filename = st.sidebar.selectbox("Fichier à analyser :", images_names)
+selected_path = images_list[images_names.index(selected_filename)]
+
+# Algorithme pour reconstruire le chemin du "Ground Truth Color" (Masque Parfait) de Cityscapes
+city_name = selected_filename.split('_')[0]
+gt_color_filename = selected_filename.replace('_leftImg8bit.png', '_gtFine_color.png')
+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"):
+    st.markdown("---")
+    
+    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:
+                # payload 'multipart/form-data'
+                files = {"file": (selected_filename, image_file, "image/png")}
+                response = requests.post(f"{API_URL}/segmentation", files=files)
+            
+            # Si le serveur nous envoie un Code HTTP 200 (Succès Total)
+            if response.status_code == 200:
+                # 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.")
+                
+                # --- 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.image(Image.open(selected_path), use_container_width=True)
+                
+                # B. Le Masque Parfait fourni par Cityscapes
+                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.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 🎨"):
+                    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.")
+                
+        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.")

app/requirements.txt

@@ -0,0 +1,3 @@
+streamlit==1.50.0
+requests==2.32.5
+pillow==11.3.0

guide_projet_8.md

@@ -0,0 +1,523 @@
+# 🚗 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.
+
+---
+
+## Phase 0 — Mise en place de l'environnement
+
+### 0.1 Créer un environnement virtuel Python dédié
+```bash
+python -m venv venv_projet8
+source venv_projet8/bin/activate
+pip install tensorflow keras numpy pandas matplotlib opencv-python albumentations flask fastapi uvicorn streamlit
+```
+- **Why** : Isoler les dépendances évite les conflits entre projets. C'est une pratique professionnelle standard.
+- **Notions** : *virtual environments*, gestion de dépendances avec `pip`, `requirements.txt`.
+
+### 0.2 Structurer le répertoire de travail
+```
+Projet_8/
+├── data/               # Données Cityscapes (déjà présent)
+├── notebooks/          # Notebooks d'exploration et d'entraînement
+├── src/                # Code source réutilisable (data generator, model, utils)
+├── api/                # Code de l'API Flask/FastAPI
+├── app/                # Code de l'application web Streamlit/Flask
+├── models/             # Modèles sauvegardés (.h5, .keras)
+├── docs/               # Note technique + supports de présentation
+└── requirements.txt
+```
+- **Why** : Une structure claire rend le projet "industrialisable" (critère évalué dans les livrables) et facilite la collaboration.
+- **Notions** : *project scaffolding*, bonnes pratiques d'organisation de projets ML.
+
+### 0.3 Initialiser un dépôt Git
+```bash
+git init
+echo "venv_projet8/\ndata/\nmodels/*.h5\n__pycache__/" > .gitignore
+```
+- **Why** : Le versionnement est indispensable pour tracer l'évolution du code, revenir en arrière, et montrer ta démarche.
+- **Notions** : *Git*, versionnement, `.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/).
+
+- **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.
+
+### 1.2 Comprendre la structure des fichiers
+Pour chaque image, Cityscapes fournit :
+
+| Fichier | Description |
+|---------|-------------|
+| `*_leftImg8bit.png` | Image caméra brute (1024×2048) |
+| `*_gtFine_labelIds.png` | Mask avec label ID par pixel (0-33) |
+| `*_gtFine_color.png` | Mask coloré (visualisation) |
+| `*_gtFine_instanceIds.png` | Mask d'instances |
+| `*_gtFine_polygons.json` | Annotations polygonales |
+
+- **Why** : Comprendre ce que chaque fichier représente est crucial avant de construire ton pipeline de données. Tu utiliseras principalement `leftImg8bit` + `labelIds`.
+- **Notions** : *semantic segmentation*, *instance segmentation*, label maps, correspondance pixel-classe.
+
+### 1.3 Comprendre les 8 catégories principales vs les 32 sous-catégories
+
+Le projet demande de travailler avec les **8 catégories principales** :
+
+| ID Cat. | Catégorie | Sous-catégories incluses |
+|---------|-----------|-------------------------|
+| 0 | **void** | unlabeled, ego vehicle, rectification border, out of roi, static, dynamic |
+| 1 | **flat** | road, sidewalk, parking, rail track |
+| 2 | **construction** | building, wall, fence, guard rail, bridge, tunnel |
+| 3 | **object** | pole, polegroup, traffic light, traffic sign |
+| 4 | **nature** | vegetation, terrain |
+| 5 | **sky** | sky |
+| 6 | **human** | person, rider |
+| 7 | **vehicle** | car, truck, bus, caravan, trailer, train, motorcycle, bicycle |
+
+- **Why** : C'est une contrainte explicite du projet (Franck). Tu dois mapper les 32 sous-catégories vers ces 8. Cela simplifie le problème et rend le modèle plus robuste.
+- **Notions** : *label remapping*, *category grouping*, dictionnaire de correspondance Cityscapes.
+
+### 1.4 Explorer visuellement les données (EDA)
+Dans un notebook, afficher côte à côte :
+- L'image brute
+- Le mask coloré (`gtFine_color`)
+- Le mask labelIds remappé vers les 8 catégories
+- Distribution des classes par image (histogrammes)
+
+- **Why** : L'EDA permet de détecter le *class imbalance* (par exemple, "road" et "building" dominent, "rider" est rare). Cela guidera tes choix d'augmentation de données et de loss function.
+- **Notions** : *Exploratory Data Analysis*, *class imbalance*, visualisation de masks de segmentation, `matplotlib.imshow()`.
+
+---
+
+## Phase 2 — État de l'Art et Recherche Bibliographique
+
+### 2.1 Étudier les architectures de segmentation sémantique
+
+Architectures incontournables à comprendre et comparer :
+
+| Architecture | Principe clé | Avantage |
+|-------------|--------------|----------|
+| **FCN** (Fully Convolutional Network) | Remplace les couches FC par des convolutions | Premier modèle end-to-end pour la segmentation |
+| **U-Net** | Encoder-decoder avec skip connections | Excellent pour les détails fins, idéal pour les données limitées |
+| **SegNet** | Encoder-decoder avec pooling indices | Plus léger en mémoire que U-Net |
+| **DeepLab v3+** | Atrous convolutions + ASPP + encoder-decoder | State-of-the-art, capture multi-échelle |
+| **PSPNet** | Pyramid Pooling Module | Capture le contexte global |
+
+- **Why** : La note technique demande une "présentation des différentes approches et une synthèse de l'état de l'art". Tu dois comprendre les forces/faiblesses de chaque architecture pour justifier ton choix.
+- **Notions** : *encoder-decoder architecture*, *skip connections*, *atrous/dilated convolutions*, *feature pyramid*, *receptive field*.
+
+### 2.2 Étudier les métriques de segmentation
+
+| Métrique | Formule/Description |
+|----------|-------------------|
+| **Pixel Accuracy** | % de pixels correctement classifiés |
+| **Mean IoU (mIoU)** | Intersection over Union moyenné sur toutes les classes |
+| **Dice Coefficient** | 2×TP / (2×TP + FP + FN) |
+| **Per-class IoU** | IoU calculé pour chaque classe individuellement |
+
+- **Why** : Le pixel accuracy est trompeur sur des données déséquilibrées. Le mIoU est la métrique standard en segmentation sémantique et sera celle que l'évaluateur attend.
+- **Notions** : *IoU (Intersection over Union)*, *Dice score*, *confusion matrix* pixel-level, *mean IoU*.
+
+### 2.3 Étudier les loss functions adaptées
+
+- **Categorical Cross-Entropy** : Standard, mais sensible au class imbalance
+- **Weighted Cross-Entropy** : Pondération inversement proportionnelle à la fréquence de la classe
+- **Dice Loss** : Optimise directement le Dice Coefficient
+- **Focal Loss** : Réduit la contribution des exemples bien classifiés
+- **Combinaison** : Dice Loss + Cross-Entropy souvent utilisée en pratique
+
+- **Why** : Le choix de la loss function a un impact direct sur les performances, surtout avec des classes déséquilibrées (road vs rider).
+- **Notions** : *loss functions*, *class weighting*, *focal loss*, *dice loss*.
+
+---
+
+## Phase 3 — Pipeline de Données
+
+### 3.1 Créer un Data Generator Keras
+
+```python
+class CityscapesGenerator(tf.keras.utils.Sequence):
+    def __init__(self, image_paths, mask_paths, batch_size, img_size, augment=False):
+        ...
+    def __getitem__(self, idx):
+        # Charge batch d'images + masks
+        # Remapping 32 → 8 catégories
+        # Resize
+        # Augmentation (si train)
+        # One-hot encoding du mask
+        ...
+```
+
+- **Why** : Les images Cityscapes (1024×2048) sont trop volumineuses pour tout charger en RAM. Un generator charge les données par batch à la volée. C'est un critère du livrable ("caractère industrialisable").
+- **Notions** : `tf.keras.utils.Sequence`, *batch loading*, *lazy loading*, *one-hot encoding* de masks, *yield* vs *return*.
+
+### 3.2 Implémenter le label remapping (32 → 8 catégories)
+
+```python
+# Dictionnaire de mapping utilisant la documentation Cityscapes
+LABEL_TO_CATEGORY = {
+    0: 0, 1: 0, 2: 0, 3: 0, 4: 0, 5: 0, 6: 0,   # void
+    7: 1, 8: 1, 9: 1, 10: 1,                       # flat
+    11: 2, 12: 2, 13: 2, 14: 2, 15: 2, 16: 2,      # construction
+    17: 3, 18: 3, 19: 3, 20: 3,                     # object
+    21: 4, 22: 4,                                    # nature
+    23: 5,                                           # sky
+    24: 6, 25: 6,                                    # human
+    26: 7, 27: 7, 28: 7, 29: 7, 30: 7, 31: 7, 32: 7, 33: 7  # vehicle
+}
+```
+
+- **Why** : Franck (le collègue en charge du traitement d'images) a spécifié que seules les 8 catégories principales sont nécessaires. Ce remapping doit être fait dans le pipeline de données, pas manuellement.
+- **Notions** : *label encoding*, *numpy vectorized mapping* (`np.vectorize` ou table de lookup), correspondance Cityscapes.
+
+### 3.3 Implémenter l'augmentation de données
+
+Techniques à appliquer :
+- **Flip horizontal** (le plus commun pour la conduite)
+- **Rotation légère** (±10°)
+- **Variations de luminosité/contraste**
+- **Random crop + resize**
+- **Ajout de bruit gaussien**
+
+> ⚠️ 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*.
+
+### 3.4 Gérer le redimensionnement des images
+
+Réduire les images de 1024×2048 à une taille gérable :
+- **256×512** : bon compromis vitesse/qualité pour les premiers tests
+- **512×1024** : meilleure résolution si ressources GPU suffisantes
+
+- **Why** : Les images originales sont très grandes. Entraîner en pleine résolution nécessite un GPU puissant (32+ Go VRAM). Le redimensionnement est un compromis nécessaire.
+- **Notions** : *image resizing*, interpolation bilinéaire vs nearest-neighbor (pour les masks !), *aspect ratio preservation*.
+
+---
+
+## Phase 4 — Entraînement du Modèle
+
+### 4.1 Commencer avec un modèle simple (baseline)
+
+Entraîner un U-Net simple depuis zéro comme baseline :
+- Encoder : blocs Conv2D + BatchNorm + ReLU + MaxPool
+- Decoder : UpSampling2D + Concatenate (skip connections) + Conv2D
+- Sortie : Conv2D(8, (1,1), activation='softmax')
+
+- **Why** : Un modèle simple permet de valider que tout le pipeline fonctionne (data loading, training loop, évaluation) avant d'investir du temps dans des architectures plus complexes.
+- **Notions** : *U-Net architecture*, *encoder-decoder*, *skip connections*, *softmax pour classification multi-classe pixel-level*.
+
+### 4.2 Utiliser le Transfer Learning
+
+Utiliser un backbone pré-entraîné sur ImageNet :
+- **MobileNetV2** : léger, idéal pour l'embarqué
+- **ResNet50** : bon compromis performance/poids
+- **EfficientNet** : état de l'art en efficacité
+
+```python
+base_model = tf.keras.applications.MobileNetV2(input_shape=(256, 512, 3), include_top=False, weights='imagenet')
+```
+
+- **Why** : Le transfer learning permet d'obtenir de bien meilleures performances avec moins de données et moins de temps d'entraînement. Les features bas-niveau (contours, textures) apprises sur ImageNet sont transférables.
+- **Notions** : *transfer learning*, *feature extraction vs fine-tuning*, *backbone freezing/unfreezing*, `keras.applications`.
+
+### 4.3 Implémenter un modèle avancé (DeepLab v3+ ou similaire)
+
+Options :
+- Utiliser `segmentation_models` library : `pip install segmentation-models`
+- Implémenter DeepLab v3+ manuellement avec Keras
+- Utiliser TensorFlow Hub pour charger un modèle pré-entraîné
+
+- **Why** : La comparaison entre un modèle simple (baseline) et un modèle avancé est attendue dans la note technique. DeepLab v3+ est souvent le meilleur choix pour Cityscapes.
+- **Notions** : *ASPP (Atrous Spatial Pyramid Pooling)*, *dilated convolutions*, *multi-scale feature extraction*.
+
+### 4.4 Configurer l'entraînement
+
+```python
+model.compile(
+    optimizer=tf.keras.optimizers.Adam(learning_rate=1e-4),
+    loss='categorical_crossentropy',  # ou dice_loss + CE combinée
+    metrics=['accuracy', MeanIoU(num_classes=8)]
+)
+
+callbacks = [
+    tf.keras.callbacks.ModelCheckpoint('best_model.keras', save_best_only=True, monitor='val_mean_iou', mode='max'),
+    tf.keras.callbacks.EarlyStopping(patience=10, monitor='val_mean_iou', mode='max'),
+    tf.keras.callbacks.ReduceLROnPlateau(factor=0.5, patience=5),
+    tf.keras.callbacks.TensorBoard(log_dir='./logs')
+]
+```
+
+- **Why** : Les callbacks automatisent la sauvegarde du meilleur modèle, l'arrêt précoce (évite l'overfitting), et l'ajustement du learning rate. C'est une démarche professionnelle.
+- **Notions** : *callbacks Keras*, *early stopping*, *learning rate scheduling*, *model checkpointing*, *TensorBoard*.
+
+### 4.5 Entraîner et comparer les modèles
+
+Pour chaque modèle, documenter :
+- Architecture utilisée
+- Hyperparamètres (lr, batch size, epochs, augmentation)
+- Courbes train/val loss et mIoU
+- Per-class IoU sur le validation set
+- Prédictions visuelles (image / ground truth / prédiction)
+
+- **Why** : La soutenance demande la "comparaison des modèles" (10 min dédiées). Tu dois montrer une démarche itérative et justifier le modèle final retenu.
+- **Notions** : *hyperparameter tuning*, *learning curves analysis*, *overfitting vs underfitting diagnosis*, *model selection*.
+
+### 4.6 Évaluer sur le jeu de test
+
+Calculer les métriques finales sur le test set (Berlin, Bielefeld, Bonn, Leverkusen, Mainz, Munich) :
+- mIoU global
+- IoU par classe
+- Matrice de confusion pixel-level
+- Visualisations qualitatives
+
+- **Why** : L'évaluation sur le test set (jamais vu pendant l'entraînement) donne une estimation non biaisée des performances. C'est la norme en ML.
+- **Notions** : *train/val/test split*, *generalization*, *qualitative vs quantitative evaluation*.
+
+---
+
+## Phase 5 — Développement de l'API de Prédiction
+
+### 5.1 Choisir entre Flask et FastAPI
+
+| Critère | Flask | FastAPI |
+|---------|-------|---------|
+| 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.
+
+- **Why** : Laura veut une "API simple à utiliser". FastAPI génère automatiquement une documentation interactive (Swagger UI) qui permet de tester l'API sans code client.
+- **Notions** : *REST API*, *endpoints*, *HTTP methods* (POST), *content types* (multipart/form-data, JSON).
+
+### 5.2 Concevoir l'endpoint de prédiction
+
+```python
+from fastapi import FastAPI, File, UploadFile
+import numpy as np
+from PIL import Image
+import io
+
+app = FastAPI(title="Cityscapes Segmentation API")
+
+# Charger le modèle au démarrage
+model = tf.keras.models.load_model('best_model.keras')
+
+@app.post("/predict")
+async def predict(file: UploadFile = File(...)):
+    # 1. Lire l'image uploadée
+    image = Image.open(io.BytesIO(await file.read()))
+    # 2. Prétraiter (resize, normalisation)
+    # 3. Prédire le mask
+    # 4. Post-traiter (argmax, resize au format original)
+    # 5. Retourner le mask (encodé en base64 ou en JSON)
+    return {"mask": mask_as_list, "classes": class_names}
+```
+
+- **Why** : Cet endpoint est le cœur du livrable 2. Il prend une image et retourne le mask prédit. Il sera consommé par l'application web (livrable 3).
+- **Notions** : *API endpoint design*, *image I/O* (bytes → PIL → numpy), *model inference pipeline*, *base64 encoding*.
+
+### 5.3 Ajouter des endpoints utilitaires
+
+- `GET /` : Infos sur l'API (version, modèle utilisé, classes)
+- `GET /health` : Health check
+- `GET /classes` : Liste des 8 catégories et leurs couleurs
+
+- **Why** : Des endpoints d'information facilitent l'intégration et le monitoring. C'est une bonne pratique d'architecture API.
+- **Notions** : *API design patterns*, *health checks*, *API versioning*.
+
+### 5.4 Tester l'API en local
+
+```bash
+uvicorn api.main:app --reload --host 0.0.0.0 --port 8000
+# Tester sur http://localhost:8000/docs (Swagger UI)
+```
+
+- **Why** : Toujours tester en local avant de déployer. La Swagger UI permet de tester visuellement l'upload d'image et la réponse.
+- **Notions** : *local development server*, *API testing*, *Swagger/OpenAPI*.
+
+---
+
+## Phase 6 — Développement de l'Application Web
+
+### 6.1 Concevoir l'application Streamlit (ou Flask)
+
+L'application doit permettre :
+1. **Afficher la liste des IDs** des images disponibles (test set)
+2. **Sélectionner un ID** → lancer la prédiction via l'API
+3. **Afficher 3 images côte à côte** : image réelle | mask réel | mask prédit
+
+```python
+import streamlit as st
+import requests
+
+st.title("🚗 Segmentation d'Images - Future Vision Transport")
+
+# Liste des images disponibles
+image_ids = get_available_image_ids()
+selected_id = st.selectbox("Sélectionner une image :", image_ids)
+
+if st.button("Lancer la prédiction"):
+    # Appel à l'API
+    response = requests.post(API_URL + "/predict", files={"file": image_bytes})
+    predicted_mask = decode_response(response.json())
+    
+    col1, col2, col3 = st.columns(3)
+    col1.image(original_image, caption="Image réelle")
+    col2.image(ground_truth_mask, caption="Mask réel")
+    col3.image(predicted_mask, caption="Mask prédit")
+```
+
+- **Why** : Cette application est l'interface de démonstration (livrable 3). Elle doit consommer l'API, pas faire la prédiction directement — cela prouve que l'architecture est bien découplée.
+- **Notions** : *Streamlit*, *API consumption* (`requests`), *image display*, *UI/UX pour une démo*, *client-server architecture*.
+
+### 6.2 Ajouter des fonctionnalités bonus
+
+- Palette de couleurs pour les classes (légende)
+- Overlay du mask sur l'image originale (transparence)
+- Métriques affichées (IoU par classe vs ground truth)
+- Upload d'une image personnelle (pas du dataset)
+
+- **Why** : Ces fonctionnalités impressionnent l'évaluateur et montrent une maîtrise au-delà du minimum requis.
+- **Notions** : *image compositing*, *alpha blending*, *color mapping*.
+
+---
+
+## Phase 7 — Déploiement sur le Cloud
+
+### 7.1 Choisir une plateforme Cloud
+
+| Plateforme | Coût | Difficulté | GPU |
+|-----------|------|-----------|-----|
+| **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é) | ⭐ | ❌ |
+| **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é.
+- **Notions** : *cloud deployment*, *PaaS vs IaaS*, *containerization concepts*.
+
+### 7.2 Containeriser avec Docker
+
+```dockerfile
+# API
+FROM python:3.10-slim
+WORKDIR /app
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+COPY . .
+EXPOSE 8000
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]
+```
+
+- **Why** : Docker garantit que l'environnement est identique en local et en production. La plupart des plateformes Cloud supportent Docker nativement.
+- **Notions** : *Docker*, *Dockerfile*, *containers vs VMs*, *image build*, *port mapping*.
+
+### 7.3 Déployer l'API et l'application
+
+Deux déploiements séparés :
+1. **API** : déploiement du service de prédiction
+2. **App web** : déploiement de l'interface Streamlit (pointe vers l'URL de l'API)
+
+- **Why** : Séparer l'API de l'application web est une architecture microservices. Cela prouve la modularité de ton système.
+- **Notions** : *microservices architecture*, *environment variables* pour l'URL de l'API, *CORS configuration*.
+
+### 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.
+
+- **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.
+
+---
+
+## Phase 8 — Rédaction de la Note Technique (~10 pages)
+
+### 8.1 Structure recommandée
+
+| Section | Contenu | ~Pages |
+|---------|---------|--------|
+| **1. Introduction** | Contexte (Future Vision Transport), objectifs, contraintes | 1 |
+| **2. État de l'Art** | Revue des architectures (FCN, U-Net, SegNet, DeepLab), métriques | 2 |
+| **3. Dataset et Préparation** | Cityscapes, 8 catégories, EDA, augmentation | 1.5 |
+| **4. Modèle Retenu** | Architecture détaillée, hyperparamètres, justification du choix | 2 |
+| **5. Résultats** | Comparaison des modèles, mIoU, courbes, gains de l'augmentation | 2 |
+| **6. Mise en Production** | Architecture API + App, déploiement Cloud | 1 |
+| **7. Conclusion** | Bilan, limites, pistes d'amélioration | 0.5 |
+
+- **Why** : La note technique est un livrable clé (livrable 4). Elle doit démontrer ta rigueur scientifique et ta capacité à synthétiser.
+- **Notions** : *technical writing*, *scientific methodology*, *results presentation*.
+
+### 8.2 Points clés à inclure
+
+- **Comparaison explicite** des modèles (tableau mIoU)
+- **Gains de l'augmentation** : comparer modèle sans augmentation vs avec
+- **Visualisations** : courbes de loss, exemples de prédictions, matrice de confusion
+- **Pistes d'amélioration** : Real-time inference, quantization, pruning, TensorRT
+
+- **Why** : Ces éléments sont explicitement demandés dans le descriptif des livrables.
+- **Notions** : *ablation study*, *model comparison*, *scientific rigor*.
+
+---
+
+## Phase 9 — Support de Présentation (max 30 slides)
+
+### 9.1 Structure calquée sur le timing de soutenance
+
+| Bloc | Durée | Slides | Contenu |
+|------|-------|--------|---------|
+| **Contexte & Objectifs** | 5 min | 5-7 | Entreprise, chaîne de vision, ton rôle, métriques |
+| **Modèles & Résultats** | 10 min | 12-15 | Architectures, comparaisons, visualisations, augmentation |
+| **Mise en Production** | 5 min | 5-8 | Architecture API/App, déploiement, démo live |
+
+- **Why** : La soutenance est strictement chronométrée (20 min ±5). Une présentation trop courte (<15 min) ou trop longue (>25 min) peut être refusée.
+- **Notions** : *presentation skills*, *storytelling technique*, *demo preparation*.
+
+### 9.2 Préparer la démo live
+
+Préparer un script de démo :
+1. Ouvrir l'application web déployée
+2. Sélectionner une image du test set
+3. Lancer la prédiction
+4. Montrer image / mask réel / mask prédit côte à côte
+5. Éventuellement tester avec une image uploadée
+
+> Tester la démo **plusieurs fois avant** la soutenance !
+
+- **Why** : La démo est le moment fort de la soutenance. Un bug en live est très pénalisant. Prépare aussi des screenshots de backup au cas où le Cloud tombe.
+- **Notions** : *demo rehearsal*, *fallback plan*.
+
+---
+
+## ✅ Checklist des Livrables
+
+| # | Livrable | Format | Nommage |
+|---|----------|--------|---------|
+| 1 | **Scripts/Notebooks** (pipeline complet) | `.ipynb` / `.py` | `Nom_Prénom_1_scripts_mmaaaa` |
+| 2 | **API de prédiction** (déployée sur le Cloud) | Flask/FastAPI | `Nom_Prénom_2_API_mmaaaa` |
+| 3 | **Application web** (déployée sur le Cloud) | Streamlit/Flask | `Nom_Prénom_3_application_Flask_mmaaaa` |
+| 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`.
+
+---
+
+## 🎯 Notions Clés à Maîtriser (Résumé)
+
+| Domaine | Notions |
+|---------|---------|
+| **Computer Vision** | Semantic segmentation, encoder-decoder, skip connections, dilated convolutions |
+| **Deep Learning** | Transfer learning, data augmentation, loss functions (Dice, Focal, CE), callbacks |
+| **Keras/TensorFlow** | `tf.keras.utils.Sequence`, `keras.applications`, custom training loops, `MeanIoU` |
+| **MLOps** | Docker, API REST, déploiement Cloud, CI/CD basique |
+| **Data Engineering** | Data generators, label remapping, preprocessing pipelines |
+| **Évaluation** | mIoU, Dice, pixel accuracy, confusion matrix, per-class metrics |
+| **Communication** | Note technique, présentation de résultats, démo live |

mlflow.db

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

models/best_unet_model.keras

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

mon_avancement.md

@@ -0,0 +1,38 @@
+# Avancement au 20/03/2026
+
+## Objectif actuel
+
+
+## Avancement
+
+
+## Prochaines étapes
+
+Remapper les 32 sous catégories de Cityscapes en 8 catégories
+
+Faire une EDA:
+    Dans un notebook, afficher côte à côte :
+    - L'image brute
+    - Le mask coloré (gtFine_color)
+    - Le mask labelIds remappé vers les 8 catégories
+    - Distribution des classes par image (histogrammes)
+
+Faire tourner le google colab https://colab.research.google.com/drive/1jZ2tdEyJ2xaERUCwyQ5juwPJrEyIAtBN?usp=sharing#scrollTo=O9oKKrUPQD9s
+L'objectif est juste d'obtenir un modèle où la segmentation est correcte.
+Mettre le modèle dans l'api et le déployer.
+
+Faire des tests unitaires dans le projet 7
+Mettre de l'argent pour upgrade le projet 7 et faire tourner l'app, ou essayer dans render
+
+Entrainement du modèle
+Affichage des résultats
+Il faut que j'ai la segmentation et que mon modèle puisse renvoyer les images.
+
+
+Parler de l'augmentation des données. Quand j'ai mes images de voiture, je les pivote, etc pour augementer mes images pour l'entrainement.
+Parler du modèle. Expliquer ce qu'est le U-net. Qu'estce que qui se passe et comment ça se passe.
+Comment j'ai pu faire avec le transfer-learning
+Parler des différents modèles et comparer leurs résultats.
+Insister sur le github. Comment j'ai fait mon github, comment je le link avec render. Comment je le link avec streamlit et vérifier les résultats visuellement.
+Parler du CI/CD
+Parler de la FASTAPPi

requirements.txt

@@ -0,0 +1,12 @@
+fastapi
+uvicorn
+python-multipart
+tensorflow
+pandas
+numpy
+pillow
+streamlit
+albumentations
+matplotlib
+scipy
+azure-monitor-opentelemetry

resume_execution_notebook.md

@@ -0,0 +1,41 @@
+# Synthèse de l'Exécution du Notebook (MobileNetV2-UNet)
+
+Ce document résume les actions effectuées par Gemini CLI pour adapter et exécuter localement le notebook Colab trouvé sur internet (`Copie_de_p08_david_scanu_notebook_MobileNetV2_UNet.ipynb`), ainsi que les résultats produits par cette exécution.
+
+## 1. Contexte et Objectif
+
+Le but était de prendre un notebook Google Colab conçu pour l'entraînement d'un modèle de segmentation sémantique (architecture MobileNetV2-UNet sur le jeu de données Cityscapes) et de l'exécuter de bout en bout sur l'environnement local.
+
+## 2. Fichiers de configuration et d'adaptation créés
+
+Pour rendre le notebook exécutable localement (hors de l'environnement Google Colab) et de manière automatisée, Gemini CLI a généré plusieurs scripts Python "patch" pour modifier le code du notebook à la volée :
+
+*   **`fix_colab.py`** : A commenté toutes les lignes spécifiques à Google Colab (comme `import google.colab` ou `drive.mount`), qui auraient provoqué des erreurs en local.
+*   **`patch_notebook.py`** : A remplacé le long processus de téléchargement du véritable jeu de données Cityscapes par une fonction générant un **jeu de données fictif (mock)**. Cela a permis de tester l'intégralité du pipeline (de l'entraînement à l'évaluation) très rapidement sans devoir télécharger des gigaoctets de données.
+*   **`fix_epochs.py`** : A probablement réduit le nombre d'époques d'entraînement (epochs) pour accélérer l'exécution du test de bout en bout.
+*   **`fix_paths.py` / `patch_train.py` / `patch_image.py`** : Ont servi à corriger les chemins de fichiers et d'autres petits détails d'implémentation pour s'assurer que le notebook puisse tourner correctement sur votre machine.
+*   **`notebook_script.py`** : Le code Python final, extrait du notebook, prêt à être exécuté.
+
+## 3. Résultats et Fichiers Générés (Outputs)
+
+L'exécution du notebook a généré une arborescence complète de résultats, principalement documentée dans le fichier `outputs_summary.md` :
+
+*   **Modèles Entraînés (`content/experiments/.../models/`) :**
+    *   `cityscapes_segmentation_model.keras` : Le modèle complet de fin d'entraînement.
+    *   `checkpoints/best_model.keras` : Le meilleur modèle sauvegardé en cours de route (celui à utiliser pour les prédictions).
+    *   `class_mapping.json` : Le dictionnaire qui associe les classes prédites (IDs) à leurs couleurs et noms (ex: "route", "voiture").
+*   **Métriques et Évaluation (`content/experiments/.../results/`) :**
+    *   Des fichiers CSV et JSON contenant l'IoU par classe, la matrice de confusion, le rapport de classification et l'historique d'entraînement.
+*   **Visualisations (`content/experiments/.../visualizations/`) :**
+    *   Des graphiques de l'historique d'entraînement (Loss/Accuracy), la matrice de confusion visuelle, et surtout des images comparant l'image originale, le vrai masque, et la prédiction du modèle.
+*   **Suivi MLflow (`mlruns/`) :**
+    *   Une base de données locale MLflow stockant les hyperparamètres de l'expérience et ses métriques.
+
+## 4. Prochaines Étapes : Déploiement
+
+Gemini a également généré un fichier `Next_step.md` qui explique comment exploiter ces résultats dans la suite de votre projet :
+
+*   **Intégration Streamlit :** Il fournit le code (boilerplate) nécessaire pour charger le `best_model.keras` et le `class_mapping.json` dans votre application `app.py`. Le modèle est capable de prendre une image uploadée et de renvoyer un masque segmenté coloré.
+*   **Déploiement sur Render :** Des mises en garde importantes y sont précisées :
+    *   Gérer la taille du modèle (76 MB), qui passe sur Git classique mais qui, s'il était plus gros, nécessiterait Git LFS.
+    *   Faire attention à la limite de RAM (512 MB) du niveau gratuit de Render, TensorFlow étant très gourmand. Il est conseillé d'utiliser `tensorflow-cpu` dans le `requirements.txt` pour éviter les crashs "Out of Memory" (OOM).

tests/test_api.py

@@ -0,0 +1,79 @@
+import requests
+import urllib.parse
+import pandas as pd
+
+# 1. Define your base API URL
+base_url = "https://predictionsentiments-azepf7eme8dvftaa.francecentral-01.azurewebsites.net/feeling_predictions/"
+# URL locale pour MLFlow
+#base_url = "http://127.0.0.1:8000/feeling_predictions/"
+
+# 2. Define a list of 10 different sentences (mixing happy and sad to test your model)
+sentences = [
+    "I just got a promotion at work and I am thrilled!",
+    "My dog passed away yesterday and my heart is broken.",
+    "The weather is absolutely beautiful today, I love it.",
+    "I failed my math exam despite studying all night.",
+    "We had a wonderful family dinner with lots of laughs.",
+    "I feel so lonely and isolated in this new city.",
+    "Winning the championship was the best moment of my life.",
+    "My flight got canceled and I missed my best friend's wedding.",
+    "I am enjoying a nice, relaxing cup of coffee by the window.",
+    "Everything is going wrong today and I just want to cry."
+]
+
+# 3. Initialize an empty list to store all the results
+all_results = []
+
+headers = {"accept": "application/json"}
+
+print("Starting predictions...\n")
+
+# 4. Loop through each sentence in the list
+for text in sentences:
+    # URL-encode the sentence safely
+    encoded_text = urllib.parse.quote(text)
+    full_url = f"{base_url}{encoded_text}"
+    
+    try:
+        # Call the API
+        response = requests.get(full_url, headers=headers)
+        response.raise_for_status() # Check for HTTP errors like 500 or 404
+        
+        # Parse the JSON response {"text": "...", "feeling_result": "..."}
+        api_data = response.json()
+        
+        # Extract the prediction
+        prediction = api_data.get("feeling_result")
+        
+        # Store the success result in our list as a dictionary
+        all_results.append({
+            "sentence": text,
+            "prediction": prediction,
+            "status": "success"
+        })
+        
+        print(f"Processed: '{text[:30]}...' -> {prediction.upper()}")
+        
+    except requests.exceptions.RequestException as e:
+        print(f"Error processing '{text[:30]}...': {e}")
+        
+        # If there is an error, we still store it so we don't lose track
+        all_results.append({
+            "sentence": text,
+            "prediction": "ERROR",
+            "status": str(e)
+        })
+
+print("\n--- All 10 requests completed! ---")
+
+# 5. Display and save the stored results
+# Converting the list of dictionaries into a Pandas DataFrame is the easiest way to handle the data
+df_results = pd.DataFrame(all_results)
+
+print("\nHere is your final data table:")
+print(df_results)
+
+# Save the results to a CSV file in your folder
+csv_filename = "api_predictions_results.csv"
+df_results.to_csv(csv_filename, index=False, encoding="utf-8")
+print(f"\nResults have been successfully saved to '{csv_filename}'.")