Update src/streamlit_app_stable.py

src/streamlit_app_stable.py

@@ -4,12 +4,12 @@ import io
 from PIL import Image
 import requests
 import torch
-import gc
+import gc  # Garbage Collector pour libérer la mémoire
 import time
 import sys
 import psutil
 
-# Configuration de la page Streamlit
+# --- Configuration de la page Streamlit ---
 st.set_page_config(
     page_title="AgriLens AI - Analyse de Plantes",
     page_icon="🌱",
@@ -17,7 +17,8 @@ st.set_page_config(
     initial_sidebar_state="expanded"
 )
 
-# Initialisation des variables de session pour maintenir l'état de l'application
+# --- Initialisation des variables de session ---
+# Ces variables maintiennent l'état de l'application entre les interactions utilisateur.
 if 'model_loaded' not in st.session_state:
     st.session_state.model_loaded = False
 if 'model' not in st.session_state:
@@ -40,48 +41,55 @@ if 'device' not in st.session_state:
 def check_model_health():
     """Vérifie si le modèle et le processeur sont correctement chargés et opérationnels."""
     try:
+        # Vérifie si les objets existent et si le modèle a bien un attribut 'device' (indiquant une initialisation)
         return (st.session_state.model is not None and
                 st.session_state.processor is not None and
                 hasattr(st.session_state.model, 'device'))
-    except Exception:
+    except Exception: # Capture toute exception qui pourrait survenir (ex: modèle corrompu)
         return False
 
 def diagnose_loading_issues():
-    """Diagnostique les problèmes potentiels (RAM, disque, connexion, GPU) avant le chargement du modèle."""
+    """
+    Diagnostique les problèmes potentiels avant le chargement du modèle,
+    en se concentrant sur les contraintes d'un environnement Hugging Face Spaces CPU.
+    """
     issues = []
     
     try:
         ram = psutil.virtual_memory()
         ram_gb = ram.total / (1024**3)
-        # 16GB est le minimum pour Gemma 3n sur CPU. Le Space 'basic' a 16GB.
-        # Tout ce qui est en dessous de 15GB libre est un risque.
-        if ram_gb < 15: # Ajusté pour être plus réaliste pour le CPU basic
-            issues.append(f"⚠️ RAM faible: {ram_gb:.1f}GB (minimum requis: 15GB pour ce modèle sur CPU)")
+        # Pour Gemma 3n, 16GB est le minimum SYNDICAT, et souvent insuffisant sur un CPU.
+        # Si le total est vraiment bas, cela alerte.
+        if ram_gb < 15: 
+            issues.append(f"⚠️ RAM faible: {ram_gb:.1f}GB (minimum requis: 15GB pour ce modèle sur CPU, mais 16GB total peut être juste).")
     except Exception as e:
         issues.append(f"⚠️ Impossible de vérifier la RAM : {e}")
 
     try:
         disk_usage = psutil.disk_usage('/')
         disk_gb = disk_usage.free / (1024**3)
-        if disk_gb < 10: # Espace nécessaire pour le modèle et le cache
+        # Le modèle et le cache nécessitent plusieurs Go. 10GB libre est une bonne marge.
+        if disk_gb < 10: 
             issues.append(f"⚠️ Espace disque faible: {disk_gb:.1f}GB libre sur '/'")
     except Exception as e:
         issues.append(f"⚠️ Impossible de vérifier l'espace disque : {e}")
     
+    # Vérifie la connexion au Hugging Face Hub pour le téléchargement du modèle
     try:
-        requests.get("https://huggingface.co", timeout=5) # Vérifie la connexion au Hub HF
+        requests.get("https://huggingface.co", timeout=5)
     except requests.exceptions.RequestException:
-        issues.append("⚠️ Problème de connexion à Hugging Face Hub")
+        issues.append("⚠️ Problème de connexion à Hugging Face Hub. Le téléchargement du modèle pourrait échouer.")
     
     if torch.cuda.is_available():
         try:
             gpu_memory = torch.cuda.get_device_properties(0).total_memory / (1024**3)
-            if gpu_memory < 8: # Gemma 3n a besoin d'au moins 8GB VRAM pour fonctionner confortablement
+            # Gemma 3n requiert au moins 8GB VRAM pour fonctionner décemment
+            if gpu_memory < 8: 
                 issues.append(f"⚠️ GPU mémoire faible: {gpu_memory:.1f}GB (recommandé: 8GB+)")
         except Exception as e:
             issues.append(f"⚠️ Erreur lors de la vérification de la mémoire GPU : {e}")
     else:
-        issues.append("ℹ️ CUDA non disponible - Le modèle fonctionnera sur CPU (très lentement et potentiellement avec des erreurs de mémoire)")
+        issues.append("ℹ️ CUDA non disponible. Le modèle fonctionnera sur CPU (très lentement et potentiellement avec des erreurs de mémoire).")
     
     return issues
 
@@ -89,6 +97,7 @@ def resize_image_if_needed(image, max_size=(1024, 1024)):
     """Redimensionne l'image si ses dimensions dépassent max_size pour optimiser l'entrée du modèle."""
     original_size = image.size
     if image.size[0] > max_size[0] or image.size[1] > max_size[1]:
+        # Utilise LANCZOS pour une meilleure qualité lors du redimensionnement
         image.thumbnail(max_size, Image.Resampling.LANCZOS)
         return image, True
     return image, False
@@ -109,7 +118,7 @@ def t(key):
     """Gère les traductions pour l'interface utilisateur."""
     translations = {
         "fr": {
-            "title": "🌱 AgriLens AI - Analyse de Plantes",
+            "title": "🌱 AgriLens AI - Assistant d'Analyse de Plantes",
             "subtitle": "Analysez vos plantes avec l'IA pour détecter les maladies",
             "tabs": ["📸 Analyse d'Image", "📝 Analyse de Texte", "⚙️ Configuration", "ℹ️ À Propos"],
             "image_analysis_title": "📸 Analyse d'Image de Plante",
@@ -141,7 +150,8 @@ def t(key):
     }
     return translations[st.session_state.language].get(key, key)
 
-# --- Constantes pour le modèle (ID et chemins locaux) ---
+# --- Fonctions de chargement et d'analyse du modèle ---
+
 MODEL_ID_LOCAL = "D:/Dev/model_gemma" # Chemin local pour votre machine (sera ignoré sur HF Spaces)
 MODEL_ID_HF = "google/gemma-3n-E4B-it" # ID du modèle sur Hugging Face Hub
 
@@ -158,13 +168,14 @@ def load_model():
     """
     Charge le modèle Gemma 3n et son processeur associé.
     Tente d'abord le chargement depuis un dossier local, puis depuis Hugging Face Hub.
-    Comprend des optimisations pour la gestion de la mémoire.
+    Comprend des optimisations pour la gestion de la mémoire, critiques pour les environnements CPU limités.
     """
     try:
-        # Importe les classes de transformers ici pour un chargement paresseux et optimisé de la mémoire
+        # Importe les classes de transformers ici pour un chargement paresseux (lazy loading)
+        # Cela réduit l'empreinte mémoire initiale du script avant même que le modèle ne soit chargé.
         from transformers import AutoProcessor, Gemma3nForConditionalGeneration
         
-        # Limite le nombre de tentatives de chargement pour éviter des boucles infinies
+        # Limite le nombre de tentatives de chargement pour éviter des boucles infinies en cas de problème persistant
         if st.session_state.load_attempt_count >= 3:
             st.error("❌ Trop de tentatives de chargement ont échoué. Veuillez vérifier votre configuration et redémarrer l'application.")
             return None, None
@@ -177,16 +188,17 @@ def load_model():
                 for issue in issues:
                     st.write(issue)
         
-        # Libère la mémoire du Garbage Collector de Python et le cache GPU (si applicable)
-        gc.collect() 
+        # Libère la mémoire autant que possible
+        gc.collect() # Force le ramasse-miettes de Python
         if torch.cuda.is_available():
-            torch.cuda.empty_cache() 
+            torch.cuda.empty_cache() # Vide le cache GPU s'il existe
 
         processor = None
         model = None
-        device_map = get_device_map() # Détermine si le GPU ou le CPU sera utilisé
+        device_map = get_device_map() # Détermine le device_map ("auto" ou "cpu")
 
-        # Vérifie si le modèle est disponible localement et complet
+        # Stratégie de chargement : Tente d'abord en local, puis depuis Hugging Face Hub
+        # Vérifie si le dossier local existe et contient un fichier de configuration pour s'assurer qu'il s'agit d'un modèle complet
         local_model_found = os.path.exists(MODEL_ID_LOCAL) and os.path.exists(os.path.join(MODEL_ID_LOCAL, "config.json"))
 
         if local_model_found:
@@ -195,18 +207,18 @@ def load_model():
                 processor = AutoProcessor.from_pretrained(MODEL_ID_LOCAL, trust_remote_code=True)
                 model = Gemma3nForConditionalGeneration.from_pretrained(
                     MODEL_ID_LOCAL,
-                    # Utilise bfloat16 pour le GPU (plus rapide, moins de mémoire), float32 pour le CPU (compatibilité)
+                    # Utilise bfloat16 pour le GPU (si disponible), sinon float32 pour le CPU (meilleure compatibilité et moins de risques sur CPU limité)
                     torch_dtype=torch.bfloat16 if device_map == "auto" else torch.float32, 
                     trust_remote_code=True,
-                    low_cpu_mem_usage=True, # Tente de réduire la consommation de RAM CPU pendant le chargement
-                    device_map=device_map # Le mapping du périphérique (GPU ou CPU)
+                    low_cpu_mem_usage=True, # Option cruciale pour réduire la consommation de RAM CPU lors du chargement
+                    device_map=device_map # Applique le mapping du périphérique détecté (GPU ou CPU)
                 )
                 st.success("✅ Modèle chargé avec succès depuis le dossier local.")
                 st.session_state.model_status = "Chargé (Local)"
             except Exception as e:
                 st.warning(f"⚠️ Échec du chargement depuis le local ({e}). Tentative depuis Hugging Face Hub...")
         
-        # Si le modèle n'a pas été chargé localement ou si le chargement local a échoué, tente depuis Hugging Face Hub
+        # Si le modèle n'a pas été chargé localement (ou si le chargement local a échoué), tente depuis Hugging Face Hub
         if model is None: 
             try:
                 st.info(f"Chargement du modèle depuis Hugging Face Hub : {MODEL_ID_HF}...")
@@ -222,14 +234,15 @@ def load_model():
                 st.session_state.model_status = "Chargé (Hub)"
             except Exception as e:
                 st.error(f"❌ Échec du chargement du modèle depuis Hugging Face Hub : {e}")
-                return None, None # Échec final, le modèle n'a pas pu être chargé
+                # Si le chargement échoue, même depuis le Hub, retourne None pour signaler l'échec.
+                return None, None 
         
-        # Met à jour les variables de session si le modèle a été chargé avec succès
+        # Met à jour les variables de session avec le modèle et le processeur chargés
         st.session_state.model = model
         st.session_state.processor = processor
         st.session_state.model_loaded = True
         st.session_state.model_load_time = time.time()
-        st.session_state.load_attempt_count = 0 # Réinitialise le compteur après un chargement réussi
+        st.session_state.load_attempt_count = 0 # Réinitialise le compteur après un succès
         
         return model, processor
 
@@ -237,28 +250,28 @@ def load_model():
         st.error("❌ Erreur : Les bibliothèques `transformers` ou `torch` ne sont pas installées. Veuillez vérifier votre `requirements.txt`.")
         return None, None
     except Exception as e:
-        # Capture toutes les autres exceptions non spécifiques à l'import (ex: OOM lors du chargement)
+        # Capture toutes les autres exceptions potentielles (ex: OOM, erreurs de configuration)
         st.error(f"❌ Erreur générale lors du chargement du modèle : {e}")
         return None, None
 
-# --- Fonctions d'analyse (Image et Texte) ---
-
 def analyze_image_multilingual(image, prompt_text=""):
     """
     Analyse une image de plante en utilisant le modèle Gemma et un prompt personnalisé.
-    Retourne le résultat de l'analyse.
+    Retourne le résultat de l'analyse. Utilise `apply_chat_template` pour un formatage correct.
     """
-    # Vérifie que le modèle est bien chargé avant de tenter l'analyse
+    # Vérifie que le modèle est bien chargé et en bonne santé avant de procéder à l'analyse
     if not st.session_state.model_loaded or not check_model_health():
         st.error("❌ Modèle IA non chargé ou non fonctionnel. Veuillez le charger via la barre latérale.")
         return None
     
     try:
+        # S'assure que l'image est en format RGB, requis par la plupart des modèles
         if image.mode != 'RGB':
             image = image.convert('RGB')
         
         # Prépare le prompt textuel qui accompagnera l'image
         if not prompt_text:
+            # Prompt par défaut pour l'analyse d'image (sans le token <image> ici, il est géré par `messages`)
             user_text_prompt = """Analyse cette image de plante et fournis un diagnostic complet :
 1.  **État général de la plante :** Décris son apparence globale et sa vitalité.
 2.  **Identification des problèmes :** Liste les maladies, parasites ou carences visibles.
@@ -271,8 +284,7 @@ Réponds de manière structurée et claire en français."""
         else:
             user_text_prompt = prompt_text
 
-        # Utilise `processor.apply_chat_template` pour formater l'entrée multimodale (image + texte).
-        # Ceci est essentiel pour les modèles comme Gemma 3n.
+        # Structure le prompt en utilisant le format 'messages' attendu par `apply_chat_template`
         messages = [
             {
                 "role": "user",
@@ -283,26 +295,26 @@ Réponds de manière structurée et claire en français."""
             }
         ]
 
-        # Traite les messages en inputs tensoriels et les déplace sur le device du modèle
+        # Applique le chat template pour obtenir les inputs tokenisés. C'est crucial pour les modèles multimodaux.
         inputs = st.session_state.processor.apply_chat_template(
             messages,
             add_generation_prompt=True, # Indique au modèle de commencer à générer après ce prompt
             tokenize=True,
             return_dict=True,
             return_tensors="pt",
-        ).to(st.session_state.model.device)
+        ).to(st.session_state.model.device) # Déplace les inputs sur le device approprié (CPU ou GPU)
         
         # Génère la réponse du modèle
-        input_len = inputs["input_ids"].shape[-1] # Longueur du prompt encodé
+        input_len = inputs["input_ids"].shape[-1] # Récupère la longueur du prompt encodé
         with st.spinner("🔍 Analyse d'image en cours..."):
             outputs = st.session_state.model.generate(
                 **inputs,
-                max_new_tokens=512, # Limite la longueur de la réponse
-                do_sample=True,      # Active l'échantillonnage (réponses plus variées)
-                temperature=0.7,     # Contrôle le niveau de créativité/aléatoire
+                max_new_tokens=512, # Limite la longueur de la réponse générée
+                do_sample=True,      # Active l'échantillonnage pour des réponses plus variées
+                temperature=0.7,     # Contrôle le niveau de créativité/aléatoire de la génération
                 top_p=0.9            # Stratégie d'échantillonnage Top-P
             )
-            # Décode uniquement la partie générée par le modèle (exclut le prompt initial)
+            # Décode uniquement la partie générée par le modèle, en excluant le prompt initial
             generation = outputs[0][input_len:] 
             response = st.session_state.processor.decode(generation, skip_special_tokens=True)
             
@@ -315,14 +327,14 @@ Réponds de manière structurée et claire en français."""
 def analyze_text_multilingual(text_description):
     """
     Analyse une description textuelle des symptômes d'une plante en utilisant le modèle Gemma.
-    Retourne le diagnostic et les recommandations.
+    Retourne le diagnostic et les recommandations. Utilise `apply_chat_template`.
     """
     if not st.session_state.model_loaded or not check_model_health():
         st.error("❌ Modèle IA non chargé ou non fonctionnel. Veuillez le charger via la barre latérale.")
         return None
     
     try:
-        # Prépare le prompt textuel dans le format 'messages' pour `apply_chat_template`
+        # Prépare le prompt textuel dans le format 'messages' pour apply_chat_template
         messages = [
             {
                 "role": "user",
@@ -343,13 +355,14 @@ Réponds en français de manière claire et structurée."""}
             }
         ]
 
+        # Applique le chat template pour formater les inputs et les tokeniser
         inputs = st.session_state.processor.apply_chat_template(
             messages,
-            add_generation_prompt=True, # Important pour la génération
+            add_generation_prompt=True, # Indique au modèle de commencer à générer après le prompt
             tokenize=True,
             return_dict=True,
             return_tensors="pt",
-        ).to(st.session_state.model.device)
+        ).to(st.session_state.model.device) # Déplace les tensors sur le bon device
         
         input_len = inputs["input_ids"].shape[-1]
         with st.spinner("🔍 Analyse textuelle en cours..."):
@@ -418,7 +431,7 @@ with st.sidebar:
                 model_loaded_success = load_model()
                 if model_loaded_success[0] is not None and model_loaded_success[1] is not None:
                     st.success("✅ Modèle IA chargé avec succès !")
-                    # `st.rerun()` est généralement évité ici sur Spaces, car le redémarrage est géré par la plateforme.
+                    # `st.rerun()` peut être utile, mais sur Spaces, un redémarrage du Space est plus fiable.
                 else:
                     st.error("❌ Échec du chargement du modèle IA.")