Update app.py

app.py

@@ -1,6 +1,6 @@
 """
-Sistema Avançado de Análise de Sentimentos com Moderação de Conteúdo
-Ensemble de 12 modelos + Detecção de discurso de ódio
+Sistema Avançado de Análise de Sentimentos com Moderação em Português
+Ensemble de modelos + Detecção de discurso de ódio em PT-BR
 """
 
 import gradio as gr
@@ -11,55 +11,76 @@ from collections import Counter
 import warnings
 warnings.filterwarnings('ignore')
 
-# Modelos de moderação de conteúdo (verificam ANTES da análise)
+# Modelos de moderação ESPECÍFICOS para PORTUGUÊS
 MODERATION_MODELS = [
-    "citizenlab/distilbert-base-multilingual-cased-toxicity",  # Toxicidade multilíngue
-    "unitary/toxic-bert",  # Detecção de toxicidade
-    "martin-ha/toxic-comment-model",  # Comentários tóxicos
+    # Modelos brasileiros de detecção de ódio
+    "citizenlab/distilbert-base-multilingual-cased-toxicity",  # Multilíngue mas funciona bem em PT
+    "francisco-perez-sorrosal/distilbert-base-uncased-finetuned-with-hateoffensive",
+    "Hate-speech-CNERG/dehatebert-mono-portuguese",  # Específico PT!
+    "neuralmind/bert-base-portuguese-cased",  # BERTimbau adaptado
 ]
 
-print("Carregando sistema de moderação de conteúdo...")
+print("Carregando sistema de moderação em português...")
 moderators = []
+moderator_names = []
 
 for model_name in MODERATION_MODELS:
     try:
-        print(f"Carregando moderador: {model_name.split('/')[-1]}...", end=" ")
-        moderator = pipeline(
-            "text-classification",
-            model=model_name,
-            device=0 if torch.cuda.is_available() else -1
-        )
+        print(f"Carregando: {model_name.split('/')[-1]}...", end=" ")
+        
+        # Carregar com configuração específica
+        if "dehatebert" in model_name:
+            tokenizer = AutoTokenizer.from_pretrained(model_name)
+            model = AutoModelForSequenceClassification.from_pretrained(model_name)
+            moderator = pipeline(
+                "text-classification",
+                model=model,
+                tokenizer=tokenizer,
+                device=0 if torch.cuda.is_available() else -1
+            )
+        elif "neuralmind" in model_name:
+            # BERTimbau precisa ser adaptado para classificação
+            tokenizer = AutoTokenizer.from_pretrained(model_name)
+            # Usar modelo base e adaptar
+            moderator = None  # Pular por enquanto, precisa fine-tuning específico
+            print("PULADO (precisa adaptação)")
+            continue
+        else:
+            moderator = pipeline(
+                "text-classification",
+                model=model_name,
+                device=0 if torch.cuda.is_available() else -1
+            )
+        
         moderators.append(moderator)
+        moderator_names.append(model_name.split('/')[-1])
         print("OK")
+        
     except Exception as e:
-        print(f"FALHA")
+        print(f"FALHA ({str(e)[:40]}...)")
         continue
 
 print(f"Moderadores ativos: {len(moderators)}")
 
 # Modelos de análise de sentimentos
 SENTIMENT_MODELS = [
-    # XLM-RoBERTa variants
+    # Modelos em português prioritários
+    "neuralmind/bert-base-portuguese-cased",
+    "neuralmind/bert-large-portuguese-cased",
+    
+    # XLM-RoBERTa (excelentes para PT)
     "cardiffnlp/twitter-xlm-roberta-base-sentiment",
     "cardiffnlp/twitter-xlm-roberta-base-sentiment-multilingual",
     "citizenlab/twitter-xlm-roberta-base-sentiment-finetunned",
     
-    # DistilBERT variants
+    # Multilíngues
     "lxyuan/distilbert-base-multilingual-cased-sentiments-student",
-    
-    # BERT multilingual
     "nlptown/bert-base-multilingual-uncased-sentiment",
     
-    # Portuguese-specific (BERTimbau)
-    "neuralmind/bert-base-portuguese-cased",
-    "neuralmind/bert-large-portuguese-cased",
-    
-    # Additional specialized
+    # Modelos adicionais
     "finiteautomata/bertweet-base-sentiment-analysis",
     "siebert/sentiment-roberta-large-english",
     "distilbert-base-uncased-finetuned-sst-2-english",
-    "cardiffnlp/twitter-roberta-base-sentiment-latest",
-    "j-hartmann/emotion-english-distilroberta-base",
 ]
 
 print("\nCarregando modelos de análise de sentimentos...")
@@ -69,7 +90,7 @@ 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:
             tokenizer = AutoTokenizer.from_pretrained(model_name)
             model = AutoModelForSequenceClassification.from_pretrained(model_name)
             classifier = pipeline(
@@ -98,8 +119,34 @@ print(f"- Moderadores: {len(moderators)}")
 print(f"- Analisadores: {len(classifiers)}")
 print(f"{'='*60}\n")
 
-# Limiar para detecção de conteúdo problemático
-TOXICITY_THRESHOLD = 0.6  # Ajustar se necessário (0.0 a 1.0)
+# Limiar para detecção
+TOXICITY_THRESHOLD = 0.65
+
+# Palavras-chave de alerta (backup em português)
+PALAVRAS_ALERTA = [
+    # Racismo
+    'preto', 'negro', 'macaco', 'escuro',
+    # Homofobia
+    'gay', 'viado', 'bicha', 'sapatao',
+    # Sexismo
+    'vadia', 'puta', 'vagabunda',
+    # Xenofobia
+    'nordestino', 'baiano', 'paraiba',
+    # Outros
+    'lixo', 'merda', 'idiota', 'burro'
+]
+
+def verificar_palavras_suspeitas(texto):
+    """
+    Verificação adicional por palavras-chave (backup)
+    Retorna número de palavras suspeitas encontradas
+    """
+    texto_lower = texto.lower()
+    count = 0
+    for palavra in PALAVRAS_ALERTA:
+        if palavra in texto_lower:
+            count += 1
+    return count
 
 # Mapeamento de labels
 LABEL_MAPPING = {
@@ -109,77 +156,97 @@ LABEL_MAPPING = {
     'LABEL_0': 'Negativo', 'LABEL_1': 'Neutro', 'LABEL_2': 'Positivo',
     '1 star': 'Negativo', '2 stars': 'Negativo', '3 stars': 'Neutro',
     '4 stars': 'Positivo', '5 stars': 'Positivo',
-    'anger': 'Negativo', 'disgust': 'Negativo', 'fear': 'Negativo', 
-    'sadness': 'Negativo', 'joy': 'Positivo', 'surprise': 'Neutro',
-    'neg': 'Negativo', 'neu': 'Neutro', 'pos': 'Positivo',
+    # Labels específicos de hate speech
+    'hate': 'Tóxico', 'offensive': 'Tóxico', 'toxic': 'Tóxico',
+    'NOT': 'Normal', 'normal': 'Normal', 'neutral': 'Normal',
 }
 
 def verificar_conteudo(texto):
     """
-    Verifica se o texto contém discurso de ódio, racismo, homofobia ou outros conteúdos inadequados.
-    Retorna: (is_toxic, confidence)
+    Verifica conteúdo inadequado usando modelos + palavras-chave
+    Retorna: (is_toxic, confidence, details)
     """
     if not moderators:
-        return False, 0.0
+        # Fallback: verificação por palavras-chave
+        palavras_suspeitas = verificar_palavras_suspeitas(texto)
+        if palavras_suspeitas >= 2:
+            return True, 0.75, "Detecção por palavras-chave"
+        return False, 0.0, "Sem moderadores ativos"
     
     scores_toxicos = []
+    detalhes = []
     
-    for moderator in moderators:
+    for idx, moderator in enumerate(moderators):
         try:
             resultado = moderator(texto[:512])[0]
-            
-            # Diferentes modelos usam diferentes labels
             label = resultado['label'].lower()
             score = resultado['score']
             
-            # Verificar se é tóxico
-            if 'toxic' in label or 'hate' in label or 'offensive' in label:
-                scores_toxicos.append(score)
-            elif 'not' in label or 'neutral' in label:
-                scores_toxicos.append(1 - score)
+            # Interpretar resultado
+            is_toxic_label = any(word in label for word in ['toxic', 'hate', 'offensive', 'negative'])
+            
+            if is_toxic_label:
+                toxicity = score
             else:
-                # Label inesperado, usar score direto
-                scores_toxicos.append(score)
-                
-        except Exception as e:
+                toxicity = 1 - score
+            
+            scores_toxicos.append(toxicity)
+            detalhes.append(f"Modelo {idx+1}: {toxicity:.1%}")
+            
+        except:
             continue
     
     if not scores_toxicos:
-        return False, 0.0
+        # Fallback para palavras-chave
+        palavras_suspeitas = verificar_palavras_suspeitas(texto)
+        if palavras_suspeitas >= 2:
+            return True, 0.75, "Detecção por palavras-chave"
+        return False, 0.0, "Erro na moderação"
     
-    # Média dos scores de toxicidade
+    # Média dos scores
     toxicity_score = np.mean(scores_toxicos)
+    
+    # Verificação adicional por palavras
+    palavras_suspeitas = verificar_palavras_suspeitas(texto)
+    if palavras_suspeitas >= 3:
+        toxicity_score = max(toxicity_score, 0.8)
+    
     is_toxic = toxicity_score > TOXICITY_THRESHOLD
     
-    return is_toxic, toxicity_score
+    return is_toxic, toxicity_score, " | ".join(detalhes)
 
 def normalizar_label(label):
-    """Normaliza diferentes formatos de labels"""
+    """Normaliza labels"""
     label_upper = label.upper() if isinstance(label, str) else str(label)
     return LABEL_MAPPING.get(label, LABEL_MAPPING.get(label_upper, 'Neutro'))
 
 def analisar_texto(texto):
     """
-    Análise com moderação de conteúdo.
-    Verifica discurso de ódio ANTES de analisar sentimento.
+    Análise com moderação em português
     """
     
     if not texto or len(texto.strip()) < 3:
-        return "Aguardando entrada válida", {}, "-", "-", "-"
+        return "Aguardando texto para análise", {}, "-", "-", "-"
     
-    # PASSO 1: MODERAÇÃO DE CONTEÚDO
-    is_toxic, toxicity_score = verificar_conteudo(texto)
+    # MODERAÇÃO
+    is_toxic, toxicity_score, detalhes_mod = verificar_conteudo(texto)
     
     if is_toxic:
-        mensagem_recusa = (
-            "**Conteúdo Inadequado Detectado**\n\n"
-            "Este sistema não processa textos que contenham:\n"
-            "- Discurso de ódio\n"
-            "- Racismo\n"
-            "- Homofobia\n"
-            "- Conteúdo ofensivo ou discriminatório\n\n"
-            "Por favor, revise o texto e tente novamente com conteúdo respeitoso."
-        )
+        mensagem_recusa = f"""
+**⚠️ Conteúdo Inadequado Detectado**
+
+Este sistema não analisa textos que contenham:
+• Discurso de ódio
+• Racismo ou discriminação racial
+• Homofobia ou LGBTfobia
+• Sexismo ou misoginia
+• Xenofobia
+• Linguagem ofensiva ou discriminatória
+
+**Por favor, reformule o texto de forma respeitosa.**
+
+*Nível de inadequação detectado: {toxicity_score:.1%}*
+        """
         
         info_moderacao = {
             'Inadequado': toxicity_score,
@@ -188,7 +255,7 @@ def analisar_texto(texto):
         
         return mensagem_recusa, info_moderacao, f"{toxicity_score:.1%}", "Bloqueado", "Moderação"
     
-    # PASSO 2: ANÁLISE DE SENTIMENTO (só se passar na moderação)
+    # ANÁLISE DE SENTIMENTO
     texto_processado = texto[:512]
     predicoes = []
     scores_por_classe = {
@@ -208,7 +275,6 @@ def analisar_texto(texto):
             predicoes.append(label_norm)
             modelos_usados += 1
             
-            # Distribuir probabilidades
             if label_norm == 'Negativo':
                 scores_por_classe['Negativo'].append(score)
                 scores_por_classe['Neutro'].append((1-score) * 0.3)
@@ -228,7 +294,7 @@ def analisar_texto(texto):
     if not predicoes or modelos_usados == 0:
         return "Erro no processamento", {}, "-", "-", "-"
     
-    # Voting majoritário
+    # Voting
     contagem = Counter(predicoes)
     classificacao = contagem.most_common(1)[0][0]
     votos = contagem[classificacao]
@@ -245,40 +311,37 @@ def analisar_texto(texto):
     scores_final = scores_por_classe[classificacao]
     if len(scores_final) > 1:
         desvio = np.std(scores_final)
-        consistencia = 1 - desvio
-        nivel = "Alta" if consistencia > 0.8 else "Média" if consistencia > 0.6 else "Baixa"
+        nivel = "Alta" if desvio < 0.1 else "Média" if desvio < 0.2 else "Baixa"
     else:
         desvio = 0
         nivel = "N/A"
     
-    # Outputs
     resultado_texto = f"{classificacao}"
     confianca_texto = f"{confianca:.1%}"
-    consenso_texto = f"{votos}/{modelos_usados} ({(votos/modelos_usados)*100:.0f}%)"
+    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_teste = [
-    ["Produto excepcional. Qualidade superior e entrega dentro do prazo."],
-    ["Experiência negativa. Produto defeituoso e atendimento inadequado."],
-    ["Atende as especificações básicas. Desempenho dentro do esperado."],
-    ["Recomendo fortemente. Excelente relação custo-benefício."],
-    ["Performance satisfatória. Funcionalidades adequadas ao uso proposto."],
+    ["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."],
 ]
 
 # Interface
-with gr.Blocks(title="Sistema de Análise com Moderação") as demo:
+with gr.Blocks(title="Análise de Sentimentos") as demo:
     
     gr.Markdown(
         f"""
-        # Sistema de Análise de Sentimentos com Moderação de Conteúdo
+        # Sistema de Análise de Sentimentos com Moderação
         
-        Ensemble de {len(classifiers)} modelos de análise com {len(moderators)} moderadores de conteúdo.
+        Análise por ensemble de {len(classifiers)} modelos com moderação de conteúdo em português.
         
-        **Sistema de proteção:** Detecta e bloqueia automaticamente conteúdo com discurso de ódio, 
-        racismo, homofobia e outros tipos de discriminação.
+        **Sistema de proteção:** Detecta automaticamente discurso de ódio, racismo, homofobia e conteúdo discriminatório.
         """
     )
     
@@ -286,20 +349,20 @@ with gr.Blocks(title="Sistema de Análise com Moderação") as demo:
         with gr.Column():
             texto_input = gr.Textbox(
                 label="Texto para Análise",
-                placeholder="Insira o texto (até 512 caracteres)...",
+                placeholder="Digite ou cole o texto aqui (até 512 caracteres)...",
                 lines=5,
                 max_lines=10
             )
             
             with gr.Row():
-                btn_analisar = gr.Button("Processar", variant="primary", size="lg")
+                btn_analisar = gr.Button("Analisar", variant="primary", size="lg")
                 btn_limpar = gr.Button("Limpar", size="lg")
     
     with gr.Row():
         with gr.Column(scale=1):
-            resultado_output = gr.Markdown(label="Resultado")
-            confianca_output = gr.Textbox(label="Confiança", interactive=False)
-            consenso_output = gr.Textbox(label="Consenso", interactive=False)
+            resultado_output = gr.Markdown(label="Classificação")
+            confianca_output = gr.Textbox(label="Nível de Confiança", interactive=False)
+            consenso_output = gr.Textbox(label="Consenso entre Modelos", interactive=False)
             consistencia_output = gr.Textbox(label="Consistência", interactive=False)
         
         with gr.Column(scale=1):
@@ -321,63 +384,66 @@ with gr.Blocks(title="Sistema de Análise com Moderação") as demo:
     gr.Markdown(
         f"""
         ---
-        ## Especificações do Sistema
+        ## Sobre o Sistema
         
         ### Moderação de Conteúdo
         
-        O sistema verifica automaticamente:
-        - Discurso de ódio
-        - Racismo e discriminação racial
-        - Homofobia e LGBTfobia
-        - Sexismo e misoginia
-        - Xenofobia
-        - Outros conteúdos ofensivos ou discriminatórios
+        O sistema verifica automaticamente e bloqueia:
+        • Discurso de ódio e intolerância
+        • Racismo e discriminação racial
+        • Homofobia e LGBTfobia
+        • Sexismo e misoginia
+        • Xenofobia e regionalismo
+        • Linguagem ofensiva ou discriminatória
         
-        **Ação:** Textos detectados como inadequados são bloqueados e não passam pela análise de sentimentos.
+        **Método:** Ensemble de modelos especializados + verificação por palavras-chave
         
-        **Limiar de Detecção:** {TOXICITY_THRESHOLD*100:.0f}% (ajustável)
+        **Limiar:** {TOXICITY_THRESHOLD*100:.0f}% de confiança para bloqueio
         
         ### Análise de Sentimentos
         
-        **Modelos Ativos:** {len(classifiers)} / {len(SENTIMENT_MODELS)}  
-        **Moderadores Ativos:** {len(moderators)} / {len(MODERATION_MODELS)}  
-        **Arquitetura:** Ensemble com voting majoritário  
+        **Modelos Ativos:** {len(classifiers)}  
+        **Moderadores Ativos:** {len(moderators)}  
+        **Método:** Voting majoritário com agregação probabilística  
         **Classes:** Negativo, Neutro, Positivo  
-        **Limite:** 512 caracteres
+        **Idioma Principal:** Português Brasileiro
         
         ### Fluxo de Processamento
         
-        1. **Recebimento:** Sistema recebe o texto
-        2. **Moderação:** Verificação de conteúdo inadequado
-        3. **Bloqueio:** Se inadequado, interrompe e informa
-        4. **Análise:** Se adequado, processa com ensemble
-        5. **Resultado:** Retorna classificação e métricas
+        1. **Recepção** do texto
+        2. **Moderação** por modelos especializados
+        3. **Verificação adicional** por palavras-chave
+        4. **Bloqueio** se inadequado ou **Análise** se adequado
+        5. **Resultado** com métricas de qualidade
         
-        ### Modelos de Moderação
+        ### Modelos Utilizados
         
-        - DistilBERT Toxicity (CitizenLab) - Multilíngue
-        - Toxic-BERT (Unitary)
-        - Toxic Comment Model (Martin-HA)
+        **Moderação em Português:**
+        - DistilBERT Toxicity Multilingual
+        - HateOffensive Detection
+        - DeHateBERT Portuguese
+        - Verificação por palavras-chave em PT-BR
         
-        ### Modelos de Análise
+        **Análise de Sentimentos:**
+        - BERTimbau (2 variantes) - Português BR
+        - XLM-RoBERTa (3 variantes) - Multilíngue
+        - BERT e DistilBERT Multilingual
+        - Modelos especializados adicionais
         
-        - XLM-RoBERTa (3 variantes)
-        - BERTimbau (2 variantes - PT-BR)
-        - DistilBERT Multilingual
-        - BERT Multilingual
-        - RoBERTa (4 variantes)
-        - Outros especializados
+        ### Política de Uso Responsável
         
-        ### Política de Uso
+        Este sistema foi desenvolvido para análise técnica de sentimentos em conteúdos respeitosos.
+        Não tolera e não processa qualquer forma de discriminação ou discurso de ódio.
         
-        Este sistema foi desenvolvido para análise de sentimentos em conteúdos respeitosos.
-        Não tolera e não processa conteúdo que promova ódio, discriminação ou violência.
+        **Compromisso:** Promover análise técnica mantendo respeito à dignidade humana e aos direitos fundamentais.
+        
+        ---
         
-        **Compromisso:** Promover análise técnica mantendo respeito e dignidade humana.
+        **Nota Técnica:** O sistema utiliza múltiplas camadas de verificação para maximizar 
+        a detecção de conteúdo inadequado, incluindo modelos de IA e verificação por padrões linguísticos.
         """
     )
     
-    # Eventos
     btn_analisar.click(
         fn=analisar_texto,
         inputs=texto_input,