Update app.py

app.py

@@ -1,99 +1,159 @@
+Hugging Face's logo
+Hugging Face
+Models
+Datasets
+Spaces
+Community
+Docs
+Pricing
+
+
+
+Spaces:
+
+fatmata
+/
+psybot-backende
+
+
+like
+0
+
+App
+Files
+Community
+Settings
+psybot-backende
+/
+app.py
+
+fatmata's picture
+fatmata
+Update app.py
+5e65e37
+verified
+28 minutes ago
+raw
+
+Copy download link
+history
+blame
+edit
+delete
+
+4.49 kB
 import gradio as gr
-import random
-from textblob import TextBlob
-
-# ========= Fonctions utilitaires =========
+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"}
 
 def detect_language(text):
-    """Détecte la langue du texte"""
-    blob = TextBlob(text)
-    return blob.detect_language()
-
-def translate(text, target_lang="en"):
-    """Traduit le texte vers target_lang"""
-    blob = TextBlob(text)
     try:
-        return str(blob.translate(to=target_lang))
-    except Exception:
-        return text  # si la traduction échoue, on garde le texte original
-
-def predict(text):
-    """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"
+        detected_lang = detect(text)
+        return detected_lang if detected_lang in ["fr", "en", "ar"] else "en"
+    except:
+        return "en"
 
-def search_duckduckgo(query):
-    """Simule une recherche (à remplacer par vrai moteur si besoin)"""
-    return [f"Résultat fictif pour : {query}"]
+def search_duckduckgo(query, max_results=3):
+    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):
-    """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 =========
+    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
+
+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"
 
 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 {
-            "response": "\n".join([translate(r, original_lang) for r in response]),
-            "response_type": "recherche",
-            "emotions": None,
-            "steps": steps
-        }
+        return "\n".join([translate(r, original_lang) for r in response])
 
     compound, is_unacceptable, emotion = classify_emotion(text_en)
-    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 {
-        "response": translate(gpt_response, original_lang),
-        "response_type": "gpt",
-        "emotions": emotion,
-        "steps": steps
-    }
+        return translate("Je ressens beaucoup de tension dans votre message.", original_lang)
 
-# ========= Interface Gradio =========
+    gpt_response = generate_response(text_en)
+    return translate(gpt_response, original_lang)
 
+# === Interface Gradio ===
 iface = gr.Interface(
     fn=classify_and_respond,
     inputs=gr.Textbox(lines=2, placeholder="Écris ton message..."),
-    outputs="json",   # 🔴 renvoie un JSON structuré pour le frontend
+    outputs="text",
     title="PsyBot",
     description="Chatbot psychologue multilingue basé sur GPT + BERT + MiniBERT"
 )