PyTDC (Therapeutics Data Commons)

Aperçu

PyTDC est une plateforme de science ouverte fournissant des datasets et benchmarks prêts pour l'IA en découverte et développement de médicaments. Accédez à des datasets curés couvrant l'ensemble du pipeline thérapeutique avec des métriques d'évaluation standardisées et des splits de données significatifs, organisés en trois catégories : prédiction à instance unique (propriétés moléculaires/protéiques), prédiction à instances multiples (interactions drogue-cible, DDI) et génération (génération de molécules, rétrosynthèse).

Quand utiliser cette skill

Cette skill doit être utilisée quand :

• Travailler avec des datasets de découverte de médicaments ou ML thérapeutique
• Benchmarker des modèles de machine learning sur des tâches pharmaceutiques standardisées
• Prédire des propriétés moléculaires (ADME, toxicité, bioactivité)
• Prédire des interactions drogue-cible ou drogue-drogue
• Générer de nouvelles molécules avec des propriétés désirées
• Accéder à des datasets curés avec des splits train/test appropriés (scaffold, cold-split)
• Utiliser des oracles moléculaires pour l'optimisation de propriétés

Installation et configuration

Installez PyTDC avec pip :

uv pip install PyTDC

Pour mettre à jour vers la dernière version :

uv pip install PyTDC --upgrade

Dépendances principales (installées automatiquement) :

• numpy, pandas, tqdm, seaborn, scikit_learn, fuzzywuzzy

Des packages supplémentaires sont installés automatiquement selon les besoins pour des fonctionnalités spécifiques.

Démarrage rapide

Le modèle de base pour accéder à tout dataset TDC suit cette structure :

from tdc.<problem> import <Task>
data = <Task>(name='<Dataset>')
split = data.get_split(method='scaffold', seed=1, frac=[0.7, 0.1, 0.2])
df = data.get_data(format='df')

Où :

• <problem> : Un de single_pred, multi_pred, ou generation
• <Task> : Catégorie de tâche spécifique (ex. ADME, DTI, MolGen)
• <Dataset> : Nom du dataset dans cette tâche

Exemple - Charger des données ADME :

from tdc.single_pred import ADME
data = ADME(name='Caco2_Wang')
split = data.get_split(method='scaffold')
# Retourne un dict avec les DataFrames 'train', 'valid', 'test'

Tâches de prédiction à instance unique

La prédiction à instance unique implique de prévoir des propriétés d'entités biomédicales individuelles (molécules, protéines, etc.).

Catégories de tâches disponibles

1. ADME (Absorption, Distribution, Métabolisme, Excrétion)

Prédire les propriétés pharmacocinétiques des molécules de médicaments.

from tdc.single_pred import ADME
data = ADME(name='Caco2_Wang')  # Perméabilité intestinale
# Autres datasets : HIA_Hou, Bioavailability_Ma, Lipophilicity_AstraZeneca, etc.

Datasets ADME courants :

• Caco2 - Perméabilité intestinale
• HIA - Absorption intestinale humaine
• Bioavailability - Biodisponibilité orale
• Lipophilicity - Coefficient de partition octanol-eau
• Solubility - Solubilité aqueuse
• BBB - Pénétration de la barrière hémato-encéphalique
• CYP - Métabolisme du cytochrome P450

2. Toxicity (Tox)

Prédire la toxicité et les effets indésirables des composés.

from tdc.single_pred import Tox
data = Tox(name='hERG')  # Cardiotoxicité
# Autres datasets : AMES, DILI, Carcinogens_Lagunin, etc.

Datasets de toxicité courants :

• hERG - Toxicité cardiaque
• AMES - Mutagénicité
• DILI - Lésion hépatique induite par un médicament
• Carcinogens - Cancérogénicité
• ClinTox - Toxicité d'essai clinique

3. HTS (High-Throughput Screening)

Prédictions de bioactivité à partir de données de criblage.

from tdc.single_pred import HTS
data = HTS(name='SARSCoV2_Vitro_Touret')

4. QM (Quantum Mechanics)

Propriétés de mécanique quantique des molécules.

from tdc.single_pred import QM
data = QM(name='QM7')

5. Autres tâches de prédiction simple

• Yields : Prédiction du rendement des réactions chimiques
• Epitope : Prédiction d'épitope pour les biologiques
• Develop : Prédictions au stade du développement
• CRISPROutcome : Prédiction des résultats de l'édition génique

Format des données

Les datasets de prédiction simple retournent typiquement des DataFrames avec des colonnes :

• Drug_ID ou Compound_ID : Identifiant unique
• Drug ou X : Chaîne SMILES ou représentation moléculaire
• Y : Étiquette cible (continue ou binaire)

Tâches de prédiction à instances multiples

La prédiction à instances multiples implique de prévoir des propriétés d'interactions entre plusieurs entités biomédicales.

Catégories de tâches disponibles

1. DTI (Drug-Target Interaction)

Prédire l'affinité de liaison entre les médicaments et les cibles protéiques.

from tdc.multi_pred import DTI
data = DTI(name='BindingDB_Kd')
split = data.get_split()

Datasets disponibles :

• BindingDB_Kd - Constante de dissociation (52 284 paires)
• BindingDB_IC50 - Concentration inhibitrice demi-maximale (991 486 paires)
• BindingDB_Ki - Constante d'inhibition (375 032 paires)
• DAVIS, KIBA - Datasets de liaison kinase

Format des données : Drug_ID, Target_ID, Drug (SMILES), Target (séquence), Y (affinité de liaison)

2. DDI (Drug-Drug Interaction)

Prédire les interactions entre paires de médicaments.

from tdc.multi_pred import DDI
data = DDI(name='DrugBank')
split = data.get_split()

Tâche de classification multi-classe prédisant les types d'interaction. Le dataset contient 191 808 paires DDI avec 1 706 médicaments.

3. PPI (Protein-Protein Interaction)

Prédire les interactions protéine-protéine.

from tdc.multi_pred import PPI
data = PPI(name='HuRI')

4. Autres tâches multi-prédiction

• GDA : Associations gène-maladie
• DrugRes : Prédiction de résistance aux médicaments
• DrugSyn : Prédiction de synergie médicamenteuse
• PeptideMHC : Liaison peptide-MHC
• AntibodyAff : Prédiction d'affinité d'anticorps
• MTI : Interactions miRNA-cible
• Catalyst : Prédiction de catalyseur
• TrialOutcome : Prédiction des résultats d'essai clinique

Tâches de génération

Les tâches de génération impliquent de créer de nouvelles entités biomédicales avec les propriétés désirées.

1. Génération moléculaire (MolGen)

Générer des molécules diverses et novatrices avec des propriétés chimiques souhaitables.

from tdc.generation import MolGen
data = MolGen(name='ChEMBL_V29')
split = data.get_split()

À utiliser avec des oracles pour optimiser vers des propriétés spécifiques :

from tdc import Oracle
oracle = Oracle(name='GSK3B')
score = oracle('CC(C)Cc1ccc(cc1)C(C)C(O)=O')  # Évaluer SMILES

Voir references/oracles.md pour toutes les fonctions oracle disponibles.

2. Rétrosynthèse (RetroSyn)

Prédire les réactifs nécessaires pour synthétiser une molécule cible.

from tdc.generation import RetroSyn
data = RetroSyn(name='USPTO')
split = data.get_split()

Le dataset contient 1 939 253 réactions de la base de données USPTO.

3. Génération de molécules appariées

Générer des paires de molécules (ex. paires prodigue-médicament).

from tdc.generation import PairMolGen
data = PairMolGen(name='Prodrug')

Pour la documentation oracle détaillée et les workflows de génération moléculaire, consultez references/oracles.md et scripts/molecular_generation.py.

Groupes de benchmarks

Les groupes de benchmarks fournissent des collections curées de datasets connexes pour l'évaluation systématique des modèles.

Groupe de benchmarks ADMET

from tdc.benchmark_group import admet_group
group = admet_group(path='data/')

# Obtenir les datasets de benchmark
benchmark = group.get('Caco2_Wang')
predictions = {}

for seed in [1, 2, 3, 4, 5]:
    train, valid = benchmark['train'], benchmark['valid']
    # Entraîner le modèle ici
    predictions[seed] = model.predict(benchmark['test'])

# Évaluer avec les 5 seeds requis
results = group.evaluate(predictions)

Le groupe ADMET comprend 22 datasets couvrant l'absorption, la distribution, le métabolisme, l'excrétion et la toxicité.

Autres groupes de benchmarks

Les groupes de benchmarks disponibles incluent des collections pour :

• Propriétés ADMET
• Interactions drogue-cible
• Prédiction de combinaisons de médicaments
• Et d'autres tâches thérapeutiques spécialisées

Pour les workflows d'évaluation des benchmarks, voir scripts/benchmark_evaluation.py.

Fonctions de données

TDC fournit des utilitaires complets de traitement de données organisés en quatre catégories.

1. Splits de dataset

Récupérer les partitions train/validation/test avec différentes stratégies :

# Split scaffold (par défaut pour la plupart des tâches)
split = data.get_split(method='scaffold', seed=1, frac=[0.7, 0.1, 0.2])

# Split aléatoire
split = data.get_split(method='random', seed=42, frac=[0.8, 0.1, 0.1])

# Cold split (pour les tâches DTI/DDI)
split = data.get_split(method='cold_drug', seed=1)  # Médicaments non vus dans le test
split = data.get_split(method='cold_target', seed=1)  # Cibles non vues dans le test

Stratégies de split disponibles :

• random : Mélange aléatoire
• scaffold : Basé sur le scaffold (pour la diversité chimique)
• cold_drug, cold_target, cold_drug_target : Pour les tâches DTI
• temporal : Splits temporels pour les datasets temporels

2. Évaluation de modèles

Utiliser les métriques standardisées pour l'évaluation :

from tdc import Evaluator

# Pour la classification binaire
evaluator = Evaluator(name='ROC-AUC')
score = evaluator(y_true, y_pred)

# Pour la régression
evaluator = Evaluator(name='RMSE')
score = evaluator(y_true, y_pred)

Métriques disponibles : ROC-AUC, PR-AUC, F1, Accuracy, RMSE, MAE, R2, Spearman, Pearson, et plus.

3. Traitement des données

TDC fournit 11 utilitaires clés de traitement :

from tdc.chem_utils import MolConvert

# Conversion de format de molécule
converter = MolConvert(src='SMILES', dst='PyG')
pyg_graph = converter('CC(C)Cc1ccc(cc1)C(C)C(O)=O')

Les utilitaires de traitement incluent :

• Conversion de format de molécule (SMILES, SELFIES, PyG, DGL, ECFP, etc.)
• Filtres de molécules (PAINS, ressemblance à un médicament)
• Binarisation d'étiquettes et conversion d'unités
• Équilibrage de données (surécchantillonnage/sous-échantillonnage)
• Échantillonnage négatif pour les données appariées
• Transformation de graphes
• Récupération d'entités (CID vers SMILES, UniProt vers séquence)

Pour la documentation complète des utilitaires, voir references/utilities.md.

4. Oracles de génération de molécules

TDC fournit 17+ fonctions oracle pour l'optimisation moléculaire :

from tdc import Oracle

# Oracle unique
oracle = Oracle(name='DRD2')
score = oracle('CC(C)Cc1ccc(cc1)C(C)C(O)=O')

# Oracles multiples
oracle = Oracle(name='JNK3')
scores = oracle(['SMILES1', 'SMILES2', 'SMILES3'])

Pour la documentation oracle complète, voir references/oracles.md.

Fonctionnalités avancées

Récupérer les datasets disponibles

from tdc.utils import retrieve_dataset_names

# Obtenir tous les datasets ADME
adme_datasets = retrieve_dataset_names('ADME')

# Obtenir tous les datasets DTI
dti_datasets = retrieve_dataset_names('DTI')

Transformations d'étiquettes

# Obtenir le mappage d'étiquettes
label_map = data.get_label_map(name='DrugBank')

# Convertir les étiquettes
from tdc.chem_utils import label_transform
transformed = label_transform(y, from_unit='nM', to_unit='p')

Requêtes de base de données

from tdc.utils import cid2smiles, uniprot2seq

# Convertir PubChem CID vers SMILES
smiles = cid2smiles(2244)

# Convertir l'ID UniProt vers la séquence d'acides aminés
sequence = uniprot2seq('P12345')

Workflows courants

Workflow 1 : Entraîner un modèle de prédiction simple

Voir scripts/load_and_split_data.py pour un exemple complet :

from tdc.single_pred import ADME
from tdc import Evaluator

# Charger les données
data = ADME(name='Caco2_Wang')
split = data.get_split(method='scaffold', seed=42)

train, valid, test = split['train'], split['valid'], split['test']

# Entraîner le modèle (l'utilisateur implémente)
# model.fit(train['Drug'], train['Y'])

# Évaluer
evaluator = Evaluator(name='MAE')
# score = evaluator(test['Y'], predictions)

Workflow 2 : Évaluation de benchmark

Voir scripts/benchmark_evaluation.py pour un exemple complet avec plusieurs seeds et le protocole d'évaluation approprié.

Workflow 3 : Génération moléculaire avec oracles

Voir scripts/molecular_generation.py pour un exemple de génération dirigée par objectif utilisant des fonctions oracle.

Ressources

Cette skill inclut des ressources bundlées pour les workflows TDC courants :

scripts/

• load_and_split_data.py : Modèle pour charger et diviser les datasets TDC avec différentes stratégies
• benchmark_evaluation.py : Modèle pour exécuter les évaluations des groupes de benchmarks avec le protocole 5-seeds approprié
• molecular_generation.py : Modèle pour la génération moléculaire utilisant les fonctions oracle

references/

• datasets.md : Catalogue complet de tous les datasets disponibles organisés par type de tâche
• oracles.md : Documentation complète de tous les 17+ oracles de génération moléculaire
• utilities.md : Guide détaillé des utilitaires de traitement de données, de split et d'évaluation

Ressources supplémentaires

• Site officiel : https://tdcommons.ai
• Documentation : https://tdc.readthedocs.io
• GitHub : https://github.com/mims-harvard/TDC
• Article : NeurIPS 2021 - "Therapeutics Data Commons: Machine Learning Datasets and Tasks for Drug Discovery and Development"