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/data/Lib/site-packages/onedal/datatypes/_data_conversion.py

@@ -1,110 +0,0 @@
-# ==============================================================================
-# Copyright 2021 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 types import ModuleType
-
-import numpy as np
-
-from onedal import _default_backend as backend
-
-
-def _apply_and_pass(func, *args, **kwargs):
-    if len(args) == 1:
-        return func(args[0], **kwargs)
-    return tuple(map(lambda arg: func(arg, **kwargs), args))
-
-
-def _convert_one_to_table(arg, queue=None):
-    # All inputs for table conversion must be array-like or sparse, not scalars
-    return backend.to_table(np.atleast_2d(arg) if np.isscalar(arg) else arg, queue)
-
-
-def to_table(*args, queue=None):
-    """Create oneDAL tables from scalars and/or arrays.
-
-    Parameters
-    ----------
-    *args : {scalar, numpy array, sycl_usm_ndarray, csr_matrix, or csr_array}
-        Arguments to be individually converted to oneDAL tables.
-
-    queue : SyclQueue or None, default=None
-        SYCL Queue object to be associated with the oneDAL tables. Default
-        value None causes no change in data location or queue.
-
-    Returns
-    -------
-    tables: {oneDAL homogeneous tables}
-        Converted oneDAL tables.
-
-    Notes
-    -----
-        Tables will use pointers to the original array data. Scalars
-        and non-contiguous arrays will be copies. Arrays may be
-        modified in-place by oneDAL during computation. Transformation
-        is possible only for data located on CPU and SYCL-enabled Intel
-        GPUs. Each array may only be of a single data type (i.e. each
-        must be homogeneous).
-    """
-    return _apply_and_pass(_convert_one_to_table, *args, queue=queue)
-
-
-if backend.is_dpc:
-
-    def convert_one_from_table(table, sycl_queue=None, sua_iface=None, xp=None):
-        # Currently only `__sycl_usm_array_interface__` protocol used to
-        # convert into dpnp/dpctl tensors.
-        if sua_iface:
-            if (
-                sycl_queue
-                and sycl_queue.sycl_device.is_cpu
-                and table.__sycl_usm_array_interface__["syclobj"] is None
-            ):
-                # oneDAL returns tables with None sycl queue for CPU sycl queue inputs.
-                # This workaround is necessary for the functional preservation
-                # of the compute-follows-data execution.
-                # Host tables first converted into numpy.narrays and then to array from xp
-                # namespace.
-                return xp.asarray(
-                    backend.from_table(table), usm_type="device", sycl_queue=sycl_queue
-                )
-            else:
-                # By default DPNP ndarray created with a copy.
-                # TODO:
-                # investigate why dpnp.array(table, copy=False) doesn't work.
-                # Work around with using dpctl.tensor.asarray.
-                if isinstance(xp, ModuleType) and xp.__name__ == "dpnp":
-                    return xp.array(xp.dpctl.tensor.asarray(table), copy=False)
-                else:
-                    return xp.asarray(table)
-
-        return backend.from_table(table)
-
-else:
-
-    def convert_one_from_table(table, sycl_queue=None, sua_iface=None, xp=None):
-        # Currently only `__sycl_usm_array_interface__` protocol used to
-        # convert into dpnp/dpctl tensors.
-        if sua_iface:
-            raise RuntimeError(
-                "SYCL usm array conversion from table requires the DPC backend"
-            )
-        return backend.from_table(table)
-
-
-def from_table(*args, sycl_queue=None, sua_iface=None, xp=None):
-    return _apply_and_pass(
-        convert_one_from_table, *args, sycl_queue=sycl_queue, sua_iface=sua_iface, xp=xp
-    )

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

@@ -1,200 +0,0 @@
-# ==============================================================================
-# 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 sklearn.decomposition._pca import _infer_dimension
-from sklearn.utils.extmath import stable_cumsum
-
-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 BasePCA(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
-
-    # 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, stage=None):
-        if stage is None:
-            n_components = self._resolve_n_components_for_training(data.shape)
-        elif stage == "predict":
-            n_components = self.n_components_
-        return {
-            "fptype": data.dtype,
-            "method": self.method,
-            "n_components": n_components,
-            "is_deterministic": self.is_deterministic,
-            "whiten": self.whiten,
-        }
-
-    def _validate_n_components(self, n_components, n_samples, n_features):
-        if n_components is None:
-            n_components = min(n_samples, n_features)
-        if n_components == "mle":
-            if n_samples < n_features:
-                raise ValueError(
-                    "n_components='mle' is only supported if n_samples >= n_features"
-                )
-        elif not 0 <= n_components <= min(n_samples, n_features):
-            raise ValueError(
-                "n_components=%r must be between 0 and "
-                "min(n_samples, n_features)=%r with "
-                "svd_solver='full'" % (n_components, min(n_samples, n_features))
-            )
-        elif n_components >= 1:
-            if not isinstance(n_components, numbers.Integral):
-                raise ValueError(
-                    "n_components=%r must be of type int "
-                    "when greater than or equal to 1, "
-                    "was of type=%r" % (n_components, type(n_components))
-                )
-
-    def _resolve_n_components_for_training(self, shape_tuple):
-        if self.n_components is None or self.n_components == "mle":
-            return min(shape_tuple)
-        elif (
-            isinstance(self.n_components, float)
-            and self.n_components > 0.0
-            and self.n_components <= 1.0
-        ):
-            return min(shape_tuple)
-        else:
-            return self.n_components
-
-    def _resolve_n_components_for_result(self, shape_tuple):
-        if self.n_components is None:
-            return min(shape_tuple)
-        elif self.n_components == "mle":
-            return _infer_dimension(self.explained_variance_, shape_tuple[0])
-        elif 0.0 < self.n_components < 1.0:
-            ratio_cumsum = stable_cumsum(self.explained_variance_ratio_)
-            return np.searchsorted(ratio_cumsum, self.n_components, side="right") + 1
-        elif isinstance(self.n_components, float) and self.n_components == 1.0:
-            return min(shape_tuple)
-        else:
-            return self.n_components
-
-    def _compute_noise_variance(self, n_components, n_sf_min):
-        if n_components < n_sf_min:
-            if len(self.explained_variance_) == n_sf_min:
-                return self.explained_variance_[n_components:].mean()
-            elif len(self.explained_variance_) < n_sf_min:
-                # TODO Rename variances_ to var_ to align with sklearn/sklearnex IncrementalPCA
-                if hasattr(self, "variances_"):
-                    resid_var = self.variances_.sum()
-                elif hasattr(self, "var_"):
-                    resid_var = self.var_.sum()
-
-                resid_var -= self.explained_variance_.sum()
-                return resid_var / (n_sf_min - n_components)
-        else:
-            return 0.0
-
-    def _create_model(self):
-        m = self.model()
-        m.eigenvectors = to_table(self.components_)
-        m.means = to_table(self.mean_)
-        if self.whiten:
-            m.eigenvalues = to_table(self.explained_variance_)
-        self._onedal_model = m
-        return m
-
-    @supports_queue
-    def predict(self, X, queue=None):
-        model = self._create_model()
-        X_table = to_table(X, queue=queue)
-        params = self._get_onedal_params(X_table, stage="predict")
-        result = self.infer(params, model, X_table)
-        return from_table(result.transformed_data)
-
-    transform = predict
-
-
-class PCA(BasePCA):
-
-    @supports_queue
-    def fit(self, X, y=None, queue=None):
-        use_raw_input = _get_config().get("use_raw_input", False) is True
-        sua_iface, xp, _ = _get_sycl_namespace(X)
-        if use_raw_input and sua_iface:
-            queue = X.sycl_queue
-
-        n_samples, n_features = X.shape
-        n_sf_min = min(n_samples, n_features)
-        self._validate_n_components(self.n_components, n_samples, n_features)
-
-        # TODO: investigate why np.ndarray with OWNDATA=FALSE flag
-        # fails to be converted to oneDAL table
-        if isinstance(X, np.ndarray) and not X.flags["OWNDATA"]:
-            X = X.copy()
-
-        X = to_table(X, queue=queue)
-        params = self._get_onedal_params(X)
-        hparams = get_hyperparameters("pca", "train")
-        if hparams is not None and not hparams.is_default:
-            result = self.train(params, hparams.backend, X)
-        else:
-            result = self.train(params, X)
-
-        self.mean_ = from_table(result.means).ravel()
-        self.variances_ = from_table(result.variances)
-        self.components_ = from_table(result.eigenvectors)
-        self.singular_values_ = from_table(result.singular_values).ravel()
-        self.explained_variance_ = np.maximum(from_table(result.eigenvalues).ravel(), 0)
-        self.explained_variance_ratio_ = from_table(
-            result.explained_variances_ratio
-        ).ravel()
-        self.n_samples_ = n_samples
-        self.n_features_ = n_features
-
-        n_components = self._resolve_n_components_for_result(X.shape)
-        self.n_components_ = n_components
-        self.noise_variance_ = self._compute_noise_variance(n_components, n_sf_min)
-
-        if n_components < params["n_components"]:
-            self.explained_variance_ = self.explained_variance_[:n_components]
-            self.components_ = self.components_[:n_components]
-            self.singular_values_ = self.singular_values_[:n_components]
-            self.explained_variance_ratio_ = self.explained_variance_ratio_[:n_components]
-
-        return self