deepchem

Par mkurman · zorai

npx skills add https://github.com/mkurman/zorai --skill deepchem

name: deepchem description: ML moléculaire avec des featurizers variés et des datasets pré-construits. À utiliser pour la prédiction de propriétés (ADMET, toxicité) avec du ML traditionnel ou des GNNs si vous cherchez des options étendues de featurization et les benchmarks MoleculeNet. Idéal pour des expériences rapides avec des modèles pré-entraînés, diverses représentations moléculaires. Pour les workflows PyTorch orientés graphes, utilisez torchdrug ; pour les datasets de benchmark, utilisez pytdc. license: MIT license tags: [molecular-ml, drug-discovery, cheminformatics-ml, toxicity-prediction, deepchem] metadata: skill-author: K-Dense Inc. ----------|------|-------------------|------------| | < 1K samples | N'importe lequel | SklearnModel (RandomForest) | CircularFingerprint | | 1K-100K | Classification/Régression | GBDTModel ou MultitaskRegressor | CircularFingerprint | | > 100K | Propriétés moléculaires | GCNModel, AttentiveFPModel, DMPNNModel | MolGraphConvFeaturizer | | N'importe lequel (petit de préférence) | Transfer learning | ChemBERTa, GROVER, MolFormer | Spécifique au modèle | | Structures cristallines | Propriétés des matériaux | CGCNNModel, MEGNetModel | Structure-based | | Séquences protéiques | Propriétés protéiques | ProtBERT | Sequence-based |

Exemple : ML traditionnel

from sklearn.ensemble import RandomForestRegressor

# Encapsuler le modèle scikit-learn
sklearn_model = RandomForestRegressor(n_estimators=100)
model = dc.models.SklearnModel(model=sklearn_model)
model.fit(train)

Exemple : Deep Learning

# Régresseur multitâche (pour les fingerprints)
model = dc.models.MultitaskRegressor(
    n_tasks=2,
    n_features=2048,
    layer_sizes=[1000, 500],
    dropouts=0.25,
    learning_rate=0.001
)
model.fit(train, nb_epoch=50)

Exemple : Réseaux de neurones graphiques

# Graph Convolutional Network
model = dc.models.GCNModel(
    n_tasks=1,
    mode='regression',
    batch_size=128,
    learning_rate=0.001
)
model.fit(train, nb_epoch=50)

# Graph Attention Network
model = dc.models.GATModel(n_tasks=1, mode='classification')
model.fit(train, nb_epoch=50)

# Attentive Fingerprint
model = dc.models.AttentiveFPModel(n_tasks=1, mode='regression')
model.fit(train, nb_epoch=50)

5. Benchmarks MoleculeNet

Accès rapide à plus de 30 datasets de benchmark curés avec des splits train/valid/test standardisés :

# Charger le dataset de benchmark
tasks, datasets, transformers = dc.molnet.load_tox21(
    featurizer='GraphConv',  # ou 'ECFP', 'Weave', 'Raw'
    splitter='scaffold',     # ou 'random', 'stratified'
    reload=False
)
train, valid, test = datasets

# Entraîner et évaluer
model = dc.models.GCNModel(n_tasks=len(tasks), mode='classification')
model.fit(train, nb_epoch=50)

metric = dc.metrics.Metric(dc.metrics.roc_auc_score)
test_score = model.evaluate(test, [metric])

Datasets courants :

  • Classification : load_tox21(), load_bbbp(), load_hiv(), load_clintox()
  • Régression : load_delaney(), load_freesolv(), load_lipo()
  • Propriétés quantiques : load_qm7(), load_qm8(), load_qm9()
  • Matériaux : load_perovskite(), load_bandgap(), load_mp_formation_energy()

Voir references/api_reference.md pour la liste complète des datasets.

6. Transfer Learning

Exploiter les modèles pré-entraînés pour améliorer les performances, particulièrement sur petits datasets :

# ChemBERTa (BERT pré-entraîné sur 77M molécules)
model = dc.models.HuggingFaceModel(
    model='seyonec/ChemBERTa-zinc-base-v1',
    task='classification',
    n_tasks=1,
    learning_rate=2e-5  # LR plus basse pour fine-tuning
)
model.fit(train, nb_epoch=10)

# GROVER (graph transformer pré-entraîné sur 10M molécules)
model = dc.models.GroverModel(
    task='regression',
    n_tasks=1
)
model.fit(train, nb_epoch=20)

Quand utiliser le transfer learning :

  • Datasets petits (< 1 000 samples)
  • Scaffolds moléculaires nouveaux
  • Ressources de calcul limitées
  • Besoin de prototypage rapide

Utilisez le script scripts/transfer_learning.py pour des workflows guided transfer learning.

7. Évaluation des modèles

# Définir les métriques
classification_metrics = [
    dc.metrics.Metric(dc.metrics.roc_auc_score, name='ROC-AUC'),
    dc.metrics.Metric(dc.metrics.accuracy_score, name='Accuracy'),
    dc.metrics.Metric(dc.metrics.f1_score, name='F1')
]

regression_metrics = [
    dc.metrics.Metric(dc.metrics.r2_score, name='R²'),
    dc.metrics.Metric(dc.metrics.mean_absolute_error, name='MAE'),
    dc.metrics.Metric(dc.metrics.root_mean_squared_error, name='RMSE')
]

# Évaluer
train_scores = model.evaluate(train, classification_metrics)
test_scores = model.evaluate(test, classification_metrics)

8. Faire des prédictions

# Prédire sur le test set
predictions = model.predict(test)

# Prédire sur de nouvelles molécules
new_smiles = ['CCO', 'c1ccccc1', 'CC(C)O']
new_features = featurizer.featurize(new_smiles)
new_dataset = dc.data.NumpyDataset(X=new_features)

# Appliquer les mêmes transformations qu'à l'entraînement
for transformer in transformers:
    new_dataset = transformer.transform(new_dataset)

predictions = model.predict(new_dataset)

Workflows typiques

Workflow A : Évaluation rapide sur benchmark

Pour évaluer un modèle sur des benchmarks standards :

import deepchem as dc

# 1. Charger le benchmark
tasks, datasets, _ = dc.molnet.load_bbbp(
    featurizer='GraphConv',
    splitter='scaffold'
)
train, valid, test = datasets

# 2. Entraîner le modèle
model = dc.models.GCNModel(n_tasks=len(tasks), mode='classification')
model.fit(train, nb_epoch=50)

# 3. Évaluer
metric = dc.metrics.Metric(dc.metrics.roc_auc_score)
test_score = model.evaluate(test, [metric])
print(f"Test ROC-AUC: {test_score}")

Workflow B : Prédiction sur données personnalisées

Pour entraîner sur des datasets moléculaires personnalisés :

import deepchem as dc

# 1. Charger et featuriser les données
featurizer = dc.feat.CircularFingerprint(radius=2, size=2048)
loader = dc.data.CSVLoader(
    tasks=['activity'],
    feature_field='smiles',
    featurizer=featurizer
)
dataset = loader.create_dataset('my_molecules.csv')

# 2. Diviser les données (utiliser ScaffoldSplitter pour les molécules !)
splitter = dc.splits.ScaffoldSplitter()
train, valid, test = splitter.train_valid_test_split(dataset)

# 3. Normaliser (optionnel mais recommandé)
transformers = [dc.trans.NormalizationTransformer(
    transform_y=True, dataset=train
)]
for transformer in transformers:
    train = transformer.transform(train)
    valid = transformer.transform(valid)
    test = transformer.transform(test)

# 4. Entraîner le modèle
model = dc.models.MultitaskRegressor(
    n_tasks=1,
    n_features=2048,
    layer_sizes=[1000, 500],
    dropouts=0.25
)
model.fit(train, nb_epoch=50)

# 5. Évaluer
metric = dc.metrics.Metric(dc.metrics.r2_score)
test_score = model.evaluate(test, [metric])

Workflow C : Transfer Learning sur petit dataset

Pour exploiter les modèles pré-entraînés :

import deepchem as dc

# 1. Charger les données (les modèles pré-entraînés ont souvent besoin du SMILES brut)
loader = dc.data.CSVLoader(
    tasks=['activity'],
    feature_field='smiles',
    featurizer=dc.feat.DummyFeaturizer()  # Le modèle gère la featurization
)
dataset = loader.create_dataset('small_dataset.csv')

# 2. Diviser les données
splitter = dc.splits.ScaffoldSplitter()
train, test = splitter.train_test_split(dataset)

# 3. Charger le modèle pré-entraîné
model = dc.models.HuggingFaceModel(
    model='seyonec/ChemBERTa-zinc-base-v1',
    task='classification',
    n_tasks=1,
    learning_rate=2e-5
)

# 4. Fine-tuner
model.fit(train, nb_epoch=10)

# 5. Évaluer
predictions = model.predict(test)

Voir references/workflows.md pour 8 exemples de workflows détaillés couvrant la génération moléculaire, la science des matériaux, l'analyse protéique, et plus.

Scripts d'exemple

Cette skill inclut trois scripts production-ready dans le répertoire scripts/ :

1. predict_solubility.py

Entraîner et évaluer des modèles de prédiction de solubilité. Fonctionne avec le benchmark Delaney ou des données CSV personnalisées.

# Utiliser le benchmark Delaney
python scripts/predict_solubility.py

# Utiliser des données personnalisées
python scripts/predict_solubility.py \
    --data my_data.csv \
    --smiles-col smiles \
    --target-col solubility \
    --predict "CCO" "c1ccccc1"

2. graph_neural_network.py

Entraîner diverses architectures de réseaux de neurones graphiques sur des données moléculaires.

# Entraîner GCN sur Tox21
python scripts/graph_neural_network.py --model gcn --dataset tox21

# Entraîner AttentiveFP sur des données personnalisées
python scripts/graph_neural_network.py \
    --model attentivefp \
    --data molecules.csv \
    --task-type regression \
    --targets activity \
    --epochs 100

3. transfer_learning.py

Fine-tuner les modèles pré-entraînés (ChemBERTa, GROVER) sur des tâches de prédiction de propriétés moléculaires.

# Fine-tuner ChemBERTa sur BBBP
python scripts/transfer_learning.py --model chemberta --dataset bbbp

# Fine-tuner GROVER sur des données personnalisées
python scripts/transfer_learning.py \
    --model grover \
    --data small_dataset.csv \
    --target activity \
    --task-type classification \
    --epochs 20

Patterns courants et bonnes pratiques

Pattern 1 : Toujours utiliser Scaffold Splitting pour les molécules

# BON : Prévient les fuites de données
splitter = dc.splits.ScaffoldSplitter()
train, test = splitter.train_test_split(dataset)

# MAUVAIS : Molécules similaires dans train et test
splitter = dc.splits.RandomSplitter()
train, test = splitter.train_test_split(dataset)

Pattern 2 : Normaliser les features et cibles

transformers = [
    dc.trans.NormalizationTransformer(
        transform_y=True,  # Normaliser aussi les valeurs cible
        dataset=train
    )
]
for transformer in transformers:
    train = transformer.transform(train)
    test = transformer.transform(test)

Pattern 3 : Commencer simple, puis scaler

  1. Commencer avec Random Forest + CircularFingerprint (baseline rapide)
  2. Essayer XGBoost/LightGBM si RF fonctionne bien
  3. Passer au deep learning (MultitaskRegressor) si vous avez >5 000 samples
  4. Essayer les GNNs si vous avez >10 000 samples
  5. Utiliser le transfer learning pour les petits datasets ou nouveaux scaffolds

Pattern 4 : Gérer les données déséquilibrées

# Option 1 : Balancing transformer
transformer = dc.trans.BalancingTransformer(dataset=train)
train = transformer.transform(train)

# Option 2 : Utiliser des métriques équilibrées
metric = dc.metrics.Metric(dc.metrics.balanced_accuracy_score)

Pattern 5 : Éviter les problèmes de mémoire

# Utiliser DiskDataset pour les grands datasets
dataset = dc.data.DiskDataset.from_numpy(X, y, w, ids)

# Utiliser des batch sizes plus petits
model = dc.models.GCNModel(batch_size=32)  # Au lieu de 128

Pièges courants

Problème 1 : Fuite de données en drug discovery

Problème : Utiliser un splitting aléatoire permet aux molécules similaires d'être dans train/test. Solution : Toujours utiliser ScaffoldSplitter pour les datasets moléculaires.

Problème 2 : GNN qui sous-performe vs fingerprints

Problème : Les réseaux de neurones graphiques performent pire que les fingerprints simples. Solutions :

  • S'assurer que le dataset est assez grand (>10 000 samples typiquement)
  • Augmenter les epochs d'entraînement (50-100)
  • Essayer différentes architectures (AttentiveFP, DMPNN au lieu de GCN)
  • Utiliser les modèles pré-entraînés (GROVER)

Problème 3 : Overfitting sur petits datasets

Problème : Le modèle mémorise les données d'entraînement. Solutions :

  • Utiliser une régularisation plus forte (augmenter dropout à 0,5)
  • Utiliser des modèles plus simples (Random Forest au lieu de deep learning)
  • Appliquer le transfer learning (ChemBERTa, GROVER)
  • Collecter plus de données

Problème 4 : Erreurs d'import

Problème : Erreurs « Module not found ». Solution : S'assurer que DeepChem est installé avec les dépendances requises :

uv pip install deepchem
# Pour les modèles PyTorch
uv pip install deepchem[torch]
# Pour toutes les features
uv pip install deepchem[all]

Documentation de référence

Cette skill inclut une documentation de référence complète :

references/api_reference.md

Documentation API complète incluant :

  • Tous les data loaders et leurs cas d'usage
  • Classes Dataset et quand utiliser chacune
  • Catalogue complet des featurizers avec guide de sélection
  • Catalogue des modèles organisé par catégorie (50+ modèles)
  • Descriptions des datasets MoleculeNet
  • Métriques et fonctions d'évaluation
  • Patterns de code courants

Quand consulter : Chercher dans ce fichier quand vous avez besoin de détails API spécifiques, noms de paramètres, ou quand vous voulez explorer les options disponibles.

references/workflows.md

Huit workflows end-to-end détaillés :

  1. Prédiction de propriétés moléculaires à partir de SMILES
  2. Utiliser les benchmarks MoleculeNet
  3. Optimisation d'hyperparamètres
  4. Transfer learning avec modèles pré-entraînés
  5. Génération moléculaire avec GANs
  6. Prédiction de propriétés des matériaux
  7. Analyse de séquences protéiques
  8. Intégration de modèles personnalisés

Quand consulter : Utiliser ces workflows comme templates pour implémenter des solutions complètes.

Notes d'installation

Installation basique :

uv pip install deepchem

Pour les modèles PyTorch (GCN, GAT, etc.) :

uv pip install deepchem[torch]

Pour toutes les features :

uv pip install deepchem[all]

Si des erreurs d'import surviennent, l'utilisateur peut avoir besoin de dépendances spécifiques. Consulter la documentation DeepChem pour les instructions d'installation détaillées.

Ressources supplémentaires

Skills similaires

torchdrug
mkurman / zorai

Appliquer des GNN et modèles pré-entraînés à la découverte de molécules et protéines.

309