Create app_backup.py

app_backup.py

@@ -0,0 +1,471 @@
+"""
+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
+import torch
+from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification
+import numpy as np
+from collections import Counter
+import warnings
+warnings.filterwarnings('ignore')
+
+# 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",
+]
+
+print("Carregando sistema de moderação...")
+moderators = []
+
+for model_name in MODERATION_MODELS:
+    try:
+        print(f"Moderador: {model_name.split('/')[-1]}...", end=" ")
+        
+        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(
+                "text-classification",
+                model=model,
+                tokenizer=tokenizer,
+                device=0 if torch.cuda.is_available() else -1
+            )
+        else:
+            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)}")
+
+# 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",
+    "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...")
+classifiers = []
+
+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 or "Emo" in model_name:
+            tokenizer = AutoTokenizer.from_pretrained(model_name)
+            model = AutoModelForSequenceClassification.from_pretrained(model_name)
+            classifier = pipeline(
+                "sentiment-analysis" if "sentiment" in model_name else "text-classification",
+                model=model, 
+                tokenizer=tokenizer,
+                device=0 if torch.cuda.is_available() else -1
+            )
+        else:
+            classifier = pipeline(
+                "sentiment-analysis", 
+                model=model_name,
+                device=0 if torch.cuda.is_available() else -1
+            )
+        
+        classifiers.append(classifier)
+        print("OK")
+        
+    except Exception as e:
+        print("FALHA")
+        continue
+
+print(f"\n{'='*60}")
+print(f"Sistema completo:")
+print(f"- Analisadores: {len(classifiers)}")
+print(f"- Moderadores: {len(moderators)}")
+print(f"{'='*60}\n")
+
+# Limiar AUMENTADO para evitar falsos positivos
+TOXICITY_THRESHOLD = 0.80  # Aumentado para reduzir falsos positivos
+
+# 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',
+    
+    # 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', 'surprise': 'Neutro',
+    'joy': 'Positivo', 'love': 'Positivo', 'admiration': 'Positivo',
+    
+    # Outros formatos
+    'neg': 'Negativo', 'neu': 'Neutro', 'pos': 'Positivo',
+}
+
+def verificar_linguagem(texto):
+    """
+    Verifica linguagem imprópria com MAIS modelos e threshold MAIOR
+    Com interpretação melhorada de labels
+    """
+    if not moderators or len(texto.strip()) < 3:
+        return False, 0.0
+    
+    scores_toxicos = []
+    
+    for moderator in moderators:
+        try:
+            resultado = moderator(texto[:512])[0]
+            label = resultado['label'].lower()
+            score = resultado['score']
+            
+            # Interpretar labels com MAIS cuidado
+            # Labels que indicam TOXICIDADE
+            toxic_keywords = ['toxic', 'hate', 'offensive', 'hateful', 'obscene', 'threat', 'insult']
+            # Labels que indicam NORMALIDADE
+            normal_keywords = ['not', 'normal', 'neutral', 'clean']
+            
+            is_toxic_label = any(word in label for word in toxic_keywords)
+            is_normal_label = any(word in label for word in normal_keywords)
+            
+            # Calcular toxicity score com lógica melhorada
+            if is_toxic_label and not is_normal_label:
+                # Label diz que é tóxico
+                toxicity = score
+            elif is_normal_label or 'not' in label:
+                # Label diz que NÃO é tóxico
+                toxicity = 1 - score
+            else:
+                # Label ambíguo, assumir score direto se alto
+                toxicity = score if score > 0.5 else 1 - score
+            
+            scores_toxicos.append(toxicity)
+            
+        except:
+            continue
+    
+    if not scores_toxicos:
+        return False, 0.0
+    
+    # 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
+
+def normalizar_label(label):
+    """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 MELHOR cálculo de confiança
+    """
+    
+    if not texto or len(texto.strip()) < 3:
+        return "Aguardando texto para análise", {}, "-", "-", "-"
+    
+    # ANÁLISE DE SENTIMENTO
+    texto_processado = texto[:512]
+    predicoes = []
+    scores_brutos = []  # Para melhor cálculo
+    
+    scores_por_classe = {
+        'Negativo': [],
+        'Neutro': [],
+        'Positivo': []
+    }
+    
+    modelos_usados = 0
+    
+    for classifier in classifiers:
+        try:
+            resultado = classifier(texto_processado)[0]
+            label_norm = normalizar_label(resultado['label'])
+            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)
+                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)
+                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)
+                remaining = 1 - score
+                scores_por_classe['Negativo'].append(remaining * 0.6)
+                scores_por_classe['Neutro'].append(remaining * 0.4)
+                
+        except:
+            continue
+    
+    if not predicoes or modelos_usados == 0:
+        return "Erro no processamento", {}, "-", "-", "-"
+    
+    # Voting majoritário
+    contagem = Counter(predicoes)
+    classificacao = contagem.most_common(1)[0][0]
+    votos = contagem[classificacao]
+    
+    # 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()}
+    
+    # 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]
+    if len(scores_final) > 1:
+        desvio = np.std(scores_final)
+        nivel = "Alta" if desvio < 0.1 else "Média" if desvio < 0.2 else "Baixa"
+    else:
+        desvio = 0
+        nivel = "N/A"
+    
+    # VERIFICAR LINGUAGEM (com threshold mais alto)
+    has_improper, improper_score = verificar_linguagem(texto)
+    
+    # LÓGICA INTELIGENTE: Se Positivo com boa confiança, provavelmente não é ofensivo
+    if classificacao == 'Positivo' and confianca_final > 0.70:
+        has_improper = False  # Ignora alerta para textos claramente positivos
+    
+    # Se Neutro ou Negativo, ainda verifica normalmente
+    
+    # Formatar resultado
+    if has_improper:
+        resultado_texto = f"""**{classificacao}**
+
+⚠️ **Alerta de Conteúdo**
+
+Detectada possível linguagem imprópria (confiança: {improper_score:.1%}).
+
+Recomendamos evitar:
+• Discurso de ódio
+• Termos discriminatórios
+• Linguagem ofensiva
+
+O sentimento foi analisado normalmente."""
+    else:
+        resultado_texto = f"**{classificacao}**"
+    
+    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 variados
+casos_teste = [
+    ["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 Avançada") as demo:
+    
+    gr.Markdown(
+        f"""
+        # Sistema Avançado de Análise de Sentimentos
+        
+        Análise por ensemble de **{len(classifiers)} modelos** especializados.
+        
+        **Sistema de verificação:** {len(moderators)} moderadores detectam linguagem imprópria.
+        """
+    )
+    
+    with gr.Row():
+        with gr.Column():
+            texto_input = gr.Textbox(
+                label="Texto para Análise",
+                placeholder="Digite ou cole o texto aqui (até 512 caracteres)...",
+                lines=5,
+                max_lines=10
+            )
+            
+            with gr.Row():
+                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="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)
+        
+        with gr.Column(scale=1):
+            probs_output = gr.Label(
+                label="Distribuição de Probabilidades",
+                num_top_classes=3
+            )
+    
+    gr.Markdown("### Casos de Teste")
+    
+    gr.Examples(
+        examples=casos_teste,
+        inputs=texto_input,
+        outputs=[resultado_output, probs_output, confianca_output, consenso_output, consistencia_output],
+        fn=analisar_texto,
+        cache_examples=False
+    )
+    
+    gr.Markdown(
+        f"""
+        ---
+        ## Especificações do Sistema
+        
+        ### Análise de Sentimento
+        
+        **Modelos Ativos:** {len(classifiers)} / {len(SENTIMENT_MODELS)}
+        
+        **Arquitetura:**
+        - BERTimbau (português específico)
+        - XLM-RoBERTa (multilíngue)
+        - BERT e DistilBERT
+        - RoBERTa especializados
+        - Modelos de emoção
+        
+        **Método:**
+        - Voting majoritário
+        - Agregação por mediana (reduz outliers)
+        - Confiança combinada (voting + score)
+        
+        ### Verificação de Linguagem
+        
+        **Moderadores Ativos:** {len(moderators)} / {len(MODERATION_MODELS)}
+        
+        **Threshold:** {TOXICITY_THRESHOLD*100:.0f}% (mais alto para evitar falsos positivos)
+        
+        **Lógica Inteligente:**
+        - Textos claramente positivos (>70% confiança) não geram alertas
+        - Foco em detectar problemas reais
+        
+        **Modelos:**
+        - DistilBERT Toxicity
+        - Toxic-BERT (Unitary)
+        - Toxic Comment Model
+        - RoBERTa Hate Speech
+        - DeHateBERT Portuguese
+        
+        ### 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)
+        
+        ### Fluxo de Processamento
+        
+        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
+        """
+    )
+    
+    btn_analisar.click(
+        fn=analisar_texto,
+        inputs=texto_input,
+        outputs=[resultado_output, probs_output, confianca_output, consenso_output, consistencia_output]
+    )
+    
+    btn_limpar.click(
+        fn=lambda: ("", "", "", "", "", {}),
+        inputs=None,
+        outputs=[texto_input, resultado_output, confianca_output, consenso_output, consistencia_output, probs_output]
+    )
+    
+    texto_input.submit(
+        fn=analisar_texto,
+        inputs=texto_input,
+        outputs=[resultado_output, probs_output, confianca_output, consenso_output, consistencia_output]
+    )
+
+if __name__ == "__main__":
+    demo.launch()