scikit-learn-intelex 2024.7.0__py310-none-win_amd64.whl → 2025.0.1__py310-none-win_amd64.whl

{scikit_learn_intelex-2024.7.0.data → scikit_learn_intelex-2025.0.1.data}/data/Lib/site-packages/sklearnex/covariance/incremental_covariance.py

@@ -35,7 +35,7 @@ from sklearnex import config_context
 from .._device_offload import dispatch, wrap_output_data
 from .._utils import PatchingConditionsChain, register_hyperparameters
 from ..metrics import pairwise_distances
-from ..utils import get_namespace
+from ..utils._array_api import get_namespace
 
 if sklearn_check_version("1.2"):
     from sklearn.utils._param_validation import Interval
@@ -44,9 +44,9 @@ if sklearn_check_version("1.2"):
 @control_n_jobs(decorated_methods=["partial_fit", "fit", "_onedal_finalize_fit"])
 class IncrementalEmpiricalCovariance(BaseEstimator):
     """
-    Incremental estimator for covariance.
-    Allows to compute empirical covariance estimated by maximum
-    likelihood method if data are splitted into batches.
+    Maximum likelihood covariance estimator that allows for the estimation when the data are split into
+    batches. The user can use the ``partial_fit`` method to provide a single batch of data or use the ``fit`` method to provide
+    the entire dataset.
 
     Parameters
     ----------
@@ -79,13 +79,31 @@ class IncrementalEmpiricalCovariance(BaseEstimator):
 
     n_samples_seen_ : int
         The number of samples processed by the estimator. Will be reset on
-        new calls to fit, but increments across ``partial_fit`` calls.
+        new calls to ``fit``, but increments across ``partial_fit`` calls.
 
     batch_size_ : int
         Inferred batch size from ``batch_size``.
 
     n_features_in_ : int
-        Number of features seen during :term:`fit` `partial_fit`.
+        Number of features seen during ``fit`` or ``partial_fit``.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearnex.covariance import IncrementalEmpiricalCovariance
+    >>> inccov = IncrementalEmpiricalCovariance(batch_size=1)
+    >>> X = np.array([[1, 2], [3, 4]])
+    >>> inccov.partial_fit(X[:1])
+    >>> inccov.partial_fit(X[1:])
+    >>> inccov.covariance_
+    np.array([[1., 1.],[1., 1.]])
+    >>> inccov.location_
+    np.array([2., 3.])
+    >>> inccov.fit(X)
+    >>> inccov.covariance_
+    np.array([[1., 1.],[1., 1.]])
+    >>> inccov.location_
+    np.array([2., 3.])
     """
 
     _onedal_incremental_covariance = staticmethod(onedal_IncrementalEmpiricalCovariance)
@@ -115,9 +133,9 @@ class IncrementalEmpiricalCovariance(BaseEstimator):
         )
         return patching_status
 
-    def _onedal_finalize_fit(self):
+    def _onedal_finalize_fit(self, queue=None):
         assert hasattr(self, "_onedal_estimator")
-        self._onedal_estimator.finalize_fit()
+        self._onedal_estimator.finalize_fit(queue=queue)
         self._need_to_finalize = False
 
         if not daal_check_version((2024, "P", 400)) and self.assume_centered:
@@ -192,7 +210,7 @@ class IncrementalEmpiricalCovariance(BaseEstimator):
             else:
                 self.n_samples_seen_ += X.shape[0]
 
-            self._onedal_estimator.partial_fit(X, queue)
+            self._onedal_estimator.partial_fit(X, queue=queue)
         finally:
             self._need_to_finalize = True
 
@@ -326,7 +344,7 @@ class IncrementalEmpiricalCovariance(BaseEstimator):
             X_batch = X[batch]
             self._onedal_partial_fit(X_batch, queue=queue, check_input=False)
 
-        self._onedal_finalize_fit()
+        self._onedal_finalize_fit(queue=queue)
 
         return self
 

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

@@ -26,6 +26,7 @@ from sklearn.covariance.tests.test_covariance import (
 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,
@@ -37,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]])
@@ -143,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

{scikit_learn_intelex-2024.7.0.data → scikit_learn_intelex-2025.0.1.data}/data/Lib/site-packages/sklearnex/decomposition/pca.py

@@ -32,7 +32,7 @@ if daal_check_version((2024, "P", 100)):
 
     from .._device_offload import dispatch, wrap_output_data
     from .._utils import PatchingConditionsChain
-    from ..utils import get_namespace
+    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

{scikit_learn_intelex-2024.7.0.data → scikit_learn_intelex-2025.0.1.data}/data/Lib/site-packages/sklearnex/dispatcher.py

@@ -48,7 +48,6 @@ 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,
             )
@@ -60,14 +59,6 @@ def get_patch_map_core(preview=False):
             # 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"] = [
                 [
@@ -143,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,
         )
@@ -155,6 +147,7 @@ def get_patch_map_core(preview=False):
         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
@@ -176,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]]
@@ -412,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.7.0.data → scikit_learn_intelex-2025.0.1.data}/data/Lib/site-packages/sklearnex/ensemble/_forest.py

@@ -57,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

{scikit_learn_intelex-2024.7.0.data → scikit_learn_intelex-2025.0.1.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.7.0.data → scikit_learn_intelex-2025.0.1.data}/data/Lib/site-packages/sklearnex/linear_model/coordinate_descent.py

@@ -15,16 +15,16 @@
 # ===============================================================================
 
 from daal4py.sklearn.linear_model import ElasticNet, Lasso
-from onedal._device_offload import support_usm_ndarray
+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_usm_ndarray(queue_param=False)(ElasticNet.fit)
-ElasticNet.predict = support_usm_ndarray(queue_param=False)(ElasticNet.predict)
-ElasticNet.score = support_usm_ndarray(queue_param=False)(ElasticNet.score)
+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_usm_ndarray(queue_param=False)(Lasso.fit)
-Lasso.predict = support_usm_ndarray(queue_param=False)(Lasso.predict)
-Lasso.score = support_usm_ndarray(queue_param=False)(Lasso.score)
+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.7.0.data → scikit_learn_intelex-2025.0.1.data}/data/Lib/site-packages/sklearnex/linear_model/incremental_linear.py

@@ -49,8 +49,9 @@ from .._utils import PatchingConditionsChain, register_hyperparameters
 )
 class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimator):
     """
-    Incremental estimator for linear regression.
-    Allows to train linear regression if data are splitted into batches.
+    Trains a linear regression model, allows for computation if the data are split into
+    batches. The user can use the ``partial_fit`` method to provide a single batch of data or use the ``fit`` method to provide
+    the entire dataset.
 
     Parameters
     ----------
@@ -68,8 +69,7 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
     batch_size : int, default=None
         The number of samples to use for each batch. Only used when calling
         ``fit``. If ``batch_size`` is ``None``, then ``batch_size``
-        is inferred from the data and set to ``5 * n_features``, to provide a
-        balance between approximation accuracy and memory consumption.
+        is inferred from the data and set to ``5 * n_features``.
 
     Attributes
     ----------
@@ -83,12 +83,9 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
         Independent term in the linear model. Set to 0.0 if
         `fit_intercept = False`.
 
-    n_features_in_ : int
-        Number of features seen during :term:`fit`.
-
     n_samples_seen_ : int
         The number of samples processed by the estimator. Will be reset on
-        new calls to fit, but increments across ``partial_fit`` calls.
+        new calls to ``fit``, but increments across ``partial_fit`` calls.
         It should be not less than `n_features_in_` if `fit_intercept`
         is False and not less than `n_features_in_` + 1 if `fit_intercept`
         is True to obtain regression coefficients.
@@ -97,8 +94,26 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
         Inferred batch size from ``batch_size``.
 
     n_features_in_ : int
-        Number of features seen during :term:`fit` `partial_fit`.
-
+        Number of features seen during ``fit`` or ``partial_fit``.
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> from sklearnex.linear_model import IncrementalLinearRegression
+    >>> inclr = IncrementalLinearRegression(batch_size=2)
+    >>> X = np.array([[1, 2], [3, 4], [5, 6], [7, 10]])
+    >>> y = np.array([1.5, 3.5, 5.5, 8.5])
+    >>> inclr.partial_fit(X[:2], y[:2])
+    >>> inclr.partial_fit(X[2:], y[2:])
+    >>> inclr.coef_
+    np.array([0.5., 0.5.])
+    >>> inclr.intercept_
+    np.array(0.)
+    >>> inclr.fit(X)
+    >>> inclr.coef_
+    np.array([0.5., 0.5.])
+    >>> inclr.intercept_
+    np.array(0.)
     """
 
     _onedal_incremental_linear = staticmethod(onedal_IncrementalLinearRegression)
@@ -147,7 +162,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 +209,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 +278,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):
@@ -312,12 +326,12 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
         Parameters
         ----------
         X : array-like of shape (n_samples, n_features)
-            Training data, where `n_samples` is the number of samples and
+            Training data, where ``n_samples`` is the number of samples and
             `n_features` is the number of features.
 
         y : array-like of shape (n_samples,) or (n_samples, n_targets)
-            Target values, where `n_samples` is the number of samples and
-            `n_targets` is the number of targets.
+            Target values, where ``n_samples`` is the number of samples and
+            ``n_targets`` is the number of targets.
 
         Returns
         -------
@@ -340,20 +354,20 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
 
     def fit(self, X, y):
         """
-        Fit the model with X and y, using minibatches of size batch_size.
+        Fit the model with X and y, using minibatches of size ``batch_size``.
 
         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. It is necessary for
-            `n_samples` to be not less than `n_features` if `fit_intercept`
-            is False and not less than `n_features` + 1 if `fit_intercept`
+            Training data, where ``n_samples`` is the number of samples and
+            ``n_features`` is the number of features. It is necessary for
+            ``n_samples`` to be not less than ``n_features`` if ``fit_intercept``
+            is False and not less than ``n_features + 1`` if ``fit_intercept``
             is True
 
         y : array-like of shape (n_samples,) or (n_samples, n_targets)
-            Target values, where `n_samples` is the number of samples and
-            `n_targets` is the number of targets.
+            Target values, where ``n_samples`` is the number of samples and
+            ``n_targets`` is the number of targets.
 
         Returns
         -------
@@ -377,10 +391,15 @@ class IncrementalLinearRegression(MultiOutputMixin, RegressorMixin, BaseEstimato
     def predict(self, X, y=None):
         """
         Predict using the linear model.
+
         Parameters
         ----------
         X : array-like or sparse matrix, shape (n_samples, n_features)
             Samples.
+
+        y : Ignored
+            Not used, present for API consistency by convention.
+
         Returns
         -------
         C : array, shape (n_samples, n_targets)