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

scikit_learn_intelex-2025.8.0.data/data/Lib/site-packages/onedal/linear_model/incremental_linear_model.py

@@ -0,0 +1,201 @@
+# ==============================================================================
+# Copyright 2024 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+from .._device_offload import supports_queue
+from ..common._backend import bind_default_backend
+from ..common.hyperparameters import get_hyperparameters
+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 BaseIncrementalLinear(BaseLinearRegression):
+
+    @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
+        # Get the pointer to partial_result from backend
+        self._queue = None
+        self._outtype = 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
+
+    @supports_queue
+    def partial_fit(self, X, y, queue=None):
+        """Prepare regression from batch data as `_partial_result`.
+
+        Computes partial data for linear 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
+            SYCL Queue object for device code execution. Default
+            value None causes computation on host.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+
+        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
+            )
+        else:
+            self._partial_result = self.partial_train(
+                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
+
+    def finalize_fit(self, queue=None):
+        """Finalize linear regression from the current `_partial_result`.
+
+        Results are stored as `coef_` and `intercept_`.
+
+        Parameters
+        ----------
+        queue : SyclQueue or 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:
+            hparams = get_hyperparameters("linear_regression", "train")
+            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, like=self._outtype
+            )
+            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 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
+    ----------
+    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
+        (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, alpha=1.0, fit_intercept=True, copy_X=False, algorithm="norm_eq"):
+        super().__init__(
+            fit_intercept=fit_intercept, alpha=alpha, copy_X=copy_X, algorithm=algorithm
+        )
+        self._reset()

scikit_learn_intelex-2025.8.0.data/data/Lib/site-packages/onedal/linear_model/linear_model.py

@@ -0,0 +1,230 @@
+# ==============================================================================
+# Copyright 2023 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ==============================================================================
+
+from abc import ABCMeta, abstractmethod
+
+import numpy as np
+
+from daal4py.sklearn._utils import daal_check_version
+
+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 import _sycl_queue_manager as QM
+from ..utils.validation import _check_n_features, _num_features
+
+
+class BaseLinearRegression(metaclass=ABCMeta):
+
+    @abstractmethod
+    def __init__(self, fit_intercept, copy_X, algorithm, alpha=0.0):
+        self.fit_intercept = fit_intercept
+        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): ...
+
+    @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):
+        intercept = "intercept|" if self.fit_intercept else ""
+        params = {
+            "fptype": dtype,
+            "method": self.algorithm,
+            "intercept": self.fit_intercept,
+            "result_option": (intercept + "coefficients"),
+        }
+        if daal_check_version((2024, "P", 600)):
+            params["alpha"] = self.alpha
+
+        return params
+
+    def _create_model(self):
+        model = self.model()
+
+        # force dtype and shape for all supported estimators to numpy
+
+        if np.isscalar(self.coef_):
+            coef = np.asarray(self.coef_).reshape(1, 1)
+        else:
+            # 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:
+            intercept = from_table(to_table(self.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()
+        )
+
+        self._onedal_model = model
+
+        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.
+
+        Parameters
+        ----------
+        X : array-like or sparse matrix, shape (n_samples, n_features)
+            Samples.
+
+        queue : SyclQueue or None, default=None
+            SYCL Queue object for device code execution. Default
+            value None causes computation on host.
+
+        Returns
+        -------
+        y : array, shape (n_samples, n_targets)
+            Returns predicted values.
+        """
+
+        _check_is_fitted(self)
+
+        _check_n_features(self, X, False)
+
+        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, self._onedal_model, X_table)
+        y = from_table(result.responses, like=X)
+
+        return y
+
+
+class LinearRegression(BaseLinearRegression):
+    """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)
+
+
+class Ridge(BaseLinearRegression):
+    """Ridge 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.
+
+    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,
+        fit_intercept=True,
+        copy_X=False,
+        *,
+        algorithm="norm_eq",
+        alpha=1.0,
+    ):
+        super().__init__(
+            fit_intercept=fit_intercept, copy_X=copy_X, algorithm=algorithm, alpha=alpha
+        )

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/linear_model/logistic_regression.py

@@ -29,7 +29,6 @@ from ..common._estimator_checks import _check_is_fitted
 from ..common._mixin import ClassifierMixin
 from ..datatypes import from_table, to_table
 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,
@@ -96,7 +95,15 @@ class BaseLogisticRegression(metaclass=ABCMeta):
             self.classes_, y = np.unique(y, return_inverse=True)
             y = y.astype(dtype=np.int32)
         else:
-            self.classes_ = get_unique_values_with_dpep(y)
+            _, xp, _ = _get_sycl_namespace(X)
+            # 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)
+
             n_classes = len(self.classes_)
             if n_classes != 2:
                 raise ValueError("Only binary classification is supported")
@@ -201,21 +208,16 @@ 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)
+        _, 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):
@@ -225,9 +227,6 @@ class BaseLogisticRegression(metaclass=ABCMeta):
 
 
 class LogisticRegression(ClassifierMixin, BaseLogisticRegression):
-    """
-    Logistic Regression oneDAL implementation.
-    """
 
     def __init__(
         self,

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/onedal/linear_model/tests/test_linear_regression.py

@@ -161,21 +161,21 @@ def test_overdetermined_system(queue, dtype, fit_intercept):
     if queue and queue.sycl_device.is_gpu and not daal_check_version((2025, "P", 200)):
         pytest.skip("Functionality introduced in later versions")
     gen = np.random.default_rng(seed=123)
-    X = gen.standard_normal(size=(10, 20))
-    y = gen.standard_normal(size=X.shape[0])
+    X = gen.standard_normal(size=(10, 20)).astype(dtype)
+    y = gen.standard_normal(size=X.shape[0]).astype(dtype)
 
     model = LinearRegression(fit_intercept=fit_intercept).fit(X, y)
     if not fit_intercept:
         A = X.T @ X
         b = X.T @ y
-        x = model.coef_
+        x = np.squeeze(model.coef_)
     else:
         Xi = np.c_[X, np.ones((X.shape[0], 1))]
         A = Xi.T @ Xi
         b = Xi.T @ y
-        x = np.r_[model.coef_, model.intercept_]
+        x = np.r_[np.squeeze(model.coef_), model.intercept_]
     residual = A @ x - b
-    assert np.all(np.abs(residual) < 1e-6)
+    assert np.all(np.abs(residual) < (1e-6 if dtype is np.float64 else 1e-5))
 
 
 @pytest.mark.parametrize("queue", get_queues())
@@ -189,22 +189,22 @@ def test_singular_matrix(queue, dtype, fit_intercept):
     if queue and queue.sycl_device.is_gpu and not daal_check_version((2025, "P", 200)):
         pytest.skip("Functionality introduced in later versions")
     gen = np.random.default_rng(seed=123)
-    X = gen.standard_normal(size=(20, 4))
+    X = gen.standard_normal(size=(20, 4)).astype(dtype)
     X[:, 2] = X[:, 3]
-    y = gen.standard_normal(size=X.shape[0])
+    y = gen.standard_normal(size=X.shape[0]).astype(dtype)
 
     model = LinearRegression(fit_intercept=fit_intercept).fit(X, y)
     if not fit_intercept:
         A = X.T @ X
         b = X.T @ y
-        x = model.coef_
+        x = np.squeeze(model.coef_)
     else:
         Xi = np.c_[X, np.ones((X.shape[0], 1))]
         A = Xi.T @ Xi
         b = Xi.T @ y
-        x = np.r_[model.coef_, model.intercept_]
+        x = np.r_[np.squeeze(model.coef_), model.intercept_]
     residual = A @ x - b
-    assert np.all(np.abs(residual) < 1e-6)
+    assert np.all(np.abs(residual) < (1e-6 if dtype is np.float64 else 1e-5))
 
 
 @pytest.mark.parametrize("queue", get_queues())
@@ -250,10 +250,3 @@ def test_multioutput_regression(queue, dtype, fit_intercept, problem_type):
     expected_pred = X @ model.coef_.T + model.intercept_.reshape((1, -1))
     tol = 1e-5 if pred.dtype == np.float32 else 1e-7
     assert_allclose(pred, expected_pred, rtol=tol)
-
-    # check that it also works when 'y' is a list of lists
-    Y_lists = Y.tolist()
-    model_lists = LinearRegression(fit_intercept=fit_intercept).fit(X, Y_lists)
-    assert_allclose(model.coef_, model_lists.coef_)
-    if fit_intercept:
-        assert_allclose(model.intercept_, model_lists.intercept_)