scikit-learn-intelex 2025.6.1__py39-none-win_amd64.whl → 2025.8.0__py39-none-win_amd64.whl

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/decomposition/tests/test_pca.py

@@ -24,11 +24,25 @@ from onedal.tests.utils._dataframes_support import (
     _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())
-def test_sklearnex_import(dataframe, queue):
-    from sklearnex.decomposition import PCA
+@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)
@@ -41,7 +55,18 @@ def test_sklearnex_import(dataframe, queue):
         [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)
@@ -56,3 +81,30 @@ def test_sklearnex_import(dataframe, queue):
     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.6.1.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")
@@ -529,6 +524,17 @@ def sklearn_is_patched(name=None, return_map=False):
 
 
 def is_patched_instance(instance: object) -> bool:
-    """Returns True if the `instance` is patched with scikit-learn-intelex"""
+    """Check if given instance is patched with scikit-learn-intelex.
+
+    Parameters
+    ----------
+    instance : object
+        Python object, usually a scikit-learn estimator instance.
+
+    Returns
+    -------
+    Check : bool
+        Boolean whether instance is a daal4py or sklearnex estimator.
+    """
     module = getattr(instance, "__module__", "")
     return ("daal4py" in module) or ("sklearnex" in module)

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

@@ -52,14 +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._dpep_helpers import get_unique_values_with_dpep
 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
@@ -123,7 +122,13 @@ class BaseForest(oneDALEstimator, ABC):
             if sample_weight is not None:
                 sample_weight = [sample_weight]
         else:
-            self.classes_ = get_unique_values_with_dpep(y)
+            # try catch needed for raw_inputs + array_api data where unlike
+            # numpy the way to yield unique values is via `unique_values`
+            # This should be removed when refactored for gpu zero-copy
+            try:
+                self.classes_ = xp.unique(y)
+            except AttributeError:
+                self.classes_ = xp.unique_values(y)
             self.n_classes_ = len(self.classes_)
         self.n_features_in_ = X.shape[1]
 
@@ -453,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_:
@@ -826,7 +834,8 @@ class ForestClassifier(BaseForest, _sklearn_ForestClassifier):
         res = self._onedal_estimator.predict(X, queue=queue)
         try:
             return xp.take(
-                xp.asarray(self.classes_), xp.astype(xp.reshape(res, (-1,)), xp.int64)
+                xp.asarray(self.classes_, device=res.sycl_queue),
+                xp.astype(xp.reshape(res, (-1,)), xp.int64),
             )
         except AttributeError:
             return np.take(self.classes_, res.ravel().astype(np.int64, casting="unsafe"))
@@ -896,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.")
@@ -1206,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.6.1.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.6.1.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"

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.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(
@@ -60,8 +58,11 @@ class IncrementalLinearRegression(
     MultiOutputMixin, RegressorMixin, oneDALEstimator, BaseEstimator
 ):
     """
-    Trains a linear regression model, allows for computation if the data are split into
-    batches. The user can use the ``partial_fit`` method to provide a single batch of data or use the ``fit`` method to provide
+    Incremental Ordinary least squares Linear Regression.
+
+    Trains a linear regression model, allows for computation if the data
+    are split into batches. The user can use the ``partial_fit`` method
+    to provide a single batch of data or use the ``fit`` method to provide
     the entire dataset.
 
     Parameters
@@ -107,6 +108,10 @@ class IncrementalLinearRegression(
     n_features_in_ : int
         Number of features seen during ``fit`` or ``partial_fit``.
 
+    Notes
+    -----
+    Sparse data formats are not supported. Input dtype must be ``float32`` or ``float64``.
+
     %incremental_serialization_note%
 
     Examples
@@ -137,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],
         }
 
@@ -157,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,
             )
@@ -172,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(
@@ -182,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:
@@ -227,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
@@ -257,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
@@ -271,48 +286,9 @@ 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 linear model with X and y. All of X and y is
-        processed as a single batch.
+        Incremental fit with X and y. X and y are processed as a single batch.
 
         Parameters
         ----------
@@ -324,11 +300,16 @@ class IncrementalLinearRegression(
             Target values, where ``n_samples`` is the number of samples and
             ``n_targets`` is the number of targets.
 
+        check_input : bool, default=True
+            Run validate_data on X and y.
+
         Returns
         -------
         self : IncrementalLinearRegression
             Returns the instance itself.
         """
+        if sklearn_check_version("1.2") and check_input:
+            self._validate_params()
 
         dispatch(
             self,
@@ -354,7 +335,7 @@ class IncrementalLinearRegression(
             ``n_features`` is the number of features. It is necessary for
             ``n_samples`` to be not less than ``n_features`` if ``fit_intercept``
             is False and not less than ``n_features + 1`` if ``fit_intercept``
-            is True
+            is 'True'.
 
         y : array-like of shape (n_samples,) or (n_samples, n_targets)
             Target values, where ``n_samples`` is the number of samples and
@@ -365,6 +346,8 @@ class IncrementalLinearRegression(
         self : IncrementalLinearRegression
             Returns the instance itself.
         """
+        if sklearn_check_version("1.2"):
+            self._validate_params()
 
         dispatch(
             self,
@@ -406,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__