app logs

app.py

@@ -57,13 +57,14 @@ def get_model():
     return get_model.model_data
 
 def parse_model_output(response):
-    pattern = r"Enunciado clínico: (.*?)\s*Alternativas: (.*?)\s*Gabarito: (.*?)\s*Explicação: (.*)"
+    logger.debug(f"Saída bruta do modelo: {response}")
+    pattern = r"Enunciado clínico: (.*?)(?:\s*Alternativas: (.*?))?(?:\s*Gabarito: (.*?))?(?:\s*Explicação: (.*?))?"
     match = re.match(pattern, response, re.DOTALL)
     if match:
-        question = match.group(1).strip()
-        options = [opt.strip() for opt in match.group(2).split(",")]
-        answer = match.group(3).strip()
-        explanation = match.group(4).strip()
+        question = match.group(1).strip() if match.group(1) else response[:200]
+        options = [opt.strip() for opt in (match.group(2) or "").split(",") if opt.strip()] if match.group(2) else []
+        answer = match.group(3).strip() if match.group(3) else ""
+        explanation = match.group(4).strip() if match.group(4) else "Sem explicação ou parsing incompleto"
         if len(options) >= 4:
             return {
                 "question": f"Enunciado clínico: {question}",
@@ -71,7 +72,8 @@ def parse_model_output(response):
                 "answer": answer,
                 "explanation": explanation
             }
-    return {"question": response, "options": [], "answer": "", "explanation": "Erro no parsing"}
+    logger.warning(f"Parsing falhou para: {response[:200]}")
+    return {"question": response[:200] if len(response) > 200 else response, "options": [], "answer": "", "explanation": "Erro no parsing ou formato inválido"}
 
 def generate_question_from_prompt(theme, difficulty, example_question=None):
     model_data = get_model()
@@ -85,29 +87,17 @@ def generate_question_from_prompt(theme, difficulty, example_question=None):
     logger.info(f"Gerando questão com tema: {theme}, dificuldade: {difficulty}")
 
     if example_question:
-        example_text = (
-            f"Enunciado clínico: {example_question['question'].split('Considerando')[-1].strip()} "
-            f"Alternativas: {', '.join(example_question['options'])} "
-            f"Gabarito: {example_question['answer']} "
-            f"Explicação: {example_question['explanation']}"
-        )
-        prompt = (
-            f"Baseado no exemplo: '{example_text}', gere uma questão sobre '{theme}', dificuldade {difficulty}, "
-            f"estilo prova USP. Formato: 'Enunciado clínico: [texto]. Alternativas: A) [opção], B) [opção], C) [opção], D) [opção]. "
-            f"Gabarito: [letra]. Explicação: [texto].'"
-        )
+        example_text = example_question.get("question", "") + " " + ", ".join(example_question.get("options", []))
+        prompt = f"Com base em: '{example_text[:100]}', gere uma questão curta sobre '{theme}', dificuldade '{difficulty}', estilo USP. Responda apenas: 'Enunciado clínico: [texto]. Alternativas: A) [opção], B) [opção], C) [opção], D) [opção]. Gabarito: [letra]. Explicação: [texto].'"
     else:
-        prompt = (
-            f"Gere uma questão sobre '{theme}', dificuldade {difficulty}, estilo prova USP. Formato: "
-            f"'Enunciado clínico: [texto]. Alternativas: A) [opção], B) [opção], C) [opção], D) [opção]. "
-            f"Gabarito: [letra]. Explicação: [texto].'"
-        )
+        prompt = f"Gere uma questão curta sobre '{theme}', dificuldade '{difficulty}', estilo USP. Responda apenas: 'Enunciado clínico: [texto]. Alternativas: A) [opção], B) [opção], C) [opção], D) [opção]. Gabarito: [letra]. Explicação: [texto].'"
     try:
         inputs = tokenizer(prompt, return_tensors="pt", padding=True, truncation=True, max_length=512)
-        outputs = model.generate(**inputs, max_new_tokens=256, temperature=0.7, top_p=0.9)
+        outputs = model.generate(**inputs, max_new_tokens=256, do_sample=True, temperature=0.7, top_p=0.9)
         response = tokenizer.decode(outputs[0], skip_special_tokens=True)
+        logger.debug(f"Resposta bruta: {response}")
         result = parse_model_output(response)
-        logger.debug(f"Questão gerada com sucesso: {result}")
+        logger.debug(f"Questão processada: {result}")
         gc.collect()
         return result
     except Exception as e:
@@ -115,22 +105,33 @@ def generate_question_from_prompt(theme, difficulty, example_question=None):
         gc.collect()
         return {"question": f"Erro na geração: {e}", "options": [], "answer": "", "explanation": "Tente novamente."}
 
-# Função para gerar e exibir simulado
+# Função para exibir perguntas do JSON e gerar adicionais
 def generate_simulado():
     logger.info("Iniciando geração de simulado...")
-    simulado = []
+    
+    # Exibe as 5 primeiras perguntas do JSON
+    max_json_questions = min(5, len(examples))
+    for i in range(max_json_questions):
+        question_data = examples[i]
+        logger.info(f"Questão do JSON {i + 1}: {question_data['question']}")
+        for opt in question_data['options']:
+            logger.info(f"  {opt}")
+        logger.info(f"  Gabarito: {question_data['answer']}")
+        logger.info(f"  Explicação: {question_data['explanation']}")
+
+    # Gera 5 perguntas adicionais com o modelo
     for i in range(5):
+        logger.debug(f"Gerando pergunta adicional {i + 1}")
         example = examples[i % len(examples)] if examples else None
-        logger.debug(f"Processando questão {i + 1} com exemplo: {example is not None}")
         question_data = generate_question_from_prompt("clinica medica", "medio", example)
-        simulado.append(question_data)
-        logger.info(f"Questão {i + 1}: {question_data['question']}")
+        logger.info(f"Questão Gerada {max_json_questions + i + 1}: {question_data['question']}")
         for opt in question_data['options']:
             logger.info(f"  {opt}")
         logger.info(f"  Gabarito: {question_data['answer']}")
         logger.info(f"  Explicação: {question_data['explanation']}")
+
     logger.info("Geração de simulado concluída.")
-    return {"simulado": simulado}
+    return {"simulado": examples[:5] + [generate_question_from_prompt("clinica medica", "medio") for _ in range(5)]}
 
 # Força carregamento inicial
 logger.info("Testando carregamento inicial do modelo...")
@@ -138,7 +139,7 @@ start_time = time.time()
 model_data = get_model()
 if model_data:
     logger.info(f"Modelo e tokenizer inicializados em {time.time() - start_time:.2f} segundos.")
-    time.sleep(1)  # Adiciona delay de 1 segundo para garantir estabilidade
+    time.sleep(1)  # Delay para estabilidade
     generate_simulado()
 else:
     logger.error("Falha na inicialização do modelo.")
@@ -153,9 +154,9 @@ async def generate_question(theme: str, difficulty: str):
 
 @app.get("/simulado")
 async def get_simulado(num_questions: int = 5):
-    simulado = []
-    for _ in range(num_questions):
-        example = examples[_ % len(examples)] if examples else None
+    simulado = examples[:min(5, len(examples))]  # Até 5 do JSON
+    for _ in range(min(5, num_questions - len(simulado))):  # Gera até 5 adicionais
+        example = examples[0] if examples else None
         question_data = generate_question_from_prompt("clinica medica", "medio", example)
         simulado.append(question_data)
     return {"simulado": simulado}