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

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

@@ -1,351 +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
-from numbers import Number
-
-import numpy as np
-
-from daal4py.sklearn._utils import daal_check_version, get_dtype, make2d
-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._estimator_checks import _check_is_fitted
-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_array, _check_n_features, _check_X_y, _num_features
-
-
-class BaseLinearRegression(metaclass=ABCMeta):
-    """
-    Base class for LinearRegression oneDAL implementation.
-    """
-
-    @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
-
-    @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=np.float32):
-        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()
-
-        coefficients = self.coef_
-        dtype = get_dtype(coefficients)
-
-        if coefficients.ndim == 2:
-            n_features_in = coefficients.shape[1]
-            n_targets_in = coefficients.shape[0]
-        else:
-            n_features_in = coefficients.size
-            n_targets_in = 1
-
-        intercept = self.intercept_
-        if isinstance(intercept, Number):
-            assert n_targets_in == 1
-        else:
-            if not isinstance(intercept, np.ndarray):
-                intercept = np.asarray(intercept, dtype=dtype)
-            assert n_targets_in == intercept.size
-
-        coefficients, intercept = make2d(coefficients), make2d(intercept)
-        coefficients = coefficients.T if n_targets_in == 1 else coefficients
-
-        assert coefficients.shape == (
-            n_targets_in,
-            n_features_in,
-        ), f"{coefficients.shape}, {n_targets_in}, {n_features_in}"
-        assert intercept.shape == (n_targets_in, 1), f"{intercept.shape}, {n_targets_in}"
-
-        desired_shape = (n_targets_in, n_features_in + 1)
-        packed_coefficients = np.zeros(desired_shape, dtype=dtype)
-
-        packed_coefficients[:, 1:] = coefficients
-        if self.fit_intercept:
-            packed_coefficients[:, 0][:, np.newaxis] = intercept
-
-        model.packed_coefficients = to_table(
-            packed_coefficients, queue=QM.get_global_queue()
-        )
-
-        self._onedal_model = model
-
-        return model
-
-    @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 : dpctl.SyclQueue
-            If not None, uses this queue for computations.
-
-        Returns
-        -------
-        C : array, shape (n_samples, n_targets)
-            Returns predicted values.
-        """
-
-        _check_is_fitted(self)
-
-        sua_iface, xp, _ = _get_sycl_namespace(X)
-        use_raw_input = _get_config().get("use_raw_input", False) is True
-        if use_raw_input and sua_iface is not None:
-            queue = X.sycl_queue
-
-        if not use_raw_input:
-            X = _check_array(
-                X, dtype=[np.float64, np.float32], force_all_finite=False, ensure_2d=False
-            )
-            X = make2d(X)
-
-        _check_n_features(self, X, False)
-
-        if hasattr(self, "_onedal_model"):
-            model = self._onedal_model
-        else:
-            model = self._create_model()
-
-        X_table = to_table(X, queue=queue)
-        params = self._get_onedal_params(X_table.dtype)
-        result = self.infer(params, model, X_table)
-        y = from_table(result.responses, sua_iface=sua_iface, sycl_queue=queue, xp=xp)
-
-        if y.shape[1] == 1 and self.coef_.ndim == 1:
-            return xp.reshape(y, (-1,))
-        else:
-            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 : string, default="norm_eq"
-        Algorithm used for computation on oneDAL side
-    """
-
-    def __init__(
-        self,
-        fit_intercept=True,
-        copy_X=False,
-        *,
-        algorithm="norm_eq",
-        **kwargs,
-    ):
-        super().__init__(fit_intercept=fit_intercept, copy_X=copy_X, algorithm=algorithm)
-
-    @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 : dpctl.SyclQueue
-            If not None, use this queue for computations.
-
-        Returns
-        -------
-        self : object
-            Fitted Estimator.
-        """
-
-        sua_iface, xp, _ = _get_sycl_namespace(X)
-        use_raw_input = _get_config().get("use_raw_input", False) is True
-        if use_raw_input and sua_iface is not None:
-            queue = X.sycl_queue
-        if _get_config()["use_raw_input"] is False:
-            if not isinstance(X, np.ndarray):
-                X = np.asarray(X)
-
-            dtype = get_dtype(X)
-            if dtype not in [np.float32, np.float64]:
-                dtype = np.float64
-                X = X.astype(dtype, copy=self.copy_X)
-
-            y = np.asarray(y).astype(dtype=dtype)
-
-            X, y = _check_X_y(X, y, force_all_finite=False, accept_2d_y=True)
-
-        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, sycl_queue=queue
-        )
-        self.coef_, self.intercept_ = (
-            packed_coefficients[:, 1:],
-            packed_coefficients[:, 0],
-        )
-
-        if self.coef_.shape[0] == 1 and y.ndim == 1:
-            self.coef_ = self.coef_.ravel()
-            self.intercept_ = self.intercept_[0]
-
-        return self
-
-
-class Ridge(BaseLinearRegression):
-    """
-    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",
-        **kwargs,
-    ):
-        super().__init__(
-            fit_intercept=fit_intercept, alpha=alpha, copy_X=copy_X, algorithm=algorithm
-        )
-
-    @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 : dpctl.SyclQueue
-            If not None, use this queue for computations.
-
-        Returns
-        -------
-        self : object
-            Fitted Estimator.
-        """
-        X = _check_array(
-            X,
-            dtype=[np.float64, np.float32],
-            force_all_finite=False,
-            ensure_2d=False,
-            copy=self.copy_X,
-        )
-        if not isinstance(X, np.ndarray):
-            X = np.asarray(X)
-
-        dtype = get_dtype(X)
-        if dtype not in [np.float32, np.float64]:
-            dtype = np.float64
-            X = X.astype(dtype, copy=self.copy_X)
-
-        y = np.asarray(y).astype(dtype=dtype)
-
-        X, y = _check_X_y(X, y, force_all_finite=False, accept_2d_y=True)
-
-        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.dtype)
-
-        result = self.train(params, X_table, y_table)
-        self._onedal_model = result.model
-
-        packed_coefficients = from_table(result.model.packed_coefficients)
-        self.coef_, self.intercept_ = (
-            packed_coefficients[:, 1:],
-            packed_coefficients[:, 0],
-        )
-
-        if self.coef_.shape[0] == 1 and y.ndim == 1:
-            self.coef_ = self.coef_.ravel()
-            self.intercept_ = self.intercept_[0]
-
-        return self

scikit_learn_intelex-2025.6.1.data/data/Lib/site-packages/onedal/utils/_dpep_helpers.py

@@ -1,71 +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.
-# ==============================================================================
-
-"""Utilities for Data Parallel Extensions libs, such as DPNP, DPCtl.
-See `Data Parallel Extensions for Python <https://github.com/IntelPython/DPEP>`__
-"""
-
-import functools
-
-from daal4py.sklearn._utils import _package_check_version
-
-
-@functools.lru_cache(maxsize=256, typed=False)
-def is_dpctl_available(version=None):
-    """Checks availability of DPCtl package"""
-    try:
-        import dpctl
-        import dpctl.tensor as dpt
-
-        dpctl_available = True
-    except ImportError:
-        dpctl_available = False
-    if dpctl_available and version is not None:
-        dpctl_available = _package_check_version(version, dpctl.__version__)
-    return dpctl_available
-
-
-@functools.lru_cache(maxsize=256, typed=False)
-def is_dpnp_available(version=None):
-    """Checks availability of DPNP package"""
-    try:
-        import dpnp
-
-        dpnp_available = True
-    except ImportError:
-        dpnp_available = False
-    if dpnp_available and version is not None:
-        dpnp_available = _package_check_version(version, dpnp.__version__)
-    return dpnp_available
-
-
-dpctl_available = is_dpctl_available()
-dpnp_available = is_dpnp_available()
-
-
-if dpnp_available:
-    import dpnp
-if dpctl_available:
-    import dpctl.tensor as dpt
-
-
-def get_unique_values_with_dpep(X):
-    if dpnp_available:
-        return dpnp.unique(X)
-    elif dpctl_available:
-        return dpt.unique_values(X)
-    else:
-        raise RuntimeError("No DPEP package available to provide `unique` function.")

scikit_learn_intelex-2025.6.1.data/data/Lib/site-packages/sklearnex/linear_model/tests/test_logreg.py

@@ -1,134 +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
-import pytest
-from numpy.testing import assert_allclose, assert_array_equal
-from scipy.sparse import csr_matrix
-from sklearn.datasets import load_breast_cancer, load_iris, make_classification
-from sklearn.metrics import accuracy_score
-from sklearn.model_selection import train_test_split
-
-from daal4py.sklearn._utils import daal_check_version
-from onedal.tests.utils._dataframes_support import (
-    _as_numpy,
-    _convert_to_dataframe,
-    get_dataframes_and_queues,
-    get_queues,
-)
-from sklearnex import config_context
-
-
-def prepare_input(X, y, dataframe, queue):
-    X_train, X_test, y_train, y_test = train_test_split(
-        X, y, train_size=0.8, random_state=42
-    )
-    X_train = _convert_to_dataframe(X_train, sycl_queue=queue, target_df=dataframe)
-    y_train = _convert_to_dataframe(y_train, sycl_queue=queue, target_df=dataframe)
-    X_test = _convert_to_dataframe(X_test, sycl_queue=queue, target_df=dataframe)
-    return X_train, X_test, y_train, y_test
-
-
-@pytest.mark.parametrize(
-    "dataframe,queue", get_dataframes_and_queues(device_filter_="cpu")
-)
-def test_sklearnex_multiclass_classification(dataframe, queue):
-    from sklearnex.linear_model import LogisticRegression
-
-    X, y = load_iris(return_X_y=True)
-    X_train, X_test, y_train, y_test = prepare_input(X, y, dataframe, queue=queue)
-
-    logreg = LogisticRegression(fit_intercept=True, solver="lbfgs", max_iter=200).fit(
-        X_train, y_train
-    )
-
-    if daal_check_version((2024, "P", 1)):
-        assert "sklearnex" in logreg.__module__
-    else:
-        assert "daal4py" in logreg.__module__
-
-    y_pred = _as_numpy(logreg.predict(X_test))
-    assert accuracy_score(y_test, y_pred) > 0.99
-
-
-@pytest.mark.parametrize(
-    "dataframe,queue",
-    get_dataframes_and_queues(),
-)
-def test_sklearnex_binary_classification(dataframe, queue):
-    from sklearnex.linear_model import LogisticRegression
-
-    X, y = load_breast_cancer(return_X_y=True)
-    X_train, X_test, y_train, y_test = prepare_input(X, y, dataframe, queue=queue)
-
-    logreg = LogisticRegression(fit_intercept=True, solver="newton-cg", max_iter=100).fit(
-        X_train, y_train
-    )
-
-    if daal_check_version((2024, "P", 1)):
-        assert "sklearnex" in logreg.__module__
-    else:
-        assert "daal4py" in logreg.__module__
-    if (
-        dataframe != "numpy"
-        and queue is not None
-        and queue.sycl_device.is_gpu
-        and daal_check_version((2024, "P", 1))
-    ):
-        # fit was done on gpu
-        assert hasattr(logreg, "_onedal_estimator")
-
-    y_pred = _as_numpy(logreg.predict(X_test))
-    assert accuracy_score(y_test, y_pred) > 0.95
-
-
-if daal_check_version((2024, "P", 700)):
-
-    @pytest.mark.parametrize("queue", get_queues("gpu"))
-    @pytest.mark.parametrize("dtype", [np.float32, np.float64])
-    @pytest.mark.parametrize(
-        "dims", [(3007, 17, 0.05), (50000, 100, 0.01), (512, 10, 0.5)]
-    )
-    def test_csr(queue, dtype, dims):
-        from sklearnex.linear_model import LogisticRegression
-
-        n, p, density = dims
-
-        # Create sparse dataset for classification
-        X, y = make_classification(n, p, random_state=42)
-        X = X.astype(dtype)
-        y = y.astype(dtype)
-        np.random.seed(2007 + n + p)
-        mask = np.random.binomial(1, density, (n, p))
-        X = X * mask
-        X_sp = csr_matrix(X)
-
-        model = LogisticRegression(fit_intercept=True, solver="newton-cg")
-        model_sp = LogisticRegression(fit_intercept=True, solver="newton-cg")
-
-        with config_context(target_offload="gpu:0"):
-            model.fit(X, y)
-            pred = model.predict(X)
-            prob = model.predict_proba(X)
-            model_sp.fit(X_sp, y)
-            pred_sp = model_sp.predict(X_sp)
-            prob_sp = model_sp.predict_proba(X_sp)
-
-        rtol = 2e-4
-        assert_allclose(pred, pred_sp, rtol=rtol)
-        assert_allclose(prob, prob_sp, rtol=rtol)
-        assert_allclose(model.coef_, model_sp.coef_, rtol=rtol)
-        assert_allclose(model.intercept_, model_sp.intercept_, rtol=rtol)

scikit_learn_intelex-2025.6.1.data/data/Lib/site-packages/sklearnex/spmd/cluster/dbscan.py

@@ -1,50 +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 ABC
-
-from onedal.spmd.cluster import DBSCAN as onedal_DBSCAN
-
-from ...cluster import DBSCAN as DBSCAN_Batch
-
-
-class BaseDBSCANspmd(ABC):
-    def _onedal_dbscan(self, **onedal_params):
-        return onedal_DBSCAN(**onedal_params)
-
-
-class DBSCAN(BaseDBSCANspmd, DBSCAN_Batch):
-    __doc__ = DBSCAN_Batch.__doc__
-
-    def _onedal_cpu_supported(self, method_name, *data):
-        # TODO:
-        # check which methods supported SPMD interface on CPU.
-        ready = super()._onedal_cpu_supported(method_name, *data)
-        if not ready:
-            raise RuntimeError(
-                f"Method {method_name} in {self.__class__.__name__} "
-                "is not supported with given inputs."
-            )
-        return ready
-
-    def _onedal_gpu_supported(self, method_name, *data):
-        ready = super()._onedal_gpu_supported(method_name, *data)
-        if not ready:
-            raise RuntimeError(
-                f"Method {method_name} in {self.__class__.__name__} "
-                "is not supported with given inputs."
-            )
-        return ready

scikit_learn_intelex-2025.6.1.data/data/Lib/site-packages/sklearnex/spmd/ensemble/forest.py

@@ -1,71 +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 onedal.spmd.ensemble import RandomForestClassifier as onedal_RandomForestClassifier
-from onedal.spmd.ensemble import RandomForestRegressor as onedal_RandomForestRegressor
-
-from ...ensemble import RandomForestClassifier as RandomForestClassifier_Batch
-from ...ensemble import RandomForestRegressor as RandomForestRegressor_Batch
-
-
-class RandomForestClassifier(RandomForestClassifier_Batch):
-    __doc__ = RandomForestClassifier_Batch.__doc__
-    _onedal_factory = onedal_RandomForestClassifier
-
-    def _onedal_cpu_supported(self, method_name, *data):
-        # TODO:
-        # check which methods supported SPMD interface on CPU.
-        ready = super()._onedal_cpu_supported(method_name, *data)
-        if not ready:
-            raise RuntimeError(
-                f"Method {method_name} in {self.__class__.__name__} "
-                "is not supported with given inputs."
-            )
-        return ready
-
-    def _onedal_gpu_supported(self, method_name, *data):
-        ready = super()._onedal_gpu_supported(method_name, *data)
-        if not ready:
-            raise RuntimeError(
-                f"Method {method_name} in {self.__class__.__name__} "
-                "is not supported with given inputs."
-            )
-        return ready
-
-
-class RandomForestRegressor(RandomForestRegressor_Batch):
-    __doc__ = RandomForestRegressor_Batch.__doc__
-    _onedal_factory = onedal_RandomForestRegressor
-
-    def _onedal_cpu_supported(self, method_name, *data):
-        # TODO:
-        # check which methods supported SPMD interface on CPU.
-        ready = super()._onedal_cpu_supported(method_name, *data)
-        if not ready:
-            raise RuntimeError(
-                f"Method {method_name} in {self.__class__.__name__} "
-                "is not supported with given inputs."
-            )
-        return ready
-
-    def _onedal_gpu_supported(self, method_name, *data):
-        ready = super()._onedal_gpu_supported(method_name, *data)
-        if not ready:
-            raise RuntimeError(
-                f"Method {method_name} in {self.__class__.__name__} "
-                "is not supported with given inputs."
-            )
-        return ready