Update app.py

app.py

@@ -1,383 +1,121 @@
 import gradio as gr
-from datetime import datetime
-from sentence_transformers import SentenceTransformer
-import numpy as np
-from typing import Dict, List, Tuple
-from textblob import TextBlob
-import json
-import os
-from pathlib import Path
-
-# Configuração inicial
-def setup_environment():
-    """Configura o ambiente inicial e carrega os dados necessários."""
-    # Verifica se o arquivo JSON existe
-    if not Path("coach_data.json").exists():
-        raise FileNotFoundError("O arquivo coach_data.json não foi encontrado")
+from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
+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")
     
-    try:
-        # Carrega os dados do JSON
-        with open('coach_data.json', 'r', encoding='utf-8') as f:
-            data = json.load(f)
-            return (
-                data['perguntas'],
-                data['tone_patterns'],
-                data['respostas_coach']
-            )
-    except json.JSONDecodeError:
-        raise ValueError("Erro ao decodificar o arquivo JSON")
-    except KeyError as e:
-        raise KeyError(f"Chave obrigatória não encontrada no JSON: {e}")
-
-# Carrega o modelo de embeddings
-try:
-    model = SentenceTransformer('all-MiniLM-L6-v2')
-except Exception as e:
-    raise RuntimeError(f"Erro ao carregar o modelo de embeddings: {e}")
-
-# Carrega os dados do coach
-PERGUNTAS, TONE_PATTERNS, RESPOSTAS_COACH = setup_environment()
+    # 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)
 
-class EnhancedCoach:
-    def __init__(self):
-        """Inicializa o coach com os estados necessários."""
-        self.pergunta_atual = 0
-        self.inicio = datetime.now()
-        self.historico_respostas = []
-        self.sessao_completa = False
-        self.tone_history = []
-        self.response_quality_metrics = []
+# 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:"""
     
-    def analyze_response_quality(self, text: str) -> Dict[str, float]:
-        """Analisa a qualidade da resposta do usuário."""
-        sentences = [s.strip() for s in text.split('.') if s.strip()]
-        words = text.lower().split()
-        
-        metrics = {
-            "depth": self._calculate_depth(text, words),
-            "clarity": self._calculate_clarity(sentences),
-            "specificity": self._calculate_specificity(text, words),
-            "actionability": self._calculate_actionability(sentences)
-        }
-        
-        self.response_quality_metrics.append(metrics)
-        return metrics
+    input_ids = question_pipeline[0](prompt, return_tensors="pt").input_ids
     
-    def _calculate_depth(self, text: str, words: List[str]) -> float:
-        """Calcula a profundidade da resposta."""
-        if not words:
-            return 0.0
-            
-        unique_words = len(set(words))
-        word_length_avg = sum(len(word) for word in words) / len(words)
-        sentences = [s.strip() for s in text.split('.') if s.strip()]
-        
-        word_variety = unique_words / len(words)
-        sentence_length = len(sentences)
-        complexity = word_length_avg / 5
-        
-        depth_score = (word_variety * 0.4 + 
-                      min(sentence_length / 3, 1.0) * 0.4 + 
-                      complexity * 0.2)
-        
-        return min(1.0, depth_score)
+    outputs = question_pipeline[1].generate(
+        input_ids,
+        max_length=100,
+        num_return_sequences=1,
+        temperature=0.7,
+        top_p=0.9,
+        do_sample=True
+    )
     
-    def _calculate_clarity(self, sentences: List[str]) -> float:
-        """Calcula a clareza da resposta."""
-        if not sentences:
-            return 0.0
-        avg_length = sum(len(s.split()) for s in sentences) / len(sentences)
-        return 1.0 if 10 <= avg_length <= 20 else 0.7
+    question = question_pipeline[0].decode(outputs[0], skip_special_tokens=True)
+    return question.split("Question:")[-1].strip()
+
+# 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}"
     
-    def _calculate_specificity(self, text: str, words: List[str]) -> float:
-        """Calcula a especificidade da resposta."""
-        specific_indicators = [
-            "exemplo", "especificamente", "concretamente", 
-            "situação", "caso", "quando", "onde", "como",
-            "projeto", "equipe", "reunião", "feedback",
-            "resultado", "impacto", "mudança", "melhoria",
-            "implementei", "desenvolvi", "criei", "estabeleci",
-            "eu", "minha", "nosso", "realizei", "fiz"
-        ]
-        
-        indicator_count = sum(text.lower().count(ind) for ind in specific_indicators)
-        response_length_factor = min(len(words) / 20, 1.0)
-        
-        return min(1.0, (indicator_count * 0.7 + response_length_factor * 0.3))
+    Gere uma reflexão construtiva sobre a resposta, considerando:
+    - Pontos fortes demonstrados
+    - Áreas para desenvolvimento
+    - Sugestões práticas
     
-    def _calculate_actionability(self, sentences: List[str]) -> float:
-        """Calcula a acionabilidade da resposta."""
-        action_verbs = [
-            "implementar", "fazer", "criar", "desenvolver", "estabelecer", 
-            "planejar", "executar", "medir", "avaliar", "iniciar",
-            "construir", "liderar", "coordenar", "definir", "ajustar"
-        ]
-        if not sentences:
-            return 0.0
-        actionable = sum(1 for s in sentences 
-                        if any(verb in s.lower() for verb in action_verbs))
-        return min(1.0, actionable / len(sentences))
-
-    def analisar_tom(self, texto: str) -> Tuple[str, float]:
-        """Analisa o tom predominante da resposta."""
-        texto_lower = texto.lower()
-        blob = TextBlob(texto)
-        
-        tone_scores = {}
-        for tone, patterns in TONE_PATTERNS.items():
-            score = sum(texto_lower.count(pattern) for pattern in patterns)
-            tone_scores[tone] = score * (1 + abs(blob.sentiment.polarity))
-            
-        predominant_tone = max(tone_scores.items(), key=lambda x: x[1])
-        return predominant_tone[0], predominant_tone[1]
-
-    def analisar_sentimento(self, texto: str) -> str:
-        """Analisa o sentimento geral da resposta."""
-        positive_words = [
-            "consegui", "superei", "aprendi", "melhorei", "efetivo",
-            "cresci", "evoluí", "realizei", "alcancei", "progresso"
-        ]
-        negative_words = [
-            "difícil", "desafiador", "complicado", "problema", "falha",
-            "obstáculo", "limitação", "erro", "confuso", "inseguro"
-        ]
-        
-        texto_lower = texto.lower()
-        positive_count = sum(1 for word in positive_words if word in texto_lower)
-        negative_count = sum(1 for word in negative_words if word in texto_lower)
-        
-        if positive_count > negative_count:
-            return "positive"
-        elif negative_count > positive_count:
-            return "improvement"
-        return "neutral"
-
-    def extrair_acao_especifica(self, texto: str) -> str:
-        """Extrai uma ação específica da resposta do usuário."""
-        sentences = texto.split('.')
-        for sentence in sentences:
-            if any(action in sentence.lower() for action in ["eu", "minha", "realizei", "fiz"]):
-                return sentence.strip()
-        return texto.split('.')[0].strip()
-
-    def encontrar_melhor_resposta(self, texto_usuario: str, categoria: str) -> str:
-        """Encontra a melhor resposta do coach baseada no texto do usuário."""
-        sentimento = self.analisar_sentimento(texto_usuario)
-        acao_especifica = self.extrair_acao_especifica(texto_usuario)
-        
-        respostas_categoria = RESPOSTAS_COACH[categoria][sentimento]
-        user_embedding = model.encode(texto_usuario)
-        
-        melhor_resposta = None
-        maior_similaridade = -1
-        
-        for template in respostas_categoria:
-            context_embedding = model.encode(template["context"])
-            similaridade = np.dot(user_embedding, context_embedding)
-            
-            if similaridade > maior_similaridade:
-                maior_similaridade = similaridade
-                melhor_resposta = template["response"]
-        
-        return melhor_resposta.format(specific_action=acao_especifica.lower())
+    Reflexão:"""
     
-    def gerar_resposta(self, texto_usuario: str) -> str:
-        """Gera uma resposta completa do coach."""
-        quality_metrics = self.analyze_response_quality(texto_usuario)
-        
-        if quality_metrics["depth"] < 0.15 and quality_metrics["specificity"] < 0.1:
-            return """### Feedback Inicial 💭
-
-Para oferecer um feedback mais valioso, poderia compartilhar mais detalhes específicos sobre sua experiência? 
-Alguns aspectos que enriqueceriam sua reflexão:
-- Exemplos concretos da situação
-- Ações específicas tomadas
-- Resultados observados"""
-
-        if self.sessao_completa:
-            self.__init__()
-            
-        if self.pergunta_atual >= len(PERGUNTAS):
-            tempo = (datetime.now() - self.inicio).seconds // 60
-            return self.gerar_sumario_final(tempo)
-            
-        tom_predominante, intensidade = self.analisar_tom(texto_usuario)
-        self.tone_history.append(tom_predominante)
-        
-        pergunta_atual = PERGUNTAS[self.pergunta_atual]
-        self.historico_respostas.append(texto_usuario)
-        
-        feedback = self.encontrar_melhor_resposta(
-            texto_usuario, 
-            pergunta_atual["categoria"]
-        )
-        
-        tom_insight = self._gerar_insight_tom(tom_predominante, intensidade)
-        padrao_identificado = self._analisar_padroes()
-        
-        resposta = f"""### Feedback Personalizado 💭\n\n{feedback}{padrao_identificado}\n\n{tom_insight}"""
-        resposta += self._gerar_pontos_aprofundamento()
-        
-        self.pergunta_atual += 1
-        if self.pergunta_atual < len(PERGUNTAS):
-            resposta += self._gerar_proxima_pergunta()
+    input_ids = reflection_pipeline[0](prompt, return_tensors="pt").input_ids
+    
+    outputs = reflection_pipeline[1].generate(
+        input_ids,
+        max_length=200,
+        num_return_sequences=1,
+        temperature=0.7,
+        top_p=0.9,
+        do_sample=True
+    )
+    
+    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:
-            self.sessao_completa = True
-            tempo = (datetime.now() - self.inicio).seconds // 60
-            resposta += self.gerar_sumario_final(tempo)
-        
-        return resposta
-
-    def _gerar_insight_tom(self, tom: str, intensidade: float) -> str:
-        """Gera insights baseados no tom da resposta."""
-        insights = {
-            "confiante": "Sua confiança ao abordar este tema é notável. Como você construiu esta segurança?",
-            "reflexivo": "Sua abordagem reflexiva traz profundidade à análise. Continue explorando diferentes perspectivas.",
-            "hesitante": "Percebo algumas incertezas naturais do processo. Que apoio ajudaria a fortalecer sua confiança?",
-            "pragmatico": "Seu foco em resultados práticos é valioso. Como você equilibra isso com visão de longo prazo?",
-            "emocional": "Sua conexão emocional com a liderança demonstra comprometimento genuíno."
-        }
-        
-        if intensidade > 2:
-            return f"\n\n💡 {insights[tom]} Sua expressão é particularmente intensa neste aspecto."
-        return f"\n\n💡 {insights[tom]}"
-
-    def _analisar_padroes(self) -> str:
-        """Analisa padrões nas respostas do usuário."""
-        if len(self.historico_respostas) <= 1:
-            return ""
+            # Gerar reflexão para resposta anterior
+            last_question = history[-1][0]
+            reflection = generate_reflection(reflection_pipeline, last_question, answer)
             
-        sentimento_atual = self.analisar_sentimento(self.historico_respostas[-1])
-        sentimento_anterior = self.analisar_sentimento(self.historico_respostas[-2])
-        
-        if sentimento_atual == sentimento_anterior == "positive":
-            return "\n\n💡 Observo um padrão consistente de confiança em suas respostas. Continue desenvolvendo esses pontos fortes!"
-        elif sentimento_atual == sentimento_anterior == "improvement":
-            return "\n\n💡 Percebo que você está identificando áreas de desenvolvimento. Vamos focar em estratégias práticas para esses desafios."
-        return ""
-
-    def _gerar_pontos_aprofundamento(self) -> str:
-        """Gera pontos para aprofundamento da reflexão."""
-        return """
-
-#### Pontos para Aprofundamento:
-1. Como essa experiência se conecta com seus valores de liderança?
-2. Que recursos específicos você identificou como necessários?
-3. Qual seria o próximo marco de desenvolvimento nessa área?"""
-
-    def _gerar_proxima_pergunta(self) -> str:
-        """Gera a próxima pergunta da sequência."""
-        proxima = PERGUNTAS[self.pergunta_atual]
-        return f"""\n\n### Próxima Reflexão: {proxima['categoria'].title()} 🎯\n\n{proxima['pergunta']}\n\nTome um momento para refletir e conectar com suas experiências..."""
-
-    def primeira_pergunta(self) -> str:
-        """Gera a mensagem inicial e primeira pergunta do coach."""
-        return f"""### 👋 Bem-vindo à sua Jornada de Desenvolvimento!
-
-Vamos explorar aspectos importantes da sua liderança através de reflexões guiadas.
-
-{PERGUNTAS[0]['pergunta']}
-
-Tome um momento para conectar com suas experiências e compartilhe sua perspectiva..."""
+            # Gerar nova pergunta
+            new_question = generate_question(question_pipeline)
+            
+            return "", history + [(last_question, answer), (reflection, None), (new_question, None)]
 
-    def gerar_sumario_final(self, tempo: int) -> str:
-        """Gera o sumário final da sessão."""
-        sentimentos = [self.analisar_sentimento(resp) for resp in self.historico_respostas]
-        predominante = max(set(sentimentos), key=sentimentos.count)
+    with gr.Blocks(title="Mentor de Liderança - Powered by Open Source LLMs") as demo:
+        gr.Markdown("""
+        # 🎯 Mentor de Liderança AI
+        Desenvolva suas habilidades de liderança através de perguntas reflexivas e feedback personalizado.
         
-        tone_pattern = max(set(self.tone_history), key=self.tone_history.count)
-        tone_insight = f"\n\n#### Padrão de Comunicação:\nSeu estilo predominante é {tone_pattern}, o que sugere {self._interpretar_padrao_tom(tone_pattern)}"
+        Powered by:
+        - TinyLlama (Geração de Perguntas)
+        - BLOOM (Análise e Reflexões)
+        """)
         
-        avg_metrics = {
-            key: sum(m[key] for m in self.response_quality_metrics) / len(self.response_quality_metrics)
-            for key in ["depth", "clarity", "specificity", "actionability"]
-        }
-        
-        quality_insights = "\n\n#### Insights de Qualidade das Respostas:"
-        if avg_metrics["depth"] > 0.7:
-            quality_insights += "\n- Suas reflexões demonstram profundidade significativa"
-        if avg_metrics["specificity"] > 0.7:
-            quality_insights += "\n- Você fornece exemplos concretos e detalhados"
-        if avg_metrics["actionability"] > 0.7:
-            quality_insights += "\n- Suas respostas são orientadas para ação"
-        
-        if predominante == "positive":
-            perfil = "Você demonstra forte autoconhecimento e confiança em sua liderança."
-        elif predominante == "improvement":
-            perfil = "Você demonstra excelente capacidade de identificar oportunidades de desenvolvimento."
-        else:
-            perfil = "Você demonstra uma abordagem equilibrada entre conquistas e desafios."
-        
-        return f"""
-### 🎉 Jornada de Desenvolvimento Concluída!
-
-⏱️ Tempo de reflexão: {tempo} minutos
-📝 Temas explorados: {len(PERGUNTAS)}
-
-#### Perfil de Liderança Observado:
-{perfil}{tone_insight}{quality_insights}
-
-#### Recomendações Personalizadas:
-1. Implemente uma ação específica mencionada em suas reflexões esta semana
-2. Mantenha um diário de liderança focado nos temas discutidos
-3. Estabeleça checkpoints mensais para revisar seu progresso
-
-Deseja iniciar uma nova jornada de desenvolvimento com outros temas?"""
-
-    def _interpretar_padrao_tom(self, tom: str) -> str:
-        """Interpreta o padrão de tom identificado nas respostas."""
-        interpretacoes = {
-            "confiante": "uma base sólida para influenciar e liderar equipes.",
-            "reflexivo": "uma capacidade valiosa de considerar múltiplas perspectivas.",
-            "hesitante": "uma oportunidade para fortalecer sua confiança através da prática.",
-            "pragmatico": "um foco valioso em resultados e implementação.",
-            "emocional": "uma forte conexão com o impacto humano da liderança."
-        }
-        return interpretacoes.get(tom, "um estilo único de liderança.")
-
-def criar_interface():
-    """Cria a interface do usuário usando Gradio."""
-    coach = EnhancedCoach()
-    
-    with gr.Blocks(title="Coach de Liderança", theme=gr.themes.Soft()) as app:
-        gr.Markdown("""# 🚀 Coach de Liderança
-        Desenvolva sua liderança através de reflexão guiada e feedback personalizado.""")
-        
-        chat = gr.Chatbot(
-            value=[[None, coach.primeira_pergunta()]],
-            height=600,
-            show_label=False
-        )
+        chatbot = gr.Chatbot(height=400)
+        msg = gr.Textbox(label="Sua Resposta", placeholder="Digite sua resposta aqui...")
         
         with gr.Row():
-            txt = gr.Textbox(
-                placeholder="Compartilhe sua reflexão aqui...",
-                lines=4,
-                label="Sua Resposta"
-            )
-            btn = gr.Button("Enviar", variant="primary")
+            submit = gr.Button("Enviar")
+            clear = gr.Button("Limpar Conversa")
         
-        def responder(mensagem, historico):
-            if not mensagem.strip():
-                return "", historico
-            
-            resposta = coach.gerar_resposta(mensagem)
-            historico.append([mensagem, resposta])
-            return "", historico
+        submit.click(
+            process_interaction,
+            inputs=[msg, chatbot],
+            outputs=[msg, chatbot]
+        )
         
-        txt.submit(responder, [txt, chat], [txt, chat])
-        btn.click(responder, [txt, chat], [txt, chat])
+        clear.click(lambda: ("", None), outputs=[msg, chatbot])
     
-    return app
+    return demo
 
 def main():
-    """Função principal para iniciar a aplicação."""
-    try:
-        app = criar_interface()
-        app.launch()
-    except Exception as e:
-        print(f"Erro ao iniciar a aplicação: {e}")
-        raise
+    # 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()