Chemprop

Chemprop webserver overview

Upload a CSV of 500 molecules with their measured aqueous solubility, and Chemprop returns a trained model about 40 seconds later, together with its predictions for the 50 molecules it held back and the error on them. Upload that model again with a list of molecules nobody has measured, and it predicts their solubility. That is the whole loop: your own measurements become a model that screens new structures before anyone makes them. Solubility is only an example; the same works for potency, toxicity, permeability, a yield or any value you have measured for a set of molecules.

Chemprop is a directed message passing neural network (D-MPNN). It reads each molecule as a graph of atoms and bonds, passes information along the bonds for a few steps, and combines what it learned into one vector per molecule, which a small feed-forward network turns into the prediction.

The method was introduced by Yang et al. (2019), and ProteinIQ runs Chemprop 2.3.1, described by Graff et al. (2026). It is the same model family behind ADMET-AI, which applies Chemprop models already trained on public ADMET data. Chemprop is for the case where the property you care about, or your own assay, is not covered by a pretrained model.

There are two tasks. Train a model fits regression, binary, multiclass or spectral models from a CSV of SMILES and values, with single or multiple targets, mixtures such as solute and solvent, atom-mapped reactions, ensembles and fine-tuning from the CheMeleon foundation model. Predict with a trained model applies one or more model files to new molecules and can add an uncertainty for each prediction.

Pricing

A job costs at least 20 credits, and most jobs cost exactly that. Above the floor, the quote follows the estimated run time: the number of rows times epochs times models for training, and the number of molecules times model files for prediction. The exact quote is shown before submission.

Training with the default model, at the default ensemble size of 1:

Training rows	10 epochs	50 epochs (default)	100 epochs	200 epochs
500	20	20	20	20
1,000	20	20	20	20
5,000	20	22	43	85
10,000	20	43	85	169
50,000	43	211	421	423

Training with the default 50 epochs and several ensemble members:

Training rows	1 model	3 models	5 models	10 models
1,000	20	20	22	43
5,000	22	64	106	211
10,000	43	127	211	421

Replicates multiply the price in the same way as ensemble members. Fine-tuning CheMeleon runs on a GPU and is priced separately:

Training rows	5 epochs	10 epochs	20 epochs	50 epochs
500	20	20	24	39
1,000	20	24	34	63
5,000	39	63	112	259
10,000	63	112	210	504

A foundation model file of your own is priced like CheMeleon. Prediction costs 20 credits up to about 300,000 molecules with one model file; 100,000 molecules cost 31 credits with 5 model files and 61 with 10, and Monte Carlo dropout counts each dropout sample like another model file. The architecture, batch size, task type, split and featurization settings do not change the price.

Each job runs for at most 4 hours. Default-model quotes stop growing at 423 credits, which corresponds to that limit; a job estimated at the cap will most likely stop at the time limit, and a job that fails is refunded.

Inputs

Input	Task	Description
Training data	Train	Required CSV with a header row, a SMILES column and one or more columns of measured values. Blank cells are missing values.
Validation data	Train	Optional CSV used as the validation set. Needs Test data as well.
Test data	Train	Optional CSV used as the test set. The training data is then split into training and validation only, so set the test fraction in Split sizes to 0.
Splits file	Train	Optional JSON list of splits with zero-based train, val and test row indices, such as [{"train": "0-79", "val": "80-89", "test": "90-99"}].
Checkpoint models	Train	Optional Chemprop .pt or .ckpt files whose weights start the training. One model is trained per file, and the architecture settings must match them.
Foundation model file	Train	Optional Chemprop .pt model whose message passing is reused with a new feed-forward network, instead of CheMeleon.
Molecules	Predict	Required CSV with a header row and the same SMILES columns the model was trained on. Other columns are kept in the predictions file.
Trained models	Predict	One or more Chemprop .pt or .ckpt files, such as best.pt from a training run. Several files are averaged as an ensemble.
Calibration data	Predict	Optional CSV with SMILES and measured values, used to calibrate the uncertainties.

CSV and JSON files can be uploaded up to 50 MiB or pasted as text. Model files can be up to 2,000 MiB each, and up to 100 files fit in Checkpoint models or Trained models. CSV files must end in .csv. Chemprop reads every CSV itself, so a misspelled column name or a SMILES that RDKit cannot parse stops the run with Chemprop's own error message.

Model files are checked before they are loaded. A file that contains anything other than Chemprop, PyTorch, Lightning and NumPy objects is refused, because loading a model file can otherwise run code. Files written by Chemprop 2 training runs pass this check.

Settings

Task chooses between Train a model and Predict with a trained model. The CSV column and featurization settings apply to both; the task, training, split, pretraining and architecture settings apply to training; the uncertainty settings apply to prediction. Every default is the Chemprop 2.3.1 default.

CSV columns

Parameter	Type	Default	Description
SMILES columns	string	first column	Columns holding SMILES, separated by commas. Two or more model mixtures such as solute and solvent, each with its own encoder.
Reaction columns	string	none	Columns holding atom-mapped reaction SMILES (REACTANT>AGENT>PRODUCT), featurized as a condensed graph of reaction.
Target columns	string	all remaining columns	Columns holding the values to learn. Train only.
Ignored columns	string	none	Columns left out when the target columns are chosen automatically. Train only.
Weight column	string	none	Column holding a loss weight for each row. Train only.
Split column	string	none	Column assigning each row to train, val or test, replacing the split method. Train only.
Descriptor columns	string	none	Columns of extra per-molecule values, such as temperature, added to the learned representation. Predict needs the same columns.
No header row	boolean	false	The first CSV row holds data, not column names.

Task and loss

Parameter	Type	Default	Description
Task type	enum	regression	regression, regression-mve, regression-evidential, regression-quantile, classification, classification-dirichlet, multiclass, multiclass-dirichlet or spectral. Classification targets are 0 or 1; multiclass targets are class indices.
Number of classes	integer	3	Classes for the multiclass types, at least 2.
Loss function	enum	task default	MSE for regression, binary cross-entropy for classification, cross-entropy for multiclass and SID for spectra unless another loss is chosen. Bounded losses read targets written as <value or >value.
Evidential regularization	number	0	Regularization of the evidential loss. Soleimany et al. (2021) recommend 0.2.
Evidential epsilon	number	1e-08	Epsilon of the evidential regularization.
Quantile interval alpha	number	0.1	Target error bound of the quantile interval loss, from 0 to 1.
Evaluation metrics	enum list	task default	Metrics reported on the validation and test sets, from mse, mae, rmse, the bounded variants, r2, binary-mcc, multiclass-mcc, roc, prc, accuracy and f1.
Tracking metric	string	val_loss	Metric watched for early stopping and for choosing the best epoch.
Task weights	string	equal	Loss weight for each target, separated by spaces or commas.
Class balance	boolean	false	Each batch holds equal numbers of positives and negatives. Binary classification only.
Per-target test scores	boolean	false	Also reports each target's test metrics, not only their average.

Training

Parameter	Type	Default	Description
Epochs	integer	50	Training epochs. Must be more than Warmup epochs.
Early stopping patience	integer	all epochs	Epochs without improvement before training stops.
Minimum improvement	number	0	Smallest change in the tracked metric that counts as an improvement.
Warmup epochs	integer	2	Epochs over which the learning rate rises from the initial to the maximum rate, before decaying to the final rate.
Initial learning rate	number	0.0001	Learning rate at the start of warmup.
Maximum learning rate	number	0.001	Learning rate at the end of warmup.
Final learning rate	number	0.0001	Learning rate at the last epoch.
Batch size	integer	64	Molecules per training batch.
Gradient clipping	number	none	Gradient norm at which gradients are clipped.
Ensemble size	integer	1	Models trained on each data split. Prediction averages them and can report their spread as uncertainty.
PyTorch seed	integer	random	Seed for weight initialization. Empty draws a new seed, so two runs give different models.

Data split

Parameter	Type	Default	Description
Split method	enum	RANDOM	RANDOM, SCAFFOLD_BALANCED, RANDOM_WITH_REPEATED_SMILES, KENNARD_STONE or KMEANS. Not used with a split column or splits file.
Split sizes	string	0.8, 0.1, 0.1	Training, validation and test fractions.
Split key molecule	integer	0	With several SMILES columns, the zero-based index of the molecule that scaffold and repeated-SMILES splits use.
Replicates	integer	1	Repeated trainings on different random splits, each with its own models.
Data seed	integer	0	Seed for splitting the data and shuffling batches.
Save SMILES of each split	boolean	false	Writes the SMILES of each set as CSV files.
Save rows of each split	boolean	false	Writes the input rows of each set as CSV files.

Foundation and transfer learning

Parameter	Type	Default	Description
Foundation model	enum	none	CHEMELEON starts message passing from CheMeleon and trains a new feed-forward network. Its own message-passing size, depth, activation and aggregation replace the architecture settings.
Freeze message passing	boolean	false	Keeps the message-passing weights of the checkpoint fixed. Needs Checkpoint models.
Frozen FFN layers	integer	0	Also keeps the first n feed-forward layers of the checkpoint fixed. Needs frozen message passing.

Model architecture

Parameter	Type	Default	Description
Message hidden size	string	300	Size of the hidden messages; one value per SMILES column sizes multicomponent encoders separately.
Message passing steps	string	3	Message-passing steps; one value per SMILES column sets each encoder.
Dropout	number	0	Dropout probability in the message-passing and feed-forward layers.
Aggregation	enum	norm	How atom representations are combined: norm, mean or sum.
Aggregation normalization	number	100	Divisor of the summed atom features in norm aggregation.
Activation	enum	RELU	Activation function, from the PyTorch activations such as RELU, GELU, SILU, TANH and LEAKYRELU.
Activation arguments	string	none	Arguments for the activation, such as negative_slope=0.1.
FFN hidden size	string	300	Width of the feed-forward hidden layers, one value or one per layer.
FFN hidden layers	integer	1	Hidden layers in the feed-forward network.
Message bias	boolean	false	Adds a bias term to the message-passing layers.
Undirected messages	boolean	false	Passes messages on undirected bonds.
Atom messages	boolean	false	Passes messages on atoms instead of bonds.
Shared encoder	boolean	false	Uses one message-passing network for every SMILES column.
Batch normalization	boolean	false	Applies batch normalization after aggregation.

Featurization

These settings apply to both tasks. A prediction must use the same featurization the model was trained with.

Parameter	Type	Default	Description
Atom features	enum	V2	V2, V1, ORGANIC or RIGR. CheMeleon needs V2.
Molecule descriptors	enum list	none	Molecule-level features added to the learned representation: morgan_binary, morgan_count, rdkit_2d, v1_rdkit_2d, v1_rdkit_2d_normalized or charge.
No descriptor scaling	boolean	false	Leaves extra descriptors unscaled. Chemprop advises this for Morgan fingerprints.
Reaction featurization	enum	REAC_DIFF	How reaction features are built: REAC_DIFF, REAC_PROD, PROD_DIFF or their _BALANCE variants for imbalanced reactions.
Keep explicit hydrogens	boolean	false	Keeps hydrogens written in the SMILES in the graph.
Add hydrogens	boolean	false	Adds hydrogens to the graph.
Ignore stereochemistry	boolean	false	Ignores R/S and cis/trans information.
Reorder atoms by map number	boolean	false	Orders atoms by their atom-map numbers.

Uncertainty

Parameter	Type	Default	Description
Uncertainty method	enum	none	ensemble, dropout, mve, evidential-total, evidential-epistemic, evidential-aleatoric, quantile-regression, classification, classification-dirichlet or multiclass-dirichlet.
Calibration method	enum	none	Calibrates the uncertainties on Calibration data: zscaling, zelikman-interval, mve-weighting or conformal-regression for regression; platt, isotonic or conformal-multilabel for classification; conformal-multiclass, conformal-adaptive or isotonic-multiclass for multiclass.
Uncertainty evaluation	enum list	none	Scores the uncertainties against measured values in the Molecules CSV, such as nll-regression, miscalibration_area, ence, spearman and the conformal coverage methods.
Dropout probability	number	0.1	Dropout probability for Monte Carlo dropout.
Dropout samples	integer	10	Number of Monte Carlo dropout samples.
Interval percentile	number	95	Percentile covered by zelikman-interval calibration.
Conformal alpha	number	0.1	Target error rate of conformal calibration.
Keep only SMILES and predictions	boolean	false	Removes the other input columns from the predictions file.

Outputs

Output	Task	Description
model_<i>/best.pt	Train	The trained model, one per ensemble member, inside replicate_<r>/ when there are several replicates. This is the file to use in Trained models.
model_<i>/test_predictions.csv	Train	The model's predictions for the test set, in Chemprop's own columns: the target columns hold predicted values.
model_<i>/trainer_logs/version_0/metrics.csv	Train	Training and validation loss and metrics for each epoch.
config.toml	Train	Every setting of the run, readable by Chemprop to repeat it.
splits.json	Train	The row indices of the training, validation and test sets.
train.csv, val.csv, test.csv and *_smiles.csv	Train	The rows or SMILES of each set, when the save switches are on.
preds.csv	Predict	The molecules CSV with a prediction column per target, and a <target>_unc column when an uncertainty method is set.
preds_individual.csv	Predict	Each model's prediction in its own column, when several model files are given.
chemprop.log, console.log	both	The Chemprop log and the full console output.
provenance.json	both	The exact command, the settings, SHA-256 hashes of the inputs and the run time.

After training, the Predictions table shows the test-set predictions of the first model and Test metrics lists each model's test metrics. After prediction, Predictions shows preds.csv, Each model shows the individual predictions, and Uncertainty evaluation lists the scores of any evaluation methods.

Typical run times, measured on ProteinIQ, are 10 to 20 seconds for a prediction of a few hundred molecules, about 40 seconds to train on 500 molecules for 50 epochs, and about 10 minutes for 42,000 rows at 5 epochs. CheMeleon fine-tuning of 4,200 molecules for 50 epochs takes about 15 minutes on the GPU.

Understanding results

The number to read first after training is the test metric. With no evaluation metric chosen, Chemprop reports mse (mean squared error) for regression and roc (ROC AUC) for binary classification. MSE is in the squared units of your target, so its square root is the typical error in the original units: an MSE of 0.75 on log solubility means predictions are off by about 0.9 log units on a typical molecule.

Judge it against the spread of the target itself. A model whose MSE equals the variance of the test-set values does no better than predicting the mean for every molecule; adding r2 to Evaluation metrics reports that comparison directly, with 1 for perfect predictions and 0 for the mean. A ROC AUC of 0.5 is chance and 1 ranks every active above every inactive.

The test set is small, so the metric is noisy. The default split holds back 10% of the rows, 50 molecules for a 500-molecule dataset, and a different random split can move the metric noticeably. Two ensemble members trained on the 500-molecule solubility example gave test MSEs of 0.80 and 0.72 on the same split. To see how much of a result is the split, set Replicates to 3 or 5 and compare the metrics across replicates.

A random split also flatters a model when the test set contains close analogs of training molecules. If the model will score new chemical series, choose SCAFFOLD_BALANCED in Split method: each Bemis-Murcko scaffold then stays in one set, and the test metric is closer to what you will see on unfamiliar scaffolds. Expect it to be worse than the random-split metric. metrics.csv shows whether training converged: validation loss that is still falling at the last epoch suggests more epochs, and validation loss that rises while training loss keeps falling is overfitting.

For prediction, the <target>_unc column tells you which predictions to trust. With ensemble, it is the variance of the predictions of the model files you gave, so it needs at least two; molecules unlike anything in the training data often get a larger value.

mve, evidential-* and quantile-regression read an uncertainty the model learned during training, and need a model trained with the matching Task type. These values are relative unless calibrated: they rank molecules from more to less certain, but a raw variance is not a confidence interval. A Calibration method with measured Calibration data turns them into calibrated values, and Uncertainty evaluation with measured values in the Molecules CSV checks how well they track the real errors; spearman near 1 means the largest uncertainties go with the largest errors.

A model is only as broad as its training data. A prediction for a molecule outside that chemical space can look as precise as any other, so read predictions together with their uncertainty and with the test metric of the split that matches how you will use the model. When you do not have measurements of your own, ADMET-AI and toxicity prediction provide pretrained predictions instead, and the ADMET prediction page compares the options.

Two Chemprop 2.3.1 combinations fail in Chemprop itself and stop with its error: training with Task type spectral fails while writing the test predictions, and conformal-multiclass calibration fails during prediction.

Sources

• Graff, D. E. et al. Chemprop v2: An Efficient, Modular Machine Learning Package for Chemical Property Prediction. Journal of Chemical Information and Modeling (2026). doi:10.1021/acs.jcim.5c02332
• Heid, E. et al. Chemprop: A Machine Learning Package for Chemical Property Prediction. Journal of Chemical Information and Modeling (2024). doi:10.1021/acs.jcim.3c01250
• Yang, K. et al. Analyzing Learned Molecular Representations for Property Prediction. Journal of Chemical Information and Modeling (2019). doi:10.1021/acs.jcim.9b00237
• Chemprop repository and documentation, github.com/chemprop/chemprop