scikit-learn-intelex 2025.1.0__py312-none-win_amd64.whl → 2025.4.0__py312-none-win_amd64.whl

{scikit_learn_intelex-2025.1.0.data → scikit_learn_intelex-2025.4.0.data}/data/Lib/site-packages/onedal/neighbors/neighbors.py

@@ -31,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,
@@ -130,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,
@@ -427,10 +427,10 @@ 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
@@ -442,7 +442,7 @@ class KNeighborsClassifier(NeighborsBase, ClassifierMixin):
             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:
@@ -451,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
@@ -562,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"
@@ -585,14 +581,14 @@ 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):
         if type(model) is kdtree_knn_classification_model:
@@ -602,7 +598,7 @@ class KNeighborsRegressor(NeighborsBase, RegressorMixin):
 
         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
@@ -615,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
 
@@ -732,10 +728,10 @@ 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
@@ -747,15 +743,15 @@ class NearestNeighbors(NeighborsBase):
             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.1.0.data → scikit_learn_intelex-2025.4.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.1.0.data → scikit_learn_intelex-2025.4.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
 
@@ -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.4.0.data/data/Lib/site-packages/onedal/utils/tests/test_validation.py

@@ -0,0 +1,142 @@
+# ==============================================================================
+# 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 numpy.random as rand
+import pytest
+import scipy.sparse as sp
+
+from onedal.tests.utils._dataframes_support import (
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+)
+from onedal.utils.validation import assert_all_finite
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize(
+    "shape",
+    [
+        [16, 2048],
+        [65539],  # 2**16 + 3,
+        [1000, 1000],
+        [
+            3,
+        ],
+    ],
+)
+@pytest.mark.parametrize("allow_nan", [False, True])
+@pytest.mark.parametrize(
+    "dataframe, queue", get_dataframes_and_queues("numpy,dpnp,dpctl")
+)
+def test_sum_infinite_actually_finite(dtype, shape, allow_nan, dataframe, queue):
+    X = np.empty(shape, dtype=dtype)
+    X.fill(np.finfo(dtype).max)
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    assert_all_finite(X, allow_nan=allow_nan)
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize(
+    "shape",
+    [
+        [16, 2048],
+        [65539],  # 2**16 + 3,
+        [1000, 1000],
+        [
+            3,
+        ],
+    ],
+)
+@pytest.mark.parametrize("allow_nan", [False, True])
+@pytest.mark.parametrize("check", ["inf", "NaN", None])
+@pytest.mark.parametrize("seed", [0, 123456])
+@pytest.mark.parametrize(
+    "dataframe, queue", get_dataframes_and_queues("numpy,dpnp,dpctl")
+)
+def test_assert_finite_random_location(
+    dtype, shape, allow_nan, check, seed, dataframe, queue
+):
+    rand.seed(seed)
+    X = rand.uniform(high=np.finfo(dtype).max, size=shape).astype(dtype)
+
+    if check:
+        loc = rand.randint(0, X.size - 1)
+        X.reshape((-1,))[loc] = float(check)
+
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+
+    if check is None or (allow_nan and check == "NaN"):
+        assert_all_finite(X, allow_nan=allow_nan)
+    else:
+        msg_err = "Input contains " + ("infinity" if allow_nan else "NaN, infinity") + "."
+        with pytest.raises(ValueError, match=msg_err):
+            assert_all_finite(X, allow_nan=allow_nan)
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("allow_nan", [False, True])
+@pytest.mark.parametrize("check", ["inf", "NaN", None])
+@pytest.mark.parametrize("seed", [0, 123456])
+@pytest.mark.parametrize(
+    "dataframe, queue", get_dataframes_and_queues("numpy,dpnp,dpctl")
+)
+def test_assert_finite_random_shape_and_location(
+    dtype, allow_nan, check, seed, dataframe, queue
+):
+    lb, ub = 2, 1048576  # ub is 2^20
+    rand.seed(seed)
+    X = rand.uniform(high=np.finfo(dtype).max, size=rand.randint(lb, ub)).astype(dtype)
+
+    if check:
+        loc = rand.randint(0, X.size - 1)
+        X[loc] = float(check)
+
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+
+    if check is None or (allow_nan and check == "NaN"):
+        assert_all_finite(X, allow_nan=allow_nan)
+    else:
+        msg_err = "Input contains " + ("infinity" if allow_nan else "NaN, infinity") + "."
+        with pytest.raises(ValueError, match=msg_err):
+            assert_all_finite(X, allow_nan=allow_nan)
+
+
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+@pytest.mark.parametrize("allow_nan", [False, True])
+@pytest.mark.parametrize("check", ["inf", "NaN", None])
+@pytest.mark.parametrize("seed", [0, 123456])
+def test_assert_finite_sparse(dtype, allow_nan, check, seed):
+    lb, ub = 2, 2056
+    rand.seed(seed)
+    X = sp.random(
+        rand.randint(lb, ub),
+        rand.randint(lb, ub),
+        format="csr",
+        dtype=dtype,
+        random_state=rand.default_rng(seed),
+    )
+
+    if check:
+        locx = rand.randint(0, X.data.shape[0] - 1)
+        X.data[locx] = float(check)
+
+    if check is None or (allow_nan and check == "NaN"):
+        assert_all_finite(X, allow_nan=allow_nan)
+    else:
+        msg_err = "Input contains " + ("infinity" if allow_nan else "NaN, infinity") + "."
+        with pytest.raises(ValueError, match=msg_err):
+            assert_all_finite(X, allow_nan=allow_nan)

{scikit_learn_intelex-2025.1.0.data → scikit_learn_intelex-2025.4.0.data}/data/Lib/site-packages/onedal/utils/validation.py

@@ -31,7 +31,12 @@ else:
 from sklearn.preprocessing import LabelEncoder
 from sklearn.utils.validation import check_array
 
-from daal4py.sklearn.utils.validation import _assert_all_finite
+from daal4py.sklearn.utils.validation import (
+    _assert_all_finite as _daal4py_assert_all_finite,
+)
+from onedal import _backend
+from onedal.common._policy import _get_policy
+from onedal.datatypes import to_table
 
 
 class DataConversionWarning(UserWarning):
@@ -135,10 +140,10 @@ def _check_array(
     if force_all_finite:
         if sp.issparse(array):
             if hasattr(array, "data"):
-                _assert_all_finite(array.data)
+                _daal4py_assert_all_finite(array.data)
                 force_all_finite = False
         else:
-            _assert_all_finite(array)
+            _daal4py_assert_all_finite(array)
             force_all_finite = False
     array = check_array(
         array=array,
@@ -153,15 +158,6 @@ def _check_array(
 
     if sp.issparse(array):
         return array
-
-    # TODO: Convert this kind of arrays to a table like in daal4py
-    if not array.flags.aligned and not array.flags.writeable:
-        array = np.array(array.tolist())
-
-    # TODO: If data is not contiguous copy to contiguous
-    # Need implemeted numpy table in oneDAL
-    if not array.flags.c_contiguous and not array.flags.f_contiguous:
-        array = np.ascontiguousarray(array, array.dtype)
     return array
 
 
@@ -200,7 +196,7 @@ def _check_X_y(
     if y_numeric and y.dtype.kind == "O":
         y = y.astype(np.float64)
     if force_all_finite:
-        _assert_all_finite(y)
+        _daal4py_assert_all_finite(y)
 
     lengths = [X.shape[0], y.shape[0]]
     uniques = np.unique(lengths)
@@ -285,7 +281,7 @@ def _type_of_target(y):
     # check float and contains non-integer float values
     if y.dtype.kind == "f" and np.any(y != y.astype(int)):
         # [.1, .2, 3] or [[.1, .2, 3]] or [[1., .2]] and not [1., 2., 3.]
-        _assert_all_finite(y)
+        _daal4py_assert_all_finite(y)
         return "continuous" + suffix
 
     if (len(np.unique(y)) > 2) or (y.ndim >= 2 and len(y[0]) > 1):
@@ -438,3 +434,31 @@ def _is_csr(x):
     return isinstance(x, sp.csr_matrix) or (
         hasattr(sp, "csr_array") and isinstance(x, sp.csr_array)
     )
+
+
+def _assert_all_finite(X, allow_nan=False, input_name=""):
+    policy = _get_policy(None, X)
+    X_t = to_table(X)
+    params = {
+        "fptype": X_t.dtype,
+        "method": "dense",
+        "allow_nan": allow_nan,
+    }
+    if not _backend.finiteness_checker.compute.compute(policy, params, X_t).finite:
+        type_err = "infinity" if allow_nan else "NaN, infinity"
+        padded_input_name = input_name + " " if input_name else ""
+        msg_err = f"Input {padded_input_name}contains {type_err}."
+        raise ValueError(msg_err)
+
+
+def assert_all_finite(
+    X,
+    *,
+    allow_nan=False,
+    input_name="",
+):
+    _assert_all_finite(
+        X.data if sp.issparse(X) else X,
+        allow_nan=allow_nan,
+        input_name=input_name,
+    )

{scikit_learn_intelex-2025.1.0.data → scikit_learn_intelex-2025.4.0.data}/data/Lib/site-packages/sklearnex/_utils.py

@@ -16,14 +16,27 @@
 
 import logging
 import os
-import sys
+import re
 import warnings
 from abc import ABC
 
+import sklearn
+
 from daal4py.sklearn._utils import (
     PatchingConditionsChain as daal4py_PatchingConditionsChain,
 )
-from daal4py.sklearn._utils import daal_check_version
+from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
+
+# Note: if inheriting from '_HTMLDocumentationLinkMixin' here, it then doesn't matter
+# the order of inheritance of classes for estimators when this is later subclassed,
+# whereas if inheriting from something else, the subclass that inherits from this needs
+# to be the first inherited class in estimators in order for it to take effect.
+if sklearn_check_version("1.4"):
+    from sklearn.utils._estimator_html_repr import _HTMLDocumentationLinkMixin
+
+    BaseForHTMLDocLink = _HTMLDocumentationLinkMixin
+else:
+    BaseForHTMLDocLink = ABC
 
 
 class PatchingConditionsChain(daal4py_PatchingConditionsChain):
@@ -106,27 +119,59 @@ def register_hyperparameters(hyperparameters_map):
     Adds `get_hyperparameters` method to class.
     """
 
-    def wrap_class(estimator_class):
-        def get_hyperparameters(self, op):
-            return hyperparameters_map[op]
+    def decorator(cls):
+        """Add `get_hyperparameters()` static method"""
+
+        class StaticHyperparametersAccessor:
+            """Like a @staticmethod, but additionally raises a Warning when called on an instance."""
+
+            def __get__(self, instance, _):
+                if instance is not None:
+                    warnings.warn(
+                        "Hyperparameters are static variables and can not be modified per instance."
+                    )
+                return self.get_hyperparameters
+
+            def get_hyperparameters(self, op):
+                return hyperparameters_map[op]
+
+        cls.get_hyperparameters = StaticHyperparametersAccessor()
+        return cls
+
+    return decorator
+
 
-        estimator_class.get_hyperparameters = get_hyperparameters
-        return estimator_class
+# This abstract class is meant to generate a clickable doc link for classses
+# in sklearnex that are not part of base scikit-learn.
+class IntelEstimator(BaseForHTMLDocLink):
+    @property
+    def _doc_link_module(self) -> str:
+        return "sklearnex"
 
-    return wrap_class
+    @property
+    def _doc_link_template(self) -> str:
+        module_path, _ = self.__class__.__module__.rsplit(".", 1)
+        class_name = self.__class__.__name__
+        return f"https://uxlfoundation.github.io/scikit-learn-intelex/latest/non-scikit-algorithms.html#{module_path}.{class_name}"
 
 
 # This abstract class is meant to generate a clickable doc link for classses
-# in sklearnex that are not part of base scikit-learn. It should be inherited
-# before inheriting from a scikit-learn estimator, otherwise will get overriden
-# by the estimator's original.
-class IntelEstimator(ABC):
+# in sklearnex that have counterparts in scikit-learn.
+class PatchableEstimator(BaseForHTMLDocLink):
     @property
     def _doc_link_module(self) -> str:
         return "sklearnex"
 
     @property
     def _doc_link_template(self) -> str:
+        if re.search(r"^\d\.\d\.\d$", sklearn.__version__):
+            sklearn_version_parts = sklearn.__version__.split(".")
+            doc_version_url = sklearn_version_parts[0] + "." + sklearn_version_parts[1]
+        else:
+            doc_version_url = "stable"
         module_path, _ = self.__class__.__module__.rsplit(".", 1)
+        module_path = re.sub("sklearnex", "sklearn", module_path)
         class_name = self.__class__.__name__
-        return f"https://intel.github.io/scikit-learn-intelex/latest/non-scikit-algorithms.html#{module_path}.{class_name}"
+        # for TSNE, which re-uses daal4py
+        module_path = re.sub(r"daal4py\.", "", module_path)
+        return f"https://scikit-learn.org/{doc_version_url}/modules/generated/{module_path}.{class_name}.html"

{scikit_learn_intelex-2025.1.0.data → scikit_learn_intelex-2025.4.0.data}/data/Lib/site-packages/sklearnex/basic_statistics/basic_statistics.py

@@ -17,13 +17,15 @@
 import warnings
 
 import numpy as np
+from scipy.sparse import issparse
 from sklearn.base import BaseEstimator
 from sklearn.utils import check_array
 from sklearn.utils.validation import _check_sample_weight
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
-from daal4py.sklearn._utils import sklearn_check_version
+from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
 from onedal.basic_statistics import BasicStatistics as onedal_BasicStatistics
+from onedal.utils import _is_csr
 
 from .._device_offload import dispatch
 from .._utils import IntelEstimator, PatchingConditionsChain
@@ -62,13 +64,13 @@ class BasicStatistics(IntelEstimator, BaseEstimator):
         mean_ : ndarray of shape (n_features,)
             Mean of each feature over all samples.
         variance_ : ndarray of shape (n_features,)
-            Variance of each feature over all samples.
+            Variance of each feature over all samples. Bessel's correction is used.
         variation_ : ndarray of shape (n_features,)
-            Variation of each feature over all samples.
+            Variation of each feature over all samples. Bessel's correction is used.
         sum_squares_ : ndarray of shape (n_features,)
             Sum of squares for each feature over all samples.
         standard_deviation_ : ndarray of shape (n_features,)
-            Standard deviation of each feature over all samples.
+            Unbiased standard deviation of each feature over all samples. Bessel's correction is used.
         sum_squares_centered_ : ndarray of shape (n_features,)
             Centered sum of squares for each feature over all samples.
         second_order_raw_moment_ : ndarray of shape (n_features,)
@@ -166,21 +168,50 @@ class BasicStatistics(IntelEstimator, BaseEstimator):
             f"'{self.__class__.__name__}' object has no attribute '{attr}'"
         )
 
-    def _onedal_supported(self, method_name, *data):
+    def _onedal_cpu_supported(self, method_name, *data):
         patching_status = PatchingConditionsChain(
             f"sklearnex.basic_statistics.{self.__class__.__name__}.{method_name}"
         )
         return patching_status
 
-    _onedal_cpu_supported = _onedal_supported
-    _onedal_gpu_supported = _onedal_supported
+    def _onedal_gpu_supported(self, method_name, *data):
+        patching_status = PatchingConditionsChain(
+            f"sklearnex.basic_statistics.{self.__class__.__name__}.{method_name}"
+        )
+        X, sample_weight = data
+
+        is_data_supported = not issparse(X) or (
+            _is_csr(X) and daal_check_version((2025, "P", 200))
+        )
+
+        is_sample_weight_supported = sample_weight is None or not issparse(X)
+
+        patching_status.and_conditions(
+            [
+                (
+                    is_sample_weight_supported,
+                    "Sample weights are not supported for CSR data format",
+                ),
+                (
+                    is_data_supported,
+                    "Supported data formats: Dense, CSR (oneDAL version >= 2025.2.0).",
+                ),
+            ]
+        )
+        return patching_status
 
     def _onedal_fit(self, X, sample_weight=None, queue=None):
         if sklearn_check_version("1.2"):
             self._validate_params()
 
         if sklearn_check_version("1.0"):
-            X = validate_data(self, X, dtype=[np.float64, np.float32], ensure_2d=False)
+            X = validate_data(
+                self,
+                X,
+                dtype=[np.float64, np.float32],
+                ensure_2d=False,
+                accept_sparse="csr",
+            )
         else:
             X = check_array(X, dtype=[np.float64, np.float32])
 

{scikit_learn_intelex-2025.1.0.data → scikit_learn_intelex-2025.4.0.data}/data/Lib/site-packages/sklearnex/basic_statistics/incremental_basic_statistics.py

@@ -103,6 +103,13 @@ class IncrementalBasicStatistics(IntelEstimator, BaseEstimator):
     ----
     Attribute exists only if corresponding result option has been provided.
 
+    Note
+    ----
+    Serializing instances of this class will trigger a forced finalization of calculations.
+    Since finalize_fit can't be dispatched without directly provided queue
+    and the dispatching policy can't be serialized, the computation is finalized
+    during serialization call and the policy is not saved in serialized data.
+
     Note
     ----
     Names of attributes without the trailing underscore are