scikit-learn-intelex 2025.7.0__py312-none-win_amd64.whl → 2025.9.0__py312-none-win_amd64.whl

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

@@ -0,0 +1,164 @@
+# ===============================================================================
+# 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
+import scipy.sparse as sp
+from numpy.testing import assert_allclose
+from sklearn.base import clone
+from sklearn.datasets import load_iris
+
+from daal4py.sklearn._utils import daal_check_version, sklearn_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_
+
+    assert_allclose(res_non_batched, res_batched)
+
+
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues("numpy,dpctl"))
+def test_changed_estimated_attributes(with_array_api, dataframe, queue):
+    # check that attributes necessary for the PCA onedal estimator match
+    # changes occurring in the sklearnex estimator
+    X, y = load_iris(return_X_y=True)
+
+    X_0 = _convert_to_dataframe(X[y == 0], sycl_queue=queue, target_df=dataframe)
+    X = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+
+    est0 = PCA(n_components=4).fit(X_0)
+    est = clone(est0)
+    assert not hasattr(est, "_onedal_estimator")
+    est.fit(X)
+    assert not np.array_equal(_as_numpy(est.transform(X)), _as_numpy(est0.transform(X)))
+
+    # copy over parameters necessary for transform
+    est.mean_ = est0.mean_
+    est.components_ = est0.components_
+    est.explained_variance_ = est0.explained_variance_
+    est.n_components_ = est0.n_components_  # is trivial but exercises the logic
+
+    assert np.array_equal(_as_numpy(est.transform(X)), _as_numpy(est0.transform(X)))
+
+
+@pytest.mark.skipif(
+    not sklearn_check_version("1.5"),
+    reason='svd_solver="auto" does not support sparse inputs',
+)
+@pytest.mark.allow_sklearn_fallback
+def test_create_model_behavior():
+    # verify that fit fallbacks does not break ``transform`` as the oneDAL
+    # model is generated JIT
+
+    X, _ = load_iris(return_X_y=True)
+    # generate a onedal estimator
+    est = PCA(n_components=3)
+    X_trans = est.fit_transform(X)
+
+    # force data to sparse for a fallback to sklearn
+    X_sp = sp.csr_matrix(X)
+    est.fit(X_sp)
+    # In the case of a fallback, the model should be set to none by clobbered
+    # fitted attributes
+    assert est._onedal_estimator._onedal_model is None
+
+    X_trans_sparse = est.transform(X)
+    # use allclose as data was fit with sklearn and onedal on the same data
+    # but using different backends
+    assert_allclose(X_trans, X_trans_sparse)

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.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.9.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.9.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.9.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"

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/sklearnex/linear_model/incremental_linear.py

@@ -17,11 +17,10 @@
 import numbers
 import warnings
 
-import numpy as np
 from sklearn.base import BaseEstimator, MultiOutputMixin, RegressorMixin
 from sklearn.linear_model import LinearRegression as _sklearn_LinearRegression
 from sklearn.metrics import r2_score
-from sklearn.utils import check_array, gen_batches
+from sklearn.utils import gen_batches
 from sklearn.utils.validation import check_is_fitted
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
@@ -31,13 +30,6 @@ from onedal.linear_model import (
 )
 from sklearnex._config import get_config
 
-from ..utils.validation import validate_data
-
-if sklearn_check_version("1.2"):
-    from sklearn.utils._param_validation import Interval
-
-from onedal.common.hyperparameters import get_hyperparameters
-
 from .._device_offload import dispatch, wrap_output_data
 from .._utils import (
     PatchingConditionsChain,
@@ -45,12 +37,18 @@ from .._utils import (
     register_hyperparameters,
 )
 from ..base import oneDALEstimator
+from ..utils._array_api import enable_array_api, get_namespace
+from ..utils.validation import validate_data
+
+if sklearn_check_version("1.2"):
+    from sklearn.utils._param_validation import Interval
 
 
+@enable_array_api("1.5")  # validate_data y_numeric requires sklearn >=1.5
 @register_hyperparameters(
     {
-        "fit": get_hyperparameters("linear_regression", "train"),
-        "partial_fit": get_hyperparameters("linear_regression", "train"),
+        "fit": ("linear_regression", "train"),
+        "partial_fit": ("linear_regression", "train"),
     }
 )
 @control_n_jobs(
@@ -144,7 +142,7 @@ class IncrementalLinearRegression(
         _parameter_constraints: dict = {
             "fit_intercept": ["boolean"],
             "copy_X": ["boolean"],
-            "n_jobs": [Interval(numbers.Integral, -1, None, closed="left"), None],
+            "n_jobs": [numbers.Integral, None],
             "batch_size": [Interval(numbers.Integral, 1, None, closed="left"), None],
         }
 
@@ -164,14 +162,16 @@ class IncrementalLinearRegression(
     _onedal_gpu_supported = _onedal_supported
 
     def _onedal_predict(self, X, queue=None):
-        if get_config()["use_raw_input"] is False:
+        if not get_config()["use_raw_input"]:
             if sklearn_check_version("1.2"):
                 self._validate_params()
 
+            xp, _ = get_namespace(X)
+
             X = validate_data(
                 self,
                 X,
-                dtype=[np.float64, np.float32],
+                dtype=[xp.float64, xp.float32],
                 copy=self.copy_X,
                 reset=False,
             )
@@ -179,7 +179,11 @@ class IncrementalLinearRegression(
         assert hasattr(self, "_onedal_estimator")
         if self._need_to_finalize:
             self._onedal_finalize_fit()
-        return self._onedal_estimator.predict(X, queue=queue)
+        res = self._onedal_estimator.predict(X, queue=queue)
+
+        if res.shape[1] == 1 and self.coef_.ndim == 1:
+            res = xp.reshape(res, (-1,))
+        return res
 
     def _onedal_score(self, X, y, sample_weight=None, queue=None):
         return r2_score(
@@ -189,22 +193,17 @@ class IncrementalLinearRegression(
     def _onedal_partial_fit(self, X, y, check_input=True, queue=None):
         first_pass = not hasattr(self, "n_samples_seen_") or self.n_samples_seen_ == 0
 
-        if sklearn_check_version("1.2"):
-            self._validate_params()
-
-        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, y)
             X, y = validate_data(
                 self,
                 X,
                 y,
-                dtype=[np.float64, np.float32],
+                dtype=[xp.float64, xp.float32],
                 reset=first_pass,
                 copy=self.copy_X,
                 multi_output=True,
-                ensure_all_finite=False,
+                y_numeric=True,
             )
 
         if first_pass:
@@ -234,20 +233,29 @@ class IncrementalLinearRegression(
         assert hasattr(self, "_onedal_estimator")
         self._onedal_validate_underdetermined(self.n_samples_seen_, self.n_features_in_)
         self._onedal_estimator.finalize_fit()
+
+        self.n_features_in_ = self._onedal_estimator.n_features_in_
+        self._coef_ = self._onedal_estimator.coef_
+        self._intercept_ = self._onedal_estimator.intercept_
+
+        if self._coef_.shape[0] == 1:
+            self._coef_ = self._coef_[0, ...]  # set to 1d
+            self._intercept_ = self._intercept_[0]  # set 1d to scalar
+
         self._need_to_finalize = False
 
     def _onedal_fit(self, X, y, queue=None):
-        if get_config()["use_raw_input"] is False:
-            if sklearn_check_version("1.2"):
-                self._validate_params()
+        if not get_config()["use_raw_input"]:
+            xp, _ = get_namespace(X, y)
+
             X, y = validate_data(
                 self,
                 X,
                 y,
-                dtype=[np.float64, np.float32],
+                dtype=[xp.float64, xp.float32],
                 copy=self.copy_X,
                 multi_output=True,
-                ensure_2d=True,
+                y_numeric=True,
             )
 
         n_samples, n_features = X.shape
@@ -264,7 +272,7 @@ class IncrementalLinearRegression(
             self._onedal_estimator._reset()
 
         for batch in gen_batches(n_samples, self.batch_size_):
-            X_batch, y_batch = X[batch], y[batch]
+            X_batch, y_batch = X[batch, ...], y[batch, ...]
             self._onedal_partial_fit(X_batch, y_batch, check_input=False, queue=queue)
 
         # finite check occurs on onedal side
@@ -278,44 +286,6 @@ class IncrementalLinearRegression(
         self._onedal_finalize_fit()
         return self
 
-    @property
-    def intercept_(self):
-        if hasattr(self, "_onedal_estimator"):
-            if self._need_to_finalize:
-                self._onedal_finalize_fit()
-
-            return self._onedal_estimator.intercept_
-        else:
-            raise AttributeError(
-                f"'{self.__class__.__name__}' object has no attribute 'intercept_'"
-            )
-
-    @intercept_.setter
-    def intercept_(self, value):
-        self.__dict__["intercept_"] = value
-        if hasattr(self, "_onedal_estimator"):
-            self._onedal_estimator.intercept_ = value
-            del self._onedal_estimator._onedal_model
-
-    @property
-    def coef_(self):
-        if hasattr(self, "_onedal_estimator"):
-            if self._need_to_finalize:
-                self._onedal_finalize_fit()
-
-            return self._onedal_estimator.coef_
-        else:
-            raise AttributeError(
-                f"'{self.__class__.__name__}' object has no attribute 'coef_'"
-            )
-
-    @coef_.setter
-    def coef_(self, value):
-        self.__dict__["coef_"] = value
-        if hasattr(self, "_onedal_estimator"):
-            self._onedal_estimator.coef_ = value
-            del self._onedal_estimator._onedal_model
-
     def partial_fit(self, X, y, check_input=True):
         """
         Incremental fit with X and y. X and y are processed as a single batch.
@@ -338,6 +308,8 @@ class IncrementalLinearRegression(
         self : IncrementalLinearRegression
             Returns the instance itself.
         """
+        if sklearn_check_version("1.2") and check_input:
+            self._validate_params()
 
         dispatch(
             self,
@@ -374,6 +346,8 @@ class IncrementalLinearRegression(
         self : IncrementalLinearRegression
             Returns the instance itself.
         """
+        if sklearn_check_version("1.2"):
+            self._validate_params()
 
         dispatch(
             self,
@@ -415,5 +389,39 @@ class IncrementalLinearRegression(
             sample_weight=sample_weight,
         )
 
+    @property
+    def coef_(self):
+        if hasattr(self, "_onedal_estimator") and self._need_to_finalize:
+            self._onedal_finalize_fit()
+        return self._coef_
+
+    @coef_.setter
+    def coef_(self, value):
+        if hasattr(self, "_onedal_estimator"):
+            self._onedal_estimator.coef_ = value
+            self._onedal_estimator._onedal_model = None
+        self._coef_ = value
+
+    @coef_.deleter
+    def coef_(self):
+        del self._coef_
+
+    @property
+    def intercept_(self):
+        if hasattr(self, "_onedal_estimator") and self._need_to_finalize:
+            self._onedal_finalize_fit()
+        return self._intercept_
+
+    @intercept_.setter
+    def intercept_(self, value):
+        if hasattr(self, "_onedal_estimator"):
+            self._onedal_estimator.intercept_ = value
+            self._onedal_estimator._onedal_model = None
+        self._intercept_ = value
+
+    @intercept_.deleter
+    def intercept_(self):
+        del self._intercept_
+
     score.__doc__ = _sklearn_LinearRegression.score.__doc__
     predict.__doc__ = _sklearn_LinearRegression.predict.__doc__