app.py

import gradio as gr
import numpy as np
from transformers import pipeline

class DiscAnalyzer:
    def __init__(self):
        self.disc_profiles = {
            'D': 'Dominance',
            'I': 'Influence',
            'S': 'Steadiness',
            'C': 'Compliance'
        }
        
        # Usando um modelo mais leve e otimizado para texto
        self.generator = pipeline(
            "text-generation",
            model="facebook/opt-125m",  # Modelo muito mais leve que o BLOOM
            device="cpu"  # Forçando CPU para evitar problemas de CUDA
        )

    def generate_llm_report(self, scores, perfil_principal):
        """
        Gera relatório personalizado usando modelo mais leve.
        """
        prompt = f"""Analise o perfil DISC:
D:{scores['D']:.1f}% I:{scores['I']:.1f}% S:{scores['S']:.1f}% C:{scores['C']:.1f}%
Perfil Principal: {self.disc_profiles[perfil_principal]}
"""
        
        try:
            # Configurações otimizadas para geração mais rápida
            output = self.generator(
                prompt,
                max_length=300,  # Reduzido para resposta mais concisa
                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, *args):
        """
        Versão otimizada da avaliação DISC.
        """
        # Converter todos os inputs para números de uma vez
        responses = [int(arg) for arg in args]

        # Cálculo otimizado dos scores
        scores = {
            'D': sum(responses[i] for i in [0, 4, 8, 12]) / 16 * 100,
            'I': sum(responses[i] for i in [1, 5, 9, 13]) / 16 * 100,
            'S': sum(responses[i] for i in [2, 6, 10, 14]) / 16 * 100,
            'C': sum(responses[i] for i in [3, 7, 11, 15]) / 16 * 100
        }
        
        perfil_principal = max(scores, key=scores.get)
        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():
    analyzer = DiscAnalyzer()
    
    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")

        # Criação otimizada das questões
        questions = [
            "1. Sou direto e decisivo", "2. Sou sociável e entusiasta",
            "3. Sou paciente e cooperativo", "4. Sou preciso e analítico",
            "5. Gosto de assumir riscos", "6. Sou bom comunicador",
            "7. Sou bom ouvinte", "8. Sou organizado",
            "9. Tomo iniciativa", "10. Sou persuasivo",
            "11. Trabalho bem em equipe", "12. Sou detalhista",
            "13. Busco resultados", "14. Sou motivador",
            "15. Sou confiável", "16. Sou sistemático"
        ]

        # Criando sliders em grupos de 4
        sliders = []
        for i in range(0, 16, 4):
            with gr.Row():
                with gr.Column():
                    for j in range(4):
                        sliders.append(gr.Slider(1, 4, value=2, step=1, label=questions[i+j]))

        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",
            height=400,
            width=600
        )

        analyze_btn.click(
            fn=analyzer.avaliar_disc,
            inputs=sliders,
            outputs=[perfil_output, relatorio_output, plot_output]
        )

    return interface

if __name__ == "__main__":
    interface = create_disc_interface()
    interface.launch(
        server_name="0.0.0.0",
        server_port=7860,
        share=True
    )