Update app.py

app.py

@@ -1,178 +1,158 @@
 """
-Versão Gradio para Hugging Face Spaces
+Sistema de Análise de Sentimentos - Ensemble de Modelos
+Desenvolvido para classificação de textos em português
 """
 
 import gradio as gr
 import torch
-from transformers import AutoTokenizer, AutoModelForSequenceClassification
+from transformers import pipeline
 import numpy as np
+from collections import Counter
 
-# Configuração
-MODEL_NAME = "lxyuan/distilbert-base-multilingual-cased-sentiments-student"
+# Modelos selecionados para português
+MODELS = [
+    "cardiffnlp/twitter-xlm-roberta-base-sentiment",
+    "lxyuan/distilbert-base-multilingual-cased-sentiments-student",
+    "nlptown/bert-base-multilingual-uncased-sentiment",
+    "citizenlab/twitter-xlm-roberta-base-sentiment-finetunned",
+    "cardiffnlp/twitter-xlm-roberta-base-sentiment-multilingual"
+]
 
-# Carregar modelo
-print("Carregando modelo...")
-tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
-model = AutoModelForSequenceClassification.from_pretrained(MODEL_NAME)
-model.eval()
-print("Modelo carregado com sucesso!")
+print("Inicializando modelos...")
+classifiers = []
 
-# Labels
-LABEL_MAP = {
-    0: "NEGATIVO",
-    1: "NEUTRO",
-    2: "POSITIVO"
-}
+for model_name in MODELS:
+    try:
+        classifier = pipeline("sentiment-analysis", model=model_name, device=0 if torch.cuda.is_available() else -1)
+        classifiers.append(classifier)
+        print(f"OK: {model_name.split('/')[-1]}")
+    except:
+        print(f"Falha: {model_name.split('/')[-1]}")
+
+print(f"{len(classifiers)} modelos ativos")
 
-EMOJI_MAP = {
-    "NEGATIVO": "😢",
-    "NEUTRO": "😐",
-    "POSITIVO": "😊"
+# Padronização de labels
+LABEL_MAP = {
+    'NEGATIVE': 'Negativo', 'negative': 'Negativo', 'NEG': 'Negativo',
+    'NEUTRAL': 'Neutro', 'neutral': 'Neutro', 'NEU': 'Neutro',
+    'POSITIVE': 'Positivo', 'positive': 'Positivo', 'POS': 'Positivo',
+    '1 star': 'Negativo', '2 stars': 'Negativo',
+    '3 stars': 'Neutro',
+    '4 stars': 'Positivo', '5 stars': 'Positivo',
 }
 
-def classificar_sentimento(texto):
-    """
-    Classifica o sentimento do texto.
-    """
+def processar(texto):
+    """Classifica texto usando ensemble de modelos"""
+    
     if not texto or len(texto.strip()) < 3:
-        return "Por favor, digite um texto válido.", {}, 0.0
+        return "Aguardando entrada", {}, "-", "-"
     
-    # Tokenizar
-    inputs = tokenizer(
-        texto,
-        padding=True,
-        truncation=True,
-        max_length=512,
-        return_tensors='pt'
-    )
+    texto = texto[:500]
+    predicoes = []
+    scores = {'Negativo': [], 'Neutro': [], 'Positivo': []}
     
-    # Predição
-    with torch.no_grad():
-        outputs = model(**inputs)
+    for clf in classifiers:
+        try:
+            result = clf(texto)[0]
+            label = LABEL_MAP.get(result['label'], result['label'])
+            score = result['score']
+            
+            predicoes.append(label)
+            
+            # Distribuição de scores
+            for classe in scores.keys():
+                if classe == label:
+                    scores[classe].append(score)
+                else:
+                    scores[classe].append((1-score)/(len(scores)-1))
+        except:
+            continue
     
-    # Probabilidades
-    probs = torch.nn.functional.softmax(outputs.logits, dim=-1)
-    probs = probs.numpy()[0]
+    if not predicoes:
+        return "Erro no processamento", {}, "-", "-"
     
-    # Resultado
-    pred_class = int(np.argmax(probs))
-    sentimento = LABEL_MAP[pred_class]
-    confianca = float(np.max(probs))
+    # Resultado por voting
+    contagem = Counter(predicoes)
+    resultado = contagem.most_common(1)[0][0]
+    votos = contagem[resultado]
     
-    # Criar dicionário de probabilidades para o Label
-    prob_dict = {
-        f"{EMOJI_MAP[LABEL_MAP[i]]} {LABEL_MAP[i]}": float(probs[i])
-        for i in range(len(probs))
-    }
+    # Probabilidades
+    probs = {k: np.mean(v) if v else 0 for k, v in scores.items()}
+    total = sum(probs.values())
+    if total > 0:
+        probs = {k: v/total for k, v in probs.items()}
     
-    # Resultado principal
-    resultado = f"{EMOJI_MAP[sentimento]} **{sentimento}**"
+    confianca = probs[resultado]
+    info = f"{votos}/{len(predicoes)} modelos"
     
-    return resultado, prob_dict, confianca
+    return resultado, probs, f"{confianca:.2%}", info
 
-# Exemplos
-exemplos = [
-    ["Adorei o produto! Superou minhas expectativas."],
-    ["Péssimo atendimento, nunca mais volto."],
-    ["Ok, nada de especial."],
-    ["O filme é sensacional! Recomendo muito!"],
-    ["Horrível! Pior experiência da minha vida."],
-    ["Satisfeito com a compra, chegou rápido."],
+# Casos de teste
+casos = [
+    ["Produto de qualidade superior. Recomendo para uso profissional."],
+    ["Apresenta defeitos graves. Não atende especificações mínimas."],
+    ["Desempenho adequado. Corresponde à descrição do fabricante."],
+    ["Excelente custo-benefício. Entrega conforme prometido."],
+    ["Qualidade inferior ao esperado. Necessita melhorias significativas."],
 ]
 
-# Interface Gradio
-with gr.Blocks(title="Análise de Sentimentos") as demo:
-    gr.Markdown(
-        """
-        # 🤖 Análise de Sentimentos com IA
-        
-        Descubra o sentimento por trás do texto usando modelos Transformer!
-        
-        Digite ou cole um texto e descubra se é **positivo**, **negativo** ou **neutro**.
-        """
-    )
+# Interface
+demo = gr.Blocks(title="Análise de Sentimentos")
+
+with demo:
+    gr.Markdown("# Sistema de Análise de Sentimentos")
+    gr.Markdown("Classificação automática usando ensemble de modelos Transformer")
     
     with gr.Row():
-        with gr.Column(scale=2):
-            texto_input = gr.Textbox(
-                label="📝 Digite seu texto aqui",
-                placeholder="Ex: Adorei o produto! Superou todas as minhas expectativas...",
-                lines=5,
-                max_lines=10
-            )
-            
-            with gr.Row():
-                btn_analisar = gr.Button("🔍 Analisar Sentimento", variant="primary")
-                btn_limpar = gr.Button("🗑️ Limpar")
+        entrada = gr.Textbox(
+            label="Texto",
+            placeholder="Insira o texto para análise",
+            lines=4
+        )
     
     with gr.Row():
-        with gr.Column(scale=1):
-            resultado_output = gr.Markdown(
-                label="Resultado",
-                value=""
-            )
-            
-            confianca_output = gr.Number(
-                label="📊 Confiança"
-            )
+        btn_proc = gr.Button("Processar", variant="primary")
+        btn_limp = gr.Button("Limpar")
+    
+    with gr.Row():
+        with gr.Column():
+            resultado = gr.Textbox(label="Classificação")
+            confianca = gr.Textbox(label="Confiança")
+            info = gr.Textbox(label="Consenso")
         
-        with gr.Column(scale=1):
-            probs_output = gr.Label(
-                label="📈 Distribuição de Probabilidades",
-                num_top_classes=3
-            )
+        with gr.Column():
+            probs = gr.Label(label="Probabilidades")
     
-    gr.Markdown("### 💡 Exemplos para testar:")
+    gr.Markdown("### Casos de Teste")
     gr.Examples(
-        examples=exemplos,
-        inputs=texto_input,
-        outputs=[resultado_output, probs_output, confianca_output],
-        fn=classificar_sentimento,
-        cache_examples=False
+        examples=casos,
+        inputs=entrada,
+        outputs=[resultado, probs, confianca, info],
+        fn=processar
     )
     
     gr.Markdown(
         """
         ---
-        ### 📚 Sobre o Modelo
-        
-        Este sistema usa modelos **Transformer** treinados em milhares de textos em português.
+        **Especificações Técnicas**
         
-        **Características:**
-        - ✅ Análise em tempo real
-        - ✅ Suporte para português brasileiro
-        - ✅ Alta precisão
-        - ✅ Múltiplas classes (Positivo, Neutro, Negativo)
+        Método: Ensemble voting com 5 modelos Transformer  
+        Idioma: Português (BR/PT)  
+        Classes: Negativo, Neutro, Positivo  
+        Limite: 500 caracteres por texto
         
-        **Limitações:**
-        - Textos muito longos são truncados
-        - Sarcasmo pode ser difícil de detectar
-        - Contexto cultural pode afetar resultados
-        
-        ---
-        **Feito com ❤️ usando Transformers e Gradio**
+        Modelos utilizados:
+        - XLM-RoBERTa (Cardiff NLP)
+        - DistilBERT Multilingual
+        - BERT Multilingual (NLP Town)
+        - XLM-RoBERTa Fine-tuned (CitizenLab)
+        - XLM-RoBERTa Multilingual (Cardiff NLP)
         """
     )
     
-    # Eventos
-    btn_analisar.click(
-        fn=classificar_sentimento,
-        inputs=texto_input,
-        outputs=[resultado_output, probs_output, confianca_output]
-    )
-    
-    btn_limpar.click(
-        fn=lambda: ("", "", {}, 0.0),
-        inputs=None,
-        outputs=[texto_input, resultado_output, probs_output, confianca_output]
-    )
-    
-    texto_input.submit(
-        fn=classificar_sentimento,
-        inputs=texto_input,
-        outputs=[resultado_output, probs_output, confianca_output]
-    )
+    btn_proc.click(fn=processar, inputs=entrada, outputs=[resultado, probs, confianca, info])
+    btn_limp.click(fn=lambda: ("", "", "", "", {}), outputs=[entrada, resultado, confianca, info, probs])
+    entrada.submit(fn=processar, inputs=entrada, outputs=[resultado, probs, confianca, info])
 
-# Iniciar
 if __name__ == "__main__":
     demo.launch()