scikit-learn-intelex 2025.4.0__py39-none-win_amd64.whl → 2025.5.0__py39-none-win_amd64.whl

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.5.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)

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

@@ -20,12 +20,17 @@ 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 as onedal_BaseEstimator
+from .._config import _get_config
 from ..common._estimator_checks import _check_is_fitted
 from ..common._mixin import ClassifierMixin
 from ..datatypes import from_table, to_table
-from ..utils import (
+from ..utils._array_api import _get_sycl_namespace
+from ..utils._dpep_helpers import get_unique_values_with_dpep
+from ..utils.validation import (
     _check_array,
     _check_n_features,
     _check_X_y,
@@ -35,7 +40,7 @@ from ..utils import (
 )
 
 
-class BaseLogisticRegression(onedal_BaseEstimator, metaclass=ABCMeta):
+class BaseLogisticRegression(metaclass=ABCMeta):
     @abstractmethod
     def __init__(self, tol, C, fit_intercept, solver, max_iter, algorithm):
         self.tol = tol
@@ -45,6 +50,16 @@ class BaseLogisticRegression(onedal_BaseEstimator, metaclass=ABCMeta):
         self.max_iter = max_iter
         self.algorithm = algorithm
 
+    @abstractmethod
+    def train(self, params, X, y): ...
+
+    @abstractmethod
+    def infer(self, params, X): ...
+
+    # direct access to the backend model constructor
+    @abstractmethod
+    def model(self): ...
+
     def _get_onedal_params(self, is_csr, dtype=np.float32):
         intercept = "intercept|" if self.fit_intercept else ""
         return {
@@ -62,31 +77,36 @@ class BaseLogisticRegression(onedal_BaseEstimator, metaclass=ABCMeta):
             ),
         }
 
-    def _fit(self, X, y, module, queue):
+    def _fit(self, X, y):
+        use_raw_input = _get_config()["use_raw_input"] is True
+
         sparsity_enabled = daal_check_version((2024, "P", 700))
-        X, y = _check_X_y(
-            X,
-            y,
-            accept_sparse=sparsity_enabled,
-            force_all_finite=True,
-            accept_2d_y=False,
-            dtype=[np.float64, np.float32],
-        )
+        if not use_raw_input:
+            X, y = _check_X_y(
+                X,
+                y,
+                accept_sparse=sparsity_enabled,
+                force_all_finite=True,
+                accept_2d_y=False,
+                dtype=[np.float64, np.float32],
+            )
+            if _type_of_target(y) != "binary":
+                raise ValueError("Only binary classification is supported")
+
+            self.classes_, y = np.unique(y, return_inverse=True)
+            y = y.astype(dtype=np.int32)
+        else:
+            self.classes_ = get_unique_values_with_dpep(y)
+            n_classes = len(self.classes_)
+            if n_classes != 2:
+                raise ValueError("Only binary classification is supported")
         is_csr = _is_csr(X)
 
         self.n_features_in_ = _num_features(X, fallback_1d=True)
-
-        if _type_of_target(y) != "binary":
-            raise ValueError("Only binary classification is supported")
-
-        self.classes_, y = np.unique(y, return_inverse=True)
-        y = y.astype(dtype=np.int32)
-
-        policy = self._get_policy(queue, X, y)
-        X_table, y_table = to_table(X, y, queue=queue)
+        X_table, y_table = to_table(X, y, queue=QM.get_global_queue())
         params = self._get_onedal_params(is_csr, X_table.dtype)
 
-        result = module.train(policy, params, X_table, y_table)
+        result = self.train(params, X_table, y_table)
 
         self._onedal_model = result.model
         self.n_iter_ = np.array([result.iterations_count])
@@ -100,8 +120,8 @@ class BaseLogisticRegression(onedal_BaseEstimator, metaclass=ABCMeta):
 
         return self
 
-    def _create_model(self, module, policy):
-        m = module.model()
+    def _create_model(self):
+        m = self.model()
 
         coefficients = self.coef_
         dtype = get_dtype(coefficients)
@@ -143,59 +163,65 @@ class BaseLogisticRegression(onedal_BaseEstimator, metaclass=ABCMeta):
         if self.fit_intercept:
             packed_coefficients[:, 0][:, np.newaxis] = intercept
 
-        m.packed_coefficients = to_table(
-            packed_coefficients, queue=getattr(policy, "_queue", None)
-        )
+        m.packed_coefficients = to_table(packed_coefficients, queue=QM.get_global_queue())
 
         self._onedal_model = m
 
         return m
 
-    def _infer(self, X, module, queue):
+    def _infer(self, X):
         _check_is_fitted(self)
+
         sparsity_enabled = daal_check_version((2024, "P", 700))
 
-        X = _check_array(
-            X,
-            dtype=[np.float64, np.float32],
-            accept_sparse=sparsity_enabled,
-            force_all_finite=True,
-            ensure_2d=False,
-            accept_large_sparse=sparsity_enabled,
-        )
+        if not _get_config()["use_raw_input"]:
+            X = _check_array(
+                X,
+                dtype=[np.float64, np.float32],
+                accept_sparse=sparsity_enabled,
+                force_all_finite=True,
+                ensure_2d=False,
+                accept_large_sparse=sparsity_enabled,
+            )
         is_csr = _is_csr(X)
         _check_n_features(self, X, False)
 
         X = make2d(X)
-        policy = self._get_policy(queue, X)
 
         if hasattr(self, "_onedal_model"):
             model = self._onedal_model
         else:
-            model = self._create_model(module, policy)
+            model = self._create_model()
 
-        X_table = to_table(X, queue=queue)
+        X_table = to_table(X, queue=QM.get_global_queue())
         params = self._get_onedal_params(is_csr, X.dtype)
 
-        result = module.infer(policy, params, model, X_table)
+        result = self.infer(params, model, X_table)
         return result
 
-    def _predict(self, X, module, queue):
-        result = self._infer(X, module, queue)
-        y = from_table(result.responses)
-        y = np.take(self.classes_, y.ravel(), axis=0)
+    def _predict(self, X):
+        result = self._infer(X)
+        sua_iface, xp, _ = _get_sycl_namespace(X)
+        y = from_table(
+            result.responses,
+            sua_iface=sua_iface,
+            sycl_queue=QM.get_global_queue(),
+            xp=xp,
+        )
+        y = xp.take(xp.asarray(self.classes_), xp.reshape(y, (-1,)), axis=0)
         return y
 
-    def _predict_proba(self, X, module, queue):
-        result = self._infer(X, module, queue)
-
-        y = from_table(result.probabilities)
-        y = y.reshape(-1, 1)
-        return np.hstack([1 - y, y])
+    def _predict_proba(self, X):
+        result = result = self._infer(X)
+        sua_iface, xp, _ = _get_sycl_namespace(X)
+        queue = QM.get_global_queue()
+        y = from_table(result.probabilities, sua_iface=sua_iface, sycl_queue=queue, xp=xp)
+        return xp.stack([1 - y, y], axis=1)
 
-    def _predict_log_proba(self, X, module, queue):
-        y_proba = self._predict_proba(X, module, queue)
-        return np.log(y_proba)
+    def _predict_log_proba(self, X):
+        _, xp, _ = _get_sycl_namespace(X)
+        y_proba = self._predict_proba(X)
+        return xp.log(y_proba)
 
 
 class LogisticRegression(ClassifierMixin, BaseLogisticRegression):
@@ -223,25 +249,27 @@ class LogisticRegression(ClassifierMixin, BaseLogisticRegression):
             algorithm=algorithm,
         )
 
+    @bind_default_backend("logistic_regression.classification")
+    def train(self, params, X, y, queue=None): ...
+
+    @bind_default_backend("logistic_regression.classification")
+    def infer(self, params, X, model, queue=None): ...
+
+    @bind_default_backend("logistic_regression.classification")
+    def model(self): ...
+
+    @supports_queue
     def fit(self, X, y, queue=None):
-        return super()._fit(
-            X, y, self._get_backend("logistic_regression", "classification", None), queue
-        )
+        return self._fit(X, y)
 
+    @supports_queue
     def predict(self, X, queue=None):
-        y = super()._predict(
-            X, self._get_backend("logistic_regression", "classification", None), queue
-        )
-        return y
+        return self._predict(X)
 
+    @supports_queue
     def predict_proba(self, X, queue=None):
-        y = super()._predict_proba(
-            X, self._get_backend("logistic_regression", "classification", None), queue
-        )
-        return y
+        return self._predict_proba(X)
 
+    @supports_queue
     def predict_log_proba(self, X, queue=None):
-        y = super()._predict_log_proba(
-            X, self._get_backend("logistic_regression", "classification", None), queue
-        )
-        return y
+        return self._predict_log_proba(X)