scikit-learn-intelex 2024.6.0__py310-none-win_amd64.whl → 2025.0.0__py310-none-win_amd64.whl

{scikit_learn_intelex-2024.6.0.data → scikit_learn_intelex-2025.0.0.data}/data/Lib/site-packages/sklearnex/covariance/tests/test_incremental_covariance.py

@@ -16,13 +16,19 @@
 
 import numpy as np
 import pytest
+from numpy.linalg import slogdet
 from numpy.testing import assert_allclose
+from scipy.linalg import pinvh
 from sklearn.covariance.tests.test_covariance import (
     test_covariance,
     test_EmpiricalCovariance_validates_mahalanobis,
 )
+from sklearn.datasets import load_diabetes
+from sklearn.decomposition import PCA
 
+from daal4py.sklearn._utils import daal_check_version
 from onedal.tests.utils._dataframes_support import (
+    _as_numpy,
     _convert_to_dataframe,
     get_dataframes_and_queues,
 )
@@ -32,6 +38,11 @@ from onedal.tests.utils._dataframes_support import (
 @pytest.mark.parametrize("dtype", [np.float32, np.float64])
 @pytest.mark.parametrize("assume_centered", [True, False])
 def test_sklearnex_partial_fit_on_gold_data(dataframe, queue, dtype, assume_centered):
+    is_gpu = queue is not None and queue.sycl_device.is_gpu
+    if assume_centered and is_gpu and not daal_check_version((2025, "P", 0)):
+        pytest.skip(
+            "Due to a bug on oneDAL side, means are not set to zero when assume_centered=True"
+        )
     from sklearnex.covariance import IncrementalEmpiricalCovariance
 
     X = np.array([[0, 1], [0, 1]])
@@ -138,6 +149,11 @@ def test_sklearnex_partial_fit_on_random_data(
 def test_sklearnex_fit_on_random_data(
     dataframe, queue, num_batches, row_count, column_count, dtype, assume_centered
 ):
+    is_gpu = queue is not None and queue.sycl_device.is_gpu
+    if assume_centered and is_gpu and not daal_check_version((2025, "P", 0)):
+        pytest.skip(
+            "Due to a bug on oneDAL side, means are not set to zero when assume_centered=True"
+        )
     from sklearnex.covariance import IncrementalEmpiricalCovariance
 
     seed = 77
@@ -163,6 +179,36 @@ def test_sklearnex_fit_on_random_data(
     assert_allclose(expected_means, result.location_, atol=1e-6)
 
 
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
+def test_whitened_toy_score(dataframe, queue):
+    from sklearnex.covariance import IncrementalEmpiricalCovariance
+
+    # Load a sklearn toy dataset with sufficient data
+    X, _ = load_diabetes(return_X_y=True)
+    n = X.shape[1]
+
+    # Transform the data into uncorrelated, unity variance components
+    X = PCA(whiten=True).fit_transform(X)
+
+    # change dataframe
+    X_df = _convert_to_dataframe(X, sycl_queue=queue, target_df=dataframe)
+
+    # fit data
+    est = IncrementalEmpiricalCovariance()
+    est.fit(X_df)
+    # location_ attribute approximately zero (10,), covariance_ identity (10,10)
+
+    # The log-likelihood can be calculated simply due to covariance_
+    # use of scipy.linalg.pinvh, np.linalg.sloget and np.cov for estimator
+    # independence
+    expected_result = (
+        -(n - slogdet(pinvh(np.cov(X.T, bias=1)))[1] + n * np.log(2 * np.pi)) / 2
+    )
+    # expected_result = -14.1780602988
+    result = _as_numpy(est.score(X_df))
+    assert_allclose(expected_result, result, atol=1e-6)
+
+
 # Monkeypatch IncrementalEmpiricalCovariance into relevant sklearn.covariance tests
 @pytest.mark.allow_sklearn_fallback
 @pytest.mark.parametrize(

{scikit_learn_intelex-2024.6.0.data → scikit_learn_intelex-2025.0.0.data}/data/Lib/site-packages/sklearnex/decomposition/pca.py

@@ -32,6 +32,7 @@ if daal_check_version((2024, "P", 100)):
 
     from .._device_offload import dispatch, wrap_output_data
     from .._utils import PatchingConditionsChain
+    from ..utils._array_api import get_namespace
 
     if sklearn_check_version("1.1") and not sklearn_check_version("1.2"):
         from sklearn.utils import check_scalar
@@ -42,7 +43,6 @@ if daal_check_version((2024, "P", 100)):
     from sklearn.decomposition import PCA as sklearn_PCA
 
     from onedal.decomposition import PCA as onedal_PCA
-    from sklearnex.utils import get_namespace
 
     @control_n_jobs(decorated_methods=["fit", "transform", "fit_transform"])
     class PCA(sklearn_PCA):
@@ -210,6 +210,29 @@ if daal_check_version((2024, "P", 100)):
                 # Scikit-learn PCA["covariance_eigh"] was fit
                 return self._transform(X_fit, xp, x_is_centered=x_is_centered)
 
+        @wrap_output_data
+        def inverse_transform(self, X):
+            xp, _ = get_namespace(X)
+
+            mean = self.mean_
+            if self.whiten:
+                components = (
+                    xp.sqrt(self.explained_variance_[:, np.newaxis]) * self.components_
+                )
+            else:
+                components = self.components_
+
+            if "numpy" not in xp.__name__:
+                # DPCtl and dpnp require inputs to be on the same device for
+                # matrix multiplication and division. The type and location
+                # of the components and mean are dependent on the sklearn
+                # version, this makes sure it is of the same type and on the
+                # same device as the data (compute follows data).
+                components = xp.asarray(components, device=X.device)
+                mean = xp.asarray(mean, device=X.device)
+
+            return X @ components + mean
+
         def _onedal_supported(self, method_name, X):
             class_name = self.__class__.__name__
             patching_status = PatchingConditionsChain(
@@ -381,6 +404,7 @@ if daal_check_version((2024, "P", 100)):
         fit.__doc__ = sklearn_PCA.fit.__doc__
         transform.__doc__ = sklearn_PCA.transform.__doc__
         fit_transform.__doc__ = sklearn_PCA.fit_transform.__doc__
+        inverse_transform.__doc__ = sklearn_PCA.inverse_transform.__doc__
 
 else:
     from daal4py.sklearn.decomposition import PCA

{scikit_learn_intelex-2024.6.0.data → scikit_learn_intelex-2025.0.0.data}/data/Lib/site-packages/sklearnex/dispatcher.py

@@ -48,25 +48,17 @@ def get_patch_map_core(preview=False):
             import sklearn.decomposition as decomposition_module
 
             # Preview classes for patching
-            from .preview.cluster import KMeans as KMeans_sklearnex
             from .preview.covariance import (
                 EmpiricalCovariance as EmpiricalCovariance_sklearnex,
             )
             from .preview.decomposition import IncrementalPCA as IncrementalPCA_sklearnex
+            from .preview.linear_model import Ridge as Ridge_sklearnex
 
             # Since the state of the lru_cache without preview cannot be
             # guaranteed to not have already enabled sklearnex algorithms
             # when preview is used, setting the mapping element[1] to None
             # should NOT be done. This may lose track of the unpatched
             # sklearn estimator or function.
-            # KMeans
-            cluster_module, _, _ = mapping["kmeans"][0][0]
-            sklearn_obj = mapping["kmeans"][0][1]
-            mapping.pop("kmeans")
-            mapping["kmeans"] = [
-                [(cluster_module, "KMeans", KMeans_sklearnex), sklearn_obj]
-            ]
-
             # Covariance
             mapping["empiricalcovariance"] = [
                 [
@@ -90,6 +82,15 @@ def get_patch_map_core(preview=False):
                     None,
                 ]
             ]
+
+            # Ridge
+            linear_model_module, _, _ = mapping["ridge"][0][0]
+            sklearn_obj = mapping["ridge"][0][1]
+            mapping.pop("ridge")
+            mapping["ridge"] = [
+                [(linear_model_module, "Ridge", Ridge_sklearnex), sklearn_obj]
+            ]
+
         return mapping
 
     from daal4py.sklearn.monkeypatch.dispatcher import _get_map_of_algorithms
@@ -111,6 +112,9 @@ def get_patch_map_core(preview=False):
         import sklearn.decomposition as decomposition_module
         import sklearn.ensemble as ensemble_module
         import sklearn.linear_model as linear_model_module
+        import sklearn.manifold as manifold_module
+        import sklearn.metrics as metrics_module
+        import sklearn.model_selection as model_selection_module
         import sklearn.neighbors as neighbors_module
         import sklearn.svm as svm_module
 
@@ -130,6 +134,7 @@ def get_patch_map_core(preview=False):
             from .utils.parallel import _FuncWrapperOld as _FuncWrapper_sklearnex
 
         from .cluster import DBSCAN as DBSCAN_sklearnex
+        from .cluster import KMeans as KMeans_sklearnex
         from .covariance import (
             IncrementalEmpiricalCovariance as IncrementalEmpiricalCovariance_sklearnex,
         )
@@ -138,11 +143,19 @@ def get_patch_map_core(preview=False):
         from .ensemble import ExtraTreesRegressor as ExtraTreesRegressor_sklearnex
         from .ensemble import RandomForestClassifier as RandomForestClassifier_sklearnex
         from .ensemble import RandomForestRegressor as RandomForestRegressor_sklearnex
+        from .linear_model import ElasticNet as ElasticNet_sklearnex
         from .linear_model import (
             IncrementalLinearRegression as IncrementalLinearRegression_sklearnex,
         )
+        from .linear_model import IncrementalRidge as IncrementalRidge_sklearnex
+        from .linear_model import Lasso as Lasso_sklearnex
         from .linear_model import LinearRegression as LinearRegression_sklearnex
         from .linear_model import LogisticRegression as LogisticRegression_sklearnex
+        from .linear_model import Ridge as Ridge_sklearnex
+        from .manifold import TSNE as TSNE_sklearnex
+        from .metrics import pairwise_distances as pairwise_distances_sklearnex
+        from .metrics import roc_auc_score as roc_auc_score_sklearnex
+        from .model_selection import train_test_split as train_test_split_sklearnex
         from .neighbors import KNeighborsClassifier as KNeighborsClassifier_sklearnex
         from .neighbors import KNeighborsRegressor as KNeighborsRegressor_sklearnex
         from .neighbors import LocalOutlierFactor as LocalOutlierFactor_sklearnex
@@ -156,6 +169,10 @@ def get_patch_map_core(preview=False):
         mapping.pop("dbscan")
         mapping["dbscan"] = [[(cluster_module, "DBSCAN", DBSCAN_sklearnex), None]]
 
+        # KMeans
+        mapping.pop("kmeans")
+        mapping["kmeans"] = [[(cluster_module, "KMeans", KMeans_sklearnex), None]]
+
         # PCA
         mapping.pop("pca")
         mapping["pca"] = [[(decomposition_module, "PCA", PCA_sklearnex), None]]
@@ -168,6 +185,32 @@ def get_patch_map_core(preview=False):
         mapping["nusvr"] = [[(svm_module, "NuSVR", NuSVR_sklearnex), None]]
         mapping["nusvc"] = [[(svm_module, "NuSVC", NuSVC_sklearnex), None]]
 
+        # ElasticNet
+        mapping.pop("elasticnet")
+        mapping["elasticnet"] = [
+            [
+                (
+                    linear_model_module,
+                    "ElasticNet",
+                    ElasticNet_sklearnex,
+                ),
+                None,
+            ]
+        ]
+
+        # Lasso
+        mapping.pop("lasso")
+        mapping["lasso"] = [
+            [
+                (
+                    linear_model_module,
+                    "Lasso",
+                    Lasso_sklearnex,
+                ),
+                None,
+            ]
+        ]
+
         # Linear Regression
         mapping.pop("linear")
         mapping.pop("linearregression")
@@ -201,6 +244,54 @@ def get_patch_map_core(preview=False):
         ]
         mapping["logisticregression"] = mapping["log_reg"]
 
+        # Ridge
+        mapping.pop("ridge")
+        mapping["ridge"] = [
+            [
+                (
+                    linear_model_module,
+                    "Ridge",
+                    Ridge_sklearnex,
+                ),
+                None,
+            ]
+        ]
+
+        # manifold
+        mapping.pop("tsne")
+        mapping["tsne"] = [
+            [
+                (manifold_module, "TSNE", TSNE_sklearnex),
+                None,
+            ]
+        ]
+
+        # metrics
+        mapping.pop("distances")
+        mapping.pop("roc_auc_score")
+        mapping["distances"] = [
+            [
+                (metrics_module, "pairwise_distances", pairwise_distances_sklearnex),
+                None,
+            ]
+        ]
+        mapping["pairwise_distances"] = mapping["distances"]
+        mapping["roc_auc_score"] = [
+            [
+                (metrics_module, "roc_auc_score", roc_auc_score_sklearnex),
+                None,
+            ]
+        ]
+
+        # model_selection
+        mapping.pop("train_test_split")
+        mapping["train_test_split"] = [
+            [
+                (model_selection_module, "train_test_split", train_test_split_sklearnex),
+                None,
+            ]
+        ]
+
         # kNN
         mapping.pop("knn_classifier")
         mapping.pop("kneighborsclassifier")
@@ -318,6 +409,19 @@ def get_patch_map_core(preview=False):
             ]
         ]
 
+        if daal_check_version((2024, "P", 600)):
+            # IncrementalRidge
+            mapping["incrementalridge"] = [
+                [
+                    (
+                        linear_model_module,
+                        "IncrementalRidge",
+                        IncrementalRidge_sklearnex,
+                    ),
+                    None,
+                ]
+            ]
+
         # Configs
         mapping["set_config"] = [
             [(base_module, "set_config", set_config_sklearnex), None]

{scikit_learn_intelex-2024.6.0.data → scikit_learn_intelex-2025.0.0.data}/data/Lib/site-packages/sklearnex/ensemble/_forest.py

@@ -38,7 +38,12 @@ from sklearn.tree import (
 )
 from sklearn.tree._tree import Tree
 from sklearn.utils import check_random_state, deprecated
-from sklearn.utils.validation import check_array, check_is_fitted, check_X_y
+from sklearn.utils.validation import (
+    _check_sample_weight,
+    check_array,
+    check_is_fitted,
+    check_X_y,
+)
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import (
@@ -52,10 +57,10 @@ from onedal.ensemble import RandomForestClassifier as onedal_RandomForestClassif
 from onedal.ensemble import RandomForestRegressor as onedal_RandomForestRegressor
 from onedal.primitives import get_tree_state_cls, get_tree_state_reg
 from onedal.utils import _num_features, _num_samples
-from sklearnex.utils import get_namespace
 
 from .._device_offload import dispatch, wrap_output_data
 from .._utils import PatchingConditionsChain
+from ..utils._array_api import get_namespace
 
 if sklearn_check_version("1.2"):
     from sklearn.utils._param_validation import Interval
@@ -70,7 +75,7 @@ class BaseForest(ABC):
         X, y = self._validate_data(
             X,
             y,
-            multi_output=False,
+            multi_output=True,
             accept_sparse=False,
             dtype=[np.float64, np.float32],
             force_all_finite=False,
@@ -78,7 +83,7 @@ class BaseForest(ABC):
         )
 
         if sample_weight is not None:
-            sample_weight = self.check_sample_weight(sample_weight, X)
+            sample_weight = _check_sample_weight(sample_weight, X)
 
         if y.ndim == 2 and y.shape[1] == 1:
             warnings.warn(
@@ -289,38 +294,6 @@ class BaseForest(ABC):
                 "min_bin_size must be integral number but was " "%r" % self.min_bin_size
             )
 
-    def check_sample_weight(self, sample_weight, X, dtype=None):
-        n_samples = _num_samples(X)
-
-        if dtype is not None and dtype not in [np.float32, np.float64]:
-            dtype = np.float64
-
-        if sample_weight is None:
-            sample_weight = np.ones(n_samples, dtype=dtype)
-        elif isinstance(sample_weight, numbers.Number):
-            sample_weight = np.full(n_samples, sample_weight, dtype=dtype)
-        else:
-            if dtype is None:
-                dtype = [np.float64, np.float32]
-            sample_weight = check_array(
-                sample_weight,
-                accept_sparse=False,
-                ensure_2d=False,
-                dtype=dtype,
-                order="C",
-                force_all_finite=False,
-            )
-            if sample_weight.ndim != 1:
-                raise ValueError("Sample weights must be 1D array or scalar")
-
-            if sample_weight.shape != (n_samples,):
-                raise ValueError(
-                    "sample_weight.shape == {}, expected {}!".format(
-                        sample_weight.shape, (n_samples,)
-                    )
-                )
-        return sample_weight
-
     @property
     def estimators_(self):
         if hasattr(self, "_cached_estimators_"):

{scikit_learn_intelex-2024.6.0.data → scikit_learn_intelex-2025.0.0.data}/data/Lib/site-packages/sklearnex/ensemble/tests/test_forest.py

@@ -46,11 +46,10 @@ def test_sklearnex_import_rf_classifier(dataframe, queue):
     assert_allclose([1], _as_numpy(rf.predict([[0, 0, 0, 0]])))
 
 
-# TODO: fix RF regressor predict for the GPU sycl_queue.
-@pytest.mark.parametrize(
-    "dataframe,queue", get_dataframes_and_queues(device_filter_="cpu")
-)
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 def test_sklearnex_import_rf_regression(dataframe, queue):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("RF regressor predict for the GPU sycl_queue is buggy.")
     from sklearnex.ensemble import RandomForestRegressor
 
     X, y = make_regression(n_features=4, n_informative=2, random_state=0, shuffle=False)
@@ -69,11 +68,10 @@ def test_sklearnex_import_rf_regression(dataframe, queue):
             assert_allclose([-6.839], pred, atol=1e-2)
 
 
-# TODO: fix ET classifier predict for the GPU sycl_queue.
-@pytest.mark.parametrize(
-    "dataframe,queue", get_dataframes_and_queues(device_filter_="cpu")
-)
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 def test_sklearnex_import_et_classifier(dataframe, queue):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("ET classifier predict for the GPU sycl_queue is buggy.")
     from sklearnex.ensemble import ExtraTreesClassifier
 
     X, y = make_classification(
@@ -93,11 +91,10 @@ def test_sklearnex_import_et_classifier(dataframe, queue):
     assert_allclose([1], _as_numpy(rf.predict([[0, 0, 0, 0]])))
 
 
-# TODO: fix ET regressor predict for the GPU sycl_queue.
-@pytest.mark.parametrize(
-    "dataframe,queue", get_dataframes_and_queues(device_filter_="cpu")
-)
+@pytest.mark.parametrize("dataframe,queue", get_dataframes_and_queues())
 def test_sklearnex_import_et_regression(dataframe, queue):
+    if queue and queue.sycl_device.is_gpu:
+        pytest.skip("ET regressor predict for the GPU sycl_queue is buggy.")
     from sklearnex.ensemble import ExtraTreesRegressor
 
     X, y = make_regression(n_features=1, random_state=0, shuffle=False)

{scikit_learn_intelex-2024.6.0.data → scikit_learn_intelex-2025.0.0.data}/data/Lib/site-packages/sklearnex/linear_model/__init__.py

@@ -16,6 +16,7 @@
 
 from .coordinate_descent import ElasticNet, Lasso
 from .incremental_linear import IncrementalLinearRegression
+from .incremental_ridge import IncrementalRidge
 from .linear import LinearRegression
 from .logistic_regression import LogisticRegression
 from .ridge import Ridge
@@ -23,6 +24,7 @@ from .ridge import Ridge
 __all__ = [
     "ElasticNet",
     "IncrementalLinearRegression",
+    "IncrementalRidge",
     "Lasso",
     "LinearRegression",
     "LogisticRegression",

{scikit_learn_intelex-2024.6.0.data → scikit_learn_intelex-2025.0.0.data}/data/Lib/site-packages/sklearnex/linear_model/coordinate_descent.py

@@ -15,3 +15,16 @@
 # ===============================================================================
 
 from daal4py.sklearn.linear_model import ElasticNet, Lasso
+from onedal._device_offload import support_input_format
+
+# Note: `sklearnex.linear_model.ElasticNet` only has functional
+# sycl GPU support. No GPU device will be offloaded.
+ElasticNet.fit = support_input_format(queue_param=False)(ElasticNet.fit)
+ElasticNet.predict = support_input_format(queue_param=False)(ElasticNet.predict)
+ElasticNet.score = support_input_format(queue_param=False)(ElasticNet.score)
+
+# Note: `sklearnex.linear_model.Lasso` only has functional
+# sycl GPU support. No GPU device will be offloaded.
+Lasso.fit = support_input_format(queue_param=False)(Lasso.fit)
+Lasso.predict = support_input_format(queue_param=False)(Lasso.predict)
+Lasso.score = support_input_format(queue_param=False)(Lasso.score)

{scikit_learn_intelex-2024.6.0.data → scikit_learn_intelex-2025.0.0.data}/data/Lib/site-packages/sklearnex/linear_model/incremental_linear.py

@@ -147,7 +147,7 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
         assert hasattr(self, "_onedal_estimator")
         if self._need_to_finalize:
             self._onedal_finalize_fit()
-        return self._onedal_estimator.predict(X, queue)
+        return self._onedal_estimator.predict(X, queue=queue)
 
     def _onedal_score(self, X, y, sample_weight=None, queue=None):
         return r2_score(
@@ -194,17 +194,17 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
         onedal_params = {"fit_intercept": self.fit_intercept, "copy_X": self.copy_X}
         if not hasattr(self, "_onedal_estimator"):
             self._onedal_estimator = self._onedal_incremental_linear(**onedal_params)
-        self._onedal_estimator.partial_fit(X, y, queue)
+        self._onedal_estimator.partial_fit(X, y, queue=queue)
         self._need_to_finalize = True
 
-    def _onedal_finalize_fit(self):
+    def _onedal_finalize_fit(self, queue=None):
         assert hasattr(self, "_onedal_estimator")
         is_underdetermined = self.n_samples_seen_ < self.n_features_in_ + int(
             self.fit_intercept
         )
         if is_underdetermined:
             raise ValueError("Not enough samples to finalize")
-        self._onedal_estimator.finalize_fit()
+        self._onedal_estimator.finalize_fit(queue=queue)
         self._need_to_finalize = False
 
     def _onedal_fit(self, X, y, queue=None):
@@ -263,8 +263,7 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
                 "Only one sample available. You may want to reshape your data array"
             )
 
-        self._onedal_finalize_fit()
-
+        self._onedal_finalize_fit(queue=queue)
         return self
 
     def get_intercept_(self):