scikit-learn-intelex 2025.0.0__py312-none-manylinux_2_28_x86_64.whl

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)

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",
+]

onedal/linear_model/incremental_linear_model.py

@@ -0,0 +1,258 @@
+# ==============================================================================
+# 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.
+# ==============================================================================
+
+import numpy as np
+
+from daal4py.sklearn._utils import get_dtype
+
+from ..common.hyperparameters import get_hyperparameters
+from ..datatypes import _convert_to_supported, from_table, to_table
+from ..utils import _check_X_y, _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 : string, 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()
+
+    def _reset(self):
+        self._partial_result = self._get_backend(
+            "linear_model", "regression", "partial_train_result"
+        )
+
+    def partial_fit(self, X, y, queue=None):
+        """
+        Computes partial data for linear regression
+        from data batch X and saves it to `_partial_result`.
+        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) in
+            case of multiple targets
+            Responses for training data.
+
+        queue : dpctl.SyclQueue
+            If not None, use this queue for computations.
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        module = self._get_backend("linear_model", "regression")
+
+        self._queue = queue
+        policy = self._get_policy(queue, X)
+
+        X, y = _convert_to_supported(policy, X, y)
+
+        if not hasattr(self, "_dtype"):
+            self._dtype = get_dtype(X)
+            self._params = self._get_onedal_params(self._dtype)
+
+        y = np.asarray(y, dtype=self._dtype)
+
+        X, y = _check_X_y(
+            X, y, dtype=[np.float64, np.float32], accept_2d_y=True, force_all_finite=False
+        )
+
+        self.n_features_in_ = _num_features(X, fallback_1d=True)
+        X_table, y_table = to_table(X, y)
+        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,
+            )
+        else:
+            self._partial_result = module.partial_train(
+                policy, self._params, self._partial_result, X_table, y_table
+            )
+
+    def finalize_fit(self, queue=None):
+        """
+        Finalizes linear regression computation and obtains coefficients
+        from the current `_partial_result`.
+
+        Parameters
+        ----------
+        queue : dpctl.SyclQueue
+            If not None, use this queue for computations.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+
+        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)
+
+        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(),
+        )
+
+        return self
+
+
+class IncrementalRidge(BaseLinearRegression):
+    """
+    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 : string, default="norm_eq"
+        Algorithm used for computation on oneDAL side
+    """
+
+    def __init__(self, alpha=1.0, fit_intercept=True, copy_X=False, algorithm="norm_eq"):
+        module = self._get_backend("linear_model", "regression")
+        super().__init__(
+            fit_intercept=fit_intercept, alpha=alpha, copy_X=copy_X, algorithm=algorithm
+        )
+        self._partial_result = module.partial_train_result()
+
+    def _reset(self):
+        module = self._get_backend("linear_model", "regression")
+        self._partial_result = module.partial_train_result()
+
+    def partial_fit(self, X, y, queue=None):
+        """
+        Computes partial data for ridge regression
+        from data batch X and saves it to `_partial_result`.
+        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) in
+            case of multiple targets
+            Responses for training data.
+
+        queue : dpctl.SyclQueue
+            If not None, use this queue for computations.
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        module = self._get_backend("linear_model", "regression")
+
+        self._queue = queue
+        policy = self._get_policy(queue, X)
+
+        X, y = _convert_to_supported(policy, X, y)
+
+        if not hasattr(self, "_dtype"):
+            self._dtype = get_dtype(X)
+            self._params = self._get_onedal_params(self._dtype)
+
+        y = np.asarray(y, dtype=self._dtype)
+
+        X, y = _check_X_y(
+            X, y, dtype=[np.float64, np.float32], accept_2d_y=True, force_all_finite=False
+        )
+
+        self.n_features_in_ = _num_features(X, fallback_1d=True)
+        X_table, y_table = to_table(X, y)
+        self._partial_result = module.partial_train(
+            policy, self._params, self._partial_result, X_table, y_table
+        )
+
+    def finalize_fit(self, queue=None):
+        """
+        Finalizes ridge regression computation and obtains coefficients
+        from the current `_partial_result`.
+
+        Parameters
+        ----------
+        queue : dpctl.SyclQueue
+            If available, uses provided queue for computations.
+
+        Returns
+        -------
+        self : object
+            Returns the instance itself.
+        """
+        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)
+
+        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(),
+        )
+
+        return self