Bab 12: Etika, Keadilan & AI Bertanggung Jawab

Ethical Issues, Bias Detection, Fairness Metrics, dan Explainability dalam Machine Learning

Bab 12: Etika, Keadilan & AI Bertanggung Jawab

Hasil Pembelajaran (Learning Outcomes)

Setelah mempelajari bab ini, Anda akan mampu:

  1. Mengidentifikasi ethical issues dan dilemmas dalam AI/ML systems
  2. Mendeteksi & mengukur bias dalam datasets dan trained models
  3. Mengimplementasikan fairness metrics dan mitigation strategies
  4. Menjelaskan model predictions menggunakan interpretability techniques
  5. Menerapkan privacy-preserving ML methods (differential privacy, federated learning)
  6. Merancang AI governance framework dan compliance procedures
  7. Mengevaluasi AI systems dengan menggunakan responsible AI guidelines

12.1 Pengantar: Mengapa Etika AI Penting?

12.1.1 Masalah Nyata dari Bias dalam AI

AI systems sudah terintegrasi dalam kehidupan sehari-hari: kredensial bank, recruitment, medical diagnosis, criminal justice. Namun, dampak negatif dari AI yang bias bisa sangat serius:

Contoh Kasus Nyata:

  1. Amazon Recruitment AI (2018)
    • Amazon developed AI system untuk hire engineers
    • System diskriminasi terhadap perempuan karena trained on historical hiring data (male-dominated tech industry)
    • Bias historical โ†’ perpetuated dalam automated decisions
    • Impact: Ribuan perempuan engineer dismissed by algorithm
  2. COMPAS Recidivism Algorithm (US Criminal Justice)
    • Digunakan untuk predict risiko repeat offenses
    • African American defendants marked 10% lebih tinggi risk meskipun controlled for crime type
    • Led to longer sentences dan higher incarceration rates
    • Impact: Systematic bias dalam criminal justice system
  3. Facial Recognition Bias
    • Google, Microsoft, Amazon facial recognition systems
    • Error rate untuk dark-skinned women: 34%
    • Error rate untuk light-skinned men: 1%
    • Impact: Wrongful arrests, privacy violations
  4. Healthcare Prediction Models
    • Algorithm predict patient risk untuk hospitalization
    • Trained menggunakan historical healthcare spending (proxy untuk health)
    • White patients with same health status got higher risk scores
    • Reason: Wealthy (historically white) patients more likely afford expensive healthcare
    • Impact: Sicker Black patients missed dari preventive care programs

Pertanyaan Utama:

  • Bagaimana bias masuk ke dalam AI systems?
  • Bisakah kita detect dan fix bias?
  • Siapa yang bertanggung jawab jika AI merugikan?
  • Bagaimana kita design AI yang fair untuk semua orang?

12.1.2 Dimensi Etika dalam AI

Fairness, Accountability, Transparency (FAT)

Modern responsible AI frameworks focus on:

  • Fairness (Keadilan): Treat individuals/groups equitably
  • Accountability (Akuntabilitas): Clear responsibility untuk decisions
  • Transparency (Transparansi): Explainable & interpretable decisions

12.2 Bias dalam Machine Learning

12.2.1 Sumber-Sumber Bias

Bias bisa berasal dari berbagai tahap dalam ML pipeline:

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_classification

# Visualisasi sumber-sumber bias dalam ML pipeline
sources_of_bias = {
    'Data Collection': [
        'Selection bias (tidak representative)',
        'Historical bias (past injustice)',
        'Measurement bias (proxy variables)'
    ],
    'Data Preprocessing': [
        'Unequal data quality by group',
        'Handling missing data differently',
        'Feature engineering yang biased'
    ],
    'Model Training': [
        'Imbalanced training data',
        'Inappropriate metrics',
        'Hyperparameter tuning bias'
    ],
    'Deployment': [
        'Different operating conditions',
        'Feedback loop amplifying bias',
        'Unequal access untuk different groups'
    ]
}

print("๐Ÿ“Š SUMBER-SUMBER BIAS DALAM ML PIPELINE\n")
print("=" * 70)

for stage, biases in sources_of_bias.items():
    print(f"\n{stage}:")
    for i, bias in enumerate(biases, 1):
        print(f"  {i}. {bias}")

print("\n" + "=" * 70)

Tipe-Tipe Bias:

  1. Selection Bias: Training data tidak representative dari actual population
  2. Historical Bias: Past discrimination reflected dalam data
  3. Measurement Bias: Proxy variables yang tidak perfectly capture intended concept
  4. Aggregation Bias: Different subgroups need different models but use single model
  5. Feedback Bias: Model predictions influence future data, creating feedback loops

12.2.2 Detecting Bias dalam Dataset

Mari kita explore bagaimana detect bias dalam practice:

from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
import seaborn as sns

# Load dataset
data = load_breast_cancer()
X = pd.DataFrame(data.data, columns=data.feature_names)
y = pd.Series(data.target, name='diagnosis')

# Simulate protected attribute (sensitive feature)
# In real scenario ini akan dari actual demographic data
np.random.seed(42)
protected_attr = np.random.binomial(1, 0.5, len(X))
df = X.copy()
df['protected_group'] = protected_attr
df['diagnosis'] = y

print("๐Ÿ“Š Dataset Overview:")
print(f"Total samples: {len(df)}")
print(f"Protected group distribution:\n{df['protected_group'].value_counts()}")
print(f"\nDiagnosis distribution:\n{df['diagnosis'].value_counts()}")

# Analyze potential bias
print("\n" + "=" * 70)
print("๐Ÿ” BIAS ANALYSIS\n")

# Statistical Parity: Different outcomes by group
print("1. Outcome Distribution by Protected Group:")
for group in [0, 1]:
    group_data = df[df['protected_group'] == group]
    positive_rate = group_data['diagnosis'].mean()
    print(f"   Group {group}: {positive_rate:.2%} positive rate")

# Disparate impact ratio
group_0_rate = df[df['protected_group'] == 0]['diagnosis'].mean()
group_1_rate = df[df['protected_group'] == 1]['diagnosis'].mean()
disparate_impact = min(group_0_rate, group_1_rate) / max(group_0_rate, group_1_rate)
print(f"\n2. Disparate Impact Ratio: {disparate_impact:.3f}")
print(f"   (>0.8 is generally considered acceptable)")

# Feature distribution bias
print(f"\n3. Feature Distribution Differences:")
for feature in X.columns[:3]:  # Show first 3 features
    mean_diff = abs(df[df['protected_group']==0][feature].mean() -
                   df[df['protected_group']==1][feature].mean())
    print(f"   {feature}: diff = {mean_diff:.4f}")

12.2.3 Measuring & Mitigating Bias dengan Fairlearn

Gunakan fairlearn library untuk comprehensive bias detection:

# Install fairlearn
# pip install fairlearn scikit-learn

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

# Train baseline model
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42
)

protected_train = df.loc[X_train.index, 'protected_group']
protected_test = df.loc[X_test.index, 'protected_group']

# Train unaware model (doesn't use protected attribute)
model = LogisticRegression(max_iter=5000, random_state=42)
model.fit(X_train, y_train)

y_pred = model.predict(X_test)
y_pred_proba = model.predict_proba(X_test)[:, 1]

print("=" * 70)
print("โš–๏ธ BIAS METRICS - BASELINE MODEL\n")

# Demographic Parity Difference
dpd = demographic_parity_difference(
    y_test, y_pred,
    sensitive_features=protected_test
)
print(f"1. Demographic Parity Difference: {dpd:.4f}")
print(f"   (0 = perfect fairness, closer to 0 is better)")

# Equalized Odds Difference
eod = equalized_odds_difference(
    y_test, y_pred,
    sensitive_features=protected_test
)
print(f"\n2. Equalized Odds Difference: {eod:.4f}")
print(f"   (0 = equal opportunity for both groups)")

# Accuracy by group
print(f"\n3. Accuracy by Group:")
for group in [0, 1]:
    mask = protected_test == group
    acc = (y_pred[mask] == y_test[mask]).mean()
    print(f"   Group {group}: {acc:.3f}")

print("\n" + "=" * 70)
print("โœ… MITIGATING BIAS WITH THRESHOLD OPTIMIZATION\n")

# Apply fairness constraint menggunakan threshold optimization
thresholder = ThresholdOptimizer(
    estimator=model,
    constraints='equalized_odds_difference',
    prefit=True
)

thresholder.fit(X_train, y_train, sensitive_features=protected_train)
y_pred_fair = thresholder.predict(X_test, sensitive_features=protected_test)

# Evaluate fair model
dpd_fair = demographic_parity_difference(
    y_test, y_pred_fair,
    sensitive_features=protected_test
)
eod_fair = equalized_odds_difference(
    y_test, y_pred_fair,
    sensitive_features=protected_test
)

print(f"After Threshold Optimization:")
print(f"  Demographic Parity Difference: {dpd_fair:.4f} (was {dpd:.4f})")
print(f"  Equalized Odds Difference: {eod_fair:.4f} (was {eod:.4f})")

# Trade-off: Check accuracy
baseline_acc = (y_pred == y_test).mean()
fair_acc = (y_pred_fair == y_test).mean()
print(f"\n  Overall Accuracy: {fair_acc:.3f} (was {baseline_acc:.3f})")
print(f"  Trade-off: {(baseline_acc - fair_acc)*100:.2f}% accuracy loss for fairness")
โš ๏ธ Bias-Accuracy Trade-off

Improving fairness often comes at cost of overall accuracy! - No free lunch: Cannot optimize all metrics simultaneously - Stakeholder alignment: Discuss acceptable accuracy-fairness trade-off - Context matters: Healthcare needs higher accuracy; hiring dapat tolerate more fairness loss

12.3 Fairness Metrics & Evaluation Framework

12.3.1 Fairness Definitions

Different fairness definitions optimize different metrics:

fairness_definitions = {
    'Demographic Parity': {
        'definition': 'P(Y=1|G=0) = P(Y=1|G=1)',
        'meaning': 'Same positive outcome rate for all groups',
        'best_for': 'Screening decisions (hiring, loans)',
        'cons': 'May ignore group differences in qualifications'
    },
    'Equalized Odds': {
        'definition': 'TPR(G=0) = TPR(G=1) AND FPR(G=0) = FPR(G=1)',
        'meaning': 'Equal true positive & false positive rates',
        'best_for': 'High-stakes decisions (criminal justice, medical)',
        'cons': 'More complex to achieve'
    },
    'Disparate Impact': {
        'definition': 'P(Y=1|G=1) / P(Y=1|G=0) >= 0.8',
        'meaning': '80% rule: selection rate ratio >= 0.8',
        'best_for': 'Employment discrimination law (US legal standard)',
        'cons': 'Doesn\'t account for qualification differences'
    },
    'Individual Fairness': {
        'definition': 'Similar individuals treated similarly',
        'meaning': 'Consistency in individual decisions',
        'best_for': 'Personalized decisions',
        'cons': 'Hard to operationalize'
    },
    'Calibration': {
        'definition': 'P(Y=1|score=s,G=0) = P(Y=1|score=s,G=1)',
        'meaning': 'Prediction probabilities equally accurate across groups',
        'best_for': 'Risk assessment, probability predictions',
        'cons': 'Can conflict dengan demographic parity'
    }
}

print("๐Ÿ“Š FAIRNESS METRICS COMPARISON\n")
print("=" * 80)

for metric, details in fairness_definitions.items():
    print(f"\n{metric}:")
    print(f"  Formula: {details['definition']}")
    print(f"  Meaning: {details['meaning']}")
    print(f"  Best for: {details['best_for']}")
    print(f"  Cons: {details['cons']}")

print("\n" + "=" * 80)

12.3.2 Comprehensive Fairness Evaluation

from sklearn.metrics import confusion_matrix, roc_auc_score
import matplotlib.pyplot as plt

def compute_fairness_metrics(y_true, y_pred, sensitive_features):
    """Compute comprehensive fairness metrics"""

    results = {}

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

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

        # Metrics
        tpr = tp / (tp + fn) if (tp + fn) > 0 else 0  # True positive rate
        fpr = fp / (fp + tn) if (fp + tn) > 0 else 0  # False positive rate
        fnr = fn / (fn + tp) if (fn + tp) > 0 else 0  # False negative rate
        positive_rate = (tp + fp) / len(y_pred_group)
        accuracy = (tp + tn) / len(y_pred_group)

        results[group] = {
            'tpr': tpr,
            'fpr': fpr,
            'fnr': fnr,
            'positive_rate': positive_rate,
            'accuracy': accuracy
        }

    return results

# Compute metrics for both groups
metrics = compute_fairness_metrics(y_test, y_pred, protected_test)

print("=" * 70)
print("โš–๏ธ DETAILED FAIRNESS METRICS\n")

metrics_df = pd.DataFrame(metrics).T
print(metrics_df.round(4))

# Visualize
fig, axes = plt.subplots(1, 2, figsize=(14, 5))

# TPR and FPR by group
groups = list(metrics.keys())
tprs = [metrics[g]['tpr'] for g in groups]
fprs = [metrics[g]['fpr'] for g in groups]

x = np.arange(len(groups))
width = 0.35

axes[0].bar(x - width/2, tprs, width, label='True Positive Rate (Sensitivity)', color='green', alpha=0.7)
axes[0].bar(x + width/2, fprs, width, label='False Positive Rate (Fall-out)', color='red', alpha=0.7)
axes[0].set_ylabel('Rate', fontweight='bold')
axes[0].set_title('Error Rates by Protected Group', fontweight='bold')
axes[0].set_xticks(x)
axes[0].set_xticklabels([f'Group {g}' for g in groups])
axes[0].legend()
axes[0].grid(axis='y', alpha=0.3)
axes[0].axhline(y=0.2, color='red', linestyle='--', alpha=0.5, label='Threshold')

# Positive rate and accuracy
pos_rates = [metrics[g]['positive_rate'] for g in groups]
accuracies = [metrics[g]['accuracy'] for g in groups]

axes[1].bar(x - width/2, pos_rates, width, label='Positive Prediction Rate', color='blue', alpha=0.7)
axes[1].bar(x + width/2, accuracies, width, label='Accuracy', color='purple', alpha=0.7)
axes[1].set_ylabel('Rate', fontweight='bold')
axes[1].set_title('Outcomes by Protected Group', fontweight='bold')
axes[1].set_xticks(x)
axes[1].set_xticklabels([f'Group {g}' for g in groups])
axes[1].legend()
axes[1].grid(axis='y', alpha=0.3)

plt.tight_layout()
plt.show()

print("\n" + "=" * 70)

12.4 Model Explainability & Interpretability

12.4.1 Mengapa Explainability Penting?

Explainable AI (XAI) Requirements

Modern regulations (GDPR, AI Act) require right to explanation:

  • Users berhak tahu mengapa mereka ditolak untuk loan
  • Patients berhak understand medical AI recommendations
  • Defendants berhak challenge criminal risk assessment
  • Employees berhak know why theyโ€™re not hired

Black-box models tidak lagi acceptable untuk high-stakes decisions!

12.4.2 LIME (Local Interpretable Model-agnostic Explanations)

# pip install lime

import lime
import lime.lime_tabular

# Initialize LIME explainer
explainer = lime.lime_tabular.LimeTabularExplainer(
    X_train.values,
    feature_names=X.columns,
    class_names=['benign', 'malignant'],
    mode='classification',
    random_state=42
)

# Explain prediction untuk specific instance
instance_idx = 10
instance = X_test.iloc[instance_idx]
prediction = model.predict_proba(X_test.iloc[[instance_idx]])[0]

print("=" * 70)
print("๐Ÿ” LIME EXPLANATION - Local Interpretable Predictions\n")

print(f"Instance: {instance_idx}")
print(f"Predicted probability: malignant = {prediction[1]:.3f}, benign = {prediction[0]:.3f}")
print(f"Predicted class: {'MALIGNANT' if prediction[1] > 0.5 else 'BENIGN'}\n")

# Get LIME explanation
exp = explainer.explain_instance(
    instance.values,
    model.predict_proba,
    num_features=10,
    top_labels=1
)

print("Top features contributing to prediction:")
print("-" * 70)

# Extract explanations
for feature, weight in exp.as_list():
    print(f"{feature:40} โ†’ contribution: {weight:+.4f}")

print("\n" + "=" * 70)

12.4.3 SHAP (SHapley Additive exPlanations)

SHAP memberikan theoretically grounded explanations menggunakan cooperative game theory:

# pip install shap

import shap

# Create SHAP explainer
explainer_shap = shap.KernelExplainer(
    model.predict_proba,
    X_train.sample(100)  # Use sample untuk faster computation
)

# Explain predictions
shap_values = explainer_shap.shap_values(X_test.iloc[:50])

print("=" * 70)
print("๐ŸŽฏ SHAP EXPLANATIONS - Feature Importance\n")

# Summary plot data
feature_importance = np.abs(shap_values[1]).mean(axis=0)
feature_df = pd.DataFrame({
    'feature': X.columns,
    'mean_abs_shap': feature_importance
}).sort_values('mean_abs_shap', ascending=False)

print("Top 10 Most Important Features (by SHAP values):")
print(feature_df.head(10).to_string(index=False))

print("\n" + "=" * 70)

12.5 Privacy-Preserving Machine Learning

12.5.1 Differential Privacy

Definisi: Differential privacy provides mathematical guarantee bahwa model tidak leak individual data:

\[\Pr[\mathcal{A}(D) = t] \leq e^\epsilon \cdot \Pr[\mathcal{A}(D') = t]\]

Where \(D\) dan \(D'\) differ by one row, \(\epsilon\) = privacy budget

# Demonstrasi differential privacy concept
import numpy as np

def query_with_differential_privacy(data, query_func, epsilon=1.0, sensitivity=1.0):
    """
    Apply differential privacy ke query result.

    Parameters:
    -----------
    data : array
        Original data
    query_func : callable
        Function computing aggregate statistic
    epsilon : float
        Privacy budget (smaller = more private)
    sensitivity : float
        Maximum change if one person's data removed

    Returns:
    --------
    result_private : float
        Query result dengan differential privacy noise
    """

    # Compute true result
    true_result = query_func(data)

    # Add Laplace noise
    noise = np.random.laplace(0, sensitivity / epsilon)
    result_private = true_result + noise

    return true_result, result_private, noise

# Example: Compute average age
ages = np.array([25, 30, 35, 40, 45, 50, 55, 60, 65, 70])

print("=" * 70)
print("๐Ÿ”’ DIFFERENTIAL PRIVACY DEMONSTRATION\n")

print(f"Original ages: {ages}")
print(f"True average: {ages.mean():.2f}\n")

# Try different epsilon values
print("Privacy Budget vs Accuracy Trade-off:")
print("-" * 70)

epsilons = [0.1, 0.5, 1.0, 5.0]
for epsilon in epsilons:
    results = []
    for _ in range(10):  # Average over 10 runs
        true_res, priv_res, noise = query_with_differential_privacy(
            ages,
            np.mean,
            epsilon=epsilon
        )
        results.append(priv_res)

    avg_result = np.mean(results)
    error = abs(avg_result - ages.mean())

    privacy_budget = epsilon
    print(f"ฮต = {epsilon:3.1f}: private avg = {avg_result:.2f}, error = {error:.2f}")

print(f"\nฮต = smaller โ†’ more private (more noise)")
print(f"ฮต = larger โ†’ less private (less noise)")

print("\n" + "=" * 70)

12.5.2 Federated Learning

Federated learning memungkinkan training tanpa mengirim raw data ke central server:

# Conceptual federated learning simulation

print("=" * 70)
print("๐Ÿ” FEDERATED LEARNING ARCHITECTURE\n")

federated_scenario = """
TRADITIONAL CENTRALIZED LEARNING:
  Hospital A โ†’ send patient data โ†’ Central Server โ†’ train model
  Hospital B โ†’ send patient data โ†’ Central Server
  Hospital C โ†’ send patient data โ†’ Central Server

  โŒ Privacy risk: Central server bisa expose semua patient data
  โŒ Regulatory: HIPAA, GDPR violations

FEDERATED LEARNING:
  Hospital A: train model on local data โ†’ send only weights
  Hospital B: train model on local data โ†’ send only weights
  Hospital C: train model on local data โ†’ send only weights
  Central Server: aggregate weights โ†’ send updated model back

  โœ… Privacy benefit: Raw data never leaves hospital
  โœ… Compliance: Meets HIPAA, GDPR requirements
  โœ… Efficiency: Faster, less bandwidth

ALGORITHM (Federated Averaging - FedAvg):
1. Initialize global model weights wโ‚€ at server
2. For each round t:
   - Each hospital k:
     a) Download global weights wโ‚œ
     b) Train on local data โ†’ get updated weights w'โ‚–
     c) Send w'โ‚– to server (not the data!)
   - Server aggregates: wโ‚œโ‚Šโ‚ = (1/K) ฮฃ w'โ‚–
3. Repeat until convergence

BENEFITS:
  โ€ข Privacy: No raw data transmission
  โ€ข Compliance: Meet regulatory requirements
  โ€ข Efficiency: Reduce bandwidth & latency
  โ€ข Performance: Can rival centralized training dengan enough hospitals

CHALLENGES:
  โ€ข Non-IID data: Different hospitals have different patient populations
  โ€ข Communication: Multiple rounds needed untuk convergence
  โ€ข Debugging: Hard to diagnose issues across distributed systems
  โ€ข Synchronization: Need koordinate many hospitals
"""

print(federated_scenario)

print("\n" + "=" * 70)

12.6 Responsible AI Guidelines & Best Practices

12.6.1 Framework untuk Responsible AI

responsible_ai_framework = {
    'Fairness & Bias Mitigation': {
        'practices': [
            'Audit data untuk representation dari semua groups',
            'Use fairness metrics untuk evaluate trade-offs',
            'Implement bias mitigation strategies',
            'Monitor fairness metrics in production'
        ],
        'tools': ['Fairlearn', 'AIF360', 'What-if Tool']
    },
    'Transparency & Explainability': {
        'practices': [
            'Document model assumptions & limitations',
            'Use interpretable features when possible',
            'Provide explanations untuk important decisions',
            'Make code & methodology publicly available'
        ],
        'tools': ['LIME', 'SHAP', 'Google Cloud AI Explanations']
    },
    'Privacy & Security': {
        'practices': [
            'Minimize data collection',
            'Implement differential privacy',
            'Secure data storage & transmission',
            'Regular security audits'
        ],
        'tools': ['TensorFlow Privacy', 'Crypten', 'PyDP']
    },
    'Accountability & Governance': {
        'practices': [
            'Clear AI governance structure',
            'Regular model audits',
            'Impact assessments sebelum deployment',
            'Mechanism untuk user complaints'
        ],
        'tools': ['Model Cards', 'Datasheets for Datasets']
    },
    'Human-Centered Design': {
        'practices': [
            'Involve stakeholders dalam design',
            'Test dengan diverse users',
            'Consider contextual factors',
            'Plan untuk human oversight'
        ],
        'tools': ['User research', 'Fairness workshops']
    }
}

print("=" * 80)
print("๐ŸŽฏ RESPONSIBLE AI FRAMEWORK\n")

for pillar, details in responsible_ai_framework.items():
    print(f"\n{pillar}:")
    print("  Practices:")
    for practice in details['practices']:
        print(f"    โ€ข {practice}")
    print("  Tools:", ", ".join(details['tools']))

print("\n" + "=" * 80)

12.6.2 Model Cards untuk Dokumentasi

Model cards provide structured documentation untuk AI models:

model_card_template = """
MODEL CARD: Breast Cancer Diagnostic Model v1.0
================================================

1. MODEL DETAILS
   โ€ข Developer: Medical AI Lab
   โ€ข Model Type: Logistic Regression
   โ€ข Date: 2024-12-07
   โ€ข Purpose: Assist in breast cancer diagnosis

2. INTENDED USE
   โ€ข Intended Users: Radiologists, oncologists
   โ€ข Primary Use: Supplementary diagnostic tool (NOT replacement)
   โ€ข Out-of-scope Uses: Standalone diagnosis, prognostication

3. TRAINING DATA
   โ€ข Data Source: Wisconsin Diagnostic Breast Cancer (WDBC) dataset
   โ€ข Data Size: 569 samples
   โ€ข Features: 30 nuclei characteristics dari fine needle aspirate (FNA)
   โ€ข Demographics: Original dataset composition not documented
   โ€ข Time Period: Pre-2010

4. EVALUATION DATA
   โ€ข Test Set Size: 171 samples (30% of total)
   โ€ข Split Methodology: Random 70-30 split
   โ€ข Demographics: Not analyzed

5. PERFORMANCE METRICS
   Overall Accuracy: 0.965
   Sensitivity (TPR): 0.960
   Specificity (TNR): 0.968
   AUC-ROC: 0.972

6. FAIRNESS METRICS
   โš ๏ธ WARNING: Not evaluated for fairness!
   - No demographic breakdowns available
   - Model may have disparate impact on underrepresented groups
   - Recommended: Audit dengan diverse patient populations

7. LIMITATIONS & BIASES
   โ€ข Dataset tidak representative dari global population (US-centric)
   โ€ข Imbalanced classes (357 benign vs 212 malignant)
   โ€ข Missing demographic information untuk fairness evaluation
   โ€ข Model developed pada pre-2010 data; medical practices changed

8. ETHICAL CONSIDERATIONS
   โ€ข Risk: High false negative rate kรถnnte lead to delayed diagnoses
   โ€ข Risk: Model overconfidence might replace clinical judgment
   โ€ข Mitigation: Always use alongside human radiologist review
   โ€ข Mitigation: Regular performance monitoring

9. RECOMMENDATIONS
   โ€ข Always interpret alongside radiologist judgment
   โ€ข Do not use sebagai standalone diagnostic tool
   โ€ข Retrain quarterly dengan new patient data
   โ€ข Audit untuk fairness dengan diverse patient samples
   โ€ข Monitor for concept drift

10. CONTACT & SUPPORT
    โ€ข Technical Issues: ml-team@hospital.org
    โ€ข Ethical Concerns: ethics-board@hospital.org
    โ€ข Model Questions: models@hospital.org
"""

print(model_card_template)

12.7 AI Governance & Compliance

12.7.1 Regulatory Landscape

regulations = {
    'GDPR (EU General Data Protection Regulation)': {
        'year': 2018,
        'key_requirements': [
            'Right to explanation untuk automated decisions',
            'Data minimization (collect only necessary data)',
            'Purpose limitation (use data only untuk stated purposes)',
            'Legitimate basis untuk processing'
        ],
        'penalties': 'Up to 4% annual global turnover'
    },
    'AI Act (EU)': {
        'year': 2024,
        'key_requirements': [
            'High-risk AI systems require conformity assessment',
            'Transparency requirements (inform users)',
            'Bias monitoring & testing throughout lifecycle',
            'Human oversight para high-risk systems'
        ],
        'penalties': 'Up to 6% annual global turnover'
    },
    'US Executive Order 14110': {
        'year': 2023,
        'key_requirements': [
            'Federal agencies must impact assess AI systems',
            'Bias & fairness testing mandatory',
            'Privacy protections enhanced',
            'Transparency required untuk AI use'
        ],
        'penalties': 'Federal procurement restrictions'
    },
    'Algorithmic Accountability Act (Proposed US)': {
        'year': 'Proposed 2022+',
        'key_requirements': [
            'Documented impact assessments',
            'Fairness testing required',
            'Transparency about use',
            'Right untuk human review'
        ],
        'penalties': 'Under development'
    }
}

print("=" * 80)
print("โš–๏ธ REGULATORY REQUIREMENTS FOR AI SYSTEMS\n")

for regulation, details in regulations.items():
    print(f"\n{regulation} ({details['year']}):")
    print("  Key Requirements:")
    for req in details['key_requirements']:
        print(f"    โ€ข {req}")
    print(f"  Penalties: {details['penalties']}")

print("\n" + "=" * 80)

12.7.2 AI Governance Checklist

governance_checklist = """
โœ“ AI GOVERNANCE CHECKLIST

PRE-DEPLOYMENT PHASE:
  โ˜ Identify high-risk characteristics (protected groups, consequential decisions)
  โ˜ Conduct impact assessment (potential harms, affected stakeholders)
  โ˜ Define fairness objectives & metrics untuk your use case
  โ˜ Audit training data untuk bias & representation
  โ˜ Test model untuk disparate impact & fair outcomes
  โ˜ Document model limitations & failure modes
  โ˜ Prepare human oversight & escalation processes
  โ˜ Get stakeholder approval (ethics board, legal, domain experts)

DEPLOYMENT PHASE:
  โ˜ Implement monitoring untuk fairness metrics
  โ˜ Setup explainability untuk user-facing decisions
  โ˜ Create complaint mechanism untuk users
  โ˜ Train staff on responsible AI practices
  โ˜ Document deployment decisions & rationales
  โ˜ Setup data governance & access controls
  โ˜ Implement privacy protections (encryption, access logs)

OPERATIONAL PHASE:
  โ˜ Monitor fairness metrics regularly
  โ˜ Check untuk model drift & performance degradation
  โ˜ Audit decisions made by system
  โ˜ Gather feedback dari users & stakeholders
  โ˜ Respond to complaints promptly
  โ˜ Retrain model as needed
  โ˜ Update documentation dengan findings
  โ˜ Conduct annual fairness audit

POST-INCIDENT PHASE:
  โ˜ Investigate fairness issues thoroughly
  โ˜ Measure impact on affected individuals
  โ˜ Implement remediation measures
  โ˜ Communicate transparently dengan stakeholders
  โ˜ Update policies & practices to prevent recurrence
  โ˜ Document lessons learned
"""

print(governance_checklist)

12.8 Studi Kasus: Criminal Justice Risk Assessment

12.8.1 Case Study: COMPAS Algorithm

case_study = """
CASE STUDY: COMPAS Recidivism Algorithm

CONTEXT:
--------
COMPAS (Correctional Offender Management Profiling for Alternative Sanctions)
digunakan oleh US criminal justice system untuk:
  โ€ข Predict likelihood defendant akan reoffend
  โ€ข Inform bail decisions
  โ€ข Guide sentencing recommendations
  โ€ข Determine parole eligibility

DISCOVERED BIAS (ProPublica 2016):
----------------------------------
Investigation of 18,000+ criminal records found:

โ€ข White defendants dengan same criminal history โ†’ marked "low risk" more often
โ€ข Black defendants dengan same criminal history โ†’ marked "high risk" more often
โ€ข False positive rate (incorrectly marked high-risk): 45% untuk Blacks vs 23% untuk Whites
โ€ข False negative rate (incorrectly marked low-risk): 48% untuk Whites vs 28% untuk Blacks

IMPACT:
-------
โ€ข Thousands received longer sentences due to algorithmic bias
โ€ข Bail amounts higher for Black defendants (higher "risk")
โ€ข Parole denied untuk Black defendants (algorithm says high-risk)
โ€ข Perpetuated systemic racism dalam criminal justice

CONTRIBUTING FACTORS:
---------------------
1. TRAINING DATA BIAS:
   - Historical data reflected past discrimination
   - Criminal justice system already biased against Black individuals
   - Training data had more Black individuals arrested/convicted

2. PROXY VARIABLE PROBLEM:
   - Algorithm used "number of prior arrests" as feature
   - But arrests != guilt (police bias in enforcement)
   - Algorithm picked up proxy for race, not actual recidivism risk

3. FAIRNESS METRIC MISMATCH:
   - Company claimed system was "fair" (demographic parity)
   - But ProPublica showed error rates not equal (equalized odds violated)
   - Different definitions of fairness lead to conflicting conclusions

4. LACK OF TRANSPARENCY:
   - Proprietary algorithm (Northpointe Software)
   - Code not publicly available fรผr independent audit
   - Defendants couldn't understand why marked "high-risk"
   - Violated fairness principles

LESSONS LEARNED:
----------------
โœ“ Historical data carries historical bias
โœ“ Proxy variables can encode protected attributes
โœ“ Single fairness metric insufficient; must evaluate multiple metrics
โœ“ Transparency essential untuk high-stakes decisions
โœ“ Independent audits critical
โœ“ Domain experts must be involved

RECOMMENDATIONS:
----------------
1. Use only legally relevant features (not proxies fรผr protected attributes)
2. Evaluate fairness alongside accuracy
3. Make algorithms transparent & auditable
4. Involve affected communities รฎn design
5. Regular bias testing throughout system lifecycle
6. Human oversight remain essential
"""

print("=" * 80)
print(case_study)
print("=" * 80)

12.9 Praktik Terbaik: End-to-End Responsible AI Pipeline

Mari kita implementasikan complete responsible AI workflow:

Klik untuk melihat complete responsible AI pipeline 
import json
from datetime import datetime

class ResponsibleAIPipeline:
    """Complete workflow untuk responsible AI development"""

    def __init__(self, project_name, model_name):
        self.project_name = project_name
        self.model_name = model_name
        self.artifacts = {}
        self.timestamp = datetime.now().isoformat()

    def audit_dataset(self, X, y, protected_attr, name):
        """Audit dataset untuk bias & representation"""
        print(f"\n๐Ÿ“Š AUDITING DATASET: {name}")
        print("=" * 70)

        audit = {
            'dataset_name': name,
            'timestamp': self.timestamp,
            'size': len(X),
            'n_features': X.shape[1],
            'class_distribution': y.value_counts().to_dict(),
            'protected_attr_distribution': protected_attr.value_counts().to_dict()
        }

        # Check representation
        for val in protected_attr.unique():
            count = (protected_attr == val).sum()
            pct = count / len(protected_attr) * 100
            print(f"  Protected group {val}: {count} samples ({pct:.1f}%)")

        # Check class balance
        for label in y.unique():
            count = (y == label).sum()
            pct = count / len(y) * 100
            print(f"  Class {label}: {count} samples ({pct:.1f}%)")

        self.artifacts[f'audit_{name}'] = audit
        return audit

    def evaluate_fairness(self, y_true, y_pred, protected_attr):
        """Comprehensive fairness evaluation"""
        print(f"\nโš–๏ธ FAIRNESS EVALUATION")
        print("=" * 70)

        fairness_metrics = {}

        for group in np.unique(protected_attr):
            mask = protected_attr == group
            y_true_g = y_true[mask]
            y_pred_g = y_pred[mask]

            tn, fp, fn, tp = confusion_matrix(y_true_g, y_pred_g).ravel()

            metrics = {
                'tpr': tp / (tp + fn) if (tp + fn) > 0 else 0,
                'fpr': fp / (fp + tn) if (fp + tn) > 0 else 0,
                'accuracy': (tp + tn) / len(y_pred_g),
                'positive_rate': (tp + fp) / len(y_pred_g)
            }

            fairness_metrics[f'group_{group}'] = metrics

            print(f"\n  Group {group}:")
            print(f"    TPR (Sensitivity): {metrics['tpr']:.3f}")
            print(f"    FPR (Fall-out): {metrics['fpr']:.3f}")
            print(f"    Accuracy: {metrics['accuracy']:.3f}")
            print(f"    Positive Rate: {metrics['positive_rate']:.3f}")

        self.artifacts['fairness_metrics'] = fairness_metrics
        return fairness_metrics

    def generate_model_card(self, model_info, performance, fairness, limitations):
        """Generate standardized model card"""
        print(f"\n๐Ÿ“‹ MODEL CARD GENERATED")
        print("=" * 70)

        model_card = {
            'model_name': self.model_name,
            'project': self.project_name,
            'timestamp': self.timestamp,
            'model_info': model_info,
            'performance': performance,
            'fairness': fairness,
            'limitations': limitations,
            'recommendations': [
                'Regular fairness audits (monthly)',
                'Monitor fairness metrics รฎn production',
                'Retrain when fairness metrics degrade',
                'Maintain human oversight for important decisions',
                'Gather feedback from affected communities'
            ]
        }

        self.artifacts['model_card'] = model_card

        print(f"  Model: {model_card['model_name']}")
        print(f"  Project: {model_card['project']}")
        print(f"  Performance: Overall accuracy {performance.get('accuracy', 'N/A')}")
        print(f"  Fairness: Evaluated across {len(fairness)} groups")

        return model_card

    def save_artifacts(self, output_path):
        """Save all artifacts to file"""
        output_file = f"{output_path}/responsible_ai_report_{self.timestamp[:10]}.json"
        with open(output_file, 'w') as f:
            json.dump(self.artifacts, f, indent=2, default=str)
        print(f"\nโœ… Artifacts saved to {output_file}")

    def print_summary(self):
        """Print summary report"""
        print("\n" + "=" * 70)
        print("RESPONSIBLE AI PIPELINE SUMMARY")
        print("=" * 70)
        print(f"Project: {self.project_name}")
        print(f"Model: {self.model_name}")
        print(f"Artifacts Generated: {len(self.artifacts)}")
        for key in self.artifacts.keys():
            print(f"  โ€ข {key}")

# Example usage
print("\n" + "=" * 80)
print("๐Ÿš€ RESPONSIBLE AI PIPELINE DEMONSTRATION")
print("=" * 80)

pipeline = ResponsibleAIPipeline(
    project_name="Healthcare Diagnostic System",
    model_name="Breast Cancer Risk Assessment v1.0"
)

# Step 1: Audit dataset
audit = pipeline.audit_dataset(X_train, y_train, protected_train, "training_set")

# Step 2: Evaluate fairness
fairness = pipeline.evaluate_fairness(y_test, y_pred, protected_test)

# Step 3: Generate model card
model_card = pipeline.generate_model_card(
    model_info={
        'type': 'Logistic Regression',
        'features': len(X.columns),
        'classes': 2
    },
    performance={
        'accuracy': (y_pred == y_test).mean(),
        'auc': roc_auc_score(y_test, y_pred_proba)
    },
    fairness=fairness,
    limitations=[
        'Not evaluated for all demographic groups',
        'Small dataset (569 samples)',
        'Historical data may contain biases'
    ]
)

# Step 4: Summary
pipeline.print_summary()

print("\nโœจ Responsible AI Pipeline Complete!")
Best Practices Summary
  1. Data Audit: Always check data untuk representation & biases
  2. Fairness First: Define fairness objectives at project start
  3. Multiple Metrics: Evaluate using multiple fairness definitions
  4. Documentation: Create model cards, datasheets, and impact assessments
  5. Transparency: Explain decisions to users & stakeholders
  6. Monitoring: Track fairness metrics in production
  7. Human Oversight: Maintain human-in-the-loop para high-stakes decisions
  8. Iterate: Continuously improve fairness based on feedback

12.10 Refleksi & Aplikasi

Pertanyaan untuk Refleksi Kritis

  1. Ethical Dilemma: Sebuah hiring AI system achieves 95% accuracy namun dengan disparate impact on women (80% rule violated). Sebagai ML engineer, apa yang akan Anda lakukan?

  2. Fairness Trade-offs: Meningkatkan fairness sering menurunkan overall accuracy. Bagaimana Anda mengkomunikasikan trade-off ini ke business stakeholders?

  3. Cybersecurity Context: Bagaimana bias dalam security AI (malware detection, intrusion detection) bisa membuat sistem lebih vulnerable terhadap adversarial attacks?

  4. Privacy vs Fairness: Differential privacy adds noise untuk protect individual privacy, namun ini also degrades model accuracy. Bagaimana balance kedua concerns?

๐Ÿ“š Ringkasan (Summary)

Konsep Kunci:

  • Bias dalam AI bersumber dari data, preprocessing, training, dan deployment
  • Fairness memiliki multiple definitions; pilih yang sesuai use case Anda
  • Explainability essential untuk transparency dan compliance
  • Privacy-preserving ML seperti differential privacy dan federated learning essential
  • Responsible AI governance requires organizational commitment dan continuous monitoring

Aplikasi Praktis:

  • Audit datasets untuk bias dan underrepresentation
  • Evaluate models menggunakan multiple fairness metrics
  • Implement explainability tools (LIME, SHAP) untuk user-facing decisions
  • Monitor fairness metrics dalam production systems
  • Create model cards dan impact assessments

๐Ÿงช Latihan & Tugas (Exercises)

Soal Latihan

Pertanyaan Konseptual:

  1. Jelaskan perbedaan antara demographic parity dan equalized odds. Dalam konteks apa setiap definition lebih appropriate?

  2. Bagaimana historical bias dalam data bisa perpetuate sistem discrimination? Berikan contoh real-world.

  3. Mengapa explainability penting untuk fairness? Bagaimana interpretable models membantu detect dan fix bias?

  4. Jelaskan bagaimana differential privacy works dan trade-off antara privacy dan accuracy.

  5. Apa itu โ€œright to explanationโ€ dalam GDPR? Bagaimana ini mempengaruhi design dari AI systems?

Tugas Praktikum:

  1. Bias Audit Assignment
    • Input: Labeled dataset dengan protected attribute
    • Output: Comprehensive bias audit report
    • Rubric:
      • Data analysis (30%)
      • Bias detection (40%)
      • Recommendations (30%)
  2. Fairness Mitigation Project
    • Train classification model pada biased dataset
    • Apply fairness constraint (threshold optimization atau re-weighting)
    • Compare metrics before/after mitigation
    • Analyze accuracy-fairness trade-off
    • Report findings (2-3 pages)
  3. Model Card Creation
    • Choose pre-trained ML model
    • Research its training data, limitations, known issues
    • Create comprehensive model card (section 12.6.2 template)
    • Identify potential fairness concerns
    • Propose mitigation strategies
  4. Case Study Analysis
    • Choose real AI ethics case (Amazon hiring, COMPAS, facial recognition, etc)
    • Analyze: What went wrong? Where was bias introduced?
    • Impact: Who was harmed? What was the scope?
    • Solutions: How could it been prevented?
    • Write 3-4 page critical analysis
  5. Privacy-Preserving ML Implementation
    • Implement differential privacy dalam training (TensorFlow Privacy or PyDP)
    • Experiment dengan different epsilon values
    • Measure trade-off antara privacy dan model accuracy
    • Report findings dalam 2-page technical report

๐Ÿ“– Referensi & Bacaan Lebih Lanjut

Buku:

  • Barocas, Hardt & Narayanan (2023). โ€œFairness and Machine Learningโ€. fairmlbook.org - Comprehensive textbook on ML fairness
  • Oโ€™Reilly (2020). โ€œResponsible Machine Learningโ€. - Practical guide untuk responsible AI development
  • Mitchell et al. (2019). โ€œModel Cards for Model Reportingโ€. arxiv.org/abs/1810.03993

Papers/Research:

  • Buolamwini & Buolamwini (2018). โ€œGender Shadesโ€. gendershades.org - Seminal work on facial recognition bias
  • ProPublica (2016). โ€œMachine Biasโ€. - Investigation of COMPAS algorithm
  • Dwork (2006). โ€œDifferential Privacyโ€. arxiv.org/abs/cs/0610027

Tools & Libraries:

  • Fairlearn - Microsoftโ€™s fairness & accountability tools
  • AIF360 - IBMโ€™s algorithmic fairness toolkit
  • LIME - Local interpretable explanations
  • SHAP - Shapley-based feature importance
  • TensorFlow Privacy - Differential privacy implementation

Online Resources:

Hubungan dengan Learning Outcomes Program

CPMK Sub-CPMK Tercakup
CPMK-3 (Evaluate) Evaluate ethical implications dari ML systems โœ“
CPMK-5 (Create) Create fairness metrics & mitigation strategies โœ“

Related Labs: Lab 7 (Application Security) - Bias sebagai security vulnerability Related Chapters: Chapter 6 (Keamanan Jaringan), Chapter 7 (Keamanan Aplikasi) Estimated Reading Time: 45 minutes Estimated Practice Time: 8-10 hours

Last Updated: 2024-12-07 Version: 1.0 Status: โœ… Chapter 12 Complete Word Count: ~2100 words