scikit-learn-intelex 2025.0.0__py311-none-manylinux_2_28_x86_64.whl

daal4py/mb/model_builders.py

@@ -0,0 +1,377 @@
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+# daal4py Model builders API
+
+from typing import Literal, Optional
+
+import numpy as np
+
+import daal4py as d4p
+
+try:
+    from pandas import DataFrame
+    from pandas.core.dtypes.cast import find_common_type
+
+    pandas_is_imported = True
+except (ImportError, ModuleNotFoundError):
+    pandas_is_imported = False
+
+from sklearn.utils.metaestimators import available_if
+
+
+def parse_dtype(dt):
+    if dt == np.double:
+        return "double"
+    if dt == np.single:
+        return "float"
+    raise ValueError(f"Input array has unexpected dtype = {dt}")
+
+
+def getFPType(X):
+    if pandas_is_imported:
+        if isinstance(X, DataFrame):
+            dt = find_common_type(X.dtypes.tolist())
+            return parse_dtype(dt)
+
+    dt = getattr(X, "dtype", None)
+    return parse_dtype(dt)
+
+
+class GBTDAALBaseModel:
+    def __init__(self):
+        self.model_type: Optional[Literal["xgboost", "catboost", "lightgbm"]] = None
+
+    @property
+    def _is_regression(self):
+        return hasattr(self, "daal_model_") and isinstance(
+            self.daal_model_, d4p.gbt_regression_model
+        )
+
+    def _get_params_from_lightgbm(self, params):
+        self.n_classes_ = params["num_tree_per_iteration"]
+        objective_fun = params["objective"]
+        if self.n_classes_ <= 2:
+            if "binary" in objective_fun:  # nClasses == 1
+                self.n_classes_ = 2
+
+        self.n_features_in_ = params["max_feature_idx"] + 1
+
+    def _get_params_from_xgboost(self, params):
+        self.n_classes_ = int(params["learner"]["learner_model_param"]["num_class"])
+        objective_fun = params["learner"]["learner_train_param"]["objective"]
+        if self.n_classes_ <= 2:
+            if objective_fun in ["binary:logistic", "binary:logitraw"]:
+                self.n_classes_ = 2
+
+        self.n_features_in_ = int(params["learner"]["learner_model_param"]["num_feature"])
+
+    def _get_params_from_catboost(self, params):
+        if "class_params" in params["model_info"]:
+            self.n_classes_ = len(params["model_info"]["class_params"]["class_to_label"])
+        self.n_features_in_ = len(params["features_info"]["float_features"])
+
+    def _convert_model_from_lightgbm(self, booster):
+        lgbm_params = d4p.get_lightgbm_params(booster)
+        self.daal_model_ = d4p.get_gbt_model_from_lightgbm(booster, lgbm_params)
+        self._get_params_from_lightgbm(lgbm_params)
+
+    def _convert_model_from_xgboost(self, booster):
+        xgb_params = d4p.get_xgboost_params(booster)
+        self.daal_model_ = d4p.get_gbt_model_from_xgboost(booster, xgb_params)
+        self._get_params_from_xgboost(xgb_params)
+
+    def _convert_model_from_catboost(self, booster):
+        catboost_params = d4p.get_catboost_params(booster)
+        self.daal_model_ = d4p.get_gbt_model_from_catboost(booster)
+        self._get_params_from_catboost(catboost_params)
+
+    def _convert_model(self, model):
+        (submodule_name, class_name) = (
+            model.__class__.__module__,
+            model.__class__.__name__,
+        )
+        self_class_name = self.__class__.__name__
+
+        # Build GBTDAALClassifier from LightGBM
+        if (submodule_name, class_name) == ("lightgbm.sklearn", "LGBMClassifier"):
+            if self_class_name == "GBTDAALClassifier":
+                self._convert_model_from_lightgbm(model.booster_)
+            else:
+                raise TypeError(
+                    f"Only GBTDAALClassifier can be created from\
+                                 {submodule_name}.{class_name} (got {self_class_name})"
+                )
+        # Build GBTDAALClassifier from XGBoost
+        elif (submodule_name, class_name) == ("xgboost.sklearn", "XGBClassifier"):
+            if self_class_name == "GBTDAALClassifier":
+                self._convert_model_from_xgboost(model.get_booster())
+            else:
+                raise TypeError(
+                    f"Only GBTDAALClassifier can be created from\
+                                 {submodule_name}.{class_name} (got {self_class_name})"
+                )
+        # Build GBTDAALClassifier from CatBoost
+        elif (submodule_name, class_name) == ("catboost.core", "CatBoostClassifier"):
+            if self_class_name == "GBTDAALClassifier":
+                self._convert_model_from_catboost(model)
+            else:
+                raise TypeError(
+                    f"Only GBTDAALClassifier can be created from\
+                                 {submodule_name}.{class_name} (got {self_class_name})"
+                )
+        # Build GBTDAALRegressor from LightGBM
+        elif (submodule_name, class_name) == ("lightgbm.sklearn", "LGBMRegressor"):
+            if self_class_name == "GBTDAALRegressor":
+                self._convert_model_from_lightgbm(model.booster_)
+            else:
+                raise TypeError(
+                    f"Only GBTDAALRegressor can be created from\
+                                 {submodule_name}.{class_name} (got {self_class_name})"
+                )
+        # Build GBTDAALRegressor from XGBoost
+        elif (submodule_name, class_name) == ("xgboost.sklearn", "XGBRegressor"):
+            if self_class_name == "GBTDAALRegressor":
+                self._convert_model_from_xgboost(model.get_booster())
+            else:
+                raise TypeError(
+                    f"Only GBTDAALRegressor can be created from\
+                                 {submodule_name}.{class_name} (got {self_class_name})"
+                )
+        # Build GBTDAALRegressor from CatBoost
+        elif (submodule_name, class_name) == ("catboost.core", "CatBoostRegressor"):
+            if self_class_name == "GBTDAALRegressor":
+                self._convert_model_from_catboost(model)
+            else:
+                raise TypeError(
+                    f"Only GBTDAALRegressor can be created from\
+                                 {submodule_name}.{class_name} (got {self_class_name})"
+                )
+        # Build GBTDAALModel from LightGBM
+        elif (submodule_name, class_name) == ("lightgbm.basic", "Booster"):
+            if self_class_name == "GBTDAALModel":
+                self._convert_model_from_lightgbm(model)
+            else:
+                raise TypeError(
+                    f"Only GBTDAALModel can be created from\
+                                 {submodule_name}.{class_name} (got {self_class_name})"
+                )
+        # Build GBTDAALModel from XGBoost
+        elif (submodule_name, class_name) == ("xgboost.core", "Booster"):
+            if self_class_name == "GBTDAALModel":
+                self._convert_model_from_xgboost(model)
+            else:
+                raise TypeError(
+                    f"Only GBTDAALModel can be created from\
+                                 {submodule_name}.{class_name} (got {self_class_name})"
+                )
+        # Build GBTDAALModel from CatBoost
+        elif (submodule_name, class_name) == ("catboost.core", "CatBoost"):
+            if self_class_name == "GBTDAALModel":
+                self._convert_model_from_catboost(model)
+            else:
+                raise TypeError(
+                    f"Only GBTDAALModel can be created from\
+                                 {submodule_name}.{class_name} (got {self_class_name})"
+                )
+        else:
+            raise TypeError(f"Unknown model format {submodule_name}.{class_name}")
+
+    def _predict_classification(
+        self, X, fptype, resultsToEvaluate, pred_contribs=False, pred_interactions=False
+    ):
+        if X.shape[1] != self.n_features_in_:
+            raise ValueError("Shape of input is different from what was seen in `fit`")
+
+        if not hasattr(self, "daal_model_"):
+            raise ValueError(
+                (
+                    "The class {} instance does not have 'daal_model_' attribute set. "
+                    "Call 'fit' with appropriate arguments before using this method."
+                ).format(type(self).__name__)
+            )
+
+        # Prediction
+        try:
+            return self._predict_classification_with_results_to_compute(
+                X, fptype, resultsToEvaluate, pred_contribs, pred_interactions
+            )
+        except TypeError as e:
+            if "unexpected keyword argument 'resultsToCompute'" in str(e):
+                if pred_contribs or pred_interactions:
+                    # SHAP values requested, but not supported by this version
+                    raise TypeError(
+                        f"{'pred_contribs' if pred_contribs else 'pred_interactions'} not supported by this version of daal4py"
+                    ) from e
+            else:
+                # unknown type error
+                raise
+        except RuntimeError as e:
+            if "Method is not implemented" in str(e):
+                if pred_contribs or pred_interactions:
+                    raise NotImplementedError(
+                        f"{'pred_contribs' if pred_contribs else 'pred_interactions'} is not implemented for classification models"
+                    )
+            else:
+                raise
+
+        # fallback to calculation without `resultsToCompute`
+        predict_algo = d4p.gbt_classification_prediction(
+            nClasses=self.n_classes_,
+            fptype=fptype,
+            resultsToEvaluate=resultsToEvaluate,
+        )
+        predict_result = predict_algo.compute(X, self.daal_model_)
+
+        if resultsToEvaluate == "computeClassLabels":
+            return predict_result.prediction.ravel().astype(np.int64, copy=False)
+        else:
+            return predict_result.probabilities
+
+    def _predict_classification_with_results_to_compute(
+        self,
+        X,
+        fptype,
+        resultsToEvaluate,
+        pred_contribs=False,
+        pred_interactions=False,
+    ):
+        """Assume daal4py supports the resultsToCompute kwarg"""
+        resultsToCompute = ""
+        if pred_contribs:
+            resultsToCompute = "shapContributions"
+        elif pred_interactions:
+            resultsToCompute = "shapInteractions"
+
+        predict_algo = d4p.gbt_classification_prediction(
+            nClasses=self.n_classes_,
+            fptype=fptype,
+            resultsToCompute=resultsToCompute,
+            resultsToEvaluate=resultsToEvaluate,
+        )
+        predict_result = predict_algo.compute(X, self.daal_model_)
+
+        if pred_contribs:
+            return predict_result.prediction.ravel().reshape((-1, X.shape[1] + 1))
+        elif pred_interactions:
+            return predict_result.prediction.ravel().reshape(
+                (-1, X.shape[1] + 1, X.shape[1] + 1)
+            )
+        elif resultsToEvaluate == "computeClassLabels":
+            return predict_result.prediction.ravel().astype(np.int64, copy=False)
+        else:
+            return predict_result.probabilities
+
+    def _predict_regression(
+        self, X, fptype, pred_contribs=False, pred_interactions=False
+    ):
+        if X.shape[1] != self.n_features_in_:
+            raise ValueError("Shape of input is different from what was seen in `fit`")
+
+        if not hasattr(self, "daal_model_"):
+            raise ValueError(
+                (
+                    "The class {} instance does not have 'daal_model_' attribute set. "
+                    "Call 'fit' with appropriate arguments before using this method."
+                ).format(type(self).__name__)
+            )
+
+        try:
+            return self._predict_regression_with_results_to_compute(
+                X, fptype, pred_contribs, pred_interactions
+            )
+        except TypeError as e:
+            if "unexpected keyword argument 'resultsToCompute'" in str(e):
+                if pred_contribs or pred_interactions:
+                    # SHAP values requested, but not supported by this version
+                    raise TypeError(
+                        f"{'pred_contribs' if pred_contribs else 'pred_interactions'} not supported by this version of daalp4y"
+                    ) from e
+            else:
+                # unknown type error
+                raise
+
+        # fallback to calculation without `resultsToCompute`
+        predict_algo = d4p.gbt_regression_prediction(fptype=fptype)
+        predict_result = predict_algo.compute(X, self.daal_model_)
+        return predict_result.prediction.ravel()
+
+    def _predict_regression_with_results_to_compute(
+        self, X, fptype, pred_contribs=False, pred_interactions=False
+    ):
+        """Assume daal4py supports the resultsToCompute kwarg"""
+        resultsToCompute = ""
+        if pred_contribs:
+            resultsToCompute = "shapContributions"
+        elif pred_interactions:
+            resultsToCompute = "shapInteractions"
+
+        predict_algo = d4p.gbt_regression_prediction(
+            fptype=fptype, resultsToCompute=resultsToCompute
+        )
+        predict_result = predict_algo.compute(X, self.daal_model_)
+
+        if pred_contribs:
+            return predict_result.prediction.ravel().reshape((-1, X.shape[1] + 1))
+        elif pred_interactions:
+            return predict_result.prediction.ravel().reshape(
+                (-1, X.shape[1] + 1, X.shape[1] + 1)
+            )
+        else:
+            return predict_result.prediction.ravel()
+
+
+class GBTDAALModel(GBTDAALBaseModel):
+    def predict(self, X, pred_contribs=False, pred_interactions=False):
+        fptype = getFPType(X)
+        if self._is_regression:
+            return self._predict_regression(X, fptype, pred_contribs, pred_interactions)
+        else:
+            if (pred_contribs or pred_interactions) and self.model_type != "xgboost":
+                raise NotImplementedError(
+                    f"{'pred_contribs' if pred_contribs else 'pred_interactions'} is not implemented for classification models"
+                )
+            return self._predict_classification(
+                X, fptype, "computeClassLabels", pred_contribs, pred_interactions
+            )
+
+    def _check_proba(self):
+        return not self._is_regression
+
+    @available_if(_check_proba)
+    def predict_proba(self, X):
+        fptype = getFPType(X)
+        return self._predict_classification(X, fptype, "computeClassProbabilities")
+
+
+def convert_model(model):
+    try:
+        gbm = GBTDAALModel()
+        gbm._convert_model(model)
+    except TypeError as err:
+        if "Only GBTDAALRegressor can be created" in str(err):
+            gbm = d4p.sklearn.ensemble.GBTDAALRegressor.convert_model(model)
+        elif "Only GBTDAALClassifier can be created" in str(err):
+            gbm = d4p.sklearn.ensemble.GBTDAALClassifier.convert_model(model)
+        else:
+            raise
+
+    for type_str in ("xgboost", "lightgbm", "catboost"):
+        if type_str in str(type(model)):
+            gbm.model_type = type_str
+            break
+
+    return gbm

daal4py/sklearn/__init__.py

@@ -0,0 +1,40 @@
+# ==============================================================================
+# Copyright 2014 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 .monkeypatch.dispatcher import _get_map_of_algorithms as sklearn_patch_map
+from .monkeypatch.dispatcher import _patch_names as sklearn_patch_names
+from .monkeypatch.dispatcher import disable as unpatch_sklearn
+from .monkeypatch.dispatcher import enable as patch_sklearn
+from .monkeypatch.dispatcher import patch_is_enabled as sklearn_is_patched
+
+__all__ = [
+    "cluster",
+    "decomposition",
+    "ensemble",
+    "linear_model",
+    "manifold",
+    "metrics",
+    "model_selection",
+    "neighbors",
+    "patch_sklearn",
+    "sklearn_is_patched",
+    "sklearn_patch_map",
+    "sklearn_patch_names",
+    "svm",
+    "tree",
+    "unpatch_sklearn",
+    "utils",
+]

daal4py/sklearn/_n_jobs_support.py

@@ -0,0 +1,242 @@
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+import logging
+import threading
+from functools import wraps
+from inspect import Parameter, signature
+from multiprocessing import cpu_count
+from numbers import Integral
+from warnings import warn
+
+import threadpoolctl
+
+from daal4py import daalinit as set_n_threads
+from daal4py import num_threads as get_n_threads
+
+from ._utils import sklearn_check_version
+
+if sklearn_check_version("1.2"):
+    from sklearn.utils._param_validation import validate_parameter_constraints
+
+
+# Note: getting controller in global scope of this module is required
+# to avoid overheads by its initialization per each function call
+threadpool_controller = threadpoolctl.ThreadpoolController()
+
+
+def get_suggested_n_threads(n_cpus):
+    """
+    Function to get `n_threads` limit
+    if `n_jobs` is set in upper parallelization context.
+    Usually, limit is equal to `n_logical_cpus` // `n_jobs`.
+    Returns None if limit is not set.
+    """
+    n_threads_map = {
+        lib_ctl.internal_api: lib_ctl.get_num_threads()
+        for lib_ctl in threadpool_controller.lib_controllers
+        if lib_ctl.internal_api != "mkl"
+    }
+    # openBLAS is limited to 24, 64 or 128 threads by default
+    # depending on SW/HW configuration.
+    # thus, these numbers of threads from openBLAS are uninformative
+    if "openblas" in n_threads_map and n_threads_map["openblas"] in [24, 64, 128]:
+        del n_threads_map["openblas"]
+    # remove default values equal to n_cpus as uninformative
+    for backend in list(n_threads_map.keys()):
+        if n_threads_map[backend] == n_cpus:
+            del n_threads_map[backend]
+    if len(n_threads_map) > 0:
+        return min(n_threads_map.values())
+    else:
+        return None
+
+
+def _run_with_n_jobs(method):
+    """
+    Decorator for running of methods containing oneDAL kernels with 'n_jobs'.
+
+    Outside actual call of decorated method, this decorator:
+    - checks correctness of passed 'n_jobs',
+    - deducts actual number of threads to use,
+    - sets and resets this number for oneDAL environment.
+    """
+
+    @wraps(method)
+    def method_wrapper(self, *args, **kwargs):
+        # threading parallel backend branch
+        if not isinstance(threading.current_thread(), threading._MainThread):
+            warn(
+                "'Threading' parallel backend is not supported by "
+                "Intel(R) Extension for Scikit-learn*. "
+                "Falling back to usage of all available threads."
+            )
+            result = method(self, *args, **kwargs)
+            return result
+        # multiprocess parallel backends branch
+        # preemptive validation of n_jobs parameter is required
+        # because '_run_with_n_jobs' decorator is applied on top of method
+        # where validation takes place
+        if sklearn_check_version("1.2") and hasattr(self, "_parameter_constraints"):
+            validate_parameter_constraints(
+                parameter_constraints={"n_jobs": self._parameter_constraints["n_jobs"]},
+                params={"n_jobs": self.n_jobs},
+                caller_name=self.__class__.__name__,
+            )
+        # search for specified n_jobs
+        n_jobs = self.n_jobs
+        n_cpus = cpu_count()
+        # receive n_threads limitation from upper parallelism context
+        # using `threadpoolctl.ThreadpoolController`
+        n_threads = get_suggested_n_threads(n_cpus)
+        # get real `n_jobs` number of threads for oneDAL
+        # using sklearn rules and `n_threads` from upper parallelism context
+        if n_jobs is None or n_jobs == 0:
+            if n_threads is None:
+                # default branch with no setting for n_jobs
+                return method(self, *args, **kwargs)
+            else:
+                n_jobs = n_threads
+        elif n_jobs < 0:
+            if n_threads is None:
+                n_jobs = max(1, n_cpus + n_jobs + 1)
+            else:
+                n_jobs = max(1, n_threads + n_jobs + 1)
+        # branch with set n_jobs
+        old_n_threads = get_n_threads()
+        if n_jobs != old_n_threads:
+            logger = logging.getLogger("sklearnex")
+            cl = self.__class__
+            logger.debug(
+                f"{cl.__module__}.{cl.__name__}.{method.__name__}: "
+                f"setting {n_jobs} threads (previous - {old_n_threads})"
+            )
+            set_n_threads(n_jobs)
+        result = method(self, *args, **kwargs)
+        if n_jobs != old_n_threads:
+            set_n_threads(old_n_threads)
+        return result
+
+    return method_wrapper
+
+
+def control_n_jobs(decorated_methods: list = []):
+    """
+    Decorator for controlling the 'n_jobs' parameter in an estimator class.
+
+    This decorator is designed to be applied to both estimators with and without
+    native support for the 'n_jobs' parameter in the original Scikit-learn APIs.
+    When applied to an estimator without 'n_jobs' support in
+    its original '__init__' method, this decorator adds the 'n_jobs' parameter.
+
+    Additionally, this decorator allows for fine-grained control over which methods
+    should be executed with the 'n_jobs' parameter. The methods specified in
+    the 'decorated_methods' argument will run with 'n_jobs',
+    while all other methods remain unaffected.
+
+    Parameters
+    ----------
+        decorated_methods (list): A list of method names to be executed with 'n_jobs'.
+
+    Example
+    -------
+        @control_n_jobs(decorated_methods=['fit', 'predict'])
+
+        class MyEstimator:
+
+            def __init__(self, *args, **kwargs):
+                # Your original __init__ implementation here
+
+            def fit(self, *args, **kwargs):
+                # Your original fit implementation here
+
+            def predict(self, *args, **kwargs):
+                # Your original predict implementation here
+
+            def other_method(self, *args, **kwargs):
+                # Methods not listed in decorated_methods will not be affected by 'n_jobs'
+                pass
+    """
+
+    def class_wrapper(original_class):
+        original_class._n_jobs_supported_onedal_methods = decorated_methods.copy()
+
+        original_init = original_class.__init__
+
+        if sklearn_check_version("1.2") and hasattr(
+            original_class, "_parameter_constraints"
+        ):
+            parameter_constraints = original_class._parameter_constraints
+            if "n_jobs" not in parameter_constraints:
+                parameter_constraints["n_jobs"] = [Integral, None]
+
+        @wraps(original_init)
+        def init_with_n_jobs(self, *args, n_jobs=None, **kwargs):
+            original_init(self, *args, **kwargs)
+            self.n_jobs = n_jobs
+
+        # add "n_jobs" parameter to signature of wrapped init
+        # if estimator doesn't originally support it
+        sig = signature(original_init)
+        if "n_jobs" not in sig.parameters:
+            params_copy = sig.parameters.copy()
+            params_copy.update(
+                {
+                    "n_jobs": Parameter(
+                        name="n_jobs", kind=Parameter.KEYWORD_ONLY, default=None
+                    )
+                }
+            )
+            init_with_n_jobs.__signature__ = sig.replace(parameters=params_copy.values())
+            original_class.__init__ = init_with_n_jobs
+
+        # add n_jobs to __doc__ string if needed
+        if (
+            hasattr(original_class, "__doc__")
+            and isinstance(original_class.__doc__, str)
+            and "n_jobs : int" not in original_class.__doc__
+        ):
+            parameters_doc_tail = "\n    Attributes"
+            n_jobs_doc = """
+    n_jobs : int, default=None
+        The number of jobs to use in parallel for the computation.
+        ``None`` means using all physical cores
+        unless in a :obj:`joblib.parallel_backend` context.
+        ``-1`` means using all logical cores.
+        See :term:`Glossary <n_jobs>` for more details.
+"""
+            original_class.__doc__ = original_class.__doc__.replace(
+                parameters_doc_tail, n_jobs_doc + parameters_doc_tail
+            )
+
+        # decorate methods to be run with applied n_jobs parameter
+        for method_name in decorated_methods:
+            # if method doesn't exist, we want it to raise an Exception
+            method = getattr(original_class, method_name)
+            if not hasattr(method, "__onedal_n_jobs_decorated__"):
+                decorated_method = _run_with_n_jobs(method)
+                # sign decorated method for testing and other purposes
+                decorated_method.__onedal_n_jobs_decorated__ = True
+                setattr(original_class, method_name, decorated_method)
+            else:
+                warn(
+                    f"{original_class.__name__}.{method_name} already has "
+                    "oneDAL n_jobs support and will not be decorated."
+                )
+
+        return original_class
+
+    return class_wrapper