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

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/onedal/linear_model/incremental_linear_model.py

@@ -14,41 +14,16 @@
 # limitations under the License.
 # ==============================================================================
 
-import numpy as np
-
-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 .._device_offload import supports_queue
+from ..common._backend import bind_default_backend
 from ..common.hyperparameters import get_hyperparameters
-from ..datatypes import from_table, to_table
-from ..utils._array_api import _get_sycl_namespace
-from ..utils.validation import _check_X_y, _num_features
+from ..datatypes import from_table, return_type_constructor, to_table
+from ..utils import _sycl_queue_manager as QM
+from ..utils.validation import _num_features
 from .linear_model import BaseLinearRegression
 
 
-class IncrementalLinearRegression(BaseLinearRegression):
-    """Incremental Linear Regression oneDAL implementation.
-
-    Parameters
-    ----------
-    fit_intercept : bool, default=True
-        Whether to calculate the intercept for this model. If set
-        to False, no intercept will be used in calculations
-        (i.e. data is expected to be centered).
-
-    copy_X : bool, default=True
-        If True, X will be copied; else, it may be overwritten.
-
-    algorithm : str, default="norm_eq"
-        Algorithm used for oneDAL computation.
-    """
-
-    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()
+class BaseIncrementalLinear(BaseLinearRegression):
 
     @bind_default_backend("linear_model.regression")
     def partial_train_result(self): ...
@@ -63,6 +38,7 @@ class IncrementalLinearRegression(BaseLinearRegression):
         self._need_to_finalize = False
         # Get the pointer to partial_result from backend
         self._queue = None
+        self._outtype = None
         self._partial_result = self.partial_train_result()
 
     def __getstate__(self):
@@ -100,30 +76,18 @@ class IncrementalLinearRegression(BaseLinearRegression):
         self : object
             Returns the instance itself.
         """
-        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)
-
-        if not hasattr(self, "_params"):
-            self._params = self._get_onedal_params(X.dtype)
 
         self._queue = queue
+        if not self._outtype:
+            self._outtype = return_type_constructor(X)
         self.n_features_in_ = _num_features(X, fallback_1d=True)
 
         X_table, y_table = to_table(X, y, queue=queue)
+        if not hasattr(self, "_params"):
+            self._params = self._get_onedal_params(X_table.dtype)
 
         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
@@ -133,6 +97,10 @@ class IncrementalLinearRegression(BaseLinearRegression):
                 self._params, self._partial_result, X_table, y_table
             )
 
+        # If a secondary fit occurs in any form, set model to None.
+        if self._onedal_model is not None:
+            self._onedal_model = None
+
         self._need_to_finalize = True
         return self
 
@@ -166,18 +134,45 @@ class IncrementalLinearRegression(BaseLinearRegression):
             self._onedal_model = result.model
 
             packed_coefficients = from_table(
-                result.model.packed_coefficients, sycl_queue=self._queue
+                result.model.packed_coefficients, like=self._outtype
             )
-            self.coef_, self.intercept_ = (
-                packed_coefficients[:, 1:].squeeze(),
-                packed_coefficients[:, 0].squeeze(),
+            self.coef_ = (
+                packed_coefficients[:, 1:]
+                if packed_coefficients.shape[1] > 2
+                else packed_coefficients[:, 1]
             )
+
+            self.intercept_ = packed_coefficients[:, 0]
+
+            self._outtype = None
             self._need_to_finalize = False
 
         return self
 
 
-class IncrementalRidge(BaseLinearRegression):
+class IncrementalLinearRegression(BaseIncrementalLinear):
+    """Incremental Linear Regression oneDAL implementation.
+
+    Parameters
+    ----------
+    fit_intercept : bool, default=True
+        Whether to calculate the intercept for this model. If set
+        to False, no intercept will be used in calculations
+        (i.e. data is expected to be centered).
+
+    copy_X : bool, default=True
+        If True, X will be copied; else, it may be overwritten.
+
+    algorithm : str, default="norm_eq"
+        Algorithm used for computation on oneDAL side.
+    """
+
+    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._reset()
+
+
+class IncrementalRidge(BaseIncrementalLinear):
     """Incremental Ridge Regression oneDAL implementation.
 
     Parameters
@@ -203,111 +198,4 @@ 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):
-        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
-        # and the dispatching policy can't be serialized, the computation is finalized
-        # here and the policy is not saved in serialized data.
-
-        self.finalize_fit()
-        data = self.__dict__.copy()
-        data.pop("_queue", None)
-
-        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):
-        """Prepare regression from batch data as `_partial_result`.
-
-        Computes partial data for ridge regression from data batch X.
-
-        Parameters
-        ----------
-        X : array-like of shape (n_samples, n_features)
-            Training data batch, where `n_samples` is the number of samples
-            in the batch, and `n_features` is the number of features.
-
-        y : array-like of shape (n_samples,) or (n_samples, n_targets)
-            Responses for training data.
-
-        queue : SyclQueue or None, default=None
-            SYCL Queue object for device code execution. Default
-            value None causes computation on host.
-
-        Returns
-        -------
-        self : object
-            Returns the instance itself.
-        """
-        self._queue = queue
-        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.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 = 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
-
-    def finalize_fit(self, queue=None):
-        """Finalize ridge regression from the current ``_partial_result``.
-
-        Parameters
-        ----------
-        queue : SyclQueue or None, default=None
-            SYCL Queue object for device code execution. Default
-            value None causes computation on host.
-
-        Returns
-        -------
-        self : object
-            Returns the instance itself.
-        """
-        if self._need_to_finalize:
-            with QM.manage_global_queue(self._queue):
-                result = self.finalize_train(self._params, self._partial_result)
-
-                self._onedal_model = result.model
-
-            packed_coefficients = from_table(result.model.packed_coefficients)
-            self.coef_, self.intercept_ = (
-                packed_coefficients[:, 1:].squeeze(),
-                packed_coefficients[:, 0].squeeze(),
-            )
-
-            self._need_to_finalize = False
-
-        return self

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

@@ -15,21 +15,18 @@
 # ==============================================================================
 
 from abc import ABCMeta, abstractmethod
-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 daal4py.sklearn._utils import daal_check_version
 
-from .._config import _get_config
+from .._device_offload import supports_queue
+from ..common._backend import bind_default_backend
 from ..common._estimator_checks import _check_is_fitted
 from ..common.hyperparameters import get_hyperparameters
 from ..datatypes import from_table, to_table
-from ..utils._array_api import _get_sycl_namespace
-from ..utils.validation import _check_array, _check_n_features, _check_X_y, _num_features
+from ..utils import _sycl_queue_manager as QM
+from ..utils.validation import _check_n_features, _num_features
 
 
 class BaseLinearRegression(metaclass=ABCMeta):
@@ -40,6 +37,7 @@ class BaseLinearRegression(metaclass=ABCMeta):
         self.alpha = alpha
         self.copy_X = copy_X
         self.algorithm = algorithm
+        self._onedal_model = None
 
     @bind_default_backend("linear_model.regression")
     def train(self, *args, **kwargs): ...
@@ -51,7 +49,7 @@ class BaseLinearRegression(metaclass=ABCMeta):
     @bind_default_backend("linear_model.regression")
     def model(self): ...
 
-    def _get_onedal_params(self, dtype=np.float32):
+    def _get_onedal_params(self, dtype):
         intercept = "intercept|" if self.fit_intercept else ""
         params = {
             "fptype": dtype,
@@ -67,39 +65,23 @@ class BaseLinearRegression(metaclass=ABCMeta):
     def _create_model(self):
         model = self.model()
 
-        coefficients = self.coef_
-        dtype = get_dtype(coefficients)
+        # force dtype and shape for all supported estimators to numpy
 
-        if coefficients.ndim == 2:
-            n_features_in = coefficients.shape[1]
-            n_targets_in = coefficients.shape[0]
+        if np.isscalar(self.coef_):
+            coef = np.asarray(self.coef_).reshape(1, 1)
         else:
-            n_features_in = coefficients.size
-            n_targets_in = 1
-
-        intercept = self.intercept_
-        if isinstance(intercept, Number):
-            assert n_targets_in == 1
+            # generalized atleast_2d for numpy and array_api inputs
+            # if an empty array, will fail for a multitude of reasons
+            coef = from_table(
+                to_table(self.coef_[None] if self.coef_.ndim == 1 else self.coef_)
+            )
+        if np.isscalar(self.intercept_):
+            intercept = np.asarray(self.intercept_).reshape(1, 1)
         else:
-            if not isinstance(intercept, np.ndarray):
-                intercept = np.asarray(intercept, dtype=dtype)
-            assert n_targets_in == intercept.size
-
-        coefficients, intercept = make2d(coefficients), make2d(intercept)
-        coefficients = coefficients.T if n_targets_in == 1 else coefficients
-
-        assert coefficients.shape == (
-            n_targets_in,
-            n_features_in,
-        ), f"{coefficients.shape}, {n_targets_in}, {n_features_in}"
-        assert intercept.shape == (n_targets_in, 1), f"{intercept.shape}, {n_targets_in}"
-
-        desired_shape = (n_targets_in, n_features_in + 1)
-        packed_coefficients = np.zeros(desired_shape, dtype=dtype)
+            intercept = from_table(to_table(self.intercept_))
 
-        packed_coefficients[:, 1:] = coefficients
-        if self.fit_intercept:
-            packed_coefficients[:, 0][:, np.newaxis] = intercept
+        # will do automatic dtype promotion based on the two datatypes
+        packed_coefficients = np.concatenate((intercept, coef), axis=1)
 
         model.packed_coefficients = to_table(
             packed_coefficients, queue=QM.get_global_queue()
@@ -109,6 +91,49 @@ class BaseLinearRegression(metaclass=ABCMeta):
 
         return model
 
+    @supports_queue
+    def fit(self, X, y, queue=None):
+        """Fit linear model.
+
+        Parameters
+        ----------
+        X : {array-like, sparse matrix} of shape (n_samples, n_features)
+            Training data.
+
+        y : array-like of shape (n_samples,) or (n_samples, n_targets)
+            Target values. Will be cast to X's dtype if necessary.
+
+        queue : SyclQueue or None, default=None
+            SYCL Queue object for device code execution. Default
+            value None causes computation on host.
+
+        Returns
+        -------
+        self : object
+            Fitted Estimator.
+        """
+
+        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_table.dtype)
+
+        hparams = get_hyperparameters("linear_regression", "train")
+        if hparams is not None and not hparams.is_default:
+            result = self.train(params, hparams.backend, X_table, y_table)
+        else:
+            result = self.train(params, X_table, y_table)
+
+        self._onedal_model = result.model
+
+        packed_coefficients = from_table(result.model.packed_coefficients, like=X)
+        self.coef_, self.intercept_ = (
+            packed_coefficients[:, 1:],
+            packed_coefficients[:, 0],
+        )
+
+        return self
+
     @supports_queue
     def predict(self, X, queue=None):
         """Predict using the linear model.
@@ -130,33 +155,17 @@ class BaseLinearRegression(metaclass=ABCMeta):
 
         _check_is_fitted(self)
 
-        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)
-
         _check_n_features(self, X, False)
 
-        if hasattr(self, "_onedal_model"):
-            model = self._onedal_model
-        else:
-            model = self._create_model()
+        if self._onedal_model is None:
+            self._onedal_model = self._create_model()
 
         X_table = to_table(X, queue=queue)
         params = self._get_onedal_params(X_table.dtype)
-        result = self.infer(params, model, X_table)
-        y = from_table(result.responses, sua_iface=sua_iface, sycl_queue=queue, xp=xp)
+        result = self.infer(params, self._onedal_model, X_table)
+        y = from_table(result.responses, like=X)
 
-        if y.shape[1] == 1 and self.coef_.ndim == 1:
-            return xp.reshape(y, (-1,))
-        else:
-            return y
+        return y
 
 
 class LinearRegression(BaseLinearRegression):
@@ -185,83 +194,12 @@ 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.
-
-        Parameters
-        ----------
-        X : {array-like, sparse matrix} of shape (n_samples, n_features)
-            Training data.
-
-        y : array-like of shape (n_samples,) or (n_samples, n_targets)
-            Target values. Will be cast to X's dtype if necessary.
-
-        queue : SyclQueue or None, default=None
-            SYCL Queue object for device code execution. Default
-            value None causes computation on host.
-
-        Returns
-        -------
-        self : object
-            Fitted Estimator.
-        """
-
-        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)
-
-            dtype = get_dtype(X)
-            if dtype not in [np.float32, np.float64]:
-                dtype = np.float64
-                X = X.astype(dtype, copy=self.copy_X)
-
-            y = np.asarray(y).astype(dtype=dtype)
-
-            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)
-
-        X_table, y_table = to_table(X, y, queue=queue)
-        params = self._get_onedal_params(X_table.dtype)
-
-        hparams = get_hyperparameters("linear_regression", "train")
-        if hparams is not None and not hparams.is_default:
-            result = self.train(params, hparams.backend, X_table, y_table)
-        else:
-            result = self.train(params, X_table, y_table)
-
-        self._onedal_model = result.model
-
-        packed_coefficients = from_table(
-            result.model.packed_coefficients, sycl_queue=queue
-        )
-        self.coef_, self.intercept_ = (
-            packed_coefficients[:, 1:],
-            packed_coefficients[:, 0],
-        )
-
-        if self.coef_.shape[0] == 1 and y.ndim == 1:
-            self.coef_ = self.coef_.ravel()
-            self.intercept_ = self.intercept_[0]
-
-        return self
-
 
 class Ridge(BaseLinearRegression):
     """Ridge Regression oneDAL implementation.
 
     Parameters
     ----------
-    alpha : float, default=1.0
-        Regularization strength; must be a positive float. Regularization
-        improves the conditioning of the problem and reduces the variance of
-        the estimates. Larger values specify stronger regularization.
-
     fit_intercept : bool, default=True
         Whether to calculate the intercept for this model. If set
         to False, no intercept will be used in calculations
@@ -272,72 +210,21 @@ class Ridge(BaseLinearRegression):
 
     algorithm : str, default="norm_eq"
         Algorithm used for oneDAL computation.
+
+    alpha : float, default=1.0
+        Regularization strength; must be a positive float. Regularization
+        improves the conditioning of the problem and reduces the variance of
+        the estimates. Larger values specify stronger regularization.
     """
 
     def __init__(
         self,
-        alpha=1.0,
         fit_intercept=True,
         copy_X=False,
         *,
         algorithm="norm_eq",
+        alpha=1.0,
     ):
         super().__init__(
-            fit_intercept=fit_intercept, alpha=alpha, copy_X=copy_X, algorithm=algorithm
+            fit_intercept=fit_intercept, copy_X=copy_X, algorithm=algorithm, alpha=alpha
         )
-
-    @supports_queue
-    def fit(self, X, y, queue=None):
-        """Fit Ridge regressor.
-
-        Parameters
-        ----------
-        X : {array-like, sparse matrix} of shape (n_samples, n_features)
-            Training data.
-
-        y : array-like of shape (n_samples,) or (n_samples, n_targets)
-            Target values. Will be cast to X's dtype if necessary.
-
-        queue : SyclQueue or None, default=None
-            SYCL Queue object for device code execution. Default
-            value None causes computation on host.
-
-        Returns
-        -------
-        self : object
-            Fitted Estimator.
-        """
-        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)
-
-        dtype = get_dtype(X)
-        if dtype not in [np.float32, np.float64]:
-            dtype = np.float64
-            X = X.astype(dtype, copy=self.copy_X)
-
-        y = np.asarray(y).astype(dtype=dtype)
-
-        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)
-
-        X_table, y_table = to_table(X, y, queue=queue)
-        params = self._get_onedal_params(X.dtype)
-
-        result = self.train(params, X_table, y_table)
-        self._onedal_model = result.model
-
-        packed_coefficients = from_table(result.model.packed_coefficients)
-        self.coef_, self.intercept_ = (
-            packed_coefficients[:, 1:],
-            packed_coefficients[:, 0],
-        )
-
-        return self

{scikit_learn_intelex-2025.7.0.data → scikit_learn_intelex-2025.9.0.data}/data/Lib/site-packages/onedal/linear_model/logistic_regression.py

@@ -208,28 +208,38 @@ class BaseLogisticRegression(metaclass=ABCMeta):
 
     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,
-        )
+        _, xp, _ = _get_sycl_namespace(X)
+        y = from_table(result.responses, like=X)
         y = xp.take(xp.asarray(self.classes_), xp.reshape(y, (-1,)), axis=0)
         return 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)
+        result = self._infer(X)
+        _, xp, _ = _get_sycl_namespace(X)
+        y = from_table(result.probabilities, like=X)
+        y = xp.reshape(y, -1)
         return xp.stack([1 - y, y], axis=1)
 
     def _predict_log_proba(self, X):
         _, xp, _ = _get_sycl_namespace(X)
         y_proba = self._predict_proba(X)
+        # These are the same thresholds used by oneDAL during the model fitting procedure
+        if y_proba.dtype == np.float32:
+            min_prob = 1e-7
+            max_prob = 1.0 - 1e-7
+        else:
+            min_prob = 1e-15
+            max_prob = 1.0 - 1e-15
+        y_proba = xp.clip(y_proba, min_prob, max_prob)
         return xp.log(y_proba)
 
+    def _decision_function(self, X):
+        _, xp, _ = _get_sycl_namespace(X)
+        raw = xp.matmul(X, xp.reshape(self.coef_, -1))
+        if self.fit_intercept:
+            raw += self.intercept_
+        return raw
+
 
 class LogisticRegression(ClassifierMixin, BaseLogisticRegression):
 
@@ -277,3 +287,7 @@ class LogisticRegression(ClassifierMixin, BaseLogisticRegression):
     @supports_queue
     def predict_log_proba(self, X, queue=None):
         return self._predict_log_proba(X)
+
+    @supports_queue
+    def decision_function(self, X, queue=None):
+        return self._decision_function(X)