scikit-learn-intelex 2025.7.0__py311-none-win_amd64.whl → 2025.8.0__py311-none-win_amd64.whl

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/basic_statistics/incremental_basic_statistics.py

@@ -14,10 +14,8 @@
 # limitations under the License.
 # ==============================================================================
 
-import numpy as np
 from sklearn.base import BaseEstimator
-from sklearn.utils import check_array, gen_batches
-from sklearn.utils.validation import _check_sample_weight
+from sklearn.utils import gen_batches
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
@@ -29,7 +27,8 @@ from .._config import get_config
 from .._device_offload import dispatch
 from .._utils import PatchingConditionsChain, _add_inc_serialization_note
 from ..base import oneDALEstimator
-from ..utils.validation import validate_data
+from ..utils._array_api import enable_array_api, get_namespace
+from ..utils.validation import _check_sample_weight, validate_data
 
 if sklearn_check_version("1.2"):
     from sklearn.utils._param_validation import Interval, StrOptions
@@ -38,6 +37,7 @@ import numbers
 import warnings
 
 
+@enable_array_api
 @control_n_jobs(decorated_methods=["partial_fit", "_onedal_finalize_fit"])
 class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
     """
@@ -159,12 +159,7 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
         }
 
     def __init__(self, result_options="all", batch_size=None):
-        if result_options == "all":
-            self.result_options = (
-                self._onedal_incremental_basic_statistics.get_all_result_options()
-            )
-        else:
-            self.result_options = result_options
+        self.result_options = result_options
         self._need_to_finalize = False
         self.batch_size = batch_size
 
@@ -177,15 +172,7 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
     _onedal_cpu_supported = _onedal_supported
     _onedal_gpu_supported = _onedal_supported
 
-    def _get_onedal_result_options(self, options):
-        if isinstance(options, list):
-            onedal_options = "|".join(self.result_options)
-        else:
-            onedal_options = options
-        assert isinstance(onedal_options, str)
-        return options
-
-    def _onedal_finalize_fit(self):
+    def _onedal_finalize_fit(self, queue=None):
         assert hasattr(self, "_onedal_estimator")
         self._onedal_estimator.finalize_fit()
         self._need_to_finalize = False
@@ -193,19 +180,20 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
     def _onedal_partial_fit(self, X, sample_weight=None, queue=None, check_input=True):
         first_pass = not hasattr(self, "n_samples_seen_") or self.n_samples_seen_ == 0
 
-        use_raw_input = get_config().get("use_raw_input", False) is True
         # never check input when using raw input
-        check_input &= use_raw_input is False
-        if check_input:
+        if check_input and not get_config()["use_raw_input"]:
+            xp, _ = get_namespace(X)
             X = validate_data(
                 self,
                 X,
-                dtype=[np.float64, np.float32],
+                dtype=[xp.float64, xp.float32],
                 reset=first_pass,
             )
 
-        if not use_raw_input and sample_weight is not None:
-            sample_weight = _check_sample_weight(sample_weight, X)
+            if sample_weight is not None:
+                sample_weight = _check_sample_weight(
+                    sample_weight, X, dtype=[xp.float64, xp.float32]
+                )
 
         if first_pass:
             self.n_samples_seen_ = X.shape[0]
@@ -213,28 +201,25 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
         else:
             self.n_samples_seen_ += X.shape[0]
 
-        onedal_params = {
-            "result_options": self._get_onedal_result_options(self.result_options)
-        }
         if not hasattr(self, "_onedal_estimator"):
             self._onedal_estimator = self._onedal_incremental_basic_statistics(
-                **onedal_params
+                result_options=self.result_options
             )
-        self._onedal_estimator.partial_fit(X, weights=sample_weight, queue=queue)
+
+        self._onedal_estimator.partial_fit(X, sample_weight=sample_weight, queue=queue)
         self._need_to_finalize = True
 
     def _onedal_fit(self, X, sample_weight=None, queue=None):
-        use_raw_input = get_config().get("use_raw_input", False) is True
-        if not use_raw_input:
-            if sklearn_check_version("1.2"):
-                self._validate_params()
-
-            X = validate_data(self, X, dtype=[np.float64, np.float32])
+        if not get_config()["use_raw_input"]:
+            xp, _ = get_namespace(X, sample_weight)
+            X = validate_data(self, X, dtype=[xp.float64, xp.float32])
 
             if sample_weight is not None:
-                sample_weight = _check_sample_weight(sample_weight, X)
+                sample_weight = _check_sample_weight(
+                    sample_weight, X, dtype=[xp.float64, xp.float32]
+                )
 
-        n_samples, n_features = X.shape
+        _, n_features = X.shape
         if self.batch_size is None:
             self.batch_size_ = 5 * n_features
         else:
@@ -258,11 +243,12 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
         return self
 
     def __getattr__(self, attr):
-        result_options = self.__dict__["result_options"]
         sattr = attr.removesuffix("_")
         is_statistic_attr = (
-            isinstance(result_options, str) and (sattr == result_options)
-        ) or (isinstance(result_options, list) and (sattr in result_options))
+            sattr in self._onedal_estimator.options
+            if "_onedal_estimator" in self.__dict__
+            else False
+        )
         if is_statistic_attr:
             if self._need_to_finalize:
                 self._onedal_finalize_fit()
@@ -270,7 +256,8 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
                 warnings.warn(
                     "Result attributes without a trailing underscore were deprecated in version 2025.1 and will be removed in 2026.0"
                 )
-            return getattr(self._onedal_estimator, sattr)
+                attr += "_"
+            return getattr(self._onedal_estimator, attr)
         if attr in self.__dict__:
             return self.__dict__[attr]
 
@@ -301,6 +288,8 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
         self : IncrementalBasicStatistics
             Returns the instance itself.
         """
+        if sklearn_check_version("1.2") and check_input:
+            self._validate_params()
         dispatch(
             self,
             "partial_fit",
@@ -334,6 +323,8 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
         self : IncrementalBasicStatistics
             Returns the instance itself.
         """
+        if sklearn_check_version("1.2"):
+            self._validate_params()
         dispatch(
             self,
             "fit",

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/cluster/dbscan.py

@@ -14,42 +14,30 @@
 # limitations under the License.
 # ===============================================================================
 
-import numbers
-from abc import ABC
-
 from scipy import sparse as sp
 from sklearn.cluster import DBSCAN as _sklearn_DBSCAN
-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 onedal.cluster import DBSCAN as onedal_DBSCAN
+from onedal.utils._array_api import _is_numpy_namespace
 
 from .._config import get_config
 from .._device_offload import dispatch
 from .._utils import PatchingConditionsChain
 from ..base import oneDALEstimator
-from ..utils.validation import validate_data
+from ..utils._array_api import enable_array_api, get_namespace
+from ..utils.validation import _check_sample_weight, validate_data
 
 if sklearn_check_version("1.1") and not sklearn_check_version("1.2"):
-    from sklearn.utils import check_scalar
-
-
-class BaseDBSCAN(oneDALEstimator):
-    def _onedal_dbscan(self, **onedal_params):
-        return onedal_DBSCAN(**onedal_params)
+    import numbers
 
-    def _save_attributes(self):
-        assert hasattr(self, "_onedal_estimator")
-
-        self.labels_ = self._onedal_estimator.labels_
-        self.core_sample_indices_ = self._onedal_estimator.core_sample_indices_
-        self.components_ = self._onedal_estimator.components_
-        self.n_features_in_ = self._onedal_estimator.n_features_in_
+    from sklearn.utils import check_scalar
 
 
+@enable_array_api
 @control_n_jobs(decorated_methods=["fit"])
-class DBSCAN(BaseDBSCAN, _sklearn_DBSCAN):
+class DBSCAN(oneDALEstimator, _sklearn_DBSCAN):
     __doc__ = _sklearn_DBSCAN.__doc__
 
     if sklearn_check_version("1.2"):
@@ -86,9 +74,18 @@ class DBSCAN(BaseDBSCAN, _sklearn_DBSCAN):
         self.p = p
         self.n_jobs = n_jobs
 
+    _onedal_dbscan = staticmethod(onedal_DBSCAN)
+
     def _onedal_fit(self, X, y, sample_weight=None, queue=None):
-        if get_config()["use_raw_input"] is False:
-            X = validate_data(self, X, ensure_all_finite=False)
+        xp, _ = get_namespace(X, y, sample_weight)
+        if not get_config()["use_raw_input"]:
+            X = validate_data(
+                self, X, accept_sparse="csr", dtype=[xp.float64, xp.float32]
+            )
+            if sample_weight is not None:
+                sample_weight = _check_sample_weight(
+                    sample_weight, X, dtype=[xp.float64, xp.float32]
+                )
 
         onedal_params = {
             "eps": self.eps,
@@ -103,7 +100,17 @@ class DBSCAN(BaseDBSCAN, _sklearn_DBSCAN):
         self._onedal_estimator = self._onedal_dbscan(**onedal_params)
 
         self._onedal_estimator.fit(X, y=y, sample_weight=sample_weight, queue=queue)
-        self._save_attributes()
+        if self._onedal_estimator.core_sample_indices_ is None:
+            kwargs = {"dtype": xp.int32}  # always the same
+            if not _is_numpy_namespace(xp):
+                kwargs["device"] = X.device
+            self.core_sample_indices_ = xp.empty((0,), **kwargs)
+        else:
+            self.core_sample_indices_ = self._onedal_estimator.core_sample_indices_
+
+        self.components_ = xp.take(X, self.core_sample_indices_, axis=0)
+        self.labels_ = self._onedal_estimator.labels_
+        self.n_features_in_ = X.shape[1]
 
     def _onedal_supported(self, method_name, *data):
         class_name = self.__class__.__name__
@@ -111,7 +118,7 @@ class DBSCAN(BaseDBSCAN, _sklearn_DBSCAN):
             f"sklearn.cluster.{class_name}.{method_name}"
         )
         if method_name == "fit":
-            X, y, sample_weight = data
+            X = data[0]
             patching_status.and_conditions(
                 [
                     (
@@ -175,10 +182,6 @@ class DBSCAN(BaseDBSCAN, _sklearn_DBSCAN):
         else:
             if self.eps <= 0.0:
                 raise ValueError(f"eps == {self.eps}, must be > 0.0.")
-
-        use_raw_input = get_config().get("use_raw_input", False) is True
-        if not use_raw_input and sample_weight is not None:
-            sample_weight = _check_sample_weight(sample_weight, X)
         dispatch(
             self,
             "fit",

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/cluster/k_means.py

@@ -334,6 +334,7 @@ if daal_check_version((2023, "P", 200)):
             return X
 
         _transform = support_input_format(_sklearn_KMeans._transform)
+        transform = support_input_format(_sklearn_KMeans.transform)
 
         @wrap_output_data
         def score(self, X, y=None, sample_weight=None):

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/covariance/incremental_covariance.py

@@ -27,6 +27,7 @@ from sklearn.utils.validation import _num_features, check_is_fitted
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
+from onedal._device_offload import support_sycl_format
 from onedal.covariance import (
     IncrementalEmpiricalCovariance as onedal_IncrementalEmpiricalCovariance,
 )
@@ -231,6 +232,7 @@ class IncrementalEmpiricalCovariance(oneDALEstimator, BaseEstimator):
         return self
 
     @wrap_output_data
+    @support_sycl_format
     def score(self, X_test, y=None):
         xp, _ = get_namespace(X_test)
 

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/decomposition/pca.py

@@ -44,11 +44,11 @@ if daal_check_version((2024, "P", 100)):
 
     from sklearn.decomposition import PCA as _sklearn_PCA
 
-    from onedal.common.hyperparameters import get_hyperparameters
+    from onedal._device_offload import support_sycl_format
     from onedal.decomposition import PCA as onedal_PCA
     from onedal.utils._array_api import _is_numpy_namespace
 
-    @register_hyperparameters({"fit": get_hyperparameters("pca", "train")})
+    @register_hyperparameters({"fit": ("pca", "train")})
     @control_n_jobs(decorated_methods=["fit", "transform", "fit_transform"])
     class PCA(oneDALEstimator, _sklearn_PCA):
         __doc__ = _sklearn_PCA.__doc__
@@ -111,6 +111,10 @@ if daal_check_version((2024, "P", 100)):
                 self.iterated_power = iterated_power
                 self.random_state = random_state
 
+        # guarantee operability with dpnp/dpctl, runs on CPU unless
+        # array_api_dispatch is enabled.
+        score_samples = support_sycl_format(_sklearn_PCA.score_samples)
+
         def fit(self, X, y=None):
             self._fit(X)
             return self
@@ -414,6 +418,7 @@ if daal_check_version((2024, "P", 100)):
         transform.__doc__ = _sklearn_PCA.transform.__doc__
         fit_transform.__doc__ = _sklearn_PCA.fit_transform.__doc__
         inverse_transform.__doc__ = _sklearn_PCA.inverse_transform.__doc__
+        score_samples.__doc__ = _sklearn_PCA.score_samples.__doc__
 
 else:
     from daal4py.sklearn.decomposition import PCA

scikit_learn_intelex-2025.8.0.data/data/Lib/site-packages/sklearnex/decomposition/tests/test_pca.py

@@ -0,0 +1,110 @@
+# ===============================================================================
+# Copyright 2023 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ===============================================================================
+
+import numpy as np
+import pytest
+from numpy.testing import assert_allclose
+
+from daal4py.sklearn._utils import daal_check_version
+from onedal.tests.utils._dataframes_support import (
+    _as_numpy,
+    _convert_to_dataframe,
+    get_dataframes_and_queues,
+)
+from sklearnex.decomposition import PCA
+
+
+@pytest.fixture
+def hyperparameters(request):
+    hparams = PCA.get_hyperparameters("fit")
+
+    def restore_hyperparameters():
+        if daal_check_version((2025, "P", 700)):
+            PCA.reset_hyperparameters("fit")
+
+    request.addfinalizer(restore_hyperparameters)
+    return hparams
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+@pytest.mark.parametrize("macro_block", [None, 2])
+@pytest.mark.parametrize("grain_size", [None, 2])
+def test_sklearnex_import(hyperparameters, dataframe, queue, macro_block, grain_size):
+
+    X = [[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]]
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+    X_transformed_expected = [
+        [-1.38340578, -0.2935787],
+        [-2.22189802, 0.25133484],
+        [-3.6053038, -0.04224385],
+        [1.38340578, 0.2935787],
+        [2.22189802, -0.25133484],
+        [3.6053038, 0.04224385],
+    ]
+
+    if daal_check_version((2025, "P", 700)):
+        if macro_block is not None:
+            if queue and queue.sycl_device.is_gpu:
+                pytest.skip("Test for CPU-only functionality")
+            hyperparameters.cpu_macro_block = macro_block
+        if grain_size is not None:
+            if queue and queue.sycl_device.is_gpu:
+                pytest.skip("Test for CPU-only functionality")
+            hyperparameters.cpu_grain_size = grain_size
+
+    pca = PCA(n_components=2, svd_solver="covariance_eigh")
+
+    pca.fit(X)
+    X_transformed = pca.transform(X)
+    X_fit_transformed = PCA(n_components=2, svd_solver="covariance_eigh").fit_transform(X)
+
+    if daal_check_version((2024, "P", 100)):
+        assert "sklearnex" in pca.__module__
+        assert hasattr(pca, "_onedal_estimator")
+    else:
+        assert "daal4py" in pca.__module__
+
+    tol = 1e-5 if _as_numpy(X_transformed).dtype == np.float32 else 1e-7
+    assert_allclose([6.30061232, 0.54980396], _as_numpy(pca.singular_values_))
+    assert_allclose(X_transformed_expected, _as_numpy(X_transformed), rtol=tol)
+    assert_allclose(X_transformed_expected, _as_numpy(X_fit_transformed), rtol=tol)
+
+
+@pytest.mark.skipif(
+    not daal_check_version((2025, "P", 700)),
+    reason="Functionality introduced in a later version",
+)
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+def test_non_batched_covariance(hyperparameters, dataframe, queue):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("Test for CPU-only functionality")
+
+    from sklearnex.decomposition import PCA
+
+    # This generates a random matrix with non-independent columns
+    rng = np.random.default_rng(seed=123)
+    S = rng.standard_normal(size=(6, 5))
+    S = S.T @ S
+    mu = rng.standard_normal(size=5)
+    X = rng.multivariate_normal(mu, S, size=20)
+
+    hyperparameters.cpu_max_cols_batched = np.iinfo(np.int32).max
+    res_batched = PCA().fit(X).components_
+
+    hyperparameters.cpu_max_cols_batched = 1
+    res_non_batched = PCA().fit(X).components_
+
+    np.testing.assert_allclose(res_non_batched, res_batched)

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/dispatcher.py

@@ -118,12 +118,6 @@ def get_patch_map_core(preview=False):
         from ._config import config_context as config_context_sklearnex
         from ._config import get_config as get_config_sklearnex
         from ._config import set_config as set_config_sklearnex
-
-        if sklearn_check_version("1.2.1"):
-            from .utils.parallel import _FuncWrapper as _FuncWrapper_sklearnex
-        else:
-            from .utils.parallel import _FuncWrapperOld as _FuncWrapper_sklearnex
-
         from .cluster import DBSCAN as DBSCAN_sklearnex
         from .cluster import KMeans as KMeans_sklearnex
         from .covariance import (
@@ -155,6 +149,7 @@ def get_patch_map_core(preview=False):
         from .svm import SVR as SVR_sklearnex
         from .svm import NuSVC as NuSVC_sklearnex
         from .svm import NuSVR as NuSVR_sklearnex
+        from .utils.parallel import _FuncWrapper as _FuncWrapper_sklearnex
 
         # DBSCAN
         mapping.pop("dbscan")

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/ensemble/_forest.py

@@ -52,13 +52,13 @@ from daal4py.sklearn._utils import (
     daal_check_version,
     sklearn_check_version,
 )
+from onedal._device_offload import support_input_format
 from onedal.ensemble import ExtraTreesClassifier as onedal_ExtraTreesClassifier
 from onedal.ensemble import ExtraTreesRegressor as onedal_ExtraTreesRegressor
 from onedal.ensemble import RandomForestClassifier as onedal_RandomForestClassifier
 from onedal.ensemble import RandomForestRegressor as onedal_RandomForestRegressor
 from onedal.primitives import get_tree_state_cls, get_tree_state_reg
 from onedal.utils.validation import _num_features, _num_samples
-from sklearnex import get_hyperparameters
 from sklearnex._utils import register_hyperparameters
 
 from .._config import get_config
@@ -458,6 +458,9 @@ class ForestClassifier(BaseForest, _sklearn_ForestClassifier):
         if self._onedal_factory is None:
             raise TypeError(f" oneDAL estimator has not been set.")
 
+    decision_path = support_input_format(_sklearn_ForestClassifier.decision_path)
+    apply = support_input_format(_sklearn_ForestClassifier.apply)
+
     def _estimators_(self):
         super()._estimators_()
         for est in self._cached_estimators_:
@@ -902,6 +905,9 @@ class ForestRegressor(BaseForest, _sklearn_ForestRegressor):
         if self._onedal_factory is None:
             raise TypeError(f" oneDAL estimator has not been set.")
 
+    decision_path = support_input_format(_sklearn_ForestRegressor.decision_path)
+    apply = support_input_format(_sklearn_ForestRegressor.apply)
+
     def _onedal_fit_ready(self, patching_status, X, y, sample_weight):
         if sp.issparse(y):
             raise ValueError("sparse multilabel-indicator for y is not supported.")
@@ -1212,7 +1218,7 @@ class ForestRegressor(BaseForest, _sklearn_ForestRegressor):
     score.__doc__ = _sklearn_ForestRegressor.score.__doc__
 
 
-@register_hyperparameters({"infer": get_hyperparameters("decision_forest", "infer")})
+@register_hyperparameters({"predict": ("decision_forest", "infer")})
 @control_n_jobs(decorated_methods=["fit", "predict", "predict_proba", "score"])
 class RandomForestClassifier(ForestClassifier):
     __doc__ = _sklearn_RandomForestClassifier.__doc__

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/ensemble/tests/test_forest.py

@@ -35,9 +35,24 @@ hparam_values = [
 ]
 
 
+@pytest.fixture
+def hyperparameters(request):
+    from sklearnex.ensemble import RandomForestClassifier
+
+    hparams = RandomForestClassifier.get_hyperparameters("predict")
+
+    def restore_hyperparameters():
+        RandomForestClassifier.reset_hyperparameters("predict")
+
+    request.addfinalizer(restore_hyperparameters)
+    return hparams
+
+
 @pytest.mark.parametrize("dataframe, queue", get_dataframes_and_queues())
 @pytest.mark.parametrize("block, trees, rows, scale", hparam_values)
-def test_sklearnex_import_rf_classifier(dataframe, queue, block, trees, rows, scale):
+def test_sklearnex_import_rf_classifier(
+    hyperparameters, dataframe, queue, block, trees, rows, scale
+):
     from sklearnex.ensemble import RandomForestClassifier
 
     X, y = make_classification(
@@ -51,12 +66,12 @@ def test_sklearnex_import_rf_classifier(dataframe, queue, block, trees, rows, sc
     X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
     y = _convert_to_dataframe(y, sycl_queue=queue, target_df=dataframe)
     rf = RandomForestClassifier(max_depth=2, random_state=0).fit(X, y)
-    hparams = RandomForestClassifier.get_hyperparameters("infer")
-    if hparams and block is not None:
-        hparams.block_size = block
-        hparams.min_trees_for_threading = trees
-        hparams.min_number_of_rows_for_vect_seq_compute = rows
-        hparams.scale_factor_for_vect_parallel_compute = scale
+
+    if hyperparameters and block is not None:
+        hyperparameters.block_size = block
+        hyperparameters.min_trees_for_threading = trees
+        hyperparameters.min_number_of_rows_for_vect_seq_compute = rows
+        hyperparameters.scale_factor_for_vect_parallel_compute = scale
     assert "sklearnex" in rf.__module__
     assert_allclose([1], _as_numpy(rf.predict([[0, 0, 0, 0]])))
 

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/linear_model/coordinate_descent.py

@@ -24,6 +24,7 @@ from ..base import oneDALEstimator
 # sycl GPU support. No GPU device will be offloaded.
 ElasticNet.fit = support_input_format(ElasticNet.fit)
 ElasticNet.predict = support_input_format(ElasticNet.predict)
+ElasticNet.path = staticmethod(support_input_format(ElasticNet.path))
 ElasticNet.score = support_input_format(ElasticNet.score)
 if sklearn_check_version("1.4"):
     ElasticNet._doc_link_module = "daal4py"
@@ -36,6 +37,7 @@ if sklearn_check_version("1.4"):
 # sycl GPU support. No GPU device will be offloaded.
 Lasso.fit = support_input_format(Lasso.fit)
 Lasso.predict = support_input_format(Lasso.predict)
+Lasso.path = staticmethod(support_input_format(Lasso.path))
 Lasso.score = support_input_format(Lasso.score)
 if sklearn_check_version("1.4"):
     Lasso._doc_link_module = "daal4py"