Update src/streamlit_app_stable.py

src/streamlit_app_stable.py

@@ -4,11 +4,13 @@ import io
 from PIL import Image
 import requests
 import torch
-import google.generativeai as genai # Importé mais non utilisé dans ce code
 import gc
 import time
 import sys
 import psutil
+# from transformers import AutoProcessor, Gemma3nForConditionalGeneration # Importés plus bas pour éviter de charger inutilement
+# Importations pour le chargement du modèle seulement si nécessaire
+# from transformers import AutoProcessor, Gemma3nForConditionalGeneration
 
 # --- Configuration de la page ---
 st.set_page_config(
@@ -19,6 +21,7 @@ st.set_page_config(
 )
 
 # --- Initialisation des variables de session ---
+# Initialise les variables de session pour gérer 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:
@@ -33,54 +36,50 @@ if 'language' not in st.session_state:
     st.session_state.language = "fr"
 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
 
 # --- Fonctions d'aide système ---
 
 def check_model_health():
     """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 un attribut 'device' (ce qui suggère 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:
-        # Si une exception survient (ex: AttributeError si model ou processor est None)
         return False
 
 def diagnose_loading_issues():
     """Diagnostique les problèmes potentiels avant le chargement du modèle."""
     issues = []
     
-    # Vérification RAM
     try:
         ram = psutil.virtual_memory()
         ram_gb = ram.total / (1024**3)
-        if ram_gb < 8: # Recommandation générale pour les gros modèles
+        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}")
 
-    # Vérification Espace Disque (utile si le modèle est téléchargé localement)
     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:
             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érification connexion Hugging Face
     try:
         requests.get("https://huggingface.co", timeout=5)
     except requests.exceptions.RequestException:
         issues.append("⚠️ Problème de connexion à Hugging Face Hub")
     
-    # Vérification CUDA
     if torch.cuda.is_available():
         try:
             gpu_memory = torch.cuda.get_device_properties(0).total_memory / (1024**3)
-            if gpu_memory < 4: # Recommandation minimale pour ce type de modèle
-                issues.append(f"⚠️ GPU mémoire faible: {gpu_memory:.1f}GB (recommandé: 6GB+ pour ce modèle)")
+            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+)")
         except Exception as e:
             issues.append(f"⚠️ Erreur lors de la vérification de la mémoire GPU : {e}")
     else:
@@ -88,14 +87,13 @@ def diagnose_loading_issues():
     
     return issues
 
-def resize_image_if_needed(image, max_size=(800, 800)):
+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."""
     original_size = image.size
     if image.size[0] > max_size[0] or image.size[1] > max_size[1]:
-        # Utiliser Image.Resampling.LANCZOS pour une meilleure qualité de redimensionnement
         image.thumbnail(max_size, Image.Resampling.LANCZOS)
-        return image, True # Retourne l'image redimensionnée et un booléen indiquant que le redimensionnement a eu lieu
-    return image, False # Retourne l'image originale et False
+        return image, True
+    return image, False
 
 def afficher_ram_disponible(context=""):
     """Affiche l'utilisation de la RAM de manière lisible."""
@@ -109,7 +107,6 @@ def afficher_ram_disponible(context=""):
         st.write(f"💾 Impossible d'afficher l'utilisation de la RAM {context}: {e}")
 
 # --- Gestion des traductions ---
-
 def t(key):
     """Fonction pour gérer les traductions."""
     translations = {
@@ -144,18 +141,22 @@ def t(key):
             "model_status": "AI Model Status"
         }
     }
-    # Retourne la traduction si elle existe, sinon retourne la clé elle-même
     return translations[st.session_state.language].get(key, key)
 
 # --- Fonctions de chargement et d'analyse du modèle ---
 
-# IMPORTANT: Sur Hugging Face Spaces, le chemin local D:/Dev/model_gemma n'existera PAS.
-# Le code se rabattra automatiquement sur le chargement depuis le Hub Hugging Face.
-# Si vous exécutez ceci localement et que vous avez téléchargé le modèle,
-# assurez-vous que le chemin est correct et accessible.
 MODEL_ID_LOCAL = "D:/Dev/model_gemma" # Path local (pour votre machine)
 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."""
+    if torch.cuda.is_available():
+        st.session_state.device = "cuda"
+        return "auto" # Hugging Face gérera l'allocation sur GPU
+    else:
+        st.session_state.device = "cpu"
+        return "cpu" # Forcer l'utilisation du CPU
+
 def load_model():
     """
     Charge le modèle Gemma 3n et son processeur associé.
@@ -163,11 +164,9 @@ def load_model():
     Gère les erreurs et les tentatives de chargement.
     """
     try:
-        # Importation des bibliothèques nécessaires UNIQUEMENT lors du chargement du modèle
-        # pour éviter des erreurs si elles ne sont pas installées dans l'environnement de base
+        # Importer seulement lorsque c'est nécessaire
         from transformers import AutoProcessor, Gemma3nForConditionalGeneration
         
-        # Limiter les tentatives de chargement pour éviter les 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
@@ -180,19 +179,15 @@ def load_model():
                 for issue in issues:
                     st.write(issue)
         
-        # Libérer la mémoire GPU si disponible et si nécessaire
         gc.collect()
         if torch.cuda.is_available():
             torch.cuda.empty_cache()
 
         processor = None
         model = None
-        
-        # --- Stratégie de chargement : Local d'abord, puis Hub ---
-        
-        # Vérifier si le chemin local existe et s'il contient des fichiers de modèle
-        local_model_found = os.path.exists(MODEL_ID_LOCAL) and \
-                              os.path.exists(os.path.join(MODEL_ID_LOCAL, "config.json"))
+        device_map = get_device_map() # Déterminer le device_map
+
+        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:
@@ -200,42 +195,38 @@ 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, # Recommandé pour Gemma 3n si le matériel le supporte
+                    torch_dtype=torch.bfloat16 if device_map == "auto" else torch.float32, # Utilise bfloat16 si GPU, sinon float32 sur CPU
                     trust_remote_code=True,
-                    low_cpu_mem_usage=True, # Tente de réduire l'utilisation de la RAM CPU pendant le chargement
-                    device_map="cpu"       # Forcer l'utilisation du CPU. Changer en "auto" si vous avez un GPU configuré.
+                    low_cpu_mem_usage=True,
+                    device_map=device_map
                 )
                 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 chargement local échoue malgré l'existence du dossier, on tente le Hub.
-                # On ne met pas à jour model et processor ici pour permettre la tentative Hub.
         
-        # Si le modèle n'a pas été chargé localement, tenter depuis Hugging Face Hub
-        if model is None:
+        if model is None: # Si le chargement local a échoué ou n'a pas été tenté
             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,
+                    torch_dtype=torch.bfloat16 if device_map == "auto" else torch.float32,
                     trust_remote_code=True,
                     low_cpu_mem_usage=True,
-                    device_map="cpu" # Forcer l'utilisation du CPU
+                    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}")
-                return None, None # Échec final
+                return None, None
         
-        # Mettre à jour l'état de la session si le chargement a réussi
         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
         
         return model, processor
 
@@ -256,11 +247,9 @@ def analyze_image_multilingual(image, prompt_text=""):
         return None
     
     try:
-        # S'assurer que l'image est en mode RGB
         if image.mode != 'RGB':
             image = image.convert('RGB')
         
-        # Préparation du prompt par défaut s'il n'est pas fourni
         if not prompt_text:
             prompt_text = """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é.
@@ -270,39 +259,31 @@ def analyze_image_multilingual(image, prompt_text=""):
 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. Utilise des termes simples et compréhensibles pour un jardinier."""
+Réponds de manière structurée et claire en français.""" # Prompt légèrement simplifié
 
-        # Préparation des entrées pour le modèle
-        # Le processeur s'attend à une liste d'images si plusieurs sont passées, même s'il n'y en a qu'une.
         inputs = st.session_state.processor(
             images=[image],
             text=prompt_text,
             return_tensors="pt"
         )
         
-        # Déplacer les tensors sur le bon device (CPU dans notre cas, ou GPU si `device_map="auto"` était utilisé)
         inputs = {key: val.to(st.session_state.model.device) for key, val in inputs.items()}
 
-        # Générer la réponse avec le modèle
         with st.spinner("🔍 Analyse d'image en cours..."):
             outputs = st.session_state.model.generate(
                 **inputs,
-                max_new_tokens=512, # Nombre maximal de nouveaux tokens à générer
-                do_sample=True,      # Permet la génération stochastique
-                temperature=0.7,     # Contrôle la créativité (plus bas = plus déterministe)
-                top_p=0.9            # Stratégie d'échantillonnage pour contrôler la diversité
+                max_new_tokens=512,
+                do_sample=True,
+                temperature=0.7,
+                top_p=0.9
             )
         
-        # Décoder la réponse générée
         response = st.session_state.processor.decode(outputs[0], skip_special_tokens=True)
         
-        # Extraire uniquement la partie générée par le modèle, en retirant le prompt initial
-        # Ceci peut nécessiter un ajustement si le modèle répète le prompt ou s'y réfère différemment
         if prompt_text.strip() in response:
             response_only = response.split(prompt_text.strip())[-1].strip()
         else:
-            # Si le prompt n'est pas exactement dans la réponse, essayons de trouver une partie logique
-            response_only = response.strip() # Utiliser la réponse brute si split échoue
+            response_only = response.strip()
             
         return response_only
         
@@ -320,30 +301,27 @@ def analyze_text_multilingual(text_description):
         return None
     
     try:
-        # Préparation du prompt pour l'analyse textuelle
+        # Prompt légèrement simplifié pour réduire la complexité et les potentiels problèmes de cache sur CPU
         prompt = f"""Analyse la description des symptômes de cette plante et fournis un diagnostic détaillé :
 
 **Description des symptômes :**
 {text_description}
 
-**Instructions pour le diagnostic :**
-1.  **Diagnostic probable :** Quel est le problème principal (maladie, carence, etc.) ?
-2.  **Causes possibles :** Quelles sont les raisons derrière ces symptômes ?
-3.  **Recommandations de traitement :** Quels traitements sont les plus adaptés ?
-4.  **Conseils de soins préventifs :** Comment éviter que le problème ne se reproduise ?
+**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 de manière structurée, claire et en français. Ne répète pas la description des symptômes dans ta réponse."""
+Réponds en français de manière claire et structurée."""
 
-        # Préparation des entrées pour le modèle (sans image ici)
         inputs = st.session_state.processor(
             text=prompt,
             return_tensors="pt"
         )
         
-        # Déplacer les tensors sur le bon device
         inputs = {key: val.to(st.session_state.model.device) for key, val in inputs.items()}
 
-        # Générer la réponse
         with st.spinner("🔍 Analyse textuelle en cours..."):
             outputs = st.session_state.model.generate(
                 **inputs,
@@ -353,10 +331,8 @@ Réponds de manière structurée, claire et en français. Ne répète pas la des
                 top_p=0.9
             )
         
-        # Décoder la réponse
         response = st.session_state.processor.decode(outputs[0], skip_special_tokens=True)
         
-        # Extraire uniquement la partie générée par le modèle
         if prompt.strip() in response:
             response_only = response.split(prompt.strip())[-1].strip()
         else:
@@ -370,7 +346,6 @@ Réponds de manière structurée, claire et en français. Ne répète pas la des
 
 # --- Interface Utilisateur Streamlit ---
 
-# Titre principal et sous-titre
 st.title(t("title"))
 st.markdown(t("subtitle"))
 
@@ -378,7 +353,6 @@ st.markdown(t("subtitle"))
 with st.sidebar:
     st.header(t("config_title"))
     
-    # Option de sélection de langue
     lang_selector_options = ["Français", "English"]
     current_lang_index = 0 if st.session_state.language == "fr" else 1
     language_selected = st.selectbox(
@@ -387,52 +361,41 @@ with st.sidebar:
         index=current_lang_index,
         help="Sélectionnez la langue de l'interface et des réponses."
     )
-    # Mise à jour de la langue de la session si elle change
     st.session_state.language = "fr" if language_selected == "Français" else "en"
     
     st.divider()
     
-    # Section pour la 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:
-            # Formatte le temps de chargement pour une meilleure lisibilité
             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 (utile pour tester les chargements)
         if st.button("🔄 Recharger le modèle", type="secondary"):
             st.session_state.model_loaded = False
             st.session_state.model = None
             st.session_state.processor = None
             st.session_state.model_status = "Non chargé"
-            st.session_state.load_attempt_count = 0 # Réinitialiser le compteur pour une nouvelle tentative
+            st.session_state.load_attempt_count = 0
             st.info("Modèle déchargé. Cliquez sur 'Charger le modèle IA' pour le recharger.")
-            # Sur Hugging Face Spaces, il n'est pas nécessaire de faire `st.rerun()` après ce bouton,
-            # car le redémarrage se fait via l'interface du Space si nécessaire.
     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()` est utile si vous voulez rafraîchir l'interface immédiatement après le chargement
-                    # mais il peut causer des boucles si mal géré. Souvent, un redémarrage du Space est plus propre.
-                    # st.rerun() 
+                    # `st.rerun()` peut être tenté, mais un redémarrage du Space est souvent plus sûr.
                 else:
                     st.error("❌ Échec du chargement du modèle IA.")
 
-    # Informations sur l'utilisation des ressources
     st.divider()
     st.subheader("📊 Ressources Système")
     afficher_ram_disponible()
-    # Afficher l'utilisation GPU si disponible
     if torch.cuda.is_available():
         try:
             gpu_memory = torch.cuda.memory_allocated(0) / (1024**3)
@@ -450,13 +413,12 @@ with tab1: # Onglet Analyse d'Image
     st.header(t("image_analysis_title"))
     st.markdown(t("image_analysis_desc"))
     
-    # Choix entre upload et capture webcam
     capture_option = st.radio(
         "Choisissez votre méthode de capture :",
         ["📁 Upload d'image" if st.session_state.language == "fr" else "📁 Upload Image",
          "📷 Capture par webcam" if st.session_state.language == "fr" else "📷 Webcam Capture"],
         horizontal=True,
-        key="image_capture_method" # Clé unique pour le widget radio
+        key="image_capture_method"
     )
     
     uploaded_file = None
@@ -466,20 +428,18 @@ 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 pour une meilleure performance)."
+            help="Formats acceptés : PNG, JPG, JPEG (taille max recommandée : 10MB)."
         )
-        # Limiter la taille du fichier uploadé pour une meilleure expérience
-        if uploaded_file is not None and uploaded_file.size > 10 * 1024 * 1024: # 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" # Clé unique pour le widget caméra
+            key="webcam_photo"
         )
     
-    # Traitement de l'image si un fichier est uploadé ou capturé
     image_to_analyze = None
     if uploaded_file is not None:
         try:
@@ -492,11 +452,9 @@ 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 du bouton d'analyse si une image est prête
     if image_to_analyze is not None:
-        # Redimensionner l'image si nécessaire pour l'affichage et l'analyse
         original_size = image_to_analyze.size
-        resized_image, was_resized = resize_image_if_needed(image_to_analyze, max_size=(1024, 1024)) # Augmentation de la taille max pour l'analyse
+        resized_image, was_resized = resize_image_if_needed(image_to_analyze)
         
         col1, col2 = st.columns([1, 1])
         with col1:
@@ -505,7 +463,6 @@ with tab1: # Onglet Analyse d'Image
                 st.info(f"ℹ️ Image redimensionnée de {original_size} à {resized_image.size} pour l'analyse.")
         
         with col2:
-            # Options d'analyse 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(
@@ -526,9 +483,8 @@ with tab1: # Onglet Analyse d'Image
                 )
                 
                 if st.button("🔍 Analyser l'image", type="primary", key="analyze_image_button"):
-                    # Déterminer le prompt basé sur la sélection de l'utilisateur
-                    final_prompt = custom_prompt_input.strip() # Utiliser le prompt personnalisé s'il existe
-                    if not final_prompt: # Sinon, utiliser un prompt par défaut basé sur le type d'analyse
+                    final_prompt = custom_prompt_input.strip()
+                    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é.
@@ -538,7 +494,7 @@ with tab1: # Onglet Analyse d'Image
 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. Utilise des termes simples et compréhensibles pour un jardinier."""
+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.
@@ -547,7 +503,7 @@ Réponds de manière structurée et claire en français. Utilise des termes simp
 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.
@@ -556,13 +512,12 @@ Réponds en français de manière structurée."""
 
 Réponds en français de manière structurée."""
                     
-                    # Appel de la fonction d'analyse
                     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")
-                        st.markdown(analysis_result) # Afficher le résultat Markdown
+                        st.markdown(analysis_result)
                     else:
                         st.error("❌ Échec de l'analyse de l'image.")
             else:
@@ -572,18 +527,15 @@ with tab2: # Onglet Analyse de Texte
     st.header(t("text_analysis_title"))
     st.markdown(t("text_analysis_desc"))
     
-    # Zone de texte pour que l'utilisateur décrive les 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."
     )
     
-    # Bouton d'analyse du texte
     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():
-                # Appel de la fonction d'analyse textuelle
                 analysis_result = analyze_text_multilingual(text_description_input)
                 
                 if analysis_result:
@@ -600,12 +552,10 @@ with tab2: # Onglet Analyse de Texte
 with tab3: # Onglet Configuration & Informations
     st.header(t("config_title"))
     
-    col1, col2 = st.columns(2) # Créer deux colonnes pour organiser les informations
+    col1, col2 = st.columns(2)
     
-    with col1: # Section Informations Système
+    with col1:
         st.subheader("🔧 Informations Système")
-        
-        # Affichage des informations système générales
         try:
             ram = psutil.virtual_memory()
             st.write(f"**RAM Totale :** {ram.total / (1024**3):.1f} GB")
@@ -623,7 +573,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: # 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():
@@ -643,7 +593,6 @@ with tab3: # Onglet Configuration & Informations
 with tab4: # Onglet À Propos
     st.header(t("about_title"))
     
-    # Utilisation de Markdown pour une mise en page plus riche
     st.markdown("""
     ## 🌱 AgriLens AI : Votre Assistant d'Analyse de Plantes
 
@@ -658,12 +607,8 @@ with tab4: # Onglet À Propos
 
     ### 🤖 Technologie Utilisée :
 
-    *   **Modèle IA :** Fine-tuné sur des tâches de vision et de langage, avec une spécialisation dans l'agronomie et la botanique. (Utilise le modèle **Google Gemma 3n E4B IT** pour cette application).
-    *   **Bibliothèques :**
-        *   `transformers` et `torch` pour le fonctionnement des modèles IA.
-        *   `Streamlit` pour une interface utilisateur web interactive et facile à utiliser.
-        *   `Pillow` pour le traitement d'images.
-        *   `psutil` pour l'affichage des ressources système.
+    *   **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 :
 
@@ -675,9 +620,8 @@ with tab4: # Onglet À Propos
 
     ### 🔧 Support et Optimisation :
 
-    *   **Mode Local vs. Hub :** Le modèle peut être chargé depuis un répertoire local (si configuré sur votre machine) ou directement depuis le Hugging Face Hub.
-    *   **Gestion Mémoire :** L'application essaie d'optimiser l'utilisation de la mémoire, mais les grands modèles IA nécessitent des ressources significatives (RAM et potentiellement VRAM).
-    *   **Performance :** Les performances peuvent varier en fonction de votre matériel et de la configuration de votre environnement (CPU vs GPU). Pour une expérience optimale avec ce type de modèle, un GPU est fortement recommandé.
+    *   **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.
 
     ---
 
@@ -685,7 +629,7 @@ with tab4: # Onglet À Propos
     """)
 
 # --- Pied de page ---
-st.divider() # Ligne de séparation
+st.divider()
 st.markdown("""
 <div style='text-align: center; color: #666;'>
   🌱 AgriLens AI - Assistant d'Analyse de Plantes |