Update app.py

app.py

@@ -1,5 +1,7 @@
 import gradio as gr
 import os
+import subprocess
+import sys
 import requests
 import json
 import logging
@@ -8,40 +10,41 @@ import time
 import tempfile
 import shutil
 
-# Imports conditionnels pour éviter les erreurs
-try:
-    import numpy as np
-    NUMPY_AVAILABLE = True
-except ImportError:
-    NUMPY_AVAILABLE = False
-    import array
-    
-try:
-    from pathlib import Path
-    PATHLIB_AVAILABLE = True
-except ImportError:
-    PATHLIB_AVAILABLE = False
+# Configuration du logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
-try:
-    from huggingface_hub import HfApi
-    HF_HUB_AVAILABLE = True
-except ImportError:
-    HF_HUB_AVAILABLE = False
-    
-try:
-    import numpy as np
-    NUMPY_AVAILABLE = True
-except ImportError:
-    NUMPY_AVAILABLE = False
+# Fonction d'installation automatique
+def install_package(package_name):
+    """Installe un package Python"""
+    try:
+        subprocess.check_call([sys.executable, "-m", "pip", "install", package_name])
+        return True
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Erreur installation {package_name}: {e}")
+        return False
+
+# Imports conditionnels avec tentative d'installation
+def safe_import(module_name, package_name=None):
+    """Import sécurisé avec possibilité d'installation"""
+    if package_name is None:
+        package_name = module_name
     
-try:
-    import torch
-    import torch.nn as nn
-    TORCH_AVAILABLE = True
-except ImportError:
-    TORCH_AVAILABLE = False
+    try:
+        return __import__(module_name), True
+    except ImportError:
+        logger.warning(f"{module_name} non trouvé")
+        return None, False
+
+# Tentative d'imports
+numpy, NUMPY_AVAILABLE = safe_import('numpy')
+torch_module, TORCH_AVAILABLE = safe_import('torch')
+if torch_module:
+    torch = torch_module
+else:
     torch = None
 
+# Import transformers
 try:
     from transformers import (
         AutoTokenizer, AutoModel, AutoProcessor, 
@@ -51,87 +54,131 @@ try:
     TRANSFORMERS_AVAILABLE = True
 except ImportError:
     TRANSFORMERS_AVAILABLE = False
+    logger.warning("Transformers non disponible")
 
+# Import datasets
 try:
     from datasets import Dataset, load_dataset, concatenate_datasets
     DATASETS_AVAILABLE = True
 except ImportError:
     DATASETS_AVAILABLE = False
+    logger.warning("Datasets non disponible")
+
+# Import HuggingFace Hub
+try:
+    from huggingface_hub import HfApi
+    HF_HUB_AVAILABLE = True
+except ImportError:
+    HF_HUB_AVAILABLE = False
+    logger.warning("HuggingFace Hub non disponible")
 
+# Import PIL
 try:
     from PIL import Image
     PIL_AVAILABLE = True
 except ImportError:
     PIL_AVAILABLE = False
 
+# Import librosa
 try:
     import librosa
     LIBROSA_AVAILABLE = True
 except ImportError:
     LIBROSA_AVAILABLE = False
 
+# Import OpenCV
 try:
     import cv2
     CV2_AVAILABLE = True
 except ImportError:
     CV2_AVAILABLE = False
 
-# Configuration du logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
 class MultimodalTrainer:
     def __init__(self):
-        # Vérification des dépendances
-        self.dependencies_ok = self.check_dependencies()
-        
-        if not TORCH_AVAILABLE:
-            self.device = "cpu"
-            logger.warning("PyTorch non disponible")
-        else:
-            self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
-            
         self.current_model = None
         self.current_tokenizer = None
         self.current_processor = None
         self.training_data = []
         
+        # Device selection
+        if TORCH_AVAILABLE and torch.cuda.is_available():
+            self.device = torch.device("cuda")
+        else:
+            self.device = "cpu"
+            
+        # HF API
         if HF_HUB_AVAILABLE:
             self.hf_api = HfApi()
         else:
             self.hf_api = None
         
+    def install_dependencies(self, packages_to_install):
+        """Installe les dépendances manquantes"""
+        installation_results = []
+        
+        for package in packages_to_install:
+            installation_results.append(f"📦 Installation de {package}...")
+            success = install_package(package)
+            if success:
+                installation_results.append(f"✅ {package} installé avec succès!")
+            else:
+                installation_results.append(f"❌ Échec installation {package}")
+        
+        installation_results.append("\n🔄 Redémarrage requis pour prendre effet")
+        return "\n".join(installation_results)
+    
     def check_dependencies(self):
-        """Vérifie les dépendances installées"""
+        """Vérifie et affiche l'état des dépendances"""
         deps = {
+            "NumPy": NUMPY_AVAILABLE,
             "PyTorch": TORCH_AVAILABLE,
             "Transformers": TRANSFORMERS_AVAILABLE,
             "Datasets": DATASETS_AVAILABLE,
-            "PIL": PIL_AVAILABLE,
-            "Librosa": LIBROSA_AVAILABLE,
-            "OpenCV": CV2_AVAILABLE,
-            "NumPy": NUMPY_AVAILABLE,
-            "HuggingFace Hub": HF_HUB_AVAILABLE
+            "HuggingFace Hub": HF_HUB_AVAILABLE,
+            "PIL (Images)": PIL_AVAILABLE,
+            "Librosa (Audio)": LIBROSA_AVAILABLE,
+            "OpenCV (Vidéo)": CV2_AVAILABLE
         }
         
-        status = "📦 État des dépendances:\n"
-        for name, available in deps.items():
-            status += f"{'✅' if available else '❌'} {name}\n"
-            
-        if not TORCH_AVAILABLE:
-            status += "\n⚠️ PyTorch requis pour l'entraînement!"
-        if not TRANSFORMERS_AVAILABLE:
-            status += "\n⚠️ Transformers requis pour les modèles!"
-            
-        return status
+        status = "📦 État des dépendances:\n\n"
+        
+        # Dépendances critiques
+        critical_deps = ["PyTorch", "Transformers", "Datasets"]
+        status += "🔥 CRITIQUES:\n"
+        for dep in critical_deps:
+            icon = "✅" if deps.get(dep.replace(" ", "").replace("(", "").replace(")", "")) else "❌"
+            status += f"{icon} {dep}\n"
+        
+        status += "\n🔧 OPTIONNELLES:\n"
+        optional_deps = ["NumPy", "HuggingFace Hub", "PIL (Images)", "Librosa (Audio)", "OpenCV (Vidéo)"]
+        for dep in optional_deps:
+            key = dep.replace(" ", "").replace("(", "").replace(")", "").replace("Images", "").replace("Audio", "").replace("Vidéo", "")
+            if key == "HuggingFaceHub":
+                key = "HuggingFace Hub"
+            icon = "✅" if deps.get(key) else "⚠️"
+            status += f"{icon} {dep}\n"
+        
+        # Système info
+        status += f"\n💻 SYSTÈME:\n"
+        status += f"🐍 Python: {sys.version.split()[0]}\n"
+        status += f"💾 Device: {self.device}\n"
+        
+        if TORCH_AVAILABLE and torch.cuda.is_available():
+            status += f"🚀 GPU: {torch.cuda.get_device_name()}\n"
+            status += f"🔋 VRAM: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f}GB\n"
         
+        return status
+    
     def load_model(self, model_name: str, model_type: str = "causal"):
         """Charge un modèle depuis Hugging Face"""
         if not TRANSFORMERS_AVAILABLE:
-            return "❌ Transformers non installé!"
+            return "❌ Transformers non installé! Utilisez l'outil d'installation."
             
         if not TORCH_AVAILABLE:
-            return "❌ PyTorch non installé!"
+            return "❌ PyTorch non installé! Utilisez l'outil d'installation."
+        
+        if not model_name.strip():
+            return "❌ Veuillez entrer un nom de modèle"
             
         try:
             logger.info(f"Chargement du modèle: {model_name}")
@@ -151,232 +198,98 @@ class MultimodalTrainer:
                     trust_remote_code=True
                 )
             
-            # Charge le tokenizer et processor
+            # Charge le tokenizer
             try:
                 self.current_tokenizer = AutoTokenizer.from_pretrained(
                     model_name, trust_remote_code=True
                 )
-            except:
-                logger.warning("Tokenizer non trouvé, utilisation d'un tokenizer par défaut")
+                if self.current_tokenizer.pad_token is None:
+                    self.current_tokenizer.pad_token = self.current_tokenizer.eos_token
+            except Exception as e:
+                logger.warning(f"Tokenizer non trouvé: {e}")
                 
+            # Charge le processor
             try:
                 self.current_processor = AutoProcessor.from_pretrained(
                     model_name, trust_remote_code=True
                 )
-            except:
-                logger.warning("Processor non trouvé")
+            except Exception as e:
+                logger.warning(f"Processor non trouvé: {e}")
                 
-            return f"✅ Modèle {model_name} chargé avec succès!"
+            return f"✅ Modèle {model_name} chargé avec succès!\nType: {type(self.current_model).__name__}"
             
         except Exception as e:
             error_msg = f"❌ Erreur lors du chargement: {str(e)}"
             logger.error(error_msg)
             return error_msg
     
-    def load_collection_datasets(self, collection_url: str):
-        """Charge tous les datasets d'une collection HF"""
+    def load_single_dataset(self, dataset_name: str, split: str = "train"):
+        """Charge un dataset individuel"""
         if not DATASETS_AVAILABLE:
-            return "❌ Datasets non installé!"
-            
-        try:
-            # Extrait l'ID de la collection depuis l'URL
-            collection_id = collection_url.split("/")[-1]
-            
-            # Pour l'instant, utilise l'API HF de base
-            try:
-                from huggingface_hub import list_datasets_in_collection
-                collection_items = list_datasets_in_collection(collection_id)
-            except ImportError:
-                return "❌ Fonction collection non disponible, ajoutez manuellement les datasets"
-            
-            datasets_info = []
-            loaded_datasets = []
-            
-            for item in collection_items:
-                try:
-                    dataset_name = item.id
-                    dataset = load_dataset(dataset_name, split='train', streaming=False)
-                    loaded_datasets.append(dataset)
-                    datasets_info.append(f"✅ {dataset_name}: {len(dataset)} exemples")
-                    logger.info(f"Dataset chargé: {dataset_name}")
-                except Exception as e:
-                    datasets_info.append(f"❌ {dataset_name}: {str(e)}")
-                    logger.error(f"Erreur dataset {dataset_name}: {e}")
+            return "❌ Datasets non installé! Utilisez l'outil d'installation."
             
-            # Combine tous les datasets
-            if loaded_datasets:
-                combined_dataset = concatenate_datasets(loaded_datasets)
-                self.training_data = combined_dataset
-                
-            result = f"📊 Collection chargée!\n" + "\n".join(datasets_info)
-            result += f"\n\n🔢 Total combiné: {len(self.training_data)} exemples"
-            
-            return result
+        if not dataset_name.strip():
+            return "❌ Veuillez entrer un nom de dataset"
             
-        except Exception as e:
-            error_msg = f"❌ Erreur collection: {str(e)}"
-            logger.error(error_msg)
-            return error_msg
-    
-    def load_single_dataset(self, dataset_name: str, split: str = "train"):
-        """Charge un dataset individuel"""
         try:
             dataset = load_dataset(dataset_name, split=split)
             
             if hasattr(self, 'training_data') and self.training_data:
-                # Combine avec les données existantes
                 self.training_data = concatenate_datasets([self.training_data, dataset])
             else:
                 self.training_data = dataset
                 
-            return f"✅ Dataset {dataset_name} ajouté! Total: {len(self.training_data)} exemples"
+            return f"✅ Dataset {dataset_name} ajouté!\n📊 Total: {len(self.training_data)} exemples\n🔍 Colonnes: {list(self.training_data.column_names)}"
             
         except Exception as e:
             error_msg = f"❌ Erreur dataset: {str(e)}"
             logger.error(error_msg)
             return error_msg
     
-    def process_multimodal_data(self, example):
-        """Traite les données multimodales pour l'entraînement"""
-        processed = {}
+    def simulate_training(self, output_dir: str, num_epochs: int, learning_rate: float, batch_size: int):
+        """Simulation d'entraînement (mode démo)"""
+        if not self.current_model and not self.training_data:
+            return "❌ Aucun modèle ou donnée chargé!"
         
-        # Traitement du texte
-        if 'text' in example:
-            if self.current_tokenizer:
-                tokens = self.current_tokenizer(
-                    example['text'], 
-                    truncation=True, 
-                    padding=True, 
-                    max_length=512,
-                    return_tensors="pt"
-                )
-                processed.update(tokens)
+        # Simulation
+        steps = ["🏗️ Préparation des données", "🔧 Configuration du modèle", "🚀 Début entraînement"]
+        result = "📋 SIMULATION D'ENTRAÎNEMENT:\n\n"
+        result += f"📂 Sortie: {output_dir}\n"
+        result += f"🔄 Époques: {num_epochs}\n"
+        result += f"📚 Learning rate: {learning_rate}\n"
+        result += f"📦 Batch size: {batch_size}\n\n"
         
-        # Traitement des images
-        if 'image' in example:
-            try:
-                if isinstance(example['image'], str):
-                    # URL ou chemin
-                    if example['image'].startswith('http'):
-                        response = requests.get(example['image'])
-                        image = Image.open(io.BytesIO(response.content))
-                    else:
-                        image = Image.open(example['image'])
-                else:
-                    image = example['image']
-                
-                if self.current_processor:
-                    image_inputs = self.current_processor(
-                        images=image, return_tensors="pt"
-                    )
-                    processed.update(image_inputs)
-                    
-            except Exception as e:
-                logger.warning(f"Erreur traitement image: {e}")
-        
-        # Traitement audio
-        if 'audio' in example:
-            try:
-                if isinstance(example['audio'], str):
-                    audio_data, sr = librosa.load(example['audio'], sr=16000)
-                else:
-                    audio_data = example['audio']
-                    sr = 16000
-                
-                # Conversion basique pour l'exemple
-                processed['audio'] = torch.tensor(audio_data).unsqueeze(0)
-                
-            except Exception as e:
-                logger.warning(f"Erreur traitement audio: {e}")
-        
-        return processed
-    
-    def start_training(self, 
-                      output_dir: str,
-                      num_epochs: int = 3,
-                      learning_rate: float = 5e-5,
-                      batch_size: int = 4,
-                      save_steps: int = 500):
-        """Lance l'entraînement du modèle"""
-        
-        if not self.current_model:
-            return "❌ Aucun modèle chargé!"
-        
-        if not self.training_data:
-            return "❌ Aucune donnée d'entraînement!"
-        
-        try:
-            # Préparation des données
-            logger.info("Préparation des données...")
-            
-            # Arguments d'entraînement
-            training_args = TrainingArguments(
-                output_dir=output_dir,
-                num_train_epochs=num_epochs,
-                per_device_train_batch_size=batch_size,
-                learning_rate=learning_rate,
-                logging_steps=50,
-                save_steps=save_steps,
-                eval_steps=save_steps,
-                warmup_steps=100,
-                fp16=torch.cuda.is_available(),
-                dataloader_num_workers=2,
-                remove_unused_columns=False,
-                report_to=None  # Désactive wandb/tensorboard
-            )
+        for i, step in enumerate(steps):
+            result += f"Étape {i+1}: {step} ✅\n"
             
-            # Data collator
-            data_collator = DataCollatorForLanguageModeling(
-                tokenizer=self.current_tokenizer,
-                mlm=False
-            ) if self.current_tokenizer else None
-            
-            # Trainer
-            trainer = Trainer(
-                model=self.current_model,
-                args=training_args,
-                train_dataset=self.training_data,
-                data_collator=data_collator,
-            )
-            
-            # Lance l'entraînement
-            logger.info("🚀 Début de l'entraînement...")
-            trainer.train()
-            
-            # Sauvegarde
-            trainer.save_model()
-            if self.current_tokenizer:
-                self.current_tokenizer.save_pretrained(output_dir)
-            
-            return f"✅ Entraînement terminé! Modèle sauvegardé dans {output_dir}"
-            
-        except Exception as e:
-            error_msg = f"❌ Erreur entraînement: {str(e)}"
-            logger.error(error_msg)
-            return error_msg
+        result += "\n⚠️ MODE DÉMO - Pour un vrai entraînement, installez PyTorch + Transformers"
+        return result
     
     def get_model_info(self):
         """Retourne les informations du modèle actuel"""
         if not self.current_model:
-            return "Aucun modèle chargé"
+            return "❌ Aucun modèle chargé"
         
-        info = f"📋 Modèle actuel:\n"
-        info += f"Type: {type(self.current_model).__name__}\n"
-        info += f"Device: {next(self.current_model.parameters()).device}\n"
+        info = f"📋 INFORMATIONS DU MODÈLE:\n\n"
+        info += f"🏷️ Type: {type(self.current_model).__name__}\n"
+        info += f"💾 Device: {next(self.current_model.parameters()).device}\n"
         
         # Compte les paramètres
-        total_params = sum(p.numel() for p in self.current_model.parameters())
-        trainable_params = sum(p.numel() for p in self.current_model.parameters() if p.requires_grad)
-        
-        info += f"Paramètres totaux: {total_params:,}\n"
-        info += f"Paramètres entraînables: {trainable_params:,}\n"
+        if TORCH_AVAILABLE:
+            total_params = sum(p.numel() for p in self.current_model.parameters())
+            trainable_params = sum(p.numel() for p in self.current_model.parameters() if p.requires_grad)
+            
+            info += f"🔢 Paramètres totaux: {total_params:,}\n"
+            info += f"🎯 Paramètres entraînables: {trainable_params:,}\n"
         
         if hasattr(self, 'training_data') and self.training_data:
-            info += f"\n📊 Données: {len(self.training_data)} exemples"
+            info += f"\n📊 DONNÉES:\n"
+            info += f"📈 Exemples: {len(self.training_data):,}\n"
+            info += f"📝 Colonnes: {list(self.training_data.column_names)}\n"
         
         return info
 
-# Initialisation du trainer
+# Initialisation
 trainer = MultimodalTrainer()
 
 # Interface Gradio
@@ -385,11 +298,55 @@ def create_interface():
         
         gr.Markdown("""
         # 🔥 Multimodal Training Hub
-        ### Entraînez vos modèles multimodaux avec facilité!
+        ### Plateforme d'entraînement de modèles multimodaux
         
-        Supporté: Texte 📝 • Images 🖼️ • Audio 🎵 • Vidéo 🎬
+        🤖 Modèles • 📊 Datasets • 🏋️ Training • 🛠️ Outils
         """)
         
+        with gr.Tab("🔧 Diagnostic"):
+            gr.Markdown("### 🩺 Vérification du système")
+            
+            with gr.Row():
+                check_deps_btn = gr.Button("🔍 Vérifier dépendances", variant="primary")
+                install_core_btn = gr.Button("📦 Installer packages critiques", variant="secondary")
+            
+            deps_status = gr.Textbox(
+                label="État des dépendances",
+                lines=15,
+                interactive=False
+            )
+            
+            with gr.Row():
+                install_transformers_btn = gr.Button("🤗 Installer Transformers")
+                install_torch_btn = gr.Button("🔥 Installer PyTorch")
+                install_datasets_btn = gr.Button("📊 Installer Datasets")
+            
+            install_status = gr.Textbox(
+                label="Status d'installation",
+                lines=5,
+                interactive=False
+            )
+            
+            # Events
+            check_deps_btn.click(trainer.check_dependencies, outputs=deps_status)
+            
+            install_transformers_btn.click(
+                lambda: trainer.install_dependencies(["transformers"]),
+                outputs=install_status
+            )
+            install_torch_btn.click(
+                lambda: trainer.install_dependencies(["torch", "torchvision"]),
+                outputs=install_status
+            )
+            install_datasets_btn.click(
+                lambda: trainer.install_dependencies(["datasets"]),
+                outputs=install_status
+            )
+            install_core_btn.click(
+                lambda: trainer.install_dependencies(["torch", "transformers", "datasets", "accelerate"]),
+                outputs=install_status
+            )
+        
         with gr.Tab("🤖 Modèle"):
             with gr.Row():
                 with gr.Column():
@@ -411,23 +368,25 @@ def create_interface():
                         interactive=False,
                         lines=8
                     )
+                    
+                    info_btn = gr.Button("ℹ️ Info modèle")
+                    model_info = gr.Textbox(
+                        label="Informations détaillées",
+                        interactive=False,
+                        lines=8
+                    )
             
             load_model_btn.click(
                 trainer.load_model,
                 inputs=[model_input, model_type],
                 outputs=model_status
             )
+            
+            info_btn.click(trainer.get_model_info, outputs=model_info)
         
         with gr.Tab("📊 Données"):
             with gr.Row():
                 with gr.Column():
-                    gr.Markdown("### 📦 Collection HuggingFace")
-                    collection_input = gr.Textbox(
-                        label="URL de la collection",
-                        placeholder="https://huggingface.co/collections/kvn420/op-67aa4430ba254a4ff0689742"
-                    )
-                    load_collection_btn = gr.Button("📥 Charger collection", variant="secondary")
-                    
                     gr.Markdown("### 📝 Dataset individuel")
                     dataset_input = gr.Textbox(
                         label="Nom du dataset",
@@ -437,7 +396,7 @@ def create_interface():
                         label="Split",
                         value="train"
                     )
-                    load_dataset_btn = gr.Button("➕ Ajouter dataset", variant="secondary")
+                    load_dataset_btn = gr.Button("➕ Ajouter dataset", variant="primary")
                     
                 with gr.Column():
                     data_status = gr.Textbox(
@@ -446,12 +405,6 @@ def create_interface():
                         lines=12
                     )
             
-            load_collection_btn.click(
-                trainer.load_collection_datasets,
-                inputs=collection_input,
-                outputs=data_status
-            )
-            
             load_dataset_btn.click(
                 trainer.load_single_dataset,
                 inputs=[dataset_input, dataset_split],
@@ -478,77 +431,33 @@ def create_interface():
                             minimum=1
                         )
                     
-                    with gr.Row():
-                        learning_rate = gr.Number(
-                            label="Learning rate",
-                            value=5e-5,
-                            step=1e-6
-                        )
-                        save_steps = gr.Number(
-                            label="Save steps",
-                            value=500,
-                            minimum=100
-                        )
+                    learning_rate = gr.Number(
+                        label="Learning rate",
+                        value=5e-5,
+                        step=1e-6
+                    )
                     
-                    train_btn = gr.Button("🚀 Lancer l'entraînement", variant="primary", size="lg")
+                    train_btn = gr.Button("🚀 Simuler entraînement", variant="primary", size="lg")
                     
                 with gr.Column():
                     training_status = gr.Textbox(
                         label="Status de l'entraînement",
                         interactive=False,
-                        lines=8
-                    )
-                    
-                    info_btn = gr.Button("ℹ️ Info modèle")
-                    model_info = gr.Textbox(
-                        label="Informations du modèle",
-                        interactive=False,
-                        lines=6
+                        lines=12
                     )
             
             train_btn.click(
-                trainer.start_training,
-                inputs=[output_dir, num_epochs, learning_rate, batch_size, save_steps],
+                trainer.simulate_training,
+                inputs=[output_dir, num_epochs, learning_rate, batch_size],
                 outputs=training_status
             )
-            
-            info_btn.click(
-                trainer.get_model_info,
-                outputs=model_info
-            )
         
-        with gr.Tab("📚 Aide"):
-            gr.Markdown("""
-            ## 🚀 Guide d'utilisation
-            
-            ### 1. Charger un modèle
-            - Entrez le nom d'un modèle HuggingFace (ex: `kvn420/Tenro_V4.1`)
-            - Choisissez le type (causal pour génération, base pour embedding)
-            - Cliquez sur "Charger le modèle"
-            
-            ### 2. Ajouter des données
-            **Collection:** Chargez tous les datasets d'une collection HF
-            **Dataset individuel:** Ajoutez un dataset spécifique
-            
-            ### 3. Entraîner
-            - Configurez les paramètres d'entraînement
-            - Lancez l'entraînement avec "🚀 Lancer l'entraînement"
-            
-            ### 📋 Formats supportés
-            - **Texte:** Colonnes `text`, `prompt`, `conversation`
-            - **Images:** Colonnes `image`, `images` (URLs ou chemins)
-            - **Audio:** Colonnes `audio` (fichiers audio)
-            - **Vidéo:** Colonnes `video` (fichiers vidéo)
-            
-            ### ⚡ Conseils
-            - Utilisez un GPU pour l'entraînement (T4, A10G recommandé)
-            - Ajustez le batch_size selon votre mémoire GPU
-            - Sauvegardez régulièrement avec save_steps
-            """)
+        # Auto-check au démarrage
+        app.load(trainer.check_dependencies, outputs=deps_status)
     
     return app
 
-# Lancement de l'application
+# Lancement
 if __name__ == "__main__":
     app = create_interface()
     app.launch(share=True, server_name="0.0.0.0", server_port=7860)