scikit-learn-intelex 2025.0.1__py311-none-win_amd64.whl → 2025.2.0__py311-none-win_amd64.whl

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/onedal/decomposition/incremental_pca.py

@@ -18,7 +18,7 @@ import numpy as np
 
 from daal4py.sklearn._utils import get_dtype
 
-from ..datatypes import _convert_to_supported, from_table, to_table
+from ..datatypes import from_table, to_table
 from ..utils import _check_array
 from .pca import BasePCA
 
@@ -99,11 +99,22 @@ class IncrementalPCA(BasePCA):
         self._reset()
 
     def _reset(self):
-        self._partial_result = self._get_backend(
-            "decomposition", "dim_reduction", "partial_train_result"
-        )
+        self._need_to_finalize = False
+        module = self._get_backend("decomposition", "dim_reduction")
         if hasattr(self, "components_"):
             del self.components_
+        self._partial_result = module.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
 
     def partial_fit(self, X, queue):
         """Incremental fit with X. All of X is processed as a single batch.
@@ -144,13 +155,12 @@ class IncrementalPCA(BasePCA):
         self._queue = queue
 
         policy = self._get_policy(queue, X)
-        X = _convert_to_supported(policy, X)
+        X_table = to_table(X, queue=queue)
 
         if not hasattr(self, "_dtype"):
-            self._dtype = get_dtype(X)
-            self._params = self._get_onedal_params(X)
+            self._dtype = X_table.dtype
+            self._params = self._get_onedal_params(X_table)
 
-        X_table = to_table(X)
         self._partial_result = self._get_backend(
             "decomposition",
             "dim_reduction",
@@ -160,6 +170,7 @@ class IncrementalPCA(BasePCA):
             self._partial_result,
             X_table,
         )
+        self._need_to_finalize = True
         return self
 
     def finalize_fit(self, queue=None):
@@ -177,28 +188,27 @@ class IncrementalPCA(BasePCA):
         self : object
             Returns the instance itself.
         """
-        if queue is not None:
-            policy = self._get_policy(queue)
-        else:
-            policy = self._get_policy(self._queue)
-        result = self._get_backend(
-            "decomposition",
-            "dim_reduction",
-            "finalize_train",
-            policy,
-            self._params,
-            self._partial_result,
-        )
-        self.mean_ = from_table(result.means).ravel()
-        self.var_ = from_table(result.variances).ravel()
-        self.components_ = from_table(result.eigenvectors)
-        self.singular_values_ = np.nan_to_num(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.noise_variance_ = self._compute_noise_variance(
-            self.n_components_, min(self.n_samples_seen_, self.n_features_in_)
-        )
-
+        if self._need_to_finalize:
+            module = self._get_backend("decomposition", "dim_reduction")
+            if queue is not None:
+                policy = self._get_policy(queue)
+            else:
+                policy = self._get_policy(self._queue)
+            result = module.finalize_train(policy, self._params, self._partial_result)
+            self.mean_ = from_table(result.means).ravel()
+            self.var_ = from_table(result.variances).ravel()
+            self.components_ = from_table(result.eigenvectors)
+            self.singular_values_ = np.nan_to_num(
+                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.noise_variance_ = self._compute_noise_variance(
+                self.n_components_, min(self.n_samples_seen_, self.n_features_in_)
+            )
+        self._need_to_finalize = False
         return self

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/onedal/decomposition/pca.py

@@ -22,7 +22,7 @@ from sklearn.decomposition._pca import _infer_dimension
 from sklearn.utils.extmath import stable_cumsum
 
 from ..common._base import BaseEstimator
-from ..datatypes import _convert_to_supported, from_table, to_table
+from ..datatypes import from_table, to_table
 
 
 class BasePCA(BaseEstimator, metaclass=ABCMeta):
@@ -48,7 +48,7 @@ class BasePCA(BaseEstimator, metaclass=ABCMeta):
         elif stage == "predict":
             n_components = self.n_components_
         return {
-            "fptype": "float" if data.dtype == np.float32 else "double",
+            "fptype": data.dtype,
             "method": self.method,
             "n_components": n_components,
             "is_deterministic": self.is_deterministic,
@@ -130,11 +130,11 @@ class BasePCA(BaseEstimator, metaclass=ABCMeta):
     def predict(self, X, queue=None):
         policy = self._get_policy(queue, X)
         model = self._create_model()
-        X = _convert_to_supported(policy, X)
-        params = self._get_onedal_params(X, stage="predict")
+        X_table = to_table(X, queue=queue)
+        params = self._get_onedal_params(X_table, stage="predict")
 
         result = self._get_backend(
-            "decomposition", "dim_reduction", "infer", policy, params, model, to_table(X)
+            "decomposition", "dim_reduction", "infer", policy, params, model, X_table
         )
         return from_table(result.transformed_data)
 
@@ -151,11 +151,11 @@ class PCA(BasePCA):
         # fails to be converted to oneDAL table
         if isinstance(X, np.ndarray) and not X.flags["OWNDATA"]:
             X = X.copy()
-        X = _convert_to_supported(policy, X)
 
+        X = to_table(X, queue=queue)
         params = self._get_onedal_params(X)
         result = self._get_backend(
-            "decomposition", "dim_reduction", "train", policy, params, to_table(X)
+            "decomposition", "dim_reduction", "train", policy, params, X
         )
 
         self.mean_ = from_table(result.means).ravel()

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/onedal/decomposition/tests/test_incremental_pca.py

@@ -19,6 +19,7 @@ import pytest
 from numpy.testing import assert_allclose
 
 from daal4py.sklearn._utils import daal_check_version
+from onedal.datatypes import from_table
 from onedal.decomposition import IncrementalPCA
 from onedal.tests.utils._device_selection import get_queues
 
@@ -196,3 +197,89 @@ def test_on_random_data(
         whiten and queue is not None and queue.sycl_device.device_type.name == "gpu"
     ):
         assert_allclose(transformed_data, expected_transformed_data, atol=tol)
+
+
+@pytest.mark.parametrize("queue", get_queues())
+@pytest.mark.parametrize("dtype", [np.float32, np.float64])
+def test_incremental_estimator_pickle(queue, dtype):
+    import pickle
+
+    from onedal.decomposition import IncrementalPCA
+
+    incpca = IncrementalPCA()
+
+    # Check that estimator can be serialized without any data.
+    dump = pickle.dumps(incpca)
+    incpca_loaded = pickle.loads(dump)
+    seed = 77
+    gen = np.random.default_rng(seed)
+    X = gen.uniform(low=-0.3, high=+0.7, size=(10, 10))
+    X = X.astype(dtype)
+    X_split = np.array_split(X, 2)
+    incpca.partial_fit(X_split[0], queue=queue)
+    incpca_loaded.partial_fit(X_split[0], queue=queue)
+    assert incpca._need_to_finalize == True
+    assert incpca_loaded._need_to_finalize == True
+
+    # Check that estimator can be serialized after partial_fit call.
+    dump = pickle.dumps(incpca)
+    incpca_loaded = pickle.loads(dump)
+    assert incpca._need_to_finalize == False
+    # Finalize is called during serialization to make sure partial results are finalized correctly.
+    assert incpca_loaded._need_to_finalize == False
+
+    partial_n_rows = from_table(incpca._partial_result.partial_n_rows)
+    partial_n_rows_loaded = from_table(incpca_loaded._partial_result.partial_n_rows)
+    assert_allclose(partial_n_rows, partial_n_rows_loaded)
+
+    partial_crossproduct = from_table(incpca._partial_result.partial_crossproduct)
+    partial_crossproduct_loaded = from_table(
+        incpca_loaded._partial_result.partial_crossproduct
+    )
+    assert_allclose(partial_crossproduct, partial_crossproduct_loaded)
+
+    partial_sum = from_table(incpca._partial_result.partial_sum)
+    partial_sum_loaded = from_table(incpca_loaded._partial_result.partial_sum)
+    assert_allclose(partial_sum, partial_sum_loaded)
+
+    auxiliary_table_count = incpca._partial_result.auxiliary_table_count
+    auxiliary_table_count_loaded = incpca_loaded._partial_result.auxiliary_table_count
+    assert_allclose(auxiliary_table_count, auxiliary_table_count_loaded)
+
+    for i in range(auxiliary_table_count):
+        aux_table = incpca._partial_result.get_auxiliary_table(i)
+        aux_table_loaded = incpca_loaded._partial_result.get_auxiliary_table(i)
+        assert_allclose(from_table(aux_table), from_table(aux_table_loaded))
+
+    incpca.partial_fit(X_split[1], queue=queue)
+    incpca_loaded.partial_fit(X_split[1], queue=queue)
+    assert incpca._need_to_finalize == True
+    assert incpca_loaded._need_to_finalize == True
+
+    dump = pickle.dumps(incpca_loaded)
+    incpca_loaded = pickle.loads(dump)
+
+    assert incpca._need_to_finalize == True
+    assert incpca_loaded._need_to_finalize == False
+
+    incpca.finalize_fit()
+    incpca_loaded.finalize_fit()
+
+    # Check that finalized estimator can be serialized.
+    dump = pickle.dumps(incpca_loaded)
+    incpca_loaded = pickle.loads(dump)
+
+    assert_allclose(incpca.singular_values_, incpca_loaded.singular_values_, atol=1e-6)
+    assert_allclose(incpca.n_samples_seen_, incpca_loaded.n_samples_seen_, atol=1e-6)
+    assert_allclose(incpca.n_features_in_, incpca_loaded.n_features_in_, atol=1e-6)
+    assert_allclose(incpca.mean_, incpca_loaded.mean_, atol=1e-6)
+    assert_allclose(incpca.var_, incpca_loaded.var_, atol=1e-6)
+    assert_allclose(
+        incpca.explained_variance_, incpca_loaded.explained_variance_, atol=1e-6
+    )
+    assert_allclose(incpca.components_, incpca_loaded.components_, atol=1e-6)
+    assert_allclose(
+        incpca.explained_variance_ratio_,
+        incpca_loaded.explained_variance_ratio_,
+        atol=1e-6,
+    )

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/onedal/ensemble/forest.py

@@ -18,19 +18,18 @@ import numbers
 import warnings
 from abc import ABCMeta, abstractmethod
 from math import ceil
-from numbers import Number
 
 import numpy as np
 from sklearn.ensemble import BaseEnsemble
 from sklearn.utils import check_random_state
 
 from daal4py.sklearn._utils import daal_check_version
-from onedal import _backend
+from sklearnex import get_hyperparameters
 
 from ..common._base import BaseEstimator
 from ..common._estimator_checks import _check_is_fitted
 from ..common._mixin import ClassifierMixin, RegressorMixin
-from ..datatypes import _convert_to_supported, from_table, to_table
+from ..datatypes import from_table, to_table
 from ..utils import (
     _check_array,
     _check_n_features,
@@ -159,7 +158,7 @@ class BaseForest(BaseEstimator, BaseEnsemble, metaclass=ABCMeta):
         seed = rs.randint(0, np.iinfo("i").max)
 
         onedal_params = {
-            "fptype": "float" if data.dtype == np.float32 else "double",
+            "fptype": data.dtype,
             "method": self.algorithm,
             "infer_mode": self.infer_mode,
             "voting_mode": self.voting_mode,
@@ -307,9 +306,9 @@ class BaseForest(BaseEstimator, BaseEnsemble, metaclass=ABCMeta):
         else:
             data = (X, y)
         policy = self._get_policy(queue, *data)
-        data = _convert_to_supported(policy, *data)
+        data = to_table(*data, queue=queue)
         params = self._get_onedal_params(data[0])
-        train_result = module.train(policy, params, *to_table(*data))
+        train_result = module.train(policy, params, *data)
 
         self._onedal_model = train_result.model
 
@@ -346,7 +345,7 @@ class BaseForest(BaseEstimator, BaseEnsemble, metaclass=ABCMeta):
         # upate error msg.
         raise NotImplementedError("Creating model is not supported.")
 
-    def _predict(self, X, module, queue):
+    def _predict(self, X, module, queue, hparams=None):
         _check_is_fitted(self)
         X = _check_array(
             X, dtype=[np.float64, np.float32], force_all_finite=True, accept_sparse=False
@@ -355,25 +354,33 @@ class BaseForest(BaseEstimator, BaseEnsemble, metaclass=ABCMeta):
         policy = self._get_policy(queue, X)
 
         model = self._onedal_model
-        X = _convert_to_supported(policy, X)
+        X = to_table(X, queue=queue)
         params = self._get_onedal_params(X)
-        result = module.infer(policy, params, model, to_table(X))
+        if hparams is not None and not hparams.is_default:
+            result = module.infer(policy, params, hparams.backend, model, X)
+        else:
+            result = module.infer(policy, params, model, X)
+
         y = from_table(result.responses)
         return y
 
-    def _predict_proba(self, X, module, queue):
+    def _predict_proba(self, X, module, queue, hparams=None):
         _check_is_fitted(self)
         X = _check_array(
             X, dtype=[np.float64, np.float32], force_all_finite=True, accept_sparse=False
         )
         _check_n_features(self, X, False)
         policy = self._get_policy(queue, X)
-        X = _convert_to_supported(policy, X)
+        X = to_table(X, queue=queue)
         params = self._get_onedal_params(X)
         params["infer_mode"] = "class_probabilities"
 
         model = self._onedal_model
-        result = module.infer(policy, params, model, to_table(X))
+        if hparams is not None and not hparams.is_default:
+            result = module.infer(policy, params, hparams.backend, model, X)
+        else:
+            result = module.infer(policy, params, model, X)
+
         y = from_table(result.probabilities)
         return y
 
@@ -458,15 +465,24 @@ class RandomForestClassifier(ClassifierMixin, BaseForest, metaclass=ABCMeta):
         )
 
     def predict(self, X, queue=None):
+        hparams = get_hyperparameters("decision_forest", "infer")
         pred = super()._predict(
-            X, self._get_backend("decision_forest", "classification", None), queue
+            X,
+            self._get_backend("decision_forest", "classification", None),
+            queue,
+            hparams,
         )
 
         return np.take(self.classes_, pred.ravel().astype(np.int64, casting="unsafe"))
 
     def predict_proba(self, X, queue=None):
+        hparams = get_hyperparameters("decision_forest", "infer")
+
         return super()._predict_proba(
-            X, self._get_backend("decision_forest", "classification", None), queue
+            X,
+            self._get_backend("decision_forest", "classification", None),
+            queue,
+            hparams,
         )
 
 

{scikit_learn_intelex-2025.0.1.data → scikit_learn_intelex-2025.2.0.data}/data/Lib/site-packages/onedal/linear_model/incremental_linear_model.py

@@ -19,7 +19,7 @@ import numpy as np
 from daal4py.sklearn._utils import get_dtype
 
 from ..common.hyperparameters import get_hyperparameters
-from ..datatypes import _convert_to_supported, from_table, to_table
+from ..datatypes import from_table, to_table
 from ..utils import _check_X_y, _num_features
 from .linear_model import BaseLinearRegression
 
@@ -47,10 +47,22 @@ class IncrementalLinearRegression(BaseLinearRegression):
         self._reset()
 
     def _reset(self):
+        self._need_to_finalize = False
         self._partial_result = self._get_backend(
             "linear_model", "regression", "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
+
     def partial_fit(self, X, y, queue=None):
         """
         Computes partial data for linear regression
@@ -77,20 +89,19 @@ class IncrementalLinearRegression(BaseLinearRegression):
         self._queue = queue
         policy = self._get_policy(queue, X)
 
-        X, y = _convert_to_supported(policy, X, y)
-
-        if not hasattr(self, "_dtype"):
-            self._dtype = get_dtype(X)
-            self._params = self._get_onedal_params(self._dtype)
-
-        y = np.asarray(y, dtype=self._dtype)
-
         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)
+
+        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 = module.partial_train(
@@ -106,6 +117,9 @@ class IncrementalLinearRegression(BaseLinearRegression):
                 policy, 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
@@ -122,27 +136,30 @@ class IncrementalLinearRegression(BaseLinearRegression):
             Returns the instance itself.
         """
 
-        if queue is not None:
-            policy = self._get_policy(queue)
-        else:
-            policy = self._get_policy(self._queue)
-
-        module = self._get_backend("linear_model", "regression")
-        hparams = get_hyperparameters("linear_regression", "train")
-        if hparams is not None and not hparams.is_default:
-            result = module.finalize_train(
-                policy, self._params, hparams.backend, self._partial_result
+        if self._need_to_finalize:
+            if queue is not None:
+                policy = self._get_policy(queue)
+            else:
+                policy = self._get_policy(self._queue)
+
+            module = self._get_backend("linear_model", "regression")
+            hparams = get_hyperparameters("linear_regression", "train")
+            if hparams is not None and not hparams.is_default:
+                result = module.finalize_train(
+                    policy, self._params, hparams.backend, self._partial_result
+                )
+            else:
+                result = module.finalize_train(policy, 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(),
             )
-        else:
-            result = module.finalize_train(policy, 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
 
@@ -171,15 +188,26 @@ class IncrementalRidge(BaseLinearRegression):
     """
 
     def __init__(self, alpha=1.0, fit_intercept=True, copy_X=False, algorithm="norm_eq"):
-        module = self._get_backend("linear_model", "regression")
         super().__init__(
             fit_intercept=fit_intercept, alpha=alpha, copy_X=copy_X, algorithm=algorithm
         )
-        self._partial_result = module.partial_train_result()
+        self._reset()
 
     def _reset(self):
         module = self._get_backend("linear_model", "regression")
         self._partial_result = module.partial_train_result()
+        self._need_to_finalize = False
+
+    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
 
     def partial_fit(self, X, y, queue=None):
         """
@@ -207,24 +235,26 @@ class IncrementalRidge(BaseLinearRegression):
         self._queue = queue
         policy = self._get_policy(queue, X)
 
-        X, y = _convert_to_supported(policy, X, y)
-
-        if not hasattr(self, "_dtype"):
-            self._dtype = get_dtype(X)
-            self._params = self._get_onedal_params(self._dtype)
-
-        y = np.asarray(y, dtype=self._dtype)
-
         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)
+
+        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)
+
         self._partial_result = module.partial_train(
             policy, 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
@@ -240,19 +270,23 @@ class IncrementalRidge(BaseLinearRegression):
         self : object
             Returns the instance itself.
         """
-        module = self._get_backend("linear_model", "regression")
-        if queue is not None:
-            policy = self._get_policy(queue)
-        else:
-            policy = self._get_policy(self._queue)
-        result = module.finalize_train(policy, self._params, self._partial_result)
 
-        self._onedal_model = result.model
+        if self._need_to_finalize:
+            module = self._get_backend("linear_model", "regression")
+            if queue is not None:
+                policy = self._get_policy(queue)
+            else:
+                policy = self._get_policy(self._queue)
+            result = module.finalize_train(policy, self._params, self._partial_result)
 
-        packed_coefficients = from_table(result.model.packed_coefficients)
-        self.coef_, self.intercept_ = (
-            packed_coefficients[:, 1:].squeeze(),
-            packed_coefficients[:, 0].squeeze(),
-        )
+            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