Update app.py

app.py

@@ -1,178 +1,174 @@
 import gradio as gr
-import pandas as pd
-import matplotlib.pyplot as plt
-import seaborn as sns
-from ctransformers import AutoModelForCausalLM
-import json
-import os
-
-# Arquivo para armazenar o contador
-COUNTER_FILE = "disc_usage_counter.json"
-
-# Função para gerenciar o contador
-def load_counter():
-    if os.path.exists(COUNTER_FILE):
-        with open(COUNTER_FILE, 'r') as f:
-            return json.load(f)
-    return {"total_uses": 0}
-
-def save_counter(counter):
-    with open(COUNTER_FILE, 'w') as f:
-        json.dump(counter, f)
-
-def increment_counter():
-    counter = load_counter()
-    counter["total_uses"] += 1
-    save_counter(counter)
-    return f"Total de avaliações realizadas: {counter['total_uses']}"
-
-def get_counter_text():
-    counter = load_counter()
-    return f"Total de avaliações realizadas: {counter['total_uses']}"
-
-# Configuração do modelo local
-def load_model():
-    return AutoModelForCausalLM.from_pretrained(
-        'TheBloke/Mistral-7B-Instruct-v0.1-GGUF',
-        model_file='mistral-7b-instruct-v0.1.Q4_K_M.gguf',
-        model_type='mistral',
-        gpu_layers=0
-    )
-
-# Questões DISC (mantido igual)
-perguntas = {
-    'D': [
-        "Eu sou direto e vou direto ao ponto",
-        "Eu gosto de estar no controle",
-        "Eu sou competitivo e gosto de vencer",
-        "Eu tomo decisões rapidamente"
-    ],
-    'I': [
-        "Eu sou extrovertido e sociável",
-        "Eu gosto de conhecer novas pessoas",
-        "Eu sou entusiasta e otimista",
-        "Eu gosto de trabalhar em equipe"
-    ],
-    'S': [
-        "Eu sou paciente e calmo",
-        "Eu prefiro ambientes estáveis",
-        "Eu sou bom ouvinte",
-        "Eu ajudo os outros sempre que posso"
-    ],
-    'C': [
-        "Eu sou detalhista e preciso",
-        "Eu sigo regras e procedimentos",
-        "Eu analiso todas as opções antes de decidir",
-        "Eu gosto de qualidade e excelência"
-    ]
-}
-
-def calcular_disc(respostas):
-    resultados = {'D': 0, 'I': 0, 'S': 0, 'C': 0}
-    
-    for tipo, valor in respostas.items():
-        perfil = tipo[0]
-        resultados[perfil] += valor
-    
-    total = sum(resultados.values())
-    for perfil in resultados:
-        resultados[perfil] = (resultados[perfil] / total) * 100
-    
-    return resultados
-
-def criar_grafico(resultados):
-    plt.figure(figsize=(10, 6))
-    sns.barplot(x=list(resultados.keys()), y=list(resultados.values()))
-    plt.title('Seu Perfil DISC')
-    plt.xlabel('Dimensões')
-    plt.ylabel('Porcentagem')
-    
-    for i, v in enumerate(resultados.values()):
-        plt.text(i, v, f'{v:.1f}%', ha='center', va='bottom')
-    
-    return plt
-
-def gerar_analise_llm(llm, resultados, respostas_brutas):
-    prompt = f"""<s>[INST] Como um especialista em análise comportamental DISC, faça uma análise detalhada do seguinte perfil:
-
-Resultados percentuais:
-Dominância (D): {resultados['D']:.1f}%
-Influência (I): {resultados['I']:.1f}%
-Estabilidade (S): {resultados['S']:.1f}%
-Conformidade (C): {resultados['C']:.1f}%
-
-Respostas com pontuações mais altas:
-"""
-
-    for tipo, valor in respostas_brutas.items():
-        if valor >= 4:
-            dimensao = tipo[0]
-            num_questao = int(tipo[1]) - 1
-            questao = perguntas[dimensao][num_questao]
-            prompt += f"- Pontuação {valor}/5 para: {questao}\n"
-
-    prompt += """
-Forneça:
-1. Análise geral do perfil
-2. Pontos fortes e áreas de desenvolvimento
-3. Sugestões de desenvolvimento profissional
-4. Como este perfil pode interagir melhor com outros perfis
-5. Ambientes de trabalho mais adequados
-[/INST]"""
-
-    return llm(prompt, max_new_tokens=1024, temperature=0.7)
+import numpy as np
+from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
+import torch
 
 class DiscAnalyzer:
     def __init__(self):
-        self.llm = load_model()
-    
-    def avaliar_disc(self, values):
-        # Incrementa o contador
-        counter_text = increment_counter()
+        self.disc_profiles = {
+            'D': 'Dominance',
+            'I': 'Influence',
+            'S': 'Steadiness',
+            'C': 'Compliance'
+        }
         
-        # Processamento normal
-        respostas = {}
-        for i, (tipo, perguntas_tipo) in enumerate(perguntas.items()):
-            for j, pergunta in enumerate(perguntas_tipo):
-                respostas[f"{tipo}{j+1}"] = values[i*4 + j]
+        # Inicializar modelo do Hugging Face
+        # Usando BLOOM-560M que tem bom suporte para português
+        self.tokenizer = AutoTokenizer.from_pretrained("bigscience/bloom-560m")
+        self.model = AutoModelForCausalLM.from_pretrained("bigscience/bloom-560m")
+        self.generator = pipeline(
+            "text-generation",
+            model=self.model,
+            tokenizer=self.tokenizer,
+            device=0 if torch.cuda.is_available() else -1
+        )
+
+    def generate_llm_report(self, scores, perfil_principal):
+        """
+        Gera relatório personalizado usando modelo do Hugging Face baseado nos scores DISC.
+        """
+        prompt = f"""
+        Analise o seguinte perfil DISC e gere um relatório detalhado:
         
-        resultados = calcular_disc(respostas)
-        fig = criar_grafico(resultados)
-        analise = gerar_analise_llm(self.llm, resultados, respostas)
+        Perfil DISC:
+        - Dominância: {scores['D']:.1f}%
+        - Influência: {scores['I']:.1f}%
+        - Estabilidade: {scores['S']:.1f}%
+        - Conformidade: {scores['C']:.1f}%
         
-        return fig, analise, counter_text
+        Perfil Principal: {self.disc_profiles[perfil_principal]}
 
-# Interface Gradio
-analyzer = DiscAnalyzer()
-
-with gr.Blocks(title="Avaliação DISC com LLM Local") as app:
-    gr.Markdown("# Avaliação de Perfil DISC com Análise Avançada")
-    
-    # Contador de uso (corrigido)
-    gr.Markdown(get_counter_text())
-    
-    gr.Markdown("### Avalie cada afirmação em uma escala de 1 a 5")
-    
-    sliders = []
-    for tipo, perguntas_tipo in perguntas.items():
-        with gr.Group():
-            gr.Markdown(f"## Dimensão {tipo}")
-            for pergunta in perguntas_tipo:
-                sliders.append(gr.Slider(1, 5, value=3, label=pergunta))
-    
-    btn = gr.Button("Avaliar Perfil")
-    
-    with gr.Row():
-        plot = gr.Plot()
-    
-    analise = gr.Markdown(label="Análise Detalhada do Perfil")
-    uso = gr.Markdown(label="Contador de Uso")
+        Relatório do Perfil:
+        """
+        
+        try:
+            # Gerar relatório
+            output = self.generator(
+                prompt,
+                max_length=1000,
+                num_return_sequences=1,
+                temperature=0.7,
+                top_p=0.9,
+                do_sample=True
+            )
+            
+            return output[0]['generated_text'].replace(prompt, "").strip()
+            
+        except Exception as e:
+            return f"Erro ao gerar relatório: {str(e)}"
+
+    def avaliar_disc(self, 
+                    q1, q2, q3, q4,
+                    q5, q6, q7, q8,
+                    q9, q10, q11, q12,
+                    q13, q14, q15, q16):
+        """
+        Avalia o perfil DISC baseado nas respostas do questionário.
+        """
+        # Converter inputs para números
+        responses = [
+            int(q1), int(q2), int(q3), int(q4),
+            int(q5), int(q6), int(q7), int(q8),
+            int(q9), int(q10), int(q11), int(q12),
+            int(q13), int(q14), int(q15), int(q16)
+        ]
+
+        # Calcular scores para cada dimensão DISC
+        d_score = sum([responses[i] for i in [0, 4, 8, 12]]) / 16 * 100
+        i_score = sum([responses[i] for i in [1, 5, 9, 13]]) / 16 * 100
+        s_score = sum([responses[i] for i in [2, 6, 10, 14]]) / 16 * 100
+        c_score = sum([responses[i] for i in [3, 7, 11, 15]]) / 16 * 100
+
+        # Encontrar o perfil dominante
+        scores = {
+            'D': d_score,
+            'I': i_score,
+            'S': s_score,
+            'C': c_score
+        }
+        perfil_principal = max(scores, key=scores.get)
+        
+        # Gerar relatório LLM
+        relatorio_llm = self.generate_llm_report(scores, perfil_principal)
+
+        return (
+            f"Seu perfil principal é {self.disc_profiles[perfil_principal]} ({perfil_principal})",
+            relatorio_llm,
+            {
+                "Dimensão": list(scores.keys()),
+                "Score": list(scores.values())
+            }
+        )
+
+def create_disc_interface():
+    """
+    Cria a interface Gradio para o analisador DISC.
+    """
+    analyzer = DiscAnalyzer()
     
-    btn.click(
-        fn=analyzer.avaliar_disc,
-        inputs=sliders,
-        outputs=[plot, analise, uso]
-    )
+    with gr.Blocks(title="Análise de Perfil DISC") as interface:
+        gr.Markdown("# Analisador de Perfil DISC com IA")
+        gr.Markdown("""
+        Responda cada questão com valores de 1 a 4, onde:
+        - 1 = Discordo totalmente
+        - 2 = Discordo parcialmente
+        - 3 = Concordo parcialmente
+        - 4 = Concordo totalmente
+        """)
+
+        with gr.Row():
+            with gr.Column():
+                q1 = gr.Slider(1, 4, value=2, step=1, label="1. Sou direto e decisivo")
+                q2 = gr.Slider(1, 4, value=2, step=1, label="2. Sou sociável e entusiasta")
+                q3 = gr.Slider(1, 4, value=2, step=1, label="3. Sou paciente e cooperativo")
+                q4 = gr.Slider(1, 4, value=2, step=1, label="4. Sou preciso e analítico")
+            
+            with gr.Column():
+                q5 = gr.Slider(1, 4, value=2, step=1, label="5. Gosto de assumir riscos")
+                q6 = gr.Slider(1, 4, value=2, step=1, label="6. Sou bom comunicador")
+                q7 = gr.Slider(1, 4, value=2, step=1, label="7. Sou bom ouvinte")
+                q8 = gr.Slider(1, 4, value=2, step=1, label="8. Sou organizado")
+
+            with gr.Column():
+                q9 = gr.Slider(1, 4, value=2, step=1, label="9. Tomo iniciativa")
+                q10 = gr.Slider(1, 4, value=2, step=1, label="10. Sou persuasivo")
+                q11 = gr.Slider(1, 4, value=2, step=1, label="11. Trabalho bem em equipe")
+                q12 = gr.Slider(1, 4, value=2, step=1, label="12. Sou detalhista")
+
+            with gr.Column():
+                q13 = gr.Slider(1, 4, value=2, step=1, label="13. Busco resultados")
+                q14 = gr.Slider(1, 4, value=2, step=1, label="14. Sou motivador")
+                q15 = gr.Slider(1, 4, value=2, step=1, label="15. Sou confiável")
+                q16 = gr.Slider(1, 4, value=2, step=1, label="16. Sou sistemático")
+
+        analyze_btn = gr.Button("Analisar Perfil")
+
+        with gr.Row():
+            perfil_output = gr.Textbox(label="Perfil Principal")
+            relatorio_output = gr.Markdown(label="Relatório Detalhado")
+
+        plot_output = gr.BarPlot(
+            x="Dimensão",
+            y="Score",
+            title="Scores DISC",
+            tooltip=["Dimensão", "Score"],
+            height=400,
+            width=600
+        )
+
+        analyze_btn.click(
+            fn=analyzer.avaliar_disc,
+            inputs=[q1, q2, q3, q4, q5, q6, q7, q8,
+                   q9, q10, q11, q12, q13, q14, q15, q16],
+            outputs=[perfil_output, relatorio_output, plot_output]
+        )
+
+    return interface
 
 if __name__ == "__main__":
-    app.launch()
+    interface = create_disc_interface()
+    interface.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True
+    )