scikit-learn-intelex 2025.4.0__py310-none-win_amd64.whl → 2025.6.0__py310-none-win_amd64.whl

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/onedal/linear_model/incremental_linear_model.py

@@ -16,11 +16,15 @@
 
 import numpy as np
 
-from daal4py.sklearn._utils import get_dtype
+from onedal._device_offload import supports_queue
+from onedal.common._backend import bind_default_backend
+from onedal.utils import _sycl_queue_manager as QM
 
+from .._config import _get_config
 from ..common.hyperparameters import get_hyperparameters
 from ..datatypes import from_table, to_table
-from ..utils import _check_X_y, _num_features
+from ..utils._array_api import _get_sycl_namespace
+from ..utils.validation import _check_X_y, _num_features
 from .linear_model import BaseLinearRegression
 
 
@@ -44,13 +48,23 @@ class IncrementalLinearRegression(BaseLinearRegression):
 
     def __init__(self, fit_intercept=True, copy_X=False, algorithm="norm_eq"):
         super().__init__(fit_intercept=fit_intercept, copy_X=copy_X, algorithm=algorithm)
+        self._queue = None
         self._reset()
 
+    @bind_default_backend("linear_model.regression")
+    def partial_train_result(self): ...
+
+    @bind_default_backend("linear_model.regression")
+    def partial_train(self, *args, **kwargs): ...
+
+    @bind_default_backend("linear_model.regression")
+    def finalize_train(self, *args, **kwargs): ...
+
     def _reset(self):
         self._need_to_finalize = False
-        self._partial_result = self._get_backend(
-            "linear_model", "regression", "partial_train_result"
-        )
+        # Get the pointer to partial_result from backend
+        self._queue = None
+        self._partial_result = self.partial_train_result()
 
     def __getstate__(self):
         # Since finalize_fit can't be dispatched without directly provided queue
@@ -63,6 +77,7 @@ class IncrementalLinearRegression(BaseLinearRegression):
 
         return data
 
+    @supports_queue
     def partial_fit(self, X, y, queue=None):
         """
         Computes partial data for linear regression
@@ -84,37 +99,37 @@ class IncrementalLinearRegression(BaseLinearRegression):
         self : object
             Returns the instance itself.
         """
-        module = self._get_backend("linear_model", "regression")
+        use_raw_input = _get_config().get("use_raw_input", False) is True
+        sua_iface, _, _ = _get_sycl_namespace(X)
+
+        if use_raw_input and sua_iface:
+            queue = X.sycl_queue
+        if not use_raw_input:
+            X, y = _check_X_y(
+                X,
+                y,
+                dtype=[np.float64, np.float32],
+                accept_2d_y=True,
+                force_all_finite=False,
+            )
+            y = np.asarray(y, dtype=X.dtype)
 
-        self._queue = queue
-        policy = self._get_policy(queue, X)
-
-        X, y = _check_X_y(
-            X, y, dtype=[np.float64, np.float32], accept_2d_y=True, force_all_finite=False
-        )
-        y = np.asarray(y, dtype=X.dtype)
+        if not hasattr(self, "_params"):
+            self._params = self._get_onedal_params(X.dtype)
 
+        self._queue = queue
         self.n_features_in_ = _num_features(X, fallback_1d=True)
 
         X_table, y_table = to_table(X, y, queue=queue)
 
-        if not hasattr(self, "_dtype"):
-            self._dtype = X_table.dtype
-            self._params = self._get_onedal_params(self._dtype)
-
         hparams = get_hyperparameters("linear_regression", "train")
         if hparams is not None and not hparams.is_default:
-            self._partial_result = module.partial_train(
-                policy,
-                self._params,
-                hparams.backend,
-                self._partial_result,
-                X_table,
-                y_table,
+            self._partial_result = self.partial_train(
+                self._params, hparams.backend, self._partial_result, X_table, y_table
             )
         else:
-            self._partial_result = module.partial_train(
-                policy, self._params, self._partial_result, X_table, y_table
+            self._partial_result = self.partial_train(
+                self._params, self._partial_result, X_table, y_table
             )
 
         self._need_to_finalize = True
@@ -137,28 +152,24 @@ class IncrementalLinearRegression(BaseLinearRegression):
         """
 
         if self._need_to_finalize:
-            if queue is not None:
-                policy = self._get_policy(queue)
-            else:
-                policy = self._get_policy(self._queue)
-
-            module = self._get_backend("linear_model", "regression")
             hparams = get_hyperparameters("linear_regression", "train")
-            if hparams is not None and not hparams.is_default:
-                result = module.finalize_train(
-                    policy, self._params, hparams.backend, self._partial_result
-                )
-            else:
-                result = module.finalize_train(policy, self._params, self._partial_result)
+            with QM.manage_global_queue(self._queue):
+                if hparams is not None and not hparams.is_default:
+                    result = self.finalize_train(
+                        self._params, hparams.backend, self._partial_result
+                    )
+                else:
+                    result = self.finalize_train(self._params, self._partial_result)
 
             self._onedal_model = result.model
 
-            packed_coefficients = from_table(result.model.packed_coefficients)
+            packed_coefficients = from_table(
+                result.model.packed_coefficients, sycl_queue=self._queue
+            )
             self.coef_, self.intercept_ = (
                 packed_coefficients[:, 1:].squeeze(),
                 packed_coefficients[:, 0].squeeze(),
             )
-
             self._need_to_finalize = False
 
         return self
@@ -191,12 +202,13 @@ class IncrementalRidge(BaseLinearRegression):
         super().__init__(
             fit_intercept=fit_intercept, alpha=alpha, copy_X=copy_X, algorithm=algorithm
         )
+        self._queue = None
         self._reset()
 
     def _reset(self):
-        module = self._get_backend("linear_model", "regression")
-        self._partial_result = module.partial_train_result()
         self._need_to_finalize = False
+        self._queue = None
+        self._partial_result = self.partial_train_result()
 
     def __getstate__(self):
         # Since finalize_fit can't be dispatched without directly provided queue
@@ -209,6 +221,16 @@ class IncrementalRidge(BaseLinearRegression):
 
         return data
 
+    @bind_default_backend("linear_model.regression")
+    def partial_train_result(self): ...
+
+    @bind_default_backend("linear_model.regression")
+    def partial_train(self, *args, **kwargs): ...
+
+    @bind_default_backend("linear_model.regression")
+    def finalize_train(self, *args, **kwargs): ...
+
+    @supports_queue
     def partial_fit(self, X, y, queue=None):
         """
         Computes partial data for ridge regression
@@ -230,11 +252,7 @@ class IncrementalRidge(BaseLinearRegression):
         self : object
             Returns the instance itself.
         """
-        module = self._get_backend("linear_model", "regression")
-
         self._queue = queue
-        policy = self._get_policy(queue, X)
-
         X, y = _check_X_y(
             X, y, dtype=[np.float64, np.float32], accept_2d_y=True, force_all_finite=False
         )
@@ -248,9 +266,15 @@ class IncrementalRidge(BaseLinearRegression):
             self._dtype = X_table.dtype
             self._params = self._get_onedal_params(self._dtype)
 
-        self._partial_result = module.partial_train(
-            policy, self._params, self._partial_result, X_table, y_table
-        )
+        hparams = get_hyperparameters("linear_regression", "train")
+        if hparams is not None and not hparams.is_default:
+            self._partial_result = self.partial_train(
+                self._params, hparams.backend, self._partial_result, X_table, y_table
+            )
+        else:
+            self._partial_result = self.partial_train(
+                self._params, self._partial_result, X_table, y_table
+            )
 
         self._need_to_finalize = True
         return self
@@ -270,16 +294,11 @@ class IncrementalRidge(BaseLinearRegression):
         self : object
             Returns the instance itself.
         """
-
         if self._need_to_finalize:
-            module = self._get_backend("linear_model", "regression")
-            if queue is not None:
-                policy = self._get_policy(queue)
-            else:
-                policy = self._get_policy(self._queue)
-            result = module.finalize_train(policy, self._params, self._partial_result)
+            with QM.manage_global_queue(self._queue):
+                result = self.finalize_train(self._params, self._partial_result)
 
-            self._onedal_model = result.model
+                self._onedal_model = result.model
 
             packed_coefficients = from_table(result.model.packed_coefficients)
             self.coef_, self.intercept_ = (

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/onedal/linear_model/linear_model.py

@@ -20,15 +20,19 @@ from numbers import Number
 import numpy as np
 
 from daal4py.sklearn._utils import daal_check_version, get_dtype, make2d
+from onedal._device_offload import supports_queue
+from onedal.common._backend import bind_default_backend
+from onedal.utils import _sycl_queue_manager as QM
 
-from ..common._base import BaseEstimator
+from .._config import _get_config
 from ..common._estimator_checks import _check_is_fitted
 from ..common.hyperparameters import get_hyperparameters
 from ..datatypes import from_table, to_table
-from ..utils import _check_array, _check_n_features, _check_X_y, _num_features
+from ..utils._array_api import _get_sycl_namespace
+from ..utils.validation import _check_array, _check_n_features, _check_X_y, _num_features
 
 
-class BaseLinearRegression(BaseEstimator, metaclass=ABCMeta):
+class BaseLinearRegression(metaclass=ABCMeta):
     """
     Base class for LinearRegression oneDAL implementation.
     """
@@ -40,6 +44,16 @@ class BaseLinearRegression(BaseEstimator, metaclass=ABCMeta):
         self.copy_X = copy_X
         self.algorithm = algorithm
 
+    @bind_default_backend("linear_model.regression")
+    def train(self, *args, **kwargs): ...
+
+    @bind_default_backend("linear_model.regression")
+    def infer(self, params, model, X): ...
+
+    # direct access to the backend model class
+    @bind_default_backend("linear_model.regression")
+    def model(self): ...
+
     def _get_onedal_params(self, dtype=np.float32):
         intercept = "intercept|" if self.fit_intercept else ""
         params = {
@@ -53,9 +67,8 @@ class BaseLinearRegression(BaseEstimator, metaclass=ABCMeta):
 
         return params
 
-    def _create_model(self, policy):
-        module = self._get_backend("linear_model", "regression")
-        model = module.model()
+    def _create_model(self):
+        model = self.model()
 
         coefficients = self.coef_
         dtype = get_dtype(coefficients)
@@ -92,13 +105,14 @@ class BaseLinearRegression(BaseEstimator, metaclass=ABCMeta):
             packed_coefficients[:, 0][:, np.newaxis] = intercept
 
         model.packed_coefficients = to_table(
-            packed_coefficients, queue=getattr(policy, "_queue", None)
+            packed_coefficients, queue=QM.get_global_queue()
         )
 
         self._onedal_model = model
 
         return model
 
+    @supports_queue
     def predict(self, X, queue=None):
         """
         Predict using the linear model.
@@ -115,30 +129,34 @@ class BaseLinearRegression(BaseEstimator, metaclass=ABCMeta):
         C : array, shape (n_samples, n_targets)
             Returns predicted values.
         """
-        module = self._get_backend("linear_model", "regression")
 
         _check_is_fitted(self)
 
-        policy = self._get_policy(queue, X)
+        sua_iface, xp, _ = _get_sycl_namespace(X)
+        use_raw_input = _get_config().get("use_raw_input", False) is True
+        if use_raw_input and sua_iface is not None:
+            queue = X.sycl_queue
+
+        if not use_raw_input:
+            X = _check_array(
+                X, dtype=[np.float64, np.float32], force_all_finite=False, ensure_2d=False
+            )
+            X = make2d(X)
 
-        X = _check_array(
-            X, dtype=[np.float64, np.float32], force_all_finite=False, ensure_2d=False
-        )
         _check_n_features(self, X, False)
 
         if hasattr(self, "_onedal_model"):
             model = self._onedal_model
         else:
-            model = self._create_model(policy)
+            model = self._create_model()
 
         X_table = to_table(X, queue=queue)
         params = self._get_onedal_params(X_table.dtype)
-
-        result = module.infer(policy, params, model, X_table)
-        y = from_table(result.responses)
+        result = self.infer(params, model, X_table)
+        y = from_table(result.responses, sua_iface=sua_iface, sycl_queue=queue, xp=xp)
 
         if y.shape[1] == 1 and self.coef_.ndim == 1:
-            return y.ravel()
+            return xp.reshape(y, (-1,))
         else:
             return y
 
@@ -171,6 +189,7 @@ class LinearRegression(BaseLinearRegression):
     ):
         super().__init__(fit_intercept=fit_intercept, copy_X=copy_X, algorithm=algorithm)
 
+    @supports_queue
     def fit(self, X, y, queue=None):
         """
         Fit linear model.
@@ -190,22 +209,23 @@ class LinearRegression(BaseLinearRegression):
         self : object
             Fitted Estimator.
         """
-        module = self._get_backend("linear_model", "regression")
 
-        # TODO Fix _check_X_y to make sure this conversion is there
-        if not isinstance(X, np.ndarray):
-            X = np.asarray(X)
-
-        dtype = get_dtype(X)
-        if dtype not in [np.float32, np.float64]:
-            dtype = np.float64
-            X = X.astype(dtype, copy=self.copy_X)
+        sua_iface, xp, _ = _get_sycl_namespace(X)
+        use_raw_input = _get_config().get("use_raw_input", False) is True
+        if use_raw_input and sua_iface is not None:
+            queue = X.sycl_queue
+        if _get_config()["use_raw_input"] is False:
+            if not isinstance(X, np.ndarray):
+                X = np.asarray(X)
 
-        y = np.asarray(y).astype(dtype=dtype)
+            dtype = get_dtype(X)
+            if dtype not in [np.float32, np.float64]:
+                dtype = np.float64
+                X = X.astype(dtype, copy=self.copy_X)
 
-        X, y = _check_X_y(X, y, force_all_finite=False, accept_2d_y=True)
+            y = np.asarray(y).astype(dtype=dtype)
 
-        policy = self._get_policy(queue, X, y)
+            X, y = _check_X_y(X, y, force_all_finite=False, accept_2d_y=True)
 
         self.n_features_in_ = _num_features(X, fallback_1d=True)
 
@@ -214,13 +234,15 @@ class LinearRegression(BaseLinearRegression):
 
         hparams = get_hyperparameters("linear_regression", "train")
         if hparams is not None and not hparams.is_default:
-            result = module.train(policy, params, hparams.backend, X_table, y_table)
+            result = self.train(params, hparams.backend, X_table, y_table)
         else:
-            result = module.train(policy, params, X_table, y_table)
+            result = self.train(params, X_table, y_table)
 
         self._onedal_model = result.model
 
-        packed_coefficients = from_table(result.model.packed_coefficients)
+        packed_coefficients = from_table(
+            result.model.packed_coefficients, sycl_queue=queue
+        )
         self.coef_, self.intercept_ = (
             packed_coefficients[:, 1:],
             packed_coefficients[:, 0],
@@ -269,6 +291,7 @@ class Ridge(BaseLinearRegression):
             fit_intercept=fit_intercept, alpha=alpha, copy_X=copy_X, algorithm=algorithm
         )
 
+    @supports_queue
     def fit(self, X, y, queue=None):
         """
         Fit linear model.
@@ -288,8 +311,13 @@ class Ridge(BaseLinearRegression):
         self : object
             Fitted Estimator.
         """
-        module = self._get_backend("linear_model", "regression")
-
+        X = _check_array(
+            X,
+            dtype=[np.float64, np.float32],
+            force_all_finite=False,
+            ensure_2d=False,
+            copy=self.copy_X,
+        )
         if not isinstance(X, np.ndarray):
             X = np.asarray(X)
 
@@ -302,14 +330,12 @@ class Ridge(BaseLinearRegression):
 
         X, y = _check_X_y(X, y, force_all_finite=False, accept_2d_y=True)
 
-        policy = self._get_policy(queue, X, y)
-
         self.n_features_in_ = _num_features(X, fallback_1d=True)
 
         X_table, y_table = to_table(X, y, queue=queue)
         params = self._get_onedal_params(X.dtype)
 
-        result = module.train(policy, params, X_table, y_table)
+        result = self.train(params, X_table, y_table)
         self._onedal_model = result.model
 
         packed_coefficients = from_table(result.model.packed_coefficients)