Update app.py

app.py

@@ -44,7 +44,7 @@ def check_and_import_dependencies():
     """Vérifie et importe toutes les dépendances"""
     global numpy, torch, NUMPY_AVAILABLE, TORCH_AVAILABLE, TRANSFORMERS_AVAILABLE
     global DATASETS_AVAILABLE, HF_HUB_AVAILABLE, PIL_AVAILABLE, LIBROSA_AVAILABLE, CV2_AVAILABLE
-    global AutoTokenizer, AutoModel, AutoProcessor, AutoModelForCausalLM
+    global AutoTokenizer, AutoModel, AutoProcessor, AutoModelForCausalLM, AutoConfig
     global TrainingArguments, Trainer, DataCollatorForLanguageModeling
     global Dataset, load_dataset, concatenate_datasets, HfApi, Image, librosa, cv2
     
@@ -67,14 +67,14 @@ def check_and_import_dependencies():
     # Transformers
     try:
         from transformers import (
-            AutoTokenizer, AutoModel, AutoProcessor, 
+            AutoTokenizer, AutoModel, AutoProcessor, AutoConfig,
             AutoModelForCausalLM, TrainingArguments, Trainer,
             DataCollatorForLanguageModeling
         )
         TRANSFORMERS_AVAILABLE = True
     except ImportError:
         TRANSFORMERS_AVAILABLE = False
-        AutoTokenizer = AutoModel = AutoProcessor = None
+        AutoTokenizer = AutoModel = AutoProcessor = AutoConfig = None
         AutoModelForCausalLM = TrainingArguments = Trainer = None
         DataCollatorForLanguageModeling = None
     
@@ -144,16 +144,17 @@ class MultimodalTrainer:
         """Installe les dépendances manquantes"""
         installation_results = []
         
-        # Mapping des packages
+        # Mapping des packages avec versions spécifiques
         package_mapping = {
-            "torch": "torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cpu",
-            "transformers": "transformers",
-            "datasets": "datasets",
-            "accelerate": "accelerate",
-            "pillow": "pillow",
-            "librosa": "librosa",
-            "opencv": "opencv-python",
-            "huggingface_hub": "huggingface_hub"
+            "torch": "torch==2.1.0 torchvision==0.16.0 torchaudio==2.1.0 --index-url https://download.pytorch.org/whl/cpu",
+            "transformers": "transformers>=4.46.2",
+            "datasets": "datasets>=2.21.0",
+            "accelerate": "accelerate>=1.1.0",
+            "pillow": "pillow>=10.1.0",
+            "librosa": "librosa>=0.10.1",
+            "opencv": "opencv-python-headless>=4.8.1.78",
+            "huggingface_hub": "huggingface_hub>=0.26.0",
+            "qwen": "qwen-vl-utils>=0.0.8"
         }
         
         for package in packages_to_install:
@@ -167,7 +168,7 @@ class MultimodalTrainer:
                 try:
                     subprocess.check_call([
                         sys.executable, "-m", "pip", "install", 
-                        "torch", "torchvision", "torchaudio", 
+                        "torch==2.1.0", "torchvision==0.16.0", "torchaudio==2.1.0",
                         "--index-url", "https://download.pytorch.org/whl/cpu",
                         "--quiet"
                     ])
@@ -230,145 +231,222 @@ class MultimodalTrainer:
             status += f"🚀 GPU: {torch.cuda.get_device_name()}\n"
             status += f"🔋 VRAM: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f}GB\n"
         
+        # Versions spécifiques
+        if TRANSFORMERS_AVAILABLE:
+            import transformers
+            status += f"🤗 Transformers: {transformers.__version__}\n"
+        
         return status
     
-    def load_model(self, model_name: str, model_type: str = "causal"):
-        """Charge un modèle depuis Hugging Face"""
+    def load_model_safe(self, model_name: str):
+        """Chargement sécurisé du modèle avec gestion d'erreurs avancée"""
         if not TRANSFORMERS_AVAILABLE:
-            return "❌ Transformers non installé! Utilisez l'outil d'installation."
+            return "❌ Transformers non installé! Utilisez l'outil d'installation.", None, None
             
         if not TORCH_AVAILABLE or not torch:
-            return "❌ PyTorch non installé! Utilisez l'outil d'installation."
+            return "❌ PyTorch non installé! Utilisez l'outil d'installation.", None, None
         
-        if not model_name.strip():
-            return "❌ Veuillez entrer un nom de modèle"
-            
         try:
-            logger.info(f"Chargement du modèle: {model_name}")
+            logger.info(f"Chargement sécurisé du modèle: {model_name}")
             
-            # Stratégies de chargement multiples
-            model_loaded = False
-            error_messages = []
+            # Étape 1: Vérification de la configuration
+            try:
+                config = AutoConfig.from_pretrained(model_name, trust_remote_code=True)
+                logger.info(f"Configuration chargée: {config.model_type}")
+            except Exception as e:
+                return f"❌ Erreur configuration: {str(e)}", None, None
             
-            # Stratégie 1: AutoModelForCausalLM avec trust_remote_code
-            if model_type == "causal" and not model_loaded:
-                try:
-                    self.current_model = AutoModelForCausalLM.from_pretrained(
+            # Étape 2: Chargement du tokenizer
+            tokenizer = None
+            try:
+                tokenizer = AutoTokenizer.from_pretrained(
+                    model_name, 
+                    trust_remote_code=True,
+                    use_fast=False
+                )
+                if tokenizer.pad_token is None:
+                    tokenizer.pad_token = tokenizer.eos_token
+                logger.info("Tokenizer chargé avec succès")
+            except Exception as e:
+                logger.warning(f"Tokenizer non trouvé: {e}")
+                return f"❌ Erreur tokenizer: {str(e)}", None, None
+            
+            # Étape 3: Chargement du modèle avec stratégies multiples
+            model = None
+            loading_strategies = [
+                {
+                    "name": "AutoModelForCausalLM standard",
+                    "loader": lambda: AutoModelForCausalLM.from_pretrained(
                         model_name,
                         torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
                         device_map="auto" if torch.cuda.is_available() else None,
-                        trust_remote_code=True
+                        trust_remote_code=True,
+                        low_cpu_mem_usage=True
                     )
-                    model_loaded = True
-                except Exception as e:
-                    error_messages.append(f"AutoModelForCausalLM: {str(e)}")
-            
-            # Stratégie 2: AutoModel générique
-            if not model_loaded:
-                try:
-                    self.current_model = AutoModel.from_pretrained(
+                },
+                {
+                    "name": "AutoModelForCausalLM avec config explicite",
+                    "loader": lambda: AutoModelForCausalLM.from_pretrained(
                         model_name,
+                        config=config,
                         torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
                         device_map="auto" if torch.cuda.is_available() else None,
-                        trust_remote_code=True
+                        trust_remote_code=True,
+                        low_cpu_mem_usage=True,
+                        attn_implementation="eager"
                     )
-                    model_loaded = True
-                except Exception as e:
-                    error_messages.append(f"AutoModel: {str(e)}")
-            
-            # Stratégie 3: Détection automatique basée sur le nom
-            if not model_loaded and any(x in model_name.lower() for x in ['llama', 'mistral', 'qwen', 'phi']):
-                try:
-                    # Pour les modèles de type LLaMA/Mistral/Qwen
-                    from transformers import LlamaForCausalLM, MistralForCausalLM
-                    
-                    if 'llama' in model_name.lower():
-                        self.current_model = LlamaForCausalLM.from_pretrained(
-                            model_name,
-                            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-                            device_map="auto" if torch.cuda.is_available() else None,
-                            trust_remote_code=True
-                        )
-                    elif 'mistral' in model_name.lower():
-                        self.current_model = MistralForCausalLM.from_pretrained(
-                            model_name,
-                            torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-                            device_map="auto" if torch.cuda.is_available() else None,
-                            trust_remote_code=True
-                        )
-                    model_loaded = True
-                except Exception as e:
-                    error_messages.append(f"Modèle spécifique: {str(e)}")
-            
-            # Stratégie 4: Configuration manuelle
-            if not model_loaded:
-                try:
-                    # Télécharge la configuration d'abord
-                    from transformers import AutoConfig
-                    config = AutoConfig.from_pretrained(model_name, trust_remote_code=True)
-                    
-                    # Force le model_type si manquant
-                    if not hasattr(config, 'model_type') or config.model_type is None:
-                        # Détection basée sur l'architecture
-                        if hasattr(config, 'architectures') and config.architectures:
-                            arch = config.architectures[0].lower()
-                            if 'llama' in arch:
-                                config.model_type = 'llama'
-                            elif 'mistral' in arch:
-                                config.model_type = 'mistral'
-                            elif 'qwen' in arch:
-                                config.model_type = 'qwen2'
-                            elif 'phi' in arch:
-                                config.model_type = 'phi'
-                            else:
-                                config.model_type = 'llama'  # Par défaut
-                    
-                    self.current_model = AutoModelForCausalLM.from_pretrained(
+                },
+                {
+                    "name": "AutoModel générique",
+                    "loader": lambda: AutoModel.from_pretrained(
                         model_name,
-                        config=config,
                         torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
                         device_map="auto" if torch.cuda.is_available() else None,
-                        trust_remote_code=True
+                        trust_remote_code=True,
+                        low_cpu_mem_usage=True
                     )
-                    model_loaded = True
+                }
+            ]
+            
+            last_error = None
+            for strategy in loading_strategies:
+                try:
+                    logger.info(f"Tentative: {strategy['name']}")
+                    model = strategy["loader"]()
+                    logger.info(f"✅ Succès avec: {strategy['name']}")
+                    break
                 except Exception as e:
-                    error_messages.append(f"Configuration manuelle: {str(e)}")
+                    last_error = str(e)
+                    logger.warning(f"❌ Échec {strategy['name']}: {e}")
+                    continue
             
-            if not model_loaded:
-                return f"❌ Impossible de charger le modèle. Erreurs:\n" + "\n".join(error_messages)
+            if model is None:
+                return f"❌ Toutes les stratégies ont échoué. Dernière erreur: {last_error}", None, None
             
-            # Charge le tokenizer
+            # Étape 4: Chargement du processor (optionnel)
+            processor = None
             try:
-                self.current_tokenizer = AutoTokenizer.from_pretrained(
-                    model_name, trust_remote_code=True
-                )
-                if self.current_tokenizer.pad_token is None:
-                    self.current_tokenizer.pad_token = self.current_tokenizer.eos_token
+                processor = AutoProcessor.from_pretrained(model_name, trust_remote_code=True)
+                logger.info("Processor chargé avec succès")
             except Exception as e:
-                logger.warning(f"Tokenizer non trouvé: {e}")
-                try:
-                    # Essaye avec un tokenizer générique
-                    from transformers import LlamaTokenizer
-                    self.current_tokenizer = LlamaTokenizer.from_pretrained(
-                        model_name, trust_remote_code=True
-                    )
-                except:
-                    logger.warning("Aucun tokenizer trouvé")
-                
-            # Charge le processor
+                logger.warning(f"Processor non disponible: {e}")
+            
+            return "✅ Modèle chargé avec succès!", model, tokenizer, processor
+            
+        except Exception as e:
+            error_msg = f"❌ Erreur critique: {str(e)}"
+            logger.error(error_msg)
+            return error_msg, None, None
+    
+    def load_model(self, model_name: str, model_type: str = "causal"):
+        """Charge un modèle depuis Hugging Face avec gestion d'erreurs améliorée"""
+        if not model_name.strip():
+            return "❌ Veuillez entrer un nom de modèle"
+        
+        # Utilise la méthode sécurisée
+        result = self.load_model_safe(model_name)
+        
+        if len(result) == 4:  # Succès
+            message, model, tokenizer, processor = result
+            self.current_model = model
+            self.current_tokenizer = tokenizer
+            self.current_processor = processor
+            
+            # Informations détaillées
+            info = f"{message}\n"
+            info += f"🏷️ Type: {type(model).__name__}\n"
+            if hasattr(model, 'config'):
+                info += f"🏗️ Architecture: {getattr(model.config, 'architectures', ['Inconnue'])[0] if hasattr(model.config, 'architectures') else 'Inconnue'}\n"
+                info += f"📋 Model type: {getattr(model.config, 'model_type', 'Non défini')}\n"
+            
+            if TORCH_AVAILABLE and torch:
+                info += f"💾 Device: {next(model.parameters()).device}\n"
+                total_params = sum(p.numel() for p in model.parameters())
+                info += f"🔢 Paramètres: {total_params:,}\n"
+            
+            return info
+        else:
+            # Erreur
+            return result[0]
+    
+    def diagnose_model(self, model_name: str):
+        """Diagnostique avancé d'un modèle"""
+        if not model_name.strip():
+            return "❌ Veuillez entrer un nom de modèle"
+        
+        try:
+            result = f"🔍 DIAGNOSTIC APPROFONDI: {model_name}\n\n"
+            
+            # Vérification de l'existence
             try:
-                self.current_processor = AutoProcessor.from_pretrained(
-                    model_name, trust_remote_code=True
-                )
+                config = AutoConfig.from_pretrained(model_name, trust_remote_code=True)
+                result += "✅ Modèle accessible sur Hugging Face\n\n"
+                
+                # Analyse de la configuration
+                result += "📋 CONFIGURATION:\n"
+                result += f"🏷️ Model type: {getattr(config, 'model_type', '❌ NON DÉFINI')}\n"
+                result += f"🏗️ Architectures: {getattr(config, 'architectures', ['❌ NON DÉFINI'])}\n"
+                result += f"📚 Vocab size: {getattr(config, 'vocab_size', 'Inconnu'):,}\n"
+                result += f"🧠 Hidden size: {getattr(config, 'hidden_size', 'Inconnu')}\n"
+                result += f"🔢 Layers: {getattr(config, 'num_hidden_layers', 'Inconnu')}\n"
+                result += f"🎯 Attention heads: {getattr(config, 'num_attention_heads', 'Inconnu')}\n"
+                
+                # Vérification des problèmes courants
+                result += "\n🔧 ANALYSE DES PROBLÈMES:\n"
+                
+                if not hasattr(config, 'model_type') or config.model_type is None:
+                    result += "⚠️ PROBLÈME: model_type manquant\n"
+                    if hasattr(config, 'architectures') and config.architectures:
+                        arch = config.architectures[0].lower()
+                        suggested_type = None
+                        if 'qwen' in arch:
+                            suggested_type = 'qwen2' if 'qwen2' in arch else 'qwen'
+                        elif 'llama' in arch:
+                            suggested_type = 'llama'
+                        elif 'mistral' in arch:
+                            suggested_type = 'mistral'
+                        elif 'phi' in arch:
+                            suggested_type = 'phi'
+                        
+                        if suggested_type:
+                            result += f"💡 Type suggéré: {suggested_type}\n"
+                else:
+                    result += f"✅ Model type défini: {config.model_type}\n"
+                
+                # Vérification de la compatibilité avec Transformers
+                if hasattr(config, 'architectures') and config.architectures:
+                    arch = config.architectures[0]
+                    if 'Qwen2_5OmniForCausalLM' in arch:
+                        result += "⚠️ Architecture Qwen2.5-Omni détectée\n"
+                        result += "💡 Nécessite Transformers >= 4.45.0\n"
+                        if TRANSFORMERS_AVAILABLE:
+                            import transformers
+                            current_version = transformers.__version__
+                            result += f"📦 Version actuelle: {current_version}\n"
+                
+                # Stratégies de chargement recommandées
+                result += "\n🎯 STRATÉGIES DE CHARGEMENT:\n"
+                result += "1️⃣ AutoModelForCausalLM avec trust_remote_code=True\n"
+                result += "2️⃣ Configuration explicite si model_type manquant\n"
+                result += "3️⃣ Fallback vers AutoModel générique\n"
+                
+                result += "\n✅ Diagnostic terminé - Chargement possible avec adaptations"
+                
             except Exception as e:
-                logger.warning(f"Processor non trouvé: {e}")
+                result += f"❌ Erreur d'accès: {str(e)}\n"
                 
-            return f"✅ Modèle {model_name} chargé avec succès!\nType: {type(self.current_model).__name__}\nArchitecture: {getattr(self.current_model.config, 'architectures', ['Inconnue'])[0] if hasattr(self.current_model, 'config') else 'Inconnue'}"
+                # Suggestions basées sur l'erreur
+                if "404" in str(e):
+                    result += "💡 Le modèle n'existe pas ou n'est pas public\n"
+                elif "token" in str(e).lower():
+                    result += "💡 Un token d'authentification pourrait être nécessaire\n"
+                else:
+                    result += "💡 Vérifiez le nom du modèle et votre connexion\n"
+            
+            return result
             
         except Exception as e:
-            error_msg = f"❌ Erreur lors du chargement: {str(e)}"
-            logger.error(error_msg)
-            return error_msg
+            return f"❌ Erreur diagnostic: {str(e)}"
     
     def load_single_dataset(self, dataset_name: str, split: str = "train"):
         """Charge un dataset individuel"""
@@ -437,56 +515,8 @@ class MultimodalTrainer:
             info += f"\n📊 DONNÉES:\n"
             info += f"📈 Exemples: {len(self.training_data):,}\n"
             info += f"📝 Colonnes: {list(self.training_data.column_names)}\n"
-        
-    def diagnose_model(self, model_name: str):
-        """Diagnostique un modèle avant chargement"""
-        if not model_name.strip():
-            return "❌ Veuillez entrer un nom de modèle"
-        
-        try:
-            from transformers import AutoConfig
-            import requests
-            
-            result = f"🔍 DIAGNOSTIC DU MODÈLE: {model_name}\n\n"
             
-            # Vérification de l'existence
-            try:
-                config = AutoConfig.from_pretrained(model_name, trust_remote_code=True)
-                result += "✅ Modèle accessible\n"
-                
-                # Informations sur la configuration
-                result += f"📋 Type de modèle: {getattr(config, 'model_type', 'Non défini')}\n"
-                result += f"🏗️ Architecture: {getattr(config, 'architectures', ['Inconnue'])}\n"
-                result += f"📚 Vocabulaire: {getattr(config, 'vocab_size', 'Inconnu')}\n"
-                result += f"🧠 Couches cachées: {getattr(config, 'hidden_size', 'Inconnu')}\n"
-                result += f"🔢 Nombre de couches: {getattr(config, 'num_hidden_layers', 'Inconnu')}\n"
-                
-                # Recommandations
-                if not hasattr(config, 'model_type') or config.model_type is None:
-                    result += "\n⚠️ PROBLÈME: model_type manquant\n"
-                    result += "💡 SOLUTION: Le chargeur essaiera de détecter automatiquement\n"
-                    
-                    if hasattr(config, 'architectures') and config.architectures:
-                        arch = config.architectures[0].lower()
-                        if 'llama' in arch:
-                            result += "🎯 Type détecté: LLaMA\n"
-                        elif 'mistral' in arch:
-                            result += "🎯 Type détecté: Mistral\n"
-                        elif 'qwen' in arch:
-                            result += "🎯 Type détecté: Qwen\n"
-                        elif 'phi' in arch:
-                            result += "🎯 Type détecté: Phi\n"
-                
-                result += "\n✅ Chargement possible avec les stratégies multiples"
-                
-            except Exception as e:
-                result += f"❌ Erreur d'accès: {str(e)}\n"
-                result += "💡 Vérifiez que le modèle existe et est public\n"
-            
-            return result
-            
-        except Exception as e:
-            return f"❌ Erreur diagnostic: {str(e)}"
+        return info
 
 # Initialisation
 trainer = MultimodalTrainer()
@@ -497,17 +527,18 @@ def create_interface():
         
         gr.Markdown("""
         # 🔥 Multimodal Training Hub
-        ### Plateforme d'entraînement de modèles multimodaux
+        ### Plateforme d'entraînement de modèles multimodaux optimisée pour Qwen2.5-Omni
         
         🤖 Modèles • 📊 Datasets • 🏋️ Training • 🛠️ Outils
         """)
         
         with gr.Tab("🔧 Diagnostic"):
-            gr.Markdown("### 🩺 Vérification du système")
+            gr.Markdown("### 🩺 Vérification du système et installation")
             
             with gr.Row():
                 check_deps_btn = gr.Button("🔍 Vérifier dépendances", variant="primary")
                 install_core_btn = gr.Button("📦 Installer packages critiques", variant="secondary")
+                install_qwen_btn = gr.Button("🎯 Support Qwen2.5", variant="secondary")
             
             deps_status = gr.Textbox(
                 label="État des dépendances",
@@ -545,28 +576,41 @@ def create_interface():
                 lambda: trainer.install_dependencies(["torch", "transformers", "datasets", "accelerate"]),
                 outputs=install_status
             )
+            install_qwen_btn.click(
+                lambda: trainer.install_dependencies(["transformers", "qwen"]),
+                outputs=install_status
+            )
         
         with gr.Tab("🤖 Modèle"):
             with gr.Row():
                 with gr.Column():
                     model_input = gr.Textbox(
                         label="Nom du modèle HuggingFace",
-                        placeholder="microsoft/DialoGPT-medium",
-                        value="microsoft/DialoGPT-medium"
+                        placeholder="kvn420/Tenro_V4.1",
+                        value="kvn420/Tenro_V4.1"
                     )
                     model_type = gr.Dropdown(
                         label="Type de modèle",
                         choices=["causal", "base"],
                         value="causal"
                     )
-                    load_model_btn = gr.Button("🔄 Charger le modèle", variant="primary")
-                    diagnose_btn = gr.Button("🔍 Diagnostiquer le modèle", variant="secondary")
+                    
+                    with gr.Row():
+                        load_model_btn = gr.Button("🔄 Charger le modèle", variant="primary")
+                        diagnose_btn = gr.Button("🔍 Diagnostiquer", variant="secondary")
+                    
+                    gr.Markdown("""
+                    💡 **Modèles testés:**
+                    - `kvn420/Tenro_V4.1` (Qwen2.5-Omni)
+                    - `Qwen/Qwen2.5-7B-Instruct`
+                    - `microsoft/DialoGPT-medium`
+                    """)
                     
                 with gr.Column():
                     model_status = gr.Textbox(
                         label="Status du modèle",
                         interactive=False,
-                        lines=8
+                        lines=10
                     )
                     
                     info_btn = gr.Button("ℹ️ Info modèle")
@@ -659,23 +703,4 @@ def create_interface():
                     
                 with gr.Column():
                     training_status = gr.Textbox(
-                        label="Status de l'entraînement",
-                        interactive=False,
-                        lines=12
-                    )
-            
-            train_btn.click(
-                trainer.simulate_training,
-                inputs=[output_dir, num_epochs, learning_rate, batch_size],
-                outputs=training_status
-            )
-        
-        # Auto-check au démarrage
-        app.load(trainer.check_dependencies, outputs=deps_status)
-    
-    return app
-
-# Lancement
-if __name__ == "__main__":
-    app = create_interface()
-    app.launch(share=True, server_name="0.0.0.0", server_port=7860)
+                        label="Status