ANEXO 36

Aprendizaje FARO

Este anexo corresponde a la Fase 10 — Aprendizaje y mejora continua, etapa “Aprendizaje”. Es la capa donde FARO Connect registra resultados reales, compara lo esperado contra lo ocurrido y mejora sus futuras recomendaciones, acciones, simulaciones, pesos, umbrales y diagnósticos.

Hasta el Anexo 35, FARO ya puede:

calcular KPIs,
detectar señales,
generar alertas,
identificar tensiones,
diagnosticar,
priorizar,
recomendar,
simular,
crear acciones,
asignar responsables,
controlar workflow,
exigir evidencia,
medir resultados,
calcular FARO Score.

El Anexo 36 responde:

¿Qué aprende FARO después de ver qué funcionó, qué falló y qué impacto real tuvo cada decisión?

1. Objetivo del anexo

El objetivo del Anexo 36 — Aprendizaje FARO es convertir la experiencia acumulada del sistema en mejora continua.

Debe responder:

Qué recomendaciones funcionaron.
Qué acciones fueron efectivas.
Qué simulaciones acertaron.
Qué simulaciones fallaron.
Qué alertas fueron ruido.
Qué tensiones se repiten.
Qué reglas deben ajustarse.
Qué umbrales quedaron mal.
Qué responsables ejecutan bien.
Qué áreas se bloquean.
Qué industrias requieren pesos distintos.
Qué decisiones mejoran el FARO Score.

Ejemplo:

FARO recomendó auditar descuentos.

Resultado:
Descuento bajó de 12% a 8%.
Margen subió de 21% a 24%.
Cobranza no mejoró.

Aprendizaje:
La auditoría de descuentos mejora margen, pero si no se combina con plan de cobranza, no resuelve caja.

Eso es aprendizaje útil. No es “IA mágica”; es gestión acumulada.

2. Tesis del Anexo 36

La tesis es:

FARO Connect debe aprender de la diferencia entre lo que esperaba que ocurriera y lo que realmente ocurrió.

Un sistema mediocre hace esto:

Detecta problema.
Recomienda acción.
Cierra acción.
Sigue igual.

FARO debe hacer esto:

Detecta problema.
Recomienda acción.
Simula impacto.
Crea acción.
Mide resultado.
Compara esperado vs real.
Aprende.
Ajusta futuras recomendaciones.

La diferencia es enorme.

FARO no debe ser un sistema que repite recetas. Debe ser un sistema que mejora su criterio.

3. Qué es aprendizaje FARO

El aprendizaje FARO es el proceso mediante el cual el sistema registra experiencias reales y ajusta su comportamiento futuro.

Aprende de:

KPIs antes y después,
acciones ejecutadas,
evidencia cargada,
resultado de recomendaciones,
precisión de simulaciones,
falsos positivos,
falsos negativos,
decisiones aprobadas,
decisiones rechazadas,
impacto en FARO Score,
feedback humano,
contexto industrial,
contexto de empresa.

Ejemplo JSON:

{
  "learning_event": "recommendation_effectiveness",
  "recommendation_code": "auditar_descuentos_altos",
  "industry": "construction_supplies",
  "context": {
    "discount_rate_before": 0.12,
    "gross_margin_before": 0.21
  },
  "result": {
    "discount_rate_after": 0.08,
    "gross_margin_after": 0.24
  },
  "learning": "effective_for_margin",
  "future_adjustment": "increase_recommendation_confidence"
}

4. Diferencia entre seguimiento, aprendizaje y recalibración

Secuencia:

Medición
→ aprendizaje
→ recalibración
→ mejor decisión futura

El Anexo 36 aprende. El Anexo 37 recalibra.

5. Qué debe aprender FARO

FARO debe aprender en varias capas.

1. Aprendizaje de datos.
2. Aprendizaje de KPIs.
3. Aprendizaje de señales.
4. Aprendizaje de alertas.
5. Aprendizaje de tensiones.
6. Aprendizaje de diagnósticos.
7. Aprendizaje de recomendaciones.
8. Aprendizaje de simulaciones.
9. Aprendizaje de acciones.
10. Aprendizaje de responsables.
11. Aprendizaje de workflow.
12. Aprendizaje de evidencia.
13. Aprendizaje de FARO Score.
14. Aprendizaje por industria.
15. Aprendizaje por empresa.

No aprende una sola cosa. Aprende el comportamiento completo del sistema.

6. Tipos de aprendizaje FARO

7. Aprendizaje por efectividad de acciones

FARO debe aprender qué acciones producen resultados.

Ejemplo:

Acción:
Auditar descuentos altos.

Resultado:
Margen mejora +3 puntos.

Aprendizaje:
Acción efectiva para margen.

Pero también puede pasar:

Acción:
Auditar descuentos altos.

Resultado:
Descuento baja, pero ventas caen fuerte.

Aprendizaje:
La acción mejora margen, pero puede afectar volumen si se aplica sin segmentación.

Fórmula:

Efectividad acción =
cumplimiento en plazo × 20%
+ evidencia válida × 20%
+ mejora KPI × 35%
+ resolución tensión × 20%
+ feedback humano × 5%

Código:

def efectividad_accion(
    cumplimiento_plazo,
    evidencia_valida,
    mejora_kpi,
    resolucion_tension,
    feedback_humano
):
    return round(
        cumplimiento_plazo * 0.20 +
        evidencia_valida * 0.20 +
        mejora_kpi * 0.35 +
        resolucion_tension * 0.20 +
        feedback_humano * 0.05,
        2
    )

8. Clasificación del aprendizaje por acción

Código:

def clasificar_efectividad(score):
    if score >= 0.85:
        return "muy_efectiva"
    if score >= 0.70:
        return "efectiva"
    if score >= 0.50:
        return "parcial"
    if score >= 0.30:
        return "debil"
    return "inefectiva"

9. Aprendizaje de recomendaciones

FARO debe medir si sus recomendaciones fueron aceptadas, ejecutadas y efectivas.

Indicadores:

tasa de aceptación,
tasa de conversión a acción,
tasa de efectividad,
motivos de rechazo,
impacto promedio,
industrias donde funciona mejor,
contextos donde falla.

Ejemplo:

Recomendación:
Revisar comisión por margen y cobranza.

Aceptación:
Alta.

Ejecución:
Media.

Impacto:
Bueno cuando se simula y se pilotea.
Malo cuando se aplica directo.

Aprendizaje:

Esta recomendación siempre debe pasar por simulación antes de acción general.

Código:

def aprendizaje_recomendacion(aceptadas, ejecutadas, efectivas):
    tasa_aceptacion = aceptadas["count"] / aceptadas["total"] if aceptadas["total"] else 0
    tasa_ejecucion = ejecutadas["count"] / aceptadas["count"] if aceptadas["count"] else 0
    tasa_efectividad = efectivas["count"] / ejecutadas["count"] if ejecutadas["count"] else 0

    return {
        "acceptance_rate": round(tasa_aceptacion, 2),
        "execution_rate": round(tasa_ejecucion, 2),
        "effectiveness_rate": round(tasa_efectividad, 2)
    }

10. Aprendizaje de simulaciones

FARO debe comparar lo simulado contra lo real.

Ejemplo:

Simulación:
Bajar descuento máximo a 8% mejoraría margen +3 puntos.

Resultado real:
Margen mejora +2 puntos.

Error:
1 punto.

Aprendizaje:
El modelo fue razonable, pero algo optimista.

Fórmula:

Error simulación = resultado real - resultado simulado

Código:

def error_simulacion(valor_simulado, valor_real):
    return valor_real - valor_simulado

Precisión:

def precision_simulacion(valor_simulado, valor_real):
    if valor_simulado == 0:
        return None
    return round(1 - abs(valor_real - valor_simulado) / abs(valor_simulado), 2)

11. Clasificación de simulaciones

Ejemplo:

Simulación de canje:
Valor esperado: $18M
Valor real: $14M
Precisión: 0.78

Lectura:
Razonable, pero se debe ajustar factor de liquidez y plazo.

12. Aprendizaje de falsos positivos

Un falso positivo ocurre cuando FARO detecta un problema que no era real o no aplicaba.

Ejemplo:

FARO detecta margen bajo.
Pero era liquidación aprobada de stock inmovilizado.

Debe aprender:

si existe promoción aprobada,
si el producto está marcado como liquidación,
si el margen bajo fue autorizado,
no disparar alerta crítica estándar.

Código:

def registrar_falso_positivo(entity_id, motivo, aprendizaje):
    return {
        "entity_id": entity_id,
        "feedback_type": "false_positive",
        "reason": motivo,
        "learning": aprendizaje,
        "requires_recalibration": True
    }

Ejemplos de motivos:

Promoción aprobada.
Liquidación de stock.
Canje estratégico.
Venta interna.
Evento extraordinario.
Error de carga.
Cambio temporal autorizado.

13. Aprendizaje de falsos negativos

Un falso negativo ocurre cuando FARO no detectó algo que sí era un problema.

Ejemplo:

No detectó cliente riesgoso porque estaba duplicado en el maestro.

Debe aprender:

qué dato faltó,
qué regla faltó,
qué umbral estaba alto,
qué relación no se cruzó,
qué fuente estaba débil.

Código:

def registrar_falso_negativo(caso, causa, regla_faltante=None):
    return {
        "case": caso,
        "feedback_type": "false_negative",
        "cause": causa,
        "missing_rule": regla_faltante,
        "requires_recalibration": True
    }

Ejemplo:

Falso negativo:
Cliente riesgoso no detectado.

Causa:
cliente duplicado y deuda fragmentada.

Aprendizaje:
antes de calcular mora, consolidar clientes por CUIT / identificador fiscal.

14. Aprendizaje de alertas

FARO debe aprender si una alerta fue útil o ruido.

Indicadores:

alertas generadas,
alertas convertidas en acción,
alertas cerradas como falsas,
alertas ignoradas,
alertas recurrentes,
alertas que anticiparon tensión,
alertas que no tuvieron impacto.

Código:

def utilidad_alerta(alertas_generadas, alertas_accionables, falsos_positivos):
    if alertas_generadas == 0:
        return 0

    return round(
        (alertas_accionables - falsos_positivos) / alertas_generadas,
        2
    )

Lectura:

Si una alerta se dispara mucho y casi nunca genera acción, probablemente es ruido.

Regla ejecutiva:

Una alerta que nadie atiende puede ser mala alerta, mal responsable o mala cultura. FARO debe distinguirlo.

15. Aprendizaje de tensiones

Las tensiones son más importantes que alertas aisladas.

FARO debe aprender:

qué tensiones se repiten,
cuáles son estructurales,
qué acciones las reducen,
qué KPIs las anticipan,
qué áreas están siempre involucradas,
qué responsables las destraban,
qué decisiones las resuelven.

Ejemplo:

Tensión:
Crecimiento no rentable.

Acciones efectivas:
auditar descuentos,
revisar comisión,
plan de cobranza.

Acción insuficiente:
solo aumentar ventas.

Aprendizaje:

Cuando ventas suben con margen bajo y cobranza lenta, no recomendar “vender más”. Recomendar proteger margen y caja.

16. Aprendizaje de diagnósticos

FARO debe aprender qué diagnósticos fueron correctos, parciales o equivocados.

Clasificación:

Código:

def clasificar_diagnostico(validation_status):
    validos = [
        "confirmed",
        "partially_correct",
        "rejected",
        "needs_more_data",
        "false_positive",
        "false_negative"
    ]

    if validation_status not in validos:
        raise ValueError("Estado no válido")

    return validation_status

17. Aprendizaje de responsables

FARO no debe usarse como látigo barato, pero sí debe aprender capacidad real de ejecución.

Debe medir:

tiempo de aceptación,
tiempo de cierre,
cierres en plazo,
cierres con evidencia,
acciones efectivas,
acciones vencidas,
acciones rechazadas,
bloqueos recurrentes,
sobrecarga.

Ejemplo:

Responsable A:
cierra rápido, pero con baja efectividad.

Responsable B:
cierra más lento, pero con evidencia fuerte y mejores resultados.

Lectura FARO:

No medir solo velocidad. Medir calidad de ejecución.

Código:

def score_responsable(
    cierre_en_plazo,
    evidencia_valida,
    efectividad_acciones,
    baja_vencidas,
    baja_rechazos
):
    return round(
        cierre_en_plazo * 0.20 +
        evidencia_valida * 0.25 +
        efectividad_acciones * 0.35 +
        baja_vencidas * 0.10 +
        baja_rechazos * 0.10,
        2
    )

18. Aprendizaje de workflow

FARO debe aprender dónde se traba la ejecución.

Ejemplos:

acciones que no se aceptan,
acciones que quedan esperando datos,
acciones que quedan esperando aprobación,
acciones que se vencen siempre en la misma área,
acciones que se cierran sin medición,
decisiones aprobadas sin acciones.

Código:

def detectar_cuello_workflow(eventos_workflow):
    conteo = {}

    for evento in eventos_workflow:
        estado = evento["state"]
        conteo[estado] = conteo.get(estado, 0) + 1

    return sorted(conteo.items(), key=lambda x: x[1], reverse=True)

Ejemplo:

Mayor cuello:
Waiting approval.

Aprendizaje:
Dirección está demorando aprobaciones sensibles.

19. Aprendizaje de evidencia

FARO debe aprender qué evidencias son insuficientes o se rechazan con frecuencia.

Ejemplo:

Acciones comerciales:
70% carga archivo.
40% no incluye margen.

Aprendizaje:

Modificar plantilla de evidencia para exigir margen por operación.

Código:

def tasa_evidencia_rechazada(evidencias_rechazadas, evidencias_totales):
    if evidencias_totales == 0:
        return 0
    return evidencias_rechazadas / evidencias_totales

20. Aprendizaje de calidad de datos

FARO debe aprender qué fuentes fallan.

Fuentes típicas:

ERP,
Excel,
CRM,
POS,
bancos,
WhatsApp,
documentos,
APIs,
cargas manuales.

Debe medir:

completitud,
duplicados,
errores recurrentes,
tiempo de actualización,
campos críticos faltantes,
impacto sobre diagnósticos,
acciones de corrección.

Ejemplo:

Costos de productos faltan recurrentemente.

Aprendizaje:
El módulo de margen debe bloquear diagnóstico fuerte si costos < 85% completitud.

21. Aprendizaje por industria

FARO debe aprender que cada industria tiene patrones distintos.

Construcción / insumos

Aprendizajes típicos:

margen y cobranza pesan más que volumen,
stock crítico de productos tractores afecta ventas cruzadas,
canjes deben evaluarse por liquidez,
referidos pueden erosionar margen,
comisiones deben cruzarse con margen y cobro.

Retail

promoción no siempre mejora rentabilidad,
stock lento deteriora caja,
quiebre de producto estrella afecta ticket,
merma puede explicar margen bajo.

Logística

SLA sin rentabilidad puede destruir margen,
combustible mueve resultado,
mantenimiento reactivo anticipa riesgo,
ruta no rentable puede esconder cliente deficitario.

Hotelería

ocupación alta con tarifa baja no siempre es buena,
canales caros pueden destruir rentabilidad,
RevPAR pesa más que ocupación aislada.

Salud

alta ocupación puede ocultar saturación,
tiempos de espera afectan experiencia,
insumos críticos pueden frenar prestación,
costo por prestación define rentabilidad real.

22. Aprendizaje por empresa

FARO debe adaptar lectura a cada empresa.

Ejemplo:

Empresa A:
prefiere caja antes que volumen.

Empresa B:
está en expansión y tolera margen menor temporalmente.

Empresa C:
tiene stock estratégico por inflación.

Empresa D:
opera con canjes recurrentes.

Esto no significa justificar cualquier cosa. Significa contextualizar.

Código:

def perfil_empresa_aprendizaje(historial):
    return {
        "cash_sensitivity": historial.get("cash_events_frequency"),
        "margin_sensitivity": historial.get("margin_events_frequency"),
        "stock_strategy": historial.get("stock_behavior"),
        "execution_maturity": historial.get("workflow_effectiveness")
    }

23. Aprendizaje de FARO Score

FARO debe aprender qué mueve realmente el Score.

Ejemplo:

Se creía que stock crítico impactaba -4.
Pero en esa industria genera pérdida comercial mayor.
Aprendizaje:
aumentar penalización de stock crítico para productos tractores.

Debe analizar:

drivers positivos,
drivers negativos,
eventos que anticipan caída,
acciones que recuperan Score,
componentes con mayor sensibilidad,
tensiones con mayor impacto.

Código:

def impacto_driver_score(score_before, score_after, driver_code):
    return {
        "driver": driver_code,
        "score_delta": score_after - score_before
    }

24. Aprendizaje de prioridades

FARO debe aprender si priorizó bien.

Ejemplo:

FARO priorizó stock inmovilizado.
Pero luego caja entró en crisis.

Aprendizaje:
cuando caja está por debajo del mínimo, caja debe dominar ranking.

Métrica:

Precisión de prioridad =
eventos prioritarios que efectivamente tuvieron alto impacto / eventos priorizados

Código:

def precision_priorizacion(eventos_priorizados, eventos_alto_impacto):
    if not eventos_priorizados:
        return 0

    aciertos = len(set(eventos_priorizados).intersection(set(eventos_alto_impacto)))
    return aciertos / len(eventos_priorizados)

25. Aprendizaje de “no hacer nada”

FARO también debe aprender qué pasa cuando la empresa no actúa.

Ejemplo:

FARO recomendó plan de cobranza.
No se ejecutó.
Caja cayó 8 puntos.

Aprendizaje:

La inacción frente a cobranza lenta tiene alto costo en esta empresa.

Código:

def aprendizaje_inaccion(recomendacion, impacto_no_accion):
    return {
        "recommendation_code": recomendacion,
        "not_executed": True,
        "observed_impact": impacto_no_accion,
        "learning": "inaction_cost_detected"
    }

Esto es clave para mostrar a Dirección que no decidir también decide.

26. Aprendizaje con feedback humano

El feedback humano debe incorporarse.

Opciones:

confirmar diagnóstico,
rechazar diagnóstico,
marcar falso positivo,
marcar falso negativo,
ajustar causa probable,
aceptar recomendación,
rechazar recomendación,
indicar motivo,
validar acción efectiva,
indicar acción inútil.

Ejemplo:

{
  "feedback_type": "recommendation_rejected",
  "reason": "No aplica porque el descuento fue campaña aprobada",
  "submitted_by": "Gerente Comercial",
  "learning_effect": "check_approved_campaign_before_alert"
}

Regla:

El feedback humano no debe reemplazar al dato. Debe enriquecerlo.

27. Aprendizaje supervisado vs no supervisado

Aprendizaje supervisado

Usa resultados etiquetados.

Ejemplo:

Esta recomendación fue efectiva.
Esta alerta fue falso positivo.
Esta acción resolvió la tensión.

Puede servir para:

predecir efectividad,
mejorar ranking,
ajustar recomendaciones,
clasificar alertas.

Aprendizaje no supervisado

Detecta patrones sin etiqueta previa.

Ejemplo:

Clientes con cierto patrón de compras terminan en mora.
Productos con cierta rotación anticipan quiebre.
Responsables con muchas P1 tienden a vencer acciones.

Para MVP, conviene empezar con aprendizaje supervisado simple y reglas. Lo sofisticado puede venir después. Primero que cierre bien el Excel; después le ponemos turbina.

28. Aprendizaje basado en reglas

La primera versión de aprendizaje puede ser rule-based.

Ejemplo:

def regla_aprendizaje_descuentos(resultado):
    if resultado["discount_rate_delta"] < -0.03 and resultado["gross_margin_delta"] > 0.02:
        return {
            "learning": "discount_audit_effective",
            "recommendation_adjustment": "increase_confidence"
        }

    if resultado["sales_delta"] < -0.10:
        return {
            "learning": "discount_reduction_hurt_sales",
            "recommendation_adjustment": "require_segmentation_or_pilot"
        }

    return {
        "learning": "inconclusive",
        "recommendation_adjustment": "keep_observing"
    }

Este enfoque es más confiable al principio que prometer IA predictiva sin base.

29. Aprendizaje basado en scoring

Cada acción o recomendación puede acumular score histórico.

Score histórico de recomendación =
efectividad promedio × 40%
+ aceptación × 20%
+ ejecución × 20%
+ bajo riesgo × 10%
+ precisión de impacto × 10%

Código:

def score_historico_recomendacion(
    efectividad_promedio,
    aceptacion,
    ejecucion,
    bajo_riesgo,
    precision_impacto
):
    return round(
        efectividad_promedio * 0.40 +
        aceptacion * 0.20 +
        ejecucion * 0.20 +
        bajo_riesgo * 0.10 +
        precision_impacto * 0.10,
        2
    )

Uso:

Si una recomendación tiene score histórico alto en una industria, FARO puede sugerirla antes y con mayor confianza.

30. Aprendizaje predictivo futuro

En versiones avanzadas, FARO puede usar modelos predictivos.

Ejemplos:

predecir riesgo de acción vencida,
predecir cliente moroso,
predecir quiebre de stock,
predecir caída de margen,
predecir efectividad de recomendación,
predecir impacto en FARO Score.

Herramientas posibles:

Python,
Pandas,
Scikit-learn,
XGBoost,
LightGBM,
statsmodels,
PostgreSQL,
feature store,
MLflow.

Pero con criterio:

Primero reglas trazables. Después modelos predictivos. No al revés.

31. Variables para aprendizaje

FARO debe registrar variables de contexto.

industria,
empresa,
sucursal,
área,
período,
estacionalidad,
tamaño de empresa,
nivel de madurez,
calidad de datos,
tipo de acción,
responsable,
prioridad,
confianza,
KPI antes,
KPI después,
tensión origen,
evidencia,
resultado.

Ejemplo JSON:

{
  "industry": "construction_supplies",
  "company_size": "mid_market",
  "branch_count": 3,
  "action_code": "ACT_COMMERCIAL_DISCOUNT_AUDIT",
  "priority": "P2",
  "confidence": 0.84,
  "data_quality": 0.81,
  "result": "effective"
}

32. Feature store FARO

Para aprendizaje avanzado, FARO puede tener una tabla de features.

Ejemplo:

CREATE TABLE learning_features (
    feature_id TEXT PRIMARY KEY,
    entity_type TEXT NOT NULL,
    entity_id TEXT NOT NULL,
    company_id TEXT,
    industry_id TEXT,
    feature_payload JSONB,
    label TEXT,
    label_confidence NUMERIC,
    created_at TIMESTAMP DEFAULT now()
);

Esto permite guardar:

variables de entrada,
resultado real,
etiqueta aprendida,
confianza.

33. Tabla SQL de eventos de aprendizaje

CREATE TABLE learning_events (
    learning_event_id TEXT PRIMARY KEY,
    company_id TEXT,
    branch_id TEXT,
    area_id TEXT,
    industry_id TEXT,
    entity_type TEXT NOT NULL,
    entity_id TEXT NOT NULL,
    learning_type TEXT NOT NULL,
    learning_status TEXT DEFAULT 'pending',
    context_snapshot JSONB,
    expected_result JSONB,
    actual_result JSONB,
    delta_result JSONB,
    interpretation TEXT,
    recommended_adjustment JSONB,
    confidence NUMERIC,
    created_at TIMESTAMP DEFAULT now()
);

Valores posibles de learning_type:

action_effectiveness
recommendation_effectiveness
simulation_accuracy
false_positive
false_negative
workflow_bottleneck
data_quality_issue
score_driver_learning
priority_accuracy
industry_pattern
company_pattern

34. Tabla SQL de efectividad histórica

CREATE TABLE historical_effectiveness (
    effectiveness_id TEXT PRIMARY KEY,
    company_id TEXT,
    industry_id TEXT,
    entity_type TEXT NOT NULL,
    entity_code TEXT NOT NULL,
    total_runs INTEGER DEFAULT 0,
    effective_runs INTEGER DEFAULT 0,
    partial_runs INTEGER DEFAULT 0,
    ineffective_runs INTEGER DEFAULT 0,
    false_positive_runs INTEGER DEFAULT 0,
    average_effectiveness_score NUMERIC,
    average_confidence NUMERIC,
    last_result TEXT,
    updated_at TIMESTAMP DEFAULT now()
);

35. Tabla SQL de feedback humano

CREATE TABLE human_feedback (
    feedback_id TEXT PRIMARY KEY,
    company_id TEXT,
    entity_type TEXT NOT NULL,
    entity_id TEXT NOT NULL,
    feedback_type TEXT NOT NULL,
    feedback_reason TEXT,
    feedback_comment TEXT,
    submitted_by TEXT,
    submitted_role TEXT,
    impact_on_learning JSONB,
    created_at TIMESTAMP DEFAULT now()
);

Valores posibles:

confirmed
rejected
false_positive
false_negative
partially_correct
recommendation_accepted
recommendation_rejected
action_effective
action_ineffective
needs_more_data

36. Tabla SQL de aprendizaje por industria

CREATE TABLE industry_learning (
    industry_learning_id TEXT PRIMARY KEY,
    industry_id TEXT NOT NULL,
    pattern_code TEXT NOT NULL,
    pattern_description TEXT,
    applicable_kpis JSONB,
    applicable_tensions JSONB,
    effective_actions JSONB,
    ineffective_actions JSONB,
    recommended_adjustments JSONB,
    confidence NUMERIC,
    sample_size INTEGER,
    updated_at TIMESTAMP DEFAULT now()
);

37. Tabla SQL de aprendizaje por empresa

CREATE TABLE company_learning (
    company_learning_id TEXT PRIMARY KEY,
    company_id TEXT NOT NULL,
    pattern_code TEXT NOT NULL,
    pattern_description TEXT,
    context JSONB,
    preferred_actions JSONB,
    risky_actions JSONB,
    execution_patterns JSONB,
    data_quality_patterns JSONB,
    score_drivers JSONB,
    confidence NUMERIC,
    updated_at TIMESTAMP DEFAULT now()
);

38. Tabla SQL de precisión de simulaciones

CREATE TABLE simulation_accuracy (
    accuracy_id TEXT PRIMARY KEY,
    scenario_run_id TEXT NOT NULL,
    company_id TEXT,
    industry_id TEXT,
    scenario_code TEXT,
    simulated_payload JSONB,
    actual_payload JSONB,
    error_payload JSONB,
    precision_score NUMERIC,
    adjustment_needed BOOLEAN DEFAULT false,
    recommended_adjustment JSONB,
    created_at TIMESTAMP DEFAULT now()
);

39. Motor de aprendizaje FARO

Flujo recomendado:

acción / recomendación / simulación cerrada
→ tomar snapshot inicial
→ tomar resultado real
→ comparar esperado vs real
→ clasificar resultado
→ registrar aprendizaje
→ actualizar efectividad histórica
→ generar sugerencia de ajuste
→ enviar al motor de recalibración

Código conceptual:

def motor_aprendizaje(evento):
    expected = evento.get("expected_result", {})
    actual = evento.get("actual_result", {})

    delta = {}

    for key, expected_value in expected.items():
        actual_value = actual.get(key)

        if actual_value is not None:
            delta[key] = actual_value - expected_value

    aprendizaje = {
        "entity_type": evento["entity_type"],
        "entity_id": evento["entity_id"],
        "learning_type": evento["learning_type"],
        "expected_result": expected,
        "actual_result": actual,
        "delta_result": delta,
        "confidence": evento.get("confidence", 0.70)
    }

    return aprendizaje

40. Motor de actualización de efectividad histórica

def actualizar_efectividad_historica(historial, resultado):
    historial["total_runs"] += 1

    if resultado == "effective":
        historial["effective_runs"] += 1
    elif resultado == "partial":
        historial["partial_runs"] += 1
    elif resultado == "ineffective":
        historial["ineffective_runs"] += 1
    elif resultado == "false_positive":
        historial["false_positive_runs"] += 1

    historial["average_effectiveness_score"] = (
        historial["effective_runs"] + 0.5 * historial["partial_runs"]
    ) / historial["total_runs"]

    return historial

41. Motor de aprendizaje de recomendación

def aprender_recomendacion(recomendacion, resultado):
    if resultado["effectiveness_score"] >= 0.80:
        ajuste = "increase_confidence"
    elif resultado["effectiveness_score"] >= 0.50:
        ajuste = "keep_with_conditions"
    else:
        ajuste = "reduce_priority_or_require_validation"

    return {
        "recommendation_code": recomendacion["recommendation_code"],
        "learning_type": "recommendation_effectiveness",
        "effectiveness_score": resultado["effectiveness_score"],
        "recommended_adjustment": ajuste
    }

42. Motor de aprendizaje de simulación

def aprender_simulacion(scenario_code, simulated, real):
    precision = precision_simulacion(simulated, real)

    if precision is None:
        ajuste = "cannot_evaluate"
    elif precision >= 0.85:
        ajuste = "keep_model"
    elif precision >= 0.65:
        ajuste = "minor_adjustment"
    else:
        ajuste = "recalibrate_assumptions"

    return {
        "scenario_code": scenario_code,
        "precision": precision,
        "recommended_adjustment": ajuste
    }

43. Motor de aprendizaje de alertas

def aprender_alerta(alerta_stats):
    generated = alerta_stats["generated"]
    actionable = alerta_stats["actionable"]
    false_positive = alerta_stats["false_positive"]

    if generated == 0:
        return None

    utilidad = (actionable - false_positive) / generated

    if utilidad < 0.30:
        ajuste = "reduce_sensitivity"
    elif utilidad > 0.70:
        ajuste = "keep_or_increase_priority"
    else:
        ajuste = "monitor"

    return {
        "alert_code": alerta_stats["alert_code"],
        "utility": round(utilidad, 2),
        "recommended_adjustment": ajuste
    }

44. Ejemplo completo: aprendizaje de descuentos

Situación inicial

Ventas: +18%
Margen: 21%
Descuento promedio: 12%
Cobranza: 43 días

Recomendación

Auditar descuentos mayores al 8%.

Acción

Gerente Comercial audita descuentos y propone autorización obligatoria.

Resultado

Descuento promedio baja a 8%.
Margen sube a 24%.
Cobranza sigue en 42 días.

Aprendizaje FARO

La acción fue efectiva para margen, pero insuficiente para caja.
En futuras tensiones de crecimiento no rentable, combinar auditoría de descuentos con plan de cobranza.

45. Ejemplo completo: aprendizaje de canje

Simulación inicial

Valor neto esperado: $18M
Plazo estimado: 180 días

Resultado real

Valor recuperado: $14M
Plazo real: 270 días

Aprendizaje

El factor de liquidez fue demasiado optimista.
El plazo real de realización fue mayor.
Para futuros canjes, aumentar descuento por liquidez y costo financiero.

Ajuste sugerido:

{
  "scenario_code": "exchange_deal",
  "recommended_adjustment": {
    "liquidity_factor": "reduce",
    "financial_cost_period": "increase",
    "approval_threshold": "raise"
  }
}

46. Ejemplo completo: aprendizaje de stock crítico

Acción

Activar reposición preventiva.

Resultado

Días de cobertura suben de 4 a 13.
No hubo quiebre.
Ventas se sostuvieron.

Aprendizaje

La reposición preventiva fue efectiva.
Cuando días de cobertura < plazo proveedor en producto tractor, crear acción P2 automática.

47. Ejemplo completo: aprendizaje de comisión

Recomendación

Rediseñar comisión por margen y cobranza.

Simulación

Margen esperado: +3 puntos.
Comisión total: -8%.

Resultado piloto

Margen: +2 puntos.
Comisión: -5%.
Vendedores con alto descuento reclamaron.
Ventas no cayeron significativamente.

Aprendizaje

La fórmula es viable, pero debe aplicarse gradualmente y con comunicación clara. FARO debe recomendar piloto antes de implementación total.

48. Ejemplo completo: aprendizaje de workflow

Datos

Acciones P2 de Finanzas:
60% vencidas.

Motivo:
esperan aprobación de Dirección.

Aprendizaje

El cuello de botella no está en Finanzas. Está en aprobación directiva.

Ajuste sugerido:

Crear SLA para aprobaciones.
Escalar aprobaciones P1/P2 sin respuesta.
Generar reporte de decisiones pendientes.

49. Aprendizaje y FARO Score

FARO debe usar aprendizaje para mejorar el Score.

Ejemplo:

Se detecta que acciones cerradas sin impacto estaban sumando demasiado.

Aprendizaje:
cierre operativo no debe bonificar igual que cierre efectivo.

Ajuste futuro:
bonificar más la acción medida como efectiva que la acción simplemente cerrada.

Regla:

FARO Score debe premiar resultado, no teatro de cumplimiento.

50. Aprendizaje y reportes ejecutivos

Los reportes deben incluir aprendizajes del período.

Ejemplo:

Aprendizajes del mes:
1. La auditoría de descuentos mejoró margen, pero no caja.
2. La reposición preventiva evitó quiebres en productos clave.
3. La simulación de canje fue optimista.
4. Las aprobaciones directivas son cuello de botella en P1/P2.

Esto convierte el reporte en una herramienta de mejora, no solo de control.

51. Aprendizaje y gobierno humano

No todo ajuste debe aplicarse automáticamente.

Clasificación:

Regla:

FARO aprende solo, pero no debe gobernarse solo en temas sensibles.

52. Niveles de automatización del aprendizaje

Para MVP:

Nivel 1 y 2.

Para Enterprise:

Nivel 2 y 3.

Para Neural avanzado:

Nivel 3, 4 y eventualmente 5 con auditoría.

53. Aprendizaje y auditoría

Todo aprendizaje debe ser auditable.

Debe quedar registrado:

qué se aprendió,
de qué datos salió,
qué acción o recomendación lo originó,
qué resultado real se midió,
qué ajuste se propone,
quién lo aprobó,
cuándo se aplicó,
qué cambió después.

Código conceptual:

def auditar_aprendizaje(learning_event, approved_by=None):
    return {
        "learning_event_id": learning_event["learning_event_id"],
        "recommended_adjustment": learning_event.get("recommended_adjustment"),
        "approved_by": approved_by,
        "audit_status": "pending_approval" if not approved_by else "approved",
        "created_at": "now()"
    }

54. Aprendizaje y ética de decisión

FARO debe ser especialmente prudente en:

RRHH,
comisiones,
despidos,
bloqueo de clientes,
crédito,
precios,
canjes,
proveedores estratégicos,
decisiones legales.

Regla:

En decisiones humanas, legales o sensibles, FARO aprende patrones, pero no debe automatizar sanciones o decisiones finales.

Ejemplo:

FARO puede detectar baja productividad.
No debe recomendar automáticamente despedir a alguien.
Debe recomendar revisión, evidencia y análisis humano.

55. Uso de IA en aprendizaje

La IA puede ayudar a:

resumir aprendizajes,
detectar patrones,
explicar por qué una acción funcionó,
comparar casos,
redactar ajustes sugeridos,
agrupar feedback humano,
preparar reporte de aprendizaje.

Pero no debe:

inventar causalidad,
modificar reglas sin aprobación,
aprender desde datos no validados,
confundir correlación con causa,
tomar decisiones sensibles automáticamente.

Prompt interno:

Actúa como analista ejecutivo FARO.

Con base únicamente en el payload estructurado recibido, redacta un aprendizaje claro y accionable.

No inventes datos.
No afirmes causalidad absoluta si no está demostrada.
Distingue resultado observado, hipótesis y ajuste sugerido.
Incluye:
1. evento analizado,
2. resultado esperado,
3. resultado real,
4. diferencia,
5. interpretación,
6. aprendizaje,
7. ajuste sugerido,
8. si requiere aprobación humana.

Payload:
{learning_payload}

56. Testing de aprendizaje

Test aprendizaje de simulación precisa

def test_simulacion_precisa():
    resultado = aprender_simulacion(
        scenario_code="discount_reduction",
        simulated=100,
        real=92
    )

    assert resultado["precision"] >= 0.85
    assert resultado["recommended_adjustment"] == "keep_model"

Test simulación débil requiere recalibración

def test_simulacion_debil():
    resultado = aprender_simulacion(
        scenario_code="exchange_deal",
        simulated=100,
        real=50
    )

    assert resultado["recommended_adjustment"] == "recalibrate_assumptions"

Test alerta con baja utilidad

def test_alerta_ruidosa():
    resultado = aprender_alerta({
        "alert_code": "minor_discount_alert",
        "generated": 100,
        "actionable": 15,
        "false_positive": 5
    })

    assert resultado["recommended_adjustment"] == "reduce_sensitivity"

Test efectividad acción

def test_efectividad_accion():
    score = efectividad_accion(
        cumplimiento_plazo=1,
        evidencia_valida=1,
        mejora_kpi=1,
        resolucion_tension=0.8,
        feedback_humano=1
    )

    assert score >= 0.85

57. Errores comunes en aprendizaje

58. Riesgos si no existe esta capa

59. Output final del Anexo 36

Al finalizar este anexo, FARO debe tener definido:

1. Modelo de aprendizaje FARO.
2. Aprendizaje por acción.
3. Aprendizaje por recomendación.
4. Aprendizaje por simulación.
5. Aprendizaje por alerta.
6. Aprendizaje por tensión.
7. Aprendizaje por diagnóstico.
8. Aprendizaje por responsable.
9. Aprendizaje por workflow.
10. Aprendizaje por evidencia.
11. Aprendizaje por calidad de datos.
12. Aprendizaje por industria.
13. Aprendizaje por empresa.
14. Aprendizaje por FARO Score.
15. Aprendizaje por prioridades.
16. Aprendizaje por inacción.
17. Feedback humano.
18. Falsos positivos.
19. Falsos negativos.
20. Score histórico de efectividad.
21. Precisión de simulaciones.
22. Tablas SQL de aprendizaje.
23. Motor de aprendizaje.
24. Motor de actualización histórica.
25. Motor de aprendizaje de recomendaciones.
26. Motor de aprendizaje de simulaciones.
27. Motor de aprendizaje de alertas.
28. Niveles de automatización.
29. Auditoría del aprendizaje.
30. Uso controlado de IA explicativa.
31. Testing de aprendizaje.
32. Conexión con recalibración.

60. Conexión con otros anexos

El módulo de Aprendizaje FARO registra qué recomendaciones, acciones, simulaciones, alertas, tensiones y decisiones funcionaron o fallaron, compara lo esperado contra lo real, aprende de falsos positivos y negativos, incorpora feedback humano y genera ajustes sugeridos para mejorar futuras decisiones.