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",
return_all_scores=True
)
self.temperamentos = {
'SANGUÍNEO': ['Alegre', 'Extrovertido', 'Social', 'Otimista', 'Comunicativo'],
'COLÉRICO': ['Líder', 'Determinado', 'Prático', 'Produtivo', 'Independente'],
'MELANCÓLICO': ['Perfeccionista', 'Detalhista', 'Artístico', 'Sensível', 'Idealista'],
'FLEUMÁTICO': ['Calmo', 'Pacífico', 'Objetivo', 'Diplomático', 'Organizado']
}
# 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_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 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'],
'desafios': ['tendência à dispersão', 'dificuldade com rotinas', 'pode ser superficial'],
'profissional': 'Tende a se destacar em áreas que envolvem interação social, vendas, comunicação e trabalho em equipe.',
'relacionamentos': 'Faz amizades facilmente e mantém um círculo social ativo. Precisa desenvolver maior profundidade nas relações.'
},
'COLÉRICO': {
'positivo': ['liderança', 'determinação', 'praticidade', 'foco em resultados', 'iniciativa'],
'desafios': ['impaciência', 'autoritarismo', 'dificuldade em demonstrar empatia'],
'profissional': 'Excelente em posições de liderança, gestão de projetos e empreendedorismo.',
'relacionamentos': 'Direto e objetivo nas relações, precisa desenvolver mais sensibilidade e paciência.'
},
'MELANCÓLICO': {
'positivo': ['profundidade analítica', 'criatividade', 'atenção aos detalhes', 'sensibilidade', 'perfeccionismo'],
'desafios': ['autocrítica excessiva', 'tendência à introspecção', 'dificuldade com mudanças'],
'profissional': 'Se destaca em áreas que exigem análise detalhada, planejamento e criatividade.',
'relacionamentos': 'Valoriza relações profundas e significativas, mas pode ter dificuldade em se abrir.'
},
'FLEUMÁTICO': {
'positivo': ['equilíbrio emocional', 'diplomacia', 'organização', 'confiabilidade', 'paciência'],
'desafios': ['passividade', 'resistência a mudanças', 'dificuldade em tomar iniciativa'],
'profissional': 'Eficiente em funções que requerem mediação, organização e trabalho metódico.',
'relacionamentos': 'Estável e confiável nas relações, mas pode parecer distante ou pouco expressivo.'
}
}
temp_ordenados = sorted(pontuacoes.items(), key=lambda x: x[1], reverse=True)
# 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': 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': ""
}
# Análise das características principais usando o modelo
for temp, pont in temp_ordenados[:2]:
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'] + " "
analise['relacionamentos'] += descricoes[temp]['relacionamentos'] + " "
return analise
def criar_interface():
analisador = SimpleTemperamentAnalyzer()
def validar_selecao(selecoes):
if len(selecoes) > 5:
# Retorna apenas as primeiras 5 seleções
return selecoes[:5], "Por favor, selecione apenas 5 características."
return selecoes, "" if selecoes else "Selecione até 5 características que mais combinam com você."
def processar_selecao(selecoes):
selecoes_validadas, mensagem = validar_selecao(selecoes)
if mensagem and "apenas" in mensagem: # Se excedeu o limite
return f"⚠️ {mensagem}\n\nPor favor, desmarque algumas opções para continuar."
if not selecoes_validadas:
return "Selecione algumas características para realizar a análise."
pontuacoes = analisador.analisar_respostas(selecoes_validadas)
temperamento_dominante = max(pontuacoes.items(), key=lambda x: x[1])[0]
analise = analisador.gerar_analise(temperamento_dominante, pontuacoes)
resultado = "### Resultados da Análise de Temperamento\n\n"
resultado += "**Características Selecionadas:**\n"
for caract in selecoes_validadas:
resultado += f"- {caract}\n"
resultado += "\n**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"
resultado += f"**Interpretação:** {analise['interpretacao']}\n\n"
resultado += "**Principais Características:**\n"
for caract in analise['caracteristicas']:
resultado += f"- {caract}\n"
resultado += "\n**Áreas para Desenvolvimento:**\n"
for area in analise['areas_desenvolvimento']:
resultado += f"- {area}\n"
resultado += f"\n**Perfil Profissional:**\n{analise['perfil_profissional']}\n\n"
resultado += f"**Relacionamentos:**\n{analise['relacionamentos']}\n"
return resultado
with gr.Blocks(theme=gr.themes.Soft()) as interface:
gr.Markdown("## Análise de Temperamento Simplificada")
gr.Markdown("### Selecione exatamente 5 características que mais combinam com você")
todas_caracteristicas = []
for temp, caract in analisador.temperamentos.items():
todas_caracteristicas.extend(caract)
selecoes = gr.CheckboxGroup(
choices=todas_caracteristicas,
label="Escolha 5 características:",
info="Limite: 5 características"
)
btn = gr.Button("Analisar")
saida = gr.Markdown()
# Atualiza em tempo real para validar seleções
selecoes.change(
fn=validar_selecao,
inputs=selecoes,
outputs=[selecoes, saida]
)
# Processa a análise quando o botão é clicado
btn.click(
fn=processar_selecao,
inputs=selecoes,
outputs=saida
)
return interface
if __name__ == "__main__":
interface = criar_interface()
interface.launch()