The Ethics of AI in Finance: Building Responsible Systems That Drive Innovation

Bias Detection Framework Implementation

import pandas as pd
import numpy as np
from sklearn.metrics import confusion_matrix
from scipy.stats import chi2_contingency

class BiasAuditFramework:
    """
    Comprehensive bias detection and mitigation framework for financial AI systems
    """
    
    def __init__(self, protected_attributes):
        self.protected_attributes = protected_attributes
        self.audit_results = {}
    
    def demographic_parity_test(self, y_pred, sensitive_attr):
        """
        Test if positive prediction rates are similar across groups
        """
        groups = np.unique(sensitive_attr)
        rates = {}
        
        for group in groups:
            group_mask = sensitive_attr == group
            positive_rate = np.mean(y_pred[group_mask])
            rates[group] = positive_rate
        
        # Calculate maximum difference
        max_diff = max(rates.values()) - min(rates.values())
        
        return {
            'rates_by_group': rates,
            'max_difference': max_diff,
            'passes_threshold': max_diff < 0.1  # 10% threshold
        }
    
    def equalized_odds_test(self, y_true, y_pred, sensitive_attr):
        """
        Test if TPR and FPR are similar across groups
        """
        groups = np.unique(sensitive_attr)
        results = {}
        
        for group in groups:
            group_mask = sensitive_attr == group
            y_true_group = y_true[group_mask]
            y_pred_group = y_pred[group_mask]
            
            tn, fp, fn, tp = confusion_matrix(y_true_group, y_pred_group).ravel()
            
            tpr = tp / (tp + fn) if (tp + fn) > 0 else 0
            fpr = fp / (fp + tn) if (fp + tn) > 0 else 0
            
            results[group] = {'tpr': tpr, 'fpr': fpr}
        
        return results
    
    def comprehensive_bias_audit(self, model, X_test, y_test, sensitive_attrs):
        """
        Run comprehensive bias audit across multiple fairness metrics
        """
        predictions = model.predict(X_test)
        audit_report = {}
        
        for attr_name in sensitive_attrs:
            attr_values = X_test[attr_name]
            
            # Demographic Parity
            dp_results = self.demographic_parity_test(predictions, attr_values)
            
            # Equalized Odds
            eo_results = self.equalized_odds_test(y_test, predictions, attr_values)
            
            audit_report[attr_name] = {
                'demographic_parity': dp_results,
                'equalized_odds': eo_results
            }
        
        return audit_report

# Example usage in credit scoring system
def audit_credit_model():
    """
    Example implementation for auditing a credit scoring model
    """
    # Load your model and test data
    # model = load_credit_model()
    # X_test, y_test = load_test_data()
    
    protected_attrs = ['gender', 'race', 'age_group']
    auditor = BiasAuditFramework(protected_attrs)
    
    # Run comprehensive audit
    audit_results = auditor.comprehensive_bias_audit(
        model, X_test, y_test, protected_attrs
    )
    
    # Generate actionable insights
    for attr, results in audit_results.items():
        if not results['demographic_parity']['passes_threshold']:
            print(f"⚠️  Bias detected in {attr}: {results['demographic_parity']['max_difference']:.3f}")
            print("Recommended actions:")
            print("1. Implement bias mitigation techniques")
            print("2. Retrain model with balanced datasets")
            print("3. Apply post-processing fairness constraints")
        else:
            print(f"✅ {attr}: No significant bias detected")
                        

import shap
import lime
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import train_test_split

class ExplainableFinanceAI:
    """
    Framework for building explainable AI systems in finance
    """
    
    def __init__(self, model, feature_names):
        self.model = model
        self.feature_names = feature_names
        self.explainer = None
    
    def setup_shap_explainer(self, X_train):
        """
        Initialize SHAP explainer for model interpretability
        """
        self.explainer = shap.Explainer(self.model, X_train)
        return self.explainer
    
    def generate_customer_explanation(self, customer_data, prediction):
        """
        Generate human-readable explanation for individual predictions
        """
        shap_values = self.explainer(customer_data)
        
        # Get top contributing factors
        feature_importance = []
        for i, feature in enumerate(self.feature_names):
            importance = shap_values.values[0][i]
            feature_importance.append({
                'feature': feature,
                'impact': importance,
                'value': customer_data.iloc[0][i]
            })
        
        # Sort by absolute impact
        feature_importance.sort(key=lambda x: abs(x['impact']), reverse=True)
        
        # Generate natural language explanation
        explanation = self._generate_natural_explanation(
            feature_importance[:5], prediction
        )
        
        return {
            'prediction': prediction,
            'confidence': self._calculate_confidence(shap_values),
            'explanation': explanation,
            'top_factors': feature_importance[:5]
        }
    
    def _generate_natural_explanation(self, top_factors, prediction):
        """
        Convert SHAP values into natural language explanations
        """
        decision = "approved" if prediction == 1 else "declined"
        explanation = f"Your application was {decision} based on the following key factors:\n\n"
        
        for i, factor in enumerate(top_factors, 1):
            impact_direction = "positively" if factor['impact'] > 0 else "negatively"
            explanation += f"{i}. {factor['feature'].replace('_', ' ').title()}: "
            explanation += f"Your value of {factor['value']:.2f} impacted the decision {impact_direction}.\n"
        
        return explanation
    
    def _calculate_confidence(self, shap_values):
        """
        Calculate prediction confidence based on SHAP values
        """
        total_impact = np.sum(np.abs(shap_values.values[0]))
        return min(total_impact / 10, 1.0)  # Normalize to 0-1 scale

# Regulatory Compliance Reporting
class RegulatoryReporting:
    """
    Generate compliance reports for regulatory bodies
    """
    
    @staticmethod
    def generate_model_card(model, performance_metrics, bias_audit_results):
        """
        Generate comprehensive model documentation for regulators
        """
        model_card = {
            "model_details": {
                "name": model.__class__.__name__,
                "version": "1.0",
                "date": "2025-01-01",
                "purpose": "Credit risk assessment",
                "model_type": "Classification"
            },
            "intended_use": {
                "primary_uses": ["Credit approval decisions", "Risk assessment"],
                "primary_users": ["Credit officers", "Risk managers"],
                "out_of_scope": ["Medical decisions", "Employment decisions"]
            },
            "factors": {
                "relevant_factors": ["Income", "Credit history", "Employment status"],
                "evaluation_factors": ["Accuracy", "Fairness", "Robustness"]
            },
            "metrics": performance_metrics,
            "bias_analysis": bias_audit_results,
            "training_data": {
                "description": "Historical credit application data (2020-2024)",
                "size": "500,000 samples",
                "preprocessing": "Standardization, outlier removal, feature engineering"
            },
            "quantitative_analysis": {
                "performance": performance_metrics,
                "fairness_metrics": bias_audit_results
            },
            "ethical_considerations": {
                "risks": ["Potential bias against protected groups", "Data privacy concerns"],
                "mitigation_strategies": ["Bias testing", "Regular audits", "Human oversight"]
            }
        }
        
        return model_card