scikit-learn-intelex 2025.0.1__py310-none-win_amd64.whl → 2025.2.0__py310-none-win_amd64.whl

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/onedal/neighbors/neighbors.py

@@ -20,8 +20,10 @@ from numbers import Integral
 import numpy as np
 
 from daal4py import (
+    bf_knn_classification_model,
     bf_knn_classification_prediction,
     bf_knn_classification_training,
+    kdtree_knn_classification_model,
     kdtree_knn_classification_prediction,
     kdtree_knn_classification_training,
 )
@@ -29,7 +31,7 @@ from daal4py import (
 from ..common._base import BaseEstimator
 from ..common._estimator_checks import _check_is_fitted, _is_classifier, _is_regressor
 from ..common._mixin import ClassifierMixin, RegressorMixin
-from ..datatypes import _convert_to_supported, from_table, to_table
+from ..datatypes import from_table, to_table
 from ..utils import (
     _check_array,
     _check_classification_targets,
@@ -128,7 +130,7 @@ class NeighborsCommonBase(BaseEstimator, metaclass=ABCMeta):
         else:
             p = self.p
         return {
-            "fptype": "float" if X.dtype == np.float32 else "double",
+            "fptype": X.dtype,
             "vote_weights": "uniform" if weights == "uniform" else "distance",
             "method": self._fit_method,
             "radius": self.radius,
@@ -318,20 +320,21 @@ class NeighborsBase(NeighborsCommonBase, metaclass=ABCMeta):
             self._fit_method, self.n_samples_fit_, n_features
         )
 
-        gpu_device = queue is not None and queue.sycl_device.is_gpu
-        if self.effective_metric_ == "euclidean" and not gpu_device:
+        if (
+            type(self._onedal_model) is kdtree_knn_classification_model
+            or type(self._onedal_model) is bf_knn_classification_model
+        ):
             params = super()._get_daal_params(X, n_neighbors=n_neighbors)
-        else:
-            params = super()._get_onedal_params(X, n_neighbors=n_neighbors)
-
-        prediction_results = self._onedal_predict(
-            self._onedal_model, X, params, queue=queue
-        )
-
-        if self.effective_metric_ == "euclidean" and not gpu_device:
+            prediction_results = self._onedal_predict(
+                self._onedal_model, X, params, queue=queue
+            )
             distances = prediction_results.distances
             indices = prediction_results.indices
         else:
+            params = super()._get_onedal_params(X, n_neighbors=n_neighbors)
+            prediction_results = self._onedal_predict(
+                self._onedal_model, X, params, queue=queue
+            )
             distances = from_table(prediction_results.distances)
             indices = from_table(prediction_results.indices)
 
@@ -424,27 +427,22 @@ class KNeighborsClassifier(NeighborsBase, ClassifierMixin):
             return train_alg(**params).compute(X, y).model
 
         policy = self._get_policy(queue, X, y)
-        X, y = _convert_to_supported(policy, X, y)
-        params = self._get_onedal_params(X, y)
+        X_table, y_table = to_table(X, y, queue=queue)
+        params = self._get_onedal_params(X_table, y)
         train_alg = self._get_backend(
-            "neighbors", "classification", "train", policy, params, *to_table(X, y)
+            "neighbors", "classification", "train", policy, params, X_table, y_table
         )
 
         return train_alg.model
 
     def _onedal_predict(self, model, X, params, queue):
-        gpu_device = queue is not None and queue.sycl_device.is_gpu
-        if self.effective_metric_ == "euclidean" and not gpu_device:
-            if self._fit_method == "brute":
-                predict_alg = bf_knn_classification_prediction
-
-            else:
-                predict_alg = kdtree_knn_classification_prediction
-
-            return predict_alg(**params).compute(X, model)
+        if type(self._onedal_model) is kdtree_knn_classification_model:
+            return kdtree_knn_classification_prediction(**params).compute(X, model)
+        elif type(self._onedal_model) is bf_knn_classification_model:
+            return bf_knn_classification_prediction(**params).compute(X, model)
 
         policy = self._get_policy(queue, X)
-        X = _convert_to_supported(policy, X)
+        X = to_table(X, queue=queue)
         if hasattr(self, "_onedal_model"):
             model = self._onedal_model
         else:
@@ -453,9 +451,9 @@ class KNeighborsClassifier(NeighborsBase, ClassifierMixin):
             )
         if "responses" not in params["result_option"]:
             params["result_option"] += "|responses"
-        params["fptype"] = "float" if X.dtype == np.float32 else "double"
+        params["fptype"] = X.dtype
         result = self._get_backend(
-            "neighbors", "classification", "infer", policy, params, model, to_table(X)
+            "neighbors", "classification", "infer", policy, params, model, X
         )
 
         return result
@@ -486,19 +484,19 @@ class KNeighborsClassifier(NeighborsBase, ClassifierMixin):
 
         self._validate_n_classes()
 
-        gpu_device = queue is not None and queue.sycl_device.is_gpu
-        if self.effective_metric_ == "euclidean" and not gpu_device:
+        if (
+            type(onedal_model) is kdtree_knn_classification_model
+            or type(onedal_model) is bf_knn_classification_model
+        ):
             params = self._get_daal_params(X)
-        else:
-            params = self._get_onedal_params(X)
-
-        prediction_result = self._onedal_predict(onedal_model, X, params, queue=queue)
-        if self.effective_metric_ == "euclidean" and not gpu_device:
+            prediction_result = self._onedal_predict(onedal_model, X, params, queue=queue)
             responses = prediction_result.prediction
         else:
+            params = self._get_onedal_params(X)
+            prediction_result = self._onedal_predict(onedal_model, X, params, queue=queue)
             responses = from_table(prediction_result.responses)
-        result = self.classes_.take(np.asarray(responses.ravel(), dtype=np.intp))
 
+        result = self.classes_.take(np.asarray(responses.ravel(), dtype=np.intp))
         return result
 
     def predict_proba(self, X, queue=None):
@@ -564,10 +562,6 @@ class KNeighborsRegressor(NeighborsBase, RegressorMixin):
         )
         self.weights = weights
 
-    def _get_onedal_params(self, X, y=None):
-        params = super()._get_onedal_params(X, y)
-        return params
-
     def _get_daal_params(self, data):
         params = super()._get_daal_params(data)
         params["resultsToCompute"] = "computeIndicesOfNeighbors|computeDistances"
@@ -587,28 +581,24 @@ class KNeighborsRegressor(NeighborsBase, RegressorMixin):
             return train_alg(**params).compute(X, y).model
 
         policy = self._get_policy(queue, X, y)
-        X, y = _convert_to_supported(policy, X, y)
-        params = self._get_onedal_params(X, y)
+        X_table, y_table = to_table(X, y, queue=queue)
+        params = self._get_onedal_params(X_table, y)
         train_alg_regr = self._get_backend("neighbors", "regression", None)
         train_alg_srch = self._get_backend("neighbors", "search", None)
 
         if gpu_device:
-            return train_alg_regr.train(policy, params, *to_table(X, y)).model
-        return train_alg_srch.train(policy, params, to_table(X)).model
+            return train_alg_regr.train(policy, params, X_table, y_table).model
+        return train_alg_srch.train(policy, params, X_table).model
 
     def _onedal_predict(self, model, X, params, queue):
-        gpu_device = queue is not None and queue.sycl_device.is_gpu
-        if self.effective_metric_ == "euclidean" and not gpu_device:
-            if self._fit_method == "brute":
-                predict_alg = bf_knn_classification_prediction
-
-            else:
-                predict_alg = kdtree_knn_classification_prediction
-
-            return predict_alg(**params).compute(X, model)
+        if type(model) is kdtree_knn_classification_model:
+            return kdtree_knn_classification_prediction(**params).compute(X, model)
+        elif type(model) is bf_knn_classification_model:
+            return bf_knn_classification_prediction(**params).compute(X, model)
 
+        gpu_device = queue is not None and queue.sycl_device.is_gpu
         policy = self._get_policy(queue, X)
-        X = _convert_to_supported(policy, X)
+        X = to_table(X, queue=queue)
         backend = (
             self._get_backend("neighbors", "regression", None)
             if gpu_device
@@ -621,8 +611,8 @@ class KNeighborsRegressor(NeighborsBase, RegressorMixin):
             model = self._create_model(backend)
         if "responses" not in params["result_option"] and gpu_device:
             params["result_option"] += "|responses"
-        params["fptype"] = "float" if X.dtype == np.float32 else "double"
-        result = backend.infer(policy, params, model, to_table(X))
+        params["fptype"] = X.dtype
+        result = backend.infer(policy, params, model, X)
 
         return result
 
@@ -738,35 +728,30 @@ class NearestNeighbors(NeighborsBase):
             return train_alg(**params).compute(X, y).model
 
         policy = self._get_policy(queue, X, y)
-        X, y = _convert_to_supported(policy, X, y)
-        params = self._get_onedal_params(X, y)
+        X_table = to_table(X, queue=queue)
+        params = self._get_onedal_params(X_table, y)
         train_alg = self._get_backend(
-            "neighbors", "search", "train", policy, params, to_table(X)
+            "neighbors", "search", "train", policy, params, X_table
         )
 
         return train_alg.model
 
     def _onedal_predict(self, model, X, params, queue):
-        gpu_device = queue is not None and queue.sycl_device.is_gpu
-        if self.effective_metric_ == "euclidean" and not gpu_device:
-            if self._fit_method == "brute":
-                predict_alg = bf_knn_classification_prediction
-
-            else:
-                predict_alg = kdtree_knn_classification_prediction
-
-            return predict_alg(**params).compute(X, model)
+        if type(self._onedal_model) is kdtree_knn_classification_model:
+            return kdtree_knn_classification_prediction(**params).compute(X, model)
+        elif type(self._onedal_model) is bf_knn_classification_model:
+            return bf_knn_classification_prediction(**params).compute(X, model)
 
         policy = self._get_policy(queue, X)
-        X = _convert_to_supported(policy, X)
+        X = to_table(X, queue=queue)
         if hasattr(self, "_onedal_model"):
             model = self._onedal_model
         else:
             model = self._create_model(self._get_backend("neighbors", "search", None))
 
-        params["fptype"] = "float" if X.dtype == np.float32 else "double"
+        params["fptype"] = X.dtype
         result = self._get_backend(
-            "neighbors", "search", "infer", policy, params, model, to_table(X)
+            "neighbors", "search", "infer", policy, params, model, X
         )
 
         return result

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/onedal/primitives/kernel_functions.py

@@ -19,7 +19,7 @@ import numpy as np
 from onedal import _backend
 
 from ..common._policy import _get_policy
-from ..datatypes import _convert_to_supported, from_table, to_table
+from ..datatypes import from_table, to_table
 from ..utils import _check_array
 
 
@@ -34,9 +34,8 @@ def _check_inputs(X, Y):
 
 def _compute_kernel(params, submodule, X, Y, queue):
     policy = _get_policy(queue, X, Y)
-    X, Y = _convert_to_supported(policy, X, Y)
-    params["fptype"] = "float" if X.dtype == np.float32 else "double"
-    X, Y = to_table(X, Y)
+    X, Y = to_table(X, Y, queue=queue)
+    params["fptype"] = X.dtype
     result = submodule.compute(policy, params, X, Y)
     return from_table(result.values)
 

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/onedal/svm/svm.py

@@ -25,7 +25,7 @@ from onedal import _backend
 from ..common._estimator_checks import _check_is_fitted
 from ..common._mixin import ClassifierMixin, RegressorMixin
 from ..common._policy import _get_policy
-from ..datatypes import _convert_to_supported, from_table, to_table
+from ..datatypes import from_table, to_table
 from ..utils import (
     _check_array,
     _check_n_features,
@@ -96,7 +96,7 @@ class BaseSVM(metaclass=ABCMeta):
         self.n_iter_ = 1 if max_iter < 1 else max_iter
         class_count = 0 if self.classes_ is None else len(self.classes_)
         return {
-            "fptype": "float" if data.dtype == np.float32 else "double",
+            "fptype": data.dtype,
             "method": self.algorithm,
             "kernel": self.kernel,
             "c": self.C,
@@ -174,9 +174,9 @@ class BaseSVM(metaclass=ABCMeta):
             self._scale_, self._sigma_ = _gamma, np.sqrt(0.5 / _gamma)
 
         policy = _get_policy(queue, *data)
-        X = _convert_to_supported(policy, X)
-        params = self._get_onedal_params(X)
-        result = module.train(policy, params, *to_table(*data))
+        data = to_table(*data, queue=queue)
+        params = self._get_onedal_params(data[0])
+        result = module.train(policy, params, *data)
 
         if self._sparse:
             self.dual_coef_ = sp.csr_matrix(from_table(result.coeffs).T)
@@ -253,14 +253,14 @@ class BaseSVM(metaclass=ABCMeta):
                 )
 
             policy = _get_policy(queue, X)
-            X = _convert_to_supported(policy, X)
+            X = to_table(X, queue=queue)
             params = self._get_onedal_params(X)
 
             if hasattr(self, "_onedal_model"):
                 model = self._onedal_model
             else:
                 model = self._create_model(module)
-            result = module.infer(policy, params, model, to_table(X))
+            result = module.infer(policy, params, model, X)
             y = from_table(result.responses)
         return y
 
@@ -286,7 +286,7 @@ class BaseSVM(metaclass=ABCMeta):
     def _decision_function(self, X, module, queue):
         _check_is_fitted(self)
         X = _check_array(
-            X, dtype=[np.float64, np.float32], force_all_finite=False, accept_sparse="csr"
+            X, dtype=[np.float64, np.float32], force_all_finite=True, accept_sparse="csr"
         )
         _check_n_features(self, X, False)
 
@@ -310,14 +310,14 @@ class BaseSVM(metaclass=ABCMeta):
                 )
 
         policy = _get_policy(queue, X)
-        X = _convert_to_supported(policy, X)
+        X = to_table(X, queue=queue)
         params = self._get_onedal_params(X)
 
         if hasattr(self, "_onedal_model"):
             model = self._onedal_model
         else:
             model = self._create_model(module)
-        result = module.infer(policy, params, model, to_table(X))
+        result = module.infer(policy, params, model, X)
         decision_function = from_table(result.decision_function)
 
         if len(self.classes_) == 2:

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/onedal/svm/tests/test_svc.py

@@ -14,6 +14,14 @@
 # limitations under the License.
 # ==============================================================================
 
+from os import environ
+
+# 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
+environ["SCIPY_ARRAY_API"] = "1"
+
+
 import numpy as np
 import pytest
 import sklearn.utils.estimator_checks

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/onedal/tests/test_common.py

@@ -14,18 +14,17 @@
 # limitations under the License.
 # ==============================================================================
 
+import importlib
 import os
 from glob import glob
 
-import pytest
 
-
-def test_sklearn_check_version_ban():
-    """This test blocks the use of sklearn_check_version
-    in onedal files. The versioning should occur in the
-    sklearnex package for clarity and maintainability.
+def _check_primitive_usage_ban(primitive_name, package, allowed_locations=None):
+    """This test blocks the usage of the primitive in
+    in certain files.
     """
-    from onedal import __file__ as loc
+
+    loc = importlib.util.find_spec(package).origin
 
     path = loc.replace("__init__.py", "")
     files = [y for x in os.walk(path) for y in glob(os.path.join(x[0], "*.py"))]
@@ -33,8 +32,25 @@ def test_sklearn_check_version_ban():
     output = []
 
     for f in files:
-        if open(f, "r").read().find("sklearn_check_version") != -1:
-            output += [f.replace(path, "onedal" + os.sep)]
+        if open(f, "r").read().find(primitive_name) != -1:
+            output += [f.replace(path, package + os.sep)]
+
+    # remove this file from the list
+    if allowed_locations:
+        for allowed in allowed_locations:
+            output = [i for i in output if allowed not in i]
+
+    return output
+
+
+def test_sklearn_check_version_ban():
+    """This test blocks the use of sklearn_check_version
+    in onedal files. The versioning should occur in the
+    sklearnex package for clarity and maintainability.
+    """
+    output = _check_primitive_usage_ban(
+        primitive_name="sklearn_check_version", package="onedal"
+    )
 
     # remove this file from the list
     output = "\n".join([i for i in output if "test_common.py" not in i])

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/onedal/tests/utils/_dataframes_support.py

@@ -19,20 +19,14 @@ import scipy.sparse as sp
 
 from sklearnex import get_config
 
-try:
-    import dpctl.tensor as dpt
+from ...utils._dpep_helpers import dpctl_available, dpnp_available
 
-    dpctl_available = True
-except ImportError:
-    dpctl_available = False
+if dpctl_available:
+    import dpctl.tensor as dpt
 
-try:
+if dpnp_available:
     import dpnp
 
-    dpnp_available = True
-except ImportError:
-    dpnp_available = False
-
 try:
     # This should be lazy imported in the
     # future along with other popular

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/onedal/tests/utils/_device_selection.py

@@ -18,6 +18,12 @@ import functools
 
 import pytest
 
+from ...utils._dpep_helpers import dpctl_available
+
+if dpctl_available:
+    import dpctl
+    from dpctl.memory import MemoryUSMDevice, MemoryUSMShared
+
 
 def get_queues(filter_="cpu,gpu"):
     """Get available dpctl.SycQueues for testing.
@@ -41,52 +47,41 @@ def get_queues(filter_="cpu,gpu"):
     """
     queues = [None] if "cpu" in filter_ else []
 
-    try:
-        import dpctl
-
+    if dpctl_available:
         if dpctl.has_cpu_devices() and "cpu" in filter_:
             queues.append(pytest.param(dpctl.SyclQueue("cpu"), id="SyclQueue_CPU"))
         if dpctl.has_gpu_devices() and "gpu" in filter_:
             queues.append(pytest.param(dpctl.SyclQueue("gpu"), id="SyclQueue_GPU"))
-    finally:
-        return queues
 
+    return queues
 
-def get_memory_usm():
-    try:
-        from dpctl.memory import MemoryUSMDevice, MemoryUSMShared
 
+def get_memory_usm():
+    if dpctl_available:
         return [MemoryUSMDevice, MemoryUSMShared]
-    except ImportError:
-        return []
-
+    return []
 
-def is_dpctl_available(targets=None):
-    try:
-        import dpctl
 
-        if targets is None:
-            return True
+def is_dpctl_device_available(targets):
+    if dpctl_available:
         for device in targets:
             if device == "cpu" and not dpctl.has_cpu_devices():
                 return False
             if device == "gpu" and not dpctl.has_gpu_devices():
                 return False
         return True
-    except ImportError:
-        return False
+    return False
 
 
 def device_type_to_str(queue):
     if queue is None:
         return "cpu"
 
-    from dpctl import device_type
-
-    if queue.sycl_device.device_type == device_type.cpu:
-        return "cpu"
-    if queue.sycl_device.device_type == device_type.gpu:
-        return "gpu"
+    if dpctl_available:
+        if queue.sycl_device.is_cpu:
+            return "cpu"
+        if queue.sycl_device.is_gpu:
+            return "gpu"
     return "unknown"
 
 

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/onedal/utils/_array_api.py

@@ -18,20 +18,10 @@
 
 from collections.abc import Iterable
 
-try:
-    from dpctl.tensor import usm_ndarray
-
-    dpctl_available = True
-except ImportError:
-    dpctl_available = False
-
-try:
-    import dpnp
-
-    dpnp_available = True
-except ImportError:
-    dpnp_available = False
+from ._dpep_helpers import dpctl_available, dpnp_available
 
+if dpctl_available:
+    from dpctl.tensor import usm_ndarray
 
 if dpnp_available:
     import dpnp
@@ -73,19 +63,19 @@ def _get_sycl_namespace(*arrays):
     """Get namespace of sycl arrays."""
 
     # sycl support designed to work regardless of array_api_dispatch sklearn global value
-    sycl_type = {type(x): x for x in arrays if hasattr(x, "__sycl_usm_array_interface__")}
+    sua_iface = {type(x): x for x in arrays if hasattr(x, "__sycl_usm_array_interface__")}
 
-    if len(sycl_type) > 1:
-        raise ValueError(f"Multiple SYCL types for array inputs: {sycl_type}")
+    if len(sua_iface) > 1:
+        raise ValueError(f"Multiple SYCL types for array inputs: {sua_iface}")
 
-    if sycl_type:
-        (X,) = sycl_type.values()
+    if sua_iface:
+        (X,) = sua_iface.values()
 
         if hasattr(X, "__array_namespace__"):
-            return sycl_type, X.__array_namespace__(), True
+            return sua_iface, X.__array_namespace__(), True
         elif dpnp_available and isinstance(X, dpnp.ndarray):
-            return sycl_type, dpnp, False
+            return sua_iface, dpnp, False
         else:
-            raise ValueError(f"SYCL type not recognized: {sycl_type}")
+            raise ValueError(f"SYCL type not recognized: {sua_iface}")
 
-    return sycl_type, None, False
+    return sua_iface, None, False

scikit_learn_intelex-2025.2.0.data/data/Lib/site-packages/onedal/utils/_dpep_helpers.py

@@ -0,0 +1,56 @@
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+""" Utilities for Data Parallel Extensions libs, such as DPNP, DPCtl.
+See `Data Parallel Extensions for Python <https://github.com/IntelPython/DPEP>`__
+"""
+
+import functools
+
+from daal4py.sklearn._utils import _package_check_version
+
+
+@functools.lru_cache(maxsize=256, typed=False)
+def is_dpctl_available(version=None):
+    """Checks availability of DPCtl package"""
+    try:
+        import dpctl
+        import dpctl.tensor as dpt
+
+        dpctl_available = True
+    except ImportError:
+        dpctl_available = False
+    if dpctl_available and version is not None:
+        dpctl_available = _package_check_version(version, dpctl.__version__)
+    return dpctl_available
+
+
+@functools.lru_cache(maxsize=256, typed=False)
+def is_dpnp_available(version=None):
+    """Checks availability of DPNP package"""
+    try:
+        import dpnp
+
+        dpnp_available = True
+    except ImportError:
+        dpnp_available = False
+    if dpnp_available and version is not None:
+        dpnp_available = _package_check_version(version, dpnp.__version__)
+    return dpnp_available
+
+
+dpctl_available = is_dpctl_available()
+dpnp_available = is_dpnp_available()