Update app.py

app.py

@@ -1,6 +1,6 @@
 """
-Sistema Avançado de Análise de Sentimentos
-Ensemble de 12 modelos para máxima precisão
+Sistema Avançado de Análise de Sentimentos com Moderação de Conteúdo
+Ensemble de 12 modelos + Detecção de discurso de ódio
 """
 
 import gradio as gr
@@ -11,46 +11,64 @@ from collections import Counter
 import warnings
 warnings.filterwarnings('ignore')
 
-# Lista expandida de modelos - 12 modelos especializados
-MODELS = [
-    # XLM-RoBERTa variants (multilingual, excellent for Portuguese)
+# Modelos de moderação de conteúdo (verificam ANTES da análise)
+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
+]
+
+print("Carregando sistema de moderação de conteúdo...")
+moderators = []
+
+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
+        )
+        moderators.append(moderator)
+        print("OK")
+    except Exception as e:
+        print(f"FALHA")
+        continue
+
+print(f"Moderadores ativos: {len(moderators)}")
+
+# Modelos de análise de sentimentos
+SENTIMENT_MODELS = [
+    # XLM-RoBERTa variants
     "cardiffnlp/twitter-xlm-roberta-base-sentiment",
     "cardiffnlp/twitter-xlm-roberta-base-sentiment-multilingual",
     "citizenlab/twitter-xlm-roberta-base-sentiment-finetunned",
     
-    # DistilBERT variants (fast and efficient)
+    # DistilBERT variants
     "lxyuan/distilbert-base-multilingual-cased-sentiments-student",
     
-    # BERT multilingual variants
+    # BERT multilingual
     "nlptown/bert-base-multilingual-uncased-sentiment",
     
-    # Portuguese-specific models
+    # Portuguese-specific (BERTimbau)
     "neuralmind/bert-base-portuguese-cased",
     "neuralmind/bert-large-portuguese-cased",
     
-    # Additional specialized models
+    # Additional specialized
     "finiteautomata/bertweet-base-sentiment-analysis",
     "siebert/sentiment-roberta-large-english",
-    
-    # Alternative architectures
     "distilbert-base-uncased-finetuned-sst-2-english",
     "cardiffnlp/twitter-roberta-base-sentiment-latest",
-    
-    # Backup models
     "j-hartmann/emotion-english-distilroberta-base",
 ]
 
-print("Inicializando sistema de ensemble avançado...")
-print(f"Carregando {len(MODELS)} modelos...")
-
+print("\nCarregando modelos de análise de sentimentos...")
 classifiers = []
-model_names = []
 
-for idx, model_name in enumerate(MODELS, 1):
+for idx, model_name in enumerate(SENTIMENT_MODELS, 1):
     try:
-        print(f"[{idx}/{len(MODELS)}] Carregando {model_name.split('/')[-1]}...", end=" ")
+        print(f"[{idx}/{len(SENTIMENT_MODELS)}] {model_name.split('/')[-1]}...", end=" ")
         
-        # Alguns modelos precisam ser carregados de forma diferente
         if "neuralmind" in model_name or "emotion" in model_name:
             tokenizer = AutoTokenizer.from_pretrained(model_name)
             model = AutoModelForSequenceClassification.from_pretrained(model_name)
@@ -68,59 +86,110 @@ for idx, model_name in enumerate(MODELS, 1):
             )
         
         classifiers.append(classifier)
-        model_names.append(model_name.split('/')[-1])
         print("OK")
         
-    except Exception as e:
-        print(f"FALHA ({str(e)[:30]}...)")
+    except:
+        print("FALHA")
         continue
 
-total_loaded = len(classifiers)
 print(f"\n{'='*60}")
-print(f"Sistema pronto: {total_loaded} modelos ativos")
+print(f"Sistema completo:")
+print(f"- Moderadores: {len(moderators)}")
+print(f"- Analisadores: {len(classifiers)}")
 print(f"{'='*60}\n")
 
-# Mapeamento completo de labels
+# Limiar para detecção de conteúdo problemático
+TOXICITY_THRESHOLD = 0.6  # Ajustar se necessário (0.0 a 1.0)
+
+# Mapeamento de labels
 LABEL_MAPPING = {
-    # Formato padrão 3 classes
     'NEGATIVE': 'Negativo', 'negative': 'Negativo', 'NEG': 'Negativo',
     'NEUTRAL': 'Neutro', 'neutral': 'Neutro', 'NEU': 'Neutro',
     'POSITIVE': 'Positivo', 'positive': 'Positivo', 'POS': 'Positivo',
-    
-    # Labels alternativos
     'LABEL_0': 'Negativo', 'LABEL_1': 'Neutro', 'LABEL_2': 'Positivo',
-    
-    # Sistema de estrelas (1-5)
-    '1 star': 'Negativo', '2 stars': 'Negativo',
-    '3 stars': 'Neutro',
+    '1 star': 'Negativo', '2 stars': 'Negativo', '3 stars': 'Neutro',
     '4 stars': 'Positivo', '5 stars': 'Positivo',
-    
-    # Emoções (mapeadas para sentimentos)
-    'anger': 'Negativo', 'disgust': 'Negativo', 'fear': 'Negativo', 'sadness': 'Negativo',
-    'joy': 'Positivo', 'surprise': 'Neutro',
-    
-    # Outros formatos
+    'anger': 'Negativo', 'disgust': 'Negativo', 'fear': 'Negativo', 
+    'sadness': 'Negativo', 'joy': 'Positivo', 'surprise': 'Neutro',
     'neg': 'Negativo', 'neu': 'Neutro', 'pos': 'Positivo',
 }
 
+def verificar_conteudo(texto):
+    """
+    Verifica se o texto contém discurso de ódio, racismo, homofobia ou outros conteúdos inadequados.
+    Retorna: (is_toxic, confidence)
+    """
+    if not moderators:
+        return False, 0.0
+    
+    scores_toxicos = []
+    
+    for moderator in 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)
+            else:
+                # Label inesperado, usar score direto
+                scores_toxicos.append(score)
+                
+        except Exception as e:
+            continue
+    
+    if not scores_toxicos:
+        return False, 0.0
+    
+    # Média dos scores de toxicidade
+    toxicity_score = np.mean(scores_toxicos)
+    is_toxic = toxicity_score > TOXICITY_THRESHOLD
+    
+    return is_toxic, toxicity_score
+
 def normalizar_label(label):
-    """Normaliza diferentes formatos de labels para padrão unificado"""
+    """Normaliza diferentes formatos de 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 avançada usando ensemble de múltiplos modelos
-    Retorna classificação por voting majoritário
+    Análise com moderação de conteúdo.
+    Verifica discurso de ódio ANTES de analisar sentimento.
     """
     
     if not texto or len(texto.strip()) < 3:
         return "Aguardando entrada válida", {}, "-", "-", "-"
     
-    # Limitar tamanho para eficiência
-    texto_processado = texto[:512]
+    # PASSO 1: MODERAÇÃO DE CONTEÚDO
+    is_toxic, toxicity_score = 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."
+        )
+        
+        info_moderacao = {
+            'Inadequado': toxicity_score,
+            'Adequado': 1 - toxicity_score
+        }
+        
+        return mensagem_recusa, info_moderacao, f"{toxicity_score:.1%}", "Bloqueado", "Moderação"
     
-    # Coletar previsões de todos os modelos
+    # PASSO 2: ANÁLISE DE SENTIMENTO (só se passar na moderação)
+    texto_processado = texto[:512]
     predicoes = []
     scores_por_classe = {
         'Negativo': [],
@@ -130,16 +199,12 @@ def analisar_texto(texto):
     
     modelos_usados = 0
     
-    for idx, classifier in enumerate(classifiers):
+    for classifier in classifiers:
         try:
             resultado = classifier(texto_processado)[0]
-            label_original = resultado['label']
+            label_norm = normalizar_label(resultado['label'])
             score = resultado['score']
             
-            # Normalizar label
-            label_norm = normalizar_label(label_original)
-            
-            # Adicionar previsão
             predicoes.append(label_norm)
             modelos_usados += 1
             
@@ -152,80 +217,68 @@ def analisar_texto(texto):
                 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:  # Positivo
+            else:
                 scores_por_classe['Positivo'].append(score)
                 scores_por_classe['Negativo'].append((1-score) * 0.7)
                 scores_por_classe['Neutro'].append((1-score) * 0.3)
                 
-        except Exception as e:
+        except:
             continue
     
     if not predicoes or modelos_usados == 0:
         return "Erro no processamento", {}, "-", "-", "-"
     
     # Voting majoritário
-    contagem_votos = Counter(predicoes)
-    classificacao_final = contagem_votos.most_common(1)[0][0]
-    votos_maioria = contagem_votos[classificacao_final]
+    contagem = Counter(predicoes)
+    classificacao = contagem.most_common(1)[0][0]
+    votos = contagem[classificacao]
     
-    # Calcular probabilidades médias
-    probabilidades = {}
-    for classe, scores in scores_por_classe.items():
-        if scores:
-            probabilidades[classe] = np.mean(scores)
-        else:
-            probabilidades[classe] = 0.0
-    
-    # Normalizar probabilidades para somar 1.0
-    total_prob = sum(probabilidades.values())
-    if total_prob > 0:
-        probabilidades = {k: v/total_prob for k, v in probabilidades.items()}
+    # Probabilidades
+    probs = {k: np.mean(v) if v else 0.0 for k, v in scores_por_classe.items()}
+    total = sum(probs.values())
+    if total > 0:
+        probs = {k: v/total for k, v in probs.items()}
     
-    # Calcular confiança
-    confianca = probabilidades[classificacao_final]
+    confianca = probs[classificacao]
     
-    # Calcular desvio padrão (dispersão)
-    scores_final = scores_por_classe[classificacao_final]
+    # Consistência
+    scores_final = scores_por_classe[classificacao]
     if len(scores_final) > 1:
         desvio = np.std(scores_final)
-        consistencia = 1 - desvio  # Quanto menor o desvio, maior a consistência
+        consistencia = 1 - desvio
+        nivel = "Alta" if consistencia > 0.8 else "Média" if consistencia > 0.6 else "Baixa"
     else:
-        consistencia = 1.0
-    
-    # Informações detalhadas
-    consenso = f"{votos_maioria}/{modelos_usados}"
-    percentual_consenso = f"{(votos_maioria/modelos_usados)*100:.0f}%"
-    nivel_consistencia = "Alta" if consistencia > 0.8 else "Média" if consistencia > 0.6 else "Baixa"
+        desvio = 0
+        nivel = "N/A"
     
-    # Formatação dos outputs
-    resultado_texto = f"{classificacao_final}"
+    # Outputs
+    resultado_texto = f"{classificacao}"
     confianca_texto = f"{confianca:.1%}"
-    consenso_texto = f"{consenso} modelos ({percentual_consenso})"
-    consistencia_texto = f"{nivel_consistencia} (σ={desvio:.3f})" if len(scores_final) > 1 else "N/A"
+    consenso_texto = f"{votos}/{modelos_usados} ({(votos/modelos_usados)*100:.0f}%)"
+    consistencia_texto = f"{nivel} (σ={desvio:.3f})" if desvio > 0 else "N/A"
     
-    return resultado_texto, probabilidades, confianca_texto, consenso_texto, consistencia_texto
+    return resultado_texto, probs, confianca_texto, consenso_texto, consistencia_texto
 
-# Casos de teste diversificados
+# Casos de teste
 casos_teste = [
-    ["Produto excepcional. Qualidade superior e entrega dentro do prazo estabelecido."],
-    ["Experiência extremamente negativa. Produto defeituoso e atendimento inadequado."],
-    ["Atende as especificações básicas. Desempenho dentro do esperado para a categoria."],
-    ["Recomendo fortemente. Excelente relação custo-benefício e durabilidade comprovada."],
-    ["Decepcionante. Não corresponde às especificações técnicas informadas pelo fabricante."],
+    ["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."],
-    ["Péssima qualidade. Apresentou falhas graves logo nos primeiros dias de uso."],
-    ["Surpreendeu positivamente. Supera produtos similares na mesma faixa de preço."],
 ]
 
-# Interface Gradio
-with gr.Blocks(title="Sistema de Análise de Sentimentos Avançado") as demo:
+# Interface
+with gr.Blocks(title="Sistema de Análise com Moderação") as demo:
     
     gr.Markdown(
         f"""
-        # Sistema Avançado de Análise de Sentimentos
+        # Sistema de Análise de Sentimentos com Moderação de Conteúdo
         
-        Classificação por ensemble com {total_loaded} modelos especializados.
-        Utiliza voting majoritário e agregação de probabilidades para máxima precisão.
+        Ensemble de {len(classifiers)} modelos de análise com {len(moderators)} moderadores de conteúdo.
+        
+        **Sistema de proteção:** Detecta e bloqueia automaticamente conteúdo com discurso de ódio, 
+        racismo, homofobia e outros tipos de discriminação.
         """
     )
     
@@ -244,9 +297,9 @@ with gr.Blocks(title="Sistema de Análise de Sentimentos Avançado") as demo:
     
     with gr.Row():
         with gr.Column(scale=1):
-            resultado_output = gr.Textbox(label="Classificação Final", interactive=False)
-            confianca_output = gr.Textbox(label="Nível de Confiança", interactive=False)
-            consenso_output = gr.Textbox(label="Consenso entre Modelos", interactive=False)
+            resultado_output = gr.Markdown(label="Resultado")
+            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)
         
         with gr.Column(scale=1):
@@ -268,50 +321,59 @@ with gr.Blocks(title="Sistema de Análise de Sentimentos Avançado") as demo:
     gr.Markdown(
         f"""
         ---
-        ## Especificações Técnicas
+        ## Especificações do 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
         
-        **Arquitetura:** Ensemble híbrido com voting majoritário  
-        **Modelos Ativos:** {total_loaded} / {len(MODELS)} carregados  
-        **Processamento:** Paralelo com agregação de probabilidades  
-        **Idioma Principal:** Português (BR/PT)  
+        **Ação:** Textos detectados como inadequados são bloqueados e não passam pela análise de sentimentos.
+        
+        **Limiar de Detecção:** {TOXICITY_THRESHOLD*100:.0f}% (ajustável)
+        
+        ### Análise de Sentimentos
+        
+        **Modelos Ativos:** {len(classifiers)} / {len(SENTIMENT_MODELS)}  
+        **Moderadores Ativos:** {len(moderators)} / {len(MODERATION_MODELS)}  
+        **Arquitetura:** Ensemble com voting majoritário  
         **Classes:** Negativo, Neutro, Positivo  
-        **Limite de Entrada:** 512 caracteres
+        **Limite:** 512 caracteres
         
-        ### Metodologia
+        ### Fluxo de Processamento
         
-        1. **Pré-processamento:** Normalização e truncamento do texto
-        2. **Inferência Paralela:** Cada modelo processa independentemente
-        3. **Normalização de Labels:** Unificação de diferentes formatos
-        4. **Voting Majoritário:** Classificação por maioria simples
-        5. **Agregação Probabilística:** Média ponderada das probabilidades
-        6. **Análise de Consistência:** Cálculo de desvio padrão entre modelos
+        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
         
-        ### Modelos Incluídos
+        ### Modelos de Moderação
         
-        - XLM-RoBERTa (Cardiff NLP) - 3 variantes
-        - DistilBERT Multilingual
-        - BERT Multilingual (NLP Town)
-        - BERTimbau (NeuralMind) - 2 variantes
-        - RoBERTa (Finiteautomata)
-        - Siebert Sentiment RoBERTa
-        - DistilBERT SST-2
-        - Twitter RoBERTa Latest
-        - DistilRoBERTa Emotion
+        - DistilBERT Toxicity (CitizenLab) - Multilíngue
+        - Toxic-BERT (Unitary)
+        - Toxic Comment Model (Martin-HA)
+        
+        ### Modelos de Análise
         
-        ### Métricas de Saída
+        - XLM-RoBERTa (3 variantes)
+        - BERTimbau (2 variantes - PT-BR)
+        - DistilBERT Multilingual
+        - BERT Multilingual
+        - RoBERTa (4 variantes)
+        - Outros especializados
         
-        - **Classificação Final:** Resultado do voting majoritário
-        - **Confiança:** Probabilidade média da classe predita
-        - **Consenso:** Proporção de modelos que concordam
-        - **Consistência:** Medida de dispersão (desvio padrão)
+        ### Política de Uso
         
-        ### Vantagens do Ensemble
+        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.
         
-        - Redução de viés de modelos individuais
-        - Maior robustez a diferentes tipos de texto
-        - Melhor generalização em casos ambíguos
-        - Validação cruzada automática
-        - Precisão superior (~15-20% vs modelo único)
+        **Compromisso:** Promover análise técnica mantendo respeito e dignidade humana.
         """
     )