deepchem
Deep learning for drug discovery. 60+ models (GCN, GAT, AttentiveFP, MPNN, ChemBERTa, GROVER), 50+ featurizers, MoleculeNet benchmarks, HPO, transfer learning. Unified load-featurize-split-train-evaluate API. For fingerprints use rdkit-cheminformatics; for featurization-only use molfeat.
Install / Use
npx skills add jaechang-hits/SciAgent-Skills --skill deepchemInstalls into whichever agent you are using.
SKILL.md
Installable skill definition
Quality Score
Category
AI & Machine LearningSupported Platforms
Our assessment of deepchem
deepchem scores 91/100 on our quality scale, 343rd of 944 AI & Machine Learning skills we index (top 37%).
Its SKILL.md is 23 KB long, well organised into 71 sections with 17 code examples: a thorough specification that gives an agent plenty to work with.
It has 367 GitHub stars, a meaningful sign that others use it.
Maintenance, license and trust
- The repository was last updated about 3 months ago, so deepchem is actively maintained.
- Our last check on 2026-11-20 found the source still online.
- No license is declared. By default that means all rights are reserved: you can read it, but reusing or redistributing it is not clearly permitted. Ask the author before building on it commercially.
- Its trust signals score 88/100, with 1 caution from licensing, adoption, age or documentation. These come from repository metadata, not a code audit — read the skill file before letting an agent act on it.
Safety scan
No issues foundOur scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.
AI review by kimi-k2.7-code on 2026-10-07. Automated pattern scan on 2026-10-07. It catches known dangerous patterns, not every risk — read a skill before letting an agent act on it.
deepchem compared with similar skills
All 4 of these similar skills score higher than deepchem; compare them before choosing.
| Skill | Score | Stars | Updated | Format |
|---|---|---|---|---|
| deepchem (this skill)by jaechang-hits | 91 | 367 | 3mo ago | SKILL.md |
| claude-memby thedotmack | 100 | 118.5k | today | CLAUDE.md |
| Agent-Reachby Panniantong | 100 | 113.3k | 12d ago | CLAUDE.md |
| Understand-Anythingby Egonex-AI | 100 | 93.3k | 1d ago | CLAUDE.md |
| headroomby headroomlabs-ai | 100 | 80.2k | today | CLAUDE.md |
Frequently asked questions
- How do I install deepchem?
- Run
npx skills add jaechang-hits/SciAgent-Skills --skill deepchem. The install tabs above show the steps for each supported agent. - Which AI agents does deepchem work with?
- It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
- Is deepchem safe to use?
- Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It declares no license and scores 88/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
- Is deepchem still maintained?
- The repository was last updated about 3 months ago, so deepchem is actively maintained.
Skill content
View source on GitHubname: deepchem description: "Deep learning for drug discovery. 60+ models (GCN, GAT, AttentiveFP, MPNN, ChemBERTa, GROVER), 50+ featurizers, MoleculeNet benchmarks, HPO, transfer learning. Unified load-featurize-split-train-evaluate API. For fingerprints use rdkit-cheminformatics; for featurization-only use molfeat." license: MIT
DeepChem — Deep Learning for Drug Discovery
Overview
DeepChem is an open-source Python framework providing a unified API for molecular machine learning across drug discovery, materials science, and quantum chemistry. It wraps 60+ model architectures (graph neural networks, transformers, classical ML) with 50+ molecular featurizers and standardized datasets (MoleculeNet), enabling end-to-end workflows from SMILES strings to trained predictive models.
When to Use
- Predicting molecular properties (solubility, toxicity, binding affinity) from SMILES
- Benchmarking models on MoleculeNet standardized datasets (BBBP, Tox21, ESOL, FreeSolv, etc.)
- Training graph neural networks on molecular graphs (GCN, GAT, AttentiveFP, MPNN, DMPNN)
- Fine-tuning pretrained chemical language models (ChemBERTa, GROVER, MolFormer)
- Running hyperparameter optimization for molecular ML models
- Virtual screening and hit prioritization with trained models
- Materials property prediction from crystal structures (CGCNN, MEGNet)
- Protein-ligand interaction modeling and binding affinity prediction
- For fingerprint-based cheminformatics without deep learning, use
rdkit-cheminformaticsinstead - For featurization only (no model training), use
molfeat-molecular-featurizationinstead
Prerequisites
- Python packages:
deepchem(core),torchortensorflow(backend-dependent models) - GPU: Recommended for graph neural networks and transformer models; CPU sufficient for classical ML and fingerprint models
- Data: SMILES strings with property labels (CSV), or MoleculeNet datasets (auto-downloaded)
# Core installation (includes RDKit, scikit-learn, XGBoost)
pip install deepchem
# With PyTorch backend (GNN models)
pip install deepchem[torch]
# With TensorFlow backend (legacy models)
pip install deepchem[tensorflow]
# Full installation (all backends + extras)
pip install deepchem[all]
Quick Start
import deepchem as dc
# Load MoleculeNet dataset with featurization + scaffold split
tasks, datasets, transformers = dc.molnet.load_delaney(featurizer="ECFP")
train, valid, test = datasets
# Train and evaluate a multitask regressor
model = dc.models.MultitaskRegressor(n_tasks=1, n_features=1024, dropouts=0.2)
model.fit(train, nb_epoch=50)
metric = dc.metrics.Metric(dc.metrics.pearson_r2_score)
print(f"Test R2: {model.evaluate(test, [metric])}") # {'pearson_r2_score': ~0.7}
Core API
Module 1: Data Loading and Processing
Load molecular data from CSV files or MoleculeNet benchmark datasets.
import deepchem as dc
# Load from CSV (SMILES + property columns)
loader = dc.data.CSVLoader(
tasks=["measured_log_solubility"],
feature_field="smiles",
featurizer=dc.feat.CircularFingerprint(size=2048, radius=3)
)
dataset = loader.create_dataset("solubility_data.csv")
print(f"Samples: {dataset.X.shape[0]}, Features: {dataset.X.shape[1]}")
# Samples: 1128, Features: 2048
# Load from SDF (3D structures)
sdf_loader = dc.data.SDFLoader(
tasks=["activity"],
featurizer=dc.feat.CoulombMatrix(max_atoms=50)
)
dataset_3d = sdf_loader.create_dataset("molecules.sdf")
# Load MoleculeNet benchmark datasets (auto-download + featurize + split)
# Available: load_delaney, load_bbbp, load_tox21, load_hiv, load_qm7, load_qm9, etc.
tasks, datasets, transformers = dc.molnet.load_tox21(featurizer="ECFP", splitter="scaffold")
train, valid, test = datasets
print(f"Tasks: {len(tasks)}, Train: {len(train)}, Test: {len(test)}")
# Tasks: 12, Train: ~6264, Test: ~631
# Inverse-transform predictions back to original scale
y_pred = model.predict(test)
y_original = transformers[0].untransform(y_pred)
Module 2: Molecular Featurization
Convert molecules to numerical representations for ML. DeepChem provides 50+ featurizers spanning fingerprints, descriptors, graph features, and Coulomb matrices.
import deepchem as dc
smiles = ["CCO", "CC(=O)O", "c1ccccc1", "CC(C)O"]
# Fingerprints (most common for classical ML)
ecfp = dc.feat.CircularFingerprint(size=2048, radius=3)
fp_features = ecfp.featurize(smiles)
print(f"ECFP shape: {fp_features.shape}") # (4, 2048)
# RDKit descriptors (interpretable physicochemical properties)
rdkit_desc = dc.feat.RDKitDescriptors()
desc_features = rdkit_desc.featurize(smiles)
print(f"Descriptor shape: {desc_features.shape}") # (4, 208)
# Graph features (for GNN models — returns ConvMol objects)
graph_feat = dc.feat.ConvMolFeaturizer()
graphs = graph_feat.featurize(smiles)
print(f"Atoms in first mol: {graphs[0].get_num_atoms()}") # 3
# Mol2Vec embeddings (pretrained word2vec on molecular substructures)
mol2vec = dc.feat.Mol2VecFingerprint()
embeddings = mol2vec.featurize(smiles)
print(f"Mol2Vec shape: {embeddings.shape}") # (4, 300)
Module 3: Model Training and Evaluation
DeepChem provides MultitaskRegressor and MultitaskClassifier as general-purpose models, plus specialized architectures for graph and sequence data.
import deepchem as dc
# Load dataset
tasks, datasets, transformers = dc.molnet.load_delaney(featurizer="ECFP")
train, valid, test = datasets
# Regression model (fingerprint input)
model = dc.models.MultitaskRegressor(
n_tasks=1,
n_features=1024,
layer_sizes=[1000, 500],
dropouts=0.25,
learning_rate=0.001,
batch_size=64,
)
model.fit(train, nb_epoch=100)
# Evaluate with multiple metrics
metrics = [
dc.metrics.Metric(dc.metrics.pearson_r2_score),
dc.metrics.Metric(dc.metrics.mean_absolute_error),
dc.metrics.Metric(dc.metrics.rms_score),
]
results = model.evaluate(test, metrics)
print(f"R2: {results['pearson_r2_score']:.3f}, MAE: {results['mean_absolute_error']:.3f}")
# Classification model (e.g., Tox21 toxicity prediction)
tasks, datasets, transformers = dc.molnet.load_tox21(featurizer="ECFP")
train, valid, test = datasets
clf = dc.models.MultitaskClassifier(
n_tasks=len(tasks),
n_features=1024,
layer_sizes=[1000, 500],
dropouts=0.5,
learning_rate=0.001,
)
clf.fit(train, nb_epoch=50)
roc_metric = dc.metrics.Metric(dc.metrics.roc_auc_score, np.mean)
print(f"Mean ROC-AUC: {clf.evaluate(test, [roc_metric])}")
Module 4: Graph Neural Networks
GNNs operate directly on molecular graphs (atoms as nodes, bonds as edges), avoiding information loss from fixed fingerprints.
import deepchem as dc
# Load with graph featurizer
tasks, datasets, transformers = dc.molnet.load_delaney(featurizer="GraphConv")
train, valid, test = datasets
# Graph Convolutional Network (Duvenaud et al.)
gcn_model = dc.models.GraphConvModel(
n_tasks=1,
mode="regression",
graph_conv_layers=[64, 64],
dense_layer_size=256,
dropout=0.2,
learning_rate=0.001,
batch_size=64,
)
gcn_model.fit(train, nb_epoch=100)
metric = dc.metrics.Metric(dc.metrics.pearson_r2_score)
print(f"GCN R2: {gcn_model.evaluate(test, [metric])}")
# AttentiveFP (Xiong et al.) — attention-based GNN, strong on molecular properties
tasks, datasets, transformers = dc.molnet.load_delaney(
featurizer=dc.feat.MolGraphConvFeaturizer(use_edges=True)
)
train, valid, test = datasets
attfp_model = dc.models.AttentiveFPModel(
n_tasks=1,
mode="regression",
num_layers=2,
graph_feat_size=200,
num_timesteps=2,
dropout=0.2,
learning_rate=0.001,
batch_size=64,
)
attfp_model.fit(train, nb_epoch=100)
print(f"AttentiveFP R2: {attfp_model.evaluate(test, [metric])}")
Module 5: Transfer Learning
Fine-tune pretrained chemical language models for downstream tasks with limited data.
import deepchem as dc
from deepchem.models.torch_models import ChemBERTaModel
# ChemBERTa — SMILES-based transformer (pretrained on 77M molecules)
tasks, datasets, transformers = dc.molnet.load_bbbp(featurizer=dc.feat.SmilesTokenizer())
train, valid, test = datasets
chemberta = ChemBERTaModel(
task="classification",
n_tasks=1,
model_dir="chemberta_finetuned/",
)
# Fine-tune on downstream task (BBB permeability)
chemberta.fit(train, nb_epoch=10)
metric = dc.metrics.Metric(dc.metrics.roc_auc_score)
print(f"ChemBERTa ROC-AUC: {chemberta.evaluate(test, [metric])}")
Module 6: Predictions on New Molecules
Run inference on new molecules with a trained model.
import deepchem as dc
import numpy as np
# Assume trained model from Module 3
# Featurize new molecules using same featurizer
featurizer = dc.feat.CircularFingerprint(size=1024, radius=2)
new_smiles = ["c1cc(O)ccc1", "CC(=O)Nc1ccc(O)cc1", "OC(=O)c1ccccc1"]
new_features = featurizer.featurize(new_smiles)
new_dataset = dc.data.NumpyDataset(X=new_features)
predictions = model.predict(new_dataset)
for smi, pred in zip(new_smiles, predictions):
print(f"{smi}: {pred[0]:.2f}")
# Ensemble predictions from multiple models for robustness
models = [model1, model2, model3] # trained models
all_preds = np.array([m.predict(new_dataset) for m in models])
ensemble_mean = all_preds.mean(axis=0)
ensemble_std = all_preds.std(axis=0)
print(f"Ensemble prediction: {ensemble_mean[0][0]:.2f} +/- {ensemble_std[0][0]:.2f}")
Key Concepts
Unified API Pattern
All DeepChem workflows follow a consistent 5-step pattern:
Load Data → Featurize → Split → Train → Evaluate
- Load:
CSVLoader,SDFLoader, ordc.molnet.load_*()(auto-loads MoleculeNet datasets) - Featurize: Pass featurizer to loader, or call
featurizer.featurize(smiles)directly - Split:
ScaffoldSplitter(recommended for drug discovery),RandomSplitter,ButinaSplitter - Train:
model.fit(train_dataset, nb_epoch=N) - Evaluate:
model.evaluate(test_dataset, metrics_list)
Model Selection Guide
| Data Type | Model | Key Feature | Use When |
|-----------|-------|-------------|----------|
| SMILES + fingerprints | MultitaskRegressor | Fast, baseline | First attempt, small datasets |
| SMILES + fingerprints | MultitaskClassifier | Multi-label | Multi-task classification (Tox21) |
| Molecular graphs | GraphConvModel | Learned fingerprints | Medium datasets, general properties |
| Molecular graphs | GATModel | Attention mechanism | When atom importance matters |
| Molecular graphs | AttentiveFPModel | Graph + timestep attention | State-of-art molecular properties |
| Molecular graphs | MPNNModel | Message passing | Complex molecular interactions |
| Molecular graphs | DMPNNModel | Directed MPNN | Bond-level predictions |
| SMILES strings | ChemBERTaModel | Pretrained transformer | Low-data regime, transfer learning |
| SMILES strings | GROVERModel | Graph + transformer | Rich molecular representations |
| Crystal structures | CGCNNModel | Crystal graph CNN | Materials property prediction |
| Crystal structures | MEGNetModel | Graph networks | Materials and molecules |
| Protein sequences | ProteinLigandComplexModel | Complex modeling | Binding affinity prediction |
| Tabular features | XGBoostModel, RandomForestModel | Classical ML | Interpretability, baselines |
Featurizer Selection Guide
| Featurizer | Class | Output | Best For |
|------------|-------|--------|----------|
| ECFP/Morgan | CircularFingerprint | Binary vector (1024-2048) | General QSAR, fast baselines |
| MACCS Keys | MACCSKeysFingerprint | 167-bit vector | Substructure filtering |
| RDKit 2D | RDKitDescriptors | 200+ descriptors | Interpretable models |
| Mol2Vec | Mol2VecFingerprint | 300-dim embedding | Similarity, clustering |
| ConvMol | ConvMolFeaturizer | Graph features | GraphConvModel input |
| MolGraph | MolGraphConvFeaturizer | Node + edge features
Truncated for display — read the full file on GitHub.
Related Skills
claude-mem
118.5kPersistent Context Across Sessions for Every Agent – Captures everything your agent does during sessions, compresses it with AI, and injects relevant context back into future sessions. Works with Claude Code, OpenClaw, Codex, Gemini, Hermes, Copilot, OpenCode + More
Agent-Reach
113.3kGive your AI agent eyes to see the entire internet. Read & search Twitter, Reddit, YouTube, GitHub, Bilibili, XiaoHongShu — one CLI, zero API fees.
Understand-Anything
93.3kGraphs that teach > graphs that impress. Turn any code into an interactive knowledge graph you can explore, search, and ask questions about. Works with Claude Code, Codex, Cursor, Copilot, Gemini CLI, and more.
headroom
80.2kCompress tool outputs, logs, files, and RAG chunks before they reach the LLM. 20% fewer tokens for coding agents, 60-95% fewer tokens for JSON, same answers. Library, proxy, MCP server.
Languages
Trust signals
From repository metadata: license, adoption, age and documentation. Not a code audit — see the Safety scan above for what the skill file itself contains.
