Federated Learning Integration

Integrate Oneliac's federated learning coordinator to train diagnosis models across multiple healthcare organizations while maintaining data privacy.

Overview

Federated learning enables model training on encrypted data from multiple organizations without centralizing sensitive patient information.

Architecture

Healthcare Org A          Healthcare Org B          Healthcare Org C
     ↓                         ↓                          ↓
  Local Data             Local Data                  Local Data
     ↓                         ↓                          ↓
 Encrypt Data           Encrypt Data               Encrypt Data
     ↓                         ↓                          ↓
Train Local Model      Train Local Model          Train Local Model
     ↓                         ↓                          ↓
Generate Gradients     Generate Gradients        Generate Gradients
     ↓                         ↓                          ↓
  Federated Aggregation (No raw data exposed)
     ↓
Global Model Update

API Endpoints

Register Organization

POST /api/v1/federated/organizations

Request:

{
  "organization_name": "Hospital A",
  "endpoint": "https://hospital-a.com/federated",
  "encryption_key": "key_abc123"
}

Submit Local Gradients

POST /api/v1/federated/gradients

Request:

{
  "organization_id": "org_123",
  "round": 1,
  "gradients_encrypted": "0x...",
  "model_version": "1.0.0",
  "sample_count": 1000
}

Download Global Model

GET /api/v1/federated/model

Response:

{
  "model_version": "1.0.0",
  "weights": "0x...",
  "accuracy": 0.92,
  "organizations_contributed": 3,
  "training_round": 5
}

Implementation Example

from oneliac.federated import FederatedLearner
from oneliac.encryption import DifferentialPrivacy

learner = FederatedLearner(
    organization_id="org_123",
    api_key="sk_live_..."
)

# Load local training data
local_data = load_patient_data(confidential=True)

# Train local model
model = learner.train_local(
    data=local_data,
    epochs=10,
    batch_size=32
)

# Add differential privacy noise
dp = DifferentialPrivacy(epsilon=0.1)
encrypted_gradients = dp.add_noise_to_gradients(
    model.gradients,
    sensitivity=1.0
)

# Submit to federated server
learner.submit_gradients(
    gradients=encrypted_gradients,
    round=5
)

# Download global model
global_model = learner.download_model(version="latest")

Configuration

Differential Privacy Parameters

privacy_budget = {
    "epsilon": 0.1,      # Privacy budget
    "delta": 1e-5,       # Failure probability
    "mechanism": "gaussian"
}

Aggregation Settings

aggregation_config = {
    "min_participants": 3,
    "aggregation_method": "secure_sum",
    "timeout_minutes": 30,
    "max_rounds": 100
}

Validation

Model Quality Checks

validation_results = learner.validate_submission(
    gradients=encrypted_gradients,
    checks=[
        "bounds_check",
        "nan_check",
        "privacy_check"
    ]
)

Privacy Metrics

Monitor privacy guarantees:

privacy_report = learner.get_privacy_report(round=5)
print(f"Cumulative epsilon: {privacy_report.total_epsilon}")
print(f"Organizations contributed: {privacy_report.participants}")

Best Practices

1. Data Minimization: Only include necessary features
2. Regular Audits: Verify model fairness across organizations
3. Version Control: Track model versions across rounds
4. Monitoring: Track convergence and model accuracy
5. Communication: Use secure channels for all transmissions

Troubleshooting

Gradient Submission Fails

Check privacy budget hasn't been exceeded:

current_epsilon = learner.get_current_epsilon()
if current_epsilon > max_epsilon:
    print("Privacy budget exhausted")

Model Divergence

Review local data distribution:

data_stats = learner.analyze_local_data()
print(f"Label distribution: {data_stats.label_distribution}")