Update app.py

app.py

@@ -1,10 +1,5 @@
 import os
 import json
-import base64
-import tempfile
-import requests
-import math
-import numpy as np
 import firebase_admin
 from firebase_admin import credentials, firestore
 from flask import Flask, request, jsonify
@@ -26,55 +21,23 @@ try:
 except Exception as e:
     print(f"❌ Erro ao inicializar Firebase: {e}")
 
-# ====== CONFIGS AJUSTÁVEIS (env vars) ======
-# Modelo recomendado para PT (substitua se quiser um checkpoint em inglês)
-AUDIO_SER_MODEL = os.getenv("AUDIO_SER_MODEL", "alefiury/wav2vec2-xls-r-300m-pt-br-spontaneous-speech-emotion-recognition")
-# Ex.: set ENABLE_ASR=true para ativar ASR (pode consumir muita memória)
-ENABLE_ASR = os.getenv("ENABLE_ASR", "false").lower() in ("1", "true", "yes")
-AUDIO_TOPK_RUNS = os.getenv("AUDIO_TOPK_RUNS", "10,15,20")  # exemplo: "10,15,20"
-AUDIO_SOFTMAX_TEMP = float(os.getenv("AUDIO_SOFTMAX_TEMP", "0.6"))
-MIN_LABEL_PROB = float(os.getenv("MIN_LABEL_PROB", "0.02"))
-DEPRESSION_THRESHOLD = float(os.getenv("DEPRESSION_THRESHOLD", "0.92"))
-
-# ====== PIPELINE: modelo SER (wav2vec2 finetuned) ======
+# ====== MODELO ======
 try:
-    audio_pipeline = pipeline(
-        task="audio-classification",
-        model=AUDIO_SER_MODEL
-    )
-    print(f"✅ audio_pipeline carregado: {AUDIO_SER_MODEL}")
+    model_pipeline = pipeline("text-classification", model="pysentimiento/robertuito-emotion-analysis")
+    print("✅ Modelo carregado com sucesso!")
 except Exception as e:
-    print(f"❌ Erro ao carregar audio_pipeline ({AUDIO_SER_MODEL}): {e}")
-    audio_pipeline = None
-
-# Opcional: ASR (desativado por padrão para economia de recursos)
-asr_pipeline = None
-if ENABLE_ASR:
-    try:
-        asr_pipeline = pipeline(
-            task="automatic-speech-recognition",
-            model="openai/whisper-large-v3"
-        )
-        print("✅ asr_pipeline carregado (ENABLE_ASR=true).")
-    except Exception as e:
-        print(f"⚠️ ASR indisponível: {e}")
-        asr_pipeline = None
+    print(f"❌ Erro ao carregar modelo: {e}")
+    model_pipeline = None
 
-# ====== MAPEAMENTO DE EMOÇÕES (ING->PT) ======
-# OBS: cada modelo pode usar rótulos ligeiramente diferentes; padronizamos para estes
+# ====== MAPEAMENTO DE EMOÇÕES ======
 emotion_labels = {
-    "angry": "raiva",
+    "sadness": "tristeza",
+    "joy": "alegria",
     "anger": "raiva",
-    "disgust": "insegurança",
-    "fearful": "ansiedade",
     "fear": "ansiedade",
-    "happy": "alegria",
-    "joy": "alegria",
-    "neutral": "neutro",
-    "sad": "tristeza",
-    "sadness": "tristeza",
-    "surprised": "surpreso",
-    "surprise": "surpreso",
+    "disgust": "insegurança",
+    "surprise": "alegria",
+    "others": "neutro"
 }
 
 # ====== SUGESTÕES ======
@@ -91,19 +54,19 @@ def gerar_sugestao(emotion_pt):
     }
     return sugestoes.get(emotion_pt, "Mantenha o equilíbrio emocional e cuide de você mesmo.")
 
-# ====== FALLBACK POR TEXTO ======
+# ====== FALLBACK APRIMORADO COM PALAVRAS-CHAVE ======
 EMOTION_KEYWORDS = {
     "tristeza": ["triste","desanimado","melancólico","chateado","solitário","deprimido","abatido","infeliz","desmotivado"],
     "ansiedade": ["ansioso","preocupado","nervoso","tenso","inquieto","aflito","alarmado","sobrecarregado","inseguro","apreensivo"],
     "insegurança": ["inseguro","incerto","receoso","hesitante","duvidoso","apreensivo","desconfiado"],
     "raiva": ["irritado","zangado","raiva","furioso","ódio","revoltado","frustrado","indignado","hostil","bravo","enfurecido","irado"],
     "alegria": ["feliz","animado","contente","alegre","satisfeito","entusiasmado","radiante","orgulhoso","euforia"],
-    "depressão": ["sem esperança","vazio","desesperado","sem vontade","cansado da vida","desamparado", "matar","depressivo"],
+    "depressão": ["sem esperança","vazio","desesperado","sem vontade","cansado da vida","desamparado"],
     "neutro": ["ok","normal","tranquilo","indiferente","equilibrado","estável"]
 }
 
 def fallback_emotion(text):
-    text_lower = (text or "").lower()
+    text_lower = text.lower()
     match_counts = {k: sum(1 for w in v if w in text_lower) for k, v in EMOTION_KEYWORDS.items()}
     emotion = max(match_counts, key=match_counts.get)
     if match_counts[emotion] == 0:
@@ -117,161 +80,75 @@ def fallback_emotion(text):
         "debug": "Fallback ativado"
     }
 
-# ====== UTIL: softmax temperado ======
-def tempered_softmax(scores_dict, temperature=1.0):
-    labels = list(scores_dict.keys())
-    vals = np.array([scores_dict[l] for l in labels], dtype=float)
-    vals = np.clip(vals, 1e-8, 1-1e-8)
-    logits = np.log(vals / (1 - vals))
-    scaled = logits / max(temperature, 1e-6)
-    exps = np.exp(scaled - np.max(scaled))
-    probs = exps / np.sum(exps)
-    return dict(zip(labels, probs))
+# ====== AJUSTE HÍBRIDO ======
+def hybrid_emotion(text, result):
+    text_lower = text.lower()
+    detected = result.get("emotion", "neutro")
+    max_matches = 0
 
-def average_probabilities(list_of_prob_dicts):
-    all_keys = set()
-    for d in list_of_prob_dicts:
-        all_keys.update(d.keys())
-    if not all_keys:
-        return {}
-    avg = {k: 0.0 for k in all_keys}
-    for d in list_of_prob_dicts:
-        for k in all_keys:
-            avg[k] += d.get(k, 0.0)
-    n = len(list_of_prob_dicts)
-    for k in avg:
-        avg[k] /= n
-    total = sum(avg.values()) or 1.0
-    for k in avg:
-        avg[k] /= total
-    return avg
+    for emo, keywords in EMOTION_KEYWORDS.items():
+        matches = sum(2 for w in keywords if w in text_lower)
+        if matches > max_matches:
+            max_matches = matches
+            if emo != detected:
+                detected = emo
 
-# ====== HELPERS ÁUDIO ======
-def save_bytes_to_tempfile(bbytes, suffix=".wav"):
-    fd, path = tempfile.mkstemp(suffix=suffix)
-    os.close(fd)
-    with open(path, "wb") as f:
-        f.write(bbytes)
-    return path
+    confidence = result.get("confidence", 0.0)
+    if detected != result.get("emotion"):
+        confidence = 0.7 + max_matches * 0.05
+    confidence = min(confidence, 1.0)
 
-def fetch_url_to_tempfile(url):
-    r = requests.get(url, timeout=15)
-    r.raise_for_status()
-    content_type = r.headers.get("content-type", "")
-    suffix = ".wav"
-    if "mpeg" in content_type or "mp3" in content_type:
-        suffix = ".mp3"
-    return save_bytes_to_tempfile(r.content, suffix=suffix)
+    return {
+        "status": "ok",
+        "emotion": detected,
+        "emode": [detected],
+        "confidence": round(confidence, 2),
+        "probabilities": result.get("probabilities", {detected: 1.0}),
+        "suggestion": result.get("suggestion", gerar_sugestao(detected)),
+        "debug": result.get("debug", "Híbrido aplicado")
+    }
 
-# ====== ROTA /analyze ======
+# ====== ROTA DE ANÁLISE ======
 @app.route("/analyze", methods=["POST"])
 def analyze():
     try:
-        audio_path = None
-        audio_bytes = None
-        data = None
+        data = request.get_json()
+        if not data or "text" not in data:
+            return jsonify({"error": "Campo 'text' é obrigatório."}), 400
 
-        # receber multipart/file ou json
-        if "file" in request.files:
-            f = request.files["file"]
-            audio_bytes = f.read()
-        else:
-            try:
-                data = request.get_json(silent=True)
-            except Exception:
-                data = None
-            if data:
-                if "audio_base64" in data:
-                    audio_bytes = base64.b64decode(data["audio_base64"])
-                elif "audio_url" in data:
-                    audio_path = fetch_url_to_tempfile(data["audio_url"])
-                elif "text" in data and (not audio_bytes and not audio_path):
-                    return jsonify(fallback_emotion(data["text"]))
+        text = data["text"]
 
-        if audio_bytes:
-            audio_path = save_bytes_to_tempfile(audio_bytes, suffix=".wav")
+        if not model_pipeline:
+            return jsonify(fallback_emotion(text))
 
-        if not audio_path:
-            return jsonify({"error": "Nenhum áudio foi enviado. Envie 'file', 'audio_base64' ou 'audio_url', ou 'text' para fallback."}), 400
-
-        if not audio_pipeline:
-            if data and "text" in data:
-                return jsonify(fallback_emotion(data["text"]))
-            return jsonify({"error": "Modelo de áudio indisponível no momento."}), 500
-
-        # ----- Ensemble interno: múltiplas runs com diferentes top_k -----
-        topk_list = [int(x) for x in AUDIO_TOPK_RUNS.split(",") if x.strip().isdigit()]
-        if not topk_list:
-            topk_list = [10, 15, 20]
-
-        run_probs = []
-        raw_runs = []
-
-        for topk in topk_list:
-            try:
-                raw_result = audio_pipeline(audio_path, top_k=topk)
-                probs = {}
-                # raw_result é lista de dicts
-                for item in raw_result:
-                    lbl = item.get("label", "").lower()
-                    if lbl == "fear":
-                        lbl = "fearful"
-                    probs[lbl] = float(item.get("score", 0.0))
-                if probs:
-                    run_probs.append(probs)
-                    raw_runs.append({"top_k": topk, "raw": raw_result})
-            except Exception as e:
-                print(f"⚠️ audio_pipeline falhou top_k={topk}: {e}")
-
-        if not run_probs:
-            return jsonify({"error": "Modelo não retornou rótulos em nenhuma tentativa."}), 500
-
-        avg_probs = average_probabilities(run_probs)
-
-        # recalibrar com temperatura (mais baixa => mais confiante)
-        calibrated = tempered_softmax(avg_probs, temperature=AUDIO_SOFTMAX_TEMP)
-
-        # filtrar rótulos fracos
-        filtered = {k: (v if v >= MIN_LABEL_PROB else 0.0) for k, v in calibrated.items()}
-        totalf = sum(filtered.values()) or 1.0
-        normalized = {k: (v / totalf) for k, v in filtered.items()}
-
-        top_label = max(normalized, key=normalized.get)
-        top_score = normalized[top_label]
+        result = model_pipeline(text, return_all_scores=True)
+        if not result or len(result) == 0:
+            return jsonify(fallback_emotion(text))
 
+        scores = {r["label"]: r["score"] for r in result[0]}
+        top_label = max(scores, key=scores.get)
+        confidence = round(scores[top_label], 2)
         emotion_pt = emotion_labels.get(top_label, "desconhecido")
-        if emotion_pt == "tristeza" and top_score >= DEPRESSION_THRESHOLD:
-            emotion_pt = "depressão"
 
-        probabilities_pt = { emotion_labels.get(k, k): round(float(v), 3) for k, v in normalized.items() }
+        # Ajuste especial para "tristeza" muito forte
+        if emotion_pt == "tristeza" and confidence >= 0.9:
+            emotion_pt = "depressão"
 
         base_result = {
             "status": "ok",
             "emotion": emotion_pt,
             "emode": [emotion_pt],
-            "confidence": round(float(top_score), 3),
-            "probabilities": probabilities_pt,
-            "suggestion": gerar_sugestao(emotion_pt),
-            "debug": {
-                "model": AUDIO_SER_MODEL,
-                "runs": raw_runs,
-                "avg_probs": {k: round(float(v), 4) for k, v in avg_probs.items()},
-                "calibrated": {k: round(float(v), 4) for k, v in calibrated.items()},
-                "normalized": {k: round(float(v), 4) for k, v in normalized.items()}
-            }
+            "confidence": confidence,
+            "probabilities": {emotion_labels.get(k, k): round(v,3) for k,v in scores.items()},
+            "suggestion": gerar_sugestao(emotion_pt)
         }
 
-        return jsonify(base_result)
+        # Aplica lógica híbrida com fallback de palavras-chave
+        final_result = hybrid_emotion(text, base_result)
+        return jsonify(final_result)
 
     except Exception as e:
-        print(f"❌ Erro na rota /analyze: {e}")
         return jsonify({"error": str(e)}), 500
-    finally:
-        try:
-            if 'audio_path' in locals() and audio_path and os.path.exists(audio_path):
-                os.remove(audio_path)
-        except Exception:
-            pass
 
 if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=int(os.getenv("PORT", 7860)))
+    app.run(host="0.0.0.0", port=7860)