Update app.py

app.py

@@ -1,108 +1,120 @@
 import gradio as gr
-from ctransformers import AutoModelForCausalLM
-import textwrap
-import os
+from transformers import AutoTokenizer, AutoModelForQuestionAnswering
+import torch
 import logging
-from tqdm import tqdm
+from typing import Tuple, Dict
+import warnings
+warnings.filterwarnings('ignore')
 
-# Configurar logging
+# Configuração de logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-# Diretório para cache
-CACHE_DIR = os.path.join(os.path.expanduser("~"), ".bible_qa_cache")
-os.makedirs(CACHE_DIR, exist_ok=True)
+class QAModel:
+    def __init__(self):
+        logger.info("Inicializando modelo...")
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model_name = "pierreguillou/bert-base-cased-squad-v1.1-portuguese"
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+        self.model = AutoModelForQuestionAnswering.from_pretrained(self.model_name)
+        self.model.to(self.device)
+        logger.info(f"Modelo carregado no dispositivo: {self.device}")
 
-def load_model(progress=gr.Progress()):
-    logger.info("Iniciando carregamento do modelo...")
-    progress(0, desc="Iniciando carregamento do modelo")
-    
-    try:
-        model = AutoModelForCausalLM.from_pretrained(
-            "TheBloke/Llama-2-7B-Chat-GGML",
-            model_file="llama-2-7b-chat.ggmlv3.q4_0.bin",
-            model_type="llama",
-            max_new_tokens=512,
-            temperature=0.7,
-            context_length=2048,
-            cache_dir=CACHE_DIR
-        )
-        progress(1, desc="Modelo carregado com sucesso!")
-        logger.info("Modelo carregado com sucesso!")
-        return model
-    except Exception as e:
-        logger.error(f"Erro ao carregar o modelo: {str(e)}")
-        raise
+    def answer_question(self, question: str, context: str) -> Tuple[str, Dict]:
+        # Tokenização
+        inputs = self.tokenizer.encode_plus(
+            question, context,
+            add_special_tokens=True,
+            return_tensors="pt",
+            max_length=512,
+            truncation=True,
+            padding="max_length"
+        ).to(self.device)
 
-def format_prompt(question):
-    return f"""Você é um assistente especializado em conhecimento bíblico. 
-    Por favor, responda à seguinte pergunta com base nas escrituras bíblicas:
-    
-    Pergunta: {question}
-    
-    Resposta baseada na Bíblia:"""
+        # Previsão
+        with torch.no_grad():
+            outputs = self.model(**inputs)
 
-def generate_biblical_response(question, model):
-    try:
-        prompt = format_prompt(question)
-        response = model(prompt, max_new_tokens=512)
-        return textwrap.fill(response, width=80)
-    except Exception as e:
-        logger.error(f"Erro ao gerar resposta: {str(e)}")
-        return f"Erro ao gerar resposta: {str(e)}"
+        # Processamento das respostas
+        answer_start = torch.argmax(outputs.start_logits)
+        answer_end = torch.argmax(outputs.end_logits)
 
-def create_interface():
-    with gr.Blocks() as demo:
-        gr.Markdown("""# Consultor Bíblico Virtual
-        Faça perguntas sobre a Bíblia e receba respostas baseadas nas escrituras.""")
-        
-        # Carrega o modelo uma única vez
-        model = load_model()
-        
-        with gr.Row():
-            with gr.Column():
-                question_input = gr.Textbox(
-                    lines=2,
-                    placeholder="Digite sua pergunta sobre a Bíblia aqui...",
-                    label="Sua Pergunta"
-                )
-                submit_btn = gr.Button("Enviar Pergunta")
-            
-            with gr.Column():
-                answer_output = gr.Textbox(
-                    lines=10,
-                    label="Resposta"
-                )
-        
-        # Exemplos sem cache
-        gr.Examples(
-            examples=[
-                "O que a Bíblia diz sobre amor ao próximo?",
-                "Como é descrita a criação do mundo no livro de Gênesis?",
-                "Quais são os principais ensinamentos de Jesus sobre perdão?"
+        # Convertendo para tokens e depois para texto
+        tokens = self.tokenizer.convert_ids_to_tokens(inputs["input_ids"][0])
+        answer = tokens[answer_start:answer_end + 1]
+        answer = self.tokenizer.convert_tokens_to_string(answer)
+
+        # Calculando score
+        confidence_start = torch.softmax(outputs.start_logits, dim=1)[0][answer_start].item()
+        confidence_end = torch.softmax(outputs.end_logits, dim=1)[0][answer_end].item()
+        confidence = (confidence_start + confidence_end) / 2
+
+        return answer, {
+            "confiança": f"{confidence:.2%}",
+            "início": answer_start.item(),
+            "fim": answer_end.item()
+        }
+
+def create_gradio_interface():
+    # Instanciando o modelo
+    qa_model = QAModel()
+
+    def process_question(context: str, question: str) -> Tuple[str, str]:
+        try:
+            answer, metadata = qa_model.answer_question(question, context)
+            return (
+                answer,
+                f"Confiança: {metadata['confiança']}\n"
+                f"Posição da resposta: {metadata['início']} até {metadata['fim']}"
+            )
+        except Exception as e:
+            logger.error(f"Erro ao processar pergunta: {str(e)}")
+            return "Ocorreu um erro ao processar sua pergunta.", "N/A"
+
+    # Criando a interface
+    demo = gr.Interface(
+        fn=process_question,
+        inputs=[
+            gr.Textbox(
+                label="Contexto",
+                placeholder="Cole aqui o texto de contexto...",
+                lines=10
+            ),
+            gr.Textbox(
+                label="Pergunta",
+                placeholder="Digite sua pergunta sobre o texto acima...",
+                lines=2
+            )
+        ],
+        outputs=[
+            gr.Textbox(label="Resposta"),
+            gr.Textbox(label="Metadados")
+        ],
+        title="Perguntas e Respostas em Português",
+        description="""
+        Este aplicativo usa o modelo BERT em português para responder perguntas baseadas em um contexto fornecido.
+        Cole um texto no campo de contexto e faça uma pergunta sobre ele.
+        """,
+        examples=[
+            [
+                "O Brasil é o maior país da América do Sul. Sua capital é Brasília e sua maior cidade é São Paulo. O país tem uma população de mais de 200 milhões de habitantes.",
+                "Qual é a capital do Brasil?"
             ],
-            inputs=question_input,
-            cache_examples=False  # Desativa o cache dos exemplos
-        )
-        
-        def process_question(question):
-            logger.info(f"Processando pergunta: {question}")
-            return generate_biblical_response(question, model)
-        
-        submit_btn.click(
-            fn=process_question,
-            inputs=question_input,
-            outputs=answer_output
-        )
-        
-        return demo
+            [
+                "A linguagem Python foi criada por Guido van Rossum em 1991. É uma linguagem de programação de alto nível, interpretada e orientada a objetos.",
+                "Quem criou a linguagem Python?"
+            ]
+        ],
+        theme=gr.themes.Soft()
+    )
+
+    return demo
 
 if __name__ == "__main__":
     logger.info("Iniciando aplicação...")
-    demo = create_interface()
-    demo.queue(concurrency_count=1).launch(
+    demo = create_gradio_interface()
+    demo.launch(
         server_name="0.0.0.0",
         share=True,
-        show_error=True,
-        cache_examples=False
+        show_error=True
     )