""" Capa 3 · Critic-Loop — Agente Evaluador Matemático ==================================================== Implementa el pipeline: Generador → Evaluador → Corrección → Respuesta Final Arquitectura: [Respuesta borrador del LLM] ↓ [EVALUADOR Python — verificación matemática instantánea] ↓ [¿Hay errores?] — Sí → [LLaMA 8B reescribe con feedback específico] ↓ No [Respuesta Final] El evaluador Python es determinístico — no usa LLM para detectar errores numéricos. El LLM solo se usa para REESCRIBIR si hay error detectado. Máximo 2 iteraciones para evitar loops infinitos. """ import re import json import os from datetime import datetime DATA_PATH = "/data" ERROR_LOG = os.path.join(DATA_PATH, "error_catalog.json") MAX_ITER = 2 # máximo de reintentos # ─── Catálogo de errores conocidos ─────────────────────────────────────────── # Se carga al inicio y se actualiza cuando el evaluador detecta errores nuevos. def load_error_catalog() -> dict: """Carga el catálogo de errores conocidos desde /data/error_catalog.json.""" try: if os.path.exists(ERROR_LOG): with open(ERROR_LOG, "r", encoding="utf-8") as f: return json.load(f) except Exception: pass return { "version": "1.0", "actualizado": datetime.now().isoformat(), "reglas_escala": [ { "id": "SCALE_001", "patron": r"\b(\d+[\.,]?\d*)\s*billones?\s+USD\b", "descripcion": "billion en inglés = mil millones en español, NO billón", "ejemplo_mal": "681.35 billones USD", "ejemplo_bien": "681 mil millones USD", "detectado": 0, }, { "id": "SCALE_002", "patron": r"inflaci[oó]n[^.]*?(\d+[\.,]\d+)\s*%[^.]*?[ií]ndice", "descripcion": "INPC es índice base 2018=100, NO porcentaje de inflación", "ejemplo_mal": "inflación de 127.5%", "ejemplo_bien": "INPC índice: 127.5 (base 2018=100)", "detectado": 0, }, ], "errores_detectados": [], } def save_error_catalog(catalog: dict): """Guarda el catálogo actualizado.""" try: os.makedirs(DATA_PATH, exist_ok=True) catalog["actualizado"] = datetime.now().isoformat() with open(ERROR_LOG, "w", encoding="utf-8") as f: json.dump(catalog, f, ensure_ascii=False, indent=2) except Exception: pass # ─── Verificadores matemáticos Python (determinísticos) ───────────────────── def _check_scale_billions(text: str, raw_data: dict) -> list: """ Verifica que los valores USD del World Bank estén en la escala correcta. Un 'billion' USD = 1,000 millones USD (NO 1 billón en español). """ errors = [] # Patrones de error: número seguido de "billones USD" cuando debería ser "mil millones" patron_error = re.compile( r'(\d{1,4}(?:[\.,]\d+)?)\s*billones?\s+(?:de\s+)?USD', re.IGNORECASE ) for match in patron_error.finditer(text): valor_str = match.group(1).replace(',', '.') try: valor = float(valor_str) # Si el valor está entre 1 y 9999, probablemente es "miles de millones" # mal expresado como "billones" if 1 <= valor <= 9999: # Verificar contra datos reales si están disponibles context = text[max(0, match.start()-50):match.end()+50] errors.append({ "tipo": "SCALE_001", "texto": match.group(0), "valor": valor, "contexto": context.strip(), "feedback": ( f"ERROR DE ESCALA: '{match.group(0)}' usa 'billones' incorrectamente. " f"En español mexicano, {valor:.0f} billion USD = " f"{valor:.0f} mil millones USD (NO {valor:.0f} billones). " f"Reescribe usando 'mil millones USD'." ) }) except ValueError: pass return errors def _check_inpc_as_pct(text: str) -> list: """ Verifica que el INPC no se presente como porcentaje de inflación. El INPC es un índice base 2018=100, no un porcentaje. """ errors = [] # Detectar cuando se menciona inflación con valor > 50% (imposible — sería el índice) patron = re.compile( r'inflaci[oó]n[^.]{0,50}?(\d{2,3}[\.,]\d+)\s*%', re.IGNORECASE ) for match in patron.finditer(text): try: valor = float(match.group(1).replace(',', '.')) if valor > 20: # inflación > 20% es sospechosa — probablemente es el índice errors.append({ "tipo": "SCALE_002", "texto": match.group(0), "valor": valor, "feedback": ( f"ERROR INPC: '{match.group(0)}' presenta el INPC como porcentaje. " f"El valor {valor} es el ÍNDICE INPC base 2018=100, NO el porcentaje de inflación. " f"Reescribe indicando que es el índice, no la tasa de inflación anual." ) }) except ValueError: pass return errors def _check_tiie_hallucination(text: str, raw_data: dict) -> list: """ Verifica que los valores de TIIE o tasa objetivo sean coherentes con los datos del bucket. """ errors = [] # Obtener valor real de tasa del bucket tasa_real = None tiie_real = None try: banxico = raw_data.get("banxico", {}) tasa_real = float(banxico.get("tasa_objetivo", banxico.get("SF61745", 0)) or 0) tiie_real = float(banxico.get("tiie_28_dias", banxico.get("SF43783", 0)) or 0) except Exception: pass if not tasa_real: return errors # Buscar menciones de la tasa en el texto patron_tasa = re.compile( r'tasa\s+objetivo[^.]{0,30}?(\d+[\.,]\d+)\s*%', re.IGNORECASE ) for match in patron_tasa.finditer(text): try: valor_texto = float(match.group(1).replace(',', '.')) # Tolerancia de 0.5% — diferencias mayores son sospechosas if abs(valor_texto - tasa_real) > 0.5: errors.append({ "tipo": "DATA_001", "texto": match.group(0), "valor": valor_texto, "real": tasa_real, "feedback": ( f"ERROR DATOS: La tasa objetivo mencionada es {valor_texto}% " f"pero el dato real del bucket es {tasa_real}%. " f"Corrige usando el valor exacto del bucket: {tasa_real}%." ) }) except ValueError: pass return errors def _check_math_operations(text: str) -> list: """ Verifica operaciones matemáticas simples expresadas en el texto. Ej: "X representa el Y% de Z" → verifica que X/Z ≈ Y/100 """ errors = [] # Patrón: "X millones MXN, lo que representa el Y% de Z millones" patron = re.compile( r'([\d,\.]+)\s*millones[^,]{0,60}?representa[^.]{0,60}?(\d+[\.,]\d+)\s*%[^.]{0,60}?([\d,\.]+)\s*millones', re.IGNORECASE ) for match in patron.finditer(text): try: parte = float(match.group(1).replace(',', '').replace('.', '')) if ',' in match.group(1) else float(match.group(1)) pct = float(match.group(2).replace(',', '.')) total = float(match.group(3).replace(',', '').replace('.', '')) if ',' in match.group(3) else float(match.group(3)) if total > 0: pct_calc = (parte / total) * 100 if abs(pct_calc - pct) > 1.0: # tolerancia 1% errors.append({ "tipo": "MATH_001", "texto": match.group(0), "feedback": ( f"ERROR MATEMÁTICO: {parte:,.0f}/{total:,.0f} = {pct_calc:.1f}%, " f"pero el texto dice {pct}%. Corrige el porcentaje." ) }) except (ValueError, ZeroDivisionError): pass return errors # ─── Evaluador principal ───────────────────────────────────────────────────── def evaluate_response(text: str, raw_data: dict = None) -> dict: """ Evaluador determinístico Python. Detecta errores sin llamar a LLM. Args: text: Respuesta borrador del LLM generador raw_data: Dict con datos crudos del bucket para verificación cruzada Returns: { "valid": bool, "errors": [...], "feedback": str # mensaje consolidado para el LLM corrector } """ if raw_data is None: raw_data = {} all_errors = [] all_errors.extend(_check_scale_billions(text, raw_data)) all_errors.extend(_check_inpc_as_pct(text)) all_errors.extend(_check_tiie_hallucination(text, raw_data)) all_errors.extend(_check_math_operations(text)) if not all_errors: return {"valid": True, "errors": [], "feedback": ""} # Consolidar feedback feedbacks = list({e["feedback"] for e in all_errors}) # deduplicar feedback_msg = "\n".join(f"• {f}" for f in feedbacks) # Registrar en catálogo _log_errors(all_errors) return { "valid": False, "errors": all_errors, "feedback": feedback_msg, "count": len(all_errors), } def _log_errors(errors: list): """Registra errores detectados en el catálogo para análisis posterior.""" try: catalog = load_error_catalog() for err in errors: # Actualizar contador de regla for regla in catalog.get("reglas_escala", []): if regla.get("id") == err.get("tipo"): regla["detectado"] = regla.get("detectado", 0) + 1 # Agregar al log de errores detectados (máx 100) catalog["errores_detectados"].append({ "timestamp": datetime.now().isoformat(), "tipo": err.get("tipo"), "texto": err.get("texto", "")[:100], }) # Mantener solo los últimos 100 catalog["errores_detectados"] = catalog["errores_detectados"][-100:] save_error_catalog(catalog) except Exception: pass # ─── Loop completo: Generador → Evaluador → Corrector ──────────────────────── def critic_loop( draft: str, question: str, raw_data: dict, call_model_fn, # función call_model del orquestador model: str, system_prompt: str, ) -> tuple: """ Ejecuta el loop Generador → Evaluador → Corrector. Args: draft: Respuesta borrador del LLM question: Pregunta original del usuario raw_data: Datos crudos del bucket call_model_fn: función call_model(model, messages, max_tokens) model: Modelo a usar para corrección (LLaMA 8B) system_prompt: System prompt del orquestador Returns: (respuesta_final: str, iteraciones: int, errores_detectados: int) """ current_draft = draft total_errors = 0 for iteration in range(MAX_ITER): # Paso 1: Evaluador Python (determinístico, ~1ms) result = evaluate_response(current_draft, raw_data) if result["valid"]: # Sin errores — respuesta lista return current_draft, iteration, total_errors # Paso 2: Hay errores — LLM reescribe con feedback específico total_errors += result["count"] correction_prompt = ( f"Reescribe la siguiente respuesta corrigiendo SOLO los errores indicados. " f"NO cambies los datos numéricos correctos. NO agregues información nueva.\n\n" f"ERRORES A CORREGIR:\n{result['feedback']}\n\n" f"RESPUESTA ORIGINAL:\n{current_draft}\n\n" f"PREGUNTA ORIGINAL: {question}\n\n" f"Devuelve SOLO la respuesta corregida, sin explicaciones." ) msgs = [ {"role": "system", "content": system_prompt}, {"role": "user", "content": correction_prompt} ] corrected, error = call_model_fn(model, msgs, max_tokens=800) if error or not corrected: # Si falla la corrección, devolver el borrador original return current_draft, iteration + 1, total_errors current_draft = corrected # Máximo de iteraciones alcanzado — devolver última versión return current_draft, MAX_ITER, total_errors # ─── Helper para cargar datos del bucket ───────────────────────────────────── def load_raw_data_for_validation() -> dict: """ Carga datos crudos del bucket para validación cruzada. Solo carga lo necesario — no el histórico completo. """ result = {} files = { "banxico": os.path.join(DATA_PATH, "banxico.json"), "worldbank": os.path.join(DATA_PATH, "worldbank.json"), "ift": os.path.join(DATA_PATH, "ift.json"), } for key, path in files.items(): try: if os.path.exists(path): with open(path, "r", encoding="utf-8") as f: result[key] = json.load(f) except Exception: pass return result # ─── Estado del catálogo de errores ────────────────────────────────────────── def get_error_stats() -> dict: """Retorna estadísticas del catálogo para la UI de administración.""" catalog = load_error_catalog() total = len(catalog.get("errores_detectados", [])) por_tipo = {} for err in catalog.get("errores_detectados", []): t = err.get("tipo", "UNKNOWN") por_tipo[t] = por_tipo.get(t, 0) + 1 return { "total_errores_detectados": total, "por_tipo": por_tipo, "reglas_activas": len(catalog.get("reglas_escala", [])), "ultimo_error": catalog["errores_detectados"][-1] if catalog.get("errores_detectados") else None, } if __name__ == "__main__": # Test del evaluador print("🧪 Test Critic-Loop\n") test_cases = [ { "texto": "Las exportaciones de México en 2024 fueron de 681.35 billones USD según el World Bank.", "esperado": "ERROR SCALE_001 detectado" }, { "texto": "La inflación en México fue del 127.5% según el INPC.", "esperado": "ERROR SCALE_002 detectado" }, { "texto": "Las exportaciones de México fueron $681 mil millones USD. La tasa objetivo es 6.5%.", "esperado": "Sin errores" }, { "texto": "Telcel generó 59,113 millones MXN, lo que representa el 39.8% de 148,541 millones.", "esperado": "Sin errores (59113/148541 = 39.8% ✓)" }, { "texto": "Telcel generó 59,113 millones MXN, lo que representa el 55% de 148,541 millones.", "esperado": "ERROR MATH_001 detectado (55% ≠ 39.8%)" }, ] for i, case in enumerate(test_cases, 1): result = evaluate_response(case["texto"], {}) status = "✅ VÁLIDO" if result["valid"] else f"❌ {len(result['errors'])} ERROR(ES)" print(f"Test {i}: {status}") print(f" Texto: {case['texto'][:80]}...") print(f" Esperado: {case['esperado']}") if not result["valid"]: for err in result["errors"]: print(f" → [{err['tipo']}] {err['feedback'][:100]}") print()