Update app.py

app.py

@@ -1,115 +1,99 @@
 import gradio as gr
-from transformers import AutoTokenizer, AutoModelForCausalLM, AutoModelForSequenceClassification
-import torch
-import torch.nn.functional as F
-from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
-from mtranslate import translate
-from langdetect import detect
-from duckduckgo_search import DDGS
-import re
-
-# === Nettoyage texte ===
-def clean_response(text):
-    text = re.sub(r'<[^>]+>', '', text)
-    text = re.split(r'</(Bot|name|opinion|User|[a-zA-Z]*)>', text)[0]
-    text = re.sub(r'^\s*[,.:;-]*', '', text)
-    text = re.sub(r'^\s*(Psyche|Therapist|Bot|Assistant|AI):?\s*', '', text)
-    text = re.sub(r'\([^)]*\)', '', text)
-    text = re.sub(r'\[.*?\]', '', text)
-    text = re.sub(r'[:;=8][-~]?[)D(\\/*|]', '', text)
-    text = re.sub(r'\s{2,}', ' ', text).strip()
-    sentences = re.split(r'(?<=[.!?])\s+', text)
-    return " ".join(sentences[:2]).strip()
-
-# === Charger modèles ===
-MODEL_PATH = "fatmata/gpt-psybot"
-tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH, use_fast=False)
-model = AutoModelForCausalLM.from_pretrained(MODEL_PATH)
-
-BERT_MODEL_NAME = "fatmata/bert_model"
-bert_tokenizer = AutoTokenizer.from_pretrained(BERT_MODEL_NAME)
-bert_model = AutoModelForSequenceClassification.from_pretrained(BERT_MODEL_NAME)
-
-CLASSIFIER_PATH = "fatmata/mini_bert"
-model_c = AutoModelForSequenceClassification.from_pretrained(CLASSIFIER_PATH)
-tokenizer_c = AutoTokenizer.from_pretrained(CLASSIFIER_PATH)
-
-# === Analyse émotion ===
-analyzer = SentimentIntensityAnalyzer()
-GOEMOTIONS_LABELS = ["admiration","anger","approval","autre","curiosity",
-                     "disapproval","gratitude","joy","love","neutral","sadness"]
-UNACCEPTABLE_EMOTIONS = {"anger"}
+import random
+from textblob import TextBlob
+
+# ========= Fonctions utilitaires =========
 
 def detect_language(text):
-    try:
-        detected_lang = detect(text)
-        return detected_lang if detected_lang in ["fr", "en", "ar"] else "en"
-    except:
-        return "en"
+    """Détecte la langue du texte"""
+    blob = TextBlob(text)
+    return blob.detect_language()
 
-def search_duckduckgo(query, max_results=3):
+def translate(text, target_lang="en"):
+    """Traduit le texte vers target_lang"""
+    blob = TextBlob(text)
     try:
-        search_results = list(DDGS().text(query, max_results=max_results))
-        return [result["body"] for result in search_results if "body" in result] or ["Pas trouvé."]
-    except Exception as e:
-        return [f"Erreur recherche : {str(e)}"]
-
-def generate_response(user_input):
-    prompt = f"User: {user_input}\nBot:"
-    inputs = tokenizer(prompt, return_tensors="pt")
-    output = model.generate(
-        input_ids=inputs["input_ids"],
-        max_new_tokens=150,
-        pad_token_id=tokenizer.eos_token_id,
-        eos_token_id=tokenizer.eos_token_id,
-        do_sample=True,
-        temperature=0.7,
-        top_k=50,
-        top_p=0.9,
-        repetition_penalty=1.2
-    )
-    generated_text = tokenizer.decode(output[0], skip_special_tokens=True)
-    return clean_response(generated_text.split("Bot:")[-1].strip())
-
-def classify_emotion(text):
-    sentiment_scores = analyzer.polarity_scores(text)
-    compound = sentiment_scores['compound'] * 100
-    inputs = bert_tokenizer(text, return_tensors="pt", truncation=True, padding=True, max_length=256)
-    with torch.no_grad():
-        logits = bert_model(**inputs).logits
-    probs = F.softmax(logits, dim=-1).squeeze().cpu().numpy()
-    top_emotion_index = probs.argmax()
-    top_emotion = GOEMOTIONS_LABELS[top_emotion_index]
-    return compound, top_emotion in UNACCEPTABLE_EMOTIONS, top_emotion
+        return str(blob.translate(to=target_lang))
+    except Exception:
+        return text  # si la traduction échoue, on garde le texte original
 
 def predict(text):
-    inputs = tokenizer_c(text, return_tensors="pt", padding=True, truncation=True, max_length=512)
-    with torch.no_grad():
-        outputs = model_c(**inputs)
-    logits = outputs.logits
-    return "recherche" if torch.argmax(logits, dim=-1).item() == 1 else "GPT"
+    """Détection simple de l'intention (recherche ou discussion)"""
+    keywords = ["cherche", "recherche", "trouve", "information", "wikipedia", "google"]
+    if any(word in text.lower() for word in keywords):
+        return "recherche"
+    return "discussion"
+
+def search_duckduckgo(query):
+    """Simule une recherche (à remplacer par vrai moteur si besoin)"""
+    return [f"Résultat fictif pour : {query}"]
+
+def classify_emotion(text):
+    """Détection simple des émotions (fake, à remplacer par vrai modèle)"""
+    emotions = ["joy", "sadness", "anger", "fear", "neutral"]
+    emotion = random.choice(emotions)
+    compound = random.randint(-100, 100)
+    is_unacceptable = "!" in text or "stupide" in text.lower()
+    return compound, is_unacceptable, emotion
+
+def generate_response(text):
+    """Réponse GPT fictive (à remplacer par ton modèle GPT)"""
+    responses = [
+        "Je comprends ce que tu ressens.",
+        "Peux-tu m’en dire plus ?",
+        "Ça a l’air difficile, je suis là pour t’écouter.",
+        "Merci de partager ça avec moi."
+    ]
+    return random.choice(responses)
+
+# ========= Fonction principale =========
 
 def classify_and_respond(text):
+    """Pipeline complet : détection intention → émotion → réponse"""
     original_lang = detect_language(text)
     text_en = translate(text, "en")
 
+    steps = []
     category = predict(text_en)
+    steps.append("Intention détectée")
+
     if category == "recherche":
+        steps.append("Recherche externe")
         response = search_duckduckgo(text_en)
-        return "\n".join([translate(r, original_lang) for r in response])
+        return {
+            "response": "\n".join([translate(r, original_lang) for r in response]),
+            "response_type": "recherche",
+            "emotions": None,
+            "steps": steps
+        }
 
     compound, is_unacceptable, emotion = classify_emotion(text_en)
-    if is_unacceptable and abs(compound) > 50:
-        return translate("Je ressens beaucoup de tension dans votre message.", original_lang)
+    steps.append(f"Émotion détectée : {emotion}")
 
+    if is_unacceptable and abs(compound) > 50:
+        steps.append("Message non acceptable")
+        return {
+            "response": translate("Je ressens beaucoup de tension dans votre message.", original_lang),
+            "response_type": "non acceptable",
+            "emotions": emotion,
+            "steps": steps
+        }
+
+    steps.append("Génération GPT")
     gpt_response = generate_response(text_en)
-    return translate(gpt_response, original_lang)
+    return {
+        "response": translate(gpt_response, original_lang),
+        "response_type": "gpt",
+        "emotions": emotion,
+        "steps": steps
+    }
+
+# ========= Interface Gradio =========
 
-# === Interface Gradio ===
 iface = gr.Interface(
     fn=classify_and_respond,
     inputs=gr.Textbox(lines=2, placeholder="Écris ton message..."),
-    outputs="text",
+    outputs="json",   # 🔴 renvoie un JSON structuré pour le frontend
     title="PsyBot",
     description="Chatbot psychologue multilingue basé sur GPT + BERT + MiniBERT"
 )