How to Conduct Bias Testing for AI Systems¶

# Example: Check group representation
import pandas as pd

def check_representation(df, attribute):
    """Check representation of groups in dataset."""
    counts = df[attribute].value_counts()
    percentages = df[attribute].value_counts(normalize=True) * 100

    print(f"\nRepresentation by {attribute}:")
    for group in counts.index:
        print(f"  {group}: {counts[group]:,} ({percentages[group]:.1f}%)")

    # Flag underrepresented groups (< 5% or < 100 samples)
    underrepresented = percentages[percentages < 5].index.tolist()
    small_samples = counts[counts < 100].index.tolist()

    if underrepresented or small_samples:
        print(f"\n  WARNING: Underrepresented groups: {underrepresented + small_samples}")

    return counts, percentages

from scipy import stats

def test_label_bias(df, label_col, protected_attr):
    """Test if labels differ significantly across groups."""
    groups = df[protected_attr].unique()
    rates = {}

    for group in groups:
        group_data = df[df[protected_attr] == group]
        rates[group] = group_data[label_col].mean()

    print(f"\nLabel rates by {protected_attr}:")
    for group, rate in rates.items():
        print(f"  {group}: {rate:.3f}")

    # Chi-square test for significant differences
    contingency = pd.crosstab(df[protected_attr], df[label_col])
    chi2, p_value, _, _ = stats.chi2_contingency(contingency)

    print(f"\nChi-square test: chi2={chi2:.2f}, p-value={p_value:.4f}")
    if p_value < 0.05:
        print("  WARNING: Significant difference in labels across groups")

    return rates, p_value

from sklearn.metrics import confusion_matrix

def calculate_fairness_metrics(y_true, y_pred, groups):
    """Calculate key fairness metrics by group."""
    results = {}

    for group in groups.unique():
        mask = groups == group
        y_true_group = y_true[mask]
        y_pred_group = y_pred[mask]

        tn, fp, fn, tp = confusion_matrix(y_true_group, y_pred_group).ravel()

        results[group] = {
            'positive_rate': (tp + fp) / (tp + fp + tn + fn),  # Demographic parity
            'tpr': tp / (tp + fn) if (tp + fn) > 0 else 0,     # Equal opportunity
            'fpr': fp / (fp + tn) if (fp + tn) > 0 else 0,     # Equalized odds
            'ppv': tp / (tp + fp) if (tp + fp) > 0 else 0,     # Predictive parity
            'n': len(y_true_group)
        }

    return results

def print_fairness_report(metrics):
    """Print formatted fairness report."""
    print("\nFairness Metrics by Group:")
    print("-" * 70)
    print(f"{'Group':<15} {'Pos Rate':>10} {'TPR':>10} {'FPR':>10} {'PPV':>10} {'N':>10}")
    print("-" * 70)

    for group, m in metrics.items():
        print(f"{group:<15} {m['positive_rate']:>10.3f} {m['tpr']:>10.3f} "
              f"{m['fpr']:>10.3f} {m['ppv']:>10.3f} {m['n']:>10,}")

    # Calculate disparities
    groups = list(metrics.keys())
    if len(groups) >= 2:
        print("\nDisparities (ratio of min/max):")
        for metric in ['positive_rate', 'tpr', 'fpr', 'ppv']:
            values = [m[metric] for m in metrics.values() if m[metric] > 0]
            if values:
                disparity = min(values) / max(values)
                status = "PASS" if disparity >= 0.8 else "FAIL"
                print(f"  {metric}: {disparity:.3f} ({status})")

from sklearn.metrics import precision_recall_curve

def find_fair_thresholds(y_true, y_prob, groups, target_metric='tpr'):
    """Find thresholds that equalize a metric across groups."""
    thresholds = {}

    # Find threshold for each group that achieves target rate
    target_rate = 0.5  # Example: target 50% positive rate

    for group in groups.unique():
        mask = groups == group
        y_prob_group = y_prob[mask]

        # Find threshold that gives target positive rate
        sorted_probs = np.sort(y_prob_group)[::-1]
        target_idx = int(len(sorted_probs) * target_rate)
        thresholds[group] = sorted_probs[min(target_idx, len(sorted_probs)-1)]

    return thresholds

def apply_fair_thresholds(y_prob, groups, thresholds):
    """Apply group-specific thresholds."""
    y_pred = np.zeros(len(y_prob))

    for group, threshold in thresholds.items():
        mask = groups == group
        y_pred[mask] = (y_prob[mask] >= threshold).astype(int)

    return y_pred

def monitor_bias_production(predictions_log, protected_attr,
                           alert_threshold=0.8):
    """Monitor production predictions for bias drift."""
    # Calculate recent metrics
    recent_metrics = calculate_fairness_metrics(
        predictions_log['actual'],
        predictions_log['predicted'],
        predictions_log[protected_attr]
    )

    # Check for disparity
    positive_rates = [m['positive_rate'] for m in recent_metrics.values()]
    disparity = min(positive_rates) / max(positive_rates)

    if disparity < alert_threshold:
        send_alert(f"Bias alert: {protected_attr} disparity = {disparity:.3f}")

    return disparity