Why ADMET prediction in the laboratory fails
Compound toxicity assessment and molecular property prediction in most laboratories live in different places: assay results are in spreadsheets, structures are in molecule description files, historical reports are in documents and correspondence.
When it is time to decide the fate of the next series, a chemist assembles the dataset manually and spends days on it, and some compounds drop out of consideration simply because there is no complete set of measurements for them.
The second failure point is inconsistent representations. The same molecule is described by different notations in different files, a salt and a base are recorded as separate records, and some structures arrive as images without a machine-readable description.
When merging disparate laboratory data, duplicates and lost links accumulate unnoticed — the model trains on a biased sample, and ADMET prediction diverges from experiment exactly where the error costs the most.
The third is the decision process itself. A compound is screened out by a single endpoint, without a prediction uncertainty interval and without checking whether the model applies to a new chemical class.
Promising candidates are discarded, and laboratory resources are spent on molecules that clearly will not advance further.
We break down how this is closed: from a unified representation of structures and data annotation to uncertainty estimation at every step of early candidate selection.
What ADMET prediction provides at the early selection stage
Early selection determines how many compounds even reach synthesis.
The first-stage barrier is solubility and permeability: from a structural formula, the model classifies a candidate as "pass / fail" in seconds, and only what fits the target profile reaches the laboratory. Out of a hundred submitted structures, 10–15 remain after this filter.
The second stage is metabolic stability assessment: degradation rate, contribution of major enzymes, risk of rapid clearance. Models are trained on public bioactivity datasets such as ChEMBL and on client data — so screening is mechanism-based, not by a single hard threshold.
This is where the error class "the model is confident, but the laboratory does not confirm" is eliminated.
Compound prioritization turns disparate predictions into a synthesis queue: candidates are ranked by the probability of passing all checks at once, not by a single endpoint.
This is the reduction in the number of syntheses — the laboratory receives a subset instead of the entire series, and the selection cycle compresses from weeks to days.
Reproducibility of predictions relies on fixing the model version, data split, hyperparameters, and structure representation, plus checksums of the training data.
Re-running six months later yields the same numbers, and a discrepancy becomes a reason to investigate the data, not to retrain the model from scratch.
Comparison of approaches: ready-made services, fine-tuning, in-house model
There are three real paths: an external property prediction service, fine-tuning an open model on your own measurements, and an in-house model on the client's proprietary data.
The difference between them is not "average accuracy," but where the applicability boundary lies and who is responsible for the error on a new chemotype.
| Option | When suitable | Limitations |
|---|---|---|
| External property prediction service | Quick assessment at early selection, little own data | Logic is closed, applicability domain cannot be checked, model cannot be trained on own measurements |
| Fine-tuning on own data on top of open datasets such as ChEMBL | Hundreds to thousands of own measurements, structures close to public ones | Quality is limited by the volume of measurements for the target property, cleaning and annotation are required |
| In-house model on proprietary data | Data cannot leave the perimeter, chemotypes are unique | Longer time to deployment, reproducible validation and model version support are required |
Fine-tuning almost always wins on time to launch: public datasets provide general chemistry, and your own measurements shift the prediction toward the desired series.
An in-house model is needed when the data is a trade secret or when public datasets systematically do not cover the working structures.
Separately, we fix the applicability domain: the range of structures and properties within which the prediction is confirmed by validation, and outside which the model issues a warning rather than a confident number.
We set this boundary before training, not adjust it afterward — otherwise the service becomes a generator of plausible answers.
Therefore, we start approach selection with a data audit: how many measurements, for which properties, how homogeneous they are, and whether they can be disclosed.
The answers to these questions determine which of the three options will give a prediction that can be trusted in selection.
How we build the system: stages of engineering work
ADMET prediction breaks not on the choice of algorithm, but on heterogeneous data and a vague problem statement. Therefore, we fix the order of work in advance — at each step it is clear what exactly is being checked and what result is considered acceptable.
- Problem formulation for prediction. We determine which properties are needed — solubility, permeability, metabolic stability, toxicity — and in what form the answer is needed: a number, a class, or a probability with a threshold. We agree on the quality metric and the acceptable error level for compound screening.
- Unification of chemical structures. Sources give the same molecule differently: salts, charges, tautomers, duplicates. We bring everything to canonical notation, check valences, and discard broken structures — otherwise the model learns on noise.
- Molecule feature generation. We compute descriptors and fingerprints, and add environment features. Separately, we control the split: compounds from one series must not fall into both training and validation.
- Model validation on held-out data. We test not on a random sample, but on dissimilar compounds — by chemical series and scaffolds. We look at error by subgroups and behavior at applicability boundaries: where the model is not applicable, it returns a refusal, not a number.
- Embedding the model into the calculation pipeline. We wrap it in a service with input validation, versioning, and a prediction log, and connect it to the current selection process — the result arrives where it is used, without manual file transfer.
- Handover to the team. We provide configurations, the feature schema, retraining scripts, and the regulation for updating the model on new data.
Configurations, schemas, and regulations: what we hand over at completion
Handover is not just an archive with model weights. Without a feature description, a data flow schema, and validation rules, your team will not be able to retrain the model on new data and confirm the reproducibility of predictions.
Therefore, we assemble the package so that it can be accepted by a formal checklist and launched without our involvement.
- Code and environment — a repository with training and prediction inference, pinned dependencies, and deployment instructions: the build reproduces on a clean machine in your infrastructure.
- Model documentation — architecture, hyperparameters, validation scheme, and applicability boundaries: for which compound classes the prediction is stable, and where it is unreliable.
- Data and feature map — dataset sources, cleaning rules, descriptors, handling of missing values and outliers; it allows tracing the origin of any prediction.
- Data flow schemas — the path from compound upload to result, storage and update points, and failure behavior.
- Prediction quality control — held-out sets, error thresholds, and distribution shift checks; if a threshold is exceeded, retraining stops.
- Retraining regulation — triggers, frequency, the procedure for accepting a new version, and rollback to the previous one.
- Team training — code and data walkthrough, and the first independent model update cycle under our guidance.
Case: how we halved the share of false candidates
Selection was manual: chemists reviewed docking output and decided from experience which molecules to send for synthesis. The cycle took weeks, and a significant portion of compounds failed not on activity, but on property checks — solubility, permeability, toxicity. That was the main loss item.
What it was before implementation
We measured three metrics: the share of false candidates (passed selection but failed laboratory validation), the number of checks per confirmed candidate, and the selection cycle time.
The baseline was 62% false candidates: two out of three synthesized molecules did not reach the target. Data lay in disparate spreadsheets, some properties were not modeled at all, and decisions were made on a single activity endpoint.
What we changed
We assembled a unified corpus from open sources — taking ChEMBL as a base — and the client's internal archives.
We trained separate models for each ADMET property instead of one generalized model: the mixed task blurred feature contributions, and toxicity error dragged solubility prediction along.
We added applicability domain estimation — if a molecule is far from the training set, the model does not give a confident answer, but flags it as unreliable and sends it for manual review. We selected the cutoff threshold on historical data to maximize confirmation rate, not recall.
We also changed the process: only what passed the threshold for all properties at once, not just one, goes to the laboratory. Ranking is now two-level — first prediction, then a check for chemical feasibility.
Result
The share of false candidates fell from 62% to 29% — by half. The number of laboratory checks per confirmed candidate decreased 2.3 times with the same synthesis volume.
The selection cycle compressed from three weeks to several days, because the main filtering happens before the laboratory, not after. Models, selection rules, and the decision log are fixed — the result reproduces on new compound series.
What to do if you already have your own calculation pipeline?
Your own calculation pipeline is not an obstacle, but ready support: it already has proven descriptors, debugged validation, and accumulated rejection rules.
Therefore, we do not rewrite everything from scratch, but start with an inventory: which scripts calculate what, where historical datasets are stored, and which constraints were imposed manually by experts.
Embedding goes alongside, not instead: the new model is placed behind the same interface as the current calculations — the same structure formats at input and the same response format, so the calling code remains untouched.
The first run is on historical datasets, compared with logs of past calculations: this shows where the model wins and where it diverges from the old one.
Almost everything should be reused — computed descriptors, intermediate results, annotations, and expert rules: they go into both the features and the reference for comparison.
We do not discard old models: they remain an arbiter on disputed compound classes until the new one shows consistently better quality.
A separate task is preserving accumulated rules: thresholds, substructure constraints, and series exclusions.
We transfer them into an explicit post-processing layer and describe them as code with tests, otherwise the knowledge rests on one engineer and is lost at the first change.
The gradual transition is staged: first a shadow mode, where the new model computes but the old one makes the decision; then enabling on selected compound groups; and only then — the main path with rollback to the previous calculation.
Technical concerns: data, accuracy, applicability
During problem review, technical concerns are usually the same: is there enough data, is there leakage between training and validation, how to reconcile measurements from different laboratories, and what to do with unfamiliar compounds. We discuss the details on your dataset.
How much data is needed for prediction to be reliable?
We look not at the total number of records, but at the number of series and the diversity of the chemical space. Thousands of compounds with consistent measurements give a stable prediction for one property, while hundreds of similar analogs will not replace it.
How do you check the model for overfitting and leakage?
We split the sample by chemical series, not randomly, and remove indirect hints about the answer from the features. If quality on held-out series drops sharply, the model is not deployed.
The data was collected by different measurement methods — what should be done about it?
We mark each method as a separate source and check transfer between laboratories. We do not blur discrepancies by averaging, but show them as an interval: it is clear where the prediction is stable and where it depends on the source.
What about compounds outside the training set?
For each molecule, we calculate the distance from the training data. If it is outside the applicability domain, the model returns not a number, but a flag — the compound goes to experiment or to a separate fine-tuning cycle.
Can the model update itself?
We do not make it fully automatic: a data shift can silently break the prediction. New measurements accumulate, retraining follows the regulation, and only a version with metrics no worse than the previous one goes into operation.
Let's discuss the task and come back with an estimate and plan
The first problem review takes about an hour and is substantive: what exactly needs to be predicted, on which chemical space, and what decision you make based on the result.
We do not start with model selection — first we fix where ADMET prediction embeds into your compound selection process and what routine it removes. Below is what is useful to have on hand from the client side at this meeting.
- Data arrays: structures with known property values, in what form they are stored, and how well the required endpoints are covered.
- List of ADMET properties critical for your selection: solubility, permeability, metabolic stability, toxicity — you set the priorities.
- Output requirements: a table with values and confidence intervals, library ranking, or binary rejection of candidates.
- Data constraints: where it is stored, what may be transferred, and whether work inside your perimeter is required.
- Success metric in your terms: the share of screened-out clearly unsuitable candidates, and agreement of the prediction with laboratory results.
- Examples of compounds where the current selection fails — they define the applicability boundaries of the future model.
After the review, we come back with an estimate and work plan: stages, what we validate on the held-out set, and which properties we cover first.
A separate item in the plan is the applicability boundaries of the solution — for which compound class the prediction is stable, where the model goes beyond the training distribution, and the result must be confirmed in the laboratory. Payment and scope of stages are fixed before the start.
Describe the prediction task — we'll come back with an estimate and plan.
