Upload 14 files

scripts/analyze_and_filter_mito_dataset.py.py

@@ -0,0 +1,56 @@
+# -*- coding: utf-8 -*-
+"""Untitled17.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1GwdSjrwh3f6QCzOa8KHr_XkWy0KmZvdV
+"""
+
+import pandas as pd
+from pathlib import Path
+
+df = pd.read_parquet(BASE_PATH / 'data' / 'processed' / 'mutations_dataset_final.parquet')
+
+
+
+STRICT_MITO_GENES = {
+    'OPA1', 'MFN1', 'MFN2', 'DNM1L', 'FIS1',
+    'AFG3L2', 'SPG7', 'LONP1', 'CLPP', 'YME1L1', 'OMA1', 'HTRA2',
+    'NDUFAF1', 'NDUFAF2', 'NDUFAF3', 'NDUFAF4', 'NDUFAF5', 'NDUFAF6', 'NDUFAF7',
+    'NUBPL', 'ACAD9', 'TIMMDC1', 'FOXRED1',
+    'NDUFS1', 'NDUFS2', 'NDUFS3', 'NDUFS4', 'NDUFS6', 'NDUFS7', 'NDUFS8',
+    'NDUFV1', 'NDUFV2', 'NDUFA1', 'NDUFA2', 'NDUFA9', 'NDUFA10', 'NDUFA11', 'NDUFA12', 'NDUFA13',
+    'NDUFB3', 'NDUFB8', 'NDUFB9', 'NDUFB10', 'NDUFB11',
+    'SDHA', 'SDHB', 'SDHC', 'SDHD', 'SDHAF1', 'SDHAF2',
+    'BCS1L', 'TTC19', 'UQCRB', 'UQCRQ', 'UQCRC2', 'CYC1',
+    'SURF1', 'SCO1', 'SCO2', 'COX10', 'COX14', 'COX15', 'COX20',
+    'COA5', 'COA6', 'COA7', 'PET100', 'COX4I1', 'COX6A1', 'COX6B1', 'COX7B', 'COX8A',
+    'ATP5F1A', 'ATP5F1D', 'ATP5F1E', 'TMEM70', 'ATPAF2',
+    'TIMM50', 'TIMM8A', 'DNAJC19', 'AGK', 'TOMM20', 'TOMM40',
+    'CHCHD2', 'CHCHD10', 'CHCHD4', 'AIFM1', 'COX17',
+    'HSPA9', 'HSPD1', 'HSPE1', 'CLPB',
+    'AARS2', 'DARS2', 'EARS2', 'FARS2', 'HARS2', 'IARS2', 'LARS2', 'MARS2',
+    'NARS2', 'RARS2', 'SARS2', 'TARS2', 'VARS2', 'YARS2',
+    'GFM1', 'TSFM', 'TUFM', 'C12orf65', 'RMND1', 'GTPBP3', 'MTO1', 'TRMU',
+    'MRPS16', 'MRPS22', 'MRPL3', 'MRPL12', 'MRPL44',
+    'POLG', 'POLG2', 'TWNK', 'TFAM', 'RRM2B', 'MPV17', 'DGUOK', 'TK2',
+    'SUCLA2', 'SUCLG1', 'FBXL4',
+    'PDHA1', 'PDHB', 'PDHX', 'DLD', 'DLAT',
+    'PC', 'PCCA', 'PCCB', 'MUT', 'MMAA', 'MMAB', 'MMACHC',
+    'LIAS', 'LIPT1', 'BOLA3', 'NFU1', 'ISCA1', 'ISCA2', 'IBA57', 'GLRX5', 'FDXR',
+    'COQ2', 'COQ4', 'COQ6', 'COQ7', 'COQ8A', 'COQ9', 'PDSS1', 'PDSS2',
+    'SLC25A4', 'SLC25A3', 'SLC25A12', 'SLC25A13', 'SLC25A19', 'SLC25A22',
+    'TAZ', 'SERAC1', 'LRPPRC', 'TACO1', 'ELAC2', 'TRNT1', 'PNPT1',
+}
+
+df_mito_strict = df[df['gene_symbol'].isin(STRICT_MITO_GENES)].copy()
+
+df_mito_strict.to_parquet(
+    BASE_PATH / 'data' / 'processed' / 'mutations_dataset_mito_strict.parquet'
+)
+df_mito_strict.to_csv(
+    BASE_PATH / 'data' / 'processed' / 'mutations_dataset_mito_strict.tsv',
+    sep='\t',
+    index=False
+)

scripts/analyze_bias_and_train_strict_mito.py.py

@@ -0,0 +1,180 @@
+# -*- coding: utf-8 -*-
+"""Untitled17.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1GwdSjrwh3f6QCzOa8KHr_XkWy0KmZvdV
+"""
+
+import pandas as pd
+import numpy as np
+from pathlib import Path
+from sklearn.ensemble import GradientBoostingClassifier
+from sklearn.preprocessing import StandardScaler
+from sklearn.metrics import roc_auc_score, average_precision_score, roc_curve, precision_recall_curve
+import matplotlib.pyplot as plt
+from tqdm import tqdm
+import pickle
+
+PATHS = {
+    'features': BASE_PATH / 'features',
+    'models': BASE_PATH / 'models',
+    'results': BASE_PATH / 'results',
+    'figures': BASE_PATH / 'results' / 'figures',
+}
+
+PATHS['figures'].mkdir(parents=True, exist_ok=True)
+
+df_full = 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_all = [c for c in df_full.columns if c not in id_cols]
+
+length_related = ['protein_length', 'position_absolute', 'distance_to_n_term', 'distance_to_c_term']
+feature_cols_no_length = [c for c in feature_cols_all if c not in length_related]
+
+print(f"   Features totales: {len(feature_cols_all)}")
+print(f"   Features sans longueur: {len(feature_cols_no_length)}")
+
+X_all = df_full[feature_cols_all].values
+X_no_length = df_full[feature_cols_no_length].values
+y = df_full['label'].values
+
+X_all = np.nan_to_num(X_all, nan=0.0, posinf=0.0, neginf=0.0)
+X_no_length = np.nan_to_num(X_no_length, nan=0.0, posinf=0.0, neginf=0.0)
+
+proteins = df_full['uniprot_acc'].unique()
+
+def quick_lpocv(X, y, proteins_list, df, max_proteins=100):
+    """LPOCV rapide sur un échantillon de protéines"""
+    results = []
+
+    np.random.seed(42)
+    sample_proteins = np.random.choice(proteins_list, size=min(max_proteins, len(proteins_list)), replace=False)
+
+    for protein in tqdm(sample_proteins, desc="LPOCV rapide"):
+        test_mask = df['uniprot_acc'] == protein
+        train_mask = ~test_mask
+
+        if test_mask.sum() < 2:
+            continue
+
+        X_train, y_train = X[train_mask], y[train_mask]
+        X_test, y_test = X[test_mask], y[test_mask]
+
+        scaler = StandardScaler()
+        X_train_s = scaler.fit_transform(X_train)
+        X_test_s = scaler.transform(X_test)
+
+        model = GradientBoostingClassifier(n_estimators=50, max_depth=3, random_state=42)
+        model.fit(X_train_s, y_train)
+
+        y_pred = model.predict_proba(X_test_s)[:, 1]
+
+        for pred, true in zip(y_pred, y_test):
+            results.append({'y_true': true, 'y_pred': pred})
+
+    df_res = pd.DataFrame(results)
+    if len(df_res) > 0 and len(df_res['y_true'].unique()) > 1:
+        return roc_auc_score(df_res['y_true'], df_res['y_pred'])
+    return 0
+
+
+df_strict = pd.read_parquet(PATHS['features'] / 'features_classical_mito_strict.parquet')
+
+print(f"   Mutations: {len(df_strict):,}")
+print(f"   Pathogènes: {(df_strict['label']==1).sum():,}")
+print(f"   Bénins: {(df_strict['label']==0).sum():,}")
+
+X_strict = df_strict[feature_cols_all].values
+y_strict = df_strict['label'].values
+X_strict = np.nan_to_num(X_strict, nan=0.0, posinf=0.0, neginf=0.0)
+
+proteins_strict = df_strict['uniprot_acc'].unique()
+print(f"   Protéines: {len(proteins_strict)}")
+
+
+lpocv_strict_results = []
+
+for protein in tqdm(proteins_strict, desc="LPOCV strict"):
+    test_mask = df_strict['uniprot_acc'] == protein
+    train_mask = ~test_mask
+
+    if test_mask.sum() < 2:
+        continue
+
+    X_train = X_strict[train_mask]
+    y_train = y_strict[train_mask]
+    X_test = X_strict[test_mask]
+    y_test = y_strict[test_mask]
+
+    scaler = StandardScaler()
+    X_train_s = scaler.fit_transform(X_train)
+    X_test_s = scaler.transform(X_test)
+
+    model = GradientBoostingClassifier(n_estimators=100, max_depth=4, learning_rate=0.1, random_state=42)
+    model.fit(X_train_s, y_train)
+
+    y_pred = model.predict_proba(X_test_s)[:, 1]
+
+    for i, (pred, true) in enumerate(zip(y_pred, y_test)):
+        lpocv_strict_results.append({
+            'protein': protein,
+            'y_true': true,
+            'y_pred': pred,
+        })
+
+df_lpocv_strict = pd.DataFrame(lpocv_strict_results)
+
+if len(df_lpocv_strict) > 0 and len(df_lpocv_strict['y_true'].unique()) > 1:
+    auc_roc_strict = roc_auc_score(df_lpocv_strict['y_true'], df_lpocv_strict['y_pred'])
+    auc_pr_strict = average_precision_score(df_lpocv_strict['y_true'], df_lpocv_strict['y_pred'])
+
+    print(f"   AUC-ROC: {auc_roc_strict:.4f}")
+    print(f"   AUC-PR:  {auc_pr_strict:.4f}")
+else:
+    auc_roc_strict = 0
+    auc_pr_strict = 0
+
+scaler_strict = StandardScaler()
+X_strict_scaled = scaler_strict.fit_transform(X_strict)
+
+model_strict = GradientBoostingClassifier(
+    n_estimators=300,
+    max_depth=5,
+    learning_rate=0.05,
+    min_samples_leaf=5,
+    subsample=0.8,
+    random_state=42
+)
+
+model_strict.fit(X_strict_scaled, y_strict)
+
+importance_strict = pd.DataFrame({
+    'feature': feature_cols_all,
+    'importance': model_strict.feature_importances_
+}).sort_values('importance', ascending=False)
+
+print("\n   Top 10 features (strict mito):")
+for i, row in importance_strict.head(10).iterrows():
+    print(f"   {row['importance']:.4f}  {row['feature']}")
+
+model_strict_data = {
+    'model': model_strict,
+    'scaler': scaler_strict,
+    'feature_cols': feature_cols_all,
+    'metrics': {
+        'auc_roc_lpocv': auc_roc_strict,
+        'auc_pr_lpocv': auc_pr_strict,
+    },
+    'n_samples': len(X_strict),
+}
+
+with open(PATHS['models'] / 'model_classical_mito_strict.pkl', 'wb') as f:
+    pickle.dump(model_strict_data, f)
+
+
+df_lpocv_full = pd.read_parquet(PATHS['results'] / 'lpocv_predictions.parquet')
+auc_roc_full = roc_auc_score(df_lpocv_full['y_true'], df_lpocv_full['y_pred_proba'])
+auc_pr_full = average_precision_score(df_lpocv_full['y_true'], df_lpocv_full['y_pred_proba'])

scripts/build_clinvar_mito_dataset.py.py

@@ -0,0 +1,333 @@
+# -*- coding: utf-8 -*-
+"""Untitled17.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1GwdSjrwh3f6QCzOa8KHr_XkWy0KmZvdV
+"""
+
+import pandas as pd
+import numpy as np
+import gzip
+import re
+from pathlib import Path
+from tqdm import tqdm
+
+
+
+PATHS = {
+    'data_raw': BASE_PATH / 'data' / 'raw',
+    'data_processed': BASE_PATH / 'data' / 'processed',
+    'checkpoints': BASE_PATH / 'models' / 'checkpoints',
+}
+
+for path in PATHS.values():
+    path.mkdir(parents=True, exist_ok=True)
+
+AA_3TO1 = {
+    'Ala': 'A', 'Arg': 'R', 'Asn': 'N', 'Asp': 'D', 'Cys': 'C',
+    'Glu': 'E', 'Gln': 'Q', 'Gly': 'G', 'His': 'H', 'Ile': 'I',
+    'Leu': 'L', 'Lys': 'K', 'Met': 'M', 'Phe': 'F', 'Pro': 'P',
+    'Ser': 'S', 'Thr': 'T', 'Trp': 'W', 'Tyr': 'Y', 'Val': 'V'
+}
+
+
+
+clinvar_file = Path("/content/drive/MyDrive/clinvar/variation_summary.txt.gz")
+
+if clinvar_file.exists():
+    print(f"   Fichier: {clinvar_file}")
+
+    with gzip.open(clinvar_file, "rt") as f:
+        df_clinvar_raw = pd.read_csv(f, sep="\t", low_memory=False)
+
+    print(f"   Lignes totales: {len(df_clinvar_raw):,}")
+    print(f"   Colonnes: {df_clinvar_raw.columns.tolist()[:10]}...")
+
+    df_clinvar = df_clinvar_raw[
+        df_clinvar_raw["GeneSymbol"].notna() &
+        df_clinvar_raw["ProteinChange"].notna() &
+        df_clinvar_raw["ClinicalSignificance"].str.contains("Pathogenic|Benign", case=False, na=False)
+    ].copy()
+
+    print(f"   Après filtre basique: {len(df_clinvar):,}")
+
+    MITO_KEYWORDS = [
+        "mitochondrial", "Leigh", "MELAS", "MERRF", "NARP", "LHON",
+        "optic atrophy", "OXPHOS", "complex I", "complex II", "complex III",
+        "complex IV", "complex V", "cardiomyopathy", "encephalopathy",
+        "myopathy", "aminoacyl-tRNA", "respiratory chain"
+    ]
+
+    pattern = "|".join(MITO_KEYWORDS)
+
+    MITO_GENES = [
+        'OPA1', 'MFN1', 'MFN2', 'DNM1L', 'AFG3L2', 'SPG7',
+        'SURF1', 'SCO1', 'SCO2', 'COX10', 'COX15', 'COX6B1',
+        'NDUFAF1', 'NDUFAF2', 'NDUFAF3', 'NDUFAF4', 'NDUFAF5', 'NDUFAF6',
+        'NUBPL', 'ACAD9', 'TIMMDC1', 'FOXRED1',
+        'CHCHD10', 'CHCHD2', 'TIMM50', 'DNAJC19', 'AGK',
+        'HARS2', 'IARS2', 'LARS2', 'MARS2', 'RARS2', 'VARS2', 'YARS2',
+        'DARS2', 'SARS2', 'TARS2', 'AARS2', 'EARS2', 'FARS2', 'NARS2', 'PARS2',
+        'POLG', 'POLG2', 'TWNK', 'RRM2B', 'MPV17', 'DGUOK', 'TK2',
+        'SUCLA2', 'SUCLG1', 'FBXL4', 'SLC25A4', 'SLC25A3',
+        'RMND1', 'GTPBP3', 'MTO1', 'TRMU', 'TSFM', 'GFM1', 'C12orf65',
+        'LRPPRC', 'TACO1', 'MTFMT', 'ELAC2',
+        'BCS1L', 'TTC19', 'UQCRQ', 'UQCRB', 'UQCRC2',
+        'COA5', 'COA6', 'COA7', 'PET100', 'PET117',
+        'TMEM70', 'ATP5F1A', 'ATP5F1D', 'ATP5F1E',
+    ]
+
+    df_mito = df_clinvar[
+        df_clinvar["PhenotypeList"].str.contains(pattern, case=False, na=False) |
+        df_clinvar["GeneSymbol"].str.upper().isin([g.upper() for g in MITO_GENES])
+    ].copy()
+
+    print(f"   Variants mitochondriaux: {len(df_mito):,}")
+
+else:
+    print("   non trouvé")
+    print("   → Téléchargez depuis: https://ftp.ncbi.nlm.nih.gov/pub/clinvar/tab_delimited/")
+    df_mito = pd.DataFrame()
+
+
+
+records = []
+
+if len(df_mito) > 0:
+    for _, row in tqdm(df_mito.iterrows(), total=len(df_mito), desc="Parsing"):
+        protein_change = str(row.get("ProteinChange", ""))
+
+        match = re.search(r'p\.([A-Z])(\d+)([A-Z])', protein_change)
+
+        if not match:
+            match = re.search(r'p\.([A-Z][a-z]{2})(\d+)([A-Z][a-z]{2})', protein_change)
+            if match:
+                wt_3, pos, mut_3 = match.groups()
+                wt = AA_3TO1.get(wt_3)
+                mut = AA_3TO1.get(mut_3)
+                if wt and mut:
+                    match = type('Match', (), {'groups': lambda: (wt, pos, mut)})()
+                else:
+                    match = None
+
+        if not match:
+            continue
+
+        wt, pos, mut = match.groups()
+
+        clin_sig = str(row.get("ClinicalSignificance", "")).lower()
+
+        if "pathogenic" in clin_sig and "benign" not in clin_sig:
+            label = 1
+        elif "benign" in clin_sig and "pathogenic" not in clin_sig:
+            label = 0
+        else:
+            continue
+
+        review = str(row.get("ReviewStatus", ""))
+
+        records.append({
+            "gene_symbol": str(row["GeneSymbol"]).upper(),
+            "position": int(pos) - 1,
+            "wt_aa": wt,
+            "mut_aa": mut,
+            "label": label,
+            "source": "ClinVar_local",
+            "review_status": review,
+            "clinical_significance": row.get("ClinicalSignificance", ""),
+            "phenotype": str(row.get("PhenotypeList", ""))[:100],
+        })
+
+df_clinvar_parsed = pd.DataFrame(records)
+
+print(f"\n   ✓ Variants parsés: {len(df_clinvar_parsed)}")
+
+if len(df_clinvar_parsed) > 0:
+    print(f"\n   Labels:")
+    print(df_clinvar_parsed["label"].value_counts())
+
+    print(f"\n   Top 15 gènes:")
+    print(df_clinvar_parsed["gene_symbol"].value_counts().head(15))
+
+    print(f"\n   Review status:")
+    print(df_clinvar_parsed["review_status"].value_counts().head(5))
+
+
+uniprot_file = PATHS['data_raw'] / 'uniprot_mito_extended.parquet'
+proteins_file = PATHS['data_processed'] / 'proteins_targeted.parquet'
+
+seq_dict = {}
+gene_to_acc = {}
+acc_to_info = {}
+
+if uniprot_file.exists():
+    df_uniprot = pd.read_parquet(uniprot_file)
+    for _, row in df_uniprot.iterrows():
+        acc = row['accession']
+        seq = row['sequence']
+        gene = str(row['gene_name']).upper() if row['gene_name'] else ''
+
+        seq_dict[acc] = seq
+        acc_to_info[acc] = {
+            'cysteine_fraction': row.get('cysteine_fraction', seq.count('C')/len(seq) if seq else 0),
+            'mito_region': row.get('mito_region', 'Unknown'),
+        }
+
+        if gene:
+            gene_to_acc[gene] = acc
+            gene_to_acc[gene.replace('-', '')] = acc
+
+    print(f"   Protéines UniProt: {len(df_uniprot)}")
+
+if proteins_file.exists():
+    df_proteins = pd.read_parquet(proteins_file)
+    for _, row in df_proteins.iterrows():
+        acc = row['accession']
+        seq = row['sequence']
+        gene = row['gene_symbol'].upper()
+
+        if acc not in seq_dict:
+            seq_dict[acc] = seq
+        gene_to_acc[gene] = acc
+
+    print(f"   Protéines : {len(df_proteins)}")
+
+print(f"    séquences: {len(seq_dict)}")
+print(f"   Gènes : {len(gene_to_acc)}")
+
+
+
+validated = []
+not_found_genes = set()
+seq_mismatch = 0
+
+for _, row in tqdm(df_clinvar_parsed.iterrows(), total=len(df_clinvar_parsed), desc="Validation"):
+    gene = row['gene_symbol']
+
+    acc = gene_to_acc.get(gene)
+
+    if not acc:
+        for variant in [gene.replace('-', ''), gene.split('-')[0], gene.split('_')[0]]:
+            if variant in gene_to_acc:
+                acc = gene_to_acc[variant]
+                break
+
+    if not acc:
+        not_found_genes.add(gene)
+        continue
+
+    seq = seq_dict.get(acc, '')
+    if not seq:
+        continue
+
+    pos = row['position']
+    wt = row['wt_aa']
+    mut = row['mut_aa']
+
+    if 0 <= pos < len(seq):
+        if seq[pos] == wt:
+            info = acc_to_info.get(acc, {})
+
+            validated.append({
+                'uniprot_acc': acc,
+                'gene_symbol': gene,
+                'position': pos,
+                'wt_aa': wt,
+                'mut_aa': mut,
+                'label': row['label'],
+                'source': row['source'],
+                'review_status': row.get('review_status', ''),
+                'clinical_significance': row.get('clinical_significance', ''),
+                'phenotype': row.get('phenotype', ''),
+                'cysteine_fraction': info.get('cysteine_fraction', 0),
+                'mito_region': info.get('mito_region', 'Unknown'),
+            })
+        else:
+            seq_mismatch += 1
+
+df_validated = pd.DataFrame(validated)
+
+
+
+if len(df_validated) > 0:
+    print(f"\n   Labels validés:")
+    print(df_validated["label"].value_counts())
+
+
+benign_file = PATHS['data_processed'] / 'mutations_master.parquet'
+
+if benign_file.exists():
+    df_benign_existing = pd.read_parquet(benign_file)
+    print(f"   Socle bénin existant: {len(df_benign_existing)}")
+
+    # Préparer pour fusion
+    df_benign_existing = df_benign_existing.copy()
+    df_benign_existing['label'] = 0
+    df_benign_existing['source'] = df_benign_existing.get('label_source', 'gnomAD_UniProt')
+
+else:
+    df_benign_existing = pd.DataFrame()
+
+
+
+datasets = []
+
+if len(df_validated) > 0:
+    datasets.append(df_validated)
+    print(f"   + ClinVar: {len(df_validated)}")
+
+if len(df_benign_existing) > 0:
+    cols = ['uniprot_acc', 'position', 'wt_aa', 'mut_aa', 'label', 'source']
+    cols_exist = [c for c in cols if c in df_benign_existing.columns]
+    df_benign_clean = df_benign_existing[cols_exist].copy()
+
+    if 'gene_symbol' not in df_benign_clean.columns and 'gene_symbol' in df_benign_existing.columns:
+        df_benign_clean['gene_symbol'] = df_benign_existing['gene_symbol']
+
+    datasets.append(df_benign_clean)
+    print(f"   + Bénins existants: {len(df_benign_clean)}")
+
+if datasets:
+    df_final = pd.concat(datasets, ignore_index=True)
+
+    df_final['mutation_key'] = (
+        df_final['uniprot_acc'].astype(str) + '_' +
+        df_final['position'].astype(str) + '_' +
+        df_final['mut_aa'].astype(str)
+    )
+
+    df_final['priority'] = df_final['source'].apply(lambda x: 0 if 'ClinVar' in str(x) else 1)
+    df_final = df_final.sort_values('priority')
+    df_final = df_final.drop_duplicates(subset='mutation_key', keep='first')
+    df_final = df_final.drop(columns=['priority', 'mutation_key'])
+
+    print(f"\n   ✓ Dataset final: {len(df_final)}")
+else:
+    df_final = pd.DataFrame()
+    print("    Aucun dataset à fusionner")
+
+
+
+if len(df_final) > 0:
+
+    df_final['n_terminal'] = df_final['position'] < 50
+    df_final['cysteine_gained'] = df_final['mut_aa'] == 'C'
+    df_final['cysteine_lost'] = df_final['wt_aa'] == 'C'
+    df_final['mutation_id'] = df_final['wt_aa'] + (df_final['position'] + 1).astype(str) + df_final['mut_aa']
+
+    df_final['ros_axis'] = (
+        df_final['cysteine_lost'] |
+        df_final['cysteine_gained'] |
+        (df_final.get('cysteine_fraction', 0) > 0.03) |
+        (df_final.get('mito_region', '') == 'IMS')
+    )
+
+    df_final['import_axis'] = df_final['n_terminal']
+
+    df_final.to_parquet(PATHS['data_processed'] / 'mutations_dataset_final.parquet')
+    df_final.to_csv(PATHS['data_processed'] / 'mutations_dataset_final.tsv', sep='\t', index=False)
+
+    if len(df_clinvar_parsed) > 0:
+        df_clinvar_parsed.to_parquet(PATHS['data_raw'] / 'clinvar_mito_parsed.parquet')

scripts/build_clinvar_uniprot_dataset.py.py

@@ -0,0 +1,269 @@
+# -*- coding: utf-8 -*-
+"""Untitled17.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1GwdSjrwh3f6QCzOa8KHr_XkWy0KmZvdV
+"""
+
+import pandas as pd
+import numpy as np
+import gzip
+import re
+from pathlib import Path
+from tqdm import tqdm
+
+PATHS = {
+    'data_raw': BASE_PATH / 'data' / 'raw',
+    'data_processed': BASE_PATH / 'data' / 'processed',
+}
+
+for path in PATHS.values():
+    path.mkdir(parents=True, exist_ok=True)
+
+AA_3TO1 = {
+    'Ala': 'A', 'Arg': 'R', 'Asn': 'N', 'Asp': 'D', 'Cys': 'C',
+    'Glu': 'E', 'Gln': 'Q', 'Gly': 'G', 'His': 'H', 'Ile': 'I',
+    'Leu': 'L', 'Lys': 'K', 'Met': 'M', 'Phe': 'F', 'Pro': 'P',
+    'Ser': 'S', 'Thr': 'T', 'Trp': 'W', 'Tyr': 'Y', 'Val': 'V'
+}
+
+
+
+print(f"   Fichier: {uniprot_file.name}")
+
+with gzip.open(uniprot_file, 'rt') as f:
+    df_uniprot = pd.read_csv(f, sep='\t', low_memory=False)
+
+print(f"   Protéines : {len(df_uniprot):,}")
+print(f"   Colonnes: {df_uniprot.columns.tolist()}")
+
+seq_dict = {}
+gene_to_acc = {}
+acc_to_info = {}
+
+for _, row in tqdm(df_uniprot.iterrows(), total=len(df_uniprot), desc="Indexation"):
+    acc = row['Entry']
+    seq = row['Sequence']
+
+    if pd.isna(seq) or not seq:
+        continue
+
+    seq_dict[acc] = seq
+    acc_to_info[acc] = {
+        'length': len(seq),
+        'cysteine_count': seq.count('C'),
+        'cysteine_fraction': seq.count('C') / len(seq) if seq else 0,
+        'protein_name': str(row.get('Protein names', ''))[:50],
+    }
+
+    gene_names = str(row.get('Gene Names', ''))
+    if gene_names and gene_names != 'nan':
+        for gene in gene_names.split():
+            gene_upper = gene.upper().strip()
+            if gene_upper:
+                gene_to_acc[gene_upper] = acc
+                gene_to_acc[gene_upper.replace('-', '')] = acc
+
+print(f"\n   Séquences indexées: {len(seq_dict):,}")
+print(f"   Gènes mappés: {len(gene_to_acc):,}")
+
+df_uniprot_clean = df_uniprot[['Entry', 'Gene Names', 'Sequence', 'Protein names']].copy()
+df_uniprot_clean.columns = ['accession', 'gene_names', 'sequence', 'protein_name']
+df_uniprot_clean = df_uniprot_clean[df_uniprot_clean['sequence'].notna()]
+df_uniprot_clean.to_parquet(PATHS['data_raw'] / 'uniprot_human_reviewed.parquet')
+
+
+
+clinvar_parsed_file = PATHS['data_raw'] / 'clinvar_mito_parsed.parquet'
+
+if clinvar_parsed_file.exists():
+    df_clinvar = pd.read_parquet(clinvar_parsed_file)
+    print(f"   ✓ ClinVar parsé chargé: {len(df_clinvar):,}")
+else:
+    print("   Parsing ClinVar depuis le fichier brut...")
+
+    clinvar_file = Path("")
+
+    with gzip.open(clinvar_file, "rt") as f:
+        df_raw = pd.read_csv(f, sep="\t", low_memory=False)
+
+    df_filtered = df_raw[
+        df_raw['GeneSymbol'].notna() &
+        df_raw['ClinicalSignificance'].str.contains("athogenic|enign", case=False, na=False)
+    ].copy()
+
+    MITO_GENES = [
+        'OPA1', 'MFN1', 'MFN2', 'DNM1L', 'AFG3L2', 'SPG7', 'LONP1', 'CLPP',
+        'NDUFAF1', 'NDUFAF2', 'NDUFAF3', 'NDUFAF4', 'NDUFAF5', 'NDUFAF6',
+        'NUBPL', 'ACAD9', 'TIMMDC1', 'FOXRED1',
+        'NDUFS1', 'NDUFS2', 'NDUFS3', 'NDUFS4', 'NDUFS6', 'NDUFS7', 'NDUFS8',
+        'NDUFV1', 'NDUFV2', 'NDUFA1', 'NDUFA2', 'NDUFA9', 'NDUFA10', 'NDUFA11', 'NDUFA12', 'NDUFA13',
+        'SDHA', 'SDHB', 'SDHC', 'SDHD', 'SDHAF1', 'SDHAF2',
+        'BCS1L', 'TTC19', 'UQCRB', 'UQCRQ', 'UQCRC2',
+        'SURF1', 'SCO1', 'SCO2', 'COX10', 'COX14', 'COX15', 'COX20',
+        'COA5', 'COA6', 'COA7', 'PET100',
+        'COX4I1', 'COX6A1', 'COX6B1', 'COX7B', 'COX8A',
+        'ATP5F1A', 'ATP5F1D', 'ATP5F1E', 'TMEM70',
+        'TIMM50', 'TIMM8A', 'DNAJC19', 'AGK',
+        'CHCHD2', 'CHCHD10', 'AIFM1',
+        'HSPA9', 'HSPD1',
+        'AARS2', 'DARS2', 'EARS2', 'FARS2', 'HARS2', 'IARS2', 'LARS2', 'MARS2',
+        'NARS2', 'RARS2', 'SARS2', 'TARS2', 'VARS2', 'YARS2',
+        'GFM1', 'TSFM', 'C12orf65',
+        'POLG', 'POLG2', 'TWNK', 'TFAM', 'RRM2B', 'MPV17', 'DGUOK', 'TK2',
+        'SUCLA2', 'SUCLG1', 'FBXL4',
+        'PDHA1', 'PDHB', 'PDHX', 'DLD',
+        'PC', 'PCCA', 'PCCB', 'MUT',
+        'LIAS', 'LIPT1', 'BOLA3', 'NFU1', 'ISCA1', 'ISCA2', 'IBA57', 'GLRX5',
+        'COQ2', 'COQ4', 'COQ6', 'COQ7', 'COQ8A', 'COQ9', 'PDSS1', 'PDSS2',
+        'SLC25A4', 'SLC25A3', 'SLC25A12', 'SLC25A13',
+        'TAZ', 'SERAC1',
+        'LRPPRC', 'TACO1', 'ELAC2', 'TRNT1',
+    ]
+
+    MITO_PHENOTYPES = [
+        'mitochondrial', 'Leigh', 'MELAS', 'MERRF', 'NARP', 'LHON',
+        'optic atrophy', 'encephalopathy', 'cardiomyopathy', 'myopathy',
+        'Complex I', 'Complex IV', 'OXPHOS', 'respiratory chain', 'lactic acidosis',
+    ]
+
+    mito_genes_upper = [g.upper() for g in MITO_GENES]
+    mask_gene = df_filtered['GeneSymbol'].str.upper().isin(mito_genes_upper)
+
+    phenotype_pattern = '|'.join(MITO_PHENOTYPES)
+    mask_phenotype = df_filtered['PhenotypeList'].str.contains(phenotype_pattern, case=False, na=False)
+
+    df_mito = df_filtered[mask_gene | mask_phenotype].copy()
+
+    records = []
+    for _, row in tqdm(df_mito.iterrows(), total=len(df_mito), desc="Parsing"):
+        name = str(row.get('Name', ''))
+
+        wt, pos, mut = None, None, None
+
+        match = re.search(r'p\.([A-Z][a-z]{2})(\d+)([A-Z][a-z]{2})', name)
+        if match:
+            wt_3, pos_str, mut_3 = match.groups()
+            wt = AA_3TO1.get(wt_3)
+            mut = AA_3TO1.get(mut_3)
+            pos = int(pos_str)
+
+        if not wt:
+            match = re.search(r'p\.([A-Z])(\d+)([A-Z])', name)
+            if match:
+                wt, pos_str, mut = match.groups()
+                pos = int(pos_str)
+
+        if not (wt and mut and pos):
+            continue
+
+        if wt not in 'ACDEFGHIKLMNPQRSTVWY' or mut not in 'ACDEFGHIKLMNPQRSTVWY':
+            continue
+
+        clin_sig = str(row.get('ClinicalSignificance', '')).lower()
+
+        if 'pathogenic' in clin_sig and 'benign' not in clin_sig and 'conflicting' not in clin_sig:
+            label = 1
+        elif 'benign' in clin_sig and 'pathogenic' not in clin_sig and 'conflicting' not in clin_sig:
+            label = 0
+        else:
+            continue
+
+        records.append({
+            'gene_symbol': str(row['GeneSymbol']).upper(),
+            'position': pos - 1,
+            'wt_aa': wt,
+            'mut_aa': mut,
+            'label': label,
+            'source': 'ClinVar',
+            'clinical_significance': row.get('ClinicalSignificance', ''),
+            'review_status': str(row.get('ReviewStatus', '')),
+        })
+
+    df_clinvar = pd.DataFrame(records)
+    df_clinvar['mutation_key'] = df_clinvar['gene_symbol'] + '_' + df_clinvar['position'].astype(str) + '_' + df_clinvar['mut_aa']
+    df_clinvar = df_clinvar.drop_duplicates(subset='mutation_key', keep='first')
+
+    df_clinvar.to_parquet(clinvar_parsed_file)
+
+print(df_clinvar['label'].value_counts())
+
+print(df_clinvar['gene_symbol'].value_counts().head(15))
+
+
+
+genes_clinvar = set(df_clinvar['gene_symbol'].unique())
+genes_mapped = set(gene_to_acc.keys())
+genes_found = genes_clinvar & genes_mapped
+genes_missing = genes_clinvar - genes_mapped
+
+print(f"    ClinVar: {len(genes_clinvar)}")
+print(f"    trouvés: {len(genes_found)} ({100*len(genes_found)/len(genes_clinvar):.1f}%)")
+print(f"    manquants: {len(genes_missing)}")
+
+if genes_missing and len(genes_missing) <= 20:
+    print(f"   Manquants: {genes_missing}")
+
+validated = []
+stats = {'found': 0, 'not_found': 0, 'mismatch': 0}
+
+for _, row in tqdm(df_clinvar.iterrows(), total=len(df_clinvar), desc="Validation"):
+    gene = row['gene_symbol']
+
+    acc = gene_to_acc.get(gene)
+    if not acc:
+        for variant in [gene.replace('-', ''), gene.split('-')[0], gene.split(';')[0]]:
+            variant = variant.upper()
+            if variant in gene_to_acc:
+                acc = gene_to_acc[variant]
+                break
+
+    if not acc:
+        stats['not_found'] += 1
+        continue
+
+    seq = seq_dict.get(acc, '')
+    if not seq:
+        stats['not_found'] += 1
+        continue
+
+    pos = row['position']
+    wt = row['wt_aa']
+    mut = row['mut_aa']
+
+    if 0 <= pos < len(seq) and seq[pos] == wt:
+        info = acc_to_info.get(acc, {})
+
+        validated.append({
+            'uniprot_acc': acc,
+            'gene_symbol': gene,
+            'position': pos,
+            'wt_aa': wt,
+            'mut_aa': mut,
+            'label': row['label'],
+            'source': 'ClinVar',
+            'review_status': row.get('review_status', ''),
+            'cysteine_fraction': info.get('cysteine_fraction', 0),
+            'protein_name': info.get('protein_name', ''),
+        })
+        stats['found'] += 1
+    else:
+        stats['mismatch'] += 1
+
+
+
+if len(df_validated) > 0:
+    df_validated['mutation_id'] = df_validated['wt_aa'] + (df_validated['position'] + 1).astype(str) + df_validated['mut_aa']
+    df_validated['n_terminal'] = df_validated['position'] < 50
+    df_validated['cysteine_gained'] = df_validated['mut_aa'] == 'C'
+    df_validated['cysteine_lost'] = df_validated['wt_aa'] == 'C'
+    df_validated['ros_axis'] = df_validated['cysteine_lost'] | df_validated['cysteine_gained'] | (df_validated['cysteine_fraction'] > 0.03)
+    df_validated['import_axis'] = df_validated['n_terminal']
+
+    df_validated['mutation_key'] = df_validated['uniprot_acc'] + '_' + df_validated['position'].astype(str) + '_' + df_validated['mut_aa']
+    df_validated = df_validated.drop_duplicates(subset='mutation_key', keep='first')
+
+    df_validated.to_parquet(PATHS['data_processed'] / 'mutations_dataset_final.parquet')
+    df_validated.to_csv(PATHS['data_processed'] / 'mutations_dataset_final.tsv', sep='\t', index=False)

scripts/build_mito_clinvar_dataset.py.py

@@ -0,0 +1,377 @@
+# -*- coding: utf-8 -*-
+"""Untitled17.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1GwdSjrwh3f6QCzOa8KHr_XkWy0KmZvdV
+"""
+
+import pandas as pd
+import numpy as np
+import gzip
+import re
+from pathlib import Path
+from tqdm import tqdm
+
+
+
+PATHS = {
+    'data_raw': BASE_PATH / 'data' / 'raw',
+    'data_processed': BASE_PATH / 'data' / 'processed',
+}
+
+for path in PATHS.values():
+    path.mkdir(parents=True, exist_ok=True)
+
+AA_3TO1 = {
+    'Ala': 'A', 'Arg': 'R', 'Asn': 'N', 'Asp': 'D', 'Cys': 'C',
+    'Glu': 'E', 'Gln': 'Q', 'Gly': 'G', 'His': 'H', 'Ile': 'I',
+    'Leu': 'L', 'Lys': 'K', 'Met': 'M', 'Phe': 'F', 'Pro': 'P',
+    'Ser': 'S', 'Thr': 'T', 'Trp': 'W', 'Tyr': 'Y', 'Val': 'V'
+}
+
+
+print(f"   Fichier: {clinvar_file}")
+print(f"   Taille: {clinvar_file.stat().st_size / 1e6:.1f} MB")
+
+with gzip.open(clinvar_file, "rt") as f:
+    df_raw = pd.read_csv(f, sep="\t", low_memory=False)
+
+print(f"   ✓ Lignes : {len(df_raw):,}")
+print(f"   ✓ Colonnes: {len(df_raw.columns)}")
+
+for i, col in enumerate(df_raw.columns):
+    print(f"      {i}: {col}")
+
+
+
+
+gene_col = 'GeneSymbol' if 'GeneSymbol' in df_raw.columns else 'Gene'
+name_col = 'Name' if 'Name' in df_raw.columns else None
+clin_sig_col = 'ClinicalSignificance' if 'ClinicalSignificance' in df_raw.columns else 'ClinSig'
+phenotype_col = 'PhenotypeList' if 'PhenotypeList' in df_raw.columns else None
+
+print(f"    gène: {gene_col}")
+print(f"    nom: {name_col}")
+print(f"    signification: {clin_sig_col}")
+print(f"    phénotype: {phenotype_col}")
+
+df_filtered = df_raw[
+    df_raw[gene_col].notna() &
+    df_raw[clin_sig_col].str.contains("athogenic|enign", case=False, na=False)
+].copy()
+
+
+MITO_GENES = [
+    'OPA1', 'MFN1', 'MFN2', 'DNM1L', 'FIS1',
+    'AFG3L2', 'SPG7', 'OMA1', 'YME1L1', 'LONP1', 'CLPP', 'HTRA2',
+    'NDUFAF1', 'NDUFAF2', 'NDUFAF3', 'NDUFAF4', 'NDUFAF5', 'NDUFAF6', 'NDUFAF7', 'NDUFAF8',
+    'NUBPL', 'ACAD9', 'TIMMDC1', 'FOXRED1', 'ECSIT',
+    'NDUFS1', 'NDUFS2', 'NDUFS3', 'NDUFS4', 'NDUFS6', 'NDUFS7', 'NDUFS8',
+    'NDUFV1', 'NDUFV2', 'NDUFA1', 'NDUFA2', 'NDUFA9', 'NDUFA10', 'NDUFA11', 'NDUFA12', 'NDUFA13',
+    'NDUFB3', 'NDUFB8', 'NDUFB9', 'NDUFB10', 'NDUFB11',
+    'SDHA', 'SDHB', 'SDHC', 'SDHD', 'SDHAF1', 'SDHAF2',
+    'BCS1L', 'TTC19', 'UQCRB', 'UQCRQ', 'UQCRC2', 'UQCRFS1', 'CYC1',
+    'SURF1', 'SCO1', 'SCO2', 'COX10', 'COX14', 'COX15', 'COX20',
+    'COA5', 'COA6', 'COA7', 'COA8', 'PET100', 'PET117',
+    'COX4I1', 'COX4I2', 'COX5A', 'COX6A1', 'COX6A2', 'COX6B1', 'COX6C', 'COX7A1', 'COX7B', 'COX8A',
+    'ATP5F1A', 'ATP5F1B', 'ATP5F1C', 'ATP5F1D', 'ATP5F1E',
+    'ATP5MC1', 'ATP5MC2', 'ATP5MC3', 'ATP5MG', 'ATP5PB', 'ATP5PD', 'ATP5PF',
+    'TMEM70', 'ATPAF2',
+    'TIMM50', 'TIMM44', 'TIMM23', 'TIMM22', 'TIMM8A', 'TIMM8B', 'TIMM13',
+    'TOMM20', 'TOMM22', 'TOMM40', 'TOMM70',
+    'DNAJC19', 'PAM16', 'MAGMAS', 'AGK',
+    'CHCHD2', 'CHCHD10', 'CHCHD4', 'AIFM1', 'GFER',
+    'COX17', 'COX19', 'SCO1', 'SCO2',
+    'HSPA9', 'HSPD1', 'HSPE1', 'CLPB',
+    'AARS2', 'CARS2', 'DARS2', 'EARS2', 'FARS2', 'GARS1', 'HARS2', 'IARS2',
+    'KARS1', 'LARS2', 'MARS2', 'NARS2', 'PARS2', 'QARS1', 'RARS2', 'SARS2',
+    'TARS2', 'VARS2', 'WARS2', 'YARS2',
+    'GFM1', 'GFM2', 'TSFM', 'TUFM', 'MRPS16', 'MRPS22', 'MRPL3', 'MRPL12', 'MRPL44',
+    'C12orf65', 'RMND1', 'GTPBP3', 'MTO1', 'TRMU',
+    'POLG', 'POLG2', 'TWNK', 'TFAM', 'TFB1M', 'TFB2M', 'TEFM',
+    'RRM2B', 'MPV17', 'DGUOK', 'TK2', 'SUCLA2', 'SUCLG1', 'ABAT',
+    'PDHA1', 'PDHB', 'PDHX', 'DLD', 'DLAT',
+    'BCKDHA', 'BCKDHB', 'DBT',
+    'PC', 'PCCA', 'PCCB', 'MUT', 'MMAA', 'MMAB', 'MMACHC', 'MMADHC',
+    'LIAS', 'LIPT1', 'LIPT2', 'BOLA3', 'NFU1', 'ISCA1', 'ISCA2', 'IBA57',
+    'GLRX5', 'FDXR', 'FDX1', 'FDX2',
+    'COQ2', 'COQ4', 'COQ5', 'COQ6', 'COQ7', 'COQ8A', 'COQ8B', 'COQ9', 'PDSS1', 'PDSS2',
+    'FBXL4', 'SLC25A4', 'SLC25A3', 'SLC25A12', 'SLC25A13', 'SLC25A19', 'SLC25A22',
+    'SERAC1', 'TAZ', 'DCAKD',
+    'LRPPRC', 'TACO1', 'MTFMT', 'ELAC2', 'TRNT1',
+    'PNPT1', 'PUS1', 'FASTKD2',
+    'IDH2', 'IDH3A', 'IDH3B', 'IDH3G',
+]
+
+MITO_PHENOTYPES = [
+    'mitochondrial', 'Leigh', 'MELAS', 'MERRF', 'NARP', 'LHON',
+    'Kearns-Sayre', 'CPEO', 'optic atrophy', 'encephalopathy',
+    'cardiomyopathy', 'myopathy', 'Complex I', 'Complex II',
+    'Complex III', 'Complex IV', 'Complex V', 'OXPHOS',
+    'respiratory chain', 'lactic acidosis', 'Alpers',
+    'Pearson', 'Barth', 'Sengers', 'aminoacyl-tRNA',
+]
+
+mito_genes_upper = [g.upper() for g in MITO_GENES]
+
+mask_gene = df_filtered[gene_col].str.upper().isin(mito_genes_upper)
+
+mask_phenotype = pd.Series(False, index=df_filtered.index)
+if phenotype_col and phenotype_col in df_filtered.columns:
+    phenotype_pattern = '|'.join(MITO_PHENOTYPES)
+    mask_phenotype = df_filtered[phenotype_col].str.contains(phenotype_pattern, case=False, na=False)
+
+df_mito = df_filtered[mask_gene | mask_phenotype].copy()
+
+print(f"\n    {mask_gene.sum():,}")
+print(f"    {mask_phenotype.sum():,}")
+print(f"   Total (union): {len(df_mito):,}")
+
+
+
+records = []
+
+for _, row in tqdm(df_mito.iterrows(), total=len(df_mito), desc="Parsing"):
+    name = str(row.get('Name', ''))
+
+    wt, pos, mut = None, None, None
+
+    match = re.search(r'p\.([A-Z][a-z]{2})(\d+)([A-Z][a-z]{2})', name)
+    if match:
+        wt_3, pos_str, mut_3 = match.groups()
+        wt = AA_3TO1.get(wt_3)
+        mut = AA_3TO1.get(mut_3)
+        pos = int(pos_str)
+
+    if not wt:
+        match = re.search(r'p\.([A-Z])(\d+)([A-Z])', name)
+        if match:
+            wt, pos_str, mut = match.groups()
+            pos = int(pos_str)
+
+    if not wt:
+        match = re.search(r'\(p\.([A-Z][a-z]{2})(\d+)([A-Z][a-z]{2})\)', name)
+        if match:
+            wt_3, pos_str, mut_3 = match.groups()
+            wt = AA_3TO1.get(wt_3)
+            mut = AA_3TO1.get(mut_3)
+            pos = int(pos_str)
+
+    if not (wt and mut and pos):
+        continue
+
+    if wt not in 'ACDEFGHIKLMNPQRSTVWY' or mut not in 'ACDEFGHIKLMNPQRSTVWY':
+        continue
+
+    clin_sig = str(row.get(clin_sig_col, '')).lower()
+
+    if 'pathogenic' in clin_sig and 'benign' not in clin_sig and 'conflicting' not in clin_sig:
+        label = 1
+    elif 'benign' in clin_sig and 'pathogenic' not in clin_sig and 'conflicting' not in clin_sig:
+        label = 0
+    else:
+        continue
+
+    records.append({
+        'gene_symbol': str(row[gene_col]).upper(),
+        'position': pos - 1,
+        'wt_aa': wt,
+        'mut_aa': mut,
+        'label': label,
+        'source': 'ClinVar',
+        'clinical_significance': row.get(clin_sig_col, ''),
+        'review_status': str(row.get('ReviewStatus', '')),
+        'phenotype': str(row.get(phenotype_col, ''))[:100] if phenotype_col else '',
+    })
+
+df_parsed = pd.DataFrame(records)
+
+
+if len(df_parsed) > 0:
+
+    print(df_parsed['label'].value_counts())
+
+
+    print(df_parsed['gene_symbol'].value_counts().head(15))
+
+    df_parsed['mutation_key'] = df_parsed['gene_symbol'] + '_' + df_parsed['position'].astype(str) + '_' + df_parsed['mut_aa']
+    df_parsed = df_parsed.drop_duplicates(subset='mutation_key', keep='first')
+    print(f"\n   Après dédoublonnage: {len(df_parsed):,}")
+
+uniprot_file = PATHS['data_raw'] / 'uniprot_mito_extended.parquet'
+proteins_file = PATHS['data_processed'] / 'proteins_targeted.parquet'
+
+seq_dict = {}
+gene_to_acc = {}
+acc_to_info = {}
+
+if uniprot_file.exists():
+    df_uniprot = pd.read_parquet(uniprot_file)
+    for _, row in df_uniprot.iterrows():
+        acc = row['accession']
+        seq = row['sequence']
+        gene = str(row['gene_name']).upper() if pd.notna(row['gene_name']) else ''
+
+        seq_dict[acc] = seq
+        acc_to_info[acc] = {
+            'cysteine_fraction': row.get('cysteine_fraction', seq.count('C')/len(seq) if seq else 0),
+            'mito_region': row.get('mito_region', 'Unknown'),
+        }
+
+        if gene:
+            gene_to_acc[gene] = acc
+            gene_to_acc[gene.replace('-', '')] = acc
+
+    print(f"   Protéines UniProt: {len(df_uniprot):,}")
+
+if proteins_file.exists():
+    df_proteins = pd.read_parquet(proteins_file)
+    for _, row in df_proteins.iterrows():
+        acc = row['accession']
+        seq = row['sequence']
+        gene = row['gene_symbol'].upper()
+
+        if acc not in seq_dict:
+            seq_dict[acc] = seq
+        gene_to_acc[gene] = acc
+
+    print(f"   Protéines : {len(df_proteins)}")
+
+print(f"    séquences: {len(seq_dict):,}")
+print(f"    mappés: {len(gene_to_acc):,}")
+
+if len(df_parsed) > 0:
+    genes_clinvar = set(df_parsed['gene_symbol'].unique())
+    genes_mapped = set(gene_to_acc.keys())
+    genes_found = genes_clinvar & genes_mapped
+    genes_missing = genes_clinvar - genes_mapped
+
+    print(f"\n   Gènes : {len(genes_clinvar)}")
+    print(f"    trouvés  : {len(genes_found)}")
+    print(f"    manquants: {len(genes_missing)}")
+
+    if genes_missing:
+        print(f"   Exemples manquants: {list(genes_missing)[:10]}")
+
+
+
+validated = []
+stats = {'not_found': 0, 'seq_mismatch': 0, 'valid': 0}
+
+for _, row in tqdm(df_parsed.iterrows(), total=len(df_parsed), desc="Validation"):
+    gene = row['gene_symbol']
+
+    acc = gene_to_acc.get(gene)
+    if not acc:
+        for variant in [gene.replace('-', ''), gene.split('-')[0]]:
+            if variant in gene_to_acc:
+                acc = gene_to_acc[variant]
+                break
+
+    if not acc:
+        stats['not_found'] += 1
+        continue
+
+    seq = seq_dict.get(acc, '')
+    if not seq:
+        stats['not_found'] += 1
+        continue
+
+    pos = row['position']
+    wt = row['wt_aa']
+    mut = row['mut_aa']
+
+    if 0 <= pos < len(seq):
+        if seq[pos] == wt:
+            info = acc_to_info.get(acc, {})
+
+            validated.append({
+                'uniprot_acc': acc,
+                'gene_symbol': gene,
+                'position': pos,
+                'wt_aa': wt,
+                'mut_aa': mut,
+                'label': row['label'],
+                'source': 'ClinVar',
+                'review_status': row.get('review_status', ''),
+                'clinical_significance': row.get('clinical_significance', ''),
+                'phenotype': row.get('phenotype', ''),
+                'cysteine_fraction': info.get('cysteine_fraction', 0),
+                'mito_region': info.get('mito_region', 'Unknown'),
+            })
+            stats['valid'] += 1
+        else:
+            stats['seq_mismatch'] += 1
+    else:
+        stats['seq_mismatch'] += 1
+
+df_validated = pd.DataFrame(validated)
+
+
+if len(df_validated) > 0:
+    print(f"\n   Labels validés:")
+    print(df_validated['label'].value_counts())
+
+
+
+benign_file = PATHS['data_processed'] / 'mutations_master.parquet'
+
+if benign_file.exists():
+    df_benign_existing = pd.read_parquet(benign_file)
+    df_benign_existing = df_benign_existing.copy()
+    df_benign_existing['label'] = 0
+    df_benign_existing['source'] = 'gnomAD_UniProt'
+    print(f"   Socle bénin existant: {len(df_benign_existing)}")
+else:
+    df_benign_existing = pd.DataFrame()
+    print("   Pas de socle bénin existant")
+
+
+
+datasets = []
+
+if len(df_validated) > 0:
+    datasets.append(df_validated)
+    print(f"   + ClinVar validé: {len(df_validated)}")
+
+if len(df_benign_existing) > 0:
+    cols_needed = ['uniprot_acc', 'position', 'wt_aa', 'mut_aa', 'label', 'source']
+    cols_available = [c for c in cols_needed if c in df_benign_existing.columns]
+
+    df_benign_clean = df_benign_existing[cols_available].copy()
+
+    if 'gene_symbol' in df_benign_existing.columns:
+        df_benign_clean['gene_symbol'] = df_benign_existing['gene_symbol']
+
+    datasets.append(df_benign_clean)
+    print(f"   + Bénins existants: {len(df_benign_clean)}")
+
+if datasets:
+    df_final = pd.concat(datasets, ignore_index=True)
+
+    df_final['mutation_key'] = (
+        df_final['uniprot_acc'].astype(str) + '_' +
+        df_final['position'].astype(str) + '_' +
+        df_final['mut_aa'].astype(str)
+    )
+    df_final['priority'] = df_final['source'].apply(lambda x: 0 if 'ClinVar' in str(x) else 1)
+    df_final = df_final.sort_values('priority')
+    df_final = df_final.drop_duplicates(subset='mutation_key', keep='first')
+    df_final = df_final.drop(columns=['priority', 'mutation_key'])
+
+    print(f"\n   ✓ Dataset final: {len(df_final):,}")
+else:
+    df_final = pd.DataFrame()
+
+
+
+    if 'gene_symbol' in df_final.columns:
+        patho_by_gene = df_final[df_final['label']==1]['gene_symbol'].value_counts().head(20)
+        print(patho_by_gene)
+
+    df_final.to_parquet(PATHS['data_processed'] / 'mutations_dataset_final.parquet')
+    df_final.to_csv(PATHS['data_processed'] / 'mutations_dataset_final.tsv', sep='\t', index=False)
+
+    df_parsed.to_parquet(PATHS['data_raw'] / 'clinvar_mito_parsed.parquet')

scripts/build_mutation_dataset.py.py

@@ -0,0 +1,162 @@
+# -*- coding: utf-8 -*-
+"""Untitled17.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1GwdSjrwh3f6QCzOa8KHr_XkWy0KmZvdV
+"""
+
+import pandas as pd
+import numpy as np
+from ast import literal_eval
+import re
+
+df_disprot = pd.read_parquet(PATHS['disprot'] / 'disprot_data.parquet')
+df_uniprot = pd.read_parquet(PATHS['uniprot'] / 'uniprot_mitochondrial.parquet')
+df_clinvar = pd.read_parquet(PATHS['clinvar'] / 'clinvar_variants.parquet')
+df_mobidb = pd.read_parquet(PATHS['mobidb'] / 'mobidb_data.parquet')
+
+print(f"    DisProt: {len(df_disprot)} ")
+print(f"    UniProt: {len(df_uniprot)} ")
+print(f"    ClinVar: {len(df_clinvar)} ")
+print(f"    MobiDB: {len(df_mobidb)} ")
+
+
+mito_accs = set(df_uniprot['uniprot_acc'].unique())
+
+df_disprot_mito = df_disprot[df_disprot['uniprot_acc'].isin(mito_accs)].copy()
+print(f"   ✓ DisProt : {len(df_disprot_mito)} régions ({df_disprot_mito['uniprot_acc'].nunique()} protéines)")
+
+idp_mito_accs = set(df_disprot_mito['uniprot_acc'].unique())
+
+
+
+
+
+
+
+def parse_protein_change(change_str: str) -> dict:
+    if not change_str or pd.isna(change_str):
+        return None
+
+
+    aa_map = {
+        'Ala': 'A', 'Arg': 'R', 'Asn': 'N', 'Asp': 'D', 'Cys': 'C',
+        'Gln': 'Q', 'Glu': 'E', 'Gly': 'G', 'His': 'H', 'Ile': 'I',
+        'Leu': 'L', 'Lys': 'K', 'Met': 'M', 'Phe': 'F', 'Pro': 'P',
+        'Ser': 'S', 'Thr': 'T', 'Trp': 'W', 'Tyr': 'Y', 'Val': 'V',
+        'Ter': '*'
+    }
+
+    pattern = r'([A-Z][a-z]{2})(\d+)([A-Z][a-z]{2})'
+    match = re.match(pattern, change_str)
+
+    if match:
+        wt_3 = match.group(1)
+        pos = int(match.group(2))
+        mut_3 = match.group(3)
+
+        wt_1 = aa_map.get(wt_3, '?')
+        mut_1 = aa_map.get(mut_3, '?')
+
+        if wt_1 != '?' and mut_1 != '?' and mut_1 != '*':
+            return {
+                'position': pos - 1,
+                'wt_aa': wt_1,
+                'mut_aa': mut_1
+            }
+
+    return None
+
+parsed_mutations = []
+for idx, row in df_clinvar.iterrows():
+    parsed = parse_protein_change(row['protein_change'])
+    if parsed:
+        parsed['clinvar_id'] = row['clinvar_id']
+        parsed['gene'] = row['gene']
+        parsed['is_pathogenic'] = row['is_pathogenic']
+        parsed['is_benign'] = row['is_benign']
+        parsed['clinical_significance'] = row['clinical_significance']
+        parsed_mutations.append(parsed)
+
+df_mutations = pd.DataFrame(parsed_mutations)
+print(f"   ✓ {len(df_mutations)} mutations parsées avec succès")
+
+n_pathogenic = df_mutations['is_pathogenic'].sum()
+n_benign = df_mutations['is_benign'].sum()
+print(f"   ✓ Pathognes {n_pathogenic}")
+print(f"   ✓ Bénin: {n_benign}")
+
+
+
+
+
+
+gene_to_seq = {}
+gene_to_acc = {}
+for _, row in df_uniprot.iterrows():
+    gene = row['gene_name']
+    if gene and row['sequence']:
+        gene_to_seq[gene] = row['sequence']
+        gene_to_acc[gene] = row['uniprot_acc']
+
+df_mutations['sequence'] = df_mutations['gene'].map(gene_to_seq)
+df_mutations['uniprot_acc'] = df_mutations['gene'].map(gene_to_acc)
+
+df_mutations_valid = df_mutations.dropna(subset=['sequence']).copy()
+
+def validate_mutation(row):
+    seq = row['sequence']
+    pos = row['position']
+    wt = row['wt_aa']
+
+    if pos < 0 or pos >= len(seq):
+        return False
+
+    actual_aa = seq[pos]
+    return actual_aa == wt
+
+df_mutations_valid['is_valid'] = df_mutations_valid.apply(validate_mutation, axis=1)
+df_mutations_final = df_mutations_valid[df_mutations_valid['is_valid']].copy()
+
+print(f"   ✓ {len(df_mutations_final)} mutations validé")
+
+
+df_pathogenic = df_mutations_final[df_mutations_final['is_pathogenic']].copy()
+df_benign = df_mutations_final[df_mutations_final['is_benign']].copy()
+
+print(f"   Pathogènes : {len(df_pathogenic)}")
+print(f"   Bénins : {len(df_benign)}")
+
+df_pathogenic['label'] = 1
+df_benign['label'] = 0
+
+df_dataset = pd.concat([df_pathogenic, df_benign], ignore_index=True)
+df_dataset = df_dataset.sample(frac=1, random_state=42).reset_index(drop=True)
+
+print(f"   ✓ : {len(df_dataset)} mutations")
+
+
+
+disorder_regions_by_acc = {}
+for acc in df_disprot['uniprot_acc'].unique():
+    regions = df_disprot[df_disprot['uniprot_acc'] == acc][['region_start', 'region_end']].values.tolist()
+    disorder_regions_by_acc[acc] = regions
+
+def is_in_disorder_region(row):
+    acc = row['uniprot_acc']
+    pos = row['position'] + 1
+
+    if acc not in disorder_regions_by_acc:
+        return None
+    for start, end in disorder_regions_by_acc[acc]:
+        if start <= pos <= end:
+            return True
+    return False
+
+df_dataset['in_disorder_region'] = df_dataset.apply(is_in_disorder_region, axis=1)
+
+n_in_disorder = df_dataset['in_disorder_region'].sum()
+n_annotated = df_dataset['in_disorder_region'].notna().sum()
+print(f"   ✓ {n_in_disorder}/{n_annotated} ")

scripts/data_download.py

@@ -0,0 +1,344 @@
+# -*- coding: utf-8 -*-
+"""Untitled17.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1GwdSjrwh3f6QCzOa8KHr_XkWy0KmZvdV
+"""
+
+import requests
+import json
+import gzip
+import time
+import pandas as pd
+from io import StringIO, BytesIO
+from tqdm.auto import tqdm
+import pickle
+
+class DisProtDownloader:
+
+    BASE_URL = "https://disprot.org/api"
+
+    def __init__(self, save_dir: Path):
+        self.save_dir = save_dir
+        self.save_dir.mkdir(parents=True, exist_ok=True)
+
+    def download_all(self) -> pd.DataFrame:
+        """Télécharger toutes les entrées DisProt"""
+        print("\n📥 Téléchargement DisProt...")
+
+        url = f"{self.BASE_URL}/search?release=current&show_ambiguous=false&format=json"
+
+        try:
+            response = requests.get(url, timeout=120)
+            response.raise_for_status()
+            data = response.json()
+
+            entries = data.get('data', [])
+            print(f"   ✓ {len(entries)} entrées téléchargées")
+
+            records = []
+            for entry in tqdm(entries, desc="   Parsing"):
+                acc = entry.get('acc', '')
+                disprot_id = entry.get('disprot_id', '')
+                name = entry.get('name', '')
+                sequence = entry.get('sequence', '')
+                organism = entry.get('organism', '')
+
+
+                for region in entry.get('regions', []):
+                    records.append({
+                        'disprot_id': disprot_id,
+                        'uniprot_acc': acc,
+                        'name': name,
+                        'organism': organism,
+                        'sequence': sequence,
+                        'region_start': region.get('start', 0),
+                        'region_end': region.get('end', 0),
+                        'region_type': region.get('type', ''),
+                        'term_name': region.get('term_name', ''),
+                        'evidence': region.get('evidence', '')
+                    })
+
+            df = pd.DataFrame(records)
+
+
+            save_path = self.save_dir / 'disprot_data.parquet'
+            df.to_parquet(save_path)
+            print(f"   ✓ Sauvegardé: {save_path}")
+
+            return df
+
+        except Exception as e:
+            print(f"   ✗ Erreur DisProt: {e}")
+            return pd.DataFrame()
+
+
+
+
+class UniProtDownloader:
+
+    BASE_URL = "https://rest.uniprot.org/uniprotkb"
+
+    def __init__(self, save_dir: Path):
+        self.save_dir = save_dir
+        self.save_dir.mkdir(parents=True, exist_ok=True)
+
+    def download_mitochondrial_human(self, max_results: int = 5000) -> pd.DataFrame:
+        """Télécharger les protéines mitochondriales humaines"""
+
+        query = "(organism_id:9606) AND (cc_scl_term:SL-0173)"
+
+        url = f"{self.BASE_URL}/search"
+        params = {
+            'query': query,
+            'format': 'json',
+            'size': min(500, max_results),
+            'fields': 'accession,id,protein_name,gene_names,sequence,length,cc_subcellular_location,ft_domain,ft_region,organism_name'
+        }
+
+        all_results = []
+
+        try:
+            response = requests.get(url, params=params, timeout=120)
+            response.raise_for_status()
+            data = response.json()
+
+            results = data.get('results', [])
+            all_results.extend(results)
+            print(f"   ✓ {len(results)} ")
+
+            next_link = data.get('link', {}).get('next')
+            while next_link and len(all_results) < max_results:
+                time.sleep(0.5)
+                response = requests.get(next_link, timeout=120)
+                response.raise_for_status()
+                data = response.json()
+                results = data.get('results', [])
+                all_results.extend(results)
+                next_link = data.get('link', {}).get('next')
+                print(f"   ... {len(all_results)} protéines")
+
+            records = []
+            for entry in tqdm(all_results[:max_results], desc="   Parsing"):
+                acc = entry.get('primaryAccession', '')
+
+                seq_data = entry.get('sequence', {})
+                sequence = seq_data.get('value', '')
+                length = seq_data.get('length', 0)
+
+                protein_name = ''
+                if 'proteinDescription' in entry:
+                    rec_name = entry['proteinDescription'].get('recommendedName', {})
+                    protein_name = rec_name.get('fullName', {}).get('value', '')
+
+                genes = entry.get('genes', [])
+                gene_name = genes[0].get('geneName', {}).get('value', '') if genes else ''
+
+                subcell = entry.get('comments', [])
+                locations = []
+                for comment in subcell:
+                    if comment.get('commentType') == 'SUBCELLULAR LOCATION':
+                        for loc in comment.get('subcellularLocations', []):
+                            loc_val = loc.get('location', {}).get('value', '')
+                            if loc_val:
+                                locations.append(loc_val)
+
+                features = entry.get('features', [])
+                disorder_regions = []
+                for feat in features:
+                    if feat.get('type') in ['Region', 'Compositional bias']:
+                        desc = feat.get('description', '').lower()
+                        if 'disordered' in desc or 'low complexity' in desc:
+                            loc = feat.get('location', {})
+                            start = loc.get('start', {}).get('value', 0)
+                            end = loc.get('end', {}).get('value', 0)
+                            disorder_regions.append((start, end))
+
+                records.append({
+                    'uniprot_acc': acc,
+                    'protein_name': protein_name,
+                    'gene_name': gene_name,
+                    'sequence': sequence,
+                    'length': length,
+                    'subcellular_locations': '|'.join(locations),
+                    'disorder_regions': str(disorder_regions),
+                    'is_mitochondrial': True
+                })
+
+            df = pd.DataFrame(records)
+
+            save_path = self.save_dir / 'uniprot_mitochondrial.parquet'
+            df.to_parquet(save_path)
+            print(f"   ✓ : {save_path}")
+
+            return df
+
+        except Exception as e:
+            print(f"   ✗ : {e}")
+            return pd.DataFrame()
+
+
+class ClinVarDownloader:
+
+    def __init__(self, save_dir: Path):
+        self.save_dir = save_dir
+        self.save_dir.mkdir(parents=True, exist_ok=True)
+
+    def download_variants_for_genes(self, gene_list: List[str], max_per_gene: int = 100) -> pd.DataFrame:
+        base_url = "https://eutils.ncbi.nlm.nih.gov/entrez/eutils"
+
+        all_variants = []
+
+        for gene in tqdm(gene_list[:50], desc="   Gènes"):
+            try:
+                search_url = f"{base_url}/esearch.fcgi"
+                search_params = {
+                    'db': 'clinvar',
+                    'term': f'{gene}[gene] AND ("pathogenic"[clinsig] OR "benign"[clinsig]) AND "single nucleotide variant"[vartype]',
+                    'retmax': max_per_gene,
+                    'retmode': 'json'
+                }
+
+                response = requests.get(search_url, params=search_params, timeout=30)
+                response.raise_for_status()
+                search_data = response.json()
+
+                id_list = search_data.get('esearchresult', {}).get('idlist', [])
+
+                if not id_list:
+                    continue
+
+
+                time.sleep(0.34)
+
+                fetch_url = f"{base_url}/esummary.fcgi"
+                fetch_params = {
+                    'db': 'clinvar',
+                    'id': ','.join(id_list[:max_per_gene]),
+                    'retmode': 'json'
+                }
+
+                response = requests.get(fetch_url, params=fetch_params, timeout=30)
+                response.raise_for_status()
+                fetch_data = response.json()
+
+                results = fetch_data.get('result', {})
+
+                for uid in id_list[:max_per_gene]:
+                    if uid not in results or uid == 'uids':
+                        continue
+
+                    variant = results[uid]
+
+
+                    title = variant.get('title', '')
+                    clinical_sig = variant.get('clinical_significance', {}).get('description', '')
+
+                    protein_change = ''
+                    if '(p.' in title:
+                        start = title.find('(p.') + 3
+                        end = title.find(')', start)
+                        protein_change = title[start:end]
+
+                    all_variants.append({
+                        'clinvar_id': uid,
+                        'gene': gene,
+                        'title': title,
+                        'protein_change': protein_change,
+                        'clinical_significance': clinical_sig,
+                        'is_pathogenic': 'pathogenic' in clinical_sig.lower(),
+                        'is_benign': 'benign' in clinical_sig.lower()
+                    })
+
+                time.sleep(0.34)
+
+            except Exception as e:
+                print(f"   Error {gene}: {e}")
+                continue
+
+        df = pd.DataFrame(all_variants)
+
+        if len(df) > 0:
+            save_path = self.save_dir / 'clinvar_variants.parquet'
+            df.to_parquet(save_path)
+            print(f"   ✓ {len(df)}  {save_path}")
+        else:
+            print("None")
+
+        return df
+
+class MobiDBDownloader:
+
+    BASE_URL = "https://mobidb.org/api/download"
+
+    def __init__(self, save_dir: Path):
+        self.save_dir = save_dir
+        self.save_dir.mkdir(parents=True, exist_ok=True)
+
+    def download_for_proteins(self, uniprot_accs: List[str]) -> pd.DataFrame:
+
+
+        records = []
+
+        for acc in tqdm(uniprot_accs[:200], desc="   Protéines"):
+            try:
+                url = f"https://mobidb.org/api/download?acc={acc}&format=json"
+                response = requests.get(url, timeout=30)
+
+                if response.status_code != 200:
+                    continue
+
+                data = response.json()
+
+                consensus = data.get('consensus', {})
+                disorder_regions = consensus.get('disorder', {}).get('regions', [])
+
+                plddt_regions = consensus.get('plddt', {}).get('regions', [])
+
+                records.append({
+                    'uniprot_acc': acc,
+                    'disorder_content': data.get('disorder_content', 0),
+                    'disorder_regions': str(disorder_regions),
+                    'plddt_low_regions': str(plddt_regions),
+                    'sequence_length': data.get('length', 0)
+                })
+
+                time.sleep(0.1)
+
+            except Exception as e:
+                continue
+
+        df = pd.DataFrame(records)
+
+        if len(df) > 0:
+            save_path = self.save_dir / 'mobidb_data.parquet'
+            df.to_parquet(save_path)
+            print(f"   ✓ {len(df)} entrées sauvegardées: {save_path}")
+
+        return df
+
+
+disprot_downloader = DisProtDownloader(PATHS['disprot'])
+df_disprot = disprot_downloader.download_all()
+
+uniprot_downloader = UniProtDownloader(PATHS['uniprot'])
+df_uniprot = uniprot_downloader.download_mitochondrial_human(max_results=2000)
+
+if len(df_uniprot) > 0:
+    mito_genes = df_uniprot['gene_name'].dropna().unique().tolist()
+    mito_genes = [g for g in mito_genes if g]
+
+    clinvar_downloader = ClinVarDownloader(PATHS['clinvar'])
+    df_clinvar = clinvar_downloader.download_variants_for_genes(mito_genes[:100])
+else:
+    df_clinvar = pd.DataFrame()
+
+if len(df_uniprot) > 0:
+    mito_accs = df_uniprot['uniprot_acc'].tolist()
+
+    mobidb_downloader = MobiDBDownloader(PATHS['mobidb'])
+    df_mobidb = mobidb_downloader.download_for_proteins(mito_accs[:200])
+else:
+    df_mobidb = pd.DataFrame()

scripts/esm2_t33_650M_UR50D.py

@@ -0,0 +1,278 @@
+# -*- coding: utf-8 -*-
+"""Untitled17.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1GwdSjrwh3f6QCzOa8KHr_XkWy0KmZvdV
+"""
+
+import torch
+import pandas as pd
+import numpy as np
+from pathlib import Path
+from tqdm import tqdm
+import gc
+
+
+PATHS = {
+    'data_frozen': BASE_PATH / 'data' / 'frozen',
+    'data_raw': BASE_PATH / 'data' / 'raw',
+    'features': BASE_PATH / 'features',
+    'embeddings': BASE_PATH / 'embeddings',
+}
+
+PATHS['embeddings'].mkdir(parents=True, exist_ok=True)
+
+# Vérifier GPU
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+print(f"   Device: {device}")
+if torch.cuda.is_available():
+    print(f"   GPU: {torch.cuda.get_device_name(0)}")
+    print(f"   Memory: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB")
+
+
+try:
+    import esm
+    model_name = "esm2_t33_650M_UR50D"
+    model, alphabet = esm.pretrained.esm2_t33_650M_UR50D()
+except ImportError:
+    import subprocess
+    subprocess.run(['pip', 'install', 'fair-esm'], check=True)
+    import esm
+    model, alphabet = esm.pretrained.esm2_t33_650M_UR50D()
+
+model = model.to(device)
+model.eval()
+
+batch_converter = alphabet.get_batch_converter()
+
+embedding_dim = model.embed_dim
+
+df_full = pd.read_parquet(PATHS['features'] / 'features_classical_full.parquet')
+df_strict = pd.read_parquet(PATHS['features'] / 'features_classical_mito_strict.parquet')
+
+df_uniprot = pd.read_parquet(PATHS['data_raw'] / 'uniprot_human_reviewed.parquet')
+seq_dict = dict(zip(df_uniprot['accession'], df_uniprot['sequence']))
+
+print(f"    full: {len(df_full):,}")
+print(f"    strict: {len(df_strict):,}")
+print(f"   Séquences: {len(seq_dict):,}")
+
+
+def extract_esm_embeddings(sequences_dict, model, alphabet, batch_converter,
+                           device, window=25, batch_size=4, max_length=1022):
+    embeddings = {}
+
+    data = [(acc, seq[:max_length]) for acc, seq in sequences_dict.items() if seq]
+
+    print(f"   Extraction pour {len(data)} protéines...")
+
+    for i in tqdm(range(0, len(data), batch_size), desc="ESM-2"):
+        batch_data = data[i:i+batch_size]
+
+        try:
+            batch_labels, batch_strs, batch_tokens = batch_converter(batch_data)
+            batch_tokens = batch_tokens.to(device)
+
+            with torch.no_grad():
+                results = model(batch_tokens, repr_layers=[33], return_contacts=False)
+
+            representations = results["representations"][33]
+
+            for j, (acc, seq) in enumerate(batch_data):
+                seq_len = len(seq)
+
+
+                seq_repr = representations[j, 1:seq_len+1, :]
+                global_emb = seq_repr.mean(dim=0).cpu().numpy()
+
+                embeddings[acc] = global_emb
+
+            del batch_tokens, results, representations
+            if device.type == 'cuda':
+                torch.cuda.empty_cache()
+
+        except Exception as e:
+            print(f"   ⚠️ Erreur batch {i}: {e}")
+            continue
+
+    return embeddings
+
+proteins_full = set(df_full['uniprot_acc'].unique())
+proteins_strict = set(df_strict['uniprot_acc'].unique())
+proteins_all = proteins_full | proteins_strict
+
+
+seq_to_process = {acc: seq_dict[acc] for acc in proteins_all if acc in seq_dict}
+
+embeddings_global = extract_esm_embeddings(
+    seq_to_process,
+    model,
+    alphabet,
+    batch_converter,
+    device,
+    batch_size=2 if device.type == 'cuda' else 1,  # Réduire si GPU limité
+    max_length=1022
+)
+
+
+def extract_local_embeddings(df, seq_dict, model, alphabet, batch_converter,
+                             device, window=25, batch_size=8, max_per_batch=100):
+
+    local_embeddings = []
+
+    data = []
+    for idx, row in df.iterrows():
+        acc = row['uniprot_acc']
+        pos = row['position']
+        seq = seq_dict.get(acc, '')
+
+        if not seq or pos >= len(seq):
+            data.append((idx, None))
+            continue
+
+        start = max(0, pos - window)
+        end = min(len(seq), pos + window + 1)
+        local_seq = seq[start:end]
+
+        rel_pos = pos - start
+
+        data.append((idx, local_seq, rel_pos))
+
+    batch_data = []
+    batch_info = []
+
+    for item in tqdm(data, desc="Local embeddings"):
+        if item[1] is None:
+            local_embeddings.append({
+                'idx': item[0],
+                'embedding': np.zeros(embedding_dim)
+            })
+            continue
+
+        idx, local_seq, rel_pos = item
+        batch_data.append((f"mut_{idx}", local_seq))
+        batch_info.append((idx, rel_pos, len(local_seq)))
+
+        if len(batch_data) >= batch_size:
+            try:
+                batch_labels, batch_strs, batch_tokens = batch_converter(batch_data)
+                batch_tokens = batch_tokens.to(device)
+
+                with torch.no_grad():
+                    results = model(batch_tokens, repr_layers=[33], return_contacts=False)
+
+                representations = results["representations"][33]
+
+                for j, (idx, rel_pos, seq_len) in enumerate(batch_info):
+                    if rel_pos < seq_len:
+                        mut_emb = representations[j, rel_pos + 1, :].cpu().numpy()
+                    else:
+                        mut_emb = representations[j, 1:seq_len+1, :].mean(dim=0).cpu().numpy()
+
+                    local_embeddings.append({
+                        'idx': idx,
+                        'embedding': mut_emb
+                    })
+
+                del batch_tokens, results, representations
+                if device.type == 'cuda':
+                    torch.cuda.empty_cache()
+
+            except Exception as e:
+                for idx, _, _ in batch_info:
+                    local_embeddings.append({
+                        'idx': idx,
+                        'embedding': np.zeros(embedding_dim)
+                    })
+
+            batch_data = []
+            batch_info = []
+
+    if batch_data:
+        try:
+            batch_labels, batch_strs, batch_tokens = batch_converter(batch_data)
+            batch_tokens = batch_tokens.to(device)
+
+            with torch.no_grad():
+                results = model(batch_tokens, repr_layers=[33], return_contacts=False)
+
+            representations = results["representations"][33]
+
+            for j, (idx, rel_pos, seq_len) in enumerate(batch_info):
+                if rel_pos < seq_len:
+                    mut_emb = representations[j, rel_pos + 1, :].cpu().numpy()
+                else:
+                    mut_emb = representations[j, 1:seq_len+1, :].mean(dim=0).cpu().numpy()
+
+                local_embeddings.append({
+                    'idx': idx,
+                    'embedding': mut_emb
+                })
+        except:
+            for idx, _, _ in batch_info:
+                local_embeddings.append({
+                    'idx': idx,
+                    'embedding': np.zeros(embedding_dim)
+                })
+
+    return local_embeddings
+
+local_emb_full = extract_local_embeddings(
+    df_full, seq_dict, model, alphabet, batch_converter, device,
+    window=25, batch_size=8
+)
+
+local_emb_strict = extract_local_embeddings(
+    df_strict, seq_dict, model, alphabet, batch_converter, device,
+    window=25, batch_size=8
+)
+
+def create_embedding_matrix(df, embeddings_global, local_embeddings, embedding_dim):
+
+    n_samples = len(df)
+
+    X_global = np.zeros((n_samples, embedding_dim))
+    X_local = np.zeros((n_samples, embedding_dim))
+
+    for i, row in df.iterrows():
+        acc = row['uniprot_acc']
+        idx = df.index.get_loc(i)
+
+        if acc in embeddings_global:
+            X_global[idx] = embeddings_global[acc]
+
+    local_dict = {item['idx']: item['embedding'] for item in local_embeddings}
+    for i, row in df.iterrows():
+        idx = df.index.get_loc(i)
+        if i in local_dict:
+            X_local[idx] = local_dict[i]
+
+    X_combined = np.concatenate([X_global, X_local], axis=1)
+
+    return X_global, X_local, X_combined
+
+X_global_full, X_local_full, X_combined_full = create_embedding_matrix(
+    df_full, embeddings_global, local_emb_full, embedding_dim
+)
+
+X_global_strict, X_local_strict, X_combined_strict = create_embedding_matrix(
+    df_strict, embeddings_global, local_emb_strict, embedding_dim
+)
+
+print(f"   Global: {X_global_full.shape}")
+print(f"   Local: {X_local_full.shape}")
+print(f"   Combiné: {X_combined_full.shape}")
+
+np.save(PATHS['embeddings'] / 'embeddings_global_full.npy', X_global_full)
+np.save(PATHS['embeddings'] / 'embeddings_local_full.npy', X_local_full)
+np.save(PATHS['embeddings'] / 'embeddings_combined_full.npy', X_combined_full)
+
+np.save(PATHS['embeddings'] / 'embeddings_global_strict.npy', X_global_strict)
+np.save(PATHS['embeddings'] / 'embeddings_local_strict.npy', X_local_strict)
+np.save(PATHS['embeddings'] / 'embeddings_combined_strict.npy', X_combined_strict)
+
+import pickle
+with open(PATHS['embeddings'] / 'embeddings_by_protein.pkl', 'wb') as f:
+    pickle.dump(embeddings_global, f)

scripts/final_mlp_embedding_model.py.py

@@ -0,0 +1,230 @@
+# -*- coding: utf-8 -*-
+"""Untitled17.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1GwdSjrwh3f6QCzOa8KHr_XkWy0KmZvdV
+"""
+
+import pandas as pd
+import numpy as np
+from pathlib import Path
+from sklearn.preprocessing import StandardScaler
+from sklearn.metrics import roc_auc_score, average_precision_score, roc_curve, precision_recall_curve
+from sklearn.linear_model import LogisticRegression
+import matplotlib.pyplot as plt
+from tqdm import tqdm
+import pickle
+import torch
+import torch.nn as nn
+import warnings
+warnings.filterwarnings('ignore')
+
+
+PATHS = {
+    'features': BASE_PATH / 'features',
+    'embeddings': BASE_PATH / 'embeddings',
+    'models': BASE_PATH / 'models',
+    'results': BASE_PATH / 'results',
+    'figures': BASE_PATH / 'results' / 'figures',
+}
+
+df_features = 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_features.columns if c not in id_cols]
+
+X_features = df_features[feature_cols].values.astype(np.float32)
+X_features = np.nan_to_num(X_features, nan=0.0, posinf=0.0, neginf=0.0)
+y = df_features['label'].values
+proteins = df_features['uniprot_acc'].values
+
+X_emb_combined = np.load(PATHS['embeddings'] / 'embeddings_combined_full.npy').astype(np.float32)
+X_emb_local = np.load(PATHS['embeddings'] / 'embeddings_local_full.npy').astype(np.float32)
+
+print(f"    {X_features.shape}")
+print(f"    {X_emb_combined.shape}")
+
+
+
+from sklearn.decomposition import PCA
+
+pca_combined = PCA(n_components=128, random_state=42)
+X_emb_pca = pca_combined.fit_transform(X_emb_combined).astype(np.float32)
+
+pca_local = PCA(n_components=64, random_state=42)
+X_emb_local_pca = pca_local.fit_transform(X_emb_local).astype(np.float32)
+
+
+
+configs = [
+    {'name': 'Features classiques', 'X': X_features},
+    {'name': 'Embeddings ESM-2', 'X': X_emb_pca},
+    {'name': 'Features + Embeddings', 'X': np.concatenate([X_features, X_emb_pca], axis=1)},
+    {'name': 'Features + Emb. Local', 'X': np.concatenate([X_features, X_emb_local_pca], axis=1)},
+]
+
+class SimpleMLP(nn.Module):
+    def __init__(self, input_dim, hidden_dim=256):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(input_dim, hidden_dim),
+            nn.ReLU(),
+            nn.Dropout(0.3),
+            nn.Linear(hidden_dim, hidden_dim // 2),
+            nn.ReLU(),
+            nn.Dropout(0.2),
+            nn.Linear(hidden_dim // 2, 1),
+            nn.Sigmoid()
+        )
+
+    def forward(self, x):
+        return self.net(x).squeeze()
+
+def train_mlp(X_train, y_train, X_test, input_dim, device, epochs=50, lr=0.001):
+
+    model = SimpleMLP(input_dim).to(device)
+    optimizer = torch.optim.Adam(model.parameters(), lr=lr, weight_decay=1e-4)
+    criterion = nn.BCELoss()
+
+    X_train_t = torch.FloatTensor(X_train).to(device)
+    y_train_t = torch.FloatTensor(y_train).to(device)
+    X_test_t = torch.FloatTensor(X_test).to(device)
+
+    model.train()
+    batch_size = 512
+
+    for epoch in range(epochs):
+        perm = torch.randperm(len(X_train_t))
+
+        for i in range(0, len(X_train_t), batch_size):
+            idx = perm[i:i+batch_size]
+
+            optimizer.zero_grad()
+            outputs = model(X_train_t[idx])
+            loss = criterion(outputs, y_train_t[idx])
+            loss.backward()
+            optimizer.step()
+
+    model.eval()
+    with torch.no_grad():
+        y_pred = model(X_test_t).cpu().numpy()
+
+    return y_pred
+
+def evaluate_lpocv_gpu(X, y, proteins, device, epochs=30):
+
+    unique_proteins = np.unique(proteins)
+    results = []
+
+    scaler = StandardScaler()
+    X_scaled = scaler.fit_transform(X)
+
+    for protein in tqdm(unique_proteins, desc="LPOCV GPU"):
+        test_mask = proteins == protein
+        train_mask = ~test_mask
+
+        if test_mask.sum() < 2:
+            continue
+
+        X_train, y_train = X_scaled[train_mask], y[train_mask]
+        X_test, y_test = X_scaled[test_mask], y[test_mask]
+
+        y_pred = train_mlp(X_train, y_train, X_test, X.shape[1], device, epochs=epochs)
+
+        for pred, true in zip(y_pred, y_test):
+            results.append({'y_true': true, 'y_pred': float(pred)})
+
+    df_res = pd.DataFrame(results)
+
+    if len(df_res) > 0 and len(df_res['y_true'].unique()) > 1:
+        auc_roc = roc_auc_score(df_res['y_true'], df_res['y_pred'])
+        auc_pr = average_precision_score(df_res['y_true'], df_res['y_pred'])
+    else:
+        auc_roc, auc_pr = 0, 0
+
+    return auc_roc, auc_pr, df_res
+
+results_all = {}
+
+for cfg in configs:
+    print(f"\n   📊 {cfg['name']}...")
+
+    auc_roc, auc_pr, df_res = evaluate_lpocv_gpu(
+        cfg['X'], y, proteins, device, epochs=30
+    )
+
+    results_all[cfg['name']] = {
+        'auc_roc': auc_roc,
+        'auc_pr': auc_pr,
+        'predictions': df_res,
+        'n_features': cfg['X'].shape[1],
+    }
+
+    print(f"      AUC-ROC: {auc_roc:.4f}")
+    print(f"      AUC-PR:  {auc_pr:.4f}")
+
+
+def evaluate_lpocv_logreg(X, y, proteins):
+
+    unique_proteins = np.unique(proteins)
+    results = []
+
+    scaler = StandardScaler()
+    X_scaled = scaler.fit_transform(X)
+
+    for protein in tqdm(unique_proteins, desc="LPOCV LogReg", leave=False):
+        test_mask = proteins == protein
+        train_mask = ~test_mask
+
+        if test_mask.sum() < 2:
+            continue
+
+        X_train, y_train = X_scaled[train_mask], y[train_mask]
+        X_test, y_test = X_scaled[test_mask], y[test_mask]
+
+        model = LogisticRegression(max_iter=500, C=0.1, random_state=42)
+        model.fit(X_train, y_train)
+        y_pred = model.predict_proba(X_test)[:, 1]
+
+        for pred, true in zip(y_pred, y_test):
+            results.append({'y_true': true, 'y_pred': pred})
+
+    df_res = pd.DataFrame(results)
+
+    if len(df_res) > 0:
+        auc_roc = roc_auc_score(df_res['y_true'], df_res['y_pred'])
+        auc_pr = average_precision_score(df_res['y_true'], df_res['y_pred'])
+    else:
+        auc_roc, auc_pr = 0, 0
+
+    return auc_roc, auc_pr
+
+for cfg in configs:
+    auc_roc, auc_pr = evaluate_lpocv_logreg(cfg['X'], y, proteins)
+    results_all[cfg['name']]['auc_roc_logreg'] = auc_roc
+    results_all[cfg['name']]['auc_pr_logreg'] = auc_pr
+    print(f"   {cfg['name']}: LogReg AUC-ROC = {auc_roc:.4f}")
+
+
+comparison_data = []
+for name, res in results_all.items():
+    comparison_data.append({
+        'Configuration': name,
+        'Features': res['n_features'],
+        'AUC-ROC (MLP)': res['auc_roc'],
+        'AUC-PR (MLP)': res['auc_pr'],
+        'AUC-ROC (LogReg)': res.get('auc_roc_logreg', 0),
+    })
+
+df_comparison = pd.DataFrame(comparison_data)
+df_comparison = df_comparison.sort_values('AUC-ROC (MLP)', ascending=False)
+
+print("\n" + df_comparison.to_string(index=False))
+
+best_name = df_comparison.iloc[0]['Configuration']
+best_auc = df_comparison.iloc[0]['AUC-ROC (MLP)']
+print(f"\n   🏆 Meilleur: {best_name} (AUC-ROC = {best_auc:.4f})")
+
+df_comparison.to_csv(PATHS['results'] / 'comparison_final.csv', index=False)

scripts/hierarchical_validation_no_leakage.py.py

@@ -0,0 +1,426 @@
+# -*- coding: utf-8 -*-
+"""Untitled17.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1GwdSjrwh3f6QCzOa8KHr_XkWy0KmZvdV
+"""
+
+import pandas as pd
+import numpy as np
+from pathlib import Path
+from sklearn.preprocessing import StandardScaler
+from sklearn.decomposition import PCA
+from sklearn.metrics import roc_auc_score, average_precision_score
+from sklearn.linear_model import LogisticRegression
+import matplotlib.pyplot as plt
+from tqdm import tqdm
+import torch
+import torch.nn as nn
+import pickle
+import warnings
+warnings.filterwarnings('ignore')
+
+PATHS = {
+    'features': BASE_PATH / 'features',
+    'embeddings': BASE_PATH / 'embeddings',
+    'results': BASE_PATH / 'results',
+    'figures': BASE_PATH / 'results' / 'figures',
+}
+
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+print(f"   Device: {device}")
+
+
+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 = df[feature_cols].values.astype(np.float32)
+X_features = np.nan_to_num(X_features, 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
+
+
+
+
+AXES = {
+    'OXPHOS_CI': ['NDUFAF1', 'NDUFAF2', 'NDUFAF3', 'NDUFAF4', 'NDUFAF5', 'NDUFAF6',
+                  'NDUFS1', 'NDUFS2', 'NDUFS3', 'NDUFS4', 'NDUFS6', 'NDUFS7', 'NDUFS8',
+                  'NDUFV1', 'NDUFV2', 'NDUFA1', 'NDUFA2', 'NDUFA9', 'NDUFA10', 'NDUFA11',
+                  'ACAD9', 'TIMMDC1', 'FOXRED1', 'NUBPL'],
+
+    'OXPHOS_CIV': ['SURF1', 'SCO1', 'SCO2', 'COX10', 'COX14', 'COX15', 'COX20',
+                   'COA5', 'COA6', 'COA7', 'COX4I1', 'COX6A1', 'COX6B1', 'COX7B',
+                   'COX8A', 'PET100', 'PET117'],
+
+    'DYNAMICS': ['OPA1', 'MFN1', 'MFN2', 'DNM1L', 'FIS1', 'AFG3L2', 'SPG7',
+                 'YME1L1', 'OMA1', 'LONP1'],
+
+    'TRANSLATION': ['AARS2', 'DARS2', 'EARS2', 'FARS2', 'HARS2', 'IARS2', 'LARS2',
+                    'MARS2', 'NARS2', 'RARS2', 'SARS2', 'TARS2', 'VARS2', 'YARS2',
+                    'GFM1', 'TSFM', 'TUFM', 'C12orf65'],
+
+    'MTDNA': ['POLG', 'POLG2', 'TWNK', 'TFAM', 'RRM2B', 'MPV17', 'DGUOK', 'TK2',
+              'SUCLA2', 'SUCLG1', 'FBXL4'],
+
+    'METABOLISM': ['PDHA1', 'PDHB', 'PDHX', 'DLD', 'PC', 'PCCA', 'PCCB', 'MUT',
+                   'LIAS', 'LIPT1', 'BOLA3', 'NFU1', 'ISCA1', 'ISCA2', 'GLRX5'],
+
+    'IMPORT': ['TIMM50', 'TIMM8A', 'DNAJC19', 'AGK', 'TOMM20', 'TOMM40',
+               'HSPA9', 'HSPD1'],
+
+    'REDOX_IMS': ['CHCHD2', 'CHCHD10', 'CHCHD4', 'AIFM1', 'COX17', 'GFER'],
+}
+
+df['axis'] = 'OTHER'
+for axis_name, genes in AXES.items():
+    mask = df['gene_symbol'].isin(genes)
+    df.loc[mask, 'axis'] = axis_name
+
+for axis in df['axis'].value_counts().index:
+    n = (df['axis'] == axis).sum()
+    n_patho = (df[df['axis'] == axis]['label'] == 1).sum()
+    print(f"      {axis:<15} n={n:>5}  ({n_patho} patho)")
+
+def get_family(gene):
+    prefixes = ['NDUF', 'COX', 'ATP5', 'SDH', 'UQCR', 'TIM', 'TOM',
+                'SLC25', 'MRPL', 'MRPS', 'CHCHD', 'COA']
+    for prefix in prefixes:
+        if gene.startswith(prefix):
+            return prefix
+    return gene[:3] if len(gene) >= 3 else gene
+
+df['family'] = df['gene_symbol'].apply(get_family)
+axes = df['axis'].values
+families = df['family'].values
+
+
+
+def prepare_data_no_leakage(X_features, X_emb_raw, train_mask, test_mask, n_pca=128):
+
+    X_feat_train = X_features[train_mask]
+    X_feat_test = X_features[test_mask]
+    X_emb_train = X_emb_raw[train_mask]
+    X_emb_test = X_emb_raw[test_mask]
+
+    scaler_feat = StandardScaler()
+    X_feat_train_s = scaler_feat.fit_transform(X_feat_train)
+    X_feat_test_s = scaler_feat.transform(X_feat_test)
+
+    pca = PCA(n_components=min(n_pca, X_emb_train.shape[0] - 1), random_state=42)
+    X_emb_train_pca = pca.fit_transform(X_emb_train)
+    X_emb_test_pca = pca.transform(X_emb_test)
+
+    scaler_emb = StandardScaler()
+    X_emb_train_s = scaler_emb.fit_transform(X_emb_train_pca)
+    X_emb_test_s = scaler_emb.transform(X_emb_test_pca)
+
+    X_train = np.concatenate([X_feat_train_s, X_emb_train_s], axis=1)
+    X_test = np.concatenate([X_feat_test_s, X_emb_test_s], axis=1)
+
+    return X_train.astype(np.float32), X_test.astype(np.float32)
+
+class SimpleMLP(nn.Module):
+    def __init__(self, input_dim, hidden_dim=256):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(input_dim, hidden_dim),
+            nn.ReLU(),
+            nn.Dropout(0.3),
+            nn.Linear(hidden_dim, hidden_dim // 2),
+            nn.ReLU(),
+            nn.Dropout(0.2),
+            nn.Linear(hidden_dim // 2, 1),
+            nn.Sigmoid()
+        )
+
+    def forward(self, x):
+        return self.net(x).squeeze()
+
+def train_mlp_predict(X_train, y_train, X_test, device, epochs=50):
+    """Entraîner MLP et prédire"""
+    model = SimpleMLP(X_train.shape[1]).to(device)
+    optimizer = torch.optim.Adam(model.parameters(), lr=0.001, weight_decay=1e-4)
+    criterion = nn.BCELoss()
+
+    X_train_t = torch.FloatTensor(X_train).to(device)
+    y_train_t = torch.FloatTensor(y_train).to(device)
+    X_test_t = torch.FloatTensor(X_test).to(device)
+
+    model.train()
+    for _ in range(epochs):
+        optimizer.zero_grad()
+        loss = criterion(model(X_train_t), y_train_t)
+        loss.backward()
+        optimizer.step()
+
+    model.eval()
+    with torch.no_grad():
+        return model(X_test_t).cpu().numpy()
+
+def train_logreg_predict(X_train, y_train, X_test):
+    """Entraîner LogReg et prédire (plus rapide)"""
+    model = LogisticRegression(max_iter=500, C=0.1, random_state=42)
+    model.fit(X_train, y_train)
+    return model.predict_proba(X_test)[:, 1]
+
+
+unique_proteins = np.unique(proteins)
+lpocv_results = []
+
+for protein in tqdm(unique_proteins, desc="LPOCV"):
+    test_mask = proteins == protein
+    train_mask = ~test_mask
+
+    if test_mask.sum() < 2:
+        continue
+
+    y_train, y_test = y[train_mask], y[test_mask]
+
+    X_train, X_test = prepare_data_no_leakage(
+        X_features, X_emb_raw, train_mask, test_mask, n_pca=128
+    )
+
+    y_pred = train_mlp_predict(X_train, y_train, X_test, device, epochs=30)
+
+    for pred, true in zip(y_pred, y_test):
+        lpocv_results.append({'y_true': int(true), 'y_pred': float(pred)})
+
+df_lpocv = pd.DataFrame(lpocv_results)
+auc_lpocv = roc_auc_score(df_lpocv['y_true'], df_lpocv['y_pred'])
+ap_lpocv = average_precision_score(df_lpocv['y_true'], df_lpocv['y_pred'])
+
+unique_axes = [a for a in df['axis'].unique() if a != 'OTHER']
+lao_results = {}
+
+for axis in tqdm(unique_axes, desc="Leave-Axis-Out"):
+    test_mask = axes == axis
+    train_mask = axes != axis
+
+    n_test = test_mask.sum()
+    if n_test < 20:
+        continue
+
+    y_train, y_test = y[train_mask], y[test_mask]
+
+    if len(np.unique(y_test)) < 2:
+        continue
+
+    X_train, X_test = prepare_data_no_leakage(
+        X_features, X_emb_raw, train_mask, test_mask, n_pca=128
+    )
+
+    y_pred = train_logreg_predict(X_train, y_train, X_test)
+
+    auc = roc_auc_score(y_test, y_pred)
+    ap = average_precision_score(y_test, y_pred)
+
+    lao_results[axis] = {
+        'n': int(n_test),
+        'n_patho': int((y_test == 1).sum()),
+        'auc_roc': float(auc),
+        'auc_pr': float(ap),
+    }
+
+    print(f"   {axis:<15} n={n_test:>4}  AUC={auc:.3f}  AP={ap:.3f}")
+
+family_counts = df['family'].value_counts()
+large_families = family_counts[family_counts >= 50].index.tolist()
+
+lfo_results = {}
+
+for family in tqdm(large_families[:12], desc="Leave-Family-Out"):
+    test_mask = families == family
+    train_mask = families != family
+
+    n_test = test_mask.sum()
+    y_train, y_test = y[train_mask], y[test_mask]
+
+    if len(np.unique(y_test)) < 2:
+        continue
+
+    X_train, X_test = prepare_data_no_leakage(
+        X_features, X_emb_raw, train_mask, test_mask, n_pca=128
+    )
+
+    y_pred = train_logreg_predict(X_train, y_train, X_test)
+
+    auc = roc_auc_score(y_test, y_pred)
+
+    lfo_results[family] = {
+        'n': int(n_test),
+        'auc_roc': float(auc),
+    }
+
+    print(f"   {family:<10} n={n_test:>4}  AUC={auc:.3f}")
+
+
+strata = {
+    'Cysteine_lost': df['cysteine_lost'] == 1,
+    'Cysteine_gained': df['cysteine_gained'] == 1,
+    'Charge_modified': (df['charge_introducing'] == 1) | (df['charge_removing'] == 1),
+    'Proline_intro': df['proline_introduced'] == 1,
+    'N_terminal': df['is_n_terminal'] == 1,
+    'Cys_rich_prot': df['protein_cysteine_fraction'] > 0.03,
+    'ROS_vulnerable': df['ros_vulnerability_score'] > 2,
+}
+
+strata_results = {}
+
+for strata_name, mask in strata.items():
+    n = mask.sum()
+    if n < 50:
+        continue
+
+    idx_strata = np.where(mask)[0]
+    proteins_strata = proteins[mask]
+    unique_prot_strata = np.unique(proteins_strata)
+
+    results = []
+    for protein in unique_prot_strata:
+        test_m = proteins_strata == protein
+        train_m = ~test_m
+
+        if test_m.sum() < 2:
+            continue
+
+        train_idx = idx_strata[train_m]
+        test_idx = idx_strata[test_m]
+
+        global_train_mask = np.zeros(len(y), dtype=bool)
+        global_test_mask = np.zeros(len(y), dtype=bool)
+        global_train_mask[train_idx] = True
+        global_test_mask[test_idx] = True
+
+        y_train_s, y_test_s = y[global_train_mask], y[global_test_mask]
+
+        X_train, X_test = prepare_data_no_leakage(
+            X_features, X_emb_raw, global_train_mask, global_test_mask, n_pca=64
+        )
+
+        y_pred = train_logreg_predict(X_train, y_train_s, X_test)
+
+        for pred, true in zip(y_pred, y_test_s):
+            results.append({'y_true': true, 'y_pred': pred})
+
+    if len(results) > 30:
+        df_res = pd.DataFrame(results)
+        if len(df_res['y_true'].unique()) > 1:
+            auc = roc_auc_score(df_res['y_true'], df_res['y_pred'])
+            strata_results[strata_name] = {
+                'n': int(n),
+                'n_patho': int((df.loc[mask, 'label'] == 1).sum()),
+                'auc_roc': float(auc),
+            }
+            print(f"   {strata_name:<20} n={n:>4}  AUC={auc:.3f}")
+
+
+feature_groups = {
+    'Substitution': ['delta_hydrophobicity', 'delta_charge', 'delta_volume',
+                     'delta_disorder_propensity', 'abs_delta_hydro', 'abs_delta_charge',
+                     'abs_delta_volume', 'delta_aromatic'],
+    'Local_context': ['local_hydro_mean', 'local_charge_mean', 'local_disorder_mean',
+                      'local_charged_fraction', 'local_aromatic_fraction',
+                      'local_proline_fraction', 'local_glycine_fraction',
+                      'local_cysteine_fraction', 'local_disorder_promoting',
+                      'local_order_promoting', 'local_sequence_entropy'],
+    'Position': ['position_absolute', 'position_normalized', 'is_n_terminal',
+                 'is_c_terminal', 'distance_to_n_term', 'distance_to_c_term'],
+    'Cysteine_ROS': ['cysteine_gained', 'cysteine_lost', 'cysteine_change',
+                     'nearby_cysteine_count', 'cysteine_in_cys_rich_region',
+                     'ros_vulnerability_score'],
+    'Protein_global': ['protein_length', 'protein_cysteine_count',
+                       'protein_cysteine_fraction', 'protein_charged_fraction',
+                       'protein_disorder_mean'],
+    'Composite': ['idp_disruption_score', 'import_disruption_score'],
+}
+
+np.random.seed(42)
+sample_proteins = np.random.choice(unique_proteins, size=min(80, len(unique_proteins)), replace=False)
+
+def ablation_lpocv(X_feat_ablated, X_emb_raw, y, proteins, sample_proteins, n_pca=64):
+    results = []
+
+    for protein in sample_proteins:
+        test_mask = proteins == protein
+        train_mask = ~test_mask
+
+        if test_mask.sum() < 2:
+            continue
+
+        y_train, y_test = y[train_mask], y[test_mask]
+
+        X_train, X_test = prepare_data_no_leakage(
+            X_feat_ablated, X_emb_raw, train_mask, test_mask, n_pca=n_pca
+        )
+
+        y_pred = train_logreg_predict(X_train, y_train, X_test)
+
+        for pred, true in zip(y_pred, y_test):
+            results.append({'y_true': true, 'y_pred': pred})
+
+    df_res = pd.DataFrame(results)
+    if len(df_res) > 0 and len(df_res['y_true'].unique()) > 1:
+        return roc_auc_score(df_res['y_true'], df_res['y_pred'])
+    return 0
+
+auc_baseline = ablation_lpocv(X_features, X_emb_raw, y, proteins, sample_proteins)
+print(f"   AUC baseline: {auc_baseline:.4f}")
+
+auc_no_emb = ablation_lpocv(X_features, np.zeros_like(X_emb_raw[:, :10]), y, proteins, sample_proteins, n_pca=8)
+print(f"   AUC sans embeddings: {auc_no_emb:.4f}  Δ={auc_no_emb - auc_baseline:+.4f}")
+
+feature_to_idx = {f: i for i, f in enumerate(feature_cols)}
+ablation_results = {'Embeddings_ESM2': {'auc': auc_no_emb, 'delta': auc_no_emb - auc_baseline}}
+
+for group_name, group_features in feature_groups.items():
+    remove_idx = [feature_to_idx[f] for f in group_features if f in feature_to_idx]
+    keep_idx = [i for i in range(len(feature_cols)) if i not in remove_idx]
+
+    X_ablated = X_features[:, keep_idx]
+
+    auc = ablation_lpocv(X_ablated, X_emb_raw, y, proteins, sample_proteins)
+    delta = auc - auc_baseline
+
+    ablation_results[group_name] = {
+        'auc': float(auc),
+        'delta': float(delta),
+        'n_removed': len(remove_idx),
+    }
+
+    print(f"   Sans {group_name:<15} AUC={auc:.4f}  Δ={delta:+.4f}  (-{len(remove_idx)} feat)")
+
+
+lao_mean = np.mean([r['auc_roc'] for r in lao_results.values()]) if lao_results else 0
+lao_std = np.std([r['auc_roc'] for r in lao_results.values()]) if lao_results else 0
+lfo_mean = np.mean([r['auc_roc'] for r in lfo_results.values()]) if lfo_results else 0
+most_important = min(ablation_results, key=lambda x: ablation_results[x]['delta']) if ablation_results else 'N/A'
+
+
+results_summary = {
+    'lpocv': {
+        'auc_roc': float(auc_lpocv),
+        'auc_pr': float(ap_lpocv),
+        'n_predictions': len(df_lpocv),
+    },
+    'leave_axis_out': lao_results,
+    'leave_family_out': lfo_results,
+    'stratification': strata_results,
+    'ablation': ablation_results,
+    'methodology': {
+        'scaler': 'StandardScaler fit on train only',
+        'pca': 'PCA fit on train only (128 components)',
+        'axes_source': 'OMIM, ClinVar, MitoCarta 3.0, KEGG',
+    }
+}
+
+with open(PATHS['results'] / 'hierarchical_validation_final.pkl', 'wb') as f:
+    pickle.dump(results_summary, f)
+
+df_lpocv.to_parquet(PATHS['results'] / 'lpocv_predictions_final.parquet')

scripts/lpocv_validation.py.py

@@ -0,0 +1,193 @@
+# -*- coding: utf-8 -*-
+"""Untitled17.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1GwdSjrwh3f6QCzOa8KHr_XkWy0KmZvdV
+"""
+
+import pandas as pd
+import numpy as np
+from sklearn.ensemble import GradientBoostingClassifier
+from sklearn.metrics import roc_auc_score, average_precision_score, precision_recall_curve, f1_score
+from sklearn.preprocessing import StandardScaler
+from tqdm.auto import tqdm
+import warnings
+warnings.filterwarnings('ignore')
+
+####Leave-Protein-Out Cross-Validation (LPOCV) of the mechanistic pathogenicity model.
+
+
+df_features = pd.read_parquet(PATHS['data_processed'] / 'mutation_features.parquet')
+
+df_features['disorder_x_charge'] = df_features['delta_disorder_propensity'] * df_features['delta_charge']
+df_features['disorder_x_hydro'] = df_features['delta_disorder_propensity'] * df_features['delta_hydrophobicity']
+df_features['ros_x_cysteine'] = df_features['ros_sensitivity'] * df_features['local_cysteine_density']
+df_features['propagation_x_disorder'] = df_features['propagation_extent'] * abs(df_features['predicted_delta_disorder_mean'])
+df_features['disorder_confidence_ratio'] = df_features['predicted_delta_disorder_mean'] / (df_features['predicted_delta_disorder_std'] + 0.01)
+df_features['abs_delta_disorder'] = abs(df_features['delta_disorder_propensity'])
+df_features['abs_delta_charge'] = abs(df_features['delta_charge'])
+df_features['abs_delta_hydro'] = abs(df_features['delta_hydrophobicity'])
+df_features['is_n_terminal'] = (df_features['position'] < 50).astype(int)
+df_features['is_c_terminal'] = 0
+df_features['is_charge_changing'] = (df_features['delta_charge'] != 0).astype(int)
+df_features['is_disorder_increasing'] = (df_features['delta_disorder_propensity'] > 0).astype(int)
+df_features['is_high_ros'] = (df_features['ros_sensitivity'] > 0.5).astype(int)
+df_features['region_matrix'] = (df_features['region_type'] == 'matrix_idr').astype(int)
+df_features['region_ims'] = (df_features['region_type'] == 'ims_idr').astype(int)
+df_features['region_presequence'] = (df_features['region_type'] == 'presequence').astype(int)
+df_features['region_membrane'] = (df_features['region_type'] == 'membrane_adjacent').astype(int)
+
+df_features['has_disorder_annotation'] = df_features['in_disorder_region'].notna()
+df_features['in_disorder_region'] = df_features['in_disorder_region'].fillna(False)
+
+print(f"   ✓ {len(df_features)} mutations")
+print(f"   ✓ {df_features['uniprot_acc'].nunique()} protéines uniques")
+
+
+
+features_mechanistic = [
+    'delta_hydrophobicity', 'delta_charge', 'delta_volume',
+    'delta_disorder_propensity', 'delta_aromatic',
+    'local_charge_density', 'local_disorder_mean', 'local_disorder_variance',
+    'local_hydrophobicity', 'local_aromatic_density',
+    'local_proline_density', 'local_glycine_density', 'local_cysteine_density',
+    'predicted_delta_disorder_mean', 'predicted_delta_disorder_std',
+    'propagation_extent', 'max_effective_delta',
+    'delta_cpr', 'delta_ncpr', 'delta_kappa',
+    'ros_sensitivity', 'import_efficiency_change',
+    'cysteine_gained', 'cysteine_lost', 'disulfide_disruption_risk',
+    'oxidation_sensitivity_change',
+    'region_matrix', 'region_ims', 'region_presequence', 'region_membrane',
+    'disorder_x_charge', 'disorder_x_hydro', 'ros_x_cysteine',
+    'propagation_x_disorder', 'disorder_confidence_ratio',
+    'abs_delta_disorder', 'abs_delta_charge', 'abs_delta_hydro',
+    'is_n_terminal', 'is_charge_changing', 'is_disorder_increasing', 'is_high_ros'
+]
+
+
+def leave_protein_out_cv(df, feature_cols, model_params, threshold=None):
+
+    proteins = df['uniprot_acc'].unique()
+
+    all_y_true = []
+    all_y_prob = []
+    all_y_pred = []
+    protein_results = []
+
+    for protein in tqdm(proteins, desc="LPOCV"):
+        train_mask = df['uniprot_acc'] != protein
+        test_mask = df['uniprot_acc'] == protein
+
+        df_train = df[train_mask]
+        df_test = df[test_mask]
+
+        if len(df_test) < 2 or df_train['label'].sum() < 5:
+            continue
+
+        X_train = df_train[feature_cols].fillna(0).values
+        y_train = df_train['label'].values
+        X_test = df_test[feature_cols].fillna(0).values
+        y_test = df_test['label'].values
+
+        scaler = StandardScaler()
+        X_train_scaled = scaler.fit_transform(X_train)
+        X_test_scaled = scaler.transform(X_test)
+
+        model = GradientBoostingClassifier(**model_params)
+        model.fit(X_train_scaled, y_train)
+
+        y_prob = model.predict_proba(X_test_scaled)[:, 1]
+
+        all_y_true.extend(y_test)
+        all_y_prob.extend(y_prob)
+
+        if y_test.sum() > 0:
+            try:
+                protein_auc = roc_auc_score(y_test, y_prob)
+            except:
+                protein_auc = np.nan
+            protein_results.append({
+                'protein': protein,
+                'n_mutations': len(y_test),
+                'n_pathogenic': y_test.sum(),
+                'auc': protein_auc
+            })
+
+    all_y_true = np.array(all_y_true)
+    all_y_prob = np.array(all_y_prob)
+
+    auc_roc = roc_auc_score(all_y_true, all_y_prob)
+    auc_pr = average_precision_score(all_y_true, all_y_prob)
+
+    if threshold is None:
+        precisions, recalls, thresholds = precision_recall_curve(all_y_true, all_y_prob)
+        f1_scores = 2 * (precisions * recalls) / (precisions + recalls + 1e-10)
+        optimal_idx = np.argmax(f1_scores)
+        threshold = thresholds[optimal_idx] if optimal_idx < len(thresholds) else 0.5
+
+    all_y_pred = (all_y_prob >= threshold).astype(int)
+
+    tp = ((all_y_pred == 1) & (all_y_true == 1)).sum()
+    fp = ((all_y_pred == 1) & (all_y_true == 0)).sum()
+    fn = ((all_y_pred == 0) & (all_y_true == 1)).sum()
+
+    recall = tp / (tp + fn) if (tp + fn) > 0 else 0
+    precision = tp / (tp + fp) if (tp + fp) > 0 else 0
+
+    return {
+        'auc_roc': auc_roc,
+        'auc_pr': auc_pr,
+        'threshold': threshold,
+        'recall': recall,
+        'precision': precision,
+        'y_true': all_y_true,
+        'y_prob': all_y_prob,
+        'protein_results': pd.DataFrame(protein_results)
+    }
+
+model_params = {
+    'n_estimators': 200,
+    'max_depth': 5,
+    'learning_rate': 0.05,
+    'min_samples_split': 10,
+    'min_samples_leaf': 5,
+    'subsample': 0.8,
+    'random_state': 42
+}
+
+results_A = leave_protein_out_cv(df_features, features_mechanistic, model_params)
+
+print(f"   AUC-ROC: {results_A['auc_roc']:.4f}")
+print(f"   AUC-PR:  {results_A['auc_pr']:.4f}")
+print(f"   Seuil:   {results_A['threshold']:.3f}")
+print(f"   Recall:  {results_A['recall']:.2%}")
+print(f"   Precision: {results_A['precision']:.2%}")
+
+
+
+df_protein_results = results_A['protein_results'].dropna()
+df_protein_results = df_protein_results.sort_values('n_pathogenic', ascending=False)
+
+for _, row in df_protein_results.head(10).iterrows():
+    auc_str = f"{row['auc']:.2f}" if not np.isnan(row['auc']) else "N/A"
+    print(f"   {row['protein']}: {row['n_mutations']} mut ({row['n_pathogenic']} patho) - AUC: {auc_str}")
+
+
+validation_results = {
+    'model_A_mechanistic': {
+        'features': features_mechanistic,
+        'auc_roc': results_A['auc_roc'],
+        'auc_pr': results_A['auc_pr'],
+        'threshold': results_A['threshold'],
+        'recall': results_A['recall'],
+        'precision': results_A['precision']
+    },
+
+}
+
+import json
+results_path = PATHS['evaluations'] / 'lpocv_results.json'
+with open(results_path, 'w') as f:
+    json.dump(validation_results, f, indent=2)

scripts/model_comparison_features_vs_esm2.py.py

@@ -0,0 +1,218 @@
+# -*- coding: utf-8 -*-
+"""Untitled17.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1GwdSjrwh3f6QCzOa8KHr_XkWy0KmZvdV
+"""
+
+import pandas as pd
+import numpy as np
+from pathlib import Path
+from sklearn.ensemble import GradientBoostingClassifier
+from sklearn.preprocessing import StandardScaler
+from sklearn.decomposition import PCA
+from sklearn.metrics import roc_auc_score, average_precision_score, roc_curve, precision_recall_curve
+import matplotlib.pyplot as plt
+from tqdm import tqdm
+import pickle
+import warnings
+warnings.filterwarnings('ignore')
+
+PATHS = {
+    'features': BASE_PATH / 'features',
+    'embeddings': BASE_PATH / 'embeddings',
+    'models': BASE_PATH / 'models',
+    'results': BASE_PATH / 'results',
+    'figures': BASE_PATH / 'results' / 'figures',
+}
+
+PATHS['figures'].mkdir(parents=True, exist_ok=True)
+
+
+
+df_features = 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_features.columns if c not in id_cols]
+
+X_features = df_features[feature_cols].values
+X_features = np.nan_to_num(X_features, nan=0.0, posinf=0.0, neginf=0.0)
+y = df_features['label'].values
+proteins = df_features['uniprot_acc'].values
+
+print(f"   Features classiques: {X_features.shape}")
+
+X_emb_combined = np.load(PATHS['embeddings'] / 'embeddings_combined_full.npy')
+X_emb_local = np.load(PATHS['embeddings'] / 'embeddings_local_full.npy')
+
+print(f"{X_emb_combined.shape}")
+print(f"{X_emb_local.shape}")
+
+print(f"\n   {np.sum(y==1)} pathogènes, {np.sum(y==0)} bénins")
+print(f"    {len(np.unique(proteins))}")
+
+
+n_components_combined = 128
+pca_combined = PCA(n_components=n_components_combined, random_state=42)
+X_emb_pca = pca_combined.fit_transform(X_emb_combined)
+print(f"    {X_emb_combined.shape[1]} → {n_components_combined}")
+print(f"     {pca_combined.explained_variance_ratio_.sum():.2%}")
+
+
+n_components_local = 64
+pca_local = PCA(n_components=n_components_local, random_state=42)
+X_emb_local_pca = pca_local.fit_transform(X_emb_local)
+print(f"    {X_emb_local.shape[1]} → {n_components_local}")
+print(f"    {pca_local.explained_variance_ratio_.sum():.2%}")
+
+configs = [
+    {
+        'name': 'Features classiques',
+        'X': X_features,
+    },
+    {
+        'name': 'Embeddings ESM-2',
+        'X': X_emb_pca,
+    },
+    {
+        'name': 'Features + Embeddings',
+        'X': np.concatenate([X_features, X_emb_pca], axis=1),
+    },
+    {
+        'name': 'Features + Emb. Local',
+        'X': np.concatenate([X_features, X_emb_local_pca], axis=1),
+    },
+]
+
+for cfg in configs:
+    print(f"   {cfg['name']}: {cfg['X'].shape[1]} features")
+
+def evaluate_lpocv_fast(X, y, proteins, n_estimators=100, max_depth=4):
+
+    unique_proteins = np.unique(proteins)
+    results = []
+
+    for protein in tqdm(unique_proteins, desc="LPOCV", leave=False):
+        test_mask = proteins == protein
+        train_mask = ~test_mask
+
+        n_test = test_mask.sum()
+        if n_test < 2:
+            continue
+
+        X_train, y_train = X[train_mask], y[train_mask]
+        X_test, y_test = X[test_mask], y[test_mask]
+
+        scaler = StandardScaler()
+        X_train_s = scaler.fit_transform(X_train)
+        X_test_s = scaler.transform(X_test)
+
+        model = GradientBoostingClassifier(
+            n_estimators=n_estimators,
+            max_depth=max_depth,
+            learning_rate=0.1,
+            min_samples_leaf=10,
+            subsample=0.8,
+            random_state=42
+        )
+        model.fit(X_train_s, y_train)
+
+        y_pred = model.predict_proba(X_test_s)[:, 1]
+
+        for pred, true in zip(y_pred, y_test):
+            results.append({'y_true': true, 'y_pred': pred})
+
+    df_res = pd.DataFrame(results)
+
+    if len(df_res) > 0 and len(df_res['y_true'].unique()) > 1:
+        auc_roc = roc_auc_score(df_res['y_true'], df_res['y_pred'])
+        auc_pr = average_precision_score(df_res['y_true'], df_res['y_pred'])
+    else:
+        auc_roc, auc_pr = 0, 0
+
+    return auc_roc, auc_pr, df_res
+
+results_all = {}
+
+for cfg in configs:
+    print(f"\n   📊 {cfg['name']}...")
+
+    auc_roc, auc_pr, df_res = evaluate_lpocv_fast(
+        cfg['X'], y, proteins,
+        n_estimators=100,
+        max_depth=4
+    )
+
+    results_all[cfg['name']] = {
+        'auc_roc': auc_roc,
+        'auc_pr': auc_pr,
+        'predictions': df_res,
+        'n_features': cfg['X'].shape[1],
+    }
+
+    print(f"      AUC-ROC: {auc_roc:.4f}")
+    print(f"      AUC-PR:  {auc_pr:.4f}")
+
+
+best_X = None
+for cfg in configs:
+    if cfg['name'] == best_name:
+        best_X = cfg['X']
+        break
+
+print(f"   Entraînement: {best_name}...")
+
+scaler_final = StandardScaler()
+X_scaled = scaler_final.fit_transform(best_X)
+
+model_final = GradientBoostingClassifier(
+    n_estimators=300,
+    max_depth=5,
+    learning_rate=0.05,
+    min_samples_leaf=10,
+    subsample=0.8,
+    random_state=42
+)
+
+model_final.fit(X_scaled, y)
+
+if 'Features' in best_name:
+    importances = model_final.feature_importances_
+
+    if best_name == 'Features classiques':
+        imp_names = feature_cols
+    elif best_name == 'Features + Embeddings':
+        imp_names = feature_cols + [f'emb_pca_{i}' for i in range(X_emb_pca.shape[1])]
+    else:
+        imp_names = feature_cols + [f'emb_local_{i}' for i in range(X_emb_local_pca.shape[1])]
+
+    importance_df = pd.DataFrame({
+        'feature': imp_names,
+        'importance': importances
+    }).sort_values('importance', ascending=False)
+
+    print("\n   Top 15 features:")
+    for _, row in importance_df.head(15).iterrows():
+        print(f"      {row['importance']:.4f}  {row['feature']}")
+
+    importance_df.to_csv(PATHS['results'] / 'feature_importances_best_model.csv', index=False)
+
+model_data = {
+    'model': model_final,
+    'scaler': scaler_final,
+    'pca_combined': pca_combined if 'Embeddings' in best_name and 'Local' not in best_name else None,
+    'pca_local': pca_local if 'Local' in best_name else None,
+    'feature_cols': feature_cols,
+    'config_name': best_name,
+    'metrics': {
+        'auc_roc_lpocv': results_all[best_name]['auc_roc'],
+        'auc_pr_lpocv': results_all[best_name]['auc_pr'],
+    },
+}
+
+with open(PATHS['models'] / 'model_best.pkl', 'wb') as f:
+    pickle.dump(model_data, f)
+
+df_comparison.to_csv(PATHS['results'] / 'comparison_features_embeddings.csv', index=False)

scripts/phase1_freeze_and_classical_features.py.py

@@ -0,0 +1,308 @@
+# -*- coding: utf-8 -*-
+"""Untitled17.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1GwdSjrwh3f6QCzOa8KHr_XkWy0KmZvdV
+"""
+
+import pandas as pd
+import numpy as np
+from pathlib import Path
+from tqdm import tqdm
+from datetime import datetime
+import hashlib
+import json
+
+
+PATHS = {
+    'data_processed': BASE_PATH / 'data' / 'processed',
+    'data_frozen': BASE_PATH / 'data' / 'frozen',
+    'features': BASE_PATH / 'features',
+}
+
+for path in PATHS.values():
+    path.mkdir(parents=True, exist_ok=True)
+
+AA_PROPERTIES = {
+    'A': {'hydro': 1.8, 'charge': 0, 'volume': 88.6, 'disorder': 0.06, 'aromatic': 0},
+    'R': {'hydro': -4.5, 'charge': 1, 'volume': 173.4, 'disorder': 0.18, 'aromatic': 0},
+    'N': {'hydro': -3.5, 'charge': 0, 'volume': 114.1, 'disorder': 0.14, 'aromatic': 0},
+    'D': {'hydro': -3.5, 'charge': -1, 'volume': 111.1, 'disorder': 0.19, 'aromatic': 0},
+    'C': {'hydro': 2.5, 'charge': 0, 'volume': 108.5, 'disorder': -0.02, 'aromatic': 0},
+    'Q': {'hydro': -3.5, 'charge': 0, 'volume': 143.8, 'disorder': 0.16, 'aromatic': 0},
+    'E': {'hydro': -3.5, 'charge': -1, 'volume': 138.4, 'disorder': 0.20, 'aromatic': 0},
+    'G': {'hydro': -0.4, 'charge': 0, 'volume': 60.1, 'disorder': 0.17, 'aromatic': 0},
+    'H': {'hydro': -3.2, 'charge': 0.5, 'volume': 153.2, 'disorder': 0.10, 'aromatic': 1},
+    'I': {'hydro': 4.5, 'charge': 0, 'volume': 166.7, 'disorder': -0.49, 'aromatic': 0},
+    'L': {'hydro': 3.8, 'charge': 0, 'volume': 166.7, 'disorder': -0.37, 'aromatic': 0},
+    'K': {'hydro': -3.9, 'charge': 1, 'volume': 168.6, 'disorder': 0.21, 'aromatic': 0},
+    'M': {'hydro': 1.9, 'charge': 0, 'volume': 162.9, 'disorder': -0.23, 'aromatic': 0},
+    'F': {'hydro': 2.8, 'charge': 0, 'volume': 189.9, 'disorder': -0.41, 'aromatic': 1},
+    'P': {'hydro': -1.6, 'charge': 0, 'volume': 112.7, 'disorder': 0.41, 'aromatic': 0},
+    'S': {'hydro': -0.8, 'charge': 0, 'volume': 89.0, 'disorder': 0.13, 'aromatic': 0},
+    'T': {'hydro': -0.7, 'charge': 0, 'volume': 116.1, 'disorder': 0.04, 'aromatic': 0},
+    'W': {'hydro': -0.9, 'charge': 0, 'volume': 227.8, 'disorder': -0.35, 'aromatic': 1},
+    'Y': {'hydro': -1.3, 'charge': 0, 'volume': 193.6, 'disorder': -0.26, 'aromatic': 1},
+    'V': {'hydro': 4.2, 'charge': 0, 'volume': 140.0, 'disorder': -0.38, 'aromatic': 0},
+}
+
+
+
+df_full = pd.read_parquet(PATHS['data_processed'] / 'mutations_dataset_final.parquet')
+print(f"   Dataset complet: {len(df_full):,} mutations")
+
+mito_strict_file = PATHS['data_processed'] / 'mutations_dataset_mito_strict.parquet'
+if mito_strict_file.exists():
+    df_strict = pd.read_parquet(mito_strict_file)
+else:
+    STRICT_MITO_GENES = {
+        'OPA1', 'MFN1', 'MFN2', 'DNM1L', 'AFG3L2', 'SPG7', 'LONP1', 'CLPP', 'YME1L1',
+        'NDUFAF1', 'NDUFAF2', 'NDUFAF3', 'NDUFAF4', 'NDUFAF5', 'NDUFAF6', 'NDUFAF7',
+        'NUBPL', 'ACAD9', 'TIMMDC1', 'FOXRED1',
+        'NDUFS1', 'NDUFS2', 'NDUFS3', 'NDUFS4', 'NDUFS6', 'NDUFS7', 'NDUFS8',
+        'NDUFV1', 'NDUFV2', 'NDUFA1', 'NDUFA2', 'NDUFA9', 'NDUFA10', 'NDUFA11', 'NDUFA12', 'NDUFA13',
+        'SDHA', 'SDHB', 'SDHC', 'SDHD', 'SDHAF1', 'SDHAF2',
+        'BCS1L', 'TTC19', 'UQCRB', 'UQCRQ', 'UQCRC2', 'CYC1',
+        'SURF1', 'SCO1', 'SCO2', 'COX10', 'COX14', 'COX15', 'COX20',
+        'COA5', 'COA6', 'COA7', 'PET100', 'COX4I1', 'COX6A1', 'COX6B1', 'COX7B', 'COX8A',
+        'ATP5F1A', 'ATP5F1D', 'ATP5F1E', 'TMEM70', 'ATPAF2',
+        'TIMM50', 'TIMM8A', 'DNAJC19', 'AGK', 'TOMM20', 'TOMM40',
+        'CHCHD2', 'CHCHD10', 'CHCHD4', 'AIFM1', 'COX17',
+        'HSPA9', 'HSPD1', 'HSPE1', 'CLPB',
+        'AARS2', 'DARS2', 'EARS2', 'FARS2', 'HARS2', 'IARS2', 'LARS2', 'MARS2',
+        'NARS2', 'RARS2', 'SARS2', 'TARS2', 'VARS2', 'YARS2',
+        'GFM1', 'TSFM', 'TUFM', 'C12orf65', 'RMND1', 'GTPBP3', 'MTO1', 'TRMU',
+        'POLG', 'POLG2', 'TWNK', 'TFAM', 'RRM2B', 'MPV17', 'DGUOK', 'TK2',
+        'SUCLA2', 'SUCLG1', 'FBXL4',
+        'PDHA1', 'PDHB', 'PDHX', 'DLD', 'DLAT',
+        'PC', 'PCCA', 'PCCB', 'MUT', 'MMAA', 'MMAB', 'MMACHC',
+        'LIAS', 'LIPT1', 'BOLA3', 'NFU1', 'ISCA1', 'ISCA2', 'IBA57', 'GLRX5', 'FDXR',
+        'COQ2', 'COQ4', 'COQ6', 'COQ7', 'COQ8A', 'COQ9', 'PDSS1', 'PDSS2',
+        'SLC25A4', 'SLC25A3', 'SLC25A12', 'SLC25A13', 'SLC25A19', 'SLC25A22',
+        'TAZ', 'SERAC1', 'LRPPRC', 'TACO1', 'ELAC2', 'TRNT1', 'PNPT1',
+    }
+    df_strict = df_full[df_full['gene_symbol'].isin(STRICT_MITO_GENES)].copy()
+
+
+def compute_hash(df):
+    """Calculer un hash du dataset pour vérification d'intégrité"""
+    content = df.to_json()
+    return hashlib.md5(content.encode()).hexdigest()
+
+freeze_metadata = {
+    'freeze_date': datetime.now().isoformat(),
+    'freeze_version': '1.0',
+    'datasets': {
+        'full': {
+            'filename': 'mutations_dataset_final_FROZEN.parquet',
+            'n_mutations': len(df_full),
+            'n_pathogenic': int((df_full['label'] == 1).sum()),
+            'n_benign': int((df_full['label'] == 0).sum()),
+            'n_genes': int(df_full['gene_symbol'].nunique()),
+            'hash': compute_hash(df_full),
+        },
+        'mito_strict': {
+            'filename': 'mutations_dataset_mito_strict_FROZEN.parquet',
+            'n_mutations': len(df_strict),
+            'n_pathogenic': int((df_strict['label'] == 1).sum()),
+            'n_benign': int((df_strict['label'] == 0).sum()),
+            'n_genes': int(df_strict['gene_symbol'].nunique()),
+            'hash': compute_hash(df_strict),
+        }
+    },
+    'note': 'FROZEN - DO NOT MODIFY LABELS AFTER THIS POINT'
+}
+
+df_full.to_parquet(PATHS['data_frozen'] / 'mutations_dataset_final_FROZEN.parquet')
+df_strict.to_parquet(PATHS['data_frozen'] / 'mutations_dataset_mito_strict_FROZEN.parquet')
+
+uniprot_file = PATHS['data_processed'].parent / 'raw' / 'uniprot_human_reviewed.parquet'
+
+if uniprot_file.exists():
+    df_uniprot = pd.read_parquet(uniprot_file)
+    seq_dict = dict(zip(df_uniprot['accession'], df_uniprot['sequence']))
+else:
+    import gzip
+    uniprot_gz = Path("")
+    with gzip.open(uniprot_gz, 'rt') as f:
+        df_uniprot = pd.read_csv(f, sep='\t', low_memory=False)
+    seq_dict = dict(zip(df_uniprot['Entry'], df_uniprot['Sequence']))
+
+
+
+def extract_classical_features(row, seq_dict, window=15):
+    """
+    Extraire les features classiques IDP pour une mutation.
+
+    Features extraites (~45):
+    - Propriétés de substitution (delta)
+    - Contexte local (fenêtre ±window)
+    - Position dans la protéine
+    - Composition locale
+    - Indicateurs biologiques
+    """
+
+    acc = row['uniprot_acc']
+    pos = row['position']
+    wt = row['wt_aa']
+    mut = row['mut_aa']
+
+    seq = seq_dict.get(acc, '')
+
+    features = {}
+
+    if not seq or pos >= len(seq):
+        return None
+
+    wt_props = AA_PROPERTIES.get(wt, {})
+    mut_props = AA_PROPERTIES.get(mut, {})
+
+    features['delta_hydrophobicity'] = mut_props.get('hydro', 0) - wt_props.get('hydro', 0)
+    features['delta_charge'] = mut_props.get('charge', 0) - wt_props.get('charge', 0)
+    features['delta_volume'] = mut_props.get('volume', 0) - wt_props.get('volume', 0)
+    features['delta_disorder_propensity'] = mut_props.get('disorder', 0) - wt_props.get('disorder', 0)
+    features['delta_aromatic'] = mut_props.get('aromatic', 0) - wt_props.get('aromatic', 0)
+
+    features['abs_delta_hydro'] = abs(features['delta_hydrophobicity'])
+    features['abs_delta_charge'] = abs(features['delta_charge'])
+    features['abs_delta_volume'] = abs(features['delta_volume'])
+
+
+    start = max(0, pos - window)
+    end = min(len(seq), pos + window + 1)
+    local_seq = seq[start:end]
+
+    if len(local_seq) > 0:
+        features['local_hydro_mean'] = np.mean([AA_PROPERTIES.get(aa, {}).get('hydro', 0) for aa in local_seq])
+        features['local_charge_mean'] = np.mean([AA_PROPERTIES.get(aa, {}).get('charge', 0) for aa in local_seq])
+        features['local_disorder_mean'] = np.mean([AA_PROPERTIES.get(aa, {}).get('disorder', 0) for aa in local_seq])
+
+        features['local_charged_fraction'] = sum(1 for aa in local_seq if aa in 'RDEHK') / len(local_seq)
+        features['local_aromatic_fraction'] = sum(1 for aa in local_seq if aa in 'FWY') / len(local_seq)
+        features['local_proline_fraction'] = local_seq.count('P') / len(local_seq)
+        features['local_glycine_fraction'] = local_seq.count('G') / len(local_seq)
+        features['local_cysteine_fraction'] = local_seq.count('C') / len(local_seq)
+
+        disorder_promoting = set('AEGRQSKP')
+        order_promoting = set('WFYILMVC')
+        features['local_disorder_promoting'] = sum(1 for aa in local_seq if aa in disorder_promoting) / len(local_seq)
+        features['local_order_promoting'] = sum(1 for aa in local_seq if aa in order_promoting) / len(local_seq)
+    else:
+        for key in ['local_hydro_mean', 'local_charge_mean', 'local_disorder_mean',
+                    'local_charged_fraction', 'local_aromatic_fraction', 'local_proline_fraction',
+                    'local_glycine_fraction', 'local_cysteine_fraction',
+                    'local_disorder_promoting', 'local_order_promoting']:
+            features[key] = 0
+
+
+    prot_len = len(seq)
+
+    features['position_absolute'] = pos
+    features['position_normalized'] = pos / prot_len if prot_len > 0 else 0
+    features['protein_length'] = prot_len
+
+    features['is_n_terminal'] = 1 if pos < 50 else 0
+    features['is_c_terminal'] = 1 if pos > prot_len - 50 else 0
+    features['distance_to_n_term'] = pos
+    features['distance_to_c_term'] = prot_len - pos - 1
+
+
+
+    features['protein_cysteine_count'] = seq.count('C')
+    features['protein_cysteine_fraction'] = seq.count('C') / prot_len if prot_len > 0 else 0
+    features['protein_charged_fraction'] = sum(1 for aa in seq if aa in 'RDEHK') / prot_len if prot_len > 0 else 0
+    features['protein_disorder_mean'] = np.mean([AA_PROPERTIES.get(aa, {}).get('disorder', 0) for aa in seq])
+
+    features['cysteine_gained'] = 1 if mut == 'C' else 0
+    features['cysteine_lost'] = 1 if wt == 'C' else 0
+    features['cysteine_change'] = features['cysteine_gained'] - features['cysteine_lost']
+
+    features['nearby_cysteine_count'] = local_seq.count('C') - (1 if wt == 'C' else 0)
+    features['cysteine_in_cys_rich_region'] = 1 if features['local_cysteine_fraction'] > 0.05 else 0
+
+
+    features['charge_introducing'] = 1 if wt_props.get('charge', 0) == 0 and mut_props.get('charge', 0) != 0 else 0
+    features['charge_removing'] = 1 if wt_props.get('charge', 0) != 0 and mut_props.get('charge', 0) == 0 else 0
+    features['charge_reversing'] = 1 if wt_props.get('charge', 0) * mut_props.get('charge', 0) < 0 else 0
+
+
+
+    features['proline_introduced'] = 1 if mut == 'P' and wt != 'P' else 0
+    features['proline_removed'] = 1 if wt == 'P' and mut != 'P' else 0
+    features['glycine_introduced'] = 1 if mut == 'G' and wt != 'G' else 0
+    features['glycine_removed'] = 1 if wt == 'G' and mut != 'G' else 0
+
+
+
+    features['idp_disruption_score'] = (
+        abs(features['delta_disorder_propensity']) * 2 +
+        abs(features['delta_charge']) * 1.5 +
+        features['proline_introduced'] * 2 +
+        features['proline_removed'] * 1
+    )
+
+    features['ros_vulnerability_score'] = (
+        features['cysteine_lost'] * 3 +
+        features['cysteine_gained'] * 1 +
+        features['cysteine_in_cys_rich_region'] * 2 +
+        (1 if features['protein_cysteine_fraction'] > 0.03 else 0) * 1
+    )
+
+    features['import_disruption_score'] = (
+        features['is_n_terminal'] * 2 +
+        features['charge_reversing'] * (2 if pos < 50 else 0) +
+        abs(features['delta_hydrophobicity']) * (1 if pos < 30 else 0)
+    )
+
+    return features
+
+
+features_list = []
+failed = 0
+
+for idx, row in tqdm(df_full.iterrows(), total=len(df_full), desc="Features"):
+    feats = extract_classical_features(row, seq_dict)
+
+    if feats:
+        feats['mutation_idx'] = idx
+        feats['uniprot_acc'] = row['uniprot_acc']
+        feats['gene_symbol'] = row['gene_symbol']
+        feats['position'] = row['position']
+        feats['wt_aa'] = row['wt_aa']
+        feats['mut_aa'] = row['mut_aa']
+        feats['label'] = row['label']
+        features_list.append(feats)
+    else:
+        failed += 1
+
+df_features_full = pd.DataFrame(features_list)
+
+print(f"\n    Features extraites: {len(df_features_full):,}")
+print(f"    Échecs: {failed}")
+
+
+features_list_strict = []
+
+for idx, row in tqdm(df_strict.iterrows(), total=len(df_strict), desc="Features strict"):
+    feats = extract_classical_features(row, seq_dict)
+
+    if feats:
+        feats['mutation_idx'] = idx
+        feats['uniprot_acc'] = row['uniprot_acc']
+        feats['gene_symbol'] = row['gene_symbol']
+        feats['position'] = row['position']
+        feats['wt_aa'] = row['wt_aa']
+        feats['mut_aa'] = row['mut_aa']
+        feats['label'] = row['label']
+        features_list_strict.append(feats)
+
+df_features_strict = pd.DataFrame(features_list_strict)
+
+
+df_features_full.to_parquet(PATHS['features'] / 'features_classical_full.parquet')
+df_features_strict.to_parquet(PATHS['features'] / 'features_classical_mito_strict.parquet')
+
+feature_cols = [c for c in df_features_full.columns if c not in
+                ['mutation_idx', 'uniprot_acc', 'gene_symbol', 'position', 'wt_aa', 'mut_aa', 'label']]

scripts/train_baseline_classical_model.py.py

@@ -0,0 +1,247 @@
+# -*- coding: utf-8 -*-
+"""Untitled17.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1GwdSjrwh3f6QCzOa8KHr_XkWy0KmZvdV
+"""
+
+import pandas as pd
+import numpy as np
+from pathlib import Path
+from math import log2
+from tqdm import tqdm
+from sklearn.ensemble import GradientBoostingClassifier
+from sklearn.preprocessing import StandardScaler
+from sklearn.metrics import roc_auc_score, average_precision_score, classification_report
+import warnings
+warnings.filterwarnings('ignore')
+
+PATHS = {
+    'data_frozen': BASE_PATH / 'data' / 'frozen',
+    'features': BASE_PATH / 'features',
+    'models': BASE_PATH / 'models',
+    'results': BASE_PATH / 'results',
+}
+
+for path in PATHS.values():
+    path.mkdir(parents=True, exist_ok=True)
+
+def shannon_entropy(seq):
+    """Calculer l'entropie de Shannon d'une séquence"""
+    if not seq or len(seq) == 0:
+        return 0.0
+    probs = [seq.count(aa)/len(seq) for aa in set(seq)]
+    return -sum(p * log2(p) for p in probs if p > 0)
+
+df_features_full = pd.read_parquet(PATHS['features'] / 'features_classical_full.parquet')
+df_features_strict = pd.read_parquet(PATHS['features'] / 'features_classical_mito_strict.parquet')
+
+print(f"   Features chargées (full): {len(df_features_full):,}")
+print(f"   Features chargées (strict): {len(df_features_strict):,}")
+
+uniprot_file = BASE_PATH / 'data' / 'raw' / 'uniprot_human_reviewed.parquet'
+df_uniprot = pd.read_parquet(uniprot_file)
+seq_dict = dict(zip(df_uniprot['accession'], df_uniprot['sequence']))
+
+print(f"   Séquences: {len(seq_dict):,}")
+
+def add_entropy_feature(df, seq_dict, window=15):
+    """Ajouter la feature d'entropie locale"""
+    entropies = []
+
+    for _, row in tqdm(df.iterrows(), total=len(df), desc="Entropie"):
+        seq = seq_dict.get(row['uniprot_acc'], '')
+        pos = row['position']
+
+        if seq and 0 <= pos < len(seq):
+            start = max(0, pos - window)
+            end = min(len(seq), pos + window + 1)
+            local_seq = seq[start:end]
+            entropies.append(shannon_entropy(local_seq))
+        else:
+            entropies.append(0.0)
+
+    df['local_sequence_entropy'] = entropies
+    return df
+
+print("\n   Ajout de l'entropie locale...")
+df_features_full = add_entropy_feature(df_features_full, seq_dict)
+df_features_strict = add_entropy_feature(df_features_strict, seq_dict)
+
+df_features_full.to_parquet(PATHS['features'] / 'features_classical_full.parquet')
+df_features_strict.to_parquet(PATHS['features'] / 'features_classical_mito_strict.parquet')
+
+
+
+
+id_cols = ['mutation_idx', 'uniprot_acc', 'gene_symbol', 'position', 'wt_aa', 'mut_aa', 'label']
+feature_cols = [c for c in df_features_full.columns if c not in id_cols]
+
+print(f"   Features: {len(feature_cols)}")
+
+X_full = df_features_full[feature_cols].values
+y_full = df_features_full['label'].values
+
+X_strict = df_features_strict[feature_cols].values
+y_strict = df_features_strict['label'].values
+
+print(f"   X shape: {X_full.shape}")
+print(f"   y: {np.sum(y_full==1)} pathogènes, {np.sum(y_full==0)} bénins")
+
+print(f"   X shape: {X_strict.shape}")
+print(f"   y: {np.sum(y_strict==1)} pathogènes, {np.sum(y_strict==0)} bénins")
+
+X_full = np.nan_to_num(X_full, nan=0.0, posinf=0.0, neginf=0.0)
+X_strict = np.nan_to_num(X_strict, nan=0.0, posinf=0.0, neginf=0.0)
+
+
+
+from sklearn.model_selection import train_test_split
+
+X_train, X_test, y_train, y_test = train_test_split(
+    X_full, y_full, test_size=0.2, random_state=42, stratify=y_full
+)
+
+print(f"   Train: {len(X_train)} ({np.sum(y_train==1)} patho)")
+print(f"   Test: {len(X_test)} ({np.sum(y_test==1)} patho)")
+
+scaler = StandardScaler()
+X_train_scaled = scaler.fit_transform(X_train)
+X_test_scaled = scaler.transform(X_test)
+
+
+model = GradientBoostingClassifier(
+    n_estimators=300,
+    max_depth=5,
+    learning_rate=0.05,
+    min_samples_leaf=10,
+    subsample=0.8,
+    random_state=42,
+    verbose=0
+)
+
+model.fit(X_train_scaled, y_train)
+y_pred_proba = model.predict_proba(X_test_scaled)[:, 1]
+y_pred = model.predict(X_test_scaled)
+
+auc_roc = roc_auc_score(y_test, y_pred_proba)
+auc_pr = average_precision_score(y_test, y_pred_proba)
+
+print(f"   AUC-ROC: {auc_roc:.4f}")
+print(f"   AUC-PR:  {auc_pr:.4f}")
+
+print(classification_report(y_test, y_pred, target_names=['Bénin', 'Pathogène']))
+
+
+proteins = df_features_full['uniprot_acc'].unique()
+print(f"   Protéines uniques: {len(proteins)}")
+
+lpocv_results = []
+proteins_evaluated = 0
+
+
+for protein in tqdm(proteins, desc="LPOCV"):
+    test_mask = df_features_full['uniprot_acc'] == protein
+    train_mask = ~test_mask
+
+    if test_mask.sum() < 2:
+        continue
+
+    X_train_lpo = X_full[train_mask]
+    y_train_lpo = y_full[train_mask]
+    X_test_lpo = X_full[test_mask]
+    y_test_lpo = y_full[test_mask]
+
+    if len(np.unique(y_test_lpo)) < 2:
+        pass
+
+    scaler_lpo = StandardScaler()
+    X_train_lpo_scaled = scaler_lpo.fit_transform(X_train_lpo)
+    X_test_lpo_scaled = scaler_lpo.transform(X_test_lpo)
+
+    model_lpo = GradientBoostingClassifier(
+        n_estimators=100,
+        max_depth=4,
+        learning_rate=0.1,
+        min_samples_leaf=10,
+        random_state=42,
+        verbose=0
+    )
+
+    model_lpo.fit(X_train_lpo_scaled, y_train_lpo)
+
+    y_pred_lpo = model_lpo.predict_proba(X_test_lpo_scaled)[:, 1]
+
+    for i, (pred, true) in enumerate(zip(y_pred_lpo, y_test_lpo)):
+        lpocv_results.append({
+            'protein': protein,
+            'y_true': true,
+            'y_pred_proba': pred,
+        })
+
+    proteins_evaluated += 1
+
+df_lpocv = pd.DataFrame(lpocv_results)
+
+
+if len(df_lpocv) > 0 and len(df_lpocv['y_true'].unique()) > 1:
+    auc_roc_lpocv = roc_auc_score(df_lpocv['y_true'], df_lpocv['y_pred_proba'])
+    auc_pr_lpocv = average_precision_score(df_lpocv['y_true'], df_lpocv['y_pred_proba'])
+
+    print(f"\n   📊 RÉSULTATS LPOCV:")
+    print(f"   AUC-ROC: {auc_roc_lpocv:.4f}")
+    print(f"   AUC-PR:  {auc_pr_lpocv:.4f}")
+else:
+    auc_roc_lpocv = 0
+    auc_pr_lpocv = 0
+
+
+scaler_final = StandardScaler()
+X_full_scaled = scaler_final.fit_transform(X_full)
+
+model_final = GradientBoostingClassifier(
+    n_estimators=300,
+    max_depth=5,
+    learning_rate=0.05,
+    min_samples_leaf=10,
+    subsample=0.8,
+    random_state=42,
+    verbose=0
+)
+
+model_final.fit(X_full_scaled, y_full)
+
+importances = model_final.feature_importances_
+importance_df = pd.DataFrame({
+    'feature': feature_cols,
+    'importance': importances
+}).sort_values('importance', ascending=False)
+for i, row in importance_df.head(20).iterrows():
+    print(f"   {row['importance']:.4f}  {row['feature']}")
+
+importance_df.to_csv(PATHS['results'] / 'feature_importances_classical.csv', index=False)
+
+
+import pickle
+
+model_data = {
+    'model': model_final,
+    'scaler': scaler_final,
+    'feature_cols': feature_cols,
+    'metrics': {
+        'auc_roc_split': auc_roc,
+        'auc_pr_split': auc_pr,
+        'auc_roc_lpocv': auc_roc_lpocv,
+        'auc_pr_lpocv': auc_pr_lpocv,
+    },
+    'n_samples': len(X_full),
+    'n_features': len(feature_cols),
+}
+
+with open(PATHS['models'] / 'model_classical_baseline.pkl', 'wb') as f:
+    pickle.dump(model_data, f)
+
+
+df_lpocv.to_parquet(PATHS['results'] / 'lpocv_predictions.parquet')