🤖 machine learning

Scikit-fingerprints: Python library for scikit-learn compatible molecular fingerprints and chemoinformatics

The paper introduces scikit-fingerprints, a comprehensive Python library built on RDKit that bridges the gap between chemoinformatics and the scikit-learn ecosystem by providing fully compatible molecular fingerprints, similarity measures, and workflow tools to streamline the development, reproduction, and deployment of molecular machine learning models.

Original authors: Jakub Adamczyk, Adam Staniszewski

Published 2026-08-04

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Jakub Adamczyk, Adam Staniszewski

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine a world where scientists are trying to design new medicines, but instead of mixing chemicals in a beaker, they are mixing data on computers. This field is called chemoinformatics, and its main job is to teach computers how to "see" molecules. To do this, computers need to turn complex 3D shapes of atoms into simple lists of numbers, kind of like turning a delicious, multi-layered cake into a recipe card with just numbers for flour, sugar, and eggs. These number lists are called "fingerprints" because they act like a unique ID for every molecule.

For a long time, the tools scientists used to make these fingerprints were like old, clunky machines that only spoke their own secret language. They were great at their specific job, but they couldn't talk to the modern, super-smart tools that data scientists use to build artificial intelligence. It was like trying to plug a vintage radio into a modern smart home system; the wires didn't match, and the whole process was messy, slow, and prone to breaking. This paper introduces a new tool called scikit-fingerprints that acts as a universal translator and a master builder, connecting the world of chemical molecules with the world of modern machine learning.

The Universal Translator for Molecules

The authors, Jakub Adamczyk and Adam Staniszewski, built a new Python library called scikit-fingerprints. Think of it as a giant, Swiss Army knife for molecular data that fits perfectly into the "scikit-learn" ecosystem. Scikit-learn is the most popular toolbox for teaching computers to learn from data, but until now, it didn't know how to handle molecules very well. The old chemical tools were like isolated islands; you had to write special, messy code to move data between them and the learning algorithms. Scikit-fingerprints bridges that gap, allowing scientists to build entire drug-discovery workflows using the same clean, familiar blocks they use for everything else.

The library is built on top of RDKit, a powerful, open-source toolkit that has been the standard for handling chemical structures for years. However, while RDKit is powerful, it wasn't designed to play nicely with modern machine learning pipelines. Scikit-fingerprints takes the heavy lifting of RDKit and wraps it in a neat, standardized package. It ensures that every step of the process—from reading a chemical name (SMILES string) to training a model—follows the same rules. This means you can swap out one part of your process for another without having to rewrite your entire code.

A Toolbox Full of Tricks

The paper explains that this library does much more than just turn molecules into numbers. It offers a complete suite of tools that cover the entire journey of a drug discovery project:

The Fingerprint Factory: The library includes over 30 different ways to create molecular fingerprints. Some look for specific shapes (substructures), while others count how many times certain patterns appear. It's like having a menu of different cameras, each taking a unique photo of the molecule to highlight different details.
The Bouncer (Filters): Before you even start testing, you might want to kick out bad actors. The library has over 30 "filters" that act like bouncers at a club. They check if a molecule is "drug-like" or if it contains dangerous, reactive parts that would ruin the experiment. If a molecule fails the rules, it gets kicked out automatically.
The Ruler (Distances and Similarities): Scientists often need to know how similar two molecules are. The library provides over a dozen ways to measure this distance, acting like a super-accurate ruler that can compare molecules based on their fingerprints or even their 3D shapes.
The Safety Net (Applicability Domain): This is a crucial feature. It helps scientists know when a model is guessing and when it's actually sure. It checks if a new molecule looks enough like the ones the model was trained on. If the new molecule is too weird, the tool flags it as "unreliable," preventing scientists from trusting bad predictions.
The Splitter: To test if a model works, you need to split your data into a "training" set and a "testing" set. The library offers smart ways to do this, ensuring that the test molecules are truly different from the training ones, which gives a more honest score of how well the model will work in the real world.

Speeding Up the Process

One of the biggest problems in this field is that calculating these fingerprints can be incredibly slow, especially when you have millions of molecules. The paper highlights that scikit-fingerprints is built for speed. It uses parallel processing, which means it can use all the cores of a computer's processor at once, rather than doing one thing at a time.

The authors tested their tool and found it to be significantly faster than the old ways of doing things. For example, when they tried to calculate a specific type of fingerprint (the PubChem fingerprint) for a large dataset, their method was much quicker than the standard web-based tools, which often get stuck or crash when asked to do too much at once. In tests with nearly 7 million molecules, the library managed to process them efficiently, using a "sparse" format that saves a massive amount of computer memory—reducing memory usage by a factor of 39 to 45 times compared to older methods.

They also solved a tricky problem with tuning hyperparameters (the settings that control how the machine learning model learns). Usually, if you want to find the best settings, the computer has to re-calculate the fingerprints every single time it tries a new setting, which is a waste of time. Scikit-fingerprints is smart enough to calculate the fingerprint once and reuse it for all the different settings, saving hours of computing time.

Why This Matters

The paper doesn't claim to have discovered a new drug or solved the mystery of life. Instead, it offers a practical, open-source solution to a very boring but critical problem: making the tools of chemistry talk to the tools of artificial intelligence. By making these workflows easier, faster, and less prone to errors, the library allows scientists to prototype their ideas quickly and reproduce their results reliably.

The authors emphasize that this is an open project, meaning anyone can use it for free and even help improve it. They are already working on adding even more features, like using advanced neural networks to create new types of molecular fingerprints. For a curious teenager or a seasoned scientist, this library represents a shift from messy, custom-built scripts to a streamlined, professional workflow where building a machine learning model for molecules is as easy as snapping together Lego bricks. It turns the complex, chaotic world of chemical data into something organized, efficient, and ready for the future of drug discovery.

Technical Summary: scikit-fingerprints

Problem Statement

Chemoinformatics workflows typically require converting molecular graphs into fixed-length numerical vectors (fingerprints) to enable machine learning (ML) processing. While molecular fingerprints are foundational to tasks like property prediction, virtual screening, and chemical space visualization, existing open-source toolkits (RDKit, CDK, Open Babel) are not natively compatible with the Python ML ecosystem based on scikit-learn conventions.

These legacy toolkits expose object-oriented APIs tied to their specific molecule types, lack support for the scikit-learn interface, and offer limited parallelization capabilities. Consequently, building robust Quantitative Structure-Activity Relationship (QSAR) or Quantitative Structure-Property Relationship (QSPR) pipelines often requires stitching together ad-hoc scripts. This approach is repetitive, error-prone, difficult to reproduce, and hinders the transition from experimental scripts to production-grade MLOps deployments.

Methodology

The authors present scikit-fingerprints, a Python library built on top of RDKit that bridges the gap between chemoinformatics and the scikit-learn ecosystem. The library adheres strictly to scikit-learn API conventions, ensuring that molecular processing components can be treated as composable building blocks within standard ML pipelines.

Key methodological design choices include:

Unified Interfaces: All components (fingerprints, filters, splitters, estimators) inherit from scikit-learn base classes. Fingerprints and preprocessors act as stateless transformers (exposing .transform()), while applicability domain (AD) estimators follow the standard estimator interface (.fit(), .predict()).
Parallelization and Efficiency: Computations are parallelized using joblib across CPU cores, with support for distributed computation via a Dask backend. The library utilizes mini-batching and sparse matrix representations (SciPy CSR) to handle the high sparsity of molecular fingerprints, significantly reducing memory usage.
Extensibility: The library is designed to be extensible, allowing users to implement custom filters or fingerprints by inheriting from base classes and overriding specific methods.
Optimized Hyperparameter Search: To address the computational bottleneck of recomputing fingerprints during grid search, the library implements a nested search loop (FingerprintEstimatorGridSearch). This allows fingerprints to be computed once per configuration and reused across downstream model hyperparameter tuning, rather than recomputing for every estimator fold.

Key Contributions

The library provides a comprehensive suite of functionalities covering the entire molecular ML workflow:

Molecular Fingerprints: Over 30 fingerprint implementations (e.g., ECFP, MACCS, E3FP, Mordred, MAP4) spanning substructural, hashed, descriptor-based, and conformer-based families. These are exposed as scikit-learn transformers supporting both dense and sparse outputs.
Molecular Filters: Over 30 filters for removing undesirable compounds, including physicochemical rules (Lipinski, Ghose, Veber, REOS) and substructural alerts (PAINS, Brenk, Glaxo).
Distance and Similarity Measures: Implementation of over a dozen measures (e.g., Tanimoto, Dice, MCS, Fraggle) as functions compatible with scikit-learn algorithms like UMAP and HDBSCAN. This includes optimized bulk computation of $N \times N$ similarity matrices using sparse operations.
Model Selection and Splitting: Scaffold-aware and diversity-aware train-test splitting strategies (Bemis-Murcko, Butina, MaxMin, PubChem time split) that match scikit-learn signatures.
Applicability Domain (AD) Estimation: 11 AD estimators (e.g., kNN, leverage, convex hull, TOPKAT) to quantify prediction reliability, implemented as dataset-dependent estimators.
Preprocessing and Datasets: Utilities for standardizing molecules (MolStandardizer), generating 3D conformers (ETKDGv3), and loading curated benchmark datasets (MoleculeNet, TDC, LRGB, MoleculeACE) directly from the HuggingFace Hub.
Virtual Screening Metrics: Dedicated metrics such as Enrichment Factor, RIE, and BEDROC for evaluating ranking performance.

Results and Benchmarks

The authors evaluated the library using the HIV dataset from MoleculeNet (34,000 compounds) on a 14-core CPU. Key performance findings include:

Hyperparameter Tuning: The nested search loop significantly reduces tuning time. For a large grid search, the library required only 6 fingerprint computations compared to 810 for a standard scikit-learn GridSearchCV approach. On a dataset of 10,000 molecules, this resulted in a time saving of nearly 9.5 minutes.
PubChem Fingerprint Calculation: A local, parallelized implementation of the PubChem (CACTVS) fingerprint using SMARTS patterns was shown to be considerably faster than the standard REST API approach, which suffers from rate limiting and HTTP overhead.
Bulk Similarity Computation: The library's sparse matrix-based implementation of bulk Tanimoto similarity ( $N \times N$ ) demonstrated superior speed and scalability compared to RDKit's one-to-many approach, particularly for larger datasets.
Large-Scale Scalability: The library successfully computed 2048-bit ECFP4 fingerprints for datasets containing up to 7.1 million molecules (Mcule In Stock subset) on commodity hardware. Sparse representations reduced memory usage by a factor of 39–45 compared to dense representations (e.g., reducing 13.6 GB to 312 MB for the Mcule dataset).

Significance and Claims

The paper claims that scikit-fingerprints lowers the barrier to reproducible, production-ready molecular machine learning by unifying chemoinformatics tools under a single, familiar scikit-learn interface. By enabling entire workflows—from raw SMILES strings to serialized, deployable models—to be assembled from composable building blocks, the library facilitates:

Faster prototyping through unified interfaces and efficient parallelization.
Easier reproduction via standardized pipelines and built-in benchmark datasets.
Simpler deployment by leveraging the mature tooling of the surrounding Python ML ecosystem.

The authors emphasize that the library is not merely a wrapper for RDKit but introduces novel methods (such as specific AD estimators and filters) and optimizations (nested search, sparse bulk similarity) that address specific limitations in current chemoinformatics workflows. The project is fully open-source (MIT license) and actively developed, with future plans to integrate neural network-based embeddings and additional clustering/diversity picking algorithms.