Update app.py

app.py

@@ -1,6 +1,6 @@
 """
-Sistema de Análise de Sentimentos com Alerta de Conteúdo
-Analisa SEMPRE o sentimento, depois avisa se tiver linguagem imprópria
+Sistema Avançado de Análise de Sentimentos
+Versão melhorada com mais modelos e melhor cálculo de confiança
 """
 
 import gradio as gr
@@ -11,9 +11,12 @@ from collections import Counter
 import warnings
 warnings.filterwarnings('ignore')
 
-# Modelos de moderação (usados DEPOIS da análise)
+# Modelos de moderação - MAIS MODELOS
 MODERATION_MODELS = [
     "citizenlab/distilbert-base-multilingual-cased-toxicity",
+    "unitary/toxic-bert",
+    "martin-ha/toxic-comment-model",
+    "facebook/roberta-hate-speech-dynabench-r4-target",
     "Hate-speech-CNERG/dehatebert-mono-portuguese",
 ]
 
@@ -22,9 +25,9 @@ moderators = []
 
 for model_name in MODERATION_MODELS:
     try:
-        print(f"Carregando: {model_name.split('/')[-1]}...", end=" ")
+        print(f"Moderador: {model_name.split('/')[-1]}...", end=" ")
         
-        if "dehatebert" in model_name:
+        if "dehatebert" in model_name or "roberta-hate" in model_name:
             tokenizer = AutoTokenizer.from_pretrained(model_name)
             model = AutoModelForSequenceClassification.from_pretrained(model_name)
             moderator = pipeline(
@@ -49,20 +52,39 @@ for model_name in MODERATION_MODELS:
 
 print(f"Moderadores ativos: {len(moderators)}")
 
-# Modelos de análise de sentimentos (12 modelos)
+# MAIS MODELOS DE SENTIMENTO - Expandido de 12 para 18
 SENTIMENT_MODELS = [
+    # Português específico (prioritários)
     "neuralmind/bert-base-portuguese-cased",
     "neuralmind/bert-large-portuguese-cased",
+    "rufimelo/bert-large-portuguese-cased-finetuned-with-yelp-reviews",
+    
+    # XLM-RoBERTa (excelentes para multilíngue)
     "cardiffnlp/twitter-xlm-roberta-base-sentiment",
     "cardiffnlp/twitter-xlm-roberta-base-sentiment-multilingual",
     "citizenlab/twitter-xlm-roberta-base-sentiment-finetunned",
+    
+    # BERT Multilíngue
     "lxyuan/distilbert-base-multilingual-cased-sentiments-student",
     "nlptown/bert-base-multilingual-uncased-sentiment",
+    
+    # RoBERTa variants
     "finiteautomata/bertweet-base-sentiment-analysis",
     "siebert/sentiment-roberta-large-english",
-    "distilbert-base-uncased-finetuned-sst-2-english",
     "cardiffnlp/twitter-roberta-base-sentiment-latest",
+    "cardiffnlp/twitter-roberta-base-sentiment",
+    
+    # DistilBERT variants
+    "distilbert-base-uncased-finetuned-sst-2-english",
+    "bhadresh-savani/distilbert-base-uncased-emotion",
+    
+    # Emotion models (mapeados para sentimento)
     "j-hartmann/emotion-english-distilroberta-base",
+    "arpanghoshal/EmoRoBERTa",
+    
+    # Modelos adicionais especializados
+    "michellejieli/emotion_text_classifier",
+    "mrm8488/distilroberta-finetuned-financial-news-sentiment-analysis",
 ]
 
 print("\nCarregando modelos de análise de sentimentos...")
@@ -72,11 +94,11 @@ for idx, model_name in enumerate(SENTIMENT_MODELS, 1):
     try:
         print(f"[{idx}/{len(SENTIMENT_MODELS)}] {model_name.split('/')[-1]}...", end=" ")
         
-        if "neuralmind" in model_name or "emotion" in model_name:
+        if "neuralmind" in model_name or "emotion" in model_name or "Emo" in model_name:
             tokenizer = AutoTokenizer.from_pretrained(model_name)
             model = AutoModelForSequenceClassification.from_pretrained(model_name)
             classifier = pipeline(
-                "sentiment-analysis", 
+                "sentiment-analysis" if "sentiment" in model_name else "text-classification",
                 model=model, 
                 tokenizer=tokenizer,
                 device=0 if torch.cuda.is_available() else -1
@@ -91,7 +113,7 @@ for idx, model_name in enumerate(SENTIMENT_MODELS, 1):
         classifiers.append(classifier)
         print("OK")
         
-    except:
+    except Exception as e:
         print("FALHA")
         continue
 
@@ -101,25 +123,34 @@ print(f"- Analisadores: {len(classifiers)}")
 print(f"- Moderadores: {len(moderators)}")
 print(f"{'='*60}\n")
 
-# Limiar para alerta
-TOXICITY_THRESHOLD = 0.70
+# Limiar AUMENTADO para evitar falsos positivos
+TOXICITY_THRESHOLD = 0.75  # Aumentado de 0.70 para 0.75
 
-# Mapeamento de labels
+# Mapeamento expandido de labels
 LABEL_MAPPING = {
+    # Sentimento padrão
     'NEGATIVE': 'Negativo', 'negative': 'Negativo', 'NEG': 'Negativo',
     'NEUTRAL': 'Neutro', 'neutral': 'Neutro', 'NEU': 'Neutro',
     'POSITIVE': 'Positivo', 'positive': 'Positivo', 'POS': 'Positivo',
     'LABEL_0': 'Negativo', 'LABEL_1': 'Neutro', 'LABEL_2': 'Positivo',
-    '1 star': 'Negativo', '2 stars': 'Negativo', '3 stars': 'Neutro',
+    
+    # Estrelas
+    '1 star': 'Negativo', '2 stars': 'Negativo',
+    '3 stars': 'Neutro',
     '4 stars': 'Positivo', '5 stars': 'Positivo',
+    
+    # Emoções -> Sentimentos
     'anger': 'Negativo', 'disgust': 'Negativo', 'fear': 'Negativo', 
-    'sadness': 'Negativo', 'joy': 'Positivo', 'surprise': 'Neutro',
+    'sadness': 'Negativo', 'surprise': 'Neutro',
+    'joy': 'Positivo', 'love': 'Positivo', 'admiration': 'Positivo',
+    
+    # Outros formatos
+    'neg': 'Negativo', 'neu': 'Neutro', 'pos': 'Positivo',
 }
 
 def verificar_linguagem(texto):
     """
-    Verifica se há linguagem imprópria (DEPOIS da análise)
-    Retorna: (has_improper, score)
+    Verifica linguagem imprópria com MAIS modelos e threshold MAIOR
     """
     if not moderators or len(texto.strip()) < 3:
         return False, 0.0
@@ -132,12 +163,13 @@ def verificar_linguagem(texto):
             label = resultado['label'].lower()
             score = resultado['score']
             
-            # Interpretar resultado
-            is_toxic_label = any(word in label for word in ['toxic', 'hate', 'offensive'])
+            # Interpretar com mais cuidado
+            is_toxic_label = any(word in label for word in ['toxic', 'hate', 'offensive', 'hateful'])
             
             if is_toxic_label:
                 toxicity = score
             else:
+                # Se label é "normal" ou "not toxic", inverter
                 toxicity = 1 - score
             
             scores_toxicos.append(toxicity)
@@ -150,6 +182,8 @@ def verificar_linguagem(texto):
     
     # Média dos scores
     toxicity_score = np.mean(scores_toxicos)
+    
+    # Threshold MAIOR para reduzir falsos positivos
     has_improper = toxicity_score > TOXICITY_THRESHOLD
     
     return has_improper, toxicity_score
@@ -161,18 +195,17 @@ def normalizar_label(label):
 
 def analisar_texto(texto):
     """
-    NOVA LÓGICA:
-    1. SEMPRE analisa o sentimento primeiro
-    2. DEPOIS verifica se tem linguagem imprópria
-    3. Mostra sentimento + aviso (se necessário)
+    Análise com MELHOR cálculo de confiança
     """
     
     if not texto or len(texto.strip()) < 3:
         return "Aguardando texto para análise", {}, "-", "-", "-"
     
-    # PASSO 1: ANÁLISE DE SENTIMENTO (SEMPRE!)
+    # ANÁLISE DE SENTIMENTO
     texto_processado = texto[:512]
     predicoes = []
+    scores_brutos = []  # Para melhor cálculo
+    
     scores_por_classe = {
         'Negativo': [],
         'Neutro': [],
@@ -188,20 +221,25 @@ def analisar_texto(texto):
             score = resultado['score']
             
             predicoes.append(label_norm)
+            scores_brutos.append(score)
             modelos_usados += 1
             
+            # Distribuição mais conservadora
             if label_norm == 'Negativo':
                 scores_por_classe['Negativo'].append(score)
-                scores_por_classe['Neutro'].append((1-score) * 0.3)
-                scores_por_classe['Positivo'].append((1-score) * 0.7)
+                remaining = 1 - score
+                scores_por_classe['Neutro'].append(remaining * 0.4)
+                scores_por_classe['Positivo'].append(remaining * 0.6)
             elif label_norm == 'Neutro':
                 scores_por_classe['Neutro'].append(score)
-                scores_por_classe['Negativo'].append((1-score) * 0.5)
-                scores_por_classe['Positivo'].append((1-score) * 0.5)
-            else:
+                remaining = 1 - score
+                scores_por_classe['Negativo'].append(remaining * 0.5)
+                scores_por_classe['Positivo'].append(remaining * 0.5)
+            else:  # Positivo
                 scores_por_classe['Positivo'].append(score)
-                scores_por_classe['Negativo'].append((1-score) * 0.7)
-                scores_por_classe['Neutro'].append((1-score) * 0.3)
+                remaining = 1 - score
+                scores_por_classe['Negativo'].append(remaining * 0.6)
+                scores_por_classe['Neutro'].append(remaining * 0.4)
                 
         except:
             continue
@@ -209,18 +247,32 @@ def analisar_texto(texto):
     if not predicoes or modelos_usados == 0:
         return "Erro no processamento", {}, "-", "-", "-"
     
-    # Voting
+    # Voting majoritário
     contagem = Counter(predicoes)
     classificacao = contagem.most_common(1)[0][0]
     votos = contagem[classificacao]
     
-    # Probabilidades
-    probs = {k: np.mean(v) if v else 0.0 for k, v in scores_por_classe.items()}
+    # MELHOR cálculo de probabilidades
+    probs = {}
+    for classe in ['Negativo', 'Neutro', 'Positivo']:
+        scores = scores_por_classe[classe]
+        if scores:
+            # Usar mediana ao invés de média para reduzir outliers
+            probs[classe] = float(np.median(scores))
+        else:
+            probs[classe] = 0.0
+    
+    # Normalizar
     total = sum(probs.values())
     if total > 0:
         probs = {k: v/total for k, v in probs.items()}
     
-    confianca = probs[classificacao]
+    # Confiança baseada em voting + score
+    confianca_voting = votos / modelos_usados
+    confianca_score = probs[classificacao]
+    
+    # Confiança final = média ponderada (60% voting, 40% score)
+    confianca_final = (confianca_voting * 0.6) + (confianca_score * 0.4)
     
     # Consistência
     scores_final = scores_por_classe[classificacao]
@@ -231,7 +283,7 @@ def analisar_texto(texto):
         desvio = 0
         nivel = "N/A"
     
-    # PASSO 2: VERIFICAR LINGUAGEM IMPRÓPRIA (DEPOIS!)
+    # VERIFICAR LINGUAGEM (com threshold mais alto)
     has_improper, improper_score = verificar_linguagem(texto)
     
     # Formatar resultado
@@ -240,46 +292,45 @@ def analisar_texto(texto):
 
 ⚠️ **Alerta de Conteúdo**
 
-Este texto contém linguagem imprópria ou ofensiva (nível: {improper_score:.1%}).
+Detectada possível linguagem imprópria (confiança: {improper_score:.1%}).
 
-Evite usar:
+Recomendamos evitar:
 • Discurso de ódio
-• Termos racistas ou homofóbicos
-• Linguagem discriminatória
-• Xingamentos graves
+• Termos discriminatórios
+• Linguagem ofensiva
 
-O sentimento foi analisado, mas recomendamos reformular o texto de forma respeitosa."""
+O sentimento foi analisado normalmente."""
     else:
         resultado_texto = f"**{classificacao}**"
     
-    confianca_texto = f"{confianca:.1%}"
+    confianca_texto = f"{confianca_final:.1%}"
     consenso_texto = f"{votos}/{modelos_usados} modelos ({(votos/modelos_usados)*100:.0f}%)"
     consistencia_texto = f"{nivel} (σ={desvio:.3f})" if desvio > 0 else "N/A"
     
     return resultado_texto, probs, confianca_texto, consenso_texto, consistencia_texto
 
-# Casos de teste
+# Casos de teste variados
 casos_teste = [
-    ["Este produto superou minhas expectativas. Qualidade excelente e entrega rápida."],
-    ["Experiência muito negativa. O produto apresentou defeitos e o atendimento foi inadequado."],
-    ["Produto atende o esperado. Funcionalidades básicas dentro do padrão da categoria."],
-    ["Recomendo fortemente. Excelente custo-benefício e durabilidade comprovada."],
-    ["Satisfatório. Cumpre o prometido sem grandes destaques."],
-    ["Produto horrível, péssima qualidade, muito ruim."],
+    ["Este produto superou todas as minhas expectativas. Qualidade excepcional!"],
+    ["Experiência extremamente negativa. Produto defeituoso e atendimento péssimo."],
+    ["Produto normal. Atende o básico sem grandes destaques ou problemas."],
+    ["Recomendo! Excelente custo-benefício e entrega rápida."],
+    ["Satisfatório. Funciona conforme descrito, nada além disso."],
+    ["Produto horrível, péssima qualidade, muito ruim, não recomendo."],
+    ["Maravilhoso! Adorei cada detalhe, perfeito em todos os aspectos!"],
+    ["Decepcionante. Não corresponde à descrição e apresenta defeitos graves."],
 ]
 
 # Interface
-with gr.Blocks(title="Análise de Sentimentos") as demo:
+with gr.Blocks(title="Análise de Sentimentos Avançada") as demo:
     
     gr.Markdown(
         f"""
-        # Sistema de Análise de Sentimentos
+        # Sistema Avançado de Análise de Sentimentos
         
-        Análise por ensemble de {len(classifiers)} modelos com verificação de linguagem imprópria.
+        Análise por ensemble de **{len(classifiers)} modelos** especializados.
         
-        **Como funciona:**
-        1. Analisa o sentimento do texto (Negativo, Neutro ou Positivo)
-        2. Verifica se há linguagem imprópria e alerta (mas ainda mostra o sentimento)
+        **Sistema de verificação:** {len(moderators)} moderadores detectam linguagem imprópria.
         """
     )
     
@@ -298,7 +349,7 @@ with gr.Blocks(title="Análise de Sentimentos") as demo:
     
     with gr.Row():
         with gr.Column(scale=1):
-            resultado_output = gr.Markdown(label="Resultado")
+            resultado_output = gr.Markdown(label="Classificação")
             confianca_output = gr.Textbox(label="Confiança", interactive=False)
             consenso_output = gr.Textbox(label="Consenso", interactive=False)
             consistencia_output = gr.Textbox(label="Consistência", interactive=False)
@@ -322,43 +373,57 @@ with gr.Blocks(title="Análise de Sentimentos") as demo:
     gr.Markdown(
         f"""
         ---
-        ## Sobre o Sistema
+        ## Especificações do Sistema
         
-        ### Fluxo de Análise
+        ### Análise de Sentimento
         
-        1. **Análise de Sentimento** (sempre executada)
-           - {len(classifiers)} modelos analisam o texto
-           - Voting majoritário determina: Negativo, Neutro ou Positivo
-           - Cálculo de confiança e consenso
+        **Modelos Ativos:** {len(classifiers)} / {len(SENTIMENT_MODELS)}
         
-        2. **Verificação de Linguagem** (após a análise)
-           - {len(moderators)} modelos verificam conteúdo impróprio
-           - Se detectado (>{TOXICITY_THRESHOLD*100:.0f}%), adiciona alerta
-           - **Não bloqueia a análise**, apenas informa
-        
-        ### Modelos de Análise
-        
-        - BERTimbau (2 variantes) - Português BR
-        - XLM-RoBERTa (3 variantes) - Multilíngue
-        - BERT e DistilBERT Multilingual
+        **Arquitetura:**
+        - BERTimbau (português específico)
+        - XLM-RoBERTa (multilíngue)
+        - BERT e DistilBERT
         - RoBERTa especializados
-        - Outros modelos complementares
+        - Modelos de emoção
+        
+        **M��todo:**
+        - Voting majoritário
+        - Agregação por mediana (reduz outliers)
+        - Confiança combinada (voting + score)
         
         ### Verificação de Linguagem
         
-        - DistilBERT Toxicity Multilingual
+        **Moderadores Ativos:** {len(moderators)} / {len(MODERATION_MODELS)}
+        
+        **Threshold:** {TOXICITY_THRESHOLD*100:.0f}% (balanceado para evitar falsos positivos)
+        
+        **Modelos:**
+        - DistilBERT Toxicity
+        - Toxic-BERT (Unitary)
+        - Toxic Comment Model
+        - RoBERTa Hate Speech
         - DeHateBERT Portuguese
         
-        **Importante:** O sistema SEMPRE analisa o sentimento. Se houver linguagem imprópria,
-        você verá o resultado da análise + um aviso recomendando reformular o texto.
+        ### Melhorias Implementadas
+        
+        ✅ **Mais modelos** ({len(classifiers)} analisadores, {len(moderators)} moderadores)
+        
+        ✅ **Melhor confiança** (combina voting + probabilidades)
+        
+        ✅ **Menos falsos positivos** (threshold aumentado de 70% → 75%)
+        
+        ✅ **Agregação robusta** (mediana ao invés de média)
+        
+        ✅ **Distribuição conservadora** (scores mais equilibrados)
         
-        ### Por Que Este Design?
+        ### Fluxo de Processamento
         
-        Este approach permite:
-        - **Análise técnica completa** mesmo de textos com problemas
-        - **Feedback educativo** sobre linguagem inadequada
-        - **Transparência** nos resultados
-        - **Não censura** a análise, apenas orienta
+        1. **Análise paralela** por todos os modelos
+        2. **Voting majoritário** determina classificação
+        3. **Agregação por mediana** calcula probabilidades
+        4. **Confiança combinada** (60% voting + 40% score)
+        5. **Verificação de linguagem** com threshold elevado
+        6. **Resultado final** com métricas de qualidade
         """
     )