scikit-learn-intelex 2024.4.0__py312-none-win_amd64.whl → 2025.10.0__py312-none-win_amd64.whl

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/ensemble/tests/test_random_forest.py

@@ -0,0 +1,97 @@
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+import pytest
+from numpy.testing import assert_allclose
+from sklearn.datasets import make_classification, make_regression
+
+from daal4py.sklearn._utils import daal_check_version
+from onedal.ensemble import RandomForestClassifier, RandomForestRegressor
+from onedal.tests.utils._device_selection import get_queues
+
+
+@pytest.mark.parametrize("queue", get_queues())
+def test_rf_classifier(queue):
+    X, y = make_classification(
+        n_samples=100,
+        n_features=4,
+        n_informative=2,
+        n_redundant=0,
+        random_state=0,
+        shuffle=False,
+    )
+    rf = RandomForestClassifier(max_depth=2, random_state=0).fit(X, y, queue=queue)
+    assert_allclose([1], rf.predict([[0, 0, 0, 0]], queue=queue))
+
+
+@pytest.mark.parametrize("queue", get_queues())
+def test_rf_regression(queue):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("RF regressor predict for the GPU sycl_queue is buggy.")
+    X, y = make_regression(
+        n_samples=100, n_features=4, n_informative=2, random_state=0, shuffle=False
+    )
+    rf = RandomForestRegressor(max_depth=2, random_state=0).fit(X, y, queue=queue)
+
+    # GPU and CPU implementations of Random Forest use RNGs differently. They build
+    # different ensembles of trees, thereby requiring separate check values.
+    if queue and queue.sycl_device.is_gpu:
+        if daal_check_version((2024, "P", 0)):
+            assert_allclose([1.82], rf.predict([[0, 0, 0, 0]], queue=queue), atol=1e-2)
+        else:
+            assert_allclose([-6.83], rf.predict([[0, 0, 0, 0]], queue=queue), atol=1e-2)
+    else:
+        if daal_check_version((2024, "P", 0)):
+            assert_allclose([-6.97], rf.predict([[0, 0, 0, 0]], queue=queue), atol=1e-2)
+        else:
+            assert_allclose([-6.83], rf.predict([[0, 0, 0, 0]], queue=queue), atol=1e-2)
+
+
+@pytest.mark.skipif(
+    not daal_check_version((2023, "P", 101)), reason="requires OneDAL 2023.1.1"
+)
+@pytest.mark.parametrize("queue", get_queues("gpu"))
+def test_rf_classifier_random_splitter(queue):
+    X, y = make_classification(
+        n_samples=100,
+        n_features=4,
+        n_informative=2,
+        n_redundant=0,
+        random_state=0,
+        shuffle=False,
+    )
+    rf = RandomForestClassifier(max_depth=2, random_state=0, splitter_mode="random").fit(
+        X, y, queue=queue
+    )
+    assert_allclose([1], rf.predict([[0, 0, 0, 0]], queue=queue))
+
+
+@pytest.mark.parametrize("queue", get_queues("gpu"))
+def test_rf_regression_random_splitter(queue):
+    # splitter_mode selection only for GPU enabled.
+    # For CPU only `best` mode is supported.
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("RF regressor predict for the GPU sycl_queue is buggy.")
+    X, y = make_regression(
+        n_samples=100, n_features=4, n_informative=2, random_state=0, shuffle=False
+    )
+    rf = RandomForestRegressor(max_depth=2, random_state=0, splitter_mode="random").fit(
+        X, y, queue=queue
+    )
+    if daal_check_version((2024, "P", 0)):
+        assert_allclose([-6.88], rf.predict([[0, 0, 0, 0]], queue=queue), atol=1e-2)
+    else:
+        assert_allclose([-6.83], rf.predict([[0, 0, 0, 0]], queue=queue), atol=1e-2)

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/linear_model/__init__.py

@@ -0,0 +1,27 @@
+# ===============================================================================
+# 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 .incremental_linear_model import IncrementalLinearRegression, IncrementalRidge
+from .linear_model import LinearRegression, Ridge
+from .logistic_regression import LogisticRegression
+
+__all__ = [
+    "IncrementalLinearRegression",
+    "IncrementalRidge",
+    "LinearRegression",
+    "LogisticRegression",
+    "Ridge",
+]

scikit_learn_intelex-2025.10.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.10.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
+        )