AI Compliance

AI compliance ensures systems meet regulatory requirements like GDPR, EU AI Act, and industry-specific standards through governance, monitoring, and documentation.

Compliance Framework

from dataclasses import dataclass
from typing import List, Dict
from datetime import datetime

@dataclass
class ComplianceRequirement:
    name: str
    framework: str
    description: str
    status: str  # compliant, non_compliant, pending
    evidence: List[str] = None

class AIComplianceManager:
    def __init__(self):
        self.requirements: List[ComplianceRequirement] = []
        self.audit_log = []

    def add_requirement(self, name: str, framework: str, description: str):
        self.requirements.append(ComplianceRequirement(
            name=name, framework=framework,
            description=description, status="pending"
        ))

    def assess_compliance(self, model_info: dict) -> Dict:
        results = {}
        for req in self.requirements:
            assessment = self._check_requirement(req, model_info)
            req.status = assessment["status"]
            results[req.name] = assessment
        return results

    def _check_requirement(self, req: ComplianceRequirement, model_info: dict) -> Dict:
        if req.name == "data_privacy":
            return self._check_privacy(model_info)
        elif req.name == "bias_detection":
            return self._check_bias(model_info)
        elif req.name == "explainability":
            return self._check_explainability(model_info)
        return {"status": "pending", "details": "Manual review needed"}

    def _check_privacy(self, model_info: dict) -> Dict:
        has_anonymization = model_info.get("data_anonymized", False)
        has_consent = model_info.get("user_consent", False)
        return {
            "status": "compliant" if has_anonymization and has_consent else "non_compliant",
            "details": {"anonymization": has_anonymization, "consent": has_consent}
        }

    def _check_bias(self, model_info: dict) -> Dict:
        fairness_score = model_info.get("fairness_score", 0)
        return {
            "status": "compliant" if fairness_score > 0.8 else "non_compliant",
            "details": {"fairness_score": fairness_score}
        }

    def generate_report(self) -> Dict:
        compliant = sum(1 for r in self.requirements if r.status == "compliant")
        total = len(self.requirements)
        return {
            "timestamp": datetime.now().isoformat(),
            "compliance_rate": compliant / total if total else 0,
            "requirements": {r.name: r.status for r in self.requirements},
            "non_compliant": [r.name for r in self.requirements if r.status != "compliant"]
        }

    def log_audit_event(self, event_type: str, details: dict):
        self.audit_log.append({
            "timestamp": datetime.now().isoformat(),
            "event_type": event_type,
            "details": details
        })

# Usage
manager = AIComplianceManager()
manager.add_requirement("data_privacy", "GDPR", "Personal data protection")
manager.add_requirement("bias_detection", "EU_AI_Act", "Fairness requirements")
assessment = manager.assess_compliance(model_info)

Bias Detection

import numpy as np

class BiasDetector:
    def __init__(self):
        self.metrics = {}

    def demographic_parity(self, predictions: dict, sensitive_attr: str) -> float:
        groups = {}
        for pred, attr in zip(predictions["labels"], predictions[sensitive_attr]):
            groups.setdefault(attr, []).append(pred)
        rates = {g: np.mean(v) for g, v in groups.items()}
        return max(rates.values()) - min(rates.values())

    def equalized_odds(self, predictions: dict, ground_truth: dict,
                       sensitive_attr: str) -> float:
        groups = {}
        for pred, true, attr in zip(predictions["labels"], ground_truth,
                                     predictions[sensitive_attr]):
            groups.setdefault(attr, []).append((pred, true))
        tpr_diff = 0
        for g, pairs in groups.items():
            tp = sum(1 for p, t in pairs if p == 1 and t == 1)
            fn = sum(1 for p, t in pairs if p == 0 and t == 1)
            tpr = tp / (tp + fn) if (tp + fn) > 0 else 0
            tpr_diff = max(tpr_diff, abs(tpr - 0.5))
        return tpr_diff

    def full_bias_audit(self, predictions: dict, ground_truth: dict) -> dict:
        results = {}
        for attr in ["gender", "race", "age_group"]:
            if attr in predictions:
                results[attr] = {
                    "demographic_parity": self.demographic_parity(predictions, attr),
                    "equalized_odds": self.equalized_odds(predictions, ground_truth, attr)
                }
        return results

# Usage
detector = BiasDetector()
audit = detector.full_bias_audit(predictions, ground_truth)

Explainability

class ExplainabilityTool:
    def __init__(self, model):
        self.model = model

    def shap_explanation(self, X: np.ndarray, feature_names: list) -> dict:
        import shap
        explainer = shap.TreeExplainer(self.model)
        shap_values = explainer.shap_values(X)
        return {"shap_values": shap_values, "features": feature_names}

    def lime_explanation(self, text: str, class_names: list) -> dict:
        from lime.lime_text import LimeTextExplainer
        explainer = LimeTextExplainer(class_names=class_names)
        exp = explainer.explain_instance(text, self.model.predict_proba, num_features=10)
        return {"features": exp.as_list(), "intercept": exp.intercept}

    def generate_explanation_report(self, predictions: list, data: np.ndarray) -> str:
        report = "AI Model Explanation Report\n"
        report += "=" * 40 + "\n"
        for i, pred in enumerate(predictions[:5]):
            report += f"\nSample {i+1}: Predicted {pred}\n"
            report += "Key factors: [feature importance data]\n"
        return report

# Usage
explainer = ExplainabilityTool(model)
shap_result = explainer.shap_explanation(X_test[:10], feature_names)

Key Takeaways

• GDPR requires data protection and user consent for AI systems
• EU AI Act categorizes AI systems by risk level with specific requirements
• Bias detection ensures fair outcomes across demographic groups
• Explainability makes AI decisions interpretable and auditable
• Audit trails document all AI system interactions for compliance