scikit-learn-intelex 2025.5.0__py313-none-win_amd64.whl → 2025.6.0__py313-none-win_amd64.whl

scikit_learn_intelex-2025.6.0.data/data/Lib/site-packages/sklearnex/_device_offload.py

@@ -0,0 +1,194 @@
+# ==============================================================================
+# Copyright 2021 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.
+# ==============================================================================
+
+from collections.abc import Callable
+from functools import wraps
+from typing import Any, Union
+
+from onedal._device_offload import _copy_to_usm, _transfer_to_host
+from onedal.utils import _sycl_queue_manager as QM
+from onedal.utils._array_api import _asarray, _is_numpy_namespace
+from onedal.utils._dpep_helpers import dpnp_available
+
+if dpnp_available:
+    import dpnp
+    from onedal.utils._array_api import _convert_to_dpnp
+
+from ._config import config_context, get_config, set_config
+from ._utils import PatchingConditionsChain, get_tags
+from .base import oneDALEstimator
+
+
+def _get_backend(
+    obj: type[oneDALEstimator], method_name: str, *data
+) -> tuple[Union[bool, None], PatchingConditionsChain]:
+    """This function verifies the hardware conditions, data characteristics, and
+    estimator parameters necessary for offloading computation to oneDAL. The status
+    of this patching is returned as a PatchingConditionsChain object along with a
+    boolean flag signaling whether the computation can be offloaded to oneDAL or not.
+    It is assumed that the queue (which determined what hardware to possibly use for
+    oneDAL) has been previously and extensively collected (i.e. the data has already
+    been checked using onedal's SyclQueueManager for queues)."""
+    queue = QM.get_global_queue()
+    cpu_device = queue is None or getattr(queue.sycl_device, "is_cpu", True)
+    gpu_device = queue is not None and getattr(queue.sycl_device, "is_gpu", False)
+
+    if cpu_device:
+        patching_status = obj._onedal_cpu_supported(method_name, *data)
+        return patching_status.get_status(), patching_status
+
+    if gpu_device:
+        patching_status = obj._onedal_gpu_supported(method_name, *data)
+        if (
+            not patching_status.get_status()
+            and (config := get_config())["allow_fallback_to_host"]
+        ):
+            QM.fallback_to_host()
+            return None, patching_status
+        return patching_status.get_status(), patching_status
+
+    raise RuntimeError("Device support is not implemented for the supplied data type.")
+
+
+if "array_api_dispatch" in get_config():
+    _array_api_offload = lambda: get_config()["array_api_dispatch"]
+else:
+    _array_api_offload = lambda: False
+
+
+def dispatch(
+    obj: type[oneDALEstimator],
+    method_name: str,
+    branches: dict[Callable, Callable],
+    *args,
+    **kwargs,
+) -> Any:
+    """Dispatch object method call to oneDAL if conditionally possible.
+    Depending on support conditions, oneDAL will be called, otherwise it will
+    fall back to calling scikit-learn.  Dispatching to oneDAL can be influenced
+    by the 'use_raw_input' or 'allow_fallback_to_host' config parameters.
+
+    Parameters
+    ----------
+    obj : object
+        sklearnex object which inherits from oneDALEstimator and contains
+        ``onedal_cpu_supported`` and ``onedal_gpu_supported`` methods which
+        evaluate oneDAL support.
+
+    method_name : string
+        name of method to be evaluated for oneDAL support
+
+    branches : dict
+        dictionary containing functions to be called. Only keys 'sklearn' and
+        'onedal' are used which should contain the relevant scikit-learn and
+        onedal object methods respectively. All functions should accept the
+        inputs from *args and **kwargs. Additionally, the onedal object method
+        must accept a 'queue' keyword.
+
+    *args : tuple
+        arguments to be supplied to the dispatched method
+
+    **kwargs : dict
+        keyword arguments to be supplied to the dispatched method
+
+    Returns
+    -------
+    unknown : object
+        Returned object dependent on the supplied branches. Implicitly the returned
+        object types should match for the sklearn and onedal object methods.
+    """
+
+    if get_config()["use_raw_input"]:
+        return branches["onedal"](obj, *args, **kwargs)
+
+    # Determine if array_api dispatching is enabled, and if estimator is capable
+    onedal_array_api = _array_api_offload() and get_tags(obj).onedal_array_api
+    sklearn_array_api = _array_api_offload() and get_tags(obj).array_api_support
+
+    # backend can only be a boolean or None, None signifies an unverified backend
+    backend: "bool | None" = None
+
+    # config context needs to be saved, as the sycl_queue_manager interacts with
+    # target_offload, which can regenerate a GPU queue later on. Therefore if a
+    # fallback occurs, then the state of target_offload must be set to default
+    # so that later use of get_global_queue only sends to host. We must modify
+    # the target offload settings, but we must also set the original value at the
+    # end, hence the need of a contextmanager.
+    with QM.manage_global_queue(None, *args):
+        if onedal_array_api:
+            backend, patching_status = _get_backend(obj, method_name, *args)
+            if backend:
+                queue = QM.get_global_queue()
+                patching_status.write_log(queue=queue, transferred_to_host=False)
+                return branches["onedal"](obj, *args, **kwargs, queue=queue)
+            elif sklearn_array_api and backend is False:
+                patching_status.write_log(transferred_to_host=False)
+                return branches["sklearn"](obj, *args, **kwargs)
+
+        # move data to host because of multiple reasons: array_api fallback to host,
+        # non array_api supporing oneDAL code, issues with usm support in sklearn.
+        has_usm_data_for_args, hostargs = _transfer_to_host(*args)
+        has_usm_data_for_kwargs, hostvalues = _transfer_to_host(*kwargs.values())
+
+        hostkwargs = dict(zip(kwargs.keys(), hostvalues))
+        has_usm_data = has_usm_data_for_args or has_usm_data_for_kwargs
+
+        while backend is None:
+            backend, patching_status = _get_backend(obj, method_name, *hostargs)
+
+        if backend:
+            queue = QM.get_global_queue()
+            patching_status.write_log(queue=queue, transferred_to_host=False)
+            return branches["onedal"](obj, *hostargs, **hostkwargs, queue=queue)
+        else:
+            if sklearn_array_api and not has_usm_data:
+                # dpnp fallback is not handled properly yet.
+                patching_status.write_log(transferred_to_host=False)
+                return branches["sklearn"](obj, *args, **kwargs)
+            else:
+                patching_status.write_log()
+                return branches["sklearn"](obj, *hostargs, **hostkwargs)
+
+
+def wrap_output_data(func: Callable) -> Callable:
+    """
+    Converts and moves the output arrays of the decorated function
+    to match the input array type and device.
+    """
+
+    @wraps(func)
+    def wrapper(self, *args, **kwargs) -> Any:
+        result = func(self, *args, **kwargs)
+        if not (len(args) == 0 and len(kwargs) == 0):
+            data = (*args, *kwargs.values())
+
+            usm_iface = getattr(data[0], "__sycl_usm_array_interface__", None)
+            if usm_iface is not None:
+                result = _copy_to_usm(usm_iface["syclobj"], result)
+                if dpnp_available and isinstance(data[0], dpnp.ndarray):
+                    result = _convert_to_dpnp(result)
+                return result
+
+            if get_config().get("transform_output") in ("default", None):
+                input_array_api = getattr(data[0], "__array_namespace__", lambda: None)()
+                if input_array_api and not _is_numpy_namespace(input_array_api):
+                    input_array_api_device = data[0].device
+                    result = _asarray(
+                        result, input_array_api, device=input_array_api_device
+                    )
+        return result
+
+    return wrapper

{scikit_learn_intelex-2025.5.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/_utils.py

@@ -28,16 +28,19 @@ from daal4py.sklearn._utils import (
 )
 from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
 
-# Note: if inheriting from '_HTMLDocumentationLinkMixin' here, it then doesn't matter
-# the order of inheritance of classes for estimators when this is later subclassed,
-# whereas if inheriting from something else, the subclass that inherits from this needs
-# to be the first inherited class in estimators in order for it to take effect.
-if sklearn_check_version("1.4"):
-    from sklearn.utils._estimator_html_repr import _HTMLDocumentationLinkMixin
-
-    BaseForHTMLDocLink = _HTMLDocumentationLinkMixin
+# Not an ideal solution, but this allows for access to the outputs of older
+# sklearnex tag dictionaries in a way similar to the sklearn >=1.6 tag
+# dataclasses via duck-typing. At some point this must be removed for direct
+# use of get_tags in all circumstances, dictated by sklearn support. This is
+# implemented in a way to minimally impact performance.
+
+
+if sklearn_check_version("1.6"):
+    from sklearn.utils import get_tags
 else:
-    BaseForHTMLDocLink = ABC
+    from sklearn.base import BaseEstimator
+
+    get_tags = lambda obj: type("Tags", (), BaseEstimator._get_tags(obj))
 
 
 class PatchingConditionsChain(daal4py_PatchingConditionsChain):
@@ -142,20 +145,6 @@ def register_hyperparameters(hyperparameters_map):
     return decorator
 
 
-# This abstract class is meant to generate a clickable doc link for classses
-# in sklearnex that are not part of base scikit-learn.
-class ExtensionEstimator(BaseForHTMLDocLink):
-    @property
-    def _doc_link_module(self) -> str:
-        return "sklearnex"
-
-    @property
-    def _doc_link_template(self) -> str:
-        module_path, _ = self.__class__.__module__.rsplit(".", 1)
-        class_name = self.__class__.__name__
-        return f"https://uxlfoundation.github.io/scikit-learn-intelex/latest/non-scikit-algorithms.html#{module_path}.{class_name}"
-
-
 def _add_inc_serialization_note(class_docstrings: str) -> str:
     """Adds a small note note about serialization for extension estimators that are incremental.
     The class docstrings should leave a placeholder '%incremental_serialization_note%' inside
@@ -179,25 +168,3 @@ the policy is not saved in serialized data."""
     return class_docstrings.replace(
         r"%incremental_serialization_note%", inc_serialization_note
     )
-
-
-# This abstract class is meant to generate a clickable doc link for classses
-# in sklearnex that have counterparts in scikit-learn.
-class PatchableEstimator(BaseForHTMLDocLink):
-    @property
-    def _doc_link_module(self) -> str:
-        return "sklearnex"
-
-    @property
-    def _doc_link_template(self) -> str:
-        if re.search(r"^\d\.\d\.\d$", sklearn.__version__):
-            sklearn_version_parts = sklearn.__version__.split(".")
-            doc_version_url = sklearn_version_parts[0] + "." + sklearn_version_parts[1]
-        else:
-            doc_version_url = "stable"
-        module_path, _ = self.__class__.__module__.rsplit(".", 1)
-        module_path = re.sub("sklearnex", "sklearn", module_path)
-        class_name = self.__class__.__name__
-        # for TSNE, which re-uses daal4py
-        module_path = re.sub(r"daal4py\.", "", module_path)
-        return f"https://scikit-learn.org/{doc_version_url}/modules/generated/{module_path}.{class_name}.html"

scikit_learn_intelex-2025.6.0.data/data/Lib/site-packages/sklearnex/base.py

@@ -0,0 +1,109 @@
+# ===============================================================================
+# Copyright contributors to the oneDAL project
+#
+# 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.
+# ===============================================================================
+
+from sklearn.base import BaseEstimator
+
+from daal4py.sklearn._utils import sklearn_check_version
+
+if sklearn_check_version("1.6"):
+    from dataclasses import dataclass, fields
+
+    from sklearn.utils import Tags as _sklearn_Tags
+
+    @dataclass
+    class Tags(_sklearn_Tags):
+        onedal_array_api: bool = False
+
+
+class oneDALEstimator:
+    """Inherited class for all oneDAL-based estimators.
+
+    This class must be inherited before any scikit-learn estimator
+    classes (i.e. those which inherit from scikit-learn's BaseEstimator).
+
+    It enables:
+
+      - dispatching to oneDAL
+      - html documentation
+
+    Notes
+    -----
+    Sklearnex-only estimators must inherit this class directly before
+    BaseEstimator in order to properly render documentation.  Other
+    sklearn classes like Mixins can be before this class in the MRO
+    without any impact on functionality.
+    """
+
+    if sklearn_check_version("1.6"):
+        # Starting in sklearn 1.6, _more_tags is deprecated. An oneDALEstimator
+        # is defined to handle the various versioning issues with the tags and
+        # with the ongoing rollout of sklearn's array_api support. This will make
+        # maintenance easier, and centralize tag changes to a single location.
+
+        def __sklearn_tags__(self) -> Tags:
+            # This convention is unnecessarily restrictive with more performant
+            # alternatives but it best follows sklearn. Subclasses will now only need
+            # to set `onedal_array_api` to True to signify gpu zero-copy support
+            # and maintenance is smaller because of underlying sklearn infrastructure
+            sktags = super().__sklearn_tags__()
+            tag_dict = {
+                field.name: getattr(sktags, field.name) for field in fields(sktags)
+            }
+            return Tags(**tag_dict)
+
+    elif sklearn_check_version("1.3"):
+
+        def _more_tags(self) -> dict[bool]:
+            return {"onedal_array_api": False}
+
+    else:
+        # array_api_support tag was added in sklearn 1.3 via scikit-learn/scikit-learn#26372
+        def _more_tags(self) -> dict[bool, bool]:
+            return {"array_api_support": False, "onedal_array_api": False}
+
+    if sklearn_check_version("1.4"):
+
+        @property
+        def _doc_link_module(self) -> str:
+            return "sklearnex"
+
+        def _doc_link_url_param_generator(self, *_) -> dict[str, str]:
+            return {
+                "estimator_module": "sklearn."
+                + self.__class__.__module__.rsplit(".", 2)[-2],
+                "estimator_name": self.__class__.__name__,
+            }
+
+        def _get_doc_link(self) -> str:
+            # This method is meant to generate a clickable doc link for classses
+            # in sklearnex including those that are not part of base scikit-learn.
+            # It should be inherited before inheriting from a scikit-learn estimator.
+
+            mro = self.__class__.__mro__
+            # The next object in the Estimators MRO after oneDALEstimator should be
+            # the equivalent sklearn estimator, if it is BaseEstimator, it is a
+            # sklearnex-only estimator.
+            url = BaseEstimator._get_doc_link(self)
+            if (
+                url
+                and oneDALEstimator in mro
+                and mro[mro.index(oneDALEstimator) + 1] is BaseEstimator
+            ):
+                module_path, _ = self.__class__.__module__.rsplit(".", 1)
+                class_name = self.__class__.__name__
+                url = f"https://uxlfoundation.github.io/scikit-learn-intelex/latest/non-scikit-algorithms.html#{module_path}.{class_name}"
+
+            return url

{scikit_learn_intelex-2025.5.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/basic_statistics/basic_statistics.py

@@ -28,7 +28,8 @@ from onedal.basic_statistics import BasicStatistics as onedal_BasicStatistics
 from onedal.utils.validation import _is_csr
 
 from .._device_offload import dispatch
-from .._utils import ExtensionEstimator, PatchingConditionsChain
+from .._utils import PatchingConditionsChain
+from ..base import oneDALEstimator
 from ..utils.validation import validate_data
 
 if sklearn_check_version("1.2"):
@@ -36,7 +37,7 @@ if sklearn_check_version("1.2"):
 
 
 @control_n_jobs(decorated_methods=["fit"])
-class BasicStatistics(ExtensionEstimator, BaseEstimator):
+class BasicStatistics(oneDALEstimator, BaseEstimator):
     """
     Estimator for basic statistics.
     Allows to compute basic statistics for provided data.

{scikit_learn_intelex-2025.5.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/basic_statistics/incremental_basic_statistics.py

@@ -27,11 +27,8 @@ from onedal.basic_statistics import (
 
 from .._config import get_config
 from .._device_offload import dispatch
-from .._utils import (
-    ExtensionEstimator,
-    PatchingConditionsChain,
-    _add_inc_serialization_note,
-)
+from .._utils import PatchingConditionsChain, _add_inc_serialization_note
+from ..base import oneDALEstimator
 from ..utils.validation import validate_data
 
 if sklearn_check_version("1.2"):
@@ -42,7 +39,7 @@ import warnings
 
 
 @control_n_jobs(decorated_methods=["partial_fit", "_onedal_finalize_fit"])
-class IncrementalBasicStatistics(ExtensionEstimator, BaseEstimator):
+class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
     """
     Calculates basic statistics on the given data, allows for computation when the data are split into
     batches. The user can use ``partial_fit`` method to provide a single batch of data or use the ``fit`` method to provide

{scikit_learn_intelex-2025.5.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/cluster/dbscan.py

@@ -27,14 +27,15 @@ from onedal.cluster import DBSCAN as onedal_DBSCAN
 
 from .._config import get_config
 from .._device_offload import dispatch
-from .._utils import PatchableEstimator, PatchingConditionsChain
+from .._utils import PatchingConditionsChain
+from ..base import oneDALEstimator
 from ..utils.validation import validate_data
 
 if sklearn_check_version("1.1") and not sklearn_check_version("1.2"):
     from sklearn.utils import check_scalar
 
 
-class BaseDBSCAN(ABC):
+class BaseDBSCAN(oneDALEstimator):
     def _onedal_dbscan(self, **onedal_params):
         return onedal_DBSCAN(**onedal_params)
 
@@ -48,7 +49,7 @@ class BaseDBSCAN(ABC):
 
 
 @control_n_jobs(decorated_methods=["fit"])
-class DBSCAN(PatchableEstimator, _sklearn_DBSCAN, BaseDBSCAN):
+class DBSCAN(BaseDBSCAN, _sklearn_DBSCAN):
     __doc__ = _sklearn_DBSCAN.__doc__
 
     if sklearn_check_version("1.2"):

{scikit_learn_intelex-2025.5.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/cluster/k_means.py

@@ -35,15 +35,18 @@ if daal_check_version((2023, "P", 200)):
 
     from daal4py.sklearn._n_jobs_support import control_n_jobs
     from daal4py.sklearn._utils import sklearn_check_version
+    from onedal._device_offload import support_input_format
     from onedal.cluster import KMeans as onedal_KMeans
     from onedal.utils.validation import _is_csr
 
     from .._device_offload import dispatch, wrap_output_data
-    from .._utils import PatchableEstimator, PatchingConditionsChain
+    from .._utils import PatchingConditionsChain
+    from ..base import oneDALEstimator
+    from ..utils._array_api import get_namespace
     from ..utils.validation import validate_data
 
     @control_n_jobs(decorated_methods=["fit", "fit_transform", "predict", "score"])
-    class KMeans(PatchableEstimator, _sklearn_KMeans):
+    class KMeans(oneDALEstimator, _sklearn_KMeans):
         __doc__ = _sklearn_KMeans.__doc__
 
         if sklearn_check_version("1.2"):
@@ -317,16 +320,20 @@ if daal_check_version((2023, "P", 200)):
         _onedal_gpu_supported = _onedal_supported
         _onedal_cpu_supported = _onedal_supported
 
-        @wrap_output_data
-        def fit_transform(self, X, y=None, sample_weight=None):
-            return self.fit(X, sample_weight=sample_weight)._transform(X)
-
-        @wrap_output_data
-        def transform(self, X):
-            check_is_fitted(self)
+        def _check_test_data(self, X):
+            xp, _ = get_namespace(X)
+            X = validate_data(
+                self,
+                X,
+                accept_sparse="csr",
+                reset=False,
+                dtype=[xp.float64, xp.float32],
+                order="C",
+                accept_large_sparse=False,
+            )
+            return X
 
-            X = self._check_test_data(X)
-            return self._transform(X)
+        _transform = support_input_format(_sklearn_KMeans._transform)
 
         @wrap_output_data
         def score(self, X, y=None, sample_weight=None):
@@ -381,8 +388,6 @@ if daal_check_version((2023, "P", 200)):
 
         fit.__doc__ = _sklearn_KMeans.fit.__doc__
         predict.__doc__ = _sklearn_KMeans.predict.__doc__
-        transform.__doc__ = _sklearn_KMeans.transform.__doc__
-        fit_transform.__doc__ = _sklearn_KMeans.fit_transform.__doc__
         score.__doc__ = _sklearn_KMeans.score.__doc__
 
 else:

{scikit_learn_intelex-2025.5.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/covariance/incremental_covariance.py

@@ -30,16 +30,17 @@ from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
 from onedal.covariance import (
     IncrementalEmpiricalCovariance as onedal_IncrementalEmpiricalCovariance,
 )
+from onedal.utils._array_api import _is_numpy_namespace
 from sklearnex import config_context
 
 from .._config import get_config
 from .._device_offload import dispatch, wrap_output_data
 from .._utils import (
-    ExtensionEstimator,
     PatchingConditionsChain,
     _add_inc_serialization_note,
     register_hyperparameters,
 )
+from ..base import oneDALEstimator
 from ..metrics import pairwise_distances
 from ..utils._array_api import get_namespace
 from ..utils.validation import check_feature_names, validate_data
@@ -49,7 +50,7 @@ if sklearn_check_version("1.2"):
 
 
 @control_n_jobs(decorated_methods=["partial_fit", "fit", "_onedal_finalize_fit"])
-class IncrementalEmpiricalCovariance(ExtensionEstimator, BaseEstimator):
+class IncrementalEmpiricalCovariance(oneDALEstimator, BaseEstimator):
     """
     Maximum likelihood covariance estimator that allows for the estimation when the data are split into
     batches. The user can use the ``partial_fit`` method to provide a single batch of data or use the ``fit`` method to provide
@@ -231,11 +232,11 @@ class IncrementalEmpiricalCovariance(ExtensionEstimator, BaseEstimator):
         X = validate_data(
             self,
             X_test,
-            dtype=[np.float64, np.float32],
+            dtype=[xp.float64, xp.float32],
             reset=False,
         )
 
-        if "numpy" not in xp.__name__:
+        if not _is_numpy_namespace(xp):
             location = xp.asarray(location, device=X_test.device)
             # depending on the sklearn version, check_array
             # and validate_data will return only numpy arrays
@@ -361,12 +362,13 @@ class IncrementalEmpiricalCovariance(ExtensionEstimator, BaseEstimator):
         # self.location_) , and will check for finiteness via check array
         # check_feature_names will match _validate_data functionally
         location = self.location_[np.newaxis, :]
-        if "numpy" not in xp.__name__:
+        if not _is_numpy_namespace(xp):
             # Guarantee that inputs to pairwise_distances match in type and location
             location = xp.asarray(location, device=X.device)
 
         try:
             dist = pairwise_distances(X, location, metric="mahalanobis", VI=precision)
+
         except ValueError as e:
             # Throw the expected sklearn error in an n_feature length violation
             if "Incompatible dimension for X and Y matrices: X.shape[1] ==" in str(e):
@@ -377,6 +379,9 @@ class IncrementalEmpiricalCovariance(ExtensionEstimator, BaseEstimator):
             else:
                 raise e
 
+        if not _is_numpy_namespace(xp):
+            dist = xp.asarray(dist, device=X.device)
+
         return (xp.reshape(dist, (-1,))) ** 2
 
     _onedal_cpu_supported = _onedal_supported

{scikit_learn_intelex-2025.5.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/decomposition/pca.py

@@ -18,8 +18,6 @@ import logging
 
 from daal4py.sklearn._utils import daal_check_version
 
-from .._utils import PatchableEstimator
-
 if daal_check_version((2024, "P", 100)):
     import numbers
     from math import sqrt
@@ -34,6 +32,7 @@ if daal_check_version((2024, "P", 100)):
 
     from .._device_offload import dispatch, wrap_output_data
     from .._utils import PatchingConditionsChain
+    from ..base import oneDALEstimator
     from ..utils._array_api import get_namespace
     from ..utils.validation import validate_data
 
@@ -48,7 +47,7 @@ if daal_check_version((2024, "P", 100)):
     from onedal.decomposition import PCA as onedal_PCA
 
     @control_n_jobs(decorated_methods=["fit", "transform", "fit_transform"])
-    class PCA(PatchableEstimator, _sklearn_PCA):
+    class PCA(oneDALEstimator, _sklearn_PCA):
         __doc__ = _sklearn_PCA.__doc__
 
         if sklearn_check_version("1.2"):

{scikit_learn_intelex-2025.5.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/ensemble/_forest.py

@@ -64,7 +64,8 @@ from sklearnex._utils import register_hyperparameters
 
 from .._config import get_config
 from .._device_offload import dispatch, wrap_output_data
-from .._utils import PatchableEstimator, PatchingConditionsChain
+from .._utils import PatchingConditionsChain
+from ..base import oneDALEstimator
 from ..utils._array_api import get_namespace
 from ..utils.validation import check_n_features, validate_data
 
@@ -74,7 +75,7 @@ if sklearn_check_version("1.4"):
     from daal4py.sklearn.utils import _assert_all_finite
 
 
-class BaseForest(PatchableEstimator, ABC):
+class BaseForest(oneDALEstimator, ABC):
     _onedal_factory = None
 
     def _onedal_fit(self, X, y, sample_weight=None, queue=None):
@@ -400,7 +401,7 @@ class BaseForest(PatchableEstimator, ABC):
             self.estimator = estimator
 
 
-class ForestClassifier(_sklearn_ForestClassifier, BaseForest):
+class ForestClassifier(BaseForest, _sklearn_ForestClassifier):
     # Surprisingly, even though scikit-learn warns against using
     # their ForestClassifier directly, it actually has a more stable
     # API than the user-facing objects (over time). If they change it
@@ -850,7 +851,7 @@ class ForestClassifier(_sklearn_ForestClassifier, BaseForest):
         )
 
 
-class ForestRegressor(_sklearn_ForestRegressor, BaseForest):
+class ForestRegressor(BaseForest, _sklearn_ForestRegressor):
     _err = "out_of_bag_error_r2|out_of_bag_error_prediction"
     _get_tree_state = staticmethod(get_tree_state_reg)
 

{scikit_learn_intelex-2025.5.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/linear_model/coordinate_descent.py

@@ -14,17 +14,29 @@
 # limitations under the License.
 # ===============================================================================
 
+from daal4py.sklearn._utils import sklearn_check_version
 from daal4py.sklearn.linear_model import ElasticNet, Lasso
 from onedal._device_offload import support_input_format
 
+from ..base import oneDALEstimator
+
 # Note: `sklearnex.linear_model.ElasticNet` only has functional
 # sycl GPU support. No GPU device will be offloaded.
 ElasticNet.fit = support_input_format(ElasticNet.fit)
 ElasticNet.predict = support_input_format(ElasticNet.predict)
 ElasticNet.score = support_input_format(ElasticNet.score)
+if sklearn_check_version("1.4"):
+    ElasticNet._doc_link_module = "daal4py"
+    ElasticNet._doc_link_url_param_generator = (
+        oneDALEstimator._doc_link_url_param_generator
+    )
+
 
 # Note: `sklearnex.linear_model.Lasso` only has functional
 # sycl GPU support. No GPU device will be offloaded.
 Lasso.fit = support_input_format(Lasso.fit)
 Lasso.predict = support_input_format(Lasso.predict)
 Lasso.score = support_input_format(Lasso.score)
+if sklearn_check_version("1.4"):
+    Lasso._doc_link_module = "daal4py"
+    Lasso._doc_link_url_param_generator = oneDALEstimator._doc_link_url_param_generator