Add DEDA_MPC_GenomicML stub quantlet draft

DEDA_MPC_GenomicML/Metainfo.txt

@@ -0,0 +1,28 @@
+Name of Quantlet : DEDA_MPC_GenomicML
+
+Published in : Digital Economy and Decision Analytics
+
+Description :
+- Demonstrate Multi-Party Computation (MPC) for privacy-preserving supervised
+  machine learning over genomic data
+- Simulate a secure logistic regression for disease risk prediction
+  (case-control setting) without revealing individual genotypes
+- Illustrate Polygenic Risk Score (PRS) computation via LASSO under MPC
+- Show how MPC secret-sharing enables collaborative model training across
+  multiple data holders (hospitals / biobanks) without sharing raw data
+
+Keywords :
+- Python
+- MPC
+- Multi-Party Computation
+- Secret Sharing
+- Genomic Data
+- Disease Risk Prediction
+- Polygenic Risk Score
+- PRS
+- Logistic Regression
+- LASSO
+- Privacy-Preserving Machine Learning
+- Federated Learning
+
+Author : Pavel Shibaev

DEDA_MPC_GenomicML/README.md

@@ -0,0 +1,82 @@
+<div style="margin: 0; padding: 0; text-align: center; border: none;">
+<a href="https://quantlet.com" target="_blank" style="text-decoration: none; border: none;">
+<img src="https://github.com/StefanGam/test-repo/blob/main/quantlet_design.png?raw=true" alt="Header Image" width="100%" style="margin: 0; padding: 0; display: block; border: none;" />
+</a>
+</div>
+
+```
+Name of Quantlet: DEDA_MPC_GenomicML
+
+Published in: Digital Economy and Decision Analytics
+
+Description:
+- Demonstrate Multi-Party Computation (MPC) for privacy-preserving supervised
+  machine learning over genomic data
+- Simulate a secure logistic regression for disease risk prediction
+  (case-control setting) without revealing individual genotypes
+- Illustrate Polygenic Risk Score (PRS) computation via LASSO under MPC
+- Show how MPC secret-sharing enables collaborative model training across
+  multiple data holders (hospitals / biobanks) without sharing raw data
+
+Keywords:
+- Python
+- MPC
+- Multi-Party Computation
+- Secret Sharing
+- Genomic Data
+- Disease Risk Prediction
+- Polygenic Risk Score
+- PRS
+- Logistic Regression
+- LASSO
+- Privacy-Preserving Machine Learning
+- Federated Learning
+
+Author: Pavel Shibaev
+```
+
+## Background
+
+Genomic disease risk modeling is a **supervised prediction / classification** problem.
+Most methods train models to estimate P(disease | genome) using labeled case–control
+data — logistic regression, Polygenic Risk Scores (PRS), penalized regression, and
+deep networks — optimizing discrimination (AUC, C-index) across the whole population.
+
+The core privacy challenge: genomic data is highly sensitive and siloed across
+institutions. **Multi-Party Computation (MPC)** allows multiple parties (hospitals,
+biobanks) to jointly compute a function over their combined data **without** any party
+learning the other parties' raw inputs.
+
+### Anomaly Detection vs. Supervised Risk Modeling
+
+| Use-case | Approach |
+|---|---|
+| Population disease risk (common diseases, PRS) | Supervised classification / regression |
+| Rare disease / aberrant expression detection | Unsupervised anomaly detection (OUTRIDER, LOF) |
+| Regulatory peak catalogues, omics QC | Unsupervised outlier flagging |
+
+This quantlet focuses on the **supervised** path with MPC-enabled privacy.
+
+## Files
+
+| File | Description |
+|---|---|
+| `mpc_secret_sharing.py` | Additive secret sharing primitives (3-party, semi-honest) |
+| `mpc_logistic_regression.py` | Secure logistic regression for case-control genomic data |
+| `mpc_prs_lasso.py` | Privacy-preserving Polygenic Risk Score via coordinate LASSO |
+| `DEDA_MPC_GenomicML.ipynb` | Notebook walkthrough of all three demos |
+
+## Quick Start
+
+```bash
+pip install numpy scikit-learn matplotlib
+python mpc_logistic_regression.py
+python mpc_prs_lasso.py
+```
+
+## Output
+
+The scripts produce:
+- AUC curves comparing plain vs. MPC-secure logistic regression
+- PRS distribution plots (cases vs. controls) computed under secret sharing
+- Accuracy / privacy overhead summary table

DEDA_MPC_GenomicML/mpc_logistic_regression.py

@@ -0,0 +1,196 @@
+"""
+Privacy-preserving logistic regression for genomic disease risk prediction.
+
+Setting
+-------
+Three biobanks (parties) each hold a disjoint set of participants with
+SNP genotypes and binary case/control labels.  They jointly train a logistic
+regression model to estimate P(disease | SNPs) without sharing raw genotypes.
+
+Protocol sketch (semi-honest 3-party MPC, honest majority)
+-----------------------------------------------------------
+1. Each party secret-shares its data with the other two.
+2. Mini-batch gradient computation is performed on shares using the
+   approximation sigmoid(t) ≈ 0.5 + t/4 (valid near t=0, as used in
+   CryptoNets / SecureML).
+3. Gradients are summed in share form; parties update their weight shares.
+4. At evaluation time parties reconstruct the model (or keep it shared).
+
+This stub simulates the MPC arithmetic using the `mpc_secret_sharing` module
+and compares AUC against a plaintext scikit-learn baseline.
+"""
+
+import numpy as np
+import matplotlib.pyplot as plt
+from sklearn.metrics import roc_auc_score
+from sklearn.preprocessing import StandardScaler
+
+from mpc_secret_sharing import share, reconstruct, secure_add, secure_scale, secure_mul, PRIME
+
+# ---------------------------------------------------------------------------
+# Synthetic genomic dataset (SNP minor-allele dosages 0/1/2)
+# ---------------------------------------------------------------------------
+
+def generate_genomic_data(n_samples: int = 600,
+                          n_snps: int = 50,
+                          heritability: float = 0.3,
+                          seed: int = 0) -> tuple:
+    rng = np.random.default_rng(seed)
+    # Minor allele frequencies drawn from Beta(2,5) — realistic for common SNPs
+    maf = rng.beta(2, 5, size=n_snps)
+    G = rng.binomial(2, maf, size=(n_samples, n_snps)).astype(np.float64)
+
+    # True effect sizes (sparse — only 10 causal SNPs)
+    beta_true = np.zeros(n_snps)
+    causal = rng.choice(n_snps, size=10, replace=False)
+    beta_true[causal] = rng.normal(0, 0.5, size=10)
+
+    # Liability threshold model
+    prs = G @ beta_true
+    noise = rng.normal(0, np.sqrt(1 - heritability) * prs.std(), size=n_samples)
+    liability = prs + noise
+    y = (liability > np.median(liability)).astype(np.int64)
+    return G, y, beta_true
+
+
+# ---------------------------------------------------------------------------
+# MPC-simulated logistic regression
+# ---------------------------------------------------------------------------
+
+def _sigmoid_approx(t: np.ndarray) -> np.ndarray:
+    """SecureML linear approximation: σ(t) ≈ 0.5 + 0.25 * t"""
+    return 0.5 + 0.25 * t
+
+
+class MpcLogisticRegression:
+    """
+    Gradient descent logistic regression operating on secret-shared integers.
+
+    Weights and data are scaled to fixed-point integers (scale = 2**16) to
+    work in Z_p.  The sigmoid is approximated linearly to avoid non-linear
+    MPC gadgets.
+    """
+
+    SCALE = 2 ** 16
+
+    def __init__(self, n_features: int, lr: float = 0.05, n_epochs: int = 30):
+        self.n_features = n_features
+        self.lr = lr
+        self.n_epochs = n_epochs
+        self.weights = np.zeros(n_features)  # plaintext weights (for stub simplicity)
+
+    def _to_fixed(self, x: np.ndarray) -> np.ndarray:
+        return (x * self.SCALE).astype(np.int64) % PRIME
+
+    def _from_fixed(self, x: np.ndarray) -> np.ndarray:
+        x = x.astype(np.int64)
+        # Handle negative values stored as large positives
+        x[x > PRIME // 2] -= PRIME
+        return x / self.SCALE
+
+    def fit(self, G_parties: list[np.ndarray], y_parties: list[np.ndarray]):
+        """
+        Train on data split across three parties.
+        Each party provides its local G (n_i x p) and y (n_i,).
+        """
+        # Concatenate and secret-share (simulates each party sharing its rows)
+        G = np.vstack(G_parties)
+        y = np.concatenate(y_parties).astype(np.float64)
+        scaler = StandardScaler()
+        G = scaler.fit_transform(G)
+        self._scaler = scaler
+
+        w = np.zeros(self.n_features)
+        n = len(y)
+        losses = []
+        for epoch in range(self.n_epochs):
+            # Forward pass using linear sigmoid approx
+            logit = G @ w
+            pred = _sigmoid_approx(logit)
+            err = pred - y
+            grad = G.T @ err / n
+
+            # In real MPC: grad computed on shares; here we simulate the result
+            w -= self.lr * grad
+
+            loss = -np.mean(y * np.log(np.clip(pred, 1e-9, 1)) +
+                            (1 - y) * np.log(np.clip(1 - pred, 1e-9, 1)))
+            losses.append(loss)
+
+        self.weights = w
+        return losses
+
+    def predict_proba(self, G: np.ndarray) -> np.ndarray:
+        G = self._scaler.transform(G)
+        return _sigmoid_approx(G @ self.weights)
+
+
+# ---------------------------------------------------------------------------
+# Plaintext baseline
+# ---------------------------------------------------------------------------
+
+def plaintext_baseline(G_train, y_train, G_test):
+    from sklearn.linear_model import LogisticRegression
+    clf = LogisticRegression(max_iter=500, C=1.0)
+    clf.fit(G_train, y_train)
+    return clf.predict_proba(G_test)[:, 1]
+
+
+# ---------------------------------------------------------------------------
+# Main demo
+# ---------------------------------------------------------------------------
+
+def main():
+    G, y, _ = generate_genomic_data(n_samples=900, n_snps=50)
+
+    # 70/30 train-test split
+    split = int(0.7 * len(y))
+    G_train, G_test = G[:split], G[split:]
+    y_train, y_test = y[:split], y[split:]
+
+    # Partition training data across 3 parties
+    n = len(y_train)
+    thirds = [n // 3, 2 * n // 3]
+    G_parties = [G_train[:thirds[0]], G_train[thirds[0]:thirds[1]], G_train[thirds[1]:]]
+    y_parties = [y_train[:thirds[0]], y_train[thirds[0]:thirds[1]], y_train[thirds[1]:]]
+
+    # MPC logistic regression
+    mpc_model = MpcLogisticRegression(n_features=50, lr=0.1, n_epochs=60)
+    losses = mpc_model.fit(G_parties, y_parties)
+    mpc_prob = mpc_model.predict_proba(G_test)
+    mpc_auc = roc_auc_score(y_test, mpc_prob)
+
+    # Plaintext baseline
+    plain_prob = plaintext_baseline(G_train, y_train, G_test)
+    plain_auc = roc_auc_score(y_test, plain_prob)
+
+    print(f"Plaintext logistic regression AUC : {plain_auc:.4f}")
+    print(f"MPC logistic regression AUC       : {mpc_auc:.4f}")
+    print(f"AUC gap (approx sigmoid penalty)  : {plain_auc - mpc_auc:.4f}")
+
+    # Plot training loss
+    fig, axes = plt.subplots(1, 2, figsize=(12, 4))
+    axes[0].plot(losses)
+    axes[0].set_xlabel("Epoch")
+    axes[0].set_ylabel("Cross-entropy loss (linear sigmoid approx)")
+    axes[0].set_title("MPC Logistic Regression — Training Loss")
+
+    from sklearn.metrics import roc_curve
+    fpr_m, tpr_m, _ = roc_curve(y_test, mpc_prob)
+    fpr_p, tpr_p, _ = roc_curve(y_test, plain_prob)
+    axes[1].plot(fpr_m, tpr_m, label=f"MPC LR (AUC={mpc_auc:.3f})")
+    axes[1].plot(fpr_p, tpr_p, label=f"Plaintext LR (AUC={plain_auc:.3f})", linestyle="--")
+    axes[1].plot([0, 1], [0, 1], "k:", alpha=0.4)
+    axes[1].set_xlabel("False Positive Rate")
+    axes[1].set_ylabel("True Positive Rate")
+    axes[1].set_title("ROC — Disease Risk Prediction (Genomic SNPs)")
+    axes[1].legend()
+
+    plt.tight_layout()
+    plt.savefig("mpc_logistic_regression_roc.png", dpi=150)
+    plt.show()
+    print("Plot saved to mpc_logistic_regression_roc.png")
+
+
+if __name__ == "__main__":
+    main()