scikit-learn-intelex 2025.0.1__py311-none-manylinux_2_28_x86_64.whl → 2025.2.0__py311-none-manylinux_2_28_x86_64.whl

daal4py/sklearn/_n_jobs_support.py

@@ -15,6 +15,7 @@
 # ==============================================================================
 
 import logging
+import sys
 import threading
 from functools import wraps
 from inspect import Parameter, signature
@@ -76,7 +77,7 @@ def _run_with_n_jobs(method):
     """
 
     @wraps(method)
-    def method_wrapper(self, *args, **kwargs):
+    def n_jobs_wrapper(self, *args, **kwargs):
         # threading parallel backend branch
         if not isinstance(threading.current_thread(), threading._MainThread):
             warn(
@@ -117,7 +118,10 @@ def _run_with_n_jobs(method):
                 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:
+        if n_jobs == old_n_threads:
+            return method(self, *args, **kwargs)
+
+        try:
             logger = logging.getLogger("sklearnex")
             cl = self.__class__
             logger.debug(
@@ -125,12 +129,11 @@ def _run_with_n_jobs(method):
                 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:
+            return method(self, *args, **kwargs)
+        finally:
             set_n_threads(old_n_threads)
-        return result
 
-    return method_wrapper
+    return n_jobs_wrapper
 
 
 def control_n_jobs(decorated_methods: list = []):
@@ -149,7 +152,8 @@ def control_n_jobs(decorated_methods: list = []):
 
     Parameters
     ----------
-        decorated_methods (list): A list of method names to be executed with 'n_jobs'.
+    decorated_methods: list
+        A list of method names to be executed with 'n_jobs'.
 
     Example
     -------
@@ -209,14 +213,16 @@ def control_n_jobs(decorated_methods: list = []):
             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.
+            # Python 3.13 removed extra tab in class doc string
+            tab = "    " if sys.version_info.minor < 13 else ""
+            parameters_doc_tail = f"\n{tab}Attributes"
+            n_jobs_doc = f"""
+{tab}n_jobs : int, default=None
+{tab}    The number of jobs to use in parallel for the computation.
+{tab}    ``None`` means using all physical cores
+{tab}    unless in a :obj:`joblib.parallel_backend` context.
+{tab}    ``-1`` means using all logical cores.
+{tab}    See :term:`Glossary <n_jobs>` for more details.
 """
             original_class.__doc__ = original_class.__doc__.replace(
                 parameters_doc_tail, n_jobs_doc + parameters_doc_tail

daal4py/sklearn/_utils.py

@@ -18,7 +18,7 @@ import functools
 import os
 import sys
 import warnings
-from typing import Any, Callable, Tuple
+from typing import Any, Tuple
 
 import numpy as np
 from numpy.lib.recfunctions import require_fields
@@ -95,17 +95,21 @@ def daal_check_version(
     return False
 
 
-@functools.lru_cache(maxsize=256, typed=False)
-def sklearn_check_version(ver):
-    if hasattr(Version(ver), "base_version"):
-        base_sklearn_version = Version(sklearn_version).base_version
-        res = bool(Version(base_sklearn_version) >= Version(ver))
+def _package_check_version(version_to_check, available_version):
+    if hasattr(Version(version_to_check), "base_version"):
+        base_package_version = Version(available_version).base_version
+        res = bool(Version(base_package_version) >= Version(version_to_check))
     else:
         # packaging module not available
-        res = bool(Version(sklearn_version) >= Version(ver))
+        res = bool(Version(available_version) >= Version(version_to_check))
     return res
 
 
+@functools.lru_cache(maxsize=256, typed=False)
+def sklearn_check_version(ver):
+    return _package_check_version(ver, sklearn_version)
+
+
 def parse_dtype(dt):
     if dt == np.double:
         return "double"

daal4py/sklearn/ensemble/AdaBoostClassifier.py

@@ -25,13 +25,19 @@ from sklearn.utils.multiclass import check_classification_targets
 from sklearn.utils.validation import check_array, check_is_fitted, check_X_y
 
 import daal4py as d4p
+from daal4py.sklearn._utils import sklearn_check_version
 
 from .._n_jobs_support import control_n_jobs
 from .._utils import getFPType
 
+if sklearn_check_version("1.6"):
+    from sklearn.utils.validation import validate_data
+else:
+    validate_data = BaseEstimator._validate_data
+
 
 @control_n_jobs(decorated_methods=["fit", "predict"])
-class AdaBoostClassifier(BaseEstimator, ClassifierMixin):
+class AdaBoostClassifier(ClassifierMixin, BaseEstimator):
     def __init__(
         self,
         split_criterion="gini",
@@ -89,7 +95,7 @@ class AdaBoostClassifier(BaseEstimator, ClassifierMixin):
             )
 
         # Check that X and y have correct shape
-        X, y = check_X_y(X, y, y_numeric=False, dtype=[np.single, np.double])
+        X, y = check_X_y(X, y, y_numeric=False, dtype=[np.float64, np.float32])
 
         check_classification_targets(y)
 
@@ -151,9 +157,7 @@ class AdaBoostClassifier(BaseEstimator, ClassifierMixin):
         check_is_fitted(self)
 
         # Input validation
-        X = check_array(X, dtype=[np.single, np.double])
-        if X.shape[1] != self.n_features_in_:
-            raise ValueError("Shape of input is different from what was seen in `fit`")
+        X = validate_data(self, X, dtype=[np.float64, np.float32], reset=False)
 
         # Trivial case
         if self.n_classes_ == 1:

daal4py/sklearn/ensemble/GBTDAAL.py

@@ -26,10 +26,16 @@ from sklearn.utils.multiclass import check_classification_targets
 from sklearn.utils.validation import check_array, check_is_fitted, check_X_y
 
 import daal4py as d4p
+from daal4py.sklearn._utils import sklearn_check_version
 
 from .._n_jobs_support import control_n_jobs
 from .._utils import getFPType
 
+if sklearn_check_version("1.6"):
+    from sklearn.utils.validation import validate_data
+else:
+    validate_data = BaseEstimator._validate_data
+
 
 class GBTDAALBase(BaseEstimator, d4p.mb.GBTDAALBaseModel):
     def __init__(
@@ -128,15 +134,22 @@ class GBTDAALBase(BaseEstimator, d4p.mb.GBTDAALBaseModel):
     def _more_tags(self):
         return {"allow_nan": self.allow_nan_}
 
+    if sklearn_check_version("1.6"):
+
+        def __sklearn_tags__(self):
+            tags = super().__sklearn_tags__()
+            tags.input_tags.allow_nan = self.allow_nan_
+            return tags
+
 
 @control_n_jobs(decorated_methods=["fit", "predict"])
-class GBTDAALClassifier(GBTDAALBase, ClassifierMixin):
+class GBTDAALClassifier(ClassifierMixin, GBTDAALBase):
     def fit(self, X, y):
         # Check the algorithm parameters
         self._check_params()
 
         # Check that X and y have correct shape
-        X, y = check_X_y(X, y, y_numeric=False, dtype=[np.single, np.double])
+        X, y = check_X_y(X, y, y_numeric=False, dtype=[np.float64, np.float32])
 
         check_classification_targets(y)
 
@@ -196,15 +209,18 @@ class GBTDAALClassifier(GBTDAALBase, ClassifierMixin):
     def _predict(
         self, X, resultsToEvaluate, pred_contribs=False, pred_interactions=False
     ):
-        # Input validation
-        if not self.allow_nan_:
-            X = check_array(X, dtype=[np.single, np.double])
-        else:
-            X = check_array(X, dtype=[np.single, np.double], force_all_finite="allow-nan")
-
         # Check is fit had been called
         check_is_fitted(self, ["n_features_in_", "n_classes_"])
 
+        # Input validation
+        X = validate_data(
+            self,
+            X,
+            dtype=[np.float64, np.float32],
+            force_all_finite="allow-nan" if self.allow_nan_ else True,
+            reset=False,
+        )
+
         # Trivial case
         if self.n_classes_ == 1:
             return np.full(X.shape[0], self.classes_[0])
@@ -251,13 +267,13 @@ class GBTDAALClassifier(GBTDAALBase, ClassifierMixin):
 
 
 @control_n_jobs(decorated_methods=["fit", "predict"])
-class GBTDAALRegressor(GBTDAALBase, RegressorMixin):
+class GBTDAALRegressor(RegressorMixin, GBTDAALBase):
     def fit(self, X, y):
         # Check the algorithm parameters
         self._check_params()
 
         # Check that X and y have correct shape
-        X, y = check_X_y(X, y, y_numeric=True, dtype=[np.single, np.double])
+        X, y = check_X_y(X, y, y_numeric=True, dtype=[np.float64, np.float32])
 
         # Convert to 2d array
         y_ = y.reshape((-1, 1))
@@ -297,15 +313,18 @@ class GBTDAALRegressor(GBTDAALBase, RegressorMixin):
         return self
 
     def predict(self, X, pred_contribs=False, pred_interactions=False):
-        # Input validation
-        if not self.allow_nan_:
-            X = check_array(X, dtype=[np.single, np.double])
-        else:
-            X = check_array(X, dtype=[np.single, np.double], force_all_finite="allow-nan")
-
         # Check is fit had been called
         check_is_fitted(self, ["n_features_in_"])
 
+        # Input validation
+        X = validate_data(
+            self,
+            X,
+            dtype=[np.float64, np.float32],
+            force_all_finite="allow-nan" if self.allow_nan_ else True,
+            reset=False,
+        )
+
         fptype = getFPType(X)
         return self._predict_regression(X, fptype, pred_contribs, pred_interactions)
 

daal4py/sklearn/linear_model/tests/test_linear.py

@@ -14,6 +14,18 @@
 # limitations under the License.
 # ==============================================================================
 
+
+from os import environ
+
+from daal4py.sklearn._utils import sklearn_check_version
+
+# sklearn requires manual enabling of Scipy array API support
+# if `array-api-compat` package is present in environment
+# TODO: create generic approach to handle this for all tests
+if sklearn_check_version("1.6"):
+    environ["SCIPY_ARRAY_API"] = "1"
+
+
 import numpy as np
 import pytest
 from sklearn.datasets import make_regression

daal4py/sklearn/metrics/_pairwise.py

@@ -48,7 +48,12 @@ from daal4py.sklearn.utils.validation import _daal_check_array
 from .._utils import PatchingConditionsChain, getFPType, sklearn_check_version
 
 if sklearn_check_version("1.3"):
-    from sklearn.utils._param_validation import Integral, StrOptions, validate_params
+    from sklearn.utils._param_validation import (
+        Hidden,
+        Integral,
+        StrOptions,
+        validate_params,
+    )
 
 
 def _daal4py_cosine_distance_dense(X):
@@ -65,7 +70,7 @@ def _daal4py_correlation_distance_dense(X):
     return res.correlationDistance
 
 
-def pairwise_distances(
+def _pairwise_distances(
     X, Y=None, metric="euclidean", *, n_jobs=None, force_all_finite=True, **kwds
 ):
     if metric not in _VALID_METRICS and not callable(metric) and metric != "precomputed":
@@ -140,16 +145,92 @@ def pairwise_distances(
     return _parallel_pairwise(X, Y, func, n_jobs, **kwds)
 
 
+# logic to deprecate `force_all_finite` from sklearn:
+# it was renamed to `ensure_all_finite` since 1.6 and will be removed in 1.8
 if sklearn_check_version("1.3"):
+    pairwise_distances_parameters = {
+        "X": ["array-like", "sparse matrix"],
+        "Y": ["array-like", "sparse matrix", None],
+        "metric": [StrOptions(set(_VALID_METRICS) | {"precomputed"}), callable],
+        "n_jobs": [Integral, None],
+        "force_all_finite": [
+            "boolean",
+            StrOptions({"allow-nan"}),
+            Hidden(StrOptions({"deprecated"})),
+        ],
+        "ensure_all_finite": [
+            "boolean",
+            StrOptions({"allow-nan"}),
+            Hidden(None),
+        ],
+    }
+    if sklearn_check_version("1.6"):
+        if sklearn_check_version("1.8"):
+            del pairwise_distances_parameters["force_all_finite"]
+
+            def pairwise_distances(
+                X,
+                Y=None,
+                metric="euclidean",
+                *,
+                n_jobs=None,
+                ensure_all_finite=None,
+                **kwds,
+            ):
+                return _pairwise_distances(
+                    X,
+                    Y,
+                    metric,
+                    n_jobs=n_jobs,
+                    force_all_finite=ensure_all_finite,
+                    **kwds,
+                )
+
+        else:
+            from sklearn.utils.deprecation import _deprecate_force_all_finite
+
+            def pairwise_distances(
+                X,
+                Y=None,
+                metric="euclidean",
+                *,
+                n_jobs=None,
+                force_all_finite="deprecated",
+                ensure_all_finite=None,
+                **kwds,
+            ):
+                force_all_finite = _deprecate_force_all_finite(
+                    force_all_finite, ensure_all_finite
+                )
+                return _pairwise_distances(
+                    X, Y, metric, n_jobs=n_jobs, force_all_finite=force_all_finite, **kwds
+                )
+
+    else:
+        del pairwise_distances_parameters["ensure_all_finite"]
+
+        def pairwise_distances(
+            X,
+            Y=None,
+            metric="euclidean",
+            *,
+            n_jobs=None,
+            force_all_finite=True,
+            **kwds,
+        ):
+            return _pairwise_distances(
+                X,
+                Y,
+                metric,
+                n_jobs=n_jobs,
+                force_all_finite=force_all_finite,
+                **kwds,
+            )
+
     pairwise_distances = validate_params(
-        {
-            "X": ["array-like", "sparse matrix"],
-            "Y": ["array-like", "sparse matrix", None],
-            "metric": [StrOptions(set(_VALID_METRICS) | {"precomputed"}), callable],
-            "n_jobs": [Integral, None],
-            "force_all_finite": ["boolean", StrOptions({"allow-nan"})],
-        },
+        pairwise_distances_parameters,
         prefer_skip_nested_validation=True,
     )(pairwise_distances)
-
+else:
+    pairwise_distances = _pairwise_distances
 pairwise_distances.__doc__ = pairwise_distances_original.__doc__

daal4py/sklearn/monkeypatch/tests/test_patching.py

@@ -55,7 +55,10 @@ def get_result_log():
     absolute_path = str(pathlib.Path(__file__).parent.absolute())
     try:
         process = subprocess.check_output(
-            [sys.executable, absolute_path + "/utils/_launch_algorithms.py"]
+            [
+                sys.executable,
+                os.sep.join([absolute_path, "utils", "_launch_algorithms.py"]),
+            ]
         )
     except subprocess.CalledProcessError as e:
         print(e)

daal4py/sklearn/monkeypatch/tests/utils/_launch_algorithms.py

@@ -29,8 +29,7 @@ import sys
 from sklearn.datasets import load_diabetes, load_iris, make_regression
 from sklearn.metrics import pairwise_distances, roc_auc_score
 
-absolute_path = str(pathlib.Path(__file__).parent.absolute())
-sys.path.append(absolute_path + "/../")
+sys.path.append(str(pathlib.Path(__file__).parent.parent.absolute()))
 from _models_info import MODELS_INFO, TYPES
 
 
@@ -84,7 +83,7 @@ def run_patch(model_info, dtype):
         logging.info(i)
 
 
-def run_algotithms():
+def run_algorithms():
     for info in MODELS_INFO:
         for t in TYPES:
             model_name = get_class_name(info["model"])
@@ -114,5 +113,5 @@ def run_utils():
 
 
 if __name__ == "__main__":
-    run_algotithms()
+    run_algorithms()
     run_utils()

daal4py/sklearn/utils/validation.py

@@ -98,9 +98,12 @@ def _assert_all_finite(
     )
     _dal_ready = _patching_status.and_conditions(
         [
-            (X.ndim in [1, 2], "X has not 1 or 2 dimensions."),
-            (not np.any(np.equal(X.shape, 0)), "X shape contains 0."),
-            (dt in [np.float32, np.float64], "X dtype is not float32 or float64."),
+            (X.ndim in [1, 2], f"Input {input_name} does not have 1 or 2 dimensions."),
+            (not np.any(np.equal(X.shape, 0)), f"Input {input_name} shape contains a 0."),
+            (
+                dt in [np.float32, np.float64],
+                f"Input {input_name} dtype is not float32 or float64.",
+            ),
         ]
     )
     _patching_status.write_log()

onedal/_config.py

@@ -21,6 +21,7 @@ import threading
 _default_global_config = {
     "target_offload": "auto",
     "allow_fallback_to_host": False,
+    "allow_sklearn_after_onedal": True,
 }
 
 _threadlocal = threading.local()

onedal/_device_offload.py

@@ -23,49 +23,26 @@ from sklearn import get_config
 
 from ._config import _get_config
 from .utils._array_api import _asarray, _is_numpy_namespace
+from .utils._dpep_helpers import dpctl_available, dpnp_available
 
-try:
+if dpctl_available:
     from dpctl import SyclQueue
     from dpctl.memory import MemoryUSMDevice, as_usm_memory
     from dpctl.tensor import usm_ndarray
+else:
+    import onedal
 
-    dpctl_available = True
-except ImportError:
-    dpctl_available = False
+    # setting fallback to `object` will make if isinstance call
+    # in _get_global_queue always true for situations without the
+    # dpc backend when `device_offload` is used. Instead, it will
+    # fail at the policy check phase yielding a RuntimeError
+    SyclQueue = getattr(onedal._backend, "SyclQueue", object)
 
-try:
+if dpnp_available:
     import dpnp
 
     from .utils._array_api import _convert_to_dpnp
 
-    dpnp_available = True
-except ImportError:
-    dpnp_available = False
-
-
-class DummySyclQueue:
-    """This class is designed to act like dpctl.SyclQueue
-    to allow device dispatching in scenarios when dpctl is not available"""
-
-    class DummySyclDevice:
-        def __init__(self, filter_string):
-            self._filter_string = filter_string
-            self.is_cpu = "cpu" in filter_string
-            self.is_gpu = "gpu" in filter_string
-            self.has_aspect_fp64 = self.is_cpu
-
-            if not (self.is_cpu):
-                logging.warning(
-                    "Device support is limited. "
-                    "Please install dpctl for full experience"
-                )
-
-        def get_filter_string(self):
-            return self._filter_string
-
-    def __init__(self, filter_string):
-        self.sycl_device = self.DummySyclDevice(filter_string)
-
 
 def _copy_to_usm(queue, array):
     if not dpctl_available:
@@ -140,25 +117,23 @@ def _transfer_to_host(queue, *data):
             raise RuntimeError("Input data shall be located on single target device")
 
         host_data.append(item)
-    return queue, host_data
+    return has_usm_data, queue, host_data
 
 
 def _get_global_queue():
     target = _get_config()["target_offload"]
 
-    QueueClass = DummySyclQueue if not dpctl_available else SyclQueue
-
     if target != "auto":
-        if isinstance(target, QueueClass):
+        if isinstance(target, SyclQueue):
             return target
-        return QueueClass(target)
+        return SyclQueue(target)
     return None
 
 
 def _get_host_inputs(*args, **kwargs):
     q = _get_global_queue()
-    q, hostargs = _transfer_to_host(q, *args)
-    q, hostvalues = _transfer_to_host(q, *kwargs.values())
+    _, q, hostargs = _transfer_to_host(q, *args)
+    _, q, hostvalues = _transfer_to_host(q, *kwargs.values())
     hostkwargs = dict(zip(kwargs.keys(), hostvalues))
     return q, hostargs, hostkwargs
 

onedal/basic_statistics/basic_statistics.py

@@ -20,7 +20,7 @@ from abc import ABCMeta, abstractmethod
 import numpy as np
 
 from ..common._base import BaseEstimator
-from ..datatypes import _convert_to_supported, from_table, to_table
+from ..datatypes import from_table, to_table
 from ..utils import _is_csr
 from ..utils.validation import _check_array
 
@@ -57,7 +57,7 @@ class BaseBasicStatistics(BaseEstimator, metaclass=ABCMeta):
     def _get_onedal_params(self, is_csr, dtype=np.float32):
         options = self._get_result_options(self.options)
         return {
-            "fptype": "float" if dtype == np.float32 else "double",
+            "fptype": dtype,
             "method": "sparse" if is_csr else self.algorithm,
             "result_option": options,
         }
@@ -81,11 +81,11 @@ class BasicStatistics(BaseBasicStatistics):
         if sample_weight is not None:
             sample_weight = _check_array(sample_weight, ensure_2d=False)
 
-        data, sample_weight = _convert_to_supported(policy, data, sample_weight)
         is_single_dim = data.ndim == 1
-        data_table, weights_table = to_table(data, sample_weight)
 
-        dtype = data.dtype
+        data_table, weights_table = to_table(data, sample_weight, queue=queue)
+
+        dtype = data_table.dtype
         raw_result = self._compute_raw(data_table, weights_table, policy, dtype, is_csr)
         for opt, raw_value in raw_result.items():
             value = from_table(raw_value).ravel()