AI Ethics & Responsible AI

import pandas as pd
import numpy as np
from sklearn.metrics import confusion_matrix, classification_report
import matplotlib.pyplot as plt
import seaborn as sns

class BiasDetector:
    def __init__(self, model, X_test, y_test, sensitive_features):
        self.model = model
        self.X_test = X_test
        self.y_test = y_test
        self.sensitive_features = sensitive_features
        self.predictions = model.predict(X_test)
    
    def demographic_parity(self, sensitive_feature):
        """
        Demografische Parität: Gleiche Positive Rate für alle Gruppen
        """
        df = pd.DataFrame({
            'prediction': self.predictions,
            'sensitive': self.X_test[sensitive_feature]
        })
        
        positive_rates = df.groupby('sensitive')['prediction'].mean()
        
        print("Demographic parity:")
        for group, rate in positive_rates.items():
            print(f"  {group}: {rate:.3f}")
        
        # Differenz zwischen höchster und niedrigster Rate
        disparity = positive_rates.max() - positive_rates.min()
        print(f"  Disparity: {disparity:.3f}")
        
        return positive_rates, disparity
    
    def equalized_odds(self, sensitive_feature):
        """
        Equalized Odds: Gleiche TPR und FPR für alle Gruppen
        """
        df = pd.DataFrame({
            'prediction': self.predictions,
            'actual': self.y_test,
            'sensitive': self.X_test[sensitive_feature]
        })
        
        results = {}
        for group in df['sensitive'].unique():
            group_data = df[df['sensitive'] == group]
            tn, fp, fn, tp = confusion_matrix(
                group_data['actual'], 
                group_data['prediction']
            ).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}
        
        print("Equalized Odds:")
        for group, metrics in results.items():
            print(f"  {group}: TPR={metrics['TPR']:.3f}, FPR={metrics['FPR']:.3f}")
        
        return results
    
    def fairness_metrics_report(self):
        """Umfassender Fairness-Report"""
        print("=== BIAS DETECTION REPORT ===\n")
        
        for feature in self.sensitive_features:
            print(f"Analysis for feature: {feature}")
            print("-" * 40)
            
            # Demografische Parität
            pos_rates, disparity = self.demographic_parity(feature)
            
            # Equalized Odds
            eq_odds = self.equalized_odds(feature)
            
            # Visualisierung
            self.plot_bias_metrics(feature, pos_rates)
            
            print("\n")
    
    def plot_bias_metrics(self, sensitive_feature, positive_rates):
        """Bias-Metriken visualisieren"""
        plt.figure(figsize=(10, 4))
        
        plt.subplot(1, 2, 1)
        positive_rates.plot(kind='bar')
        plt.title(f'Positive Rate by {sensitive_feature}')
        plt.ylabel('Positive Rate')
        plt.xticks(rotation=45)
        
        plt.subplot(1, 2, 2)
        df = pd.DataFrame({
            'prediction': self.predictions,
            'sensitive': self.X_test[sensitive_feature]
        })
        
        for group in df['sensitive'].unique():
            group_preds = df[df['sensitive'] == group]['prediction']
            plt.hist(group_preds, alpha=0.7, label=f'{group}', bins=20)
        
        plt.title('Prediction Distribution')
        plt.xlabel('Prediction Score')
        plt.ylabel('Frequency')
        plt.legend()
        
        plt.tight_layout()
        plt.show()

# Beispiel-Verwendung
# Angenommen, wir haben ein Modell für Kreditvergabe
bias_detector = BiasDetector(
    model=trained_model,
    X_test=X_test,
    y_test=y_test,
    sensitive_features=['gender', 'race', 'age_group']
)

# Fairness-Analyse durchführen
bias_detector.fairness_metrics_report()

import shap
import pandas as pd
import matplotlib.pyplot as plt

class ModelExplainer:
    def __init__(self, model, X_train, feature_names=None):
        self.model = model
        self.X_train = X_train
        self.feature_names = feature_names or X_train.columns
        
        # SHAP Explainer initialisieren
        self.explainer = shap.Explainer(model, X_train)
    
    def explain_instance(self, instance, show_plot=True):
        """Explaining individual predictions"""
        shap_values = self.explainer(instance.reshape(1, -1))
        
        if show_plot:
            shap.waterfall_plot(shap_values[0])
        
        return shap_values
    
    def global_feature_importance(self, X_sample, max_display=10):
        """Globale Feature-Wichtigkeit"""
        shap_values = self.explainer(X_sample)
        
        # Summary Plot
        plt.figure(figsize=(10, 6))
        shap.summary_plot(shap_values, X_sample, 
                         feature_names=self.feature_names,
                         max_display=max_display, show=False)
        plt.title('Global Feature Importance')
        plt.tight_layout()
        plt.show()
        
        # Feature-Ranking
        importance_df = pd.DataFrame({
            'feature': self.feature_names,
            'importance': np.abs(shap_values.values).mean(0)
        }).sort_values('importance', ascending=False)
        
        return importance_df
    
    def partial_dependence_analysis(self, feature_idx, X_sample):
        """Partial dependency for a feature"""
        shap_values = self.explainer(X_sample)
        
        plt.figure(figsize=(8, 6))
        shap.partial_dependence_plot(
            feature_idx, self.model.predict, X_sample,
            ice=False, model_expected_value=True, 
            feature_expected_value=True
        )
        plt.title(f'Partial Dependence: {self.feature_names[feature_idx]}')
        plt.show()

# Model-agnostic Explanation mit LIME
from lime.lime_tabular import LimeTabularExplainer

class LIMEExplainer:
    def __init__(self, X_train, feature_names, class_names, mode='classification'):
        self.explainer = LimeTabularExplainer(
            X_train.values,
            feature_names=feature_names,
            class_names=class_names,
            mode=mode,
            discretize_continuous=True
        )
    
    def explain_instance(self, instance, model_predict_fn, num_features=10):
        """Explain single instance with LIME"""
        explanation = self.explainer.explain_instance(
            instance, model_predict_fn, num_features=num_features
        )
        
        # Visualisierung in Jupyter Notebook
        explanation.show_in_notebook(show_table=True)
        
        return explanation

# Praktisches Beispiel
# Angenommen, wir haben ein Kreditrisiko-Modell
explainer = ModelExplainer(
    model=credit_model,
    X_train=X_train,
    feature_names=['income', 'age', 'debt_ratio', 'credit_history']
)

# Einzelne Entscheidung erklären
customer_data = np.array([50000, 35, 0.3, 750])  # Einkommen, Alter, Verschuldung, Credit Score
shap_values = explainer.explain_instance(customer_data)

# Globale Feature-Wichtigkeit
importance_df = explainer.global_feature_importance(X_test.sample(1000))
print("Top 5 wichtigste Features:")
print(importance_df.head())