Strategi Mitigasi Bias: Pra-pemrosesan, Pemrosesan, dan Pascapemrosesan

from fairlearn.preprocessing import CorrelationRemover
import numpy as np
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler

# Reweighing: compute weights to balance (group, label) combinations
def compute_reweighing_weights(y, sensitive):
    n = len(y)
    weights = np.ones(n)
    for label in np.unique(y):
        for group in np.unique(sensitive):
            mask = (y == label) & (sensitive == group)
            expected = (y == label).mean() * (sensitive == group).mean()
            actual = mask.mean()
            if actual > 0:
                weights[mask] = expected / actual
    return weights

# Usage: model.fit(X_train, y_train, sample_weight=weights)

from fairlearn.preprocessing import CorrelationRemover
import numpy as np

X = np.random.randn(500, 5)
sensitive = np.random.choice([0, 1], 500)

# Project out correlation with sensitive attribute
cr = CorrelationRemover(sensitive_feature_ids=[0])  # column 0 is sensitive
X_fair = cr.fit_transform(X)

print('Original correlation with sensitive:', np.corrcoef(X[:, 0], sensitive)[0, 1])
print('After removal:', np.corrcoef(X_fair[:, 0], sensitive)[0, 1])

from fairlearn.reductions import ExponentiatedGradient, EqualizedOdds
from sklearn.linear_model import LogisticRegression
import numpy as np

np.random.seed(42)
X = np.random.randn(600, 4)
sensitive = np.random.choice(['A', 'B'], 600)
y = (X[:, 0] + np.random.randn(600) * 0.5 > 0).astype(int)

base_estimator = LogisticRegression(max_iter=1000)
mitigator = ExponentiatedGradient(
    base_estimator,
    constraints=EqualizedOdds(),
    eps=0.05  # allowed violation
)
mitigator.fit(X, y, sensitive_features=sensitive)
y_pred_fair = mitigator.predict(X)
print('Predictions generated:', y_pred_fair[:10])

from fairlearn.reductions import GridSearch, DemographicParity
from sklearn.tree import DecisionTreeClassifier

gs = GridSearch(
    DecisionTreeClassifier(max_depth=4),
    constraints=DemographicParity(),
    grid_size=10
)
gs.fit(X, y, sensitive_features=sensitive)

# Inspect trade-off frontier
for pred in gs.predictors_:
    y_hat = pred.predict(X)
    acc = (y_hat == y).mean()
    dp_diff = abs(
        y_hat[sensitive == 'A'].mean() - y_hat[sensitive == 'B'].mean()
    )
    print(f'Accuracy={acc:.3f} | DP difference={dp_diff:.3f}')

import numpy as np
from sklearn.metrics import recall_score

# Assume model outputs probabilities: proba_A, proba_B for each group
np.random.seed(0)
proba = np.random.beta(2, 5, 600)  # model probability scores
y_true = (proba > 0.3 + np.random.randn(600) * 0.1).astype(int)

mask_A = sensitive == 'A'
mask_B = sensitive == 'B'

# Find threshold for group B to match group A's TPR at threshold 0.5
base_tpr = recall_score(y_true[mask_A], (proba[mask_A] >= 0.5).astype(int))
for thresh in np.arange(0.2, 0.7, 0.01):
    tpr_B = recall_score(y_true[mask_B], (proba[mask_B] >= thresh).astype(int))
    if abs(tpr_B - base_tpr) < 0.02:
        print(f'Equal-opportunity threshold for group B: {thresh:.2f} (TPR={tpr_B:.3f})')
        break

from fairlearn.postprocessing import ThresholdOptimizer
from fairlearn.metrics import equalized_odds_difference
from sklearn.linear_model import LogisticRegression

base_model = LogisticRegression(max_iter=1000)
base_model.fit(X, y)

to = ThresholdOptimizer(
    estimator=base_model,
    constraints='equalized_odds',
    objective='balanced_accuracy_score',
    predict_method='predict_proba'
)
to.fit(X, y, sensitive_features=sensitive)
y_pred_to = to.predict(X, sensitive_features=sensitive)

print('EO difference before:', equalized_odds_difference(y, base_model.predict(X), sensitive_features=sensitive))
print('EO difference after:', equalized_odds_difference(y, y_pred_to, sensitive_features=sensitive))

comparison = {
    'Pre-processing (reweighing/removal)': {
        'requires_retraining': True,
        'model_agnostic': True,
        'typical_accuracy_cost': 'Low to medium'
    },
    'In-processing (Exp. Gradient)': {
        'requires_retraining': True,
        'model_agnostic': True,
        'typical_accuracy_cost': 'Medium'
    },
    'Post-processing (threshold optimizer)': {
        'requires_retraining': False,
        'model_agnostic': True,
        'typical_accuracy_cost': 'Low (if scores are calibrated)'
    }
}
for method, props in comparison.items():
    print(method, '->', props)

from fairlearn.metrics import MetricFrame, demographic_parity_difference
from sklearn.metrics import accuracy_score
import numpy as np

results = []
for threshold_offset in [0.0, -0.05, -0.10, -0.15]:
    y_hat = np.where(
        sensitive == 'B',
        (proba >= 0.5 + threshold_offset).astype(int),
        (proba >= 0.5).astype(int)
    )
    acc = accuracy_score(y_true, y_hat)
    dp = demographic_parity_difference(y_true, y_hat, sensitive_features=sensitive)
    results.append({'offset': threshold_offset, 'accuracy': acc, 'dp_diff': abs(dp)})
    print(f'offset={threshold_offset:.2f}: accuracy={acc:.3f}, dp_diff={abs(dp):.3f}')

# Non-technical checklist for responsible deployment
checklist = [
    'Affected community consulted on fairness definition',
    'Model card documents protected attributes, metrics, and mitigation',
    'Fairness metrics monitored in production alongside accuracy',
    'Individual appeal process exists for adverse decisions',
    'Third-party audit scheduled before high-stakes deployment',
    'Data provenance documented to detect historical bias sources'
]
for item in checklist:
    print('[x]', item)

# Sketch of a full fairness-aware pipeline
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import StandardScaler
from fairlearn.reductions import ExponentiatedGradient, EqualizedOdds
from sklearn.linear_model import LogisticRegression

# Step 1: pre-process (reweighing done externally via sample_weight)
preprocessor = StandardScaler()
X_scaled = preprocessor.fit_transform(X)

# Step 2: in-processing with fairness constraint
mitigator = ExponentiatedGradient(
    LogisticRegression(max_iter=1000),
    constraints=EqualizedOdds(),
    eps=0.05
)
mitigator.fit(X_scaled, y, sensitive_features=sensitive)

# Step 3: evaluate and document
y_fair = mitigator.predict(X_scaled)
print('Fair model accuracy:', (y_fair == y).mean().round(3))