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

scikit_learn_intelex-2025.6.1.data/data/Lib/site-packages/onedal/basic_statistics/basic_statistics.py

@@ -1,111 +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.
-# ==============================================================================
-
-from abc import ABCMeta, abstractmethod
-
-import numpy as np
-
-from onedal._device_offload import supports_queue
-
-from .._config import _get_config
-from ..common._backend import bind_default_backend
-from ..datatypes import from_table, to_table
-from ..utils.validation import _check_array, _is_csr
-
-
-class BaseBasicStatistics(metaclass=ABCMeta):
-    @abstractmethod
-    def __init__(self, result_options, algorithm):
-        self.options = result_options
-        self.algorithm = algorithm
-
-    @bind_default_backend("basic_statistics")
-    def compute(self, params, data_table, weights_table): ...
-
-    @staticmethod
-    def get_all_result_options():
-        return [
-            "min",
-            "max",
-            "sum",
-            "mean",
-            "variance",
-            "variation",
-            "sum_squares",
-            "standard_deviation",
-            "sum_squares_centered",
-            "second_order_raw_moment",
-        ]
-
-    def _get_result_options(self, options):
-        if options == "all":
-            options = self.get_all_result_options()
-        if isinstance(options, list):
-            options = "|".join(options)
-        assert isinstance(options, str)
-        return options
-
-    def _get_onedal_params(self, is_csr, dtype=np.float32):
-        options = self._get_result_options(self.options)
-        return {
-            "fptype": dtype,
-            "method": "sparse" if is_csr else self.algorithm,
-            "result_option": options,
-        }
-
-
-class BasicStatistics(BaseBasicStatistics):
-    """
-    Basic Statistics oneDAL implementation.
-    """
-
-    def __init__(self, result_options="all", algorithm="by_default"):
-        super().__init__(result_options, algorithm)
-
-    @supports_queue
-    def fit(self, data, sample_weight=None, queue=None):
-        is_csr = _is_csr(data)
-
-        use_raw_input = _get_config().get("use_raw_input", False) is True
-        if not use_raw_input:
-            if data is not None and not is_csr:
-                data = _check_array(data, ensure_2d=False)
-            if sample_weight is not None:
-                sample_weight = _check_array(sample_weight, ensure_2d=False)
-
-        is_single_dim = data.ndim == 1
-
-        data_table, weights_table = to_table(data, sample_weight, queue=queue)
-
-        dtype = data_table.dtype
-        raw_result = raw_result = self._compute_raw(
-            data_table, weights_table, dtype, is_csr
-        )
-        for opt, raw_value in raw_result.items():
-            value = from_table(raw_value).ravel()
-            if is_single_dim:
-                setattr(self, opt, value[0])
-            else:
-                setattr(self, opt, value)
-
-        return self
-
-    def _compute_raw(self, data_table, weights_table, dtype=np.float32, is_csr=False):
-        params = self._get_onedal_params(is_csr, dtype)
-        result = self.compute(params, data_table, weights_table)
-        options = self._get_result_options(self.options).split("|")
-
-        return {opt: getattr(result, opt) for opt in options}

scikit_learn_intelex-2025.6.1.data/data/Lib/site-packages/onedal/datatypes/_data_conversion.py

@@ -1,117 +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.
-# ==============================================================================
-
-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.
-
-    Note: this implementation can be used with scipy.sparse, numpy ndarrays,
-    DPCTL/DPNP usm_ndarrays and scalars. 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. This works
-    for data located on CPU and SYCL-enabled Intel GPUs. Each array may only
-    be of a single datatype (i.e. each must be homogeneous).
-
-    Parameters
-    ----------
-    *args : {scalar, numpy array, sycl_usm_ndarray, csr_matrix, or csr_array}
-        arg1, arg2... The arrays should be given as arguments.
-
-    Returns
-    -------
-    tables: {oneDAL homogeneous tables}
-    """
-    return _apply_and_pass(_convert_one_to_table, *args, queue=queue)
-
-
-if backend.is_dpc:
-
-    try:
-        # try/catch is used here instead of dpep_helpers because
-        # of circular import issues of _data_conversion.py and
-        # utils/validation.py. This is a temporary fix until the
-        # issue with dpnp is addressed, at which point this can
-        # be removed entirely.
-        import dpnp
-
-        def _table_to_array(table, xp=None):
-            # 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 xp == dpnp:
-                return dpnp.array(dpnp.dpctl.tensor.asarray(table), copy=False)
-            else:
-                return xp.asarray(table)
-
-    except ImportError:
-
-        def _table_to_array(table, xp=None):
-            return xp.asarray(table)
-
-    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:
-                return _table_to_array(table, xp=xp)
-
-        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.6.1.data/data/Lib/site-packages/onedal/linear_model/incremental_linear_model.py

@@ -1,311 +0,0 @@
-# ==============================================================================
-# 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 ..common.hyperparameters import get_hyperparameters
-from ..datatypes import from_table, to_table
-from ..utils._array_api import _get_sycl_namespace
-from ..utils.validation 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._queue = None
-        self._reset()
-
-    @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._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):
-        """
-        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.
-        """
-        use_raw_input = _get_config().get("use_raw_input", False) is True
-        sua_iface, _, _ = _get_sycl_namespace(X)
-
-        if use_raw_input and sua_iface:
-            queue = X.sycl_queue
-        if not use_raw_input:
-            X, y = _check_X_y(
-                X,
-                y,
-                dtype=[np.float64, np.float32],
-                accept_2d_y=True,
-                force_all_finite=False,
-            )
-            y = np.asarray(y, dtype=X.dtype)
-
-        if not hasattr(self, "_params"):
-            self._params = self._get_onedal_params(X.dtype)
-
-        self._queue = queue
-        self.n_features_in_ = _num_features(X, fallback_1d=True)
-
-        X_table, y_table = to_table(X, y, queue=queue)
-
-        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
-            )
-
-        self._need_to_finalize = True
-        return self
-
-    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 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, sycl_queue=self._queue
-            )
-            self.coef_, self.intercept_ = (
-                packed_coefficients[:, 1:].squeeze(),
-                packed_coefficients[:, 0].squeeze(),
-            )
-            self._need_to_finalize = False
-
-        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"):
-        super().__init__(
-            fit_intercept=fit_intercept, alpha=alpha, copy_X=copy_X, algorithm=algorithm
-        )
-        self._queue = None
-        self._reset()
-
-    def _reset(self):
-        self._need_to_finalize = False
-        self._queue = 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
-
-    @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): ...
-
-    @supports_queue
-    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.
-        """
-        self._queue = queue
-        X, y = _check_X_y(
-            X, y, dtype=[np.float64, np.float32], accept_2d_y=True, force_all_finite=False
-        )
-        y = np.asarray(y, dtype=X.dtype)
-
-        self.n_features_in_ = _num_features(X, fallback_1d=True)
-
-        X_table, y_table = to_table(X, y, queue=queue)
-
-        if not hasattr(self, "_dtype"):
-            self._dtype = X_table.dtype
-            self._params = self._get_onedal_params(self._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
-            )
-
-        self._need_to_finalize = True
-        return self
-
-    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.
-        """
-        if self._need_to_finalize:
-            with QM.manage_global_queue(self._queue):
-                result = self.finalize_train(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(),
-            )
-
-            self._need_to_finalize = False
-
-        return self