Spaces:
Sleeping
Sleeping
Download modules/critic_loop.py from Fercor95mx/mx-data-api: direct link, hf CLI and curl.
- Browser
- Download file 16.4 kB
-
https://huggingface.co/spaces/Fercor95mx/mx-data-api/resolve/main/modules/critic_loop.py
- Command line
-
hf download hf://spaces/Fercor95mx/mx-data-api/modules/critic_loop.py
-
curl -L -o critic_loop.py https://huggingface.co/spaces/Fercor95mx/mx-data-api/resolve/main/modules/critic_loop.py
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() |