Create app.py

app.py

@@ -0,0 +1,158 @@
+from fastapi import FastAPI
+from pydantic import BaseModel
+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):
+    try:
+        detected_lang = detect(text)
+        return detected_lang if detected_lang in ["fr", "en", "ar"] else "en"
+    except:
+        return "en"
+
+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):
+    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_category(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"
+
+# =============================
+# Fonction principale
+# =============================
+def classify_and_respond(text):
+    steps = []
+    original_lang = detect_language(text)
+    text_en = translate(text, "en")
+
+    # Étape 1 : prédiction catégorie
+    category = predict_category(text_en)
+    steps.append("Catégorie détectée : " + category)
+
+    if category == "recherche":
+        response = search_duckduckgo(text_en)
+        final_response = "\n".join([translate(r, original_lang) for r in response])
+        steps.append("Résultats DuckDuckGo récupérés")
+        return {
+            "response": final_response,
+            "response_type": "recherche",
+            "emotions": None,
+            "steps": steps
+        }
+
+    # Étape 2 : analyse émotion
+    compound, is_unacceptable, emotion = classify_emotion(text_en)
+    steps.append(f"Émotion détectée : {emotion} (score={compound:.2f})")
+
+    if is_unacceptable and abs(compound) > 50:
+        final_response = translate("Je ressens beaucoup de tension dans votre message.", original_lang)
+        steps.append("Réponse émotion inacceptable envoyée")
+        return {
+            "response": final_response,
+            "response_type": "non acceptable",
+            "emotions": emotion,
+            "steps": steps
+        }
+
+    # Étape 3 : génération GPT
+    gpt_response = generate_response(text_en)
+    final_response = translate(gpt_response, original_lang)
+    steps.append("Réponse GPT générée et traduite")
+
+    return {
+        "response": final_response,
+        "response_type": "gpt",
+        "emotions": emotion,
+        "steps": steps
+    }
+
+# =============================
+# API FastAPI
+# =============================
+app = FastAPI()
+
+class RequestBody(BaseModel):
+    text: str
+
+@app.post("/predict")
+async def predict_api(body: RequestBody):
+    return classify_and_respond(body.text)