Update app.py

app.py

@@ -43,7 +43,6 @@ class BiblicalExample:
         """Extract meaningful keywords from question and response."""
         text = f"{self.question} {self.base_response}"
         words = text.lower().split()
-        # Remove common Portuguese stop words
         stop_words = {'a', 'o', 'e', 'de', 'do', 'da', 'em', 'para', 'com', 'um', 'uma'}
         keywords = [word for word in words if len(word) > 3 and word not in stop_words]
         return list(set(keywords))
@@ -51,15 +50,12 @@ class BiblicalExample:
 class TextProcessor:
     @staticmethod
     def normalize_text(text: str) -> str:
-        """Normalize text by removing special characters and extra spaces."""
         text = re.sub(r'[^\w\s]', ' ', text)
         text = ' '.join(text.lower().split())
         return text
 
     @staticmethod
     def extract_main_concepts(text: str) -> List[str]:
-        """Extract main concepts from text using basic NLP techniques."""
-        # Remove common words and keep meaningful terms
         stop_words = {'a', 'o', 'e', 'de', 'do', 'da', 'em', 'para', 'com', 'um', 'uma', 'que', 'como'}
         words = TextProcessor.normalize_text(text).split()
         concepts = [word for word in words if word not in stop_words and len(word) > 3]
@@ -73,13 +69,11 @@ class ResponseValidator:
         self.concept_match_threshold = 0.25
 
     def calculate_text_similarity(self, text1: str, text2: str) -> float:
-        """Calculate text similarity using SequenceMatcher."""
         normalized_text1 = self.text_processor.normalize_text(text1)
         normalized_text2 = self.text_processor.normalize_text(text2)
         return SequenceMatcher(None, normalized_text1, normalized_text2).ratio()
 
     def calculate_keyword_similarity(self, text1: str, text2: str) -> float:
-        """Calculate keyword similarity between texts."""
         keywords1 = set(self.text_processor.extract_main_concepts(text1))
         keywords2 = set(self.text_processor.extract_main_concepts(text2))
         if not keywords1 or not keywords2:
@@ -87,7 +81,6 @@ class ResponseValidator:
         return len(keywords1.intersection(keywords2)) / len(keywords1.union(keywords2))
 
     def calculate_concept_similarity(self, question: str, example: BiblicalExample) -> float:
-        """Calculate concept similarity between question and example."""
         question_concepts = set(self.text_processor.extract_main_concepts(question))
         example_concepts = set(example.keywords)
         if not question_concepts or not example_concepts:
@@ -95,12 +88,10 @@ class ResponseValidator:
         return len(question_concepts.intersection(example_concepts)) / len(question_concepts.union(example_concepts))
 
     def validate_response(self, question: str, example: BiblicalExample) -> Tuple[bool, Dict[str, float]]:
-        """Validate response relevance using multiple metrics."""
         text_similarity = self.calculate_text_similarity(question, example.question)
         keyword_similarity = self.calculate_keyword_similarity(question, example.question)
         concept_similarity = self.calculate_concept_similarity(question, example)
 
-        # Calculate weighted score
         weights = {'text': 0.4, 'keyword': 0.3, 'concept': 0.3}
         total_score = (
             text_similarity * weights['text'] +
@@ -143,102 +134,142 @@ class SapienciaBiblica:
             logger.error(f"Erro ao carregar modelo: {str(e)}")
             raise
 
-    def get_default_examples_dict(self) -> Dict[str, List[BiblicalExample]]:
-        return {
-            "casamento": [
-                BiblicalExample(
-                    question="Como melhorar a comunicação no casamento?",
-                    passage="Efésios 4:29",
-                    text="Não saia da vossa boca nenhuma palavra torpe, mas só a que for boa para promover a edificação, para que dê graça aos que a ouvem.",
-                    base_response="A comunicação efetiva no casamento requer sabedoria, paciência e amor. A Bíblia nos ensina a usar palavras que edificam e não destroem.",
-                    application="Pratique escuta ativa, escolha momentos adequados para conversas importantes, e sempre fale com amor e respeito.",
-                    sentiment="supportive",
-                    theme="casamento"
-                ),
-                BiblicalExample(
-                    question="Como lidar com conflitos no casamento?",
-                    passage="Efésios 4:26-27",
-                    text="Irai-vos e não pequeis; não se ponha o sol sobre a vossa ira. Não deis lugar ao diabo.",
-                    base_response="Os conflitos são naturais, mas devem ser resolvidos com sabedoria e amor, sem deixar que a raiva tome conta.",
-                    application="Resolva os conflitos no mesmo dia, pratique o perdão e busque entender o ponto de vista do cônjuge.",
-                    sentiment="instructive",
-                    theme="casamento"
-                )
-            ],
-            "familia": [
-                BiblicalExample(
-                    question="Como educar filhos segundo a Bíblia?",
-                    passage="Provérbios 22:6",
-                    text="Instrui o menino no caminho em que deve andar, e até quando envelhecer não se desviará dele.",
-                    base_response="A educação dos filhos deve ser baseada em princípios bíblicos, com amor, disciplina e exemplo.",
-                    application="Estabeleça rotinas de devocional em família, seja exemplo de caráter e aplique disciplina com amor.",
-                    sentiment="instructive",
-                    theme="familia"
-                )
-            ],
-            "vida_espiritual": [
-                BiblicalExample(
-                    question="Como desenvolver uma vida de oração?",
-                    passage="1 Tessalonicenses 5:17",
-                    text="Orai sem cessar.",
-                    base_response="A vida de oração se desenvolve através da prática constante e sincera.",
-                    application="Reserve um tempo diário para oração, mantenha um diário de oração e pratique a gratidão.",
-                    sentiment="spiritual",
-                    theme="vida_espiritual"
-                )
-            ],
-            "trabalho": [
-                BiblicalExample(
-                    question="Como ter integridade no trabalho?",
-                    passage="Colossenses 3:23",
-                    text="E tudo quanto fizerdes, fazei-o de coração, como ao Senhor.",
-                    base_response="A integridade no trabalho significa fazer o melhor possível, como se trabalhássemos diretamente para Deus.",
-                    application="Seja honesto, pontual e dedicado em suas responsabilidades profissionais.",
-                    sentiment="professional",
-                    theme="trabalho"
-                )
-            ],
-            "relacionamentos": [
-                BiblicalExample(
-                    question="Como construir amizades verdadeiras?",
-                    passage="Provérbios 17:17",
-                    text="Em todo tempo ama o amigo, e na angústia nasce o irmão.",
-                    base_response="Amizades verdadeiras são construídas com amor, lealdade e presença constante.",
-                    application="Seja presente, demonstre interesse genuíno e apoie seus amigos nos momentos difíceis.",
-                    sentiment="friendly",
-                    theme="relacionamentos"
-                )
-            ],
-            "geral": [
-                BiblicalExample(
-                    question="Como encontrar paz em tempos difíceis?",
-                    passage="João 14:27",
-                    text="Deixo-vos a paz, a minha paz vos dou; não vo-la dou como o mundo a dá. Não se turbe o vosso coração, nem se atemorize.",
-                    base_response="A verdadeira paz vem de Deus e permanece mesmo em meio às tribulações.",
-                    application="Mantenha seu foco em Deus, pratique a gratidão e confie em Suas promessas.",
-                    sentiment="comforting",
-                    theme="geral"
-                ),
-                BiblicalExample(
-                    question="Como tomar decisões sábias?",
-                    passage="Tiago 1:5",
-                    text="E, se algum de vós tem falta de sabedoria, peça-a a Deus, que a todos dá liberalmente.",
-                    base_response="A sabedoria verdadeira vem de Deus e está disponível para todos que a pedem com fé.",
-                    application="Ore pedindo sabedoria, busque conselho de pessoas piedosas e avalie as decisões à luz da Palavra.",
-                    sentiment="instructive",
-                    theme="geral"
-                ),
-                BiblicalExample(
-                    question="Como vencer o medo?",
-                    passage="2 Timóteo 1:7",
-                    text="Porque Deus não nos deu espírito de covardia, mas de poder, de amor e de moderação.",
-                    base_response="O medo não vem de Deus, que nos dá poder, amor e equilíbrio para enfrentar desafios.",
-                    application="Identifique seus medos, ore sobre eles e confie no poder de Deus.",
-                    sentiment="encouraging",
-                    theme="geral"
-                )
-            ]
+    def get_unique_response(self, question: str, theme: str = None) -> Tuple[str, Dict, str]:
+        """Generate a unique response for each question."""
+        if not question.strip():
+            return "Por favor, faça uma pergunta específica.", {}, self.format_history()
+            
+        if not theme or theme not in self.biblical_examples:
+            theme = self.find_best_theme(question)
+        
+        try:
+            # Encontrar exemplo base mais relevante
+            best_example, validation_metrics = self.find_best_example(question, theme)
+            
+            if not best_example:
+                return self.generate_fallback_response(question, theme), {
+                    "theme": theme,
+                    "status": "no_matching_example"
+                }, self.format_history()
+
+            # Gerar resposta personalizada usando BERT
+            context = f"{best_example.text} {best_example.application}"
+            inputs = self.tokenizer(
+                question,
+                context,
+                return_tensors="pt",
+                max_length=512,
+                truncation=True,
+                padding=True
+            ).to(self.device)
+
+            # Obter resposta do modelo
+            with torch.no_grad():
+                outputs = self.model(**inputs)
+                start_scores = outputs.start_logits
+                end_scores = outputs.end_logits
+                
+                start_idx = torch.argmax(start_scores)
+                end_idx = torch.argmax(end_scores)
+                
+                # Extrair resposta gerada
+                answer_tokens = inputs["input_ids"][0][start_idx:end_idx + 1]
+                generated_answer = self.tokenizer.decode(answer_tokens)
+
+            # Gerar reflexão específica
+            reflection = self.generate_specific_reflection(question, best_example)
+            
+            # Formatar resposta final
+            sentiment = self.analyze_sentiment(question)
+            final_response = self.format_customized_response(
+                question=question,
+                generated_answer=generated_answer,
+                reflection=reflection,
+                example=best_example,
+                sentiment=sentiment
+            )
+
+            # Preparar metadata
+            metadata = self.create_metadata(best_example, theme, validation_metrics)
+            metadata.update({
+                "response_type": "generated",
+                "generation_success": True
+            })
+
+            # Salvar no histórico
+            history = self.save_to_history(question, theme, final_response, metadata)
+            
+            return final_response, metadata, history
+
+        except Exception as e:
+            logger.error(f"Erro na geração de resposta: {str(e)}")
+            return self.generate_fallback_response(question, theme), {
+                "theme": theme,
+                "status": "generation_error"
+            }, self.format_history()
+
+    def format_customized_response(self, question: str, generated_answer: str, reflection: str, 
+                                 example: BiblicalExample, sentiment: str) -> str:
+        """Format a unique response with generated content and biblical guidance."""
+        intro = {
+            'positive': "Que bom que você está buscando orientação! ",
+            'negative': "Entendo seu momento e estou aqui para ajudar. ",
+            'neutral': "Agradeço sua busca por sabedoria. "
         }
+
+        # Limpar e validar a resposta gerada
+        generated_answer = generated_answer.strip()
+        if len(generated_answer) < 10:  # Resposta muito curta, usar base
+            generated_answer = example.base_response
+
+        return f"""
+🌟 Orientação Personalizada:
+{intro[sentiment]}{generated_answer}
+
+📖 Passagem Bíblica:
+{example.passage}: {example.text}
+
+✨ Aplicação Prática:
+{example.application}
+
+💭 Reflexão Específica para Sua Situação:
+{reflection}
+
+🙏 Observação: 
+Esta orientação é baseada em princípios bíblicos. Para questões específicas, 
+considere consultar sua liderança espiritual local.
+"""
+
+    def generate_specific_reflection(self, question: str, example: BiblicalExample) -> str:
+        """Generate a specific reflection based on the question and biblical context."""
+        try:
+            context = f"{question} {example.text} {example.application}"
+            
+            inputs = self.tokenizer(
+                "Como aplicar este princípio bíblico nesta situação específica?",
+                context,
+                return_tensors="pt",
+                max_length=512,
+                truncation=True
+            ).to(self.device)
+
+            with torch.no_grad():
+                outputs = self.model(**inputs)
+                start_idx = torch.argmax(outputs.start_logits)
+                end_idx = torch.argmax(outputs.end_logits)
+                
+                tokens = self.tokenizer.convert_ids_to_tokens(inputs["input_ids"][0][start_idx:end_idx+1])
+                reflection = self.tokenizer.convert_tokens_to_string(tokens)
+
+            if len(reflection.strip()) < 10:
+                return "Aplique estes princípios bíblicos em sua situação específica, buscando sabedoria em oração."
+                
+            return reflection.strip()
+
+        except Exception as e:
+            logger.error(f"Erro ao gerar reflexão: {str(e)}")
+            return "Reflita sobre como aplicar estes princípios em sua vida, buscando a direção de Deus."
+
     def find_best_theme(self, question: str) -> str:
         """Find the most relevant theme for the question."""
         question = question.lower()
@@ -253,16 +284,23 @@ class SapienciaBiblica:
         max_matches = 0
         best_theme = "geral"
         
+        # Analisar similaridade com cada tema
         for theme, keywords in theme_keywords.items():
             matches = sum(1 for keyword in keywords if keyword in question)
-            if matches > max_matches:
-                max_matches = matches
+            similarity_score = self.validator.calculate_text_similarity(
+                question,
+                ' '.join(keywords)
+            )
+            
+            total_score = matches + (similarity_score * 2)
+            if total_score > max_matches:
+                max_matches = total_score
                 best_theme = theme
         
         return best_theme
 
     def find_best_example(self, question: str, theme: str) -> Tuple[Optional[BiblicalExample], Dict[str, float]]:
-        """Find the most relevant example and return validation metrics."""
+        """Find the most relevant example and validation metrics."""
         examples = self.biblical_examples.get(theme, self.biblical_examples["geral"])
         best_score = 0
         best_example = None
@@ -278,32 +316,6 @@ class SapienciaBiblica:
         
         return best_example, best_metrics
 
-    def get_unique_response(self, question: str, theme: str = None) -> Tuple[str, Dict, str]:
-        """Get a validated response for the given question."""
-        if not question.strip():
-            return "Por favor, faça uma pergunta específica.", {}, self.format_history()
-            
-        if not theme or theme not in self.biblical_examples:
-            theme = self.find_best_theme(question)
-        
-        best_example, validation_metrics = self.find_best_example(question, theme)
-        
-        if not best_example:
-            response = self.generate_fallback_response(question, theme)
-            metadata = {
-                "theme": theme,
-                "status": "no_matching_example",
-                "validation_metrics": validation_metrics
-            }
-            return response, metadata, self.format_history()
-        
-        sentiment = self.analyze_sentiment(question)
-        response = self.format_response(best_example, sentiment)
-        metadata = self.create_metadata(best_example, theme, validation_metrics)
-        history = self.save_to_history(question, theme, response, metadata)
-        
-        return response, metadata, history
-
     def analyze_sentiment(self, text: str) -> str:
         """Analyze the sentiment of the input text."""
         positive_words = {'alegria', 'esperança', 'paz', 'amor', 'gratidão', 'feliz', 'bem'}
@@ -315,31 +327,8 @@ class SapienciaBiblica:
         
         return 'positive' if pos_count > neg_count else 'negative' if neg_count > pos_count else 'neutral'
 
-    def format_response(self, example: BiblicalExample, sentiment: str) -> str:
-        """Format the response with appropriate introduction based on sentiment."""
-        intro = {
-            'positive': "Que bom que você está buscando orientação! ",
-            'negative': "Entendo seu momento e estou aqui para ajudar. ",
-            'neutral': "Agradeço sua busca por sabedoria. "
-        }
-        
-        return f"""
-🌟 Orientação Personalizada:
-{intro[sentiment]}{example.base_response}
-
-📖 Passagem Bíblica:
-{example.passage}: {example.text}
-
-✨ Aplicação Prática:
-{example.application}
-
-🙏 Observação: 
-Esta orientação é baseada em princípios bíblicos. Para questões específicas, 
-considere consultar sua liderança espiritual local.
-"""
-
     def generate_fallback_response(self, question: str, theme: str) -> str:
-        """Generate a thoughtful fallback response when no good match is found."""
+        """Generate a thoughtful fallback response."""
         theme_verses = {
             "casamento": ("Efésios 5:25", "Maridos, amai vossas mulheres, como também Cristo amou a igreja..."),
             "familia": ("Salmos 127:3", "Eis que os filhos são herança do Senhor..."),
@@ -495,15 +484,13 @@ def create_interface():
                         interactive=False
                     )
 
-        # Configure examples with cache directory
         gr.Examples(
             examples=counselor.get_examples_for_interface(),
             inputs=[theme, question],
             outputs=[answer_output, metadata_output, history_output],
             fn=counselor.get_unique_response,
             label="📝 Exemplos de Perguntas",
-            examples_per_page=5,
-            cache_examples=True  # This is valid for Examples component
+            examples_per_page=5
         )
 
         submit_btn.click(