Update app.py

app.py

@@ -1,121 +1,138 @@
 import gradio as gr
-from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
+from transformers import pipeline
 import torch
 
-# Configurando os modelos
 def setup_models():
-    # Modelo para geração de perguntas (TinyLlama)
-    question_tokenizer = AutoTokenizer.from_pretrained("TinyLlama/TinyLlama-1.1B-Chat")
-    question_model = AutoModelForCausalLM.from_pretrained("TinyLlama/TinyLlama-1.1B-Chat")
-    
-    # Modelo para reflexões (BLOOM)
-    reflection_tokenizer = AutoTokenizer.from_pretrained("bigscience/bloom-560m")
-    reflection_model = AutoModelForCausalLM.from_pretrained("bigscience/bloom-560m")
-    
-    return (question_tokenizer, question_model), (reflection_tokenizer, reflection_model)
-
-# Geração de perguntas usando TinyLlama
-def generate_question(question_pipeline):
-    prompt = """Generate one thought-provoking leadership question in Portuguese. 
-    Focus on topics like: team management, decision making, conflict resolution, or motivation.
-    Question:"""
+    # Usando modelos públicos que não requerem autenticação
+    print("Inicializando modelos...")
     
-    input_ids = question_pipeline[0](prompt, return_tensors="pt").input_ids
+    # Modelo para geração de texto - usando GPT2 pequeno em português
+    question_generator = pipeline(
+        "text-generation",
+        model="pierreguillou/gpt2-small-portuguese",
+        max_length=100
+    )
     
-    outputs = question_pipeline[1].generate(
-        input_ids,
-        max_length=100,
-        num_return_sequences=1,
-        temperature=0.7,
-        top_p=0.9,
-        do_sample=True
+    # Modelo para análise de sentimento/reflexão
+    reflection_generator = pipeline(
+        "text-generation",
+        model="microsoft/DialoGPT-small",
+        max_length=200
     )
     
-    question = question_pipeline[0].decode(outputs[0], skip_special_tokens=True)
-    return question.split("Question:")[-1].strip()
+    return question_generator, reflection_generator
 
-# Geração de reflexões usando BLOOM
-def generate_reflection(reflection_pipeline, question, answer):
-    prompt = f"""Com base na pergunta: "{question}"
-    E na resposta: "{answer}"
-    
-    Gere uma reflexão construtiva sobre a resposta, considerando:
-    - Pontos fortes demonstrados
-    - Áreas para desenvolvimento
-    - Sugestões práticas
-    
-    Reflexão:"""
-    
-    input_ids = reflection_pipeline[0](prompt, return_tensors="pt").input_ids
+# Lista predefinida de perguntas sobre liderança
+LEADERSHIP_QUESTIONS = [
+    "Como você lida com conflitos entre membros da sua equipe?",
+    "Qual foi a decisão mais difícil que você já tomou como líder?",
+    "Como você mantém sua equipe motivada em períodos desafiadores?",
+    "De que forma você promove o desenvolvimento profissional da sua equipe?",
+    "Como você equilibra as necessidades individuais com os objetivos organizacionais?",
+    "Como você lida com resistência a mudanças na sua equipe?",
+    "Qual é sua abordagem para dar feedback negativo?",
+    "Como você desenvolve a autonomia dos membros da sua equipe?"
+]
+
+class LeadershipMentor:
+    def __init__(self, question_gen, reflection_gen):
+        self.question_generator = question_gen
+        self.reflection_generator = reflection_gen
+        self.current_question = 0
+        
+    def get_next_question(self):
+        """Retorna a próxima pergunta da lista"""
+        if self.current_question < len(LEADERSHIP_QUESTIONS):
+            question = LEADERSHIP_QUESTIONS[self.current_question]
+            return question
+        return None
     
-    outputs = reflection_pipeline[1].generate(
-        input_ids,
-        max_length=200,
-        num_return_sequences=1,
-        temperature=0.7,
-        top_p=0.9,
-        do_sample=True
-    )
+    def generate_reflection(self, question, answer):
+        """Gera uma reflexão sobre a resposta do usuário"""
+        prompt = f"""
+        Analisando a resposta sobre liderança:
+        Pergunta: {question}
+        Resposta: {answer}
+        
+        Reflexão construtiva:"""
+        
+        reflection = self.reflection_generator(prompt, max_length=200)[0]['generated_text']
+        # Limpar e formatar a reflexão
+        reflection = reflection.split("Reflexão construtiva:")[-1].strip()
+        return reflection
     
-    reflection = reflection_pipeline[0].decode(outputs[0], skip_special_tokens=True)
-    return reflection.split("Reflexão:")[-1].strip()
-
-# Interface Gradio
-def create_interface(question_pipeline, reflection_pipeline):
-    def process_interaction(answer, history):
-        if not history:
-            # Primeira interação - gerar pergunta
-            question = generate_question(question_pipeline)
-            return "", history + [(question, None)]
-        else:
-            # Gerar reflexão para resposta anterior
-            last_question = history[-1][0]
-            reflection = generate_reflection(reflection_pipeline, last_question, answer)
-            
-            # Gerar nova pergunta
-            new_question = generate_question(question_pipeline)
+    def process_interaction(self, answer, history):
+        """Processa a interação do usuário"""
+        if not answer:
+            return "", history
             
-            return "", history + [(last_question, answer), (reflection, None), (new_question, None)]
+        current_question = LEADERSHIP_QUESTIONS[self.current_question]
+        
+        # Gerar reflexão
+        reflection = self.generate_reflection(current_question, answer)
+        
+        # Atualizar histórico
+        new_history = history + [
+            (current_question, answer),
+            ("🤔 Reflexão:", reflection)
+        ]
+        
+        # Avançar para próxima pergunta
+        self.current_question += 1
+        
+        # Verificar se ainda há perguntas
+        if self.current_question < len(LEADERSHIP_QUESTIONS):
+            next_question = LEADERSHIP_QUESTIONS[self.current_question]
+            new_history.append(("📝 Próxima pergunta:", next_question))
+        else:
+            new_history.append(("✨ Sessão concluída!", "Obrigado por participar!"))
+        
+        return "", new_history
 
-    with gr.Blocks(title="Mentor de Liderança - Powered by Open Source LLMs") as demo:
+def create_interface():
+    question_gen, reflection_gen = setup_models()
+    mentor = LeadershipMentor(question_gen, reflection_gen)
+    
+    with gr.Blocks(title="Mentor de Liderança AI") as demo:
         gr.Markdown("""
         # 🎯 Mentor de Liderança AI
-        Desenvolva suas habilidades de liderança através de perguntas reflexivas e feedback personalizado.
         
-        Powered by:
-        - TinyLlama (Geração de Perguntas)
-        - BLOOM (Análise e Reflexões)
+        Desenvolva suas habilidades de liderança através de perguntas reflexivas 
+        e feedback personalizado.
         """)
         
-        chatbot = gr.Chatbot(height=400)
-        msg = gr.Textbox(label="Sua Resposta", placeholder="Digite sua resposta aqui...")
+        chatbot = gr.Chatbot(height=600, label="Sessão de Mentoria")
+        msg = gr.Textbox(
+            label="Sua Resposta",
+            placeholder="Digite sua resposta aqui...",
+            lines=3
+        )
         
         with gr.Row():
-            submit = gr.Button("Enviar")
-            clear = gr.Button("Limpar Conversa")
+            submit = gr.Button("Enviar Resposta")
+            clear = gr.Button("Reiniciar Sessão")
+        
+        # Iniciar com primeira pergunta
+        chatbot.value = [("📝 Primeira pergunta:", LEADERSHIP_QUESTIONS[0])]
         
         submit.click(
-            process_interaction,
+            mentor.process_interaction,
             inputs=[msg, chatbot],
             outputs=[msg, chatbot]
         )
         
-        clear.click(lambda: ("", None), outputs=[msg, chatbot])
+        def reset_session():
+            mentor.current_question = 0
+            return "", [(f"📝 Primeira pergunta:", LEADERSHIP_QUESTIONS[0])]
+        
+        clear.click(
+            reset_session,
+            outputs=[msg, chatbot]
+        )
     
     return demo
 
-def main():
-    # Configuração dos modelos
-    print("Inicializando modelos...")
-    question_pipeline, reflection_pipeline = setup_models()
-    
-    # Criação e lançamento da interface
-    print("Criando interface...")
-    demo = create_interface(question_pipeline, reflection_pipeline)
-    
-    # Lançamento do app
-    print("Lançando aplicação...")
-    demo.launch(share=True)
-
 if __name__ == "__main__":
-    main()
+    print("Iniciando sistema de mentoria...")
+    demo = create_interface()
+    demo.launch(share=True)