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

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

@@ -15,12 +15,16 @@
 # ==============================================================================
 
 import logging
+from typing import Any, Dict, Tuple
 from warnings import warn
 
 from daal4py.sklearn._utils import daal_check_version
 from onedal import _backend
 
-if daal_check_version((2024, "P", 0)):
+if not daal_check_version((2024, "P", 0)):
+    warn("Hyperparameters are supported in oneDAL starting from 2024.0.0 version.")
+    hyperparameters_map = {}
+else:
     _hparams_reserved_words = [
         "algorithm",
         "op",
@@ -56,9 +60,16 @@ if daal_check_version((2024, "P", 0)):
                 return super().__getattribute__(__name)
             elif __name in self.getters.keys():
                 return self.getters[__name]()
-            else:
-                raise ValueError(
-                    f"Unknown '{__name}' name in "
+            try:
+                # try to return attribute from base class
+                # required to read builtin attributes like __class__, __doc__, etc.
+                # which are used in debuggers
+                return super().__getattribute__(__name)
+            except AttributeError:
+                # raise an AttributeError with a hyperparameter-specific message
+                # for easier debugging
+                raise AttributeError(
+                    f"Unknown attribute '{__name}' in "
                     f"'{self.algorithm}.{self.op}' hyperparameters"
                 )
 
@@ -70,7 +81,7 @@ if daal_check_version((2024, "P", 0)):
                 self.setters[__name](__value)
             else:
                 raise ValueError(
-                    f"Unknown '{__name}' name in "
+                    f"Unknown attribute '{__name}' in "
                     f"'{self.algorithm}.{self.op}' hyperparameters"
                 )
 
@@ -83,13 +94,16 @@ if daal_check_version((2024, "P", 0)):
             for method in filter(lambda f: f.startswith(prefix), dir(obj))
         }
 
-    hyperparameters_backend = {
+    hyperparameters_backend: Dict[Tuple[str, str], Any] = {
         (
             "linear_regression",
             "train",
         ): _backend.linear_model.regression.train_hyperparameters(),
         ("covariance", "compute"): _backend.covariance.compute_hyperparameters(),
     }
+    if daal_check_version((2024, "P", 300)):
+        df_infer_hp = _backend.decision_forest.infer_hyperparameters
+        hyperparameters_backend[("decision_forest", "infer")] = df_infer_hp()
     hyperparameters_map = {}
 
     for (algorithm, op), hyperparameters in hyperparameters_backend.items():
@@ -106,11 +120,6 @@ if daal_check_version((2024, "P", 0)):
             algorithm, op, setters, getters, hyperparameters
         )
 
-    def get_hyperparameters(algorithm, op):
-        return hyperparameters_map[(algorithm, op)]
-
-else:
 
-    def get_hyperparameters(algorithm, op):
-        warn("Hyperparameters are supported in oneDAL starting from 2024.0.0 version.")
-        return None
+def get_hyperparameters(algorithm, op):
+    return hyperparameters_map.get((algorithm, op), None)

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

@@ -22,8 +22,9 @@ from onedal.tests.utils._device_selection import (
     device_type_to_str,
     get_memory_usm,
     get_queues,
-    is_dpctl_available,
+    is_dpctl_device_available,
 )
+from onedal.utils._dpep_helpers import dpctl_available
 
 
 @pytest.mark.parametrize("queue", get_queues())
@@ -43,7 +44,7 @@ def test_with_numpy_data(queue):
     assert _get_policy(queue, X, y).get_device_name() == device_name
 
 
-@pytest.mark.skipif(not is_dpctl_available(), reason="depends on dpctl")
+@pytest.mark.skipif(not dpctl_available, reason="depends on dpctl")
 @pytest.mark.parametrize("queue", get_queues("cpu,gpu"))
 @pytest.mark.parametrize("memtype", get_memory_usm())
 def test_with_usm_ndarray_data(queue, memtype):
@@ -61,7 +62,7 @@ def test_with_usm_ndarray_data(queue, memtype):
 
 
 @pytest.mark.skipif(
-    not is_dpctl_available(["cpu", "gpu"]), reason="test uses multiple devices"
+    not is_dpctl_device_available(["cpu", "gpu"]), reason="test uses multiple devices"
 )
 @pytest.mark.parametrize("memtype", get_memory_usm())
 def test_queue_parameter_with_usm_ndarray(memtype):

scikit_learn_intelex-2025.2.0.data/data/Lib/site-packages/onedal/common/tests/test_sycl.py

@@ -0,0 +1,128 @@
+# ==============================================================================
+# 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 numpy as np
+import pytest
+
+from onedal import _backend, _is_dpc_backend
+from onedal.tests.utils._device_selection import get_queues
+from onedal.utils._dpep_helpers import dpctl_available
+
+
+@pytest.mark.skipif(
+    not _is_dpc_backend or not dpctl_available, reason="requires dpc backend and dpctl"
+)
+@pytest.mark.parametrize("device_type", ["cpu", "gpu"])
+@pytest.mark.parametrize("device_number", [None, 0, 1, 2, 3])
+def test_sycl_queue_string_creation(device_type, device_number):
+    # create devices from strings
+    from dpctl import SyclQueue
+    from dpctl._sycl_queue import SyclQueueCreationError
+
+    onedal_SyclQueue = _backend.SyclQueue
+
+    device = (
+        ":".join([device_type, str(device_number)])
+        if device_number is not None
+        else device_type
+    )
+
+    raised_exception_dpctl = False
+    raised_exception_backend = False
+
+    try:
+        dpctl_string = SyclQueue(device).sycl_device.filter_string
+    except SyclQueueCreationError:
+        raised_exception_dpctl = True
+
+    try:
+        onedal_string = onedal_SyclQueue(device).sycl_device.filter_string
+    except RuntimeError:
+        raised_exception_backend = True
+
+    assert raised_exception_dpctl == raised_exception_backend
+    if not raised_exception_backend:
+        # dpctl filter string converts simple sycl filter_strings
+        # i.e. "gpu:1" -> "opencl:gpu:0", use SyclQueue to convert
+        # for matching, as oneDAL sycl queue only returns simple
+        # strings as these are operationally sufficient
+        assert SyclQueue(onedal_string).sycl_device.filter_string == dpctl_string
+
+
+@pytest.mark.skipif(
+    not _is_dpc_backend or not dpctl_available, reason="requires dpc backend and dpctl"
+)
+@pytest.mark.parametrize("queue", get_queues())
+def test_sycl_queue_conversion(queue):
+    if queue is None:
+        pytest.skip("Not a dpctl queue")
+    SyclQueue = queue.__class__
+    onedal_SyclQueue = _backend.SyclQueue
+
+    q = onedal_SyclQueue(queue)
+
+    # convert back and forth to test `_get_capsule` attribute
+    for i in range(10):
+        q = SyclQueue(q.sycl_device.filter_string)
+        q = onedal_SyclQueue(q)
+
+    assert q.sycl_device.filter_string in queue.sycl_device.filter_string
+
+
+@pytest.mark.skipif(
+    not _is_dpc_backend or not dpctl_available, reason="requires dpc backend and dpctl"
+)
+@pytest.mark.parametrize("queue", get_queues())
+def test_sycl_device_attributes(queue):
+    from dpctl import SyclQueue
+
+    if queue is None:
+        pytest.skip("Not a dpctl queue")
+    onedal_SyclQueue = _backend.SyclQueue
+
+    onedal_queue = onedal_SyclQueue(queue)
+
+    # check fp64 support
+    assert onedal_queue.sycl_device.has_aspect_fp64 == queue.sycl_device.has_aspect_fp64
+    # check fp16 support
+    assert onedal_queue.sycl_device.has_aspect_fp16 == queue.sycl_device.has_aspect_fp16
+    # check is_cpu
+    assert onedal_queue.sycl_device.is_cpu == queue.sycl_device.is_cpu
+    # check is_gpu
+    assert onedal_queue.sycl_device.is_gpu == queue.sycl_device.is_gpu
+    # check device number
+    assert onedal_queue.sycl_device.filter_string in queue.sycl_device.filter_string
+
+
+@pytest.mark.skipif(not _is_dpc_backend, reason="requires dpc backend")
+def test_backend_queue():
+    try:
+        q = _backend.SyclQueue("cpu")
+    except RuntimeError:
+        pytest.skip("OpenCL CPU runtime not installed")
+
+    # verify copying via a py capsule object is functional
+    q2 = _backend.SyclQueue(q._get_capsule())
+    # verify copying via the _get_capsule attribute
+    q3 = _backend.SyclQueue(q)
+
+    q_array = [q, q2, q3]
+
+    assert all([queue.sycl_device.has_aspect_fp64 for queue in q_array])
+    assert all([queue.sycl_device.has_aspect_fp16 for queue in q_array])
+    assert all([queue.sycl_device.is_cpu for queue in q_array])
+    assert all([not queue.sycl_device.is_gpu for queue in q_array])
+    assert all(["cpu" in queue.sycl_device.filter_string for queue in q_array])

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

@@ -22,7 +22,7 @@ from onedal.utils import _check_array
 
 from ..common._base import BaseEstimator
 from ..common.hyperparameters import get_hyperparameters
-from ..datatypes import _convert_to_supported, from_table, to_table
+from ..datatypes import from_table, to_table
 
 
 class BaseEmpiricalCovariance(BaseEstimator, metaclass=ABCMeta):
@@ -33,7 +33,7 @@ class BaseEmpiricalCovariance(BaseEstimator, metaclass=ABCMeta):
 
     def _get_onedal_params(self, dtype=np.float32):
         params = {
-            "fptype": "float" if dtype == np.float32 else "double",
+            "fptype": dtype,
             "method": self.method,
         }
         if daal_check_version((2024, "P", 1)):
@@ -95,9 +95,8 @@ class EmpiricalCovariance(BaseEmpiricalCovariance):
         """
         policy = self._get_policy(queue, X)
         X = _check_array(X, dtype=[np.float64, np.float32])
-        X = _convert_to_supported(policy, X)
-        dtype = get_dtype(X)
-        params = self._get_onedal_params(dtype)
+        X = to_table(X, queue=queue)
+        params = self._get_onedal_params(X.dtype)
         hparams = get_hyperparameters("covariance", "compute")
         if hparams is not None and not hparams.is_default:
             result = self._get_backend(
@@ -107,12 +106,10 @@ class EmpiricalCovariance(BaseEmpiricalCovariance):
                 policy,
                 params,
                 hparams.backend,
-                to_table(X),
+                X,
             )
         else:
-            result = self._get_backend(
-                "covariance", None, "compute", policy, params, to_table(X)
-            )
+            result = self._get_backend("covariance", None, "compute", policy, params, X)
         if daal_check_version((2024, "P", 1)) or (not self.bias):
             self.covariance_ = from_table(result.cov_matrix)
         else:

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

@@ -17,7 +17,7 @@ import numpy as np
 
 from daal4py.sklearn._utils import daal_check_version, get_dtype
 
-from ..datatypes import _convert_to_supported, from_table, to_table
+from ..datatypes import from_table, to_table
 from ..utils import _check_array
 from .covariance import BaseEmpiricalCovariance
 
@@ -57,10 +57,22 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
         self._reset()
 
     def _reset(self):
+        self._need_to_finalize = False
         self._partial_result = self._get_backend(
             "covariance", None, "partial_compute_result"
         )
 
+    def __getstate__(self):
+        # Since finalize_fit can't be dispatched without directly provided queue
+        # and the dispatching policy can't be serialized, the computation is finalized
+        # here and the policy is not saved in serialized data.
+
+        self.finalize_fit()
+        data = self.__dict__.copy()
+        data.pop("_queue", None)
+
+        return data
+
     def partial_fit(self, X, y=None, queue=None):
         """
         Computes partial data for the covariance matrix
@@ -89,13 +101,12 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
 
         policy = self._get_policy(queue, X)
 
-        X = _convert_to_supported(policy, X)
+        X_table = to_table(X, queue=queue)
 
         if not hasattr(self, "_dtype"):
-            self._dtype = get_dtype(X)
+            self._dtype = X_table.dtype
 
         params = self._get_onedal_params(self._dtype)
-        table_X = to_table(X)
         self._partial_result = self._get_backend(
             "covariance",
             None,
@@ -103,8 +114,9 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
             policy,
             params,
             self._partial_result,
-            table_X,
+            X_table,
         )
+        self._need_to_finalize = True
 
     def finalize_fit(self, queue=None):
         """
@@ -121,26 +133,29 @@ class IncrementalEmpiricalCovariance(BaseEmpiricalCovariance):
         self : object
             Returns the instance itself.
         """
-        params = self._get_onedal_params(self._dtype)
-        if queue is not None:
-            policy = self._get_policy(queue)
-        else:
-            policy = self._get_policy(self._queue)
-
-        result = self._get_backend(
-            "covariance",
-            None,
-            "finalize_compute",
-            policy,
-            params,
-            self._partial_result,
-        )
-        if daal_check_version((2024, "P", 1)) or (not self.bias):
-            self.covariance_ = from_table(result.cov_matrix)
-        else:
-            n_rows = self._partial_result.partial_n_rows
-            self.covariance_ = from_table(result.cov_matrix) * (n_rows - 1) / n_rows
-
-        self.location_ = from_table(result.means).ravel()
+        if self._need_to_finalize:
+            params = self._get_onedal_params(self._dtype)
+            if queue is not None:
+                policy = self._get_policy(queue)
+            else:
+                policy = self._get_policy(self._queue)
+
+            result = self._get_backend(
+                "covariance",
+                None,
+                "finalize_compute",
+                policy,
+                params,
+                self._partial_result,
+            )
+            if daal_check_version((2024, "P", 1)) or (not self.bias):
+                self.covariance_ = from_table(result.cov_matrix)
+            else:
+                n_rows = self._partial_result.partial_n_rows
+                self.covariance_ = from_table(result.cov_matrix) * (n_rows - 1) / n_rows
+
+            self.location_ = from_table(result.means).ravel()
+
+            self._need_to_finalize = False
 
         return self

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

@@ -18,6 +18,7 @@ import numpy as np
 import pytest
 from numpy.testing import assert_allclose
 
+from onedal.datatypes import from_table
 from onedal.tests.utils._device_selection import get_queues
 
 
@@ -42,8 +43,8 @@ def test_on_gold_data_unbiased(queue, dtype):
     assert_allclose(expected_means, result.location_)
 
     X = np.array([[1, 2], [3, 6]])
-    X_split = np.array_split(X, 2)
     X = X.astype(dtype)
+    X_split = np.array_split(X, 2)
     inccov = IncrementalEmpiricalCovariance()
 
     for i in range(2):
@@ -120,3 +121,70 @@ def test_partial_fit_on_random_data(
 
     assert_allclose(expected_covariance, result.covariance_, atol=1e-6)
     assert_allclose(expected_means, result.location_, atol=1e-6)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_incremental_estimator_pickle(queue, dtype):
+    import pickle
+
+    from onedal.covariance import IncrementalEmpiricalCovariance
+
+    inccov = IncrementalEmpiricalCovariance()
+
+    # Check that estimator can be serialized without any data.
+    dump = pickle.dumps(inccov)
+    inccov_loaded = pickle.loads(dump)
+    seed = 77
+    gen = np.random.default_rng(seed)
+    X = gen.uniform(low=-0.3, high=+0.7, size=(10, 10))
+    X = X.astype(dtype)
+    X_split = np.array_split(X, 2)
+    inccov.partial_fit(X_split[0], queue=queue)
+    inccov_loaded.partial_fit(X_split[0], queue=queue)
+
+    assert inccov._need_to_finalize == True
+    assert inccov_loaded._need_to_finalize == True
+
+    # Check that estimator can be serialized after partial_fit call.
+    dump = pickle.dumps(inccov)
+    inccov_loaded = pickle.loads(dump)
+
+    assert inccov._need_to_finalize == False
+    # Finalize is called during serialization to make sure partial results are finalized correctly.
+    assert inccov_loaded._need_to_finalize == False
+
+    partial_n_rows = from_table(inccov._partial_result.partial_n_rows)
+    partial_n_rows_loaded = from_table(inccov_loaded._partial_result.partial_n_rows)
+    assert_allclose(partial_n_rows, partial_n_rows_loaded)
+
+    partial_crossproduct = from_table(inccov._partial_result.partial_crossproduct)
+    partial_crossproduct_loaded = from_table(
+        inccov_loaded._partial_result.partial_crossproduct
+    )
+    assert_allclose(partial_crossproduct, partial_crossproduct_loaded)
+
+    partial_sums = from_table(inccov._partial_result.partial_sums)
+    partial_sums_loaded = from_table(inccov_loaded._partial_result.partial_sums)
+    assert_allclose(partial_sums, partial_sums_loaded)
+
+    inccov.partial_fit(X_split[1], queue=queue)
+    inccov_loaded.partial_fit(X_split[1], queue=queue)
+    assert inccov._need_to_finalize == True
+    assert inccov_loaded._need_to_finalize == True
+
+    dump = pickle.dumps(inccov_loaded)
+    inccov_loaded = pickle.loads(dump)
+
+    assert inccov._need_to_finalize == True
+    assert inccov_loaded._need_to_finalize == False
+
+    inccov.finalize_fit()
+    inccov_loaded.finalize_fit()
+
+    # Check that finalized estimator can be serialized.
+    dump = pickle.dumps(inccov_loaded)
+    inccov_loaded = pickle.loads(dump)
+
+    assert_allclose(inccov.location_, inccov_loaded.location_, atol=1e-6)
+    assert_allclose(inccov.covariance_, inccov_loaded.covariance_, atol=1e-6)

scikit_learn_intelex-2025.2.0.data/data/Lib/site-packages/onedal/datatypes/__init__.py

@@ -0,0 +1,19 @@
+# ==============================================================================
+# 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 ._data_conversion import from_table, to_table
+
+__all__ = ["from_table", "to_table"]

scikit_learn_intelex-2025.2.0.data/data/Lib/site-packages/onedal/datatypes/_data_conversion.py

@@ -0,0 +1,121 @@
+# ==============================================================================
+# 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 warnings
+
+import numpy as np
+
+from onedal import _backend, _is_dpc_backend
+
+
+def _apply_and_pass(func, *args, **kwargs):
+    if len(args) == 1:
+        return func(args[0], **kwargs)
+    return tuple(map(lambda arg: func(arg, **kwargs), args))
+
+
+def _convert_one_to_table(arg, queue=None):
+    # All inputs for table conversion must be array-like or sparse, not scalars
+    return _backend.to_table(np.atleast_2d(arg) if np.isscalar(arg) else arg, queue)
+
+
+def to_table(*args, queue=None):
+    """Create oneDAL tables from scalars and/or arrays.
+
+    Note: this implementation can be used with scipy.sparse, numpy ndarrays,
+    DPCTL/DPNP usm_ndarrays and scalars. Tables will use pointers to the
+    original array data. Scalars and non-contiguous arrays will be copies.
+    Arrays may be modified in-place by oneDAL during computation. This works
+    for data located on CPU and SYCL-enabled Intel GPUs. Each array may only
+    be of a single datatype (i.e. each must be homogeneous).
+
+    Parameters
+    ----------
+    *args : {scalar, numpy array, sycl_usm_ndarray, csr_matrix, or csr_array}
+        arg1, arg2... The arrays should be given as arguments.
+
+    Returns
+    -------
+    tables: {oneDAL homogeneous tables}
+    """
+    return _apply_and_pass(_convert_one_to_table, *args, queue=queue)
+
+
+if _is_dpc_backend:
+
+    try:
+        # try/catch is used here instead of dpep_helpers because
+        # of circular import issues of _data_conversion.py and
+        # utils/validation.py. This is a temporary fix until the
+        # issue with dpnp is addressed, at which point this can
+        # be removed entirely.
+        import dpnp
+
+        def _table_to_array(table, xp=None):
+            # By default DPNP ndarray created with a copy.
+            # TODO:
+            # investigate why dpnp.array(table, copy=False) doesn't work.
+            # Work around with using dpctl.tensor.asarray.
+            if xp == dpnp:
+                return dpnp.array(dpnp.dpctl.tensor.asarray(table), copy=False)
+            else:
+                return xp.asarray(table)
+
+    except ImportError:
+
+        def _table_to_array(table, xp=None):
+            return xp.asarray(table)
+
+    from ..common._policy import _HostInteropPolicy
+
+    def convert_one_from_table(table, sycl_queue=None, sua_iface=None, xp=None):
+        # Currently only `__sycl_usm_array_interface__` protocol used to
+        # convert into dpnp/dpctl tensors.
+        if sua_iface:
+            if (
+                sycl_queue
+                and sycl_queue.sycl_device.is_cpu
+                and table.__sycl_usm_array_interface__["syclobj"] is None
+            ):
+                # oneDAL returns tables with None sycl queue for CPU sycl queue inputs.
+                # This workaround is necessary for the functional preservation
+                # of the compute-follows-data execution.
+                # Host tables first converted into numpy.narrays and then to array from xp
+                # namespace.
+                return xp.asarray(
+                    _backend.from_table(table), usm_type="device", sycl_queue=sycl_queue
+                )
+            else:
+                return _table_to_array(table, xp=xp)
+
+        return _backend.from_table(table)
+
+else:
+
+    def convert_one_from_table(table, sycl_queue=None, sua_iface=None, xp=None):
+        # Currently only `__sycl_usm_array_interface__` protocol used to
+        # convert into dpnp/dpctl tensors.
+        if sua_iface:
+            raise RuntimeError(
+                "SYCL usm array conversion from table requires the DPC backend"
+            )
+        return _backend.from_table(table)
+
+
+def from_table(*args, sycl_queue=None, sua_iface=None, xp=None):
+    return _apply_and_pass(
+        convert_one_from_table, *args, sycl_queue=sycl_queue, sua_iface=sua_iface, xp=xp
+    )