Метрики справедливости: демографический паритет и равные возможности

import pandas as pd
import numpy as np

# Toy loan dataset
np.random.seed(42)
df = pd.DataFrame({
    'income': np.random.normal(50000, 15000, 1000),
    'credit_score': np.random.normal(650, 80, 1000),
    'gender': np.random.choice(['M', 'F'], 1000),
    'approved': np.random.choice([0, 1], 1000, p=[0.4, 0.6])
})

# Simulate a biased approval: female applicants approved 10% less
df.loc[df['gender'] == 'F', 'approved'] = (
    df.loc[df['gender'] == 'F', 'approved'] * 0.85
).round().astype(int).clip(0, 1)
print(df.groupby('gender')['approved'].mean())

from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler

features = ['income', 'credit_score']
X = df[features].values
y = df['approved'].values
g = df['gender'].values

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

model = LogisticRegression()
model.fit(X_scaled, y)
y_pred = model.predict(X_scaled)

# Demographic parity difference
rate_M = y_pred[g == 'M'].mean()
rate_F = y_pred[g == 'F'].mean()
print(f'Approval rate M: {rate_M:.3f}')
print(f'Approval rate F: {rate_F:.3f}')
print(f'Demographic parity difference: {abs(rate_M - rate_F):.3f}')

from sklearn.metrics import recall_score

# True positive rate per group (recall among actually qualified)
mask_M = g == 'M'
mask_F = g == 'F'

tpr_M = recall_score(y[mask_M], y_pred[mask_M])
tpr_F = recall_score(y[mask_F], y_pred[mask_F])

print(f'True positive rate M (recall): {tpr_M:.3f}')
print(f'True positive rate F (recall): {tpr_F:.3f}')
print(f'Equal opportunity difference: {abs(tpr_M - tpr_F):.3f}')
# A value > 0.05 is often flagged as meaningful unfairness

from sklearn.metrics import confusion_matrix

def false_positive_rate(y_true, y_pred):
    tn, fp, fn, tp = confusion_matrix(y_true, y_pred).ravel()
    return fp / (fp + tn) if (fp + tn) > 0 else 0.0

fpr_M = false_positive_rate(y[mask_M], y_pred[mask_M])
fpr_F = false_positive_rate(y[mask_F], y_pred[mask_F])

print(f'FPR M: {fpr_M:.3f}  TPR M: {tpr_M:.3f}')
print(f'FPR F: {fpr_F:.3f}  TPR F: {tpr_F:.3f}')
print(f'Equalized odds: TPR diff={abs(tpr_M-tpr_F):.3f}, FPR diff={abs(fpr_M-fpr_F):.3f}')

# Visualise trade-off: adjust threshold per group
import numpy as np

proba = model.predict_proba(X_scaled)[:, 1]

# Without fairness: single 0.5 threshold
y_single = (proba >= 0.5).astype(int)

# With equal opportunity: lower threshold for F to equalise TPR
# Find threshold for F that gives same TPR as M
tpr_target = recall_score(y[mask_M], y_single[mask_M])
print(f'Target TPR from M group: {tpr_target:.3f}')
for thresh in np.arange(0.3, 0.7, 0.01):
    y_adj = proba[mask_F] >= thresh
    if recall_score(y[mask_F], y_adj) >= tpr_target:
        print(f'Threshold for F to achieve equal opportunity: {thresh:.2f}')
        break

from fairlearn.metrics import MetricFrame, demographic_parity_difference
from fairlearn.metrics import equalized_odds_difference
from sklearn.metrics import accuracy_score, precision_score, recall_score

mf = MetricFrame(
    metrics={
        'accuracy': accuracy_score,
        'precision': precision_score,
        'recall': recall_score
    },
    y_true=y,
    y_pred=y_pred,
    sensitive_features=g
)
print(mf.by_group)
print('Demographic parity diff:', demographic_parity_difference(y, y_pred, sensitive_features=g))
print('Equalized odds diff:', equalized_odds_difference(y, y_pred, sensitive_features=g))

from sklearn.calibration import calibration_curve
import matplotlib.pyplot as plt

fig, ax = plt.subplots()
for group in ['M', 'F']:
    mask = g == group
    prob_true, prob_pred = calibration_curve(
        y[mask], proba[mask], n_bins=5
    )
    ax.plot(prob_pred, prob_true, marker='o', label=f'gender={group}')
ax.plot([0, 1], [0, 1], 'k--', label='Perfect calibration')
ax.set(xlabel='Mean predicted probability', ylabel='Fraction of positives')
ax.legend()
plt.title('Calibration curves by gender')
plt.tight_layout()
plt.savefig('calibration_by_group.png', dpi=150)

import pandas as pd
from fairlearn.metrics import MetricFrame
from sklearn.metrics import accuracy_score

# Add a second protected attribute
df['race'] = np.random.choice(['A', 'B'], len(df))
sensitive_df = df[['gender', 'race']]

mf_intersect = MetricFrame(
    metrics={'accuracy': accuracy_score},
    y_true=y,
    y_pred=y_pred,
    sensitive_features=sensitive_df
)
print(mf_intersect.by_group)
print('Worst accuracy subgroup:', mf_intersect.by_group.min())

# Decision guide: which metric to use
criteria_guide = {
    'hiring / college admission': 'Demographic parity — equal representation',
    'medical screening': 'Equal opportunity — equalise recall (catch all sick patients)',
    'fraud / recidivism': 'Equalized odds — control both FPR and TPR',
    'credit scoring': 'Calibration — predicted risk reflects actual risk per group'
}
for use_case, criterion in criteria_guide.items():
    print(f'{use_case}: {criterion}')

# Summary of limitations
limitations = [
    'Proxy features (zip code, surname) can encode protected attributes even when removed',
    'Satisfying one fairness criterion can violate another (impossibility theorem)',
    'Metrics are group-level averages; individual unfairness can persist',
    'Binary group splits may hide variation within groups',
    'Historical data reflects past discrimination; fair training data is often unavailable'
]
for i, lim in enumerate(limitations, 1):
    print(f'{i}. {lim}')