To patch scikit-learn with Intel® Extension for Scikit-learn* is to replace stock scikit-learn algorithms with their optimized versions provided by the extension. You can always undo the patch.

There are different ways to patch scikit-learn:


These patching methods are interchangeable. They support different enabling scenarios while producing the same result.

  • Without editing the code of a scikit-learn application by using the following command line flag:

    python -m sklearnex
  • Directly from the script:

    from sklearnex import patch_sklearn


You have to import scikit-learn after these lines. Otherwise, the patching will not affect the original scikit-learn estimators.

  • Through importing the desired estimator from the sklearnex module in your script:

    from sklearnex.neighbors import NearestNeighbors
  • Through global patching to enable patching for your scikit-learn installation for all further runs:

    python -m sklearnex.glob patch_sklearn
global patching

Use global patching to patch all your scikit-learn applications without any additional actions.


  • Intel® Extension for Scikit-learn*

  • Scikit-learn

  • read and write permissions to Scikit-learn files

To patch all supported algorithms, run:

python -m sklearnex.glob patch_sklearn

If you want to patch only some algorithms, use --algorithm or -a keys with a list of algorithms to patch.

For example, to patch only SVC and RandomForestClassifier estimators, run:

python -m sklearnex.glob patch_sklearn -a svc random_forest_classifier

If you do not want to receive patching notifications, then use --no-verbose or -nv keys:

python -m sklearnex.glob patch_sklearn -a svc random_forest_classifier -nv


If you run the global patching command several times with different parameters, then only the last configuration will be applied.

To disable global patching, use the following command:

python -m sklearnex.glob unpatch_sklearn

You can also enable global patching in your code. To do this, use the patch_sklearn function with the global_patch argument:

from sklearnex import patch_sklearn
import sklearn

After that, Scikit-learn patches will be enabled in the current application and in all others that use the same environment.

To disable global patching via code, use the global_patch argument in the unpatch_sklearn function:

from sklearnex import unpatch_sklearn


If you clone an environment with enabled global patching, it will already be applied in the new environment.


To undo the patch is to return to the use of original scikit-learn implementation and replace patched algorithms with the stock scikit-learn algorithms. Unpatching requires scikit-learn to be re-imported again:

# Re-import scikit-learn algorithms after the unpatch:
from sklearn.cluster import KMeans

How it works

The extension replaces the original estimators in scikit-learn modules with the optimized ones. If the desired algorithm parameters are not supported by the Intel® Extension for Scikit-learn*, then the result of the original scikit-learn is returned.

See also

Verbose Mode