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/decomposition/incremental_pca.py

@@ -0,0 +1,218 @@
+# ==============================================================================
+# 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 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 ..datatypes import from_table, return_type_constructor, to_table
+from .pca import PCA
+
+
+class IncrementalPCA(PCA):
+    """Incremental oneDAL PCA estimator.
+
+    Parameters
+    ----------
+    n_components : int, default=None
+        Number of components to keep. If ``n_components`` is ``None``,
+        then ``n_components`` is set to ``min(n_samples, n_features)``.
+
+    is_deterministic : bool, default=True
+        When True the ``components_`` vectors are chosen in deterministic
+        way, otherwise some of them can be oppositely directed.
+
+    method : str, default='cov'
+        Method used in oneDAL computation.
+
+    whiten : bool, default=False
+        When True the ``components_`` vectors are divided
+        by ``n_samples`` times ``components_`` to ensure uncorrelated outputs
+        with unit component-wise variances.
+
+        Whitening will remove some information from the transformed signal
+        (the relative variance scales of the components) but can sometimes
+        improve the predictive accuracy of the downstream estimators by
+        making data respect some hard-wired assumptions.
+
+    Attributes
+    ----------
+        components_ : ndarray of shape (n_components, n_features)
+        Principal axes in feature space, representing the directions of
+        maximum variance in the data. Equivalently, the right singular
+        vectors of the centered input data, parallel to its eigenvectors.
+        The components are sorted by decreasing ``explained_variance_``.
+
+        explained_variance_ : ndarray of shape (n_components,)
+            Variance explained by each of the selected components.
+
+        explained_variance_ratio_ : ndarray of shape (n_components,)
+            Percentage of variance explained by each of the selected components.
+            If all components are stored, the sum of explained variances is equal
+            to 1.0.
+
+        singular_values_ : ndarray of shape (n_components,)
+            The singular values corresponding to each of the selected components.
+            The singular values are equal to the 2-norms of the ``n_components``
+            variables in the lower-dimensional space.
+
+        mean_ : ndarray of shape (n_features,)
+            Per-feature empirical mean, aggregate over calls to ``partial_fit``.
+
+        var_ : ndarray of shape (n_features,)
+            Per-feature empirical variance, aggregate over calls to
+            ``partial_fit``.
+
+        noise_variance_ : float
+            Equal to the average of (min(n_features, n_samples) - n_components)
+            smallest eigenvalues of the covariance matrix of X.
+    """
+
+    def __init__(
+        self,
+        n_components=None,
+        is_deterministic=True,
+        method="cov",
+        whiten=False,
+    ):
+        self.n_components = n_components
+        self.method = method
+        self.is_deterministic = is_deterministic
+        self.whiten = whiten
+        self._queue = None
+        self._reset()
+
+    @bind_default_backend("decomposition.dim_reduction")
+    def finalize_train(self, params, partial_result): ...
+
+    @bind_default_backend("decomposition.dim_reduction")
+    def partial_train(self, params, partial_result, X_table): ...
+
+    @bind_default_backend("decomposition.dim_reduction")
+    def partial_train_result(self): ...
+
+    def _reset(self):
+        self._onedal_model = None
+        self._need_to_finalize = False
+        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, queue=None):
+        """Generate partial PCA from batch data in `_partial_result`.
+
+        Computes partial data for PCA on from data batch X.
+
+        Parameters
+        ----------
+        X : array-like of shape (n_samples, n_features)
+            Training data, where `n_samples` is the number of samples and
+            `n_features` is the number of features.
+
+        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.
+        """
+
+        n_samples, n_features = X.shape
+        first_pass = not self._need_to_finalize
+        if first_pass:
+            self.components_ = None
+            self.n_samples_seen_ = n_samples
+            self.n_features_in_ = n_features
+            self.n_components_ = self.n_components if self.n_components else X.shape[0]
+        else:
+            self.n_samples_seen_ += n_samples
+
+        if not self._outtype:
+            self._outtype = return_type_constructor(X)
+        self._queue = queue
+
+        X_table = to_table(X, queue=queue)
+
+        if not hasattr(self, "_dtype"):
+            self._dtype = X_table.dtype
+            self._params = self._get_onedal_params(X_table)
+
+        self._partial_result = self.partial_train(
+            self._params, self._partial_result, X_table
+        )
+        if self._onedal_model is not None:
+            self._onedal_model = None
+        self._need_to_finalize = True
+        return self
+
+    def finalize_fit(self):
+        """Finalize statistics from the current `_partial_result`.
+
+        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)
+
+            (
+                mean_,
+                var_,
+                self.components_,
+                sing_vals_,
+                eigenvalues_,
+                var_ratio,
+            ) = from_table(
+                result.means,
+                result.variances,
+                result.eigenvectors,
+                result.singular_values,
+                result.eigenvalues,
+                result.explained_variances_ratio,
+                like=self._outtype,
+            )
+
+            # tables are 2d, but outputs are inherently 1d, reduce dimensions
+            self.mean_ = mean_[0, ...]
+            self.var_ = var_[0, ...]
+            self.singular_values_ = sing_vals_[0, ...]
+            self.explained_variance_ = eigenvalues_[0, ...]
+            self.explained_variance_ratio_ = var_ratio[0, ...]
+
+            # set partial result attributes to defaults
+            self._need_to_finalize = False
+            self._outtype = None
+            self._queue = None
+
+        return self

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/decomposition/pca.py

@@ -0,0 +1,124 @@
+# ==============================================================================
+# 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 numbers
+from abc import ABCMeta
+
+import numpy as np
+
+from onedal._device_offload import supports_queue
+from onedal.common._backend import bind_default_backend
+
+from .._config import _get_config
+from ..common.hyperparameters import get_hyperparameters
+from ..datatypes import from_table, to_table
+from ..utils._array_api import _get_sycl_namespace
+
+
+class PCA(metaclass=ABCMeta):
+
+    def __init__(
+        self,
+        n_components=None,
+        is_deterministic=True,
+        method="cov",
+        whiten=False,
+    ):
+        self.n_components = n_components
+        self.method = method
+        self.is_deterministic = is_deterministic
+        self.whiten = whiten
+        self._onedal_model = None
+
+    # provides direct access to the backend model constructor
+    @bind_default_backend("decomposition.dim_reduction")
+    def model(self): ...
+
+    @bind_default_backend("decomposition.dim_reduction")
+    def train(self, params, X): ...
+
+    @bind_default_backend("decomposition.dim_reduction")
+    def infer(self, params, X, model): ...
+
+    def _get_onedal_params(self, data):
+        return {
+            "fptype": data.dtype,
+            "method": self.method,
+            "n_components": self.n_components_,
+            "is_deterministic": self.is_deterministic,
+            "whiten": self.whiten,
+        }
+
+    def _create_model(self, queue=None):
+        m = self.model()
+        m.eigenvectors = to_table(self.components_, queue=queue)
+        m.means = to_table(self.mean_, queue=queue)
+        if self.whiten:
+            m.eigenvalues = to_table(self.explained_variance_, queue=queue)
+        return m
+
+    @supports_queue
+    def predict(self, X, queue=None):
+        X_table = to_table(X, queue=queue)
+        params = self._get_onedal_params(X_table)
+        if self._onedal_model is None:
+            self._onedal_model = self._create_model(queue)
+        result = self.infer(params, self._onedal_model, X_table)
+        return from_table(result.transformed_data, like=X)
+
+    @supports_queue
+    def fit(self, X, y=None, queue=None):
+
+        X_table = to_table(X, queue=queue)
+        # define n_components_ to allow for external modification of
+        # transforms
+        self.n_components_ = self.n_components
+
+        params = self._get_onedal_params(X_table)
+        hparams = get_hyperparameters("pca", "train")
+        if hparams is not None and not hparams.is_default:
+            result = self.train(params, hparams.backend, X_table)
+        else:
+            result = self.train(params, X_table)
+
+        (
+            mean_,
+            var_,
+            self.components_,
+            sing_vals_,
+            eigenvalues_,
+            var_ratio,
+        ) = from_table(
+            result.means,
+            result.variances,
+            result.eigenvectors,
+            result.singular_values,
+            result.eigenvalues,
+            result.explained_variances_ratio,
+            like=X,
+        )
+
+        # tables are 2d, but outputs are inherently 1d, reduce dimensions
+        self.mean_ = mean_[0, ...]
+        self.var_ = var_[0, ...]
+        self.singular_values_ = sing_vals_[0, ...]
+        self.explained_variance_ = eigenvalues_[0, ...]
+        self.explained_variance_ratio_ = var_ratio[0, ...]
+
+        if self._onedal_model is not None:
+            self._onedal_model = None
+
+        return self

scikit_learn_intelex-2025.10.0.data/data/Lib/site-packages/onedal/decomposition/tests/test_incremental_pca.py

@@ -0,0 +1,291 @@
+# ==============================================================================
+# 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
+import pytest
+from numpy.testing import assert_allclose
+
+from daal4py.sklearn._utils import daal_check_version
+from onedal.datatypes import from_table
+from onedal.decomposition import IncrementalPCA
+from onedal.tests.utils._device_selection import get_queues
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("is_deterministic", [True, False])
+@pytest.mark.parametrize("whiten", [True, False])
+@pytest.mark.parametrize("num_blocks", [1, 2, 3])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_on_gold_data(queue, is_deterministic, whiten, num_blocks, dtype):
+    X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])
+    X = X.astype(dtype=dtype)
+    X_split = np.array_split(X, num_blocks)
+    incpca = IncrementalPCA(
+        is_deterministic=is_deterministic, whiten=whiten, n_components=2
+    )
+
+    for i in range(num_blocks):
+        incpca.partial_fit(X_split[i], queue=queue)
+
+    result = incpca.finalize_fit()
+
+    transformed_data = incpca.predict(X, queue=queue)
+
+    expected_n_components_ = 2
+    expected_components_ = np.array([[0.83849224, 0.54491354], [-0.54491354, 0.83849224]])
+    expected_singular_values_ = np.array([6.30061232, 0.54980396])
+    expected_mean_ = np.array([0, 0])
+    expected_var_ = np.array([5.6, 2.4])
+    expected_explained_variance_ = np.array([7.93954312, 0.06045688])
+    expected_explained_variance_ratio_ = np.array([0.99244289, 0.00755711])
+    expected_transformed_data = (
+        np.array(
+            [
+                [-0.49096647, -1.19399271],
+                [-0.78854479, 1.02218579],
+                [-1.27951125, -0.17180692],
+                [0.49096647, 1.19399271],
+                [0.78854479, -1.02218579],
+                [1.27951125, 0.17180692],
+            ]
+        )
+        if whiten
+        else np.array(
+            [
+                [-1.38340578, -0.2935787],
+                [-2.22189802, 0.25133484],
+                [-3.6053038, -0.04224385],
+                [1.38340578, 0.2935787],
+                [2.22189802, -0.25133484],
+                [3.6053038, 0.04224385],
+            ]
+        )
+    )
+
+    tol = 1e-7
+    if transformed_data.dtype == np.float32:
+        tol = 7e-6 if whiten else 1e-6
+
+    assert result.n_components_ == expected_n_components_
+
+    assert_allclose(result.singular_values_, expected_singular_values_, atol=tol)
+    assert_allclose(result.mean_, expected_mean_, atol=tol)
+    assert_allclose(result.var_, expected_var_, atol=tol)
+    assert_allclose(result.explained_variance_, expected_explained_variance_, atol=tol)
+    assert_allclose(
+        result.explained_variance_ratio_, expected_explained_variance_ratio_, atol=tol
+    )
+    if is_deterministic and daal_check_version((2024, "P", 500)):
+        assert_allclose(result.components_, expected_components_, atol=tol)
+        assert_allclose(transformed_data, expected_transformed_data, atol=tol)
+    else:
+        for i in range(result.n_components_):
+            abs_dot_product = np.abs(
+                np.dot(result.components_[i], expected_components_[i])
+            )
+            assert np.abs(abs_dot_product - 1.0) < tol
+
+            if np.dot(result.components_[i], expected_components_[i]) < 0:
+                assert_allclose(
+                    -transformed_data[i], expected_transformed_data[i], atol=tol
+                )
+            else:
+                assert_allclose(
+                    transformed_data[i], expected_transformed_data[i], atol=tol
+                )
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("n_components", [None, 1, 5])
+@pytest.mark.parametrize("whiten", [True, False])
+@pytest.mark.parametrize("num_blocks", [1, 10])
+@pytest.mark.parametrize("row_count", [100, 1000])
+@pytest.mark.parametrize("column_count", [10, 100])
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_on_random_data(
+    queue, n_components, whiten, num_blocks, row_count, column_count, dtype
+):
+    seed = 78
+    gen = np.random.default_rng(seed)
+    X = gen.uniform(low=-0.3, high=0.7, size=(row_count, column_count))
+    X = X.astype(dtype=dtype)
+    X_split = np.array_split(X, num_blocks)
+    # it is necessary to limit n_components by the nature of using
+    # np.linalg.eig to verify PCA computation
+    if n_components is None and X_split[0].shape[0] > column_count:
+        n_components = column_count
+    incpca = IncrementalPCA(n_components=n_components, whiten=whiten)
+
+    for i in range(num_blocks):
+        incpca.partial_fit(X_split[i], queue=queue)
+
+    incpca.finalize_fit()
+
+    transformed_data = incpca.predict(X, queue=queue)
+    tol = 3e-3 if transformed_data.dtype == np.float32 else 2e-6
+
+    n_components = incpca.n_components_
+    expected_n_samples_seen = X.shape[0]
+    expected_n_features_in = X.shape[1]
+    n_samples_seen = incpca.n_samples_seen_
+    n_features_in = incpca.n_features_in_
+    assert n_samples_seen == expected_n_samples_seen
+    assert n_features_in == expected_n_features_in
+
+    components = incpca.components_
+    singular_values = incpca.singular_values_
+    centered_data = X - np.mean(X, axis=0)
+    cov_eigenvalues, cov_eigenvectors = np.linalg.eig(
+        centered_data.T @ centered_data / (n_samples_seen - 1)
+    )
+    cov_eigenvalues = np.nan_to_num(cov_eigenvalues)
+    cov_eigenvalues[cov_eigenvalues < 0] = 0
+    eigenvalues_order = np.argsort(cov_eigenvalues)[::-1]
+    sorted_eigenvalues = cov_eigenvalues[eigenvalues_order]
+    sorted_eigenvectors = cov_eigenvectors[:, eigenvalues_order]
+    expected_singular_values = np.sqrt(sorted_eigenvalues * (n_samples_seen - 1))[
+        :n_components
+    ]
+    expected_components = sorted_eigenvectors.T[:n_components]
+
+    assert_allclose(singular_values, expected_singular_values, atol=tol)
+    for i in range(n_components):
+        component_length = np.dot(components[i], components[i])
+        assert np.abs(component_length - 1.0) < tol
+        abs_dot_product = np.abs(np.dot(components[i], expected_components[i]))
+        assert np.abs(abs_dot_product - 1.0) < tol
+
+    expected_mean = np.mean(X, axis=0)
+    assert_allclose(incpca.mean_, expected_mean, atol=tol)
+
+    expected_var_ = np.var(X, ddof=1, axis=0)
+    assert_allclose(incpca.var_, expected_var_, atol=tol)
+
+    expected_explained_variance = sorted_eigenvalues[:n_components]
+    assert_allclose(incpca.explained_variance_, expected_explained_variance, atol=tol)
+
+    expected_explained_variance_ratio = expected_explained_variance / np.sum(
+        sorted_eigenvalues
+    )
+    assert_allclose(
+        incpca.explained_variance_ratio_, expected_explained_variance_ratio, atol=tol
+    )
+
+    expected_noise_variance = (
+        np.mean(sorted_eigenvalues[n_components:])
+        if len(sorted_eigenvalues) > n_components
+        else 0.0
+    )
+    # TODO Fix noise variance computation (It is necessary to update C++ side)
+    # assert np.abs(incpca.noise_variance_ - expected_noise_variance) < tol
+
+    expected_transformed_data = centered_data @ components.T
+    if whiten:
+        scale = np.sqrt(incpca.explained_variance_)
+        min_scale = np.finfo(scale.dtype).eps
+        scale[scale < min_scale] = np.inf
+        expected_transformed_data /= scale
+
+    if daal_check_version((2024, "P", 500)) or not (
+        whiten and queue is not None and queue.sycl_device.device_type.name == "gpu"
+    ):
+        assert_allclose(transformed_data, expected_transformed_data, atol=tol)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_incremental_estimator_pickle(queue, dtype):
+    import pickle
+
+    from onedal.decomposition import IncrementalPCA
+
+    incpca = IncrementalPCA()
+
+    # Check that estimator can be serialized without any data.
+    dump = pickle.dumps(incpca)
+    incpca_loaded = pickle.loads(dump)
+    seed = 77
+    gen = np.random.default_rng(seed)
+    X = gen.uniform(low=-0.3, high=0.7, size=(10, 10))
+    X = X.astype(dtype)
+    X_split = np.array_split(X, 2)
+    incpca.partial_fit(X_split[0], queue=queue)
+    incpca_loaded.partial_fit(X_split[0], queue=queue)
+    assert incpca._need_to_finalize == True
+    assert incpca_loaded._need_to_finalize == True
+
+    # Check that estimator can be serialized after partial_fit call.
+    dump = pickle.dumps(incpca)
+    incpca_loaded = pickle.loads(dump)
+    assert incpca._need_to_finalize == False
+    # Finalize is called during serialization to make sure partial results are finalized correctly.
+    assert incpca_loaded._need_to_finalize == False
+
+    partial_n_rows = from_table(incpca._partial_result.partial_n_rows)
+    partial_n_rows_loaded = from_table(incpca_loaded._partial_result.partial_n_rows)
+    assert_allclose(partial_n_rows, partial_n_rows_loaded)
+
+    partial_crossproduct = from_table(incpca._partial_result.partial_crossproduct)
+    partial_crossproduct_loaded = from_table(
+        incpca_loaded._partial_result.partial_crossproduct
+    )
+    assert_allclose(partial_crossproduct, partial_crossproduct_loaded)
+
+    partial_sum = from_table(incpca._partial_result.partial_sum)
+    partial_sum_loaded = from_table(incpca_loaded._partial_result.partial_sum)
+    assert_allclose(partial_sum, partial_sum_loaded)
+
+    auxiliary_table_count = incpca._partial_result.auxiliary_table_count
+    auxiliary_table_count_loaded = incpca_loaded._partial_result.auxiliary_table_count
+    assert_allclose(auxiliary_table_count, auxiliary_table_count_loaded)
+
+    for i in range(auxiliary_table_count):
+        aux_table = incpca._partial_result.get_auxiliary_table(i)
+        aux_table_loaded = incpca_loaded._partial_result.get_auxiliary_table(i)
+        assert_allclose(from_table(aux_table), from_table(aux_table_loaded))
+
+    incpca.partial_fit(X_split[1], queue=queue)
+    incpca_loaded.partial_fit(X_split[1], queue=queue)
+    assert incpca._need_to_finalize == True
+    assert incpca_loaded._need_to_finalize == True
+
+    dump = pickle.dumps(incpca_loaded)
+    incpca_loaded = pickle.loads(dump)
+
+    assert incpca._need_to_finalize == True
+    assert incpca_loaded._need_to_finalize == False
+
+    incpca.finalize_fit()
+    incpca_loaded.finalize_fit()
+
+    # Check that finalized estimator can be serialized.
+    dump = pickle.dumps(incpca_loaded)
+    incpca_loaded = pickle.loads(dump)
+
+    assert_allclose(incpca.singular_values_, incpca_loaded.singular_values_, atol=1e-6)
+    assert_allclose(incpca.n_samples_seen_, incpca_loaded.n_samples_seen_, atol=1e-6)
+    assert_allclose(incpca.n_features_in_, incpca_loaded.n_features_in_, atol=1e-6)
+    assert_allclose(incpca.mean_, incpca_loaded.mean_, atol=1e-6)
+    assert_allclose(incpca.var_, incpca_loaded.var_, atol=1e-6)
+    assert_allclose(
+        incpca.explained_variance_, incpca_loaded.explained_variance_, atol=1e-6
+    )
+    assert_allclose(incpca.components_, incpca_loaded.components_, atol=1e-6)
+    assert_allclose(
+        incpca.explained_variance_ratio_,
+        incpca_loaded.explained_variance_ratio_,
+        atol=1e-6,
+    )

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

@@ -0,0 +1,19 @@
+# ==============================================================================
+# Copyright Contributors to the oneDAL Project
+#
+# 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 .dummy import DummyEstimator
+
+__all__ = ["DummyEstimator"]