IA Responsable: Construyendo Sistemas de Machine Learning Éticos

import pandas as pd
from fairlearn.metrics import MetricFrame
from sklearn.metrics import accuracy_score, precision_score, recall_score
 
def audit_model_fairness(
    y_true: pd.Series,
    y_pred: pd.Series,
    sensitive_features: pd.DataFrame
) -> dict:
    """
    Auditoría completa de equidad entre grupos demográficos.
    """
 
    # Calcular métricas entre grupos
    metrics = {
        'accuracy': accuracy_score,
        'precision': precision_score,
        'recall': recall_score,
        'selection_rate': lambda y_t, y_p: y_p.mean(),
    }
 
    results = {}
 
    for feature_name in sensitive_features.columns:
        metric_frame = MetricFrame(
            metrics=metrics,
            y_true=y_true,
            y_pred=y_pred,
            sensitive_features=sensitive_features[feature_name]
        )
 
        results[feature_name] = {
            'by_group': metric_frame.by_group.to_dict(),
            'differences': metric_frame.difference().to_dict(),
            'ratios': metric_frame.ratio().to_dict(),
            'overall': metric_frame.overall.to_dict()
        }
 
        # Señalar disparidades significativas
        for metric_name, ratio in metric_frame.ratio().items():
            if ratio < 0.8:  # Regla del 80% comúnmente usada en empleo
                print(f"ADVERTENCIA: {feature_name} - ratio de {metric_name} = {ratio:.2f}")
 
    return results

import shap
 
def explain_prediction(model, instance, feature_names, background_data):
    """Generar explicación SHAP para una sola predicción."""
 
    # Crear explicador
    explainer = shap.Explainer(model, background_data)
 
    # Calcular valores SHAP para esta instancia
    shap_values = explainer(instance)
 
    # Crear diccionario de explicación
    explanation = {
        'prediction': model.predict(instance)[0],
        'base_value': explainer.expected_value,
        'feature_contributions': dict(zip(
            feature_names,
            shap_values.values[0]
        ))
    }
 
    return explanation
 
def generate_explanation_text(explanation: dict) -> str:
    """Convertir explicación SHAP a texto legible."""
    text = f"Predicción: {'Aprobado' if explanation['prediction'] == 1 else 'Denegado'}\n\n"
    text += "Factores clave:\n"
 
    for feature, contribution in explanation['top_factors']:
        direction = "aumentó" if contribution > 0 else "disminuyó"
        text += f"  • {feature}: {direction} la probabilidad en {abs(contribution):.2f}\n"
 
    return text

from dataclasses import dataclass
from enum import Enum
 
class DecisionPath(Enum):
    AUTOMATIC = "automático"
    HUMAN_REVIEW = "revisión_humana"
    ESCALATION = "escalación"
 
def route_decision(
    prediction: int,
    confidence: float,
    explanation: dict,
    is_high_stakes: bool = False
) -> PredictionWithConfidence:
    """
    Enrutar predicciones basado en confianza y riesgo.
    """
 
    # Decisiones de alto riesgo siempre obtienen revisión humana
    if is_high_stakes:
        return PredictionWithConfidence(
            prediction=prediction,
            confidence=confidence,
            explanation=explanation,
            decision_path=DecisionPath.HUMAN_REVIEW,
            review_reason="Decisión de alto riesgo requiere aprobación humana"
        )
 
    # Predicciones de baja confianza necesitan revisión
    if confidence < 0.7:
        return PredictionWithConfidence(
            prediction=prediction,
            confidence=confidence,
            explanation=explanation,
            decision_path=DecisionPath.HUMAN_REVIEW,
            review_reason=f"Baja confianza ({confidence:.2f})"
        )
 
    # Alta confianza, caso normal - puede proceder automáticamente
    return PredictionWithConfidence(
        prediction=prediction,
        confidence=confidence,
        explanation=explanation,
        decision_path=DecisionPath.AUTOMATIC
    )