Update app.py

app.py

@@ -4,7 +4,7 @@ import os
 import re
 import vertexai
 from vertexai.generative_models import GenerativeModel, Part, SafetySetting
-from difflib import SequenceMatcher  # Para comparar similitud
+from difflib import SequenceMatcher
 
 # --------------------
 # CONFIGURACIÓN GLOBAL
@@ -53,7 +53,7 @@ def extraer_texto(pdf_path: str) -> str:
     return texto_total
 
 # -----------
-# PARSEO TEXTO
+# PARSEO DE TEXTO
 # -----------
 def split_secciones(texto: str) -> (str, str):
     """
@@ -97,128 +97,153 @@ def parsear_enumeraciones(texto: str) -> dict:
     return resultado
 
 # ------------
-# COMPARACIÓN
+# COMPARACIÓN Y ANÁLISIS
 # ------------
 def similar_textos(texto1: str, texto2: str) -> float:
     """Calcula la similitud entre dos textos (valor entre 0 y 1)."""
     return SequenceMatcher(None, texto1, texto2).ratio()
 
-def comparar_preguntas_respuestas(dict_docente: dict, dict_alumno: dict) -> str:
+def comparar_preguntas_respuestas(dict_docente: dict, dict_alumno: dict) -> (str, list):
     """
-    Compara dict_docente vs dict_alumno y retorna retroalimentación.
-    - Si la 'Pregunta X' no está en dict_alumno, se recomienda revisar el tema.
-    - Si está, se compara la respuesta del alumno con la correcta.
-    Se eliminan los saltos de línea en la respuesta del alumno.
+    Compara las respuestas del docente (correctas) con las del alumno.
+    Para cada pregunta:
+      - Si no fue asignada se indica "No fue asignada".
+      - Si fue asignada se calcula la similitud y se evalúa:
+          * Correcta: ratio >= 0.85
+          * Incompleta: 0.5 <= ratio < 0.85
+          * Incorrecta: ratio < 0.5
+    Devuelve:
+      - Un string con la retroalimentación por pregunta.
+      - Una lista de diccionarios con el análisis por pregunta (para la conclusión).
+        Solo se incluyen las preguntas que fueron asignadas al alumno.
     """
-    retroalimentacion = []
+    feedback = []
+    analisis = []
     for pregunta, resp_correcta in dict_docente.items():
-        resp_alumno = dict_alumno.get(pregunta, None)
-        if resp_alumno is None or resp_alumno.strip() == "":
-            retroalimentacion.append(
+        # Se “limpian” los textos para eliminar saltos de línea y espacios de más.
+        correct_clean = " ".join(resp_correcta.split())
+        resp_alumno_raw = dict_alumno.get(pregunta, "").strip()
+        
+        if not resp_alumno_raw:
+            feedback.append(
                 f"**{pregunta}**\n"
                 f"Respuesta del alumno: No fue asignada.\n"
-                f"Respuesta correcta: {' '.join(resp_correcta.split())}\n"
-                f"Recomendación: Revisar el tema correspondiente.\n"
+                f"Respuesta correcta: {correct_clean}\n"
             )
+            # Se agrega al análisis, pero marcando que no fue asignada.
+            analisis.append({"pregunta": pregunta, "asignada": False})
         else:
-            # Eliminar saltos de línea y espacios extra
-            resp_alumno_clean = " ".join(resp_alumno.split())
-            resp_correcta_clean = " ".join(resp_correcta.split())
-            ratio = similar_textos(resp_alumno_clean.lower(), resp_correcta_clean.lower())
-            if ratio >= 0.8:
-                feedback_text = "La respuesta es correcta."
+            alumno_clean = " ".join(resp_alumno_raw.split())
+            ratio = similar_textos(alumno_clean.lower(), correct_clean.lower())
+            if ratio >= 0.85:
+                eval_text = "La respuesta es correcta."
+                resultado = "correcta"
+            elif ratio >= 0.5:
+                eval_text = "La respuesta es incompleta. Se observa que faltan conceptos clave."
+                resultado = "incompleta"
             else:
-                feedback_text = "La respuesta no coincide completamente. Se recomienda revisar la explicación y reforzar el concepto."
-            retroalimentacion.append(
+                eval_text = "La respuesta es incorrecta. No se refleja el mecanismo o concepto correcto."
+                resultado = "incorrecta"
+            feedback.append(
                 f"**{pregunta}**\n"
-                f"Respuesta del alumno: {resp_alumno_clean}\n"
-                f"Respuesta correcta: {resp_correcta_clean}\n"
-                f"{feedback_text}\n"
+                f"Respuesta del alumno: {alumno_clean}\n"
+                f"Respuesta correcta: {correct_clean}\n"
+                f"{eval_text}\n"
             )
-    return "\n".join(retroalimentacion)
+            analisis.append({"pregunta": pregunta, "asignada": True, "resultado": resultado})
+    return "\n".join(feedback), analisis
 
 # -----------
-# FUNCIÓN LÓGICA
+# FUNCIÓN PRINCIPAL
 # -----------
 def revisar_examen(json_cred, pdf_docente, pdf_alumno):
     """
-    Función generadora que muestra progreso en Gradio con yield.
-    Realiza los siguientes pasos:
+    Función generadora que:
       1. Configura credenciales.
-      2. Extrae texto de los PDFs.
-      3. Separa secciones 'Preguntas' y 'RESPUESTAS'.
-      4. Parsea las enumeraciones.
-      5. Compara las respuestas y genera retroalimentación con recomendaciones.
-      6. Llama a un LLM para generar un resumen final.
+      2. Extrae y parsea el contenido de los PDFs.
+      3. Compara las respuestas del alumno con las correctas.
+      4. Genera una retroalimentación detallada por pregunta.
+      5. Llama a un LLM para obtener un resumen final que incluya:
+           - Puntos fuertes (conceptos bien entendidos).
+           - Puntos a reforzar (respuestas incompletas o incorrectas).
+           - Recomendación general (solo considerando las preguntas asignadas).
     """
     yield "Cargando credenciales..."
     try:
         configurar_credenciales(json_cred.name)
-
+        
         yield "Inicializando Vertex AI..."
         vertexai.init(project="deploygpt", location="us-central1")
-
+        
         yield "Extrayendo texto del PDF del docente..."
         texto_docente = extraer_texto(pdf_docente.name)
-
+        
         yield "Extrayendo texto del PDF del alumno..."
         texto_alumno = extraer_texto(pdf_alumno.name)
-
+        
         yield "Dividiendo secciones (docente)..."
         preguntas_doc, respuestas_doc = split_secciones(texto_docente)
-
+        
         yield "Dividiendo secciones (alumno)..."
         preguntas_alum, respuestas_alum = split_secciones(texto_alumno)
-
+        
         yield "Parseando enumeraciones (docente)..."
         dict_preg_doc = parsear_enumeraciones(preguntas_doc)
         dict_resp_doc = parsear_enumeraciones(respuestas_doc)
-
-        # Unir preguntas y respuestas del docente
+        
+        # Unir las respuestas del docente (correctas)
         dict_docente = {}
-        for key_preg in dict_preg_doc:
-            resp_doc = dict_resp_doc.get(key_preg, "")
-            dict_docente[key_preg] = resp_doc
-
+        for key in dict_preg_doc:
+            dict_docente[key] = dict_resp_doc.get(key, "")
+        
         yield "Parseando enumeraciones (alumno)..."
         dict_preg_alum = parsear_enumeraciones(preguntas_alum)
         dict_resp_alum = parsear_enumeraciones(respuestas_alum)
-
-        # Unir preguntas y respuestas del alumno
+        
+        # Unir las respuestas del alumno
         dict_alumno = {}
-        for key_preg in dict_preg_alum:
-            resp_alum = dict_resp_alum.get(key_preg, "")
-            dict_alumno[key_preg] = resp_alum
-
+        for key in dict_preg_alum:
+            dict_alumno[key] = dict_resp_alum.get(key, "")
+        
         yield "Comparando preguntas y respuestas..."
-        feedback = comparar_preguntas_respuestas(dict_docente, dict_alumno)
-
-        if len(feedback.strip()) < 5:
+        feedback_text, analisis = comparar_preguntas_respuestas(dict_docente, dict_alumno)
+        
+        if len(feedback_text.strip()) < 5:
             yield "No se encontraron preguntas o respuestas válidas."
             return
+        
+        # Generar resumen global utilizando el LLM
+        # Se filtran solo las preguntas asignadas (se omiten las que no fueron asignadas)
+        analisis_asignadas = [a for a in analisis if a.get("asignada")]
+        resumen_prompt = f"""
+A continuación se presenta el análisis por pregunta de un examen sobre la regulación del colesterol, considerando solo las preguntas asignadas al alumno:
+
+{analisis_asignadas}
 
+Con base en este análisis, genera un resumen del desempeño del alumno en el examen que incluya:
+- Puntos fuertes: conceptos que el alumno ha comprendido correctamente.
+- Puntos a reforzar: preguntas en las que la respuesta fue incompleta o incorrecta, indicando qué conceptos clave faltaron o se confundieron.
+- Una recomendación general sobre si el alumno demuestra comprender los fundamentos o si necesita repasar el tema.
+
+No incluyas en el análisis las preguntas que no fueron asignadas.
+"""
         yield "Generando resumen final con LLM..."
-        # Llamada final al LLM:
         model = GenerativeModel(
             "gemini-1.5-pro-001",
-            system_instruction=["Eres un profesor experto de bioquímica. No inventes preguntas."]
+            system_instruction=["Eres un profesor experto en bioquímica. Evalúa el desempeño del alumno basándote en los conceptos clave, sin inventar elementos adicionales."]
         )
-        summary_prompt = f"""
-Comparación de preguntas y respuestas:
-{feedback}
-Por favor, genera un breve resumen del desempeño del alumno, indicando si entiende los conceptos y recomendando reforzar los puntos necesarios.
-"""
-        summary_part = Part.from_text(summary_prompt)
+        summary_part = Part.from_text(resumen_prompt)
         summary_resp = model.generate_content(
             [summary_part],
             generation_config=generation_config,
             safety_settings=safety_settings,
             stream=False
         )
-        final_result = f"{feedback}\n\n**Resumen**\n{summary_resp.text.strip()}"
-
+        resumen_final = summary_resp.text.strip()
+        
+        final_result = f"{feedback_text}\n\n**Resumen del desempeño:**\n{resumen_final}"
         yield final_result
-
+        
     except Exception as e:
         yield f"Error al procesar: {str(e)}"
 
@@ -237,8 +262,10 @@ interface = gr.Interface(
     description=(
         "Sube las credenciales, el PDF del docente (con las preguntas y respuestas correctas) y el PDF del alumno. "
         "El sistema separa las secciones 'Preguntas' y 'RESPUESTAS', parsea las enumeraciones y luego compara las respuestas. "
-        "Finalmente, se genera un resumen con recomendaciones para reforzar los conceptos según el desempeño del alumno."
+        "Se evalúa si el alumno comprende los conceptos fundamentales: si la respuesta está incompleta se indica qué falta, "
+        "si es incorrecta se comenta por qué, y se omiten las preguntas no asignadas. Finalmente, se genera un resumen con recomendaciones."
     )
 )
 
 interface.launch(debug=True)
+