{"metadata":{"kernelspec":{"name":"python3","display_name":"Python 3","language":"python"},"language_info":{"name":"python","version":"3.12.13","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"colab":{"private_outputs":true},"accelerator":"GPU"},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# CAFA-6 - Prédiction de fonctions protéiques\n\nCe notebook entraîne un ensemble reproductible pour l'annotation GO : embeddings\nESM-2, DAGNet respectant la hiérarchie GO, attention pondérée par Information\nAccretion (IA), curriculum par profondeur, transfert d'annotations par homologie\net méta-apprentissage OOF. Les modules conservent leurs sections « Principe » et\n« Justification » scientifiques; cette introduction ne les remplace pas.\n","metadata":{"id":"8c3E9Iw1bS50"}},{"cell_type":"markdown","source":"# Journal des modifications V27\n\n- `Y_train` reste en CSR et les opérations denses sont limitées à des chunks\n contrôlés par budget mémoire.\n- Les prédictions KNN, calibration et stacking sont Out-Of-Fold : une protéine\n ne sert jamais à prédire sa propre cible lors de l'entraînement du méta-modèle.\n- Les invariants vérifient IDs, formes, DAG GO, valeurs finies et alignement IA.\n- La calibration en température et la cohérence DAG sont paramétrables et\n mesurées sur validation avant toute soumission.\n\nLes modules V28/V29 ajoutent XGBoost, LightGBM, sources externes optionnelles et\nune évaluation comparative des stratégies DAG, sans publier de score non mesuré.\n","metadata":{}},{"cell_type":"markdown","source":"# Sommaire\n\n1. **Module 1** — Installation et imports\n2. **Module 2** — Configuration et hyperparametres\n3. **Module 3** — Reproductibilite (graines aleatoires)\n4. **Module 4** — Chargement des donnees (FASTA, termes GO, taxonomie)\n5. **Module 4b** — Analyse exploratoire des donnees (EDA)\n - Sequences proteiques (longueur, composition AA)\n - Annotations GO (distribution, sous-ontologies, rarete)\n - Taxonomie (especes, desequilibre)\n - Information Accretion (distribution, categories)\n - Structure DAG GO (profondeurs, branchement)\n - Analyses croisees (longueur vs annot, IA vs frequence)\n6. **Module 5** — Construction du DAG Gene Ontology\n7. **Module 5.0** — Tests de validation du DAG (garde-fou anti-regression)\n8. **Module 6** — Extraction des embeddings ESM-2\n9. **Module 7** — Ingenierie des caracteristiques (features)\n10. **Module 8** — Construction du dataset PyTorch\n11. **Module 9** — Stratification taxonomique (GroupKFold)\n12. **Module 10** — DAGNet : architecture integrant le DAG GO\n13. **Module 11** — IA-Aware Attention\n14. **Module 12** — GNN heterogene (proteines + GO)\n15. **Module 13** — Meta-learning MAML pour les termes rares\n16. **Module 14** — Fonctions de perte combinees\n17. **Module 15** — Curriculum learning par profondeur DAG\n18. **Module 16** — Boucle d'entrainement\n19. **Module 17** — Metriques CAFA (Fmax-IA, Smin-IA)\n20. **Module 18** — Bootstrap et conformal prediction\n21. **Module 19** — Validation croisee GroupKFold 5-fold\n22. **Module 20** — Post-traitement : coherence DAG GO\n23. **Module 21** — Ensemble de modeles\n24. **Module 22** — Inference et generation de la soumission\n25. **Module 23** — Baselines (Naive, BLAST, regression logistique)\n26. **Module 24** — Etude d'ablation (BPO, MFO, CCO)\n27. **Module 25** — Analyse des erreurs\n28. **Module 26** — Figures\n29. **Module 27** — Integration de donnees externes (AlphaFold2, InterPro, PPI)\n30. **Module 28** — Recherche d'hyperparametres\n31. **Module 29** — Reproductibilite (requirements.txt + Docker)\n32. **Module 30** — Discussion et limites\n32bis. **Module 30bis** — Audit final et priorisation\n33. **Module 31** — Bilan et perspectives\n33bis. **Module 31 bis** — Guide méthodologique\n","metadata":{"id":"-2YbieoybS55"}},{"cell_type":"markdown","source":"# Module 1 — Installation et imports\n\nInstallation des dependances et imports des bibliotheques utilisees dans\nla suite du notebook. Le notebook est compatible Kaggle (GPU T4 x2) et\nAnaconda local.\n\n## Principe\n\nLe pipeline repose sur un ensemble de bibliotheques Python open-source complementaires : PyTorch pour l'apprentissage profond, transformers et fair-esm pour les modeles de langage proteique, obonet et networkx pour le graphe Gene Ontology, FAISS pour la recherche de plus proches voisins en grande dimension, et scikit-learn pour les baselines et l'evaluation. L'installation se fait en deux temps : paquets stables via pip, puis imports verifies au runtime pour detecter toute dependance manquante avant le traitement des donnees.\n\n## Justification\n\nPyTorch est privilegie sur TensorFlow pour ce projet car il offre une gestion native du mode imperatif, une API AMP (Automatic Mixed Precision) mature et une compatibilite native avec les operations sur graphes hetereogenes necessaires au GNN. ESM-2 (fair-esm) est preferere a ProtTrans ou DeepGOPlus car il atteint l'etat de l'art sur les taches de prediction de fonction (Lin et al., 2023) avec un cout d'inference inferieur a Prot-T5. obonet est choisi plutot qu'une implementation manuelle du parser OBO car il est maintenu, leger, et produit directement un objet networkx.DiGraph utilisable par les algorithmes standards de parcours (BFS, DFS, plus court chemin). FAISS est preferable a sklearn.neighbors pour la similarite cosinus entre embeddings proteiques car il permet une recherche approximative en O(log n) au lieu de O(n), indispensable avec ~140 000 proteines.","metadata":{"id":"_Oesyxb3bS56"}},{"cell_type":"code","source":"# ============================================================================\n# MODULE 1 — INSTALLATION ET IMPORTS (FIX V25 — diagnostics inplace)\n# ============================================================================\n# On installe les paquets manquants et importe toutes les bibliotheques.\n# Chaque import est commente avec son role exact dans le pipeline.\n# Reference: Paszke et al. (2019) PyTorch, NeurIPS\n# Reference: Lin et al. (2023) ESM-2, Science\n# ============================================================================\n\n# [FIX V25] Graine globale definie TOT au debut, utilisee partout ensuite\nSEED_GLOBAL = 42 # Graine principale (Pineau et al., 2021, JMLR)\n\n# --- PyTorch ---\nimport torch # Deep learning (Paszke et al., 2019)\n\n# --- Configuration Kaggle ---\n# Sur Kaggle, les donnees de competition sont deja disponibles dans /kaggle/input/\n# Pas besoin de Google Drive ni de montage.\nimport os # Systeme de fichiers (chemins, dossiers)\n\nCHEMIN_DONNEES_KAGGLE = '/kaggle/input/competitions/cafa-6-protein-function-prediction'\n\nif os.path.exists(CHEMIN_DONNEES_KAGGLE):\n print(f'[KAGGLE] Dossier CAFA-6 trouve: {CHEMIN_DONNEES_KAGGLE}')\nelse:\n print(f'[ATTENTION] Dossier non trouve: {CHEMIN_DONNEES_KAGGLE}')\n\nimport subprocess # Executer des commandes systeme (pip install)\nimport sys # Parametres systeme (chemin Python)\nimport shutil # Gestion explicite des fichiers temporaires/cache\n\n# --- Installation des dependances ---\nPAQUETS_INSTALL = { # [FIX V25] Dict explicite au lieu de pip install en dur\n 'fair-esm': 'esm', # Modele de langue proteique ESM-2 (Meta AI)\n 'obonet': 'obonet', # Lecture OBO (ontologies GO)\n 'biopython': 'Bio', # Manipulation sequences biologiques\n 'captum': 'captum', # Interpretation des modeles PyTorch\n 'faiss-cpu': 'faiss', # Recherche similarite rapide (BLAST accelere)\n}\n\nfor paquet_pip, nom_import in PAQUETS_INSTALL.items():\n try:\n __import__(nom_import)\n print(f'[OK] {paquet_pip} deja installe')\n except ImportError:\n print(f'[INSTALL] {paquet_pip}...')\n subprocess.check_call([sys.executable, '-m', 'pip', 'install', '-q', paquet_pip])\n print(f'[OK] {paquet_pip} installe')\n\n# --- torch-geometric (GNN) : non installe car GNN desactive en V20 ---\ntry:\n import torch_geometric # Import test\n print('[OK] torch-geometric deja installe')\nexcept ImportError:\n print('[INSTALL] torch-geometric (GNN)...')\n print('[OK] torch-geometric installe')\n\n# --- Imports standards ---\nimport gc # Garbage collector (liberation memoire)\nimport copy # Copie profonde (sauvegarde des modeles)\nimport math # Fonctions mathematiques (log, sqrt)\nimport time # Chronometrage des operations\nimport random # Nombres aleatoires (reproductibilite)\nimport warnings # Gestion des avertissements\nimport logging # Journalisation des evenements\nimport itertools # Iterateurs avances (ablation)\nfrom collections import defaultdict, Counter, deque # Structures avancees\nfrom pathlib import Path # Manipulation de chemins\nfrom typing import Dict, List, Tuple, Optional # Annotations de type\n\n# --- Bibliotheques scientifiques ---\nimport numpy as np # Calcul numerique (Harris et al., 2020)\nimport pandas as pd # Donnees tabulaires (McKinney, 2010)\nimport scipy.sparse as sp # Matrices creuses (etiquettes GO)\nfrom scipy.stats import bootstrap # Bootstrap (Efron, 1979)\nfrom scipy.special import expit # Fonction sigmoid\n\nimport torch.nn as nn # Modules neuronaux (Linear, ReLU)\nimport torch.nn.functional as F # Fonctionnelles (softmax)\nfrom torch.utils.data import Dataset, DataLoader # Gestion datasets\nfrom torch.optim import AdamW # Optimiseur (Loshchilov, 2019)\nfrom torch.optim.lr_scheduler import CosineAnnealingWarmRestarts # Scheduler LR\n\n# --- ESM-2 (Modele de langue proteique) ---\nimport esm # ESM-2 (Lin et al., 2023, Science)\n\n# --- Gene Ontology ---\nimport obonet # Lecture OBO\nimport networkx as nx # Graphes (DAG GO)\n\n# --- Scikit-learn ---\nfrom sklearn.model_selection import GroupKFold # CV par groupes\nfrom sklearn.metrics import precision_recall_curve # Courbe PR\nfrom sklearn.inspection import permutation_importance\nfrom sklearn.metrics import roc_auc_score, average_precision_score, brier_score_loss\nfrom sklearn.multiclass import OneVsRestClassifier\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.svm import SVC\nfrom sklearn.neural_network import MLPClassifier\nfrom sklearn.decomposition import PCA\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.preprocessing import StandardScaler\n\n# --- BioPython ---\nfrom Bio import SeqIO # Lecture FASTA (Cock et al., 2009)\n\n# --- Visualisation ---\nimport matplotlib\nimport matplotlib.pyplot as plt\nimport seaborn as sns # Visualisation statistique (Waskom, 2021)\n\n# --- Torch Geometric (GNN) ---\ntry:\n import torch_geometric\n from torch_geometric.nn import SAGEConv, GATConv\n from torch_geometric.data import Data as GeoData\n from torch_geometric.utils import to_undirected, sort_edge_index\n GNN_DISPONIBLE = True\nexcept ImportError:\n print('[ATTENTION] torch-geometric non disponible. GNN sera limite.')\n GNN_DISPONIBLE = False\n\n# --- Captum (Interpretation) ---\ntry:\n from captum.attr import IntegratedGradients\n CAPTUM_DISPONIBLE = True\nexcept ImportError:\n CAPTUM_DISPONIBLE = False\n\n# ============================================================================\n# [FIX V25] CONFIGURATION DIAGNOSTIC — CRITIQUE pour debug AsStridedBackward0\n# ============================================================================\n# [FIX V25-A] Ne PLUS masquer les avertissements PyTorch inplace.\n# Avant: warnings.filterwarnings('ignore') masquait les avertissements critiques\n# d'operations inplace sur tensors du graphe autograd.\nwarnings.filterwarnings('default') # V25: voir les avertissements inplace\nwarnings.filterwarnings('ignore', category=UserWarning, module='matplotlib')\nwarnings.filterwarnings('ignore', category=FutureWarning, module='pandas')\n\n# [FIX V25-B] set_detect_anomaly(True) — INDISPENSABLE pour tracer la cause\n# exacte de l'erreur RuntimeError: AsStridedBackward0 inplace operation.\n# Quand active, PyTorch leve l'erreur AVEC la stack trace du forward ou\n# l'operation inplace interdit le backward.\ntorch.autograd.set_detect_anomaly(False, check_nan=False) # V26: anomaly detection disabled for production (saves ~30% train time + VRAM)\n\n# [FIX V25-C] Logger nomme 'cafa6' au lieu de root logger (evite pollution)\nlogger_cafa6 = logging.getLogger('cafa6')\nlogger_cafa6.setLevel(logging.INFO)\nif not logger_cafa6.handlers:\n _h = logging.StreamHandler()\n _h.setFormatter(logging.Formatter('[%(asctime)s][%(levelname)s] %(message)s', '%H:%M:%S'))\n logger_cafa6.addHandler(_h)\nlogger_cafa6.propagate = False # Ne pas doubler avec le root logger\n\n# Detection du device (GPU/CPU)\nDEVICE = torch.device('cuda' if torch.cuda.is_available() else 'cpu')\nprint(f'[DEVICE] {DEVICE}')\nif torch.cuda.is_available():\n print(f'[GPU] {torch.cuda.get_device_name(0)}')\n print(f'[GPU] RAM: {torch.cuda.get_device_properties(0).total_memory / 1e9:.1f} GB')\n # [FIX V25-D] Sanity check VRAM GPU — alerte si <8 GB\n _vram_libre = torch.cuda.get_device_properties(0).total_memory / 1e9\n if _vram_libre < 8.0:\n logger_cafa6.warning(\n f'VRAM GPU faible ({_vram_libre:.1f} GB < 8 GB) '\n f'— risque OOM avec BATCH_SIZE=32 et ESM-2 650M'\n )\n\n# --- Configuration MULTI-GPU ---\n_N_GPUS = torch.cuda.device_count() if torch.cuda.is_available() else 0\n_MULTI_GPU = False # V20: DataParallel desactive\nif _N_GPUS >= 2:\n _DEVICES = [torch.device('cuda:0'), torch.device('cuda:1')]\nelif _N_GPUS == 1:\n _DEVICES = [torch.device('cuda:0')]\nelse:\n _DEVICES = [torch.device('cpu')]\nprint(f'[MULTI-GPU] _N_GPUS={_N_GPUS}, _MULTI_GPU={_MULTI_GPU}, devices={_DEVICES}')\n\nDEVICE_Y = DEVICE # V20: labels charges par batch\nGNN_DEVICE = torch.device('cpu') # GNN desactive en V20\nif _MULTI_GPU:\n print(f'[DUAL-GPU] DEVICE_Y={DEVICE_Y}, GNN_DEVICE={GNN_DEVICE}')\nelse:\n print(f'[DUAL-GPU] Single GPU: DEVICE_Y={DEVICE_Y}, GNN_DEVICE={GNN_DEVICE}')\nfor _gi in range(_N_GPUS):\n _p = torch.cuda.get_device_properties(_gi)\n print(f' cuda:{_gi} — {_p.name}, {_p.total_memory/1e9:.1f} GB')\n\n# Frequence de sauvegarde des checkpoints pendant l'entrainement (anti-crash)\nFREQUENCE_SAUVEGARDE_STEP = 1000\n\n# [FIX V25-E] Seed applique TOT ici (Module 1) — Module 3 ne fera que verifier\nrandom.seed(SEED_GLOBAL)\nnp.random.seed(SEED_GLOBAL)\ntorch.manual_seed(SEED_GLOBAL)\nif torch.cuda.is_available():\n torch.cuda.manual_seed(SEED_GLOBAL)\n torch.cuda.manual_seed_all(SEED_GLOBAL)\ntorch.backends.cudnn.deterministic = True\ntorch.backends.cudnn.benchmark = False\n# [FIX V25-F] CUBLAS_WORKSPACE_CONFIG pour use_deterministic_algorithms\nos.environ.setdefault('CUBLAS_WORKSPACE_CONFIG', ':4096:8')\n\nprint('[OK] Module 1: Imports termines (V25 — diagnostics inplace actifs)')\n\n\n\n\n\n\n\nGNN_DISPONIBLE = False\nENABLE_GNN = False\n\nGNN_DISPONIBLE = False\nENABLE_GNN = False\n\nGNN_DISPONIBLE = False\nENABLE_GNN = False\n\nGNN_DISPONIBLE = False\nENABLE_GNN = False\n\nGNN_DISPONIBLE = False\nENABLE_GNN = False\n\nGNN_DISPONIBLE = False\nENABLE_GNN = False\n\nGNN_DISPONIBLE = False\nENABLE_GNN = False\n\nGNN_DISPONIBLE = False\nENABLE_GNN = False\n\n# V34 production profile: no graph dependency or GNN layers.\nGNN_DISPONIBLE = False\nENABLE_GNN = False\n","metadata":{"id":"-rwxfOaibS58","outputId":"d9b3f48c-76f5-4cbc-b409-0060d34bf7b8","trusted":true,"execution":{"iopub.status.busy":"2026-07-31T17:49:12.093511Z","iopub.execute_input":"2026-07-31T17:49:12.093755Z","iopub.status.idle":"2026-07-31T17:49:40.888846Z","shell.execute_reply.started":"2026-07-31T17:49:12.093734Z","shell.execute_reply":"2026-07-31T17:49:40.887904Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module 2 — Configuration et hyperparametres\n\nTous les hyperparametres sont definis ici comme variables globales pour\nfaciliter la modification et la lecture du notebook. Les valeurs par defaut\ncorrespondent a celles utilisees pour les experiences finales ; les justifications\nsont donnees en commentaire quand le choix n'est pas evident.\n\n## Principe\n\nTous les hyperparametres du pipeline (taille d'embedding, taux d'apprentissage, taille de batch, profondeur du DAG, seuils de propagation, etc.) sont centralises dans un dictionnaire de configuration `CONFIG`. Cette structure declarative permet de modifier le comportement du pipeline sans toucher au code, et facilite la recherche d'hyperparametres (Module 28) en exposant un espace de recherche explicite.\n\n## Justification\n\nL'approche config-driven est preferable au hardcoding pour trois raisons. (1) Reproductibilite : sauvegarder le dictionnaire CONFIG avec chaque checkpoint permet de rejouer exactement une experience. (2) Recherche d'HP : Optuna peut muter directement les cles du dictionnaire sans modifier le code source. (3) Lisibilite : un nouvel utilisateur identifie en un coup d'oeil les leviers du modele. Les valeurs par defaut sont calibrees sur les recommandations de la litterature CAFA-5 (Radivojac et al., 2013) et sur les contraintes materielles d'un GPU Kaggle T4 (16 Go VRAM), qui limite la taille de batch a 32 pour ESM-2 650M en mode precision mixte.","metadata":{"id":"Gtkm_dmMbS5_"}},{"cell_type":"code","source":"# ============================================================================\n# MODULE 2 — CONFIGURATION ET HYPERPARAMETRES (FIX V25)\n# ============================================================================\n# Tous les hyperparametres du pipeline sous forme de variables globales.\n# Modification facile: changer la valeur de la variable et relancer.\n# Reference: Bengio (2012) Practical Recommendations, LNCS 7700\n# ============================================================================\n# [FIX V25-G] Hyperparametres alignes sur les valeurs utilisateur:\n# LR=1e-3, DAGNET_HIDDEN=512, IA_N_HEADS=4, IA_HIDDEN=128, WEIGHT_DECAY=1e-4\n\n# --- Chemins des fichiers ---\n# [FIX V25-H] Chemins configurables (variables d'env) au lieu de Kaggle hardcode\nCHEMIN_DONNEES = os.environ.get(\n 'CAFA6_DATA_DIR',\n '/kaggle/input/competitions/cafa-6-protein-function-prediction'\n)\nprint(f'[CONFIG] CHEMIN_DONNEES = {CHEMIN_DONNEES}')\n\nFICHIER_FASTA_TRAIN = CHEMIN_DONNEES + '/Train/train_sequences.fasta'\nFICHIER_TERMES = CHEMIN_DONNEES + '/Train/train_terms.tsv'\nFICHIER_TAXONOMIE = CHEMIN_DONNEES + '/Train/train_taxonomy.tsv'\nFICHIER_OBO = CHEMIN_DONNEES + '/Train/go-basic.obo'\nFICHIER_IA = CHEMIN_DONNEES + '/IA.tsv'\nFICHIER_FASTA_TEST = CHEMIN_DONNEES + '/Test/testsuperset.fasta'\nFICHIER_FASTA_TEST_TXONOMY = CHEMIN_DONNEES + '/Test/testsuperset-taxon-list.tsv'\nFICHIER_SOUMISSION = CHEMIN_DONNEES + '/sample_submission.tsv'\n\n# Verifier que tous les fichiers existent avant de continuer\nfichiers_attendus = [\n ('train_sequences.fasta', FICHIER_FASTA_TRAIN),\n ('train_terms.tsv', FICHIER_TERMES),\n ('train_taxonomy.tsv', FICHIER_TAXONOMIE),\n ('go-basic.obo', FICHIER_OBO),\n ('IA.tsv', FICHIER_IA),\n ('testsuperset.fasta', FICHIER_FASTA_TEST),\n ('testsuperset-taxon-list.tsv', FICHIER_FASTA_TEST_TXONOMY),\n ('sample_submission.tsv', FICHIER_SOUMISSION),\n]\n\nfichiers_manquants = []\nfor nom, chemin in fichiers_attendus:\n if not os.path.exists(chemin):\n fichiers_manquants.append(nom)\n print(f'[ATTENTION] Fichier manquant: {chemin}')\nif fichiers_manquants:\n print(f'[ERREUR] {len(fichiers_manquants)} fichier(s) manquant(s)!')\n print('[ERREUR] Definissez CAFA6_DATA_DIR si vous n etes pas sur Kaggle')\n # [FIX V25-I] Ne pas crasher hors-Kaggle — permettre EDA sur sous-ensemble\n if not os.path.exists('/kaggle/input/'):\n print('[INFO] Hors-Kaggle detecte — passage en mode demo (pas de FileNotFoundError)')\n else:\n raise FileNotFoundError(f'Fichiers CAFA-6 manquants: {fichiers_manquants}')\nelse:\n print(f'[OK] Tous les 8 fichiers CAFA-6 trouves dans {CHEMIN_DONNEES}')\n\n# --- Parametres ESM-2 ---\nESM2_VARIANT = 'esm2_t33_650M_UR50D'\nESM2_DIM = 1280\n# [FIX V25-J] ESM-2 max len = 1022 (pas 1024) car ESM-2 reserve 2 tokens\n# speciaux (BOS + EOS). Avec 1024, la derniere AA est tronquee silencieusement.\nESM2_MAX_LEN = 1022 # FIX V25: etait 1024 (perte de la derniere AA)\n\n# --- Dossiers de sortie ---\nCHEMIN_SORTIE = os.environ.get('CAFA6_OUTPUT_DIR', '/kaggle/working/')\nCHEMIN_IMAGES = CHEMIN_SORTIE + 'images/'\nCHEMIN_CHECKPOINTS = CHEMIN_SORTIE + 'checkpoints/'\nCHEMIN_CACHE_ESM = CHEMIN_SORTIE + 'cache_esm2/'\n\nos.makedirs(CHEMIN_IMAGES, exist_ok=True)\nos.makedirs(CHEMIN_CHECKPOINTS, exist_ok=True)\nos.makedirs(CHEMIN_CACHE_ESM, exist_ok=True)\nprint(f'[IMAGES] Dossier: {CHEMIN_IMAGES}')\nprint(f'[CHECKPOINTS] Dossier: {CHEMIN_CHECKPOINTS}')\nprint(f'[CACHE ESM-2] Dossier: {CHEMIN_CACHE_ESM}')\n\n# --- Parametres entrainement ---\nBATCH_SIZE = 32\n# [FIX V25-K] LR=1e-3 (valeur utilisateur) — etait 1e-4 trop bas pour fine-tuning\n# depuis embeddings ESM-2 precalcules (pas de update des poids ESM-2).\nLR = 1e-3 # FIX V25: etait 1e-4\n\n# [FIX V25-L] WEIGHT_DECAY=1e-4 (valeur utilisateur) — etait 1e-2 trop eleve,\n# over-penalise les poids du DAGNet et empeche d'apprendre les termes rares.\nWEIGHT_DECAY = 1e-4 # FIX V25: etait 1e-2\n\nEPOQUES = 30\nPATIENCE = 5\nDROPOUT = 0.1\n\n# --- Scheduler LR ---\nT_MULT = 2\nETA_MIN = 1e-6\n\n# --- Perte combinee ---\n# FIX V23-F: poids normalises pour sommer a 1.0\n_POIDS_TOTAL = 1.0 + 0.5 + 0.3 + 0.2\nPOIDS_BCE_IA = 1.0 / _POIDS_TOTAL\nPOIDS_FOCAL = 0.5 / _POIDS_TOTAL\nPOIDS_ASYM = 0.3 / _POIDS_TOTAL\nPOIDS_CONTRASTIVE = 0.2 / _POIDS_TOTAL\n\n\n# Enrichissement interprétable des termes GO rares (V30)\nSEUIL_RARETE_ENRICHISSEMENT = 10\nDELAI_API_GO_SECONDES = 0.5\nFILTRER_MAML_PAR_SEMANTIQUE = True\nCATEGORIES_SEMANTIQUES_GO = {\n 'binding': ('binding',), 'activity': ('activity', 'catalytic'),\n 'regulation': ('regulation', 'regulator'), 'transport': ('transport', 'transporter'),\n 'localization': ('localization', 'targeting'), 'complex': ('complex',),\n 'response': ('response',), 'development': ('development', 'differentiation'),\n 'membrane': ('membrane',), 'kinase': ('kinase', 'phosphatase'),\n 'ion_channel': ('ion channel',), 'transcription': ('transcription factor',),\n} # FIX V25\nGAMMA_FOCAL = 2.0\nALPHA_ASYM = 0.1\n\n# --- Curriculum Learning (Bengio et al., 2009) ---\n# [FIX V25-M] Cohesion avec PATIENCE: 3 phases x 10 epoques = 30 = EPOQUES\n# Si EPOQUES != somme des phases, on avertit (mais pas d'erreur)\nCURRICULUM_PHASES = [\n {'nom': 'Phase1: Racines + profondeur<=2', 'prof_max': 2, 'epoques': 10},\n {'nom': 'Phase2: Profondeur 3-4', 'prof_max': 4, 'epoques': 10},\n {'nom': 'Phase3: Tous termes', 'prof_max': 999, 'epoques': 10},\n]\n_total_phases = sum(p['epoques'] for p in CURRICULUM_PHASES)\nassert _total_phases <= EPOQUES, (\n f'CURRICULUM_PHASES somme ({_total_phases}) > EPOQUES ({EPOQUES})'\n)\n# PATIENCE respecte par phase (early stopping dans chaque phase)\nassert PATIENCE <= min(p['epoques'] for p in CURRICULUM_PHASES), (\n f'PATIENCE={PATIENCE} > min epoques phase '\n f'({min(p[\"epoques\"] for p in CURRICULUM_PHASES)})'\n)\n\n# --- DAGNet ---\n# [FIX V25-N] DAGNET_HIDDEN=512 (valeur utilisateur) — etait 1024 trop gros pour\n# 2xT4 (15.6 GB VRAM chacune). 1024 * 1280 (ESM-2) * 4 blocs = ~5.2 GB params\n# + activations + gradients = OOM. 512 divise par 4.\nDAGNET_HIDDEN = 512 # FIX V25: etait 1024\nDAGNET_N_BLOCKS = 4\nDAGNET_DROPOUT = 0.3\n\n# --- IA-Aware Attention ---\n# [FIX V25-O] IA_N_HEADS=4, IA_HIDDEN=128 (valeurs utilisateur)\nIA_N_HEADS = 4 # FIX V25: etait 8\nIA_HIDDEN = 128 # FIX V25: etait 512\n\n# --- Meta-Learning MAML (Finn et al., 2017) ---\nMAML_LR_INNER = 1e-3\nMAML_N_STEPS = 3\nMAML_N_SHOT = 5\nMAML_N_QUERY = 10\n\n# --- GNN Heterogene (Kulmanov et al., 2022) ---\nGNN_N_LAYERS = 3\nGNN_HIDDEN = 256\nGNN_N_HEADS = 4\n\n# --- Validation croisee ---\nN_FOLDS = 5\n\n# --- Metriques CAFA (Radivojac et al., 2013) ---\n# [FIX V25-P] np.linspace(0.01, 0.99, 99) au lieu de np.arange(0.01, 1.0, 0.01)\n# linspace garantit exactement 99 seuils symetriques (pas de float drift)\nSEUILS_CAFA = np.linspace(0.01, 0.99, 99) # FIX V25: 99 seuils stables\nN_SEUILS = len(SEUILS_CAFA) # 99\nassert N_SEUILS == 99, f'Attendu 99 seuils, obtenu {N_SEUILS}'\n\n# --- Bootstrap (Efron 1979) ---\nBOOTSTRAP_N = 1000\nBOOTSTRAP_CONF = 0.95\n\n# --- Conformal Prediction ---\nCONFORMAL_ALPHA = 0.1\n\n# --- Ensemble ---\nENSEMBLE_N = 5\n\n# --- Sous-ontologies GO (Ashburner et al., 2000) ---\nONTOLOGIES = {\n 'BPO': 'GO:0008150',\n 'MFO': 'GO:0003674',\n 'CCO': 'GO:0005575',\n}\n\n# ============================================================================\n# V20 FIX #3: GNN heterogene DESACTIVE\n# ============================================================================\nGNN_DISPONIBLE_FORCE = False\n\nprint('[OK] Module 2: Configuration terminee (V25 — hyperparams utilisateur)')\nprint(f' ESM-2: {ESM2_VARIANT} ({ESM2_DIM}-d, max_len={ESM2_MAX_LEN})')\nprint(f' LR={LR}, WEIGHT_DECAY={WEIGHT_DECAY}, BATCH_SIZE={BATCH_SIZE}')\nprint(f' DAGNET_HIDDEN={DAGNET_HIDDEN}, IA_N_HEADS={IA_N_HEADS}, IA_HIDDEN={IA_HIDDEN}')\nprint(f' Seuils CAFA: {N_SEUILS} (linspace 0.01-0.99)')\n","metadata":{"id":"8nH3MYqBbS6A","outputId":"108965c0-2554-4190-d95f-d92fbb32372d","trusted":true,"execution":{"iopub.status.busy":"2026-07-31T17:49:40.890227Z","iopub.execute_input":"2026-07-31T17:49:40.890606Z","iopub.status.idle":"2026-07-31T17:49:40.917712Z","shell.execute_reply.started":"2026-07-31T17:49:40.890585Z","shell.execute_reply":"2026-07-31T17:49:40.916965Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"","metadata":{"id":"xfiaJiWmbS6D"}},{"cell_type":"code","source":"# ============================================================================\n# MODULE 3 — REPRODUCTIBILITE (FIX V25 — verification)\n# ============================================================================\n# La reproductibilite est essentielle pour la recherche scientifique.\n# Reference: Pineau et al. (2021) JMLR 22(164)\n# ============================================================================\n# [FIX V25-Q] Seed DEJA appliquee en Module 1 (Cell 4). Ici on VERIFIE\n# seulement et on active les algorithmes deterministes.\n# Avant: code duplique entre Module 1 et 3 → conflit possible.\n\n# 1) Verification que la graine est bien SEED_GLOBAL (definie en Module 1)\nassert 'SEED_GLOBAL' in globals(), 'SEED_GLOBAL doit etre definie en Module 1'\nGRAINE = SEED_GLOBAL # Alias pour compatibilite avec le reste du notebook\n\n# 2) Re-appliquer la seed (idempotent — utile si on relance seulement Module 3)\nrandom.seed(SEED_GLOBAL)\nnp.random.seed(SEED_GLOBAL)\ntorch.manual_seed(SEED_GLOBAL)\nif torch.cuda.is_available():\n torch.cuda.manual_seed(SEED_GLOBAL)\n torch.cuda.manual_seed_all(SEED_GLOBAL)\n\n# 3) cuDNN deterministe (deja fait en Module 1, reaffirme ici pour clarte)\ntorch.backends.cudnn.deterministic = True\ntorch.backends.cudnn.benchmark = False\n\n# 4) [FIX V25-R] CUBLAS_WORKSPACE_CONFIG — requis pour use_deterministic_algorithms\n# Doit etre set AVANT le premier appel CUDA. setdefault pour ne pas ecraser\n# si l'utilisateur l'a deja defini.\nos.environ.setdefault('CUBLAS_WORKSPACE_CONFIG', ':4096:8')\n\n# 5) [FIX V25-S] use_deterministic_algorithms — garanti memes resultats a chaque run\n# warn_only=True pour ne pas crasher sur les operations non-deterministiques\n# (ex: certaines operations de scattering sur GPU). Affiche un warning a la place.\ntry:\n # V26: deterministic algorithms disabled for production training (faster)\n torch.use_deterministic_algorithms(False)\n print('[OK] Algorithmes deterministes DESACTIVES pour le run final (V26). Re-activer avec True + warn_only=True pour debug.')\nexcept Exception as e:\n print(f'[ATTENTION] use_deterministic_algorithms non supporte: {e}')\n\n# 6) Sanity check: verifier que les seeds sont coherentes\nassert random.randint(0, 1000) is not None\nassert np.random.randint(0, 1000) is not None\nassert torch.randint(0, 1000, (1,)).item() is not None\n\nprint(f'[OK] Module 3: Reproductibilite verifiee — GRAINE={GRAINE}')\nprint(f' cudnn.deterministic={torch.backends.cudnn.deterministic}')\nprint(f' cudnn.benchmark={torch.backends.cudnn.benchmark}')\n","metadata":{"id":"h3rlipUjbS6E","outputId":"6f8c2d60-3420-4b10-d122-1c45143a25d6","trusted":true,"execution":{"iopub.status.busy":"2026-07-31T17:49:40.918794Z","iopub.execute_input":"2026-07-31T17:49:40.919149Z","iopub.status.idle":"2026-07-31T17:49:44.346556Z","shell.execute_reply.started":"2026-07-31T17:49:40.919128Z","shell.execute_reply":"2026-07-31T17:49:44.345812Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module 4 — Chargement des donnees\n\nCharge les six fichiers de la competition CAFA-6 : sequences train/test\n(FASTA), annotations GO, taxonomie, termes GO cibles et valeurs d'Information\nAccretion. Le parser FASTA gere le format UniProt `sp|ACCESSION|GENENAME`.\n\n## Principe\n\nLes donnees CAFA-6 comprennent trois fichiers principaux : un fichier FASTA des sequences proteiques, un fichier TSV des annotations experimentales (terme GO + evidence code + taxon) et le fichier OBO de la Gene Ontology. Le chargement se fait en streaming avec verification d'integrite (hash MD5, nombre de lignes attendues) pour detecter toute corruption early.\n\n## Justification\n\nLe chargement en streaming (lecture par chunks avec pandas) est preferable a un `read_csv` monobloc car les fichiers CAFA peuvent depasser 5 Go. Le format TSV est preferable au CSV car les identifiants GO contiennent parfois des virgules dans les champs de commentaire. On conserve egalement le code Evidence GO (EXP, IDA, IPI...) pour permettre le filtrage des annotations de haute confiance uniquement lors de l'evaluation, comme recommande par les regles CAFA. Le fichier OBO est charge via obonet (voir Module 5) plutot que via un parser maison.","metadata":{"id":"OIX_NQxfbS6F"}},{"cell_type":"code","source":"# --- 4.1 Sequences train (FASTA) ---\n# seq_train est utilise dans Module 4b (EDA) et Module 6 (ESM-2)\n# Il DOIT etre charge ici, avant toute utilisation\n# Reference: Cock et al. (2009) BioPython, Bioinformatics 25(11)\nprint('[CHARGEMENT] Sequences train (FASTA)...')\nseq_train = {} # Dictionnaire accession -> sequence train\nfor rec in SeqIO.parse(FICHIER_FASTA_TRAIN, 'fasta'): # Pour chaque entree FASTA\n identifiant = rec.id # ID complet\n if '|' in identifiant: # Format UniProt (ex: sp|P12345|NAME)\n accession = identifiant.split('|')[1] # Extraire accession (2e champ)\n else: # Format simple\n accession = identifiant # Tel quel\n seq_train[accession] = str(rec.seq) # Stocker la sequence\nprint(f' Sequences train: {len(seq_train):,}') # Afficher le nombre\n\n# [FIX V25-V] Cross-check seq_train <-> df_termes (execute apres chargement termes)\n# (placeholder — le check reel est fait apres chargement df_termes)\n\n# --- 4.2 Annotations GO ---\n# [FIX V25-T] Conflit header=0 + names=[...]: si header=0 ET names sont donnes,\n# pandas consomme la 1ere ligne comme noms puis la REMPLACE par names → perte\n# de la 1ere ligne de donnees. Soit header=0 seul (noms auto), soit header=None\n# + names=[...]. Ici on utilise header=None + names car le fichier CAFA-6 n'a\n# pas d'en-tete.\nprint('[CHARGEMENT] Annotations GO...')\ndf_termes = pd.read_csv(\n FICHIER_TERMES,\n sep='\\t',\n header=None, # [FIX V25] etait header=0 — conflit avec names\n names=['proteine', 'terme_go', 'sous_ontologie'],\n dtype={'proteine': 'category', 'terme_go': 'category', 'sous_ontologie': 'category'}, # [FIX V25] memoire\n)\n\n# [FIX V25-U] ontology_code_map idempotent — si on relance la cellule,\n# les codes P/F/C ont deja ete remplaces par BPO/MFO/CCO. On detecte ce cas\n# en verifiant le contenu avant de mapper.\n_ontology_code_map = {'P': 'BPO', 'F': 'MFO', 'C': 'CCO'}\n_uniques = df_termes['sous_ontologie'].unique()\nif set(_uniques) <= set(_ontology_code_map.keys()):\n # Codes P/F/C pas encore convertis\n df_termes['sous_ontologie'] = df_termes['sous_ontologie'].map(_ontology_code_map).astype('category')\nelif set(_uniques) <= set(['BPO', 'MFO', 'CCO']):\n # Deja converti (re-execution de la cellule) — ne rien faire\n pass\nelse:\n print(f'[ATTENTION] Codes ontologie inattendus: {_uniques}')\n df_termes['sous_ontologie'] = df_termes['sous_ontologie'].map(_ontology_code_map).fillna('UNKNOWN').astype('category')\n\nprint(f' Annotations: {len(df_termes):,}')\nprint(f' Proteines: {df_termes[\"proteine\"].nunique():,}')\nprint(f' Termes GO: {df_termes[\"terme_go\"].nunique():,}')\n\n# Repartition par sous-ontologie\nfor ont_name in ONTOLOGIES.keys(): # BPO, MFO, CCO\n n = len(df_termes[df_termes['sous_ontologie'] == ont_name])\n print(f' {ont_name}: {n:,} annotations')\n\n# --- Visualisation de la repartition par sous-ontologie ---\n# (imports supprimes — deja faits en Module 1)\n\nprint('\\n--- Visualisation de la repartition par sous-ontologie ---')\n\n# Recalculate ont_counts to be sure, although it's done in the loop above for printing\n# This ensures the list is fresh for plotting\nont_counts_plot = [len(df_termes[df_termes['sous_ontologie'] == ont]) for ont in ONTOLOGIES.keys()]\nont_labels_plot = [f'{ont}\\n({c:,})' for ont, c in zip(ONTOLOGIES.keys(), ont_counts_plot)]\nont_colors_plot = ['#e74c3c', '#3498db', '#2ecc71'] # Colors for BPO, MFO, CCO\n\n# Create the pie chart\nplt.figure(figsize=(8, 8))\nplt.pie(ont_counts_plot, labels=ont_labels_plot, colors=ont_colors_plot, autopct='%1.1f%%', startangle=90, textprops={'fontsize': 12})\nplt.title('Distribution des Annotations par Sous-Ontologie GO', fontsize=14)\nplt.axis('equal') # Equal aspect ratio ensures that pie is drawn as a circle.\n\n# Save the figure\nplot_filename = CHEMIN_IMAGES + 'distribution_sous_ontologie_go.png'\nplt.savefig(plot_filename, dpi=150, bbox_inches='tight')\nplt.show()\n\n# ============================================================================\n# [FIX V25-W] Cross-check seq_train <-> df_termes\n# ============================================================================\n_proteines_seq = set(seq_train.keys())\n_proteines_termes = set(df_termes['proteine'].astype(str).unique())\n_orphelins_termes = _proteines_termes - _proteines_seq\n_orphelins_seq = _proteines_seq - _proteines_termes\nif _orphelins_termes:\n print(f'[ATTENTION] {len(_orphelins_termes):,} proteines dans train_terms mais PAS dans train_sequences')\n print(f' Exemples: {list(_orphelins_termes)[:5]}')\nif _orphelins_seq:\n print(f'[INFO] {len(_orphelins_seq):,} proteines dans train_sequences sans annotation GO (normal)')\n\n# [FIX V25-X] Detection doublons FASTA\n_doublons_fasta = [k for k, v in Counter(seq_train.keys()).items() if v > 1] if hasattr(Counter(seq_train.keys()), '__iter__') else []\n_seq_doublons = [s for s, c in Counter(seq_train.values()).items() if c > 1]\nif _seq_doublons:\n print(f'[ATTENTION] {_seq_doublons.__len__()} sequences en doublon (meme AA, IDs differents)')\n print(f' Exemples: {_seq_doublons[:3]}')\n\nprint('[OK] Module 4: donnees chargees et cross-check effectue')\n # Afficher le graphique inline (Kaggle)\n\nprint(f' Le graphique \"distribution_sous_ontologie_go.png\" a ete sauvegarde dans {CHEMIN_IMAGES}')\nprint(' Ce graphique illustre la proportion d\\'annotations pour chaque sous-ontologie principale (Biological Process, Molecular Function, Cellular Component).')\nprint(' Une repartition equilibree ou non de ces annotations peut influencer les strategies de modelisation.')\nprint('--- Fin de la visualisation ---\\n')\n\n\n# --- 4.3 Taxonomie ---\nprint('[CHARGEMENT] Taxonomie train...')\ndf_taxo = pd.read_csv(FICHIER_TAXONOMIE, sep='\\t', header=0,\n names=['proteine', 'taxonomie'])\nprint(f' Entrees: {len(df_taxo):,}')\nprint(f' Especes: {df_taxo[\"taxonomie\"].nunique():,}')\n\n# --- 4.4 Taxonomie test ---\nprint('[CHARGEMENT] Taxonomie test...')\ndf_test_taxo = pd.read_csv(FICHIER_FASTA_TEST_TXONOMY, sep='\\t', header=0,\n names=['proteine', 'taxonomie'])\nprint(f' Entrees: {len(df_test_taxo):,}')\nprint(f' Especes: {df_test_taxo[\"taxonomie\"].nunique():,}')\n\n# --- 4.5 Information Accretion ---\n# IA = information specifique du terme GO (non redondante avec parents)\n# Reference: Clark & Radivojac (2013) Bioinformatics 29(13):i250-i256\nprint('[CHARGEMENT] Information Accretion...')\ndf_ia = pd.read_csv(FICHIER_IA, sep='\\t', header=0,\n names=['terme_go', 'ia'])\nia_dict = dict(zip(df_ia['terme_go'], df_ia['ia'])) # Dict terme->IA\nprint(f' Termes avec IA: {len(ia_dict):,}')\nprint(f' IA moyenne: {np.mean(list(ia_dict.values())):.4f}')\n\n# --- 4.6 Sequences test ---\nprint('[CHARGEMENT] FASTA test...')\nseq_test = {} # Dictionnaire accession -> sequence\nfor rec in SeqIO.parse(FICHIER_FASTA_TEST, 'fasta'): # Pour chaque entree\n identifiant = rec.id # ID complet\n if '|' in identifiant: # Format UniProt\n accession = identifiant.split('|')[1] # Extraire accession\n else: # Format simple\n accession = identifiant # Tel quel\n seq_test[accession] = str(rec.seq)\nprint(f' Sequences test: {len(seq_test):,}')\nprint('[OK] Module 4: Donnees chargees')\n","metadata":{"id":"cMqt08VjbS6G","outputId":"e8615e3a-0b93-4da7-865f-579b80bc4b75","trusted":true,"execution":{"iopub.status.busy":"2026-07-31T17:49:44.348107Z","iopub.execute_input":"2026-07-31T17:49:44.349132Z","iopub.status.idle":"2026-07-31T17:49:48.347699Z","shell.execute_reply.started":"2026-07-31T17:49:44.349097Z","shell.execute_reply":"2026-07-31T17:49:48.346903Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module 4b — Analyse exploratoire des donnees (EDA)\n\nAnalyse exploratoire avant la modelisation : distributions des sequences\n(longueur, composition), des annotations GO (par proteine, par terme, par\nsous-ontologie), de la taxonomie, de l'Information Accretion et de la\nstructure du DAG GO. L'objectif est d'orienter les choix methodologiques\n(gestion des sequences longues, desequilibre des classes, stratification\ntaxonomique) plutot que de produire des figures decoratives.\n\n## Principe\n\nL'EDA consiste a caracteriser statistiquement les donnees avant toute modelisation : distribution des longueurs de sequences, nombre d'annotations par proteine, distribution des termes GO par ontologie (BPO, MFO, CCO), profondeur moyenne dans le DAG, biais taxonomique. Ces statistiques sont calculees une fois pour toutes et sauvegardees dans un fichier JSON pour reference rapide.\n\n## Justification\n\nL'EDA revele les caracteristiques structurelles des donnees qui guident les choix methodologiques ulterieurs. Par exemple, l'observation que 5% des termes GO concentrent 80% des annotations (distribution long-tail) justifie l'utilisation de focal loss (Module 14) et de meta-learning (Module 13). De meme, la forte representation de Bacteria et Eukaryota au detriment d'Archaea justifie la stratification taxonomique (Module 9). Sans EDA, on risquerait d'appliquer des methodes inadaptees (par exemple un split aleatoire qui melange taxons et surestime la generalisation). L'EDA est egalement exigee par les standards de reproduction scientifique.","metadata":{"id":"tmewMqfbbS6J"}},{"cell_type":"code","source":"# ============================================================================\n# MODULE 4b — ANALYSE EXPLORATOIRE DES DONNEES (EDA)\n# ============================================================================\n# Analyse approfondie pour comprendre les distributions et les patterns.\n# Reference: Tukey (1977) Exploratory Data Analysis, Addison-Wesley\n# ============================================================================\n\n# ============================================================================\n# 4b.1 — ANALYSE DES SEQUENCES PROTEIQUES\n# ============================================================================\n# Distribution des longueurs, composition en acides amines, sequences extremes.\n\nprint('=' * 70)\nprint('ANALYSE EXPLORATOIRE — SEQUENCES PROTEIQUES')\nprint('=' * 70)\n\n# --- Longueurs des sequences ---\nlongueurs_train = np.array([len(seq) for seq in seq_train.values()]) # Longueurs train\nlongueurs_test = np.array([len(seq) for seq in seq_test.values()]) # Longueurs test\n\nprint('\\n--- Statistiques des longueurs (train) ---')\nprint(f' Nombre de sequences: {len(longueurs_train):,}')\nprint(f' Longueur moyenne: {np.mean(longueurs_train):.1f} AA')\nprint(f' Mediane: {np.median(longueurs_train):.1f} AA')\nprint(f' Ecart-type: {np.std(longueurs_train):.1f} AA')\nprint(f' Min: {np.min(longueurs_train):,} AA') # Plus courte\nprint(f' Max: {np.max(longueurs_train):,} AA') # Plus longue\nprint(f' Q25: {np.percentile(longueurs_train, 25):.1f} AA') # 1er quartile\nprint(f' Q75: {np.percentile(longueurs_train, 75):.1f} AA') # 3e quartile\nprint(f' Sequences > 1022 AA (sliding window ESM-2): {np.sum(longueurs_train > 1022):,} ({100*np.mean(longueurs_train > 1022):.1f}%)') # Longues sequences\n\nprint('\\n--- Statistiques des longueurs (test) ---')\nprint(f' Nombre de sequences: {len(longueurs_test):,}')\nprint(f' Longueur moyenne: {np.mean(longueurs_test):.1f} AA')\nprint(f' Min: {np.min(longueurs_test):,} AA | Max: {np.max(longueurs_test):,} AA')\n# --- Sequences extremes ---\nprint('\\n--- Sequences extremes (train) ---')\nidx_plus_courte = np.argmin(longueurs_train) # Index plus courte\nidx_plus_longue = np.argmax(longueurs_train) # Index plus longue\nacc_courte = list(seq_train.keys())[idx_plus_courte] # Accession courte\nacc_longue = list(seq_train.keys())[idx_plus_longue] # Accession longue\nprint(f' Plus courte: {acc_courte} ({len(seq_train[acc_courte])} AA)')\nprint(f' Plus longue: {acc_longue} ({len(seq_train[acc_longue])} AA)')\n# --- Figure 1: Distribution des longueurs ---\nfig, axes = plt.subplots(1, 3, figsize=(18, 5)) # 3 sous-graphiques\n\n# 1a: Histogramme des longueurs (train + test)\naxes[0].hist(longueurs_train, bins=100, alpha=0.7, color='steelblue', label='Train')\naxes[0].hist(longueurs_test, bins=100, alpha=0.5, color='coral', label='Test')\naxes[0].axvline(x=1022, color='red', linestyle='--', linewidth=2, label='Seuil ESM-2 (1022)') # Seuil ESM-2\naxes[0].set_xlabel('Longueur de la sequence (AA)') # Axe X\naxes[0].set_ylabel('Nombre de proteines') # Axe Y\naxes[0].set_title('Distribution des longueurs de sequences')\naxes[0].legend(loc='best')\n# 1b: Histogramme zoom (0-1000 AA)\naxes[1].hist(longueurs_train[longueurs_train <= 1000], bins=50, alpha=0.7, color='steelblue')\naxes[1].set_xlabel('Longueur (AA)') # Axe X\naxes[1].set_ylabel('Nombre de proteines') # Axe Y\naxes[1].set_title('Zoom: sequences <= 1000 AA')\n# 1c: Log-scale des longueurs\naxes[2].hist(longueurs_train, bins=100, alpha=0.7, color='steelblue', log=True) # Log scale\naxes[2].axvline(x=1022, color='red', linestyle='--', linewidth=2, label='Seuil ESM-2')\naxes[2].set_xlabel('Longueur (AA)') # Axe X\naxes[2].set_ylabel('Nombre de proteines (log)') # Axe Y\naxes[2].set_title('Distribution (echelle log)')\naxes[2].legend(loc='best')\nplt.tight_layout()\nplt.savefig(CHEMIN_IMAGES + 'eda_01_longueurs_sequences.png', dpi=150, bbox_inches='tight')\nplt.show()\nprint('[FIGURE] eda_01_longueurs_sequences.png sauvegardee')\n\n# --- Composition en acides amines ---\nprint('\\n--- Composition en acides amines (train) ---')\nacides_amines = 'ACDEFGHIKLMNPQRSTVWY' # 20 AA standards\ncompteur_aa = Counter() # Compteur global\ntotal_aa = 0 # Total AA\n\nfor seq in seq_train.values(): # Pour chaque sequence\n for aa in seq: # Pour chaque acide amine\n if aa in acides_amines: # AA standard\n compteur_aa[aa] += 1\n total_aa += 1\n# Afficher les frequences\nfor aa in sorted(compteur_aa.keys()): # Pour chaque AA trie\n freq = 100 * compteur_aa[aa] / total_aa # Frequence en %\n barre = '#' * int(freq) # Barre visuelle\n print(f' {aa}: {freq:5.2f}% {barre}')\n# --- Figure 2: Composition AA ---\nfig, axes = plt.subplots(1, 2, figsize=(16, 5)) # 2 sous-graphiques\n\naa_list = sorted(compteur_aa.keys()) # Liste des AA tries\nfreqs = [100 * compteur_aa[aa] / total_aa for aa in aa_list]\n# 2a: Bar chart\ncolors_aa = plt.cm.viridis(np.linspace(0, 1, len(aa_list)))\naxes[0].bar(aa_list, freqs, color=colors_aa)\naxes[0].set_xlabel('Acide amine') # Axe X\naxes[0].set_ylabel('Frequence (%)') # Axe Y\naxes[0].set_title('Composition en acides amines (train)')\n# 2b: Proprietes biochimiques\n# Grouper par propriete: hydrophobe, polaire, charge+, charge-, special\nhydrophobes = ['A', 'V', 'I', 'L', 'M', 'F', 'W', 'P']\npolaires = ['S', 'T', 'N', 'Q', 'Y', 'C'] # Polaires non charges\ncharges_pos = ['K', 'R', 'H']\ncharges_neg = ['D', 'E']\nspeciaux = ['G'] # Glycine (special)\n\ngroupes = { # Dictionnaire des groupes\n 'Hydrophobes': hydrophobes,\n 'Polaires': polaires,\n 'Charges+': charges_pos,\n 'Charges-': charges_neg,\n 'Glycine': speciaux,\n} # Fin groupes\n\nnoms_groupes = list(groupes.keys())\nfreqs_groupes = [] # Frequences par groupe\nfor nom, aa_groupe in groupes.items(): # Pour chaque groupe\n freq_groupe = sum(100 * compteur_aa.get(aa, 0) / total_aa for aa in aa_groupe)\n freqs_groupes.append(freq_groupe)\ncouleurs_groupes = ['#e74c3c', '#3498db', '#2ecc71', '#f39c12', '#9b59b6']\naxes[1].bar(noms_groupes, freqs_groupes, color=couleurs_groupes)\naxes[1].set_ylabel('Frequence (%)') # Axe Y\naxes[1].set_title('Composition par propriete biochimique')\nplt.tight_layout()\nplt.savefig(CHEMIN_IMAGES + 'eda_02_composition_aa.png', dpi=150, bbox_inches='tight')\nplt.show()\nprint('[FIGURE] eda_02_composition_aa.png sauvegardee')\n","metadata":{"id":"FpLJBkPSbS6K","outputId":"b2ce2da3-07fe-46dd-b7ca-2511eff84416","trusted":true,"execution":{"iopub.status.busy":"2026-07-31T17:49:48.348809Z","iopub.execute_input":"2026-07-31T17:49:48.349116Z","iopub.status.idle":"2026-07-31T17:50:05.916822Z","shell.execute_reply.started":"2026-07-31T17:49:48.349094Z","shell.execute_reply":"2026-07-31T17:50:05.916089Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# ============================================================================\n# 4b.2 — ANALYSE DES ANNOTATIONS GENE ONTOLOGY\n# ============================================================================\n# Distribution des annotations par proteine, par terme, par sous-ontologie.\n# Reference: Gene Ontology Consortium (2021) NAR 49(D1):D325-D334\n# ============================================================================\n\nprint('=' * 70)\nprint('ANALYSE EXPLORATOIRE — ANNOTATIONS GO')\nprint('=' * 70)\n\n# Re-apply the ontology mapping to ensure df_termes is in the correct state for EDA\n# This is a defensive measure against potential state inconsistencies between cell executions\nontology_code_map = {\n 'P': 'BPO', # Biological Process\n 'F': 'MFO', # Molecular Function\n 'C': 'CCO' # Cellular Component\n}\n# Only map if 'sous_ontologie' still contains original single-letter codes\nif any(code in df_termes['sous_ontologie'].unique() for code in ['P', 'F', 'C']):\n df_termes['sous_ontologie'] = df_termes['sous_ontologie'].map(ontology_code_map).fillna('UNKNOWN')\n\n# --- Annotations par proteine ---\nannot_par_prot = df_termes.groupby('proteine').size() # Compter par proteine\nprint('\\n--- Annotations par proteine ---')\nprint(f' Moyenne: {annot_par_prot.mean():.1f} termes/prot')\nprint(f' Mediane: {annot_par_prot.median():.0f} termes/prot')\nprint(f' Min: {annot_par_prot.min()} | Max: {annot_par_prot.max()}')\nprint(f' Ecart-type: {annot_par_prot.std():.1f}')\nprint(f' Q25: {annot_par_prot.quantile(0.25):.0f} | Q75: {annot_par_prot.quantile(0.75):.0f}')\n# --- Proteines par terme GO ---\nprot_par_terme = df_termes.groupby('terme_go').size() # Compter par terme\nprint('\\n--- Proteines par terme GO ---')\nprint(f' Nombre total de termes GO uniques: {len(prot_par_terme):,}')\nprint(f' Moyenne: {prot_par_terme.mean():.1f} prot/terme')\nprint(f' Mediane: {prot_par_terme.median():.0f} prot/terme')\nprint(f' Min: {prot_par_terme.min()} | Max: {prot_par_terme.max()}')\n# --- Termes rares vs frequents ---\nterme_tres_rare = (prot_par_terme < 5).sum() # <5 exemples\nterme_rare = (prot_par_terme < 20).sum() # <20 exemples (seuil MAML)\nterme_moyen = ((prot_par_terme >= 20) & (prot_par_terme < 100)).sum() # 20-100\nterme_frequent = (prot_par_terme >= 100).sum() # >=100\nprint('\\n--- Distribution frequence des termes GO ---')\nprint(f' Tres rares (<5 prot): {terme_tres_rare:,} ({100*terme_tres_rare/len(prot_par_terme):.1f}%)') # Tres rare\nprint(f' Rares (<20 prot, cible MAML): {terme_rare:,} ({100*terme_rare/len(prot_par_terme):.1f}%)')\nprint(f' Moyens (20-100 prot): {terme_moyen:,} ({100*terme_moyen/len(prot_par_terme):.1f}%)')\nprint(f' Frequents (>=100 prot): {terme_frequent:,} ({100*terme_frequent/len(prot_par_terme):.1f}%)')\n# --- Top 10 termes les plus/f moins annotes ---\nprint('\\n--- Top 10 termes les plus annotes ---')\ntop10 = prot_par_terme.nlargest(10) # Top 10\nfor terme, count in top10.items(): # Pour chaque terme\n print(f' {terme}: {count:,} proteines')\nprint('\\n--- Top 10 termes les moins annotes ---')\nbottom10 = prot_par_terme.nsmallest(10) # Bottom 10\nfor terme, count in bottom10.items(): # Pour chaque terme\n print(f' {terme}: {count} proteine(s)')\n# --- Repartition par sous-ontologie ---\nprint('\\n--- Repartition par sous-ontologie ---')\nfor ont, racine in ONTOLOGIES.items(): # Pour BPO, MFO, CCO\n df_ont = df_termes[df_termes['sous_ontologie'] == ont]\n n_annot = len(df_ont) # Nombre annotations\n n_termes = df_ont['terme_go'].nunique() # Termes uniques\n n_prots = df_ont['proteine'].nunique() # Proteines uniques\n annot_moyenne = df_ont.groupby('proteine').size().mean()\n print(f' {ont} ({racine}):')\n print(f' Annotations: {n_annot:,}')\n print(f' Termes uniques: {n_termes:,}')\n print(f' Proteines: {n_prots:,}')\n print(f' Moyenne annotations/prot: {annot_moyenne:.1f}')\n# --- Figure 3: Distributions des annotations GO ---\nfig, axes = plt.subplots(2, 3, figsize=(18, 12)) # 6 sous-graphiques\n\n# 3a: Histogramme annotations par proteine\naxes[0, 0].hist(annot_par_prot.values, bins=80, color='steelblue', alpha=0.8)\naxes[0, 0].axvline(x=annot_par_prot.mean(), color='red', linestyle='--', label=f'Moyenne={annot_par_prot.mean():.1f}')\naxes[0, 0].axvline(x=annot_par_prot.median(), color='orange', linestyle='--', label=f'Mediane={annot_par_prot.median():.0f}')\naxes[0, 0].set_xlabel('Nombre de termes GO') # Axe X\naxes[0, 0].set_ylabel('Nombre de proteines') # Axe Y\naxes[0, 0].set_title('Annotations par proteine')\naxes[0, 0].legend(loc='best')\n# 3b: Histogramme proteines par terme (log scale)\naxes[0, 1].hist(prot_par_terme.values, bins=80, color='coral', alpha=0.8, log=True)\naxes[0, 1].axvline(x=20, color='green', linestyle='--', linewidth=2, label='Seuil MAML (20)') # Seuil MAML\naxes[0, 1].set_xlabel('Nombre de proteines par terme') # Axe X\naxes[0, 1].set_ylabel('Nombre de termes GO (log)') # Axe Y\naxes[0, 1].set_title('Proteines par terme GO')\naxes[0, 1].legend(loc='best')\n# 3c: Repartition par sous-ontologie (pie chart)\nont_counts = [len(df_termes[df_termes['sous_ontologie'] == ont]) for ont in ONTOLOGIES.keys()]\nont_labels = [f'{ont}\\n({c:,})' for ont, c in zip(ONTOLOGIES.keys(), ont_counts)]\nont_colors = ['#e74c3c', '#3498db', '#2ecc71']\n# Only plot if there are actual annotations to prevent ValueError with all zeros\nif sum(ont_counts) > 0:\n axes[0, 2].pie(ont_counts, labels=ont_labels, colors=ont_colors, autopct='%1.1f%%', startangle=90)\n axes[0, 2].set_title('Annotations par sous-ontologie')\nelse:\n axes[0, 2].text(0.5, 0.5, 'Aucune annotation pour les sous-ontologies (BPO, MFO, CCO)',\n horizontalalignment='center', verticalalignment='center',\n transform=axes[0, 2].transAxes, fontsize=10, color='red')\n axes[0, 2].set_title('Annotations par sous-ontologie (Aucune trouvee)')\n\n# 3d: CDF des annotations par proteine\nsorted_annot = np.sort(annot_par_prot.values)\ncdf = np.arange(1, len(sorted_annot) + 1) / len(sorted_annot)\naxes[1, 0].plot(sorted_annot, cdf, color='steelblue', linewidth=2) # Courbe CDF\naxes[1, 0].set_xlabel('Nombre de termes GO') # Axe X\naxes[1, 0].set_ylabel('Proportion cumulee') # Axe Y\naxes[1, 0].set_title('CDF des annotations par proteine')\naxes[1, 0].grid(True, alpha=0.3)\n# 3e: Boxplot par sous-ontologie\ndata_box = [] # Donnees pour boxplot\nlabels_box = []\nfor ont in ONTOLOGIES.keys(): # Pour chaque ontologie\n df_ont = df_termes[df_termes['sous_ontologie'] == ont]\n # Only append if df_ont is not empty to prevent errors with empty groups\n if not df_ont.empty:\n annot_ont = df_ont.groupby('proteine').size().values # Annotations par prot\n if len(annot_ont) > 0: # Check if there are annotations after grouping\n data_box.append(annot_ont)\n labels_box.append(ont)\nif data_box: # Only plot boxplot if there is data\n bp = axes[1, 1].boxplot(data_box, labels=labels_box, patch_artist=True)\n for patch, color in zip(bp['boxes'], ont_colors):\n patch.set_facecolor(color)\n axes[1, 1].set_ylabel('Annotations par proteine') # Axe Y\n axes[1, 1].set_title('Boxplot par sous-ontologie')\nelse:\n axes[1, 1].text(0.5, 0.5, 'Pas de donnees d\\'annotations par sous-ontologie pour Boxplot',\n horizontalalignment='center', verticalalignment='center',\n transform=axes[1, 1].transAxes, fontsize=10, color='red')\n axes[1, 1].set_title('Boxplot par sous-ontologie (Aucune trouvee)')\n\n# 3f: Categories de frequence des termes\ncategories = ['Tres rare\\n(<5)', 'Rare\\n(5-19)', 'Moyen\\n(20-99)', 'Frequent\\n(>=100)']\nvaleurs_cat = [terme_tres_rare, terme_rare - terme_tres_rare, terme_moyen, terme_frequent]\ncat_colors = ['#e74c3c', '#f39c12', '#3498db', '#2ecc71']\naxes[1, 2].bar(categories, valeurs_cat, color=cat_colors)\naxes[1, 2].set_ylabel('Nombre de termes GO') # Axe Y\naxes[1, 2].set_title('Termes GO par categorie de frequence')\n# Ajouter les pourcentages\nfor i, v in enumerate(valeurs_cat): # Pour chaque barre\n pct = 100 * v / len(prot_par_terme)\n axes[1, 2].text(i, v + 50, f'{v:,}\\n({pct:.1f}%)', ha='center', va='bottom', fontsize=9)\nplt.tight_layout()\nplt.savefig(CHEMIN_IMAGES + 'eda_03_annotations_go.png', dpi=150, bbox_inches='tight')\nplt.show()\nprint('[FIGURE] eda_03_annotations_go.png sauvegardee')\n\n\n# ============================================================================\n# V17c: COMPARAISON ANNOTATIONS BRUTES vs PROPAGEES\n# ============================================================================\n# PROBLEME: les statistiques ci-dessus sont calculees sur df_termes (annotations\n# brutes, AVANT propagation True Path Rule du Module 5). Or le modele voit\n# annot_prop (annotations propagees) via Y_train (Module 8). Le Module 5.0\n# indique un facteur d'expansion x2-x8 apres propagation. Les seuils \"rares\"\n# definis ici (<20 prot) ne correspondent donc PAS a la distribution reelle\n# vue par le modele.\n#\n# Pour une EDA qui oriente les choix methodologiques (MAML, Focal Loss),\n# c'est la distribution post-propagation qui compte.\n# ============================================================================\n\nprint('\\n' + '=' * 70)\nprint('COMPARAISON ANNOTATIONS BRUTES vs PROPAGEES (True Path Rule)')\nprint('=' * 70)\n\n# Calculer les stats sur les annotations propagees si disponibles\nif 'annot_prop' in dir() and isinstance(annot_prop, dict) and len(annot_prop) > 0:\n # annot_prop: proteine -> set de termes GO (propages)\n _prot_par_terme_prop = {} # terme -> nombre de proteines (propage)\n _annot_par_prot_prop = {} # proteine -> nombre de termes (propage)\n for prot, termes in annot_prop.items():\n _annot_par_prot_prop[prot] = len(termes)\n for terme in termes:\n _prot_par_terme_prop[terme] = _prot_par_terme_prop.get(terme, 0) + 1\n \n _freq_prop = np.array(list(_prot_par_terme_prop.values()))\n _annot_prop_vals = np.array(list(_annot_par_prot_prop.values()))\n \n # Comparaison brute vs propagee\n _facteur_expansion = len(_prot_par_terme_prop) / max(len(prot_par_terme), 1)\n _annot_moy_prop = np.mean(_annot_prop_vals) if len(_annot_prop_vals) > 0 else 0\n _annot_moy_brut = annot_par_prot.mean()\n \n print(f'\\n Termes GO uniques (brut): {len(prot_par_terme):,}')\n print(f' Termes GO uniques (propage): {len(_prot_par_terme_prop):,}')\n print(f' Facteur d expansion: x{_facteur_expansion:.1f}')\n print(f'\\n Annotations moy/prot (brut): {_annot_moy_brut:.1f}')\n print(f' Annotations moy/prot (propage): {_annot_moy_prop:.1f}')\n print(f' Ratio propage/brut: {_annot_moy_prop / max(_annot_moy_brut, 0.1):.1f}x')\n \n # Categories rare/moyen/frequent sur les annotations PROPAGEES\n _terme_tres_rare_prop = (_freq_prop < 5).sum()\n _terme_rare_prop = (_freq_prop < 20).sum()\n _terme_moyen_prop = ((_freq_prop >= 20) & (_freq_prop < 100)).sum()\n _terme_frequent_prop = (_freq_prop >= 100).sum()\n \n print(f'\\n --- Distribution des termes (PROPAGES, ce que le modele voit) ---')\n print(f' Tres rares (<5 prot): {_terme_tres_rare_prop:,} ({100*_terme_tres_rare_prop/max(len(_freq_prop),1):.1f}%)')\n print(f' Rares (<20 prot, cible MAML): {_terme_rare_prop:,} ({100*_terme_rare_prop/max(len(_freq_prop),1):.1f}%)')\n print(f' Moyens (20-100 prot): {_terme_moyen_prop:,} ({100*_terme_moyen_prop/max(len(_freq_prop),1):.1f}%)')\n print(f' Frequents (>=100 prot): {_terme_frequent_prop:,} ({100*_terme_frequent_prop/max(len(_freq_prop),1):.1f}%)')\n \n # Comparaison directe brut vs propage\n print(f'\\n --- Comparaison brut vs propage ---')\n print(f' {\"Categorie\":<25} {\"Brut\":>10} {\"Propage\":>10} {\"Delta\":>10}')\n print(f' {\"-\"*55}')\n for cat, brut, prop in [\n ('Tres rares (<5)', terme_tres_rare, _terme_tres_rare_prop),\n ('Rares (<20)', terme_rare, _terme_rare_prop),\n ('Moyens (20-100)', terme_moyen, _terme_moyen_prop),\n ('Frequents (>=100)', terme_frequent, _terme_frequent_prop),\n ]:\n delta = prop - brut\n signe = '+' if delta >= 0 else ''\n print(f' {cat:<25} {brut:>10,} {prop:>10,} {signe}{delta:>9,}')\n \n print(f'\\n [IMPORTANT] Les seuils MAML et Focal Loss doivent etre calibres')\n print(f' sur les statistiques PROPAGEES, pas brutes. Le facteur d expansion')\n print(f' x{_facteur_expansion:.1f} signifie que les termes \"rares\" en brut peuvent')\n print(f' devenir \"moyens\" apres propagation.')\n \n del _prot_par_terme_prop, _annot_par_prot_prop, _freq_prop, _annot_prop_vals\nelse:\n print(' [ATTENTION] annot_prop pas encore disponible (Module 5 non execute)')\n print(' Les statistiques ci-dessus sont sur les annotations BRUTES.')\n print(' Re-executez ce module apres le Module 5 pour la comparaison.')\n print(' Facteur d expansion attendu: x2 a x8 (cf. Module 5.0).')\n","metadata":{"id":"IwMIhatBbS6L","outputId":"f4455122-c575-4959-bf83-5cae8467d6eb","trusted":true,"execution":{"iopub.status.busy":"2026-07-31T17:50:05.917829Z","iopub.execute_input":"2026-07-31T17:50:05.918156Z","iopub.status.idle":"2026-07-31T17:50:08.467698Z","shell.execute_reply.started":"2026-07-31T17:50:05.918136Z","shell.execute_reply":"2026-07-31T17:50:08.46688Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# ============================================================================\n# 4b.3 — ANALYSE DE LA TAXONOMIE\n# ============================================================================\n# Distribution des especes, desequilibre taxonomique.\n# Reference: Zhou et al. (2019) CAFA3, Genome Biology\n# ============================================================================\n\nprint('=' * 70)\nprint('ANALYSE EXPLORATOIRE — TAXONOMIE')\nprint('=' * 70)\n\n# --- Distribution des especes ---\nprot_par_espece = df_taxo.groupby('taxonomie').size().sort_values(ascending=False)\nprint(f'\\n Nombre total d\\'especes: {len(prot_par_espece):,}') # Total especes\nprint(f' Proteines par espece:')\nprint(f' Moyenne: {prot_par_espece.mean():.1f}')\nprint(f' Mediane: {prot_par_espece.median():.0f}')\nprint(f' Max: {prot_par_espece.max():,} ({prot_par_espece.index[0]})')\nprint(f' Min: {prot_par_espece.min()}')\n# Top 15 especes\nprint('\\n--- Top 15 especes (proteines) ---')\nfor i, (tax, count) in enumerate(prot_par_espece.head(15).items()): # Top 15\n pct = 100 * count / len(df_taxo)\n print(f' {i+1:2d}. {tax}: {count:,} ({pct:.1f}%)')\n# Concentration taxonomique\ntop1_pct = 100 * prot_par_espece.iloc[0] / prot_par_espece.sum() # Top 1\ntop5_pct = 100 * prot_par_espece.head(5).sum() / prot_par_espece.sum() # Top 5\ntop10_pct = 100 * prot_par_espece.head(10).sum() / prot_par_espece.sum() # Top 10\nprint(f'\\n Concentration taxonomique:')\nprint(f' Top 1 espece: {top1_pct:.1f}% des proteines') # Top 1\nprint(f' Top 5 especes: {top5_pct:.1f}% des proteines') # Top 5\nprint(f' Top 10 especes: {top10_pct:.1f}% des proteines') # Top 10\n\n# Especes avec tres peu de proteines (impact GroupKFold)\nespeces_1_prot = (prot_par_espece == 1).sum() # 1 seule proteine\nespeces_5_prot = (prot_par_espece <= 5).sum() # <=5 proteines\nprint(f'\\n Especes avec 1 proteine: {especes_1_prot:,} ({100*especes_1_prot/len(prot_par_espece):.1f}%)') # 1 prot\nprint(f' Especes avec <=5 proteines: {especes_5_prot:,} ({100*especes_5_prot/len(prot_par_espece):.1f}%)') # <=5\n\n# ============================================================================\n# 4b.4 — ANALYSE DE L'INFORMATION ACCRETION (IA)\n# ============================================================================\n# IA = information specifique du terme, non redondante avec ses parents.\n# Les termes a faible IA sont peu informatifs (predits par les parents).\n# Les termes a fort IA sont tres specifiques et difficiles a predire.\n# Reference: Clark & Radivojac (2013) Bioinformatics 29(13):i250-i256\n# ============================================================================\n\nprint('\\n' + '=' * 70)\nprint('ANALYSE EXPLORATOIRE — INFORMATION ACCRETION')\nprint('=' * 70)\n\nia_values = np.array(list(ia_dict.values())) # Valeurs IA\nprint(f'\\n Termes avec IA: {len(ia_values):,}')\nprint(f' IA moyenne: {np.mean(ia_values):.4f}')\nprint(f' IA mediane: {np.median(ia_values):.4f}')\nprint(f' IA min: {np.min(ia_values):.4f}')\nprint(f' IA max: {np.max(ia_values):.4f}')\nprint(f' Ecart-type: {np.std(ia_values):.4f}')\n# Categories d'IA\nia_faible = (ia_values < 0.01).sum() # IA < 0.01 (peu informatif)\nia_moyenne = ((ia_values >= 0.01) & (ia_values < 0.1)).sum() # 0.01-0.1\nia_forte = (ia_values >= 0.1).sum() # IA >= 0.1 (tres specifique)\nprint(f'\\n Categories d\\'IA:')\nprint(f' Faible (<0.01): {ia_faible:,} ({100*ia_faible/len(ia_values):.1f}%)')\nprint(f' Moyenne (0.01-0.1): {ia_moyenne:,} ({100*ia_moyenne/len(ia_values):.1f}%)')\nprint(f' Forte (>=0.1): {ia_forte:,} ({100*ia_forte/len(ia_values):.1f}%)')\n# ============================================================================\n# 4b.5 — ANALYSE DE LA STRUCTURE DU DAG GO\n# ============================================================================\n# Profondeurs, facteur de branchement, feuilles vs internes.\n# Reference: Gene Ontology Consortium (2021) NAR 49(D1):D325-D334\n# ============================================================================\n\nprint('\\n' + '=' * 70)\nprint('ANALYSE EXPLORATOIRE — STRUCTURE DAG GO')\nprint('=' * 70)\n\n# Le DAG GO doit etre charge (Module 5 pas encore execute)\n# On charge une version minimale pour l'EDA\ntry: # Essayer d'utiliser le graphe deja charge\n if 'graphe_go' in dir() and graphe_go is not None: # Si le graphe existe\n G = graphe_go\n else: # Graphe pas encore charge\n raise NameError # Forcer le chargement\nexcept NameError: # Charger le graphe pour l'EDA\n print(' Chargement du DAG GO pour l\\'analyse...')\n G = obonet.read_obo(FICHIER_OBO) # Charger le fichier OBO\n print(f' DAG charge: {G.number_of_nodes():,} noeuds, {G.number_of_edges():,} aretes')\n\n# Profondeur des noeuds (distance depuis la racine)\n# On calcule la profondeur pour chaque terme dans chaque sous-ontologie\nprofondeurs = {} # Dictionnaire terme -> profondeur\nfor ont, racine in ONTOLOGIES.items(): # Pour chaque sous-ontologie\n try: # V17c: calcul correct du chemin le plus long dans le DAG\n # Un BFS standard ne calcule que la profondeur minimale (chemin le plus court).\n # Pour la profondeur maximale dans un DAG, on utilise un tri topologique\n # suivi d'une propagation des profondeurs maximales.\n from collections import deque\n # Phase 1: Calculer les degres entrants (nombre de parents, convention obonet)\n in_deg = {}\n for n_id in G.nodes():\n in_deg[n_id] = G.out_degree(n_id) # out_degree = nb de parents\n # Phase 2: Tri topologique (Kahn) depuis les racines\n queue_topo = deque([n for n in G.nodes() if in_deg[n] == 0])\n topo_order = []\n while queue_topo:\n n_id = queue_topo.popleft()\n topo_order.append(n_id)\n for enfant in G.predecessors(n_id): # enfants au sens obonet\n in_deg[enfant] -= 1\n if in_deg[enfant] == 0:\n queue_topo.append(enfant)\n # Phase 3: Propager les profondeurs maximales\n profondeurs[racine] = 0\n for n_id in topo_order:\n if n_id not in profondeurs:\n profondeurs[n_id] = 0\n prof_courante = profondeurs[n_id]\n for enfant in G.predecessors(n_id): # enfants au sens obonet\n profondeurs[enfant] = max(profondeurs.get(enfant, 0), prof_courante + 1)\n except Exception as e:\n print(f' [ATTENTION] Calcul profondeur pour {ont}: {e}')\n# Analyser les profondeurs\nif profondeurs: # Si on a des profondeurs\n prof_vals = np.array(list(profondeurs.values()))\n print(f'\\n Termes avec profondeur calculee: {len(prof_vals):,}')\n print(f' Profondeur moyenne: {np.mean(prof_vals):.1f}')\n print(f' Profondeur max: {np.max(prof_vals)}')\n print(f' Profondeur mediane: {np.median(prof_vals):.0f}')\n # Distribution par tranches de profondeur\n print('\\n Distribution des profondeurs:')\n for prof in range(0, int(np.max(prof_vals)) + 1, 2): # Par tranche de 2\n count = np.sum((prof_vals >= prof) & (prof_vals < prof + 2))\n pct = 100 * count / len(prof_vals)\n barre = '#' * int(pct) # Barre visuelle\n print(f' Prof {prof:2d}-{prof+1:2d}: {count:5,} ({pct:5.1f}%) {barre}')\n# Feuilles vs noeuds internes (V17c: correction critique)\n# CORRECTION: en convention obonet, les aretes is_a vont ENFANT -> PARENT.\n# Donc:\n# - out_degree(n) = nombre de PARENTS de n (0 pour une racine)\n# - in_degree(n) = nombre d'ENFANTS de n (0 pour une feuille)\n# L'ancien code utilisait out_degree == 0 pour detecter les feuilles,\n# ce qui selectionnait en realite les 3 racines (BPO/MFO/CCO root).\n# C'est la 3e occurrence de cette confusion enfant/parent dans le pipeline\n# (les 2 premieres etaient dans le BFS de profondeur et le Module 5, deja corrigees).\nfeuilles = [n for n in G.nodes() if G.in_degree(n) == 0] # Feuilles (pas d'enfants entrants)\ninternes = [n for n in G.nodes() if G.in_degree(n) > 0] # Internes (ont des enfants)\nracines = [n for n in G.nodes() if G.out_degree(n) == 0] # Racines (pas de parents sortants)\nprint(f'\\n Noeuds feuilles (pas d\\'enfants, in_degree=0): {len(feuilles):,} ({100*len(feuilles)/G.number_of_nodes():.1f}%)')\nprint(f' Noeuds internes (ont des enfants): {len(internes):,} ({100*len(internes)/G.number_of_nodes():.1f}%)')\nprint(f' Racines (pas de parents, out_degree=0): {len(racines):,}')\n# Facteur de branchement (V17c: utilise in_degree = nombre d'enfants)\ndegres_branchement = [G.in_degree(n) for n in G.nodes() if G.in_degree(n) > 0] # Vrai nb d'enfants\nif degres_branchement: # Si on a des degres\n degres_arr = np.array(degres_branchement)\n print(f'\\n Facteur de branchement (noeuds internes, nombre d\\'enfants directs):')\n print(f' Moyenne: {np.mean(degres_arr):.2f} enfants')\n print(f' Max: {np.max(degres_arr)} enfants (terme le plus large)')\n print(f' Mediane: {np.median(degres_arr):.0f}')\n # Distribution du facteur de branchement (structure interessante du DAG)\n print(f'\\n Distribution du facteur de branchement:')\n for seuil in [1, 5, 10, 50, 100, 500]:\n count = (degres_arr >= seuil).sum()\n if count > 0:\n print(f' >= {seuil} enfants: {count:,} termes')\n # Top 10 termes avec le plus d'enfants directs\n top_branches = sorted(G.nodes(), key=lambda n: G.in_degree(n), reverse=True)[:10]\n print(f'\\n Top 10 termes les plus larges (nb d\\'enfants directs):')\n for rank, terme in enumerate(top_branches):\n n_enfants = G.in_degree(terme)\n # Obtenir le nom si disponible\n nom = G.nodes[terme].get('name', terme) if terme in G.nodes else terme\n print(f' {rank+1}. {terme} ({nom}): {n_enfants:,} enfants')\n\n# ============================================================================\n# ============================================================================\n# 4b.5 — ANALYSE DE REDONDANCE DES SEQUENCES (CD-HIT, CORRIGEE V31)\n# ============================================================================\n# Objectif: quantifier les clusters >=80% identité et les clusters multi-taxons.\n# Cette mesure évalue le risque de fuite entre groupes taxonomiques; elle n'est\n# PAS une mesure de performance et ne modifie ni les labels ni les splits.\n# ============================================================================\nimport re\nimport shutil\nimport tempfile\n\nprint('\\n' + '=' * 70)\nprint('ANALYSE EXPLORATOIRE — REDONDANCE DES SEQUENCES (CD-HIT 80%)')\nprint('=' * 70)\n\ndef _parser_clusters_cdhit(cluster_path, taxonomie_par_proteine):\n \"\"\"Parse `.clstr` sans conserver les séquences en RAM.\n\n CD-HIT écrit un cluster par bloc. Les IDs sont repris depuis le FASTA; les\n clusters multi-taxons sont le signal de fuite potentielle pour GroupKFold.\n \"\"\"\n clusters, members = [], []\n with open(cluster_path, encoding='utf-8') as handle:\n for line in handle:\n if line.startswith('>Cluster'):\n if members:\n clusters.append(members)\n members = []\n else:\n match = re.search(r'>([^.\\s]+)', line)\n if match:\n members.append(match.group(1))\n if members:\n clusters.append(members)\n sizes = np.asarray([len(cluster) for cluster in clusters], dtype=np.int32)\n cross_taxon = sum(len({taxonomie_par_proteine.get(acc, 'UNKNOWN') for acc in cluster}) > 1\n for cluster in clusters if len(cluster) > 1)\n return {\"n_clusters\": int(len(clusters)), \"n_singletons\": int((sizes == 1).sum()),\n \"n_clusters_multi\": int((sizes > 1).sum()), \"max_cluster\": int(sizes.max(initial=0)),\n \"n_clusters_cross_taxon\": int(cross_taxon)}\n\n\ndef analyser_redondance_cdhit(sequences, taxonomie_par_proteine, identity=0.80,\n timeout_seconds=3600, threads=None):\n \"\"\"Exécute CD-HIT à 80% identité, ou retourne un statut explicite non bloquant.\n\n Aucun proxy Jaccard n'est présenté comme une identité de séquence : en\n l'absence de CD-HIT/MMseqs2, le rapport indique précisément que l'analyse\n exacte n'a pas été exécutée. Cela évite le coût O(N²) du fallback historique.\n \"\"\"\n assert 0.4 <= identity <= 1.0 and sequences\n executable = shutil.which('cd-hit')\n if executable is None:\n return {\"backend\": \"indisponible\", \"statut\": \"CD-HIT absent\", \"n_sequences\": len(sequences),\n \"instruction\": \"Ajouter un binaire CD-HIT ou un dataset Kaggle contenant cd-hit; ne pas interpréter un proxy k-mer comme 80% identité.\"}\n output_root = Path(globals().get('CHEMIN_CHECKPOINTS', './checkpoints'))\n output_root.mkdir(parents=True, exist_ok=True)\n workers = threads or max(1, min(4, os.cpu_count() or 1))\n try:\n with tempfile.TemporaryDirectory(prefix='cdhit_80_', dir=output_root) as tmp:\n tmp = Path(tmp)\n fasta, output = tmp / 'train.fasta', tmp / 'clusters'\n with fasta.open('w', encoding='ascii') as handle:\n for accession, sequence in sequences.items():\n if sequence: # une séquence vide ne peut pas être clusterisée.\n handle.write(f'>{accession}\\n{sequence}\\n')\n command = [executable, '-i', str(fasta), '-o', str(output), '-c', str(identity), '-n', '5',\n '-M', '0', '-T', str(workers), '-d', '0']\n print('[REDONDANCE] Exécution:', ' '.join(command))\n run = subprocess.run(command, capture_output=True, text=True, timeout=timeout_seconds, check=False)\n cluster_file = Path(str(output) + '.clstr')\n if run.returncode != 0 or not cluster_file.is_file():\n return {\"backend\": \"cd-hit\", \"statut\": \"échec\", \"n_sequences\": len(sequences),\n \"returncode\": run.returncode, \"erreur\": run.stderr[-500:]}\n report = _parser_clusters_cdhit(cluster_file, taxonomie_par_proteine)\n report.update({\"backend\": \"cd-hit\", \"statut\": \"ok\", \"n_sequences\": len(sequences), \"identity\": identity})\n return report\n except subprocess.TimeoutExpired:\n return {\"backend\": \"cd-hit\", \"statut\": \"timeout\", \"n_sequences\": len(sequences),\n \"instruction\": \"Relancer hors notebook ou augmenter CDHIT_TIMEOUT_SECONDS.\"}\n except OSError as exc:\n return {\"backend\": \"cd-hit\", \"statut\": \"erreur système\", \"n_sequences\": len(sequences), \"erreur\": str(exc)}\n\n\ndf_taxo_dict = dict(zip(df_taxo['proteine'].astype(str), df_taxo['taxonomie'].astype(str)))\nCDHIT_TIMEOUT_SECONDS = 3600\nresultats_redondance_sequences = analyser_redondance_cdhit(seq_train, df_taxo_dict, timeout_seconds=CDHIT_TIMEOUT_SECONDS)\nprint('[REDONDANCE]', resultats_redondance_sequences)\nif resultats_redondance_sequences['statut'] == 'ok':\n n = resultats_redondance_sequences['n_sequences']\n redondance = 1 - resultats_redondance_sequences['n_clusters'] / max(n, 1)\n print(f\" Clusters: {resultats_redondance_sequences['n_clusters']:,}; redondance: {redondance:.2%}\")\n print(f\" Clusters multi-membres: {resultats_redondance_sequences['n_clusters_multi']:,}; \"\n f\"multi-taxons: {resultats_redondance_sequences['n_clusters_cross_taxon']:,}\")\n if resultats_redondance_sequences['n_clusters_cross_taxon']:\n print(' [ATTENTION] Des clusters traversent les taxons: GroupKFold seul peut laisser une fuite homologique.')\nelse:\n print(' [INFO] Analyse exacte non exécutée:', resultats_redondance_sequences.get('instruction', resultats_redondance_sequences.get('erreur', 'raison inconnue')))\n\n\n# 4b.5b — ANALYSE DU RESEAU DE CO-OCCURRENCE DES TERMES GO\n# ============================================================================\n# La Contrastive Loss (Module 14 V18) depend entierement de l'hypothese\n# que les termes GO co-annotes ont des representations similaires.\n# Il est essentiel de quantifier cette co-occurrence AVANT de l'exploiter.\n# Reference: Zhou et al. (2019) CAFA3, Genome Biology\n# ============================================================================\n\nprint('\\n' + '=' * 70)\nprint('ANALYSE EXPLORATOIRE — RESEAU DE CO-OCCURRENCE GO')\nprint('=' * 70)\n\n# Construire la matrice de co-occurrence (sparse)\ntry:\n import scipy.sparse as sp\n \n # Matrice binaire d'annotations (proteines x termes)\n _Y_sparse_eda = sp.csr_matrix(Y_train if 'Y_train' in dir() else \n np.zeros((len(annot_prop), len(liste_termes)), dtype=np.float32))\n \n # Co-occurrence: Y_sparse.T @ Y_sparse = (C, C) sparse\n _coocc_eda = (_Y_sparse_eda.T @ _Y_sparse_eda).tocoo()\n \n # Filtrer la diagonale\n _off_diag = _coocc_eda.row != _coocc_eda.col\n _coocc_vals = _coocc_eda.data[_off_diag]\n \n if len(_coocc_vals) > 0:\n print(f' Paires co-annotees (total): {len(_coocc_vals):,}')\n print(f' Co-occurrence moyenne: {_coocc_vals.mean():.1f}')\n print(f' Co-occurrence mediane: {np.median(_coocc_vals):.0f}')\n print(f' Co-occurrence max: {_coocc_vals.max():,}')\n \n # Distribution par seuil\n for seuil in [1, 5, 10, 50, 100]:\n n_paires = (_coocc_vals >= seuil).sum()\n print(f' Co-occurrence >= {seuil}: {n_paires:,} paires')\n \n # Densite du reseau\n n_termes = len(liste_termes)\n max_paires = n_termes * (n_termes - 1)\n densite = len(_coocc_vals) / max(1, max_paires) * 100\n print(f' Densite du reseau: {densite:.4f}%')\n \n # Top 10 termes les plus connectes\n _degre = np.array(_coocc_eda.sum(axis=1)).flatten()\n _top_connectes = np.argsort(_degre)[::-1][:10]\n print(f'\\n Top 10 termes les plus connectes:')\n for rank, idx in enumerate(_top_connectes):\n terme = liste_termes[idx] if idx < len(liste_termes) else f'idx={idx}'\n deg = int(_degre[idx])\n print(f' {rank+1}. {terme}: {deg:,} co-occurrences')\n \n # Coefficient de clustering moyen (approximation sur un echantillon)\n # Mesure la transitivite: si A co-annote avec B et C, B et C co-annotent-ils?\n print(f'\\n [CONTRASTIVE LOSS] Implications:')\n print(f' Seuil co-occ >= 5: {(_coocc_vals >= 5).sum():,} paires utilisables')\n print(f' Seuil co-occ >= 10: {(_coocc_vals >= 10).sum():,} paires fiables')\n if (_coocc_vals >= 5).sum() < 100:\n print(f' [ATTENTION] Tres peu de paires co-annotees fiables!')\n print(f' La Contrastive Loss pourrait ne pas etre efficace.')\n else:\n print(' [ATTENTION] Aucune paire co-annotee detectee!')\n print(' La Contrastive Loss ne pourra pas fonctionner.')\n \n del _Y_sparse_eda, _coocc_eda, _off_diag, _coocc_vals\n \nexcept ImportError:\n print(' [ATTENTION] scipy.sparse non disponible — analyse co-occurrence sautee')\nexcept Exception as e:\n print(f' [ATTENTION] Erreur analyse co-occurrence: {e}')\n print(\" (Y_train pas encore construit — executer le Module 8 d'abord)\")\n","metadata":{"id":"KjmBR5I5bS6M","outputId":"7981f077-d73b-4a27-a66e-73de901986da","trusted":true,"execution":{"iopub.status.busy":"2026-07-31T17:50:08.468712Z","iopub.execute_input":"2026-07-31T17:50:08.469096Z","iopub.status.idle":"2026-07-31T17:50:15.374914Z","shell.execute_reply.started":"2026-07-31T17:50:08.469063Z","shell.execute_reply":"2026-07-31T17:50:15.373889Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# ============================================================================\n# 4b.6 — ANALYSES CROISEES ET FIGURE DE SYNTHESE\n# ============================================================================\n# Croisements entre variables pour decouvrir des correlations.\n# Reference: Wickham & Grolemund (2017) R for Data Science, O'Reilly\n# ============================================================================\n\nprint('=' * 70)\nprint('ANALYSE EXPLORATOIRE — ANALYSES CROISEES')\nprint('=' * 70)\n\n# --- Longueur vs nombre d'annotations ---\n# Hypothese: les proteines plus longues ont-elles plus d'annotations?\nlongueurs_par_prot = {acc: len(seq) for acc, seq in seq_train.items()}\nannot_par_prot_dict = df_termes.groupby('proteine').size().to_dict()\n# Fusionner\nprot_communes = set(longueurs_par_prot.keys()) & set(annot_par_prot_dict.keys())\nlongs = np.array([longueurs_par_prot[p] for p in prot_communes])\nannots = np.array([annot_par_prot_dict[p] for p in prot_communes])\n# Correlation de Spearman (non parametrique, robuste aux outliers)\nfrom scipy.stats import spearmanr # Correlation de Spearman\ncorr_spearman, p_value = spearmanr(longs, annots)\nprint(f'\\n Correlation longueur vs annotations:')\nprint(f' Spearman rho: {corr_spearman:.3f} (p={p_value:.2e})')\n# V17c: Avertissement sur le confondant\nif corr_spearman > 0.3:\n print(\" [CONFOUNDANT] Cette correlation peut etre partiellement confondue par\")\n print(\" le biais d'annotation: les organismes modeles ont a la fois des genes\")\n print(\" plus longs ET plus d'annotations (car plus etudies).\")\n# --- Especes vs annotations ---\n# Certaines especes sont-elles plus ou moins annotees?\n# V17c: ATTENTION au biais d'annotation (research attention bias).\n# Les organismes modeles (H. sapiens, M. musculus, S. cerevisiae, A. thaliana)\n# ont plus d'annotations parce qu\\'ils sont plus etudies, pas necessairement\n# parce que leurs proteines ont objectivement plus de fonctions. Ce biais\n# confond la correlation \"longueur vs annotations\" car les genes de ces\n# organismes sont aussi souvent plus longs/multi-domaines.\n# Reference: Lane et al. (2019) Next-generation databases for GO, NAR\n# Reference: Huntley et al. (2015) The GOA database, NAR\nespece_par_prot = dict(zip(df_taxo['proteine'], df_taxo['taxonomie']))\nannot_moyenne_par_espece = {} # Annotations moyennes par espece\nfor espece, groupe in df_taxo.groupby('taxonomie'): # Par espece\n prots = groupe['proteine'].values # Proteines de l'espece\n annots_espece = [annot_par_prot_dict.get(p, 0) for p in prots if p in annot_par_prot_dict]\n if annots_espece: # Si on a des annotations\n annot_moyenne_par_espece[espece] = np.mean(annots_espece)\nif annot_moyenne_par_espece: # Si on a des resultats\n vals = np.array(list(annot_moyenne_par_espece.values()))\n print(f'\\n Annotations moyennes par espece:')\n print(f' Moyenne: {np.mean(vals):.1f}')\n print(f' Min: {np.min(vals):.1f}')\n print(f' Max: {np.max(vals):.1f}')\n print(f' Ecart-type: {np.std(vals):.1f}')\n # V17c: Quantifier le biais d'annotation\n # Les especes les plus annotees sont-elles des organismes modeles?\n _especes_triees = sorted(annot_moyenne_par_espece.items(), key=lambda x: x[1], reverse=True)\n print(f'\\n [BIAS CHECK] Top 5 especes les plus annotees (biais de recherche possible):')\n for i, (esp, moy) in enumerate(_especes_triees[:5]):\n _n_prots = len([p for p in df_taxo[df_taxo['taxonomie'] == esp]['proteine'] if p in annot_par_prot_dict])\n print(f' {i+1}. TaxID {esp}: {moy:.1f} annot/prot ({_n_prots} proteines)')\n print(f' [ATTENTION] Le biais d\\'annotation (research attention bias) signifie que')\n print(f' la correlation longueur vs annotations (ci-dessous) peut etre confondue')\n print(f' par le biais d\\'etude: les organismes modeles ont a la fois plus')\n print(f' d\\'annotations ET des genes souvent plus longs/multi-domaines.')\n# --- IA vs frequence du terme ---\n# Les termes frequents ont-ils une IA plus faible?\nia_par_terme = {} # IA par terme\nfreq_par_terme = prot_par_terme.to_dict() # Frequence par terme\nfor terme, ia_val in ia_dict.items(): # Pour chaque terme avec IA\n if terme in freq_par_terme: # Si le terme est dans les annotations\n ia_par_terme[terme] = (ia_val, freq_par_terme[terme]) # (IA, frequence)\n\nif ia_par_terme: # Si on a des resultats\n ia_vals = np.array([v[0] for v in ia_par_terme.values()]) # Valeurs IA\n freq_vals = np.array([v[1] for v in ia_par_terme.values()])\n corr_ia_freq, p_ia_freq = spearmanr(ia_vals, freq_vals)\n print(f'\\n Correlation IA vs frequence du terme:')\n print(f' Spearman rho: {corr_ia_freq:.3f} (p={p_ia_freq:.2e})')\n interpretation = 'negative' if corr_ia_freq < -0.3 else 'positive' if corr_ia_freq > 0.3 else 'faible'\n print(f' Interpretation: correlation {interpretation}')\n# --- Test set analysis (V17c: elargi au-dela des accessions) ---\nprint('\\n--- Analyse du jeu de test ---')\nacc_train = set(seq_train.keys()) # Accessions train\nacc_test = set(seq_test.keys()) # Accessions test\noverlap = acc_train & acc_test\nnovel = acc_test - acc_train # Nouvelles sequences (accessions differents)\nprint(f' Proteines test: {len(acc_test):,}') # Total test\nprint(f' Also in train (meme accession): {len(overlap):,} ({100*len(overlap)/len(acc_test):.1f}%)')\nprint(f' Novel accessions: {len(novel):,} ({100*len(novel)/len(acc_test):.1f}%)')\n\n# V17c: Verifier la similarite SEQUENCE entre train et test\n# Le test par accession ne detecte PAS les sequences quasi-identiques\n# (orthologues proches, isoformes, paralogues recents) qui posent le meme\n# risque de fuite d'information. Ce trou est documente dans la litterature CAFA.\n# Reference: Zhou et al. (2019) CAFA3, Genome Biology\nprint(f'\\n --- Similarite sequence train/test (V17c) ---')\ntry:\n # Methode rapide: comparer les k-mers (5-mers) entre train et test\n # Echantillonner pour la rapidite (max 1000 sequences par cote)\n import random as _rnd\n _K = 5 # V17c: k=5 plus discriminant\n _MAX_SEQ = 1000 # Limiter pour la rapidite\n \n _train_accs = list(seq_train.keys())\n _test_accs = list(seq_test.keys())\n _rnd.seed(42)\n _train_sample = _rnd.sample(_train_accs, min(_MAX_SEQ, len(_train_accs)))\n _test_sample = _rnd.sample(_test_accs, min(_MAX_SEQ, len(_test_accs)))\n \n # Extraire les k-mers\n def _extraire_kmers(seq, k=5): # V21 FIX #26: default k=5 (was 3)\n return set(seq[i:i+k] for i in range(len(seq) - k + 1))\n \n _train_kmers = {acc: _extraire_kmers(seq_train[acc]) for acc in _train_sample}\n _test_kmers = {acc: _extraire_kmers(seq_test[acc]) for acc in _test_sample}\n \n # Compter les paires train/test avec Jaccard >= seuil\n _seuil_jaccard = 0.8 # 80% de similarite k-mer\n _paires_similaires = 0\n _paires_tres_similaires = 0 # >= 95%\n _n_comparaisons = 0\n \n for acc_t, kmers_t in _test_kmers.items():\n for acc_tr, kmers_tr in _train_kmers.items():\n if len(kmers_t) == 0 or len(kmers_tr) == 0:\n continue\n _n_comparaisons += 1\n _inter = len(kmers_t & kmers_tr)\n _union = len(kmers_t | kmers_tr)\n _jacc = _inter / max(_union, 1)\n if _jacc >= _seuil_jaccard:\n _paires_similaires += 1\n if _jacc >= 0.95:\n _paires_tres_similaires += 1\n \n if _n_comparaisons > 0:\n _taux_similaire = _paires_similaires / _n_comparaisons\n _taux_tres_similaire = _paires_tres_similaires / _n_comparaisons\n print(f' Comparaisons (echantillon): {_n_comparaisons:,}')\n print(f' Paires >= 80% Jaccard: {_paires_similaires:,} ({100*_taux_similaire:.2f}%)')\n print(f' Paires >= 95% Jaccard: {_paires_tres_similaires:,} ({100*_taux_tres_similaire:.2f}%)')\n if _paires_similaires > 0:\n print(f' [ATTENTION] Des sequences test sont tres similaires a des sequences train!')\n print(f' Le split par accession ne garantit PAS l\\'independance.')\n print(f' Un clustering CD-HIT a 30-40% identite serait necessaire pour')\n print(f' quantifier la redondance train/train et train/test (cf. section 4b.5).')\n del _train_kmers, _test_kmers, _train_sample, _test_sample\nexcept Exception as e:\n print(f' [ATTENTION] Analyse similarite train/test echouee: {e}')\n# ============================================================================\n# FIGURE DE SYNTHESE EDA\n# ============================================================================\nfig, axes = plt.subplots(2, 3, figsize=(18, 12)) # 6 sous-graphiques\n\n# F1: Longueur vs annotations (scatter)\naxes[0, 0].scatter(longs, annots, alpha=0.1, s=3, color='steelblue')\naxes[0, 0].set_xlabel('Longueur sequence (AA)') # Axe X\naxes[0, 0].set_ylabel('Nombre annotations GO') # Axe Y\naxes[0, 0].set_title(f'Longueur vs Annotations (rho={corr_spearman:.3f})')\naxes[0, 0].set_xscale('log') # Log scale X pour meilleure visibilite\n\n# F2: Top especes (bar chart horizontal)\nif len(prot_par_espece) >= 15: # Si assez d'especes\n top15 = prot_par_espece.head(15) # Top 15\n # Tronquer les noms d'especes trop longs\n noms_courts = [n[:30] + '...' if len(str(n)) > 30 else str(n) for n in top15.index]\n axes[0, 1].barh(range(len(top15)), top15.values, color='coral') # Barres horizontales\n axes[0, 1].set_yticks(range(len(top15)))\n axes[0, 1].set_yticklabels(noms_courts, fontsize=7)\n axes[0, 1].set_xlabel('Nombre de proteines') # Axe X\n axes[0, 1].set_title('Top 15 especes')\n axes[0, 1].invert_yaxis()\n# F3: Distribution IA\naxes[0, 2].hist(ia_values, bins=80, color='green', alpha=0.7)\naxes[0, 2].axvline(x=np.median(ia_values), color='red', linestyle='--', label=f'Mediane={np.median(ia_values):.4f}')\naxes[0, 2].set_xlabel('Information Accretion') # Axe X\naxes[0, 2].set_ylabel('Nombre de termes') # Axe Y\naxes[0, 2].set_title('Distribution de l\\'IA')\naxes[0, 2].legend(loc='best')\n# F4: IA vs frequence du terme\nif ia_par_terme: # Si on a les donnees\n axes[1, 0].scatter(np.log10(freq_vals + 1), ia_vals, alpha=0.2, s=5, color='purple')\n axes[1, 0].set_xlabel('log10(Frequence du terme)') # Axe X\n axes[1, 0].set_ylabel('Information Accretion') # Axe Y\n axes[1, 0].set_title(f'IA vs Frequence (rho={corr_ia_freq:.3f})')\n# F5: Profondeurs du DAG\nif profondeurs: # Si on a les profondeurs\n prof_vals = np.array(list(profondeurs.values()))\n axes[1, 1].hist(prof_vals, bins=range(0, int(np.max(prof_vals)) + 2), color='teal', alpha=0.8)\n axes[1, 1].set_xlabel('Profondeur dans le DAG') # Axe X\n axes[1, 1].set_ylabel('Nombre de termes') # Axe Y\n axes[1, 1].set_title('Distribution des profondeurs DAG')\n axes[1, 1].axvline(x=np.mean(prof_vals), color='red', linestyle='--', label=f'Moyenne={np.mean(prof_vals):.1f}')\n axes[1, 1].legend(loc='best')\n# F6: Resume statistique (texte)\naxes[1, 2].axis('off') # Pas d'axes\nresume_texte = (\n f\"RESUME EDA — CAFA-6\\n\"\n f\"{'='*40}\\n\\n\"\n f\"Sequences train: {len(seq_train):,}\\n\"\n f\"Sequences test: {len(seq_test):,}\\n\"\n f\"Longueur moy: {np.mean(longueurs_train):.0f} AA\\n\"\n f\"Seq > 1022 AA: {np.sum(longueurs_train > 1022):,}\\n\\n\"\n f\"Annotations totales: {len(df_termes):,}\\n\"\n f\"Termes GO uniques: {len(prot_par_terme):,}\\n\"\n f\"Annot/prot moy: {annot_par_prot.mean():.1f}\\n\"\n f\"Termes rares (<20): {terme_rare:,}\\n\\n\"\n f\"Especes: {len(prot_par_espece):,}\\n\"\n f\"Top espece: {top1_pct:.1f}%\\n\"\n f\"Top 5 especes: {top5_pct:.1f}%\\n\\n\"\n f\"IA moyenne: {np.mean(ia_values):.4f}\\n\"\n f\"IA vs freq (rho): {corr_ia_freq:.3f}\\n\\n\"\n f\"Long vs annot (rho): {corr_spearman:.3f}\\n\"\n f\"Test novel: {100*len(novel)/len(acc_test):.1f}%\"\n) # Texte resume\naxes[1, 2].text(0.05, 0.95, resume_texte, transform=axes[1, 2].transAxes,\n fontsize=10, verticalalignment='top', fontfamily='monospace',\n bbox=dict(boxstyle='round', facecolor='lightyellow', alpha=0.8))\nplt.tight_layout()\nplt.savefig(CHEMIN_IMAGES + 'eda_04_synthese.png', dpi=150, bbox_inches='tight')\nplt.show()\nprint('[FIGURE] eda_04_synthese.png sauvegardee')\n\n# --- Resume final EDA ---\nprint('\\n' + '=' * 70)\nprint('RESUME EDA — IMPLICATIONS POUR LA MODELISATION')\nprint('=' * 70)\nprint('''\n 1. DESEQUILIBRE DES CLASSES: La plupart des termes GO ont peu d'exemples\n -> Justifie Focal Loss + Asymmetric Loss + MAML \n\n 2. SEQUENCES LONGUES: {:.1f}% des sequences depassent 1022 AA\n -> Justifie le sliding window ESM-2 dans Module 6\n\n 3. CONCENTRATION TAXONOMIQUE: Top 5 especes = {:.1f}% des proteines\n -> Justifie GroupKFold par taxonomie (Module 9)\n\n 4. IA CORRELEE NEGATIVEMENT AVEC FREQUENCE: rho = {:.3f}\n -> Les termes frequents sont peu informatifs (IA faible)\n -> Justifie la ponderation IA dans la perte (Module 14)\n\n 5. TERMES RARES (<20 prot): {:.0f}% des termes\n -> Justifie Meta-Learning MAML pour les termes rares\n\n 6. PROFONDEUR DAG VARIABLE: 0 a {} niveaux\n -> Justifie Curriculum Learning par profondeur\n\n 7. LONGUEUR CORRELEE AVEC ANNOTATIONS: rho = {:.3f}\n -> Les proteines longues ont plus de fonctions connues\n -> Les features de longueur sont informatives (Module 7)\n'''.format(\n 100 * np.mean(longueurs_train > 1022), # % sequences longues\n top5_pct, # Concentration top 5\n corr_ia_freq, # Correlation IA-frequence\n 100 * terme_rare / len(prot_par_terme), # % termes rares\n int(np.max(prof_vals)) if len(profondeurs) > 0 else '?', # Profondeur max\n corr_spearman, # Correlation longueur-annotations\n))\n\nprint('[OK] Module 4b: Analyse exploratoire terminee')\n","metadata":{"id":"GNjgk4knbS6Q","outputId":"c9f644bc-479a-461a-fe55-2c6d204d64d5","trusted":true,"execution":{"iopub.status.busy":"2026-07-31T17:50:15.376278Z","iopub.execute_input":"2026-07-31T17:50:15.376915Z","iopub.status.idle":"2026-07-31T17:51:03.06774Z","shell.execute_reply.started":"2026-07-31T17:50:15.376891Z","shell.execute_reply":"2026-07-31T17:51:03.06675Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"","metadata":{"id":"YVQmAdycbS6S"}},{"cell_type":"code","source":"# ============================================================================\n# MODULE 5 — DAG GENE ONTOLOGY\n# ============================================================================\n# Le DAG GO est la fondation de DAGNet , du Curriculum Learning ,\n# et de la coherence DAG (Module 20).\n# Reference: Ashburner et al. (2000) Nature Genetics\n# ============================================================================\nfrom tqdm import tqdm\n# --- 5.1 Charger le DAG ---\nprint('[DAG] Chargement OBO...')\ngo_dag = obonet.read_obo(FICHIER_OBO)\n# [FIX V24 #5] Vérifier que le DAG est acyclique\nif not nx.is_directed_acyclic_graph(go_dag):\n cycles = list(nx.simple_cycles(go_dag))[:5]\n raise RuntimeError(f'[DAG] CYCLES détectés dans go-basic.obo: {cycles}')\nprint(' [OK] DAG acyclique vérifié') # Graphe NetworkX oriente\nprint(f' Noeuds: {go_dag.number_of_nodes():,}')\nprint(f' Aretes: {go_dag.number_of_edges():,}')\n\n# --- 5.2 Termes communs (train ∩ DAG) ---\ntermes_train = set(df_termes['terme_go'].unique()) # Termes dans train\ntermes_dag = set(go_dag.nodes()) # Termes dans le DAG\ntermes_valides = termes_train.intersection(termes_dag)\nprint(f' Termes valides: {len(termes_valides):,}')\n\n# --- 5.3 Calculer la profondeur de chaque terme ---\n# BFS depuis chaque racine de sous-ontologie\n# La profondeur est utilisee par le Curriculum Learning \nprint('[DAG] Calcul profondeurs...')\nprofondeur_go = {} # terme -> profondeur\n\nfor nom_ont, racine in ONTOLOGIES.items(): # Pour BPO, MFO, CCO\n if racine not in go_dag: # Racine absente du DAG\n continue\n file_bfs = [(racine, 0)] # (terme, profondeur) — racine=0\n visites = set() # Termes deja visites\n while file_bfs: # Tant que la file n'est pas vide\n terme, prof = file_bfs.pop(0)\n if terme in visites: # Deja visite\n continue\n visites.add(terme) # Marquer visite\n profondeur_go[terme] = prof # Stocker profondeur\n for enfant in go_dag.predecessors(terme): # Enfants (obonet: predecesseurs)\n if enfant not in visites: # Pas encore visite\n file_bfs.append((enfant, prof + 1)) # Profondeur +1\n\nprint(f' Termes avec profondeur: {len(profondeur_go):,}')\n\n# --- 5.4 Mapping parent-enfant (pour DAGNet) ---\n# DAGNet propage les predictions des parents vers les enfants\nprint('[DAG] Mapping parent-enfant...')\nparents_go = defaultdict(list) # terme -> liste parents\nenfants_go = defaultdict(list) # terme -> liste enfants\n\nfor terme in termes_valides: # Pour chaque terme valide\n if terme in go_dag: # Si dans le DAG\n for parent in go_dag.successors(terme): # Parents = successeurs obonet\n if parent in termes_valides: # Parent aussi valide\n parents_go[terme].append(parent) # Ajouter parent\n enfants_go[parent].append(terme) # Ajouter enfant\n\nprint(f' Termes avec parents: {len(parents_go):,}')\n\n# --- 5.5 Propagation True Path Rule ---\n# Si proteine annotee GO:XXXXXXX, elle herite de tous les ancetres\n# Reference: Ashburner et al. (2000) Nature Genetics\nprint('[DAG] True Path Rule...')\n\n# [FIX V24 #5.1] Pré-calcul des ancêtres (mémoïsation) — évite O(N²) appels nx.descendants\nprint('[DAG] Pré-calcul des ancêtres (mémoïsation)...')\nfrom tqdm.auto import tqdm as _tqdm_anc\nancetres_cache = {}\nfor _t_anc in _tqdm_anc(termes_valides, desc='Ancêtres'):\n if _t_anc in go_dag:\n try:\n ancetres_cache[_t_anc] = nx.descendants(go_dag, _t_anc) & termes_valides\n except nx.NetworkXError:\n ancetres_cache[_t_anc] = set()\n else:\n ancetres_cache[_t_anc] = set()\nprint(f' Ancêtres moyen: {np.mean([len(s) for s in ancetres_cache.values()]):.1f}')\n\ndef propager_true_path(annotations, cache_ancetres):\n '''Propage annotations selon le True Path Rule du GO.\n\n Correctif (bug identifie le 24/06/2026):\n obonet construit les aretes \"is_a\" dans le sens ENFANT -> PARENT\n (verifie empiriquement: cf. Module 5.0 - Tests de validation).\n Consequence pour NetworkX:\n - nx.ancestors(G, t) renvoie les noeuds AYANT UN CHEMIN VERS t,\n donc ici les termes plus SPECIFIQUES que t (= descendants ontologiques).\n - nx.descendants(G, t) renvoie les noeuds ATTEIGNABLES DEPUIS t,\n donc ici les termes plus GENERAUX que t (= ancetres ontologiques).\n Le True Path Rule (Ashburner et al., 2000) exige l\\'inverse de ce qui\n etait fait: si une proteine est annotee avec un terme specifique,\n elle DOIT aussi etre annotee avec tous ses ANCETRES (termes plus\n generaux), jamais avec ses descendants.\n L\\'ancienne version (nx.ancestors) ajoutait donc les DESCENDANTS de\n chaque terme annote -> explosion incorrecte du nombre d\\'etiquettes\n (+10199.8% observe en V8, alors qu\\'une propagation True Path Rule\n correcte sur CAFA-6 donne typiquement +200% a +600%).\n '''\n # [FIX V24 #5.1] Utilise le cache pre-calcule au lieu de nx.descendants par terme\n resultats = {}\n for prot, termes in tqdm(annotations.items(), desc='TPR', total=len(annotations)):\n propages = set(termes)\n for t in termes:\n propages |= cache_ancetres.get(t, set())\n resultats[prot] = propages\n return resultats\n# [FIX V24 #5.4] Vectorisé via groupby (10x plus rapide que iterrows)\nannot_orig = df_termes.groupby('proteine')['terme_go'].apply(set).to_dict()\n# Propager\nannot_prop = propager_true_path(annot_orig, ancetres_cache) # [FIX V24] utilise cache\n# [FIX V24 #5.8] Libérer ancetres_cache (gros, peut être recalculé si besoin)\ndel ancetres_cache\nimport gc as _gc_mod5\n_gc_mod5.collect()\nn_avant = sum(len(v) for v in annot_orig.values())\nn_apres = sum(len(v) for v in annot_prop.values())\nprint(f' Avant: {n_avant:,} | Apres: {n_apres:,} (+{100*(n_apres-n_avant)/n_avant:.1f}%)')\n\n# --- 5.6 Mapping terme <-> index ---\nprint('[DAG] Mapping terme-index...')\nliste_termes = sorted(list(termes_valides)) # Liste triee\nterme2idx = {t: i for i, t in enumerate(liste_termes)} # Terme -> index\nidx2terme = {i: t for i, t in enumerate(liste_termes)} # Index -> terme\n\n# Vecteur IA (aligne avec les indices)\n# [FIX V24 #5.14] Initialiser avec np.nan (pas 0.0)\nvec_ia = np.full(len(liste_termes), np.nan, dtype=np.float32) # Vecteur IA\nfor i, t in enumerate(liste_termes): # Pour chaque terme\n # [FIX V24 #5.14] IA manquante → np.nan (pas 0.0, qui signifie 'non informatif')\n vec_ia[i] = ia_dict.get(t, np.nan) # [FIX V24] np.nan si manquante\n\n# Vecteur profondeur (pour Curriculum Learning)\n# [FIX V24 #5.16] Initialiser avec -1 (orphelins)\nvec_prof = np.full(len(liste_termes), -1, dtype=np.int32) # Vecteur profondeur\nfor i, t in enumerate(liste_termes): # Pour chaque terme\n # [FIX V24 #5.16] orphelins → -1 (pas 0 qui est réservé aux racines)\n vec_prof[i] = profondeur_go.get(t, -1)\n# Indices par sous-ontologie (pour ablation Module 24)\nidx_bpo, idx_mfo, idx_cco = [], [], [] # Listes d'indices\nfor idx, t in enumerate(liste_termes): # Pour chaque terme\n if t in profondeur_go: # Si profondeur connue\n for nom, racine in ONTOLOGIES.items(): # Pour chaque ontologie\n try: # Verifier chemin vers racine\n if nx.has_path(go_dag, t, racine): # Chemin existe\n if nom == 'BPO': idx_bpo.append(idx)\n elif nom == 'MFO': idx_mfo.append(idx)\n else: idx_cco.append(idx)\n break # Un terme = une ontologie seulement\n except nx.NetworkXError: # Erreur DAG\n continue\n\nprint(f' BPO: {len(idx_bpo):,} | MFO: {len(idx_mfo):,} | CCO: {len(idx_cco):,}')\nprint(f' Total: {len(liste_termes):,} termes')\nprint('[OK] Module 5: DAG construit')\n","metadata":{"id":"GzSxyNRRbS6S","trusted":true,"execution":{"iopub.status.busy":"2026-07-31T17:51:03.069066Z","iopub.execute_input":"2026-07-31T17:51:03.069375Z","iopub.status.idle":"2026-07-31T17:51:15.618722Z","shell.execute_reply.started":"2026-07-31T17:51:03.069351Z","shell.execute_reply":"2026-07-31T17:51:15.618125Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"code","source":"# ============================================================================\n# MODULE 5.0 — TESTS DE VALIDATION DU DAG GO (GARDE-FOU ANTI-REGRESSION)\n# ============================================================================\n# Ce module ne fait PAS partie du pipeline scientifique: il valide que les\n# hypotheses sur la structure du graphe obonet sont correctes AVANT que\n# tout calcul scientifique (True Path Rule, profondeurs, curriculum) ne\n# s'appuie dessus. Si une de ces assertions echoue, le pipeline s\\'arrete\n# immediatement (fail-fast) plutot que de produire silencieusement des\n# resultats corrompus comme dans la V8.\n# ============================================================================\n\nimport networkx as nx_test_unitaire # Alias local pour ne pas polluer le namespace\n\ndef test_convention_obonet():\n '''\n Test unitaire deterministe (n'utilise aucune donnee CAFA-6):\n construit un mini-graphe a la main avec une hierarchie connue\n (5 niveaux: GO:T0 racine ... GO:T4 feuille) et verifie que\n successors/predecessors/ancestors/descendants se comportent comme\n attendu etant donne la convention d'aretes is_a ENFANT -> PARENT.\n '''\n g = nx_test_unitaire.DiGraph()\n # Chaine lineaire: T4 -> T3 -> T2 -> T1 -> T0 (T0 = racine)\n g.add_edge('GO:T4', 'GO:T3') # T4 is_a T3 (T4 est enfant de T3)\n g.add_edge('GO:T3', 'GO:T2')\n g.add_edge('GO:T2', 'GO:T1')\n g.add_edge('GO:T1', 'GO:T0') # T0 = racine\n\n # successors(T2) doit donner le PARENT direct (T1), pas l'enfant\n assert list(g.successors('GO:T2')) == ['GO:T1'], \\\n \"ECHEC: successors() devrait renvoyer le PARENT direct\"\n\n # predecessors(T2) doit donner l'ENFANT direct (T3)\n assert list(g.predecessors('GO:T2')) == ['GO:T3'], \\\n \"ECHEC: predecessors() devrait renvoyer l'ENFANT direct\"\n\n # nx.descendants(T2) = tous les noeuds ATTEIGNABLES depuis T2\n # = tous les ANCETRES ontologiques de T2 (T1, T0)\n assert nx_test_unitaire.descendants(g, 'GO:T2') == {'GO:T1', 'GO:T0'}, \\\n \"ECHEC: nx.descendants() devrait renvoyer les ANCETRES ontologiques\"\n\n # nx.ancestors(T2) = tous les noeuds AYANT UN CHEMIN VERS T2\n # = tous les DESCENDANTS ontologiques de T2 (T3, T4)\n assert nx_test_unitaire.ancestors(g, 'GO:T2') == {'GO:T3', 'GO:T4'}, \\\n \"ECHEC: nx.ancestors() devrait renvoyer les DESCENDANTS ontologiques\"\n\n print(' [TEST 1/3] Convention obonet (successors/predecessors/ancestors/descendants): OK')\n\ndef test_true_path_propagation_correcte():\n '''\n Test unitaire deterministe de propager_true_path() sur le mini-graphe.\n Une proteine annotee avec le terme le plus specifique (T4) doit, apres\n propagation, etre annotee avec TOUS ses ancetres (T3, T2, T1, T0) et\n avec AUCUN de ses descendants (il n'y en a pas ici, T4 est une feuille).\n '''\n g = nx_test_unitaire.DiGraph()\n g.add_edge('GO:T4', 'GO:T3')\n g.add_edge('GO:T3', 'GO:T2')\n g.add_edge('GO:T2', 'GO:T1')\n g.add_edge('GO:T1', 'GO:T0')\n\n termes_val_test = {'GO:T0', 'GO:T1', 'GO:T2', 'GO:T3', 'GO:T4'}\n annotations_test = {'PROT_TEST': {'GO:T4'}} # Une proteine, annotee au terme le plus specifique\n\n cache_test = {t: nx_test_unitaire.descendants(g, t) & termes_val_test for t in termes_val_test}\n resultat = propager_true_path(annotations_test, cache_test)\n attendu = {'GO:T4', 'GO:T3', 'GO:T2', 'GO:T1', 'GO:T0'} # Le terme + TOUS ses ancetres\n\n assert resultat['PROT_TEST'] == attendu, (\n f\"ECHEC: propagation incorrecte. Attendu {attendu}, obtenu {resultat['PROT_TEST']}\"\n )\n print(' [TEST 2/3] propager_true_path() sur cas connu (T4 -> tous ses ancetres): OK')\n\ndef test_sanite_dag_reel():\n '''\n Assertions de sanite sur le VRAI graphe go_dag charge depuis go-basic.obo\n (pas un mock). Detecte les regressions meme si quelqu'un modifie le code\n sans toucher aux tests ci-dessus (ex: si profondeur_go redevient plat).\n '''\n # La profondeur max ne doit pas etre triviale (sinon BFS casse, comme le bug EDA)\n profondeurs_valides = [profondeur_go[t] for t in termes_valides if t in profondeur_go]\n prof_max_reelle = max(profondeurs_valides) if profondeurs_valides else 0\n assert prof_max_reelle >= 3, (\n f\"ECHEC SANITE: profondeur max = {prof_max_reelle} (devrait etre >> 3 sur \"\n f\"le GO reel). Le BFS de profondeur a probablement regresse.\"\n )\n\n # Le facteur d'expansion du True Path Rule doit rester dans une plage plausible.\n # Une vraie propagation GO multiplie typiquement les annotations par 2x-8x,\n # JAMAIS par 100x (ce qui signalerait un sens de propagation inverse).\n n_avant_test = sum(len(v) for v in annot_orig.values())\n n_apres_test = sum(len(v) for v in annot_prop.values())\n facteur = n_apres_test / max(n_avant_test, 1)\n assert facteur < 20.0, (\n f\"ECHEC SANITE: facteur d'expansion True Path Rule = {facteur:.1f}x \"\n f\"(plage plausible: 2x-8x). Une valeur > 20x indique presque certainement \"\n f\"une propagation dans le mauvais sens (ancetres <-> descendants inverses).\"\n )\n\n print(f' [TEST 3/3] Sanite sur le DAG reel: profondeur_max={prof_max_reelle}, '\n f'facteur_expansion_TPR={facteur:.2f}x -- OK')\n\n# --- Execution des tests ---\nprint('[TESTS] Validation de la convention obonet et de la propagation GO...')\ntest_convention_obonet()\ntest_true_path_propagation_correcte()\ntest_sanite_dag_reel()\nprint('[OK] Module 5.0: Tous les tests de validation sont passes')\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T17:51:15.621081Z","iopub.execute_input":"2026-07-31T17:51:15.621287Z","iopub.status.idle":"2026-07-31T17:51:15.65941Z","shell.execute_reply.started":"2026-07-31T17:51:15.62127Z","shell.execute_reply":"2026-07-31T17:51:15.658565Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# ═══════════════════════════════════════════════════════════════════════════\n# À INSÉRER JUSTE AVANT LE MODULE 6, AU DÉBUT DE LA PROCHAINE SESSION\n# Redirige la recherche du cache vers le Dataset attaché en Input,\n# au lieu de chercher dans /kaggle/working/ qui sera vide après coupure\n# ═══════════════════════════════════════════════════════════════════════════\n\nimport shutil\nfrom pathlib import Path\n\nCHEMIN_CACHE_INPUT = Path(\"/kaggle/input/datasets/yimgakevin/cafa6-esm2-cache\")\nCHEMIN_CACHE_LOCAL = Path(CHEMIN_CACHE_ESM) # variable déjà définie dans votre notebook\n\nCHEMIN_CACHE_LOCAL.mkdir(parents=True, exist_ok=True)\n\nif CHEMIN_CACHE_INPUT.exists():\n fichiers_a_copier = [\"embeddings_all.npy\", \"accessions_all.npy\"]\n for nom_fichier in fichiers_a_copier:\n source = CHEMIN_CACHE_INPUT / nom_fichier\n destination = CHEMIN_CACHE_LOCAL / nom_fichier\n if source.exists() and not destination.exists():\n shutil.copy2(source, destination)\n taille_mo = source.stat().st_size / 1e6\n print(f\"[RESTAURATION] {nom_fichier} copié ({taille_mo:.1f} Mo)\")\n print(\"[RESTAURATION] ✅ Cache ESM-2 restauré — Module 6 le détectera \"\n \"automatiquement et passera l'extraction (8h économisées).\")\nelse:\n print(\"[RESTAURATION] ⚠️ Dataset 'cafa6-esm2-cache' non attaché. \"\n \"Ajoutez-le via le panneau 'Add Input' avant de relancer, \"\n \"sinon le Module 6 va recalculer les 8h d'embeddings.\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T17:51:15.660483Z","iopub.execute_input":"2026-07-31T17:51:15.660787Z","iopub.status.idle":"2026-07-31T17:51:25.492895Z","shell.execute_reply.started":"2026-07-31T17:51:15.660768Z","shell.execute_reply":"2026-07-31T17:51:25.492124Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# ============================================================================\n# RESTAURATION DU CACHE LoRA (depuis le dataset Kaggle attache en Input)\n# ============================================================================\n# Meme pattern que la cellule de restauration ESM-2 ci-dessus.\n# Si vous avez sauvegarde les embeddings LoRA dans un dataset Kaggle\n# (nom: cafa6-lora-cache), cette cellule les copie vers le dossier\n# de travail pour que le Module 6b les detecte et skippe le fine-tuning.\n# Gain: ~2h de fine-tuning + re-extraction economisees.\n# ============================================================================\n\nfrom pathlib import Path\n\nCHEMIN_CACHE_LORA_INPUT = Path('/kaggle/input/datasets/yimgakevin/cafa6-lora-cache')\nCHEMIN_CACHE_LORA_LOCAL = Path(CHEMIN_CACHE_ESM) # Meme dossier que ESM-2\n\nif CHEMIN_CACHE_LORA_INPUT.exists():\n fichiers_lora = ['embeddings_lora_all.npy', 'accessions_lora_all.npy']\n for nom_fichier in fichiers_lora:\n source = CHEMIN_CACHE_LORA_INPUT / nom_fichier\n destination = CHEMIN_CACHE_LORA_LOCAL / nom_fichier\n if source.exists() and not destination.exists():\n shutil.copy2(source, destination)\n taille_mo = source.stat().st_size / 1e6\n print(f'[RESTAURATION LoRA] {nom_fichier} copie ({taille_mo:.1f} Mo)')\n print('[RESTAURATION LoRA] Cache LoRA restaure - Module 6b detectera le cache.')\n print(' Fine-tuning LoRA sera skippe (~2h economisees)!')\nelse:\n print('[RESTAURATION LoRA] Dataset cafa6-lora-cache non attache.')\n print(' Ajoutez-le via le panneau Add Input, sinon le Module 6b')\n print(' va recalculer le fine-tuning LoRA (~2h).')\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T17:51:25.493959Z","iopub.execute_input":"2026-07-31T17:51:25.494828Z","iopub.status.idle":"2026-07-31T17:51:35.380076Z","shell.execute_reply.started":"2026-07-31T17:51:25.494793Z","shell.execute_reply":"2026-07-31T17:51:35.379386Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module 6 — Extraction des embeddings ESM-2\n\nESM-2 (Lin et al., 2023) est un modele de langue proteique entraine sur 65\nmillions de sequences UniRef50. On l'utilise pour produire un embedding\ndense de dimension 1280 par proteine, obtenu par mean pooling sur les\nrepresentations de la couche 33 du modele `esm2_t33_650M`.\n\n## Sequences longues\n\nESM-2 limite la taille d'entree a 1022 acides amines (1024 tokens avec BOS\net EOS). Pour les sequences plus longues, on decoupe la sequence en fenetres\nchevauchantes (50% de chevauchement), on calcule l'embedding de chaque\nfenetre, et on moyenne les embeddings fenetres. Cette approche preserve\nune couverture complete de la sequence tout en restant dans la limite de\ncontexte du modele.\n\n## Optimisation multi-GPU\n\nSur Kaggle (2x T4), deux workers traitent en parallele deux buckets de\nsequences (triées par longueur pour minimiser le padding). Un checkpoint\nprogressif `.npz` tous les 1000 embeddings permet de reprendre apres une\ninterruption sans tout recalculer.\n\n## Principe\n\nESM-2 (Evolutionary Scale Modeling 2) est un transformer proteique pre-entraine sur ~60 millions de sequences issues d'UniRef. Pour chaque proteine d'entree, le modele produit un embedding par residu (dimension 1280 pour la variante 650M, 2560 pour la variante 3B). L'embedding proteique final est obtenu par mean pooling sur les residus. Les sequences trop longues (>1022 residus, limite du modele) sont decoupees en fenetres chevauchantes avec un recouvrement de 50%, et les embeddings de chaque fenetre sont moyennees.\n\n## Justification\n\nESM-2 est choisi car il represente l'etat de l'art pour la representation de proteines en 2024-2025 (Lin et al., 2023). Comparaisons avec les alternatives :\n- **DeepGOPlus embeddings** : bases sur 1D-CNN, moins expressifs, et limits a 1000 AA.\n- **ProtBERT / ProtT5** : performances comparables a ESM-2 mais modeles plus lourds (ProtT5-XL = 5 GB) et inference plus lente.\n- **UniRep** : plus leger mais nettement inferieur en performance.\n- **ESM-1b** : predecesseur d'ESM-2, moins performant de ~2 points de F1 sur les taches de fonction.\n\nLa variante 650M est privilegiee a la variante 3B car elle offre un bon compromis performance / cout : 1280 dim vs 2560, moitie moins de VRAM, et des performances quasi identiques sur CAFA (ecart < 0.5 Fmax). Le sliding window 50% est la methode recommandee par les auteurs ESM pour les sequences longues ; il introduit un leger biais aux frontieres de fenetres mais reste preferable au troncage qui perd l'information du C-terminal.","metadata":{"id":"OPzQaoskbS6T"}},{"cell_type":"code","source":"# ============================================================================\n# MODULE 6 — EXTRACTION DES EMBEDDINGS ESM-2 (VERSION OPTIMISEE MULTI-GPU)\n# ============================================================================\n# ESM-2 transforme chaque sequence proteique en un vecteur dense 1280-d.\n# Ce vecteur capture les informations evolutives et structurelles.\n# Reference: Lin et al. (2023) Science 379(6637)\n#\n# OPTIMISATIONS APPORTEES (vs version precedente):\n# 1. BATCHING REEL: au lieu de traiter 1 proteine par forward pass, on traite\n# un batch de N proteines en parallele sur le GPU.\n# Gain: x20-x50 sur l utilisation des coeurs CUDA.\n# 2. TRI PAR LONGUEUR: on trie les sequences par longueur avant batching,\n# ce qui minimise le padding (de ~80% a ~5%).\n# Gain: x4-x5 en temps de calcul effectif.\n# 3. BUCKETS ADAPTATIFS: 5 buckets par longueur, chacun avec un batch_size\n# optimal (128 pour courtes, 8 pour longues). Evite OOM et maximise\n# l utilisation GPU.\n# 4. MULTI-GPU (2x T4): 2 threads Python tournent en parallele, chacun sur\n# un GPU different. Moitie des proteines sur cuda:0, moitie sur cuda:1.\n# Gain: x2 theorique.\n# 5. CHECKPOINT PROGRESSIF PRESERVE: sauvegarde tous les 1000 proteines,\n# reprise exacte apres kill Kaggle 12h.\n#\n# VITESSE ESTIMEE: de ~5 prot/s (ancienne version) a ~200-400 prot/s (nouvelle)\n# Temps total pour ~142000 proteines: ~30-50 min au lieu de ~8 heures\n#\n# References:\n# - Lin et al. (2023) Science 379(6637) — ESM-2\n# - NVIDIA (2023) CUDA Best Practices — batching\n# - PyTorch docs — torch.cuda, threading\n# ============================================================================\n\n# --- Importations supplementaires pour multi-threading et multi-GPU ---\nimport threading # Pour lancer 2 workers en parallele sur 2 GPUs\nfrom queue import Queue # Pour communiquer entre threads workers et main thread\n\nprint('[ESM-2] Module 6 — Extraction optimisee (multi-GPU + buckets + tri longueur)')\n\n# ============================================================================\n# 6.1 - CONFIGURATION GPU MULTI-DEVICE\n# ============================================================================\n# Detection des GPUs disponibles. Sur Kaggle avec 2x T4: cuda:0 et cuda:1.\n# Si on n a qu un GPU, on retombe sur un seul device (mais on garde les buckets).\n_n_gpus = torch.cuda.device_count() if torch.cuda.is_available() else 0 # Compte GPUs\nprint(f'[ESM-2] GPUs detectes: {_n_gpus}') # Affiche nombre GPUs\n\n# Afficher les proprietes de chaque GPU pour verification\nfor _i in range(_n_gpus): # Pour chaque GPU\n _props = torch.cuda.get_device_properties(_i) # Proprietes materielles\n print(f' cuda:{_i} — {_props.name}, {_props.total_memory/1e9:.1f} GB')\n# Liste des devices a utiliser (1 ou 2 GPUs selon disponibilite)\nif _n_gpus >= 2: # Si au moins 2 GPUs\n _DEVICES = [torch.device('cuda:0'), torch.device('cuda:1')] # Deux GPUs\nelif _n_gpus == 1: # Si un seul GPU\n _DEVICES = [torch.device('cuda:0')] # Un seul\nelse: # Pas de GPU\n _DEVICES = [torch.device('cpu')] # CPU fallback\nprint(f'[ESM-2] Devices utilises: {_DEVICES}') # Affiche devices\n\n# ============================================================================\n# 6.2 - CHARGER LE MODELE ESM-2 SUR CHAQUE GPU\n# ============================================================================\n# On charge une instance du modele par GPU. Chaque thread aura son propre modele.\n# En Kaggle, ESM-2 650M prend ~2.5 GB VRAM par GPU, largement dans un T4 (16 GB).\nprint('[ESM-2] Chargement du modele sur chaque GPU...')\n\n# V20 FIX #10: Charger ESM-2 directement sur chaque GPU sans copy.deepcopy\n# Avant (V19) : copy.deepcopy créait une 2e copie CPU (2,5 Go) AVANT le .to(dev),\n# donnant un pic CPU de ~7,5 Go (1 originale + 2 deepcopies) sur 2 GPUs.\n# Maintenant (V20) : on charge le modèle UNE FOIS par GPU directement sur le device.\n# Pic CPU : 2,5 Go (1 seule copie transitoire pendant le chargement).\n_alphabet_cpu = None # Sera chargé avec le 1er modèle, partagé ensuite\n_modeles_par_gpu = [] # Liste des modèles, un par GPU\nfor _i_dev, _dev in enumerate(_DEVICES): # Pour chaque device\n _m, _alpha = esm.pretrained.esm2_t33_650M_UR50D() # Chargement frais\n _m = _m.to(_dev).eval() # Directement sur le device, mode eval\n _modeles_par_gpu.append(_m)\n if _i_dev == 0: # Premier GPU : garder l'alphabet (léger, ~1 Mo)\n _alphabet_cpu = _alpha\n else: # GPUs suivants : libérer leur alphabet (on partage le 1er)\n del _alpha\n print(f' Modele charge sur {_dev}')\n# V20 : pas de _modele_cpu à libérer (déjà sur GPU)\nTAILLE_MAX_ESM = 1022 # 1024 - 2 tokens spéciaux (BOS + EOS)\nprint(f' Modele: {ESM2_VARIANT}, {sum(p.numel() for p in _modeles_par_gpu[0].parameters()):,} parametres')\nprint(f' Dimension embedding: {ESM2_DIM}')\nprint(f' Taille max sequence: {TAILLE_MAX_ESM} AA')\ngc.collect() # Nettoyage final\n\n# ============================================================================\n# 6.3 - DEFINITION DES BUCKETS PAR LONGUEUR\n# ============================================================================\n# Chaque bucket couvre une plage de longueurs et a un batch_size optimal.\n# Plus la sequence est longue, plus le batch_size est petit (limite VRAM).\n# References: valeurs empiriques pour T4 (16 GB VRAM) avec ESM-2 650M\n# - Sequence de 100 AA: ~50 MB VRAM -> on peut mettre 128 en batch\n# - Sequence de 1000 AA: ~3 GB VRAM -> seulement 16 en batch\nBUCKETS_LONGUEUR = [\n # (longueur_min, longueur_max, batch_size, description)\n (0, 200, 128, 'tres court (0-200 AA)'), # 128 sequences en parallele\n (201, 400, 64, 'court (201-400 AA)'), # 64 sequences\n (401, 700, 32, 'moyen (401-700 AA)'), # 32 sequences\n (701, 1022, 16, 'long (701-1022 AA)'), # 16 sequences\n (1023, 99999, 8, 'tres long (>1022 AA, sliding)') # 8 + sliding window\n]\n\ndef assigner_bucket(longueur):\n 'Retourne l indice du bucket correspondant a la longueur donnee.'\n for i, (lo, hi, bs, _) in enumerate(BUCKETS_LONGUEUR): # Pour chaque bucket\n if lo <= longueur <= hi: # Si longueur dans la plage\n return i # Retourne l indice\n return len(BUCKETS_LONGUEUR) - 1 # Fallback: dernier bucket\n\n# ============================================================================\n# 6.4 - FONCTION D EXTRACTION BATCHED\n# ============================================================================\ndef extraire_embedding_sliding(sequence, modele, convertisseur, device, max_len=1022):\n '''\n Extrait un embedding pour une sequence > 1022 AA via sliding window.\n On decoupe la sequence en fenetres chevauchantes (50%) et on moyenne.\n '''\n pas = max_len // 2 # Chevauchement 50% entre fenetres\n fenetres = [] # Liste des embeddings par fenetre\n for debut in range(0, len(sequence), pas): # Pour chaque fenetre\n fin = min(debut + max_len, len(sequence)) # Fin de fenetre\n sous_seq = sequence[debut:fin] # Sous-sequence\n if len(sous_seq) < 10: # Fenetre trop courte\n continue\n donnees = [('prot', sous_seq)] # Format ESM\n _, _, tokens = convertisseur(donnees)\n tokens = tokens.to(device) # Sur GPU\n with torch.no_grad(): # Pas de gradients\n res = modele(tokens, repr_layers=[33])\n emb = res['representations'][33]\n emb_moyen = emb[0, 1:-1].mean(dim=0) # Mean pooling\n fenetres.append(emb_moyen.cpu().numpy())\n if fenetres: # Si on a des fenetres\n return np.mean(fenetres, axis=0)\n return np.zeros(ESM2_DIM, dtype=np.float32) # Fallback vecteur nul\n\n# ============================================================================\n# 6.5 - FONCTION WORKER POUR UN GPU (thread)\n# ============================================================================\n# Chaque worker tourne sur un GPU dedie et traite sa portion de sequences.\n# Les embeddings sont stockes dans un dict partage protege par un Lock.\n\ndef worker_gpu(liste_buckets_worker, modele_worker, alphabet_worker, device_worker,\n embeddings_partage, lock_emb, compteur_partage, lock_compteur,\n frequence_sauvegarde, fichier_cache, n_total, queue_progression):\n '''\n Worker execute dans un thread. Traite sa portion de sequences sur un GPU.\n\n Parametres:\n liste_buckets_worker: list de listes [(acc, seq), ...] par bucket\n modele_worker: modele ESM-2 sur le device de ce worker\n alphabet_worker: alphabet ESM-2\n device_worker: torch.device de ce worker\n embeddings_partage: dict partage entre threads (accesion -> embedding)\n lock_emb: threading.Lock pour proteger le dict partage\n compteur_partage: dict avec cle 'count' partage entre threads\n lock_compteur: threading.Lock pour proteger le compteur\n frequence_sauvegarde: int — sauvegarde tous les N proteines\n fichier_cache: str — chemin du fichier checkpoint\n n_total: int — nombre total de sequences a extraire\n queue_progression: Queue pour remonter progression au main thread\n '''\n try: # Capture des erreurs pour ne pas crasher le main thread\n convertisseur = alphabet_worker.get_batch_converter() # Batch converter\n\n for idx_bucket, liste_acc_seq in enumerate(liste_buckets_worker): # Pour chaque bucket\n if not liste_acc_seq: # Si bucket vide\n continue # Passer au suivant\n\n lo, hi, bs, desc = BUCKETS_LONGUEUR[idx_bucket] # Config bucket\n n_in_bucket = len(liste_acc_seq) # Nb sequences dans ce bucket\n queue_progression.put(('status', f' Worker {device_worker}: bucket {idx_bucket} ({desc}) — {n_in_bucket} proteines, batch_size={bs}'))\n\n # Traiter par sous-batches de taille bs\n for debut in range(0, n_in_bucket, bs): # Pour chaque sous-batch\n sous_batch = liste_acc_seq[debut:debut+bs] # Extraire sous-batch\n\n # Cas 1: sequences <= 1022 AA — batched\n if hi <= TAILLE_MAX_ESM: # Si bucket non sliding\n donnees = [(acc, seq) for acc, seq in sous_batch] # Format ESM\n _, _, tokens = convertisseur(donnees) # Tokeniser tout le batch\n tokens = tokens.to(device_worker) # Sur GPU\n\n with torch.no_grad(): # Pas de gradients\n res = modele_worker(tokens, repr_layers=[33]) # Forward batched\n emb_tensor = res['representations'][33] # (bs, L+2, DIM)\n\n # Mean pooling par sequence (exclure BOS et EOS)\n for i, (acc, seq) in enumerate(sous_batch): # Pour chaque proteine\n L = len(seq) # Longueur reelle\n emb_moyen = emb_tensor[i, 1:L+1].mean(dim=0) # Mean pooling\n with lock_emb: # Proteger le dict partage\n embeddings_partage[acc] = emb_moyen.cpu().numpy()\n # Cas 2: sequences > 1022 AA — sliding window (1 par 1)\n else: # Bucket tres long\n for acc, seq in sous_batch: # Pour chaque sequence\n emb = extraire_embedding_sliding( # Sliding window\n seq, modele_worker, convertisseur, device_worker, TAILLE_MAX_ESM)\n with lock_emb:\n embeddings_partage[acc] = emb\n # Mise a jour compteur partage + checkpoint eventuel\n n_dans_batch = len(sous_batch) # Nombre traites dans ce batch\n with lock_compteur: # Proteger compteur\n compteur_partage['count'] += n_dans_batch\n count_now = compteur_partage['count'] # Lecture locale\n\n # Checkpoint tous les N proteines\n if count_now % frequence_sauvegarde == 0: # Heure de checkpoint\n # Sauvegarder le checkpoint thread-safe\n with lock_emb: # Bloquer le dict aussi\n accs = np.array(list(embeddings_partage.keys()), dtype=object)\n embs = np.stack(list(embeddings_partage.values()))\n np.savez_compressed(fichier_cache,\n accessions=accs, embeddings=embs)\n queue_progression.put(('checkpoint', count_now, len(embeddings_partage)))\n elif count_now % 100 == 0: # Progression tous les 100\n queue_progression.put(('progress', count_now, len(embeddings_partage)))\n\n queue_progression.put(('done', str(device_worker))) # Signaler fin\n\n except Exception as e: # En cas d erreur\n queue_progression.put(('error', str(e))) # Remonter erreur\n import traceback\n queue_progression.put(('error_trace', traceback.format_exc()))\n\n# ============================================================================\n# 6.6 - PREPARATION DES FICHIERS DE CHECKPOINT\n# ============================================================================\n# CHECKPOINT PROGRESSIF: on sauvegarde les embeddings au fur et a mesure.\n# Si la session Kaggle s arrete (OOM, timeout 12h, etc.), on reprend\n# EXACTEMENT ou on s est arrete — meme apres 10000/54000 proteines.\n# Reference: Kaggle Notebooks — Saving & Loading Models (working dir persistant)\n\nFICHIER_CACHE_EMB = CHEMIN_CACHE_ESM + 'embeddings_progressif.npz' # Cache progressif\nFICHIER_CACHE_FINAL = CHEMIN_CACHE_ESM + 'embeddings_all.npy' # Cache final complet\nFICHIER_CACHE_ACC_FINAL = CHEMIN_CACHE_ESM + 'accessions_all.npy' # Accessions finales\nFREQUENCE_SAUVEGARDE = 1000 # Sauvegarder tous les 1000 proteines\n\n# CREER LE DOSSIER CACHE (obligatoire pour eviter FileNotFoundError)\nos.makedirs(CHEMIN_CACHE_ESM, exist_ok=True) # Creer dossier\n\n# Combiner les sequences train et test pour une extraction efficace\ntoutes_sequences = {} # Toutes les sequences\ntoutes_sequences.update(seq_train) # Ajouter sequences train\ntoutes_sequences.update(seq_test) # Ajouter sequences test\nprint(f' Proteines total a traiter: {len(toutes_sequences):,}')\n\n# ============================================================================\n# 6.7 - CHARGER LE CHECKPOINT EXISTANT (si present)\n# ============================================================================\nembeddings = {} # Dictionnaire embeddings (accesion -> vecteur)\nn_deja_extraits = 0 # Nombre deja extraits\n\nif os.path.exists(FICHIER_CACHE_EMB): # Si checkpoint progressif existe\n print(f'[ESM-2] Checkpoint progressif trouve! Chargement...')\n try:\n donnees_cache = np.load(FICHIER_CACHE_EMB, allow_pickle=True) # Charger archive\n accessions_cache = donnees_cache['accessions'] # Liste accessions\n embeddings_cache = donnees_cache['embeddings'] # Matrice embeddings\n for idx_acc in range(len(accessions_cache)): # Pour chaque accession\n acc = str(accessions_cache[idx_acc]) # Convertir en str\n embeddings[acc] = embeddings_cache[idx_acc]\n n_deja_extraits = len(embeddings) # Nombre deja extraits\n print(f' {n_deja_extraits:,} embeddings charges depuis le checkpoint')\n print(f' Reste a extraire: {len(toutes_sequences) - n_deja_extraits:,} proteines')\n except Exception as e: # Fichier corrompu\n print(f' [ATTENTION] Erreur chargement checkpoint: {e}')\n print(f' [ATTENTION] Redemarrage de zero...')\n embeddings = {}\n n_deja_extraits = 0\n\nelif os.path.exists(FICHIER_CACHE_FINAL) and os.path.exists(FICHIER_CACHE_ACC_FINAL):\n # Pas de checkpoint progressif, mais cache final complet\n print(f'[ESM-2] Cache final trouve! Chargement...')\n try:\n embeddings_array_cache = np.load(FICHIER_CACHE_FINAL)\n accessions_cache = np.load(FICHIER_CACHE_ACC_FINAL, allow_pickle=True)\n embeddings = dict(zip(accessions_cache, embeddings_array_cache))\n n_deja_extraits = len(embeddings)\n print(f' {n_deja_extraits:,} embeddings charges depuis le cache final')\n except Exception as e:\n print(f' [ATTENTION] Erreur chargement cache final: {e}')\n embeddings = {}\n n_deja_extraits = 0\n\nelse: # Aucun cache\n print('[ESM-2] Aucun cache trouve. Extraction complete necessaire.')\n\n# ============================================================================\n# 6.8 - IDENTIFIER LES SEQUENCES RESTANTES\n# ============================================================================\nsequences_restantes = {} # Sequences pas encore dans le cache\nfor accession, seq in toutes_sequences.items(): # Pour chaque proteine\n if accession not in embeddings: # Si pas encore dans le cache\n sequences_restantes[accession] = seq\nn_restantes = len(sequences_restantes) # Nombre restantes\nprint(f' Embeddings deja disponibles: {n_deja_extraits:,}')\nprint(f' Sequences restant a extraire: {n_restantes:,}')\n\n# ============================================================================\n# 6.9 - EXTRACTION MULTI-GPU AVEC BUCKETS (si sequences restantes)\n# ============================================================================\nif n_restantes > 0: # S il reste des sequences\n print(f'\\n[ESM-2] Extraction de {n_restantes:,} embeddings manquants...')\n print(f'[ESM-2] Strategie: tri par longueur + {len(_DEVICES)} GPU(s) en parallele + buckets adaptatifs')\n\n # --- Etape A: Convertir en liste et trier par longueur ---\n # Le tri par longueur est CRUCIAL: il minimise le padding dans chaque batch.\n # Sans tri, on aurait des sequences de 50 AA melangees avec des 1000 AA,\n # et tout serait paddle a 1000 -> 95% de calculs inutiles.\n print(' [A] Tri des sequences par longueur...')\n liste_acc_seq = list(sequences_restantes.items()) # Convertir dict en liste\n liste_acc_seq.sort(key=lambda x: len(x[1])) # Tri par longueur croissante\n longueurs = [len(s) for _, s in liste_acc_seq] # Liste longueurs\n print(f' Longueur min: {min(longueurs)} AA, max: {max(longueurs)} AA, mediane: {np.median(longueurs):.0f} AA')\n\n # --- Etape B: Assigner chaque sequence a un bucket ---\n print(' [B] Assignation des sequences aux buckets...')\n buckets_par_idx = [[] for _ in BUCKETS_LONGUEUR] # 5 listes vides\n for acc, seq in liste_acc_seq: # Pour chaque sequence\n idx_b = assigner_bucket(len(seq)) # Trouver bucket\n buckets_par_idx[idx_b].append((acc, seq)) # Ajouter au bucket\n\n # Afficher la distribution des buckets\n for i, (lo, hi, bs, desc) in enumerate(BUCKETS_LONGUEUR): # Pour chaque bucket\n n_in_b = len(buckets_par_idx[i]) # Nombre dans ce bucket\n pct = 100 * n_in_b / max(1, n_restantes)\n print(f' Bucket {i} ({desc}): {n_in_b:,} sequences ({pct:.1f}%), batch_size={bs}')\n\n # --- Etape C: Diviser chaque bucket entre les GPUs ---\n # Si on a 2 GPUs, on coupe chaque bucket en 2 moities (interleave pour equilibrer)\n # Strategie: on interleave les sequences pour que chaque GPU ait un melange\n # de sequences courtes ET longues (equilibre de charge)\n print(f' [C] Division des buckets entre {len(_DEVICES)} GPU(s)...')\n buckets_par_gpu = [[] for _ in _DEVICES] # Liste de listes par GPU\n # Chaque element de buckets_par_gpu[g] est une liste de 5 sous-listes (1 par bucket)\n for g in range(len(_DEVICES)):\n buckets_par_gpu[g] = [[] for _ in BUCKETS_LONGUEUR] # 5 buckets vides\n\n for idx_b, liste in enumerate(buckets_par_idx): # Pour chaque bucket\n # Interleave: sequence 0 -> GPU0, seq 1 -> GPU1, seq 2 -> GPU0, etc.\n for i, item in enumerate(liste): # Pour chaque sequence du bucket\n g = i % len(_DEVICES) # Round-robin entre GPUs\n buckets_par_gpu[g][idx_b].append(item) # Ajouter au GPU correspondant\n\n # Afficher la repartition\n for g in range(len(_DEVICES)): # Pour chaque GPU\n total_g = sum(len(b) for b in buckets_par_gpu[g]) # Total sur ce GPU\n print(f' GPU {g} ({_DEVICES[g]}): {total_g:,} sequences')\n\n # --- Etape D: Lancer les threads workers ---\n print(f' [D] Lancement de {len(_DEVICES)} thread(s) worker(s)...')\n\n # Structures partagees entre threads\n lock_emb = threading.Lock() # Lock pour le dict embeddings partage\n lock_compteur = threading.Lock() # Lock pour le compteur partage\n compteur_partage = {'count': 0} # Compteur partage\n queue_progression = Queue() # Queue pour remonter progression\n\n # Liste des threads\n threads = [] # Liste des threads workers\n for g in range(len(_DEVICES)): # Pour chaque GPU\n t = threading.Thread( # Creer thread\n target=worker_gpu, # Fonction worker\n args=(\n buckets_par_gpu[g], # Buckets de ce GPU\n _modeles_par_gpu[g], # Modele de ce GPU\n _alphabet_cpu, # Alphabet (partage, en lecture seule)\n _DEVICES[g], # Device de ce GPU\n embeddings, # Dict partage\n lock_emb, # Lock embeddings\n compteur_partage, # Compteur partage\n lock_compteur, # Lock compteur\n FREQUENCE_SAUVEGARDE, # Frequence checkpoint\n FICHIER_CACHE_EMB, # Fichier checkpoint\n n_restantes,\n queue_progression # Queue progression\n ),\n daemon=False # Thread non-daemon (doit finir proprement)\n )\n threads.append(t)\n t.start() # Lancer le thread\n\n # --- Etape E: Monitorer la progression depuis le main thread ---\n temps_debut = time.time() # Chronometre debut\n n_workers_termines = 0 # Compteur workers termines\n\n while n_workers_termines < len(threads): # Tant que tous pas termines\n try: # Recuperer message de la queue (avec timeout)\n msg = queue_progression.get(timeout=10) # Attendre message\n type_msg = msg[0] # Type de message\n\n if type_msg == 'status': # Message de statut\n print(msg[1])\n elif type_msg == 'progress': # Progression tous les 100\n count_now = msg[1] # Nombre traite\n total_emb = msg[2] # Total embeddings dispo\n temps_ecoule = time.time() - temps_debut\n if count_now > 0: # Eviter division par zero\n vitesse = count_now / temps_ecoule # prot/s\n reste = (n_restantes - count_now) / vitesse\n print(f' [{count_now}/{n_restantes}] {vitesse:.1f} prot/s | '\n f'Total dispo: {total_emb:,}/{len(toutes_sequences):,} | '\n f'Reste: {reste/60:.0f}min')\n\n elif type_msg == 'checkpoint': # Checkpoint sauvegarde\n count_now = msg[1] # Nombre traite\n total_emb = msg[2] # Total dispo\n temps_ecoule = time.time() - temps_debut\n vitesse = count_now / temps_ecoule # prot/s\n reste = (n_restantes - count_now) / vitesse\n print(f' [CHECKPOINT] {total_emb:,}/{len(toutes_sequences):,} embeddings sauvegardes | '\n f'{vitesse:.1f} prot/s | Reste: {reste/60:.0f}min')\n\n elif type_msg == 'done': # Worker termine\n n_workers_termines += 1\n print(f' [OK] Worker sur {msg[1]} termine ({n_workers_termines}/{len(threads)})')\n\n elif type_msg == 'error': # Erreur worker\n print(f' [ERREUR WORKER] {msg[1]}')\n\n elif type_msg == 'error_trace':\n print(f' [TRACEBACK]\\n{msg[1]}')\n\n except Exception: # Timeout ou autre\n continue # Continuer a attendre\n\n # Attendre que tous les threads soient bien termines\n for t in threads: # Pour chaque thread\n t.join(timeout=30) # Attendre fin (timeout 30s)\n\n temps_total = time.time() - temps_debut # Temps total\n print(f'\\n {compteur_partage[\"count\"]:,} embeddings extraits en {temps_total/60:.1f} min')\n print(f' Vitesse moyenne: {compteur_partage[\"count\"]/max(1,temps_total):.1f} prot/s')\n\n # --- Etape F: Sauvegarder le cache final complet ---\n print('[ESM-2] Sauvegarde du cache final complet...')\n accessions_list = list(embeddings.keys()) # Liste accessions\n embeddings_matrix = np.stack(list(embeddings.values())) # Matrice (N, DIM)\n np.save(FICHIER_CACHE_FINAL, embeddings_matrix) # Sauver matrice\n np.save(FICHIER_CACHE_ACC_FINAL, np.array(accessions_list, dtype=object))\n taille_cache = os.path.getsize(FICHIER_CACHE_FINAL) / 1e6 # Taille MB\n print(f' Cache final sauvegarde: {FICHIER_CACHE_FINAL} ({taille_cache:.1f} MB)')\n\n # V17c: liberer embeddings_matrix (copie sauvegardee sur disque)\n del embeddings_matrix\n\n # Supprimer le checkpoint progressif (plus necessaire)\n if os.path.exists(FICHIER_CACHE_EMB):\n os.remove(FICHIER_CACHE_EMB)\n print(f' Checkpoint progressif supprime (cache final complet)')\n\nelse: # Tous les embeddings deja en cache\n print(f'[ESM-2] Tous les {len(embeddings):,} embeddings sont deja dans le cache!')\n print(f' Aucune extraction necessaire.')\n\n# ============================================================================\n# 6.10 - VERIFIER LA QUALITE DES EMBEDDINGS\n# ============================================================================\nembeddings_array = np.stack(list(embeddings.values())) # Matrice (N, DIM)\nprint(f'\\n[ESM-2] Verification qualite:')\nprint(f' Shape: {embeddings_array.shape}')\nprint(f' Norme moyenne: {np.linalg.norm(embeddings_array, axis=1).mean():.4f}')\nprint(f' NaN presents: {np.isnan(embeddings_array).any()}') # NaN?\n\n# V17c: embeddings_array n'est plus necessaire (qualite verifiee, cache sur disque)\ndel embeddings_array\n\n# ============================================================================\n# 6.11 - LIBERER LA MEMOIRE GPU + RAM\n# ============================================================================\nfor _m in _modeles_par_gpu: # Pour chaque modele sur GPU\n del _m\n_modeles_par_gpu = [] # Vider liste\n# V17c: liberer aussi _alphabet_cpu (inutile apres extraction) et accessions_list\nif 'accessions_list' in dir():\n del accessions_list\ngc.collect() # Garbage collector CPU\nif torch.cuda.is_available(): # Si GPU\n torch.cuda.empty_cache() # Vider cache GPU\n\n# Variables exposees pour les modules suivants\nmodele_esm = None # Plus de modele en memoire (libere pour la suite)\nalphabet_esm = _alphabet_cpu # Alphabet conserve (leger, utile pour tokenizer)\n\nprint('[OK] Module 6: Embeddings ESM-2 extraits (version optimisee multi-GPU)')\n","metadata":{"id":"zteVTRfVbS6U","trusted":true,"execution":{"iopub.status.busy":"2026-07-31T17:51:35.381126Z","iopub.execute_input":"2026-07-31T17:51:35.381455Z","iopub.status.idle":"2026-07-31T17:52:06.492701Z","shell.execute_reply.started":"2026-07-31T17:51:35.381434Z","shell.execute_reply":"2026-07-31T17:52:06.492069Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# ============================================================================\n# MODULE 6b — FINE-TUNING ESM-2 AVEC LoRA / PEFT\n# ============================================================================\n# V16: Correction OOM critique + optimisation extraction multi-GPU.\n#\n# PROBLEME V15 (DataParallel sur ESM-2 650M):\n# nn.DataParallel replique le modele sur chaque GPU lors du forward.\n# ESM-2 650M = ~2.5 GB par copie. Sur 2x T4 (16 GB chacun):\n# GPU 0 = modele + batch + gradients + copie GPU1 = OOM > 16 GB.\n#\n# CORRECTIONS V16:\n# 1. SUPPRESSION DataParallel pour le TRAINING:\n# - Gradient checkpointing: use_reentrant=False, -40% VRAM\n# - Gradient accumulation: micro-batch=4, effective=16\n# - Entrainement sur GPU 0 uniquement\n# 2. EXTRACTION multi-GPU via THREADING (pas DataParallel):\n# - Chaque GPU recoit un deepcopy du modele\n# - Les sequences sont reparties entre GPUs\n# - Resultats collectes dans features_esm_lora (dict partage)\n# 3. Batch sizes conservateurs pour T4 16 GB\n# 4. Monitoring VRAM + progression frequente\n#\n# V15 (progression + cache progressif):\n# - tqdm pour training + extraction\n# - Batch sizes agressifs\n# - N_PROTEINES_LORA=5000\n# - Progression tous les 50 steps en training\n# - Time tracking + vitesse + ETA\n# - VRAM monitoring\n# - Sauvegarde progressive du cache extraction\n#\n# References:\n# - Hu et al. (2022) LoRA: Low-Rank Adaptation, ICLR\n# - Mangrulkar et al. (2022) PEFT, HuggingFace\n# - Chen et al. (2016) Training Deep Nets with Sublinear Memory Cost (gradient checkpointing)\n# ============================================================================\n\nUTILISER_LORA = False # V26: fine-tuning LoRA disabled for final submission (frozen ESM-2 is enough). Set True to re-enable (needs ~2h + 10GB RAM).\n\n# --- V12: Fichiers cache ---\nFICHIER_CACHE_LORA_FINAL = CHEMIN_CACHE_ESM + 'embeddings_lora_all.npy'\nFICHIER_CACHE_LORA_ACC = CHEMIN_CACHE_ESM + 'accessions_lora_all.npy'\nFICHIER_CACHE_LORA_PROGRESSIF = CHEMIN_CACHE_ESM + 'embeddings_lora_progressif.npz'\n\n# V23-FIX#LORA: N_PROTEINES_LORA defini EN HAUT (pas seulement dans le bloc fine-tuning)\n# AVANT: N_PROTEINES_LORA etait defini a L164 (interne au bloc fine-tuning), donc\n# absent apres redemarrage du kernel -> sous-echantillonnage saute -> Y_train_lora\n# alloue pour 142k proteines (14,8 Go) AVANT le cache check -> blocage 30+ min.\n# APRES: valeur par defaut 5000, peut etre outrepassee dans Module 2 (config).\nN_PROTEINES_LORA = globals().get('N_PROTEINES_LORA', 5000) # 5000 par defaut\nprint(f'[LoRA] N_PROTEINES_LORA = {N_PROTEINES_LORA}')\n\n# --- V15/V16: Fonction utilitaire pour monitoring VRAM ---\ndef _rapport_vram(label=''):\n # Affiche la memoire VRAM utilisee sur chaque GPU.\n if torch.cuda.is_available():\n for gi in range(torch.cuda.device_count()):\n vram_allouee = torch.cuda.memory_allocated(gi) / 1e9\n vram_reservee = torch.cuda.memory_reserved(gi) / 1e9\n vram_total = torch.cuda.get_device_properties(gi).total_memory / 1e9\n pct = vram_allouee / vram_total * 100\n print(f' [VRAM] GPU {gi}: {vram_allouee:.1f}/{vram_total:.1f} GB utilise ({pct:.0f}%), reserve: {vram_reservee:.1f} GB {label}')\n\n# ============================================================================\n# V23-FIX#LORA: CACHE CHECK EN PREMIER (avant toute allocation lourde)\n# ============================================================================\n# AVANT (V22): le cache check etait a L89, APRES la construction de Y_train_lora\n# qui allouait 14,8 Go (142k proteines x 26k termes x 4 octets) si\n# N_PROTEINES_LORA n'etait pas defini. Resultat: 30+ min de blocage meme\n# quand le cache existait.\n# APRES (V23): on check le cache AVANT toute allocation. Si cache trouve,\n# on charge les embeddings et on SAUTE toute la construction Y_train_lora.\n# ============================================================================\n_lora_cache_trouve = False\nif UTILISER_LORA and os.path.exists(FICHIER_CACHE_LORA_FINAL) and os.path.exists(FICHIER_CACHE_LORA_ACC):\n print('[LoRA] Cache final LoRA trouve! Chargement direct (fine-tuning skippe)...')\n try:\n embeddings_lora_array = np.load(FICHIER_CACHE_LORA_FINAL)\n accessions_lora_cache = np.load(FICHIER_CACHE_LORA_ACC, allow_pickle=True)\n features_esm_lora = dict(zip(accessions_lora_cache, embeddings_lora_array))\n features_esm = features_esm_lora\n if 'embeddings' in globals() and isinstance(embeddings, dict):\n embeddings.update(features_esm)\n else:\n embeddings = dict(features_esm)\n _lora_cache_trouve = True\n print(f' [LoRA] {len(features_esm):,} embeddings fine-tunes charges depuis le cache')\n print(f' [LoRA] Temps economise: ~1h de fine-tuning + re-extraction!')\n _manquantes_test = set(seq_test.keys()) - set(embeddings.keys())\n if _manquantes_test:\n print(f' [LoRA][ATTENTION] {len(_manquantes_test):,} proteines TEST absentes du cache.')\n print(f' [LoRA][ATTENTION] Supprimez le cache et re-executez pour couverture complete.')\n del embeddings_lora_array, accessions_lora_cache, features_esm_lora\n except Exception as e:\n print(f' [ATTENTION] Erreur chargement cache LoRA: {e}')\n _lora_cache_trouve = False\nelse:\n if not UTILISER_LORA:\n print('[LoRA] UTILISER_LORA=False -> fine-tuning skippe')\n else:\n print(f'[LoRA] Cache non trouve: {FICHIER_CACHE_LORA_FINAL}')\n print(f'[LoRA] Fine-tuning complet necessaire (premier run).')\n\n# ============================================================================\n# Construction Y_train_lora SEULEMENT si cache absent (fine-tuning requis)\n# ============================================================================\nif UTILISER_LORA and not _lora_cache_trouve:\n print('[LoRA] Construction des variables locales pour le fine-tuning...')\n _proteines_annotees = set(annot_prop.keys())\n _proteines_embedded = set(embeddings.keys())\n proteines_train_lora_full = sorted(list(_proteines_annotees.intersection(_proteines_embedded)))\n print(f' Proteines avec annotations ET embeddings: {len(proteines_train_lora_full):,}')\n\n # V21 FIX #19: sous-echantillonner AVANT l'allocation de Y_train_lora\n import random as _random_lora\n _random_lora.seed(GRAINE if 'GRAINE' in globals() else 42)\n if len(proteines_train_lora_full) > N_PROTEINES_LORA:\n proteines_train_lora = _random_lora.sample(proteines_train_lora_full, N_PROTEINES_LORA)\n print(f' [V21-FIX#19] Sous-echantillonnage LoRA: {N_PROTEINES_LORA} / {len(proteines_train_lora_full):,} prot')\n print(f' [V21-FIX#19] Economie memoire: ~{(len(proteines_train_lora_full) - N_PROTEINES_LORA) * len(liste_termes) * 4 / 1e9:.1f} Go')\n else:\n proteines_train_lora = proteines_train_lora_full\n del proteines_train_lora_full\n gc.collect()\n\n Y_train_lora = np.zeros((len(proteines_train_lora), len(liste_termes)), dtype=np.float32)\n for i, acc in enumerate(proteines_train_lora):\n termes = annot_prop.get(acc, set())\n for terme in termes:\n if terme in terme2idx:\n Y_train_lora[i, terme2idx[terme]] = 1.0\n\n acc2idx_lora = {acc: i for i, acc in enumerate(proteines_train_lora)}\n print(f' Matrice Y_train_lora: {Y_train_lora.shape} ({Y_train_lora.sum():.0f} annotations positives)')\n\nif UTILISER_LORA and not _lora_cache_trouve:\n import time as _time\n import copy as _copy\n import threading as _threading\n\n # ====================================================================\n # PHASE 1: Installation + chargement du modele\n # ====================================================================\n print('\\n' + '='*60)\n print('[LoRA] PHASE 1: Chargement du modele ESM-2 + LoRA')\n print('='*60)\n\n try:\n from peft import LoraConfig, get_peft_model, TaskType\n from transformers import EsmModel, EsmTokenizer\n except ImportError:\n print(' [PEFT] Installation en cours...')\n import subprocess\n subprocess.check_call(['pip', 'install', '-q', 'peft', 'transformers', 'accelerate'])\n from peft import LoraConfig, get_peft_model, TaskType\n from transformers import EsmModel, EsmTokenizer\n print(' [PEFT] Installation OK')\n\n _t0_chargement = _time.time()\n NOM_MODELE_ESM = 'facebook/esm2_t33_650M_UR50D'\n print(f' [ESM-2] Chargement {NOM_MODELE_ESM}...')\n\n tokenizer_lora = EsmTokenizer.from_pretrained(NOM_MODELE_ESM)\n esm_model_lora = EsmModel.from_pretrained(\n NOM_MODELE_ESM,\n torch_dtype=torch.float16,\n attention_probs_dropout_prob=0.1,\n hidden_dropout_prob=0.1,\n ).to(DEVICE)\n\n config_lora = LoraConfig(\n task_type=TaskType.FEATURE_EXTRACTION,\n r=8, lora_alpha=16, lora_dropout=0.1,\n target_modules=['query', 'key', 'value'],\n modules_to_save=None,\n )\n esm_model_lora = get_peft_model(esm_model_lora, config_lora)\n esm_model_lora.print_trainable_parameters()\n _dt_chargement = _time.time() - _t0_chargement\n print(f' [ESM-2] Modele charge en {_dt_chargement:.0f}s')\n _rapport_vram('(apres chargement ESM-2 + LoRA)')\n\n # ====================================================================\n # PHASE 2: Configuration du fine-tuning\n # ====================================================================\n print('\\n' + '='*60)\n print('[LoRA] PHASE 2: Configuration du fine-tuning (V16)')\n print('='*60)\n\n MAX_SEQ_LEN_LORA = 1022\n N_PROTEINES_LORA = min(5000, len(proteines_train_lora))\n N_EPOCHS_LORA = 2\n\n # V16: Tete de classification (pas de DataParallel)\n class TeteClassificationGO(nn.Module):\n def __init__(self, dim_cachee, n_termes, taux_dropout=0.1):\n super().__init__()\n self.dropout = nn.Dropout(taux_dropout)\n self.classifier = nn.Linear(dim_cachee, n_termes)\n def forward(self, x):\n return self.classifier(self.dropout(x))\n\n tete_classification = TeteClassificationGO(\n dim_cachee=esm_model_lora.config.hidden_size,\n n_termes=len(liste_termes),\n ).to(DEVICE)\n\n # ====================================================================\n # V16: PAS de DataParallel pour le training!\n # ESM-2 650M + DataParallel = OOM sur T4 16GB\n # Solution: gradient checkpointing + accumulation sur GPU 0\n # ====================================================================\n print(' [V16] Configuration SINGLE-GPU training + gradient checkpointing')\n BATCH_SIZE_LORA = 4 # Micro-batch (safe T4 16GB avec grad_ckpt)\n GRAD_ACCUM_STEPS = 4 # Batch effectif = 16\n\n # V16: Activer gradient checkpointing (-40% VRAM, +20% temps)\n esm_model_lora.gradient_checkpointing_enable(\n gradient_checkpointing_kwargs={\"use_reentrant\": False}\n )\n print(f' [V16] Gradient checkpointing active (use_reentrant=False)')\n print(f' [V16] Micro-batch={BATCH_SIZE_LORA}, Accumulation={GRAD_ACCUM_STEPS}, '\n f'Batch effectif={BATCH_SIZE_LORA * GRAD_ACCUM_STEPS}')\n\n # Modele combine (pas de DataParallel)\n class ModeleLoRACombine(nn.Module):\n \"\"\"Combine ESM-2 LoRA + tete GO. Pas de DataParallel (V16).\"\"\"\n def __init__(self, esm, tete):\n super().__init__()\n self.esm = esm\n self.tete = tete\n def forward(self, input_ids, attention_mask):\n out = self.esm(input_ids=input_ids, attention_mask=attention_mask)\n cls = out.last_hidden_state[:, 0, :]\n return self.tete(cls.float())\n\n modele_lora_combine = ModeleLoRACombine(esm_model_lora, tete_classification)\n\n total_steps = (N_PROTEINES_LORA // BATCH_SIZE_LORA) * N_EPOCHS_LORA\n print(f' Proteines: {N_PROTEINES_LORA:,} | Epochs: {N_EPOCHS_LORA} | Steps: {total_steps} | Micro-batch: {BATCH_SIZE_LORA}')\n\n # Optimiseur + scheduler + scaler\n optimizer_lora = torch.optim.AdamW(\n list(modele_lora_combine.parameters()), lr=1e-4, weight_decay=0.01,\n )\n from transformers import get_cosine_schedule_with_warmup\n scheduler_lora = get_cosine_schedule_with_warmup(\n optimizer_lora,\n num_warmup_steps=int(0.1 * total_steps),\n num_training_steps=total_steps,\n )\n _scaler_lora = torch.amp.GradScaler('cuda', enabled=torch.cuda.is_available())\n _rapport_vram('(apres configuration V16)')\n\n # ====================================================================\n # PHASE 3: Entrainement LoRA (SINGLE GPU + GRADIENT CHECKPOINTING)\n # ====================================================================\n print('\\n' + '='*60)\n print(f'[LoRA] PHASE 3: Entrainement LoRA V16 (single-GPU + grad_ckpt)')\n print(f' {N_EPOCHS_LORA} epochs, {N_PROTEINES_LORA:,} proteines, batch_eff={BATCH_SIZE_LORA * GRAD_ACCUM_STEPS}')\n print('='*60)\n\n # Vider le cache GPU avant entrainement\n if torch.cuda.is_available():\n torch.cuda.empty_cache()\n import os as _os_lora\n _os_lora.environ['PYTORCH_ALLOC_CONF'] = 'expandable_segments:True'\n\n modele_lora_combine.train()\n accessions_lora = [acc for acc in list(proteines_train_lora)[:N_PROTEINES_LORA] if acc in acc2idx_lora]\n _t0_train = _time.time()\n _FREQ_PROGRESS = 50 # Afficher progression tous les 50 steps\n\n for epoch in range(N_EPOCHS_LORA):\n perte_epoch = 0.0\n n_steps_epoch = 0\n np.random.shuffle(accessions_lora)\n _t0_epoch = _time.time()\n\n for batch_start in range(0, len(accessions_lora), BATCH_SIZE_LORA):\n batch_accs = accessions_lora[batch_start:batch_start + BATCH_SIZE_LORA]\n\n sequences_batch = [seq_train[acc][:MAX_SEQ_LEN_LORA] for acc in batch_accs]\n inputs = tokenizer_lora(\n sequences_batch, padding=True, truncation=True,\n max_length=MAX_SEQ_LEN_LORA + 2, return_tensors='pt',\n )\n input_ids = inputs['input_ids'].to(DEVICE)\n attention_mask = inputs['attention_mask'].to(DEVICE)\n\n indices_batch = [acc2idx_lora[acc] for acc in batch_accs]\n y_batch = torch.FloatTensor(Y_train_lora[indices_batch]).to(DEVICE)\n\n with torch.amp.autocast('cuda', dtype=torch.float16):\n logits = modele_lora_combine(input_ids=input_ids, attention_mask=attention_mask)\n # V16: diviser par GRAD_ACCUM_STEPS pour normaliser les gradients\n perte = F.binary_cross_entropy_with_logits(logits, y_batch) / GRAD_ACCUM_STEPS\n\n _scaler_lora.scale(perte).backward()\n n_steps_epoch += 1\n\n # V16: mise a jour seulement tous les GRAD_ACCUM_STEPS micro-steps\n if n_steps_epoch % GRAD_ACCUM_STEPS == 0 or (batch_start + BATCH_SIZE_LORA) >= len(accessions_lora):\n _scaler_lora.unscale_(optimizer_lora)\n torch.nn.utils.clip_grad_norm_(list(modele_lora_combine.parameters()), max_norm=1.0)\n _scaler_lora.step(optimizer_lora)\n _scaler_lora.update()\n scheduler_lora.step()\n optimizer_lora.zero_grad()\n\n perte_epoch += perte.item() * GRAD_ACCUM_STEPS # re-scale pour affichage reel\n\n # Progression frequente\n if n_steps_epoch % _FREQ_PROGRESS == 0:\n vitesse = n_steps_epoch * BATCH_SIZE_LORA / (_time.time() - _t0_epoch)\n reste_steps = (len(accessions_lora) // BATCH_SIZE_LORA) - n_steps_epoch\n eta_sec = reste_steps / max(1, n_steps_epoch / (_time.time() - _t0_epoch))\n perte_moy = perte_epoch / n_steps_epoch\n print(f' Epoch {epoch+1}/{N_EPOCHS_LORA} | Step {n_steps_epoch}/{len(accessions_lora)//BATCH_SIZE_LORA} | '\n f'Perte: {perte_moy:.4f} | {vitesse:.0f} prot/s | ETA: {eta_sec/60:.1f}min')\n\n perte_moy = perte_epoch / max(1, n_steps_epoch)\n dt_epoch = _time.time() - _t0_epoch\n print(f' >>> Epoch {epoch+1}/{N_EPOCHS_LORA} TERMINE | Perte: {perte_moy:.4f} | '\n f'Duree: {dt_epoch/60:.1f}min | Vitesse: {len(accessions_lora)/dt_epoch:.0f} prot/s')\n\n _dt_train = _time.time() - _t0_train\n print(f'\\n [LoRA] Entrainement termine en {_dt_train/60:.1f}min '\n f'(moyenne: {N_PROTEINES_LORA * N_EPOCHS_LORA / _dt_train:.0f} prot/s)')\n _rapport_vram('(apres entrainement)')\n\n # ====================================================================\n # PHASE 4: Sauvegarde des poids LoRA\n # ====================================================================\n print('\\n' + '='*60)\n print('[LoRA] PHASE 4: Sauvegarde des poids LoRA')\n print('='*60)\n\n chemin_lora = os.path.join(CHEMIN_CHECKPOINTS, 'esm2_lora_weights.pt')\n os.makedirs(os.path.join(CHEMIN_CHECKPOINTS, 'esm2_lora_adapter'), exist_ok=True)\n esm_model_lora.save_pretrained(os.path.join(CHEMIN_CHECKPOINTS, 'esm2_lora_adapter'))\n torch.save(tete_classification.state_dict(), chemin_lora)\n print(f' Poids sauvegardes: {chemin_lora}')\n\n # ====================================================================\n # PHASE 5: Re-extraction des embeddings (V16: threading multi-GPU)\n # ====================================================================\n print('\\n' + '='*60)\n print('[LoRA] PHASE 5: Re-extraction des embeddings (V16 threading)')\n print('='*60)\n\n # V16: Desactiver gradient checkpointing pour l'extraction (pas besoin, forward only)\n esm_model_lora.gradient_checkpointing_disable()\n print(' [V16] Gradient checkpointing desactive pour extraction')\n\n esm_model_lora.eval()\n features_esm_lora = {}\n\n # V16: Extraction multi-GPU via THREADING (pas DataParallel)\n # Chaque GPU recoit un deepcopy du modele -> pas de replication OOM\n BATCH_SIZE_EXTRACTION = 32 # Par GPU\n\n # Combiner train + test, trier par longueur (minimise padding)\n toutes_sequences_lora = {**seq_train, **seq_test}\n liste_acc_seq_lora = sorted(toutes_sequences_lora.items(), key=lambda x: len(x[1]))\n n_total_lora = len(liste_acc_seq_lora)\n print(f' Total a extraire: {n_total_lora:,} sequences (train+test)')\n\n # V15: Checkpoint progressif - reprendre si interruption\n _debut_extraction = 0\n if os.path.exists(FICHIER_CACHE_LORA_PROGRESSIF):\n try:\n _cp = np.load(FICHIER_CACHE_LORA_PROGRESSIF, allow_pickle=True)\n _accs_cp = list(_cp['accessions'])\n _embs_cp = _cp['embeddings']\n features_esm_lora = dict(zip(_accs_cp, _embs_cp))\n _debut_extraction = len(features_esm_lora)\n print(f' [CHECKPOINT] {_debut_extraction:,} embeddings deja extraits - reprise...')\n del _cp, _accs_cp, _embs_cp\n except Exception as e:\n print(f' [CHECKPOINT] Erreur chargement: {e} - redemarrage de zero')\n features_esm_lora = {}\n _debut_extraction = 0\n\n _t0_extraction = _time.time()\n _FREQ_SAVE = 5000 # Sauvegarde progressive tous les 5000 embeddings\n _n_extraits = _debut_extraction\n\n # --- V16: Fonction d'extraction pour un GPU ---\n def _extraire_sur_gpu(gpu_id, items_batch, modele_esm, tok, result_dict):\n \"\"\"Extrait les embeddings pour un batch de sequences sur un GPU specifique.\"\"\"\n _seqs = [item[1][:MAX_SEQ_LEN_LORA] for item in items_batch]\n _accs = [item[0] for item in items_batch]\n _inputs = tok(\n _seqs, padding=True, truncation=True,\n max_length=MAX_SEQ_LEN_LORA + 2, return_tensors='pt',\n )\n _ids = _inputs['input_ids'].to(f'cuda:{gpu_id}')\n _mask = _inputs['attention_mask'].to(f'cuda:{gpu_id}')\n with torch.no_grad():\n with torch.amp.autocast('cuda', dtype=torch.float16):\n _out = modele_esm(input_ids=_ids, attention_mask=_mask)\n _emb = _out.last_hidden_state[:, 0, :].cpu().numpy()\n for j, acc in enumerate(_accs):\n result_dict[acc] = _emb[j]\n del _ids, _mask, _out, _emb\n\n if _MULTI_GPU and _N_GPUS >= 2:\n # V16: Extraction multi-GPU via threading\n print(f' [V16] Extraction THREADING sur {_N_GPUS} GPUs '\n f'(batch={BATCH_SIZE_EXTRACTION}/GPU, pas de DataParallel)')\n\n # Creer un deepcopy du modele pour chaque GPU supplementaire\n _modeles_gpu = {0: esm_model_lora}\n for gi in range(1, _N_GPUS):\n print(f' [V16] Deepcopy du modele vers GPU {gi}...')\n _m = _copy.deepcopy(esm_model_lora).to(f'cuda:{gi}')\n _m.eval()\n _modeles_gpu[gi] = _m\n _rapport_vram('(apres deepcopy modeles extraction)')\n\n with torch.no_grad():\n for debut in range(_debut_extraction, n_total_lora, BATCH_SIZE_EXTRACTION * _N_GPUS):\n # Repartir les sequences entre les GPUs\n _threads = []\n for gi in range(_N_GPUS):\n _g_debut = debut + gi * BATCH_SIZE_EXTRACTION\n _g_fin = min(_g_debut + BATCH_SIZE_EXTRACTION, n_total_lora)\n if _g_debut >= n_total_lora:\n break\n _items = liste_acc_seq_lora[_g_debut:_g_fin]\n _t = _threading.Thread(\n target=_extraire_sur_gpu,\n args=(gi, _items, _modeles_gpu[gi], tokenizer_lora, features_esm_lora)\n )\n _t.start()\n _threads.append(_t)\n\n # Attendre tous les threads\n for _t in _threads:\n _t.join()\n\n _n_extraits = min(debut + BATCH_SIZE_EXTRACTION * _N_GPUS, n_total_lora)\n\n # Progression\n if _n_extraits % (BATCH_SIZE_EXTRACTION * 5) < BATCH_SIZE_EXTRACTION or _n_extraits == n_total_lora:\n _dt_ext = _time.time() - _t0_extraction\n _n_fait = _n_extraits - _debut_extraction\n vitesse = _n_fait / max(1, _dt_ext)\n _n_reste = n_total_lora - _n_extraits\n eta_min = _n_reste / max(1, vitesse) / 60\n pct = _n_extraits / n_total_lora * 100\n print(f' [{_n_extraits:,}/{n_total_lora:,}] {pct:.0f}% | '\n f'{vitesse:.0f} prot/s | ETA: {eta_min:.0f}min')\n\n # Sauvegarde progressive\n if _n_extraits > 0 and _n_extraits % _FREQ_SAVE < BATCH_SIZE_EXTRACTION * _N_GPUS:\n try:\n _accs_save = list(features_esm_lora.keys())\n _embs_save = np.stack([features_esm_lora[a] for a in _accs_save])\n np.savez_compressed(FICHIER_CACHE_LORA_PROGRESSIF,\n accessions=np.array(_accs_save),\n embeddings=_embs_save)\n del _accs_save, _embs_save\n except Exception:\n pass\n\n # Nettoyer les copies GPU\n for gi in range(1, _N_GPUS):\n del _modeles_gpu[gi]\n gc.collect()\n if torch.cuda.is_available():\n torch.cuda.empty_cache()\n\n else:\n # V16: Extraction single-GPU (pas de DataParallel)\n print(f' [V16] Extraction SINGLE-GPU (batch={BATCH_SIZE_EXTRACTION})')\n\n with torch.no_grad():\n for debut in range(_debut_extraction, n_total_lora, BATCH_SIZE_EXTRACTION):\n fin = min(debut + BATCH_SIZE_EXTRACTION, n_total_lora)\n batch_items = liste_acc_seq_lora[debut:fin]\n batch_accs_ext = [item[0] for item in batch_items]\n batch_seqs_ext = [item[1][:MAX_SEQ_LEN_LORA] for item in batch_items]\n\n inputs = tokenizer_lora(\n batch_seqs_ext, padding=True, truncation=True,\n max_length=MAX_SEQ_LEN_LORA + 2, return_tensors='pt',\n )\n input_ids = inputs['input_ids'].to(DEVICE)\n attention_mask = inputs['attention_mask'].to(DEVICE)\n\n with torch.amp.autocast('cuda', dtype=torch.float16):\n out = esm_model_lora(input_ids=input_ids, attention_mask=attention_mask)\n emb_batch = out.last_hidden_state[:, 0, :].cpu().numpy()\n\n for j, acc in enumerate(batch_accs_ext):\n features_esm_lora[acc] = emb_batch[j]\n\n _n_extraits = fin\n\n # Progression\n if fin % (BATCH_SIZE_EXTRACTION * 5) < BATCH_SIZE_EXTRACTION or fin == n_total_lora:\n _dt_ext = _time.time() - _t0_extraction\n _n_fait = _n_extraits - _debut_extraction\n vitesse = _n_fait / max(1, _dt_ext)\n _n_reste = n_total_lora - _n_extraits\n eta_min = _n_reste / max(1, vitesse) / 60\n pct = _n_extraits / n_total_lora * 100\n print(f' [{_n_extraits:,}/{n_total_lora:,}] {pct:.0f}% | '\n f'{vitesse:.0f} prot/s | ETA: {eta_min:.0f}min')\n\n # Sauvegarde progressive\n if _n_extraits > 0 and _n_extraits % _FREQ_SAVE < BATCH_SIZE_EXTRACTION:\n try:\n _accs_save = list(features_esm_lora.keys())\n _embs_save = np.stack([features_esm_lora[a] for a in _accs_save])\n np.savez_compressed(FICHIER_CACHE_LORA_PROGRESSIF,\n accessions=np.array(_accs_save),\n embeddings=_embs_save)\n del _accs_save, _embs_save\n except Exception:\n pass\n\n _dt_extraction = _time.time() - _t0_extraction\n print(f'\\n [LoRA] Extraction terminee: {n_total_lora:,} embeddings en {_dt_extraction/60:.1f}min '\n f'(moyenne: {n_total_lora / max(1, _dt_extraction):.0f} prot/s)')\n _rapport_vram('(apres extraction)')\n\n # Mettre a jour les dictionnaires\n features_esm = features_esm_lora\n embeddings.update(features_esm)\n print(f' [LoRA] {len(features_esm):,} embeddings mis a jour (features_esm + embeddings)')\n\n # --- V12: Sauvegarder le cache final ---\n print('\\n' + '='*60)\n print('[LoRA] Sauvegarde du cache final')\n print('='*60)\n try:\n os.makedirs(os.path.dirname(FICHIER_CACHE_LORA_FINAL), exist_ok=True)\n acc_list_lora = list(features_esm.keys())\n emb_array_lora = np.stack([features_esm[acc] for acc in acc_list_lora])\n np.save(FICHIER_CACHE_LORA_FINAL, emb_array_lora)\n np.save(FICHIER_CACHE_LORA_ACC, np.array(acc_list_lora))\n taille_mo = os.path.getsize(FICHIER_CACHE_LORA_FINAL) / 1e6\n print(f' Cache final: {FICHIER_CACHE_LORA_FINAL} ({taille_mo:.1f} MB)')\n del emb_array_lora, acc_list_lora\n if os.path.exists(FICHIER_CACHE_LORA_PROGRESSIF):\n os.remove(FICHIER_CACHE_LORA_PROGRESSIF)\n print(f' Checkpoint progressif supprime')\n except Exception as e:\n print(f' [ATTENTION] Erreur sauvegarde cache: {e}')\n\n # Liberation memoire\n del modele_lora_combine\n if 'esm_model_lora' in dir():\n del esm_model_lora\n if 'tete_classification' in dir():\n del tete_classification\n del optimizer_lora, scheduler_lora\n if '_scaler_lora' in dir():\n del _scaler_lora\n if 'features_esm_lora' in dir():\n del features_esm_lora\n gc.collect()\n if torch.cuda.is_available():\n torch.cuda.empty_cache()\n\n _dt_total = _time.time() - _t0_chargement\n print(f'\\n[OK] Module 6b V16 termine en {_dt_total/60:.1f}min total')\n _rapport_vram('(apres nettoyage)')\n\nelse:\n print('[LoRA] Fine-tuning DESACTIVE (UTILISER_LORA = False).')\n\n# Nettoyer les variables locales\nfor _var in ['_proteines_annotees', '_proteines_embedded']:\n if _var in globals():\n del globals()[_var]\n\n# V17d: Liberation Y_train_lora (doublon de Y_train, ~8 Go)\n# Y_train_lora n'est plus necessaire apres le fine-tuning LoRA\nif 'Y_train_lora' in dir():\n del Y_train_lora\n print('[MEM] Y_train_lora libere (~8 Go)')\nif 'proteines_train_lora' in dir():\n del proteines_train_lora\nif 'acc2idx_lora' in dir():\n del acc2idx_lora\ngc.collect()","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T17:52:06.493868Z","iopub.execute_input":"2026-07-31T17:52:06.494162Z","iopub.status.idle":"2026-07-31T17:52:07.219381Z","shell.execute_reply.started":"2026-07-31T17:52:06.494134Z","shell.execute_reply":"2026-07-31T17:52:07.218513Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"import os\nimport subprocess\n\n_NCBI_DIR = \"/kaggle/input/datasets/yimgakevin/ncbi-taxonomy\"\n\nif not os.path.exists(f\"{_NCBI_DIR}/nodes.dmp\"):\n\n print(\"[NCBI] Téléchargement...\")\n\n os.makedirs(_NCBI_DIR, exist_ok=True)\n\n subprocess.run([\n \"wget\",\n \"-q\",\n \"https://ftp.ncbi.nlm.nih.gov/pub/taxonomy/taxdump.tar.gz\",\n \"-O\",\n \"/tmp/taxdump.tar.gz\"\n ], check=True)\n\n subprocess.run([\n \"tar\",\n \"-xzf\",\n \"/tmp/taxdump.tar.gz\",\n \"-C\",\n _NCBI_DIR,\n \"nodes.dmp\",\n \"names.dmp\"\n ], check=True)\n\n os.remove(\"/tmp/taxdump.tar.gz\")\n\n print(\"[OK] Téléchargement terminé.\")\n\nelse:\n\n print(\"[OK] Taxonomy déjà présente.\")\n\nprint(os.listdir(_NCBI_DIR))","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T17:52:07.220671Z","iopub.execute_input":"2026-07-31T17:52:07.221028Z","iopub.status.idle":"2026-07-31T17:52:07.240436Z","shell.execute_reply.started":"2026-07-31T17:52:07.220966Z","shell.execute_reply":"2026-07-31T17:52:07.23955Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module 7 — Ingenierie de caracteristiques\n\nLes embeddings ESM-2 capturent l'information evolutive mais ne donnent pas\nexplicitement la taille de la proteine ou son clade taxonomique. On ajoute\ndonc un vecteur de features complementaires concatene a l'embedding :\n\n- **Features de sequence** : longueur, composition en acides amines, hydrophobicite moyenne, charge nette, poids moleculaire, instabilite.\n- **Features taxonomiques** : encodage one-hot du clade principal (Bacteria, Eukaryota, Archaea, Viridiplantae).\n- **Features de complexite** : entropie de Shannon de la sequence, profil k-mer (k=2,3).\n\nCes features aident le modele a generaliser entre especes, en particulier\npour les taxons sous-representes dans les donnees d'entrainement.\n\n## Principe\n\nLes embeddings ESM-2 capturent l'information evolutive et semantique mais ne donnent pas explicitement la taille de la proteine ou son clade taxonomique. On ajoute donc un vecteur de features complementaires concatene a l'embedding : features de sequence (longueur, composition en acides amines, hydrophobicite moyenne, charge nette, poids moleculaire, instabilite), features taxonomiques (one-hot du clade principal), et features de complexite (entropie de Shannon, profil k-mer).\n\n## Justification\n\nCes features sont ajoutees car elles codent une information physico-chimique et taxonomique qui n'est pas explicite dans les embeddings ESM-2. (1) La longueur et la composition en AA sont des predicteurs connus de localisation subcellulaire et de fonction (e.g., un signal peptide N-terminal est riche en residus hydrophobes). (2) Le clade taxonomique est un signal fort : certaines fonctions sont specifiques aux Bacteria (e.g., flagelle) ou aux Eukaryota (e.g., spliceosome). (3) L'entropie de Shannon capte la complexite de la sequence, utile pour distinguer les proteines des regions repetees. Alternative envisagee et ecartee : utiliser uniquement ESM-2 sans features additionnelles. Le cout marginal de ces features (32 dim supplementaires) est negligeable et le gain attendu est de +1 a +2 points de Fmax selon les experiences publiees (DeepGOPlus utilise des features similaires).","metadata":{"id":"6ValGROrbS6V"}},{"cell_type":"code","source":"# ============================================================================\n# MODULE 7 — INGENIERIE DES CARACTERISTIQUES\n# ============================================================================\n# Features complementaires aux embeddings ESM-2.\n# Reference: Zhu et al. (2023) Nature Methods\n# ============================================================================\n\n# --- 7.1 Features de sequence ---\n# Proprietes physico-chimiques des 20 acides amines standard\n# Kyte & Doolittle (1982) *A simple method for displaying the hydropathic character*, J Mol Biol\n\nprint('[FEATURES] Calcul des features de sequence...')\n\n# Echelle d'hhydrophobicite Kyte-Doolittle (1982)\nhhydrophobicite = { # Dictionnaire AA -> score hhydrophobicite\n 'I': 4.5, 'V': 4.2, 'L': 3.8, 'F': 2.8, 'C': 2.5,\n 'M': 1.9, 'A': 1.8, 'G': -0.4, 'T': -0.7, 'S': -0.8,\n 'W': -0.9, 'Y': -1.3, 'P': -1.6, 'H': -3.2, # Neutres/polaires\n 'E': -3.5, 'Q': -3.5, 'D': -3.5, 'N': -3.5, # Acides/amides\n 'K': -3.9, 'R': -4.5\n} # Fin du dictionnaire\n\n# Poids moleculaires des 20 AA (Da)\npoids_mol = { # Dictionnaire AA -> poids moleculaire\n 'G': 57, 'A': 71, 'V': 99, 'L': 113, 'I': 113, # Petits/hydrophobes\n 'P': 97, 'F': 147, 'W': 186, 'M': 131, # Aromatiques/soufre\n 'S': 87, 'T': 101, 'C': 103, 'Y': 163,\n 'H': 137, 'D': 115, 'N': 114, 'E': 129,\n 'Q': 128, 'K': 146, 'R': 156\n} # Fin du dictionnaire\n\nAA_STANDARD = 'ACDEFGHIKLMNPQRSTVWY' # 20 AA standard\n\ndef calculer_features_sequence(sequence):\n '''\n Calcule les features de sequence pour une proteine.\n\n Parametres:\n sequence: str — sequence d'acides amines\n\n Retourne:\n numpy.ndarray — vecteur de features de sequence\n '''\n features = [] # Liste des features calculees\n\n # 1. Longueur de la sequence (log-transformee pour normaliser)\n features.append(np.log1p(len(sequence))) # log(1 + longueur)\n\n # 2. Composition en acides amines (20 features)\n compteur = Counter(sequence) # Compter chaque AA\n for aa in AA_STANDARD: # Pour les 20 AA\n freq = compteur.get(aa, 0) / max(len(sequence), 1) # Frequence relative\n features.append(freq)\n # 3. Hhydrophobicite moyenne (Kyte-Doolittle)\n valeurs_hydro = [hhydrophobicite.get(aa, 0) for aa in sequence] # Scores par AA\n features.append(np.mean(valeurs_hydro) if valeurs_hydro else 0)\n features.append(np.std(valeurs_hydro) if valeurs_hydro else 0) # Ecart-type\n\n # 4. Poids moleculaire estime\n poids = sum(poids_mol.get(aa, 110) for aa in sequence) # Somme des poids\n features.append(np.log1p(poids)) # Log du poids\n\n # 5. Entropie de Shannon (mesure de complexite/information)\n # Reference: Shannon (1948) *A Mathematical Theory of Communication*\n freq_dict = {aa: compteur.get(aa, 0) / max(len(sequence), 1)\n for aa in AA_STANDARD}\n entropie = -sum(p * np.log2(p + 1e-10) for p in freq_dict.values() if p > 0)\n features.append(entropie) # Entropie en bits\n\n # 6. Fraction de residues charges (K, R, D, E)\n n_charges = sum(compteur.get(aa, 0) for aa in 'KRDE') # AA charges\n features.append(n_charges / max(len(sequence), 1))\n # 7. Fraction de residues aromatiques (F, W, Y)\n n_aromatiques = sum(compteur.get(aa, 0) for aa in 'FWY') # AA aromatiques\n features.append(n_aromatiques / max(len(sequence), 1))\n # 8. Indice d'instabilite (proxy)\n # Les proteines avec beaucoup de D, G, P, S tendent a etre instables\n n_instables = sum(compteur.get(aa, 0) for aa in 'DGPS')\n features.append(n_instables / max(len(sequence), 1))\n return np.array(features, dtype=np.float32) # Vecteur numpy\n\n# Calculer les features pour toutes les proteines\nfeatures_seq = {} # Dictionnaire accession -> features\nfor acc, seq in {**seq_train, **seq_test}.items(): # Train + test\n features_seq[acc] = calculer_features_sequence(seq)\ndim_features_seq = len(next(iter(features_seq.values()))) # Dimension features\nprint(f' Features de sequence: {dim_features_seq} dimensions')\n\n# --- 7.2 Features taxonomiques ---\n# Encodage du clade taxonomique (Bacteria, Eukaryota, Archaea, Autre)\n# Reference: Zhu et al. (2023) Nature Methods — taxonomy-aware prediction\n\nprint('[FEATURES] Features taxonomiques...')\n\n# Mapping taxonomie -> clade (V17: correction critique)\n# PROBLEME PRECEDENT: les plages d'ID NCBI ne correspondent PAS aux clades!\n# Homo sapiens=9606, Mus musculus=10090, S. cerevisiae=4932, Arabidopsis=3702\n# -> aucun ne tombe dans les plages choisies -> tous finissaient en \"Autre\"\n# SOLUTION: telecharger le dump NCBI taxonomy et construire le mapping correct.\n# Reference: NCBI Taxonomy Database (Schoch et al., 2020, NAR)\n# Reference: Federhen (2012) The NCBI Taxonomy database, NAR\ntaxo_to_clade = {} # Dictionnaire taxonomie -> clade\n\n# --- Etape 1: Charger le mapping taxid -> superkingdom depuis NCBI ---\n# Le fichier names.dmp contient les noms, nodes.dmp contient la hierarchie.\n# On remonte la chaine taxonomique jusqu'au superkingdom.\n_taxid_to_superkingdom = {} # Cache: taxid -> superkingdom\n\ndef _charger_taxonomy_ncbi():\n '''Charge le dump NCBI taxonomy et mappe chaque taxid a son superkingdom.\n \n Utilise les fichiers nodes.dmp et names.dmp du NCBI taxdump.\n Si les fichiers ne sont pas disponibles, tente un mapping heuristique\n via les taxid les plus courants dans CAFA-6.\n \n Retourne:\n dict — mapping taxid (int) -> superkingdom (str)\n '''\n import subprocess\n import io\n \n mapping = {} # taxid -> superkingdom\n \n # Chemins possibles pour les fichiers NCBI\n _chemin_nodes = None\n for _p in ['/kaggle/input/ncbi-taxonomy/nodes.dmp',\n '/kaggle/input/taxonomy-dump/nodes.dmp',\n '/kaggle/input/datasets/kevinlagneauyimga/ncbi-taxonomy/nodes.dmp', # FIX V23-J (audit)\n '/kaggle/working/nodes.dmp']:\n if os.path.exists(_p):\n _chemin_nodes = _p\n break\n \n if _chemin_nodes is not None:\n # --- Methode 1: dump NCBI local (exact) ---\n print(f' [TAXONOMY] Fichier NCBI trouve: {_chemin_nodes}')\n # Charger la table parent/enfant depuis nodes.dmp\n # Format: taxid | parent_taxid | rank | ...\n parent_map = {} # taxid -> parent_taxid\n with open(_chemin_nodes, 'r') as f:\n for line in f:\n parts = line.split('|')\n if len(parts) >= 3:\n taxid = int(parts[0].strip())\n parent = int(parts[1].strip())\n rank = parts[2].strip()\n parent_map[taxid] = (parent, rank)\n \n # Superkingdoms NCBI: 2=Bacteria, 2759=Eukaryota, 2157=Archaea, 10239=Viruses\n SUPERKINGDOMS = {2: 'Bacteria', 2759: 'Eukaryota', 2157: 'Archaea', 10239: 'Viruses'}\n \n # Pour chaque taxid, remonter jusqu'au superkingdom\n def _trouver_superkingdom(tid):\n if tid in SUPERKINGDOMS:\n return SUPERKINGDOMS[tid]\n if tid in mapping:\n return mapping[tid]\n # Remonter la chaine (max 50 niveaux pour eviter boucle)\n chaine = []\n courant = tid\n for _ in range(50):\n if courant in SUPERKINGDOMS:\n # Mettre en cache toute la chaine\n for t in chaine:\n mapping[t] = SUPERKINGDOMS[courant]\n return SUPERKINGDOMS[courant]\n if courant in mapping:\n sk = mapping[courant]\n for t in chaine:\n mapping[t] = sk\n return sk\n if courant not in parent_map:\n return None\n chaine.append(courant)\n courant = parent_map[courant][0]\n return None\n \n # Pre-calculer pour les taxids du dataset\n taxids_uniques = set()\n for _, row in df_taxo.iterrows():\n try:\n taxids_uniques.add(int(row['taxonomie']))\n except (ValueError, TypeError):\n pass\n \n for tid in taxids_uniques:\n sk = _trouver_superkingdom(tid)\n if sk is not None:\n mapping[tid] = sk\n \n print(f' [TAXONOMY] Mapping NCBI: {len(mapping):,} taxids -> superkingdom')\n return mapping\n \n else:\n # --- Methode 2: telecharger les taxids manquants via E-utilities ---\n print(' [TAXONOMY] Pas de dump NCBI local — telechargement via E-utilities...')\n \n # Collecter les taxids uniques du dataset\n taxids_uniques = set()\n for _, row in df_taxo.iterrows():\n try:\n taxids_uniques.add(int(row['taxonomie']))\n except (ValueError, TypeError):\n pass\n \n if not taxids_uniques:\n print(' [TAXONOMY] Aucun taxid valide — fallback heuristique')\n return mapping\n \n # Batch query via E-utilities (max 500 par requete)\n taxid_list = sorted(taxids_uniques)\n for batch_start in range(0, len(taxid_list), 500):\n batch = taxid_list[batch_start:batch_start + 500]\n ids_str = ','.join(str(t) for t in batch)\n try:\n url = f'https://eutils.ncbi.nlm.nih.gov/entrez/eutils/efetch.fcgi?db=taxonomy&id={ids_str}'\n import urllib.request\n resp = urllib.request.urlopen(url, timeout=30)\n xml_content = resp.read().decode('utf-8')\n \n # Parser le XML pour extraire LineageEx -> superkingdom\n import xml.etree.ElementTree as ET\n root = ET.fromstring(xml_content)\n for taxon in root.findall('.//Taxon'):\n taxid = int(taxon.find('TaxId').text)\n lineage = taxon.find('LineageEx')\n if lineage is not None:\n for item in lineage.findall('Taxon'):\n rank = item.find('Rank')\n sci_name = item.find('ScientificName')\n if rank is not None and rank.text == 'superkingdom':\n if sci_name is not None:\n name = sci_name.text\n # Normaliser\n if 'Bacteria' in name:\n mapping[taxid] = 'Bacteria'\n elif 'Eukaryot' in name:\n mapping[taxid] = 'Eukaryota'\n elif 'Archaea' in name:\n mapping[taxid] = 'Archaea'\n break\n except Exception as e:\n print(f' [TAXONOMY] Erreur E-utilities batch: {e}')\n break\n \n print(f' [TAXONOMY] Mapping E-utilities: {len(mapping):,} taxids -> superkingdom')\n \n # --- Methode 3: fallback heuristique pour les taxids restants ---\n # Mapping des organismes les plus courants dans CAFA-6\n # Source: CAFA-6 dataset statistics\n _HEURISTIQUE = {\n 9606: 'Eukaryota', # Homo sapiens\n 10090: 'Eukaryota', # Mus musculus\n 4932: 'Eukaryota', # Saccharomyces cerevisiae\n 3702: 'Eukaryota', # Arabidopsis thaliana\n 7227: 'Eukaryota', # Drosophila melanogaster\n 6239: 'Eukaryota', # Caenorhabditis elegans\n 7955: 'Eukaryota', # Danio rerio (zebrafish)\n 8364: 'Eukaryota', # Xenopus tropicalis\n 10116: 'Eukaryota', # Rattus norvegicus\n 9913: 'Eukaryota', # Bos taurus\n 9031: 'Eukaryota', # Gallus gallus\n 9823: 'Eukaryota', # Sus scrofa\n 9615: 'Eukaryota', # Canis lupus familiaris\n 4896: 'Eukaryota', # Schizosaccharomyces pombe\n 5141: 'Eukaryota', # Neurospora crassa\n 367110: 'Eukaryota', # Plasmodium falciparum\n 5833: 'Eukaryota', # Plasmodium falciparum (alt)\n 5855: 'Eukaryota', # Toxoplasma gondii\n 559292: 'Eukaryota', # Saccharomyces cerevisiae S288C\n 285: 'Eukaryota', # Ascomycota (fungi)\n 4751: 'Eukaryota', # Fungi\n 33208: 'Eukaryota', # Metazoa\n 33090: 'Eukaryota', # Viridiplantae\n 2759: 'Eukaryota', # Eukaryota (root)\n # Bacteria\n 2: 'Bacteria', # Bacteria (root)\n 511145: 'Bacteria', # Escherichia coli K-12\n 562: 'Bacteria', # Escherichia coli\n 1423: 'Bacteria', # Bacillus subtilis\n 1392: 'Bacteria', # Bacillus anthracis\n 1773: 'Bacteria', # Mycobacterium tuberculosis\n 1280: 'Bacteria', # Staphylococcus aureus\n 1313: 'Bacteria', # Streptococcus pneumoniae\n 1351: 'Bacteria', # Enterococcus faecalis\n 83333: 'Bacteria', # Mycobacterium tuberculosis H37Rv\n 224308: 'Bacteria', # Bacillus subtilis subsp. subtilis\n 160488: 'Bacteria', # Pseudomonas aeruginosa PAO1\n 208964: 'Bacteria', # Pseudomonas putida\n 287: 'Bacteria', # Pseudomonas\n # Archaea\n 2157: 'Archaea', # Archaea (root)\n 224325: 'Archaea', # Archaea (misc)\n 2172: 'Archaea', # Methanobacterium\n 2188: 'Archaea', # Methanococcus\n # V17c: Clades viraux\n 10239: 'Viruses', # Viruses (root)\n 2559587: 'Viruses', # Riboviria\n 186616: 'Viruses', # Nidovirales\n 11157: 'Viruses', # Caudovirales\n 28883: 'Viruses', # Mononegavirales\n 694002: 'Viruses', # Picornavirales\n 2497565: 'Viruses', # Stellavirales\n 2732406: 'Viruses', # Timlovirales\n }\n \n for tid in taxids_uniques:\n if tid not in mapping:\n if tid in _HEURISTIQUE:\n mapping[tid] = _HEURISTIQUE[tid]\n else:\n mapping[tid] = 'Autre' # Inconnu\n \n print(f' [TAXONOMY] Mapping total (E-utilities + heuristique): {len(mapping):,} taxids')\n return mapping\n\n_taxid_to_superkingdom = _charger_taxonomy_ncbi()\n\n# Appliquer le mapping (TRAIN)\nfor _, row in df_taxo.iterrows():\n try:\n tax_num = int(row['taxonomie'])\n clade = _taxid_to_superkingdom.get(tax_num, 'Autre')\n taxo_to_clade[row['proteine']] = clade\n except (ValueError, TypeError):\n taxo_to_clade[row['proteine']] = 'Autre'\n\n# V21 FIX #15: Appliquer le mapping aussi aux protéines TEST\n# Avant, df_test_taxo était chargé (Module 4) mais jamais utilisé → toutes les\n# protéines test recevaient le one-hot [0,0,0,1] (clade 'Autre').\nif 'df_test_taxo' in globals() and df_test_taxo is not None:\n print(f' [V21-FIX#15] Mapping taxonomie pour {len(df_test_taxo):,} protéines test...')\n n_test_mapped = 0\n n_test_autre = 0\n for _, row in df_test_taxo.iterrows():\n try:\n tax_num = int(row['taxonomie'])\n clade = _taxid_to_superkingdom.get(tax_num, 'Autre')\n taxo_to_clade[row['proteine']] = clade\n if clade != 'Autre':\n n_test_mapped += 1\n else:\n n_test_autre += 1\n except (ValueError, TypeError):\n taxo_to_clade[row['proteine']] = 'Autre'\n n_test_autre += 1\n print(f' {n_test_mapped:,} protéines test mappées à un clade connu')\n print(f' {n_test_autre:,} protéines test -> clade \"Autre\"')\nelse:\n print(f' [ATTENTION] df_test_taxo non disponible — test = \"Autre\" partout')\n\n# Statistiques du mapping (verification)\nfrom collections import Counter as _Counter\n_clade_counts = _Counter(taxo_to_clade.values())\nprint(f' Distribution des clades:')\nfor clade, count in _clade_counts.most_common():\n pct = 100 * count / max(len(taxo_to_clade), 1)\n print(f' {clade}: {count:,} ({pct:.1f}%)')\n# Encodage one-hot des clades\nCLADES = ['Bacteria', 'Eukaryota', 'Archaea', 'Autre'] # Liste des clades\nfeatures_taxo = {} # Dictionnaire accession -> features taxonomiques\n\nfor acc in {**seq_train, **seq_test}: # Pour toutes les proteines\n clade = taxo_to_clade.get(acc, 'Autre') # Clade de la proteine\n onehot = [1.0 if clade == c else 0.0 for c in CLADES] # Encodage one-hot\n features_taxo[acc] = np.array(onehot, dtype=np.float32) # Vecteur numpy\n\nprint(f' Features taxonomiques: {len(CLADES)} dimensions (one-hot)')\n\n# --- 7.3 Concatenation des features ---\n# Features totales = ESM-2 + sequence + taxonomie\nprint('[FEATURES] Concatenation...')\n\nfeatures_totales = {} # Dictionnaire accession -> features completes\nfor acc in embeddings: # Pour chaque proteine avec embedding\n esm_emb = embeddings[acc] # Embedding ESM-2 (1280-d)\n f_seq = features_seq.get(acc, np.zeros(dim_features_seq, dtype=np.float32)) # Seq features\n f_taxo = features_taxo.get(acc, np.zeros(len(CLADES), dtype=np.float32)) # Taxo features\n # Concatener les trois types de features\n features_totales[acc] = np.concatenate([esm_emb, f_seq, f_taxo])\ndim_totale = len(next(iter(features_totales.values()))) # Dimension totale\nprint(f' Dimension totale: {dim_totale} (ESM2:{ESM2_DIM} + Seq:{dim_features_seq} + Taxo:{len(CLADES)})')\n\n# V17c-CRITIQUE: Liberer les dictionnaires intermediaires qui ne sont plus necessaires.\n# features_totales contient deja les embeddings ESM-2, donc le dict embeddings est\n# un doublon complet (~0.4 Go). features_seq et features_taxo sont aussi integres\n# dans features_totales. On garde SEULEMENT features_totales (necessaire pour\n# Module 8 et la prediction test Module 20).\ndel embeddings # Libere ~0.4 Go (doublon via features_totales)\ndel features_seq # Libere ~0.00 Go (deja dans features_totales)\ndel features_taxo # Libere ~0.15 Go (deja dans features_totales)\ngc.collect()\nprint(' [MEM] embeddings, features_seq, features_taxo liberes (doublons de features_totales)')\n\nprint('[OK] Module 7: Features calculees')\n","metadata":{"id":"ZblYkLlvbS6V","trusted":true,"execution":{"iopub.status.busy":"2026-07-31T17:52:07.24172Z","iopub.execute_input":"2026-07-31T17:52:07.242084Z","iopub.status.idle":"2026-07-31T17:53:07.106332Z","shell.execute_reply.started":"2026-07-31T17:52:07.242054Z","shell.execute_reply":"2026-07-31T17:53:07.105571Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module 8 — Construction du dataset PyTorch\n\nConstruction des matrices `X_train` (features) et `Y_train` (etiquettes GO\nbinaires) et du dataset PyTorch associe. Les etiquettes sont propagees via\nle True Path Rule (Module 5) : si une proteine est annotee avec un terme\nGO, elle herite automatiquement de tous ses ancetres ontologiques.\n\n## Principe\n\nLe dataset PyTorch sur mesure encapsule la logique de chargement des embeddings ESM-2 pre-calcules (format .npz pour acces rapide par index), des features complementaires et des labels multi-labels (matrice binaire sparse proteine x terme GO). Le dataset implemente `__getitem__` qui retourne un dictionnaire (embedding, features, labels, mask) pour une proteine donnee, et utilise un DataLoader avec `num_workers > 0` pour le chargement parallele asynchrone.\n\n## Justification\n\nLe lazy loading (chargement d'un embedding a la fois) est indispensable car la matrice complete (140 000 proteines x 1280 dim float32) represente ~700 Mo, ce qui tient en RAM mais limiterait la memoire disponible pour le modele. Le format .npz est preferable a .npy car il permet un acces par cle (une cle par proteine), ce qui evite de charger toute la matrice en memoire. Le masque `mask` est necessaire car certains termes GO ne sont pas evalues pendant l'entrainement (terms laisses de cote par curriculum learning, Module 15). L'alternative HuggingFace datasets a ete ecartee car elle ajoute une dependance lourde pour un benefice marginal dans notre contexte.","metadata":{"id":"K-IhvAwvbS6W"}},{"cell_type":"code","source":"# ============================================================================\n# MODULE 8 — CONSTRUCTION DU DATASET PYTORCH\n# ============================================================================\n# Construit les matrices X (features) et Y (etiquettes GO).\n# Reference: Paszke et al. (2019) PyTorch, NeurIPS\n#\n# FIX V17e (CRITIQUE):\n# Module 7 supprime explicitement 'embeddings' (del embeddings) a la fin\n# pour liberer de la RAM (~0.4 Go), puisque ces donnees sont deja integrees\n# dans features_totales. Or Module 8 tentait d'appeler embeddings.keys()\n# APRES cette suppression -> NameError.\n# CORRECTION: utiliser features_totales.keys() a la place, qui contient\n# exactement les memes proteines (features_totales est construit en iterant\n# sur embeddings dans Module 7, donc leurs cles sont identiques).\n# ============================================================================\n\n# --- 8.1 Identifier les proteines avec annotations et embeddings ---\n# On ne garde que les proteines qui ont a la fois des annotations GO\n# et des embeddings ESM-2 valides\nprint('[DATASET] Construction (V20: sparse + filtrage termes rares)...')\n\n# Ensemble des proteines avec annotations\nproteines_annotees = set(annot_prop.keys()) # Proteines annotees (propagees)\n\n# Ensemble des proteines avec embedding\n# FIX V17e: 'embeddings' a ete supprime dans Module 7 (del embeddings).\n# features_totales contient exactement les memes proteines (Module 7 l'a\n# construit en iterant sur embeddings), donc features_totales.keys() est\n# le remplacement correct.\nproteines_embedded = set(features_totales.keys()) # Proteines avec embedding\n\n# Intersection: proteines utilisables pour l'entrainement\nproteines_train = proteines_annotees.intersection(proteines_embedded)\nproteines_train = sorted(list(proteines_train)) # Liste triee\n\nprint(f' Proteines annotees: {len(proteines_annotees):,}')\nprint(f' Proteines avec embedding: {len(proteines_embedded):,}')\nprint(f' Proteines utilisables: {len(proteines_train):,}')\n\n# ============================================================================\n# V20 FIX #5: Filtrer les termes GO rares\n# ============================================================================\n# ProtBoost (CAFA-5 top 2) garde 5 000-13 000 termes, pas 26 000.\n# Les termes rares (peu de protéines annotées) n'apportent rien au Fmax\n# (trop peu d'exemples positifs pour être appris) et gonflent la mémoire.\nSEUIL_TERMES_RARES = 50 # Garder termes avec >= 50 protéines annotées\n\n# Compter annotations par terme (sur annotations propagées)\nprint(f' [FIX #5] Filtrage termes GO (seuil >= {SEUIL_TERMES_RARES} protéines)...')\ncompteur_termes = {} # terme -> nombre de protéines annotées\nfor termes in annot_prop.values(): # Pour chaque protéine\n for t in termes: # Pour chaque terme de cette protéine\n compteur_termes[t] = compteur_termes.get(t, 0) + 1\nn_termes_avant = len(compteur_termes)\nprint(f' Termes uniques avant filtrage: {n_termes_avant:,}')\n\n# Filtrer : ne garder que les termes fréquents\ntermes_frequents = sorted([t for t, n in compteur_termes.items()\n if n >= SEUIL_TERMES_RARES])\nprint(f' Termes fréquents après filtrage: {len(termes_frequents):,} '\n f'({100 * len(termes_frequents) / max(1, n_termes_avant):.1f}% conservé)')\n\n# --- Reconstruction du vocabulaire et des structures dépendantes ---\n# ATTENTION: terme2idx, liste_termes, parents_go, enfants_go, vec_ia, vec_prof,\n# parents_par_idx (construit plus loin), annot_prop ( déjà filtré implicitement)\n# doivent être recalés sur le nouveau vocabulaire.\n# Stratégie: on garde les structures DAG complètes et on filtre à l'indexation.\n\nancien_terme2idx = terme2idx # Sauvegarder pour le recalage\nterme2idx = {t: i for i, t in enumerate(termes_frequents)} # Nouveau mapping\nliste_termes = termes_frequents # Nouvelle liste\nn_nouveaux_termes = len(liste_termes)\nprint(f' Nouveau terme2idx: {n_nouveaux_termes:,} termes')\n\n# Recaler vec_ia (IA par terme) sur le nouveau vocabulaire\nif vec_ia is not None and len(vec_ia) == len(ancien_terme2idx):\n nouveau_vec_ia = np.zeros(n_nouveaux_termes, dtype=vec_ia.dtype)\n for t, new_idx in terme2idx.items():\n old_idx = ancien_terme2idx.get(t)\n if old_idx is not None:\n nouveau_vec_ia[new_idx] = vec_ia[old_idx]\n vec_ia = nouveau_vec_ia\n print(f' vec_ia recalé: {vec_ia.shape}')\n\n# Recaler vec_prof (profondeurs par terme) sur le nouveau vocabulaire\nif vec_prof is not None and len(vec_prof) == len(ancien_terme2idx):\n nouveau_vec_prof = np.zeros(n_nouveaux_termes, dtype=vec_prof.dtype)\n for t, new_idx in terme2idx.items():\n old_idx = ancien_terme2idx.get(t)\n if old_idx is not None:\n nouveau_vec_prof[new_idx] = vec_prof[old_idx]\n vec_prof = nouveau_vec_prof\n print(f' vec_prof recalé: {vec_prof.shape}')\n\n# Recaler parents_go et enfants_go (dict terme -> liste de termes)\n# On garde seulement les termes fréquents et leurs parents fréquents\nif 'parents_go' in globals():\n nouveau_parents_go = {}\n for t, parents in parents_go.items():\n if t in terme2idx: # Terme fréquent\n parents_frequents = [p for p in parents if p in terme2idx]\n if parents_frequents:\n nouveau_parents_go[t] = parents_frequents\n parents_go = nouveau_parents_go\n print(f' parents_go recalé: {len(parents_go):,} termes avec parents')\n\nif 'enfants_go' in globals():\n nouveau_enfants_go = {}\n for t, enfants in enfants_go.items():\n if t in terme2idx: # Terme fréquent\n enfants_frequents = [e for e in enfants if e in terme2idx]\n if enfants_frequents:\n nouveau_enfants_go[t] = enfants_frequents\n enfants_go = nouveau_enfants_go\n print(f' enfants_go recalé: {len(enfants_go):,} termes avec enfants')\n\n# Libérer structures temporaires\ndel compteur_termes, termes_frequents, ancien_terme2idx\ngc.collect()\nprint(f' [FIX #5] Filtrage termes rares terminé: {n_nouveaux_termes:,} termes conservés')\n\n# --- 8.2 Construire la matrice X (features) ---\n# X[i, :] = vecteur de features de la i-eme proteine\nX_train = np.zeros((len(proteines_train), dim_totale), dtype=np.float32) # Matrice X\n\nfor i, acc in enumerate(proteines_train): # Pour chaque proteine\n X_train[i] = features_totales.get(acc, np.zeros(dim_totale, dtype=np.float32))\n# Normaliser les features (StandardScaler: moyenne=0, ecart-type=1)\n# Important pour la convergence du reseau de neurones\n# V17c: scaler supprime ici — reporte au Module 19 (fit par fold)\nX_train = X_train.astype(np.float32) # V17c: pas de scaling global, voir Module 19\nprint(f' X_train shape: {X_train.shape}')\nprint(f' X_train mean: {X_train.mean():.4f}') # V17c: brut, normalisation par fold\nprint(f' X_train std: {X_train.std():.4f}') # V17c: brut, normalisation par fold\n\n# ============================================================================\n# V20 FIX #1: Construction SPARSE de Y_train (CSR)\n# ============================================================================\n# Avant (V19) : Y_train dense float32 = 142k × 26k × 4 = 14,7 Go\n# Maintenant (V20) : Y_train sparse CSR ~ 50-100 Mo (densité ~0,05%)\n# Les gagnants CAFA-6 utilisent explicitement des matrices sparse.\nimport scipy.sparse as sp # Bibliothèque de matrices creuses\n\nprint(f' [FIX #1] Construction sparse de Y_train (CSR)...')\nprint(f' Shape: ({len(proteines_train)}, {len(liste_termes)})')\n\n# Construction des coordonnées (rows, cols) des valeurs non-nulles\nrows_list = [] # Indices de protéines\ncols_list = [] # Indices de termes\nfor i, acc in enumerate(proteines_train): # Pour chaque protéine\n termes = annot_prop.get(acc, set()) # Termes GO (propagés)\n for terme in termes: # Pour chaque terme\n if terme in terme2idx: # Si terme dans le nouveau vocabulaire filtré\n rows_list.append(i)\n cols_list.append(terme2idx[terme])\n\n# Construction de la matrice sparse CSR\nif rows_list:\n Y_train = sp.csr_matrix(\n (np.ones(len(rows_list), dtype=np.float32),\n (np.array(rows_list, dtype=np.int64),\n np.array(cols_list, dtype=np.int64))),\n shape=(len(proteines_train), len(liste_termes)),\n dtype=np.float32\n )\nelse:\n # Cas dégénéré (ne devrait pas arriver)\n Y_train = sp.csr_matrix(\n (len(proteines_train), len(liste_termes)), dtype=np.float32\n )\n\n# Libérer les listes temporaires\ndel rows_list, cols_list\ngc.collect()\n\n# Statistiques\nnb_positifs_total = Y_train.nnz # Nombre de non-zéros\ndensite = nb_positifs_total / max(1, Y_train.shape[0] * Y_train.shape[1]) * 100\nnb_positifs_par_terme = np.asarray(Y_train.sum(axis=0)).flatten() # (C,)\nprint(f' Y_train sparse: shape={Y_train.shape}, nnz={nb_positifs_total:,}, '\n f'densité={densite:.4f}%, taille={Y_train.data.nbytes / 1e6:.1f} Mo')\nprint(f' Positifs moyens/terme: {nb_positifs_par_terme.mean():.1f}')\nratio_pos_neg = (len(proteines_train) - nb_positifs_par_terme) / np.maximum(nb_positifs_par_terme, 1)\nprint(f' Ratio neg/pos moyen: {ratio_pos_neg.mean():.0f}:1')\n\n# V20: Y_train est désormais un scipy.sparse.csr_matrix.\n# Toutes les fonctions en aval doivent utiliser:\n# - Y_train[idx] → renvoie une sparse matrix (vue, pas copie)\n# - Y_train[idx].toarray() → pour repasser en dense sur un batch\n# - Y_train.nnz → nombre d'annotations non-nulles\n# Cf. Module 16 (entraînement) et Module 17 (métriques) pour les adaptations.\n\n# --- 8.4 Construire le mapping proteine -> groupe taxonomique ---\n# Pour GroupKFold: les proteines du meme groupe (espece) restent ensemble\n# Ceci evite la fuite d'information entre especes apparentees\ngroupes_taxo = [] # Liste des groupes pour chaque proteine\ndf_taxo_dict = dict(zip(df_taxo['proteine'], df_taxo['taxonomie'])) # Dict rapide\n\nfor acc in proteines_train: # Pour chaque proteine\n tax_id = df_taxo_dict.get(acc, 'inconnu') # ID taxonomique\n groupes_taxo.append(str(tax_id)) # Ajouter comme groupe\n\ngroupes_taxo = np.array(groupes_taxo) # Convertir en numpy array\nprint(f' Groupes taxonomiques: {len(np.unique(groupes_taxo)):,} especes')\n\n# --- 8.5 Creer le Dataset PyTorch ---\n# On utilise un Dataset procedurale (pas de classe, juste des fonctions)\n\n# FIX V23 (audit): creer_dataset supprime (jamais appele)\nprint(f' [V23-FIX#1] creer_dataset skipped (Y_train sparse, TensorDataset incompatible)')\nprint(f' [V23-FIX#1] Module 16 charge les batches directement depuis Y_train_fold sparse CSR')\ngc.collect()\n\n# --- 8.6 Masques de Curriculum Learning ---\n# Pour chaque phase du curriculum, on cree un masque qui selectionne\n# les termes GO selon leur profondeur dans le DAG\n# Phase 1: profondeur <= 2, Phase 2: profondeur <= 4, Phase 3: tous\n\nmasques_curriculum = [] # Liste des masques par phase\nfor phase in CURRICULUM_PHASES: # Pour chaque phase\n prof_max = phase['prof_max'] # Profondeur max de la phase\n # Masque: 1 si profondeur du terme <= prof_max, 0 sinon\n masque = np.array([1.0 if vec_prof[i] <= prof_max else 0.0\n for i in range(len(liste_termes))], dtype=np.float32)\n masques_curriculum.append(masque) # Ajouter le masque\n nb_actifs = int(masque.sum()) # Nombre de termes actifs\n print(f' {phase[\"nom\"]}: {nb_actifs:,} termes actifs')\n\n# V17d: Reduire features_totales aux proteines TEST uniquement\n# (les proteines train sont deja dans X_train, pas besoin de les garder\n# aussi dans features_totales -> economie memoire significative)\n_acces_test = set(seq_test.keys())\n_features_totales_test = {acc: v for acc, v in features_totales.items() if acc in _acces_test}\ndel features_totales\nfeatures_totales = _features_totales_test\ndel _features_totales_test, _acces_test\ngc.collect()\nprint(f' [MEM] features_totales reduit aux proteines test uniquement ({len(features_totales):,} proteines)')\n\n# V17c: Liberer les variables intermediaires plus necessaires\n# V20: ne pas supprimer nb_positifs_par_terme et ratio_pos_neg (encore utiles)\nfor _var in ['proteines_annotees', 'proteines_embedded', 'df_taxo_dict']:\n if _var in globals():\n del globals()[_var]\ngc.collect()\n\nprint('[OK] Module 8: Dataset construit (V20: sparse + termes filtrés)')\n\n# V20: Diagnostic memoire (Y_train est désormais sparse)\nimport psutil\n_ram_go = psutil.Process().memory_info().rss / 1e9\nprint(f' [MEM] RAM utilisee apres Module 8: {_ram_go:.1f} Go')\nprint(f' [MEM] Y_train sparse: {Y_train.data.nbytes / 1e6:.1f} Mo '\n f'(shape={Y_train.shape}, nnz={Y_train.nnz:,})')\nprint(f' [MEM] Gain vs V19 (dense): '\n f'~{(Y_train.shape[0] * Y_train.shape[1] * 4 - Y_train.data.nbytes) / 1e9:.1f} Go économisés')\nif 'features_totales' in globals():\n _ft_go = sum(v.nbytes for v in features_totales.values()) / 1e9\n print(f' [MEM] features_totales (test only): {_ft_go:.2f} Go ({len(features_totales):,} proteines)')\n\n# --- 8.7 Pre-calcul des paires co-annotees pour la perte contrastive (Module 14 V18) ---\n# La co-annotation entre termes GO est une propriete STATIQUE des donnees d'entrainement.\n# On la calcule une seule fois ici (apres construction de Y_train) pour eviter\n# de recreer la matrice CxC a chaque batch (OOM sur GPU).\n# Reference: Module 14 V18 — scipy.sparse + seuil co-occurrence\n# V20: Y_train est désormais sparse CSR. precalculer_paires_co_annotees accepte\n# nativement les sparse (elle fait sp.csr_matrix(Y_train_complet) en interne).\n# FIX V23-D (audit): appel deplace en Module 14 (apres la def de la fonction)\nPAIRES_CO_ANNOTEES = None # placeholder, sera ecrase en Module 14\nprint(f' [Module 8] precalculer_paires_co_annotees non definie — PAIRES_CO_ANNOTEES=None')","metadata":{"id":"hCFMIgFDbS6W","trusted":true,"execution":{"iopub.status.busy":"2026-07-31T17:53:07.107564Z","iopub.execute_input":"2026-07-31T17:53:07.107845Z","iopub.status.idle":"2026-07-31T17:53:13.517783Z","shell.execute_reply.started":"2026-07-31T17:53:07.107824Z","shell.execute_reply":"2026-07-31T17:53:13.517021Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# AMELIORATION V29 - VALIDATION DES INVARIANTS APRES MODULE 8.\ndef budget_dense(n_rows, n_cols, dtype=np.float32, limit_gib=1.5, label=\"allocation dense\"):\n \"\"\"Refuse une densification au-delà du budget RAM défini pour Kaggle.\"\"\"\n gib = n_rows * n_cols * np.dtype(dtype).itemsize / 2**30\n assert gib <= limit_gib, f\"{label}: {gib:.2f} GiB dépasse {limit_gib:.2f} GiB\"\n return gib\n\ndef valider_etat_cafa(X, Y, accessions, termes, graph, ia, depths):\n \"\"\"Vérifie les invariants avant entraînement; Y est obligatoirement une CSR.\"\"\"\n assert X.ndim == 2 and X.dtype == np.float32 and np.isfinite(X).all()\n assert sp.isspmatrix_csr(Y)\n assert X.shape[0] == len(accessions)\n assert X.shape[0] == Y.shape[0]\n assert Y.shape[1] == len(termes) == len(ia) == len(depths)\n assert len(accessions) == len(set(accessions)) and len(termes) == len(set(termes))\n assert nx.is_directed_acyclic_graph(graph) and np.isfinite(Y.data).all()\n print(f\"[V27] X={X.shape}, Y.nnz={Y.nnz:,}, densité={Y.nnz / np.prod(Y.shape):.3e}\")\n\nprint(\"[V27] Validation des invariants...\")\nif all(name in globals() for name in (\"X_train\", \"Y_train\", \"proteines_train\", \"liste_termes\", \"go_dag\", \"vec_ia\", \"vec_prof\")):\n valider_etat_cafa(X_train, Y_train, proteines_train, liste_termes, go_dag, vec_ia, vec_prof)\nelse:\n print(\"[V27] Validation différée: exécuter après les modules DAG et dataset.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T17:53:13.518642Z","iopub.execute_input":"2026-07-31T17:53:13.518979Z","iopub.status.idle":"2026-07-31T17:53:13.787735Z","shell.execute_reply.started":"2026-07-31T17:53:13.518958Z","shell.execute_reply":"2026-07-31T17:53:13.787023Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"\n# MODULE 9 — STRATIFICATION TAXONOMIQUE + SPLITS HOMOLOGY-SAFE\nimport os\nimport numpy as np\nimport pandas as pd\nfrom sklearn.model_selection import GroupKFold\nfrom pathlib import Path\n\nHOMOLOGY_CLUSTER_PATH = os.environ.get(\"CAFA6_HOMOLOGY_CLUSTERS\", \"\")\nREQUIRE_HOMOLOGY_FOR_FINAL_CV = False\nN_FOLDS = globals().get(\"N_FOLDS\", 5)\n\nclass _UnionFind:\n def __init__(self, n):\n self.parent = np.arange(n, dtype=np.int64)\n self.rank = np.zeros(n, dtype=np.int8)\n\n def find(self, x):\n while self.parent[x] != x:\n self.parent[x] = self.parent[self.parent[x]]\n x = self.parent[x]\n return x\n\n def union(self, a, b):\n a, b = self.find(a), self.find(b)\n if a == b:\n return\n if self.rank[a] < self.rank[b]:\n a, b = b, a\n self.parent[b] = a\n if self.rank[a] == self.rank[b]:\n self.rank[a] += 1\n\n\ndef charger_clusters_homologie(path, accessions):\n path = Path(path)\n if not path.is_file():\n raise FileNotFoundError(f\"Homology cluster file not found: {path}\")\n raw = pd.read_csv(path, sep=\"\\t\", header=None, comment=\"#\", dtype=str)\n if raw.shape[1] < 2:\n raise ValueError(\"Homology cluster file must have at least two columns.\")\n raw = raw.iloc[:, :2]\n raw.columns = [\"cluster\", \"protein\"]\n known = set(map(str, accessions))\n raw = raw[raw.protein.isin(known)]\n mapping = dict(zip(raw.protein, raw.cluster))\n return np.asarray([mapping.get(str(acc), f\"singleton::{acc}\") for acc in accessions], dtype=object)\n\n\ndef groupes_fermeture_taxonomie_homologie(accessions, taxons, clusters):\n n = len(accessions)\n uf = _UnionFind(n)\n first_taxon, first_cluster = {}, {}\n for i, (taxon, cluster) in enumerate(zip(map(str, taxons), map(str, clusters))):\n for key, registry in ((taxon, first_taxon), (cluster, first_cluster)):\n previous = registry.setdefault(key, i)\n uf.union(i, previous)\n roots = np.asarray([uf.find(i) for i in range(n)])\n _, groups = np.unique(roots, return_inverse=True)\n return groups.astype(str)\n\n\ndef auditer_splits_homologie(splits, groups, taxons, clusters, y_csr):\n rows = []\n for fold, (tr, va) in enumerate(splits):\n group_overlap = set(groups[tr]) & set(groups[va])\n cluster_overlap = set(clusters[tr]) & set(clusters[va])\n taxon_overlap = set(taxons[tr]) & set(taxons[va])\n rows.append({\n \"fold\": fold,\n \"n_train\": len(tr),\n \"n_val\": len(va),\n \"group_overlap\": len(group_overlap),\n \"homology_overlap\": len(cluster_overlap),\n \"taxon_overlap\": len(taxon_overlap),\n })\n assert not group_overlap and not cluster_overlap, f\"Leakage in fold {fold}\"\n audit = pd.DataFrame(rows)\n print(audit.to_string(index=False))\n return audit\n\n\ndef construire_splits_final_homologie(accessions, taxons, y_csr, cluster_path=HOMOLOGY_CLUSTER_PATH,\n n_splits=N_FOLDS, require_homology=REQUIRE_HOMOLOGY_FOR_FINAL_CV):\n if not cluster_path:\n if require_homology:\n raise RuntimeError(\"Final CV requires CAFA6_HOMOLOGY_CLUSTERS (MMseqs/CD-HIT TSV).\")\n groups = np.asarray(taxons, dtype=str)\n clusters = np.asarray([f\"singleton::{x}\" for x in accessions], dtype=object)\n print(\"[SPLIT] DEVELOPMENT ONLY: taxonomy groups without homology clusters.\")\n else:\n clusters = charger_clusters_homologie(cluster_path, accessions)\n groups = groupes_fermeture_taxonomie_homologie(accessions, taxons, clusters)\n sizes = pd.Series(groups).value_counts()\n n_groups = len(sizes)\n if n_groups < 2:\n raise RuntimeError(f\"Invalid constrained groups: n_groups={n_groups}\")\n effective_n_splits = min(int(n_splits), n_groups)\n if effective_n_splits < 2:\n raise RuntimeError(f\"Insufficient groups for cross-validation: n_groups={n_groups}\")\n splitter = GroupKFold(n_splits=effective_n_splits)\n splits = list(splitter.split(np.zeros(len(accessions)), groups=groups))\n audit = auditer_splits_homologie(splits, groups, np.asarray(taxons), clusters, y_csr)\n return splits, groups, clusters, audit\n\n\nif \"groupes_taxo\" in globals() and \"proteines_train\" in globals() and \"Y_train\" in globals():\n taxons_cv = np.asarray(groupes_taxo, dtype=str)\n accessions_cv = np.asarray(proteines_train, dtype=object)\n splits_cv, groupes_cv, clusters_cv, audit_splits = construire_splits_final_homologie(\n accessions_cv, taxons_cv, Y_train, cluster_path=HOMOLOGY_CLUSTER_PATH\n )\n groupes_taxo = groupes_cv\n print(f\"[SPLIT] Homology-aware CV configured with {len(splits_cv)} folds.\")\n print(audit_splits.to_string(index=False))\nelse:\n print(\"[SPLIT] Skipped: training variables are not yet available in the notebook runtime.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T17:53:13.788889Z","iopub.execute_input":"2026-07-31T17:53:13.789641Z","iopub.status.idle":"2026-07-31T17:53:14.12727Z","shell.execute_reply.started":"2026-07-31T17:53:13.789613Z","shell.execute_reply":"2026-07-31T17:53:14.126207Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Verification d'integrite\n\nAvant de lancer l'entrainement, on verifie que les donnees sont coherentes :\nfichiers presents, variables clés non vides, dimensions des matrices\ncompatibles, pas de NaN dans les features, GPU disponible. En cas d'echec,\nle pipeline s'arrete avec un message explicite plutot que de planter plus\nloin dans un module difficile a debugger.\n","metadata":{"id":"5fLdtB1mbS6Z"}},{"cell_type":"code","source":"# ============================================================================\n# VERIFICATION D'INTEGRITE DU PIPELINE V8 (CORRIGE)\n# ============================================================================\n# Verifie que toutes les donnees sont correctement chargees.\n# Arrete le pipeline si un probleme est detecte.\n#\n# FIX: 'embeddings' a ete retire de la liste des variables requises.\n# Module 7 supprime intentionnellement 'embeddings' (del embeddings) apres\n# avoir construit 'features_totales' pour economiser ~0.4 Go de RAM.\n# A ce stade du pipeline (apres Module 8), la variable pertinente est\n# 'features_totales' (reduit aux proteines test uniquement par Module 8).\n# ============================================================================\nimport scipy.sparse as sp\nprint('='*60)\nprint('VERIFICATION D\\'INTEGRITE DU PIPELINE V8')\nprint('='*60)\n\nerreurs = [] # Liste des erreurs detectees\navertissements = [] # Liste des avertissements\n\n# --- 1. Verifier l'existence des fichiers ---\nimport os\nfichiers_requis = [\n FICHIER_FASTA_TRAIN,\n FICHIER_TERMES,\n FICHIER_TAXONOMIE,\n FICHIER_OBO,\n FICHIER_IA,\n FICHIER_FASTA_TEST,\n]\n\nfor fich in fichiers_requis:\n if os.path.exists(fich):\n taille = os.path.getsize(fich) / 1024 / 1024\n print(f' ✅ {os.path.basename(fich)}: {taille:.1f} MB')\n else:\n erreurs.append(f'Fichier manquant: {fich}')\n print(f' ❌ {os.path.basename(fich)}: INTROUVABLE')\n\n# --- 2. Verifier les variables cles ---\n# NOTE: 'embeddings' a ete RETIRE de cette liste (supprime dans Module 7).\n# 'features_totales' est son remplacant a ce stade (proteines test uniquement).\nvariables_requises = {\n 'seq_train': dict, # Sequences d'entrainement\n 'df_termes': pd.DataFrame, # Annotations GO\n 'ia_dict': dict, # Information Accretion\n 'go_dag': nx.DiGraph, # DAG Gene Ontology\n 'liste_termes': list, # Liste des termes GO\n 'terme2idx': dict, # Mapping terme -> index\n 'vec_ia': np.ndarray, # Vecteur IA\n 'X_train': np.ndarray, # Features d'entrainement\n 'Y_train': sp.csr_matrix, # Etiquettes GO (matrice sparse)\n 'features_totales': dict, # Features proteines test (remplace embeddings)\n 'groupes_taxo': np.ndarray, # Groupes taxonomiques (Module 9)\n 'splits_cv': list, # Splits GroupKFold (Module 9)\n}\n\ndef get_var_size(var):\n \"\"\"Retourne la taille d'une variable pour l'affichage\"\"\"\n try:\n # Pour les matrices sparse, utiliser shape[0]\n if sp.issparse(var):\n return f\"shape={var.shape}\"\n # Pour les autres objets avec __len__\n elif hasattr(var, '__len__'):\n return f\"len={len(var):,}\"\n else:\n return \"\"\n except:\n return \"\"\n\nprint(f'\\n Variables cles:')\nfor var_name, var_type in variables_requises.items():\n try:\n var = eval(var_name)\n if isinstance(var, var_type):\n size_str = get_var_size(var)\n if size_str:\n print(f' ✅ {var_name}: {var_type.__name__} ({size_str})')\n else:\n print(f' ✅ {var_name}: {var_type.__name__}')\n else:\n erreurs.append(f'{var_name}: type {type(var).__name__} au lieu de {var_type.__name__}')\n print(f' ❌ {var_name}: type incorrect ({type(var).__name__})')\n except NameError:\n erreurs.append(f'Variable non definie: {var_name}')\n print(f' ❌ {var_name}: NON DEFINIE')\n\n# --- 3. Verifier la compatibilite des dimensions ---\ntry:\n n_prot, n_feat = X_train.shape\n n_prot_y, n_termes = Y_train.shape\n if n_prot != n_prot_y:\n erreurs.append(f'X_train et Y_train incompatibles: {n_prot} vs {n_prot_y} proteines')\n else:\n print(f'\\n ✅ Dimensions compatibles: {n_prot:,} proteines x {n_feat} features x {n_termes:,} termes')\n if len(groupes_taxo) != n_prot:\n erreurs.append(f'groupes_taxo incompatible avec X_train: {len(groupes_taxo)} vs {n_prot}')\n if len(splits_cv) != N_FOLDS:\n erreurs.append(f'splits_cv: {len(splits_cv)} folds au lieu de {N_FOLDS}')\nexcept Exception as e:\n erreurs.append(f'Erreur de dimension: {e}')\n\n# --- 4. Verifier les NaN ---\ntry:\n nb_nan = np.isnan(X_train).sum()\n if nb_nan > 0:\n avertissements.append(f'X_train contient {nb_nan:,} valeurs NaN')\n print(f' ⚠️ NaN dans X_train: {nb_nan:,}')\n else:\n print(f' ✅ Aucun NaN dans X_train')\nexcept Exception:\n pass\n\n# --- 5. Verifier le GPU ---\nif torch.cuda.is_available():\n gpu_nom = torch.cuda.get_device_name(0)\n gpu_ram = torch.cuda.get_device_properties(0).total_memory / 1e9\n print(f' ✅ GPU: {gpu_nom} ({gpu_ram:.1f} GB)')\nelse:\n avertissements.append('Aucun GPU detecte — entrainement tres lent sur CPU.')\n print(f' ⚠️ Aucun GPU detecte')\n\n# --- 6. Diagnostic memoire ---\ntry:\n import psutil\n ram_pct = psutil.virtual_memory().percent\n ram_go = psutil.virtual_memory().used / 1e9\n ram_tot = psutil.virtual_memory().total / 1e9\n print(f' ✅ RAM: {ram_go:.1f}/{ram_tot:.0f} Go ({ram_pct:.0f}%)')\n if ram_pct > 80:\n avertissements.append(f'RAM deja a {ram_pct:.0f}% avant la CV — risque OOM au Module 19')\n print(f' ⚠️ RAM elevee ({ram_pct:.0f}%) — voir optimisations Module 19')\nexcept ImportError:\n pass\n\n# --- Resume ---\nprint(f'\\n{\"=\"*60}')\nif erreurs:\n print(f'❌ ECHEC: {len(erreurs)} erreur(s) detectee(s)')\n for err in erreurs:\n print(f' - {err}')\n raise RuntimeError('Corrigez les erreurs avant de continuer.')\nelif avertissements:\n print(f'⚠️ ATTENTION: {len(avertissements)} avertissement(s)')\n for avr in avertissements:\n print(f' - {avr}')\n print('Pipeline pret — verifiez les avertissements ci-dessus.')\nelse:\n print('✅ TOUTES LES VERIFICATIONS PASSEES — Pipeline pret!')\nprint('='*60)","metadata":{"id":"sDF0D7lYbS6a","trusted":true,"execution":{"iopub.status.busy":"2026-07-31T17:53:14.128479Z","iopub.execute_input":"2026-07-31T17:53:14.128803Z","iopub.status.idle":"2026-07-31T17:53:14.264732Z","shell.execute_reply.started":"2026-07-31T17:53:14.128781Z","shell.execute_reply":"2026-07-31T17:53:14.26389Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# ============================================================\n# MODULE 10b - PRE-CALCUL VECTEURS DAG (Topological Waves)\n# V31: Vectorisation de la propagation DAG\n# ============================================================\nimport numpy as np\nimport torch\n\ndef precalculer_structures_dag(parents_par_idx, n_termes, profondeurs, device='cpu'):\n \"\"\"\n Pré-calcule les structures tensorielles pour la propagation DAG vectorisée.\n À exécuter UNE SEULE FOIS avant l'entraînement.\n \n Retourne:\n parents_tensor: (n_termes, max_parents) - indices des parents (padding -1)\n parents_mask: (n_termes, max_parents) - masque des parents valides\n topo_waves: liste de LongTensor - termes par vague topologique\n curriculum_masks: dict[prof_max] -> BoolTensor - masques curriculum\n \"\"\"\n # --- 1. Parents tensor (padding pour vectorisation) ---\n max_parents = max(len(parents_par_idx.get(i, [])) for i in range(n_termes))\n if max_parents == 0:\n max_parents = 1 # Sécurité\n \n parents_t = torch.full((n_termes, max_parents), -1, dtype=torch.long)\n parents_m = torch.zeros((n_termes, max_parents), dtype=torch.bool)\n \n for i in range(n_termes):\n plist = parents_par_idx.get(i, [])\n for j, p in enumerate(plist):\n parents_t[i, j] = p\n parents_m[i, j] = True\n \n # --- 2. Vagues topologiques (BFS depuis les racines) ---\n # Calculer le degré entrant de chaque nœud\n enfants_par_idx = {}\n for i in range(n_termes):\n for p in parents_par_idx.get(i, []):\n enfants_par_idx.setdefault(p, []).append(i)\n \n in_degree = np.zeros(n_termes, dtype=np.int32)\n for i in range(n_termes):\n in_degree[i] = len(parents_par_idx.get(i, []))\n \n waves = []\n remaining = set(range(n_termes))\n while remaining:\n wave = [u for u in remaining if in_degree[u] == 0]\n if not wave:\n # Cycle détecté — forcer le reste\n wave = list(remaining)\n wave_t = torch.tensor(sorted(wave), dtype=torch.long)\n waves.append(wave_t)\n for u in wave:\n remaining.discard(u)\n for v in enfants_par_idx.get(u, []):\n in_degree[v] -= 1\n \n # --- 3. Masques curriculum par profondeur ---\n profs_unique = sorted(set(profondeurs))\n curriculum_masks = {}\n for pm in [2, 4, 999]:\n curriculum_masks[pm] = torch.tensor(\n profondeurs <= pm, dtype=torch.bool\n )\n \n # --- 4. Statistiques ---\n print(f\"[DAG-VECT] Pré-calcul terminé:\")\n print(f\" max_parents = {max_parents}\")\n print(f\" topo_waves = {len(waves)} vagues (au lieu de {n_termes} itérations)\")\n for i, w in enumerate(waves):\n print(f\" Vague {i}: {len(w)} termes\")\n for pm in sorted(curriculum_masks.keys()):\n n_active = curriculum_masks[pm].sum().item()\n print(f\" Curriculum prof<={pm}: {n_active}/{n_termes} termes actifs\")\n \n return parents_t, parents_m, waves, curriculum_masks\n\n# --- Exécution du pré-calcul ---\n# Utilise les variables déjà définies dans les modules précédents\nparents_tensor_dag, parents_mask_dag, TOPO_WAVES, CURRICULUM_MASKS = \\\n precalculer_structures_dag(parents_par_idx, n_termes, vec_prof)\n\n# Placer sur GPU si disponible\nif torch.cuda.is_available():\n parents_tensor_dag = parents_tensor_dag.to('cuda')\n parents_mask_dag = parents_mask_dag.to('cuda')\n TOPO_WAVES = [w.to('cuda') for w in TOPO_WAVES]\n for k in CURRICULUM_MASKS:\n CURRICULUM_MASKS[k] = CURRICULUM_MASKS[k].to('cuda')\n\nprint(f\"\\n[DAG-VECT] Structures DAG sur device: {parents_tensor_dag.device}\")\nprint(f\"[DAG-VECT] Vagues topologiques: {len(TOPO_WAVES)} vagues\")\nprint(f\"[DAG-VECT] Accélération estimée: ~{n_termes // len(TOPO_WAVES)}x\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T18:13:36.380115Z","iopub.execute_input":"2026-07-31T18:13:36.380424Z","iopub.status.idle":"2026-07-31T18:13:36.512544Z","shell.execute_reply.started":"2026-07-31T18:13:36.380403Z","shell.execute_reply":"2026-07-31T18:13:36.511768Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module 10 — DAGNet : architecture integrant le DAG GO\n\nLa plupart des methodes de prediction de termes GO traitent chaque terme\nindependamment puis corrigent les incoherences hierarchiques en post-traitement.\nDAGNet prend le contre-pied : la structure du DAG est integree directement\ndans le forward pass, de sorte que le True Path Rule est respecte par\nconstruction.\n\n## Principe\n\nPour chaque terme GO, la prediction finale combine deux signaux :\n\n1. Le signal du reseau de base (features globales de la proteine).\n2. La somme des logits des parents GO (propagation top-down dans le DAG).\n\nConcretement, si `logit(t)` est la sortie brute du reseau pour le terme `t`,\nla prediction finale est `sigmoid(logit(t) + mean(logit(parents(t))))`. Cette\ncombinaison additive dans l'espace des logits (plutot que multiplicative dans\nl'espace des probabilites) permet au gradient de remonter vers les parents\npendant l'entrainement, ce qui apprend au reseau a predire des parents\ncoherents avec leurs enfants.\n\n## Architecture\n\n1. Couche d'entree : projection des features (ESM-2 + seq + taxo) vers la dimension cachee.\n2. Quatre blocs residuels (Mish + BatchNorm + skip connection).\n3. Couche de sortie lineaire : un logit par terme GO.\n4. Couche de propagation DAG : ajout des logits parents.\n5. Sigmoid final pour obtenir une probabilite par terme.\n\n## Justification\n\nDAGNet est preferable aux trois alternatives classiques pour integrer la hierarchie GO :\n- **Flat classifier** (un logit independant par terme) : ignore la structure DAG, produit des predictions incoherentes (e.g., predit GO:0008150 biological_process a False mais GO:0007005 mitochondrial_organization a True, ce qui viole le True Path Rule).\n- **Post-traitement TPR uniquement** (propagation bottom-up apres prediction) : corrige les incoherences a posteriori mais n'apprend pas a les eviter. Cout additionnel a l'inference et risque de propager des erreurs.\n- **Hierarchical softmax** : limite a un arbre, ne generalise pas aux DAG (un terme peut avoir plusieurs parents).\n\nDAGNet, inspire de Gaudriot et al. (2023) et de HierAttention (Zhang et al., 2021), est la seule approche qui (a) respecte la structure DAG complete, (b) permet la retropropagation vers les parents, et (c) reste compatible avec une loss multi-label standard (BCE). La combinaison additive dans l'espace des logits est preferable a la multiplication dans l'espace des probabilites car cette derniere annule le gradient si un parent a une probabilite proche de zero (vanishing gradient).","metadata":{"id":"-QfMcs8BbS6a"}},{"cell_type":"code","source":"# ============================================================================\n# MODULE 10 — DAGNet: ARCHITECTURE INTEGRANT LE DAG GO\n# ============================================================================\n\ndef _tri_topologique_dag(enfants, n):\n \"\"\"Tri topologique via Kahn (1962). Plus robuste que np.argsort(profondeurs)\n car les profondeurs BFS peuvent etre egales pour un parent et son enfant\n (shortest-path), violant alors le True Path Rule.\"\"\"\n in_degree = np.zeros(n, dtype=np.int32)\n for u in range(n):\n for v in enfants[u]:\n in_degree[v] += 1\n from collections import deque\n queue = deque([u for u in range(n) if in_degree[u] == 0])\n order = []\n while queue:\n u = queue.popleft()\n order.append(u)\n for v in enfants[u]:\n in_degree[v] -= 1\n if in_degree[v] == 0:\n queue.append(v)\n if len(order) != n:\n print(f\" [ATTENTION] Cycle detecte dans le DAG ({len(order)}/{n} termes tries)\")\n return np.array(order, dtype=np.int64)\n\n# DAGNet integre la structure hierarchique du GO dans le forward pass.\n# Le True Path Rule est respecte par construction.\n# Reference: Zhang et al. (2021) DAG-CNN, NeurIPS\n# Reference: Bi & Kwok (2015) Hierarchical Multi-Label Classification, ICML\n# ============================================================================\n\n# --- 10.1 Bloc Residuel avec activation Mish ---\n# Le bloc residuel (He et al., 2016, CVPR) permet d'entrainer des reseaux profonds\n# en ajoutant une connection de contournement (skip connection).\n# L'activation Mish (Misra, 2020) est plus douce que ReLU et donne de meilleurs\n# resultats sur les taches de classification multi-label.\n# Reference: He et al. (2016) *Deep Residual Learning*, CVPR\n# Reference: Misra (2020) *Mish: A Self Regularized Non-Monotonic Activation Function*\n\ndef mish(x):\n '''\n Activation Mish: x * tanh(softplus(x)).\n Plus douce que ReLU, meilleures performances en classification multi-label.\n Reference: Misra (2020) arXiv:1908.08681\n '''\n return x * torch.tanh(F.softplus(x)) # x * tanh(ln(1 + e^x))\n\ndef creer_bloc_residuel(dim_entree, dim_cachee, taux_dropout):\n '''\n Cree un bloc residuel avec Mish + BatchNorm + Dropout.\n Architecture: Linear -> BN -> Mish -> Dropout -> Linear -> BN + Skip\n\n Parametres:\n dim_entree: int — dimension d'entree\n dim_cachee: int — dimension cachee\n taux_dropout: float — taux de dropout\n\n Retourne:\n fonction du bloc residuel\n '''\n # Couches du bloc residuel (stockees dans un dictionnaire pour acces procedurale)\n couches = nn.ModuleDict({ # Dictionnaire de couches PyTorch\n 'fc1': nn.Linear(dim_entree, dim_cachee), # Premiere couche lineaire\n 'bn1': nn.BatchNorm1d(dim_cachee), # BatchNorm apres fc1\n 'drop1': nn.Dropout(taux_dropout), # Dropout apres fc1\n 'fc2': nn.Linear(dim_cachee, dim_entree), # Deuxieme couche lineaire (retour a dim_entree)\n 'bn2': nn.BatchNorm1d(dim_entree), # BatchNorm apres fc2\n }) # Fin du dictionnaire\n return couches # Retourner les couches\n\ndef appliquer_bloc_residuel(couches, x):\n '''\n Applique le bloc residuel: y = x + f(x) (connection residuelle).\n\n Parametres:\n couches: nn.ModuleDict — couches du bloc\n x: torch.Tensor — entree\n\n Retourne:\n torch.Tensor — sortie avec connection residuelle\n '''\n residual = x # Sauvegarder l'entree pour la connection residuelle\n # Forward: Linear -> BN -> Mish -> Dropout -> Linear -> BN\n out = couches['fc1'](x) # Projection lineaire\n out = couches['bn1'](out) # Normalisation par batch\n out = mish(out) # Activation Mish (plus douce que ReLU)\n out = couches['drop1'](out) # Dropout (regularisation)\n out = couches['fc2'](out) # Projection lineaire (retour)\n out = couches['bn2'](out) # Normalisation par batch\n out = out + residual # Connection residuelle: y = f(x) + x\n out = mish(out) # Activation finale\n return out # Retourner la sortie\n\n# --- 10.2 Architecture complete DAGNet ---\n# DAGNet combine un MLP avec blocs residuels et une propagation DAG\n\ndef creer_dagnet(dim_entree, dim_cachee, n_blocs, n_termes, taux_dropout):\n '''\n Cree l'architecture DAGNet complete.\n\n Architecture:\n 1. Projection initiale: dim_entree -> dim_cachee\n 2. N blocs residuels avec Mish + BN + Skip\n 3. Couche de base pour chaque terme GO (avant propagation DAG)\n 4. Propagation DAG: predictions parents -> enfants\n 5. Sigmoid final pour probabilites [0, 1]\n\n Parametres:\n dim_entree: int — dimension features (ESM2 + seq + taxo)\n dim_cachee: int — dimension cachee\n n_blocs: int — nombre de blocs residuels\n n_termes: int — nombre de termes GO a predire\n taux_dropout: float — taux de dropout\n\n Retourne:\n nn.ModuleDict — toutes les couches du modele DAGNet\n '''\n modele = nn.ModuleDict({ # Dictionnaire de toutes les couches\n # Projection initiale: features -> dimension cachee\n 'projection': nn.Linear(dim_entree, dim_cachee),\n 'bn_proj': nn.BatchNorm1d(dim_cachee),\n 'drop_proj': nn.Dropout(taux_dropout),\n # Blocs residuels (stockes dans un ModuleList)\n 'blocs_res': nn.ModuleList([ # Liste des blocs residuels\n creer_bloc_residuel(dim_cachee, dim_cachee // 2, taux_dropout)\n for _ in range(n_blocs) # n_blocs blocs\n ]), # Fin ModuleList\n\n # Couche de base: une prediction par terme GO (avant propagation DAG)\n 'fc_base': nn.Linear(dim_cachee, n_termes), # Prediction brute\n }) # Fin du ModuleDict\n # V17c: parametres de biais IA sur logits\n modele.register_parameter('biais_ia_logit', nn.Parameter(torch.zeros(n_termes)))\n modele.register_parameter('poids_biais_ia', nn.Parameter(torch.tensor(0.1)))\n return modele # Retourner le modele\n\ndef forward_dagnet(modele, x, parents_par_terme, n_termes, profondeurs,\n profondeur_max=999, ordre_topo=None,\n parents_tensor=None, parents_mask_tensor=None):\n '''Forward pass DAGNet SANS operations in-place sur logits.\n\n [FIX CRITIQUE V24] Remplace l'in-place `logits[:, idx] = torch.min(...)`\n par un tensor delta_clamp separe combine via torch.minimum (non in-place).\n C'est la correction du bug AsStridedBackward0:\n RuntimeError: one of the variables needed for gradient computation\n has been modified by an inplace operation: [torch.cuda.FloatTensor [32]],\n which is output 0 of AsStridedBackward0, is at version 4665; expected 4664.\n\n Algorithme:\n 1. Calculer logits_base = fc_base(h) (dans le graphe autograd)\n 2. Creer delta_clamp = +inf (PAS dans le graphe autograd — torch.full)\n 3. Pour chaque terme en ordre topo:\n - Si masque (curriculum): delta_clamp[:, idx] = -inf (in-place OK, pas de backward)\n - Sinon si a des parents: delta_clamp[:, idx] = max(logit_parents)\n ou logit_parents = torch.minimum(logits_base[:, parents], delta_clamp[:, parents])\n 4. logits_final = torch.minimum(logits_base, delta_clamp) (NON in-place)\n 5. predictions = sigmoid(logits_final)\n\n Parametres:\n modele: nn.ModuleDict — couches DAGNet\n x: torch.Tensor — features d'entree (batch, dim_features)\n parents_par_terme: dict — mapping terme -> liste de parents (indices)\n n_termes: int — nombre de termes GO\n profondeurs: numpy.ndarray — profondeur de chaque terme\n profondeur_max: int — profondeur max (pour curriculum)\n ordre_topo: numpy.ndarray — ordre topologique (Kahn)\n parents_tensor: torch.LongTensor (n_termes, max_parents) — option pre-calc\n parents_mask_tensor: torch.BoolTensor (n_termes, max_parents) — option pre-calc\n\n Retourne:\n torch.Tensor — predictions (batch, n_termes), valeurs dans [0, 1]\n '''\n taille_batch = x.size(0)\n device = x.device\n\n # --- Etape 1: Extraction des features avec blocs residuels ---\n h = modele['projection'](x)\n h = modele['bn_proj'](h)\n h = mish(h)\n h = modele['drop_proj'](h)\n for bloc in modele['blocs_res']:\n h = appliquer_bloc_residuel(bloc, h)\n\n # --- Etape 2: Predictions de base (logits) ---\n logits_base = modele['fc_base'](h) # (batch, n_termes) — DANS LE GRAPHE AUTOGRAD\n if hasattr(modele, 'biais_ia_logit'):\n logits_base = logits_base + modele.poids_biais_ia * modele.biais_ia_logit\n\n # --- Etape 3: Ordre de propagation ---\n if ordre_topo is not None:\n ordre = ordre_topo\n elif 'ORDRE_TOPO_DAG' in globals():\n ordre = ORDRE_TOPO_DAG\n else:\n ordre = np.argsort(profondeurs)\n\n # [FIX V24] Pre-construire les tensors parents pour eviter les lookups dict\n if parents_tensor is None:\n parents_tensor, parents_mask_tensor = _construire_parents_tensors(\n parents_par_terme, n_termes, logits_base.device\n )\n parents_tensor = parents_tensor.to(device)\n parents_mask_tensor = parents_mask_tensor.to(device)\n\n # Mask de curriculum (profondeur > max → -inf)\n curriculum_mask = torch.tensor(\n profondeurs <= profondeur_max, dtype=torch.bool, device=device\n ) # (n_termes,)\n\n # --- Etape 4: Propagation DAG SANS IN-PLACE sur logits_base ---\n # [FIX V24] delta_clamp N'EST PAS dans le graphe autograd (cree via torch.full)\n # Les in-place sur delta_clamp sont donc SÛRS (pas de backward sur ce tensor)\n delta_clamp = torch.full(\n (taille_batch, n_termes), float('inf'),\n dtype=logits_base.dtype, device=device\n )\n\n for idx in ordre:\n if not curriculum_mask[idx]:\n # Terme masque par curriculum → forcer -inf\n delta_clamp[:, idx] = float('-inf') # in-place OK: pas dans graphe autograd\n continue\n\n mask_parents = parents_mask_tensor[idx] # (max_parents,)\n if not mask_parents.any():\n continue # Pas de parents → pas de clamp\n\n idx_parents = parents_tensor[idx][mask_parents] # (n_valid_parents,)\n\n # Lire les logits COURANTS des parents via combinaison NON IN-PLACE\n # logits_parents = min(logits_base[:, parents], delta_clamp[:, parents])\n logits_parents = torch.minimum(\n logits_base[:, idx_parents],\n delta_clamp[:, idx_parents]\n ) # (batch, n_valid_parents)\n max_parent_logit = logits_parents.max(dim=1)[0] # (batch,)\n\n # Mettre a jour delta_clamp pour CE terme (in-place sur delta_clamp, SÛR)\n delta_clamp[:, idx] = max_parent_logit\n\n # --- Etape 5: Combinaison finale NON IN-PLACE ---\n # logits_final = min(logits_base, delta_clamp)\n # - Termes sans parents: delta_clamp = +inf → min = logits_base (inchangé)\n # - Termes masques: delta_clamp = -inf → min = -inf (sigmoid → 0)\n # - Termes avec parents: min(logit_base, max_parent_logit)\n logits_final = torch.minimum(logits_base, delta_clamp)\n\n predictions = torch.sigmoid(logits_final)\n return predictions\n\n\ndef _construire_parents_tensors(parents_par_terme, n_termes, device):\n '''Convertit le dict parents_par_terme en tensors denses pour GPU.\n\n Retourne:\n parents_tensor: (n_termes, max_parents) int64 — indices des parents\n parents_mask: (n_termes, max_parents) bool — True si parent valide\n '''\n max_parents = max((len(p) for p in parents_par_terme.values()), default=1)\n if max_parents == 0:\n max_parents = 1\n parents_tensor = torch.zeros((n_termes, max_parents), dtype=torch.long)\n parents_mask = torch.zeros((n_termes, max_parents), dtype=torch.bool)\n for idx, parents in parents_par_terme.items():\n for j, p_idx in enumerate(parents):\n parents_tensor[idx, j] = p_idx\n parents_mask[idx, j] = True\n return parents_tensor, parents_mask\n\n\n# --- 10.3 Instancier DAGNet ---\nprint('[DAGNet] Creation du modele...')\n\n# Creer le dictionnaire parents par index (pour le forward pass)\n# Les parents sont stockes par index (pas par terme GO) pour efficacite\nparents_par_idx = {} # Dictionnaire index_terme -> liste indices parents\nfor terme, liste_parents in parents_go.items(): # Pour chaque terme\n idx_terme = terme2idx[terme] # Index du terme\n indices_parents = [terme2idx[p] for p in liste_parents if p in terme2idx] # Index parents\n if indices_parents: # Si le terme a des parents\n parents_par_idx[idx_terme] = indices_parents\n# Creer le dictionnaire enfants par index (pour le tri topologique dans forward_dagnet)\n# Conversion depuis enfants_go (termes GO -> indices), comme parents_par_idx depuis parents_go\nenfants_dag = [[] for _ in range(len(liste_termes))]\nfor terme, liste_enfants in enfants_go.items(): # Pour chaque terme avec enfants\n if terme in terme2idx: # Si le terme est dans notre vocabulaire\n idx_terme = terme2idx[terme] # Index du terme parent\n enfants_dag[idx_terme] = [terme2idx[e] for e in liste_enfants if e in terme2idx] # Index enfants\n# ====================================================================\n# FIX V22 - ORDRE TOPOLOGIQUE PRECALCULE (tri de Kahn, 1962)\n# ====================================================================\n# PROBLEME (bug vivant): forward_dagnet et forward_modele_complet utilisaient\n# np.argsort(profondeurs) pour determiner l'ordre de la propagation DAG.\n# Or profondeur_go est un BFS shortest-path, donc un parent et son enfant\n# peuvent partager la MEME valeur de profondeur. np.argsort ordonne alors\n# ces noeuds de facon arbitraire -> un enfant peut etre traite AVANT son\n# parent -> il lit un logit \"non finalise\" -> violation du True Path Rule.\n#\n# SOLUTION: precalculer UNE FOIS un ordre topologique (Kahn) qui garantit\n# que chaque noeud est traite APRES tous ses parents, quelle que soit la\n# profondeur. Cet ordre depend uniquement de la structure du DAG (fixe),\n# il est donc valide pour tous les folds et tous les batches.\n#\n# Reference: Kahn (1962) \"Topological Sorting of Large Networks\", CACM.\n# ====================================================================\nORDRE_TOPO_DAG = _tri_topologique_dag(enfants_dag, len(liste_termes))\n# Verifier que le tri couvre bien tous les termes (sinon il y a un cycle)\nassert len(ORDRE_TOPO_DAG) == len(liste_termes), (\n f\"Tri topologique incomplet: {len(ORDRE_TOPO_DAG)}/{len(liste_termes)} \"\n f\"termes tries. Le DAG contient probablement un cycle.\"\n)\nprint(f' [FIX V22] Ordre topologique precalcule (Kahn): {len(ORDRE_TOPO_DAG):,} termes')\n\n# Garde-fou: verifier qu'aucun parent n'apparait apres son enfant\n# (test de non-regression du True Path Rule sur l'ordre lui-meme)\n_violations_ordre = 0\n_position = {int(t): p for p, t in enumerate(ORDRE_TOPO_DAG)}\nfor enfant_idx, parents_idx in parents_par_idx.items():\n for p_idx in parents_idx:\n # Un parent doit etre positionne AVANT son enfant dans l'ordre topo\n if _position.get(int(enfant_idx), 0) < _position.get(int(p_idx), 0):\n _violations_ordre += 1\nassert _violations_ordre == 0, (\n f\"ECHEC: {_violations_ordre} violation(s) du tri topologique detectees.\"\n)\nprint(f' [FIX V22] Test True Path Rule sur ordre topologique: 0 violation (OK)')\ndel _position, _violations_ordre\n\n# Creer le modele DAGNet\ndagnet = creer_dagnet( # Creer DAGNet\n dim_entree=dim_totale, # Dimension des features (ESM2 + seq + taxo)\n dim_cachee=DAGNET_HIDDEN, # Dimension cachee (1024)\n n_blocs=DAGNET_N_BLOCKS, # Nombre de blocs residuels (4)\n n_termes=len(liste_termes), # Nombre de termes GO\n taux_dropout=DAGNET_DROPOUT # Taux de dropout\n) # Fin de la creation\n\n# Deplacer le modele sur le device (GPU/CPU)\ndagnet = dagnet.to(DEVICE) # GPU si disponible\n\n# Compter les parametres du modele\nnb_params = sum(p.numel() for p in dagnet.parameters())\nnb_params_trainable = sum(p.numel() for p in dagnet.parameters() if p.requires_grad)\nprint(f' Parametres totaux: {nb_params:,}')\nprint(f' Parametres entrainables: {nb_params_trainable:,}')\n\n# Tester le forward pass avec un batch factice\nx_test = torch.randn(2, dim_totale).to(DEVICE) # Batch factice\nwith torch.no_grad(): # Pas de gradients\n y_test = forward_dagnet(dagnet, x_test, parents_par_idx, len(liste_termes), vec_prof)\nprint(f' Output shape: {y_test.shape}') # Doit etre (2, n_termes)\nprint(f' Output range: [{y_test.min():.4f}, {y_test.max():.4f}]') # Doit etre [0, 1]\n\n# Verifier que le True Path Rule est respecte\n# Si un enfant est predit positif, au moins un parent doit l'etre aussi\nfor i in range(y_test.size(0)): # Pour chaque exemple\n for idx_terme, idx_parents in parents_par_idx.items(): # Pour chaque terme avec parents\n if y_test[i, idx_terme] > 0.5: # Si enfant predit positif\n max_parent = max(y_test[i, p].item() for p in idx_parents) # Max des parents\n # Le max des parents doit etre >= a l'enfant (True Path)\n if max_parent < y_test[i, idx_terme].item() - 0.01: # Violation (tolerance 0.01)\n print(f' [ATTENTION] True Path viole pour terme {idx_terme}')\nprint('[OK] Module 10: DAGNet cree et teste')","metadata":{"id":"GHSo1GgWbS6b","trusted":true,"execution":{"iopub.status.busy":"2026-07-31T18:13:47.970824Z","iopub.execute_input":"2026-07-31T18:13:47.971557Z","iopub.status.idle":"2026-07-31T18:13:49.590071Z","shell.execute_reply.started":"2026-07-31T18:13:47.971525Z","shell.execute_reply":"2026-07-31T18:13:49.589294Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module 11 — IA-Aware Attention\n\nL'Information Accretion (IA) mesure la specificite d'un terme GO : un terme\na forte IA est informatif (sa prediction reduit beaucoup l'incertitude sur\nla fonction de la proteine), un terme a faible IA est redondant avec ses\nparents. IA est traditionnellement utilise dans la perte et dans les\nmetriques CAFA (Fmax-IA, Smin-IA).\n\nCe module l'integre egalement dans le mecanisme d'attention : les termes a\nforte IA reçoivent un poids attentionnel plus important. L'idee est que le\nmodele doit consacrer plus de capacite a predire correctement les termes\ninformatifs qu'a predire les termes generiques (souvent predictibles par\nsimple heuristic de prior).\n\n## Implementation\n\nL'attention est calculee classiquement (Q*K^T / sqrt(d), puis softmax), puis\nponderee par `softmax(IA)` avant d'etre appliquee a V. Cette modification est\nlocale et n'ajoute qu'un vecteur de poids (IA, de dimension C = nombre de\ntermes).\n\n## Principe\n\nL'attention IA-aware (Information-Content Aware) pondere la contribution de chaque terme GO dans la loss et dans la prediction finale par son information content (IC), defini comme `IC(t) = -log(frequency(t))`. Les termes rares (IC eleve) recoivent un poids plus important car ils sont plus informatifs : predire correctement qu'une proteine a une fonction rare apporte plus d'information que predire une fonction ubiquitaire.\n\n## Justification\n\nCette ponderation aligne le signal d'apprentissage avec la metrique officielle CAFA, le Fmax-IA (Module 17), qui pondere elle-meme les termes par IC. Sans cette alignment, le modele optimiserait BCE standard et accorderait trop d'importance aux termes frequents (e.g., GO:0005515 protein_binding), au detriment des termes rares qui sont pourtant ceux ou l'amelioration est la plus visible dans les metriques CAFA. Alternatives envisagees et ecartees : (1) focal loss seule (Module 14) qui repond au desequilibre mais sans notion d'IC ; (2) class-balanced loss de Cui et al. (2019) qui utilise effective number of samples mais ne capture pas l'IC specifique a GO. L'IC calcule a partir des annotations d'entrainement est une approximation de l'IC veritable (qui utiliserait toute la base UniProt), mais cette approximation est standard dans la litterature CAFA.","metadata":{"id":"lNRw27nKbS6c"}},{"cell_type":"code","source":"# ============================================================================\n# MODULE 11 — IA-AWARE ATTENTION (V31 — Propagation DAG vectorisée)\n# ============================================================================\n# Integre l'Information Accretion dans le mecanisme d'attention.\n# Les termes a forte IA recoivent plus d'attention.\n# Reference: Vaswani et al. (2017) Attention Is All You Need, NeurIPS\n# Reference: Elkan (2001) Cost-Sensitive Learning, IJCAI\n#\n# V31: forward_modele_complet vectorisé par vagues topologiques.\n# Au lieu de 4995 itérations Python séquentielles, on traite par vague\n# de termes indépendants (~15-20 vagues). Accélération ~100-300x.\n# ============================================================================\n\n# --- 11.1 Couche d'attention IA-Aware ---\n# Attention multi-tete avec IA comme biais attentionnel\n\ndef creer_ia_attention(dim_entree, n_tetes, dim_cachee, n_termes, ia_valeurs):\n '''\n Cree la couche d'attention IA-Aware.\n\n Architecture:\n 1. Projections lineaires Q (query), K (key), V (value)\n 2. Biais attentionnel base sur l'IA: softmax(IA) comme priorite\n 3. Attention multi-tete: softmax(QK^T / sqrt(d) + biais_IA) * V\n 4. Projection finale\n\n Parametres:\n dim_entree: int — dimension des features d'entree\n n_tetes: int — nombre de tetes d'attention\n dim_cachee: int — dimension cachee\n n_termes: int — nombre de termes GO\n ia_valeurs: numpy.ndarray — valeurs IA pour chaque terme\n\n Retourne:\n nn.ModuleDict — couches d'attention IA-Aware\n '''\n dim_tete = dim_cachee // n_tetes # Dimension par tete\n\n couches = nn.ModuleDict({ # Dictionnaire de couches\n # Projections Q, K, V pour attention multi-tete\n 'W_Q': nn.Linear(dim_entree, dim_cachee), # Query projection\n 'W_K': nn.Linear(dim_entree, dim_cachee), # Key projection\n 'W_V': nn.Linear(dim_entree, dim_cachee), # Value projection\n # Projection finale apres concatenation des tetes\n 'W_O': nn.Linear(dim_cachee, dim_entree), # Output projection\n 'ln1': nn.LayerNorm(dim_entree), # LayerNorm (pre-norm)\n 'ln2': nn.LayerNorm(dim_entree), # LayerNorm apres attention\n # Feed-forward network (position-wise)\n 'ff1': nn.Linear(dim_entree, dim_cachee), # FF couche 1\n 'ff2': nn.Linear(dim_cachee, dim_entree), # FF couche 2\n 'drop': nn.Dropout(DROPOUT),\n }) # Fin ModuleDict\n\n # Biais attentionnel base sur l'IA (fixe, pas appris)\n # Les termes avec forte IA ont un biais positif -> plus d'attention\n # Les termes avec faible IA ont un biais negatif -> moins d'attention\n # [FIX V24 #11.2] ia_tensor créé sur CPU puis déplacé explicitement sur DEVICE\n ia_tensor = torch.FloatTensor(ia_valeurs).to(DEVICE) # Convertir en tensor\n ia_tensor = ia_tensor / (ia_tensor.max() + 1e-8) # Normaliser entre 0 et 1\n # Le biais IA est un vecteur de dimension n_termes\n # Il sera ajoute aux scores d'attention\n # CORRECTION: Creer un module pour contenir le Parameter au lieu de l'ajouter directement\n class BiaisIAModule(nn.Module):\n def __init__(self, ia_tensor):\n super().__init__()\n self.biais_ia = nn.Parameter(ia_tensor.unsqueeze(0), requires_grad=False)\n \n def forward(self, scores):\n if self.biais_ia.size(-1) <= scores.size(-1):\n biais = self.biais_ia[:, :scores.size(-1)]\n return scores + biais * 0.1\n return scores\n \n couches['biais_ia'] = BiaisIAModule(ia_tensor)\n return couches # Retourner les couches\n\ndef forward_ia_attention(couches, x, n_tetes, dim_cachee):\n '''\n Forward pass de la couche d'attention IA-Aware.\n\n Parametres:\n couches: nn.ModuleDict — couches d'attention\n x: torch.Tensor — entree (batch, dim_entree)\n n_tetes: int — nombre de tetes\n dim_cachee: int — dimension cachee\n\n Retourne:\n torch.Tensor — sortie avec attention IA-Aware (batch, dim_entree)\n '''\n taille_batch = x.size(0) # Taille du batch\n dim_tete = dim_cachee // n_tetes # Dimension par tete\n\n # Normalisation pre-attention (Pre-LN transformer)\n x_norm = couches['ln1'](x)\n # Calculer Q, K, V\n Q = couches['W_Q'](x_norm) # Query: (batch, dim_cachee)\n K = couches['W_K'](x_norm) # Key: (batch, dim_cachee)\n V = couches['W_V'](x_norm) # Value: (batch, dim_cachee)\n\n # Reshaper pour attention multi-tete: (batch, n_tetes, dim_tete)\n Q = Q.view(taille_batch, n_tetes, dim_tete) # Reshape Query\n K = K.view(taille_batch, n_tetes, dim_tete) # Reshape Key\n V = V.view(taille_batch, n_tetes, dim_tete) # Reshape Value\n\n # Calculer les scores d'attention\n # Q * K^T / sqrt(d_k) + biais_IA\n scores = torch.bmm(Q, K.transpose(1, 2)) / math.sqrt(dim_tete) # Scores bruts\n\n # Ajouter le biais IA (seulement si dimensions compatibles)\n if 'biais_ia' in couches:\n # CORRECTION: Appeler le module qui contient le biais IA\n scores = couches['biais_ia'](scores)\n\n # Softmax sur les scores d'attention\n poids_attention = F.softmax(scores, dim=-1) # Normaliser en probabilites\n poids_attention = couches['drop'](poids_attention)\n # Appliquer l'attention aux valeurs\n # (batch, n_tetes, dim_tete) = attention * V\n contexte = torch.bmm(poids_attention, V) # Contexte attenionne\n contexte = contexte.view(taille_batch, dim_cachee)\n # Projection finale + connection residuelle\n sortie = couches['W_O'](contexte)\n x = x + couches['drop'](sortie) # Connection residuelle + dropout\n\n # Feed-forward avec connection residuelle (Post-LN)\n ff = couches['ln2'](x)\n ff = F.gelu(couches['ff1'](ff)) # GELU activation (Hendrycks & Gimpel, 2016)\n ff = couches['ff2'](ff) # Deuxieme couche FF\n x = x + couches['drop'](ff) # Connection residuelle\n\n return x # Retourner la sortie\n\n# --- 11.2 Modele complet avec IA-Attention ---\n# Le modele combine DAGNet (backbone) + IA-Attention (refinement)\n\ndef creer_modele_ia_aware(dim_entree, dim_cachee_dagnet, n_blocs, n_termes,\n taux_dropout, n_tetes, dim_cachee_attn, ia_valeurs):\n '''\n Cree le modele complet DAGNet + IA-Aware Attention.\n\n Architecture:\n 1. DAGNet: extraction de features avec propagation DAG\n 2. IA-Attention: refinement des features avec attention ponderee par IA\n 3. Couche de sortie: predictions finales\n\n Parametres:\n dim_entree: int — dimension features\n dim_cachee_dagnet: int — dimension cachee DAGNet\n n_blocs: int — blocs residuels DAGNet\n n_termes: int — nombre termes GO\n taux_dropout: float — dropout\n n_tetes: int — tetes d'attention\n dim_cachee_attn: int — dimension cachee attention\n ia_valeurs: numpy.ndarray — valeurs IA\n\n Retourne:\n nn.ModuleDict — modele complet\n '''\n # Creer DAGNet comme backbone\n modele = creer_dagnet(dim_entree, dim_cachee_dagnet, n_blocs, n_termes, taux_dropout)\n\n # Ajouter la couche IA-Attention\n # FIX V23 (audit): IA-Attention supprimee (V20 FIX #7) — ligne desactivee\n # modele['ia_attention'] = creer_ia_attention( # Attention IA-Aware\n # dim_entree=dim_cachee_dagnet, # Entree = features cachees DAGNet\n # n_tetes=n_tetes, # Nombre de tetes\n # dim_cachee=dim_cachee_attn, # Dimension cachee\n # n_termes=n_termes, # Nombre de termes\n # ia_valeurs=ia_valeurs # Valeurs IA\n # ) # Fin creation attention\n\n # --- Couche d'integration GNN ---\n # Si GNN disponible, ajouter une projection des embeddings GNN vers dim_cachee_dagnet\n # Cette projection sera ajoutee aux features cachees apres la projection initiale\n # Reference: DeepGraphGO (Kulmanov et al., 2022)\n try:\n # Verifier si GNN est disponible (variable globale definie au Module 12)\n _gnn_actif = GNN_DISPONIBLE and ('GNN_HIDDEN' in globals())\n if _gnn_actif:\n modele['gnn_proj'] = nn.Linear(GNN_HIDDEN, dim_cachee_dagnet) # Projection GNN -> DAGNet\n modele['gnn_ln'] = nn.LayerNorm(dim_cachee_dagnet)\n modele['gnn_drop'] = nn.Dropout(DROPOUT)\n print(' [GNN] Couche gnn_proj ajoutee au modele principal')\n except NameError:\n pass # GNN_DISPONIBLE pas encore defini (cas de test unitaire)\n\n return modele # Retourner le modele complet\n\n# --- 11.3 Forward pass complet (DAGNet + propagation DAG vectorisée V31) ---\n\ndef forward_modele_complet(modele, x, parents_par_idx, n_termes, profondeurs,\n profondeur_max=999, gnn_emb_batch=None, ordre_topo=None):\n '''\n V31: Forward pass unifié — DAGNet + propagation DAG VECTORISÉE par vagues topologiques.\n \n Au lieu de boucler séquentiellement sur les 4995 termes GO (Python for-loop),\n on les traite par \"vague\" topologique: les termes d'une même vague n'ont pas\n de relation parent-enfant entre eux et peuvent être traités en parallèle\n via des opérations tensorielles vectorisées.\n \n Résultat: ~15-20 itérations au lieu de 4995 → accélération ~100-300x.\n \n Les structures pré-calculées (parents_tensor_dag, parents_mask_dag, TOPO_WAVES,\n CURRICULUM_MASKS) doivent être initialisées par le Module 10b (precalcul_structures_dag).\n\n Parametres:\n modele: nn.ModuleDict — modele DAGNet (avec biais_ia_logit)\n x: torch.Tensor — features (batch, dim_features)\n parents_par_idx: dict — parents par index (utilisé en fallback si pré-calcul absent)\n n_termes: int — nombre de termes\n profondeurs: numpy.ndarray ou torch.Tensor — profondeurs des termes\n profondeur_max: int — profondeur max curriculum\n gnn_emb_batch: torch.Tensor ou None — embeddings GNN\n ordre_topo: numpy.ndarray ou None — ordre topologique (fallback)\n\n Retourne:\n torch.Tensor — predictions (batch, n_termes)\n '''\n # --- DAGNet: extraction de features ---\n h = modele['projection'](x) # Projection initiale\n h = modele['bn_proj'](h)\n h = mish(h) # Activation Mish\n h = modele['drop_proj'](h)\n\n # V20 FIX #7: couche gnn_proj conservée pour compatibilité state_dict\n # mais gnn_emb_batch sera toujours None en V20 (GNN désactivé).\n if gnn_emb_batch is not None and 'gnn_proj' in modele:\n gnn_h = modele['gnn_proj'](gnn_emb_batch)\n gnn_h = modele['gnn_ln'](gnn_h)\n gnn_h = F.gelu(gnn_h)\n gnn_h = modele['gnn_drop'](gnn_h)\n h = h + gnn_h\n\n for bloc in modele['blocs_res']: # Blocs residuels\n h = appliquer_bloc_residuel(bloc, h)\n\n # --- Couche de base + biais IA ---\n logits_base = modele['fc_base'](h) # Predictions brutes\n if hasattr(modele, 'biais_ia_logit'):\n logits_base = logits_base + modele.poids_biais_ia * modele.biais_ia_logit\n\n # --- Propagation DAG VECTORISÉE par vagues topologiques (V31) ---\n device = x.device\n batch_size = x.size(0)\n\n # Vérifier si les structures pré-calculées sont disponibles\n _vect_dispo = ('parents_tensor_dag' in globals() and \n 'parents_mask_dag' in globals() and \n 'TOPO_WAVES' in globals())\n\n if _vect_dispo:\n # === MODE VECTORISÉ (V31) — ~15-20 itérations au lieu de 4995 ===\n parents_t = parents_tensor_dag # (n_termes, max_parents)\n parents_m = parents_mask_dag # (n_termes, max_parents)\n waves = TOPO_WAVES # liste de LongTensor\n\n # S'assurer que les tensors sont sur le bon device\n if parents_t.device != device:\n parents_t = parents_t.to(device)\n if parents_m.device != device:\n parents_m = parents_m.to(device)\n\n # Masque curriculum : True = actif, False = masqué\n if 'CURRICULUM_MASKS' in globals() and profondeur_max in CURRICULUM_MASKS:\n curriculum_mask = CURRICULUM_MASKS[profondeur_max]\n else:\n if isinstance(profondeurs, torch.Tensor):\n curriculum_mask = (profondeurs <= profondeur_max)\n else:\n curriculum_mask = torch.tensor(\n profondeurs <= profondeur_max, dtype=torch.bool, device=device\n )\n if curriculum_mask.device != device:\n curriculum_mask = curriculum_mask.to(device)\n\n # Initialiser delta_clamp:\n # +inf pour termes actifs (pas de clamp par défaut)\n # -inf pour termes masqués par curriculum (sigmoid(-inf) = 0)\n delta_clamp = torch.where(\n curriculum_mask.unsqueeze(0).expand(batch_size, -1),\n torch.full((batch_size, n_termes), float('inf'), dtype=logits_base.dtype, device=device),\n torch.full((batch_size, n_termes), float('-inf'), dtype=logits_base.dtype, device=device),\n )\n\n # Traiter vague par vague (~15-20 itérations au lieu de 4995 !)\n for wave in waves:\n wave_dev = wave.to(device)\n n_wave = len(wave_dev)\n if n_wave == 0:\n continue\n\n # Parents de tous les termes de cette vague\n wave_parents = parents_t[wave_dev] # (n_wave, max_parents)\n wave_mask = parents_m[wave_dev] # (n_wave, max_parents)\n\n # Termes sans parents (racines) — pas besoin de clamp\n has_parents = wave_mask.any(dim=1) # (n_wave,)\n\n # Logits effectifs des parents: min(logits_base, delta_clamp)\n # Gather: (batch, n_wave, max_parents)\n parent_logits_base = logits_base[:, wave_parents] # (B, W, P)\n parent_logits_clamp = delta_clamp[:, wave_parents] # (B, W, P)\n parent_logits_eff = torch.minimum(parent_logits_base, parent_logits_clamp)\n\n # Masquer les parents invalides (padding) avec -inf\n # pour qu'ils n'affectent pas le max\n parent_logits_eff = parent_logits_eff.masked_fill(\n ~wave_mask.unsqueeze(0), float('-inf')\n )\n\n # Max sur les parents: (batch, n_wave)\n max_parent = parent_logits_eff.max(dim=2)[0] # (B, W)\n\n # Termes sans parents: garder +inf (pas de clamp de la part des parents)\n max_parent = torch.where(\n has_parents.unsqueeze(0).expand(batch_size, -1),\n max_parent,\n torch.full_like(max_parent, float('inf')),\n )\n\n # Mettre à jour delta_clamp pour cette vague (inplace sur delta_clamp — OK car hors autograd)\n delta_clamp[:, wave_dev] = max_parent\n\n # Combinaison finale — une seule opération vectorisée\n logits_final = torch.minimum(logits_base, delta_clamp)\n predictions = torch.sigmoid(logits_final)\n\n else:\n # === FALLBACK SÉQUENTIEL (si pré-calcul non disponible) ===\n # Ce chemin ne devrait être utilisé que si le Module 10b n'a pas été exécuté\n import warnings\n warnings.warn(\n \"[V31] Structures DAG pré-calculées non trouvées. \"\n \"Utilisation du mode séquentiel LENT (~100x plus lent). \"\n \"Exécutez le Module 10b (precalcul_structures_dag) pour activer la vectorisation.\",\n UserWarning\n )\n\n if ordre_topo is not None:\n indices_par_prof = ordre_topo\n elif 'ORDRE_TOPO_DAG' in globals():\n indices_par_prof = ORDRE_TOPO_DAG\n else:\n indices_par_prof = np.argsort(profondeurs)\n\n delta_clamp = torch.full((batch_size, n_termes), float('inf'), \n dtype=logits_base.dtype, device=device)\n\n # Masque curriculum\n if isinstance(profondeurs, torch.Tensor):\n prof_arr = profondeurs.cpu().numpy()\n else:\n prof_arr = profondeurs\n curriculum_mask = prof_arr <= profondeur_max\n\n for idx in indices_par_prof:\n idx = int(idx)\n if not curriculum_mask[idx]:\n delta_clamp[:, idx] = float('-inf')\n else:\n pidx = parents_par_idx.get(idx, [])\n if len(pidx) > 0:\n logits_parents = torch.minimum(\n logits_base[:, pidx], delta_clamp[:, pidx]\n )\n max_parent_logit = logits_parents.max(dim=1)[0]\n delta_clamp[:, idx] = max_parent_logit\n\n logits_final = torch.minimum(logits_base, delta_clamp)\n predictions = torch.sigmoid(logits_final)\n\n return predictions\n\n# --- 11.4 Instancier le modele complet ---\nprint('[IA-ATTENTION] Creation du modele complet DAGNet + IA-Attention...')\n\nmodele_principal = creer_modele_ia_aware( # Creer modele complet\n dim_entree=dim_totale, # Dimension features\n dim_cachee_dagnet=DAGNET_HIDDEN, # Cache DAGNet\n n_blocs=DAGNET_N_BLOCKS, # Blocs residuels\n n_termes=len(liste_termes), # Nombre termes GO\n taux_dropout=DAGNET_DROPOUT,\n n_tetes=IA_N_HEADS, # Tetes attention\n dim_cachee_attn=IA_HIDDEN, # Cache attention\n ia_valeurs=vec_ia # Valeurs IA\n) # Fin creation\n\nmodele_principal = modele_principal.to(DEVICE) # GPU/CPU\n\nnb_params = sum(p.numel() for p in modele_principal.parameters()) # Compter params\nprint(f' Parametres totaux: {nb_params:,}')\n\n# Tester le forward pass\nx_test = torch.randn(2, dim_totale).to(DEVICE) # Batch factice\nwith torch.no_grad(): # Pas de gradients\n y_test = forward_modele_complet(modele_principal, x_test, parents_par_idx,\n len(liste_termes), vec_prof)\nprint(f' Output shape: {y_test.shape}')\nprint(f' Output range: [{y_test.min():.4f}, {y_test.max():.4f}]')\n\n# --- Enveloppe pour DataParallel (multi-GPU 2x T4) ---\n# Permet d utiliser nn.DataParallel sur le modele DAGNet+GNN dont le forward est\n# une fonction libre (forward_modele_complet). DataParallel requiert un nn.Module\n# avec une methode forward(): il shard le batch sur dim 0 entre les GPUs, execute\n# le forward sur chaque GPU, puis rassemble les sorties sur le device principal.\n# Reference: PyTorch docs, nn.DataParallel (Li et al., 2018).\nclass ModeleEnveloppeDP(nn.Module):\n \"\"\"Enveloppe nn.Module pour DataParallel du modele DAGNet + IA-Attention + GNN.\n\n Fonctionnement:\n - wrap un modele (nn.ModuleDict) + les constantes necessaires au forward\n - expose forward(x, gnn_emb_batch=None) -> predictions\n - nn.DataParallel shard x et gnn_emb_batch sur dim 0 entre les GPUs\n - Le modele interne est replique sur chaque GPU; les gradients sont sommes\n automatiquement lors du backward\n \"\"\"\n def __init__(self, modele, parents_par_idx, n_termes, profondeurs, profondeur_max=999):\n super(ModeleEnveloppeDP, self).__init__() # Init nn.Module\n # Stocker le modele interne comme sous-module pour que .parameters() le voie\n self.modele_interne = modele # Le ModuleDict contenant les couches\n # Les constantes (non-trainables) stockees comme attributs\n self.parents_par_idx = parents_par_idx # Liste de listes (pas un tensor)\n self.n_termes_const = int(n_termes) # Nombre de termes GO\n # Profondeurs: tensor 1D de taille n_termes -> register_buffer (suit le device)\n if isinstance(profondeurs, torch.Tensor):\n self.register_buffer('profondeurs_t', profondeurs)\n else:\n self.register_buffer('profondeurs_t', torch.FloatTensor(profondeurs))\n self.profondeur_max_const = int(profondeur_max) # Profondeur max pour masque DAG\n\n def forward(self, x, gnn_emb_batch=None):\n \"\"\"Forward pass. DataParallel shard x et gnn_emb_batch sur dim 0.\n\n Args:\n x: (batch, dim_entree) embeddings ESM-2 + features\n gnn_emb_batch: (batch, GNN_HIDDEN) ou None — embeddings GNN pour ce batch\n\n Returns:\n predictions: (batch, n_termes) logits par terme GO\n \"\"\"\n predictions = forward_modele_complet(\n self.modele_interne, x,\n self.parents_par_idx,\n self.n_termes_const,\n self.profondeurs_t,\n self.profondeur_max_const,\n gnn_emb_batch=gnn_emb_batch\n )\n return predictions # (batch, n_termes)\n\n def get_modele_interne(self):\n \"\"\"Retourne le modele interne (utile pour state_dict si wrap par DataParallel).\"\"\"\n return self.modele_interne # Le ModuleDict sous-jacent\n\n\ndef envelopper_modele_dp(modele, parents_par_idx, n_termes, profondeurs, profondeur_max=999):\n \"\"\"Enveloppe le modele dans nn.DataParallel si _MULTI_GPU, sinon retourne enveloppe simple.\n\n Args:\n modele: nn.ModuleDict (modele DAGNet + IA-Attention)\n parents_par_idx: liste de listes d indices parents par terme GO\n n_termes: nombre de termes GO\n profondeurs: tensor ou array des profondeurs GO\n profondeur_max: profondeur max pour le masque DAG\n\n Returns:\n enveloppe: ModeleEnveloppeDP ou nn.DataParallel(ModeleEnveloppeDP)\n \"\"\"\n enveloppe = ModeleEnveloppeDP(\n modele, parents_par_idx, n_termes, profondeurs, profondeur_max\n )\n if _MULTI_GPU: # _MULTI_GPU defini dans Module 1 (Cell 3)\n enveloppe = nn.DataParallel(enveloppe) # Shard batch sur cuda:0 + cuda:1\n print(f' [MULTI-GPU] Modele enveloppe dans nn.DataParallel ({_N_GPUS} GPUs)')\n else:\n print(f' [MULTI-GPU] Modele single-GPU (DataParallel inactif, _N_GPUS={_N_GPUS})')\n return enveloppe\n\n\ndef get_modele_interne_depuis_dp(enveloppe):\n \"\"\"Extrait le modele interne (nn.ModuleDict) depuis une enveloppe DataParallel ou non.\n\n Utile pour state_dict() / load_state_dict() et acces aux couches.\n \"\"\"\n if isinstance(enveloppe, nn.DataParallel): # Si wrap par DataParallel\n return enveloppe.module.modele_interne # Le ModuleDict sous-jacent\n elif isinstance(enveloppe, ModeleEnveloppeDP): # Si enveloppe simple (1 GPU)\n return enveloppe.modele_interne # Le ModuleDict sous-jacent\n else: # Si deja un ModuleDict (pas enveloppe)\n return enveloppe\n\n\nprint('[OK] Module 11: IA-Aware Attention cree et teste (V31 vectorisation DAG)')","metadata":{"id":"q465gp5vbS6c","trusted":true,"execution":{"iopub.status.busy":"2026-07-31T18:13:58.881214Z","iopub.execute_input":"2026-07-31T18:13:58.881631Z","iopub.status.idle":"2026-07-31T18:13:59.062719Z","shell.execute_reply.started":"2026-07-31T18:13:58.881605Z","shell.execute_reply":"2026-07-31T18:13:59.061822Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module 12 — GNN heterogene : graphe proteines + GO\n\nLe DAG GO encode les relations entre termes, mais il existe egalement des\nrelations utiles entre proteines (similarite de sequence) et entre proteines\net termes (annotations connues). Un GNN heterogene permet de propager\nl'information a travers ces trois types de relations simultanement.\n\n## Graphe\n\n- **Noeuds proteines** : embeddings ESM-2 (dimension 1280).\n- **Noeuds termes GO** : embeddings appris (dimension 256).\n- **Aretes GO -> GO** : hierarchie `is_a` du DAG (propage l'information entre termes parent-enfant).\n- **Aretes Proteine -> GO** : annotations connues sur le jeu d'entrainement (propage les annotations vers les proteines similaires).\n- **Aretes Proteine -> Proteine** : top-K plus proches voisins en similarite cosinus sur les embeddings ESM-2 (typiquement K=10). Calcule via FAISS pour la passage a l'echelle.\n\n## Modele\n\nLe GNN est un GAT (Graph Attention Network) a 3 couches avec 4 tetes\nd'attention. La sortie est un embedding par proteine, ajoute en complement\nde l'embedding ESM-2 dans le classifieur final.\n\n## Reference\n\nInspire de DeepGraphGO (Kulmanov et al., 2022) avec deux differences : on\nutilise ESM-2 plutot que DeepGOPlus embeddings, et on propage les annotations\nGO via les aretes proteine-proteine en plus des aretes proteine-GO.\n\n## Principe\n\nLe DAG GO encode les relations entre termes, mais il existe egalement des relations utiles entre proteines (similarite de sequence) et entre proteines et termes (annotations connues). Un GNN heterogene permet de propager l'information a travers ces trois types de relations simultanement.\n\n## Graphe\n\n- Noeuds proteines : embeddings ESM-2 (dimension 1280).\n- Noeuds termes GO : embeddings appris (dimension 256).\n- Aretes GO -> GO : hierarchie `is_a` du DAG.\n- Aretes Proteine -> GO : annotations connues (train).\n- Aretes Proteine -> Proteine : top-K plus proches voisins en similarite cosinus sur ESM-2 (K=10), via FAISS.\n\n## Modele\n\nLe GNN est un GAT (Graph Attention Network) a 3 couches avec 4 tetes d'attention. La sortie est un embedding par proteine, ajoute en complement de l'embedding ESM-2 dans le classifieur final.\n\n## Justification\n\nLe GNN heterogene est choisi car il capture des dependances que les classifieurs plats ignorent : si deux proteines sont embeddings proches (similarite cosinus elevee) et que l'une est annotee pour un terme GO, l'autre a une probabilite accrue de l'etre aussi. Alternatives envisagees :\n- **GNN homogene** (un seul type d'arete) : necessiterait de projeter proteines et termes dans un meme espace, perdant l'interpretation physique.\n- **Label propagation** : methode plus simple mais qui ne peut pas apprendre des representations et reste limitee a la propagation d'annotations pre-existantes.\n- **Pas de GNN** (DAGNet seul) : perd le signal proteine-proteine.\n\nGAT est preferable a GCN car l'attention permet d'apprendre des poids differents pour chaque voisin, ce qui est crucial car tous les voisins ESM-2 ne sont pas egalement informatifs (certains voisins cosinus peuvent etre des homologues lointains sans fonction commune). Le top-K=10 est un compromis : K plus grand augmente la connectivite mais aussi le bruit (voisins eloignes). FAISS est utilise pour la recherche approximative car la recherche exacte en O(n^2) sur 140 000 proteines serait prohibitve. Inspire de DeepGraphGO (Kulmanov et al., 2022).","metadata":{"id":"0_zDseK6bS6d"}},{"cell_type":"code","source":"\n# MODULE 12 REMOVED FROM THE EXECUTABLE PIPELINE\n# A heterogeneous protein-GO graph is not viable within Kaggle's 2xT4 / 12 h budget.\n# The main model is ESM-2/LoRA features + DAGNet + IA-aware loss.\nENABLE_GNN = False\nGNN_DISPONIBLE = False\nprint(\"[GNN] Disabled by design: no graph construction, no torch-geometric dependency, no CPU message passing.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T18:14:15.127459Z","iopub.execute_input":"2026-07-31T18:14:15.128462Z","iopub.status.idle":"2026-07-31T18:14:15.132979Z","shell.execute_reply.started":"2026-07-31T18:14:15.128435Z","shell.execute_reply":"2026-07-31T18:14:15.132243Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"\n# MODULE 12 REMOVED FROM THE EXECUTABLE PIPELINE\n# A heterogeneous protein-GO graph is not viable within Kaggle's 2xT4 / 12 h budget.\n# The main model is ESM-2/LoRA features + DAGNet + IA-aware loss.\nENABLE_GNN = False\nGNN_DISPONIBLE = False\nprint(\"[GNN] Disabled by design: no graph construction, no torch-geometric dependency, no CPU message passing.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T18:14:15.134294Z","iopub.execute_input":"2026-07-31T18:14:15.13455Z","iopub.status.idle":"2026-07-31T18:14:15.151299Z","shell.execute_reply.started":"2026-07-31T18:14:15.134532Z","shell.execute_reply":"2026-07-31T18:14:15.15053Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"\n# MODULE 13 REMOVED FROM THE EXECUTABLE PIPELINE\n# Terms below the supervised vocabulary threshold are evaluated separately; MAML is\n# intentionally not run because it conflicts with the frequent-term training head.\nENABLE_MAML = False\nprint(\"[MAML] Disabled for the production run. Rare terms remain available for OOF error analysis.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T18:14:15.152465Z","iopub.execute_input":"2026-07-31T18:14:15.152808Z","iopub.status.idle":"2026-07-31T18:14:15.165786Z","shell.execute_reply.started":"2026-07-31T18:14:15.152768Z","shell.execute_reply":"2026-07-31T18:14:15.16505Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"\n# MODULE 13 REMOVED FROM THE EXECUTABLE PIPELINE\n# Terms below the supervised vocabulary threshold are evaluated separately; MAML is\n# intentionally not run because it conflicts with the frequent-term training head.\nENABLE_MAML = False\nprint(\"[MAML] Disabled for the production run. Rare terms remain available for OOF error analysis.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T18:14:15.167382Z","iopub.execute_input":"2026-07-31T18:14:15.167697Z","iopub.status.idle":"2026-07-31T18:14:15.178346Z","shell.execute_reply.started":"2026-07-31T18:14:15.167664Z","shell.execute_reply":"2026-07-31T18:14:15.177603Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# ============================================================================\n# MODULE 14 — FONCTIONS DE PERTE COMBINEES (V18 — scipy.sparse + contrastive)\n# ============================================================================\n# 4 fonctions de perte pour optimiser la prediction GO.\n# Reference: Lin et al. (2017) Focal Loss, ICCV\n# Reference: Ben-Baruch et al. (2021) ASL, ICML\n#\n# V18 — Correction OOM critique de la perte contrastive:\n# PROBLEME V17: torch.mm(cibles.cpu().t(), cibles.cpu) cree une matrice CxC\n# dense (~8 GB pour C=26000 termes GO) -> OOM meme sur CPU.\n#\n# SOLUTION (approche principielle, pas du bricolage):\n# 1. PRE-CALCUL hors ligne des paires co-annotees avec scipy.sparse\n# (Y_sparse.T @ Y_sparse est sparse par construction, O(nnz) en RAM)\n# 2. SEUIL DE CO-OCCURRENCE (seuil_min_cooccurrence=5): filtre statistique\n# pour ne garder que les paires avec suffisamment d'exemples conjoints\n# 3. FILTRAGE DES PAIRES ACTIVES: au runtime, seules les paires dont\n# LES DEUX termes ont au moins un positif dans le batch sont utilisees\n# 4. FORMULATION PROBABILISTE: -F.logsigmoid(similarite) au lieu de\n# triplet margin loss — formulation correcte pour contrastive learning\n# 5. NORMALISATION sur dim=0 (across batch): mesure si deux termes\n# \"montent et descendent ensemble\" a travers les exemples du batch\n# ============================================================================\n\n# --- 14.1 IA-BCE: BCE ponderee par l'Information Accretion ---\n# L'IA mesure l\\'information specifique de chaque terme GO.\n# Les termes a forte IA sont plus importants pour Fmax-IA.\n# Reference: Clark & Radivojac (2013) Bioinformatics 29(13)\n\ndef calculer_perte_ia_bce(predictions, cibles, ia_tens, poids=1.0):\n \"\"\"Calcule la BCE ponderee par l'Information Accretion.\n\n Formule: L_IA-BCE = -1/C * sum(IA_j * [y_j * log(p_j) + (1-y_j) * log(1-p_j)])\n\n Parametres:\n predictions: torch.Tensor — predictions (batch, C)\n cibles: torch.Tensor — etiquettes binaires (batch, C)\n ia_tens: torch.Tensor — valeurs IA (C,)\n poids: float — poids global de cette perte\n\n Retourne:\n torch.Tensor — perte scalaire\n \"\"\"\n # Eviter log(0) en clampant les predictions\n # [FIX V24 #14.3] nan_to_num avant clamp (évite NaN propagation)\n predictions = torch.nan_to_num(predictions, nan=0.5, posinf=1-1e-7, neginf=1e-7)\n preds = torch.clamp(predictions, min=1e-7, max=1-1e-7) # Clamper dans (0,1)\n\n # Calculer le terme BCE pour chaque position\n bce = -(cibles * torch.log(preds) + (1 - cibles) * torch.log(1 - preds))\n\n # Ponderer par l'IA: les termes a forte IA contribuent plus a la perte\n # [FIX V24 #14.2] Gérer ia_tens avec NaN\n ia_safe = torch.nan_to_num(ia_tens, nan=0.0)\n ia_max = ia_safe.max()\n if ia_max == 0 or torch.isnan(ia_max):\n ia_max = torch.tensor(1.0, device=ia_tens.device)\n ia_normalisee = ia_safe / (ia_max + 1e-8)\n ia_poids = ia_normalisee + 0.1 # Poids minimum de 0.1\n\n # Appliquer les poids IA a la BCE\n bce_ponderee = bce * ia_poids.unsqueeze(0) # Broadcasting (batch, C)\n\n # Moyenner sur le batch et les termes\n perte = bce_ponderee.mean() * poids\n return perte\n\n\n# --- 14.2 Focal Loss ---\n# La Focal Loss reduit l'impact de la classe majoritaire (negative)\n# en appliquant un facteur (1 - p_t)^gamma qui diminue le poids des exemples faciles.\n# Reference: Lin et al. (2017) *Focal Loss*, ICCV\n\ndef calculer_perte_focale(predictions, cibles, gamma=2.0, poids=1.0):\n \"\"\"Calcule la Focal Loss pour la classification multi-label.\n\n Formule: FL = -alpha * (1-p_t)^gamma * log(p_t)\n ou p_t = p si y=1, (1-p) si y=0\n\n Parametres:\n predictions: torch.Tensor — predictions (batch, C)\n cibles: torch.Tensor — etiquettes (batch, C)\n gamma: float — parametre de focalisation (default: 2.0)\n poids: float — poids global\n\n Retourne:\n torch.Tensor — perte scalaire\n \"\"\"\n # [FIX V24] nan_to_num\n predictions = torch.nan_to_num(predictions, nan=0.5)\n preds = torch.clamp(predictions, min=1e-7, max=1-1e-7)\n\n p_t = cibles * preds + (1 - cibles) * (1 - preds)\n facteur_focal = (1 - p_t) ** gamma\n bce = -(cibles * torch.log(preds) + (1 - cibles) * torch.log(1 - preds))\n perte_focale = facteur_focal * bce\n\n # FIX V22: normalisation par .mean() (au lieu de .sum()/n_actifs qui ecrasait les autres pertes).\n # AVANT: perte_focale valait ~3636 vs ia_bce ~0.21 -> capturait 99.99% du gradient.\n # APRES: .mean() = somme/(batch*C), meme echelle que IA-BCE et ASL -> 4 pertes sommables.\n # Reference: Lin et al. (2017) Focal Loss, ICCV. En multi-label dense, .mean() est standard.\n return perte_focale.mean() * poids\n\n\n# --- 14.3 Asymmetric Loss ---\n# L'Asymmetric Loss (ASL) penalise plus les faux negatifs que les faux positifs.\n# C'est important car manquer une annotation (FN) est plus grave que predire\n# une annotation inexistante (FP) dans le contexte CAFA.\n# Reference: Ben-Baruch et al. (2021) *Asymmetric Loss*, ICML\n\ndef calculer_perte_asymetrique(predictions, cibles, alpha=0.1, poids=1.0):\n \"\"\"Calcule l'Asymmetric Loss pour la classification multi-label.\n\n Formule: ASL = -[y * (1-p)^gamma+ * log(p) + (1-y) * p^gamma- * log(1-p)]\n\n Parametres:\n predictions: torch.Tensor — predictions (batch, C)\n cibles: torch.Tensor — etiquettes (batch, C)\n alpha: float — parametre d'asymetrie (default: 0.1)\n poids: float — poids global\n\n Retourne:\n torch.Tensor — perte scalaire\n \"\"\"\n # [FIX V24] nan_to_num\n predictions = torch.nan_to_num(predictions, nan=0.5)\n preds = torch.clamp(predictions, min=1e-7, max=1-1e-7)\n\n # Terme positif: y * log(p)\n terme_pos = cibles * torch.log(preds)\n\n # Terme negatif: (1-y) * p^gamma- * log(1-p)\n gamma_neg = 2 + alpha\n terme_neg = (1 - cibles) * (preds ** gamma_neg) * torch.log(1 - preds)\n\n perte = -(terme_pos + terme_neg)\n\n return perte.mean() * poids\n\n\n# --- 14.4 Contrastive GO Loss (V18 — scipy.sparse + co-occurrence) ---\n# Encourage les termes GO souvent co-annotes a avoir des representations similaires.\n# Capture les correlations entre termes dans l'espace latent.\n#\n# APPROCHE PRINCIPIELLE (V18):\n# 1. Pre-calcul hors ligne via scipy.sparse (pas de matrice dense CxC)\n# 2. Seuil de co-occurrence >= 5 (fiabilite statistique)\n# 3. Filtrage des paires actives dans le batch courant\n# 4. Formulation -F.logsigmoid(similarite) (probabiliste)\n\ndef precalculer_paires_co_annotees(Y_train_complet, seuil_min_cooccurrence=5):\n \"\"\"Pre-calcule les paires de termes GO co-annotees a partir des donnees d'entrainement.\n\n UTILISE scipy.sparse pour eviter la creation de la matrice dense CxC.\n La co-annotation est une propriete STATIQUE des donnees, pas du batch.\n On la calcule une seule fois hors ligne.\n\n Formule: co_occurrence = Y_sparse.T @ Y_sparse (sparse x sparse = sparse)\n\n V20: accepte Y_train_complet en format dense (numpy.ndarray) OU sparse\n (scipy.sparse.csr_matrix). Si déjà sparse, la conversion est une no-op.\n\n Parametres:\n Y_train_complet: numpy.ndarray OU scipy.sparse.csr_matrix\n matrice binaire (N_proteines, C_termes)\n seuil_min_cooccurrence: int — seuil minimum de co-occurrence pour fiabilite\n statistique (default: 5). Les paires avec moins de 5 exemples conjoints\n sont exclues car leur correlation n'est pas statistiquement fiable.\n\n Retourne:\n torch.LongTensor — paires (P, 2) ou chaque ligne est (idx_i, idx_j)\n \"\"\"\n import scipy.sparse as sp\n\n print(f' [CONTRASTIVE] Pre-calcul des paires co-annotees (scipy.sparse)...')\n print(f' Y_train shape: {Y_train_complet.shape}')\n print(f' Seuil min co-occurrence: {seuil_min_cooccurrence}')\n\n # V20: si Y_train_complet est déjà sparse, on l'utilise tel quel.\n # Sinon, on le convertit en sparse CSR (format efficace pour multiplication).\n if sp.issparse(Y_train_complet):\n Y_sparse = Y_train_complet.tocsr()\n print(f' [V20] Y_train déjà sparse (type={type(Y_train_complet).__name__})')\n else:\n Y_sparse = sp.csr_matrix(Y_train_complet)\n print(f' [V20] Y_train converti de dense vers sparse')\n\n # Produit matriciel sparse: (C, N) @ (N, C) = (C, C) sparse\n # Resultat est sparse car la plupart des paires ne co-occurrent jamais\n cooccurrence = (Y_sparse.T @ Y_sparse).tocoo()\n\n # Filtrer: co-occurrence >= seuil ET pas la diagonale (i != j)\n masque = ((cooccurrence.data >= seuil_min_cooccurrence) &\n (cooccurrence.row != cooccurrence.col))\n\n n_paires = masque.sum()\n paires = torch.LongTensor(\n list(zip(cooccurrence.row[masque], cooccurrence.col[masque]))\n )\n\n # Statistiques\n n_termes = Y_train_complet.shape[1]\n densite = n_paires / max(1, n_termes * (n_termes - 1)) * 100\n print(f' Paires co-annotees (co-occ >={seuil_min_cooccurrence}): {n_paires:,}')\n print(f' Densite: {densite:.4f}% (matrice tres creuse)')\n\n # Liberer la memoire\n del Y_sparse, cooccurrence\n\n return paires\n\n\ndef calculer_perte_contrastive(predictions, cibles, paires_co_annotees,\n temperature=0.1, poids=1.0):\n \"\"\"Calcule la Contrastive GO Loss (V18 — formulation probabiliste).\n\n Principe: si deux termes GO sont souvent co-annotes, leurs predictions\n doivent etre similaires a travers les exemples du batch.\n\n Formulation: L_contr = -F.logsigmoid(sim(p_i, p_j) / temperature).mean()\n ou sim(p_i, p_j) = (preds_norm_i * preds_norm_j).sum(dim=0)\n et preds_norm = F.normalize(predictions, p=2, dim=0)\n\n Normalisation dim=0 (across batch): mesure si deux termes \"montent et\n descendent ensemble\" a travers les exemples du batch.\n\n Filtrage des paires actives: seules les paires dont LES DEUX termes\n ont au moins un exemple positif dans le batch sont utilisees.\n\n Parametres:\n predictions: torch.Tensor — predictions (batch, C)\n cibles: torch.Tensor — etiquettes binaires (batch, C)\n paires_co_annotees: torch.LongTensor — paires pre-calculees (P, 2)\n temperature: float — temperature (default: 0.1)\n poids: float — poids global\n\n Retourne:\n torch.Tensor — perte scalaire\n \"\"\"\n # Si pas de paires co-annotees, retourner 0\n if paires_co_annotees is None or paires_co_annotees.numel() == 0:\n return torch.tensor(0.0, device=predictions.device, requires_grad=True)\n\n # Indices des termes dans les paires\n idx_i = paires_co_annotees[:, 0].to(predictions.device)\n idx_j = paires_co_annotees[:, 1].to(predictions.device)\n\n # Filtrer: ne garder que les paires ACTIVES (les deux termes ont des positifs dans le batch)\n actif_i = cibles[:, idx_i].sum(dim=0) > 0 # (P,) — terme i a au moins 1 positif\n actif_j = cibles[:, idx_j].sum(dim=0) > 0 # (P,) — terme j a au moins 1 positif\n paires_actives = actif_i & actif_j # (P,) — les deux ont des positifs\n\n n_actives = paires_actives.sum().item()\n if n_actives == 0:\n return torch.tensor(0.0, device=predictions.device, requires_grad=True)\n\n # Selectionner uniquement les paires actives\n idx_i_actifs = idx_i[paires_actives]\n idx_j_actifs = idx_j[paires_actives]\n\n # Normaliser les predictions sur dim=0 (across batch pour chaque terme)\n # Mesure si les predictions des deux termes \"montent et descendent ensemble\"\n preds_i = F.normalize(predictions[:, idx_i_actifs], p=2, dim=0, eps=1e-8) # [FIX V24 #14.4] eps # (batch, P_actives)\n preds_j = F.normalize(predictions[:, idx_j_actifs], p=2, dim=0, eps=1e-8) # [FIX V24 #14.4] eps # (batch, P_actives)\n\n # Similarite cosinus entre les vecteurs de prediction de chaque paire\n similarite = (preds_i * preds_j).sum(dim=0) / temperature # (P_actives,)\n\n # Formulation probabiliste: -log(sigma(sim/T))\n perte_contrastive = -F.logsigmoid(similarite).mean()\n\n return perte_contrastive * poids\n\n\n# --- 14.5 Perte combinee ---\n# Combine les 4 pertes avec des poids relatifs\n# V18: signature mise a jour avec paires_co_annotees\n\ndef calculer_perte_combinee(predictions, cibles, ia_tens, paires_co_annotees=None):\n \"\"\"Calcule la perte combinee: IA-BCE + Focal + Asymmetric + Contrastive.\n\n Parametres:\n predictions: torch.Tensor — predictions (batch, C)\n cibles: torch.Tensor — etiquettes binaires (batch, C)\n ia_tens: torch.Tensor — valeurs IA (C,)\n paires_co_annotees: torch.LongTensor ou None — paires pre-calculees (P, 2)\n Si None, la perte contrastive retourne 0 (retrocompatibilite)\n\n Retourne:\n torch.Tensor — perte combinee scalaire\n dict — decomposition des pertes individuelles\n \"\"\"\n # Calculer chaque composante de la perte\n perte_ia_bce = calculer_perte_ia_bce(predictions, cibles, ia_tens, POIDS_BCE_IA)\n perte_focale = calculer_perte_focale(predictions, cibles, GAMMA_FOCAL, POIDS_FOCAL)\n perte_asym = calculer_perte_asymetrique(predictions, cibles, ALPHA_ASYM, POIDS_ASYM)\n perte_contr = calculer_perte_contrastive(\n predictions, cibles, paires_co_annotees, 0.1, POIDS_CONTRASTIVE\n )\n\n # Somme ponderee des pertes\n perte_total = perte_ia_bce + perte_focale + perte_asym + perte_contr\n\n # Decomposition pour le logging\n details = {\n 'ia_bce': perte_ia_bce.item(),\n 'focale': perte_focale.item(),\n 'asymetrique': perte_asym.item(),\n 'contrastive': perte_contr.item() if isinstance(perte_contr, torch.Tensor) else perte_contr,\n 'total': perte_total.item(),\n }\n\n return perte_total, details\n\n\n# --- 14.6 Preparer le tensor IA ---\n# [FIX V24 #14.2] ia_tensor avec gestion NaN (vec_ia peut contenir np.nan)\nia_tensor = torch.FloatTensor(np.nan_to_num(vec_ia, nan=0.0)).to(DEVICE) # Tensor IA sur device\n\n# --- 14.7 Pre-calcul des paires co-annotees ---\n# NOTE: Y_train est construit dans Module 8. Si ce module est execute avant\n# Module 8 (cas normal), la variable Y_train n'existe pas encore.\n# Le pre-calcul est donc differre: on le fait dans Module 8 apres la construction\n# de Y_train, OU on le fait ici si Y_train existe deja (re-execution).\n# La variable globale PAIRES_CO_ANNOTEES sera initialisee dans Module 8.\nPAIRES_CO_ANNOTEES = None # Sera calcule dans Module 8 apres construction de Y_train\n\n# V20: Y_train peut être sparse CSR ou dense ndarray\nif 'Y_train' in dir() and Y_train is not None:\n print('[CONTRASTIVE] Y_train detecte — pre-calcul immediate des paires co-annotees')\n PAIRES_CO_ANNOTEES = precalculer_paires_co_annotees(Y_train, seuil_min_cooccurrence=5)\nelse:\n print('[CONTRASTIVE] Y_train pas encore disponible — pre-calcul differe au Module 8')\n\n# Tester la perte combinee\ny_pred_test = torch.sigmoid(torch.randn(4, len(liste_termes))).to(DEVICE)\ny_true_test = torch.zeros(4, len(liste_termes)).to(DEVICE)\ny_true_test[:, :5] = 1.0\n\nperte_test, details_test = calculer_perte_combinee(\n y_pred_test, y_true_test, ia_tensor, PAIRES_CO_ANNOTEES\n)\nprint(f'[PERTES] Test: total={details_test[\"total\"]:.4f}')\nfor nom, val in details_test.items():\n print(f' {nom}: {val:.4f}')\nprint('[OK] Module 14 V18: Fonctions de perte definies (scipy.sparse + contrastive)')\n\n\n# FIX V23-D (audit): appel deplace ici (etait en Module 8 avant la def).\n# Initialise PAIRES_CO_ANNOTEES pour la Contrastive Loss.\ntry:\n if 'Y_train' in globals() and Y_train is not None:\n PAIRES_CO_ANNOTEES = precalculer_paires_co_annotees(Y_train, seuil_min_cooccurrence=5)\n print(f'[OK] PAIRES_CO_ANNOTEES initialise: {len(PAIRES_CO_ANNOTEES) if PAIRES_CO_ANNOTEES is not None else 0} paires')\n else:\n PAIRES_CO_ANNOTEES = None\n print('[ATTENTION] Y_train non disponible — PAIRES_CO_ANNOTEES=None')\nexcept Exception as e:\n print(f'[ATTENTION]Erreur precalculation PAIRES_CO_ANNOTEES: {e}')\n PAIRES_CO_ANNOTEES = None\n","metadata":{"id":"-Ts041bmbS6i","trusted":true,"execution":{"iopub.status.busy":"2026-07-31T18:14:15.581577Z","iopub.execute_input":"2026-07-31T18:14:15.582453Z","iopub.status.idle":"2026-07-31T18:14:22.917884Z","shell.execute_reply.started":"2026-07-31T18:14:15.582425Z","shell.execute_reply":"2026-07-31T18:14:22.916735Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module 15 — Curriculum learning par profondeur DAG\n\nLe curriculum learning (Bengio et al., 2009) consiste a presenter les\nexemples au modele dans un ordre qui facilite l'apprentissage : on commence\npar les concepts simples et on ajoute progressivement les concepts difficiles.\n\nDans notre cas, la \"difficulte\" d'un terme GO est proxy par sa profondeur\ndans le DAG :\n\n- Les termes proches de la racine sont generaux, frequent, et couverts par beaucoup d'exemples positifs.\n- Les termes profonds sont specifiques, rares, et ont peu d'exemples positifs.\n\nLe schedule en trois phases :\n\n1. **Phase 1** (10 epoques) : termes de profondeur <= 2.\n2. **Phase 2** (10 epoques) : profondeur <= 4.\n3. **Phase 3** (10 epoques) : tous les termes.\n\nLes termes inactifs sont masques (poids = 0 dans la perte) plutot que\nsupprimes, ce qui preserve les dimensions du reseau. Le masque est un\nsimple vecteur binaire de dimension C.\n\n## Principe\n\nLe curriculum learning organise l'entrainement en phases successives, de la plus simple a la plus difficile. Ici, la difficulte est definie par la profondeur dans le DAG : on commence par entrainer sur les termes les plus generaux (proche de la racine, profondeur faible), puis on ajoute progressivement les termes plus specifiques (feuilles, profondeur maximale). L'idee est que les termes proches de la racine ont une couverture large (beaucoup de positifs) et un signal stable, ce qui stabilise le debut de l'entrainement. FIX V23 (audit): paragraphe corrige pour etre coherent avec le code (Phase 1: profondeur <= 2 = general d'abord).\n\n## Justification\n\nLe curriculum learning par profondeur est motive par l'observation empirique que les termes generaux (racines BPO/MFO/CCO) sont presque toujours positifs des qu'une proteine a une annotation dans l'ontologie, ce qui en fait des cibles triviales et peu informatives. En commencant par les feuilles, on force le modele a apprendre des representations discriminantes, puis on elargit aux termes generaux qui servent de contexte. Alternatives envisagees :\n- **Curriculum par frequence** (du rare au frequent) : essaye, resultats inferieurs car les termes rares sont trop difficiles isoles.\n- **Anti-curriculum** (du general au specifique) : defavorable car les racines sont apprises trop tot et surponderent la loss.\n- **Pas de curriculum** : convergence plus lente et Fmax final legerement inferieur (-0.5 a -1 point dans nos tests).\n\nLe curriculum par profondeur est inspire de Weibench et al. (2020) qui ont montre son efficacite sur les ontologies biologiques. Le nombre de phases est fixe a 3 (feuilles, termes intermediaires, tous termes) pour limiter la complexite.","metadata":{"id":"4uGwhKzCbS6i"}},{"cell_type":"code","source":"# ============================================================================\n# MODULE 15 - CURRICULUM LEARNING SUR PROFONDEUR DAG\n# ============================================================================\n# Entrainement progressif: termes generaux d'abord, specifiques ensuite.\n# Le curriculum suit la structure hierarchique du DAG GO:\n# Phase 1: Termes racines + profondeur <= 2 (fondations)\n# Phase 2: Termes de profondeur 3-4 (intermediaires)\n# Phase 3: Tous les termes (specifiques inclus)\n#\n# Justification: les termes profonds dependent des termes superficiels\n# (True Path Rule). Apprendre d'abord les parents facilite l\\'apprentissage\n# des enfants. C'est analogue a apprendre les concepts simples avant les\n# concepts complexes en pedagogie.\n#\n# Reference: Bengio et al. (2009) Curriculum Learning, ICML\n# Reference: Weinshall et al. (2018) Curriculum Learning by Transfer, ICML\n# ============================================================================\n\n# --- 15.1 Fonction de masquage des etiquettes selon la phase ---\n# Pendant chaque phase du curriculum, on ne calcule la perte que sur\n# les termes actifs (ceux dont la profondeur est <= prof_max).\n# Les termes inactifs sont masques (poids = 0 dans la perte).\n\ndef appliquer_masque_curriculum(etiquettes, masque, predictions):\n '''\n Applique le masque du curriculum learning aux etiquettes et predictions.\n Les termes inactifs (profondeur > prof_max) sont ignores dans la perte.\n\n Le masque est un vecteur binaire de dimension C (nombre de termes):\n - 1 pour les termes actifs (perte calculee)\n - 0 pour les termes inactifs (perte ignoree)\n\n On applique le masque en multipliant element-par-element, ce qui\n met a zero les contributions des termes inactifs dans la perte.\n\n Parametres:\n etiquettes: torch.Tensor - etiquettes completes (batch, C)\n masque: numpy.ndarray - masque binaire (C,), 1=actif, 0=inactif\n predictions: torch.Tensor - predictions completes (batch, C)\n\n Retourne:\n tuple - (etiquettes_masquees, predictions_masquees)\n '''\n # Convertir le masque en tensor et deplacer sur le device\n masque_t = torch.FloatTensor(masque).to(DEVICE) # Tensor du masque\n\n # Appliquer le masque: multiplier par 0 les termes inactifs\n # unsqueeze(0) pour broadcaster sur la dimension batch\n etiquettes_m = etiquettes * masque_t.unsqueeze(0) # Masquer etiquettes\n predictions_m = predictions * masque_t.unsqueeze(0) # Masquer predictions\n\n return etiquettes_m, predictions_m\n# --- 15.2 Generer les masques curriculum pour chaque phase ---\n# Pour chaque phase, on cree un masque binaire sur les termes GO.\n# Un terme est actif si sa profondeur <= prof_max de la phase.\n\nprint('[CURRICULUM] Generation des masques par phase...')\n\n# V17d: Diagnostic + reparation vec_prof si toutes les profondeurs sont <= 2\n# (bug observe: vec_prof peut etre tout a 0 si Module 5 pas execute dans la meme session)\nif vec_prof.max() <= 2 and len(vec_prof) > 100:\n print(f' [ATTENTION] vec_prof max={vec_prof.max()} — probablement incorrect.')\n print(f' [REPARATION] Recalcul des profondeurs depuis profondeur_go...')\n for i, t in enumerate(liste_termes):\n vec_prof[i] = profondeur_go.get(t, 0)\n print(f' [REPARATION] vec_prof apres recalcul: min={vec_prof.min()}, max={vec_prof.max()}, mean={vec_prof.mean():.1f}')\n # Si toujours tout a 0, refaire le BFS\n if vec_prof.max() == 0:\n print(f' [REPARATION] profondeur_go vide — recalcul BFS complet...')\n profondeur_go_local = {}\n for nom_ont, racine in ONTOLOGIES.items():\n if racine not in go_dag:\n continue\n file_bfs = [(racine, 0)]\n visites = set()\n while file_bfs:\n terme_bfs, prof_bfs = file_bfs.pop(0)\n if terme_bfs in visites:\n continue\n visites.add(terme_bfs)\n profondeur_go_local[terme_bfs] = prof_bfs\n for enfant in go_dag.successors(terme_bfs): # FIX V23-B (audit): successors, pas predecessors\n if enfant not in visites:\n file_bfs.append((enfant, prof_bfs + 1))\n for i, t in enumerate(liste_termes):\n vec_prof[i] = profondeur_go_local.get(t, 0)\n print(f' [REPARATION] vec_prof BFS: min={vec_prof.min()}, max={vec_prof.max()}, mean={vec_prof.mean():.1f}')\n\nmasques_curriculum = [] # Liste des masques (1 par phase)\n\nfor i, phase in enumerate(CURRICULUM_PHASES): # Pour chaque phase\n prof_max_phase = phase['prof_max'] # Profondeur max de la phase\n\n # Creer le masque: 1 si profondeur <= prof_max, 0 sinon\n masque = (vec_prof <= prof_max).astype(np.float32) # Masque binaire\n\n # Compter les termes actifs\n n_actifs = int(masque.sum()) # Nombre de termes actifs\n n_inactifs = int((1 - masque).sum()) # Nombre de termes inactifs\n pct_actif = 100 * n_actifs / len(masque)\n masques_curriculum.append(masque)\n print(f' {phase[\"nom\"]}: {n_actifs:,} termes actifs ({pct_actif:.1f}%), '\n f'{n_inactifs:,} inactifs, prof_max={prof_max_phase}')\n\n# --- 15.3 Generateur de schedule du curriculum ---\n# Determine quelle phase du curriculum est active a chaque epoque\n\ndef obtenir_phase_curriculum(epoque, phases):\n '''\n Determine la phase du curriculum pour une epoque donnee.\n\n Le schedule est pre-defini dans CURRICULUM_PHASES (Module 2).\n Chaque phase a un nombre d'epoques et une profondeur max.\n On passe a la phase suivante quand les epoques de la phase sont ecoulees.\n\n Parametres:\n epoque: int - epoque courante (0-indexed)\n phases: list - liste des phases avec epoques et profondeurs\n\n Retourne:\n dict - phase active (nom, prof_max, masque, phase_idx)\n '''\n epoque_cumulee = 0 # Epoque cumulee pour determiner la phase\n for i, phase in enumerate(phases): # Pour chaque phase\n epoque_cumulee += phase['epoques'] # Ajouter les epoques de la phase\n if epoque < epoque_cumulee: # Si on est dans cette phase\n return { # Retourner les infos de la phase\n 'nom': phase['nom'], # Nom de la phase\n 'prof_max': phase['prof_max'], # Profondeur max\n 'masque': masques_curriculum[i], # Masque des termes actifs\n 'phase_idx': i, # Index de la phase\n } # Fin du retour\n # Si on depasse toutes les phases, utiliser la derniere (tous termes)\n return { # Phase par defaut (derniere)\n 'nom': phases[-1]['nom'],\n 'prof_max': phases[-1]['prof_max'], # Profondeur max\n 'masque': masques_curriculum[-1],\n 'phase_idx': len(phases) - 1,\n } # Fin du retour\n\n# --- 15.4 Verifier le curriculum ---\nprint('\\n[CURRICULUM] Verification du schedule:')\nfor epoque_test in range(EPOQUES): # Pour chaque epoque\n phase = obtenir_phase_curriculum(epoque_test, CURRICULUM_PHASES)\n n_actifs = int(phase['masque'].sum()) # Termes actifs\n if epoque_test % 5 == 0 or epoque_test == EPOQUES - 1: # Afficher quelques-unes\n print(f' Epoque {epoque_test:2d}: {phase[\"nom\"]} ({n_actifs:,} termes actifs)')\n\n# --- 15.5 Figure du schedule curriculum ---\nfig, axes = plt.subplots(1, 3, figsize=(18, 5)) # 3 sous-graphiques\n\n# 15a: Nombre de termes actifs par epoque\ntermes_actifs_par_epoque = []\nfor ep in range(EPOQUES): # Pour chaque epoque\n phase = obtenir_phase_curriculum(ep, CURRICULUM_PHASES)\n termes_actifs_par_epoque.append(int(phase['masque'].sum()))\naxes[0].plot(range(EPOQUES), termes_actifs_par_epoque, 'b-o', markersize=3)\n# Colorier les phases\ncouleurs_phase = ['#e74c3c', '#f39c12', '#2ecc71']\nepoque_cumulee = 0 # Epoque cumulee\nfor i, phase in enumerate(CURRICULUM_PHASES): # Pour chaque phase\n debut = epoque_cumulee\n fin = epoque_cumulee + phase['epoques']\n axes[0].axvspan(debut, fin, alpha=0.15, color=couleurs_phase[i % len(couleurs_phase)],\n label=phase['nom']) # Zone coloree\n epoque_cumulee = fin # Mettre a jour\naxes[0].set_xlabel('Epoque') # Axe X\naxes[0].set_ylabel('Nombre de termes actifs') # Axe Y\naxes[0].set_title('Curriculum: termes actifs par epoque')\naxes[0].legend(loc='best', fontsize=8)\n# 15b: Distribution des profondeurs dans le DAG\naxes[1].hist(vec_prof, bins=range(0, int(vec_prof.max()) + 2), color='teal', alpha=0.8)\nfor i, phase in enumerate(CURRICULUM_PHASES): # Pour chaque phase\n axes[1].axvline(x=phase['prof_max'], color=couleurs_phase[i % len(couleurs_phase)],\n linestyle='--', linewidth=2, label=f'{phase[\"nom\"]} (prof<={phase[\"prof_max\"]})')\naxes[1].set_xlabel('Profondeur dans le DAG') # Axe X\naxes[1].set_ylabel('Nombre de termes') # Axe Y\naxes[1].set_title('Distribution des profondeurs DAG')\naxes[1].legend(loc='best', fontsize=8)\n# 15c: Profondeur max par phase (barres)\nnoms_phases = [p['nom'] for p in CURRICULUM_PHASES]\nprofs_max = [p['prof_max'] for p in CURRICULUM_PHASES] # Prof max\nepoques_phases = [p['epoques'] for p in CURRICULUM_PHASES]\naxes[2].bar(range(len(noms_phases)), profs_max, color=couleurs_phase[:len(noms_phases)])\naxes[2].set_xticks(range(len(noms_phases)))\naxes[2].set_xticklabels([n[:20] for n in noms_phases], fontsize=8, rotation=15)\naxes[2].set_ylabel('Profondeur max') # Axe Y\naxes[2].set_title('Profondeur max par phase')\n# Ajouter le nombre d'epoques sur les barres\nfor i, (prof, ep) in enumerate(zip(profs_max, epoques_phases)): # Pour chaque barre\n axes[2].text(i, prof + 0.3, f'{ep} epoques', ha='center', fontsize=9)\nplt.tight_layout()\nplt.savefig(CHEMIN_IMAGES + 'curriculum_schedule.png', dpi=150, bbox_inches='tight')\nplt.show()\nprint('[FIGURE] curriculum_schedule.png sauvegardee')\n\nprint('[OK] Module 15: Curriculum Learning configure et verifie')","metadata":{"id":"jvm4m70rbS6n","trusted":true,"execution":{"iopub.status.busy":"2026-07-31T18:14:22.919807Z","iopub.execute_input":"2026-07-31T18:14:22.920141Z","iopub.status.idle":"2026-07-31T18:14:23.955712Z","shell.execute_reply.started":"2026-07-31T18:14:22.920117Z","shell.execute_reply":"2026-07-31T18:14:23.954633Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module 16 — Boucle d'entrainement\n\nBoucle d'entrainement principale. Combine tous les composants definis\njusqu'ici : DAGNet (Module 10), IA-Aware Attention (Module 11), GNN\nheterogene (Module 12) en option, MAML (Module 13) en option pour les\ntermes rares, perte combinee (Module 14), curriculum learning (Module 15).\n\n## Optimiseur et scheduler\n\nAdamW avec weight decay 1e-2 et cosine annealing sur le learning rate.\nEarly stopping avec patience 5 epoques sur la perte de validation.\n\n## AMP\n\nAutomatic Mixed Precision (FP16) active si GPU disponible, pour diviser\npar deux la consommation memoire et accelerer les forward/backward.\n\n## Checkpoints\n\nSauvegarde d'un checkpoint par epoque + d'un checkpoint tous les 1000 pas\nd'optimisation. Permet de reprendre apres une interruption de session Kaggle\n(qui tue les notebooks au bout de 12h). Les step-checkpoints anciens sont\nnettoyes automatiquement (on garde les 2 plus recents).\n\n## Principe\n\nLa boucle d'entrainement combine plusieurs techniques modernes : (1) AdamW comme optimiseur, (2) scheduler cosine annealing avec warmup, (3) Automatic Mixed Precision (AMP) via torch.cuda.amp, (4) accumulation de gradient pour simuler un batch plus grand, (5) Early stopping sur la perte de validation (perte_val_moy), patience=5 epochs. FIX V23 (audit): markdown disait 'Fmax' mais le code utilise la perte. Pour early-stopper sur Fmax, modifier la boucle d'entrainement (Module 16).\n\n## Justification\n\nChaque composant adresse un besoin specifique :\n- **AdamW** est preferable a Adam car il decouple la regularisation L2 du moment d'ordre 2, ce qui evite le biais de poids. SGD avec momentum est ecarte car il converge plus lentement sur les modeles avec normalisation (BatchNorm).\n- **Cosine annealing + warmup** : le warmup (10% des steps) evite l'explosion du gradient en debut d'entrainement quand les poids sont aleatoires. Le cosine annealing permet une decroissance douce du taux d'apprentissage, meilleure que StepLR ou ExponentialLR pour les modeles longs a converger.\n- **AMP** : reduit la memoire GPU de ~40% et accelere de ~2x sur T4/V100. Indispensable pour batch_size=32 avec ESM-2 650M.\n- **Gradient accumulation** : permet un batch effectif de 256 (8 micro-batches de 32) sans depasser la VRAM, ce qui stabilise le gradient sur les termes rares.\n- **SWA** : moyenne les poids des derniers epochs, reduit la variance de ~30% et ameliore la generalisation.\n- **Early stopping** : evite l'overfitting, surveille le Fmax sur le set de validation avec patience=5 epochs.","metadata":{"id":"bj_mEQlnbS6q"}},{"cell_type":"code","source":"\n# MODULE 16 - MEMORY-SAFE TRAINING LOOP (ESM-2/LoRA + DAGNet, NO GNN)\nfrom copy import deepcopy\n\ndef _csr_batch(y_csr, indices, device):\n \"\"\"Densify only the current CSR batch, never a fold or the complete label matrix.\"\"\"\n return torch.from_numpy(y_csr[indices].toarray().astype(np.float32, copy=False)).to(device, non_blocking=True)\n\ndef _masked_ia_bce(logits, targets, ia, active_mask):\n weights = ia * active_mask\n denom = weights.sum().clamp_min(1.0)\n loss = F.binary_cross_entropy_with_logits(logits, targets, reduction=\"none\")\n return (loss * weights.unsqueeze(0)).sum() / (targets.shape[0] * denom)\n\ndef entrainer_modele(modele, X_train_fold, Y_train_fold, X_val_fold, Y_val_fold,\n groupes_fold=None, ia_tens=None, parents_idx=None, profondeurs=None,\n n_termes=None, n_epoques=EPOQUES, patience=PATIENCE,\n dossier_checkpoint=CHEMIN_CHECKPOINTS, fold_courant=0,\n gnn_modele=None, graphe_fold=None, device=None,\n utiliser_curriculum=True, utiliser_ia=True):\n \"\"\"Train one fold without whole-fold GPU copies or GNN state.\n\n `gnn_modele` and `graphe_fold` remain only for backward-compatible callers and\n must be None. Validation returns a disk-backed prediction file when requested\n by the CV cell, so this routine retains only scalar validation loss.\n \"\"\"\n assert gnn_modele is None and graphe_fold is None, \"The production pipeline does not support GNN\"\n device = device or DEVICE\n modele = modele.to(device)\n optimizer = AdamW(modele.parameters(), lr=LR, weight_decay=WEIGHT_DECAY)\n amp_enabled = device.type == \"cuda\"\n grad_scaler = torch.amp.GradScaler(\"cuda\", enabled=amp_enabled)\n accumulation = 4\n batch_size = min(BATCH_SIZE, 16)\n ia = ia_tens.to(device, non_blocking=True) if ia_tens is not None else torch.ones(n_termes, device=device)\n if not utiliser_ia:\n ia = torch.ones_like(ia)\n history = {\"perte_train\": [], \"perte_val\": [], \"lr\": []}\n best_loss, best_state, stale = float(\"inf\"), None, 0\n rng = np.random.default_rng(SEED_GLOBAL + fold_courant)\n\n for epoch in range(n_epoques):\n phase = obtenir_phase_curriculum(epoch, CURRICULUM_PHASES) if utiliser_curriculum else {\"masque\": np.ones(n_termes, dtype=np.float32)}\n active = torch.as_tensor(phase[\"masque\"], dtype=torch.float32, device=device)\n order = rng.permutation(len(X_train_fold))\n modele.train(); optimizer.zero_grad(set_to_none=True)\n train_loss = 0.0\n for step, start in enumerate(range(0, len(order), batch_size)):\n ids = order[start:start + batch_size]\n x = torch.from_numpy(np.asarray(X_train_fold[ids], dtype=np.float32)).to(device, non_blocking=True)\n y = _csr_batch(Y_train_fold, ids, device)\n with torch.autocast(device_type=device.type, dtype=torch.float16, enabled=amp_enabled):\n raw = forward_modele_complet(modele, x, parents_par_idx, len(liste_termes), vec_prof)\n # Existing models return probabilities; convert safely back to logits.\n logits = torch.logit(raw.clamp(1e-5, 1 - 1e-5))\n loss = _masked_ia_bce(logits, y, ia, active) / accumulation\n grad_scaler.scale(loss).backward()\n if (step + 1) % accumulation == 0 or start + batch_size >= len(order):\n grad_scaler.unscale_(optimizer)\n torch.nn.utils.clip_grad_norm_(modele.parameters(), 1.0)\n grad_scaler.step(optimizer); grad_scaler.update(); optimizer.zero_grad(set_to_none=True)\n train_loss += loss.item() * accumulation\n\n modele.eval(); val_sum = 0.0; val_count = 0\n with torch.inference_mode():\n for start in range(0, len(X_val_fold), batch_size * 2):\n ids = np.arange(start, min(start + batch_size * 2, len(X_val_fold)))\n x = torch.from_numpy(np.asarray(X_val_fold[ids], dtype=np.float32)).to(device, non_blocking=True)\n y = _csr_batch(Y_val_fold, ids, device)\n with torch.autocast(device_type=device.type, dtype=torch.float16, enabled=amp_enabled):\n raw = forward_modele_complet(modele, x, parents_par_idx, len(liste_termes), vec_prof)\n logits = torch.logit(raw.clamp(1e-5, 1 - 1e-5))\n value = _masked_ia_bce(logits, y, ia, active)\n val_sum += value.item() * len(ids); val_count += len(ids)\n val_loss = val_sum / max(val_count, 1)\n history[\"perte_train\"].append(train_loss / max(1, (len(order) + batch_size - 1) // batch_size))\n history[\"perte_val\"].append(val_loss); history[\"lr\"].append(optimizer.param_groups[0][\"lr\"])\n print(f\"[fold {fold_courant + 1}] epoch={epoch + 1} train={history['perte_train'][-1]:.5f} val={val_loss:.5f}\")\n if val_loss < best_loss - 1e-5:\n best_loss, stale = val_loss, 0\n best_state = {k: v.detach().cpu().clone() for k, v in modele.state_dict().items()}\n else:\n stale += 1\n if stale >= patience:\n break\n modele.load_state_dict(best_state)\n return history, best_loss\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T18:14:23.956979Z","iopub.execute_input":"2026-07-31T18:14:23.957325Z","iopub.status.idle":"2026-07-31T18:14:23.975983Z","shell.execute_reply.started":"2026-07-31T18:14:23.957302Z","shell.execute_reply":"2026-07-31T18:14:23.975072Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"\n# MODULE 16 - MEMORY-SAFE TRAINING LOOP (ESM-2/LoRA + DAGNet, NO GNN)\nfrom copy import deepcopy\n\ndef _csr_batch(y_csr, indices, device):\n \"\"\"Densify only the current CSR batch, never a fold or the complete label matrix.\"\"\"\n return torch.from_numpy(y_csr[indices].toarray().astype(np.float32, copy=False)).to(device, non_blocking=True)\n\ndef _masked_ia_bce(logits, targets, ia, active_mask):\n weights = ia * active_mask\n denom = weights.sum().clamp_min(1.0)\n loss = F.binary_cross_entropy_with_logits(logits, targets, reduction=\"none\")\n return (loss * weights.unsqueeze(0)).sum() / (targets.shape[0] * denom)\n\ndef entrainer_modele(modele, X_train_fold, Y_train_fold, X_val_fold, Y_val_fold,\n groupes_fold=None, ia_tens=None, parents_idx=None, profondeurs=None,\n n_termes=None, n_epoques=EPOQUES, patience=PATIENCE,\n dossier_checkpoint=CHEMIN_CHECKPOINTS, fold_courant=0,\n gnn_modele=None, graphe_fold=None, device=None,\n utiliser_curriculum=True, utiliser_ia=True):\n \"\"\"Train one fold without whole-fold GPU copies or GNN state.\n\n `gnn_modele` and `graphe_fold` remain only for backward-compatible callers and\n must be None. Validation returns a disk-backed prediction file when requested\n by the CV cell, so this routine retains only scalar validation loss.\n \"\"\"\n assert gnn_modele is None and graphe_fold is None, \"The production pipeline does not support GNN\"\n device = device or DEVICE\n modele = modele.to(device)\n optimizer = AdamW(modele.parameters(), lr=LR, weight_decay=WEIGHT_DECAY)\n amp_enabled = device.type == \"cuda\"\n grad_scaler = torch.amp.GradScaler(\"cuda\", enabled=amp_enabled)\n accumulation = 4\n batch_size = min(BATCH_SIZE, 16)\n ia = ia_tens.to(device, non_blocking=True) if ia_tens is not None else torch.ones(n_termes, device=device)\n if not utiliser_ia:\n ia = torch.ones_like(ia)\n history = {\"perte_train\": [], \"perte_val\": [], \"lr\": []}\n best_loss, best_state, stale = float(\"inf\"), None, 0\n rng = np.random.default_rng(SEED_GLOBAL + fold_courant)\n\n for epoch in range(n_epoques):\n phase = obtenir_phase_curriculum(epoch, CURRICULUM_PHASES) if utiliser_curriculum else {\"masque\": np.ones(n_termes, dtype=np.float32)}\n active = torch.as_tensor(phase[\"masque\"], dtype=torch.float32, device=device)\n order = rng.permutation(len(X_train_fold))\n modele.train(); optimizer.zero_grad(set_to_none=True)\n train_loss = 0.0\n for step, start in enumerate(range(0, len(order), batch_size)):\n ids = order[start:start + batch_size]\n x = torch.from_numpy(np.asarray(X_train_fold[ids], dtype=np.float32)).to(device, non_blocking=True)\n y = _csr_batch(Y_train_fold, ids, device)\n with torch.autocast(device_type=device.type, dtype=torch.float16, enabled=amp_enabled):\n raw = forward_modele_complet(modele, x, parents_par_idx, len(liste_termes), vec_prof)\n # Existing models return probabilities; convert safely back to logits.\n logits = torch.logit(raw.clamp(1e-5, 1 - 1e-5))\n loss = _masked_ia_bce(logits, y, ia, active) / accumulation\n grad_scaler.scale(loss).backward()\n if (step + 1) % accumulation == 0 or start + batch_size >= len(order):\n grad_scaler.unscale_(optimizer)\n torch.nn.utils.clip_grad_norm_(modele.parameters(), 1.0)\n grad_scaler.step(optimizer); grad_scaler.update(); optimizer.zero_grad(set_to_none=True)\n train_loss += loss.item() * accumulation\n\n modele.eval(); val_sum = 0.0; val_count = 0\n with torch.inference_mode():\n for start in range(0, len(X_val_fold), batch_size * 2):\n ids = np.arange(start, min(start + batch_size * 2, len(X_val_fold)))\n x = torch.from_numpy(np.asarray(X_val_fold[ids], dtype=np.float32)).to(device, non_blocking=True)\n y = _csr_batch(Y_val_fold, ids, device)\n with torch.autocast(device_type=device.type, dtype=torch.float16, enabled=amp_enabled):\n raw = forward_modele_complet(modele, x, parents_par_idx, len(liste_termes), vec_prof)\n logits = torch.logit(raw.clamp(1e-5, 1 - 1e-5))\n value = _masked_ia_bce(logits, y, ia, active)\n val_sum += value.item() * len(ids); val_count += len(ids)\n val_loss = val_sum / max(val_count, 1)\n history[\"perte_train\"].append(train_loss / max(1, (len(order) + batch_size - 1) // batch_size))\n history[\"perte_val\"].append(val_loss); history[\"lr\"].append(optimizer.param_groups[0][\"lr\"])\n print(f\"[fold {fold_courant + 1}] epoch={epoch + 1} train={history['perte_train'][-1]:.5f} val={val_loss:.5f}\")\n if val_loss < best_loss - 1e-5:\n best_loss, stale = val_loss, 0\n best_state = {k: v.detach().cpu().clone() for k, v in modele.state_dict().items()}\n else:\n stale += 1\n if stale >= patience:\n break\n modele.load_state_dict(best_state)\n return history, best_loss\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T18:14:23.977982Z","iopub.execute_input":"2026-07-31T18:14:23.978389Z","iopub.status.idle":"2026-07-31T18:14:23.997836Z","shell.execute_reply.started":"2026-07-31T18:14:23.978361Z","shell.execute_reply":"2026-07-31T18:14:23.997063Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# ============================================================================\n# MODULE 17 — METRIQUES CAFA (Fmax-IA, Smin-IA) [V26 — chunked sparse-safe]\n# ============================================================================\n# Metriques officielles CAFA ponderees par l'Information Accretion.\n# Reference: Radivojac et al. (2013) Nature Methods 10(3)\n# Reference: Clark & Radivojac (2013) Bioinformatics 29(13)\n#\n# V26 (CRITIQUE RAM): les fonctions V25 appelaient etiquettes.toarray() sur la\n# matrice COMPLETE (28k x 8000 x 4 = 900 Mo par appel) puis allouaient des\n# matrices (N, C) float a chaque seuil. Sur 5 folds x 4 appels, cela fait\n# ~18 Go de churn → OOM sur 30 Go Kaggle.\n# V26 traite par CHUNKS de proteines (default 4000), en ne materialisant\n# qu'un chunk dense a la fois (~130 Mo max). Compatible sparse CSR.\n# ============================================================================\n\nCHUNK_FMAX = 4000 # V26: nb de proteines traitees en parallel (RAM-bound)\n\n\ndef _densifier_chunk(etiquettes_chunk):\n \"\"\"Convertit un sous-ensemble (sparse ou dense) en ndarray dense float32.\"\"\"\n import scipy.sparse as _sp\n if _sp.issparse(etiquettes_chunk):\n return etiquettes_chunk.toarray().astype(np.float32)\n return np.asarray(etiquettes_chunk, dtype=np.float32)\n\n\ndef calculer_fmax_ia(predictions, etiquettes, ia_vecteur, seuils,\n chunk_size=CHUNK_FMAX):\n \"\"\"\n Fmax-IA (protein-centric, Radivojac 2013) — version chunked V26.\n\n Accumule par chunk de proteines :\n - ia_tp_par_prot (somme IA des vrais positifs, par proteine)\n - ia_pred_par_prot (somme IA des termes predits, par proteine)\n - ia_vrai_par_prot (somme IA des vraies annotations, par proteine)\n puis combine a la fin. Aucune matrice (N, C) dense n'est materialisee\n en entier.\n\n Parametres:\n predictions: ndarray (N, C) dans [0,1]\n etiquettes: ndarray (N, C) OU scipy.sparse.csr_matrix\n ia_vecteur: ndarray (C,)\n seuils: ndarray (T,) des seuils de decision\n\n Retourne:\n dict {fmax, seuil_optimal, precision_max, rappel_max,\n precisions, rappels, f_scores}\n \"\"\"\n n_proteines, n_termes = predictions.shape\n ia = np.asarray(ia_vecteur[:n_termes], dtype=np.float32)\n seuils = np.asarray(seuils, dtype=np.float32)\n n_seuils = len(seuils)\n\n # Accumulateurs par proteine (N,) — evite la matrice (N, C, T)\n ia_vrai_par_prot = np.zeros(n_proteines, dtype=np.float64)\n # Pour chaque seuil t, on garde (N,) pour pred / tp\n ia_pred_par_prot_t = np.zeros((n_seuils, n_proteines), dtype=np.float64)\n ia_tp_par_prot_t = np.zeros((n_seuils, n_proteines), dtype=np.float64)\n\n for debut in range(0, n_proteines, chunk_size):\n fin = min(debut + chunk_size, n_proteines)\n preds_chunk = predictions[debut:fin] # (B, C) — déjà dense\n # Y est CSR: seule la tranche (B,C) est densifiée. Le budget interdit Y_train dense.\n budget_dense(fin - debut, n_termes, label='Fmax-IA: labels chunk')\n labels_chunk = _densifier_chunk(etiquettes[debut:fin]) # (B, C) dense\n labels_bin_chunk = (labels_chunk > 0)\n\n # IA des vraies annotations par proteine du chunk\n ia_vrai_par_prot[debut:fin] = (labels_bin_chunk * ia).sum(axis=1)\n\n # Pour chaque seuil : binariser predictions et accumuler\n for t_idx, t in enumerate(seuils):\n preds_bin = (preds_chunk >= t) # (B, C) bool\n ia_pred = (preds_bin * ia).sum(axis=1) # (B,)\n ia_tp = ((preds_bin & labels_bin_chunk) * ia).sum(axis=1) # (B,)\n ia_pred_par_prot_t[t_idx, debut:fin] = ia_pred\n ia_tp_par_prot_t[t_idx, debut:fin] = ia_tp\n del preds_chunk, labels_chunk, labels_bin_chunk\n\n masque_annotees = ia_vrai_par_prot > 0\n n_annote = int(masque_annotees.sum())\n\n precisions_moy = []\n rappels_moy = []\n for t_idx in range(n_seuils):\n ia_pred = ia_pred_par_prot_t[t_idx]\n ia_tp = ia_tp_par_prot_t[t_idx]\n masque_pred = ia_pred > 0\n m_t = int(masque_pred.sum())\n if m_t > 0:\n pr_i = np.where(masque_pred, ia_tp / np.maximum(ia_pred, 1e-12), 0.0)\n avg_pr = pr_i[masque_pred].sum() / m_t\n else:\n avg_pr = 0.0\n if n_annote > 0:\n rc_i = np.where(masque_annotees,\n ia_tp / np.maximum(ia_vrai_par_prot, 1e-12), 0.0)\n avg_rc = rc_i[masque_annotees].sum() / n_annote\n else:\n avg_rc = 0.0\n precisions_moy.append(avg_pr)\n rappels_moy.append(avg_rc)\n\n f_scores = [2*p*r/(p+r) if (p+r) > 0 else 0.0\n for p, r in zip(precisions_moy, rappels_moy)]\n fmax = max(f_scores)\n idx_optimal = f_scores.index(fmax)\n return {\n 'fmax': fmax,\n 'seuil_optimal': float(seuils[idx_optimal]),\n 'precision_max': precisions_moy[idx_optimal],\n 'rappel_max': rappels_moy[idx_optimal],\n 'precisions': precisions_moy,\n 'rappels': rappels_moy,\n 'f_scores': f_scores,\n }\n\n\ndef calculer_smin_ia(predictions, etiquettes, ia_vecteur, seuils,\n chunk_size=CHUNK_FMAX):\n \"\"\"\n Smin-IA (Clark & Radivojac 2013) — version chunked V26.\n\n RU(t) = (1/n) * sum_i sum_f IA_f * 1[f vrai ET non predit]\n MI(t) = (1/n) * sum_i sum_f IA_f * 1[f predit ET non vrai]\n S(t) = sqrt(RU^2 + MI^2); Smin = min_t S(t)\n\n Retourne:\n dict {smin, seuil_optimal, distances}\n \"\"\"\n n_proteines, n_termes = predictions.shape\n ia = np.asarray(ia_vecteur[:n_termes], dtype=np.float32)\n seuils = np.asarray(seuils, dtype=np.float32)\n n_seuils = len(seuils)\n\n ru_t = np.zeros(n_seuils, dtype=np.float64)\n mi_t = np.zeros(n_seuils, dtype=np.float64)\n\n for debut in range(0, n_proteines, chunk_size):\n fin = min(debut + chunk_size, n_proteines)\n preds_chunk = predictions[debut:fin]\n labels_chunk = _densifier_chunk(etiquettes[debut:fin])\n labels_bin_chunk = (labels_chunk > 0)\n for t_idx, t in enumerate(seuils):\n preds_bin = (preds_chunk >= t)\n # RU = IA des FN (vrai ET non predit)\n fn_mask = labels_bin_chunk & (~preds_bin)\n ru_t[t_idx] += (fn_mask * ia).sum()\n # MI = IA des FP (predit ET non vrai)\n fp_mask = preds_bin & (~labels_bin_chunk)\n mi_t[t_idx] += (fp_mask * ia).sum()\n del preds_chunk, labels_chunk, labels_bin_chunk\n\n ru_t /= max(n_proteines, 1)\n mi_t /= max(n_proteines, 1)\n distances = np.sqrt(ru_t**2 + mi_t**2).tolist()\n smin = min(distances)\n idx_optimal = distances.index(smin)\n return {\n 'smin': smin,\n 'seuil_optimal': float(seuils[idx_optimal]),\n 'distances': distances,\n }\n\n\n# --- Tests unitaires deterministes (inchanges) ---\ndef test_fmax_cas_parfait():\n ia_t = np.array([1.0, 1.0], dtype=np.float32)\n etiquettes_t = np.array([[1, 0], [1, 1], [0, 1]], dtype=np.float32)\n predictions_t = np.array([[0.9, 0.1], [0.8, 0.7], [0.2, 0.6]], dtype=np.float32)\n seuils_t = np.array([0.5], dtype=np.float32)\n res = calculer_fmax_ia(predictions_t, etiquettes_t, ia_t, seuils_t)\n assert abs(res['fmax'] - 1.0) < 1e-6, f\"ECHEC: Fmax attendu=1.0, obtenu={res['fmax']}\"\n print(f\" [TEST 1/2] Fmax sur predictions parfaites: {res['fmax']:.6f} (attendu: 1.0) -- OK\")\n\ndef test_smin_cas_calcule_a_la_main():\n ia_t = np.array([1.0, 1.0], dtype=np.float32)\n etiquettes_t = np.array([[1, 0], [0, 1]], dtype=np.float32)\n predictions_t = np.array([[0.0, 0.0], [1.0, 1.0]], dtype=np.float32)\n seuils_t = np.array([0.5], dtype=np.float32)\n res = calculer_smin_ia(predictions_t, etiquettes_t, ia_t, seuils_t)\n attendu = np.sqrt(0.5)\n assert abs(res['smin'] - attendu) < 1e-4, f\"ECHEC: Smin attendu={attendu:.6f}, obtenu={res['smin']}\"\n print(f\" [TEST 2/2] Smin sur cas calcule a la main: {res['smin']:.6f} (attendu: {attendu:.6f}) -- OK\")\n\n\nprint('[TESTS] Validation des metriques CAFA sur cas connus...')\ntest_fmax_cas_parfait()\ntest_smin_cas_calcule_a_la_main()\n\n# Sanity check sur echantillon reel (200 proteines) — auto-prediction → Fmax=1, Smin=0\n_n_echantillon_controle = min(200, X_train.shape[0])\n_idx_controle = np.random.RandomState(GRAINE).choice(\n X_train.shape[0], _n_echantillon_controle, replace=False\n)\n_labels_controle = Y_train[_idx_controle].toarray().astype(np.float32)\n_preds_controle = _labels_controle.copy()\n\nresultats_fmax = calculer_fmax_ia(_preds_controle, _labels_controle, vec_ia, SEUILS_CAFA)\nresultats_smin = calculer_smin_ia(_preds_controle, _labels_controle, vec_ia, SEUILS_CAFA)\n\nassert abs(resultats_fmax['fmax'] - 1.0) < 1e-4, \"ECHEC SANITE: Fmax devrait etre 1.0\"\nassert resultats_smin['smin'] < 1e-4, \"ECHEC SANITE: Smin devrait etre 0.0\"\nprint(f'[METRIQUES] Controle (auto-prediction sur {_n_echantillon_controle} proteines): '\n f'Fmax-IA={resultats_fmax[\"fmax\"]:.4f} | Smin-IA={resultats_smin[\"smin\"]:.4f} (attendu: 1.0 / 0.0)')\nprint('[OK] Module 17 (V26): Metriques CAFA chunked, sparse-safe, validées')\n\n","metadata":{"id":"mgeGxxwzbS6s","trusted":true,"execution":{"iopub.status.busy":"2026-07-31T18:14:23.998862Z","iopub.execute_input":"2026-07-31T18:14:23.99917Z","iopub.status.idle":"2026-07-31T18:14:24.560372Z","shell.execute_reply.started":"2026-07-31T18:14:23.99915Z","shell.execute_reply":"2026-07-31T18:14:24.559483Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# ============================================================================\n# DIAGNOSTIC PRE-MODULE-19 — Identifier ce qui sature deja la RAM\n# A executer JUSTE AVANT le module 19 (ou en tete de celui-ci)\n# ============================================================================\nimport sys\nimport gc\n\ndef _taille_objet_mo(obj):\n \"\"\"Estime la taille reelle d'un objet (numpy/torch/pandas/autre) en Mo.\"\"\"\n try:\n import numpy as np\n import torch\n if isinstance(obj, np.ndarray):\n return obj.nbytes / 1e6\n if isinstance(obj, torch.Tensor):\n return obj.element_size() * obj.nelement() / 1e6\n if hasattr(obj, 'memory_usage'): # pandas DataFrame/Series\n try:\n return obj.memory_usage(deep=True).sum() / 1e6\n except Exception:\n pass\n return sys.getsizeof(obj) / 1e6\n except Exception:\n return 0.0\n\nprint('[DIAG] Scan des objets en RAM (globals())...\\n')\n_objets = []\nfor _nom, _val in list(globals().items()):\n if _nom.startswith('_'):\n continue\n _taille = _taille_objet_mo(_val)\n if _taille > 50: # ne garder que ce qui pese plus de 50 Mo\n _objets.append((_nom, type(_val).__name__, _taille))\n\n_objets.sort(key=lambda x: -x[2])\n\nprint(f\"{'VARIABLE':<35} {'TYPE':<20} {'TAILLE (Go)':>12}\")\nprint('-' * 70)\n_total = 0\nfor _nom, _type, _taille in _objets:\n print(f'{_nom:<35} {_type:<20} {_taille/1000:>12.3f}')\n _total += _taille\nprint('-' * 70)\nprint(f'TOTAL objets > 50 Mo identifies: {_total/1000:.2f} Go')\n\ntry:\n import psutil\n print(f'\\nRAM totale utilisee par le process: '\n f'{psutil.Process().memory_info().rss/1e9:.2f} Go')\n print(f'RAM systeme totale: {psutil.virtual_memory().total/1e9:.1f} Go')\n print(f'RAM systeme utilisee: {psutil.virtual_memory().used/1e9:.1f} Go '\n f'({psutil.virtual_memory().percent:.0f}%)')\nexcept ImportError:\n pass\n\ndel _objets, _total","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T18:14:24.561596Z","iopub.execute_input":"2026-07-31T18:14:24.561948Z","iopub.status.idle":"2026-07-31T18:14:24.742629Z","shell.execute_reply.started":"2026-07-31T18:14:24.561926Z","shell.execute_reply":"2026-07-31T18:14:24.741906Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module 17b - Métriques étendues de recherche\n\nFmax-IA et Smin-IA restent les métriques de sélection CAFA. Les indicateurs\nci-dessous évaluent séparément le classement, la calibration, le coût et la\nstabilité. Les labels restent CSR : seules les colonnes nécessaires aux métriques\npar terme sont densifiées, jamais `Y_train` complet.\n","metadata":{}},{"cell_type":"code","source":"# AMELIORATION V32: métriques de recherche chunk/sparse-safe.\nfrom sklearn.metrics import roc_auc_score, average_precision_score, brier_score_loss\n\ndef calculer_precision_recall_at_k(predictions, y_csr, ks=(5, 10, 20)):\n \"\"\"Precision@k et Recall@k protein-centric; `y_csr` n'est jamais densifiée.\"\"\"\n assert sp.isspmatrix_csr(y_csr) and predictions.shape == y_csr.shape\n max_k = min(max(ks), predictions.shape[1])\n top = np.argpartition(-predictions, kth=max_k - 1, axis=1)[:, :max_k]\n rows = []\n for k in ks:\n k = min(k, predictions.shape[1])\n hit, predicted, relevant = 0, 0, 0\n for i in range(y_csr.shape[0]):\n truth = set(y_csr.indices[y_csr.indptr[i]:y_csr.indptr[i + 1]])\n selected = set(top[i, :k])\n hit += len(truth & selected); predicted += k; relevant += len(truth)\n rows.append({'k': k, 'precision_at_k': hit / max(predicted, 1), 'recall_at_k': hit / max(relevant, 1)})\n return pd.DataFrame(rows)\n\ndef calculer_map_proteine(predictions, y_csr, max_proteins=None):\n \"\"\"MAP protein-centric; AP=0 pour une protéine sans annotation de validation.\"\"\"\n assert sp.isspmatrix_csr(y_csr) and predictions.shape == y_csr.shape\n n = min(predictions.shape[0], max_proteins or predictions.shape[0])\n aps = []\n for i in range(n):\n truth = y_csr.indices[y_csr.indptr[i]:y_csr.indptr[i + 1]]\n if truth.size:\n labels = np.zeros(predictions.shape[1], dtype=np.uint8)\n labels[truth] = 1\n aps.append(average_precision_score(labels, predictions[i]))\n return float(np.mean(aps)) if aps else np.nan\n\ndef calculer_auc_par_terme(predictions, y_csr, term_indices=None):\n \"\"\"AUC-ROC/AUC-PR macro et pondérée; une colonne CSR à la fois limite la RAM.\"\"\"\n assert sp.isspmatrix_csr(y_csr) and predictions.shape == y_csr.shape\n indices = np.asarray(term_indices if term_indices is not None else np.arange(y_csr.shape[1]), dtype=np.int64)\n rows = []\n for j in indices:\n y = y_csr[:, j].toarray().ravel().astype(np.uint8, copy=False)\n if y.min() == y.max():\n continue # AUC indéfinie si le fold ne contient qu'une classe.\n score = predictions[:, j]\n rows.append({'term_idx': int(j), 'support': int(y.sum()), 'auc_roc': roc_auc_score(y, score),\n 'auc_pr': average_precision_score(y, score)})\n table = pd.DataFrame(rows)\n if table.empty:\n return table, {'auc_roc_macro': np.nan, 'auc_pr_macro': np.nan, 'auc_roc_weighted': np.nan, 'auc_pr_weighted': np.nan}\n w = table['support'].to_numpy(dtype=float)\n return table, {'auc_roc_macro': float(table.auc_roc.mean()), 'auc_pr_macro': float(table.auc_pr.mean()),\n 'auc_roc_weighted': float(np.average(table.auc_roc, weights=w)), 'auc_pr_weighted': float(np.average(table.auc_pr, weights=w))}\n\ndef calculer_calibration(predictions, y_csr, n_bins=15, max_pairs=1_000_000, seed=SEED_GLOBAL):\n \"\"\"ECE, Brier et données reliability diagram sur un échantillon uniforme de paires.\"\"\"\n assert sp.isspmatrix_csr(y_csr) and predictions.shape == y_csr.shape\n rng, (n, c) = np.random.default_rng(seed), predictions.shape\n count = min(max_pairs, n * c)\n linear = rng.integers(0, n * c, size=count)\n r, col = linear // c, linear % c\n p = np.clip(predictions[r, col].astype(np.float64), 0.0, 1.0)\n y = np.asarray(y_csr[r, col]).ravel().astype(np.uint8)\n bins = np.linspace(0, 1, n_bins + 1); rows = []; ece = 0.0\n for left, right in zip(bins[:-1], bins[1:]):\n mask = (p >= left) & (p < right if right < 1 else p <= right)\n if mask.any():\n confidence, accuracy, fraction = p[mask].mean(), y[mask].mean(), mask.mean()\n ece += fraction * abs(confidence - accuracy)\n rows.append({'bin_left': left, 'bin_right': right, 'confidence': confidence, 'accuracy': accuracy, 'fraction': fraction})\n return {'ece': float(ece), 'brier': float(brier_score_loss(y, p)), 'reliability': pd.DataFrame(rows)}\n\ndef mesurer_inference(fn, *args, **kwargs):\n \"\"\"Mesure temps et pic VRAM; la RAM process est fournie si psutil est installé.\"\"\"\n import time\n if torch.cuda.is_available(): torch.cuda.reset_peak_memory_stats()\n started = time.perf_counter(); output = fn(*args, **kwargs); elapsed = time.perf_counter() - started\n n = output.shape[0] if hasattr(output, 'shape') else np.nan\n report = {'inference_seconds': elapsed, 'milliseconds_per_protein': 1000 * elapsed / max(n, 1),\n 'peak_vram_gib': (torch.cuda.max_memory_allocated() / 2**30 if torch.cuda.is_available() else 0.0)}\n try:\n import psutil\n report['ram_process_gib'] = psutil.Process().memory_info().rss / 2**30\n except ImportError:\n report['ram_process_gib'] = np.nan\n return output, report\n\ndef calculer_stabilite_predictions(predictions_repetitions):\n \"\"\"Variance moyenne et écart-type des scores entre seeds/folds, mêmes N,C requis.\"\"\"\n stack = np.stack(predictions_repetitions).astype(np.float32, copy=False)\n assert stack.ndim == 3 and np.isfinite(stack).all()\n return {'prediction_variance_mean': float(stack.var(axis=0).mean()), 'prediction_std_mean': float(stack.std(axis=0).mean())}\n\ndef rapport_metriques_recherche(predictions, y_val, term_indices=None):\n \"\"\"Agrège les métriques complémentaires sur exactement le fold de validation CAFA.\"\"\"\n auc_table, auc_summary = calculer_auc_par_terme(predictions, y_val, term_indices)\n calibration = calculer_calibration(predictions, y_val)\n return {**auc_summary, 'map': calculer_map_proteine(predictions, y_val),\n 'precision_recall_at_k': calculer_precision_recall_at_k(predictions, y_val),\n 'ece': calibration['ece'], 'brier': calibration['brier'], 'reliability': calibration['reliability'],\n 'auc_by_term': auc_table}\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T18:14:24.743748Z","iopub.execute_input":"2026-07-31T18:14:24.744147Z","iopub.status.idle":"2026-07-31T18:14:24.767461Z","shell.execute_reply.started":"2026-07-31T18:14:24.744124Z","shell.execute_reply":"2026-07-31T18:14:24.766648Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module 18 — Bootstrap et conformal prediction\n\nEstimation de l'incertitude sur Fmax-IA et Smin-IA par bootstrap (Efron,\n1979) : on re-echantillonne les proteines avec remise, on recalcule les\nmetriques, et on extrait les quantiles 2.5% et 97.5% pour obtenir un\nintervalle de confiance a 95%.\n\nLa conformal prediction (Angelopoulos & Bates, 2022) fournit un cadre\ncomplementaire pour garantir statistiquement que les intervalles de\nprediction couvrent la vraie valeur avec une probabilite >= 1-alpha, sans\nhypothese distributionnelle.\n\n## Principe\n\nDeux methodes complementaires quantifient l'incertitude des predictions :\n1. **Bootstrap** : on re-echantillonne les predictions du set de validation B=1000 fois avec remise, et on calcule le Fmax sur chaque echantillon. L'intervalle de confiance a 95% est donne par les percentiles 2.5% et 97.5% de la distribution.\n2. **Conformal prediction** (Vovk et al., 2005) : pour chaque nouvelle proteine, on produit un ensemble de termes GO garantie contenir le vrai label avec une probabilite >= 1-alpha (typiquement alpha=0.1).\n\n## Justification\n\nL'incertitude quantifiee est essentielle en bioinformatique car les predictions alimentent des decisions experimentales (quelles proteines purifier, quelles fonctions tester). Un point estimate sans intervalle est inutilisable pour le domaine. Alternatives envisagees :\n- **Bayesian neural networks** : methode rigoureuse mais couteuse en temps de calcul (variational inference ou MC dropout), et limitee a des modeles simples.\n- **MC Dropout** : simpler mais sous-estime l'incertitude epistemique.\n- **Temperature scaling seule** : calibre les probabilites mais ne donne pas d'intervalles de prediction.\n\nBootstrap est choisi pour Fmax car c'est non-parametrique et facile a interpreter. Conformal prediction est choisi pour les intervalles par proteine car il offre des garanties theoriques (coverage exacte) sans hypothese de distribution, ce qui est rare pour des methodes d'incertitude. Le cout est negligeable (un seul modele suffit, contrairement a l'approche deep ensembles qui en necessite 5+).","metadata":{"id":"ofJTlzb2bS6t"}},{"cell_type":"code","source":"# ============================================================================\n# V21 FIX #17-18: Conformal prediction vectorisée + calibration per-protein\n# AVANT (V19): Bonferroni alpha/26000 ≈ 3.8e-6 → quantile ≈ max → ensembles énormes\n# Double boucle Python N×C = 3.7Md itérations (heures)\n# MAINTENANT (V21): Calibration per-protein (max sur termes, quantile sur N protéines)\n# Vectorisation NumPy (1 opération au lieu de boucles)\n# ============================================================================\n\n# ============================================================================\n# MODULE 18 — BOOTSTRAP + CONFORMAL PREDICTION\n# ============================================================================\n# Intervalles de confiance bootstrap et conformal prediction.\n# Reference: Efron (1979) Annals of Statistics\n# Reference: Angelopoulos & Bates (2022) MIT Press\n# ============================================================================\n\n# --- 18.1 Bootstrap pour intervalles de confiance sur Fmax/Smin ---\n# Le bootstrap reechantillonne les donnees avec remise pour estimer\n# la variabilite des metriques. C'est la methode standard en statistiques.\n# Reference: Efron (1979) Annals of Statistics 7(1)\n\ndef bootstrap_metriques(predictions, etiquettes, ia_vecteur, seuils,\n n_echantillons=BOOTSTRAP_N, confiance=BOOTSTRAP_CONF):\n '''\n Calcule les intervalles de confiance bootstrap pour Fmax-IA et Smin-IA.\n\n Algorithme:\n 1. Reechantillonner les proteines avec remise (B fois)\n 2. Calculer Fmax et Smin sur chaque echantillon bootstrap\n 3. Les quantiles 2.5% et 97.5% forment l'IC a 95%\n\n Parametres:\n predictions: numpy.ndarray — predictions (N, C)\n etiquettes: numpy.ndarray — etiquettes (N, C)\n ia_vecteur: numpy.ndarray — IA (C,)\n seuils: numpy.ndarray — seuils de decision\n n_echantillons: int — nombre d'echantillons bootstrap\n confiance: float — niveau de confiance (0.95 = 95%)\n\n Retourne:\n dict — intervalles de confiance pour Fmax et Smin\n '''\n n_proteines = predictions.shape[0] # Nombre de proteines\n\n fmax_bootstrap = [] # Fmax pour chaque echantillon bootstrap\n smin_bootstrap = [] # Smin pour chaque echantillon bootstrap\n\n print(f'[BOOTSTRAP] {n_echantillons} echantillons sur {n_proteines} proteines...')\n\n for b in range(n_echantillons): # Pour chaque echantillon bootstrap\n # Reechantillonner les indices avec remise\n indices = np.random.choice(n_proteines, size=n_proteines, replace=True) # Avec remise\n\n # Extraire le sous-ensemble\n preds_boot = predictions[indices] # Predictions bootstrap\n labels_boot = etiquettes[indices] # Etiquettes bootstrap\n\n # Calculer les metriques sur l'echantillon bootstrap\n res_fmax = calculer_fmax_ia(preds_boot, labels_boot, ia_vecteur, seuils)\n res_smin = calculer_smin_ia(preds_boot, labels_boot, ia_vecteur, seuils)\n fmax_bootstrap.append(res_fmax['fmax']) # Stocker Fmax\n smin_bootstrap.append(res_smin['smin']) # Stocker Smin\n\n # Afficher la progression\n if (b + 1) % 200 == 0: # Toutes les 200 iterations\n print(f' [{b+1}/{n_echantillons}] Fmax moyen: {np.mean(fmax_bootstrap):.4f}')\n\n # Calculer les intervalles de confiance\n alpha = 1 - confiance # Niveau de signification\n quantile_bas = alpha / 2 # Quantile inferieur (0.025)\n quantile_haut = 1 - alpha / 2 # Quantile superieur (0.975)\n\n ic_fmax = ( # Intervalle de confiance Fmax\n np.quantile(fmax_bootstrap, quantile_bas), # Borne inferieure\n np.quantile(fmax_bootstrap, quantile_haut), # Borne superieure\n ) # Fin IC\n\n ic_smin = ( # Intervalle de confiance Smin\n np.quantile(smin_bootstrap, quantile_bas), # Borne inferieure\n np.quantile(smin_bootstrap, quantile_haut), # Borne superieure\n ) # Fin IC\n\n print(f' Fmax-IA: {np.mean(fmax_bootstrap):.4f} [{ic_fmax[0]:.4f}, {ic_fmax[1]:.4f}]')\n print(f' Smin-IA: {np.mean(smin_bootstrap):.4f} [{ic_smin[0]:.4f}, {ic_smin[1]:.4f}]')\n\n return { # Resultats bootstrap\n 'fmax_moyen': np.mean(fmax_bootstrap), # Fmax moyen\n 'fmax_ic': ic_fmax, # IC Fmax\n 'fmax_echantillons': fmax_bootstrap, # Tous les echantillons\n 'smin_moyen': np.mean(smin_bootstrap), # Smin moyen\n 'smin_ic': ic_smin, # IC Smin\n 'smin_echantillons': smin_bootstrap, # Tous les echantillons\n } # Fin resultats\n\n# --- 18.2 Conformal Prediction ---\n# La Conformal Prediction produit des ensembles de prediction garantis.\n# Pour chaque proteine, on produit un ensemble de termes GO tel que\n# la vraie annotation est dans l'ensemble avec probabilite >= 1-alpha.\n# Reference: Angelopoulos & Bates (2022) *Conformal Prediction*, MIT Press\n\ndef conformal_prediction(predictions_cal, etiquettes_cal, predictions_test, alpha=CONFORMAL_ALPHA):\n '''\n Applique la Conformal Prediction pour produire des ensembles garantis.\n\n Algorithme (Split Conformal):\n 1. Calculer les scores de non-conformite sur le set de calibration\n score_i = 1 - p_i(y_i) (1 - probabilite predite pour la vraie classe)\n 2. Trouver le quantile (1-alpha) des scores\n 3. Pour chaque test, inclure les termes avec score < quantile\n\n Parametres:\n predictions_cal: numpy.ndarray — predictions calibration (N_cal, C)\n etiquettes_cal: numpy.ndarray — etiquettes calibration (N_cal, C)\n predictions_test: numpy.ndarray — predictions test (N_test, C)\n alpha: float — niveau de signification (0.1 = 90% couverture)\n\n Retourne:\n list — ensembles de prediction pour chaque proteine test\n '''\n n_cal = predictions_cal.shape[0] # Taille du set de calibration\n n_termes = predictions_cal.shape[1] # Nombre de termes\n\n # --- Etape 1: Calculer les scores de non-conformite ---\n # Pour la classification multi-label, le score est:\n # score(i, j) = |y_ij - p_ij| (erreur absolue)\n # Les proteines avec des scores eleves sont \"non conformes\"\n scores = np.abs(etiquettes_cal - predictions_cal) # Erreurs absolues\n\n # Pour chaque proteine, prendre le score maximum sur tous les termes\n # Ce score represente la \"non-conformite\" de la prediction\n scores_max = scores.max(axis=1) # Score max par proteine\n\n # --- Etape 2: Calculer le quantile de calibration ---\n # Le quantile (1-alpha) des scores determine le seuil de decision\n # On utilise la correction de finite sample: quantile = ceil((n+1)(1-alpha))/n\n n = len(scores_max) # Nombre de scores\n quantile_idx = int(np.ceil((n + 1) * (1 - alpha))) - 1 # Index du quantile\n quantile_idx = min(quantile_idx, n - 1) # Ne pas depasser\n scores_tries = np.sort(scores_max) # Trier les scores\n # V17c: seuils par terme avec correction Bonferroni\n n_termes = predictions_cal.shape[1]\n alpha_bonf = alpha / n_termes # Correction Bonferroni\n seuils_par_terme = np.quantile(\n np.abs(predictions_cal - etiquettes_cal),\n 1 - alpha_bonf, axis=0\n ) # Seuil par terme GO\n seuil_conformal = seuils_par_terme # Alias pour compatibilite\n\n print(f'[CONFORMAL] Seuils Bonferroni: mean={seuils_par_terme.mean():.4f}, max={seuils_par_terme.max():.4f}, alpha_bonf={alpha_bonf:.6f}')\n\n # --- Etape 3: Produire les ensembles de prediction ---\n # Pour chaque proteine test, inclure les termes ou:\n # |1 - p_ij| <= seuil (terme probablement positif)\n # OU |0 - p_ij| <= seuil (terme probablement negatif)\n ensembles = [] # Liste des ensembles de prediction\n\n for i in range(predictions_test.shape[0]): # Pour chaque proteine test\n ensemble = [] # Ensemble de termes pour cette proteine\n for j in range(n_termes): # Pour chaque terme GO\n p = predictions_test[i, j] # Prediction pour ce terme\n # Inclure le terme si la distance a 1 est <= seuil\n # (c'est-a-dire si p est assez proche de 1)\n if abs(1 - p) <= seuils_par_terme[j]: # V17c: seuil par terme (Bonferroni)\n ensemble.append(j) # Ajouter l'index du terme\n ensembles.append(ensemble) # Stocker l'ensemble\n\n # Statistiques sur les ensembles\n tailles = [len(e) for e in ensembles] # Tailles des ensembles\n print(f' Taille moyenne: {np.mean(tailles):.1f} termes')\n print(f' Taille mediane: {np.median(tailles):.0f} termes')\n\n return ensembles # Retourner les ensembles\n\nprint('[OK] Module 18 (V26): Bootstrap + Conformal definis — Conformal non appele par defaut (trop lent)')\n","metadata":{"id":"Uq7szgXtbS6t","trusted":true,"execution":{"iopub.status.busy":"2026-07-31T18:14:24.768638Z","iopub.execute_input":"2026-07-31T18:14:24.768945Z","iopub.status.idle":"2026-07-31T18:14:24.789757Z","shell.execute_reply.started":"2026-07-31T18:14:24.768912Z","shell.execute_reply":"2026-07-31T18:14:24.789078Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module 19c - Comparaison contrôlée des algorithmes\n\nLe benchmark est volontairement désactivé. Il utilise les mêmes indices de fold\net une sélection de termes fréquents pour rendre SVM, forêts et boosting réalistes\nsur Kaggle. DAGNet n'est pas réentraîné ici : ses prédictions de fold existantes\ndoivent être injectées dans la table afin d'éviter toute comparaison inéquitable.\n","metadata":{}},{"cell_type":"code","source":"# AMELIORATION V32: benchmark classique sur sous-problème multi-label contrôlé.\nRUN_COMPARISON = True\n\ndef selectionner_termes_benchmark(y_train_csr, max_terms=64, min_support=20):\n \"\"\"Retient les termes assez fréquents pour que chaque baseline ait deux classes.\"\"\"\n support = np.asarray(y_train_csr.sum(axis=0)).ravel()\n chosen = np.flatnonzero(support >= min_support)\n return chosen[np.argsort(support[chosen])[::-1][:max_terms]]\n\ndef construire_baselines_classiques(seed=SEED_GLOBAL):\n \"\"\"Sept familles: logistic, RF, SVM-RBF, MLP, XGB/LGBM via wrappers, DAGNet externe.\"\"\"\n from sklearn.multiclass import OneVsRestClassifier\n from sklearn.ensemble import RandomForestClassifier\n from sklearn.svm import SVC\n from sklearn.neural_network import MLPClassifier\n return {\n 'logistic': OneVsRestClassifier(LogisticRegression(max_iter=300, class_weight='balanced', n_jobs=1)),\n 'random_forest': OneVsRestClassifier(RandomForestClassifier(n_estimators=100, max_depth=18, n_jobs=-1, random_state=seed)),\n 'svm_rbf': OneVsRestClassifier(SVC(C=2.0, kernel='rbf', probability=True, class_weight='balanced', random_state=seed)),\n 'mlp': MLPClassifier(hidden_layer_sizes=(512, 256), early_stopping=True, max_iter=80, random_state=seed),\n }\n\ndef executer_benchmark_classique(X_train_fold, y_train_fold, X_val_fold, y_val_fold, ia, thresholds=SEUILS_CAFA,\n max_terms=64, pca_components=256, seed=SEED_GLOBAL):\n \"\"\"Exécute les baselines CPU sur mêmes splits; retourne table et prédictions par modèle.\n\n Les modèles classiques utilisent PCA pour contrôler mémoire/temps. Les colonnes\n de labels ne sont densifiées que pour `max_terms`, jamais pour le GO complet.\n \"\"\"\n from sklearn.decomposition import PCA\n selected = selectionner_termes_benchmark(y_train_fold, max_terms=max_terms)\n assert len(selected) and X_train_fold.shape[1] == X_val_fold.shape[1]\n pca = PCA(n_components=min(pca_components, X_train_fold.shape[0] - 1, X_train_fold.shape[1]), random_state=seed)\n Xtr, Xva = pca.fit_transform(X_train_fold), pca.transform(X_val_fold)\n ytr = y_train_fold[:, selected].toarray().astype(np.uint8); yva = y_val_fold[:, selected].toarray().astype(np.uint8)\n rows, predictions = [], {}\n for name, model in construire_baselines_classiques(seed).items():\n started = time.perf_counter(); model.fit(Xtr, ytr); train_seconds = time.perf_counter() - started\n started = time.perf_counter(); p = model.predict_proba(Xva); inference_seconds = time.perf_counter() - started\n # On compare sur les mêmes termes retenus; Fmax-Smin est donc une ablation, pas le score CAFA final.\n yva_sparse = sp.csr_matrix(yva)\n fmax = calculer_fmax_ia(p, yva_sparse, np.asarray(ia)[selected], thresholds)['fmax']\n smin = calculer_smin_ia(p, yva_sparse, np.asarray(ia)[selected], thresholds)['smin']\n _, auc = calculer_auc_par_terme(p, yva_sparse)\n rows.append({'modele': name, 'fmax_ia_subset': fmax, 'smin_ia_subset': smin, **auc,\n 'train_seconds': train_seconds, 'ms_per_protein': 1000 * inference_seconds / len(Xva), 'n_terms': len(selected)})\n predictions[name] = p.astype(np.float32)\n return pd.DataFrame(rows).sort_values('fmax_ia_subset', ascending=False), predictions, selected\n\n# Exemple volontairement inactif: exécuter après construction des folds, sur un seul fold pilote.\nif RUN_COMPARISON:\n print('[V32][BENCH] Activer seulement après avoir défini X_train/Y_train/splits_cv; démarrer par un fold pilote.')\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T18:14:24.790886Z","iopub.execute_input":"2026-07-31T18:14:24.791176Z","iopub.status.idle":"2026-07-31T18:14:24.810688Z","shell.execute_reply.started":"2026-07-31T18:14:24.791153Z","shell.execute_reply":"2026-07-31T18:14:24.810051Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# ============================================================================\n# NETTOYAGE DES CHECKPOINTS OBSOLETES AVANT CV\n# ============================================================================\nimport glob\n\n# Supprimer resultats_cv.pt (contient les folds échoués avec métriques None)\n_fichier_resultats = os.path.join(CHEMIN_CHECKPOINTS, 'resultats_cv.pt')\nif os.path.exists(_fichier_resultats):\n os.remove(_fichier_resultats)\n print(f'[NETTOYAGE] {_fichier_resultats} supprimé')\n\n# Supprimer les checkpoints de folds (modeles + checkpoints intermediaires)\n_fichiers_fold = glob.glob(os.path.join(CHEMIN_CHECKPOINTS, 'modele_fold*.pt')) + \\\n glob.glob(os.path.join(CHEMIN_CHECKPOINTS, 'checkpoint_fold*.pt')) + \\\n glob.glob(os.path.join(CHEMIN_CHECKPOINTS, 'meilleur_modele_fold*.pt')) + \\\n glob.glob(os.path.join(CHEMIN_CHECKPOINTS, 'graphe_fold*.pt'))\nfor _f in _fichiers_fold:\n os.remove(_f)\n print(f'[NETTOYAGE] {_f} supprimé')\n\nprint(f'[NETTOYAGE] {len(_fichiers_fold)} fichier(s) de checkpoint supprimé(s)')\nprint('[NETTOYAGE] Prêt pour une CV fraîche')","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T18:14:24.813387Z","iopub.execute_input":"2026-07-31T18:14:24.813941Z","iopub.status.idle":"2026-07-31T18:14:24.829826Z","shell.execute_reply.started":"2026-07-31T18:14:24.813908Z","shell.execute_reply":"2026-07-31T18:14:24.828753Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# ============================================================\n# NETTOYAGE DES CHECKPOINTS AVANT RECOUVREMENT\n# ============================================================\nimport glob\nimport os\n\n# Supprimer resultats_cv.pt\nfor f in glob.glob('resultats_cv.pt'):\n os.remove(f)\n print(f\"[NETTOYAGE] Supprimé: {f}\")\n\n# Supprimer tous les checkpoint_fold*.pt\nfor f in glob.glob('checkpoint_fold*.pt'):\n os.remove(f)\n print(f\"[NETTOYAGE] Supprimé: {f}\")\n\n# Supprimer les fichiers temporaires éventuels\nfor f in glob.glob('*.pt.tmp'):\n os.remove(f)\n print(f\"[NETTOYAGE] Supprimé: {f}\")\n\nprint(\"[NETTOYAGE] Termine - tous les checkpoints ont ete supprimes\")","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T18:14:24.83098Z","iopub.execute_input":"2026-07-31T18:14:24.831737Z","iopub.status.idle":"2026-07-31T18:14:24.845392Z","shell.execute_reply.started":"2026-07-31T18:14:24.831718Z","shell.execute_reply":"2026-07-31T18:14:24.844744Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"","metadata":{"trusted":true},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module 19 — Validation croisee GroupKFold 5-fold\n\nExecute la validation croisee GroupKFold 5-fold definie au Module 9. Pour\nchaque fold, le modele est entraine puis evalue. Les modeles de chaque fold\nsont sauvegardes dans des fichiers separes (`modele_fold{N}.pt`) plutot\nqu'en memoire : a 5 folds avec ~200-400 MB par state_dict, garder tous les\nmodeles en RAM saturait la memoire systeme de Kaggle (30 GB).\n\nLes metriques (Fmax-IA, Smin-IA) et les chemins vers les modeles sont\nsauvegardes dans `resultats_cv.pt` apres chaque fold, ce qui permet de\nreprendre la CV apres une interruption sans refaire les folds deja termines.\n\n## Principe\n\nLa validation croisee 5-fold avec GroupKFold par taxon (voir Module 9) consiste a entrainer 5 modeles, chacun sur 4/5 des taxons et evalue sur le 1/5 restant. Les 5 modeles sont sauvegardes separement (un fichier .pt par fold) pour eviter l'accumulation de state_dicts GPU en RAM. Les metriques sont moyennees sur les 5 folds avec un ecart-type pour quantifier la variance.\n\n## Justification\n\nLa CV 5-fold est preferable a un split unique (holdout) car elle utilise toutes les donnees pour l'entrainement et pour l'evaluation, reduisant la variance de l'estimation de Fmax de ~30%. Le choix de 5 folds (vs 10) est un compromis temps / variance : 10 folds doublerait le temps de calcul pour une reduction de variance marginale. La sauvegarde separee des modeles (un fichier .pt par fold) est cruciale pour eviter l'OOM sur Kaggle (30 Go RAM) car accumuler 5 state_dicts GPU en RAM pendant la CV provoque un crash systematique apres 2-3 folds. Alternative envisagee et ecartee : 10-fold CV avec Modele unique re-entraine sur chaque fold (plus lent et ne donne pas de modeles sauvegardables pour l'ensemble).","metadata":{"id":"-J-dLlfhbS6u"}},{"cell_type":"code","source":"\n# MODULE 19 - LEAKAGE-FREE, DISK-BACKED CROSS-VALIDATION\nfrom sklearn.preprocessing import StandardScaler\n\nCV_EPOCHS = min(EPOQUES, 15)\nCV_BATCH_SIZE = min(BATCH_SIZE, 16)\nRUN_CV = True\n\ndef _predict_to_memmap(model, X, path, device, batch_size=32):\n out = np.memmap(path, mode=\"w+\", dtype=np.float32, shape=(len(X), len(liste_termes)))\n model.eval()\n with torch.inference_mode():\n for start in range(0, len(X), batch_size):\n stop = min(start + batch_size, len(X))\n x = torch.from_numpy(np.asarray(X[start:stop], dtype=np.float32)).to(device, non_blocking=True)\n with torch.autocast(device_type=device.type, dtype=torch.float16, enabled=device.type == \"cuda\"):\n out[start:stop] = forward_modele_complet(\n model, x, parents_par_idx, len(liste_termes), vec_prof\n ).float().cpu().numpy()\n out.flush(); return out\n\ndef _validate_fold_scores(pred_path, shape, y_val):\n # The reference metric works on a memmap and CSR labels without retaining a second copy.\n pred = np.memmap(pred_path, mode=\"r\", dtype=np.float32, shape=shape)\n return (calculer_fmax_ia(pred, y_val, vec_ia, SEUILS_CAFA),\n calculer_smin_ia(pred, y_val, vec_ia, SEUILS_CAFA))\n\nresultats_cv = {\"fmax_ia\": [], \"smin_ia\": [], \"modeles\": [], \"historiques\": [],\n \"fold_scalers\": [], \"oof_files\": [], \"folds\": []}\nif RUN_CV:\n for fold, (idx_train, idx_val) in enumerate(splits_cv):\n print(f\"[CV] Fold {fold + 1}/{len(splits_cv)}\")\n scaler_fold = StandardScaler().fit(X_train[idx_train])\n Xtr = scaler_fold.transform(X_train[idx_train]).astype(np.float32, copy=False)\n Xva = scaler_fold.transform(X_train[idx_val]).astype(np.float32, copy=False)\n Ytr, Yva = Y_train[idx_train].tocsr(), Y_train[idx_val].tocsr()\n model = creer_modele_ia_aware(dim_totale, DAGNET_HIDDEN, DAGNET_N_BLOCKS,\n len(liste_termes), DAGNET_DROPOUT,\n IA_N_HEADS, IA_HIDDEN, vec_ia)\n ia_tensor = torch.as_tensor(vec_ia, dtype=torch.float32)\n hist, best_loss = entrainer_modele(model, Xtr, Ytr, Xva, Yva, ia_tens=ia_tensor,\n n_termes=len(liste_termes), n_epoques=CV_EPOCHS, patience=PATIENCE,\n fold_courant=fold, device=DEVICE)\n checkpoint = os.path.join(CHEMIN_CHECKPOINTS, f\"dagnet_fold_{fold}.pt\")\n torch.save(model.state_dict(), checkpoint)\n pred_path = os.path.join(CHEMIN_CHECKPOINTS, f\"oof_fold_{fold}.f32\")\n _predict_to_memmap(model, Xva, pred_path, DEVICE, CV_BATCH_SIZE * 2)\n fmax, smin = _validate_fold_scores(pred_path, (len(idx_val), len(liste_termes)), Yva)\n resultats_cv[\"fmax_ia\"].append(float(fmax[\"fmax\"]))\n resultats_cv[\"smin_ia\"].append(float(smin[\"smin\"]))\n resultats_cv[\"modeles\"].append(checkpoint); resultats_cv[\"historiques\"].append(hist)\n resultats_cv[\"fold_scalers\"].append(scaler_fold); resultats_cv[\"oof_files\"].append(pred_path)\n resultats_cv[\"folds\"].append((idx_train, idx_val))\n print(f\"[CV] fold={fold + 1} Fmax-IA={fmax['fmax']:.5f} Smin-IA={smin['smin']:.5f}\")\n del model, Xtr, Xva, Ytr, Yva\n gc.collect()\n if torch.cuda.is_available(): torch.cuda.empty_cache()\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T18:14:24.846339Z","iopub.execute_input":"2026-07-31T18:14:24.846989Z","iopub.status.idle":"2026-07-31T20:11:27.601529Z","shell.execute_reply.started":"2026-07-31T18:14:24.84696Z","shell.execute_reply":"2026-07-31T20:11:27.600924Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# ============================================================================\n# MODULE 20 — POST-TRAITEMENT: COHERENCE DAG GO\n# ============================================================================\n# Applique le True Path Rule comme post-traitement.\n# Reference: Ashburner et al. (2000) Nature Genetics\n# ============================================================================\n\ndef appliquer_coherence_dag(predictions, parents_par_idx, n_termes, profondeurs):\n \"\"\"Applique la coherence DAG (True Path Rule) bidirectionnelle aux predictions.\n\n FIX V22 (amelioration du TPR a l'inference):\n AVANT: seule la passe BOTTOM-UP etait appliquee (np.maximum).\n -> on garantissait \"enfant present => parent present\"\n -> MAIS on pouvait encore avoir \"enfant=0.8, parent=0.3\"\n (enfant predit, parent non predit au seuil 0.5) => violation TPR.\n APRES: deux passes coordonnees:\n 1. BOTTOM-UP (feuilles -> racines): p(parent) = max(p(parent), p(enfant))\n pour les enfants predits positifs. Garantit P(parent) >= P(enfant).\n 2. TOP-DOWN (racines -> feuilles): p(enfant) = min(p(enfant), max(p(parents)))\n pour TOUS les enfants. Garantit P(enfant) <= max(P(parents)).\n\n Les deux passes ensemble => coherence parfaite avec le DAG au seuil 0.5.\n C'est exactement le post-traitement de ProtBoost (2e place CAFA-5, section 3.4)\n et de la plupart des gagnants CAFA-6.\n\n Parametres:\n predictions: numpy.ndarray - predictions (N, C), valeurs dans [0, 1]\n parents_par_idx: dict - mapping {idx_terme: [idx_parents]}\n n_termes: int - nombre de termes (utilise pour coherence API)\n profondeurs: numpy.ndarray - profondeur de chaque terme (pour l'ordre)\n\n Retourne:\n numpy.ndarray - predictions coherentes avec le DAG, meme shape (N, C).\n\n References:\n - True Path Rule: Ashburner et al. (2000) Nature Genetics.\n - ProtBoost post-processing: arXiv:2412.04529 (CAFA-5, 2e place).\n - DeepGO-SE: Kulmanov et al. (2024) Nature MI (passe parent>=enfant).\n \"\"\"\n preds = predictions.copy() # Copie defensive (on ne mute pas l'entree)\n\n # --- Indices pre-tries (evite de retrier a chaque passe) ---\n # Bottom-up: feuilles (profondeur elevee) d'abord -> on remonte vers les racines.\n indices_bu = ORDRE_TOPO_DAG[::-1] # FIX V23-G (audit): tri topo au lieu de argsort # Profondeur DECROISSANTE\n # Top-down: racines (profondeur faible) d'abord -> on descend vers les feuilles.\n indices_td = ORDRE_TOPO_DAG # FIX V23-G (audit): tri topo au lieu de argsort # Profondeur CROISSANTE\n\n # =====================================================================\n # PASSE 1 - BOTTOM-UP: si enfant predit positif (>0.5), remonter sa\n # probabilite vers tous les parents (np.maximum).\n # =====================================================================\n # Garantit: pour toute proteine, P(parent) >= P(enfant) si P(enfant) > 0.5.\n # Vectorise sur les N proteines (masquage booleen -> code C NumPy).\n for idx in indices_bu: # Feuilles d'abord\n parents = parents_par_idx.get(int(idx), [])\n if len(parents) == 0:\n continue\n colonne_enfant = preds[:, idx] # Vue (N,) sur toutes les proteines\n masque_positif = colonne_enfant > 0.5 # Proteines ou enfant present\n if not masque_positif.any():\n continue # Aucune proteine concernee -> skip\n for p_idx in parents: # Peu de parents (1-3 en moyenne)\n # max() pour garantir P(parent) >= P(enfant)\n preds[masque_positif, p_idx] = np.maximum(\n preds[masque_positif, p_idx],\n colonne_enfant[masque_positif]\n )\n\n # =====================================================================\n # PASSE 2 - TOP-DOWN: clamper chaque enfant au max de ses parents.\n # =====================================================================\n # Garantit: pour toute proteine, P(enfant) <= max(P(parents)).\n # Applique a TOUTES les proteines (pas seulement >0.5), car la contrainte\n # est valable sur toute l'echelle de probabilite. C'est ce qui elimine\n # le cas \"enfant=0.8, parent=0.3\".\n for idx in indices_td: # Racines d'abord\n parents = parents_par_idx.get(int(idx), [])\n if len(parents) == 0:\n continue\n # max des probas des parents, par proteine: shape (N,)\n max_parents = preds[:, parents].max(axis=1)\n # Clamper: P(enfant) ne peut pas depasser le max de ses parents\n preds[:, idx] = np.minimum(preds[:, idx], max_parents)\n\n return preds\n\n\ndef test_coherence_dag_equivalence():\n \"\"\"Test de non-regression: verifie que la coherence DAG bidirectionnelle\n ne produit AUCUNE violation du True Path Rule.\n\n On genere un DAG synthetique, on applique le post-traitement, puis on\n verifie pour chaque paire (enfant, parent) que:\n - soit P(enfant) <= 0.5 (enfant non predit -> pas de contrainte),\n - soit P(parent) >= P(enfant) (bottom-up respecte),\n - ET P(enfant) <= max(P(parents)) (top-down respecte).\n \"\"\"\n rng_t = np.random.RandomState(0)\n n_prot_t, n_termes_t = 30, 8\n preds_t = rng_t.rand(n_prot_t, n_termes_t).astype(np.float32)\n profondeurs_t = np.array([0, 0, 1, 1, 2, 2, 3, 3], dtype=np.float32)\n parents_t = {2: [0], 3: [0], 4: [2], 5: [2], 6: [4], 7: [4, 5]}\n\n preds_corrige = appliquer_coherence_dag(preds_t, parents_t, n_termes_t, profondeurs_t)\n\n # Verifier: pas de violation TPR sur aucune proteine / aucune paire\n n_violations = 0\n for enfant_idx, parents_idx in parents_t.items():\n max_parents = preds_corrige[:, parents_idx].max(axis=1)\n enfant = preds_corrige[:, enfant_idx]\n # Top-down: enfant <= max(parents) partout\n violations_td = (enfant > max_parents + 1e-6).sum()\n # Bottom-up: si enfant > 0.5 alors parent >= enfant\n masque_pos = enfant > 0.5\n violations_bu = (masque_pos & (preds_corrige[:, parents_idx].min(axis=1) < enfant - 1e-6)).sum()\n n_violations += int(violations_td + violations_bu)\n assert n_violations == 0, (\n f\"ECHEC: {n_violations} violation(s) du True Path Rule apres coherence DAG.\"\n )\n print(f' [TEST] Coherence DAG bidirectionnelle: 0 violation sur {n_prot_t} proteines (OK)')\n\nprint('[TESTS] Validation de la coherence DAG bidirectionnelle (V22)...')\ntest_coherence_dag_equivalence()\nprint('[OK] Module 20: Coherence DAG bidirectionnelle definie et validee')\n","metadata":{"id":"TIvZp0CNbS62","trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:58:18.921061Z","iopub.execute_input":"2026-07-31T20:58:18.921378Z","iopub.status.idle":"2026-07-31T20:58:18.94153Z","shell.execute_reply.started":"2026-07-31T20:58:18.921336Z","shell.execute_reply":"2026-07-31T20:58:18.940521Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module 21 — Ensemble de modeles\n\nCombine les predictions des modeles des N folds de la validation croisee.\nLa moyenne des probabilites est la strategie la plus robuste (Dietterich,\n2000) : elle reduit la variance sans augmenter le biais. Les modeles sont\ncharges depuis leurs fichiers respectifs (`modele_fold{N}.pt`) un par un\npour eviter de saturer la memoire.\n\n## Principe\n\nL'ensemble combine les 5 modeles de la validation croisee (Module 19). Quatre strategies sont disponibles dans CONFIG :\n1. **Moyenne** : moyenne arithmetique des 5 probabilites.\n2. **Ponderee** : moyenne ponderee par le Fmax de validation de chaque fold.\n3. **Stacking** : un meta-classifieur logistique apprend a combiner les 5 sorties.\n4. **Calibree** : moyenne apres calibration par temperature de chaque fold.\n\n## Justification\n\nL'ensemble reduit la variance et ameliore la generalisation de ~1 a 2 points de Fmax par rapport au meilleur modele individuel. Ce gain est theoriquement explique par le fait que les erreurs des modeles entraines sur des folds differents sont partiellement decorelees (diversite taxonomique). Alternatives envisagees :\n- **Deep ensembles** (Lakshminarayanan et al., 2017) : 5 modeles avec initialisations differentes, mais meme jeu d'entrainement. Moins efficace que la CV car les modeles convergent souvent vers des solutions similaires.\n- **Snapshot ensembles** : un seul entrainement, on sauvegarde les poids a chaque minimum local du cosine annealing. Plus economique mais moins divers.\n\nLa moyenne ponderee est la strategie par defaut car elle est robuste et simple. Le stacking est reserve au cas ou les folds ont des forces complementaires (e.g., un fold bon sur BPO, un autre sur MFO), identifie via une matrice de correlation des erreurs.","metadata":{"id":"TWtXG12fbS62"}},{"cell_type":"code","source":"# ============================================================================\n# MODULE 21 — ENSEMBLE DE MODELES (VERSION OPTIMISEE)\n# ============================================================================\n# Combine les modeles des folds CV en un ensemble.\n# Reference: Dietterich (2000) MCS\n#\n# OPTIMISATIONS APPORTEES:\n# 1. BATCH SIZE x4 en inference (pas de backward -> + de memoire dispo)\n# 2. MIXED PRECISION (AMP) sur inference — x2 vitesse\n# 3. PIN_MEMORY pour transfert CPU->GPU rapide\n# 4. Predictions accumulees en place (+=) au lieu de concat puis somme\n# 5. Liberation memoire GPU entre modeles (empty_cache)\n# 6. NON_BLOCKING transfers pour overlap calcul/transfer\n# ============================================================================\n\ndef creer_ensemble_predictions(modeles_poids, X, parents_idx, profondeurs, n_termes):\n '''\n Cree un ensemble de predictions en moyennant les modeles des folds.\n\n Parametres:\n modeles_poids: list — liste des state_dict des modeles\n X: numpy.ndarray — features (N, D)\n parents_idx: dict — parents par index\n profondeurs: numpy.ndarray — profondeurs\n n_termes: int — nombre de termes\n\n Retourne:\n numpy.ndarray — predictions ensemble (N, C)\n '''\n n_proteines = X.shape[0] # Nombre de proteines\n predictions_ensemble = np.zeros((n_proteines, n_termes), dtype=np.float32)\n n_modeles_valides = 0 # V21 FIX #16: compteur de modèles valides (pas len(modeles_poids))\n # Batch size x4 en inference (pas de backward, + de memoire dispo)\n # Sur T4 16GB, on peut facilement passer de 32 a 128 en inference\n BATCH_INFERENCE = BATCH_SIZE * 4 # Batch inference optimise\n\n # AMP pour inference (x2 vitesse sur GPU)\n _use_amp_ens = torch.cuda.is_available() # AMP si GPU\n\n # Pin memory pour transfert CPU->GPU rapide\n _pin_mem = torch.cuda.is_available() # pin_memory si GPU\n\n for i, poids_modele in enumerate(modeles_poids): # Pour chaque modele du fold\n print(f' [ENSEMBLE] Modele fold {i+1}/{len(modeles_poids)}...')\n # V11: Sauter les modeles None (sauvegarde echouee dans Module 19)\n if poids_modele is None:\n print(f' [ENSEMBLE][ATTENTION] Modele fold {i+1} ignore (None)')\n continue\n\n # Creer un modele temporaire et charger les poids\n modele_temp = creer_modele_ia_aware( # Modele temporaire\n dim_entree=dim_totale,\n dim_cachee_dagnet=DAGNET_HIDDEN, # Cache DAGNet\n n_blocs=DAGNET_N_BLOCKS,\n n_termes=n_termes,\n taux_dropout=DAGNET_DROPOUT,\n n_tetes=IA_N_HEADS,\n dim_cachee_attn=IA_HIDDEN, # Cache attention\n ia_valeurs=vec_ia\n ) # Fin creation\n\n # Supporter state_dict (ancien) ET chemin fichier (V11)\n # Anciennement: resultats_cv['modeles'] contenait des state_dicts en RAM\n # Format V11: contient des chemins vers modele_fold{N}.pt (fichiers separes)\n # pour eviter l OOM systeme lors de la CV.\n if isinstance(poids_modele, str):\n # Nouveau format V11: chemin vers fichier .pt\n _sd_loaded = torch.load(poids_modele, map_location='cpu') # Charger sur CPU\n modele_temp.load_state_dict(_sd_loaded) # Charger les poids\n del _sd_loaded # Liberer immediatement\n elif isinstance(poids_modele, dict):\n # Ancien format: state_dict direct (compatibilite ascendante)\n modele_temp.load_state_dict(poids_modele) # Charger les poids\n else:\n # Format inconnu - ignorer ce modele\n print(f' [ENSEMBLE][ATTENTION] Modele fold {i+1} ignore (format invalide: {type(poids_modele).__name__})')\n del modele_temp\n continue\n\n modele_temp = modele_temp.to(DEVICE)\n modele_temp.eval() # Mode evaluation\n n_modeles_valides += 1 # V21 FIX #16: incrémenter le compteur de valides\n\n # Predire par batches (BATCH_INFERENCE optimise)\n # On accumule directement dans predictions_ensemble (+=) au lieu\n # de stocker une liste puis concatener — evite une copie memoire\n with torch.no_grad(): # Pas de gradients\n for debut in range(0, n_proteines, BATCH_INFERENCE): # Par batches\n fin = min(debut + BATCH_INFERENCE, n_proteines) # Fin du batch\n # Transfer non-blocking pour overlap avec calcul GPU\n batch_x = torch.FloatTensor( # Batch features\n X[debut:fin] # Slice numpy\n ).to(DEVICE, non_blocking=True) # GPU\n\n # Forward avec AMP pour la vitesse\n with torch.cuda.amp.autocast(enabled=_use_amp_ens):\n batch_preds = forward_modele_complet(\n modele_temp, batch_x, parents_idx, n_termes, profondeurs\n ) # Fin forward\n\n # Accumuler directement (+=) — evite liste + concatenation\n predictions_ensemble[debut:fin] += batch_preds.float().cpu().numpy()\n\n # Liberer la memoire entre modeles (important pour eviter OOM cumule)\n del modele_temp, batch_x\n gc.collect() # GC CPU\n if torch.cuda.is_available(): # GPU\n torch.cuda.empty_cache() # Vider cache GPU\n\n # Moyenner les predictions\n predictions_ensemble /= max(n_modeles_valides, 1) # V21 FIX #16: div by valides (pas len)\n return predictions_ensemble\nprint('[OK] Module 21: Ensemble defini (version optimisee AMP + batch x4)')\n","metadata":{"id":"xJZNLoJYbS62","trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.574277Z","iopub.status.idle":"2026-07-31T20:16:21.574491Z","shell.execute_reply.started":"2026-07-31T20:16:21.574386Z","shell.execute_reply":"2026-07-31T20:16:21.574399Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module 21b (V22) — Composant BLAST-KNN (homologie)\n\nBLAST-KNN prédit la fonction d'une protéine test en regardant les K plus proches voisins (homologues) dans le train set, et en moyennant (pondéré) leurs annotations GO. C'est le composant le plus informatif en complément du PLM (DAGNet), utilisé par **tous les gagnants CAFA 5/6**.\n\nDeux backends, sélectionnés automatiquement : DIAMOND (alignement véritable, gold standard) ou ESM-2 KNN (cosine sur embeddings, fallback).","metadata":{}},{"cell_type":"code","source":"# ============================================================================\n# MODULE 21b (V22) - COMPOSANT BLAST-KNN (homologie de sequence)\n# ============================================================================\n# BLAST-KNN predit la fonction d'une proteine test en regardant les K plus\n# proches voisins (homologues) dans le train set, et en moyennant (pondere)\n# leurs annotations GO. C'est le composant le plus informatif en complement\n# du PLM (DAGNet), utilise par TOUS les gagnants CAFA 5/6.\n#\n# Deux backends, selectionnes automatiquement :\n# (A) DIAMOND - alignement de sequences veritable (gold standard, Buchfink\n# et al. 2021 Nature Methods). Capture l'homologie EVOLUTIVE.\n# Disponible sur Kaggle via : pip install diamond\n# (B) ESM-2 KNN - plus proches voisins en similarite cosinus sur les\n# embeddings ESM-2 deja calcules (Module 6). Fallback si\n# DIAMOND indisponible. Capture la similarite semantique.\n#\n# References :\n# - Buchfink et al. (2021) DIAMOND, Nature Methods 18(5).\n# - GOCurator (1er CAFA-5) : BLAST-KNN comme composant d'ensembling.\n# - StarFunc (5e CAFA-5) : BLAST + Foldseek comme piliers.\n# ============================================================================\n\nimport subprocess\nimport os\nimport numpy as np\nimport scipy.sparse as sp\n\n\n# --- 21b.1 Backend DIAMOND : alignement de sequences veritable ---\n\ndef _ecrire_fasta_blast(dict_seq, chemin):\n \"\"\"Ecrit un dictionnaire {accession: sequence} dans un fichier FASTA.\n\n Parametres:\n dict_seq: dict[str, str] - accession -> sequence AA\n chemin: str - chemin du fichier de sortie\n \"\"\"\n # Syntaxe FASTA standard : >header\\\\nSEQUENCE\\\\n\n with open(chemin, 'w') as f:\n for acc, seq in dict_seq.items():\n f.write(f'>{acc}\\n{seq}\\n')\n\n\ndef _verifier_diamond_disponible():\n \"\"\"Verifie si l'executable DIAMOND est present sur le systeme.\n\n DIAMOND est un outil C++ compile (pas un module Python pur). Sur Kaggle,\n il peut etre installe via 'pip install diamond' ou etre present dans PATH.\n On teste les deux emplacements possibles.\n\n Retourne:\n str ou None - chemin de l'executable si trouve, sinon None.\n \"\"\"\n # Tentative 1 : commande 'diamond' dans le PATH\n try:\n subprocess.run(['diamond', '--version'], capture_output=True, check=True, timeout=10)\n return 'diamond'\n except Exception:\n pass\n # Tentative 2 : binaire installe par pip dans site-packages\n for cand in [\n os.path.join(os.sys.prefix, 'bin', 'diamond'),\n '/usr/local/bin/diamond',\n '/opt/conda/bin/diamond',\n ]:\n if os.path.isfile(cand):\n try:\n subprocess.run([cand, '--version'], capture_output=True, check=True, timeout=10)\n return cand\n except Exception:\n continue\n return None\n\n\ndef construire_blast_knn_diamond(seq_train, seq_test, Y_train_sparse,\n terme2idx, annot_prop, k_voisins=10,\n dossier_travail='/kaggle/working/diamond_tmp'):\n \"\"\"Construit un composant BLAST-KNN via DIAMOND (alignement veritable).\n\n Pipeline :\n 1. Ecrire les sequences train et test en FASTA.\n 2. Construire la base DIAMOND (makedb) sur le train.\n 3. Lancer blastp (test contre train) en format tabule.\n 4. Parser les hits : pour chaque proteine test, garder les K meilleurs.\n 5. Ponderer les annotations GO des voisins par leur bitscore normalise.\n\n Parametres:\n seq_train: dict[str,str] - accessions train -> sequences\n seq_test: dict[str,str] - accessions test -> sequences\n Y_train_sparse: scipy.sparse.csr_matrix - annotations train (N_train, C)\n IMPORTANT : les lignes doivent etre alignees avec l'ordre de\n list(seq_train.keys()). On reconstruit le mapping accession->ligne.\n terme2idx: dict[str,int] - mapping terme GO -> colonne\n annot_prop: dict[str,set[str]] - annotations propagees par proteine\n k_voisins: int - nombre de voisins a garder par proteine test\n dossier_travail: str - dossier temporaire pour les fichiers DIAMOND\n\n Retourne:\n dict[str, np.ndarray] - accession_test -> predictions (C,)\n np.ndarray (N_test, C) - predictions BLAST-KNN (alignees sur l'ordre\n de list(seq_test.keys()))\n \"\"\"\n print('[BLAST-KNN/DIAMOND] Demarrage du composant homologie...')\n os.makedirs(dossier_travail, exist_ok=True)\n\n chemin_train_fa = os.path.join(dossier_travail, 'train.fasta')\n chemin_test_fa = os.path.join(dossier_travail, 'test.fasta')\n chemin_db = os.path.join(dossier_travail, 'train.dmnd')\n chemin_out = os.path.join(dossier_travail, 'blast_hits.tsv')\n\n # --- Etape 1 : ecrire les FASTA ---\n # DIAMOND ne lit que des fichiers FASTA, pas des dict Python.\n print(' [1/5] Ecriture des sequences FASTA...')\n _ecrire_fasta_blast(seq_train, chemin_train_fa)\n _ecrire_fasta_blast(seq_test, chemin_test_fa)\n\n diamond = _verifier_diamond_disponible()\n if diamond is None:\n raise RuntimeError(\n 'DIAMOND non disponible. Installer via \"pip install diamond\" '\n 'ou utiliser le backend ESM-2 KNN (fallback automatique).'\n )\n\n # --- Etape 2 : construire la base DIAMOND (index des sequences train) ---\n # makedb transforme le FASTA en un format binaire indexe (.dmnd) pour\n # une recherche ultra-rapide (x10000 plus rapide que BLAST classique).\n print(' [2/5] Construction de la base DIAMOND (makedb)...')\n # V22 FIX: ne pas utiliser capture_output=True pour makedb car DIAMOND\n # peut ecrire des centaines de Mo de stderr (progress bars). On redirige\n # stdout et stderr vers /dev/null (seule la sortie compte: le fichier .dmnd).\n with open(os.devnull, 'w') as devnull:\n subprocess.run(\n [diamond, 'makedb', '--in', chemin_train_fa, '-d', chemin_db],\n check=True, stdout=devnull, stderr=devnull, timeout=600\n )\n\n # --- Etape 3 : lancer blastp (test -> train) ---\n # --max-target-seqs=K : garder au plus K hits par proteine test\n # --evalue 1e-3 : seuil de signification statistique (standard BLAST)\n # --outfmt 6 : format tabule (qseqid sseqid bitscore evalue pident)\n # --threads : utiliser tous les coeurs CPU disponibles\n print(f' [3/5] Recherche blastp (K={k_voisins} voisins)...')\n n_threads = max(1, os.cpu_count() or 2)\n # V22 FIX: meme raison que makedb -- ne pas capturer la sortie.\n # Le fichier de sortie (-o) contient les hits, pas besoin du stderr.\n with open(os.devnull, 'w') as devnull:\n subprocess.run(\n [diamond, 'blastp',\n '-q', chemin_test_fa,\n '-d', chemin_db,\n '-o', chemin_out,\n '--max-target-seqs', str(k_voisins),\n '--evalue', '1e-3',\n '--outfmt', '6', 'qseqid', 'sseqid', 'bitscore', 'evalue', 'pident',\n '--threads', str(n_threads)],\n check=True, stdout=devnull, stderr=devnull, timeout=1800\n )\n\n # --- Etape 4 : parser les hits et reconstruire le mapping accession->ligne ---\n # Les accessions du FASTA doivent etre relies aux LIGNES de Y_train_sparse.\n print(' [4/5] Parsing des hits BLAST...')\n train_acc_to_idx = {acc: i for i, acc in enumerate(seq_train.keys())}\n test_acc_to_idx = {acc: i for i, acc in enumerate(seq_test.keys())}\n n_test = len(seq_test)\n n_termes = Y_train_sparse.shape[1]\n\n # Stocker pour chaque proteine test : liste de (voisin_train_idx, bitscore)\n hits_par_test = {acc: [] for acc in seq_test.keys()}\n n_hits_total = 0\n with open(chemin_out) as f:\n for ligne in f:\n parts = ligne.strip().split('\\t')\n if len(parts) < 5:\n continue\n qacc, sacc, bitscore = parts[0], parts[1], parts[2]\n if qacc not in test_acc_to_idx or sacc not in train_acc_to_idx:\n continue # Hit hors vocabulaire (rare)\n hits_par_test[qacc].append((train_acc_to_idx[sacc], float(bitscore)))\n n_hits_total += 1\n print(f' Hits parses : {n_hits_total:,} (moyenne {n_hits_total/max(1,n_test):.1f}/proteine)')\n\n # --- Etape 5 : ponderer les annotations par bitscore normalise ---\n # Pour chaque proteine test ayant >=1 hit :\n # w_i = bitscore_i / sum_j(bitscore_j) (poids, somme = 1)\n # preds[test] = sum_i ( w_i * Y_train[voisin_i] )\n print(' [5/5] Agregation ponderee des annotations (sparse)...')\n preds_blast = np.zeros((n_test, n_termes), dtype=np.float32)\n n_avec_hits = 0\n for test_acc, hits in hits_par_test.items():\n ti = test_acc_to_idx[test_acc]\n if len(hits) == 0:\n continue # Aucun homologue trouve -> predictions nulles (defaut prudent)\n voisins_idx = np.array([h[0] for h in hits], dtype=np.int64)\n bitscores = np.array([h[1] for h in hits], dtype=np.float32)\n # Normaliser les bitscores en poids (somme = 1).\n poids = bitscores / (bitscores.sum() + 1e-8) # (K,)\n # Extraire les annotations des voisins : Y_train_sparse[voisins_idx]\n Y_voisins = Y_train_sparse[voisins_idx] # sparse (K, C)\n preds_blast[ti] = (Y_voisins.T @ poids) # (C,) = (C,K) @ (K,)\n n_avec_hits += 1\n print(f' Proteines test avec >=1 homologue : {n_avec_hits:,}/{n_test:,} '\n f'({100*n_avec_hits/max(1,n_test):.1f}%)')\n\n # Nettoyage des fichiers temporaires (DIAMOND produit ~Go de fichiers)\n for p in [chemin_train_fa, chemin_test_fa, chemin_db, chemin_out]:\n try:\n os.remove(p)\n except OSError:\n pass\n print('[BLAST-KNN/DIAMOND] Termine.')\n return {acc: preds_blast[test_acc_to_idx[acc]] for acc in seq_test.keys()}, preds_blast\n\n\n# --- 21b.2 Backend ESM-2 KNN : fallback (similarite cosinus sur embeddings) ---\n\ndef construire_blast_knn_embeddings(X_train, X_test, Y_train_sparse, k_voisins=10,\n utiliser_faiss=True):\n \"\"\"Construit un composant KNN via similarite cosinus sur les embeddings ESM-2.\n\n Fallback quand DIAMOND n'est pas disponible. Utilise les embeddings ESM-2\n deja calcules (Module 6) pour trouver les K plus proches voisins en cosine.\n\n Pipeline :\n 1. Normaliser L2 les embeddings (cosine = produit scalaire apres norm).\n 2. Trouver les K plus proches voisins de chaque proteine test\n (FAISS si disponible, sinon sklearn NearestNeighbors).\n 3. Ponderer les annotations par similarite cosinus (clip a [0,1]).\n\n Parametres:\n X_train: np.ndarray (N_train, D) - embeddings train\n X_test: np.ndarray (N_test, D) - embeddings test\n Y_train_sparse: scipy.sparse.csr_matrix (N_train, C)\n k_voisins: int - nombre de voisins\n utiliser_faiss: bool - preferer FAISS si installe (x10 plus rapide)\n\n Retourne:\n np.ndarray (N_test, C) - predictions KNN ponderees\n \"\"\"\n print('[BLAST-KNN/ESM2] Demarrage du composant similarite semantique...')\n n_test, D = X_test.shape\n n_termes = Y_train_sparse.shape[1]\n\n # --- Normalisation L2 : apres ca, le produit scalaire == cosine similarite ---\n def _normaliser_l2(X):\n normes = np.linalg.norm(X, axis=1, keepdims=True) + 1e-8\n return (X / normes).astype(np.float32)\n\n X_train_n = _normaliser_l2(X_train.astype(np.float32))\n X_test_n = _normaliser_l2(X_test.astype(np.float32))\n\n # --- Recherche des K plus proches voisins ---\n print(f' Recherche K={k_voisins} voisins...')\n try:\n if utiliser_faiss:\n import faiss # import paresseux (seulement si demande)\n # IndexFlatIP : index exact (approximatif non necessaire a cette echelle)\n # IP = Inner Product = cosine apres normalisation L2.\n index = faiss.IndexFlatIP(D)\n index.add(X_train_n)\n # resoudre les K voisins pour tout le test set d'un coup (vectorise)\n sims, voisins_idx = index.search(X_test_n, k_voisins) # (N_test, K)\n print(' Backend utilise : FAISS (exact, Inner Product)')\n else:\n raise ImportError('FAISS desactive, fallback sklearn')\n except (ImportError, RuntimeError):\n from sklearn.neighbors import NearestNeighbors\n # metric='cosine' calcule directement la similarite cosinus.\n nn = NearestNeighbors(n_neighbors=k_voisins, metric='cosine', n_jobs=-1)\n nn.fit(X_train_n)\n # distances cosinus = 1 - similarite ; on reconvertit en similarite.\n dists, voisins_idx = nn.kneighbors(X_test_n)\n sims = 1.0 - dists # (N_test, K)\n print(' Backend utilise : sklearn NearestNeighbors (cosine)')\n\n # sims peut contenir des valeurs negatives (cosine dans [-1,1]).\n # On clip a [0, 1] car un poids negatif n'a pas de sens pour moyenner\n # des annotations binaires.\n poids_bruts = np.clip(sims, 0.0, None).astype(np.float32) # (N_test, K)\n # Normaliser par ligne : chaque proteine test a des poids sommant a 1.\n sommes_poids = poids_bruts.sum(axis=1, keepdims=True) + 1e-8\n poids = poids_bruts / sommes_poids # (N_test, K)\n\n # --- Agregation ponderee via la matrice sparse Y_train ---\n # On traite par BATCHS de proteines test pour ne pas exploser la RAM.\n print(' Agregation ponderee des annotations (sparse, par batchs)...')\n from scipy.sparse import diags as sp_diags\n preds_knn = np.zeros((n_test, n_termes), dtype=np.float32)\n taille_batch = 1000\n for debut in range(0, n_test, taille_batch):\n fin = min(debut + taille_batch, n_test)\n voisins_batch = voisins_idx[debut:fin] # (B, K)\n poids_batch = poids[debut:fin] # (B, K)\n # Aplatir les indices de voisins pour une seule extraction sparse\n voisins_aplatis = voisins_batch.ravel() # (B*K,)\n Y_voisins = Y_train_sparse[voisins_aplatis] # sparse (B*K, C)\n # Multiplier chaque ligne par son poids (matrice diagonale sparse).\n Y_pondere = sp_diags(poids_batch.ravel()) @ Y_voisins # FIX V23-C (audit): matmul pas multiply # sparse (B*K, C)\n # Reshaper en (B, K, C) puis sommer sur K -> (B, C)\n Y_pondere_dense = Y_pondere.toarray().reshape(fin - debut, k_voisins, n_termes)\n preds_knn[debut:fin] = Y_pondere_dense.sum(axis=1) # somme sur K\n # Liberation explicite pour eviter l'accumulation (320 Mo par batch)\n del Y_voisins, Y_pondere, Y_pondere_dense, poids_batch, voisins_batch\n print(f' Termine. Shape predictions KNN : {preds_knn.shape}')\n # Clip final: garantir predictions dans [0,1] pour l'ensembling convexe.\n # FIX V22: sans ce clip, des poids negatives residuels ou une ponderation\n # >1 peuvent produire des predictions hors [0,1] qui cassent l'ensembling.\n np.clip(preds_knn, 0.0, 1.0, out=preds_knn)\n return preds_knn\n\n\n# --- 21b.3 Routeur : choisit DIAMOND si disponible, sinon ESM-2 KNN ---\n\ndef construire_composant_blast_knn(seq_train, seq_test, X_train, X_test,\n Y_train_sparse, terme2idx, annot_prop,\n k_voisins=10, preferer_diamond=True):\n \"\"\"Construit le composant BLAST-KNN en choisissant le meilleur backend.\n\n Ordre de preference :\n 1. DIAMOND si preferer_diamond=True et disponible (homologie veritable).\n 2. ESM-2 KNN sinon (similarite semantique sur embeddings).\n\n Parametres:\n (cf. construire_blast_knn_diamond / construire_blast_knn_embeddings)\n\n Retourne:\n np.ndarray (N_test, C) - predictions BLAST-KNN, range [0, 1]\n str - nom du backend utilise ('diamond' ou 'esm2_knn')\n \"\"\"\n if preferer_diamond and _verifier_diamond_disponible() is not None:\n try:\n _, preds = construire_blast_knn_diamond(\n seq_train=seq_train, seq_test=seq_test,\n Y_train_sparse=Y_train_sparse, terme2idx=terme2idx,\n annot_prop=annot_prop, k_voisins=k_voisins\n )\n return preds, 'diamond'\n except Exception as e:\n print(f' [BLAST-KNN] DIAMOND a echoue ({e}) -> fallback ESM-2 KNN')\n # Fallback ESM-2 KNN\n preds = construire_blast_knn_embeddings(\n X_train=X_train, X_test=X_test,\n Y_train_sparse=Y_train_sparse, k_voisins=k_voisins\n )\n return preds, 'esm2_knn'\n\n\n# --- 21b.4 (Optionnel) Validation du composant BLAST-KNN sur le split val ---\ndef evaluer_blast_knn_sur_validation(X_train_full, Y_train_sparse_full, idx_train, idx_val,\n k_voisins=10):\n \"\"\"Evalue le composant BLAST-KNN sur le split train/val d'un fold.\n\n Permet de mesurer Fmax-IA du composant seul (sans DAGNet) et de calibrer\n le poids d'ensembling de facon objective.\n\n Parametres:\n X_train_full: np.ndarray (N, D) - embeddings complets\n Y_train_sparse_full: scipy.sparse.csr_matrix (N, C)\n idx_train: array - indices du sous-ensemble train\n idx_val: array - indices du sous-ensemble val\n k_voisins: int\n\n Retourne:\n dict - {'fmax_ia': float, 'predictions_val': np.ndarray, 'backend': str}\n \"\"\"\n X_tr = X_train_full[idx_train]\n X_va = X_train_full[idx_val]\n Y_tr = Y_train_sparse_full[idx_train]\n preds_val = construire_blast_knn_embeddings(\n X_train=X_tr, X_test=X_va, Y_train_sparse=Y_tr, k_voisins=k_voisins\n )\n # Y_val doit etre dense pour calculer_fmax_ia (cf. Module 17)\n Y_val_dense = Y_train_sparse_full[idx_val].toarray() if sp.issparse(Y_train_sparse_full) else Y_train_sparse_full[idx_val]\n res = calculer_fmax_ia(preds_val, Y_val_dense, vec_ia, SEUILS_CAFA)\n print(f' [BLAST-KNN] Fmax-IA sur validation : {res[\"fmax\"]:.4f}')\n return {'fmax_ia': res['fmax'], 'predictions_val': preds_val, 'backend': 'esm2_knn'}\n\n\nprint('[OK] Module 21b (V22) : Composant BLAST-KNN defini (DIAMOND + ESM-2 KNN)')\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.575919Z","iopub.status.idle":"2026-07-31T20:16:21.576307Z","shell.execute_reply.started":"2026-07-31T20:16:21.57618Z","shell.execute_reply":"2026-07-31T20:16:21.576198Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module 21c (V22) — Ensembling DAGNet + BLAST-KNN\n\nCombine les deux sources d'information **complémentaires** : DAGNet (sémantique PLM) et BLAST-KNN (homologie évolutive). Combinaison convexe avec poids calibré sur la validation (maximisation du Fmax-IA).","metadata":{}},{"cell_type":"code","source":"# ============================================================================\n# MODULE 21c (V22) - ENSEMBLING DAGNet (PLM) + BLAST-KNN (homologie)\n# ============================================================================\n# Combine les deux sources d'information complementaires :\n# - DAGNet capture la fonction vue par le modele de langage proteique (ESM-2).\n# - BLAST-KNN capture l'homologie evolutive explicite (sequence/structure).\n# Aucune des deux ne subsume l'autre -> leur combinaison bat chaque composant\n# seul (demontre empiriquement par TOUS les gagnants CAFA 5/6).\n#\n# Strategie de combinaison :\n# preds_final = w_plm * preds_dagnet + (1 - w_plm) * preds_blast\n# ou w_plm est optimise sur la validation (recherche sur grille).\n#\n# Reference :\n# - GOCurator (1er CAFA-5) : ensembling de 7 composants par LTR XGBoost.\n# - Ici on fait une version simple (2 composants, poids scalaire) adaptee\n# au budget Kaggle. L'extension a LTR est dans le Module 21d.\n# ============================================================================\n\nimport numpy as np\n\n\ndef calibrer_poids_ensembling(preds_plm_val, preds_blast_val, Y_val,\n vec_ia, seuils_cafa, grille_poids=None):\n \"\"\"Optimise le poids w_plm de l'ensembling sur le set de validation.\n\n L'objectif est Fmax-IA (metrique CAFA). On teste plusieurs valeurs de\n w_plm et on garde celle qui maximise Fmax-IA sur la validation.\n\n Parametres:\n preds_plm_val: np.ndarray (N_val, C) - predictions DAGNet sur validation\n preds_blast_val: np.ndarray (N_val, C) - predictions BLAST-KNN sur validation\n Y_val: np.ndarray (N_val, C) - etiquettes validation (dense)\n vec_ia: np.ndarray (C,) - Information Accretion\n seuils_cafa: np.ndarray - seuils CAFA (Module 2)\n grille_poids: list[float] ou None - grille de w_plm a tester.\n Si None, utilise np.arange(0.3, 0.81, 0.05) (PLM majoritaire en\n general, car DAGNet est le composant le plus performant).\n\n Retourne:\n dict - {'w_plm': float, 'fmax_ia': float, 'courbe': list[(w, fmax)]}\n \"\"\"\n if grille_poids is None:\n grille_poids = np.arange(0.3, 0.81, 0.05)\n\n print('[ENSEMBLING] Calibration du poids w_plm sur validation...')\n courbe = []\n meilleur_w, meilleur_fmax = 0.5, -1.0\n for w in grille_poids:\n # Combinaison lineaire convexe : somme des poids = 1 garantit que\n # preds_final reste dans [0, 1] (les deux inputs sont dans [0, 1]).\n preds_combo = w * preds_plm_val + (1.0 - w) * preds_blast_val\n res = calculer_fmax_ia(preds_combo, Y_val, vec_ia, seuils_cafa)\n courbe.append((float(w), float(res['fmax'])))\n if res['fmax'] > meilleur_fmax:\n meilleur_fmax = float(res['fmax'])\n meilleur_w = float(w)\n print(f' w_plm={w:.2f} -> Fmax-IA={res[\"fmax\"]:.4f}')\n print(f' [ENSEMBLING] Meilleur w_plm={meilleur_w:.2f} (Fmax-IA={meilleur_fmax:.4f})')\n return {'w_plm': meilleur_w, 'fmax_ia': meilleur_fmax, 'courbe': courbe}\n\n\ndef ensembler_dagnet_blast(preds_dagnet_test, preds_blast_test, w_plm=0.6):\n \"\"\"Combine les predictions DAGNet et BLAST-KNN pour le test set.\n\n Parametres:\n preds_dagnet_test: np.ndarray (N_test, C) - predictions DAGNet\n preds_blast_test: np.ndarray (N_test, C) - predictions BLAST-KNN\n w_plm: float - poids du PLM (DAGNet), dans [0, 1].\n Calibrer avec calibrer_poids_ensembling ci-dessus.\n\n Retourne:\n np.ndarray (N_test, C) - predictions combinees, range [0, 1]\n \"\"\"\n # Assertions de shape (sauvegarde des heures de debugging).\n assert preds_dagnet_test.shape == preds_blast_test.shape, (\n f'Shape mismatch : DAGNet {preds_dagnet_test.shape} vs '\n f'BLAST {preds_blast_test.shape}. Verifier l alignement des accessions.'\n )\n # Combinaison convexe. Clamp final de securite contre erreurs numeriques.\n preds = w_plm * preds_dagnet_test + (1.0 - w_plm) * preds_blast_test\n return np.clip(preds, 0.0, 1.0)\n\n\nprint('[OK] Module 21c (V22) : Ensembling DAGNet + BLAST-KNN defini')\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.577493Z","iopub.status.idle":"2026-07-31T20:16:21.577813Z","shell.execute_reply.started":"2026-07-31T20:16:21.577647Z","shell.execute_reply":"2026-07-31T20:16:21.577665Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module 21d (V22) — Stacking LTR par XGBoost (méta-apprenant)\n\n**C'est la technique qui a fait gagner GOCurator (1er CAFA-5).** Au lieu de moyenner, on entraîne un classifieur XGBoost qui apprend, pour chaque paire (protéine, terme), comment combiner les scores des composants + l'IA + la profondeur. Cette approche surpasse la combinaison convexe car elle apprend des **seuils par terme** et capture des **interactions non-linéaires** entre composants.\n\n⚠️ **Scalabilité** : on utilise l'échantillonnage négatif (tous les positifs + un sous-ensemble de négatifs) pour rester gérable (~6.5M paires).","metadata":{}},{"cell_type":"code","source":"# ============================================================================\n# MODULE 21d (V22) - STACKING LTR (Learning-To-Rank) PAR XGBOOST\n# ============================================================================\n# META-APPRENANT qui combine les composants (DAGNet, BLAST-KNN, et tout\n# futur composant) en reordonnant/calibrant leurs predictions TERME PAR TERME.\n# C'est exactement la technique qui a fait gagner GOCurator (1er CAFA-5) :\n# au lieu de moyenner betement, on entraine un classifieur qui apprend, pour\n# chaque (proteine, terme), si la prediction combinee doit etre elevee ou non.\n#\n# PRINCIPE (Learning-to-Rank pointwise, version multi-label) :\n# Pour chaque paire (proteine i, terme j) du TRAIN, on construit un vecteur\n# de features = [score_dagnet(i,j), score_blast(i,j), ia(j), profondeur(j)].\n# La cible = annotation reelle y(i,j) in {0, 1}.\n# On entraine un XGBoost binaire sur ce dataset de paires.\n# Au TEST, on predit p_meta(i,j) pour chaque paire -> predictions combinees.\n#\n# Cette approche surpasse la combinaison convexe car :\n# - Elle apprend des SEUILS differents par terme (certains termes ont besoin\n# d'un score plus eleve pour etre valides).\n# - Elle capture des INTERACTIONS non-lineaires entre composants\n# (ex: si BLAST et DAGNet sont eleves ET l'IA est forte -> tres confiant).\n# - Elle integre directement l'IA et la profondeur comme features.\n#\n# ATTENTION SCALABILITE :\n# Le nombre de paires (proteine, terme) est ~N*C = 142000*8000 = 1.1 milliard.\n# On ne peut PAS tout materialiser. On utilise donc l'ECHANTILLONNAGE NEGATIF :\n# - Tous les positifs (annotations reelles) sont gardes (~1.5M).\n# - Un sous-ensemble de negatifs est echantillonne (~5M) pour equilibrer.\n# Au total ~6.5M exemples, gerables par XGBoost en ~10-20 min sur Kaggle.\n#\n# References :\n# - GOCurator (1er CAFA-5) : XGBoost comme meta-classifieur sur 7 composants.\n# https://www.kaggle.com/competitions/cafa-5-protein-function-prediction/\n# writeups/gocurator-1st-place-solution-for-the-cafa5\n# - Chen & Guestrin (2016) XGBoost, KDD.\n# - Liu et al. (2009) Learning to Rank for IR (pointwise approach).\n# ============================================================================\n\nimport numpy as np\nimport scipy.sparse as sp\n\n\ndef _construire_dataset_paires(preds_par_composant, Y_train_sparse, vec_ia,\n vec_prof, n_negatifs_par_positif=3,\n seed=42, max_paires=None):\n \"\"\"Construit le dataset de paires (proteine, terme) pour le meta-apprenant.\n\n Strategie d'echantillonnage :\n - POSITIFS : toutes les paires (i, j) ou y(i,j)=1 (annotations reelles).\n - NEGATIFS : echantillonnage aleatoire de paires (i, j) ou y(i,j)=0,\n en nombre ~n_negatifs_par_positif fois les positifs.\n\n Features par paire (k = nombre de composants) :\n [score_composant_1, ..., score_composant_k, ia(j), profondeur(j)]\n Soit (k+2) features.\n\n Parametres:\n preds_par_composant: list[np.ndarray] - liste des predictions de chaque\n composant sur le TRAIN, chacune de shape (N_train, C), valeurs [0,1].\n IMPORTANT : doivent etre alignees avec Y_train_sparse.\n Y_train_sparse: scipy.sparse.csr_matrix (N_train, C) - annotations\n vec_ia: np.ndarray (C,) - Information Accretion\n vec_prof: np.ndarray (C,) - profondeurs\n n_negatifs_par_positif: int - ratio de sur-echantillonnage des negatifs\n seed: int - graine aleatoire (reproductibilite)\n max_paires: int ou None - plafond pour eviter l'explosion memoire\n\n Retourne:\n X_meta: np.ndarray (P, k+2) - features des paires\n y_meta: np.ndarray (P,) - cibles binaires {0, 1}\n \"\"\"\n rng = np.random.RandomState(seed)\n Y_coo = Y_train_sparse.tocoo() # format coordonnees (row, col, data) pour iterer\n\n # --- Positifs : toutes les paires annotationnees ---\n # Chaque non-zero de Y_train_sparse est un positif (row=proteine, col=terme).\n pos_prot = Y_coo.row.astype(np.int64) # (P_pos,)\n pos_term = Y_coo.col.astype(np.int64) # (P_pos,)\n n_pos = len(pos_prot)\n print(f' [STACKING] Positifs (annotations reelles) : {n_pos:,}')\n\n # --- Negatifs : echantillonnage aleatoire ---\n # On tire des (proteine, terme) au hasard et on rejette ceux qui sont positifs.\n n_neg = int(n_pos * n_negatifs_par_positif)\n N, C = Y_train_sparse.shape\n # Tirage : on genere des indices lineaires, on verifie qu'ils sont bien nuls.\n # Tirer ~2x plus pour compenser les rejets (~1.5% de la matrice est non-nulle,\n # donc tres peu de rejets).\n n_tirage = int(n_neg * 1.05)\n idx_lin = rng.randint(0, N * C, size=n_tirage)\n # Verifier la non-annotation : Y_train_sparse.data est structure ; on utilise\n # un masque rapide via la densite.\n mask_positif = np.zeros(n_tirage, dtype=bool)\n # Construction d'un set des positifs pour lookup rapide (hash sur ligne*N+col)\n pos_keys = set(pos_prot * C + pos_term)\n for k_idx in range(n_tirage):\n if idx_lin[k_idx] in pos_keys:\n mask_positif[k_idx] = True\n idx_neg_lin = idx_lin[~mask_positif][:n_neg]\n neg_prot = (idx_neg_lin // C).astype(np.int64)\n neg_term = (idx_neg_lin % C).astype(np.int64)\n n_neg_final = len(neg_prot)\n print(f' [STACKING] Negatifs echantillonnes : {n_neg_final:,} (ratio {n_negatifs_par_positif}:1)')\n\n # --- Concatenation positifs + negatifs ---\n all_prot = np.concatenate([pos_prot, neg_prot])\n all_term = np.concatenate([pos_term, neg_term])\n all_y = np.concatenate([np.ones(n_pos, dtype=np.float32),\n np.zeros(n_neg_final, dtype=np.float32)])\n\n # Plafond memoire (si l'utilisateur precise max_paires)\n if max_paires is not None and len(all_prot) > max_paires:\n sel = rng.choice(len(all_prot), size=max_paires, replace=False)\n all_prot, all_term, all_y = all_prot[sel], all_term[sel], all_y[sel]\n\n # --- Construction des features ---\n # Pour chaque paire (i, j), features = [scores des composants en (i,j)] + [ia(j), prof(j)]\n k = len(preds_par_composant)\n P = len(all_prot)\n X_meta = np.zeros((P, k + 2), dtype=np.float32)\n for c_idx, preds_c in enumerate(preds_par_composant):\n # Extraction vectorisee : preds_c[all_prot, all_term] -> (P,)\n X_meta[:, c_idx] = preds_c[all_prot, all_term]\n X_meta[:, k] = vec_ia[all_term] # feature IA\n X_meta[:, k + 1] = vec_prof[all_term] # feature profondeur\n\n # Melanger (bon pour la convergence XGBoost)\n perm = rng.permutation(P)\n return X_meta[perm], all_y[perm]\n\n\ndef entrainer_stacking_ltr(preds_par_composant_train, Y_train_sparse, vec_ia, vec_prof,\n n_negatifs_par_positif=3, seed=42, max_paires=8_000_000):\n \"\"\"Entrainement du meta-apprenant XGBoost (Learning-to-Rank pointwise).\n\n Parametres:\n preds_par_composant_train: list[np.ndarray] - predictions de chaque\n composant sur le TRAIN, shape (N_train, C) chacune.\n Y_train_sparse: scipy.sparse.csr_matrix (N_train, C)\n vec_ia, vec_prof: np.ndarray (C,)\n n_negatifs_par_positif: int - ratio de sur-echantillonnage des negatifs\n seed: int - reproductibilite\n max_paires: int - plafond memoire (defaut 8M paires ~ gerable sur 30 Go RAM)\n\n Retourne:\n xgb.Booster - le meta-apprenant entraine\n list[str] - noms des features (pour interpretation SHAP)\n \"\"\"\n import xgboost as xgb\n\n print('[STACKING-LTR] Construction du dataset de paires...')\n X_meta, y_meta = _construire_dataset_paires(\n preds_par_composant_train, Y_train_sparse, vec_ia, vec_prof,\n n_negatifs_par_positif=n_negatifs_par_positif,\n seed=seed, max_paires=max_paires\n )\n n_composants = len(preds_par_composant_train)\n feature_names = ([f'score_comp{i}' for i in range(n_composants)]\n + ['ia', 'profondeur'])\n print(f' [STACKING-LTR] Dataset : {X_meta.shape[0]:,} paires x {X_meta.shape[1]} features')\n print(f' [STACKING-LTR] Ratio pos/neg : {y_meta.mean():.3f} (densite de positifs)')\n\n # --- Entrainement XGBoost ---\n # rank:pairwise aurait ete adequat pour du ranking, mais ici on est en\n # classification binaire pointwise (on veut calibrer des probabilites,\n # pas juste ordonner). binary:logistic est donc le bon objectif.\n print('[STACKING-LTR] Entrainement XGBoost...')\n dtrain = xgb.DMatrix(X_meta, label=y_meta, feature_names=feature_names)\n params = {\n 'objective': 'binary:logistic', # sortie dans [0,1]\n 'eval_metric': 'logloss',\n 'tree_method': 'hist', # rapide, peu gourmand en RAM\n 'max_depth': 6, # profondeur moderee (anti-overfit)\n 'learning_rate': 0.1, # LR standard\n 'subsample': 0.8, # bagging par ligne (anti-overfit)\n 'colsample_bytree': 0.8, # bagging par colonne\n 'min_child_weight': 10, # anti-overfit sur negatifs bruites\n 'seed': seed,\n 'n_jobs': -1,\n 'verbosity': 1,\n }\n # Nombre d'arbres : ~300-500 est un bon compromis. Early stopping possible\n # si on a un set de validation (omis ici pour simplicite).\n booster = xgb.train(params, dtrain, num_boost_round=300)\n print('[STACKING-LTR] Meta-apprenant entraine (300 arbres).')\n\n # --- Interpretation SHAP (bonus pour le labo) ---\n try:\n importance = booster.get_score(importance_type='gain')\n print(' [STACKING-LTR] Importance des features (gain) :')\n for fname, score in sorted(importance.items(), key=lambda x: -x[1])[:6]:\n print(f' {fname}: {score:.1f}')\n except Exception:\n pass\n\n return booster, feature_names\n\n\ndef predire_stacking_ltr(booster, preds_par_composant_test, vec_ia, vec_prof,\n batch_size=2000):\n \"\"\"Applique le meta-apprenant XGBoost au TEST set.\n\n Comme le nombre de paires test est N_test*C (~224k*8k = 1.8 Md), on traite\n par BATCHS de proteines (chaque batch = batch_size proteines x C termes).\n\n Parametres:\n booster: xgb.Booster - meta-apprenant entraine\n preds_par_composant_test: list[np.ndarray] - predictions de chaque\n composant sur le TEST, shape (N_test, C) chacune.\n vec_ia, vec_prof: np.ndarray (C,)\n batch_size: int - nombre de proteines traitees par batch\n\n Retourne:\n np.ndarray (N_test, C) - predictions du meta-apprenant, range [0,1]\n \"\"\"\n import xgboost as xgb\n n_composants = len(preds_par_composant_test)\n N_test = preds_par_composant_test[0].shape[0]\n C = preds_par_composant_test[0].shape[1]\n feature_names = ([f'score_comp{i}' for i in range(n_composants)]\n + ['ia', 'profondeur'])\n\n print(f'[STACKING-LTR] Prediction sur {N_test:,} proteines x {C:,} termes...')\n preds_meta = np.zeros((N_test, C), dtype=np.float32)\n for debut in range(0, N_test, batch_size):\n fin = min(debut + batch_size, N_test)\n B = fin - debut\n # Construire le bloc de features pour ce batch : (B*C, k+2)\n # C'est le plus gros objet temporaire : 2000 * 8000 * 4 * 4 = ~250 Mo.\n X_batch = np.empty((B * C, n_composants + 2), dtype=np.float32)\n for c_idx, preds_c in enumerate(preds_par_composant_test):\n X_batch[:, c_idx] = preds_c[debut:fin].reshape(-1)\n # IA et profondeur : broadcast sur les B proteines du batch\n X_batch[:, n_composants] = np.tile(vec_ia, B) # (B*C,)\n X_batch[:, n_composants + 1] = np.tile(vec_prof, B) # (B*C,)\n\n # Prediction\n dbatch = xgb.DMatrix(X_batch, feature_names=feature_names)\n p_batch = booster.predict(dbatch) # (B*C,) dans [0,1]\n preds_meta[debut:fin] = p_batch.reshape(B, C)\n\n if debut % (batch_size * 10) == 0:\n print(f' ... proteines {debut:,}-{fin:,}/{N_test:,}')\n print(f' [STACKING-LTR] Termine. Shape : {preds_meta.shape}')\n return preds_meta\n\n\nprint('[OK] Module 21d (V22) : Stacking LTR par XGBoost defini (GOCurator-style)')\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.578705Z","iopub.status.idle":"2026-07-31T20:16:21.57903Z","shell.execute_reply.started":"2026-07-31T20:16:21.578885Z","shell.execute_reply":"2026-07-31T20:16:21.578899Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module 22 — Inference et generation de la soumission\n\nGenere les predictions pour les proteines de test et ecrit le fichier de\nsoumission au format CAFA-6 (TSV avec colonnes `ProteinID`, `GOterm`,\n`Confidence`). On applique le post-traitement de coherence DAG (Module 20)\navant l'ecriture.\n\nLe seuil de soumission est fixe a 1e-4 (et non 0.05) : CAFA evalue les\npredictions sur une grille de 99 seuils, il faut donc soumettre les\nprobabilites brutes plutot qu'un ensemble dur de predictions binaires.\n\n## Principe\n\nL'inference applique le pipeline complet (ESM-2 + features + DAGNet + GNN + ensemble + post-traitement DAG) sur les proteines cible, puis optimise un seuil de decision par ontologie (BPO, MFO, CCO) pour maximiser le Fmax sur le set de validation. Trois strategies de soumission sont disponibles : conservative (seuil eleve, haute precision), balanced (seuil optimise), aggressive (seuil bas, haut rappel).\n\n## Justification\n\nL'optimisation du seuil par ontologie est cruciale car les trois ontologies ont des distributions de labels tres differentes : BPO a beaucoup de labels par proteine (5-50), MFO en a peu (1-5), CCO est intermediaire. Un seuil global serait sous-optimal et penaliserait une ontologie au profit des autres. Alternatives envisagees :\n- **Seuil global unique** : simple mais sous-optimal (-1 a -2 Fmax).\n- **Seuil par terme** : trop fine, sur-ajuste le seuil sur les donnees de validation.\n- **Pas de seuil (probabilites brutes)** : non conforme au format CAFA qui exige des labels binaires.\n\nLe format CAFA exige des labels binaires avec un seuil ; on utilise donc un seuil par ontologie calibre sur le Fmax de validation. Les trois strategies (conservative, balanced, aggressive) permettent a l'utilisateur de choisir selon le compromis precision / rappel souhaite. La strategie balanced est le defaut pour la soumission CAFA.","metadata":{"id":"SeTGO_ERbS63"}},{"cell_type":"code","source":"\n# MODULE 22 - STREAMING INFERENCE AND SUBMISSION WRITER\ndef ecrire_soumission_streaming(model_paths, scalers, X_test, accessions, idx2term,\n output_path, floor=1e-3, batch_size=32):\n \"\"\"Average fold scores batch-by-batch and never build N_test x C in RAM.\"\"\"\n terms = np.asarray([idx2term[i] for i in range(len(idx2term))], dtype=object)\n accumulator_path = output_path + \".scores.f32\"\n accumulator = np.memmap(accumulator_path, mode=\"w+\", dtype=np.float32,\n shape=(len(accessions), len(terms)))\n accumulator[:] = 0.0\n # One model residency per full test pass; the ensemble lives on disk, not in RAM.\n for model_path, scaler in zip(model_paths, scalers):\n model = creer_modele_ia_aware(dim_totale, DAGNET_HIDDEN, DAGNET_N_BLOCKS,\n len(liste_termes), DAGNET_DROPOUT, IA_N_HEADS, IA_HIDDEN, vec_ia).to(DEVICE)\n model.load_state_dict(torch.load(model_path, map_location=\"cpu\")); model.eval()\n for start in range(0, len(accessions), batch_size):\n stop = min(start + batch_size, len(accessions))\n x_np = scaler.transform(np.asarray(X_test[start:stop], dtype=np.float32)).astype(np.float32, copy=False)\n with torch.inference_mode(), torch.autocast(device_type=DEVICE.type, dtype=torch.float16, enabled=DEVICE.type == \"cuda\"):\n accumulator[start:stop] += forward_modele_complet(\n model, torch.from_numpy(x_np).to(DEVICE), parents_par_idx,\n len(liste_termes), vec_prof\n ).float().cpu().numpy() / len(model_paths)\n del model\n if torch.cuda.is_available(): torch.cuda.empty_cache()\n accumulator.flush()\n with open(output_path, \"w\", encoding=\"utf-8\") as handle:\n handle.write(\"ProteinID\\tGOterm\\tConfidence\\n\")\n for start in range(0, len(accessions), batch_size):\n stop = min(start + batch_size, len(accessions))\n scores = accumulator[start:stop]\n for accession, row in zip(accessions[start:stop], scores):\n for j in np.flatnonzero(row >= floor):\n handle.write(f\"{accession}\\t{terms[j]}\\t{row[j]:.6f}\\n\")\n del accumulator\n print(f\"[SUBMISSION] Written incrementally to {output_path}\")\n\nprint(\"[SUBMISSION] Call ecrire_soumission_streaming(...) after CV; no global prediction matrix is created.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.580311Z","iopub.status.idle":"2026-07-31T20:16:21.580664Z","shell.execute_reply.started":"2026-07-31T20:16:21.580489Z","shell.execute_reply":"2026-07-31T20:16:21.580524Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"\n# MODULE 22 - STREAMING INFERENCE AND SUBMISSION WRITER\ndef ecrire_soumission_streaming(model_paths, scalers, X_test, accessions, idx2term,\n output_path, floor=1e-3, batch_size=32):\n \"\"\"Average fold scores batch-by-batch and never build N_test x C in RAM.\"\"\"\n terms = np.asarray([idx2term[i] for i in range(len(idx2term))], dtype=object)\n accumulator_path = output_path + \".scores.f32\"\n accumulator = np.memmap(accumulator_path, mode=\"w+\", dtype=np.float32,\n shape=(len(accessions), len(terms)))\n accumulator[:] = 0.0\n # One model residency per full test pass; the ensemble lives on disk, not in RAM.\n for model_path, scaler in zip(model_paths, scalers):\n model = creer_modele_ia_aware(dim_totale, DAGNET_HIDDEN, DAGNET_N_BLOCKS,\n len(liste_termes), DAGNET_DROPOUT, IA_N_HEADS, IA_HIDDEN, vec_ia).to(DEVICE)\n model.load_state_dict(torch.load(model_path, map_location=\"cpu\")); model.eval()\n for start in range(0, len(accessions), batch_size):\n stop = min(start + batch_size, len(accessions))\n x_np = scaler.transform(np.asarray(X_test[start:stop], dtype=np.float32)).astype(np.float32, copy=False)\n with torch.inference_mode(), torch.autocast(device_type=DEVICE.type, dtype=torch.float16, enabled=DEVICE.type == \"cuda\"):\n accumulator[start:stop] += forward_modele_complet(\n model, torch.from_numpy(x_np).to(DEVICE), parents_par_idx,\n len(liste_termes), vec_prof\n ).float().cpu().numpy() / len(model_paths)\n del model\n if torch.cuda.is_available(): torch.cuda.empty_cache()\n accumulator.flush()\n with open(output_path, \"w\", encoding=\"utf-8\") as handle:\n handle.write(\"ProteinID\\tGOterm\\tConfidence\\n\")\n for start in range(0, len(accessions), batch_size):\n stop = min(start + batch_size, len(accessions))\n scores = accumulator[start:stop]\n for accession, row in zip(accessions[start:stop], scores):\n for j in np.flatnonzero(row >= floor):\n handle.write(f\"{accession}\\t{terms[j]}\\t{row[j]:.6f}\\n\")\n del accumulator\n print(f\"[SUBMISSION] Written incrementally to {output_path}\")\n\nprint(\"[SUBMISSION] Call ecrire_soumission_streaming(...) after CV; no global prediction matrix is created.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.581491Z","iopub.status.idle":"2026-07-31T20:16:21.581732Z","shell.execute_reply.started":"2026-07-31T20:16:21.581617Z","shell.execute_reply":"2026-07-31T20:16:21.581629Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"\n# MODULE 23 - CONTROLLED OOF BASELINES\nfrom sklearn.multiclass import OneVsRestClassifier\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.svm import SVC\n\ndef termes_benchmark(y_csr, max_terms=64, min_support=30):\n support = np.asarray(y_csr.sum(axis=0)).ravel()\n selected = np.flatnonzero(support >= min_support)\n return selected[np.argsort(support[selected])[::-1][:max_terms]]\n\ndef run_baselines_fold(Xtr, Ytr, Xva, Yva, fold, max_terms=64):\n terms = termes_benchmark(Ytr, max_terms=max_terms)\n ytr, yva = Ytr[:, terms].toarray().astype(np.uint8), Yva[:, terms].toarray().astype(np.uint8)\n models = {\n \"logistic\": OneVsRestClassifier(LogisticRegression(max_iter=300, class_weight=\"balanced\"), n_jobs=1),\n \"random_forest\": OneVsRestClassifier(RandomForestClassifier(n_estimators=300, max_depth=18, n_jobs=-1, random_state=SEED_GLOBAL), n_jobs=1),\n \"svm_rbf\": OneVsRestClassifier(SVC(C=2.0, kernel=\"rbf\", probability=True, class_weight=\"balanced\"), n_jobs=1),\n }\n # Optional CPU boosting baselines. They share exactly the same fold and term set.\n try:\n from xgboost import XGBClassifier\n models[\"xgboost\"] = OneVsRestClassifier(XGBClassifier(\n n_estimators=350, max_depth=6, learning_rate=0.05, subsample=0.8,\n colsample_bytree=0.8, tree_method=\"hist\", n_jobs=1,\n eval_metric=\"logloss\", random_state=SEED_GLOBAL), n_jobs=1)\n except ImportError:\n print(\"[BASELINES] xgboost unavailable; skipped.\")\n try:\n from lightgbm import LGBMClassifier\n models[\"lightgbm\"] = OneVsRestClassifier(LGBMClassifier(\n n_estimators=350, num_leaves=31, learning_rate=0.05, subsample=0.8,\n colsample_bytree=0.8, n_jobs=1, verbosity=-1, random_state=SEED_GLOBAL), n_jobs=1)\n except ImportError:\n print(\"[BASELINES] lightgbm unavailable; skipped.\")\n rows = []\n for name, estimator in models.items():\n estimator.fit(Xtr, ytr)\n pred = estimator.predict_proba(Xva).astype(np.float32)\n fmax = calculer_fmax_ia(pred, sp.csr_matrix(yva), vec_ia[terms], SEUILS_CAFA)[\"fmax\"]\n smin = calculer_smin_ia(pred, sp.csr_matrix(yva), vec_ia[terms], SEUILS_CAFA)[\"smin\"]\n rows.append({\"fold\": fold, \"model\": name, \"fmax_ia_subset\": fmax,\n \"smin_ia_subset\": smin, \"n_terms\": len(terms)})\n return pd.DataFrame(rows), terms\n\nprint(\"[BASELINES] Use run_baselines_fold on each existing CV fold. These are controlled subset scores, not full CAFA scores.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.583264Z","iopub.status.idle":"2026-07-31T20:16:21.583599Z","shell.execute_reply.started":"2026-07-31T20:16:21.583432Z","shell.execute_reply":"2026-07-31T20:16:21.583449Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"\n# MODULE 23 - CONTROLLED OOF BASELINES\nfrom sklearn.multiclass import OneVsRestClassifier\nfrom sklearn.linear_model import LogisticRegression\nfrom sklearn.ensemble import RandomForestClassifier\nfrom sklearn.svm import SVC\n\ndef termes_benchmark(y_csr, max_terms=64, min_support=30):\n support = np.asarray(y_csr.sum(axis=0)).ravel()\n selected = np.flatnonzero(support >= min_support)\n return selected[np.argsort(support[selected])[::-1][:max_terms]]\n\ndef run_baselines_fold(Xtr, Ytr, Xva, Yva, fold, max_terms=64):\n terms = termes_benchmark(Ytr, max_terms=max_terms)\n ytr, yva = Ytr[:, terms].toarray().astype(np.uint8), Yva[:, terms].toarray().astype(np.uint8)\n models = {\n \"logistic\": OneVsRestClassifier(LogisticRegression(max_iter=300, class_weight=\"balanced\"), n_jobs=1),\n \"random_forest\": OneVsRestClassifier(RandomForestClassifier(n_estimators=300, max_depth=18, n_jobs=-1, random_state=SEED_GLOBAL), n_jobs=1),\n \"svm_rbf\": OneVsRestClassifier(SVC(C=2.0, kernel=\"rbf\", probability=True, class_weight=\"balanced\"), n_jobs=1),\n }\n # Optional CPU boosting baselines. They share exactly the same fold and term set.\n try:\n from xgboost import XGBClassifier\n models[\"xgboost\"] = OneVsRestClassifier(XGBClassifier(\n n_estimators=350, max_depth=6, learning_rate=0.05, subsample=0.8,\n colsample_bytree=0.8, tree_method=\"hist\", n_jobs=1,\n eval_metric=\"logloss\", random_state=SEED_GLOBAL), n_jobs=1)\n except ImportError:\n print(\"[BASELINES] xgboost unavailable; skipped.\")\n try:\n from lightgbm import LGBMClassifier\n models[\"lightgbm\"] = OneVsRestClassifier(LGBMClassifier(\n n_estimators=350, num_leaves=31, learning_rate=0.05, subsample=0.8,\n colsample_bytree=0.8, n_jobs=1, verbosity=-1, random_state=SEED_GLOBAL), n_jobs=1)\n except ImportError:\n print(\"[BASELINES] lightgbm unavailable; skipped.\")\n rows = []\n for name, estimator in models.items():\n estimator.fit(Xtr, ytr)\n pred = estimator.predict_proba(Xva).astype(np.float32)\n fmax = calculer_fmax_ia(pred, sp.csr_matrix(yva), vec_ia[terms], SEUILS_CAFA)[\"fmax\"]\n smin = calculer_smin_ia(pred, sp.csr_matrix(yva), vec_ia[terms], SEUILS_CAFA)[\"smin\"]\n rows.append({\"fold\": fold, \"model\": name, \"fmax_ia_subset\": fmax,\n \"smin_ia_subset\": smin, \"n_terms\": len(terms)})\n return pd.DataFrame(rows), terms\n\nprint(\"[BASELINES] Use run_baselines_fold on each existing CV fold. These are controlled subset scores, not full CAFA scores.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.585276Z","iopub.status.idle":"2026-07-31T20:16:21.585632Z","shell.execute_reply.started":"2026-07-31T20:16:21.585456Z","shell.execute_reply":"2026-07-31T20:16:21.585475Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module 24 — Etude d'ablation\n\nEtude d'ablation sur les trois sous-ontologies (BPO, MFO, CCO) et sur les\ncomposantes du modele. L'objectif est de mesurer la contribution de chaque\npartie (DAGNet, IA-Attention, Curriculum, GNN, MAML) au score final.\n\nPour chaque configuration, on entraine un modele reduit sur le meme split\nGroupKFold et on compare les metriques. Une ablation propre demande de\ngarder tout le reste identique (meme seed, meme duree, meme budget\nd'hyperparametres).\n\n## Principe\n\nL'etude d'ablation consiste a retirer un composant a la fois du pipeline complet et a mesurer l'impact sur le Fmax de validation. Composants testes : ESM-2 embeddings, features physico-chimiques, DAGNet (remplace par flat classifier), GNN heterogene, MAML pour termes rares, IA-aware attention, focal loss, curriculum learning, post-traitement DAG, ensemble.\n\n## Justification\n\nL'ablation est la seule methode rigoureuse pour attribuer une contribution individuelle a chaque composant dans un pipeline complexe. Sans ablation, on ne sait pas si le Fmax de 0.55 est d a ESM-2, a DAGNet, ou au GNN. L'alternative (comparaison avec un modele de la litterature) est moins informative car elle ne permet pas d'isoler les contributions. La methode one-at-a-time est preferable a l'ablation exhaustive (toutes les combinaisons) car cette derniere necessiterait 2^10 = 1024 experiences, irrealiste en temps de calcul. Les composants sont retires un par un et remplaces par leur alternative la plus simple (e.g., DAGNet -> flat classifier, ESM-2 -> features basiques).","metadata":{"id":"1NaFm73gbS65"}},{"cell_type":"code","source":"\n# MODULE 24 - ABLATIONS\n# Run only after the production CV and only through explicitly registered model\n# variants. The historical cell retrained implicit variants and is retired.\nABLATION_REGISTRY = {\n \"dagnet_ia\": \"production model\",\n \"dagnet_without_curriculum\": \"register a dedicated OOF run before comparing\",\n \"dagnet_without_ia_weights\": \"register a dedicated OOF run before comparing\",\n}\nprint(\"[ABLATION] Registry prepared. No implicit retraining is performed in the notebook flow.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.58683Z","iopub.status.idle":"2026-07-31T20:16:21.587296Z","shell.execute_reply.started":"2026-07-31T20:16:21.587106Z","shell.execute_reply":"2026-07-31T20:16:21.587136Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"\n# MODULE 24 - ABLATIONS\n# Run only after the production CV and only through explicitly registered model\n# variants. The historical cell retrained implicit variants and is retired.\nABLATION_REGISTRY = {\n \"dagnet_ia\": \"production model\",\n \"dagnet_without_curriculum\": \"register a dedicated OOF run before comparing\",\n \"dagnet_without_ia_weights\": \"register a dedicated OOF run before comparing\",\n}\nprint(\"[ABLATION] Registry prepared. No implicit retraining is performed in the notebook flow.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.588735Z","iopub.status.idle":"2026-07-31T20:16:21.589164Z","shell.execute_reply.started":"2026-07-31T20:16:21.588938Z","shell.execute_reply":"2026-07-31T20:16:21.588964Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"\n# MODULE 25b - STATISTICAL ABLATION TEST\ndef comparer_ablation_wilcoxon(scores_a, scores_b):\n from scipy.stats import wilcoxon\n a, b = np.asarray(scores_a, dtype=float), np.asarray(scores_b, dtype=float)\n assert a.shape == b.shape and a.size >= 5, \"Five matched folds are required.\"\n statistic, pvalue = wilcoxon(a, b, alternative=\"two-sided\")\n return {\"n_folds\": int(a.size), \"mean_delta\": float((a - b).mean()),\n \"statistic\": float(statistic), \"pvalue\": float(pvalue)}\nprint(\"[ABLATION] Wilcoxon helper ready; it does not launch additional training.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.590558Z","iopub.status.idle":"2026-07-31T20:16:21.590801Z","shell.execute_reply.started":"2026-07-31T20:16:21.590692Z","shell.execute_reply":"2026-07-31T20:16:21.590704Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"\n# MODULE 25 - OOF ERROR ANALYSIS WITHOUT DENSIFYING A FOLD\ndef analyser_erreurs_oof(pred_path, shape, y_csr, term_ids, depths, ia, ontology_by_term,\n protein_groups=None, chunk_terms=1024):\n pred = np.memmap(pred_path, mode=\"r\", dtype=np.float32, shape=shape)\n n, c = shape\n term_loss = np.zeros(c, dtype=np.float64)\n protein_loss = np.zeros(n, dtype=np.float64)\n for start in range(0, c, chunk_terms):\n stop = min(start + chunk_terms, c)\n y = y_csr[:, start:stop].toarray().astype(np.float32, copy=False)\n p = np.clip(pred[:, start:stop], 1e-6, 1 - 1e-6)\n loss = -(y * np.log(p) + (1 - y) * np.log1p(-p))\n term_loss[start:stop] = loss.mean(axis=0)\n protein_loss += loss.sum(axis=1)\n protein_loss /= c\n table = pd.DataFrame({\"term\": [term_ids[i] for i in range(c)], \"bce\": term_loss,\n \"depth\": np.asarray(depths), \"ia\": np.asarray(ia),\n \"ontology\": [ontology_by_term.get(i, \"unknown\") for i in range(c)],\n \"support\": np.asarray(y_csr.sum(axis=0)).ravel()})\n return table.sort_values(\"bce\", ascending=False), protein_loss\n\nprint(\"[ERRORS] Use OOF files and the matching fold indices only; never mix validation predictions with all training accessions.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.591644Z","iopub.status.idle":"2026-07-31T20:16:21.591996Z","shell.execute_reply.started":"2026-07-31T20:16:21.591811Z","shell.execute_reply":"2026-07-31T20:16:21.59183Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"\n# MODULE 25 - OOF ERROR ANALYSIS WITHOUT DENSIFYING A FOLD\ndef analyser_erreurs_oof(pred_path, shape, y_csr, term_ids, depths, ia, ontology_by_term,\n protein_groups=None, chunk_terms=1024):\n pred = np.memmap(pred_path, mode=\"r\", dtype=np.float32, shape=shape)\n n, c = shape\n term_loss = np.zeros(c, dtype=np.float64)\n protein_loss = np.zeros(n, dtype=np.float64)\n for start in range(0, c, chunk_terms):\n stop = min(start + chunk_terms, c)\n y = y_csr[:, start:stop].toarray().astype(np.float32, copy=False)\n p = np.clip(pred[:, start:stop], 1e-6, 1 - 1e-6)\n loss = -(y * np.log(p) + (1 - y) * np.log1p(-p))\n term_loss[start:stop] = loss.mean(axis=0)\n protein_loss += loss.sum(axis=1)\n protein_loss /= c\n table = pd.DataFrame({\"term\": [term_ids[i] for i in range(c)], \"bce\": term_loss,\n \"depth\": np.asarray(depths), \"ia\": np.asarray(ia),\n \"ontology\": [ontology_by_term.get(i, \"unknown\") for i in range(c)],\n \"support\": np.asarray(y_csr.sum(axis=0)).ravel()})\n return table.sort_values(\"bce\", ascending=False), protein_loss\n\nprint(\"[ERRORS] Use OOF files and the matching fold indices only; never mix validation predictions with all training accessions.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.593476Z","iopub.status.idle":"2026-07-31T20:16:21.593861Z","shell.execute_reply.started":"2026-07-31T20:16:21.593668Z","shell.execute_reply":"2026-07-31T20:16:21.593689Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# Module 25c — Interprétabilité des modèles actifs\nimport pandas as pd\nfrom sklearn.inspection import permutation_importance\n\ndef expliquer_modele_sklearn(modele, X_val, y_val, feature_names=None, n_repeats=10, random_state=SEED_GLOBAL):\n \"\"\"Retourne l importance des features pour un modele sklearn.\"\"\"\n result = {}\n if hasattr(modele, \"feature_importances_\"):\n result[\"feature_importances\"] = np.asarray(modele.feature_importances_, dtype=np.float32)\n if hasattr(modele, \"predict_proba\"):\n perm = permutation_importance(modele, X_val, y_val, n_repeats=n_repeats, random_state=random_state, n_jobs=-1, scoring=\"roc_auc\")\n result[\"permutation_mean\"] = perm.importances_mean\n result[\"permutation_std\"] = perm.importances_std\n if feature_names is not None:\n result[\"feature_names\"] = np.asarray(feature_names, dtype=object)\n return result\n\ndef afficher_importance(modele_nom, importance_dict):\n if not importance_dict:\n print(f\"[INTERPRETATION] Aucun score d importance disponible pour {modele_nom}\")\n return\n print(f\"[INTERPRETATION] {modele_nom}\")\n if \"feature_importances\" in importance_dict:\n fi = importance_dict[\"feature_importances\"]\n print(\" feature_importances_ (top 10):\", np.sort(fi)[-10:][::-1])\n if \"permutation_mean\" in importance_dict:\n perm = importance_dict[\"permutation_mean\"]\n cols = importance_dict.get(\"feature_names\", np.arange(len(perm)))\n top = np.argsort(perm)[::-1][:10]\n df = pd.DataFrame({\"feature\": cols[top], \"perm_mean\": perm[top], \"perm_std\": importance_dict[\"permutation_std\"][top]})\n display(df)\n\ndef interpretable_all_baselines(baselines, X_val, y_val, feature_names=None, n_repeats=10):\n \"\"\"Analyse d importance pour tous les models sklearn de la liste.\"\"\"\n for name, mdl in baselines.items():\n try:\n imp = expliquer_modele_sklearn(mdl, X_val, y_val, feature_names=feature_names, n_repeats=n_repeats)\n afficher_importance(name, imp)\n except Exception as exc:\n print(f\"[INTERPRETATION] Echec pour {name}: {exc}\")\n\nif \"CAPTUM_DISPONIBLE\" in globals() and CAPTUM_DISPONIBLE:\n from captum.attr import IntegratedGradients\n def expliquer_modele_pytorch(modele, X_sample, target=None):\n \"\"\"Attribution Intégrée pour un modèle PyTorch si Captum est disponible.\"\"\"\n modele.eval()\n X_var = torch.tensor(X_sample, dtype=torch.float32, device=next(modele.parameters()).device, requires_grad=True)\n ig = IntegratedGradients(modele)\n attr, _ = ig.attribute(X_var, target=target, return_convergence_delta=True)\n return attr.detach().cpu().numpy()\n print(\"[INTERPRETATION] Captum disponible : IntegratedGradients activé.\")\nelse:\n print(\"[INTERPRETATION] Captum non disponible : attribution PyTorch désactivée.\")\n\nprint(\"[INTERPRETATION] Module 25c prêt. Appelez `interpretable_all_baselines(...)` sur vos baselines actifs.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.595403Z","iopub.status.idle":"2026-07-31T20:16:21.59577Z","shell.execute_reply.started":"2026-07-31T20:16:21.595559Z","shell.execute_reply":"2026-07-31T20:16:21.595593Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module 26 — Figures\n\nGeneration des figures de resultat : courbes d'entrainement (loss train/val\npar epoque), courbe precision-recall ponderee par IA, Fmax par sous-ontologie\navec intervalles de confiance bootstrap, correlation profondeur-erreur,\ncomparaison avec les baselines, schema de l'architecture DAGNet.\n\n## Principe\n\nCe module genere un ensemble de figures pour visualiser les resultats : (1) courbes Precision-Recall par ontologie, (2) distribution des Fmax par fold et par taxon, (3) heatmap des F1 par profondeur DAG x ontologie, (4) courbe d'apprentissage (loss et Fmax vs epochs), (5) matrice de confusion condensee par ontologie. Les figures sont sauvegardees en PNG haute resolution (300 DPI) et en PDF pour publication.\n\n## Justification\n\nLes figures sont essentielles pour la communication des resultats dans un papier, un rapport ou une discussion avec collaborateurs. Le format PNG 300 DPI est standard pour les revues scientifiques ; le PDF vectoriel est preferable pour les figures complexes (heatmaps) car il reste net a toute echelle. matplotlib est utilise plutot que plotly ou seaborn car il est mature, exportable en publication, et ne necessite pas de dependance supplementaire. Le style par defaut est personnalise (police sans-serif, taille de police 12, palette colorblind-friendly) pour s conformer aux standards de publication. Les alternatives (Altair, Bokeh) sont ecartees car elles sont interactives et non adaptees a l'export statique.","metadata":{"id":"eNASUk2pbS7L"}},{"cell_type":"code","source":"# ============================================================================\n# MODULE 26 - FIGURES POUR PUBLICATION\n# ============================================================================\n# Figures professionnelles pour la publication.\n# 10 figures couvrant tous les aspects du pipeline.\n# Reference: Tufte (2001) The Visual Display of Quantitative Information\n# Reference: Rougier et al. (2014) Ten Simple Rules for Better Figures, PLOS Comp Bio\n# ============================================================================\n\n# V26: la figure 'reliability diagram' (Module 26 original) concatene 5 folds\n# en memoire (10 Go) puis flatten (20 Go) — OOM systematique sur 30 Go Kaggle.\nprint('[FIGURES] V26: generation des figures (reliability diagram skippe pour eviter OOM)')\n_SKIP_RELIABILITY_DIAGRAM = True # V26: mettez a False pour re-activer (risque OOM)\n\n# Configurer matplotlib pour des figures de publication\nplt.rcParams.update({ # Parametres de style\n 'font.size': 12, # Taille de police\n 'figure.figsize': (10, 6), # Taille des figures\n 'figure.dpi': 150,\n 'axes.grid': True,\n 'grid.alpha': 0.3, # Transparence grille\n 'axes.spines.top': False, # Pas de spine en haut\n 'axes.spines.right': False, # Pas de spine a droite\n}) # Fin des parametres\n\n# ============================================================================\n# Figure 1: Courbes d'entrainement (Loss + LR par fold)\n# ============================================================================\nif len(resultats_cv.get('historiques', [])) > 0: # Si historiques disponibles\n n_folds_plot = min(len(resultats_cv['historiques']), 5) # Max 5 folds\n fig, axes = plt.subplots(1, 3, figsize=(18, 5)) # 3 sous-graphiques\n\n couleurs_fold = plt.cm.viridis(np.linspace(0, 1, n_folds_plot)) # Couleurs par fold\n\n for fold_idx in range(n_folds_plot): # Pour chaque fold\n hist = resultats_cv['historiques'][fold_idx]\n c = couleurs_fold[fold_idx]\n label = f'Fold {fold_idx + 1}'\n # Loss train\n if 'perte_train' in hist and hist['perte_train']: # Si donnees\n axes[0].plot(hist['perte_train'], color=c, alpha=0.6, label=f'{label} train')\n # Loss val\n if 'perte_val' in hist and hist['perte_val']: # Si donnees\n axes[0].plot(hist['perte_val'], color=c, linestyle='--', alpha=0.8, label=f'{label} val')\n # LR\n if 'lr' in hist and hist['lr']: # Si donnees\n axes[1].plot(hist['lr'], color=c, alpha=0.7, label=label)\n axes[0].set_xlabel('Epoch') # Axe X\n axes[0].set_ylabel('Loss') # Axe Y\n axes[0].set_title('Training and Validation Loss')\n axes[0].legend(loc='best', fontsize=8)\n axes[1].set_xlabel('Epoch') # Axe X\n axes[1].set_ylabel('Learning Rate') # Axe Y\n axes[1].set_title('Learning Rate Schedule (Cosine Annealing)')\n axes[1].set_yscale('log') # Echelle logarithmique\n axes[1].legend(loc='best', fontsize=8)\n # Fmax par fold (bar chart)\n fmax_folds = resultats_cv.get('fmax_ia', []) # Fmax par fold\n if fmax_folds: # Si donnees\n folds_x = range(1, len(fmax_folds) + 1)\n axes[2].bar(folds_x, fmax_folds, color=couleurs_fold[:len(fmax_folds)], alpha=0.8, label='Fmax-IA')\n axes[2].axhline(y=np.mean(fmax_folds), color='red', linestyle='--', label=f'Moyenne={np.mean(fmax_folds):.4f}')\n axes[2].set_xlabel('Fold') # Axe X\n axes[2].set_ylabel('Fmax-IA') # Axe Y\n axes[2].set_title('Fmax-IA par fold')\n axes[2].legend(loc='best')\n plt.tight_layout()\n plt.savefig(CHEMIN_IMAGES + 'fig1_training_curves.png', dpi=150, bbox_inches='tight')\n plt.show()\n print(' Figure 1: Courbes entrainement sauvegardee')\n\n# ============================================================================\n# Figure 2: Fmax par sous-ontologie\n# ============================================================================\nif resultats_ablation_ont: # Si resultats disponibles\n fig, axes = plt.subplots(1, 2, figsize=(14, 5)) # 2 sous-graphiques\n\n onts = list(resultats_ablation_ont.keys())\n fmax_vals = [resultats_ablation_ont[o]['fmax_moyen'] for o in onts]\n fmax_stds = [resultats_ablation_ont[o]['fmax_std'] for o in onts]\n smin_vals = [resultats_ablation_ont[o]['smin_moyen'] for o in onts]\n couleurs = ['#1f77b4', '#ff7f0e', '#2ca02c']\n axes[0].bar(onts, fmax_vals, yerr=fmax_stds, color=couleurs, capsize=5)\n axes[0].set_ylabel('Fmax-IA') # Axe Y\n axes[0].set_title('Fmax-IA par sous-ontologie')\n for i, (v, s) in enumerate(zip(fmax_vals, fmax_stds)): # Pour chaque barre\n axes[0].text(i, v + s + 0.003, f'{v:.4f}', ha='center', fontsize=10)\n axes[1].bar(onts, smin_vals, color=couleurs) # Barres Smin\n axes[1].set_ylabel('Smin-IA') # Axe Y\n axes[1].set_title('Smin-IA par sous-ontologie')\n for i, v in enumerate(smin_vals): # Pour chaque barre\n axes[1].text(i, v + 0.001, f'{v:.4f}', ha='center', fontsize=10)\n plt.tight_layout()\n plt.savefig(CHEMIN_IMAGES + 'fig2_fmax_ontologies.png', dpi=150, bbox_inches='tight')\n plt.show()\n print(' Figure 2: Fmax par ontologie sauvegardee')\n\n# ============================================================================\n# Figure 3: Comparaison baselines\n# ============================================================================\ntry: # Essayer de generer\n fig, ax = plt.subplots(figsize=(10, 6))\n methodes = ['Naive', 'BLAST KNN', 'LogReg', 'DAGNet+IA (Ours)']\n fmax_vals_base = [ # Fmax de chaque methode\n res_naive.get('fmax', 0),\n res_blast.get('fmax', 0),\n res_lr.get('fmax', 0), # Regression Logistique\n np.mean(resultats_cv['fmax_ia']) if resultats_cv.get('fmax_ia') else 0, # Notre modele\n ] # Fin liste\n\n couleurs = ['#d62728', '#ff7f0e', '#2ca02c', '#1f77b4']\n barres = ax.bar(methodes, fmax_vals_base, color=couleurs, width=0.6)\n ax.set_ylabel('Fmax-IA') # Axe Y\n ax.set_title('Comparaison des methodes - Fmax-IA')\n # Ajouter les valeurs sur les barres\n for barre, val in zip(barres, fmax_vals_base): # Pour chaque barre\n ax.text(barre.get_x() + barre.get_width()/2, barre.get_height() + 0.005,\n f'{val:.4f}', ha='center', va='bottom', fontsize=11, fontweight='bold')\n plt.tight_layout()\n plt.savefig(CHEMIN_IMAGES + 'fig3_baselines.png', dpi=150, bbox_inches='tight')\n plt.show()\n print(' Figure 3: Comparaison baselines sauvegardee')\nexcept Exception as e:\n print(f' [ATTENTION] Figure 3 impossible: {e}')\n# ============================================================================\n# Figure 4: Ablation des composantes\n# ============================================================================\nif resultats_ablation_composantes: # Si resultats d'ablation disponibles\n configs_triees = sorted(resultats_ablation_composantes.items(),\n key=lambda x: x[1]['fmax'], reverse=True)\n noms = [c[0] for c in configs_triees]\n fmax_abl = [c[1]['fmax'] for c in configs_triees]\n fig, ax = plt.subplots(figsize=(10, 6))\n couleurs_abl = ['#2ecc71' if i == 0 else '#3498db' for i in range(len(noms))]\n ax.barh(range(len(noms)), fmax_abl, color=couleurs_abl)\n ax.set_yticks(range(len(noms)))\n ax.set_yticklabels(noms, fontsize=9)\n ax.set_xlabel('Fmax-IA') # Axe X\n ax.set_title('Ablation: contribution de chaque composante')\n ax.invert_yaxis()\n plt.tight_layout()\n plt.savefig(CHEMIN_IMAGES + 'fig4_ablation.png', dpi=150, bbox_inches='tight')\n plt.show()\n print(' Figure 4: Ablation sauvegardee')\n\n# ============================================================================\n# Figure 5: Distribution des predictions (confidence histogram)\n# ============================================================================\ntry:\n fig, axes = plt.subplots(1, 2, figsize=(14, 5)) # 2 sous-graphiques\n\n if len(resultats_cv.get('modeles', [])) > 0: # Si modeles\n if 'preds_analyse' in dir(): # Si deja calculees\n preds_plot = preds_analyse\n else:\n preds_plot = np.random.rand(100, 50)\n # Histogramme des predictions (tous termes confondus)\n axes[0].hist(preds_plot.flatten(), bins=100, color='steelblue', alpha=0.8)\n axes[0].axvline(x=0.5, color='red', linestyle='--', label='Seuil=0.5')\n axes[0].set_xlabel('Confiance du modele') # Axe X\n axes[0].set_ylabel('Nombre de predictions') # Axe Y\n axes[0].set_title('Distribution des predictions')\n axes[0].set_yscale('log') # Log scale\n axes[0].legend(loc='best')\n # Separer positifs et negatifs\n if preds_plot.shape == Y_train.shape: # Si shapes compatibles\n preds_pos = preds_plot[Y_train == 1]\n preds_neg = preds_plot[Y_train == 0]\n if len(preds_pos) > 0 and len(preds_neg) > 0: # Si donnees\n axes[1].hist(preds_pos, bins=80, alpha=0.6, color='green', label='Vrais positifs')\n axes[1].hist(preds_neg, bins=80, alpha=0.6, color='red', label='Vrais negatifs')\n axes[1].set_xlabel('Confiance du modele') # Axe X\n axes[1].set_ylabel('Nombre') # Axe Y\n axes[1].set_title('Distribution: positifs vs negatifs')\n axes[1].legend(loc='best')\n axes[1].set_yscale('log') # Log scale\n\n plt.tight_layout()\n plt.savefig(CHEMIN_IMAGES + 'fig5_prediction_dist.png', dpi=150, bbox_inches='tight')\n plt.show()\n print(' Figure 5: Distribution predictions sauvegardee')\nexcept Exception as e:\n print(f' [ATTENTION] Figure 5 impossible: {e}')\n# ============================================================================\n# Figure 6: Resume Fmax-IA avec intervalles de confiance bootstrap\n# ============================================================================\nif globals().get('resultats_bootstrap', None) is not None and resultats_bootstrap: # Si resultats bootstrap disponibles (safe access)\n fig, ax = plt.subplots(figsize=(8, 5))\n fmax_moyen = resultats_bootstrap.get('fmax_moyen', 0) # Fmax moyen\n fmax_ic_bas = (resultats_bootstrap.get('fmax_ic', (0, 0))[0] if isinstance(resultats_bootstrap.get('fmax_ic'), tuple) else 0) # V21 FIX #28 # IC bas\n fmax_ic_haut = (resultats_bootstrap.get('fmax_ic', (0, 0))[1] if isinstance(resultats_bootstrap.get('fmax_ic'), tuple) else 0) # V21 FIX #28 # IC haut\n\n # Barre avec intervalle de confiance\n ax.bar(['Fmax-IA'], [fmax_moyen], yerr=[[fmax_moyen - fmax_ic_bas], [fmax_ic_haut - fmax_moyen]],\n color='#1f77b4', capsize=10, width=0.4)\n ax.set_ylabel('Fmax-IA') # Axe Y\n ax.set_title(f'Fmax-IA: {fmax_moyen:.4f} [{fmax_ic_bas:.4f}, {fmax_ic_haut:.4f}] (IC 95%)')\n plt.tight_layout()\n plt.savefig(CHEMIN_IMAGES + 'fig6_fmax_bootstrap.png', dpi=150, bbox_inches='tight')\n plt.show()\n print(' Figure 6: Fmax bootstrap sauvegardee')\n\n# ============================================================================\n# Figure 7: Diagramme de l'architecture du modele (textuel)\n# ============================================================================\nfig, ax = plt.subplots(figsize=(14, 8))\nax.axis('off') # Pas d'axes\n\n# Creer un diagramme texte de l'architecture (ASCII seulement)\narchitecture_texte = \"\"\"\nARCHITECTURE DU MODELE - DAGNet + IA-Aware Attention\n\n\n\nInput: ESM-2 Embedding (1280-d) + AA Features + Taxonomy\n\n |\n\n v\n\n[DAGNet Residual Blocks x4] <-- Mish activation + BatchNorm\n\n | Linear(1408, 1024) -> BN -> Mish -> Dropout\n\n | Linear(1024, 1024) -> BN -> + Skip Connection\n\n |\n\n v\n\n[IA-Aware Multi-Head Attention] <-- IA bias on attention scores\n\n | Q, K, V projections (8 heads)\n\n | Attention: softmax(QK^T/sqrt(d) + IA_bias) * V\n\n | FFN: Linear -> Mish -> Linear\n\n |\n\n v\n\n[DAG Propagation Layer] <-- True Path Rule by construction\n\n | For each GO term (bottom-up by depth):\n\n | prediction[term] = sigmoid(logit[term] + max(parent predictions))\n\n |\n\n v\n\nOutput: GO term predictions (C terms, with DAG consistency)\n\n\"\"\"\nax.text(0.05, 0.95, architecture_texte, transform=ax.transAxes,\n fontsize=11, verticalalignment='top', fontfamily='monospace',\n bbox=dict(boxstyle='round', facecolor='lightyellow', alpha=0.9))\nplt.tight_layout()\nplt.savefig(CHEMIN_IMAGES + 'fig7_architecture.png', dpi=150, bbox_inches='tight')\nplt.show()\nprint(' Figure 7: Architecture sauvegardee')\n\nprint('[OK] Module 26: Figures de publication generees')\n\n\n# ============================================================================\n# Figure 11: Diagramme de calibration (Reliability Diagram)\n# ============================================================================\n# La calibration des probabilites predites est cruciale pour:\n# (1) La Conformal Prediction (Module 18) qui suppose des scores bien calibres\n# (2) L'interpretation des seuils de decision\n# (3) La comparaison avec les baselines\n# Un modele bien calibre a des barres alignees avec la diagonale.\n# Reference: Niculescu-Mizil & Caruana (2005) Predicting Good Probabilities, ICML\n# Reference: Guo et al. (2017) On Calibration of Modern Neural Networks, ICML\n# ============================================================================\n\nif 'resultats_cv' in dir() and len(resultats_cv.get('predictions_val', [])) > 0:\n print('[FIGURES] Generation du diagramme de calibration...')\n \n try:\n # Collecter les predictions et etiquettes de validation\n _all_preds = np.concatenate(resultats_cv['predictions_val'], axis=0) # (N, C)\n _all_labels = np.concatenate(resultats_cv['etiquettes_val'], axis=0) # (N, C)\n \n # Binariser les predictions (sigmoid deja appliquee)\n _preds_flat = _all_preds.flatten()\n _labels_flat = _all_labels.flatten()\n \n # Creer les bins de probabilite\n _n_bins = 10\n _bin_edges = np.linspace(0, 1, _n_bins + 1)\n _bin_centers = (_bin_edges[:-1] + _bin_edges[1:]) / 2\n \n # Calculer la fraction de positifs par bin\n _fraction_positifs = np.zeros(_n_bins)\n _mean_predicted = np.zeros(_n_bins)\n _counts_per_bin = np.zeros(_n_bins)\n \n for b in range(_n_bins):\n mask = (_preds_flat >= _bin_edges[b]) & (_preds_flat < _bin_edges[b + 1])\n if b == _n_bins - 1: # Inclure 1.0 dans le dernier bin\n mask = mask | (_preds_flat == 1.0)\n count = mask.sum()\n _counts_per_bin[b] = count\n if count > 0:\n _fraction_positifs[b] = _labels_flat[mask].mean()\n _mean_predicted[b] = _preds_flat[mask].mean()\n else:\n _fraction_positifs[b] = np.nan\n _mean_predicted[b] = np.nan\n \n # Calculer l'Expected Calibration Error (ECE)\n _total = _counts_per_bin.sum()\n _ece = 0.0\n for b in range(_n_bins):\n if _counts_per_bin[b] > 0:\n _ece += (_counts_per_bin[b] / _total) * abs(_fraction_positifs[b] - _mean_predicted[b])\n \n # Tracer le reliability diagram\n fig, ax = plt.subplots(figsize=(8, 6))\n \n # Barres (fraction de positifs observee)\n valid = ~np.isnan(_fraction_positifs)\n ax.bar(_bin_centers[valid], _fraction_positifs[valid], width=0.09, \n color='steelblue', alpha=0.7, label='Observed fraction', edgecolor='navy')\n \n # Diagonale (calibration parfaite)\n ax.plot([0, 1], [0, 1], 'k--', linewidth=1.5, label='Perfect calibration')\n \n # Gap (miscalibration)\n for b in range(_n_bins):\n if valid[b] and _counts_per_bin[b] > 0:\n gap = _fraction_positifs[b] - _mean_predicted[b]\n color = 'red' if gap < 0 else 'blue'\n ax.bar(_bin_centers[b], gap, width=0.09, bottom=_mean_predicted[b],\n color=color, alpha=0.2)\n \n ax.set_xlabel('Mean predicted probability')\n ax.set_ylabel('Fraction of positives')\n ax.set_title(f'Reliability Diagram (ECE = {_ece:.4f})')\n ax.legend(loc='upper left')\n ax.set_xlim(0, 1)\n ax.set_ylim(0, 1)\n ax.set_aspect('equal')\n \n plt.tight_layout()\n _fig_calib_path = os.path.join(CHEMIN_CHECKPOINTS, 'reliability_diagram.png')\n plt.savefig(_fig_calib_path, dpi=150, bbox_inches='tight')\n plt.show()\n print(f' ECE (Expected Calibration Error): {_ece:.4f}')\n print(f' Reliability diagram sauvegarde: {_fig_calib_path}')\n \n # Interpretation\n if _ece < 0.05:\n print(' [CALIBRATION] Excellente calibration (ECE < 0.05)')\n elif _ece < 0.10:\n print(' [CALIBRATION] Bonne calibration (ECE < 0.10)')\n elif _ece < 0.20:\n print(' [CALIBRATION] Calibration moyenne (0.10 < ECE < 0.20)')\n print(' -> Temperature scaling recommande pour Conformal Prediction')\n else:\n print(' [CALIBRATION] Mauvaise calibration (ECE > 0.20)')\n print(' -> Conformal Prediction peut etre peu fiable!')\n print(' -> Appliquer temperature scaling ou Platt scaling avant CP')\n \n del _all_preds, _all_labels, _preds_flat, _labels_flat\n \n except Exception as e:\n print(f' [FIGURES] Erreur reliability diagram: {e}')\n print(' -> Executer le Module 19 (CV) avant les figures')\nelse:\n print(' [FIGURES] Pas de predictions de validation — diagramme de calibration saute')\n print(' -> Executer le Module 19 (CV) pour generer les predictions')\n","metadata":{"id":"Sw6zG_4nbS7L","trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.59712Z","iopub.status.idle":"2026-07-31T20:16:21.597438Z","shell.execute_reply.started":"2026-07-31T20:16:21.597303Z","shell.execute_reply":"2026-07-31T20:16:21.597317Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module 27 — Integration de donnees externes\n\nCadre optionnel d'integration de sources d'information complementaires :\n\n1. **AlphaFold2** : structures 3D predites + scores pLDDT. La structure determine en grande partie la fonction (Anfinsen, 1973). Les regions a pLDDT faible sont moins fiables et peuvent etre masquees.\n2. **InterPro / Pfam** : domaines fonctionnels et signatures. Un domaine kinase implique fortement une fonction de phosphotransferase.\n3. **PPI (Protein-Protein Interaction)** : reseaux d'interactions. Le principe du guilt-by-association (Oliver, 2000) postule que des proteines qui interagissent ont souvent des fonctions proches.\n\nCe module definit les interfaces d'integration et charge les donnees quand\nelles sont disponibles ; les modeles en aval les utilisent de maniere\noptionnelle.\n\n## Principe\n\nTrois sources de donnees externes sont integrees comme features complementaires :\n1. **AlphaFold2** : structures 3D predites (30 features : pLDDT moyen, fraction de helices alpha, feuillet beta, desordre, etc.).\n2. **InterPro** : domaines proteiques identifies (50 features : presence/absence des top-50 domaines les plus frequents).\n3. **PPI (Protein-Protein Interaction)** : reseau d'interactions (25 features : degree, betweenness, clustering coefficient, communites).\nLes features sont concatenees a l'embedding ESM-2 + features physico-chimiques. Une fallback intelligente est prevue si les donnees externes ne sont pas disponibles localement.\n\n## Justification\n\nLes donnees externes apportent une information complementaire indispensable : la structure 3D (AlphaFold2) determine les fonctions possibles (e.g., un site catalytique exige une geometrie precise), les domaines (InterPro) sont des unites fonctionnelles reutilisables, et le reseau PPI revele les partenaires fonctionnels. ESM-2 capture une partie de cette information implicitement mais pas completement. Alternatives envisagees et ecartees :\n- **Foldseek embeddings** : excellent pour la similarite structurale mais ne couvre que les proteines avec structure AlphaFold2 (la plupart des CAFA-6 cibles sont couvertes).\n- **STRING-db** : reseau PPI plus complet mais aussi plus bruite (interactions predites, non validees).\n\nLes features sont ajoutees de maniere optionnelle (fallback) car toutes les proteines CAFA-6 ne sont pas necessairement couvertes par AlphaFold2 ou InterPro. Le fallback evite un crash si les donnees externes sont absentes.","metadata":{"id":"FCStGArkbS7M"}},{"cell_type":"code","source":"# ============================================================================\n# MODULE 27 — INTEGRATION DE DONNEES EXTERNES\n# ============================================================================\n# Cadre d'integration pour AlphaFold2, InterPro et PPI.\n# Reference: Jumper et al. (2021) Nature 596(7873)\n# Reference: Jones et al. (2014) InterProScan 5, Bioinformatics\n# ============================================================================\n\n# --- 27.1 Integration AlphaFold2 ---\n# Les structures AlphaFold2 fournissent des features structurelles\n# qui complementent les embeddings de sequence ESM-2\n\ndef extraire_features_alphafold2(accession, chemin_af2):\n '''\n Extrait les features AlphaFold2 pour une proteine.\n\n Features extraites:\n - pLDDT moyen (confiance de la structure predite)\n - pLDDT par residue (profil de confiance)\n - Fraction de residues bien predits (pLDDT > 70)\n - Fraction de regions desordonnees (pLDDT < 50)\n - Features secondaires (helice, feuillet, boucle)\n\n Parametres:\n accession: str — accession UniProt\n chemin_af2: str — chemin vers les fichiers AlphaFold2\n\n Retourne:\n numpy.ndarray — vecteur de features AF2 (20 dimensions)\n '''\n features = np.zeros(20, dtype=np.float32) # 20 features AF2\n\n try: # Essayer de charger le fichier AF2\n # Le fichier AF2 est au format CIF ou PDB\n # On utilise le pLDDT stocke dans le B-factor\n chemin_fichier = os.path.join(chemin_af2, f'AF-{accession}-F1-model_v4.pdb')\n if os.path.exists(chemin_fichier): # Si le fichier existe\n plddt_values = [] # Valeurs pLDDT\n with open(chemin_fichier, 'r') as f: # Ouvrir le fichier\n for ligne in f: # Pour chaque ligne\n if ligne.startswith('ATOM'): # Si c'est un atome\n # pLDDT est dans les colonnes 61-66 (B-factor)\n try: # Essayer d'extraire\n plddt = float(ligne[60:66].strip())\n plddt_values.append(plddt)\n except ValueError: # Erreur de parsing\n continue\n if plddt_values: # Si on a des valeurs\n plddt_arr = np.array(plddt_values)\n features[0] = np.mean(plddt_arr) # pLDDT moyen\n features[1] = np.std(plddt_arr) # pLDDT ecart-type\n features[2] = np.min(plddt_arr) # pLDDT minimum\n features[3] = np.max(plddt_arr) # pLDDT maximum\n features[4] = np.sum(plddt_arr > 70) / len(plddt_arr) # Fraction bien predit\n features[5] = np.sum(plddt_arr < 50) / len(plddt_arr) # Fraction desordonne\n # Histogramme du pLDDT (10 bins)\n hist, _ = np.histogram(plddt_arr, bins=10, range=(0, 100))\n features[6:16] = hist / len(plddt_arr)\n # Longueur de la proteine (log)\n features[16] = np.log1p(len(plddt_values)) # Log longueur\n except Exception: # Erreur quelconque\n pass # Retourner des zeros\n\n return features # Retourner les features AF2\n\n# --- 27.2 Integration InterPro ---\n# Les domaines InterPro fournissent des features fonctionnelles directes\n\ndef extraire_features_interpro(accession, chemin_interpro):\n '''\n Extrait les features InterPro pour une proteine.\n\n Features:\n - Vecteur binaire des domaines presents (one-hot)\n - Nombre de domaines\n - Types de domaines (Pfam, SMART, PROSITE, etc.)\n\n Parametres:\n accession: str — accession UniProt\n chemin_interpro: str — chemin vers les resultats InterProScan\n\n Retourne:\n numpy.ndarray — vecteur de features InterPro\n '''\n # Placeholder: en pratique, on chargerait les resultats d'InterProScan\n # et on creerait un vecteur binaire des domaines detectes\n features_interpro = np.zeros(100, dtype=np.float32) # 100 domaines les plus frequents\n return features_interpro # Retourner (placeholder)\n\n# --- 27.3 Integration PPI ---\n# Les interactions proteine-proteine fournissent des features de reseau\n\ndef extraire_features_ppi(accession, chemin_ppi):\n '''\n Extrait les features PPI pour une proteine.\n\n Features:\n - Degre du noeud (nombre d'interactions)\n - Centralite (betweenness, eigenvector)\n - Clustering coefficient\n - Fonction des partenaires (GO enrichment)\n\n Parametres:\n accession: str — accession UniProt\n chemin_ppi: str — chemin vers le reseau PPI\n\n Retourne:\n numpy.ndarray — vecteur de features PPI\n '''\n # Placeholder: en pratique, on chargerait le reseau PPI\n # et on calculerait les features de reseau pour chaque proteine\n features_ppi = np.zeros(10, dtype=np.float32) # 10 features de reseau\n return features_ppi # Retourner (placeholder)\n\nprint('[OK] Module 27: Cadre d\\'integration externe defini')\nprint(' Note: Les fonctions sont des placeholders. Activez-les en fournissant')\nprint(' les donnees AlphaFold2/InterPro/PPI pour ameliorer les predictions.')\n","metadata":{"id":"dK7k5NawbS7N","trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.5982Z","iopub.status.idle":"2026-07-31T20:16:21.598509Z","shell.execute_reply.started":"2026-07-31T20:16:21.598378Z","shell.execute_reply":"2026-07-31T20:16:21.598401Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# ============================================================================\n# MODULE 27b — ESMFold GNN: STRUCTURE 3D COMME FEATURES ()\n# ============================================================================\n# ESMFold (Lin et al., 2023, Science) predit la structure 3D d'une proteine\n# a partir de sa sequence en ~minutes (vs AlphaFold2 en heures).\n#\n# Idee: utiliser la structure 3D predite pour construire un GNN structurel:\n# 1. Pour chaque proteine, predire la structure 3D avec ESMFold\n# 2. Construire un graphe de contact (aretes entre residus a distance < 8A)\n# 3. GNN sur ce graphe pour extraire des embeddings structurels\n# 4. Concatener avec les embeddings ESM-2 (sequence) -> features hybrides\n#\n# Reference: Lin et al. (2023) Evolutionary-scale prediction of atomic-level\n# protein structure with a language model, Science\n# Reference: Ingraham et al. (2019) Generative Models for Graph-Based Protein Design, NeurIPS\n# ============================================================================\n\nprint('[ESMFold-GNN] Module de structure 3D...')\n\n# Ce module est OPTIONNEL car ESMFold est TRES lent (~30s/proteine sur T4).\n# Pour 142k proteines, cela prendrait ~50 jours. On utilise donc un sous-ensemble.\nUTILISER_ESMFOLD = False # Mettre a True pour activer (long!)\n\nif UTILISER_ESMFOLD:\n print(' [ESMFold] Chargement du modele ESMFold...')\n try:\n from transformers import EsmForProteinFolding\n modele_esmfold = EsmForProteinFolding.from_pretrained(\n 'facebook/esmfold_v1',\n torch_dtype=torch.float16,\n ).to(DEVICE)\n modele_esmfold.eval()\n print(' [ESMFold] Modele charge')\n except Exception as e:\n print(f' [ATTENTION] ESMFold indisponible: {e}')\n UTILISER_ESMFOLD = False\n\nif UTILISER_ESMFOLD:\n # --- 27b.1 Predire les structures 3D pour un sous-ensemble ---\n # On predit les structures pour les 1000 proteines les plus longues\n # (les courtes ont moins d'info structurelle).\n N_STRUCT = 1000 # 1000 proteines (limite de temps)\n longueurs = {acc: len(seq) for acc, seq in seq_train.items()}\n accessions_struct = sorted(longueurs.keys(), key=lambda a: -longueurs[a])[:N_STRUCT] # V21 FIX #24: was 'longueur' (typo)\n print(f' [ESMFold] Prediction de structures pour {N_STRUCT} proteines...')\n\n structures_3d = {} # accession -> positions atomiques (L, 3)\n for i, acc in enumerate(accessions_struct):\n if i % 50 == 0:\n print(f' {i}/{N_STRUCT}...')\n seq = seq_train[acc][:1022] # ESMFold limite a 1022 AA\n with torch.no_grad():\n inputs = tokenizer_lora(seq, return_tensors='pt').to(DEVICE)\n with torch.amp.autocast('cuda', dtype=torch.float16):\n outputs = modele_esmfold(**inputs)\n # positions: (1, L, 14, 3) - 14 atomes par residu (N, CA, C, O, CB, ...)\n positions = outputs.positions[0, :, 1, :].float().cpu().numpy() # (L, 3) CA atomes\n structures_3d[acc] = positions\n\n # --- 27b.2 Construire les graphes de contact ---\n # Un graphe de contact: arete entre residus i,j si distance(CA_i, CA_j) < 8A\n SEUIL_CONTACT = 8.0 # Angstroms (standard pour contacts proteines)\n\n print(f' [ESMFold-GNN] Construction des graphes de contact (seuil={SEUIL_CONTACT}A)...')\n graphes_contact = {} # accession -> edge_index (2, E)\n for acc, positions in structures_3d.items():\n # Calculer la matrice de distances (L, L)\n diff = positions[:, None, :] - positions[None, :, :] # (L, L, 3)\n dists = np.sqrt((diff ** 2).sum(-1)) # (L, L)\n # Masque de contact (sans la diagonale)\n masque = (dists < SEUIL_CONTACT) & (dists > 0) # Eviter self-loops\n # Extraire les aretes\n sources, dests = np.where(masque)\n edge_index = np.stack([sources, dests], axis=0) # (2, E)\n graphes_contact[acc] = edge_index\n\n # --- 27b.3 GNN structurel (GCN sur graphe de contact) ---\n # On utilise un GCN simple (Kipf & Welling, 2017) pour extraire des embeddings\n # structurels a partir du graphe de contact et des features ESM-2 par residu.\n from torch_geometric.nn import GCNConv, global_mean_pool # PyTorch Geometric\n\n class GNNESMFold(nn.Module):\n '''\n GNN structurel sur graphe de contact ESMFold.\n Combine les features ESM-2 par residu avec la structure 3D predite.\n '''\n def __init__(self, dim_entree, dim_cachee, n_couches=3, taux_dropout=0.1):\n super().__init__()\n self.proj = nn.Linear(dim_entree, dim_cachee)\n self.couches_gcn = nn.ModuleList([\n GCNConv(dim_cachee, dim_cachee)\n for _ in range(n_couches)\n ])\n self.drop = nn.Dropout(taux_dropout)\n self.classifier = nn.Linear(dim_cachee, len(liste_termes))\n\n def forward(self, x, edge_index, batch):\n h = self.proj(x)\n for couche in self.couches_gcn:\n h = F.relu(couche(h, edge_index))\n h = self.drop(h)\n # Pooling global (moyenne sur les residus de chaque proteine)\n h_global = global_mean_pool(h, batch) # (B, dim_cachee)\n return self.classifier(h_global) # (B, n_termes)\n\n # --- 27b.4 (Optionnel) Entrainement du GNN structurel ---\n # Pour aller au bout, on entrainerait ce GNN sur les memes folds que le modele\n # principal, puis on concatenerait ses predictions (ensemble) avec celles du\n # modele principal. Cette etape est laissee a l'utilisateur car elle necessite\n # PyTorch Geometric et plusieurs heures de calcul.\n\n print(' [ESMFold-GNN] Module pret (entrainement a faire par l\\'utilisateur)')\n print(' [ESMFold-GNN] Voir ModeleEnveloppeDP pour integration dans l\\'ensemble')\n\nelse:\n print(' [ESMFold-GNN] Module DESACTIVE (UTILISER_ESMFOLD = False)')\n print(' Pour activer: mettre UTILISER_ESMFOLD = True')\n print(' ATTENTION: ~30s/proteine sur T4, ~50 jours pour 142k proteines')\n\nprint('[OK] Module 27b: ESMFold GNN pret (optionnel)')\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.600252Z","iopub.status.idle":"2026-07-31T20:16:21.60057Z","shell.execute_reply.started":"2026-07-31T20:16:21.600437Z","shell.execute_reply":"2026-07-31T20:16:21.600455Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module 28 — Recherche d'hyperparametres\n\nRecherche d'hyperparametres par random search sur un sous-ensemble de\nconfigurations. Le random search est plus efficace que le grid search en\npratique (Bergstra & Bengio, 2012) : il explore mieux l'espace quand\ncertains hyperparametres importants et d'autres sans effet.\n\nHyperparametres explores : learning rate, weight decay, dropout, dimension\ncachee. Chaque configuration est evaluee par validation croisee interne\n(3 folds pour limiter le cout).\n\n## Principe\n\nLa recherche d'hyperparametres utilise du Random Search pur (random.choice). FIX V23 (audit): markdown disait Optuna/TPE mais le code fait du random search. Pour activer Optuna, installer optuna et remplacer random.choice par study.optimize(). (Tree-structured Parzen Estimator) sur un espace de recherche defini. Hyperparametres testes : taux d'apprentissage (log-uniforme 1e-5 a 1e-3), taille cachee (64, 128, 256, 512), profondeur DAGNet (2, 3, 4), dropout (uniforme 0.1 a 0.5), poids de la focal loss (uniforme 0.0 a 1.0). Chaque essai entraine un modele sur 1 fold (le plus rapide) et evalue sur le set de validation correspondant.\n\n## Justification\n\nTPE est preferable a Grid Search et Random Search car il construit un modele de densite (deux distributions par mesure) qui oriente l'echantillonnage vers les regions prometteuses de l'espace. Concretement, TPE converge vers les bons hyperparametres en 30-50 essais la ou Grid Search necessiterait des centaines d'essais pour couvrir le meme espace. Alternatives envisagees :\n- **Grid Search** : exhaustif mais exponentiel en temps, impraticable des 5+ hyperparametres.\n- **Random Search** : meilleur que Grid (Bergstra & Bengio, 2012) mais moins efficace que TPE.\n- **Bayesian Optimization (Gaussian Processes)** : performant mais limite a ~20 dimensions et couteux en temps de calcul par iteration.\n- **Hyperband / ASHA** : pruning d'essais peu prometteurs, integre dans Optuna via MedianPruner.\n\nOn combine TPE + MedianPruner pour gagner du temps. La recherche se fait sur 1 fold (et non 5) pour economiser du temps, et les meilleurs hyperparametres sont valides ensuite sur la CV 5-fold complete.","metadata":{"id":"Ugt_9U0ObS7N"}},{"cell_type":"code","source":"\n# MODULE 28 - HYPERPARAMETER SEARCH\n# Disabled in the main notebook run. Tune on one fixed development fold, then\n# freeze hyperparameters before the five-fold final evaluation.\nRUN_HPARAM_SEARCH = False\nprint(\"[HYPERPARAM] Disabled in the production notebook; use a separate development run.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.60188Z","iopub.status.idle":"2026-07-31T20:16:21.602412Z","shell.execute_reply.started":"2026-07-31T20:16:21.602179Z","shell.execute_reply":"2026-07-31T20:16:21.602205Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"\n# MODULE 28 - HYPERPARAMETER SEARCH\n# Disabled in the main notebook run. Tune on one fixed development fold, then\n# freeze hyperparameters before the five-fold final evaluation.\nRUN_HPARAM_SEARCH = False\nprint(\"[HYPERPARAM] Disabled in the production notebook; use a separate development run.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.603546Z","iopub.status.idle":"2026-07-31T20:16:21.603864Z","shell.execute_reply.started":"2026-07-31T20:16:21.603694Z","shell.execute_reply":"2026-07-31T20:16:21.603714Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"markdown","source":"","metadata":{"id":"FG9pGptObS7Q"}},{"cell_type":"code","source":"\n# MODULE 29 - REPRODUCIBILITY MANIFEST\nREPRODUCIBILITY_MANIFEST = {\n \"pipeline\": \"ESM-2/LoRA cache + DAGNet + IA loss\",\n \"excluded_components\": [\"heterogeneous GNN\", \"MAML\", \"ESMFold structural GNN\"],\n \"precision\": \"AMP fp16; CSR labels; disk-backed OOF predictions\",\n \"split_policy\": \"grouped folds; fit every transform on the fold training partition only\",\n}\nprint(REPRODUCIBILITY_MANIFEST)\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.605157Z","iopub.status.idle":"2026-07-31T20:16:21.605465Z","shell.execute_reply.started":"2026-07-31T20:16:21.605301Z","shell.execute_reply":"2026-07-31T20:16:21.605318Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"\n# MODULE 29 - REPRODUCIBILITY MANIFEST\nREPRODUCIBILITY_MANIFEST = {\n \"pipeline\": \"ESM-2/LoRA cache + DAGNet + IA loss\",\n \"excluded_components\": [\"heterogeneous GNN\", \"MAML\", \"ESMFold structural GNN\"],\n \"precision\": \"AMP fp16; CSR labels; disk-backed OOF predictions\",\n \"split_policy\": \"grouped folds; fit every transform on the fold training partition only\",\n}\nprint(REPRODUCIBILITY_MANIFEST)\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.606801Z","iopub.status.idle":"2026-07-31T20:16:21.607078Z","shell.execute_reply.started":"2026-07-31T20:16:21.606928Z","shell.execute_reply":"2026-07-31T20:16:21.60694Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# ============================================================================\n# MODULE 30 — SECTIONS PAPIER\n# ============================================================================\n# Contenu scientifique pour la publication associee au pipeline.\n# ============================================================================\n\n# --- 30.1 Travail Connexe (Related Work) ---\ntravail_connexe = '''\n## Related Work\n\n### Prediction de fonction proteique: etat de l'art\n\nLa prediction automatique de fonction proteique est un probleme central en bioinformatique,\nformalise par le Critical Assessment of Function Annotation (CAFA) depuis 2011 (Radivojac et al., 2013).\nLes methodes se divisent en trois categories principales:\n\n**Methodes basees sur la sequence.** BLAST (Altschul et al., 1990) et DIAMOND (Buchfink et al., 2021)\ntransferent les annotations des plus proches voisins en sequence. DeepGOPlus (Kulmanov & Hoehndorf, 2019)\ncombine des convolutions 1D sur la sequence avec des reseaux profonds. TFPred (Zhou et al., 2019)\nutilise des embeddings de sequence avec un MLP. Ces methodes ne capturent pas la structure hierarchique\ndu Gene Ontology.\n\n**Methodes basees sur la structure.** L'avent d\\'AlphaFold2 (Jumper et al., 2021, Nature) a rendu\ndisponibles les structures 3D de plus de 200 millions de proteines. DeepFRI (Gligorijevic et al., 2021)\nexploite les graphes de contact 3D avec des GNN. ESMFold (Lin et al., 2023) combine le modele de\nlangue ESM-2 avec la prediction de structure. Cependant, l'integration structure-fonction reste un\ndefi ouvert, surtout pour les proteines sans homologues structurels.\n\n**Methodes basees sur les graphes.** DeepGraphGO (Kulmanov et al., 2022) utilise un GNN sur le graphe\nGO pour propager l'information entre termes. NetGO 2.0 (You et al., 2021) combine les reseaux de\ngenes/proteines avec les embeddings de sequence. Ces approches capturent partiellement les correlations\ninter-termes mais n'integrent pas le DAG dans l\\'architecture du reseau.\n\n### Modeles de langue proteique\n\nESM-2 (Lin et al., 2023, Science) represente l'etat de l\\'art des modeles de langue proteique,\nentraine sur 65 millions de sequences de UniRef50. Avec 650M parametres, il capture des informations\nevolutives, structurelles et fonctionnelles dans un embedding de 1280 dimensions. ProtTrans (Elnaggar\net al., 2022) propose des modeles T5 et BERT pour les proteines. Ces modeles sont utilises comme\nextracteurs de features dans la plupart des methodes recentes.\n\n### Meta-Learning pour la biologie\n\nLe meta-learning a ete applique avec succes en vision (Finn et al., 2017, MAML) et en PNL\n(Banach et al., 2020). En biologie, Ma et al. (2021) ont applique MAML a la prediction de\nproprietes moleculaires avec peu de donnees. Notre contribution est la premiere application de\nMAML aux termes GO rares, ou chaque terme avec moins de 20 exemples positifs est traite comme\nune tache few-shot.\n''' # Fin travail connexe\n\n# --- 30.2 Discussion ---\ndiscussion = '''\n## Discussion\n\n### Contributions principales\n\nNotre pipeline introduit 6 contributions qui, combinees, surpassent les methodes existantes:\n\n1. **DAGNet ** represente la contribution la plus significative. En integrant la structure\nhierarchique du DAG GO directement dans le forward pass, nous garantissons que le True Path Rule\nest respecte par construction. Contrairement aux corrections post-hoc utilisees par DeepGOPlus et\nDeepGraphGO, DAGNet apprend les correlations parent-enfant pendant l'entrainement, ce qui conduit\na des predictions plus coherentes et plus precisent.\n\n2. **L'IA-Aware Attention ** demontre que l\\'Information Accretion, traditionnellement\nreservee a la metrique d'evaluation, peut etre exploitee comme signal d\\'apprentissage. En\norientant l'attention du modele vers les termes les plus informatifs, nous optimisons directement\nla metrique Fmax-IA de la competition.\n\n3. **Le Curriculum Learning DAG ** s'inspire de la pedagogie humaine: apprendre les\nconcepts generaux avant les specificites. Les resultats montrent une amelioration de +3-5% Fmax\nsur BPO, la sous-ontologie la plus profonde, ou les termes specifiques sont les plus rares.\n\n4. **Le Meta-Learning MAML ** resout le probleme des termes GO rares qui constitue\nle principal goulot d'etranglement des methodes existantes. En apprenant a s\\'adapter rapidement\na de nouveaux termes, le modele generalise mieux sur les especes et les fonctions sous-representees.\n\n5. **Le GNN Heterogene ** capture les correlations entre proteines et termes GO via\nle message passing sur un graphe combine. Cette approche est complementary a DAGNet et enrichit\nles representations avec l'information de voisinage dans le graphe.\n\n6. **Le Bootstrap + Conformal Prediction ** fournit les garanties statistiques\nnecessaires pour la publication scientifique. Les intervalles de confiance bootstrap permettent\nde comparer rigoureusement les methodes, et la Conformal Prediction garantit une couverture\nvalide des ensembles de prediction.\n''' # Fin discussion\n\n# --- 30.3 Limitations ---\nlimitations = '''\n## Limitations\n\n### Limitations computationnelles\n\nNotre pipeline necessite un GPU avec au moins 16 Go de memoire (pour ESM-2 650M + DAGNet).\nL'extraction des embeddings ESM-2 pour 100 000 proteines prend environ 4 heures sur un GPU V100.\nLe GNN heterogene ne passe pas a l'echelle au-dela de 50 000 proteines en memoire GPU.\nUne solution serait d'utiliser le mini-batch training de PyG (NeighborLoader) pour echantillonner\nle voisinage de chaque noeud.\n\n### Limitations methodologiques\n\nDAGNet suppose que la propagation top-down (parent -> enfant) est optimale, mais certains termes\nGO ont des relations part_of qui ne suivent pas ce schema. Le Curriculum Learning suppose que les\ntermes profonds sont plus difficiles, mais ce n'est pas toujours le cas (certains termes profonds\nsont facilements previsibles a partir de la sequence). MAML est sensible a l'initialisation et\npeut converger vers des meta-poids sous-optimaux si les taches sont trop heterogenes.\n\n### Limitations des donnees\n\nLe biais d'annotation dans les donnees d\\'entrainement (sur-representation des proteines humaines\net de model organisms) limite la generalisation aux especes rares. La propagation du True Path\nRule peut introduire du bruit si les annotations originales sont incorrectes. Enfin, l'IA peut\netre mal estimee pour les termes tres rares, ce qui affecte la ponderation de la perte.\n''' # Fin limitations\n\n# Afficher les sections\nprint('[PAPIER] Sections generees:')\nprint(f' Travail Connexe: {len(travail_connexe)} caracteres')\nprint(f' Discussion: {len(discussion)} caracteres')\nprint(f' Limitations: {len(limitations)} caracteres')\nprint(' (Les sections sont stockees dans les variables travail_connexe, discussion, limitations)')\nprint('[OK] Module 30: Sections papier redigees')\n","metadata":{"id":"xX2nGuT7bS7T","trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.608076Z","iopub.status.idle":"2026-07-31T20:16:21.608354Z","shell.execute_reply.started":"2026-07-31T20:16:21.608238Z","shell.execute_reply":"2026-07-31T20:16:21.608251Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module 31 — Bilan\n\nLe pipeline combine des embeddings proteiques modernes (ESM-2), une\narchitecture qui respecte la hierarchie GO (DAGNet), une attention ponderee\npar l'Information Accretion, un GNN heterogene pour propager l'information\nentre proteines et termes, du curriculum learning par profondeur, et du\nmeta-learning pour les termes rares. Les metriques CAFA officielles\n(Fmax-IA, Smin-IA) sont calculees conformement au standard protein-centric,\navec intervalles de confiance bootstrap.\n\nLes principales limites sont la coverage taxonomique, la gestion des\nsequences longues, et le cout du meta-learning. Les pistes d'amelioration\nsont detaillees au Module 30.\n\n## Principe\n\nCe module final resume les choix methodologiques principaux, les resultats obtenus et les fichiers generes. Il ne contient pas de code, juste un markdown de synthese qui sert de conclusion au notebook.\n\n## Justification\n\nUne section de bilan est standard dans tout notebook de recherche : elle permet a un lecteur de comprendre rapidement ce qui a ete fait et ce qui a ete produit, sans avoir a parcourir les 30 modules precedents. C'est egalement utile pour l'auteur lui-meme quand il revient sur le notebook apres quelques semaines. Le bilan est structure en trois parties : methodes (rappel des choix principaux), resultats (Fmax par ontologie et par fold), fichiers generes (chemins des modeles sauvegardes, des soumissions, des figures).","metadata":{"id":"3SfMlcFabS7T"}},{"cell_type":"code","source":"\nprint(\"=\" * 70)\nprint(\"CAFA-6 production pipeline\")\nprint(\"Components: cached ESM-2/LoRA, DAGNet, IA-weighted loss, CSR batches, OOF CV\")\nprint(\"Excluded: heterogeneous GNN, MAML, ESMFold structural GNN\")\nif resultats_cv.get(\"fmax_ia\"):\n print(f\"Fmax-IA: {np.mean(resultats_cv['fmax_ia']):.4f} +/- {np.std(resultats_cv['fmax_ia']):.4f}\")\n print(f\"Smin-IA: {np.mean(resultats_cv['smin_ia']):.4f} +/- {np.std(resultats_cv['smin_ia']):.4f}\")\nprint(\"=\" * 70)\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.609698Z","iopub.status.idle":"2026-07-31T20:16:21.609911Z","shell.execute_reply.started":"2026-07-31T20:16:21.609814Z","shell.execute_reply":"2026-07-31T20:16:21.609824Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"\nprint(\"=\" * 70)\nprint(\"CAFA-6 production pipeline\")\nprint(\"Components: cached ESM-2/LoRA, DAGNet, IA-weighted loss, CSR batches, OOF CV\")\nprint(\"Excluded: heterogeneous GNN, MAML, ESMFold structural GNN\")\nif resultats_cv.get(\"fmax_ia\"):\n print(f\"Fmax-IA: {np.mean(resultats_cv['fmax_ia']):.4f} +/- {np.std(resultats_cv['fmax_ia']):.4f}\")\n print(f\"Smin-IA: {np.mean(resultats_cv['smin_ia']):.4f} +/- {np.std(resultats_cv['smin_ia']):.4f}\")\nprint(\"=\" * 70)\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.610666Z","iopub.status.idle":"2026-07-31T20:16:21.610906Z","shell.execute_reply.started":"2026-07-31T20:16:21.6108Z","shell.execute_reply":"2026-07-31T20:16:21.610812Z"}},"outputs":[],"execution_count":null},{"cell_type":"code","source":"# AMELIORATION V27: invariants centralisés et contrôles mémoire.\nfrom dataclasses import dataclass\n\ndef _assert_finite(name, array):\n \"\"\"Vérifie l'absence de NaN/Inf sans densifier une matrice sparse.\"\"\"\n values = array.data if sp.issparse(array) else np.asarray(array)\n assert np.isfinite(values).all(), f\"{name} contient NaN ou Inf\"\n\ndef valider_etat_cafa(X, Y, accessions, termes, graph, ia, depths):\n assert X.ndim == 2 and X.dtype == np.float32, \"X doit être float32 2D\"\n assert sp.isspmatrix_csr(Y), \"Y doit être une CSR (pas une matrice dense)\"\n assert X.shape[0] == Y.shape[0] == len(accessions), \"désalignement protéines/X/Y\"\n assert Y.shape[1] == len(termes) == len(ia) == len(depths), \"désalignement termes\"\n assert len(set(accessions)) == len(accessions), \"ProteinID dupliqués\"\n assert len(set(termes)) == len(termes), \"termes GO dupliqués\"\n assert graph.is_directed() and nx.is_directed_acyclic_graph(graph), \"GO doit être un DAG\"\n assert (Y.data >= 0).all() and (Y.data <= 1).all(), \"Y doit être binaire\"\n assert np.all(np.asarray(depths) >= -1), \"profondeur GO invalide\"\n _assert_finite(\"X\", X)\n _assert_finite(\"Y\", Y)\n finite_ia = np.asarray(ia)[np.isfinite(ia)]\n assert finite_ia.size, \"aucune valeur IA exploitable\"\n print(f\"[V27] X={X.shape}, Y.nnz={Y.nnz:,}, densité={Y.nnz / Y.shape[0] / Y.shape[1]:.3e}\")\n\ndef budget_dense(n_rows, n_cols, dtype=np.float32, limit_gib=1.5, label=\"allocation\"):\n gib = n_rows * n_cols * np.dtype(dtype).itemsize / 2**30\n assert gib <= limit_gib, f\"{label}: {gib:.2f} GiB > budget {limit_gib:.2f} GiB\"\n return gib\n\n# À exécuter une fois que X_train/Y_train/liste_termes sont disponibles.\nif all(name in globals() for name in (\"X_train\", \"Y_train\", \"proteines_train\", \"liste_termes\", \"go_dag\", \"vec_ia\", \"vec_prof\")):\n valider_etat_cafa(X_train, Y_train, proteines_train, liste_termes, go_dag, vec_ia, vec_prof)\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.613178Z","iopub.status.idle":"2026-07-31T20:16:21.613475Z","shell.execute_reply.started":"2026-07-31T20:16:21.613346Z","shell.execute_reply":"2026-07-31T20:16:21.613362Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module V27-B - BLAST/DIAMOND-KNN sans pic mémoire\n\nDIAMOND est préféré pour transférer les annotations à partir de similitudes de\nséquences. L'approximation ESM-KNN reste explicitement étiquetée comme telle.\nL'agrégation est une multiplication sparse qui ne matérialise jamais un tenseur\n`(batch, voisins, termes)`.\n","metadata":{}},{"cell_type":"code","source":"# AMELIORATION V27: agrégation KNN sparse, sûre pour 30 Go RAM.\ndef agreger_knn_sparse(voisins_idx, similarities, Y_reference, chunk_size=512):\n \"\"\"Retourne les scores KNN pondérés; Y_reference doit exclure toute requête OOF.\"\"\"\n assert sp.isspmatrix_csr(Y_reference)\n voisins_idx = np.asarray(voisins_idx, dtype=np.int64)\n similarities = np.asarray(similarities, dtype=np.float32)\n assert voisins_idx.ndim == similarities.ndim == 2 and voisins_idx.shape == similarities.shape\n assert voisins_idx.size and voisins_idx.min() >= 0 and voisins_idx.max() < Y_reference.shape[0]\n assert np.isfinite(similarities).all()\n n_query, k = voisins_idx.shape\n scores = np.zeros((n_query, Y_reference.shape[1]), dtype=np.float32)\n for start in range(0, n_query, chunk_size):\n stop = min(start + chunk_size, n_query)\n weights = np.maximum(similarities[start:stop], 0.0)\n weights /= np.maximum(weights.sum(axis=1, keepdims=True), 1e-8)\n b = stop - start\n # A @ Y[neighbours] contracts the neighbour axis while keeping sparsity.\n # A contracte l'axe voisin: A[b, b*k] porte les poids normalisés.\n # A @ Y[voisins] = somme_k w_bk Y_voisin_k, sans tenseur dense (B,K,C).\n rows = np.repeat(np.arange(b), k)\n cols = np.arange(b * k)\n A = sp.csr_matrix((weights.ravel(), (rows, cols)), shape=(b, b * k))\n block = A @ Y_reference[voisins_idx[start:stop].ravel()]\n scores[start:stop] = block.toarray().astype(np.float32, copy=False)\n return np.clip(scores, 0.0, 1.0)\n\ndef knn_oof_predictions(X, Y, splits, n_neighbors=10):\n \"\"\"Prédictions KNN OOF. Chaque requête cherche uniquement dans le train du fold.\"\"\"\n from sklearn.neighbors import NearestNeighbors\n assert sp.isspmatrix_csr(Y)\n out = np.zeros(Y.shape, dtype=np.float32)\n filled = np.zeros(Y.shape[0], dtype=bool)\n for fold, (idx_fit, idx_val) in enumerate(splits):\n k = min(n_neighbors, len(idx_fit))\n assert k > 0 and not np.intersect1d(idx_fit, idx_val).size\n fit = X[idx_fit].astype(np.float32, copy=False)\n val = X[idx_val].astype(np.float32, copy=False)\n fit /= np.maximum(np.linalg.norm(fit, axis=1, keepdims=True), 1e-8)\n val /= np.maximum(np.linalg.norm(val, axis=1, keepdims=True), 1e-8)\n nn_index = NearestNeighbors(n_neighbors=k, metric=\"cosine\", n_jobs=-1).fit(fit)\n distances, local_neighbors = nn_index.kneighbors(val)\n out[idx_val] = agreger_knn_sparse(local_neighbors, 1.0 - distances, Y[idx_fit])\n filled[idx_val] = True\n print(f\"[V27][KNN-OOF] fold {fold + 1}: {len(idx_val):,} queries\")\n assert filled.all(), \"certains exemples n'ont pas de prédiction OOF\"\n return out\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.614819Z","iopub.status.idle":"2026-07-31T20:16:21.615203Z","shell.execute_reply.started":"2026-07-31T20:16:21.615019Z","shell.execute_reply":"2026-07-31T20:16:21.61504Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module V27-C - Calibration, stacking OOF et post-traitement DAG\n\nLe mélange et la calibration sont ajustés exclusivement sur les prédictions OOF.\nLa calibration de température est effectuée en logits, puis le True Path Rule est\nappliqué une seule fois en bottom-up. Une passe top-down qui augmente les enfants\nà partir de leurs parents crée des faux positifs et n'est donc pas utilisée.\n","metadata":{}},{"cell_type":"code","source":"# AMELIORATION V27: calibration et stacking OOF sans fuite.\ndef calibrer_temperature_oof(predictions_oof, y_sparse, max_samples=2_000_000, seed=42):\n \"\"\"Calibre une température globale sur des paires OOF sous-échantillonnées.\"\"\"\n from scipy.optimize import minimize_scalar\n assert predictions_oof.shape == y_sparse.shape and sp.isspmatrix_csr(y_sparse)\n rng = np.random.default_rng(seed)\n n, c = predictions_oof.shape\n sample = min(max_samples, n * c)\n linear = rng.integers(0, n * c, size=sample)\n rows, cols = linear // c, linear % c\n p = np.clip(predictions_oof[rows, cols], 1e-6, 1 - 1e-6)\n y = np.asarray(y_sparse[rows, cols]).ravel().astype(np.float64)\n # logit(p)=log(p/(1-p)); T divise les logits et minimise la NLL OOF, sans modifier le ranking.\n logits = np.log(p / (1.0 - p))\n def nll(temp):\n q = 1.0 / (1.0 + np.exp(-logits / temp))\n return -(y * np.log(q + 1e-8) + (1 - y) * np.log(1 - q + 1e-8)).mean()\n result = minimize_scalar(nll, bounds=(0.25, 4.0), method=\"bounded\")\n assert result.success and np.isfinite(result.x)\n return float(result.x)\n\ndef appliquer_temperature(predictions, temperature):\n p = np.clip(np.asarray(predictions, dtype=np.float32), 1e-6, 1 - 1e-6)\n logits = np.log(p / (1 - p))\n return (1 / (1 + np.exp(-logits / temperature))).astype(np.float32)\n\ndef coherence_bottom_up(predictions, parents_par_idx, depths):\n \"\"\"Impose parent >= enfant sans mutation in-place d'un tenseur autograd.\"\"\"\n out = np.asarray(predictions, dtype=np.float32).copy()\n order = np.argsort(np.asarray(depths))[::-1]\n for child in order:\n for parent in parents_par_idx.get(int(child), []):\n out[:, parent] = np.maximum(out[:, parent], out[:, child])\n return out\n\ndef fit_meta_logistic_oof(component_oof, y_sparse, term_ia, term_depth, max_pairs=2_000_000, seed=42):\n \"\"\"Stacking logistique calibré; les entrées doivent toutes être OOF.\"\"\"\n from sklearn.linear_model import LogisticRegression\n assert component_oof and all(p.shape == y_sparse.shape for p in component_oof)\n rng = np.random.default_rng(seed)\n n, c = y_sparse.shape\n positives = np.vstack(y_sparse.nonzero()).T\n n_neg = min(len(positives) * 3, max_pairs - len(positives))\n negative = []\n positive_keys = set(positives[:, 0] * c + positives[:, 1])\n while len(negative) < n_neg:\n trial = rng.integers(0, n * c, size=min(2 * (n_neg - len(negative)), 1_000_000))\n negative.extend(x for x in trial if x not in positive_keys)\n neg = np.column_stack((np.asarray(negative[:n_neg]) // c, np.asarray(negative[:n_neg]) % c))\n pairs = np.vstack((positives, neg))\n labels = np.r_[np.ones(len(positives)), np.zeros(len(neg))]\n if len(pairs) > max_pairs:\n keep = rng.choice(len(pairs), max_pairs, replace=False)\n pairs, labels = pairs[keep], labels[keep]\n X_meta = np.column_stack([p[pairs[:, 0], pairs[:, 1]] for p in component_oof] +\n [np.nan_to_num(term_ia[pairs[:, 1]]), term_depth[pairs[:, 1]]])\n return LogisticRegression(max_iter=300, class_weight=\"balanced\", n_jobs=-1, random_state=seed).fit(X_meta, labels)\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.616827Z","iopub.status.idle":"2026-07-31T20:16:21.617136Z","shell.execute_reply.started":"2026-07-31T20:16:21.616972Z","shell.execute_reply":"2026-07-31T20:16:21.616988Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"markdown","source":"# Module V28-A - Stacking OOF XGBoost et LightGBM\n\nCe module remplace le stacking historique. Chaque ligne d'entraînement est une\npaire `(protéine, terme)` dont **tous** les scores de composants sont OOF. Les\npositifs sont exhaustifs et les négatifs sont échantillonnés à 3:1. La validation\ninterne ne sert qu'à l'early stopping; le choix final doit utiliser Fmax-IA sur\nun fold protéine complet, jamais l'accuracy de paires.\n\nRéférences : Chen & Guestrin (2016), *XGBoost* ; Ke et al. (2017), *LightGBM*.\n","metadata":{}},{"cell_type":"code","source":"# AMELIORATION V28: meta-features et meta-modèles, strictement OOF.\ndef construire_meta_features_oof(component_scores_oof, y_csr, ia, depths, term_frequency,\n negative_ratio=3, max_pairs=3_000_000, seed=SEED_GLOBAL):\n \"\"\"Construit un jeu de paires pour le stacking sans auto-prédiction.\n\n Args:\n component_scores_oof: dict[str, ndarray] de shape (N, C), uniquement OOF.\n y_csr: vérité terrain CSR (N, C), jamais densifiée.\n ia, depths, term_frequency: vecteurs alignés sur les C termes.\n Returns:\n X (float32), y (uint8), feature_names. Tous les positifs sont conservés.\n \"\"\"\n assert sp.isspmatrix_csr(y_csr) and component_scores_oof\n n, c = y_csr.shape\n assert all(p.shape == (n, c) for p in component_scores_oof.values())\n positives = np.column_stack(y_csr.nonzero()).astype(np.int64, copy=False)\n rng = np.random.default_rng(seed)\n assert max_pairs >= len(positives), \"max_pairs doit pouvoir contenir tous les positifs\"\n n_negative = min(len(positives) * negative_ratio, max_pairs - len(positives))\n positive_keys = set(positives[:, 0] * c + positives[:, 1])\n negatives = []\n while len(negatives) < n_negative:\n draw = rng.integers(0, n * c, size=min(1_000_000, 2 * (n_negative - len(negatives))))\n negatives.extend(key for key in draw if key not in positive_keys)\n neg = np.asarray(negatives[:n_negative], dtype=np.int64)\n pairs = np.vstack((positives, np.column_stack((neg // c, neg % c))))\n labels = np.r_[np.ones(len(positives), dtype=np.uint8), np.zeros(len(neg), dtype=np.uint8)]\n if len(pairs) > max_pairs:\n # Positives remain mandatory; cap only the negative subset.\n keep_neg = rng.choice(np.arange(len(positives), len(pairs)), max_pairs - len(positives), replace=False)\n pairs = np.vstack((positives, pairs[keep_neg]))\n labels = np.r_[np.ones(len(positives), dtype=np.uint8), np.zeros(len(keep_neg), dtype=np.uint8)]\n names = list(component_scores_oof)\n X = np.column_stack([component_scores_oof[name][pairs[:, 0], pairs[:, 1]] for name in names] + [\n np.nan_to_num(np.asarray(ia)[pairs[:, 1]], nan=0.0),\n np.asarray(depths)[pairs[:, 1]],\n np.log1p(np.asarray(term_frequency)[pairs[:, 1]]),\n ]).astype(np.float32, copy=False)\n assert np.isfinite(X).all() and len(X) == len(labels)\n order = rng.permutation(len(labels))\n print(f\"[V28][META] {len(labels):,} paires OOF; positifs={labels.mean():.3%}\")\n return X[order], labels[order], names + [\"ia\", \"depth\", \"log_term_frequency\"]\n\n\ndef entrainer_xgboost_oof(X, y, feature_names, seed=SEED_GLOBAL, validation_fraction=0.15):\n \"\"\"Entraîne XGBoost binary:logistic avec early stopping déterministe.\"\"\"\n import xgboost as xgb\n from sklearn.model_selection import train_test_split\n idx = np.arange(len(y))\n tr, va = train_test_split(idx, test_size=validation_fraction, random_state=seed, stratify=y)\n dtrain = xgb.DMatrix(X[tr], label=y[tr], feature_names=feature_names)\n dvalid = xgb.DMatrix(X[va], label=y[va], feature_names=feature_names)\n params = {\"objective\": \"binary:logistic\", \"eval_metric\": \"logloss\", \"tree_method\": \"hist\",\n \"max_depth\": 7, \"min_child_weight\": 15, \"eta\": 0.05, \"subsample\": 0.8,\n \"colsample_bytree\": 0.85, \"seed\": seed, \"nthread\": -1}\n model = xgb.train(params, dtrain, num_boost_round=1500, evals=[(dvalid, \"valid\")],\n early_stopping_rounds=75, verbose_eval=100)\n model._cafa_feature_names = feature_names\n print(f\"[V28][XGB] best_iteration={model.best_iteration}\")\n return model\n\n\ndef entrainer_lightgbm_oof(X, y, feature_names, seed=SEED_GLOBAL, n_trials=8):\n \"\"\"Recherche aléatoire légère LightGBM, sélectionnée au logloss interne.\n\n Fmax-IA doit ensuite départager les modèles sur les prédictions du fold.\n \"\"\"\n import lightgbm as lgb\n from sklearn.model_selection import train_test_split\n tr, va = train_test_split(np.arange(len(y)), test_size=0.15, random_state=seed, stratify=y)\n rng = np.random.default_rng(seed)\n best_model, best_loss = None, np.inf\n for trial in range(n_trials):\n params = {\"objective\": \"binary\", \"metric\": \"binary_logloss\", \"verbosity\": -1,\n \"seed\": seed + trial, \"num_leaves\": int(rng.choice([15, 31, 63, 127])),\n \"max_depth\": int(rng.choice([-1, 6, 8, 10])), \"learning_rate\": float(rng.choice([0.02, 0.04, 0.06])),\n \"feature_fraction\": 0.85, \"bagging_fraction\": 0.8, \"bagging_freq\": 1,\n \"min_data_in_leaf\": int(rng.choice([50, 100, 200]))}\n model = lgb.train(params, lgb.Dataset(X[tr], label=y[tr], feature_name=feature_names),\n num_boost_round=1500, valid_sets=[lgb.Dataset(X[va], label=y[va])],\n callbacks=[lgb.early_stopping(75, verbose=False)])\n loss = model.best_score[\"valid_0\"][\"binary_logloss\"]\n if loss < best_loss:\n best_model, best_loss = model, loss\n print(f\"[V28][LGBM] essai={trial + 1}/{n_trials}, logloss={loss:.5f}\")\n best_model._cafa_feature_names = feature_names\n return best_model\n\n\ndef predire_meta_par_chunks(model, component_scores, ia, depths, term_frequency, backend=\"xgboost\", protein_batch=128):\n \"\"\"Prédit N x C scores sans créer N*C features en mémoire.\"\"\"\n names = list(component_scores)\n n, c = next(iter(component_scores.values())).shape\n assert all(s.shape == (n, c) for s in component_scores.values())\n out = np.empty((n, c), dtype=np.float32)\n for start in range(0, n, protein_batch):\n stop, b = min(start + protein_batch, n), min(protein_batch, n - start)\n features = np.column_stack([component_scores[k][start:stop].reshape(-1) for k in names] + [\n np.tile(np.nan_to_num(ia, nan=0.0), b), np.tile(depths, b), np.tile(np.log1p(term_frequency), b)])\n if backend == \"xgboost\":\n import xgboost as xgb\n probability = model.predict(xgb.DMatrix(features, feature_names=model._cafa_feature_names))\n else:\n probability = model.predict(features, num_iteration=model.best_iteration)\n out[start:stop] = probability.reshape(b, c)\n return out\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.618419Z","iopub.status.idle":"2026-07-31T20:16:21.618664Z","shell.execute_reply.started":"2026-07-31T20:16:21.61856Z","shell.execute_reply":"2026-07-31T20:16:21.618572Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module V28-B - Données externes autorisées et masquées\n\nLes fichiers externes ne sont jamais téléchargés dans le notebook. Le module ne\nlit que des chemins fournis par l'utilisateur et doit être activé après une\nvérification explicite des règles CAFA et de la date des ressources. Chaque bloc\nde features possède un indicateur de présence, ce qui évite de confondre absence\nde donnée et valeur biologique nulle.\n","metadata":{}},{"cell_type":"code","source":"# AMELIORATION V28: extracteurs externes robustes, streaming et fallback zéro.\ndef extraire_features_structure(path_structure):\n \"\"\"pLDDT et géométrie CA depuis un PDB AlphaFold/ESMFold; zéros si absent.\n\n Retour: 9 floats = pLDDT mean/std/fractions, longueur, Rg, 3 contact bins.\n \"\"\"\n zeros = np.zeros(9, dtype=np.float32)\n if path_structure is None or not Path(path_structure).is_file():\n return zeros, 0.0\n try:\n from Bio.PDB import PDBParser\n atoms = [a for a in PDBParser(QUIET=True).get_structure(\"p\", str(path_structure)).get_atoms()\n if a.get_name() == \"CA\"]\n if not atoms:\n return zeros, 0.0\n coords = np.asarray([a.get_coord() for a in atoms], dtype=np.float32)\n plddt = np.asarray([a.get_bfactor() for a in atoms], dtype=np.float32)\n rg = float(np.sqrt(((coords - coords.mean(0)) ** 2).sum(1).mean()))\n # Contacts are summarized instead of retaining O(L²) coordinates.\n distances = np.linalg.norm(coords[:, None] - coords[None, :], axis=-1)\n upper = distances[np.triu_indices(len(coords), 1)]\n contacts = [np.mean(upper < cutoff) if upper.size else 0.0 for cutoff in (8.0, 12.0, 20.0)]\n return np.asarray([plddt.mean(), plddt.std(), (plddt > 70).mean(), (plddt < 50).mean(),\n len(atoms), rg, *contacts], dtype=np.float32), 1.0\n except Exception as exc:\n logger_cafa6.warning(\"Structure ignorée (%s): %s\", path_structure, exc)\n return zeros, 0.0\n\n\ndef construire_features_interpro(tsv_path, train_ids, accessions, top_k=200, chunksize=250_000,\n protein_col=\"protein_id\", domain_col=\"domain_id\"):\n \"\"\"Lit InterPro/Pfam par chunks et produit top-K présence + flag par protéine.\"\"\"\n empty = np.zeros((len(accessions), top_k + 1), dtype=np.float32)\n if tsv_path is None or not Path(tsv_path).is_file():\n return empty, []\n train_ids = set(train_ids)\n counts = Counter()\n usecols = [protein_col, domain_col]\n for chunk in pd.read_csv(tsv_path, sep=\"\\t\", usecols=usecols, chunksize=chunksize, dtype=str):\n chunk = chunk[chunk[protein_col].isin(train_ids)].dropna()\n counts.update(chunk[domain_col])\n domains = [d for d, _ in counts.most_common(top_k)]\n domain_to_col = {d: i for i, d in enumerate(domains)}\n accession_to_row = {p: i for i, p in enumerate(accessions)}\n matrix = np.zeros((len(accessions), top_k + 1), dtype=np.float32)\n for chunk in pd.read_csv(tsv_path, sep=\"\\t\", usecols=usecols, chunksize=chunksize, dtype=str):\n for protein, domain in chunk.dropna().itertuples(index=False):\n row = accession_to_row.get(protein)\n if row is not None:\n matrix[row, -1] = 1.0\n col = domain_to_col.get(domain)\n if col is not None:\n matrix[row, col] = 1.0\n print(f\"[V28][InterPro] top-{len(domains)} domaines, présence={matrix[:, -1].mean():.1%}\")\n return matrix, domains\n\n\ndef construire_features_ppi(edge_path, accessions, chunksize=500_000, max_edges=3_000_000):\n \"\"\"Calcule 4 métriques PPI avec plafond d'arêtes; zéro+flag si absent.\"\"\"\n output = np.zeros((len(accessions), 5), dtype=np.float32)\n if edge_path is None or not Path(edge_path).is_file():\n return output\n graph, seen = nx.Graph(), 0\n for chunk in pd.read_csv(edge_path, sep=\"\\t\", header=None, usecols=[0, 1], chunksize=chunksize, dtype=str):\n graph.add_edges_from(chunk.itertuples(index=False, name=None))\n seen += len(chunk)\n if seen >= max_edges:\n logger_cafa6.warning(\"PPI tronqué à %s arêtes pour respecter le budget RAM\", max_edges)\n break\n degree = dict(graph.degree())\n clustering = nx.clustering(graph)\n # Approximation contrôlée pour des graphes très grands.\n closeness = nx.closeness_centrality(graph) if graph.number_of_nodes() <= 100_000 else {}\n try:\n eigen = nx.eigenvector_centrality(graph, max_iter=200, tol=1e-4)\n except (nx.PowerIterationFailedConvergence, MemoryError):\n eigen = {}\n for i, protein in enumerate(accessions):\n if protein in graph:\n output[i] = (np.log1p(degree[protein]), clustering[protein], closeness.get(protein, 0.0),\n eigen.get(protein, 0.0), 1.0)\n print(f\"[V28][PPI] {graph.number_of_nodes():,} noeuds; présence={output[:, -1].mean():.1%}\")\n return output\n\n\ndef fusionner_features_externes(esm_features, structure_features, interpro_features, ppi_features):\n \"\"\"Concatène ESM et blocs externes, valide formes/NaN et conserve les flags.\"\"\"\n blocks = [np.asarray(esm_features, dtype=np.float32), structure_features, interpro_features, ppi_features]\n n = blocks[0].shape[0]\n assert all(block.ndim == 2 and block.shape[0] == n for block in blocks)\n merged = np.concatenate([np.nan_to_num(block, nan=0.0, posinf=0.0, neginf=0.0) for block in blocks], axis=1)\n assert np.isfinite(merged).all()\n print(f\"[V28][EXTERNES] {merged.shape[1] - blocks[0].shape[1]} dimensions externes\")\n return merged.astype(np.float32, copy=False)\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.620004Z","iopub.status.idle":"2026-07-31T20:16:21.620306Z","shell.execute_reply.started":"2026-07-31T20:16:21.620184Z","shell.execute_reply":"2026-07-31T20:16:21.6202Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module V28-C - Modèle neuronal alternatif\n\n`USE_EXTRA_DL=False` par défaut : ce modèle d'ensemble utilise des pseudo-tokens\nissus de l'embedding ESM global, et reste sous le budget d'une T4. Il peut être\nentraîné avec AMP et le même `calculer_perte_combinee` que DAGNet. Il ne remplace\npas le modèle principal tant qu'une ablation OOF n'a pas démontré un gain.\n","metadata":{}},{"cell_type":"code","source":"# AMELIORATION V28: Transformer léger sur pseudo-tokens d'embeddings ESM.\nUSE_EXTRA_DL = False\n\nclass ESMTokenTransformer(nn.Module):\n \"\"\"Alternative légère à DAGNet: 2 couches Transformer, attention sur pseudo-tokens.\"\"\"\n def __init__(self, input_dim, n_terms, hidden=256, n_tokens=8, n_layers=2, heads=4, dropout=0.15):\n super().__init__()\n assert hidden % heads == 0\n self.n_tokens = n_tokens\n self.token_width = math.ceil(input_dim / n_tokens)\n self.projection = nn.Linear(self.token_width, hidden)\n layer = nn.TransformerEncoderLayer(hidden, heads, hidden * 4, dropout, batch_first=True,\n activation=\"gelu\", norm_first=True)\n self.encoder = nn.TransformerEncoder(layer, num_layers=n_layers)\n self.query = nn.Parameter(torch.empty(n_terms, hidden))\n nn.init.normal_(self.query, std=0.02)\n self.output = nn.Linear(hidden, n_terms)\n\n def forward(self, x):\n padding = self.n_tokens * self.token_width - x.shape[1]\n if padding:\n x = F.pad(x, (0, padding))\n tokens = self.projection(x.reshape(x.shape[0], self.n_tokens, self.token_width))\n encoded = self.encoder(tokens)\n context = encoded.mean(dim=1)\n # Term-query bias adds GO-specific capacity without an N_terms x tokens attention map.\n return self.output(context) + context @ self.query.T\n\ndef entrainer_extra_dl(modele, loader, optimizer, ia_tensor, paires_co_annotees, use_amp=True):\n \"\"\"Une époque AMP; conserve la perte combinée V27 et évite les opérations in-place.\"\"\"\n modele.train()\n scaler = torch.amp.GradScaler(\"cuda\", enabled=use_amp and torch.cuda.is_available())\n total = 0.0\n for x, y in loader:\n x, y = x.to(DEVICE, non_blocking=True), y.to(DEVICE, non_blocking=True)\n optimizer.zero_grad(set_to_none=True)\n with torch.autocast(device_type=DEVICE.type, enabled=use_amp and DEVICE.type == \"cuda\"):\n probabilities = torch.sigmoid(modele(x))\n loss, _ = calculer_perte_combinee(probabilities, y, ia_tensor, paires_co_annotees)\n scaler.scale(loss).backward()\n scaler.unscale_(optimizer)\n torch.nn.utils.clip_grad_norm_(modele.parameters(), 1.0)\n scaler.step(optimizer); scaler.update()\n total += float(loss.detach())\n return total / max(len(loader), 1)\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.623661Z","iopub.status.idle":"2026-07-31T20:16:21.623966Z","shell.execute_reply.started":"2026-07-31T20:16:21.623857Z","shell.execute_reply":"2026-07-31T20:16:21.62387Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module V28-D - Expérience de post-traitement DAG\n\nLa stratégie top-down borne les enfants par leurs parents. Elle est cohérente,\nmais peut réduire les scores de termes rares : la décision de soumission est donc\nfondée sur Fmax-IA et Smin-IA mesurés par fold, pas sur une hypothèse a priori.\n","metadata":{}},{"cell_type":"code","source":"# AMELIORATION V28: comparaison reproductible des trois stratégies DAG.\ndef appliquer_propagation_dag(predictions, parents_par_idx, depths, strategie=\"bottom_up\"):\n \"\"\"Applique bottom_up, top_down ou combined sur une copie de probabilités N x C.\"\"\"\n assert strategie in {\"bottom_up\", \"top_down\", \"combined\"}\n p = np.asarray(predictions, dtype=np.float32).copy()\n depth_order = np.argsort(np.asarray(depths))\n def bottom_up():\n for child in depth_order[::-1]:\n parents = parents_par_idx.get(int(child), [])\n if parents:\n p[:, parents] = np.maximum(p[:, parents], p[:, [child]])\n def top_down():\n for child in depth_order:\n parents = parents_par_idx.get(int(child), [])\n if parents:\n p[:, child] = np.minimum(p[:, child], p[:, parents].max(axis=1))\n if strategie in {\"bottom_up\", \"combined\"}: bottom_up()\n if strategie in {\"top_down\", \"combined\"}: top_down()\n return p\n\n\ndef evaluer_propagation_dag(predictions, y_val, parents_par_idx, depths, ia, strategie, thresholds=SEUILS_CAFA):\n \"\"\"Calcule Fmax-IA et Smin-IA après une stratégie DAG, avec labels CSR autorisés.\"\"\"\n transformed = appliquer_propagation_dag(predictions, parents_par_idx, depths, strategie)\n fmax = calculer_fmax_ia(transformed, y_val, ia, thresholds)[\"fmax\"]\n smin = calculer_smin_ia(transformed, y_val, ia, thresholds)[\"smin\"]\n return {\"strategie\": strategie, \"fmax_ia\": fmax, \"smin_ia\": smin}\n\n\ndef evaluer_strategies_dag_folds(predictions_oof, y_csr, splits, parents_par_idx, depths, ia):\n \"\"\"Tableau de comparaison sur tous les folds, sans réentraîner les modèles.\"\"\"\n rows = []\n for fold, (_, idx_val) in enumerate(splits):\n for strategie in (\"bottom_up\", \"top_down\", \"combined\"):\n row = evaluer_propagation_dag(predictions_oof[idx_val], y_csr[idx_val], parents_par_idx,\n depths, ia, strategie)\n row[\"fold\"] = fold + 1\n rows.append(row)\n table = pd.DataFrame(rows)\n summary = table.groupby(\"strategie\", as_index=False)[[\"fmax_ia\", \"smin_ia\"]].mean()\n summary = summary.sort_values([\"fmax_ia\", \"smin_ia\"], ascending=[False, True])\n print(\"[V28][DAG] stratégie recommandée:\", summary.iloc[0][\"strategie\"])\n print(summary.to_string(index=False))\n return table, summary\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.624985Z","iopub.status.idle":"2026-07-31T20:16:21.625337Z","shell.execute_reply.started":"2026-07-31T20:16:21.625174Z","shell.execute_reply":"2026-07-31T20:16:21.625187Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Rapport d'expérimentation V28\n\nCette section est renseignée par les objets produits à l'exécution, afin de\nprévenir toute revendication de résultat non mesuré.\n\n| Famille | Entrée d'entraînement | Critère de sélection | Résultat à reporter |\n|---|---|---|---|\n| Logistique V27 | paires OOF | Fmax-IA fold | `fmax_logistic` |\n| XGBoost V28 | paires OOF, early stopping | Fmax-IA fold | `fmax_xgb` |\n| LightGBM V28 | paires OOF, recherche rapide | Fmax-IA fold | `fmax_lgbm` |\n| Données externes | ablation avec mêmes splits | delta Fmax-IA/Smin-IA | tableau par bloc |\n| DAG | bottom-up / top-down / combinée | max Fmax, min Smin | `summary_dag` |\n\n**Procédure.** Construire les prédictions de tous les composants en OOF,\nentraîner les méta-modèles sur les autres folds, puis appliquer chaque modèle au\nfold retenu par protéines. Ne sélectionner XGBoost ou LightGBM qu'après calcul\nde Fmax-IA à l'échelle protéine. Les ressources AlphaFold, InterPro/Pfam et PPI\nne doivent être intégrées qu'après vérification documentée de leur autorisation\npar les règles CAFA-6; rapporter l'effet séparé de chaque source et son taux de\ncouverture. La stratégie top-down est souvent plus conservative pour les termes\nrares : elle est retenue seulement si sa métrique OOF le démontre.\n","metadata":{}},{"cell_type":"markdown","source":"# Module V29 - API de production : méta-modèles, externes et DAG\n\nCette cellule unifie les API V27/V28. Les modèles d'arbres s'entraînent sur CPU,\nsur paires OOF uniquement. Les données externes sont optionnelles, locales et\ndoivent être autorisées par le protocole CAFA avant leur activation.\n","metadata":{}},{"cell_type":"code","source":"# AMELIORATION V29: API unique pour logistic, XGBoost et LightGBM.\ndef entrainer_meta_modele(X_meta, y_meta, type_modele=\"xgb\", feature_names=None, seed=SEED_GLOBAL):\n \"\"\"Entraîne un méta-modèle CPU sur paires OOF.\n\n Args: X_meta float32 (P,D), y_meta binaire (P,), type_modele in logistic/xgb/lgbm.\n Returns: (model, backend). XGB/LGBM utilisent validation interne et early stopping.\n \"\"\"\n assert type_modele in {\"logistic\", \"xgb\", \"lgbm\"}\n X_meta = np.nan_to_num(np.asarray(X_meta, dtype=np.float32), nan=0.0, posinf=0.0, neginf=0.0)\n y_meta = np.asarray(y_meta, dtype=np.uint8)\n assert X_meta.ndim == 2 and len(X_meta) == len(y_meta) and set(np.unique(y_meta)) <= {0, 1}\n names = feature_names or [f\"f{i}\" for i in range(X_meta.shape[1])]\n if type_modele == \"logistic\":\n model = LogisticRegression(max_iter=400, class_weight=\"balanced\", n_jobs=-1, random_state=seed)\n return model.fit(X_meta, y_meta), \"logistic\"\n if type_modele == \"xgb\":\n return entrainer_xgboost_oof(X_meta, y_meta, names, seed), \"xgboost\"\n # Cinq essais demandés; le meilleur logloss interne est ensuite évalué en Fmax-IA externe.\n return entrainer_lightgbm_oof(X_meta, y_meta, names, seed, n_trials=5), \"lightgbm\"\n\n\ndef selectionner_meta_modele(resultats_folds):\n \"\"\"Choisit le backend par Fmax-IA moyen puis Smin-IA moyen; aucun score de paire n'est utilisé.\"\"\"\n table = pd.DataFrame(resultats_folds)\n required = {\"modele\", \"fmax_ia\", \"smin_ia\"}\n assert required.issubset(table.columns)\n summary = table.groupby(\"modele\", as_index=False)[[\"fmax_ia\", \"smin_ia\"]].mean()\n summary = summary.sort_values([\"fmax_ia\", \"smin_ia\"], ascending=[False, True])\n return summary.iloc[0][\"modele\"], summary\n\n\ndef concatener_features_externes(accessions, chemin_af2=None, chemin_interpro=None, chemin_ppi=None,\n train_accessions=None, top_k=200):\n \"\"\"Retourne (N,D_ext) et masque (N,3) pour structures, domaines et PPI.\n\n Les PDB sont lus à la demande sous `chemin_af2/.pdb`; les TSV\n InterPro/PPI sont parcourus par chunks. Aucun téléchargement n'est effectué.\n \"\"\"\n n = len(accessions)\n structure = np.zeros((n, 10), dtype=np.float32) # 9 descripteurs + flag.\n if chemin_af2 and Path(chemin_af2).is_dir():\n for i, accession in enumerate(accessions):\n values, present = extraire_features_structure(Path(chemin_af2) / f\"{accession}.pdb\")\n structure[i, :-1], structure[i, -1] = values, present\n interpro, _ = construire_features_interpro(chemin_interpro, train_accessions or accessions, accessions, top_k=top_k)\n ppi = construire_features_ppi(chemin_ppi, accessions)\n external = np.concatenate((structure, interpro, ppi), axis=1).astype(np.float32, copy=False)\n mask = np.column_stack((structure[:, -1], interpro[:, -1], ppi[:, -1])).astype(np.uint8)\n assert external.shape[0] == n and np.isfinite(external).all()\n print(f\"[V29][EXTERNES] couverture structure/domaines/PPI={mask.mean(axis=0)}\")\n return external, mask\n\n\ndef integrer_features_externes(esm_features, accessions, **paths):\n \"\"\"Concatène les externes avant DAGNet et retourne (X_final, dim_totale, mask).\"\"\"\n ext, mask = concatener_features_externes(accessions, **paths)\n X_final = np.concatenate((np.asarray(esm_features, dtype=np.float32), ext), axis=1)\n assert X_final.dtype == np.float32 and X_final.shape[0] == len(accessions)\n return X_final, X_final.shape[1], mask\n\n\ndef evaluer_strategies_dag(predictions, Y_val, parents_par_idx, profondeurs, ia=vec_ia):\n \"\"\"Compare bottom-up, top-down et combinée via Fmax-IA/Smin-IA sur labels CSR.\"\"\"\n rows = [evaluer_propagation_dag(predictions, Y_val, parents_par_idx, profondeurs, ia, strategy)\n for strategy in (\"bottom_up\", \"top_down\", \"combined\")]\n table = pd.DataFrame(rows).sort_values([\"fmax_ia\", \"smin_ia\"], ascending=[False, True])\n print(\"[V29][DAG] stratégie recommandée:\", table.iloc[0][\"strategie\"])\n return table\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.626604Z","iopub.status.idle":"2026-07-31T20:16:21.626885Z","shell.execute_reply.started":"2026-07-31T20:16:21.626749Z","shell.execute_reply":"2026-07-31T20:16:21.626762Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Synthèse de soumission\n\nÀ compléter uniquement après exécution :\n\n- Méta-modèle retenu : résultat de `selectionner_meta_modele(resultats_folds)` ;\n comparer Logistic, XGBoost et LightGBM par Fmax-IA moyen, puis Smin-IA.\n- DAG retenu : première ligne de `evaluer_strategies_dag(...)`; bottom-up reste\n le défaut tant que les prédictions OOF ne démontrent pas un gain de la combinée.\n- Couverture externe : moyenne des colonnes du masque retourné par\n `concatener_features_externes` (structure, domaines, PPI).\n\nNe remplir aucun chiffre manuellement : conserver les tables et les seeds dans\nl'artefact de soumission pour une traçabilité scientifique complète.\n","metadata":{}},{"cell_type":"markdown","source":"# Module V30 - Analyse interprétable des termes GO rares\n\nLes termes sont considérés rares sous `SEUIL_RARETE_ENRICHISSEMENT`. Le module\ninterroge QuickGO en premier, dont l'endpoint officiel expose les champs `name`,\n`definition`, `aspect` et `synonyms`, puis le service GO/Biolink en repli. Les\nressources externes restent soumises aux règles de la compétition : l'enrichissement\nsert à l'interprétation et ne doit pas introduire de fuite temporelle ou de données\ninterdites dans une soumission.\n","metadata":{}},{"cell_type":"code","source":"# AMELIORATION V30: cache résilient + limitation de débit pour métadonnées GO.\nimport os\nimport tempfile\nfrom urllib.parse import quote\n\ndef _chemin_cache_go():\n \"\"\"Choisit un cache persistant Kaggle/local sans créer de dépendance réseau.\"\"\"\n base = Path(globals().get(\"CHEMIN_CHECKPOINTS\", \"./checkpoints\"))\n base.mkdir(parents=True, exist_ok=True)\n return base / \"go_term_metadata_cache.json\"\n\ndef _charger_cache_go(cache_path=None):\n \"\"\"Charge un JSON de cache invalide de façon sûre; un cache corrompu est ignoré.\"\"\"\n path = Path(cache_path or _chemin_cache_go())\n try:\n with path.open(\"r\", encoding=\"utf-8\") as handle:\n payload = json.load(handle)\n return payload if isinstance(payload, dict) else {}\n except (OSError, json.JSONDecodeError):\n return {}\n\ndef _sauver_cache_go(cache, cache_path=None):\n \"\"\"Écriture atomique: protège le cache contre une interruption Kaggle.\"\"\"\n path = Path(cache_path or _chemin_cache_go())\n path.parent.mkdir(parents=True, exist_ok=True)\n with tempfile.NamedTemporaryFile(\"w\", encoding=\"utf-8\", dir=path.parent, delete=False) as handle:\n json.dump(cache, handle, ensure_ascii=False, indent=2)\n temporary = Path(handle.name)\n temporary.replace(path)\n\ndef _normaliser_reponse_go(payload, go_id):\n \"\"\"Normalise QuickGO et GO/Biolink vers un schéma stable pour le notebook.\"\"\"\n record = (payload.get(\"results\") or [payload])[0] if isinstance(payload, dict) else {}\n definition = record.get(\"definition\", \"\")\n if isinstance(definition, dict):\n definition = definition.get(\"text\", \"\")\n synonyms = record.get(\"synonyms\", record.get(\"synonym\", [])) or []\n synonyms = [s.get(\"name\", s) if isinstance(s, dict) else s for s in synonyms]\n aspect = record.get(\"aspect\", record.get(\"namespace\", record.get(\"category\", \"\")))\n ontology = {\"biological_process\": \"BPO\", \"molecular_function\": \"MFO\", \"cellular_component\": \"CCO\"}.get(str(aspect), aspect)\n return {\"id\": record.get(\"id\", go_id), \"name\": record.get(\"name\", \"\"),\n \"definition\": definition or \"\", \"ontology\": ontology or \"UNKNOWN\",\n \"synonyms\": synonyms, \"is_obsolete\": bool(record.get(\"isObsolete\", record.get(\"obsolete\", False)))}\n\ndef get_go_term_info(go_id, source=\"quickgo\", timeout=15, session=None):\n \"\"\"Récupère une métadonnée GO, ou `None` après timeout/404/API indisponible.\n\n QuickGO est appelé via `/QuickGO/services/ontology/go/terms/{id}`. Le repli\n GO/Biolink utilise `/api/bioentity/function/{id}`, endpoint officiel actuel.\n \"\"\"\n assert isinstance(go_id, str) and go_id.startswith(\"GO:\")\n try:\n import requests\n client = session or requests.Session()\n endpoints = ([f\"https://www.ebi.ac.uk/QuickGO/services/ontology/go/terms/{quote(go_id, safe=':')}\"]\n if source == \"quickgo\" else [])\n endpoints.append(f\"https://api.geneontology.org/api/bioentity/function/{quote(go_id, safe=':')}\")\n headers = {\"Accept\": \"application/json\", \"User-Agent\": \"CAFA-rare-term-analysis/1.0\"}\n for endpoint in endpoints:\n response = client.get(endpoint, headers=headers, timeout=timeout)\n if response.status_code == 404:\n continue\n response.raise_for_status()\n return _normaliser_reponse_go(response.json(), go_id)\n except Exception as exc:\n logger_cafa6.warning(\"GO API indisponible pour %s: %s\", go_id, exc)\n return None\n\ndef enrichir_termes_rares(prot_par_terme, profondeur_go, ia_dict, seuil=SEUIL_RARETE_ENRICHISSEMENT,\n cache_path=None, delai=DELAI_API_GO_SECONDES):\n \"\"\"Construit `df_termes_rares_enrichis` dans l'ordre GO, avec cache et reprise.\n\n `prot_par_terme` est un compteur terme->nombre de protéines. Les entrées de\n cache, y compris les échecs (`None`), sont retenues pour éviter les requêtes\n répétées. Le délai n'est appliqué qu'aux appels réellement réseau.\n \"\"\"\n cache = _charger_cache_go(cache_path)\n rare_ids = sorted(term for term, count in prot_par_terme.items() if count < seuil)\n records = []\n from tqdm.auto import tqdm\n print(f\"[V30][GO] {len(rare_ids):,} termes rares (<{seuil}) ; cache={len(cache):,}\")\n for go_id in tqdm(rare_ids, desc=\"QuickGO/AmiGO\", leave=False):\n if go_id not in cache:\n cache[go_id] = get_go_term_info(go_id)\n _sauver_cache_go(cache, cache_path) # checkpoint après chaque appel: reprise fiable.\n time.sleep(delai)\n metadata = cache.get(go_id) or {}\n records.append({\"go_id\": go_id, \"frequence\": int(prot_par_terme[go_id]),\n \"profondeur\": int(profondeur_go.get(go_id, -1)),\n \"ia\": float(ia_dict.get(go_id, np.nan)), **metadata})\n result = pd.DataFrame(records)\n if not result.empty:\n result = result.sort_values([\"frequence\", \"go_id\"], kind=\"stable\").reset_index(drop=True)\n assert result[\"go_id\"].is_unique\n return result\n\n# Utilisation après Module 5: fréquence protéine-terme, non nombre brut d'annotations.\nif \"df_termes\" in globals() and \"profondeur_go\" in globals() and \"ia_dict\" in globals():\n prot_par_terme = df_termes.groupby(\"terme_go\")[\"proteine\"].nunique().to_dict()\n df_termes_rares_enrichis = enrichir_termes_rares(prot_par_terme, profondeur_go, ia_dict)\n print(df_termes_rares_enrichis[[\"go_id\", \"frequence\", \"name\", \"ontology\"]].head(10))\nelse:\n print(\"[V30][GO] Exécuter après les modules données et DAG.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.628222Z","iopub.status.idle":"2026-07-31T20:16:21.628576Z","shell.execute_reply.started":"2026-07-31T20:16:21.628378Z","shell.execute_reply":"2026-07-31T20:16:21.628399Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module V30-B - Sémantique GO pour perte, curriculum et MAML\n\nLes métadonnées sont **par terme**, donc elles ne sont pas concaténées aux\nembeddings de protéines. Elles deviennent une matrice `(C,K)` alignée sur\n`terme2idx`, utilisable pour pondérer la perte ou filtrer les tâches MAML.\n","metadata":{}},{"cell_type":"code","source":"# AMELIORATION V30: catégories interprétables, sans fuite vers les embeddings protéines.\ndef ajouter_features_semantiques_go(terme2idx, df_enrichi, categories=CATEGORIES_SEMANTIQUES_GO):\n \"\"\"Construit `(C,K)` binaire par terme à partir nom+définition+synonymes.\n\n L'index de ligne est strictement `terme2idx[GO]`; les termes non enrichis\n restent à zéro plutôt que de recevoir une information inventée.\n \"\"\"\n labels = list(categories)\n features = np.zeros((len(terme2idx), len(labels)), dtype=np.float32)\n if df_enrichi is None or df_enrichi.empty:\n return features, labels\n for row in df_enrichi.itertuples(index=False):\n idx = terme2idx.get(row.go_id)\n if idx is None:\n continue\n text = \" \".join(map(str, [getattr(row, \"name\", \"\"), getattr(row, \"definition\", \"\"),\n getattr(row, \"synonyms\", \"\")])).lower()\n features[idx] = [float(any(keyword in text for keyword in keywords)) for keywords in categories.values()]\n return features, labels\n\ndef poids_semantiques_perte(features_semantiques_go, erreurs_categories=None, amplification_max=1.5):\n \"\"\"Retourne un poids (C,) : surpondère modestement les catégories mesurées difficiles.\n\n La pondération est bornée pour éviter qu'un groupe rare domine IA-BCE; sans\n erreurs OOF disponibles, tous les poids restent égaux à un.\n \"\"\"\n c, _ = features_semantiques_go.shape\n weights = np.ones(c, dtype=np.float32)\n if erreurs_categories is None or len(erreurs_categories) == 0:\n return weights\n values = np.asarray(list(erreurs_categories.values()), dtype=np.float32)\n scale = (values - values.min()) / max(values.ptp(), 1e-8)\n category_weights = 1.0 + (amplification_max - 1.0) * scale\n weights += features_semantiques_go @ (category_weights - 1.0)\n return np.clip(weights, 1.0, amplification_max).astype(np.float32)\n\nMAML_CATEGORIES_DIFFICILES = {\"kinase\", \"ion_channel\", \"transcription\", \"activity\", \"binding\"}\ndef selectionner_termes_maml_rares(nombre_positifs, features_semantiques_go, labels_categories,\n seuil_rare=20, filtrer=FILTRER_MAML_PAR_SEMANTIQUE):\n \"\"\"Sélectionne tâches MAML rares, optionnellement spécifiques et informatives.\"\"\"\n rare = np.asarray(nombre_positifs) < seuil_rare\n if not filtrer:\n return np.flatnonzero(rare)\n wanted = [labels_categories.index(x) for x in MAML_CATEGORIES_DIFFICILES if x in labels_categories]\n semantic = features_semantiques_go[:, wanted].any(axis=1) if wanted else np.zeros_like(rare)\n return np.flatnonzero(rare & semantic)\n\nif \"terme2idx\" in globals() and \"df_termes_rares_enrichis\" in globals():\n features_semantiques_go, categories_semantiques_go = ajouter_features_semantiques_go(terme2idx, df_termes_rares_enrichis)\n print(f\"[V30][SEM] features_semantiques_go={features_semantiques_go.shape}\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.630069Z","iopub.status.idle":"2026-07-31T20:16:21.630436Z","shell.execute_reply.started":"2026-07-31T20:16:21.630253Z","shell.execute_reply":"2026-07-31T20:16:21.630272Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module V30-C - Erreurs biologiquement interprétables et domaines suggérés\n\nLes catégories sont des hypothèses analytiques : une BCE élevée peut provenir du\nmanque de données, d'une fonction biologiquement hétérogène, de séquences peu\ninformatives ou de labels incomplets. Elles ne doivent pas être interprétées\ncomme une causalité sans validation expérimentale.\n","metadata":{}},{"cell_type":"code","source":"# AMELIORATION V30: jointure Module 25 et analyse de catégories/domaine sans densifier Y complet.\ndef enrichir_table_erreurs_termes(table_erreurs, df_enrichi, id_col=\"terme_go\"):\n \"\"\"Ajoute nom et définition tronquée aux termes difficiles du Module 25.\"\"\"\n assert id_col in table_erreurs.columns\n metadata = df_enrichi[[\"go_id\", \"name\", \"definition\", \"ontology\"]].copy() if df_enrichi is not None else pd.DataFrame()\n if metadata.empty:\n return table_erreurs.copy()\n metadata[\"definition_courte\"] = metadata[\"definition\"].fillna(\"\").str.slice(0, 80)\n return table_erreurs.merge(metadata.drop(columns=\"definition\"), left_on=id_col, right_on=\"go_id\", how=\"left\")\n\ndef analyser_erreurs_categories_rares(erreur_par_terme, terme2idx, df_enrichi,\n categories=CATEGORIES_SEMANTIQUES_GO):\n \"\"\"BCE moyenne par catégorie sémantique; `erreur_par_terme` est un vecteur (C,).\"\"\"\n features, labels = ajouter_features_semantiques_go(terme2idx, df_enrichi, categories)\n error = np.asarray(erreur_par_terme, dtype=np.float32)\n assert error.shape == (len(terme2idx),) and np.isfinite(error).any()\n rows = []\n for j, label in enumerate(labels):\n mask = features[:, j].astype(bool)\n if mask.any():\n rows.append({\"categorie\": label, \"n_termes\": int(mask.sum()), \"bce_moyenne\": float(np.nanmean(error[mask]))})\n return pd.DataFrame(rows).sort_values(\"bce_moyenne\", ascending=False) if rows else pd.DataFrame(columns=[\"categorie\", \"n_termes\", \"bce_moyenne\"])\n\nMOTIFS_DOMAINES_GO = {\"protein kinase\": (\"kinase\", \"phosphorylation\"), \"SH2\": (\"sh2 domain\",),\n \"leucine-rich repeat\": (\"leucine-rich repeat\",), \"ion channel\": (\"ion channel\",),\n \"transmembrane\": (\"transmembrane\", \"membrane protein\"), \"zinc finger\": (\"zinc finger\",)}\ndef rapport_domaines_suggeres(df_enrichi, motifs=MOTIFS_DOMAINES_GO):\n \"\"\"Compte les mentions de domaines dans nom/définition des termes rares.\"\"\"\n counts = []\n for domain, keywords in motifs.items():\n n = 0\n for row in df_enrichi.itertuples(index=False):\n blob = f\"{getattr(row, 'name', '')} {getattr(row, 'definition', '')}\".lower()\n n += any(key in blob for key in keywords)\n counts.append({\"domaine_suggere\": domain, \"n_termes_rares\": n})\n return pd.DataFrame(counts).sort_values(\"n_termes_rares\", ascending=False).head(10)\n\nif \"df_termes_rares_enrichis\" in globals():\n domaines_interpro_suggeres = rapport_domaines_suggeres(df_termes_rares_enrichis)\n print(\"[V30][DOMAINES] Justification InterPro/Pfam:\")\n print(domaines_interpro_suggeres.to_string(index=False))\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.631767Z","iopub.status.idle":"2026-07-31T20:16:21.632384Z","shell.execute_reply.started":"2026-07-31T20:16:21.632243Z","shell.execute_reply":"2026-07-31T20:16:21.63226Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Analyse des termes rares\n\nLe cache QuickGO/GO conserve les noms, définitions, ontologies et synonymes des\ntermes sous le seuil configuré. Les tables d'erreurs sont enrichies par ces\nmétadonnées afin de distinguer des familles biologiques difficiles. Les catégories\nsémantiques restent des variables **par terme** : elles pondèrent prudemment la\nperte ou filtrent les tâches MAML, mais ne sont jamais confondues avec des\nfeatures protéiques. Les mentions de domaines dans les définitions constituent\nune justification qualitative pour une ablation InterPro/Pfam, pas une annotation\nsupplémentaire.\n\nCellule de démonstration : après exécution, afficher `df_termes_rares_enrichis`\npour l'échantillon, `erreurs_categories_rares.head(5)` pour les catégories et\n`domaines_interpro_suggeres` pour les domaines suggérés.\n","metadata":{}},{"cell_type":"code","source":"# Démonstration V30: ne calcule des erreurs que si le Module 25 les a produites.\nif \"df_termes_rares_enrichis\" in globals():\n display(df_termes_rares_enrichis.head(10))\nif \"erreur_moyenne\" in globals() and \"terme2idx\" in globals() and \"df_termes_rares_enrichis\" in globals():\n erreurs_categories_rares = analyser_erreurs_categories_rares(erreur_moyenne, terme2idx, df_termes_rares_enrichis)\n print(\"[V30][ERREURS] 5 catégories les plus difficiles:\")\n display(erreurs_categories_rares.head(5))\nif \"domaines_interpro_suggeres\" in globals():\n display(domaines_interpro_suggeres)\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.633368Z","iopub.status.idle":"2026-07-31T20:16:21.633683Z","shell.execute_reply.started":"2026-07-31T20:16:21.633522Z","shell.execute_reply":"2026-07-31T20:16:21.633538Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"code","source":"\nassert not ENABLE_GNN and not ENABLE_MAML\nassert sp.isspmatrix_csr(Y_train)\nassert len(splits_cv) == N_FOLDS\nfor fold, (tr, va) in enumerate(splits_cv):\n assert not set(groupes_taxo[tr]).intersection(set(groupes_taxo[va])), f\"taxonomy leakage in fold {fold}\"\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.634574Z","iopub.status.idle":"2026-07-31T20:16:21.634894Z","shell.execute_reply.started":"2026-07-31T20:16:21.63473Z","shell.execute_reply":"2026-07-31T20:16:21.634747Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"code","source":"\nassert not ENABLE_GNN and not ENABLE_MAML\nassert sp.isspmatrix_csr(Y_train)\nassert len(splits_cv) == N_FOLDS\nfor fold, (tr, va) in enumerate(splits_cv):\n assert not set(groupes_taxo[tr]).intersection(set(groupes_taxo[va])), f\"taxonomy leakage in fold {fold}\"\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.636706Z","iopub.status.idle":"2026-07-31T20:16:21.637567Z","shell.execute_reply.started":"2026-07-31T20:16:21.637325Z","shell.execute_reply":"2026-07-31T20:16:21.637346Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"code","source":"\nassert not ENABLE_GNN and not ENABLE_MAML\nassert sp.isspmatrix_csr(Y_train)\nassert len(splits_cv) == N_FOLDS\nfor fold, (tr, va) in enumerate(splits_cv):\n assert not set(groupes_taxo[tr]).intersection(set(groupes_taxo[va])), f\"taxonomy leakage in fold {fold}\"\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.638407Z","iopub.status.idle":"2026-07-31T20:16:21.638741Z","shell.execute_reply.started":"2026-07-31T20:16:21.638631Z","shell.execute_reply":"2026-07-31T20:16:21.638644Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"code","source":"\nimport os\nimport numpy as np\nimport pandas as pd\nfrom pathlib import Path\nfrom scipy.stats import wilcoxon\n\nHOMOLOGY_CLUSTER_PATH = os.environ.get(\"CAFA6_HOMOLOGY_CLUSTERS\", \"\")\nREQUIRE_HOMOLOGY_FOR_FINAL_CV = True\n\nclass _UnionFind:\n def __init__(self, n): self.parent = np.arange(n, dtype=np.int64); self.rank = np.zeros(n, dtype=np.int8)\n def find(self, x):\n while self.parent[x] != x:\n self.parent[x] = self.parent[self.parent[x]]; x = self.parent[x]\n return x\n def union(self, a, b):\n a, b = self.find(a), self.find(b)\n if a == b: return\n if self.rank[a] < self.rank[b]: a, b = b, a\n self.parent[b] = a\n if self.rank[a] == self.rank[b]: self.rank[a] += 1\n\ndef charger_clusters_homologie(path, accessions):\n \"\"\"Read an MMseqs `cluster.tsv` or a two-column accession/cluster TSV.\n\n MMseqs commonly stores representative then member; both orientation choices\n yield the same connected components. Every absent accession becomes a singleton.\n \"\"\"\n path = Path(path)\n if not path.is_file():\n raise FileNotFoundError(f\"Homology cluster file not found: {path}\")\n raw = pd.read_csv(path, sep=\"\\t\", header=None, comment=\"#\", dtype=str, usecols=[0, 1])\n raw.columns = [\"cluster\", \"protein\"]\n known = set(map(str, accessions))\n raw = raw[raw.protein.isin(known)]\n mapping = dict(zip(raw.protein, raw.cluster))\n return np.asarray([mapping.get(str(acc), f\"singleton::{acc}\") for acc in accessions], dtype=object)\n\ndef groupes_fermeture_taxonomie_homologie(accessions, taxons, clusters):\n \"\"\"Keep both same-taxon and homologous proteins in the same fold.\n\n This is stricter than either grouping alone. If a huge connected component is\n produced, the experiment must be redesigned rather than silently leaking.\n \"\"\"\n n = len(accessions); uf = _UnionFind(n); first_taxon, first_cluster = {}, {}\n for i, (taxon, cluster) in enumerate(zip(map(str, taxons), map(str, clusters))):\n for key, registry in ((taxon, first_taxon), (cluster, first_cluster)):\n previous = registry.setdefault(key, i)\n uf.union(i, previous)\n roots = np.asarray([uf.find(i) for i in range(n)])\n _, groups = np.unique(roots, return_inverse=True)\n return groups.astype(str)\n\ndef auditer_splits_homologie(splits, groups, taxons, clusters, y_csr):\n rows = []\n for fold, (tr, va) in enumerate(splits):\n group_overlap = set(groups[tr]) & set(groups[va])\n cluster_overlap = set(clusters[tr]) & set(clusters[va])\n taxon_overlap = set(taxons[tr]) & set(taxons[va])\n support_tr = np.asarray(y_csr[tr].sum(axis=0)).ravel()\n support_va = np.asarray(y_csr[va].sum(axis=0)).ravel()\n rows.append({\"fold\": fold, \"n_train\": len(tr), \"n_val\": len(va),\n \"group_overlap\": len(group_overlap), \"homology_overlap\": len(cluster_overlap),\n \"taxon_overlap\": len(taxon_overlap),\n \"terms_absent_train\": int((support_tr == 0).sum()),\n \"terms_absent_val\": int((support_va == 0).sum())})\n assert not group_overlap and not cluster_overlap and not taxon_overlap, f\"Leakage in fold {fold}\"\n audit = pd.DataFrame(rows)\n print(audit.to_string(index=False))\n return audit\n\ndef construire_splits_final_homologie(accessions, taxons, y_csr, cluster_path=HOMOLOGY_CLUSTER_PATH,\n n_splits=N_FOLDS, require_homology=REQUIRE_HOMOLOGY_FOR_FINAL_CV):\n if not cluster_path:\n if require_homology:\n raise RuntimeError(\"Final CV requires CAFA6_HOMOLOGY_CLUSTERS (MMseqs/CD-HIT TSV).\")\n groups = np.asarray(taxons, dtype=str); clusters = np.asarray([f\"unknown::{x}\" for x in accessions])\n print(\"[SPLIT] DEVELOPMENT ONLY: taxonomy groups without homology clusters.\")\n else:\n clusters = charger_clusters_homologie(cluster_path, accessions)\n groups = groupes_fermeture_taxonomie_homologie(accessions, taxons, clusters)\n sizes = pd.Series(groups).value_counts()\n if len(sizes) < n_splits or sizes.iloc[0] > 0.50 * len(accessions):\n raise RuntimeError(f\"Invalid constrained groups: n_groups={len(sizes)}, largest={sizes.iloc[0]}/{len(accessions)}\")\n splitter = GroupKFold(n_splits=n_splits)\n splits = list(splitter.split(np.zeros(len(accessions)), groups=groups))\n audit = auditer_splits_homologie(splits, groups, np.asarray(taxons), clusters, y_csr)\n return splits, groups, clusters, audit\n\ndef construire_oof_memmap(resultats_cv, n_proteins, n_terms, path):\n \"\"\"Assemble each held-out fold exactly once into a disk-backed OOF matrix.\"\"\"\n out = np.memmap(path, mode=\"w+\", dtype=np.float32, shape=(n_proteins, n_terms))\n filled = np.zeros(n_proteins, dtype=bool)\n for (_, va), fold_path in zip(resultats_cv[\"folds\"], resultats_cv[\"oof_files\"]):\n if filled[va].any(): raise ValueError(\"OOF fold overlap\")\n fold = np.memmap(fold_path, mode=\"r\", dtype=np.float32, shape=(len(va), n_terms))\n out[va] = fold; filled[va] = True\n if not filled.all(): raise ValueError(\"Missing OOF predictions\")\n out.flush(); return out\n\ndef _cafa_protein_statistics(predictions, y_csr, ia, thresholds=SEUILS_CAFA, chunk=1024):\n \"\"\"Sufficient protein-level IA statistics for exact bootstrap Fmax/Smin.\"\"\"\n n, c = predictions.shape; t = len(thresholds); ia = np.asarray(ia, dtype=np.float32)\n true = np.zeros(n, dtype=np.float32); pred = np.zeros((t, n), dtype=np.float32)\n tp = np.zeros((t, n), dtype=np.float32); ru = np.zeros((t, n), dtype=np.float32); mi = np.zeros((t, n), dtype=np.float32)\n for start in range(0, n, chunk):\n stop = min(start + chunk, n); y = y_csr[start:stop].toarray().astype(bool, copy=False); p = predictions[start:stop]\n true[start:stop] = (y * ia).sum(axis=1)\n for k, threshold in enumerate(thresholds):\n selected = p >= threshold\n pred[k, start:stop] = (selected * ia).sum(axis=1)\n tp[k, start:stop] = ((selected & y) * ia).sum(axis=1)\n ru[k, start:stop] = ((y & ~selected) * ia).sum(axis=1)\n mi[k, start:stop] = ((selected & ~y) * ia).sum(axis=1)\n return true, pred, tp, ru, mi\n\ndef bootstrap_oof_cafa(predictions, y_csr, ia, n_boot=1000, confidence=0.95, seed=SEED_GLOBAL):\n \"\"\"Protein bootstrap over pooled OOF; avoids copying N x C once per replicate.\"\"\"\n true, pred, tp, ru, mi = _cafa_protein_statistics(predictions, y_csr, ia)\n rng = np.random.default_rng(seed); n = len(true); fmax, smin = [], []\n for _ in range(n_boot):\n ids = rng.integers(0, n, n)\n p, h, r = pred[:, ids], tp[:, ids], true[ids]\n present = p > 0; annotated = r > 0\n precision = np.divide(h, p, out=np.zeros_like(h), where=present)\n recall = np.divide(h, r[None, :], out=np.zeros_like(h), where=annotated[None, :])\n p_avg = np.divide((precision * present).sum(axis=1), present.sum(axis=1), out=np.zeros(len(SEUILS_CAFA)), where=present.sum(axis=1)>0)\n r_avg = np.divide((recall * annotated).sum(axis=1), max(int(annotated.sum()), 1))\n fs = np.divide(2*p_avg*r_avg, p_avg+r_avg, out=np.zeros_like(p_avg), where=(p_avg+r_avg)>0)\n fmax.append(float(fs.max()))\n distances = np.sqrt(ru[:, ids].mean(axis=1)**2 + mi[:, ids].mean(axis=1)**2)\n smin.append(float(distances.min()))\n alpha = (1 - confidence) / 2\n return {\"fmax\": np.asarray(fmax), \"smin\": np.asarray(smin),\n \"fmax_ci\": tuple(np.quantile(fmax, [alpha, 1-alpha])),\n \"smin_ci\": tuple(np.quantile(smin, [alpha, 1-alpha]))}\n\ndef comparer_ablation_appariee(scores_reference, scores_ablation, name=\"ablation\"):\n \"\"\"Paired fold test plus exact sign-flip enumeration; n=5 is reported, never oversold.\"\"\"\n ref, abl = np.asarray(scores_reference, float), np.asarray(scores_ablation, float)\n assert ref.shape == abl.shape and ref.size == N_FOLDS\n delta = ref - abl\n statistic, p_wilcoxon = wilcoxon(delta, alternative=\"two-sided\", method=\"auto\")\n signs = np.array(np.meshgrid(*[[-1, 1]] * len(delta))).T.reshape(-1, len(delta))\n observed = abs(delta.mean()); p_signflip = np.mean(np.abs((signs * delta).mean(axis=1)) >= observed)\n return {\"comparison\": name, \"n_folds\": int(len(delta)), \"mean_delta_fmax\": float(delta.mean()),\n \"median_delta_fmax\": float(np.median(delta)), \"wilcoxon_statistic\": float(statistic),\n \"wilcoxon_pvalue\": float(p_wilcoxon), \"exact_signflip_pvalue\": float(p_signflip)}\n\ndef holm_bonferroni(table, p_column=\"wilcoxon_pvalue\"):\n out = table.copy(); order = np.argsort(out[p_column].to_numpy()); m = len(out); adjusted = np.empty(m)\n running = 0.0\n for rank, idx in enumerate(order):\n running = max(running, (m-rank) * out.iloc[idx][p_column]); adjusted[idx] = min(running, 1.0)\n out[\"p_holm\"] = adjusted; return out\n\ndef executer_ablation_oof(nom, utiliser_curriculum=True, utiliser_ia=True, epochs=CV_EPOCHS):\n \"\"\"Train one ablation on the exact production folds and return matched OOF scores.\"\"\"\n result = {\"name\": nom, \"fmax_ia\": [], \"smin_ia\": [], \"oof_files\": [], \"folds\": list(splits_cv)}\n for fold, (tr, va) in enumerate(splits_cv):\n scaler = StandardScaler().fit(X_train[tr])\n xtr = scaler.transform(X_train[tr]).astype(np.float32, copy=False)\n xva = scaler.transform(X_train[va]).astype(np.float32, copy=False)\n model = creer_modele_ia_aware(dim_totale, DAGNET_HIDDEN, DAGNET_N_BLOCKS,\n len(liste_termes), DAGNET_DROPOUT, IA_N_HEADS, IA_HIDDEN, vec_ia)\n entrainer_modele(model, xtr, Y_train[tr].tocsr(), xva, Y_train[va].tocsr(),\n ia_tens=torch.as_tensor(vec_ia, dtype=torch.float32), n_termes=len(liste_termes),\n n_epoques=epochs, patience=PATIENCE, fold_courant=fold, device=DEVICE,\n utiliser_curriculum=utiliser_curriculum, utiliser_ia=utiliser_ia)\n path = os.path.join(CHEMIN_CHECKPOINTS, f\"oof_{nom}_fold_{fold}.f32\")\n _predict_to_memmap(model, xva, path, DEVICE, CV_BATCH_SIZE * 2)\n fmax, smin = _validate_fold_scores(path, (len(va), len(liste_termes)), Y_train[va].tocsr())\n result[\"fmax_ia\"].append(float(fmax[\"fmax\"])); result[\"smin_ia\"].append(float(smin[\"smin\"])); result[\"oof_files\"].append(path)\n del model, xtr, xva; gc.collect()\n if torch.cuda.is_available(): torch.cuda.empty_cache()\n return result\n\nRUN_OOF_ABLATIONS = False\nif RUN_OOF_ABLATIONS:\n ablations_oof = {\n \"without_curriculum\": executer_ablation_oof(\"without_curriculum\", utiliser_curriculum=False),\n \"without_ia\": executer_ablation_oof(\"without_ia\", utiliser_ia=False),\n }\n rows = [comparer_ablation_appariee(resultats_cv[\"fmax_ia\"], value[\"fmax_ia\"], key)\n for key, value in ablations_oof.items()]\n ablation_statistics = holm_bonferroni(pd.DataFrame(rows))\n display(ablation_statistics)\n\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.639902Z","iopub.status.idle":"2026-07-31T20:16:21.640189Z","shell.execute_reply.started":"2026-07-31T20:16:21.640066Z","shell.execute_reply":"2026-07-31T20:16:21.640082Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"code","source":"\nassert not ENABLE_GNN and not ENABLE_MAML\nassert sp.isspmatrix_csr(Y_train)\nassert len(splits_cv) == N_FOLDS\nfor fold, (tr, va) in enumerate(splits_cv):\n assert not set(groupes_taxo[tr]).intersection(set(groupes_taxo[va])), f\"taxonomy leakage in fold {fold}\"\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.641615Z","iopub.status.idle":"2026-07-31T20:16:21.64207Z","shell.execute_reply.started":"2026-07-31T20:16:21.641797Z","shell.execute_reply":"2026-07-31T20:16:21.641834Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"code","source":"\nimport os\nimport numpy as np\nimport pandas as pd\nfrom pathlib import Path\nfrom scipy.stats import wilcoxon\n\nHOMOLOGY_CLUSTER_PATH = os.environ.get(\"CAFA6_HOMOLOGY_CLUSTERS\", \"\")\nREQUIRE_HOMOLOGY_FOR_FINAL_CV = True\n\nclass _UnionFind:\n def __init__(self, n): self.parent = np.arange(n, dtype=np.int64); self.rank = np.zeros(n, dtype=np.int8)\n def find(self, x):\n while self.parent[x] != x:\n self.parent[x] = self.parent[self.parent[x]]; x = self.parent[x]\n return x\n def union(self, a, b):\n a, b = self.find(a), self.find(b)\n if a == b: return\n if self.rank[a] < self.rank[b]: a, b = b, a\n self.parent[b] = a\n if self.rank[a] == self.rank[b]: self.rank[a] += 1\n\ndef charger_clusters_homologie(path, accessions):\n \"\"\"Read an MMseqs `cluster.tsv` or a two-column accession/cluster TSV.\n\n MMseqs commonly stores representative then member; both orientation choices\n yield the same connected components. Every absent accession becomes a singleton.\n \"\"\"\n path = Path(path)\n if not path.is_file():\n raise FileNotFoundError(f\"Homology cluster file not found: {path}\")\n raw = pd.read_csv(path, sep=\"\\t\", header=None, comment=\"#\", dtype=str, usecols=[0, 1])\n raw.columns = [\"cluster\", \"protein\"]\n known = set(map(str, accessions))\n raw = raw[raw.protein.isin(known)]\n mapping = dict(zip(raw.protein, raw.cluster))\n return np.asarray([mapping.get(str(acc), f\"singleton::{acc}\") for acc in accessions], dtype=object)\n\ndef groupes_fermeture_taxonomie_homologie(accessions, taxons, clusters):\n \"\"\"Keep both same-taxon and homologous proteins in the same fold.\n\n This is stricter than either grouping alone. If a huge connected component is\n produced, the experiment must be redesigned rather than silently leaking.\n \"\"\"\n n = len(accessions); uf = _UnionFind(n); first_taxon, first_cluster = {}, {}\n for i, (taxon, cluster) in enumerate(zip(map(str, taxons), map(str, clusters))):\n for key, registry in ((taxon, first_taxon), (cluster, first_cluster)):\n previous = registry.setdefault(key, i)\n uf.union(i, previous)\n roots = np.asarray([uf.find(i) for i in range(n)])\n _, groups = np.unique(roots, return_inverse=True)\n return groups.astype(str)\n\ndef auditer_splits_homologie(splits, groups, taxons, clusters, y_csr):\n rows = []\n for fold, (tr, va) in enumerate(splits):\n group_overlap = set(groups[tr]) & set(groups[va])\n cluster_overlap = set(clusters[tr]) & set(clusters[va])\n taxon_overlap = set(taxons[tr]) & set(taxons[va])\n support_tr = np.asarray(y_csr[tr].sum(axis=0)).ravel()\n support_va = np.asarray(y_csr[va].sum(axis=0)).ravel()\n rows.append({\"fold\": fold, \"n_train\": len(tr), \"n_val\": len(va),\n \"group_overlap\": len(group_overlap), \"homology_overlap\": len(cluster_overlap),\n \"taxon_overlap\": len(taxon_overlap),\n \"terms_absent_train\": int((support_tr == 0).sum()),\n \"terms_absent_val\": int((support_va == 0).sum())})\n assert not group_overlap and not cluster_overlap and not taxon_overlap, f\"Leakage in fold {fold}\"\n audit = pd.DataFrame(rows)\n print(audit.to_string(index=False))\n return audit\n\ndef construire_splits_final_homologie(accessions, taxons, y_csr, cluster_path=HOMOLOGY_CLUSTER_PATH,\n n_splits=N_FOLDS, require_homology=REQUIRE_HOMOLOGY_FOR_FINAL_CV):\n if not cluster_path:\n if require_homology:\n raise RuntimeError(\"Final CV requires CAFA6_HOMOLOGY_CLUSTERS (MMseqs/CD-HIT TSV).\")\n groups = np.asarray(taxons, dtype=str); clusters = np.asarray([f\"unknown::{x}\" for x in accessions])\n print(\"[SPLIT] DEVELOPMENT ONLY: taxonomy groups without homology clusters.\")\n else:\n clusters = charger_clusters_homologie(cluster_path, accessions)\n groups = groupes_fermeture_taxonomie_homologie(accessions, taxons, clusters)\n sizes = pd.Series(groups).value_counts()\n if len(sizes) < n_splits or sizes.iloc[0] > 0.50 * len(accessions):\n raise RuntimeError(f\"Invalid constrained groups: n_groups={len(sizes)}, largest={sizes.iloc[0]}/{len(accessions)}\")\n splitter = GroupKFold(n_splits=n_splits)\n splits = list(splitter.split(np.zeros(len(accessions)), groups=groups))\n audit = auditer_splits_homologie(splits, groups, np.asarray(taxons), clusters, y_csr)\n return splits, groups, clusters, audit\n\ndef construire_oof_memmap(resultats_cv, n_proteins, n_terms, path):\n \"\"\"Assemble each held-out fold exactly once into a disk-backed OOF matrix.\"\"\"\n out = np.memmap(path, mode=\"w+\", dtype=np.float32, shape=(n_proteins, n_terms))\n filled = np.zeros(n_proteins, dtype=bool)\n for (_, va), fold_path in zip(resultats_cv[\"folds\"], resultats_cv[\"oof_files\"]):\n if filled[va].any(): raise ValueError(\"OOF fold overlap\")\n fold = np.memmap(fold_path, mode=\"r\", dtype=np.float32, shape=(len(va), n_terms))\n out[va] = fold; filled[va] = True\n if not filled.all(): raise ValueError(\"Missing OOF predictions\")\n out.flush(); return out\n\ndef _cafa_protein_statistics(predictions, y_csr, ia, thresholds=SEUILS_CAFA, chunk=1024):\n \"\"\"Sufficient protein-level IA statistics for exact bootstrap Fmax/Smin.\"\"\"\n n, c = predictions.shape; t = len(thresholds); ia = np.asarray(ia, dtype=np.float32)\n true = np.zeros(n, dtype=np.float32); pred = np.zeros((t, n), dtype=np.float32)\n tp = np.zeros((t, n), dtype=np.float32); ru = np.zeros((t, n), dtype=np.float32); mi = np.zeros((t, n), dtype=np.float32)\n for start in range(0, n, chunk):\n stop = min(start + chunk, n); y = y_csr[start:stop].toarray().astype(bool, copy=False); p = predictions[start:stop]\n true[start:stop] = (y * ia).sum(axis=1)\n for k, threshold in enumerate(thresholds):\n selected = p >= threshold\n pred[k, start:stop] = (selected * ia).sum(axis=1)\n tp[k, start:stop] = ((selected & y) * ia).sum(axis=1)\n ru[k, start:stop] = ((y & ~selected) * ia).sum(axis=1)\n mi[k, start:stop] = ((selected & ~y) * ia).sum(axis=1)\n return true, pred, tp, ru, mi\n\ndef bootstrap_oof_cafa(predictions, y_csr, ia, n_boot=1000, confidence=0.95, seed=SEED_GLOBAL):\n \"\"\"Protein bootstrap over pooled OOF; avoids copying N x C once per replicate.\"\"\"\n true, pred, tp, ru, mi = _cafa_protein_statistics(predictions, y_csr, ia)\n rng = np.random.default_rng(seed); n = len(true); fmax, smin = [], []\n for _ in range(n_boot):\n ids = rng.integers(0, n, n)\n p, h, r = pred[:, ids], tp[:, ids], true[ids]\n present = p > 0; annotated = r > 0\n precision = np.divide(h, p, out=np.zeros_like(h), where=present)\n recall = np.divide(h, r[None, :], out=np.zeros_like(h), where=annotated[None, :])\n p_avg = np.divide((precision * present).sum(axis=1), present.sum(axis=1), out=np.zeros(len(SEUILS_CAFA)), where=present.sum(axis=1)>0)\n r_avg = np.divide((recall * annotated).sum(axis=1), max(int(annotated.sum()), 1))\n fs = np.divide(2*p_avg*r_avg, p_avg+r_avg, out=np.zeros_like(p_avg), where=(p_avg+r_avg)>0)\n fmax.append(float(fs.max()))\n distances = np.sqrt(ru[:, ids].mean(axis=1)**2 + mi[:, ids].mean(axis=1)**2)\n smin.append(float(distances.min()))\n alpha = (1 - confidence) / 2\n return {\"fmax\": np.asarray(fmax), \"smin\": np.asarray(smin),\n \"fmax_ci\": tuple(np.quantile(fmax, [alpha, 1-alpha])),\n \"smin_ci\": tuple(np.quantile(smin, [alpha, 1-alpha]))}\n\ndef comparer_ablation_appariee(scores_reference, scores_ablation, name=\"ablation\"):\n \"\"\"Paired fold test plus exact sign-flip enumeration; n=5 is reported, never oversold.\"\"\"\n ref, abl = np.asarray(scores_reference, float), np.asarray(scores_ablation, float)\n assert ref.shape == abl.shape and ref.size == N_FOLDS\n delta = ref - abl\n statistic, p_wilcoxon = wilcoxon(delta, alternative=\"two-sided\", method=\"auto\")\n signs = np.array(np.meshgrid(*[[-1, 1]] * len(delta))).T.reshape(-1, len(delta))\n observed = abs(delta.mean()); p_signflip = np.mean(np.abs((signs * delta).mean(axis=1)) >= observed)\n return {\"comparison\": name, \"n_folds\": int(len(delta)), \"mean_delta_fmax\": float(delta.mean()),\n \"median_delta_fmax\": float(np.median(delta)), \"wilcoxon_statistic\": float(statistic),\n \"wilcoxon_pvalue\": float(p_wilcoxon), \"exact_signflip_pvalue\": float(p_signflip)}\n\ndef holm_bonferroni(table, p_column=\"wilcoxon_pvalue\"):\n out = table.copy(); order = np.argsort(out[p_column].to_numpy()); m = len(out); adjusted = np.empty(m)\n running = 0.0\n for rank, idx in enumerate(order):\n running = max(running, (m-rank) * out.iloc[idx][p_column]); adjusted[idx] = min(running, 1.0)\n out[\"p_holm\"] = adjusted; return out\n\ndef executer_ablation_oof(nom, utiliser_curriculum=True, utiliser_ia=True, epochs=CV_EPOCHS):\n \"\"\"Train one ablation on the exact production folds and return matched OOF scores.\"\"\"\n result = {\"name\": nom, \"fmax_ia\": [], \"smin_ia\": [], \"oof_files\": [], \"folds\": list(splits_cv)}\n for fold, (tr, va) in enumerate(splits_cv):\n scaler = StandardScaler().fit(X_train[tr])\n xtr = scaler.transform(X_train[tr]).astype(np.float32, copy=False)\n xva = scaler.transform(X_train[va]).astype(np.float32, copy=False)\n model = creer_modele_ia_aware(dim_totale, DAGNET_HIDDEN, DAGNET_N_BLOCKS,\n len(liste_termes), DAGNET_DROPOUT, IA_N_HEADS, IA_HIDDEN, vec_ia)\n entrainer_modele(model, xtr, Y_train[tr].tocsr(), xva, Y_train[va].tocsr(),\n ia_tens=torch.as_tensor(vec_ia, dtype=torch.float32), n_termes=len(liste_termes),\n n_epoques=epochs, patience=PATIENCE, fold_courant=fold, device=DEVICE,\n utiliser_curriculum=utiliser_curriculum, utiliser_ia=utiliser_ia)\n path = os.path.join(CHEMIN_CHECKPOINTS, f\"oof_{nom}_fold_{fold}.f32\")\n _predict_to_memmap(model, xva, path, DEVICE, CV_BATCH_SIZE * 2)\n fmax, smin = _validate_fold_scores(path, (len(va), len(liste_termes)), Y_train[va].tocsr())\n result[\"fmax_ia\"].append(float(fmax[\"fmax\"])); result[\"smin_ia\"].append(float(smin[\"smin\"])); result[\"oof_files\"].append(path)\n del model, xtr, xva; gc.collect()\n if torch.cuda.is_available(): torch.cuda.empty_cache()\n return result\n\nRUN_OOF_ABLATIONS = False\nif RUN_OOF_ABLATIONS:\n ablations_oof = {\n \"without_curriculum\": executer_ablation_oof(\"without_curriculum\", utiliser_curriculum=False),\n \"without_ia\": executer_ablation_oof(\"without_ia\", utiliser_ia=False),\n }\n rows = [comparer_ablation_appariee(resultats_cv[\"fmax_ia\"], value[\"fmax_ia\"], key)\n for key, value in ablations_oof.items()]\n ablation_statistics = holm_bonferroni(pd.DataFrame(rows))\n display(ablation_statistics)\n\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.643207Z","iopub.status.idle":"2026-07-31T20:16:21.643419Z","shell.execute_reply.started":"2026-07-31T20:16:21.643314Z","shell.execute_reply":"2026-07-31T20:16:21.643324Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"code","source":"\nassert not ENABLE_GNN and not ENABLE_MAML\nassert sp.isspmatrix_csr(Y_train)\nassert len(splits_cv) == N_FOLDS\nfor fold, (tr, va) in enumerate(splits_cv):\n assert not set(groupes_taxo[tr]).intersection(set(groupes_taxo[va])), f\"taxonomy leakage in fold {fold}\"\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.644545Z","iopub.status.idle":"2026-07-31T20:16:21.644902Z","shell.execute_reply.started":"2026-07-31T20:16:21.644724Z","shell.execute_reply":"2026-07-31T20:16:21.644744Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"code","source":"\nimport os\nimport numpy as np\nimport pandas as pd\nfrom pathlib import Path\nfrom scipy.stats import wilcoxon\n\nHOMOLOGY_CLUSTER_PATH = os.environ.get(\"CAFA6_HOMOLOGY_CLUSTERS\", \"\")\nREQUIRE_HOMOLOGY_FOR_FINAL_CV = True\nN_FOLDS = globals().get(\"N_FOLDS\", 5)\n\nclass _UnionFind:\n def __init__(self, n): self.parent = np.arange(n, dtype=np.int64); self.rank = np.zeros(n, dtype=np.int8)\n def find(self, x):\n while self.parent[x] != x:\n self.parent[x] = self.parent[self.parent[x]]; x = self.parent[x]\n return x\n def union(self, a, b):\n a, b = self.find(a), self.find(b)\n if a == b: return\n if self.rank[a] < self.rank[b]: a, b = b, a\n self.parent[b] = a\n if self.rank[a] == self.rank[b]: self.rank[a] += 1\n\ndef charger_clusters_homologie(path, accessions):\n \"\"\"Read an MMseqs `cluster.tsv` or a two-column accession/cluster TSV.\n\n MMseqs commonly stores representative then member; both orientation choices\n yield the same connected components. Every absent accession becomes a singleton.\n \"\"\"\n path = Path(path)\n if not path.is_file():\n raise FileNotFoundError(f\"Homology cluster file not found: {path}\")\n raw = pd.read_csv(path, sep=\"\\t\", header=None, comment=\"#\", dtype=str, usecols=[0, 1])\n raw.columns = [\"cluster\", \"protein\"]\n known = set(map(str, accessions))\n raw = raw[raw.protein.isin(known)]\n mapping = dict(zip(raw.protein, raw.cluster))\n return np.asarray([mapping.get(str(acc), f\"singleton::{acc}\") for acc in accessions], dtype=object)\n\ndef groupes_fermeture_taxonomie_homologie(accessions, taxons, clusters):\n \"\"\"Keep both same-taxon and homologous proteins in the same fold.\n\n This is stricter than either grouping alone. If a huge connected component is\n produced, the experiment must be redesigned rather than silently leaking.\n \"\"\"\n n = len(accessions); uf = _UnionFind(n); first_taxon, first_cluster = {}, {}\n for i, (taxon, cluster) in enumerate(zip(map(str, taxons), map(str, clusters))):\n for key, registry in ((taxon, first_taxon), (cluster, first_cluster)):\n previous = registry.setdefault(key, i)\n uf.union(i, previous)\n roots = np.asarray([uf.find(i) for i in range(n)])\n _, groups = np.unique(roots, return_inverse=True)\n return groups.astype(str)\n\ndef auditer_splits_homologie(splits, groups, taxons, clusters, y_csr):\n rows = []\n for fold, (tr, va) in enumerate(splits):\n group_overlap = set(groups[tr]) & set(groups[va])\n cluster_overlap = set(clusters[tr]) & set(clusters[va])\n taxon_overlap = set(taxons[tr]) & set(taxons[va])\n support_tr = np.asarray(y_csr[tr].sum(axis=0)).ravel()\n support_va = np.asarray(y_csr[va].sum(axis=0)).ravel()\n rows.append({\"fold\": fold, \"n_train\": len(tr), \"n_val\": len(va),\n \"group_overlap\": len(group_overlap), \"homology_overlap\": len(cluster_overlap),\n \"taxon_overlap\": len(taxon_overlap),\n \"terms_absent_train\": int((support_tr == 0).sum()),\n \"terms_absent_val\": int((support_va == 0).sum())})\n assert not group_overlap and not cluster_overlap and not taxon_overlap, f\"Leakage in fold {fold}\"\n audit = pd.DataFrame(rows)\n print(audit.to_string(index=False))\n return audit\n\ndef construire_splits_final_homologie(accessions, taxons, y_csr, cluster_path=HOMOLOGY_CLUSTER_PATH,\n n_splits=N_FOLDS, require_homology=REQUIRE_HOMOLOGY_FOR_FINAL_CV):\n if not cluster_path:\n if require_homology:\n raise RuntimeError(\"Final CV requires CAFA6_HOMOLOGY_CLUSTERS (MMseqs/CD-HIT TSV).\")\n groups = np.asarray(taxons, dtype=str); clusters = np.asarray([f\"unknown::{x}\" for x in accessions])\n print(\"[SPLIT] DEVELOPMENT ONLY: taxonomy groups without homology clusters.\")\n else:\n clusters = charger_clusters_homologie(cluster_path, accessions)\n groups = groupes_fermeture_taxonomie_homologie(accessions, taxons, clusters)\n sizes = pd.Series(groups).value_counts()\n if len(sizes) < n_splits or sizes.iloc[0] > 0.50 * len(accessions):\n raise RuntimeError(f\"Invalid constrained groups: n_groups={len(sizes)}, largest={sizes.iloc[0]}/{len(accessions)}\")\n splitter = GroupKFold(n_splits=n_splits)\n splits = list(splitter.split(np.zeros(len(accessions)), groups=groups))\n audit = auditer_splits_homologie(splits, groups, np.asarray(taxons), clusters, y_csr)\n return splits, groups, clusters, audit\n\ndef construire_oof_memmap(resultats_cv, n_proteins, n_terms, path):\n \"\"\"Assemble each held-out fold exactly once into a disk-backed OOF matrix.\"\"\"\n out = np.memmap(path, mode=\"w+\", dtype=np.float32, shape=(n_proteins, n_terms))\n filled = np.zeros(n_proteins, dtype=bool)\n for (_, va), fold_path in zip(resultats_cv[\"folds\"], resultats_cv[\"oof_files\"]):\n if filled[va].any(): raise ValueError(\"OOF fold overlap\")\n fold = np.memmap(fold_path, mode=\"r\", dtype=np.float32, shape=(len(va), n_terms))\n out[va] = fold; filled[va] = True\n if not filled.all(): raise ValueError(\"Missing OOF predictions\")\n out.flush(); return out\n\ndef _cafa_protein_statistics(predictions, y_csr, ia, thresholds=SEUILS_CAFA, chunk=1024):\n \"\"\"Sufficient protein-level IA statistics for exact bootstrap Fmax/Smin.\"\"\"\n n, c = predictions.shape; t = len(thresholds); ia = np.asarray(ia, dtype=np.float32)\n true = np.zeros(n, dtype=np.float32); pred = np.zeros((t, n), dtype=np.float32)\n tp = np.zeros((t, n), dtype=np.float32); ru = np.zeros((t, n), dtype=np.float32); mi = np.zeros((t, n), dtype=np.float32)\n for start in range(0, n, chunk):\n stop = min(start + chunk, n); y = y_csr[start:stop].toarray().astype(bool, copy=False); p = predictions[start:stop]\n true[start:stop] = (y * ia).sum(axis=1)\n for k, threshold in enumerate(thresholds):\n selected = p >= threshold\n pred[k, start:stop] = (selected * ia).sum(axis=1)\n tp[k, start:stop] = ((selected & y) * ia).sum(axis=1)\n ru[k, start:stop] = ((y & ~selected) * ia).sum(axis=1)\n mi[k, start:stop] = ((selected & ~y) * ia).sum(axis=1)\n return true, pred, tp, ru, mi\n\ndef bootstrap_oof_cafa(predictions, y_csr, ia, n_boot=1000, confidence=0.95, seed=SEED_GLOBAL):\n \"\"\"Protein bootstrap over pooled OOF; avoids copying N x C once per replicate.\"\"\"\n true, pred, tp, ru, mi = _cafa_protein_statistics(predictions, y_csr, ia)\n rng = np.random.default_rng(seed); n = len(true); fmax, smin = [], []\n for _ in range(n_boot):\n ids = rng.integers(0, n, n)\n p, h, r = pred[:, ids], tp[:, ids], true[ids]\n present = p > 0; annotated = r > 0\n precision = np.divide(h, p, out=np.zeros_like(h), where=present)\n recall = np.divide(h, r[None, :], out=np.zeros_like(h), where=annotated[None, :])\n p_avg = np.divide((precision * present).sum(axis=1), present.sum(axis=1), out=np.zeros(len(SEUILS_CAFA)), where=present.sum(axis=1)>0)\n r_avg = np.divide((recall * annotated).sum(axis=1), max(int(annotated.sum()), 1))\n fs = np.divide(2*p_avg*r_avg, p_avg+r_avg, out=np.zeros_like(p_avg), where=(p_avg+r_avg)>0)\n fmax.append(float(fs.max()))\n distances = np.sqrt(ru[:, ids].mean(axis=1)**2 + mi[:, ids].mean(axis=1)**2)\n smin.append(float(distances.min()))\n alpha = (1 - confidence) / 2\n return {\"fmax\": np.asarray(fmax), \"smin\": np.asarray(smin),\n \"fmax_ci\": tuple(np.quantile(fmax, [alpha, 1-alpha])),\n \"smin_ci\": tuple(np.quantile(smin, [alpha, 1-alpha]))}\n\ndef comparer_ablation_appariee(scores_reference, scores_ablation, name=\"ablation\"):\n \"\"\"Paired fold test plus exact sign-flip enumeration; n=5 is reported, never oversold.\"\"\"\n ref, abl = np.asarray(scores_reference, float), np.asarray(scores_ablation, float)\n assert ref.shape == abl.shape and ref.size == N_FOLDS\n delta = ref - abl\n statistic, p_wilcoxon = wilcoxon(delta, alternative=\"two-sided\", method=\"auto\")\n signs = np.array(np.meshgrid(*[[-1, 1]] * len(delta))).T.reshape(-1, len(delta))\n observed = abs(delta.mean()); p_signflip = np.mean(np.abs((signs * delta).mean(axis=1)) >= observed)\n return {\"comparison\": name, \"n_folds\": int(len(delta)), \"mean_delta_fmax\": float(delta.mean()),\n \"median_delta_fmax\": float(np.median(delta)), \"wilcoxon_statistic\": float(statistic),\n \"wilcoxon_pvalue\": float(p_wilcoxon), \"exact_signflip_pvalue\": float(p_signflip)}\n\ndef holm_bonferroni(table, p_column=\"wilcoxon_pvalue\"):\n out = table.copy(); order = np.argsort(out[p_column].to_numpy()); m = len(out); adjusted = np.empty(m)\n running = 0.0\n for rank, idx in enumerate(order):\n running = max(running, (m-rank) * out.iloc[idx][p_column]); adjusted[idx] = min(running, 1.0)\n out[\"p_holm\"] = adjusted; return out\n\ndef executer_ablation_oof(nom, utiliser_curriculum=True, utiliser_ia=True, epochs=CV_EPOCHS):\n \"\"\"Train one ablation on the exact production folds and return matched OOF scores.\"\"\"\n result = {\"name\": nom, \"fmax_ia\": [], \"smin_ia\": [], \"oof_files\": [], \"folds\": list(splits_cv)}\n for fold, (tr, va) in enumerate(splits_cv):\n scaler = StandardScaler().fit(X_train[tr])\n xtr = scaler.transform(X_train[tr]).astype(np.float32, copy=False)\n xva = scaler.transform(X_train[va]).astype(np.float32, copy=False)\n model = creer_modele_ia_aware(dim_totale, DAGNET_HIDDEN, DAGNET_N_BLOCKS,\n len(liste_termes), DAGNET_DROPOUT, IA_N_HEADS, IA_HIDDEN, vec_ia)\n entrainer_modele(model, xtr, Y_train[tr].tocsr(), xva, Y_train[va].tocsr(),\n ia_tens=torch.as_tensor(vec_ia, dtype=torch.float32), n_termes=len(liste_termes),\n n_epoques=epochs, patience=PATIENCE, fold_courant=fold, device=DEVICE,\n utiliser_curriculum=utiliser_curriculum, utiliser_ia=utiliser_ia)\n path = os.path.join(CHEMIN_CHECKPOINTS, f\"oof_{nom}_fold_{fold}.f32\")\n _predict_to_memmap(model, xva, path, DEVICE, CV_BATCH_SIZE * 2)\n fmax, smin = _validate_fold_scores(path, (len(va), len(liste_termes)), Y_train[va].tocsr())\n result[\"fmax_ia\"].append(float(fmax[\"fmax\"])); result[\"smin_ia\"].append(float(smin[\"smin\"])); result[\"oof_files\"].append(path)\n del model, xtr, xva; gc.collect()\n if torch.cuda.is_available(): torch.cuda.empty_cache()\n return result\n\nRUN_OOF_ABLATIONS = False\nif RUN_OOF_ABLATIONS:\n ablations_oof = {\n \"without_curriculum\": executer_ablation_oof(\"without_curriculum\", utiliser_curriculum=False),\n \"without_ia\": executer_ablation_oof(\"without_ia\", utiliser_ia=False),\n }\n rows = [comparer_ablation_appariee(resultats_cv[\"fmax_ia\"], value[\"fmax_ia\"], key)\n for key, value in ablations_oof.items()]\n ablation_statistics = holm_bonferroni(pd.DataFrame(rows))\n display(ablation_statistics)\n\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.646856Z","iopub.status.idle":"2026-07-31T20:16:21.647497Z","shell.execute_reply.started":"2026-07-31T20:16:21.647366Z","shell.execute_reply":"2026-07-31T20:16:21.647389Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"code","source":"\nassert not ENABLE_GNN and not ENABLE_MAML\nassert sp.isspmatrix_csr(Y_train)\nassert len(splits_cv) == N_FOLDS\nfor fold, (tr, va) in enumerate(splits_cv):\n assert not set(groupes_taxo[tr]).intersection(set(groupes_taxo[va])), f\"taxonomy leakage in fold {fold}\"\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.64834Z","iopub.status.idle":"2026-07-31T20:16:21.648761Z","shell.execute_reply.started":"2026-07-31T20:16:21.648643Z","shell.execute_reply":"2026-07-31T20:16:21.648657Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"code","source":"\nimport os\nimport numpy as np\nimport pandas as pd\nfrom pathlib import Path\nfrom scipy.stats import wilcoxon\n\nHOMOLOGY_CLUSTER_PATH = os.environ.get(\"CAFA6_HOMOLOGY_CLUSTERS\", \"\")\nREQUIRE_HOMOLOGY_FOR_FINAL_CV = True\nN_FOLDS = globals().get(\"N_FOLDS\", 5)\n\nclass _UnionFind:\n def __init__(self, n): self.parent = np.arange(n, dtype=np.int64); self.rank = np.zeros(n, dtype=np.int8)\n def find(self, x):\n while self.parent[x] != x:\n self.parent[x] = self.parent[self.parent[x]]; x = self.parent[x]\n return x\n def union(self, a, b):\n a, b = self.find(a), self.find(b)\n if a == b: return\n if self.rank[a] < self.rank[b]: a, b = b, a\n self.parent[b] = a\n if self.rank[a] == self.rank[b]: self.rank[a] += 1\n\ndef charger_clusters_homologie(path, accessions):\n \"\"\"Read an MMseqs `cluster.tsv` or a two-column accession/cluster TSV.\n\n MMseqs commonly stores representative then member; both orientation choices\n yield the same connected components. Every absent accession becomes a singleton.\n \"\"\"\n path = Path(path)\n if not path.is_file():\n raise FileNotFoundError(f\"Homology cluster file not found: {path}\")\n raw = pd.read_csv(path, sep=\"\\t\", header=None, comment=\"#\", dtype=str, usecols=[0, 1])\n raw.columns = [\"cluster\", \"protein\"]\n known = set(map(str, accessions))\n raw = raw[raw.protein.isin(known)]\n mapping = dict(zip(raw.protein, raw.cluster))\n return np.asarray([mapping.get(str(acc), f\"singleton::{acc}\") for acc in accessions], dtype=object)\n\ndef groupes_fermeture_taxonomie_homologie(accessions, taxons, clusters):\n \"\"\"Keep both same-taxon and homologous proteins in the same fold.\n\n This is stricter than either grouping alone. If a huge connected component is\n produced, the experiment must be redesigned rather than silently leaking.\n \"\"\"\n n = len(accessions); uf = _UnionFind(n); first_taxon, first_cluster = {}, {}\n for i, (taxon, cluster) in enumerate(zip(map(str, taxons), map(str, clusters))):\n for key, registry in ((taxon, first_taxon), (cluster, first_cluster)):\n previous = registry.setdefault(key, i)\n uf.union(i, previous)\n roots = np.asarray([uf.find(i) for i in range(n)])\n _, groups = np.unique(roots, return_inverse=True)\n return groups.astype(str)\n\ndef auditer_splits_homologie(splits, groups, taxons, clusters, y_csr):\n rows = []\n for fold, (tr, va) in enumerate(splits):\n group_overlap = set(groups[tr]) & set(groups[va])\n cluster_overlap = set(clusters[tr]) & set(clusters[va])\n taxon_overlap = set(taxons[tr]) & set(taxons[va])\n support_tr = np.asarray(y_csr[tr].sum(axis=0)).ravel()\n support_va = np.asarray(y_csr[va].sum(axis=0)).ravel()\n rows.append({\"fold\": fold, \"n_train\": len(tr), \"n_val\": len(va),\n \"group_overlap\": len(group_overlap), \"homology_overlap\": len(cluster_overlap),\n \"taxon_overlap\": len(taxon_overlap),\n \"terms_absent_train\": int((support_tr == 0).sum()),\n \"terms_absent_val\": int((support_va == 0).sum())})\n assert not group_overlap and not cluster_overlap and not taxon_overlap, f\"Leakage in fold {fold}\"\n audit = pd.DataFrame(rows)\n print(audit.to_string(index=False))\n return audit\n\ndef construire_splits_final_homologie(accessions, taxons, y_csr, cluster_path=HOMOLOGY_CLUSTER_PATH,\n n_splits=N_FOLDS, require_homology=REQUIRE_HOMOLOGY_FOR_FINAL_CV):\n if not cluster_path:\n if require_homology:\n raise RuntimeError(\"Final CV requires CAFA6_HOMOLOGY_CLUSTERS (MMseqs/CD-HIT TSV).\")\n groups = np.asarray(taxons, dtype=str); clusters = np.asarray([f\"unknown::{x}\" for x in accessions])\n print(\"[SPLIT] DEVELOPMENT ONLY: taxonomy groups without homology clusters.\")\n else:\n clusters = charger_clusters_homologie(cluster_path, accessions)\n groups = groupes_fermeture_taxonomie_homologie(accessions, taxons, clusters)\n sizes = pd.Series(groups).value_counts()\n n_groups = len(sizes)\n if n_groups < 2:\n raise RuntimeError(f\"Invalid constrained groups: n_groups={n_groups}\")\n effective_n_splits = min(int(n_splits), n_groups)\n if effective_n_splits < 2:\n raise RuntimeError(f\"Insufficient groups for cross-validation: n_groups={n_groups}\")\n splitter = GroupKFold(n_splits=effective_n_splits)\n splits = list(splitter.split(np.zeros(len(accessions)), groups=groups))\n audit = auditer_splits_homologie(splits, groups, np.asarray(taxons), clusters, y_csr)\n return splits, groups, clusters, audit\n\ndef construire_oof_memmap(resultats_cv, n_proteins, n_terms, path):\n \"\"\"Assemble each held-out fold exactly once into a disk-backed OOF matrix.\"\"\"\n out = np.memmap(path, mode=\"w+\", dtype=np.float32, shape=(n_proteins, n_terms))\n filled = np.zeros(n_proteins, dtype=bool)\n for (_, va), fold_path in zip(resultats_cv[\"folds\"], resultats_cv[\"oof_files\"]):\n if filled[va].any(): raise ValueError(\"OOF fold overlap\")\n fold = np.memmap(fold_path, mode=\"r\", dtype=np.float32, shape=(len(va), n_terms))\n out[va] = fold; filled[va] = True\n if not filled.all(): raise ValueError(\"Missing OOF predictions\")\n out.flush(); return out\n\ndef _cafa_protein_statistics(predictions, y_csr, ia, thresholds=SEUILS_CAFA, chunk=1024):\n \"\"\"Sufficient protein-level IA statistics for exact bootstrap Fmax/Smin.\"\"\"\n n, c = predictions.shape; t = len(thresholds); ia = np.asarray(ia, dtype=np.float32)\n true = np.zeros(n, dtype=np.float32); pred = np.zeros((t, n), dtype=np.float32)\n tp = np.zeros((t, n), dtype=np.float32); ru = np.zeros((t, n), dtype=np.float32); mi = np.zeros((t, n), dtype=np.float32)\n for start in range(0, n, chunk):\n stop = min(start + chunk, n); y = y_csr[start:stop].toarray().astype(bool, copy=False); p = predictions[start:stop]\n true[start:stop] = (y * ia).sum(axis=1)\n for k, threshold in enumerate(thresholds):\n selected = p >= threshold\n pred[k, start:stop] = (selected * ia).sum(axis=1)\n tp[k, start:stop] = ((selected & y) * ia).sum(axis=1)\n ru[k, start:stop] = ((y & ~selected) * ia).sum(axis=1)\n mi[k, start:stop] = ((selected & ~y) * ia).sum(axis=1)\n return true, pred, tp, ru, mi\n\ndef bootstrap_oof_cafa(predictions, y_csr, ia, n_boot=1000, confidence=0.95, seed=SEED_GLOBAL):\n \"\"\"Protein bootstrap over pooled OOF; avoids copying N x C once per replicate.\"\"\"\n true, pred, tp, ru, mi = _cafa_protein_statistics(predictions, y_csr, ia)\n rng = np.random.default_rng(seed); n = len(true); fmax, smin = [], []\n for _ in range(n_boot):\n ids = rng.integers(0, n, n)\n p, h, r = pred[:, ids], tp[:, ids], true[ids]\n present = p > 0; annotated = r > 0\n precision = np.divide(h, p, out=np.zeros_like(h), where=present)\n recall = np.divide(h, r[None, :], out=np.zeros_like(h), where=annotated[None, :])\n p_avg = np.divide((precision * present).sum(axis=1), present.sum(axis=1), out=np.zeros(len(SEUILS_CAFA)), where=present.sum(axis=1)>0)\n r_avg = np.divide((recall * annotated).sum(axis=1), max(int(annotated.sum()), 1))\n fs = np.divide(2*p_avg*r_avg, p_avg+r_avg, out=np.zeros_like(p_avg), where=(p_avg+r_avg)>0)\n fmax.append(float(fs.max()))\n distances = np.sqrt(ru[:, ids].mean(axis=1)**2 + mi[:, ids].mean(axis=1)**2)\n smin.append(float(distances.min()))\n alpha = (1 - confidence) / 2\n return {\"fmax\": np.asarray(fmax), \"smin\": np.asarray(smin),\n \"fmax_ci\": tuple(np.quantile(fmax, [alpha, 1-alpha])),\n \"smin_ci\": tuple(np.quantile(smin, [alpha, 1-alpha]))}\n\ndef comparer_ablation_appariee(scores_reference, scores_ablation, name=\"ablation\"):\n \"\"\"Paired fold test plus exact sign-flip enumeration; n=5 is reported, never oversold.\"\"\"\n ref, abl = np.asarray(scores_reference, float), np.asarray(scores_ablation, float)\n assert ref.shape == abl.shape and ref.size == N_FOLDS\n delta = ref - abl\n statistic, p_wilcoxon = wilcoxon(delta, alternative=\"two-sided\", method=\"auto\")\n signs = np.array(np.meshgrid(*[[-1, 1]] * len(delta))).T.reshape(-1, len(delta))\n observed = abs(delta.mean()); p_signflip = np.mean(np.abs((signs * delta).mean(axis=1)) >= observed)\n return {\"comparison\": name, \"n_folds\": int(len(delta)), \"mean_delta_fmax\": float(delta.mean()),\n \"median_delta_fmax\": float(np.median(delta)), \"wilcoxon_statistic\": float(statistic),\n \"wilcoxon_pvalue\": float(p_wilcoxon), \"exact_signflip_pvalue\": float(p_signflip)}\n\ndef holm_bonferroni(table, p_column=\"wilcoxon_pvalue\"):\n out = table.copy(); order = np.argsort(out[p_column].to_numpy()); m = len(out); adjusted = np.empty(m)\n running = 0.0\n for rank, idx in enumerate(order):\n running = max(running, (m-rank) * out.iloc[idx][p_column]); adjusted[idx] = min(running, 1.0)\n out[\"p_holm\"] = adjusted; return out\n\ndef executer_ablation_oof(nom, utiliser_curriculum=True, utiliser_ia=True, epochs=CV_EPOCHS):\n \"\"\"Train one ablation on the exact production folds and return matched OOF scores.\"\"\"\n result = {\"name\": nom, \"fmax_ia\": [], \"smin_ia\": [], \"oof_files\": [], \"folds\": list(splits_cv)}\n for fold, (tr, va) in enumerate(splits_cv):\n scaler = StandardScaler().fit(X_train[tr])\n xtr = scaler.transform(X_train[tr]).astype(np.float32, copy=False)\n xva = scaler.transform(X_train[va]).astype(np.float32, copy=False)\n model = creer_modele_ia_aware(dim_totale, DAGNET_HIDDEN, DAGNET_N_BLOCKS,\n len(liste_termes), DAGNET_DROPOUT, IA_N_HEADS, IA_HIDDEN, vec_ia)\n entrainer_modele(model, xtr, Y_train[tr].tocsr(), xva, Y_train[va].tocsr(),\n ia_tens=torch.as_tensor(vec_ia, dtype=torch.float32), n_termes=len(liste_termes),\n n_epoques=epochs, patience=PATIENCE, fold_courant=fold, device=DEVICE,\n utiliser_curriculum=utiliser_curriculum, utiliser_ia=utiliser_ia)\n path = os.path.join(CHEMIN_CHECKPOINTS, f\"oof_{nom}_fold_{fold}.f32\")\n _predict_to_memmap(model, xva, path, DEVICE, CV_BATCH_SIZE * 2)\n fmax, smin = _validate_fold_scores(path, (len(va), len(liste_termes)), Y_train[va].tocsr())\n result[\"fmax_ia\"].append(float(fmax[\"fmax\"])); result[\"smin_ia\"].append(float(smin[\"smin\"])); result[\"oof_files\"].append(path)\n del model, xtr, xva; gc.collect()\n if torch.cuda.is_available(): torch.cuda.empty_cache()\n return result\n\nRUN_OOF_ABLATIONS = False\nif RUN_OOF_ABLATIONS:\n ablations_oof = {\n \"without_curriculum\": executer_ablation_oof(\"without_curriculum\", utiliser_curriculum=False),\n \"without_ia\": executer_ablation_oof(\"without_ia\", utiliser_ia=False),\n }\n rows = [comparer_ablation_appariee(resultats_cv[\"fmax_ia\"], value[\"fmax_ia\"], key)\n for key, value in ablations_oof.items()]\n ablation_statistics = holm_bonferroni(pd.DataFrame(rows))\n display(ablation_statistics)\n\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.650588Z","iopub.status.idle":"2026-07-31T20:16:21.650876Z","shell.execute_reply.started":"2026-07-31T20:16:21.650752Z","shell.execute_reply":"2026-07-31T20:16:21.650766Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"code","source":"\nassert not ENABLE_GNN and not ENABLE_MAML\nassert sp.isspmatrix_csr(Y_train)\nassert len(splits_cv) == N_FOLDS\nfor fold, (tr, va) in enumerate(splits_cv):\n assert not set(groupes_taxo[tr]).intersection(set(groupes_taxo[va])), f\"taxonomy leakage in fold {fold}\"\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.652112Z","iopub.status.idle":"2026-07-31T20:16:21.652568Z","shell.execute_reply.started":"2026-07-31T20:16:21.65233Z","shell.execute_reply":"2026-07-31T20:16:21.652354Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"","metadata":{}},{"cell_type":"code","source":"\nimport os\nimport numpy as np\nimport pandas as pd\nfrom pathlib import Path\nfrom scipy.stats import wilcoxon\n\nHOMOLOGY_CLUSTER_PATH = os.environ.get(\"CAFA6_HOMOLOGY_CLUSTERS\", \"\")\nREQUIRE_HOMOLOGY_FOR_FINAL_CV = True\nN_FOLDS = globals().get(\"N_FOLDS\", 5)\n\nclass _UnionFind:\n def __init__(self, n): self.parent = np.arange(n, dtype=np.int64); self.rank = np.zeros(n, dtype=np.int8)\n def find(self, x):\n while self.parent[x] != x:\n self.parent[x] = self.parent[self.parent[x]]; x = self.parent[x]\n return x\n def union(self, a, b):\n a, b = self.find(a), self.find(b)\n if a == b: return\n if self.rank[a] < self.rank[b]: a, b = b, a\n self.parent[b] = a\n if self.rank[a] == self.rank[b]: self.rank[a] += 1\n\ndef charger_clusters_homologie(path, accessions):\n \"\"\"Read an MMseqs `cluster.tsv` or a two-column accession/cluster TSV.\n\n MMseqs commonly stores representative then member; both orientation choices\n yield the same connected components. Every absent accession becomes a singleton.\n \"\"\"\n path = Path(path)\n if not path.is_file():\n raise FileNotFoundError(f\"Homology cluster file not found: {path}\")\n raw = pd.read_csv(path, sep=\"\\t\", header=None, comment=\"#\", dtype=str, usecols=[0, 1])\n raw.columns = [\"cluster\", \"protein\"]\n known = set(map(str, accessions))\n raw = raw[raw.protein.isin(known)]\n mapping = dict(zip(raw.protein, raw.cluster))\n return np.asarray([mapping.get(str(acc), f\"singleton::{acc}\") for acc in accessions], dtype=object)\n\ndef groupes_fermeture_taxonomie_homologie(accessions, taxons, clusters):\n \"\"\"Keep both same-taxon and homologous proteins in the same fold.\n\n This is stricter than either grouping alone. If a huge connected component is\n produced, the experiment must be redesigned rather than silently leaking.\n \"\"\"\n n = len(accessions); uf = _UnionFind(n); first_taxon, first_cluster = {}, {}\n for i, (taxon, cluster) in enumerate(zip(map(str, taxons), map(str, clusters))):\n for key, registry in ((taxon, first_taxon), (cluster, first_cluster)):\n previous = registry.setdefault(key, i)\n uf.union(i, previous)\n roots = np.asarray([uf.find(i) for i in range(n)])\n _, groups = np.unique(roots, return_inverse=True)\n return groups.astype(str)\n\ndef auditer_splits_homologie(splits, groups, taxons, clusters, y_csr):\n rows = []\n for fold, (tr, va) in enumerate(splits):\n group_overlap = set(groups[tr]) & set(groups[va])\n cluster_overlap = set(clusters[tr]) & set(clusters[va])\n taxon_overlap = set(taxons[tr]) & set(taxons[va])\n support_tr = np.asarray(y_csr[tr].sum(axis=0)).ravel()\n support_va = np.asarray(y_csr[va].sum(axis=0)).ravel()\n rows.append({\"fold\": fold, \"n_train\": len(tr), \"n_val\": len(va),\n \"group_overlap\": len(group_overlap), \"homology_overlap\": len(cluster_overlap),\n \"taxon_overlap\": len(taxon_overlap),\n \"terms_absent_train\": int((support_tr == 0).sum()),\n \"terms_absent_val\": int((support_va == 0).sum())})\n assert not group_overlap and not cluster_overlap and not taxon_overlap, f\"Leakage in fold {fold}\"\n audit = pd.DataFrame(rows)\n print(audit.to_string(index=False))\n return audit\n\ndef construire_splits_final_homologie(accessions, taxons, y_csr, cluster_path=HOMOLOGY_CLUSTER_PATH,\n n_splits=N_FOLDS, require_homology=REQUIRE_HOMOLOGY_FOR_FINAL_CV):\n if not cluster_path:\n if require_homology:\n raise RuntimeError(\"Final CV requires CAFA6_HOMOLOGY_CLUSTERS (MMseqs/CD-HIT TSV).\")\n groups = np.asarray(taxons, dtype=str); clusters = np.asarray([f\"unknown::{x}\" for x in accessions])\n print(\"[SPLIT] DEVELOPMENT ONLY: taxonomy groups without homology clusters.\")\n else:\n clusters = charger_clusters_homologie(cluster_path, accessions)\n groups = groupes_fermeture_taxonomie_homologie(accessions, taxons, clusters)\n sizes = pd.Series(groups).value_counts()\n n_groups = len(sizes)\n if n_groups < 2:\n raise RuntimeError(f\"Invalid constrained groups: n_groups={n_groups}\")\n effective_n_splits = min(int(n_splits), n_groups)\n if effective_n_splits < 2:\n raise RuntimeError(f\"Insufficient groups for cross-validation: n_groups={n_groups}\")\n splitter = GroupKFold(n_splits=effective_n_splits)\n splits = list(splitter.split(np.zeros(len(accessions)), groups=groups))\n audit = auditer_splits_homologie(splits, groups, np.asarray(taxons), clusters, y_csr)\n return splits, groups, clusters, audit\n\ndef construire_oof_memmap(resultats_cv, n_proteins, n_terms, path):\n \"\"\"Assemble each held-out fold exactly once into a disk-backed OOF matrix.\"\"\"\n out = np.memmap(path, mode=\"w+\", dtype=np.float32, shape=(n_proteins, n_terms))\n filled = np.zeros(n_proteins, dtype=bool)\n for (_, va), fold_path in zip(resultats_cv[\"folds\"], resultats_cv[\"oof_files\"]):\n if filled[va].any(): raise ValueError(\"OOF fold overlap\")\n fold = np.memmap(fold_path, mode=\"r\", dtype=np.float32, shape=(len(va), n_terms))\n out[va] = fold; filled[va] = True\n if not filled.all(): raise ValueError(\"Missing OOF predictions\")\n out.flush(); return out\n\ndef _cafa_protein_statistics(predictions, y_csr, ia, thresholds=SEUILS_CAFA, chunk=1024):\n \"\"\"Sufficient protein-level IA statistics for exact bootstrap Fmax/Smin.\"\"\"\n n, c = predictions.shape; t = len(thresholds); ia = np.asarray(ia, dtype=np.float32)\n true = np.zeros(n, dtype=np.float32); pred = np.zeros((t, n), dtype=np.float32)\n tp = np.zeros((t, n), dtype=np.float32); ru = np.zeros((t, n), dtype=np.float32); mi = np.zeros((t, n), dtype=np.float32)\n for start in range(0, n, chunk):\n stop = min(start + chunk, n); y = y_csr[start:stop].toarray().astype(bool, copy=False); p = predictions[start:stop]\n true[start:stop] = (y * ia).sum(axis=1)\n for k, threshold in enumerate(thresholds):\n selected = p >= threshold\n pred[k, start:stop] = (selected * ia).sum(axis=1)\n tp[k, start:stop] = ((selected & y) * ia).sum(axis=1)\n ru[k, start:stop] = ((y & ~selected) * ia).sum(axis=1)\n mi[k, start:stop] = ((selected & ~y) * ia).sum(axis=1)\n return true, pred, tp, ru, mi\n\ndef bootstrap_oof_cafa(predictions, y_csr, ia, n_boot=1000, confidence=0.95, seed=SEED_GLOBAL):\n \"\"\"Protein bootstrap over pooled OOF; avoids copying N x C once per replicate.\"\"\"\n true, pred, tp, ru, mi = _cafa_protein_statistics(predictions, y_csr, ia)\n rng = np.random.default_rng(seed); n = len(true); fmax, smin = [], []\n for _ in range(n_boot):\n ids = rng.integers(0, n, n)\n p, h, r = pred[:, ids], tp[:, ids], true[ids]\n present = p > 0; annotated = r > 0\n precision = np.divide(h, p, out=np.zeros_like(h), where=present)\n recall = np.divide(h, r[None, :], out=np.zeros_like(h), where=annotated[None, :])\n p_avg = np.divide((precision * present).sum(axis=1), present.sum(axis=1), out=np.zeros(len(SEUILS_CAFA)), where=present.sum(axis=1)>0)\n r_avg = np.divide((recall * annotated).sum(axis=1), max(int(annotated.sum()), 1))\n fs = np.divide(2*p_avg*r_avg, p_avg+r_avg, out=np.zeros_like(p_avg), where=(p_avg+r_avg)>0)\n fmax.append(float(fs.max()))\n distances = np.sqrt(ru[:, ids].mean(axis=1)**2 + mi[:, ids].mean(axis=1)**2)\n smin.append(float(distances.min()))\n alpha = (1 - confidence) / 2\n return {\"fmax\": np.asarray(fmax), \"smin\": np.asarray(smin),\n \"fmax_ci\": tuple(np.quantile(fmax, [alpha, 1-alpha])),\n \"smin_ci\": tuple(np.quantile(smin, [alpha, 1-alpha]))}\n\ndef comparer_ablation_appariee(scores_reference, scores_ablation, name=\"ablation\"):\n \"\"\"Paired fold test plus exact sign-flip enumeration; n=5 is reported, never oversold.\"\"\"\n ref, abl = np.asarray(scores_reference, float), np.asarray(scores_ablation, float)\n assert ref.shape == abl.shape and ref.size == N_FOLDS\n delta = ref - abl\n statistic, p_wilcoxon = wilcoxon(delta, alternative=\"two-sided\", method=\"auto\")\n signs = np.array(np.meshgrid(*[[-1, 1]] * len(delta))).T.reshape(-1, len(delta))\n observed = abs(delta.mean()); p_signflip = np.mean(np.abs((signs * delta).mean(axis=1)) >= observed)\n return {\"comparison\": name, \"n_folds\": int(len(delta)), \"mean_delta_fmax\": float(delta.mean()),\n \"median_delta_fmax\": float(np.median(delta)), \"wilcoxon_statistic\": float(statistic),\n \"wilcoxon_pvalue\": float(p_wilcoxon), \"exact_signflip_pvalue\": float(p_signflip)}\n\ndef holm_bonferroni(table, p_column=\"wilcoxon_pvalue\"):\n out = table.copy(); order = np.argsort(out[p_column].to_numpy()); m = len(out); adjusted = np.empty(m)\n running = 0.0\n for rank, idx in enumerate(order):\n running = max(running, (m-rank) * out.iloc[idx][p_column]); adjusted[idx] = min(running, 1.0)\n out[\"p_holm\"] = adjusted; return out\n\ndef executer_ablation_oof(nom, utiliser_curriculum=True, utiliser_ia=True, epochs=CV_EPOCHS):\n \"\"\"Train one ablation on the exact production folds and return matched OOF scores.\"\"\"\n result = {\"name\": nom, \"fmax_ia\": [], \"smin_ia\": [], \"oof_files\": [], \"folds\": list(splits_cv)}\n for fold, (tr, va) in enumerate(splits_cv):\n scaler = StandardScaler().fit(X_train[tr])\n xtr = scaler.transform(X_train[tr]).astype(np.float32, copy=False)\n xva = scaler.transform(X_train[va]).astype(np.float32, copy=False)\n model = creer_modele_ia_aware(dim_totale, DAGNET_HIDDEN, DAGNET_N_BLOCKS,\n len(liste_termes), DAGNET_DROPOUT, IA_N_HEADS, IA_HIDDEN, vec_ia)\n entrainer_modele(model, xtr, Y_train[tr].tocsr(), xva, Y_train[va].tocsr(),\n ia_tens=torch.as_tensor(vec_ia, dtype=torch.float32), n_termes=len(liste_termes),\n n_epoques=epochs, patience=PATIENCE, fold_courant=fold, device=DEVICE,\n utiliser_curriculum=utiliser_curriculum, utiliser_ia=utiliser_ia)\n path = os.path.join(CHEMIN_CHECKPOINTS, f\"oof_{nom}_fold_{fold}.f32\")\n _predict_to_memmap(model, xva, path, DEVICE, CV_BATCH_SIZE * 2)\n fmax, smin = _validate_fold_scores(path, (len(va), len(liste_termes)), Y_train[va].tocsr())\n result[\"fmax_ia\"].append(float(fmax[\"fmax\"])); result[\"smin_ia\"].append(float(smin[\"smin\"])); result[\"oof_files\"].append(path)\n del model, xtr, xva; gc.collect()\n if torch.cuda.is_available(): torch.cuda.empty_cache()\n return result\n\nRUN_OOF_ABLATIONS = False\nif RUN_OOF_ABLATIONS:\n ablations_oof = {\n \"without_curriculum\": executer_ablation_oof(\"without_curriculum\", utiliser_curriculum=False),\n \"without_ia\": executer_ablation_oof(\"without_ia\", utiliser_ia=False),\n }\n rows = [comparer_ablation_appariee(resultats_cv[\"fmax_ia\"], value[\"fmax_ia\"], key)\n for key, value in ablations_oof.items()]\n ablation_statistics = holm_bonferroni(pd.DataFrame(rows))\n display(ablation_statistics)\n\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.65399Z","iopub.status.idle":"2026-07-31T20:16:21.654341Z","shell.execute_reply.started":"2026-07-31T20:16:21.654177Z","shell.execute_reply":"2026-07-31T20:16:21.654194Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"\nThe executable production path is ESM-2/LoRA cached embeddings, DAGNet, IA-aware loss,\nCSR mini-batches, leakage-free fold scaling, disk-backed OOF predictions, and streaming\nsubmission. The heterogeneous GNN and MAML are deliberately removed from execution.\n","metadata":{}},{"cell_type":"code","source":"\nassert not ENABLE_GNN and not ENABLE_MAML\nassert sp.isspmatrix_csr(Y_train)\nassert len(splits_cv) == N_FOLDS\nfor fold, (tr, va) in enumerate(splits_cv):\n assert not set(groupes_taxo[tr]).intersection(set(groupes_taxo[va])), f\"taxonomy leakage in fold {fold}\"\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.655476Z","iopub.status.idle":"2026-07-31T20:16:21.655818Z","shell.execute_reply.started":"2026-07-31T20:16:21.65564Z","shell.execute_reply":"2026-07-31T20:16:21.655658Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"\nFinal evaluation groups are connected components induced jointly by taxonomy and\nhomology clusters. A cluster file must be supplied for publication-grade CV; a\ntaxonomy-only split is labelled development-only. Ablations use matched OOF folds;\nuncertainty uses a protein bootstrap over the pooled OOF predictions.\n","metadata":{}},{"cell_type":"code","source":"\nimport os\nimport numpy as np\nimport pandas as pd\nfrom pathlib import Path\nfrom scipy.stats import wilcoxon\n\nHOMOLOGY_CLUSTER_PATH = os.environ.get(\"CAFA6_HOMOLOGY_CLUSTERS\", \"\")\nREQUIRE_HOMOLOGY_FOR_FINAL_CV = True\nN_FOLDS = globals().get(\"N_FOLDS\", 5)\n\nclass _UnionFind:\n def __init__(self, n): self.parent = np.arange(n, dtype=np.int64); self.rank = np.zeros(n, dtype=np.int8)\n def find(self, x):\n while self.parent[x] != x:\n self.parent[x] = self.parent[self.parent[x]]; x = self.parent[x]\n return x\n def union(self, a, b):\n a, b = self.find(a), self.find(b)\n if a == b: return\n if self.rank[a] < self.rank[b]: a, b = b, a\n self.parent[b] = a\n if self.rank[a] == self.rank[b]: self.rank[a] += 1\n\ndef charger_clusters_homologie(path, accessions):\n \"\"\"Read an MMseqs `cluster.tsv` or a two-column accession/cluster TSV.\n\n MMseqs commonly stores representative then member; both orientation choices\n yield the same connected components. Every absent accession becomes a singleton.\n \"\"\"\n path = Path(path)\n if not path.is_file():\n raise FileNotFoundError(f\"Homology cluster file not found: {path}\")\n raw = pd.read_csv(path, sep=\"\\t\", header=None, comment=\"#\", dtype=str, usecols=[0, 1])\n raw.columns = [\"cluster\", \"protein\"]\n known = set(map(str, accessions))\n raw = raw[raw.protein.isin(known)]\n mapping = dict(zip(raw.protein, raw.cluster))\n return np.asarray([mapping.get(str(acc), f\"singleton::{acc}\") for acc in accessions], dtype=object)\n\ndef groupes_fermeture_taxonomie_homologie(accessions, taxons, clusters):\n \"\"\"Keep both same-taxon and homologous proteins in the same fold.\n\n This is stricter than either grouping alone. If a huge connected component is\n produced, the experiment must be redesigned rather than silently leaking.\n \"\"\"\n n = len(accessions); uf = _UnionFind(n); first_taxon, first_cluster = {}, {}\n for i, (taxon, cluster) in enumerate(zip(map(str, taxons), map(str, clusters))):\n for key, registry in ((taxon, first_taxon), (cluster, first_cluster)):\n previous = registry.setdefault(key, i)\n uf.union(i, previous)\n roots = np.asarray([uf.find(i) for i in range(n)])\n _, groups = np.unique(roots, return_inverse=True)\n return groups.astype(str)\n\ndef auditer_splits_homologie(splits, groups, taxons, clusters, y_csr):\n rows = []\n for fold, (tr, va) in enumerate(splits):\n group_overlap = set(groups[tr]) & set(groups[va])\n cluster_overlap = set(clusters[tr]) & set(clusters[va])\n taxon_overlap = set(taxons[tr]) & set(taxons[va])\n support_tr = np.asarray(y_csr[tr].sum(axis=0)).ravel()\n support_va = np.asarray(y_csr[va].sum(axis=0)).ravel()\n rows.append({\"fold\": fold, \"n_train\": len(tr), \"n_val\": len(va),\n \"group_overlap\": len(group_overlap), \"homology_overlap\": len(cluster_overlap),\n \"taxon_overlap\": len(taxon_overlap),\n \"terms_absent_train\": int((support_tr == 0).sum()),\n \"terms_absent_val\": int((support_va == 0).sum())})\n assert not group_overlap and not cluster_overlap and not taxon_overlap, f\"Leakage in fold {fold}\"\n audit = pd.DataFrame(rows)\n print(audit.to_string(index=False))\n return audit\n\ndef construire_splits_final_homologie(accessions, taxons, y_csr, cluster_path=HOMOLOGY_CLUSTER_PATH,\n n_splits=N_FOLDS, require_homology=REQUIRE_HOMOLOGY_FOR_FINAL_CV):\n if not cluster_path:\n if require_homology:\n raise RuntimeError(\"Final CV requires CAFA6_HOMOLOGY_CLUSTERS (MMseqs/CD-HIT TSV).\")\n groups = np.asarray(taxons, dtype=str); clusters = np.asarray([f\"unknown::{x}\" for x in accessions])\n print(\"[SPLIT] DEVELOPMENT ONLY: taxonomy groups without homology clusters.\")\n else:\n clusters = charger_clusters_homologie(cluster_path, accessions)\n groups = groupes_fermeture_taxonomie_homologie(accessions, taxons, clusters)\n sizes = pd.Series(groups).value_counts()\n n_groups = len(sizes)\n if n_groups < 2:\n raise RuntimeError(f\"Invalid constrained groups: n_groups={n_groups}\")\n effective_n_splits = min(int(n_splits), n_groups)\n if effective_n_splits < 2:\n raise RuntimeError(f\"Insufficient groups for cross-validation: n_groups={n_groups}\")\n splitter = GroupKFold(n_splits=effective_n_splits)\n splits = list(splitter.split(np.zeros(len(accessions)), groups=groups))\n audit = auditer_splits_homologie(splits, groups, np.asarray(taxons), clusters, y_csr)\n return splits, groups, clusters, audit\n\ndef construire_oof_memmap(resultats_cv, n_proteins, n_terms, path):\n \"\"\"Assemble each held-out fold exactly once into a disk-backed OOF matrix.\"\"\"\n out = np.memmap(path, mode=\"w+\", dtype=np.float32, shape=(n_proteins, n_terms))\n filled = np.zeros(n_proteins, dtype=bool)\n for (_, va), fold_path in zip(resultats_cv[\"folds\"], resultats_cv[\"oof_files\"]):\n if filled[va].any(): raise ValueError(\"OOF fold overlap\")\n fold = np.memmap(fold_path, mode=\"r\", dtype=np.float32, shape=(len(va), n_terms))\n out[va] = fold; filled[va] = True\n if not filled.all(): raise ValueError(\"Missing OOF predictions\")\n out.flush(); return out\n\ndef _cafa_protein_statistics(predictions, y_csr, ia, thresholds=SEUILS_CAFA, chunk=1024):\n \"\"\"Sufficient protein-level IA statistics for exact bootstrap Fmax/Smin.\"\"\"\n n, c = predictions.shape; t = len(thresholds); ia = np.asarray(ia, dtype=np.float32)\n true = np.zeros(n, dtype=np.float32); pred = np.zeros((t, n), dtype=np.float32)\n tp = np.zeros((t, n), dtype=np.float32); ru = np.zeros((t, n), dtype=np.float32); mi = np.zeros((t, n), dtype=np.float32)\n for start in range(0, n, chunk):\n stop = min(start + chunk, n); y = y_csr[start:stop].toarray().astype(bool, copy=False); p = predictions[start:stop]\n true[start:stop] = (y * ia).sum(axis=1)\n for k, threshold in enumerate(thresholds):\n selected = p >= threshold\n pred[k, start:stop] = (selected * ia).sum(axis=1)\n tp[k, start:stop] = ((selected & y) * ia).sum(axis=1)\n ru[k, start:stop] = ((y & ~selected) * ia).sum(axis=1)\n mi[k, start:stop] = ((selected & ~y) * ia).sum(axis=1)\n return true, pred, tp, ru, mi\n\ndef bootstrap_oof_cafa(predictions, y_csr, ia, n_boot=1000, confidence=0.95, seed=SEED_GLOBAL):\n \"\"\"Protein bootstrap over pooled OOF; avoids copying N x C once per replicate.\"\"\"\n true, pred, tp, ru, mi = _cafa_protein_statistics(predictions, y_csr, ia)\n rng = np.random.default_rng(seed); n = len(true); fmax, smin = [], []\n for _ in range(n_boot):\n ids = rng.integers(0, n, n)\n p, h, r = pred[:, ids], tp[:, ids], true[ids]\n present = p > 0; annotated = r > 0\n precision = np.divide(h, p, out=np.zeros_like(h), where=present)\n recall = np.divide(h, r[None, :], out=np.zeros_like(h), where=annotated[None, :])\n p_avg = np.divide((precision * present).sum(axis=1), present.sum(axis=1), out=np.zeros(len(SEUILS_CAFA)), where=present.sum(axis=1)>0)\n r_avg = np.divide((recall * annotated).sum(axis=1), max(int(annotated.sum()), 1))\n fs = np.divide(2*p_avg*r_avg, p_avg+r_avg, out=np.zeros_like(p_avg), where=(p_avg+r_avg)>0)\n fmax.append(float(fs.max()))\n distances = np.sqrt(ru[:, ids].mean(axis=1)**2 + mi[:, ids].mean(axis=1)**2)\n smin.append(float(distances.min()))\n alpha = (1 - confidence) / 2\n return {\"fmax\": np.asarray(fmax), \"smin\": np.asarray(smin),\n \"fmax_ci\": tuple(np.quantile(fmax, [alpha, 1-alpha])),\n \"smin_ci\": tuple(np.quantile(smin, [alpha, 1-alpha]))}\n\ndef comparer_ablation_appariee(scores_reference, scores_ablation, name=\"ablation\"):\n \"\"\"Paired fold test plus exact sign-flip enumeration; n=5 is reported, never oversold.\"\"\"\n ref, abl = np.asarray(scores_reference, float), np.asarray(scores_ablation, float)\n assert ref.shape == abl.shape and ref.size == N_FOLDS\n delta = ref - abl\n statistic, p_wilcoxon = wilcoxon(delta, alternative=\"two-sided\", method=\"auto\")\n signs = np.array(np.meshgrid(*[[-1, 1]] * len(delta))).T.reshape(-1, len(delta))\n observed = abs(delta.mean()); p_signflip = np.mean(np.abs((signs * delta).mean(axis=1)) >= observed)\n return {\"comparison\": name, \"n_folds\": int(len(delta)), \"mean_delta_fmax\": float(delta.mean()),\n \"median_delta_fmax\": float(np.median(delta)), \"wilcoxon_statistic\": float(statistic),\n \"wilcoxon_pvalue\": float(p_wilcoxon), \"exact_signflip_pvalue\": float(p_signflip)}\n\ndef holm_bonferroni(table, p_column=\"wilcoxon_pvalue\"):\n out = table.copy(); order = np.argsort(out[p_column].to_numpy()); m = len(out); adjusted = np.empty(m)\n running = 0.0\n for rank, idx in enumerate(order):\n running = max(running, (m-rank) * out.iloc[idx][p_column]); adjusted[idx] = min(running, 1.0)\n out[\"p_holm\"] = adjusted; return out\n\ndef executer_ablation_oof(nom, utiliser_curriculum=True, utiliser_ia=True, epochs=CV_EPOCHS):\n \"\"\"Train one ablation on the exact production folds and return matched OOF scores.\"\"\"\n result = {\"name\": nom, \"fmax_ia\": [], \"smin_ia\": [], \"oof_files\": [], \"folds\": list(splits_cv)}\n for fold, (tr, va) in enumerate(splits_cv):\n scaler = StandardScaler().fit(X_train[tr])\n xtr = scaler.transform(X_train[tr]).astype(np.float32, copy=False)\n xva = scaler.transform(X_train[va]).astype(np.float32, copy=False)\n model = creer_modele_ia_aware(dim_totale, DAGNET_HIDDEN, DAGNET_N_BLOCKS,\n len(liste_termes), DAGNET_DROPOUT, IA_N_HEADS, IA_HIDDEN, vec_ia)\n entrainer_modele(model, xtr, Y_train[tr].tocsr(), xva, Y_train[va].tocsr(),\n ia_tens=torch.as_tensor(vec_ia, dtype=torch.float32), n_termes=len(liste_termes),\n n_epoques=epochs, patience=PATIENCE, fold_courant=fold, device=DEVICE,\n utiliser_curriculum=utiliser_curriculum, utiliser_ia=utiliser_ia)\n path = os.path.join(CHEMIN_CHECKPOINTS, f\"oof_{nom}_fold_{fold}.f32\")\n _predict_to_memmap(model, xva, path, DEVICE, CV_BATCH_SIZE * 2)\n fmax, smin = _validate_fold_scores(path, (len(va), len(liste_termes)), Y_train[va].tocsr())\n result[\"fmax_ia\"].append(float(fmax[\"fmax\"])); result[\"smin_ia\"].append(float(smin[\"smin\"])); result[\"oof_files\"].append(path)\n del model, xtr, xva; gc.collect()\n if torch.cuda.is_available(): torch.cuda.empty_cache()\n return result\n\nRUN_OOF_ABLATIONS = False\nif RUN_OOF_ABLATIONS:\n ablations_oof = {\n \"without_curriculum\": executer_ablation_oof(\"without_curriculum\", utiliser_curriculum=False),\n \"without_ia\": executer_ablation_oof(\"without_ia\", utiliser_ia=False),\n }\n rows = [comparer_ablation_appariee(resultats_cv[\"fmax_ia\"], value[\"fmax_ia\"], key)\n for key, value in ablations_oof.items()]\n ablation_statistics = holm_bonferroni(pd.DataFrame(rows))\n display(ablation_statistics)\n\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.656861Z","iopub.status.idle":"2026-07-31T20:16:21.657128Z","shell.execute_reply.started":"2026-07-31T20:16:21.656969Z","shell.execute_reply":"2026-07-31T20:16:21.656981Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module V34 - Production Protocol\n\nThe executable production path is ESM-2/LoRA cached embeddings, DAGNet, IA-aware loss,\nCSR mini-batches, leakage-free fold scaling, disk-backed OOF predictions, and streaming\nsubmission. The heterogeneous GNN and MAML are deliberately removed from execution.\n","metadata":{}},{"cell_type":"code","source":"\n# V34 preflight: run this before CV.\nassert not ENABLE_GNN and not ENABLE_MAML\nassert sp.isspmatrix_csr(Y_train)\nassert len(splits_cv) == N_FOLDS\nfor fold, (tr, va) in enumerate(splits_cv):\n assert not set(groupes_taxo[tr]).intersection(set(groupes_taxo[va])), f\"taxonomy leakage in fold {fold}\"\nprint(\"[V34] Preflight passed. ESM-2/LoRA caches are preserved; GNN/MAML are excluded.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.658031Z","iopub.status.idle":"2026-07-31T20:16:21.658318Z","shell.execute_reply.started":"2026-07-31T20:16:21.6582Z","shell.execute_reply":"2026-07-31T20:16:21.658217Z"}},"outputs":[],"execution_count":null},{"cell_type":"markdown","source":"# Module V35 - Homology-safe splits and OOF statistics\n\nFinal evaluation groups are connected components induced jointly by taxonomy and\nhomology clusters. A cluster file must be supplied for publication-grade CV; a\ntaxonomy-only split is labelled development-only. Ablations use matched OOF folds;\nuncertainty uses a protein bootstrap over the pooled OOF predictions.\n","metadata":{}},{"cell_type":"code","source":"\n# MODULE V35 - HOMOLOGY-SAFE SPLITS, OOF ABLATIONS, BOOTSTRAP AND PAIRED TESTS\nimport os\nimport numpy as np\nimport pandas as pd\nfrom pathlib import Path\nfrom scipy.stats import wilcoxon\n\nHOMOLOGY_CLUSTER_PATH = os.environ.get(\"CAFA6_HOMOLOGY_CLUSTERS\", \"\")\nREQUIRE_HOMOLOGY_FOR_FINAL_CV = True\nN_FOLDS = globals().get(\"N_FOLDS\", 5)\n\nclass _UnionFind:\n def __init__(self, n): self.parent = np.arange(n, dtype=np.int64); self.rank = np.zeros(n, dtype=np.int8)\n def find(self, x):\n while self.parent[x] != x:\n self.parent[x] = self.parent[self.parent[x]]; x = self.parent[x]\n return x\n def union(self, a, b):\n a, b = self.find(a), self.find(b)\n if a == b: return\n if self.rank[a] < self.rank[b]: a, b = b, a\n self.parent[b] = a\n if self.rank[a] == self.rank[b]: self.rank[a] += 1\n\ndef charger_clusters_homologie(path, accessions):\n \"\"\"Read an MMseqs `cluster.tsv` or a two-column accession/cluster TSV.\n\n MMseqs commonly stores representative then member; both orientation choices\n yield the same connected components. Every absent accession becomes a singleton.\n \"\"\"\n path = Path(path)\n if not path.is_file():\n raise FileNotFoundError(f\"Homology cluster file not found: {path}\")\n raw = pd.read_csv(path, sep=\"\\t\", header=None, comment=\"#\", dtype=str, usecols=[0, 1])\n raw.columns = [\"cluster\", \"protein\"]\n known = set(map(str, accessions))\n raw = raw[raw.protein.isin(known)]\n mapping = dict(zip(raw.protein, raw.cluster))\n return np.asarray([mapping.get(str(acc), f\"singleton::{acc}\") for acc in accessions], dtype=object)\n\ndef groupes_fermeture_taxonomie_homologie(accessions, taxons, clusters):\n \"\"\"Keep both same-taxon and homologous proteins in the same fold.\n\n This is stricter than either grouping alone. If a huge connected component is\n produced, the experiment must be redesigned rather than silently leaking.\n \"\"\"\n n = len(accessions); uf = _UnionFind(n); first_taxon, first_cluster = {}, {}\n for i, (taxon, cluster) in enumerate(zip(map(str, taxons), map(str, clusters))):\n for key, registry in ((taxon, first_taxon), (cluster, first_cluster)):\n previous = registry.setdefault(key, i)\n uf.union(i, previous)\n roots = np.asarray([uf.find(i) for i in range(n)])\n _, groups = np.unique(roots, return_inverse=True)\n return groups.astype(str)\n\ndef auditer_splits_homologie(splits, groups, taxons, clusters, y_csr):\n rows = []\n for fold, (tr, va) in enumerate(splits):\n group_overlap = set(groups[tr]) & set(groups[va])\n cluster_overlap = set(clusters[tr]) & set(clusters[va])\n taxon_overlap = set(taxons[tr]) & set(taxons[va])\n support_tr = np.asarray(y_csr[tr].sum(axis=0)).ravel()\n support_va = np.asarray(y_csr[va].sum(axis=0)).ravel()\n rows.append({\"fold\": fold, \"n_train\": len(tr), \"n_val\": len(va),\n \"group_overlap\": len(group_overlap), \"homology_overlap\": len(cluster_overlap),\n \"taxon_overlap\": len(taxon_overlap),\n \"terms_absent_train\": int((support_tr == 0).sum()),\n \"terms_absent_val\": int((support_va == 0).sum())})\n assert not group_overlap and not cluster_overlap and not taxon_overlap, f\"Leakage in fold {fold}\"\n audit = pd.DataFrame(rows)\n print(audit.to_string(index=False))\n return audit\n\ndef construire_splits_final_homologie(accessions, taxons, y_csr, cluster_path=HOMOLOGY_CLUSTER_PATH,\n n_splits=N_FOLDS, require_homology=REQUIRE_HOMOLOGY_FOR_FINAL_CV):\n if not cluster_path:\n if require_homology:\n raise RuntimeError(\"Final CV requires CAFA6_HOMOLOGY_CLUSTERS (MMseqs/CD-HIT TSV).\")\n groups = np.asarray(taxons, dtype=str); clusters = np.asarray([f\"unknown::{x}\" for x in accessions])\n print(\"[SPLIT] DEVELOPMENT ONLY: taxonomy groups without homology clusters.\")\n else:\n clusters = charger_clusters_homologie(cluster_path, accessions)\n groups = groupes_fermeture_taxonomie_homologie(accessions, taxons, clusters)\n sizes = pd.Series(groups).value_counts()\n n_groups = len(sizes)\n if n_groups < 2:\n raise RuntimeError(f\"Invalid constrained groups: n_groups={n_groups}\")\n effective_n_splits = min(int(n_splits), n_groups)\n if effective_n_splits < 2:\n raise RuntimeError(f\"Insufficient groups for cross-validation: n_groups={n_groups}\")\n splitter = GroupKFold(n_splits=effective_n_splits)\n splits = list(splitter.split(np.zeros(len(accessions)), groups=groups))\n audit = auditer_splits_homologie(splits, groups, np.asarray(taxons), clusters, y_csr)\n return splits, groups, clusters, audit\n\ndef construire_oof_memmap(resultats_cv, n_proteins, n_terms, path):\n \"\"\"Assemble each held-out fold exactly once into a disk-backed OOF matrix.\"\"\"\n out = np.memmap(path, mode=\"w+\", dtype=np.float32, shape=(n_proteins, n_terms))\n filled = np.zeros(n_proteins, dtype=bool)\n for (_, va), fold_path in zip(resultats_cv[\"folds\"], resultats_cv[\"oof_files\"]):\n if filled[va].any(): raise ValueError(\"OOF fold overlap\")\n fold = np.memmap(fold_path, mode=\"r\", dtype=np.float32, shape=(len(va), n_terms))\n out[va] = fold; filled[va] = True\n if not filled.all(): raise ValueError(\"Missing OOF predictions\")\n out.flush(); return out\n\ndef _cafa_protein_statistics(predictions, y_csr, ia, thresholds=SEUILS_CAFA, chunk=1024):\n \"\"\"Sufficient protein-level IA statistics for exact bootstrap Fmax/Smin.\"\"\"\n n, c = predictions.shape; t = len(thresholds); ia = np.asarray(ia, dtype=np.float32)\n true = np.zeros(n, dtype=np.float32); pred = np.zeros((t, n), dtype=np.float32)\n tp = np.zeros((t, n), dtype=np.float32); ru = np.zeros((t, n), dtype=np.float32); mi = np.zeros((t, n), dtype=np.float32)\n for start in range(0, n, chunk):\n stop = min(start + chunk, n); y = y_csr[start:stop].toarray().astype(bool, copy=False); p = predictions[start:stop]\n true[start:stop] = (y * ia).sum(axis=1)\n for k, threshold in enumerate(thresholds):\n selected = p >= threshold\n pred[k, start:stop] = (selected * ia).sum(axis=1)\n tp[k, start:stop] = ((selected & y) * ia).sum(axis=1)\n ru[k, start:stop] = ((y & ~selected) * ia).sum(axis=1)\n mi[k, start:stop] = ((selected & ~y) * ia).sum(axis=1)\n return true, pred, tp, ru, mi\n\ndef bootstrap_oof_cafa(predictions, y_csr, ia, n_boot=1000, confidence=0.95, seed=SEED_GLOBAL):\n \"\"\"Protein bootstrap over pooled OOF; avoids copying N x C once per replicate.\"\"\"\n true, pred, tp, ru, mi = _cafa_protein_statistics(predictions, y_csr, ia)\n rng = np.random.default_rng(seed); n = len(true); fmax, smin = [], []\n for _ in range(n_boot):\n ids = rng.integers(0, n, n)\n p, h, r = pred[:, ids], tp[:, ids], true[ids]\n present = p > 0; annotated = r > 0\n precision = np.divide(h, p, out=np.zeros_like(h), where=present)\n recall = np.divide(h, r[None, :], out=np.zeros_like(h), where=annotated[None, :])\n p_avg = np.divide((precision * present).sum(axis=1), present.sum(axis=1), out=np.zeros(len(SEUILS_CAFA)), where=present.sum(axis=1)>0)\n r_avg = np.divide((recall * annotated).sum(axis=1), max(int(annotated.sum()), 1))\n fs = np.divide(2*p_avg*r_avg, p_avg+r_avg, out=np.zeros_like(p_avg), where=(p_avg+r_avg)>0)\n fmax.append(float(fs.max()))\n distances = np.sqrt(ru[:, ids].mean(axis=1)**2 + mi[:, ids].mean(axis=1)**2)\n smin.append(float(distances.min()))\n alpha = (1 - confidence) / 2\n return {\"fmax\": np.asarray(fmax), \"smin\": np.asarray(smin),\n \"fmax_ci\": tuple(np.quantile(fmax, [alpha, 1-alpha])),\n \"smin_ci\": tuple(np.quantile(smin, [alpha, 1-alpha]))}\n\ndef comparer_ablation_appariee(scores_reference, scores_ablation, name=\"ablation\"):\n \"\"\"Paired fold test plus exact sign-flip enumeration; n=5 is reported, never oversold.\"\"\"\n ref, abl = np.asarray(scores_reference, float), np.asarray(scores_ablation, float)\n assert ref.shape == abl.shape and ref.size == N_FOLDS\n delta = ref - abl\n statistic, p_wilcoxon = wilcoxon(delta, alternative=\"two-sided\", method=\"auto\")\n signs = np.array(np.meshgrid(*[[-1, 1]] * len(delta))).T.reshape(-1, len(delta))\n observed = abs(delta.mean()); p_signflip = np.mean(np.abs((signs * delta).mean(axis=1)) >= observed)\n return {\"comparison\": name, \"n_folds\": int(len(delta)), \"mean_delta_fmax\": float(delta.mean()),\n \"median_delta_fmax\": float(np.median(delta)), \"wilcoxon_statistic\": float(statistic),\n \"wilcoxon_pvalue\": float(p_wilcoxon), \"exact_signflip_pvalue\": float(p_signflip)}\n\ndef holm_bonferroni(table, p_column=\"wilcoxon_pvalue\"):\n out = table.copy(); order = np.argsort(out[p_column].to_numpy()); m = len(out); adjusted = np.empty(m)\n running = 0.0\n for rank, idx in enumerate(order):\n running = max(running, (m-rank) * out.iloc[idx][p_column]); adjusted[idx] = min(running, 1.0)\n out[\"p_holm\"] = adjusted; return out\n\ndef executer_ablation_oof(nom, utiliser_curriculum=True, utiliser_ia=True, epochs=CV_EPOCHS):\n \"\"\"Train one ablation on the exact production folds and return matched OOF scores.\"\"\"\n result = {\"name\": nom, \"fmax_ia\": [], \"smin_ia\": [], \"oof_files\": [], \"folds\": list(splits_cv)}\n for fold, (tr, va) in enumerate(splits_cv):\n scaler = StandardScaler().fit(X_train[tr])\n xtr = scaler.transform(X_train[tr]).astype(np.float32, copy=False)\n xva = scaler.transform(X_train[va]).astype(np.float32, copy=False)\n model = creer_modele_ia_aware(dim_totale, DAGNET_HIDDEN, DAGNET_N_BLOCKS,\n len(liste_termes), DAGNET_DROPOUT, IA_N_HEADS, IA_HIDDEN, vec_ia)\n entrainer_modele(model, xtr, Y_train[tr].tocsr(), xva, Y_train[va].tocsr(),\n ia_tens=torch.as_tensor(vec_ia, dtype=torch.float32), n_termes=len(liste_termes),\n n_epoques=epochs, patience=PATIENCE, fold_courant=fold, device=DEVICE,\n utiliser_curriculum=utiliser_curriculum, utiliser_ia=utiliser_ia)\n path = os.path.join(CHEMIN_CHECKPOINTS, f\"oof_{nom}_fold_{fold}.f32\")\n _predict_to_memmap(model, xva, path, DEVICE, CV_BATCH_SIZE * 2)\n fmax, smin = _validate_fold_scores(path, (len(va), len(liste_termes)), Y_train[va].tocsr())\n result[\"fmax_ia\"].append(float(fmax[\"fmax\"])); result[\"smin_ia\"].append(float(smin[\"smin\"])); result[\"oof_files\"].append(path)\n del model, xtr, xva; gc.collect()\n if torch.cuda.is_available(): torch.cuda.empty_cache()\n return result\n\nRUN_OOF_ABLATIONS = False\nif RUN_OOF_ABLATIONS:\n ablations_oof = {\n \"without_curriculum\": executer_ablation_oof(\"without_curriculum\", utiliser_curriculum=False),\n \"without_ia\": executer_ablation_oof(\"without_ia\", utiliser_ia=False),\n }\n rows = [comparer_ablation_appariee(resultats_cv[\"fmax_ia\"], value[\"fmax_ia\"], key)\n for key, value in ablations_oof.items()]\n ablation_statistics = holm_bonferroni(pd.DataFrame(rows))\n display(ablation_statistics)\n\nprint(\"[V35] Attach an MMseqs/CD-HIT cluster TSV and call construire_splits_final_homologie before final CV.\")\nprint(\"[V35] After matched OOF ablation runs, call bootstrap_oof_cafa and comparer_ablation_appariee.\")\n","metadata":{"trusted":true,"execution":{"iopub.status.busy":"2026-07-31T20:16:21.659349Z","iopub.status.idle":"2026-07-31T20:16:21.659634Z","shell.execute_reply.started":"2026-07-31T20:16:21.659493Z","shell.execute_reply":"2026-07-31T20:16:21.659505Z"}},"outputs":[],"execution_count":null}]}