Upload 3 files

chatbot.py

@@ -0,0 +1,424 @@
+# chatbot_enhanced.py
+
+import random
+import re
+from datetime import datetime
+from model_mt5 import call_mt5_model
+
+class HumanChatbot:
+    def __init__(self):
+        self.conversation_history = []
+        self.user_name = None
+        self.context = {}
+        
+    def get_time_greeting(self):
+        """Retourne un salut adapté à l'heure"""
+        hour = datetime.now().hour
+        if 5 <= hour < 12:
+            return {"fr": "Bonjour", "en": "Good morning", "es": "Buenos días", "de": "Guten Morgen"}
+        elif 12 <= hour < 18:
+            return {"fr": "Bonjour", "en": "Good afternoon", "es": "Buenas tardes", "de": "Guten Tag"}
+        else:
+            return {"fr": "Bonsoir", "en": "Good evening", "es": "Buenas noches", "de": "Guten Abend"}
+
+    def detect_language(self, text):
+        """Détecte la langue principale du texte"""
+        text_lower = text.lower()
+        
+        # Mots clés par langue
+        lang_indicators = {
+            "fr": ["bonjour", "salut", "merci", "comment", "ça", "va", "oui", "non", "je", "tu", "vous"],
+            "en": ["hello", "hi", "thank", "how", "are", "you", "yes", "no", "i", "you", "the"],
+            "es": ["hola", "gracias", "cómo", "estás", "sí", "no", "yo", "tú", "el", "la"],
+            "de": ["hallo", "danke", "wie", "geht", "ja", "nein", "ich", "du", "der", "die"]
+        }
+        
+        scores = {}
+        for lang, words in lang_indicators.items():
+            scores[lang] = sum(1 for word in words if word in text_lower)
+        
+        return max(scores, key=scores.get) if max(scores.values()) > 0 else "fr"
+
+    def extract_user_name(self, text):
+        """Extrait le nom de l'utilisateur"""
+        patterns = [
+            r"je m'appelle (\w+)",
+            r"mon nom est (\w+)",
+            r"i'?m (\w+)",
+            r"my name is (\w+)",
+            r"me llamo (\w+)",
+            r"ich heiße (\w+)"
+        ]
+        
+        for pattern in patterns:
+            match = re.search(pattern, text.lower())
+            if match:
+                return match.group(1).capitalize()
+        return None
+
+    def get_emotional_response(self, user_input, lang):
+        """Génère une réponse émotionnelle selon le contexte"""
+        input_lower = user_input.lower()
+        
+        # Détection d'émotions
+        emotions = {
+            "happy": {
+                "keywords": ["content", "heureux", "joie", "super", "génial", "happy", "great", "awesome", "feliz", "genial"],
+                "responses": {
+                    "fr": ["C'est formidable ! 😊", "Je suis ravi de l'entendre ! 🎉", "Ça me fait plaisir ! ✨"],
+                    "en": ["That's wonderful! 😊", "I'm so happy to hear that! 🎉", "That's great news! ✨"],
+                    "es": ["¡Qué maravilloso! 😊", "¡Me alegra escuchar eso! 🎉", "¡Qué buena noticia! ✨"],
+                    "de": ["Das ist wunderbar! 😊", "Das freut mich sehr! 🎉", "Tolle Neuigkeiten! ✨"]
+                }
+            },
+            "sad": {
+                "keywords": ["triste", "mal", "difficile", "problème", "sad", "bad", "difficult", "problem", "triste", "mal", "schwierig"],
+                "responses": {
+                    "fr": ["Je suis désolé de l'entendre... 😔", "Ça doit être difficile pour vous.", "Je comprends votre situation."],
+                    "en": ["I'm sorry to hear that... 😔", "That must be difficult for you.", "I understand your situation."],
+                    "es": ["Lamento escuchar eso... 😔", "Debe ser difícil para ti.", "Entiendo tu situación."],
+                    "de": ["Das tut mir leid zu hören... 😔", "Das muss schwierig für Sie sein.", "Ich verstehe Ihre Situation."]
+                }
+            },
+            "confused": {
+                "keywords": ["comprends pas", "confus", "don't understand", "confused", "no entiendo", "verstehe nicht"],
+                "responses": {
+                    "fr": ["Pas de souci, je vais essayer d'être plus clair.", "Laissez-moi reformuler ça.", "Je peux vous expliquer autrement."],
+                    "en": ["No worries, let me try to be clearer.", "Let me rephrase that.", "I can explain it differently."],
+                    "es": ["No te preocupes, intentaré ser más claro.", "Déjame reformular eso.", "Puedo explicarlo de otra manera."],
+                    "de": ["Kein Problem, ich versuche klarer zu sein.", "Lassen Sie mich das umformulieren.", "Ich kann es anders erklären."]
+                }
+            }
+        }
+        
+        for emotion, data in emotions.items():
+            if any(keyword in input_lower for keyword in data["keywords"]):
+                return random.choice(data["responses"][lang])
+        
+        return None
+
+    def detect_problem_keywords(self, user_input, lang):
+        """Détecte si l'utilisateur présente un problème technique ou demande de l'aide"""
+        input_lower = user_input.lower()
+        
+        problem_keywords = {
+            "fr": [
+                "problème", "pb", "erreur", "bug", "panne", "défaut", "dysfonctionnement",
+                "ça marche pas", "ne fonctionne pas", "ne marche pas", "cassé", "bloqué",
+                "aide", "aider", "comment", "comment faire", "solution", "résoudre",
+                "pourquoi", "expliquer", "expliquez", "que faire", "urgent", "besoin d'aide"
+            ],
+            "en": [
+                "problem", "issue", "error", "bug", "broken", "not working", "doesn't work",
+                "help", "how to", "how do", "solution", "solve", "fix", "explain",
+                "why", "what to do", "urgent", "need help", "trouble", "difficulty"
+            ],
+            "es": [
+                "problema", "error", "fallo", "no funciona", "roto", "bloqueado",
+                "ayuda", "ayudar", "cómo", "solución", "resolver", "explicar",
+                "por qué", "qué hacer", "urgente", "necesito ayuda"
+            ],
+            "de": [
+                "problem", "fehler", "bug", "kaputt", "funktioniert nicht", "geht nicht",
+                "hilfe", "helfen", "wie", "lösung", "lösen", "erklären",
+                "warum", "was tun", "dringend", "brauche hilfe"
+            ]
+        }
+        
+        # Vérifier si le message contient des mots-clés de problème
+        keywords = problem_keywords.get(lang, problem_keywords["fr"])
+        return any(keyword in input_lower for keyword in keywords)
+
+    def get_contextual_response(self, user_input, lang):
+        """Génère une réponse contextuelle"""
+        input_lower = user_input.lower()
+        
+        # NOUVEAU: Détection de problèmes - transmettre directement au modèle
+        if self.detect_problem_keywords(user_input, lang):
+            return None  # Retourner None pour passer au modèle MT5
+        
+        # Questions sur le chatbot
+        if any(word in input_lower for word in ["qui es-tu", "what are you", "quién eres", "wer bist du"]):
+            responses = {
+                "fr": "Je suis votre assistant virtuel ! Je suis là pour discuter et vous aider du mieux que je peux. 🤖",
+                "en": "I'm your virtual assistant! I'm here to chat and help you as best I can. 🤖",
+                "es": "¡Soy tu asistente virtual! Estoy aquí para charlar y ayudarte lo mejor que pueda. 🤖",
+                "de": "Ich bin Ihr virtueller Assistent! Ich bin hier, um zu plaudern und Ihnen zu helfen, so gut ich kann. 🤖"
+            }
+            return responses[lang]
+        
+        # Questions sur l'humeur
+        if any(word in input_lower for word in ["comment tu vas", "how are you", "cómo estás", "wie geht es dir"]):
+            responses = {
+                "fr": ["Je vais bien, merci ! Et vous ? 😊", "Ça va très bien ! Comment allez-vous ?", "Parfait, merci de demander ! Et vous ?"],
+                "en": ["I'm doing well, thanks! How about you? 😊", "I'm great! How are you doing?", "Perfect, thanks for asking! And you?"],
+                "es": ["¡Estoy bien, gracias! ¿Y tú? 😊", "¡Muy bien! ¿Cómo estás?", "¡Perfecto, gracias por preguntar! ¿Y tú?"],
+                "de": ["Mir geht es gut, danke! Und Ihnen? 😊", "Mir geht es sehr gut! Wie geht es Ihnen?", "Perfekt, danke der Nachfrage! Und Ihnen?"]
+            }
+            return random.choice(responses[lang])
+        
+        # Expressions de politesse
+        if any(word in input_lower for word in ["s'il vous plaît", "please", "por favor", "bitte"]):
+            responses = {
+                "fr": "Bien sûr, avec plaisir ! 😊",
+                "en": "Of course, with pleasure! 😊",
+                "es": "¡Por supuesto, con mucho gusto! 😊",
+                "de": "Natürlich, gerne! 😊"
+            }
+            return responses[lang]
+        
+        return None
+
+    def get_rule_based_response(self, user_input):
+        """Version améliorée des réponses basées sur des règles"""
+        input_lower = user_input.lower()
+        lang = self.detect_language(user_input)
+        
+        # Extraction du nom si présent
+        name = self.extract_user_name(user_input)
+        if name:
+            self.user_name = name
+            responses = {
+                "fr": f"Ravi de faire votre connaissance, {name} ! 😊",
+                "en": f"Nice to meet you, {name}! 😊",
+                "es": f"¡Encantado de conocerte, {name}! 😊",
+                "de": f"Schön Sie kennenzulernen, {name}! 😊"
+            }
+            return responses[lang]
+        
+        # Réponse émotionnelle
+        emotional_response = self.get_emotional_response(user_input, lang)
+        if emotional_response:
+            return emotional_response
+        
+        # Réponse contextuelle
+        contextual_response = self.get_contextual_response(user_input, lang)
+        if contextual_response:
+            return contextual_response
+        
+        # Salutations avec variation
+        greetings = {
+            "fr": ["bonjour", "salut", "bonsoir", "coucou", "hey"],
+            "en": ["hello", "hi", "good morning", "good evening", "hey"],
+            "es": ["hola", "buenos días", "buenas tardes", "hey"],
+            "de": ["hallo", "guten tag", "guten morgen", "hey"]
+        }
+        
+        for language, keywords in greetings.items():
+            if any(word in input_lower for word in keywords):
+                time_greetings = self.get_time_greeting()
+                name_part = f" {self.user_name}" if self.user_name else ""
+                
+                if language == "fr":
+                    responses = [f"{time_greetings['fr']}{name_part} ! 👋", f"Salut{name_part} ! Comment allez-vous ? 😊"]
+                elif language == "en":
+                    responses = [f"{time_greetings['en']}{name_part}! 👋", f"Hi{name_part}! How are you doing? 😊"]
+                elif language == "es":
+                    responses = [f"¡{time_greetings['es']}{name_part}! 👋", f"¡Hola{name_part}! ¿Cómo estás? 😊"]
+                else:  # de
+                    responses = [f"{time_greetings['de']}{name_part}! 👋", f"Hallo{name_part}! Wie geht es Ihnen? 😊"]
+                
+                return random.choice(responses)
+        
+        # Remerciements avec variation
+        thanks = {
+            "fr": ["merci", "merci beaucoup"],
+            "en": ["thank you", "thanks", "thank you very much"],
+            "es": ["gracias", "muchas gracias"],
+            "de": ["danke", "vielen dank"]
+        }
+        
+        for language, keywords in thanks.items():
+            if any(word in input_lower for word in keywords):
+                responses = {
+                    "fr": ["De rien ! 😊", "Avec plaisir !", "C'est tout naturel !", "Je vous en prie !"],
+                    "en": ["You're welcome! 😊", "My pleasure!", "No problem!", "Anytime!"],
+                    "es": ["¡De nada! 😊", "¡Con mucho gusto!", "¡No hay problema!", "¡Cuando quieras!"],
+                    "de": ["Gern geschehen! 😊", "Gerne!", "Kein Problem!", "Jederzeit!"]
+                }
+                return random.choice(responses[language])
+        
+        # Adieux avec variation
+        farewell = {
+            "fr": ["au revoir", "à bientôt", "salut", "bye", "ciao"],
+            "en": ["goodbye", "see you", "bye", "farewell", "take care"],
+            "es": ["adiós", "hasta luego", "bye", "ciao", "cuídate"],
+            "de": ["tschüss", "auf wiedersehen", "bye", "ciao", "mach's gut"]
+        }
+        
+        for language, keywords in farewell.items():
+            if any(word in input_lower for word in keywords):
+                name_part = f" {self.user_name}" if self.user_name else ""
+                responses = {
+                    "fr": [f"Au revoir{name_part} ! 👋", f"À bientôt{name_part} ! 😊", "Passez une excellente journée ! ✨"],
+                    "en": [f"Goodbye{name_part}! 👋", f"See you later{name_part}! 😊", "Have a wonderful day! ✨"],
+                    "es": [f"¡Adiós{name_part}! 👋", f"¡Hasta luego{name_part}! 😊", "¡Que tengas un día maravilloso! ✨"],
+                    "de": [f"Auf Wiedersehen{name_part}! 👋", f"Bis bald{name_part}! 😊", "Haben Sie einen wunderbaren Tag! ✨"]
+                }
+                return random.choice(responses[language])
+        
+        return None
+
+    def get_bot_response(self, user_input):
+        """Fonction principale du chatbot amélioré"""
+        # Ajouter à l'historique
+        self.conversation_history.append({"user": user_input, "timestamp": datetime.now()})
+        
+        lang = self.detect_language(user_input)
+        
+        # PRIORITÉ 1: Vérifier si c'est un problème technique - directement au modèle MT5
+        if self.detect_problem_keywords(user_input, lang):
+            print(f"[DEBUG] Problème détecté, transmission au modèle MT5...")
+            
+            # Préfixes pour introduire la réponse du modèle
+            problem_prefixes = {
+                "fr": [
+                    "Je comprends votre problème. Laissez-moi vous aider :",
+                    "Voici ce que je peux vous proposer :",
+                    "D'après votre description, voici ma recommandation :",
+                    "Je vais analyser votre problème :"
+                ],
+                "en": [
+                    "I understand your problem. Let me help you:",
+                    "Here's what I can suggest:",
+                    "Based on your description, here's my recommendation:",
+                    "Let me analyze your problem:"
+                ],
+                "es": [
+                    "Entiendo tu problema. Déjame ayudarte:",
+                    "Esto es lo que puedo sugerir:",
+                    "Basándome en tu descripción, esta es mi recomendación:",
+                    "Voy a analizar tu problema:"
+                ],
+                "de": [
+                    "Ich verstehe Ihr Problem. Lassen Sie mich Ihnen helfen:",
+                    "Hier ist was ich vorschlagen kann:",
+                    "Basierend auf Ihrer Beschreibung, hier ist meine Empfehlung:",
+                    "Ich werde Ihr Problem analysieren:"
+                ]
+            }
+            
+            # Obtenir la réponse du modèle MT5
+            model_response = call_mt5_model(user_input)
+            
+            # Ajouter un préfixe approprié
+            prefix = random.choice(problem_prefixes[lang])
+            final_response = f"{prefix}\n\n{model_response}"
+            
+            self.conversation_history.append({"bot": final_response, "timestamp": datetime.now()})
+            return final_response
+        
+        # PRIORITÉ 2: Essayer les réponses basées sur des règles (salutations, politesse, etc.)
+        rule_response = self.get_rule_based_response(user_input)
+        if rule_response:
+            self.conversation_history.append({"bot": rule_response, "timestamp": datetime.now()})
+            return rule_response
+        
+        # PRIORITÉ 3: Questions générales - utiliser le modèle mT5 avec préfixe conversationnel
+        print(f"[DEBUG] Question générale, utilisation du modèle MT5...")
+        
+        # Préfixes pour rendre la réponse plus naturelle
+        general_prefixes = {
+            "fr": ["Hmm, laissez-moi réfléchir...", "Intéressant !", "Bonne question !", "Voici ce que je pense :", ""],
+            "en": ["Hmm, let me think...", "Interesting!", "Good question!", "Here's what I think:", ""],
+            "es": ["Hmm, déjame pensar...", "¡Interesante!", "¡Buena pregunta!", "Esto es lo que pienso:", ""],
+            "de": ["Hmm, lass mich nachdenken...", "Interessant!", "Gute Frage!", "Das denke ich:", ""]
+        }
+        
+        # Obtenir la réponse du modèle
+        model_response = call_mt5_model(user_input)
+        
+        # Ajouter un préfixe occasionnel pour plus de naturel
+        prefix = random.choice(general_prefixes[lang])
+        if prefix and random.random() < 0.3:  # 30% de chance d'ajouter un préfixe
+            final_response = f"{prefix} {model_response}"
+        else:
+            final_response = model_response
+        
+        self.conversation_history.append({"bot": final_response, "timestamp": datetime.now()})
+        return final_response
+
+    def get_conversation_summary(self):
+        """Retourne un résumé de la conversation"""
+        if not self.conversation_history:
+            return "Aucune conversation en cours."
+        
+        user_messages = len([msg for msg in self.conversation_history if "user" in msg])
+        bot_messages = len([msg for msg in self.conversation_history if "bot" in msg])
+        
+        return f"Conversation: {user_messages} messages utilisateur, {bot_messages} réponses du bot"
+
+# Utilisation
+def create_chatbot():
+    """Crée une nouvelle instance du chatbot"""
+    return HumanChatbot()
+
+# Exemple d'utilisation avec détection de problèmes
+if __name__ == "__main__":
+    bot = create_chatbot()
+    
+    # Test des salutations
+    print("=== Test Salutations ===")
+    print("User: Bonjour !")
+    print("Bot:", bot.get_bot_response("Bonjour !"))
+    
+    print("\nUser: Je m'appelle Marie")
+    print("Bot:", bot.get_bot_response("Je m'appelle Marie"))
+    
+    # Test des problèmes - vont directement au modèle MT5
+    print("\n=== Test Problèmes (vont au modèle MT5) ===")
+    print("User: J'ai un problème avec mon ordinateur")
+    print("Bot:", bot.get_bot_response("J'ai un problème avec mon ordinateur"))
+    
+    print("\nUser: Comment résoudre une erreur 404 ?")
+    print("Bot:", bot.get_bot_response("Comment résoudre une erreur 404 ?"))
+    
+    print("\nUser: Mon logiciel ne fonctionne pas, que faire ?")
+    print("Bot:", bot.get_bot_response("Mon logiciel ne fonctionne pas, que faire ?"))
+    
+    print("\nUser: I need help with my code")
+    print("Bot:", bot.get_bot_response("I need help with my code"))
+    
+    # Test des questions générales
+    print("\n=== Test Questions Générales ===")
+    print("User: Comment allez-vous ?")
+    print("Bot:", bot.get_bot_response("Comment allez-vous ?"))
+    
+    print("\nUser: Merci beaucoup !")
+    print("Bot:", bot.get_bot_response("Merci beaucoup !"))
+    
+    print("\nUser: Au revoir !")
+    print("Bot:", bot.get_bot_response("Au revoir !"))
+
+
+
+# Ajoutez ces lignes à la fin de votre chatbot.py pour maintenir la compatibilité
+
+# Instance globale pour la compatibilité avec l'ancien code
+_global_chatbot = None
+
+def get_bot_response(user_input):
+    """
+    Fonction wrapper pour maintenir la compatibilité avec l'ancien code
+    Utilise une instance globale du chatbot
+    """
+    global _global_chatbot
+    
+    # Créer l'instance si elle n'existe pas
+    if _global_chatbot is None:
+        _global_chatbot = HumanChatbot()
+    
+    # Retourner la réponse
+    return _global_chatbot.get_bot_response(user_input)
+
+def reset_chatbot():
+    """Réinitialise le chatbot global"""
+    global _global_chatbot
+    _global_chatbot = None
+
+def get_chatbot_stats():
+    """Retourne les statistiques du chatbot global"""
+    global _global_chatbot
+    if _global_chatbot is None:
+        return "Aucune conversation en cours."
+    return _global_chatbot.get_conversation_summary()

model_mt5.py

@@ -0,0 +1,26 @@
+import os
+from transformers import MT5ForConditionalGeneration, MT5Tokenizer
+
+# Chemin vers ton modèle local (dossier contenant config.json, pytorch_model.bin, etc.)
+
+
+model = MT5ForConditionalGeneration.from_pretrained("mt5_model", local_files_only=True)       
+import os
+tokenizer = MT5Tokenizer.from_pretrained(os.path.join(os.path.dirname(__file__), "mt5_model"), local_files_only=True)
+
+
+
+
+
+def call_mt5_model(user_input: str, target_language: str = "fr") -> str:
+   
+    # Préparation de l'entrée (tu peux personnaliser le format selon ton entraînement)
+    input_text = f"translate {target_language}: {user_input}"
+
+    # Encodage et génération
+    inputs = tokenizer.encode(input_text, return_tensors="pt", max_length=512, truncation=True)
+    outputs = model.generate(inputs, max_length=128, num_beams=4, early_stopping=True)
+
+    # Décodage
+    response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    return response

requirements.txt

@@ -0,0 +1,54 @@
+altair==5.5.0
+attrs==25.3.0
+blinker==1.9.0
+cachetools==5.5.2
+certifi==2025.4.26
+charset-normalizer==3.4.2
+click==8.2.1
+colorama==0.4.6
+filelock==3.18.0
+fsspec==2025.5.1
+gitdb==4.0.12
+GitPython==3.1.44
+huggingface-hub==0.32.4
+idna==3.10
+Jinja2==3.1.6
+jsonschema==4.24.0
+jsonschema-specifications==2025.4.1
+MarkupSafe==3.0.2
+mpmath==1.3.0
+narwhals==1.41.0
+networkx==3.4.2
+numpy==2.2.6
+packaging==24.2
+pandas==2.3.0
+pillow==11.2.1
+protobuf==6.31.1
+pyarrow==20.0.0
+pydeck==0.9.1
+python-dateutil==2.9.0.post0
+pytz==2025.2
+PyYAML==6.0.2
+referencing==0.36.2
+regex==2024.11.6
+requests==2.32.3
+rpds-py==0.25.1
+safetensors==0.5.3
+sentencepiece==0.2.0
+six==1.17.0
+smmap==5.0.2
+streamlit==1.45.1
+sympy==1.14.0
+tenacity==9.1.2
+tokenizers==0.21.1
+toml==0.10.2
+torch==2.7.1+cpu
+torchaudio==2.7.1+cpu
+torchvision==0.22.1+cpu
+tornado==6.5.1
+tqdm==4.67.1
+transformers==4.52.4
+typing_extensions==4.14.0
+tzdata==2025.2
+urllib3==2.4.0
+watchdog==6.0.0