Update src/streamlit_app_stable.py

src/streamlit_app_stable.py

@@ -1,15 +1,13 @@
 import streamlit as st
 import os
-import io
 from PIL import Image
-import requests
 import torch
-import gc  # Garbage Collector pour libérer la mémoire
+import gc
 import time
-import sys
 import psutil
+from transformers import AutoProcessor, Gemma3nForConditionalGeneration
 
-# --- Configuration de la page Streamlit ---
+# Configuration de la page
 st.set_page_config(
     page_title="AgriLens AI - Analyse de Plantes",
     page_icon="🌱",
@@ -17,8 +15,7 @@ st.set_page_config(
     initial_sidebar_state="expanded"
 )
 
-# --- Initialisation des variables de session ---
-# Ces variables maintiennent l'état de l'application entre les interactions utilisateur.
+# Initialisation des variables de session
 if 'model_loaded' not in st.session_state:
     st.session_state.model_loaded = False
 if 'model' not in st.session_state:
@@ -34,70 +31,54 @@ 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" # Défaut à CPU, sera mis à jour si GPU disponible
-
-# --- Fonctions d'aide système et diagnostic ---
+    st.session_state.device = "cpu"
 
+# Fonctions d'aide système
 def check_model_health():
-    """Vérifie si le modèle et le processeur sont correctement chargés et opérationnels."""
+    """Vérifie si le modèle et le processeur sont chargés et semblent 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: # Capture toute exception qui pourrait survenir (ex: modèle corrompu)
+    except Exception:
         return False
 
 def diagnose_loading_issues():
-    """
-    Diagnostique les problèmes potentiels avant le chargement du modèle,
-    en se concentrant sur les contraintes d'un environnement Hugging Face Spaces CPU.
-    """
+    """Diagnostique les problèmes potentiels avant le chargement du modèle."""
     issues = []
-    
+
     try:
         ram = psutil.virtual_memory()
         ram_gb = ram.total / (1024**3)
-        # 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).")
+        if ram_gb < 8:
+            issues.append(f"⚠️ RAM faible: {ram_gb:.1f}GB (recommandé: 8GB+ pour ce modèle)")
     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)
-        # Le modèle et le cache nécessitent plusieurs Go. 10GB libre est une bonne marge.
-        if disk_gb < 10: 
+        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)
-    except requests.exceptions.RequestException:
-        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)
-            # 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+)")
+            if gpu_memory < 6:
+                issues.append(f"⚠️ GPU mémoire faible: {gpu_memory:.1f}GB (recommandé: 6GB+)")
         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 (lentement)")
+
     return issues
 
-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."""
+def resize_image_if_needed(image, max_size=(1024, 1024)):
+    """Redimensionne l'image si ses dimensions dépassent max_size."""
     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
@@ -113,9 +94,9 @@ def afficher_ram_disponible(context=""):
     except Exception as e:
         st.write(f"💾 Impossible d'afficher l'utilisation de la RAM {context}: {e}")
 
-# --- Gestion des traductions ---
+# Gestion des traductions
 def t(key):
-    """Gère les traductions pour l'interface utilisateur."""
+    """Fonction pour gérer les traductions."""
     translations = {
         "fr": {
             "title": "🌱 AgriLens AI - Assistant d'Analyse de Plantes",
@@ -150,176 +131,122 @@ 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" # Chemin local pour votre machine (sera ignoré sur HF Spaces)
+# Fonctions de chargement et d'analyse du modèle
 MODEL_ID_HF = "google/gemma-3n-E4B-it" # ID du modèle sur Hugging Face Hub
 
 def get_device_map():
-    """Détermine le device_map pour le chargement du modèle (GPU si disponible, sinon CPU)."""
+    """Détermine si le modèle doit être chargé sur GPU ou CPU."""
     if torch.cuda.is_available():
         st.session_state.device = "cuda"
-        return "auto" # `device_map="auto"` permet à Hugging Face de gérer l'allocation GPU
+        return "auto"
     else:
         st.session_state.device = "cpu"
-        return "cpu" # Forcer l'utilisation du CPU
+        return "cpu"
 
 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, critiques pour les environnements CPU limités.
+    Charge le modèle Gemma 3n et son processeur associé depuis Hugging Face Hub.
+    Gère les erreurs et les tentatives de chargement.
     """
     try:
-        # 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 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
-        st.session_state.load_attempt_count += 1
 
-        st.info("🔍 Diagnostic de l'environnement avant chargement du modèle...")
+        st.session_state.load_attempt_count += 1
+        st.info("🔍 Diagnostic de l'environnement avant chargement...")
         issues = diagnose_loading_issues()
         if issues:
             with st.expander("📊 Diagnostic système", expanded=False):
                 for issue in issues:
                     st.write(issue)
-        
-        # Libère la mémoire autant que possible
-        gc.collect() # Force le ramasse-miettes de Python
+
+        gc.collect()
         if torch.cuda.is_available():
-            torch.cuda.empty_cache() # Vide le cache GPU s'il existe
-
-        processor = None
-        model = None
-        device_map = get_device_map() # Détermine le device_map ("auto" ou "cpu")
-
-        # 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:
-            try:
-                st.info(f"Chargement du modèle depuis le dossier local explicite : {MODEL_ID_LOCAL}...")
-                processor = AutoProcessor.from_pretrained(MODEL_ID_LOCAL, trust_remote_code=True)
-                model = Gemma3nForConditionalGeneration.from_pretrained(
-                    MODEL_ID_LOCAL,
-                    # 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, # 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
-        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)
-                model = Gemma3nForConditionalGeneration.from_pretrained(
-                    MODEL_ID_HF,
-                    torch_dtype=torch.bfloat16 if device_map == "auto" else torch.float32,
-                    trust_remote_code=True,
-                    low_cpu_mem_usage=True,
-                    device_map=device_map
-                )
-                st.success(f"✅ Modèle chargé avec succès depuis Hugging Face Hub ({MODEL_ID_HF}).")
-                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}")
-                # Si le chargement échoue, même depuis le Hub, retourne None pour signaler l'échec.
-                return None, None 
-        
-        # 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 succès
-        
-        return model, processor
+            torch.cuda.empty_cache()
+        device_map = get_device_map()
+
+        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)
+            model = Gemma3nForConditionalGeneration.from_pretrained(
+                MODEL_ID_HF,
+                torch_dtype=torch.bfloat16 if device_map == "auto" else torch.float32,
+                trust_remote_code=True,
+                low_cpu_mem_usage=True,
+                device_map=device_map
+            )
+            st.success(f"✅ Modèle chargé avec succès depuis Hugging Face Hub ({MODEL_ID_HF}).")
+            st.session_state.model_status = "Chargé (Hub)"
+
+            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
+
+            return model, processor
+
+        except Exception as e:
+            st.error(f"❌ Échec du chargement du modèle depuis Hugging Face Hub : {e}")
+            return None, None
 
     except ImportError:
-        st.error("❌ Erreur : Les bibliothèques `transformers` ou `torch` ne sont pas installées. Veuillez vérifier votre `requirements.txt`.")
+        st.error("❌ Erreur : Les bibliothèques `transformers` ou `torch` ne sont pas installées.")
         return None, None
     except Exception as e:
-        # 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
 
 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. Utilise `apply_chat_template` pour un formatage correct.
+    Retourne le résultat de 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.
-3.  **Diagnostic probable :** Indique la maladie ou le problème le plus probable.
-4.  **Causes possibles :** Explique ce qui a pu causer ce problème.
-5.  **Recommandations de traitement :** Propose des solutions concrètes et adaptées.
-6.  **Conseils préventifs :** Donne des astuces pour éviter que le problème ne revienne.
 
+        if not prompt_text:
+            prompt_text = """<image>
+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.
+3. **Diagnostic probable :** Indique la maladie ou le problème le plus probable.
+4. **Causes possibles :** Explique ce qui a pu causer ce problème.
+5. **Recommandations de traitement :** Propose des solutions concrètes et adaptées.
+6. **Conseils préventifs :** Donne des astuces pour éviter que le problème ne revienne.
 Réponds de manière structurée et claire en français."""
-        else:
-            user_text_prompt = prompt_text
-
-        # Structure le prompt en utilisant le format 'messages' attendu par `apply_chat_template`
-        messages = [
-            {
-                "role": "user",
-                "content": [
-                    {"type": "image", "image": image}, # L'objet Image PIL est passé ici
-                    {"type": "text", "text": user_text_prompt}
-                ]
-            }
-        ]
-
-        # 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) # 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] # Récupère la longueur du prompt encodé
+
+        if "<image>" not in prompt_text:
+            prompt_text = "<image>\n" + prompt_text
+
+        inputs = st.session_state.processor(
+            images=[image],
+            text=prompt_text,
+            return_tensors="pt"
+        )
+
+        inputs = {key: val.to(st.session_state.model.device) for key, val in inputs.items()}
+
         with st.spinner("🔍 Analyse d'image en cours..."):
+            input_len = inputs["input_ids"].shape[-1]
             outputs = st.session_state.model.generate(
                 **inputs,
-                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
+                max_new_tokens=512,
+                do_sample=True,
+                temperature=0.7,
+                top_p=0.9
             )
-            # Décode uniquement la partie générée par le modèle, en excluant le prompt initial
-            generation = outputs[0][input_len:] 
+            generation = outputs[0][input_len:]
             response = st.session_state.processor.decode(generation, skip_special_tokens=True)
-            
-        return response.strip() # Retourne la réponse nettoyée des espaces inutiles
-        
+
+        return response.strip()
+
     except Exception as e:
         st.error(f"❌ Erreur lors de l'analyse de l'image : {e}")
         return None
@@ -327,44 +254,30 @@ 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. Utilise `apply_chat_template`.
+    Retourne le diagnostic et les recommandations.
     """
     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
-        messages = [
-            {
-                "role": "user",
-                "content": [
-                    {"type": "text", "text": f"""Analyse la description des symptômes de cette plante et fournis un diagnostic détaillé :
 
+    try:
+        prompt = f"""Analyse la description des symptômes de cette plante et fournis un diagnostic détaillé :
 **Description des symptômes :**
 {text_description}
-
 **Instructions :**
-1.  **Diagnostic probable :** Quel est le problème principal ?
-2.  **Causes possibles :** Pourquoi ce problème survient-il ?
-3.  **Traitement recommandé :** Comment le résoudre ?
-4.  **Conseils préventifs :** Comment l'éviter à l'avenir ?
-
-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, # 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) # Déplace les tensors sur le bon device
-        
-        input_len = inputs["input_ids"].shape[-1]
+1. **Diagnostic probable :** Quel est le problème principal ?
+2. **Causes possibles :** Pourquoi ce problème survient-il ?
+3. **Traitement recommandé :** Comment le résoudre ?
+4. **Conseils préventifs :** Comment l'éviter à l'avenir ?
+Réponds en français de manière claire et structurée."""
+
+        inputs = st.session_state.processor(
+            text=prompt,
+            return_tensors="pt"
+        )
+
+        inputs = {key: val.to(st.session_state.model.device) for key, val in inputs.items()}
+
         with st.spinner("🔍 Analyse textuelle en cours..."):
             outputs = st.session_state.model.generate(
                 **inputs,
@@ -373,25 +286,28 @@ Réponds en français de manière claire et structurée."""}
                 temperature=0.7,
                 top_p=0.9
             )
-            generation = outputs[0][input_len:]
-            response = st.session_state.processor.decode(generation, skip_special_tokens=True)
-            
-        return response.strip()
-        
+
+        response = st.session_state.processor.decode(outputs[0], skip_special_tokens=True)
+
+        if prompt.strip() in response:
+            response_only = response.split(prompt.strip())[-1].strip()
+        else:
+            response_only = response.strip()
+
+        return response_only
+
     except Exception as e:
         st.error(f"❌ Erreur lors de l'analyse textuelle : {e}")
         return None
 
-# --- Interface Utilisateur Streamlit ---
-
+# Interface Utilisateur Streamlit
 st.title(t("title"))
 st.markdown(t("subtitle"))
 
-# --- Barre Latérale (Sidebar) pour la Configuration ---
+# Barre Latérale (Sidebar) pour la Configuration
 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(
@@ -401,20 +317,18 @@ with st.sidebar:
         help="Sélectionnez la langue de l'interface et des réponses."
     )
     st.session_state.language = "fr" if language_selected == "Français" else "en"
-    
+
     st.divider()
-    
-    # Section de gestion du modèle IA
+
     st.header(t("model_status"))
-    
+
     if st.session_state.model_loaded and check_model_health():
         st.success("✅ Modèle chargé et fonctionnel")
         st.write(f"**Statut :** `{st.session_state.model_status}`")
         if st.session_state.model_load_time:
             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
@@ -424,18 +338,15 @@ with st.sidebar:
             st.info("Modèle déchargé. Cliquez sur 'Charger le modèle IA' pour le recharger.")
     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()` peut être utile, mais sur Spaces, un redémarrage du Space est plus fiable.
                 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()
@@ -449,14 +360,13 @@ with st.sidebar:
     else:
         st.write("🚀 GPU : Non disponible (utilisation CPU)")
 
-# --- Onglets Principaux pour l'interface utilisateur ---
+# Onglets Principaux
 tab1, tab2, tab3, tab4 = st.tabs(t("tabs"))
 
-with tab1: # Onglet Analyse d'Image
+with tab1:
     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",
@@ -464,27 +374,23 @@ with tab1: # Onglet Analyse d'Image
         horizontal=True,
         key="image_capture_method"
     )
-    
+
     uploaded_file = None
     captured_image = None
-    
+
     if capture_option == ("📁 Upload d'image" if st.session_state.language == "fr" else "📁 Upload 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 pour optimiser la performance)."
+            help="Formats acceptés : PNG, JPG, JPEG (taille max recommandée : 10MB)."
         )
         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.")
     else:
         st.markdown("**📷 Capture d'image par webcam**")
         st.info("Positionnez votre plante malade devant la webcam et cliquez sur 'Prendre une photo'.")
-        captured_image = st.camera_input(
-            "Prendre une photo de la plante",
-            key="webcam_photo"
-        )
-    
-    # Traitement de l'image chargée ou capturée
+        captured_image = st.camera_input("Prendre une photo de la plante")
+
     image_to_analyze = None
     if uploaded_file is not None:
         try:
@@ -496,20 +402,18 @@ with tab1: # Onglet Analyse d'Image
             image_to_analyze = Image.open(captured_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)
-        
+
         col1, col2 = st.columns([1, 1])
         with col1:
             st.image(resized_image, caption="Image à analyser", use_container_width=True)
             if was_resized:
                 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(
@@ -521,46 +425,43 @@ with tab1: # Onglet Analyse d'Image
                     ],
                     key="image_analysis_type_selector"
                 )
-                
+
                 custom_prompt_input = st.text_area(
                     "Prompt personnalisé (optionnel) :",
                     value="",
                     height=100,
                     placeholder="Entrez une requête spécifique ici si besoin..."
                 )
-                
+
                 if st.button("🔍 Analyser l'image", type="primary", key="analyze_image_button"):
                     final_prompt = custom_prompt_input.strip()
-                    if not final_prompt: # Utilise un prompt par défaut si aucun prompt personnalisé n'est fourni
+                    if not final_prompt:
                         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é.
-2.  **Identification des problèmes :** Liste les maladies, parasites ou carences visibles.
-3.  **Diagnostic probable :** Indique la maladie ou le problème le plus probable.
-4.  **Causes possibles :** Explique ce qui a pu causer ce problème.
-5.  **Recommandations de traitement :** Propose des solutions concrètes et adaptées.
-6.  **Conseils préventifs :** Donne des astuces pour éviter que le problème ne revienne.
-
+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.
+3. **Diagnostic probable :** Indique la maladie ou le problème le plus probable.
+4. **Causes possibles :** Explique ce qui a pu causer ce problème.
+5. **Recommandations de traitement :** Propose des solutions concrètes et adaptées.
+6. **Conseils préventifs :** Donne des astuces pour éviter que le problème ne revienne.
 Réponds de manière structurée et claire en français."""
                         elif analysis_type.startswith("Identification et diagnostic de maladies"):
                             final_prompt = """Diagnostique cette plante en te concentrant sur les maladies et parasites :
-1.  Identifie les symptômes visuels spécifiques aux maladies ou parasites.
-2.  Détermine la maladie ou le parasite le plus probable.
-3.  Explique les conditions favorisant leur développement.
-4.  Propose des traitements ciblés et des méthodes de lutte.
-
+1. Identifie les symptômes visuels spécifiques aux maladies ou parasites.
+2. Détermine la maladie ou le parasite le plus probable.
+3. Explique les conditions favorisant leur développement.
+4. Propose des traitements ciblés et des méthodes de lutte.
 Réponds en français de manière structurée."""
-                        else: # Conseils de soins et d'entretien
+                        else:
                             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.
-3.  Conseils d'entretien : Donne des instructions pour l'arrosage, la fertilisation et la taille.
-4.  Améliorations recommandées : Suggère des actions pour optimiser sa croissance et sa santé.
-
+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.
+3. Conseils d'entretien : Donne des instructions pour l'arrosage, la fertilisation et la taille.
+4. Améliorations recommandées : Suggère des actions pour optimiser sa croissance et sa santé.
 Réponds en français de manière structurée."""
-                    
+
                     analysis_result = analyze_image_multilingual(resized_image, prompt_text=final_prompt)
-                    
+
                     if analysis_result:
                         st.success("✅ Analyse terminée !")
                         st.markdown("### 📋 Résultats de l'analyse")
@@ -570,22 +471,21 @@ Réponds en français de manière structurée."""
             else:
                 st.warning("⚠️ Modèle IA non chargé. Veuillez d'abord charger le modèle depuis la barre latérale.")
 
-with tab2: # Onglet Analyse de Texte
+with tab2:
     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,
         placeholder="Décrivez ici les symptômes observés sur votre plante : feuilles jaunes, taches, flétrissement, présence d'insectes, etc."
     )
-    
+
     if st.button("🔍 Analyser la description", type="primary", key="analyze_text_button"):
-        if text_description_input.strip(): # Vérifie si l'utilisateur a entré du texte
+        if text_description_input.strip():
             if st.session_state.model_loaded and check_model_health():
                 analysis_result = analyze_text_multilingual(text_description_input)
-                
+
                 if analysis_result:
                     st.success("✅ Analyse terminée !")
                     st.markdown("### 📋 Résultats de l'analyse")
@@ -597,22 +497,22 @@ with tab2: # Onglet Analyse de Texte
         else:
             st.warning("⚠️ Veuillez entrer une description des symptômes de votre plante.")
 
-with tab3: # Onglet Configuration & Informations
+with tab3:
     st.header(t("config_title"))
-    
+
     col1, col2 = st.columns(2)
-    
-    with col1: # Section Informations Système
+
+    with col1:
         st.subheader("🔧 Informations Système")
-        
+
         try:
             ram = psutil.virtual_memory()
             st.write(f"**RAM Totale :** {ram.total / (1024**3):.1f} GB")
             st.write(f"**RAM Utilisée :** {ram.used / (1024**3):.1f} GB ({ram.percent:.1f}%)")
-            
+
             disk = psutil.disk_usage('/')
             st.write(f"**Espace Disque Libre (/) :** {disk.free / (1024**3):.1f} GB")
-            
+
             if torch.cuda.is_available():
                 st.write(f"**GPU Détecté :** {torch.cuda.get_device_name(0)}")
                 gpu_props = torch.cuda.get_device_properties(0)
@@ -621,10 +521,10 @@ with tab3: # Onglet Configuration & Informations
                 st.write("**GPU :** Non disponible (fonctionnement sur CPU)")
         except Exception as e:
             st.error(f"Erreur lors de la récupération des informations système : {e}")
-    
-    with col2: # Section Statistiques du Modèle IA
+
+    with col2:
         st.subheader("📊 Statistiques du Modèle IA")
-        
+
         if st.session_state.model_loaded and check_model_health():
             st.write("**Statut :** ✅ Chargé et fonctionnel")
             if st.session_state.model is not None:
@@ -639,51 +539,40 @@ with tab3: # Onglet Configuration & Informations
             st.write("**Type de modèle :** N/A")
             st.write("**Device utilisé :** N/A")
 
-with tab4: # Onglet À Propos
+with tab4:
     st.header(t("about_title"))
-    
+
     st.markdown("""
     ## 🌱 AgriLens AI : Votre Assistant d'Analyse de Plantes
-
     **AgriLens AI** est une application alimentée par l'intelligence artificielle qui vous aide à identifier les problèmes de vos plantes, à diagnostiquer les maladies et à obtenir des conseils de traitement personnalisés. Que vous soyez un jardinier débutant ou expérimenté, AgriLens AI est là pour vous accompagner.
-
     ### 🚀 Fonctionnalités Principales :
-
-    *   **Analyse d'Images de Plantes :** Téléchargez une photo de votre plante malade, et notre IA analysera les symptômes visuels pour fournir un diagnostic précis.
-    *   **Diagnostic par Description Textuelle :** Décrivez les symptômes que vous observez, et obtenez un avis d'expert basé sur une large base de connaissances.
-    *   **Recommandations Précises :** Recevez des conseils de traitement, des suggestions de soins et des mesures préventives adaptées à chaque situation.
-    *   **Support Multilingue :** L'interface et les réponses sont disponibles en français et en anglais pour une accessibilité maximale.
-
+    - **Analyse d'Images de Plantes :** Téléchargez une photo de votre plante malade, et notre IA analysera les symptômes visuels pour fournir un diagnostic précis.
+    - **Diagnostic par Description Textuelle :** Décrivez les symptômes que vous observez, et obtenez un avis d'expert basé sur une large base de connaissances.
+    - **Recommandations Précises :** Recevez des conseils de traitement, des suggestions de soins et des mesures préventives adaptées à chaque situation.
+    - **Support Multilingue :** L'interface et les réponses sont disponibles en français et en anglais pour une accessibilité maximale.
     ### 🤖 Technologie Utilisée :
-
-    *   **Modèle IA :** Google Gemma 3n E4B IT, un modèle multimodal performant pour l'analyse de plantes.
-    *   **Bibliothèques :** `transformers`, `torch`, `streamlit`, `Pillow`, `psutil`, `requests`, `huggingface-hub`.
-
+    - **Modèle IA :** Google Gemma 3n E4B IT, un modèle multimodal performant pour l'analyse de plantes.
+    - **Bibliothèques :** `transformers`, `torch`, `streamlit`, `Pillow`, `psutil`, `requests`, `huggingface-hub`.
     ### 📝 Comment Utiliser AgriLens AI :
-
-    1.  **Chargez le Modèle IA :** Dans la barre latérale, cliquez sur "Charger le Modèle IA". Attendez que le statut passe à "Chargé et fonctionnel".
-    2.  **Analysez votre Plante :**
-        *   **Via Image :** Allez à l'onglet "📸 Analyse d'Image". Uploadez une photo de votre plante ou utilisez votre webcam. Choisissez le type d'analyse et cliquez sur "Analyser l'image".
-        *   **Via Texte :** Allez à l'onglet "📝 Analyse de Texte". Décrivez les symptômes de votre plante dans la zone de texte et cliquez sur "Analyser la description".
-    3.  **Interprétez les Résultats :** Lisez attentivement le diagnostic, les causes probables, et les recommandations fournies par l'IA.
-
+    1. **Chargez le Modèle IA :** Dans la barre latérale, cliquez sur "Charger le Modèle IA". Attendez que le statut passe à "Chargé et fonctionnel".
+    2. **Analysez votre Plante :**
+        - **Via Image :** Allez à l'onglet "📸 Analyse d'Image". Uploadez une photo de votre plante ou utilisez votre webcam. Choisissez le type d'analyse et cliquez sur "Analyser l'image".
+        - **Via Texte :** Allez à l'onglet "📝 Analyse de Texte". Décrivez les symptômes de votre plante dans la zone de texte et cliquez sur "Analyser la description".
+    3. **Interprétez les Résultats :** Lisez attentivement le diagnostic, les causes probables, et les recommandations fournies par l'IA.
     ### 🔧 Support et Optimisation :
-
-    *   **Gestion des Ressources :** Le modèle nécessite une quantité significative de RAM et idéalement un GPU pour des performances optimales. L'application s'adapte à votre environnement (CPU/GPU).
-    *   **Performance :** Les temps de réponse dépendent de votre matériel. Un GPU est fortement recommandé pour une expérience fluide.
-
+    - **Gestion des Ressources :** Le modèle nécessite une quantité significative de RAM et idéalement un GPU pour des performances optimales. L'application s'adapte à votre environnement (CPU/GPU).
+    - **Performance :** Les temps de réponse dépendent de votre matériel. Un GPU est fortement recommandé pour une expérience fluide.
     ---
-
     *Développé avec passion pour aider les jardiniers et amoureux des plantes à prendre soin de leurs cultures grâce à la puissance de l'IA.*
     """)
 
-# --- Pied de page ---
+# Pied de page
 st.divider()
 st.markdown("""
 <div style='text-align: center; color: #666;'>
-  🌱 AgriLens AI - Assistant d'Analyse de Plantes | 
-  <a href='#' target='_blank'>Documentation</a> | 
-  <a href='#' target='_blank'>Support</a> | 
+  🌱 AgriLens AI - Assistant d'Analyse de Plantes |
+  <a href='#' target='_blank'>Documentation</a> |
+  <a href='#' target='_blank'>Support</a> |
   <a href='https://huggingface.co/google/gemma-3n-E4B-it' target='_blank'>Modèle Gemma 3n</a>
 </div>
-""", unsafe_allow_html=True)
+""", unsafe_allow_html=True)