Update app.py

app.py

@@ -1,9 +1,11 @@
 import gradio as gr
 from transformers import pipeline
 import numpy as np
+from typing import List, Dict
 
 class SimpleTemperamentAnalyzer:
     def __init__(self):
+        # Modelo para análise de sentimentos em português
         self.model = pipeline(
             "text-classification",
             model="neuralmind/bert-base-portuguese-cased",
@@ -17,25 +19,67 @@ class SimpleTemperamentAnalyzer:
             'FLEUMÁTICO': ['Calmo', 'Pacífico', 'Objetivo', 'Diplomático', 'Organizado']
         }
 
-    def analisar_respostas(self, respostas_marcadas):
-        """Analisa as respostas e retorna os percentuais normalizados de cada temperamento"""
-        pontuacoes = {}
-        
-        # Calcula pontuações brutas
+        # Descrições para análise do modelo
+        self.descricoes_temperamentos = {
+            'SANGUÍNEO': 'pessoa extrovertida, social, otimista e comunicativa',
+            'COLÉRICO': 'pessoa determinada, prática, líder e independente',
+            'MELANCÓLICO': 'pessoa perfeccionista, sensível, detalhista e artística',
+            'FLEUMÁTICO': 'pessoa calma, pacífica, objetiva e organizada'
+        }
+
+    def analisar_texto_caracteristicas(self, caracteristicas: List[str]) -> Dict[str, float]:
+        """Usa o modelo NLP para analisar o texto das características selecionadas"""
+        # Junta as características em um texto para análise
+        texto_analise = " ".join(caracteristicas)
+        
+        # Análise para cada temperamento
+        scores_temp = {}
+        for temp, desc in self.descricoes_temperamentos.items():
+            # Analisa a similaridade entre as características selecionadas e a descrição do temperamento
+            resultado = self.model(f"Características: {texto_analise}. Descrição: {desc}")
+            scores_temp[temp] = resultado[0][0]['score']  # Pega o score principal
+            
+        return scores_temp
+
+    def analisar_respostas(self, respostas_marcadas: List[str]) -> Dict[str, float]:
+        """Combina análise tradicional com NLP para gerar pontuações"""
+        # Pontuações baseadas em contagem
+        pontuacoes_contagem = {}
         for temp, caracteristicas in self.temperamentos.items():
             marcadas = sum(1 for c in caracteristicas if c in respostas_marcadas)
-            pontuacoes[temp] = marcadas
-        
-        # Normaliza as pontuações para somarem 100%
-        total_pontos = sum(pontuacoes.values())
-        if total_pontos > 0:  # Evita divisão por zero
-            for temp in pontuacoes:
-                pontuacoes[temp] = (pontuacoes[temp] / total_pontos) * 100
-                
-        return pontuacoes
+            pontuacoes_contagem[temp] = marcadas
+        
+        # Pontuações baseadas em NLP
+        pontuacoes_nlp = self.analisar_texto_caracteristicas(respostas_marcadas)
+        
+        # Combina as pontuações (média ponderada)
+        pontuacoes_finais = {}
+        for temp in self.temperamentos:
+            # Peso 0.6 para contagem e 0.4 para NLP
+            pond_contagem = pontuacoes_contagem[temp] * 0.6
+            pond_nlp = pontuacoes_nlp[temp] * 0.4
+            pontuacoes_finais[temp] = pond_contagem + pond_nlp
+        
+        # Normaliza para 100%
+        total = sum(pontuacoes_finais.values())
+        if total > 0:
+            for temp in pontuacoes_finais:
+                pontuacoes_finais[temp] = (pontuacoes_finais[temp] / total) * 100
+        
+        return pontuacoes_finais
 
-    def gerar_analise(self, temperamento_dominante, pontuacoes):
-        """Gera uma análise detalhada baseada em todos os temperamentos"""
+    def interpretar_combinacao(self, temp_ordenados: List[tuple]) -> str:
+        """Usa o modelo para interpretar a combinação de temperamentos"""
+        combinacao = f"{temp_ordenados[0][0]} com {temp_ordenados[1][0]}"
+        interpretacao = self.model(
+            f"Combinação de temperamentos: {combinacao}. "
+            f"Características principais: {self.descricoes_temperamentos[temp_ordenados[0][0]]} "
+            f"com aspectos de {self.descricoes_temperamentos[temp_ordenados[1][0]]}"
+        )
+        return interpretacao[0][0]['label']
+
+    def gerar_analise(self, temperamento_dominante: str, pontuacoes: Dict[str, float]) -> Dict:
+        """Gera uma análise detalhada usando o modelo NLP"""
         descricoes = {
             'SANGUÍNEO': {
                 'positivo': ['sociabilidade', 'entusiasmo', 'carisma', 'energia positiva', 'facilidade de comunicação'],
@@ -63,23 +107,26 @@ class SimpleTemperamentAnalyzer:
             }
         }
 
-        # Ordena os temperamentos por pontuação
         temp_ordenados = sorted(pontuacoes.items(), key=lambda x: x[1], reverse=True)
         
-        # Gera análise combinada
+        # Usa o modelo para interpretar a combinação
+        interpretacao_combinacao = self.interpretar_combinacao(temp_ordenados)
+        
         analise = {
             'perfil_principal': f"Seu perfil predominante é {temperamento_dominante} ({pontuacoes[temperamento_dominante]:.1f}%), ",
-            'combinacao': "com influências significativas de " + 
-                        " e ".join([f"{temp} ({pont:.1f}%)" for temp, pont in temp_ordenados[1:3]]) + ".",
+            'combinacao': f"com influências significativas de {' e '.join([f'{temp} ({pont:.1f}%)' for temp, pont in temp_ordenados[1:3]])}.",
+            'interpretacao': interpretacao_combinacao,
             'caracteristicas': [],
             'areas_desenvolvimento': [],
             'perfil_profissional': "",
             'relacionamentos': ""
         }
         
-        # Adiciona características baseadas nos dois temperamentos principais
+        # Análise das características principais usando o modelo
         for temp, pont in temp_ordenados[:2]:
-            if pont > 20:  # Só considera temperamentos com pontuação significativa
+            if pont > 20:
+                caract_temp = " ".join(descricoes[temp]['positivo'])
+                analise_caract = self.model(f"Características principais: {caract_temp}")
                 analise['caracteristicas'].extend(descricoes[temp]['positivo'][:3])
                 analise['areas_desenvolvimento'].extend(descricoes[temp]['desafios'][:2])
                 analise['perfil_profissional'] += descricoes[temp]['profissional'] + " "
@@ -91,23 +138,18 @@ def criar_interface():
     analisador = SimpleTemperamentAnalyzer()
     
     def processar_selecao(selecoes):
-        # Calcula pontuações
         pontuacoes = analisador.analisar_respostas(selecoes)
-        
-        # Identifica temperamento dominante
         temperamento_dominante = max(pontuacoes.items(), key=lambda x: x[1])[0]
-        
-        # Gera análise
         analise = analisador.gerar_analise(temperamento_dominante, pontuacoes)
         
-        # Formata resultado
         resultado = "### Resultados da Análise de Temperamento\n\n"
         resultado += "**Pontuações:**\n"
         for temp, pont in pontuacoes.items():
             resultado += f"- {temp}: {pont:.1f}%\n"
         
         resultado += f"\n**Análise Detalhada:**\n"
-        resultado += f"{analise['perfil_principal']}{analise['combinacao']}\n\n"
+        resultado += f"{analise['perfil_principal']}{analise['combinacao']}\n"
+        resultado += f"**Interpretação:** {analise['interpretacao']}\n\n"
         
         resultado += "**Principais Características:**\n"
         for caract in analise['caracteristicas']:
@@ -122,7 +164,6 @@ def criar_interface():
         
         return resultado
 
-    # Interface Gradio
     with gr.Blocks(theme=gr.themes.Soft()) as interface:
         gr.Markdown("## Análise de Temperamento Simplificada")