Responsible AI — Fairness Metrics, Bias Types & Mitigation

import numpy as np
from sklearn.datasets import make_classification
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import confusion_matrix

try:
    from fairlearn.metrics import (demographic_parity_difference,
        equalized_odds_difference, MetricFrame)
    from fairlearn.postprocessing import ThresholdOptimizer
    from fairlearn.reductions import ExponentiatedGradient, DemographicParity
    FAIRLEARN = True
except ImportError:
    FAIRLEARN = False

# ── Simulate biased lending dataset ──
np.random.seed(42)
n = 2000
# Sensitive attribute: group A = majority, group B = minority
sensitive = np.random.choice(['A', 'B'], n, p=[0.7, 0.3])

# Income correlated with group (reflects historical inequality)
income  = np.where(sensitive == 'A',
                   np.random.normal(60, 15, n),
                   np.random.normal(48, 18, n))
credit  = np.where(sensitive == 'A',
                   np.random.normal(680, 60, n),
                   np.random.normal(640, 70, n))
debt    = np.random.normal(0.35, 0.1, n)

X = np.column_stack([income, credit, debt])
# True creditworthiness (unbiased ground truth)
y_true = (income * 0.3 + credit * 0.02 - debt * 100 > 60).astype(int)

X_train, X_test, y_train, y_test, s_train, s_test = train_test_split(
    X, y_true, sensitive, test_size=0.3, random_state=42)

# Train model (will learn historical disparities)
clf = LogisticRegression(random_state=42)
clf.fit(X_train, y_train)
y_pred = clf.predict(X_test)

# ── Manual fairness metrics ──
mask_A = s_test == 'A'
mask_B = s_test == 'B'

def approval_rate(predictions, mask):
    return predictions[mask].mean()

def tpr(predictions, labels, mask):  # True Positive Rate (recall)
    tp = ((predictions == 1) & (labels == 1) & mask).sum()
    fn = ((predictions == 0) & (labels == 1) & mask).sum()
    return tp / (tp + fn) if (tp + fn) > 0 else 0

def fpr(predictions, labels, mask):  # False Positive Rate
    fp = ((predictions == 1) & (labels == 0) & mask).sum()
    tn = ((predictions == 0) & (labels == 0) & mask).sum()
    return fp / (fp + tn) if (fp + tn) > 0 else 0

print("Fairness Metrics:")
print(f"{'Metric':<35} {'Group A':>10} {'Group B':>10} {'Difference':>12}")
print("-" * 70)

apr_A = approval_rate(y_pred, mask_A)
apr_B = approval_rate(y_pred, mask_B)
print(f"{'Approval rate (Demographic Parity)':<35} {apr_A:>10.3f} {apr_B:>10.3f} {apr_A-apr_B:>+12.3f}")

tpr_A = tpr(y_pred, y_test, mask_A)
tpr_B = tpr(y_pred, y_test, mask_B)
print(f"{'True Positive Rate (Equalised TPR)':<35} {tpr_A:>10.3f} {tpr_B:>10.3f} {tpr_A-tpr_B:>+12.3f}")

fpr_A = fpr(y_pred, y_test, mask_A)
fpr_B = fpr(y_pred, y_test, mask_B)
print(f"{'False Positive Rate':<35} {fpr_A:>10.3f} {fpr_B:>10.3f} {fpr_A-fpr_B:>+12.3f}")

# ── Fairlearn for automated fairness analysis ──
if FAIRLEARN:
    dpd = demographic_parity_difference(y_test, y_pred, sensitive_features=s_test)
    eod = equalized_odds_difference(y_test, y_pred, sensitive_features=s_test)
    print(f"
Fairlearn: DPD = {dpd:.3f}, EOD = {eod:.3f}")
    # DPD = 0: perfect demographic parity. |DPD| > 0.1 = concerning

    # ── Post-processing mitigation: threshold adjustment ──
    # Adjust classification threshold per group to equalise fairness metric
    postprocess = ThresholdOptimizer(
        estimator=clf,
        constraints="equalized_odds",   # Equalise TPR and FPR across groups
        predict_method="predict_proba",
        objective="balanced_accuracy_score"
    )
    postprocess.fit(X_train, y_train, sensitive_features=s_train)
    y_pred_fair = postprocess.predict(X_test, sensitive_features=s_test)

    dpd_after = demographic_parity_difference(y_test, y_pred_fair, sensitive_features=s_test)
    print(f"After post-processing: DPD = {dpd_after:.3f} (was {dpd:.3f})")