# auto-sklearn: scikit-learn estimators that pick their own models, and what that costs

> A research-derived AutoML toolkit that fits model selection, preprocessing and hyperparameter tuning behind the scikit-learn estimator interface, pinned to a scikit-learn version from 2021.

**automl/auto-sklearn** — Automated Machine Learning with scikit-learn

- Repository: https://github.com/automl/auto-sklearn
- Website: https://automl.github.io/auto-sklearn
- Stars: 8,138 · Forks: 1,323
- Language: Python
- License: BSD-3-Clause
- Published: 2026-10-06 · Updated: 2026-10-06 · Language: en
- Canonical page: https://hysenlabs.com/projects/automl-auto-sklearn

## The four-line interface and what sits behind it

The README's selling point is brevity. The whole estimator fits into four lines:

```python
import autosklearn.classification
cls = autosklearn.classification.AutoSklearnClassifier()
cls.fit(X_train, y_train)
predictions = cls.predict(X_test)
```

`AutoSklearnClassifier` satisfies the scikit-learn estimator protocol, so it drops into `Pipeline`, `cross_val_score` and `GridSearchCV` wherever a classifier would go. The repository description calls it a drop-in replacement for a scikit-learn estimator, and the API reference links out to the hosted manual rather than duplicating it.

What runs inside that `fit` call is the actual research contribution, and the repository topics name the pieces: automated machine learning, Bayesian optimization, hyperparameter optimization, meta-learning and SMAC. The mechanism described in the Auto-sklearn 2.0 paper is to fit a meta-model on a collection of datasets, warm-start the search from what worked on similar problems, then refine it against the actual data. The README's pipeline diagram in `doc/images/askl_pipeline.png` is the visual version of that, showing the series of transformations a single fit applies.

So the trade is explicit. You give up control of the pipeline in exchange for a good starting point, and you pay in compute time, because the search has to actually run rather than start from a guess.

## The scikit-learn pin is the real constraint

The single most consequential line in this repository is not in the README. It is in `requirements.txt`, which pins the estimator library to a narrow window:

```text
scikit-learn>=0.24.0,<0.25.0
```

That range is scikit-learn 0.24, a generation released in 2021. It means a current scikit-learn installation will not satisfy this resolver, and installing auto-sklearn into an environment that already has a modern scikit-learn either fails or forces you to downgrade it. For research work in a dedicated virtual environment or a container that is fine. For a shared analytics environment or a service that also uses scikit-learn directly, it is a hard blocker rather than an inconvenience.

The rest of the dependency list tells you what the search engine is made of: `ConfigSpace>=0.4.21,<0.5` for the configuration space, `smac>=1.2,<1.3` for the optimizer, `pynisher` for random search, and `pyrfr>=0.8.1,<0.9` for random forests, which is what the meta-learning component is built on. `dask`, `distributed`, `pandas`, `liac-arff`, `threadpoolctl`, `tqdm` and `numpy`/`scipy` complete the set.

Those upper bounds are not accidental. The v0.14.7 hotfix exists specifically to add them, and its note says it locks `ConfigSpace` to `<0.5.0` and `smac` to `<1.3` and adds upper bounds on the `automl` packages to help prevent further issues. The project's own release history records that letting these dependencies float broke something.

## POSIX only, enforced at install time

The second constraint is in `setup.py`, which opens with a guard that raises a `ValueError` before any package metadata is built:

```python
if os.name != "posix":
    raise ValueError(
        "Detected unsupported operating system: %s. Please check "
        "the compability information of auto-sklearn: https://automl.github.io"
        "/auto-sklearn/master/installation.html#windows-osx-compatibility"
        % sys.platform
    )
+```

The error text points at a documentation section called Windows and macOS compatibility, and it also misspells compatibility, which suggests the wording has not been revisited in a while. The practical effect is that installation fails outright on Windows and on macOS, and you need Linux, WSL or a container.

The repository ships a Dockerfile that handles this properly, and it is worth reading because it shows the project's assumptions in full. It starts from `ubuntu:20.04`, sets the locale to en_US.UTF-8 with a comment noting a workaround for issue 867, and installs `python3-dev`, `build-essential` and `swig`. The last of those is not incidental: `pyrfr` has a compiled component, so a C++ toolchain is a real prerequisite rather than a convenience.

It also pins thread counts to one across OpenBLAS, MKL, BLAS and OpenMP. That is the right call for this workload, since oversubscribed nested parallelism turns a model fit into thrashing, and it is one of the few projects that thinks about it explicitly.

## What v0.15.0 added, and how long ago that was

The current release is v0.15.0, published on 2023-02-13, and its changelog is the best single document for understanding where the project stopped. It adds initial support for multi-objective Auto-sklearn, meaning you can optimise for something like accuracy and inference time together rather than a single metric. It adds initial support for text features, where columns identified as string columns are tokenized using scikit-learn's own methods.

Smaller entries are more revealing about the internals. Support for passing X data to metrics exists to satisfy fairlearn metrics, which need the features to compute group fairness measures. There is an exposed interface for controlling how the toolkit performs dataset compression when required, and a documented example of interrupting the search with a callback that implements a naive early stopping. Two maintenance entries move selector-model construction from import time to construction time to improve import speed, and update StopWatch into a context manager.

The date matters more than any of it. The most recent release is from February 2023, and the release before it, v0.14.7, was published in August 2022 with a note that it was generated later but had been on PyPI for a while. The repository is not archived and the last push was on 2026-09-15, so there is current work on the `development` branch. But a project whose newest published version is more than three years old while its dependency floor is pinned to 2021 is telling you something about the maintenance posture, and the sensible reading is that this is a maintained-by-occasional-commits research codebase rather than an actively released product.

## The examples directory tells you the intended audience

The `examples/` directory is organised into numbered tiers, and the numbering is the clearest statement of who this is for: `examples/20_basic/`, `examples/40_advanced/`, `examples/60_search/` and `examples/80_extending/`, with a `README.txt` alongside.

That progression is a curriculum. Basic examples get you a working classifier. Advanced covers the configuration options. Search examples get into the optimizer behaviour and time limits, which is where the practical decisions live. Extending is for people writing their own components, which tells you the toolkit is designed to be modified rather than only configured.

The repository layout around it supports that audience. There is a `test/` directory configured in `pyproject.toml` to run under pytest with `--forked` and a minimum pytest version of 3.7, with coverage configured for branch tracking. Formatting is pinned in the same file: black targeting Python 3.7 syntax, isort with a custom section ordering that puts typing and test libraries in their own groups, and pydocstyle on the numpy convention. There is a `Dockerfile`, a `Makefile`, a `.pre-commit-config.yaml`, a `CITATION.cff` and a `MANIFEST.in`.

The citation file is a signal worth reading plainly. This is research software with a paper trail, and the README asks for citation in scientific publications while linking two papers, the 2015 NeurIPS paper and the 2020 Auto-sklearn 2.0 arXiv preprint. If you are building something commercial on it, that framing still holds, but the feature priorities follow academic needs rather than production ones.

## Where auto-sklearn loses to simpler and newer options

The honest comparison is against two very different alternatives, and auto-sklearn sits awkwardly between them.

Against a hand-written pipeline with scikit-learn's own tuning tools, auto-sklearn loses on cost and wins on starting quality. A `GridSearchCV` or `RandomizedSearchCV` over three estimators takes minutes and gives you a model you fully understand. auto-sklearn may give you a better model for a dataset it has seen something like, and you have no way to know in advance whether it will, because the meta-model's warm start is a probabilistic bet. If you already know your problem shape, the simpler option is usually correct.

Against a modern gradient boosting implementation, auto-sklearn loses on raw predictive strength. Its meta-dataset was assembled years ago, and its search space was defined around the estimators available at the time. The 0.15.0 changelog shows maintainers still adding multi-objective support and text features, which are features newer toolkits have had built in for longer. On a tabular problem today, a well-tuned gradient boosting model will usually beat whatever auto-sklearn returns for a fraction of the effort.

What auto-sklearn remains genuinely good at is being a baseline. Give it a dataset and a generous time budget and it will return a properly cross-validated model with preprocessing applied, which saves you the tedium of assembling and tuning a pipeline when the goal is a defensible starting number rather than a final system. That is a real job, and this does it in one call. The mistake is expecting the baseline to become the product.

## Conclusion

auto-sklearn is a legitimate choice for a research baseline or a tabular problem where you want a strong model fast and do not mind a long fit, and the four-line estimator interface makes it drop into a scikit-learn pipeline without ceremony. Two constraints decide whether it is usable for you, and both are visible in the repository rather than buried. The dependency file pins `scikit-learn>=0.24.0,<0.25.0`, so you are pinned to a scikit-learn generation from 2021 and cannot share an environment with a current installation, and `setup.py` raises on any system where `os.name` is not `posix`, which rules out Windows and macOS despite a Dockerfile that builds on Ubuntu. Check those two against your environment before reading anything else. If both fit, start from `examples/20_basic/` and use the time limit rather than the default budget.

## FAQ

### What is AutoML used for?

AutoML automates the parts of building a supervised model that are repetitive rather than creative: choosing an estimator, tuning its hyperparameters and assembling the preprocessing pipeline. auto-sklearn does this behind a scikit-learn estimator interface, so `AutoSklearnClassifier` can be dropped into a Pipeline or cross-validation loop like any other classifier, at the cost of a much longer fit.

### What is sklearn and what is its purpose?

scikit-learn is a Python library of classical machine learning algorithms with a shared estimator API, the same `fit`, `predict` and `score` contract that auto-sklearn implements. Its purpose is to make algorithm comparison and pipeline assembly consistent. auto-sklearn extends that contract by automating the search for which estimator and settings to use.

### Is scikit-learn still relevant in 2026?

It remains the standard Python library for classical machine learning, and its estimator API is still the integration point most tools target. The constraint auto-sklearn adds is version-specific rather than general: its requirements file pins scikit-learn to `>=0.24.0,<0.25.0`, so it cannot be installed alongside a current scikit-learn release in the same environment.

### What is AutoML in Python and how does it work?

In auto-sklearn the search is warm-started by a meta-model fitted on many datasets in advance, then refined against your specific data by the SMAC optimizer over a configuration space. In the 2.0 design the fit call applies a series of transformations including preprocessing, which the README shows in its pipeline diagram. The result is one estimator object rather than a list of scores to compare yourself.

## Sources

- [automl/auto-sklearn on GitHub](https://github.com/automl/auto-sklearn)
- [License: BSD-3-Clause](https://github.com/automl/auto-sklearn/blob/development/LICENSE)
- [Project website](https://automl.github.io/auto-sklearn)
- [README](https://github.com/automl/auto-sklearn/blob/development/README.md)
- [Releases](https://github.com/automl/auto-sklearn/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/automl-auto-sklearn