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/linear_model/logistic_regression.py

@@ -33,6 +33,7 @@ if daal_check_version((2024, "P", 1)):
     from daal4py.sklearn._n_jobs_support import control_n_jobs
     from daal4py.sklearn._utils import sklearn_check_version
     from daal4py.sklearn.linear_model.logistic_path import daal4py_fit, daal4py_predict
+    from onedal._device_offload import support_input_format
     from onedal.linear_model import LogisticRegression as onedal_LogisticRegression
     from onedal.utils.validation import _num_samples
 
@@ -99,6 +100,9 @@ if daal_check_version((2024, "P", 1)):
             )
 
         _onedal_cpu_fit = daal4py_fit
+        decision_function = support_input_format(
+            _sklearn_LogisticRegression.decision_function
+        )
 
         def _onedal_gpu_save_attributes(self):
             assert hasattr(self, "_onedal_estimator")
@@ -209,6 +213,10 @@ if daal_check_version((2024, "P", 1)):
                     (self.class_weight is None, "Class weight is not supported"),
                     (self.solver == "newton-cg", "Only newton-cg solver is supported."),
                     (self.warm_start == False, "Warm start is not supported."),
+                    (
+                        not (self.multi_class == "multinomial"),
+                        "multi_class='multinomial is not supported.",
+                    ),
                     (
                         not self.l1_ratio,
                         "l1 ratio is not supported.",

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

@@ -22,7 +22,7 @@ if daal_check_version((2024, "P", 600)):
     import numbers
 
     import numpy as np
-    from scipy.sparse import issparse
+    import scipy.sparse as sp
     from sklearn.linear_model import Ridge as _sklearn_Ridge
     from sklearn.metrics import r2_score
     from sklearn.utils.validation import check_is_fitted
@@ -40,8 +40,10 @@ if daal_check_version((2024, "P", 600)):
     from .._device_offload import dispatch, wrap_output_data
     from .._utils import PatchingConditionsChain
     from ..base import oneDALEstimator
+    from ..utils._array_api import enable_array_api, get_namespace
     from ..utils.validation import validate_data
 
+    @enable_array_api("1.5")  # validate_data y_numeric requires sklearn >=1.5
     @control_n_jobs(decorated_methods=["fit", "predict", "score"])
     class Ridge(oneDALEstimator, _sklearn_Ridge):
         __doc__ = _sklearn_Ridge.__doc__
@@ -97,6 +99,8 @@ if daal_check_version((2024, "P", 600)):
                     random_state=random_state,
                 )
 
+        _onedal_Ridge = staticmethod(onedal_Ridge)
+
         def fit(self, X, y, sample_weight=None):
             if sklearn_check_version("1.2"):
                 self._validate_params()
@@ -169,7 +173,7 @@ if daal_check_version((2024, "P", 600)):
                         "Only 'auto' solver is supported.",
                     ),
                     (
-                        not issparse(X) and not issparse(y),
+                        not sp.issparse(X) and not sp.issparse(y),
                         "Sparse input is not supported.",
                     ),
                     (sample_weight is None, "Sample weight is not supported."),
@@ -192,8 +196,8 @@ if daal_check_version((2024, "P", 600)):
             assert len(data) <= 2
 
             n_samples = _num_samples(data[0])
-            model_is_sparse = issparse(self.coef_) or (
-                self.fit_intercept and issparse(self.intercept_)
+            model_is_sparse = sp.issparse(self.coef_) or (
+                self.fit_intercept and sp.issparse(self.intercept_)
             )
             patching_status.and_conditions(
                 [
@@ -203,7 +207,7 @@ if daal_check_version((2024, "P", 600)):
                         "Only 'auto' solver is supported.",
                     ),
                     (n_samples > 0, "Number of samples is less than 1."),
-                    (not issparse(data[0]), "Sparse input is not supported."),
+                    (not sp.issparse(data[0]), "Sparse input is not supported."),
                     (not model_is_sparse, "Sparse coefficients are not supported."),
                 ]
             )
@@ -277,12 +281,14 @@ if daal_check_version((2024, "P", 600)):
                 "alpha": self.alpha,
                 "copy_X": self.copy_X,
             }
-            self._onedal_estimator = onedal_Ridge(**onedal_params)
+            self._onedal_estimator = self._onedal_Ridge(**onedal_params)
 
         def _onedal_fit(self, X, y, sample_weight, queue=None):
             # `Sample weight` is not supported. Expected to be None value.
             assert sample_weight is None
 
+            xp, _ = get_namespace(X)
+
             if sklearn_check_version("1.2"):
                 self._validate_params()
             elif sklearn_check_version("1.1"):
@@ -293,9 +299,7 @@ if daal_check_version((2024, "P", 600)):
                 self.tol = check_scalar(
                     self.tol, "tol", target_type=numbers.Real, min_val=0.0
                 )
-                if self.alpha is not None and not isinstance(
-                    self.alpha, (np.ndarray, tuple)
-                ):
+                if self.alpha is not None and np.isscalar(self.alpha):
                     self.alpha = check_scalar(
                         self.alpha,
                         "alpha",
@@ -308,7 +312,7 @@ if daal_check_version((2024, "P", 600)):
                 self,
                 X=X,
                 y=y,
-                dtype=[np.float64, np.float32],
+                dtype=[xp.float64, xp.float32],
                 accept_sparse=["csr", "csc", "coo"],
                 y_numeric=True,
                 multi_output=True,
@@ -323,19 +327,24 @@ if daal_check_version((2024, "P", 600)):
 
             self._initialize_onedal_estimator()
             self._onedal_estimator.fit(X, y, queue=queue)
-            self._save_attributes()
+            self.n_features_in_ = self._onedal_estimator.n_features_in_
+            self._coef_ = self._onedal_estimator.coef_
+            self._intercept_ = self._onedal_estimator.intercept_
 
             if sklearn_check_version("1.6"):
                 if y.ndim == 1 or y.shape[1] == 1:
-                    self.coef_ = self.coef_.ravel()
-                    self.intercept_ = self.intercept_[0]
+                    self._coef_ = self._coef_[0, ...]  # set to 1d
+                    self._intercept_ = self._intercept_[0]  # set 1d to scalar
             else:
                 if self.coef_.shape[0] == 1 and y.ndim == 1:
-                    self.coef_ = self.coef_.ravel()
-                    self.intercept_ = self.intercept_[0]
+                    self._coef_ = self._coef_[0, ...]  # set to 1d
+                    self._intercept_ = self._intercept_[0]  # set 1d to scalar
 
         def _onedal_predict(self, X, queue=None):
-            X = validate_data(self, X, accept_sparse=False, reset=False)
+            xp, _ = get_namespace(X)
+            X = validate_data(
+                self, X, accept_sparse=False, dtype=[xp.float64, xp.float32], reset=False
+            )
 
             if not hasattr(self, "_onedal_estimator"):
                 self._initialize_onedal_estimator()
@@ -343,7 +352,10 @@ if daal_check_version((2024, "P", 600)):
                 self._onedal_estimator.intercept_ = self.intercept_
 
             res = self._onedal_estimator.predict(X, queue=queue)
-            return res
+            if res.shape[1] == 1 and self.coef_.ndim == 1:
+                return xp.reshape(res, (-1,))
+            else:
+                return res
 
         def _onedal_score(self, X, y, sample_weight=None, queue=None):
             return r2_score(
@@ -352,34 +364,33 @@ if daal_check_version((2024, "P", 600)):
 
         @property
         def coef_(self):
-            return self._coef
+            return self._coef_
 
         @coef_.setter
         def coef_(self, value):
             if hasattr(self, "_onedal_estimator"):
                 self._onedal_estimator.coef_ = value
-                # checking if the model is already fitted and if so, deleting the model
-                if hasattr(self._onedal_estimator, "_onedal_model"):
-                    del self._onedal_estimator._onedal_model
-            self._coef = value
+                self._onedal_estimator._onedal_model = None
+            self._coef_ = value
+
+        @coef_.deleter
+        def coef_(self):
+            del self._coef_
 
         @property
         def intercept_(self):
-            return self._intercept
+            return self._intercept_
 
         @intercept_.setter
         def intercept_(self, value):
             if hasattr(self, "_onedal_estimator"):
                 self._onedal_estimator.intercept_ = value
-                # checking if the model is already fitted and if so, deleting the model
-                if hasattr(self._onedal_estimator, "_onedal_model"):
-                    del self._onedal_estimator._onedal_model
-            self._intercept = value
+                self._onedal_estimator._onedal_model = None
+            self._intercept_ = value
 
-        def _save_attributes(self):
-            self.n_features_in_ = self._onedal_estimator.n_features_in_
-            self._coef = self._onedal_estimator.coef_
-            self._intercept = self._onedal_estimator.intercept_
+        @intercept_.deleter
+        def intercept_(self):
+            del self._intercept_
 
         fit.__doc__ = _sklearn_Ridge.fit.__doc__
         predict.__doc__ = _sklearn_Ridge.predict.__doc__

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

@@ -29,71 +29,34 @@ from onedal.tests.utils._dataframes_support import (
 from sklearnex.tests.utils import _IS_INTEL
 
 
-# Note: this is arranged as a fixture with a finalizer instead of as a parameter
-# 'True' / 'False' in order to undo the changes later so that it doesn't affect
-# other tests afterwards. It returns a function instead of making the change
-# directly, in order to avoid importing the estimator class before the import test
-# itself, but it still needs to import the class inside the the function that it
-# returns due to serialization logic in pytest causing differences w.r.t. current
-# closure where the function is called.
-@pytest.fixture(params=[False, True])
-def non_batched_route(request):
-    def change_parameters(queue, macro_block):
-        from sklearnex.linear_model import LinearRegression
-
-        if request.param and daal_check_version((2025, "P", 500)):
-            if queue and queue.sycl_device.is_gpu:
-                pytest.skip("Test for CPU-only functionality")
-            if macro_block is not None:
-                pytest.skip("Parameter combination with no effect")
-
-            non_batched_route.curr_cpu_max_cols_batched = (
-                LinearRegression.get_hyperparameters("fit").cpu_max_cols_batched
-            )
-            non_batched_route.curr_cpu_small_rows_threshold = (
-                LinearRegression.get_hyperparameters("fit").cpu_small_rows_threshold
-            )
-            non_batched_route.curr_cpu_small_rows_max_cols_batched = (
-                LinearRegression.get_hyperparameters(
-                    "fit"
-                ).cpu_small_rows_max_cols_batched
-            )
-            LinearRegression.get_hyperparameters("fit").cpu_max_cols_batched = 1
-            LinearRegression.get_hyperparameters("fit").cpu_small_rows_threshold = 1
-            LinearRegression.get_hyperparameters(
-                "fit"
-            ).cpu_small_rows_max_cols_batched = 1
-
-        elif request.param and not daal_check_version((2025, "P", 500)):
-            pytest.skip("Functionality introduced in later versions")
-
-    def restore_params():
-        from sklearnex.linear_model import LinearRegression
-
-        if request.param and daal_check_version((2025, "P", 500)):
-            LinearRegression.get_hyperparameters("fit").cpu_max_cols_batched = (
-                non_batched_route.curr_cpu_max_cols_batched
-            )
-            LinearRegression.get_hyperparameters("fit").cpu_small_rows_threshold = (
-                non_batched_route.curr_cpu_small_rows_threshold
-            )
-            LinearRegression.get_hyperparameters(
-                "fit"
-            ).cpu_small_rows_max_cols_batched = (
-                non_batched_route.curr_cpu_small_rows_max_cols_batched
-            )
-
-    request.addfinalizer(restore_params)
-    return change_parameters
+@pytest.fixture
+def hyperparameters(request):
+    from sklearnex.linear_model import LinearRegression
+
+    hparams = LinearRegression.get_hyperparameters("fit")
+
+    def restore_hyperparameters():
+        LinearRegression.reset_hyperparameters("fit")
+
+    request.addfinalizer(restore_hyperparameters)
+    return hparams
 
 
 @pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
 @pytest.mark.parametrize("macro_block", [None, 1024])
+@pytest.mark.parametrize("non_batched_route", [False, True])
 @pytest.mark.parametrize("overdetermined", [False, True])
 @pytest.mark.parametrize("multi_output", [False, True])
 def test_sklearnex_import_linear(
-    dataframe, queue, dtype, macro_block, non_batched_route, overdetermined, multi_output
+    hyperparameters,
+    dataframe,
+    queue,
+    dtype,
+    macro_block,
+    non_batched_route,
+    overdetermined,
+    multi_output,
 ):
     if (not overdetermined or multi_output) and not daal_check_version((2025, "P", 1)):
         pytest.skip("Functionality introduced in later versions")
@@ -120,10 +83,13 @@ def test_sklearnex_import_linear(
 
     linreg = LinearRegression()
     if daal_check_version((2024, "P", 0)) and macro_block is not None:
-        hparams = LinearRegression.get_hyperparameters("fit")
-        hparams.cpu_macro_block = macro_block
-        hparams.gpu_macro_block = macro_block
-    non_batched_route(queue, macro_block)
+        hyperparameters.cpu_macro_block = macro_block
+        hyperparameters.gpu_macro_block = macro_block
+        if daal_check_version((2025, "P", 500)) and non_batched_route:
+            # If the non-batched route is requested, set the parameters to use it
+            hyperparameters.cpu_max_cols_batched = 1
+            hyperparameters.cpu_small_rows_threshold = 1
+            hyperparameters.cpu_small_rows_max_cols_batched = 1
 
     X = X.astype(dtype=dtype)
     y = y.astype(dtype=dtype)