mx-data-api / modules /critic_loop.py
Fercor95mx's picture
Upload 6 files
24431ef verified
Raw History Blame Contribute Delete
16.4 kB
"""
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()