Upload models_comparaison.py

scripts/models_comparaison.py

@@ -0,0 +1,268 @@
+import pandas as pd
+import numpy as np
+import requests
+import time
+import json
+from pathlib import Path
+import matplotlib.pyplot as plt
+from sklearn.metrics import (roc_auc_score, average_precision_score,
+                             roc_curve, precision_recall_curve)
+from sklearn.preprocessing import StandardScaler
+from sklearn.decomposition import PCA
+import torch
+import torch.nn as nn
+import warnings
+warnings.filterwarnings('ignore')
+
+BASE_PATH = Path('/content/IDP')
+PATHS = {
+    'features':   BASE_PATH / 'features',
+    'embeddings': BASE_PATH / 'embeddings',
+    'benchmark':  BASE_PATH / 'results' / 'benchmark',
+    'figures':    BASE_PATH / 'results' / 'figures',
+}
+PATHS['benchmark'].mkdir(parents=True, exist_ok=True)
+PATHS['figures'].mkdir(parents=True, exist_ok=True)
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+df = pd.read_parquet(PATHS['features'] / 'features_classical_full.parquet')
+id_cols = ['mutation_idx', 'uniprot_acc', 'gene_symbol', 'position',
+           'wt_aa', 'mut_aa', 'label']
+feature_cols = [c for c in df.columns if c not in id_cols]
+X_features = np.nan_to_num(df[feature_cols].values.astype(np.float32),
+                           nan=0.0, posinf=0.0, neginf=0.0)
+X_emb_raw  = np.load(PATHS['embeddings'] / 'embeddings_combined_full.npy').astype(np.float32)
+y          = df['label'].values
+proteins   = df['uniprot_acc'].values
+
+print(f"   Variants: {len(df)}  |  Proteins: {df['uniprot_acc'].nunique()}")
+
+
+PP_SIFT_CACHE = PATHS['benchmark'] / 'polyphen_sift_filtered.parquet'
+
+if PP_SIFT_CACHE.exists():
+    print("   ✓ PolyPhen-2/SIFT cache found — loading")
+    df_pp_sift = pd.read_parquet(PP_SIFT_CACHE)
+
+else:
+
+    our_variants = {}
+    for _, row in df.iterrows():
+        acc  = row['uniprot_acc'].split('-')[0]
+        key  = (acc, int(row['position']) + 1, row['wt_aa'], row['mut_aa'])
+        our_variants[key] = row['uniprot_acc']
+
+    print(f"   Lookup: {len(our_variants)} variants across "
+          f"{df['uniprot_acc'].nunique()} proteins\n")
+
+    session  = requests.Session()
+    session.headers.update({
+        "Accept":     "application/json",
+        "User-Agent": "research-query/1.0"
+    })
+
+    collected = []
+    unique_accs = df['uniprot_acc'].unique()
+
+    PARTIAL = PATHS['benchmark'] / 'pp_sift_partial.parquet'
+    if PARTIAL.exists():
+        done_df   = pd.read_parquet(PARTIAL)
+        done_accs = set(done_df['uniprot_acc'].str.split('-').str[0])
+        print(f"   Resuming — {len(done_accs)} proteins already fetched, "
+              f"{done_df['polyphen2_score'].notna().sum()} PP2 hits so far")
+        collected = done_df.to_dict('records')
+    else:
+        done_accs = set()
+
+    todo_accs = [a for a in unique_accs if a.split('-')[0] not in done_accs]
+    print(f"   Fetching {len(todo_accs)} proteins from UniProt variation API …")
+
+    for i, acc in enumerate(todo_accs):
+        acc_bare = acc.split('-')[0]
+        url = f"https://www.ebi.ac.uk/proteins/api/variation/{acc_bare}"
+
+        pp2_hits = sift_hits = 0
+        for attempt in range(4):
+            try:
+                r = session.get(url, timeout=30)
+                if r.status_code == 200:
+                    data = r.json()
+                    for feat in data.get('features', []):
+
+                        if feat.get('type') != 'VARIANT':
+                            continue
+
+                        pos_begin = feat.get('begin')
+                        wt_aa     = feat.get('wildType', '')
+                        mut_aa    = feat.get('alternativeSequence', '')
+
+                        if not pos_begin or not wt_aa or not mut_aa:
+                            continue
+                        if len(wt_aa) != 1 or len(mut_aa) != 1:
+                            continue
+
+                        try:
+                            pos_1 = int(pos_begin)
+                        except (ValueError, TypeError):
+                            continue
+
+                        key = (acc_bare, pos_1, wt_aa, mut_aa)
+                        if key not in our_variants:
+                            continue
+
+
+                        pp2_score  = None
+                        sift_score = None
+                        for pred in feat.get('predictions', []):
+                            algo = pred.get('predAlgorithmNameType', '')
+                            score = pred.get('score')
+                            if score is None:
+                                continue
+                            if 'PolyPhen' in algo or 'polyphen' in algo.lower():
+                                pp2_score = float(score)
+                                pp2_hits += 1
+                            elif 'SIFT' in algo or 'sift' in algo.lower():
+                                sift_score = float(score)
+                                sift_hits += 1
+
+                        collected.append({
+                            'uniprot_acc':     our_variants[key],
+                            'position':        pos_1 - 1,
+                            'wt_aa':           wt_aa,
+                            'mut_aa':          mut_aa,
+                            'polyphen2_score': pp2_score,
+                            'sift_score':      sift_score,
+                        })
+                    break
+
+                elif r.status_code == 404:
+                    break
+                elif r.status_code == 429:
+                    time.sleep(5 * (attempt + 1))
+                else:
+                    time.sleep(2 ** attempt)
+
+            except requests.exceptions.Timeout:
+                time.sleep(3)
+            except Exception as e:
+                time.sleep(2)
+
+        time.sleep(0.2)
+
+        if (i + 1) % 50 == 0:
+            partial_df = pd.DataFrame(collected).drop_duplicates(
+                subset=['uniprot_acc', 'position', 'wt_aa', 'mut_aa'])
+            partial_df.to_parquet(PARTIAL, index=False)
+            n_pp   = partial_df['polyphen2_score'].notna().sum()
+            n_sift = partial_df['sift_score'].notna().sum()
+            print(f"   … {i+1}/{len(todo_accs)} proteins | "
+                  f"variants matched: {len(partial_df)} | "
+                  f"PP2: {n_pp} | SIFT: {n_sift}")
+
+    df_pp_sift = pd.DataFrame(collected).drop_duplicates(
+        subset=['uniprot_acc', 'position', 'wt_aa', 'mut_aa'])
+    df_pp_sift.to_parquet(PP_SIFT_CACHE, index=False)
+    print(f"\n    Matched variants: {len(df_pp_sift)}")
+    print(f"    PolyPhen-2:       {df_pp_sift['polyphen2_score'].notna().sum()}")
+    print(f"    SIFT:             {df_pp_sift['sift_score'].notna().sum()}")
+
+
+print("\n" + "=" * 60)
+print(" MERGING SCORES")
+print("=" * 60)
+
+df_am = pd.read_parquet(PATHS['benchmark'] / 'alphamissense_filtered.parquet')
+
+df_bench = df[id_cols].copy()
+df_bench = df_bench.merge(
+    df_am[['uniprot_acc','position','wt_aa','mut_aa','am_pathogenicity']],
+    on=['uniprot_acc','position','wt_aa','mut_aa'], how='left')
+df_bench = df_bench.merge(
+    df_pp_sift[['uniprot_acc','position','wt_aa','mut_aa',
+                'polyphen2_score','sift_score']],
+    on=['uniprot_acc','position','wt_aa','mut_aa'], how='left')
+
+df_bench['sift_score_inv'] = 1 - df_bench['sift_score']
+
+print(f"   AlphaMissense: {df_bench['am_pathogenicity'].notna().sum()} "
+      f"({100*df_bench['am_pathogenicity'].notna().mean():.1f}%)")
+print(f"   PolyPhen-2:    {df_bench['polyphen2_score'].notna().sum()} "
+      f"({100*df_bench['polyphen2_score'].notna().mean():.1f}%)")
+print(f"   SIFT:          {df_bench['sift_score_inv'].notna().sum()} "
+      f"({100*df_bench['sift_score_inv'].notna().mean():.1f}%)")
+
+df_bench.to_parquet(PATHS['benchmark'] / 'benchmark_merged.parquet', index=False)
+
+class SimpleMLP(nn.Module):
+    def __init__(self, d, h=256):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(d,h), nn.ReLU(), nn.Dropout(0.3),
+            nn.Linear(h,h//2), nn.ReLU(), nn.Dropout(0.2),
+            nn.Linear(h//2,1), nn.Sigmoid())
+    def forward(self, x): return self.net(x).squeeze()
+
+def prepare(Xf, Xe, tr, te, n=128):
+    sf = StandardScaler()
+    Xf_tr = sf.fit_transform(Xf[tr]); Xf_te = sf.transform(Xf[te])
+    pca = PCA(n_components=min(n, Xe[tr].shape[0]-1), random_state=42)
+    Xp_tr = pca.fit_transform(Xe[tr]); Xp_te = pca.transform(Xe[te])
+    se = StandardScaler()
+    Xe_tr = se.fit_transform(Xp_tr); Xe_te = se.transform(Xp_te)
+    return (np.c_[Xf_tr,Xe_tr].astype(np.float32),
+            np.c_[Xf_te,Xe_te].astype(np.float32))
+
+def train_pred(Xtr, ytr, Xte, epochs=50):
+    m = SimpleMLP(Xtr.shape[1]).to(device)
+    opt = torch.optim.Adam(m.parameters(), lr=0.001, weight_decay=1e-4)
+    crit = nn.BCELoss()
+    Xt = torch.FloatTensor(Xtr).to(device)
+    yt = torch.FloatTensor(ytr).to(device)
+    Xv = torch.FloatTensor(Xte).to(device)
+    m.train()
+    for _ in range(epochs):
+        opt.zero_grad(); crit(m(Xt), yt).backward(); opt.step()
+    m.eval()
+    with torch.no_grad(): return m(Xv).cpu().numpy()
+
+OUR_CACHE = PATHS['benchmark'] / 'our_model_lpocv_preds.npy'
+if OUR_CACHE.exists():
+    print("\n   ✓ Model predictions cache found")
+    our_preds = np.load(OUR_CACHE)
+else:
+    our_preds = np.full(len(df), np.nan)
+    ups = np.unique(proteins)
+    print(f"\n   Running LPOCV ({len(ups)} proteins) …")
+    for i, p in enumerate(ups):
+        te = proteins == p; tr = ~te
+        if te.sum() < 2 or tr.sum() < 10: continue
+        Xtr, Xte = prepare(X_features, X_emb_raw, tr, te)
+        our_preds[te] = train_pred(Xtr, y[tr], Xte)
+        if i % 50 == 0: print(f"   … {i}/{len(ups)} proteins")
+    np.save(OUR_CACHE, our_preds)
+    print("    Saved")
+
+df_bench['our_score'] = our_preds
+
+
+tools = {
+    'Our model (MLP + ESM-2)': 'our_score',
+    'AlphaMissense':           'am_pathogenicity',
+    'PolyPhen-2':              'polyphen2_score',
+    'SIFT (inverted)':         'sift_score_inv',
+}
+results = {}
+for name, col in tools.items():
+    mask = df_bench[col].notna() & df_bench['our_score'].notna()
+    sub  = df_bench[mask]
+    if len(sub) < 50:
+        print(f"   ⚠ {name}: only {len(sub)} variants — skipping")
+        continue
+    results[name] = {
+        'auc_roc': roc_auc_score(sub['label'], sub[col]),
+        'auc_pr':  average_precision_score(sub['label'], sub[col]),
+        'n': len(sub), 'col': col, 'mask': mask}
+    print(f"   {name:<35} n={len(sub):>6,}  "
+          f"AUC-ROC={results[name]['auc_roc']:.3f}  "
+          f"AUC-PR={results[name]['auc_pr']:.3f}")