Update src/streamlit_app_stable.py

src/streamlit_app_stable.py

@@ -8,9 +8,8 @@ import gc
 import time
 import sys
 import psutil
-# Les imports de transformers sont maintenant effectués dans load_model() pour une meilleure gestion
 
-# --- Configuration de la page ---
+# Configuration de la page Streamlit
 st.set_page_config(
     page_title="AgriLens AI - Analyse de Plantes",
     page_icon="🌱",
@@ -18,7 +17,7 @@ st.set_page_config(
     initial_sidebar_state="expanded"
 )
 
-# --- Initialisation des variables de session ---
+# Initialisation des variables de session pour maintenir l'état de l'application
 if 'model_loaded' not in st.session_state:
     st.session_state.model_loaded = False
 if 'model' not in st.session_state:
@@ -34,12 +33,12 @@ if 'language' not in st.session_state:
 if 'load_attempt_count' not in st.session_state:
     st.session_state.load_attempt_count = 0
 if 'device' not in st.session_state:
-    st.session_state.device = "cpu" # Valeur par défaut
+    st.session_state.device = "cpu" # Défaut à CPU, sera mis à jour si GPU disponible
 
-# --- Fonctions d'aide système ---
+# --- Fonctions d'aide système et diagnostic ---
 
 def check_model_health():
-    """Vérifie si le modèle et le processeur sont chargés et semblent opérationnels."""
+    """Vérifie si le modèle et le processeur sont correctement chargés et opérationnels."""
     try:
         return (st.session_state.model is not None and
                 st.session_state.processor is not None and
@@ -48,44 +47,46 @@ def check_model_health():
         return False
 
 def diagnose_loading_issues():
-    """Diagnostique les problèmes potentiels avant le chargement du modèle."""
+    """Diagnostique les problèmes potentiels (RAM, disque, connexion, GPU) avant le chargement du modèle."""
     issues = []
     
     try:
         ram = psutil.virtual_memory()
         ram_gb = ram.total / (1024**3)
-        if ram_gb < 8: # Recommandation générale pour les gros modèles
-            issues.append(f"⚠️ RAM faible: {ram_gb:.1f}GB (recommandé: 8GB+ pour ce modèle)")
+        # 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)")
     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 télécharger le modèle (environ 4-5Go pour Gemma 3n)
+        if disk_gb < 10: # Espace nécessaire pour le modèle et le cache
             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}")
     
     try:
-        requests.get("https://huggingface.co", timeout=5)
+        requests.get("https://huggingface.co", timeout=5) # Vérifie la connexion au Hub HF
     except requests.exceptions.RequestException:
         issues.append("⚠️ Problème de connexion à Hugging Face Hub")
     
     if torch.cuda.is_available():
         try:
             gpu_memory = torch.cuda.get_device_properties(0).total_memory / (1024**3)
-            if gpu_memory < 6: # Recommandation pour ce type de modèle multimodal
-                issues.append(f"⚠️ GPU mémoire faible: {gpu_memory:.1f}GB (recommandé: 6GB+)")
+            if gpu_memory < 8: # Gemma 3n a besoin d'au moins 8GB VRAM pour fonctionner confortablement
+                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 (lentement)")
+        issues.append("ℹ️ CUDA non disponible - Le modèle fonctionnera sur CPU (très lentement et potentiellement avec des erreurs de mémoire)")
     
     return issues
 
-def resize_image_if_needed(image, max_size=(1024, 1024)): # Augmenté pour une meilleure analyse si possible
-    """Redimensionne l'image si ses dimensions dépassent max_size."""
+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]:
         image.thumbnail(max_size, Image.Resampling.LANCZOS)
@@ -105,10 +106,10 @@ def afficher_ram_disponible(context=""):
 
 # --- Gestion des traductions ---
 def t(key):
-    """Fonction pour gérer les traductions."""
+    """Gère les traductions pour l'interface utilisateur."""
     translations = {
         "fr": {
-            "title": "🌱 AgriLens AI - Assistant d'Analyse de Plantes",
+            "title": "🌱 AgriLens AI - 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",
@@ -140,16 +141,15 @@ def t(key):
     }
     return translations[st.session_state.language].get(key, key)
 
-# --- Fonctions de chargement et d'analyse du modèle ---
-
-MODEL_ID_LOCAL = "D:/Dev/model_gemma" # Path local (pour votre machine)
+# --- Constantes pour le modèle (ID et chemins locaux) ---
+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
 
 def get_device_map():
-    """Détermine si le modèle doit être chargé sur GPU ou CPU."""
+    """Détermine le device_map pour le chargement du modèle (GPU si disponible, sinon CPU)."""
     if torch.cuda.is_available():
         st.session_state.device = "cuda"
-        return "auto" # Hugging Face gérera l'allocation sur GPU
+        return "auto" # `device_map="auto"` permet à Hugging Face de gérer l'allocation GPU
     else:
         st.session_state.device = "cpu"
         return "cpu" # Forcer l'utilisation du CPU
@@ -157,34 +157,36 @@ def get_device_map():
 def load_model():
     """
     Charge le modèle Gemma 3n et son processeur associé.
-    Tente d'abord le chargement local, puis depuis Hugging Face Hub.
-    Gère les erreurs et les tentatives de chargement.
+    Tente d'abord le chargement depuis un dossier local, puis depuis Hugging Face Hub.
+    Comprend des optimisations pour la gestion de la mémoire.
     """
     try:
-        # Importation des bibliothèques nécessaires UNIQUEMENT lors du chargement du modèle
+        # Importe les classes de transformers ici pour un chargement paresseux et optimisé de la mémoire
         from transformers import AutoProcessor, Gemma3nForConditionalGeneration
         
+        # Limite le nombre de tentatives de chargement pour éviter des boucles infinies
         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
         st.session_state.load_attempt_count += 1
 
-        st.info("🔍 Diagnostic de l'environnement avant chargement...")
+        st.info("🔍 Diagnostic de l'environnement avant chargement du modèle...")
         issues = diagnose_loading_issues()
         if issues:
             with st.expander("📊 Diagnostic système", expanded=False):
                 for issue in issues:
                     st.write(issue)
         
-        gc.collect() # Libère la mémoire inutile
+        # Libère la mémoire du Garbage Collector de Python et le cache GPU (si applicable)
+        gc.collect() 
         if torch.cuda.is_available():
-            torch.cuda.empty_cache() # Vide le cache GPU
+            torch.cuda.empty_cache() 
 
         processor = None
         model = None
-        device_map = get_device_map() # Déterminer le device_map (auto pour GPU, cpu pour CPU)
+        device_map = get_device_map() # Détermine si le GPU ou le CPU sera utilisé
 
-        # Stratégie de chargement : Local d'abord, puis Hub
+        # Vérifie si le modèle est disponible localement et 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:
@@ -193,17 +195,19 @@ def load_model():
                 processor = AutoProcessor.from_pretrained(MODEL_ID_LOCAL, trust_remote_code=True)
                 model = Gemma3nForConditionalGeneration.from_pretrained(
                     MODEL_ID_LOCAL,
-                    torch_dtype=torch.bfloat16 if device_map == "auto" else torch.float32, # Utilise bfloat16 si GPU, sinon float32 sur CPU
+                    # Utilise bfloat16 pour le GPU (plus rapide, moins de mémoire), float32 pour le CPU (compatibilité)
+                    torch_dtype=torch.bfloat16 if device_map == "auto" else torch.float32, 
                     trust_remote_code=True,
-                    low_cpu_mem_usage=True,
-                    device_map=device_map
+                    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)
                 )
                 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...")
         
-        if model is None: # Si le chargement local a échoué ou n'a pas été tenté
+        # 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}...")
                 processor = AutoProcessor.from_pretrained(MODEL_ID_HF, trust_remote_code=True)
@@ -218,29 +222,33 @@ 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
+                return None, None # Échec final, le modèle n'a pas pu être chargé
         
-        # Mise à jour de l'état de la session si le chargement a réussi
+        # Met à jour les variables de session si le modèle a été chargé avec succè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éinitialiser le compteur si le chargement réussit
+        st.session_state.load_attempt_count = 0 # Réinitialise le compteur après un chargement réussi
         
         return model, processor
 
     except ImportError:
-        st.error("❌ Erreur : Les bibliothèques `transformers` ou `torch` ne sont pas installées.")
+        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)
         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.
     """
+    # Vérifie que le modèle est bien chargé avant de tenter 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
@@ -249,9 +257,8 @@ def analyze_image_multilingual(image, prompt_text=""):
         if image.mode != 'RGB':
             image = image.convert('RGB')
         
-        # --- GESTION DU PROMPT ET DES TOKENS SPÉCIAUX (MISE À JOUR CRITIQUE) ---
+        # 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 ajouté plus bas via 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.
@@ -264,41 +271,42 @@ Réponds de manière structurée et claire en français."""
         else:
             user_text_prompt = prompt_text
 
-        # Utilisation de processor.apply_chat_template pour formater les messages
-        # C'est la méthode recommandée pour les modèles instruction-tuned et multimodaux de Gemma
+        # Utilise `processor.apply_chat_template` pour formater l'entrée multimodale (image + texte).
+        # Ceci est essentiel pour les modèles comme Gemma 3n.
         messages = [
             {
                 "role": "user",
                 "content": [
-                    {"type": "image", "image": image}, # Passer l'objet Image PIL ici
+                    {"type": "image", "image": image}, # L'objet Image PIL est passé ici
                     {"type": "text", "text": user_text_prompt}
                 ]
             }
         ]
 
+        # Traite les messages en inputs tensoriels et les déplace sur le device du modèle
         inputs = st.session_state.processor.apply_chat_template(
             messages,
-            add_generation_prompt=True, # Important pour dire au modèle de commencer à générer après le prompt
+            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) # Déplacer les inputs sur le bon device
+        ).to(st.session_state.model.device)
         
-        # Générer la réponse
-        input_len = inputs["input_ids"].shape[-1] 
+        # Génère la réponse du modèle
+        input_len = inputs["input_ids"].shape[-1] # Longueur du prompt encodé
         with st.spinner("🔍 Analyse d'image en cours..."):
             outputs = st.session_state.model.generate(
                 **inputs,
-                max_new_tokens=512,
-                do_sample=True,
-                temperature=0.7,
-                top_p=0.9
+                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
+                top_p=0.9            # Stratégie d'échantillonnage Top-P
             )
-            # Sélectionner uniquement les tokens générés après le prompt.
+            # Décode uniquement la partie générée par le modèle (exclut le prompt initial)
             generation = outputs[0][input_len:] 
             response = st.session_state.processor.decode(generation, skip_special_tokens=True)
             
-        return response.strip()
+        return response.strip() # Retourne la réponse nettoyée des espaces inutiles
         
     except Exception as e:
         st.error(f"❌ Erreur lors de l'analyse de l'image : {e}")
@@ -314,7 +322,7 @@ def analyze_text_multilingual(text_description):
         return None
     
     try:
-        # Prompt pour l'analyse textuelle, également dans un format de message
+        # Prépare le prompt textuel dans le format 'messages' pour `apply_chat_template`
         messages = [
             {
                 "role": "user",
@@ -335,16 +343,14 @@ Réponds en français de manière claire et structurée."""}
             }
         ]
 
-        # Utilisation de processor.apply_chat_template pour formater les messages
         inputs = st.session_state.processor.apply_chat_template(
             messages,
-            add_generation_prompt=True, # Indique au modèle de commencer à générer après le prompt
+            add_generation_prompt=True, # Important pour la génération
             tokenize=True,
             return_dict=True,
             return_tensors="pt",
-        ).to(st.session_state.model.device) # Déplacer les inputs sur le bon device
+        ).to(st.session_state.model.device)
         
-        # Générer la réponse
         input_len = inputs["input_ids"].shape[-1]
         with st.spinner("🔍 Analyse textuelle en cours..."):
             outputs = st.session_state.model.generate(
@@ -354,7 +360,6 @@ Réponds en français de manière claire et structurée."""}
                 temperature=0.7,
                 top_p=0.9
             )
-            # Sélectionner uniquement les tokens générés après le prompt.
             generation = outputs[0][input_len:]
             response = st.session_state.processor.decode(generation, skip_special_tokens=True)
             
@@ -373,6 +378,7 @@ st.markdown(t("subtitle"))
 with st.sidebar:
     st.header(t("config_title"))
     
+    # Sélecteur de langue
     lang_selector_options = ["Français", "English"]
     current_lang_index = 0 if st.session_state.language == "fr" else 1
     language_selected = st.selectbox(
@@ -385,6 +391,7 @@ with st.sidebar:
     
     st.divider()
     
+    # Section de gestion du modèle IA
     st.header(t("model_status"))
     
     if st.session_state.model_loaded and check_model_health():
@@ -394,6 +401,7 @@ with st.sidebar:
             load_time_str = time.strftime('%H:%M:%S', time.localtime(st.session_state.model_load_time))
             st.write(f"**Heure de chargement :** {load_time_str}")
         
+        # Bouton pour décharger et recharger le modèle
         if st.button("🔄 Recharger le modèle", type="secondary"):
             st.session_state.model_loaded = False
             st.session_state.model = None
@@ -404,15 +412,17 @@ with st.sidebar:
     else:
         st.warning("⚠️ Modèle IA non chargé")
         
+        # Bouton pour lancer le chargement du modèle
         if st.button(t("load_model"), type="primary"):
             with st.spinner("🔄 Chargement du modèle IA en cours..."):
                 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() # Ne pas utiliser st.rerun() ici si vous voulez un comportement stable sur Spaces
+                    # `st.rerun()` est généralement évité ici sur Spaces, car le redémarrage est géré par la plateforme.
                 else:
                     st.error("❌ Échec du chargement du modèle IA.")
 
+    # Informations sur l'utilisation des ressources système
     st.divider()
     st.subheader("📊 Ressources Système")
     afficher_ram_disponible()
@@ -426,13 +436,14 @@ with st.sidebar:
     else:
         st.write("🚀 GPU : Non disponible (utilisation CPU)")
 
-# --- Onglets Principaux ---
+# --- Onglets Principaux pour l'interface utilisateur ---
 tab1, tab2, tab3, tab4 = st.tabs(t("tabs"))
 
 with tab1: # Onglet Analyse d'Image
     st.header(t("image_analysis_title"))
     st.markdown(t("image_analysis_desc"))
     
+    # Choix de la source de l'image
     capture_option = st.radio(
         "Choisissez votre méthode de capture :",
         ["📁 Upload d'image" if st.session_state.language == "fr" else "📁 Upload Image",
@@ -448,7 +459,7 @@ with tab1: # Onglet Analyse d'Image
         uploaded_file = st.file_uploader(
             t("choose_image"),
             type=['png', 'jpg', 'jpeg'],
-            help="Formats acceptés : PNG, JPG, JPEG (taille max recommandée : 10MB)."
+            help="Formats acceptés : PNG, JPG, JPEG (taille max recommandée : 10MB pour optimiser la performance)."
         )
         if uploaded_file is not None and uploaded_file.size > 10 * 1024 * 1024:
             st.warning("Le fichier est très volumineux. Il est recommandé d'utiliser des images de taille raisonnable pour une analyse plus rapide.")
@@ -460,6 +471,7 @@ with tab1: # Onglet Analyse d'Image
             key="webcam_photo"
         )
     
+    # Traitement de l'image chargée ou capturée
     image_to_analyze = None
     if uploaded_file is not None:
         try:
@@ -472,6 +484,7 @@ with tab1: # Onglet Analyse d'Image
         except Exception as e:
             st.error(f"❌ Erreur lors du traitement de l'image capturée : {e}")
     
+    # Affichage de l'image et options d'analyse si une image est disponible
     if image_to_analyze is not None:
         original_size = image_to_analyze.size
         resized_image, was_resized = resize_image_if_needed(image_to_analyze)
@@ -483,6 +496,7 @@ with tab1: # Onglet Analyse d'Image
                 st.info(f"ℹ️ Image redimensionnée de {original_size} à {resized_image.size} pour l'analyse.")
         
         with col2:
+            # Les options d'analyse sont disponibles seulement si le modèle est chargé
             if st.session_state.model_loaded and check_model_health():
                 st.subheader("Options d'analyse")
                 analysis_type = st.selectbox(
@@ -504,7 +518,7 @@ with tab1: # Onglet Analyse d'Image
                 
                 if st.button("🔍 Analyser l'image", type="primary", key="analyze_image_button"):
                     final_prompt = custom_prompt_input.strip()
-                    if not final_prompt:
+                    if not final_prompt: # Utilise un prompt par défaut si aucun prompt personnalisé n'est fourni
                         if analysis_type.startswith("Diagnostic complet"):
                             final_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é.
@@ -523,7 +537,7 @@ Réponds de manière structurée et claire en français."""
 4.  Propose des traitements ciblés et des méthodes de lutte.
 
 Réponds en français de manière structurée."""
-                        else:
+                        else: # Conseils de soins et d'entretien
                             final_prompt = """Analyse cette plante et donne des conseils de soins détaillés :
 1.  État général de la plante : Évalue sa santé actuelle.
 2.  Besoins spécifiques : Précise ses besoins en eau, lumière, nutriments et substrat.
@@ -547,6 +561,7 @@ with tab2: # Onglet Analyse de Texte
     st.header(t("text_analysis_title"))
     st.markdown(t("text_analysis_desc"))
     
+    # Zone de texte pour la description des symptômes
     text_description_input = st.text_area(
         t("enter_description"),
         height=200,
@@ -554,7 +569,7 @@ with tab2: # Onglet Analyse de Texte
     )
     
     if st.button("🔍 Analyser la description", type="primary", key="analyze_text_button"):
-        if text_description_input.strip():
+        if text_description_input.strip(): # Vérifie si l'utilisateur a entré du texte
             if st.session_state.model_loaded and check_model_health():
                 analysis_result = analyze_text_multilingual(text_description_input)
                 
@@ -574,8 +589,9 @@ with tab3: # Onglet Configuration & Informations
     
     col1, col2 = st.columns(2)
     
-    with col1:
+    with col1: # Section Informations Système
         st.subheader("🔧 Informations Système")
+        
         try:
             ram = psutil.virtual_memory()
             st.write(f"**RAM Totale :** {ram.total / (1024**3):.1f} GB")
@@ -593,7 +609,7 @@ with tab3: # Onglet Configuration & Informations
         except Exception as e:
             st.error(f"Erreur lors de la récupération des informations système : {e}")
     
-    with col2:
+    with col2: # Section Statistiques du Modèle IA
         st.subheader("📊 Statistiques du Modèle IA")
         
         if st.session_state.model_loaded and check_model_health():