Training-Time Fairness Interventions

# Scikit-learn compatible approach
from sklearn.ensemble import RandomForestClassifier
from vfairness.in_processing import FairClassifier

clf = FairClassifier(
    base_estimator=RandomForestClassifier(),
    fairness_constraint='demographic_parity',
    tolerance=0.05
)
clf.fit(X_train, y_train, sensitive_attr=gender)
y_pred = clf.predict(X_test)
print(f"Constraint satisfied: {clf.fairness_result_.constraint_satisfied}")

L_total = L_task + λ * L_fairness

import torch
from vfairness.in_processing.loss_functions import DemographicParityLoss

# Create loss function
loss_fn = DemographicParityLoss(
    lambda_fairness=0.1,  # Trade-off parameter
    warmup_epochs=5       # Epochs before applying fairness penalty
)

# Training loop
model = YourModel()
optimizer = torch.optim.Adam(model.parameters())

for epoch in range(num_epochs):
    loss_fn.set_epoch(epoch)

    for x, y, sensitive_attr in dataloader:
        optimizer.zero_grad()

        # Forward pass
        y_pred = torch.sigmoid(model(x))

        # Compute fairness-aware loss
        loss = loss_fn(y_pred, y, sensitive_attr)

        # Backward pass
        loss.backward()
        optimizer.step()

    # End of epoch tracking
    metrics = loss_fn.end_epoch()
    print(f"Epoch {epoch}: Loss={metrics.avg_total_loss:.4f}")

from vfairness.in_processing.loss_functions import EqualizedOddsLoss

loss_fn = EqualizedOddsLoss(
    lambda_fairness=0.15,
    tpr_weight=1.0,    # Weight for TPR component
    fpr_weight=0.5,    # Weight for FPR component
)

from vfairness.in_processing.loss_functions import AdversarialDebiasingLoss

loss_fn = AdversarialDebiasingLoss(
    lambda_fairness=1.0,
    adversary_hidden_dims=[64, 32],
    n_groups=2,
    use_gradient_reversal=True
)

# Move to GPU if available
loss_fn = loss_fn.to(device)

# Training loop
for x, y, sensitive_attr in dataloader:
    y_pred = torch.sigmoid(model(x))

    # Main model loss (includes adversarial penalty)
    loss = loss_fn(y_pred, y, sensitive_attr)
    loss.backward()
    optimizer.step()

    # Monitor adversary accuracy (lower is more fair)
    adv_acc = loss_fn.get_adversary_accuracy(y_pred.detach(), sensitive_attr)

from sklearn.linear_model import LogisticRegression
from vfairness.in_processing.constraints import (
    ExponentiatedGradient,
    DemographicParityConstraint,
)

# Create constraint
constraint = DemographicParityConstraint(tolerance=0.05)

# Create algorithm
eg = ExponentiatedGradient(
    base_estimator=LogisticRegression(),
    constraint=constraint,
    max_iterations=50,
    verbose=True
)

# Fit
result = eg.fit(X_train, y_train, sensitive_attr=gender)

# Predict
y_pred = eg.predict(X_test)

# Check results
print(f"Accuracy: {result.accuracy:.4f}")
print(f"Violation: {result.final_violation:.4f}")
print(f"Satisfied: {result.optimization_result.converged}")

from sklearn.ensemble import RandomForestClassifier
from vfairness.in_processing.constraints import (
    ThresholdOptimizer,
    EqualOpportunityConstraint,
)

# First train a standard classifier
base_clf = RandomForestClassifier()
base_clf.fit(X_train, y_train)

# Get probabilities
y_prob_val = base_clf.predict_proba(X_val)[:, 1]

# Optimize thresholds for fairness
optimizer = ThresholdOptimizer(
    constraint=EqualOpportunityConstraint(tolerance=0.05),
    grid_size=100
)
optimizer.fit(y_prob_val, y_val, sensitive_attr=gender_val)

# Apply to test data
y_prob_test = base_clf.predict_proba(X_test)[:, 1]
y_pred_fair = optimizer.predict(y_prob_test, gender_test)

# Get the learned thresholds
print("Thresholds per group:", optimizer.get_thresholds())

total_loss = task_loss + regularizer(y_pred, sensitive_attr)

from vfairness.in_processing.regularizers import StatisticalParityRegularizer

regularizer = StatisticalParityRegularizer(strength=0.1)

# In training loop
for x, y, sensitive_attr in dataloader:
    y_pred = torch.sigmoid(model(x))

    # Task loss
    task_loss = F.binary_cross_entropy(y_pred, y)

    # Fairness penalty
    fairness_penalty = regularizer(y_pred, sensitive_attr)

    # Combined loss
    total_loss = task_loss + fairness_penalty
    total_loss.backward()

from vfairness.in_processing.regularizers import HilbertSchmidtRegularizer

regularizer = HilbertSchmidtRegularizer(
    strength=0.1,
    kernel='rbf',
    sigma=1.0
)

# HSIC captures non-linear statistical dependence
penalty = regularizer(y_pred, sensitive_attr)

from vfairness.in_processing.calibrators import (
    TrainableGroupCalibrator,
    CalibrationAwareTrainer,
)

# Create calibrator
calibrator = TrainableGroupCalibrator(
    n_groups=2,
    method='temperature',
    learnable=True
)

# Integrate with model training
trainer = CalibrationAwareTrainer(model, calibrator)

# Training step
losses = trainer.train_step(
    x, y, group_ids,
    optimizer,
    task_loss_fn=F.cross_entropy,
    include_calibration=True
)

print(f"Task loss: {losses['task_loss']:.4f}")
print(f"Calibration loss: {losses['calibration_loss']:.4f}")

from sklearn.ensemble import RandomForestClassifier
from vfairness.in_processing.wrappers import FairClassifier

# Create fair classifier
clf = FairClassifier(
    base_estimator=RandomForestClassifier(n_estimators=100),
    fairness_constraint='equalized_odds',
    tolerance=0.05,
    method='reductions'  # or 'threshold', 'grid_search'
)

# Fit (requires sensitive_attr)
clf.fit(X_train, y_train, sensitive_attr=gender)

# Predict
y_pred = clf.predict(X_test)

# Check fairness results
print(f"Accuracy: {clf.fairness_result_.accuracy:.4f}")
print(f"Violation: {clf.fairness_result_.fairness_violation:.4f}")
print(f"Satisfied: {clf.fairness_result_.constraint_satisfied}")

from sklearn.linear_model import Ridge
from vfairness.in_processing.wrappers import FairRegressor

reg = FairRegressor(
    base_estimator=Ridge(),
    fairness_constraint='mean_parity',
    tolerance=0.1
)

reg.fit(X_train, y_train, sensitive_attr=group)
y_pred = reg.predict(X_test)

from sklearn.linear_model import LogisticRegression
from vfairness.in_processing import FairnessTrainingAnalyzer

# Create analyzer
analyzer = FairnessTrainingAnalyzer(
    X=X_train, y=y_train, sensitive_attr=gender,
    fairness_constraint='demographic_parity',
    tolerance=0.05
)

# Full analysis
report = analyzer.full_analysis(
    base_estimator=LogisticRegression(),
    include_comparisons=True,
    include_tradeoffs=True
)

# Print summary
print(report.summary())

# Export to JSON
report.to_json('training_analysis.json')

# Render as SVG
report.to_svg('training_report.svg')

loss_fn = DemographicParityLoss(
    lambda_fairness=0.1,
    warmup_epochs=5  # No fairness penalty for first 5 epochs
)

# After each epoch
metrics = loss_fn.end_epoch()
print(f"Epoch {epoch}")
print(f"  Task Loss: {metrics.avg_task_loss:.4f}")
print(f"  Fairness Loss: {metrics.avg_fairness_loss:.4f}")
print(f"  Total Loss: {metrics.avg_total_loss:.4f}")

min_θ max_λ≥0 L(θ) + Σᵢ λᵢ * gᵢ(θ)

TPR_soft = E[ŷ | y=1] ≈ mean(ŷ[y==1])

FPR_soft = E[ŷ | y=0] ≈ mean(ŷ[y==0])

┌─────────────────────────────────────────────────────────────────────┐
│                        vfairness Pipeline                           │
├─────────────────────────────────────────────────────────────────────┤
│  1. PRE-PROCESSING         │  Bias Detection & Feature Engineering │
│  ─────────────────────────────────────────────────────────────────  │
│  2. IN-PROCESSING  ←──────── This module (training interventions)  │
│  ─────────────────────────────────────────────────────────────────  │
│  3. POST-PROCESSING        │  Calibration & Threshold Adjustment   │
│  ─────────────────────────────────────────────────────────────────  │
│  4. EVALUATION             │  Fairness Metrics & Auditing          │
│  ─────────────────────────────────────────────────────────────────  │
│  5. CI/CD INTEGRATION      │  Automated Fairness Testing           │
└─────────────────────────────────────────────────────────────────────┘

from vfairness.preprocessing.bias_detection import BiasDetector
from vfairness.in_processing import FairClassifier, FairnessTrainingAnalyzer
from vfairness.evaluation import FairnessAnalyzer

# 1. Pre-processing: Detect bias
detector = BiasDetector(df, protected_attributes=["gender"], outcome_column="approved")
audit_report = detector.full_audit()

# 2. In-processing: Fair training
clf = FairClassifier(
    base_estimator=LogisticRegression(),
    fairness_constraint='demographic_parity'
)
clf.fit(X_train, y_train, sensitive_attr=gender_train)

# 3. Evaluation: Assess fairness
y_pred = clf.predict(X_test)
evaluator = FairnessAnalyzer(y_test, y_pred, sensitive_attr=gender_test)
eval_report = evaluator.get_report(include_ci=True)
print(eval_report["metrics"])