Using SyntheMol

SyntheMol is in an invite-only beta. Join the waitlist with the email you'll sign in with. We'll email you to confirm, and again when you're in. Sign in with a one-time code sent to your email, or with Google if your Google account uses the same address.

The beta is free. Your account comes with a monthly number of rollouts for designing molecules, shown on the Usage page.

A dataset is a table saved as text, such as a CSV file, with one molecule per row. It needs a column of SMILES (simplified molecular-input line-entry system) strings, under any name, and at least one property column of numbers, such as activity against your target. Everything else can stay in the file, such as compound IDs, names, notes or computed descriptors: SyntheMol reads only the columns you choose. Column names can be at most 100 characters.

The file can be separated by commas, semicolons, tabs or bars, and saved from Excel on any system: SyntheMol works out which and saves it as a plain CSV. It tells you what it changed before you upload. A column without a name is called by its position, a repeated name gets a number, and in a file that isn't comma-separated, decimal commas such as 1,5 are read as 1.5. An Excel workbook (.xlsx) has to be saved as CSV first.

When you upload a file, you choose its columns:

• The SMILES column. SyntheMol picks the column most likely to hold them, by its name or by how many of its values RDKit can read; change it if it guessed wrong. A column RDKit can't read isn't accepted, so a plate-reader export needs joining to its compound list first. Rows with no SMILES, such as controls, are left out, and counted.
• The properties to learn from. None is added for you: a column's name can't say whether a logP was measured or computed, or whether a number is a plate's or a property. Add each from a searchable list, where columns of 0 and 1 and columns of other numbers are listed apart and each list can be added at once, so a screen with a column per assay takes one click. A column that counts 1, 2, 3 down the file is listed on its own, and one with a single value throughout can't be added.
• Each property's kind: Classification for a column of 0s and 1s, where 1 marks a molecule that has the property, or Regression for experimental values, such as a pIC50 or a log MIC. The next section says which to choose.

One file can hold several properties, of either kind, and a run can learn from several files. Each property gets its own scoring model, and a run learns every property of the datasets it uses, so add only the ones you'll search with. To change a dataset's columns later, upload the file again.

A blank cell means the molecule wasn't measured for that property: it's left out of that property's model, and the dataset's page counts the blanks. Any other value that isn't a plain number, such as >64, ND or inf, is left out the same way. Before the file is saved, SyntheMol says how many such values a property has and where the first is, and the dataset's page counts them. Leaving out censored values changes what the model learns: if every inactive molecule reads >64, the model sees only the actives. To keep them, write each as a number.

One bad row doesn't stop an upload either. A row with more or fewer columns than the header, as when a name holds a comma and isn't in quotes, is left out and counted. A 0/1 column that holds another number, such as 2, can't be learned as Classification until that cell is fixed.

SMILES

Simplified Molecular Input Line Entry System: a line of text that encodes a molecule’s graph, its atoms, bonds, rings and charges, such as c1ccccc1O for phenol. You pick the column that holds them when you upload, and the dataset’s page checks every one with RDKit: Chemprop builds each molecule’s graph from its SMILES, so one RDKit can’t parse would stop the run.

Property

One column of your CSV that a scoring model learns to predict: the label, or target, in machine-learning terms, such as activity in one assay. A classification property holds 0 or 1, marking non-hits and hits; a regression property holds experimental values, such as a pIC50. Each property gets its own scoring model, learned only from the rows with a value in that column, and in the search that model’s prediction becomes one objective, maximized or minimized.

Hits

Molecules marked 1 in a classification property: the positive class, with the non-hits, marked 0, as the negative class. The classifier learns to tell the two apart, and the share of hits is the base rate that its area under the precision–recall curve (AUPRC) is judged against. With few hits the model has few examples of what a hit looks like, which limits what it can learn.

Blank

An empty cell, a missing label: the molecule wasn’t tested for that property. Each property learns only from its own labelled rows, so a blank leaves the molecule out of that property’s training, validation and test sets, and it still counts for any property it has a value for. Any other value that isn’t a number, such as >64 or ND, is left out the same way: the upload says how many there are and where the first is, and the dataset’s page counts them under Not numbers. To keep a censored value, write it as a number.

Validation

A check on SyntheMol’s server that the file is a usable dataset: a classification property’s numbers are all 0 or 1 and it has both classes, and a regression property has at least two different numbers, since a model can’t learn from a label that never changes. It also counts each property’s values and what is left out: blank cells, cells that aren’t numbers, rows without a SMILES, and rows that can’t be read because they have more or fewer columns than the header. A file that fails is deleted, with the reason. It is unrelated to the validation set, the molecules that pick a model’s best epoch.

Each property gets one of two kinds of model, chosen when you upload it. A classification model predicts the probability that a molecule is a hit, from 0 to 1, and is judged by its test AUPRC against the base rate. A regression model predicts the property's own value, such as a pIC50, and is judged by its test root-mean-square error (RMSE), in the property's units, and its Spearman ρ, whether it ranks your molecules the way your experimental values do. Every scoring model learns here, from a dataset: SyntheMol doesn't accept model files made elsewhere.

A column of 0s and 1s can be either kind; any other numbers make a regression model. If you have the experimental values, regression keeps more of them: it learns how active a molecule is, not only whether it passed your cutoff. If all you know is which molecules were hits, use classification.

During a run, a regression model's prediction counts against the molecules the search has made recently, so the search keeps pushing the value up, or down, rather than toward a fixed target. Give regression values on a log scale, such as a pIC50 rather than an IC50 in molar: values that barely vary give the search little to go on. When you upload a column whose values are strongly skewed, most small and a few very large, the upload suggests a log scale.

Chemprop

An open-source directed message-passing neural network for molecular property prediction. It reads a molecule as a graph: atoms are nodes and bonds are edges, each described by features such as element, charge, aromaticity and bond order. Every bond, in each direction, carries a hidden vector of 300 numbers; for three steps each one sums the messages from the bonds leading into it and passes them through a learned layer, so each atom ends up described by its neighbourhood out to about three bonds. The atom vectors are pooled into one vector for the molecule, and a feed-forward network with one hidden layer maps it to the prediction. Both parts learn together from your data, so the model learns its own features rather than relying on a fixed fingerprint. SyntheMol’s scoring models are Chemprop 2 models.

Checkpoint

A saved Chemprop model, one PyTorch .pt file per fold: the network’s learned weights, the settings needed to rebuild it and, for a regression model, the mean and standard deviation that turn its output back into your property’s units. Each fold’s file is saved at its best epoch, and together they make the ensemble that scores the search.

Task

Classification or regression, which sets the model’s output and its loss function. A classifier ends in a sigmoid, so it outputs the probability that a molecule is a hit, from 0 to 1, and learns by minimising binary cross-entropy, which penalises confident wrong answers most. A regression model outputs a number and learns by minimising mean squared error: Chemprop standardises your values to mean 0 and standard deviation 1 while it learns and converts its predictions back, so they come out in the property’s own units, such as a pIC50. You choose for each property when you upload: only a 0/1 column can be classification.

Choose New run on the Jobs page and pick your inputs: upload CSVs, choosing their columns as above, and choose saved datasets and models, in any mix. The run learns a scoring model for each property of the datasets, then scores molecules with those and the saved models together. A run that designs molecules can also optimize properties computed from each molecule's structure by RDKit, which need no data: drug-likeness (QED), molecular weight, cLogP, polar surface area (TPSA), hydrogen-bond donors and acceptors, rotatable bonds, aromatic rings and the fraction of sp3 carbons. Add them under Properties with Add computed property, and set each one's goal. Then configure the run: rename each property if you like, and set the options below. The search itself runs with settings tuned for SyntheMol-AB, and stops after at most 6 hours, keeping the molecules found so far.

What to run

Learn and design learns a scoring model for each property, then searches for molecules that score well on them. Learn only stops after learning, so you can check each model’s quality before searching with it. A run that uses only saved models skips learning.

Goal

The direction of a property’s objective in the search’s reward. A classifier’s objective is its predicted probability when maximizing, such as activity, and 1 minus it when minimizing, such as toxicity. A regression model’s is a sigmoid of how far its prediction sits above the median of the run’s last 1,000 predictions, or below it when minimizing, scaled by their spread.

Epochs

One epoch is one pass over the training set: the molecules go through in shuffled mini-batches, and after each batch the Adam optimiser takes one gradient-descent step on the weights. The learning rate rises linearly over the first two epochs, then decays exponentially to a tenth of its peak by the last, so the steps start small, peak and settle. Each fold keeps its checkpoint from its best epoch, so extra epochs mostly cost time, while too few stop a model before it has fit your data.

Folds

The k in k-fold cross-validation. Your molecules are split into k groups and k models are learned, one per fold: fold i is tested on group i, uses the next group as its validation set and learns from the other k − 2, its training set. Every group is a test set exactly once, so every molecule is predicted once by a model that never learned from it, and the mean of the k test scores is a cross-validated estimate of how well the model predicts new molecules. The k models together are the ensemble that scores the search.

Split

How molecules are assigned to the k groups. Scaffold groups molecules by their Bemis–Murcko scaffold, the ring systems and the linkers between them with the side chains removed, and keeps each scaffold in one group: the largest scaffold sets go first, each into the smallest group so far, so the groups come out about the same size. Each model is then tested only on scaffolds it never learned from, which estimates how it does on new chemotypes, as in the search. Random assigns molecules to groups at random, so close analogues of a test molecule usually sit in its training set, which gives a higher, more optimistic score.

Rollouts

One episode of SyntheMol-AB’s reinforcement-learning search. A transformer policy picks building blocks one at a time: it outputs a query vector, compares it with every building block that can still react, each represented by an embedding from a pretrained molecular model, and samples one from the resulting distribution, until it chooses to stop. Every reaction in the chemical space that fits the chosen blocks is then run, so one rollout can make several products. Your scoring models score them, the scores are combined into a reward, and every eight rollouts the policy is updated by REINFORCE, a policy-gradient method that makes the choices behind high rewards more likely.

Chemical space

A combinatorial library: building blocks and the reactions that join them, which together define every molecule the search can make. SyntheMol searches Onepot Core 2.0, a space of 30 billion compounds, so every molecule it designs comes with a route Onepot can make.

Review the settings and start the run. It waits in a queue until a GPU is free. Follow its progress on the Jobs page.

During the beta, the GPUs are shared with the lab's research, so each person has one run going at a time. Queue as many as you like: your next run starts when the one before it ends, and people with nothing running go first. Learning has limits too, on the rows in each dataset, the epochs, and the properties a run learns. The New run form tells you when a run is over one.

A run that designs molecules needs a plan, and draws its rollouts from the plan's rollouts for the billing period: your own plan, or in a team its owner's. From queueing until it ends, a run holds the rollouts it asked for, and a run that needs more than the plan has left won't start. A run is billed only for the rollouts it used. Learn-only runs use no rollouts.

Each property's scoring model is a Chemprop ensemble that learns with k-fold cross-validation, so every molecule is tested once, by a model that never learned from it. With a scaffold split, molecules that share a core scaffold stay in the same fold, so that model never saw its scaffold either.

A run's page shows each classification model's test AUPRC beside the base rate, the share of 1s in its column: a model at about 1.0× the base rate is no better than chance. A regression model shows its test RMSE and its Spearman ρ, and a ρ under 0.3 is marked as too weak a ranking to steer the search. Models from before ρ was recorded show R² instead.

Learning

The first step of a run, what machine learning calls training: for each property, Chemprop learns an ensemble of k models by k-fold cross-validation. Each fold’s model learns from its training set by gradient descent, keeps the epoch that scored best on its validation set, and is scored once on its test set. The test scores say how well the model predicts molecules it never learned from.

Training set

The k − 2 groups of a fold that its model learns from. Every epoch, gradient descent adjusts the model’s weights, the numbers inside the network that turn a molecule into a prediction, to lower the loss on these molecules; the learning loss, dashed on a run’s chart, is measured on them. A model always does better on its training set than on molecules it hasn’t seen, so its score there says little about how useful it is.

Validation set

The group of a fold held out to choose its best epoch: the model is scored on it after every epoch, and the epoch with the lowest validation loss becomes the fold’s model. It never updates the weights; it only chooses the epoch, which works like early stopping and amounts to tuning the number of epochs. Because that choice is made on it, the validation score is slightly optimistic, so each fold is scored again on its test set.

Test set

The group of a fold kept out of both learning and choosing the epoch, so it stands in for new molecules. Each fold is scored on its test set once, after learning; since every molecule is in exactly one test set, the mean over folds is a cross-validated estimate of how the scoring model does on molecules it hasn’t seen. Test AUPRC, Test RMSE and Spearman ρ are all test-set scores, and the ones to judge a model by.

Ensemble

The scoring model is an ensemble: the k fold models, each learned from a different training set, and a molecule’s score is the mean of their predictions. Averaging cancels part of each model’s own errors, so an ensemble is usually more accurate and steadier than any one of its models. The test scores are the fold models’ own, since every molecule is in some fold’s training set, so they estimate a single model rather than the ensemble.

Val loss

The loss function on the validation set, measured after every epoch: binary cross-entropy for a classifier, mean squared error for a regression model; lower is better. A regression model’s is computed on standardised values, so predicting your data’s mean for every molecule scores about 1. A classifier that predicted the base rate for every molecule would score about 0.69 at 50% hits and 0.20 at 5%. The learning loss, dashed, is the same function on the training set, averaged over each epoch. If validation loss rises while learning loss keeps falling, the model is overfitting: fitting the noise and quirks of its training molecules instead of what carries over to new ones.

Best epoch

The epoch with the lowest validation loss. Learning runs for every epoch, and Chemprop keeps the checkpoint from this one as the fold’s model, which works like early stopping: later epochs that overfit are discarded. Summaries show the median over folds; if it’s close to the last epoch, the model was still improving and more epochs might help.

Seed

The random seed for a run. In learning it fixes how molecules are assigned to folds, the network’s random starting weights and the order of its mini-batches; in the search it fixes the policy’s random draws. The same data, settings and seed give the same folds and starting weights, but repeats can still differ slightly, because GPU arithmetic isn’t always deterministic.

AUPRC

Area under the precision–recall curve. Rank the molecules by predicted probability and walk down the list: precision is the share of molecules so far that are hits, recall the share of all hits found so far. The area under precision plotted against recall runs from 0 to 1 and is high when the hits come first. A model that ranks at random scores about the base rate, while it scores 0.5 on AUROC, the area under the receiver operating characteristic curve, which is the chance that a random hit is ranked above a random non-hit. The many easy non-hits can’t flatter AUPRC the way they flatter AUROC, which makes AUPRC the better measure when hits are rare.

Base rate

The prevalence of the positive class: the share of a property’s labelled molecules marked 1, so 50 hits in 1,000 molecules is 5%. A model that ranks molecules at random scores an AUPRC of about the base rate, so a model’s test AUPRC is judged against it.

Test AUPRC

AUPRC on each fold’s test set, averaged over folds: a cross-validated estimate of how well the model ranks hits above non-hits among new molecules. Read the multiple beside it, AUPRC ÷ base rate: 1× is chance and the higher the better, and a warning sign marks a model too close to chance to steer the search.

× base rate

Test AUPRC divided by the base rate: how many times better than random the model ranks hits. 1× is chance. AUPRC tops out at 1, so the ceiling is 1 ÷ the base rate: 20× at a 5% base rate, but only 2× at 50%.

Near chance

The model’s test AUPRC is under twice the base rate or, when over a sixth of molecules are hits and doubling is out of reach, under a fifth of the way from the base rate to 1. Runs that recorded no base rate use a test AUROC under 0.6 instead: the area under the receiver operating characteristic curve, the chance that a random hit is ranked above a random non-hit, where 0.5 is chance. A model this close to chance gives the search a reward that is mostly noise. More labelled molecules, especially hits, usually help more than extra epochs.

Test RMSE

Root-mean-square error on each fold’s test set, averaged over folds: the square root of the mean squared difference between prediction and experimental value, in the property’s own units, so an RMSE of 0.5 on a pIC50 is half a log unit. Squaring weighs large errors heavily. RMSE has no fixed scale, so compare it with the spread of your values: predicting their mean for every molecule scores about their standard deviation. Spearman ρ says whether the model ranks your molecules the way your experimental values do, which matters more to the search.

Spearman ρ

Spearman’s rank correlation between predictions and experimental values on each fold’s test set, averaged over folds: the Pearson correlation of their ranks, from −1 to 1, tied values sharing their mean rank. Rank your molecules twice, by experimental value and by prediction: 1 means the rankings match, 0 no better than random, and below 0 the model tends to rank them backwards. It uses only ranks, so units and outliers don’t move it. The search rewards a regression prediction by where it falls among the run’s recent predictions, so the ranking is what counts. A warning sign marks a model under 0.3.

Weak ranking

Test Spearman ρ under 0.3, a weak correlation by the usual reading: the model’s ranking of molecules it never learned from barely matches the ranking from your experimental values, so the search’s reward is mostly noise. More experimental data usually helps more than extra epochs.

R²

The coefficient of determination on each fold’s test set, averaged over folds, shown in place of Spearman ρ for regression models from before SyntheMol recorded ρ: 1 minus the model’s squared error divided by the squared error of predicting the test set’s mean for every molecule. 1 is perfect, 0 is no better than predicting the average, and below 0 is worse; a warning sign marks 0 or below. Unlike ρ, it also penalises predictions that rank well but are offset or scaled wrong.

Quality

The model’s cross-validated test scores: how well it predicts molecules it never learned from. Check a classifier’s test AUPRC against the base rate, and a regression model’s Spearman ρ, or R² for older models, before designing with it. Test scores measure molecules like the ones in your data, its applicability domain in machine-learning terms; designed molecules can fall outside it, where predictions are less reliable.

For how the search builds molecules from building blocks and reactions, read the SyntheMol paper.

When a run finishes, its molecules are saved as a new dataset and open on the Molecules page, the last rollout's first. Each row has each property's prediction. There is no overall score: the search moves weight between properties as it runs, so no one weighting fits every run. Sort by the property you care about, and use filters for the rest.

Sort and filter the table, select a molecule to see its structure and flags such as pan-assay interference compound (PAINS) matches and reactive groups, and export the CSV. We email you when a run finishes or fails.

A flag says what matched and never hides a molecule. Each one names the rule that matched: for PAINS, the pattern's family in plain words, with RDKit's name and set (PAINS_A, B or C, from Baell & Holloway 2010); for a reactive electrophile, its group and the RDKit pattern. The plain PAINS names are ours: no published list names those families in words. The structure highlights the matched atoms. Point at a flag or a highlight, or tab to a flag, for the rule's source and its SMARTS, the pattern language that extends SMILES to describe substructures.

A Substructure filter keeps or drops molecules that contain PAINS (RDKit's 480 patterns), a reactive electrophile, a functional group or ring from the list, or a SMARTS you type. The functional groups and rings are RDKit's own definitions. The reactive electrophiles are RDKit's Brenk (Brenk et al. 2008) and NIH (Jadhav et al. 2010) patterns, plus one of ours for a carbonyl on an aromatic ring nitrogen, which those sets don't cover in the forms SyntheMol makes. Clicking a list's name, such as Reactive electrophiles, adds everything in it. One filter can hold several: “doesn't contain” drops a molecule with any of them, and “contains” keeps only molecules with all of them. These are matched in your browser, so they work on every run, and kept there until you sign out, so reopening a run doesn't match them again.

A run's page describes its search with these terms:

Design

The second step of a run: SyntheMol-AB’s reinforcement-learning search through Onepot Core 2.0, with your scoring models as the reward. Each rollout builds molecules from building blocks with Onepot’s reactions, so Onepot can make every molecule it finds, and the policy learns from the rewards which blocks to pick. The molecules are saved, with each model’s prediction, as a new dataset on the Molecules page.

Unique

The number of distinct molecules, by SMILES. The search can make the same molecule in more than one rollout, as the policy returns to building blocks that scored well; the saved dataset lists each once, at the rollout that first made it.

Diversity

Novelty against the run’s own history: 1 minus a molecule’s highest Tanimoto similarity to any molecule made earlier in the run, from 0 (a repeat) to 1. Tanimoto similarity compares Morgan fingerprints, which record each atom’s surroundings out to two bonds: it’s the share of features set in either molecule that are set in both. SyntheMol-AB finds the most similar earlier molecule with an approximate nearest-neighbour search, which keeps long runs fast.

Rolling average

1 minus SyntheMol-AB’s exponential moving average of each rollout’s highest similarity to the history, so it reflects what the search is making now. SyntheMol-AB uses it to balance exploration against exploitation: the policy samples building blocks from a softmax whose temperature it adjusts every rollout, raising it while the rolling similarity is above a target of 0.6 and lowering it while it’s below. A higher temperature flattens the distribution, so the policy tries blocks it rates lower; a lower one concentrates it on the blocks it rates best. Over a long run, the rolling average settles near 0.4.

Cumulative

The mean diversity over every molecule made so far. Each new molecule moves it by about 1/n, so it flattens as the run grows whatever the search is doing, and each molecule is compared with a growing history, which tilts it towards the run’s early phase. The rolling average is the better guide late in a run.

Weights

Each property’s weight in the search’s reward, the weighted sum of the properties’ shaped scores, each from 0 to 1. In score-balance mode SyntheMol-AB keeps a rolling average of each property’s score and every rollout moves weight from the properties scoring above the mean to those below, down to a floor of 0.001, so the weights show which property the search is chasing. Within a few hundred rollouts they can put almost all the weight on the property that’s hardest to satisfy.

Email hello@synthemol.com.