scikit-learn-intelex 2025.10.0__py313-none-win_amd64.whl

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/sklearnex/_config.py

@@ -0,0 +1,163 @@
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+import sys
+from contextlib import contextmanager
+
+from sklearn import get_config as skl_get_config
+from sklearn import set_config as skl_set_config
+
+from daal4py.sklearn._utils import sklearn_check_version
+from onedal._config import _get_config as onedal_get_config
+
+__all__ = ["get_config", "set_config", "config_context"]
+
+tab = "    " if (sys.version_info.major == 3 and sys.version_info.minor < 13) else ""
+_options_docstring = f"""Parameters
+{tab}----------
+{tab}target_offload : str or dpctl.SyclQueue or None
+{tab}    The device used to perform computations, either as a string indicating a name
+{tab}    recognized by the SyCL runtime, such as ``"gpu"``, ``"gpu:0"``, or as a
+{tab}    :obj:`dpctl.SyclQueue` object indicating where to move the data.
+{tab}
+{tab}    Assuming SyCL-related dependencies are installed, the list of devices recognized
+{tab}    by SyCL can be retrieved through the CLI tool ``sycl-ls`` in a shell, or through
+{tab}    :obj:`dpctl.get_devices` in a Python process.
+{tab}
+{tab}    String ``"auto"`` is also accepted.
+{tab}
+{tab}    Global default: ``"auto"``.
+{tab}
+{tab}allow_fallback_to_host : bool or None
+{tab}    If ``True``, allows computations to fall back to host device (CPU) when an unsupported
+{tab}    operation is attempted on GPU through ``target_offload``.
+{tab}
+{tab}    Global default: ``False``.
+{tab}
+{tab}allow_sklearn_after_onedal : bool or None, default=None
+{tab}    If ``True``, allows computations to fall back to stock scikit-learn when no
+{tab}    accelered version of the operation is available (see :ref:`algorithms`).
+{tab}
+{tab}    Global default: ``True``.
+{tab}
+{tab}use_raw_input : bool or None
+{tab}    If ``True``, uses the raw input data in some SPMD onedal backend computations
+{tab}    without any checks on data consistency or validity. Note that this can be
+{tab}    better achieved through usage of :ref:`array API classes <array_api>` without
+{tab}    ``target_offload``. Not recommended for general use.
+{tab}
+{tab}    Global default: ``False``.
+{tab}
+{tab}    .. deprecated:: 2026.0
+{tab}
+{tab}sklearn_configs : kwargs
+{tab}    Other settings accepted by scikit-learn. See :obj:`sklearn.set_config` for
+{tab}    details.
+{tab}
+{tab}Warnings
+{tab}--------
+{tab}Using ``use_raw_input=True`` is not recommended for general use as it
+{tab}bypasses data consistency checks, which may lead to unexpected behavior. It is
+{tab}recommended to use the newer :ref:`array API <array_api>` instead.
+{tab}
+{tab}Note
+{tab}----
+{tab}Usage of ``target_offload`` requires additional dependencies - see
+{tab}:ref:`GPU support <oneapi_gpu>` for more information."""
+
+
+def get_config():
+    """Retrieve current values for configuration set by :func:`set_config`.
+
+    Returns
+    -------
+    config : dict
+        Keys are parameter names that can be passed to :func:`set_config`.
+
+    See Also
+    --------
+    config_context : Context manager for global configuration.
+    set_config : Set global configuration.
+    """
+    sklearn = skl_get_config()
+    sklearnex = onedal_get_config()
+    return {**sklearn, **sklearnex}
+
+
+def set_config(
+    target_offload=None,
+    allow_fallback_to_host=None,
+    allow_sklearn_after_onedal=None,
+    use_raw_input=None,
+    **sklearn_configs,
+):  # numpydoc ignore=PR01,PR07
+    """Set global configuration.
+
+    %_options_docstring%
+
+    See Also
+    --------
+    config_context : Context manager for global configuration.
+    get_config : Retrieve current values of the global configuration.
+    """
+
+    skl_set_config(**sklearn_configs)
+
+    local_config = onedal_get_config(copy=False)
+
+    if target_offload is not None:
+        local_config["target_offload"] = target_offload
+    if allow_fallback_to_host is not None:
+        local_config["allow_fallback_to_host"] = allow_fallback_to_host
+    if allow_sklearn_after_onedal is not None:
+        local_config["allow_sklearn_after_onedal"] = allow_sklearn_after_onedal
+    if use_raw_input is not None:
+        local_config["use_raw_input"] = use_raw_input
+
+
+set_config.__doc__ = set_config.__doc__.replace(
+    "%_options_docstring%", _options_docstring
+)
+
+
+@contextmanager
+def config_context(**new_config):  # numpydoc ignore=PR01,PR07
+    """Context manager for local scikit-learn-intelex configurations.
+
+    %_options_docstring%
+
+    Note
+    ----
+    All settings, not just those presently modified, will be returned to
+    their previous values when the context manager is exited.
+
+    See Also
+    --------
+    set_config : Set global scikit-learn configuration.
+    get_config : Retrieve current values of the global configuration.
+    """
+    old_config = get_config()
+    set_config(**new_config)
+
+    try:
+        yield
+    finally:
+        set_config(**old_config)
+
+
+config_context.__doc__ = config_context.__doc__.replace(
+    "%_options_docstring%", _options_docstring
+)

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

@@ -0,0 +1,205 @@
+# ==============================================================================
+# 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 _transfer_to_host
+from onedal.datatypes import copy_to_dpnp, copy_to_usm
+from onedal.utils import _sycl_queue_manager as QM
+from onedal.utils._array_api import _asarray, _is_numpy_namespace
+from onedal.utils._third_party import is_dpnp_ndarray
+
+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 get_config()["allow_fallback_to_host"]:
+            QM.fallback_to_host()
+            return None, patching_status
+        return patching_status.get_status(), patching_status
+
+    if get_config()["allow_fallback_to_host"]:
+        # This may trigger if the ``onedal.utils._sycl_queue_manager.__non_queue``
+        # object is the queue (e.g. if non-SYCL device data is encountered)
+        QM.fallback_to_host()
+        return None, None
+    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 : str
+        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
+
+    # The _sycl_queue_manager verifies all arguments are on a single SYCL device or
+    # cpu and will otherwise throw an error. If located on a non-SYCL, non-CPU
+    # device, a special queue is set which will cause a failure in ``_get_backend``
+    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 supporting 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:
+    """Transform function output to match input format.
+
+    Converts and moves the output arrays of the decorated function
+    to match the input array type and device.
+
+    Parameters
+    ----------
+    func : callable
+       Function or method which has array data as input.
+
+    Returns
+    -------
+    wrapper : callable
+        Wrapped function or method which will return matching format.
+    """
+
+    @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())[0]
+            # Remove check for result __sycl_usm_array_interface__ on deprecation of use_raw_inputs
+            if (
+                usm_iface := getattr(data, "__sycl_usm_array_interface__", None)
+            ) and not hasattr(result, "__sycl_usm_array_interface__"):
+                queue = usm_iface["syclobj"]
+                return (
+                    copy_to_dpnp(queue, result)
+                    if is_dpnp_ndarray(data)
+                    else copy_to_usm(queue, result)
+                )
+
+            if get_config().get("transform_output") in ("default", None):
+                input_array_api = getattr(data, "__array_namespace__", lambda: None)()
+                if input_array_api and not _is_numpy_namespace(input_array_api):
+                    input_array_api_device = data.device
+                    result = _asarray(
+                        result, input_array_api, device=input_array_api_device
+                    )
+        return result
+
+    return wrapper

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/sklearnex/_utils.py

@@ -0,0 +1,219 @@
+# ===============================================================================
+# 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.
+# ===============================================================================
+
+import logging
+import os
+import re
+import sys
+import warnings
+from abc import ABC
+
+import sklearn
+
+from daal4py.sklearn._utils import (
+    PatchingConditionsChain as daal4py_PatchingConditionsChain,
+)
+from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
+from onedal.common.hyperparameters import (
+    get_hyperparameters as onedal_get_hyperparameters,
+)
+from onedal.common.hyperparameters import (
+    reset_hyperparameters as onedal_reset_hyperparameters,
+)
+
+# 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:
+    from sklearn.base import BaseEstimator
+
+    get_tags = lambda obj: type("Tags", (), BaseEstimator._get_tags(obj))
+
+
+class PatchingConditionsChain(daal4py_PatchingConditionsChain):
+    def get_status(self):
+        return self.patching_is_enabled
+
+    def write_log(self, queue=None, transferred_to_host=True):
+        if self.patching_is_enabled:
+            self.logger.info(
+                f"{self.scope_name}: {get_patch_message('onedal', queue=queue, transferred_to_host=transferred_to_host)}"
+            )
+        else:
+            self.logger.debug(
+                f"{self.scope_name}: debugging for the patch is enabled to track"
+                " the usage of oneAPI Data Analytics Library (oneDAL)"
+            )
+            for message in self.messages:
+                self.logger.debug(
+                    f"{self.scope_name}: patching failed with cause - {message}"
+                )
+            self.logger.info(
+                f"{self.scope_name}: {get_patch_message('sklearn', transferred_to_host=transferred_to_host)}"
+            )
+
+
+def set_sklearn_ex_verbose():
+    log_level = os.environ.get("SKLEARNEX_VERBOSE")
+
+    logger = logging.getLogger("sklearnex")
+    logging_channel = logging.StreamHandler()
+    logging_formatter = logging.Formatter("%(levelname)s:%(name)s: %(message)s")
+    logging_channel.setFormatter(logging_formatter)
+    logger.addHandler(logging_channel)
+
+    try:
+        if log_level is not None:
+            logger.setLevel(log_level)
+    except Exception:
+        warnings.warn(
+            'Unknown level "{}" for logging.\n'
+            'Please, use one of "CRITICAL", "ERROR", '
+            '"WARNING", "INFO", "DEBUG".'.format(log_level)
+        )
+
+
+def get_patch_message(s, queue=None, transferred_to_host=True):
+    if s == "onedal":
+        message = "running accelerated version on "
+        if queue is not None:
+            if queue.sycl_device.is_gpu:
+                message += "GPU"
+            elif queue.sycl_device.is_cpu:
+                message += "CPU"
+            else:
+                raise RuntimeError("Unsupported device")
+        else:
+            message += "CPU"
+    elif s == "sklearn":
+        message = "fallback to original Scikit-learn"
+    elif s == "sklearn_after_onedal":
+        message = "failed to run accelerated version, fallback to original Scikit-learn"
+    else:
+        raise ValueError(
+            f"Invalid input - expected one of 'onedal','sklearn',"
+            f" 'sklearn_after_onedal', got {s}"
+        )
+    if transferred_to_host:
+        message += (
+            ". All input data transferred to host for further backend computations."
+        )
+    return message
+
+
+def get_sklearnex_version(rule):
+    return daal_check_version(rule)
+
+
+def register_hyperparameters(hyperparameters_map):
+    """Decorator for hyperparameters support in estimator class.
+
+    Adds `get_hyperparameters` and `reset_hyperparameters` methods to class.
+
+    Parameters
+    ----------
+    hyperparameters_map : Dict[str, Tuple[str, str]]
+       Dictionary containing the mapping of the operator name in the sklearnex API
+       to the tuple (algorithm name, operation name) that contains the arguments to
+       onedal.common.hyperparameters.get_hyperparameters and
+       onedal.common.hyperparameters.reset_hyperparameters functions.
+
+    Returns
+    -------
+    decorator : function
+        Function which adds `get_hyperparameters` method to classes.
+    """
+
+    def decorator(cls):
+        """Add ``get_hyperparameters()` static method to a class.
+
+        Parameters
+        ----------
+        cls : class
+            Class to be modified.
+
+        Returns
+        -------
+        cls : class
+            Class with added `get_hyperparameters` method.
+        """
+
+        class StaticHyperparametersAccessor:
+            """Like a @staticmethod, but additionally raises a Warning when called on an instance."""
+
+            def __get__(self, instance, _):
+                if instance is not None:
+                    warnings.warn(
+                        "Hyperparameters are static variables and can not be modified per instance."
+                    )
+                return self.get_hyperparameters
+
+            def get_hyperparameters(self, op):
+                return onedal_get_hyperparameters(
+                    hyperparameters_map[op][0], hyperparameters_map[op][1]
+                )
+
+        class StaticHyperparametersResetter:
+            """Like a @staticmethod, but additionally raises a Warning when called on an instance."""
+
+            def __get__(self, instance, _):
+                if instance is not None:
+                    warnings.warn(
+                        "Hyperparameters are static variables and can not be modified per instance."
+                    )
+                return self.reset_hyperparameters
+
+            def reset_hyperparameters(self, op):
+                return onedal_reset_hyperparameters(
+                    hyperparameters_map[op][0], hyperparameters_map[op][1]
+                )
+
+        cls.get_hyperparameters = StaticHyperparametersAccessor()
+        cls.reset_hyperparameters = StaticHyperparametersResetter()
+        return cls
+
+    return decorator
+
+
+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
+    their docstrings, which will be replaced by this note.
+    """
+    # In python versions >=3.13, leading whitespace in docstrings defined through
+    # static strings (but **not through other ways**) is automatically removed
+    # from the final docstrings, while in earlier versions is kept.
+    inc_serialization_note = """Note
+----
+Serializing instances of this class will trigger a forced finalization of calculations
+when the inputs are in a sycl queue or when using GPUs. Since (internal method)
+finalize_fit can't be dispatched without directly provided queue and the dispatching
+policy can't be serialized, the computation is finalized during serialization call and
+the policy is not saved in serialized data."""
+    if sys.version_info.major == 3 and sys.version_info.minor <= 12:
+        inc_serialization_note = re.sub(
+            r"^", " " * 4, inc_serialization_note, flags=re.MULTILINE
+        )
+        inc_serialization_note = inc_serialization_note.strip()
+    return class_docstrings.replace(
+        r"%incremental_serialization_note%", inc_serialization_note
+    )

scikit_learn_intelex-2025.10.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 classes
+            # 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