scikit-learn-intelex 2025.7.0__py312-none-win_amd64.whl → 2025.9.0__py312-none-win_amd64.whl

scikit_learn_intelex-2025.9.0.data/data/Lib/site-packages/sklearnex/utils/_array_api.py

@@ -0,0 +1,217 @@
+# ==============================================================================
+# Copyright 2024 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+"""Tools to support array_api."""
+
+import math
+from collections.abc import Callable
+from typing import Union
+
+import numpy as np
+import scipy.linalg as linalg
+from sklearn.covariance import log_likelihood as _sklearn_log_likelihood
+
+from daal4py.sklearn._utils import sklearn_check_version
+from onedal.utils._array_api import _get_sycl_namespace, _is_numpy_namespace
+
+from ..base import oneDALEstimator
+
+if sklearn_check_version("1.6"):
+    from ..base import Tags
+
+if sklearn_check_version("1.2"):
+    from sklearn.utils._array_api import get_namespace as sklearn_get_namespace
+
+
+def get_namespace(*arrays):
+    """Get namespace of arrays.
+
+    Introspect `arrays` arguments and return their common Array API
+    compatible namespace object, if any. NumPy 1.22 and later can
+    construct such containers using the `numpy.array_api` namespace
+    for instance.
+
+    This function will return the namespace of SYCL-related arrays
+    which define the __sycl_usm_array_interface__ attribute
+    regardless of array_api support, the configuration of
+    array_api_dispatch, or scikit-learn version.
+
+    See: https://numpy.org/neps/nep-0047-array-api-standard.html
+
+    If `arrays` are regular numpy arrays, an instance of the
+    `_NumPyApiWrapper` compatibility wrapper is returned instead.
+
+    Namespace support is not enabled by default. To enabled it
+    call:
+
+      sklearn.set_config(array_api_dispatch=True)
+
+    or:
+
+      with sklearn.config_context(array_api_dispatch=True):
+          # your code here
+
+    Otherwise an instance of the `_NumPyApiWrapper`
+    compatibility wrapper is always returned irrespective of
+    the fact that arrays implement the `__array_namespace__`
+    protocol or not.
+
+    Parameters
+    ----------
+    *arrays : array objects
+        Array objects.
+
+    Returns
+    -------
+    namespace : module
+        Namespace shared by array objects.
+
+    is_array_api : bool
+        True of the arrays are containers that implement the Array API spec.
+    """
+
+    sycl_type, xp, is_array_api_compliant = _get_sycl_namespace(*arrays)
+
+    if sycl_type:
+        return xp, is_array_api_compliant
+    elif sklearn_check_version("1.2"):
+        return sklearn_get_namespace(*arrays)
+    else:
+        return np, False
+
+
+def _enable_array_api(original_class: type[oneDALEstimator]) -> type[oneDALEstimator]:
+    if sklearn_check_version("1.6"):
+
+        def __sklearn_tags__(self) -> Tags:
+            sktags = super(original_class, self).__sklearn_tags__()
+            sktags.onedal_array_api = True
+            return sktags
+
+        original_class.__sklearn_tags__ = __sklearn_tags__
+
+    elif sklearn_check_version("1.3"):
+
+        def _more_tags(self) -> dict[str, bool]:
+            return {"onedal_array_api": True}
+
+        original_class._more_tags = _more_tags
+
+    return original_class
+
+
+def enable_array_api(
+    class_or_str: Union[type[oneDALEstimator], str],
+) -> Union[type[oneDALEstimator], Callable]:
+    """Enable sklearnex to use dpctl, dpnp or array API inputs in oneDAL offloading.
+
+    This wrapper sets the proper flags/tags for the sklearnex infrastructure
+    to maintain the data framework, as the estimator can use it natively.
+
+    Parameters
+    ----------
+    class_or_str : oneDALEstimator subclass or str
+        Class which should enable data zero-copy support in sklearnex. By
+        default it will enable for sklearn versions >1.3. If the wrapper is
+        decorated with an argument, it must be a string defining the oldest
+        sklearn version where array API support begins.
+
+    Returns
+    -------
+    cls or wrapper : modified oneDALEstimator subclass or wrapper
+        Estimator class or wrapper.
+
+    Examples
+    --------
+    @enable_array_api  # default array API support
+    class PCA():
+        ...
+
+    @enable_array_api("1.5")  # array API support for sklearn > 1.5
+    class Ridge():
+        ...
+    """
+    if isinstance(class_or_str, str):
+        # enable array_api for the estimator for a given sklearn version str
+        if sklearn_check_version(class_or_str):
+            return _enable_array_api
+        else:
+            # do not apply the wrapper as it is not supported
+            return lambda x: x
+    else:
+        # default setting (apply array_api enablement for sklearn >=1.3)
+        return _enable_array_api(class_or_str)
+
+
+def _pinvh(a, atol=None, rtol=None, lower=True, return_rank=False, check_finite=True):
+    # array API enabled pinvh implementation, via direct translation of scipy.linalg.pinhv
+    # this should be considered a temporary stopgap until implemented in oneDAL
+    xp, _ = get_namespace(a)
+    # fall back to scipy if the namespace is of a numpy origin
+    if _is_numpy_namespace(xp):
+        return linalg.pinvh(
+            a,
+            atol=atol,
+            rtol=rtol,
+            lower=lower,
+            return_rank=return_rank,
+            check_finite=check_finite,
+        )
+
+    if check_finite:
+        raise NotImplementedError("finite checking does not occur in sklearnex's pinvh")
+
+    s, u = xp.linalg.eigh(a)
+    maxS = xp.max(xp.abs(s))
+
+    atol = 0.0 if atol is None else atol
+    rtol = max(a.shape) * xp.finfo(u.dtype).eps if (rtol is None) else rtol
+
+    if (atol < 0.0) or (rtol < 0.0):
+        raise ValueError("atol and rtol values must be positive.")
+
+    val = atol + maxS * rtol
+    above_cutoff = xp.nonzero(abs(s) > val)[0]
+
+    psigma_diag = 1.0 / xp.take(s, above_cutoff)
+    u = xp.take(u, above_cutoff, axis=1)
+
+    uconj = xp.conj(u) if xp.isdtype(u.dtype, kind="complex floating") else u
+
+    B = (u * psigma_diag) @ uconj.T
+
+    if return_rank:
+        return B, len(psigma_diag)
+    else:
+        return B
+
+
+def log_likelihood(emp_cov, precision):
+    # this is to compensate for a lack of array API support in sklearn
+    # even though it exists for ``fast_logdet``
+    xp, _ = get_namespace(emp_cov, precision)
+    p = precision.shape[0]
+    # extract sklearn.utils.extmath.fast_logdet for dpnp/dpctl support
+    sign, ld = xp.linalg.slogdet(precision)
+    if not sign > 0:
+        ld = -xp.inf
+    log_likelihood_ = -xp.sum(emp_cov * precision) + ld
+    log_likelihood_ -= p * math.log(2 * math.pi)
+    log_likelihood_ /= 2.0
+    return log_likelihood_
+
+
+log_likelihood.__doc__ = _sklearn_log_likelihood.__doc__

scikit_learn_intelex-2025.9.0.data/data/Lib/site-packages/sklearnex/utils/parallel.py

@@ -0,0 +1,97 @@
+# ===============================================================================
+# Copyright 2023 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ===============================================================================
+
+import warnings
+from functools import update_wrapper
+
+from daal4py.sklearn._utils import sklearn_check_version
+
+from .._config import config_context, get_config
+
+# Replacement of _FuncWrapper is required to correctly propagate
+# the scikit-learn-intelex configuration functions to the joblib workers.
+if sklearn_check_version("1.7"):
+
+    class _FuncWrapper:
+        """Load the global configuration before calling the function."""
+
+        def __init__(self, function):
+            self.function = function
+            update_wrapper(self, self.function)
+
+        def with_config_and_warning_filters(self, config, warning_filters):
+            self.config = config
+            self.warning_filters = warning_filters
+            return self
+
+        def __call__(self, *args, **kwargs):
+            config = getattr(self, "config", {})
+            warning_filters = getattr(self, "warning_filters", [])
+            if not config or not warning_filters:
+                warnings.warn(
+                    (
+                        "`sklearn.utils.parallel.delayed` should be used with"
+                        " `sklearn.utils.parallel.Parallel` to make it possible to"
+                        " propagate the scikit-learn configuration of the current thread to"
+                        " the joblib workers."
+                    ),
+                    UserWarning,
+                )
+
+            with config_context(**config), warnings.catch_warnings():
+                warnings.filters = warning_filters
+                return self.function(*args, **kwargs)
+
+elif sklearn_check_version("1.2.1"):
+
+    class _FuncWrapper:
+        """Load the global configuration before calling the function."""
+
+        def __init__(self, function):
+            self.function = function
+            update_wrapper(self, self.function)
+
+        def with_config(self, config):
+            self.config = config
+            return self
+
+        def __call__(self, *args, **kwargs):
+            config = getattr(self, "config", None)
+            if config is None:
+                warnings.warn(
+                    "`sklearn.utils.parallel.delayed` should be used with "
+                    "`sklearn.utils.parallel.Parallel` to make it possible to propagate "
+                    "the scikit-learn configuration of the current thread to the "
+                    "joblib workers.",
+                    UserWarning,
+                )
+                config = {}
+            with config_context(**config):
+                return self.function(*args, **kwargs)
+
+else:
+
+    class _FuncWrapper:
+        """Load the global configuration before calling the function."""
+
+        def __init__(self, function):
+            self.function = function
+            self.config = get_config()
+            update_wrapper(self, self.function)
+
+        def __call__(self, *args, **kwargs):
+            with config_context(**self.config):
+                return self.function(*args, **kwargs)

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/utils/validation.py

@@ -16,6 +16,7 @@
 
 import math
 import numbers
+from collections.abc import Sequence
 
 import scipy.sparse as sp
 from sklearn.utils.validation import _assert_all_finite as _sklearn_assert_all_finite
@@ -124,7 +125,6 @@ def validate_data(
         # run local finite check
         allow_nan = ensure_all_finite == "allow-nan"
         # the return object from validate_data can be a single
-
         # element (either x or y) or both (as a tuple). An iterator along with
         # check_x and check_y can go through the output properly without
         # stacking layers of if statements to make sure the proper input_name
@@ -135,6 +135,24 @@ def validate_data(
         if check_y:
             assert_all_finite(next(arg), allow_nan=allow_nan, input_name="y")
 
+    if check_y and kwargs.get("y_numeric", False):
+        # validate_data does not do full dtype conversions, as it uses check_X_y
+        # oneDAL can make tables from [int32, float32, float64], requiring
+        # a dtype check and conversion. This will query the array_namespace and
+        # convert y as necessary. This is important especially for regressors.
+        outx, outy = out if check_x else (None, out)
+        yp, _ = get_namespace(outy)
+
+        # avoid using ``kwargs.get("dtype")`` as it will always set up the default
+        dtype = kwargs.get("dtype", (yp.float64, yp.float32, yp.int32))
+        if not isinstance(dtype, Sequence):
+            dtype = tuple(dtype)
+
+        if outy.dtype not in dtype:
+            # use asarray rather than astype because of numpy support
+            outy = yp.asarray(outy, dtype=dtype[0])
+            out = (outx, outy) if check_x else outy
+
     return out
 
 

{scikit_learn_intelex-2025.7.0.dist-info → scikit_learn_intelex-2025.9.0.dist-info}/METADATA

@@ -1,7 +1,7 @@
 Metadata-Version: 2.1
 Name: scikit-learn-intelex
-Version: 2025.7.0
-Summary: Intel(R) Extension for Scikit-learn is a seamless way to speed up your Scikit-learn application.
+Version: 2025.9.0
+Summary: Intel® Extension for Scikit-learn is a seamless way to speed up your Scikit-learn application.
 Home-page: https://github.com/intel/scikit-learn-intelex
 Author: Intel Corporation
 Author-email: onedal.maintainers@intel.com
@@ -30,113 +30,51 @@ Classifier: Topic :: Software Development
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
-Requires-Dist: daal ==2025.7.0
+Requires-Dist: daal ==2025.9.0
 Requires-Dist: numpy >=1.19
 Requires-Dist: scikit-learn >=0.22
 
 
 # Intel(R) Extension for Scikit-learn*
 
-[![Build Status](https://dev.azure.com/daal/daal4py/_apis/build/status/CI?branchName=master)](https://dev.azure.com/daal/daal4py/_build/latest?definitionId=9&branchName=master)
-[![Coverity Scan Build Status](https://scan.coverity.com/projects/21716/badge.svg)](https://scan.coverity.com/projects/daal4py)
 [![Join the community on GitHub Discussions](https://badgen.net/badge/join%20the%20discussion/on%20github/black?icon=github)](https://github.com/uxlfoundation/scikit-learn-intelex/discussions)
 [![PyPI Version](https://img.shields.io/pypi/v/scikit-learn-intelex)](https://pypi.org/project/scikit-learn-intelex/)
 [![Conda Version](https://img.shields.io/conda/vn/conda-forge/scikit-learn-intelex)](https://anaconda.org/conda-forge/scikit-learn-intelex)
 
-With Intel(R) Extension for Scikit-learn you can accelerate your Scikit-learn applications and still have full conformance with all Scikit-Learn APIs and algorithms. This is a free software AI accelerator that brings over 10-100X acceleration across a variety of applications. And you do not even need to change the existing code!
+Extension for Scikit-learn is a **free software AI accelerator** designed to deliver over **10-100X** acceleration to your existing scikit-learn code.
+The software acceleration is achieved with vector instructions, AI hardware-specific memory optimizations, threading, and optimizations.
 
-The acceleration is achieved through the use of the Intel(R) oneAPI Data Analytics Library ([oneDAL](https://github.com/uxlfoundation/oneDAL)). Patching scikit-learn makes it a well-suited machine learning framework for dealing with real-life problems.
 
-⚠️Intel(R) Extension for Scikit-learn contains scikit-learn patching functionality that was originally available in [**daal4py**](https://github.com/uxlfoundation/scikit-learn-intelex/tree/master/daal4py) package. All future updates for the patches will be available only in Intel(R) Extension for Scikit-learn. We recommend you to use scikit-learn-intelex package instead of daal4py.
-You can learn more about daal4py in [daal4py documentation](https://intelpython.github.io/daal4py).
+With Extension for Scikit-learn, you can:
 
-## 👀 Follow us on Medium
-
-We publish blogs on Medium, so [follow us](https://medium.com/intel-analytics-software/tagged/machine-learning) to learn tips and tricks for more efficient data analysis with the help of Intel(R) Extension for Scikit-learn. Here are our latest blogs:
-
-- [Save Time and Money with Intel Extension for Scikit-learn](https://medium.com/intel-analytics-software/save-time-and-money-with-intel-extension-for-scikit-learn-33627425ae4)
-- [Superior Machine Learning Performance on the Latest Intel Xeon Scalable Processors](https://medium.com/intel-analytics-software/superior-machine-learning-performance-on-the-latest-intel-xeon-scalable-processor-efdec279f5a3)
-- [Leverage Intel Optimizations in Scikit-Learn](https://medium.com/intel-analytics-software/leverage-intel-optimizations-in-scikit-learn-f562cb9d5544)
-- [Intel Gives Scikit-Learn the Performance Boost Data Scientists Need](https://medium.com/intel-analytics-software/intel-gives-scikit-learn-the-performance-boost-data-scientists-need-42eb47c80b18)
-- [From Hours to Minutes: 600x Faster SVM](https://medium.com/intel-analytics-software/from-hours-to-minutes-600x-faster-svm-647f904c31ae)
-- [Improve the Performance of XGBoost and LightGBM Inference](https://medium.com/intel-analytics-software/improving-the-performance-of-xgboost-and-lightgbm-inference-3b542c03447e)
-- [Accelerate Kaggle Challenges Using Intel AI Analytics Toolkit](https://medium.com/intel-analytics-software/accelerate-kaggle-challenges-using-intel-ai-analytics-toolkit-beb148f66d5a)
-- [Accelerate Your scikit-learn Applications](https://medium.com/intel-analytics-software/improving-the-performance-of-xgboost-and-lightgbm-inference-3b542c03447e)
-- [Accelerate Linear Models for Machine Learning](https://medium.com/intel-analytics-software/accelerating-linear-models-for-machine-learning-5a75ff50a0fe)
-- [Accelerate K-Means Clustering](https://medium.com/intel-analytics-software/accelerate-k-means-clustering-6385088788a1)
-
-## 🔗 Important links
-- [Notebook examples](https://github.com/uxlfoundation/scikit-learn-intelex/tree/master/examples/notebooks)
-- [Documentation](https://uxlfoundation.github.io/scikit-learn-intelex/)
-- [scikit-learn API and patching](https://uxlfoundation.github.io/scikit-learn-intelex/)
-- [Benchmark code](https://github.com/IntelPython/scikit-learn_bench)
-- [Building from Sources](https://github.com/uxlfoundation/scikit-learn-intelex/blob/master/INSTALL.md)
-- [About Intel(R) oneAPI Data Analytics Library](https://github.com/uxlfoundation/oneDAL)
-- [About Intel(R) daal4py](https://github.com/uxlfoundation/scikit-learn-intelex/tree/master/daal4py)
-
-## 💬 Support
-
-Report issues, ask questions, and provide suggestions using:
-
-- [GitHub Issues](https://github.com/uxlfoundation/scikit-learn-intelex/issues)
-- [GitHub Discussions](https://github.com/uxlfoundation/scikit-learn-intelex/discussions)
-- [Forum](https://community.intel.com/t5/Intel-Distribution-for-Python/bd-p/distribution-python)
-
-You may reach out to project maintainers privately at onedal.maintainers@intel.com
+* Speed up training and inference by up to 100x with equivalent mathematical accuracy
+* Benefit from performance improvements across different hardware configurations, including [GPUs](https://uxlfoundation.github.io/scikit-learn-intelex/latest/oneapi-gpu.html) and [multi-GPU](https://uxlfoundation.github.io/scikit-learn-intelex/latest/distributed-mode.html) configurations
+* Integrate the extension into your existing Scikit-learn applications without code modifications
+* Continue to use the open-source scikit-learn API
+* Enable and disable the extension with a couple of lines of code or at the command line
 
 # 🛠 Installation
 Intel(R) Extension for Scikit-learn is available at the [Python Package Index](https://pypi.org/project/scikit-learn-intelex/),
-on Anaconda Cloud in [Conda-Forge channel](https://anaconda.org/conda-forge/scikit-learn-intelex) and in [Intel channel](https://software.repos.intel.com/python/conda/).
+in [Conda-Forge](https://anaconda.org/conda-forge/scikit-learn-intelex) and in [Intel's conda channel](https://software.repos.intel.com/python/conda/).
 Intel(R) Extension for Scikit-learn is also available as a part of [Intel® oneAPI AI Analytics Toolkit](https://software.intel.com/content/www/us/en/develop/tools/oneapi/ai-analytics-toolkit.html) (AI Kit).
 
-- PyPi (recommended by default)
+To install through `pip`:
 
 ```shell
 pip install scikit-learn-intelex
 ```
 
-- Anaconda Cloud from Conda-Forge channel (recommended for conda users by default)
-
-```shell
-conda install -c conda-forge scikit-learn-intelex
-```
-
-- Anaconda Cloud from Intel channel (recommended for Intel® Distribution for Python users)
-
-```shell
-conda install -c https://software.repos.intel.com/python/conda/ scikit-learn-intelex
-```
-
-<details><summary>[Click to expand] ℹ️ Supported configurations </summary>
-
-#### 📦 PyPi channel
-
-| OS / Python version     | **Python 3.9** | **Python 3.10**| **Python 3.11**| **Python 3.12**| **Python 3.13**|
-| :-----------------------| :-------------:| :------------: | :------------: | :------------: | :------------: |
-|    **Linux**            |  [CPU, GPU]    |   [CPU, GPU]   |   [CPU, GPU]   |   [CPU, GPU]   |   [CPU, GPU]   |
-|    **Windows**          |  [CPU, GPU]    |   [CPU, GPU]   |   [CPU, GPU]   |   [CPU, GPU]   |   [CPU, GPU]   |
-
-#### 📦 Anaconda Cloud: Conda-Forge channel
-
-| OS / Python version     | **Python 3.9** | **Python 3.10**| **Python 3.11**| **Python 3.12**| **Python 3.13**|
-| :-----------------------| :-------------:| :------------: | :------------: | :------------: | :------------: |
-|    **Linux**            |  [CPU, GPU]    |   [CPU, GPU]   |   [CPU, GPU]   |   [CPU, GPU]   |   [CPU, GPU]   |
-|    **Windows**          |  [CPU, GPU]    |   [CPU, GPU]   |   [CPU, GPU]   |   [CPU, GPU]   |   [CPU, GPU]   |
-
-#### 📦 Anaconda Cloud: Intel channel
-
-| OS / Python version     | **Python 3.9** | **Python 3.10**| **Python 3.11**| **Python 3.12**| **Python 3.13**|
-| :-----------------------| :-------------:| :------------: | :------------: | :------------: | :------------: |
-|    **Linux**            |  [CPU, GPU]    |   [CPU, GPU]   |   [CPU, GPU]   |   [CPU, GPU]   |   [CPU, GPU]   |
-|    **Windows**          |  [CPU, GPU]    |   [CPU, GPU]   |   [CPU, GPU]   |   [CPU, GPU]   |   [CPU, GPU]   |
-
-</details>
+See the [documentation](https://uxlfoundation.github.io/scikit-learn-intelex/latest/quick-start.html#installation) for more details about
+supported platforms and other ways of installing it.
 
 You can [build the package from sources](https://github.com/uxlfoundation/scikit-learn-intelex/blob/master/INSTALL.md) as well.
 
 # ⚡️ Get Started
 
-Intel CPU optimizations patching
+Easiest way to benefit from accelerations from the extension is by patching scikit-learn with it:
+
+- **Enable CPU optimizations**
+
 ```py
 import numpy as np
 from sklearnex import patch_sklearn
@@ -149,7 +87,11 @@ X = np.array([[1., 2.], [2., 2.], [2., 3.],
 clustering = DBSCAN(eps=3, min_samples=2).fit(X)
 ```
 
-Intel GPU optimizations patching
+- **Enable GPU optimizations**
+
+    _Note: executing on GPU has [additional system software requirements](https://www.intel.com/content/www/us/en/developer/articles/system-requirements/intel-oneapi-dpcpp-system-requirements.html) - see [details](https://uxlfoundation.github.io/scikit-learn-intelex/latest/oneapi-gpu.html)._
+
+
 ```py
 import numpy as np
 from sklearnex import patch_sklearn, config_context
@@ -163,6 +105,34 @@ with config_context(target_offload="gpu:0"):
     clustering = DBSCAN(eps=3, min_samples=2).fit(X)
 ```
 
+### Usage without patching
+
+Alternatively, all functionalities are also available under a separate module which can be imported directly, without involving any patching.
+
+* To run on CPU:
+
+  ```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)
+  ```
+
+* To run on GPU:
+
+  ```python
+  import numpy as np
+  from sklearnex import config_context
+  from sklearnex.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)
+  ```
+
 # 🚀 Scikit-learn patching
 
 ![](https://raw.githubusercontent.com/intel/scikit-learn-intelex/master/doc/sources/_static/scikit-learn-acceleration-2021.2.3.PNG)
@@ -172,20 +142,41 @@ Configurations:
 
 [Benchmarks code](https://github.com/IntelPython/scikit-learn_bench)
 
-Intel(R) Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://uxlfoundation.github.io/scikit-learn-intelex/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/uxlfoundation/scikit-learn-intelex/issues).
+Intel(R) Extension for Scikit-learn patching affects performance of specific Scikit-learn functionality. Refer to the [list of supported algorithms and parameters](https://uxlfoundation.github.io/scikit-learn-intelex/latest/algorithms.html) for details. In cases when unsupported parameters are used, the package fallbacks into original Scikit-learn. If the patching does not cover your scenarios, [submit an issue on GitHub](https://github.com/uxlfoundation/scikit-learn-intelex/issues).
+
+Read more about it in the documentation for [scikit-learn patching](https://uxlfoundation.github.io/scikit-learn-intelex/latest/quick-start.html#patching).
+
+## 👀 Follow us on Medium
+
+We publish blogs on Medium, so [follow us](https://medium.com/intel-analytics-software/tagged/machine-learning) to learn tips and tricks for more efficient data analysis with the help of Intel(R) Extension for Scikit-learn. Here are our latest blogs:
+
+- [Save Time and Money with Intel Extension for Scikit-learn](https://medium.com/intel-analytics-software/save-time-and-money-with-intel-extension-for-scikit-learn-33627425ae4)
+- [Superior Machine Learning Performance on the Latest Intel Xeon Scalable Processors](https://medium.com/intel-analytics-software/superior-machine-learning-performance-on-the-latest-intel-xeon-scalable-processor-efdec279f5a3)
+- [Leverage Intel Optimizations in Scikit-Learn](https://medium.com/intel-analytics-software/leverage-intel-optimizations-in-scikit-learn-f562cb9d5544)
+- [Intel Gives Scikit-Learn the Performance Boost Data Scientists Need](https://medium.com/intel-analytics-software/intel-gives-scikit-learn-the-performance-boost-data-scientists-need-42eb47c80b18)
+- [From Hours to Minutes: 600x Faster SVM](https://medium.com/intel-analytics-software/from-hours-to-minutes-600x-faster-svm-647f904c31ae)
+- [Improve the Performance of XGBoost and LightGBM Inference](https://medium.com/intel-analytics-software/improving-the-performance-of-xgboost-and-lightgbm-inference-3b542c03447e)
+- [Accelerate Kaggle Challenges Using Intel AI Analytics Toolkit](https://medium.com/intel-analytics-software/accelerate-kaggle-challenges-using-intel-ai-analytics-toolkit-beb148f66d5a)
+- [Accelerate Your scikit-learn Applications](https://medium.com/intel-analytics-software/improving-the-performance-of-xgboost-and-lightgbm-inference-3b542c03447e)
+- [Accelerate Linear Models for Machine Learning](https://medium.com/intel-analytics-software/accelerating-linear-models-for-machine-learning-5a75ff50a0fe)
+- [Accelerate K-Means Clustering](https://medium.com/intel-analytics-software/accelerate-k-means-clustering-6385088788a1)
 
-⚠️ We support optimizations for the last four versions of scikit-learn. The latest release of scikit-learn-intelex-2024.0.X supports scikit-learn 1.0.X, 1.1.X, 1.2.X and 1.3.X.
+## 🔗 Important links
+- [Notebook examples](https://github.com/uxlfoundation/scikit-learn-intelex/tree/master/examples/notebooks)
+- [Documentation](https://uxlfoundation.github.io/scikit-learn-intelex/)
+- [scikit-learn API and patching](https://uxlfoundation.github.io/scikit-learn-intelex/)
+- [Benchmark code](https://github.com/IntelPython/scikit-learn_bench)
+- [Building from Sources](https://github.com/uxlfoundation/scikit-learn-intelex/blob/master/INSTALL.md)
+- [About Intel(R) oneAPI Data Analytics Library](https://github.com/uxlfoundation/oneDAL)
 
-## 📜 Intel(R) Extension for Scikit-learn verbose
+## 💬 Support
 
-To find out which implementation of the algorithm is currently used (Intel(R) Extension for Scikit-learn or original Scikit-learn), set the environment variable:
-- On Linux: `export SKLEARNEX_VERBOSE=INFO`
-- On Windows: `set SKLEARNEX_VERBOSE=INFO`
+Report issues, ask questions, and provide suggestions using:
 
-For example, for DBSCAN you get one of these print statements depending on which implementation is used:
-- `SKLEARNEX INFO: sklearn.cluster.DBSCAN.fit: running accelerated version on CPU`
-- `SKLEARNEX INFO: sklearn.cluster.DBSCAN.fit: fallback to original Scikit-learn`
+- [GitHub Issues](https://github.com/uxlfoundation/scikit-learn-intelex/issues)
+- [GitHub Discussions](https://github.com/uxlfoundation/scikit-learn-intelex/discussions)
+- [Forum](https://community.intel.com/t5/Intel-Distribution-for-Python/bd-p/distribution-python)
 
-[Read more in the documentation](https://intel.github.io/scikit-learn-intelex/).
+You may reach out to project maintainers privately at onedal.maintainers@intel.com