TorchDrug

Aperçu

TorchDrug est une boîte à outils complète d'apprentissage automatique basée sur PyTorch pour la découverte de médicaments et les sciences moléculaires. Appliquez des réseaux de neurones graphiques, des modèles pré-entraînés et des définitions de tâches aux molécules, protéines et graphes de connaissances biologiques, y compris la prédiction de propriétés moléculaires, la modélisation de protéines, le raisonnement sur graphes de connaissances, la génération moléculaire, la planification rétrosynthétique, avec plus de 40 jeux de données curés et plus de 20 architectures de modèles.

Quand utiliser cette compétence

Cette compétence doit être utilisée avec :

Types de données :

• Chaînes SMILES ou structures moléculaires
• Séquences de protéines ou structures 3D (fichiers PDB)
• Réactions chimiques et rétrosynthèse
• Graphes de connaissances biomédicaux
• Jeux de données de découverte de médicaments

Tâches :

• Prédiction de propriétés moléculaires (solubilité, toxicité, activité)
• Prédiction de fonction ou structure de protéine
• Prédiction de liaison drogue-cible
• Génération de nouvelles structures moléculaires
• Planification de routes de synthèse chimique
• Prédiction de liens dans des bases de connaissances biomédicales
• Entraînement de réseaux de neurones graphiques sur des données scientifiques

Bibliothèques et intégration :

• TorchDrug est la bibliothèque principale
• Souvent utilisé avec RDKit pour la chémoinformatique
• Compatible avec PyTorch et PyTorch Lightning
• S'intègre avec AlphaFold et ESM pour les protéines

Démarrage

Installation

uv pip install torchdrug
# Ou avec dépendances optionnelles
uv pip install torchdrug[full]

Exemple rapide

from torchdrug import datasets, models, tasks
from torch.utils.data import DataLoader

# Charger un jeu de données moléculaire
dataset = datasets.BBBP("~/molecule-datasets/")
train_set, valid_set, test_set = dataset.split()

# Définir un modèle GNN
model = models.GIN(
    input_dim=dataset.node_feature_dim,
    hidden_dims=[256, 256, 256],
    edge_input_dim=dataset.edge_feature_dim,
    batch_norm=True,
    readout="mean"
)

# Créer une tâche de prédiction de propriété
task = tasks.PropertyPrediction(
    model,
    task=dataset.tasks,
    criterion="bce",
    metric=["auroc", "auprc"]
)

# Entraîner avec PyTorch
optimizer = torch.optim.Adam(task.parameters(), lr=1e-3)
train_loader = DataLoader(train_set, batch_size=32, shuffle=True)

for epoch in range(100):
    for batch in train_loader:
        loss = task(batch)
        optimizer.zero_grad()
        loss.backward()
        optimizer.step()

Capacités principales

1. Prédiction de propriétés moléculaires

Prédisez les propriétés chimiques, physiques et biologiques des molécules à partir de leur structure.

Cas d'utilisation :

• Propriétés de ressemblance à des médicaments et ADMET
• Criblage de toxicité
• Propriétés de chimie quantique
• Prédiction d'affinité de liaison

Composants clés :

• 20+ jeux de données moléculaires (BBBP, HIV, Tox21, QM9, etc.)
• Modèles GNN (GIN, GAT, SchNet)
• Tâches PropertyPrediction et MultipleBinaryClassification

Référence : Voir references/molecular_property_prediction.md pour :

• Catalogue complet des jeux de données
• Guide de sélection de modèles
• Flux de travail d'entraînement et meilleures pratiques
• Détails d'ingénierie des features

2. Modélisation de protéines

Travaillez avec des séquences, structures et propriétés de protéines.

Cas d'utilisation :

• Prédiction de fonction enzymatique
• Stabilité et solubilité des protéines
• Localisation subcellulaire
• Interactions protéine-protéine
• Prédiction de structure

Composants clés :

• 15+ jeux de données protéiques (EnzymeCommission, GeneOntology, PDBBind, etc.)
• Modèles de séquence (ESM, ProteinBERT, ProteinLSTM)
• Modèles de structure (GearNet, SchNet)
• Plusieurs types de tâches pour différents niveaux de prédiction

Référence : Voir references/protein_modeling.md pour :

• Jeux de données spécifiques aux protéines
• Modèles de séquence vs modèles de structure
• Stratégies de pré-entraînement
• Intégration avec AlphaFold et ESM

3. Raisonnement sur graphes de connaissances

Prédisez les liens et relations manquants dans les graphes de connaissances biologiques.

Cas d'utilisation :

• Repositionnement de médicaments
• Découverte de mécanismes de maladies
• Associations gène-maladie
• Raisonnement biomédical multi-sauts

Composants clés :

• Graphes généraux (FB15k, WN18) et biomédicaux (Hetionet)
• Modèles d'embedding (TransE, RotatE, ComplEx)
• Tâche KnowledgeGraphCompletion

Référence : Voir references/knowledge_graphs.md pour :

• Jeux de données de graphes de connaissances (incluant Hetionet avec 45k entités biomédicales)
• Comparaison des modèles d'embedding
• Métriques d'évaluation et protocoles
• Applications biomédicales

4. Génération moléculaire

Générez de nouvelles structures moléculaires avec des propriétés désirées.

Cas d'utilisation :

• Conception de médicaments de novo
• Optimisation de leads
• Exploration d'espace chimique
• Génération guidée par les propriétés

Composants clés :

• Génération autorégrressive
• GCPN (génération basée sur des politiques)
• GraphAutoregressiveFlow
• Flux de travail d'optimisation de propriétés

Référence : Voir references/molecular_generation.md pour :

• Stratégies de génération (sans condition, conditionnelle, basée sur scaffold)
• Optimisation multi-objectif
• Validation et filtrage
• Intégration avec prédiction de propriétés

5. Rétrosynthèse

Prédisez les routes de synthèse à partir de molécules cibles jusqu'aux matières premières.

Cas d'utilisation :

• Planification de synthèse
• Optimisation d'itinéraire
• Évaluation d'accessibilité synthétique
• Planification multi-étapes

Composants clés :

• Jeu de données de réactions USPTO-50k
• CenterIdentification (prédiction du centre de réaction)
• SynthonCompletion (prédiction de réactif)
• Pipeline Retrosynthesis de bout en bout

Référence : Voir references/retrosynthesis.md pour :

• Décomposition de tâches (identification du centre → complément de synthons)
• Planification de synthèse multi-étapes
• Vérification de disponibilité commerciale
• Intégration avec d'autres outils de rétrosynthèse

6. Modèles de réseaux de neurones graphiques

Catalogue complet d'architectures GNN pour différents types de données et tâches.

Modèles disponibles :

• GNN généraux : GCN, GAT, GIN, RGCN, MPNN
• Conscients de la 3D : SchNet, GearNet
• Spécifiques aux protéines : ESM, ProteinBERT, GearNet
• Graphes de connaissances : TransE, RotatE, ComplEx, SimplE
• Génératifs : GraphAutoregressiveFlow

Référence : Voir references/models_architectures.md pour :

• Descriptions détaillées des modèles
• Guide de sélection de modèles par tâche et jeu de données
• Comparaisons d'architecture
• Conseils de mise en œuvre

7. Jeux de données

Plus de 40 jeux de données curés couvrant la chimie, la biologie et les graphes de connaissances.

Catégories :

• Propriétés moléculaires (découverte de médicaments, chimie quantique)
• Propriétés protéiques (fonction, structure, interactions)
• Graphes de connaissances (généraux et biomédicaux)
• Réactions de rétrosynthèse

Référence : Voir references/datasets.md pour :

• Catalogue complet des jeux de données avec tailles et tâches
• Guide de sélection de jeux de données
• Chargement et prétraitement
• Stratégies de fractionnement (aléatoire, scaffold)

Flux de travail courants

Flux de travail 1 : Prédiction de propriétés moléculaires

Scénario : Prédire la pénétration de la barrière hémato-encéphalique pour les candidats médicaments.

Étapes :

1. Charger un jeu de données : datasets.BBBP()
2. Choisir un modèle : GIN pour les graphes moléculaires
3. Définir une tâche : PropertyPrediction avec classification binaire
4. Entraîner avec fractionnement par scaffold pour une évaluation réaliste
5. Évaluer en utilisant AUROC et AUPRC

Navigation : references/molecular_property_prediction.md → Sélection de jeu de données → Sélection de modèle → Entraînement

Flux de travail 2 : Prédiction de fonction de protéine

Scénario : Prédire la fonction enzymatique à partir de la séquence.

Étapes :

1. Charger un jeu de données : datasets.EnzymeCommission()
2. Choisir un modèle : ESM (pré-entraîné) ou GearNet (avec structure)
3. Définir une tâche : PropertyPrediction avec classification multi-classe
4. Affiner le modèle pré-entraîné ou entraîner de zéro
5. Évaluer en utilisant la précision et les métriques par classe

Navigation : references/protein_modeling.md → Sélection de modèle (séquence vs structure) → Stratégies de pré-entraînement

Flux de travail 3 : Repositionnement de médicaments via graphes de connaissances

Scénario : Trouver de nouveaux traitements de maladies dans Hetionet.

Étapes :

1. Charger un jeu de données : datasets.Hetionet()
2. Choisir un modèle : RotatE ou ComplEx
3. Définir une tâche : KnowledgeGraphCompletion
4. Entraîner avec échantillonnage négatif
5. Interroger pour les prédictions « Compound-treats-Disease »
6. Filtrer par plausibilité et mécanisme

Navigation : references/knowledge_graphs.md → Jeu de données Hetionet → Sélection de modèle → Applications biomédicales

Flux de travail 4 : Génération de molécules de novo

Scénario : Générer des molécules ressemblant à des médicaments optimisées pour la liaison cible.

Étapes :

1. Entraîner un prédicteur de propriété sur des données d'activité
2. Choisir une approche de génération : GCPN pour optimisation basée sur RL
3. Définir une fonction de récompense combinant affinité, ressemblance à un médicament, synthétisabilité
4. Générer des candidats avec contraintes de propriétés
5. Valider la chimie et filtrer par ressemblance à un médicament
6. Classer par notation multi-objectif

Navigation : references/molecular_generation.md → Génération conditionnelle → Optimisation multi-objectif

Flux de travail 5 : Planification de rétrosynthèse

Scénario : Planifier une route de synthèse pour une molécule cible.

Étapes :

1. Charger un jeu de données : datasets.USPTO50k()
2. Entraîner un modèle d'identification du centre (RGCN)
3. Entraîner un modèle de complément de synthons (GIN)
4. Combiner dans un pipeline de rétrosynthèse de bout en bout
5. Appliquer récursivement pour la planification multi-étapes
6. Vérifier la disponibilité commerciale des blocs de construction

Navigation : references/retrosynthesis.md → Types de tâches → Planification multi-étapes

Modèles d'intégration

Avec RDKit

Convertir entre molécules TorchDrug et RDKit :

from torchdrug import data
from rdkit import Chem

# SMILES → molécule TorchDrug
smiles = "CCO"
mol = data.Molecule.from_smiles(smiles)

# TorchDrug → RDKit
rdkit_mol = mol.to_molecule()

# RDKit → TorchDrug
rdkit_mol = Chem.MolFromSmiles(smiles)
mol = data.Molecule.from_molecule(rdkit_mol)

Avec AlphaFold/ESM

Utiliser les structures prédites :

from torchdrug import data

# Charger une structure prédite par AlphaFold
protein = data.Protein.from_pdb("AF-P12345-F1-model_v4.pdb")

# Construire un graphe avec des arêtes spatiales
graph = protein.residue_graph(
    node_position="ca",
    edge_types=["sequential", "radius"],
    radius_cutoff=10.0
)

Avec PyTorch Lightning

Envelopper les tâches pour l'entraînement Lightning :

import pytorch_lightning as pl

class LightningTask(pl.LightningModule):
    def __init__(self, torchdrug_task):
        super().__init__()
        self.task = torchdrug_task

    def training_step(self, batch, batch_idx):
        return self.task(batch)

    def validation_step(self, batch, batch_idx):
        pred = self.task.predict(batch)
        target = self.task.target(batch)
        return {"pred": pred, "target": target}

    def configure_optimizers(self):
        return torch.optim.Adam(self.parameters(), lr=1e-3)

Détails techniques

Pour des approfondissements sur l'architecture de TorchDrug :

Concepts fondamentaux : Voir references/core_concepts.md pour :

• Philosophie d'architecture (modulaire, configurable)
• Structures de données (Graph, Molecule, Protein, PackedGraph)
• Interface de modèle et signature de fonction forward
• Interface de tâche (predict, target, forward, evaluate)
• Flux de travail d'entraînement et meilleures pratiques
• Fonctions de perte et métriques
• Pièges courants et débogage

Aide-mémoire de référence rapide

Choisir un jeu de données :

• Propriété moléculaire → references/datasets.md → section Moléculaire
• Tâche de protéine → references/datasets.md → section Protéine
• Graphe de connaissances → references/datasets.md → section Graphe de connaissances

Choisir un modèle :

• Molécules → references/models_architectures.md → section GNN → GIN/GAT/SchNet
• Protéines (séquence) → references/models_architectures.md → section Protéine → ESM
• Protéines (structure) → references/models_architectures.md → section Protéine → GearNet
• Graphe de connaissances → references/models_architectures.md → section KG → RotatE/ComplEx

Tâches courantes :

• Prédiction de propriété → references/molecular_property_prediction.md ou references/protein_modeling.md
• Génération → references/molecular_generation.md
• Rétrosynthèse → references/retrosynthesis.md
• Raisonnement KG → references/knowledge_graphs.md

Comprendre l'architecture :

• Structures de données → references/core_concepts.md → Structures de données
• Conception de modèle → references/core_concepts.md → Interface de modèle
• Conception de tâche → references/core_concepts.md → Interface de tâche

Dépannage des problèmes courants

Problème : Erreurs d'incompatibilité de dimensions → Vérifier que model.input_dim correspond à dataset.node_feature_dim → Voir references/core_concepts.md → Attributs essentiels

Problème : Mauvaises performances sur les tâches moléculaires → Utiliser le fractionnement par scaffold, pas aléatoire → Essayer GIN au lieu de GCN → Voir references/molecular_property_prediction.md → Meilleures pratiques

Problème : Le modèle de protéine n'apprend pas → Utiliser ESM pré-entraîné pour les tâches de séquence → Vérifier la construction des arêtes pour les modèles de structure → Voir references/protein_modeling.md → Flux de travail d'entraînement

Problème : Erreurs de mémoire avec des graphes volumineux → Réduire la taille du lot → Utiliser l'accumulation de gradients → Voir references/core_concepts.md → Efficacité mémoire

Problème : Les molécules générées sont invalides → Ajouter des contraintes de validité → Post-traiter avec validation RDKit → Voir references/molecular_generation.md → Validation et filtrage

Ressources

Documentation officielle : https://torchdrug.ai/docs/ GitHub : https://github.com/DeepGraphLearning/torchdrug Article : TorchDrug: A Powerful and Flexible Machine Learning Platform for Drug Discovery

Résumé

Naviguez vers le fichier de référence approprié en fonction de votre tâche :

1. Prédiction de propriétés moléculaires → molecular_property_prediction.md
2. Modélisation de protéines → protein_modeling.md
3. Graphes de connaissances → knowledge_graphs.md
4. Génération moléculaire → molecular_generation.md
5. Rétrosynthèse → retrosynthesis.md
6. Sélection de modèles → models_architectures.md
7. Sélection de jeux de données → datasets.md
8. Détails techniques → core_concepts.md

Chaque référence fournit une couverture complète de son domaine avec des exemples, des meilleures pratiques et des cas d'utilisation courants.