| import os, json, math, numpy as np, pandas as pd, torch, torch.nn as nn |
| from pathlib import Path |
| from sklearn.metrics import roc_auc_score, average_precision_score, brier_score_loss |
| from sklearn.calibration import calibration_curve |
| from sklearn.model_selection import train_test_split |
| import matplotlib.pyplot as plt |
|
|
| DEVICE = "cuda" if torch.cuda.is_available() else "cpu" |
| PROC = Path("data/processed"); RES = Path("results"); RES.mkdir(parents=True, exist_ok=True) |
|
|
| P = pd.read_csv(PROC/"protein.csv") |
| L = pd.read_csv(PROC/"ligand.csv") |
| Y = pd.read_csv(PROC/"labels.csv") |
|
|
| def is_ethanol(s): return isinstance(s,str) and ("etoh" in s.lower() or "ethanol" in s.lower()) |
| def is_oxid(s): return isinstance(s,str) and ("h2o2" in s.lower() or "oxid" in s.lower()) |
|
|
| Y["is_ethanol"] = Y["condition"].map(is_ethanol).fillna(False) |
| Y["is_oxidative"] = Y["condition"].map(is_oxid).fillna(False) |
|
|
| pcols = [c for c in P.columns if c!="transporter"] |
| lcols = [c for c in L.columns if c.startswith("d")] |
|
|
| P_map = {r.transporter: r[pcols].to_numpy(dtype=np.float32) for _,r in P.iterrows()} |
| L_map = {r.compound: r[lcols].to_numpy(dtype=np.float32) for _,r in L.iterrows()} |
|
|
| def make_Xy(df_pairs): |
| keep = df_pairs["transporter"].isin(P_map.keys()) & df_pairs["compound"].isin(L_map.keys()) |
| df = df_pairs.loc[keep].copy() |
| X = np.stack([np.concatenate([P_map[t], L_map[c]]) for t,c in zip(df.transporter, df.compound)]).astype(np.float32) |
| y = df["y"].astype(np.float32).to_numpy() |
| return X, y, df |
|
|
| class MLP(nn.Module): |
| def __init__(self, in_dim): |
| super().__init__() |
| self.net = nn.Sequential( |
| nn.Linear(in_dim, 512), nn.ReLU(), nn.Dropout(0.2), |
| nn.Linear(512, 128), nn.ReLU(), nn.Dropout(0.2), |
| nn.Linear(128, 1) |
| ) |
| def forward(self, x): return self.net(x).squeeze(-1) |
|
|
| def fit_mlp(Xtr, ytr, Xva, yva, max_epochs=50, bs=512, lr=1e-3, patience=6): |
| Xtr=torch.from_numpy(Xtr).to(DEVICE); ytr=torch.from_numpy(ytr).to(DEVICE) |
| Xva=torch.from_numpy(Xva).to(DEVICE); yva=torch.from_numpy(yva).to(DEVICE) |
| model = MLP(Xtr.shape[1]).to(DEVICE) |
| opt = torch.optim.AdamW(model.parameters(), lr=lr, weight_decay=1e-4) |
| bce = nn.BCEWithLogitsLoss() |
| best, best_state, bad= 1e9, None, 0 |
| for ep in range(max_epochs): |
| model.train() |
| perm = torch.randperm(len(Xtr), device=DEVICE) |
| for i in range(0, len(Xtr), bs): |
| idx = perm[i:i+bs] |
| logits = model(Xtr[idx]) |
| loss = bce(logits, ytr[idx]) |
| opt.zero_grad(); loss.backward(); opt.step() |
| |
| model.eval() |
| with torch.no_grad(): |
| val = bce(model(Xva), yva).item() |
| if val < best - 1e-4: |
| best, best_state, bad = val, {k:v.detach().cpu() for k,v in model.state_dict().items()}, 0 |
| else: |
| bad += 1 |
| if bad >= patience: break |
| model.load_state_dict({k:v.to(DEVICE) for k,v in best_state.items()}) |
| model.eval() |
| return model |
|
|
| def evaluate(model, Xte, yte, tag, out_prefix): |
| Xte_t = torch.from_numpy(Xte).to(DEVICE) |
| with torch.no_grad(): p = torch.sigmoid(model(Xte_t)).cpu().numpy() |
| auroc = roc_auc_score(yte, p) if len(np.unique(yte))>1 else np.nan |
| auprc = average_precision_score(yte, p) |
| brier = brier_score_loss(yte, p) |
| prob_true, prob_pred = calibration_curve(yte, p, n_bins=10, strategy="quantile") |
| plt.figure(figsize=(3.6,3.6)) |
| plt.plot(prob_pred, prob_true, "o-", label=tag) |
| plt.plot([0,1],[0,1],"k--",lw=1) |
| plt.xlabel("Predicted"); plt.ylabel("Observed"); plt.title(f"Calibration — {tag}") |
| fn = RES/f"section5_calibration_{out_prefix}.png"; plt.tight_layout(); plt.savefig(fn, dpi=200); plt.close() |
| return {"AUROC":float(auroc), "AUPRC":float(auprc), "Brier":float(brier), "calibration_png":str(fn)} |
|
|
| train_df = Y[Y["is_ethanol"]].copy() |
| test_df = Y[Y["is_oxidative"]].copy() |
| Xtr, ytr, _ = make_Xy(train_df) |
| Xte, yte, _ = make_Xy(test_df) |
| idx_tr, idx_va = train_test_split(np.arange(len(Xtr)), test_size=0.2, random_state=42, stratify=(ytr>0)) |
| model_e2o = fit_mlp(Xtr[idx_tr], ytr[idx_tr], Xtr[idx_va], ytr[idx_va], max_epochs=60) |
| metrics_e2o = evaluate(model_e2o, Xte, yte, "Ethanol→Oxidative", "e2o") |
|
|
| train_df2 = Y[Y["is_oxidative"]].copy() |
| test_df2 = Y[Y["is_ethanol"]].copy() |
| Xtr2, ytr2, _ = make_Xy(train_df2) |
| Xte2, yte2, _ = make_Xy(test_df2) |
| idx_tr2, idx_va2 = train_test_split(np.arange(len(Xtr2)), test_size=0.2, random_state=42, stratify=(ytr2>0)) |
| model_o2e = fit_mlp(Xtr2[idx_tr2], ytr2[idx_tr2], Xtr2[idx_va2], ytr2[idx_va2], max_epochs=60) |
| metrics_o2e = evaluate(model_o2e, Xte2, yte2, "Oxidative→Ethanol", "o2e") |
|
|
| plt.figure(figsize=(4.5,3.2)) |
| plt.bar(["EtOH→Ox"], [metrics_e2o["AUPRC"]]) |
| plt.bar(["Ox→EtOH"], [metrics_o2e["AUPRC"]]) |
| plt.ylabel("AUPRC (transfer)"); plt.title("Stress transfer performance") |
| plt.tight_layout(); plt.savefig(RES/"section5_transfer_auprc.png", dpi=200); plt.close() |
|
|
| snapshot = { |
| "device": DEVICE, |
| "transfer": {"EtOH_to_Ox": metrics_e2o, "Ox_to_EtOH": metrics_o2e}, |
| "notes": "Section 5 stress transfer using Section-2 MLP and current labels.csv" |
| } |
| with open(RES/"section5_transfer_snapshot.json","w") as f: json.dump(snapshot, f, indent=2) |
| print(" Saved transfer figs & snapshot:", |
| RES/"section5_calibration_e2o.png", |
| RES/"section5_calibration_o2e.png", |
| RES/"section5_transfer_auprc.png", |
| RES/"section5_transfer_snapshot.json") |
