# scikit-learn-intelex: Intel Acceleration for Scikit-learn on CPUs and GPUs

> scikit-learn-intelex is an Apache-2.0 licensed Python extension that accelerates scikit-learn workloads by replacing calls to sklearn estimators with optimized oneDAL implementations, requiring as few as two import lines to enable and no changes to existing sklearn code.

**uxlfoundation/scikit-learn-intelex** —  Extension for Scikit-learn is a seamless way to speed up your Scikit-learn application

- Repository: https://github.com/uxlfoundation/scikit-learn-intelex
- Website: https://uxlfoundation.github.io/scikit-learn-intelex/
- Stars: 1,355 · Forks: 191
- Language: Python
- License: Apache-2.0
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/uxlfoundation-scikit-learn-intelex

## What scikit-learn-intelex does and who it targets

scikit-learn-intelex is an accelerator for scikit-learn, the most widely used Python library for machine learning on tabular data. The extension targets data scientists and engineers who have existing sklearn code and want faster training and inference on Intel CPUs without rewriting their pipelines.

The acceleration mechanism works by intercepting calls to sklearn estimator classes and redirecting them to oneDAL (oneAPI Data Analytics Library), Intel's optimized analytics library. The README describes this as patching scikit-learn: after calling `patch_sklearn()`, sklearn's DBSCAN, KMeans, RandomForest, and other supported estimators run against optimized Intel implementations rather than the original sklearn code.

The README states an average speedup of 8.5x on training and inference with equivalent mathematical accuracy, with claims of up to 100X acceleration for specific workloads under optimal conditions. These figures come from Intel's own benchmarks, referenced in the README via a link to the IntelPython/scikit-learn_bench repository.

The extension supports Python 3.10 through 3.14 and sklearn 1.6 through 1.9, as of the 2026.1.0 release. It works across single-node and multi-node configurations and includes GPU support for Intel GPUs with additional system software requirements.

## How patch_sklearn replaces sklearn calls with oneDAL

The patching mechanism is the extension's primary design decision. Rather than asking users to import estimators from a different namespace, the extension modifies the sklearn module in-place when `patch_sklearn()` is called. From that point forward, code that imports from sklearn and uses its estimators gets the accelerated implementations automatically.

The README explains that acceleration is achieved through vector instructions, AI hardware-specific memory optimizations, and threading optimizations implemented in oneDAL. The patching works at the Python level: sklearn class references are replaced with oneDAL-backed implementations that expose the same API.

This has a specific implication for compatibility. Code that was written for sklearn will behave the same way after patching, with the same API calls, the same input and output shapes, and the same hyperparameter names. The extension does not require changes to model training code, feature preprocessing pipelines, or downstream prediction code. The README is explicit that existing sklearn applications can be used without code modifications.

When an estimator is not yet covered by the extension, the call falls through to the original sklearn implementation. The extension does not break workflows for unsupported estimators; it simply provides no acceleration for them.

## Installing the extension and enabling CPU acceleration

Installation uses the standard pip command:

```bash
pip install scikit-learn-intelex
```

The package is also available through conda-forge. Full installation options including alternative channels are documented at the project's documentation site.

Enabling CPU acceleration in an existing script requires two lines before any sklearn import:

```python
import numpy as np
from sklearnex import patch_sklearn
patch_sklearn()

from sklearn.cluster import DBSCAN

X = np.array([[1., 2.], [2., 2.], [2., 3.],
              [8., 7.], [8., 8.], [25., 80.]], dtype=np.float32)
clustering = DBSCAN(eps=3, min_samples=2).fit(X)
```

The `patch_sklearn()` call must come before the sklearn import, not after. The rest of the code is identical to unpatched sklearn usage. After the patch, the DBSCAN fit runs against the oneDAL implementation rather than sklearn's default.

The README notes that the extension can also be enabled or disabled at the command line or through other patching mechanisms, documented at the project's patching guide.

## GPU support and what it requires

The extension supports Intel GPUs for some estimators using the oneAPI SYCL programming model. GPU execution requires additional system software beyond the Python package itself. The README links to Intel's oneAPI DPC++ system requirements as the reference for what must be installed.

Enabling GPU execution uses the `config_context` context manager with a `target_offload` argument:

```python
import numpy as np
from sklearnex import patch_sklearn, config_context
patch_sklearn()

from sklearn.cluster import DBSCAN

X = np.array([[1., 2.], [2., 2.], [2., 3.],
              [8., 7.], [8., 8.], [25., 80.]], dtype=np.float32)
with config_context(target_offload="gpu:0"):
    clustering = DBSCAN(eps=3, min_samples=2).fit(X)
```

The `target_offload="gpu:0"` argument targets the first detected Intel GPU. Code outside the `config_context` block runs on CPU. The GPU path is not a blanket replacement for all estimators: only estimators that have been explicitly optimized for GPU execution in oneDAL will run on the GPU; others fall back to CPU.

The GPU support distinguishes scikit-learn-intelex from the base sklearn in both capability and complexity. The system software dependency makes GPU-enabled deployments heavier to configure than CPU-only ones.

## Using the extension without patching

An alternative to patching is importing estimators directly from the `sklearnex` namespace. This approach avoids modifying the sklearn module and makes the accelerated estimator choice explicit in the import:

```python
import numpy as np
from sklearnex.cluster import DBSCAN

X = np.array([[1., 2.], [2., 2.], [2., 3.],
              [8., 7.], [8., 8.], [25., 80.]], dtype=np.float32)
clustering = DBSCAN(eps=3, min_samples=2).fit(X)
```

This is useful in codebases where a team wants explicit control over which estimators are accelerated rather than applying acceleration globally through patching. The `config_context` mechanism for GPU targeting works the same way in the no-patch path.

The README offers both approaches without recommending one over the other. The patching approach requires fewer code changes in an existing codebase; the direct import approach is more explicit and easier to reason about in a code review.

## Supported estimators, release cadence, and licence

The extension does not accelerate every sklearn estimator. Coverage grows with each release as Intel adds more oneDAL implementations. When an estimator is not covered, the extension falls back to the original sklearn implementation silently. Teams evaluating the extension for a specific pipeline should check the documentation's compatibility matrix to confirm that the estimators they use are covered.

The project releases frequently: 2025.11.0 in March 2026, 2026.0.0 in May 2026, and 2026.1.0 in June 2026. The last push was on 2026-09-24. The version numbering follows a year-dot-minor scheme.

The project is licensed under Apache-2.0, which permits commercial use, modification, and distribution without copyleft obligations. The extension was originally developed by Intel Corporation, as noted in the copyright headers, and is now maintained under the UXL Foundation organization.

CURAPS cuML, maintained by NVIDIA for its RAPIDS project, is an alternative for GPU-accelerated sklearn-compatible machine learning. The architectural difference is hardware target: cuML is designed for NVIDIA GPUs using CUDA, while scikit-learn-intelex targets Intel CPUs and Intel GPUs using oneAPI. Both projects keep the sklearn API, but they do not run on the same hardware. Teams on NVIDIA hardware should evaluate cuML; teams on Intel hardware should evaluate scikit-learn-intelex.

## Conclusion

scikit-learn-intelex is the right choice for data scientists and ML engineers working on Intel CPUs who run sklearn training or inference jobs that take noticeable time and want faster results without rewriting their code. The patching approach means most existing sklearn workflows adopt the extension in minutes. It is not the right choice for teams running NVIDIA GPUs (where cuML is the appropriate accelerator), for users on Python versions below 3.10, or for sklearn estimators that the extension does not yet cover (in those cases, sklearn falls back to its own implementation automatically). Verify which sklearn version you are using against the support matrix (sklearn 1.6 to 1.9 as of the 2026.1.0 release) before deploying the extension in a production pipeline.

## FAQ

### What is scikit-learn-intelex?

scikit-learn-intelex is an Apache-2.0 licensed Python extension that accelerates scikit-learn estimators by replacing their implementation with optimized Intel oneDAL calls. It supports CPU and Intel GPU targets and maintains full compatibility with the sklearn API.

### Does scikit-learn-intelex require an Intel processor?

The README does not explicitly state a hardware requirement for CPU usage. GPU support requires an Intel GPU and the additional oneAPI DPC++ system software documented on Intel's developer site. The README does not describe testing on non-Intel CPUs.

### Can I use scikit-learn-intelex without modifying existing sklearn code?

Yes. After importing and calling patch_sklearn() before any sklearn import, existing sklearn code runs against the accelerated implementations without any other changes. The patch must come before the sklearn import statement.

### How do I check whether a specific sklearn estimator is accelerated?

The README does not include an estimator compatibility list inline, but links to the project's documentation site at uxlfoundation.github.io/scikit-learn-intelex/ where the supported estimator list and sklearn version compatibility matrix are maintained.

## Sources

- [License: Apache-2.0](https://github.com/uxlfoundation/scikit-learn-intelex/blob/main/LICENSE)
- [Project website](https://uxlfoundation.github.io/scikit-learn-intelex/)
- [README](https://github.com/uxlfoundation/scikit-learn-intelex/blob/main/README.md)
- [Releases](https://github.com/uxlfoundation/scikit-learn-intelex/releases)
- [uxlfoundation/scikit-learn-intelex on GitHub](https://github.com/uxlfoundation/scikit-learn-intelex)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/uxlfoundation-scikit-learn-intelex