scikit-learn-intelex 2025.2.0__py310-none-win_amd64.whl → 2025.5.0__py310-none-win_amd64.whl

{scikit_learn_intelex-2025.2.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/sklearnex/_utils.py

@@ -16,13 +16,28 @@
 
 import logging
 import os
+import re
+import sys
 import warnings
 from abc import ABC
 
+import sklearn
+
 from daal4py.sklearn._utils import (
     PatchingConditionsChain as daal4py_PatchingConditionsChain,
 )
-from daal4py.sklearn._utils import daal_check_version
+from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
+
+# Note: if inheriting from '_HTMLDocumentationLinkMixin' here, it then doesn't matter
+# the order of inheritance of classes for estimators when this is later subclassed,
+# whereas if inheriting from something else, the subclass that inherits from this needs
+# to be the first inherited class in estimators in order for it to take effect.
+if sklearn_check_version("1.4"):
+    from sklearn.utils._estimator_html_repr import _HTMLDocumentationLinkMixin
+
+    BaseForHTMLDocLink = _HTMLDocumentationLinkMixin
+else:
+    BaseForHTMLDocLink = ABC
 
 
 class PatchingConditionsChain(daal4py_PatchingConditionsChain):
@@ -37,7 +52,7 @@ class PatchingConditionsChain(daal4py_PatchingConditionsChain):
         else:
             self.logger.debug(
                 f"{self.scope_name}: debugging for the patch is enabled to track"
-                " the usage of Intel® oneAPI Data Analytics Library (oneDAL)"
+                " the usage of oneAPI Data Analytics Library (oneDAL)"
             )
             for message in self.messages:
                 self.logger.debug(
@@ -128,10 +143,8 @@ def register_hyperparameters(hyperparameters_map):
 
 
 # This abstract class is meant to generate a clickable doc link for classses
-# in sklearnex that are not part of base scikit-learn. It should be inherited
-# before inheriting from a scikit-learn estimator, otherwise will get overriden
-# by the estimator's original.
-class IntelEstimator(ABC):
+# in sklearnex that are not part of base scikit-learn.
+class ExtensionEstimator(BaseForHTMLDocLink):
     @property
     def _doc_link_module(self) -> str:
         return "sklearnex"
@@ -141,3 +154,50 @@ class IntelEstimator(ABC):
         module_path, _ = self.__class__.__module__.rsplit(".", 1)
         class_name = self.__class__.__name__
         return f"https://uxlfoundation.github.io/scikit-learn-intelex/latest/non-scikit-algorithms.html#{module_path}.{class_name}"
+
+
+def _add_inc_serialization_note(class_docstrings: str) -> str:
+    """Adds a small note note about serialization for extension estimators that are incremental.
+    The class docstrings should leave a placeholder '%incremental_serialization_note%' inside
+    their docstrings, which will be replaced by this note.
+    """
+    # In python versions >=3.13, leading whitespace in docstrings defined through
+    # static strings (but **not through other ways**) is automatically removed
+    # from the final docstrings, while in earlier versions is kept.
+    inc_serialization_note = """Note
+----
+Serializing instances of this class will trigger a forced finalization of calculations
+when the inputs are in a sycl queue or when using GPUs. Since (internal method)
+finalize_fit can't be dispatched without directly provided queue and the dispatching
+policy can't be serialized, the computation is finalized during serialization call and
+the policy is not saved in serialized data."""
+    if sys.version_info.major == 3 and sys.version_info.minor <= 12:
+        inc_serialization_note = re.sub(
+            r"^", " " * 4, inc_serialization_note, flags=re.MULTILINE
+        )
+        inc_serialization_note = inc_serialization_note.strip()
+    return class_docstrings.replace(
+        r"%incremental_serialization_note%", inc_serialization_note
+    )
+
+
+# This abstract class is meant to generate a clickable doc link for classses
+# in sklearnex that have counterparts in scikit-learn.
+class PatchableEstimator(BaseForHTMLDocLink):
+    @property
+    def _doc_link_module(self) -> str:
+        return "sklearnex"
+
+    @property
+    def _doc_link_template(self) -> str:
+        if re.search(r"^\d\.\d\.\d$", sklearn.__version__):
+            sklearn_version_parts = sklearn.__version__.split(".")
+            doc_version_url = sklearn_version_parts[0] + "." + sklearn_version_parts[1]
+        else:
+            doc_version_url = "stable"
+        module_path, _ = self.__class__.__module__.rsplit(".", 1)
+        module_path = re.sub("sklearnex", "sklearn", module_path)
+        class_name = self.__class__.__name__
+        # for TSNE, which re-uses daal4py
+        module_path = re.sub(r"daal4py\.", "", module_path)
+        return f"https://scikit-learn.org/{doc_version_url}/modules/generated/{module_path}.{class_name}.html"

{scikit_learn_intelex-2025.2.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/sklearnex/basic_statistics/basic_statistics.py

@@ -25,22 +25,18 @@ from sklearn.utils.validation import _check_sample_weight
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
 from onedal.basic_statistics import BasicStatistics as onedal_BasicStatistics
-from onedal.utils import _is_csr
+from onedal.utils.validation import _is_csr
 
 from .._device_offload import dispatch
-from .._utils import IntelEstimator, PatchingConditionsChain
-
-if sklearn_check_version("1.6"):
-    from sklearn.utils.validation import validate_data
-else:
-    validate_data = BaseEstimator._validate_data
+from .._utils import ExtensionEstimator, PatchingConditionsChain
+from ..utils.validation import validate_data
 
 if sklearn_check_version("1.2"):
     from sklearn.utils._param_validation import StrOptions
 
 
 @control_n_jobs(decorated_methods=["fit"])
-class BasicStatistics(IntelEstimator, BaseEstimator):
+class BasicStatistics(ExtensionEstimator, BaseEstimator):
     """
     Estimator for basic statistics.
     Allows to compute basic statistics for provided data.
@@ -204,16 +200,13 @@ class BasicStatistics(IntelEstimator, BaseEstimator):
         if sklearn_check_version("1.2"):
             self._validate_params()
 
-        if sklearn_check_version("1.0"):
-            X = validate_data(
-                self,
-                X,
-                dtype=[np.float64, np.float32],
-                ensure_2d=False,
-                accept_sparse="csr",
-            )
-        else:
-            X = check_array(X, dtype=[np.float64, np.float32])
+        X = validate_data(
+            self,
+            X,
+            dtype=[np.float64, np.float32],
+            ensure_2d=False,
+            accept_sparse="csr",
+        )
 
         if sample_weight is not None:
             sample_weight = _check_sample_weight(sample_weight, X)
@@ -224,11 +217,11 @@ class BasicStatistics(IntelEstimator, BaseEstimator):
 
         if not hasattr(self, "_onedal_estimator"):
             self._onedal_estimator = self._onedal_basic_statistics(**onedal_params)
-        self._onedal_estimator.fit(X, sample_weight, queue)
+        self._onedal_estimator.fit(X, sample_weight, queue=queue)
         self._save_attributes()
         self.n_features_in_ = X.shape[1] if len(X.shape) > 1 else 1
 
-    def fit(self, X, y=None, *, sample_weight=None):
+    def fit(self, X, y=None, sample_weight=None):
         """Calculate statistics of X.
 
         Parameters

{scikit_learn_intelex-2025.2.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/sklearnex/basic_statistics/incremental_basic_statistics.py

@@ -25,8 +25,14 @@ from onedal.basic_statistics import (
     IncrementalBasicStatistics as onedal_IncrementalBasicStatistics,
 )
 
+from .._config import get_config
 from .._device_offload import dispatch
-from .._utils import IntelEstimator, PatchingConditionsChain
+from .._utils import (
+    ExtensionEstimator,
+    PatchingConditionsChain,
+    _add_inc_serialization_note,
+)
+from ..utils.validation import validate_data
 
 if sklearn_check_version("1.2"):
     from sklearn.utils._param_validation import Interval, StrOptions
@@ -34,14 +40,9 @@ if sklearn_check_version("1.2"):
 import numbers
 import warnings
 
-if sklearn_check_version("1.6"):
-    from sklearn.utils.validation import validate_data
-else:
-    validate_data = BaseEstimator._validate_data
-
 
 @control_n_jobs(decorated_methods=["partial_fit", "_onedal_finalize_fit"])
-class IncrementalBasicStatistics(IntelEstimator, BaseEstimator):
+class IncrementalBasicStatistics(ExtensionEstimator, BaseEstimator):
     """
     Calculates basic statistics on the given data, allows for computation when the data are split into
     batches. The user can use ``partial_fit`` method to provide a single batch of data or use the ``fit`` method to provide
@@ -103,18 +104,13 @@ class IncrementalBasicStatistics(IntelEstimator, BaseEstimator):
     ----
     Attribute exists only if corresponding result option has been provided.
 
-    Note
-    ----
-    Serializing instances of this class will trigger a forced finalization of calculations.
-    Since finalize_fit can't be dispatched without directly provided queue
-    and the dispatching policy can't be serialized, the computation is finalized
-    during serialization call and the policy is not saved in serialized data.
-
     Note
     ----
     Names of attributes without the trailing underscore are
     supported currently but deprecated in 2025.1 and will be removed in 2026.0
 
+    %incremental_serialization_note%
+
     Examples
     --------
     >>> import numpy as np
@@ -134,6 +130,8 @@ class IncrementalBasicStatistics(IntelEstimator, BaseEstimator):
     np.array([3., 4.])
     """
 
+    __doc__ = _add_inc_serialization_note(__doc__)
+
     _onedal_incremental_basic_statistics = staticmethod(onedal_IncrementalBasicStatistics)
 
     if sklearn_check_version("1.2"):
@@ -186,29 +184,26 @@ class IncrementalBasicStatistics(IntelEstimator, BaseEstimator):
         assert isinstance(onedal_options, str)
         return options
 
-    def _onedal_finalize_fit(self, queue=None):
+    def _onedal_finalize_fit(self):
         assert hasattr(self, "_onedal_estimator")
-        self._onedal_estimator.finalize_fit(queue=queue)
+        self._onedal_estimator.finalize_fit()
         self._need_to_finalize = False
 
     def _onedal_partial_fit(self, X, sample_weight=None, queue=None, check_input=True):
         first_pass = not hasattr(self, "n_samples_seen_") or self.n_samples_seen_ == 0
 
+        use_raw_input = get_config().get("use_raw_input", False) is True
+        # never check input when using raw input
+        check_input &= use_raw_input is False
         if check_input:
-            if sklearn_check_version("1.0"):
-                X = validate_data(
-                    self,
-                    X,
-                    dtype=[np.float64, np.float32],
-                    reset=first_pass,
-                )
-            else:
-                X = check_array(
-                    X,
-                    dtype=[np.float64, np.float32],
-                )
+            X = validate_data(
+                self,
+                X,
+                dtype=[np.float64, np.float32],
+                reset=first_pass,
+            )
 
-        if sample_weight is not None:
+        if not use_raw_input and sample_weight is not None:
             sample_weight = _check_sample_weight(sample_weight, X)
 
         if first_pass:
@@ -228,16 +223,15 @@ class IncrementalBasicStatistics(IntelEstimator, BaseEstimator):
         self._need_to_finalize = True
 
     def _onedal_fit(self, X, sample_weight=None, queue=None):
-        if sklearn_check_version("1.2"):
-            self._validate_params()
+        use_raw_input = get_config().get("use_raw_input", False) is True
+        if not use_raw_input:
+            if sklearn_check_version("1.2"):
+                self._validate_params()
 
-        if sklearn_check_version("1.0"):
             X = validate_data(self, X, dtype=[np.float64, np.float32])
-        else:
-            X = check_array(X, dtype=[np.float64, np.float32])
 
-        if sample_weight is not None:
-            sample_weight = _check_sample_weight(sample_weight, X)
+            if sample_weight is not None:
+                sample_weight = _check_sample_weight(sample_weight, X)
 
         n_samples, n_features = X.shape
         if self.batch_size is None:
@@ -258,7 +252,7 @@ class IncrementalBasicStatistics(IntelEstimator, BaseEstimator):
 
         self.n_features_in_ = X.shape[1]
 
-        self._onedal_finalize_fit(queue=queue)
+        self._onedal_finalize_fit()
 
         return self
 
@@ -303,7 +297,7 @@ class IncrementalBasicStatistics(IntelEstimator, BaseEstimator):
 
         Returns
         -------
-        self : object
+        self : IncrementalBasicStatistics
             Returns the instance itself.
         """
         dispatch(
@@ -320,7 +314,7 @@ class IncrementalBasicStatistics(IntelEstimator, BaseEstimator):
         return self
 
     def fit(self, X, y=None, sample_weight=None):
-        """Calculate statistics of X using minibatches of size batch_size.
+        """Calculate statistics of X using minibatches of size ``batch_size``.
 
         Parameters
         ----------
@@ -336,7 +330,7 @@ class IncrementalBasicStatistics(IntelEstimator, BaseEstimator):
 
         Returns
         -------
-        self : object
+        self : IncrementalBasicStatistics
             Returns the instance itself.
         """
         dispatch(

{scikit_learn_intelex-2025.2.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/sklearnex/cluster/dbscan.py

@@ -25,17 +25,14 @@ from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
 from onedal.cluster import DBSCAN as onedal_DBSCAN
 
+from .._config import get_config
 from .._device_offload import dispatch
-from .._utils import PatchingConditionsChain
+from .._utils import PatchableEstimator, PatchingConditionsChain
+from ..utils.validation import validate_data
 
 if sklearn_check_version("1.1") and not sklearn_check_version("1.2"):
     from sklearn.utils import check_scalar
 
-if sklearn_check_version("1.6"):
-    from sklearn.utils.validation import validate_data
-else:
-    validate_data = _sklearn_DBSCAN._validate_data
-
 
 class BaseDBSCAN(ABC):
     def _onedal_dbscan(self, **onedal_params):
@@ -51,7 +48,7 @@ class BaseDBSCAN(ABC):
 
 
 @control_n_jobs(decorated_methods=["fit"])
-class DBSCAN(_sklearn_DBSCAN, BaseDBSCAN):
+class DBSCAN(PatchableEstimator, _sklearn_DBSCAN, BaseDBSCAN):
     __doc__ = _sklearn_DBSCAN.__doc__
 
     if sklearn_check_version("1.2"):
@@ -89,8 +86,8 @@ class DBSCAN(_sklearn_DBSCAN, BaseDBSCAN):
         self.n_jobs = n_jobs
 
     def _onedal_fit(self, X, y, sample_weight=None, queue=None):
-        if sklearn_check_version("1.0"):
-            X = validate_data(self, X, force_all_finite=False)
+        if get_config()["use_raw_input"] is False:
+            X = validate_data(self, X, ensure_all_finite=False)
 
         onedal_params = {
             "eps": self.eps,
@@ -178,7 +175,8 @@ class DBSCAN(_sklearn_DBSCAN, BaseDBSCAN):
             if self.eps <= 0.0:
                 raise ValueError(f"eps == {self.eps}, must be > 0.0.")
 
-        if sample_weight is not None:
+        use_raw_input = get_config().get("use_raw_input", False) is True
+        if not use_raw_input and sample_weight is not None:
             sample_weight = _check_sample_weight(sample_weight, X)
         dispatch(
             self,

{scikit_learn_intelex-2025.2.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/sklearnex/cluster/k_means.py

@@ -36,18 +36,14 @@ if daal_check_version((2023, "P", 200)):
     from daal4py.sklearn._n_jobs_support import control_n_jobs
     from daal4py.sklearn._utils import sklearn_check_version
     from onedal.cluster import KMeans as onedal_KMeans
-    from onedal.utils import _is_csr
+    from onedal.utils.validation import _is_csr
 
     from .._device_offload import dispatch, wrap_output_data
-    from .._utils import PatchingConditionsChain
-
-    if sklearn_check_version("1.6"):
-        from sklearn.utils.validation import validate_data
-    else:
-        validate_data = _sklearn_KMeans._validate_data
+    from .._utils import PatchableEstimator, PatchingConditionsChain
+    from ..utils.validation import validate_data
 
     @control_n_jobs(decorated_methods=["fit", "fit_transform", "predict", "score"])
-    class KMeans(_sklearn_KMeans):
+    class KMeans(PatchableEstimator, _sklearn_KMeans):
         __doc__ = _sklearn_KMeans.__doc__
 
         if sklearn_check_version("1.2"):

{scikit_learn_intelex-2025.2.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/sklearnex/covariance/incremental_covariance.py

@@ -32,22 +32,24 @@ from onedal.covariance import (
 )
 from sklearnex import config_context
 
+from .._config import get_config
 from .._device_offload import dispatch, wrap_output_data
-from .._utils import IntelEstimator, PatchingConditionsChain, register_hyperparameters
+from .._utils import (
+    ExtensionEstimator,
+    PatchingConditionsChain,
+    _add_inc_serialization_note,
+    register_hyperparameters,
+)
 from ..metrics import pairwise_distances
 from ..utils._array_api import get_namespace
+from ..utils.validation import check_feature_names, validate_data
 
 if sklearn_check_version("1.2"):
     from sklearn.utils._param_validation import Interval
 
-if sklearn_check_version("1.6"):
-    from sklearn.utils.validation import validate_data
-else:
-    validate_data = BaseEstimator._validate_data
-
 
 @control_n_jobs(decorated_methods=["partial_fit", "fit", "_onedal_finalize_fit"])
-class IncrementalEmpiricalCovariance(IntelEstimator, BaseEstimator):
+class IncrementalEmpiricalCovariance(ExtensionEstimator, BaseEstimator):
     """
     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
@@ -92,12 +94,7 @@ class IncrementalEmpiricalCovariance(IntelEstimator, BaseEstimator):
     n_features_in_ : int
         Number of features seen during ``fit`` or ``partial_fit``.
 
-    Note
-    ----
-    Serializing instances of this class will trigger a forced finalization of calculations.
-    Since finalize_fit can't be dispatched without directly provided queue
-    and the dispatching policy can't be serialized, the computation is finalized
-    during serialization and the policy is not saved in serialized data.
+    %incremental_serialization_note%
 
     Examples
     --------
@@ -118,6 +115,8 @@ class IncrementalEmpiricalCovariance(IntelEstimator, BaseEstimator):
     np.array([2., 3.])
     """
 
+    __doc__ = _add_inc_serialization_note(__doc__)
+
     _onedal_incremental_covariance = staticmethod(onedal_IncrementalEmpiricalCovariance)
 
     if sklearn_check_version("1.2"):
@@ -145,9 +144,9 @@ class IncrementalEmpiricalCovariance(IntelEstimator, BaseEstimator):
         )
         return patching_status
 
-    def _onedal_finalize_fit(self, queue=None):
+    def _onedal_finalize_fit(self):
         assert hasattr(self, "_onedal_estimator")
-        self._onedal_estimator.finalize_fit(queue=queue)
+        self._onedal_estimator.finalize_fit()
         self._need_to_finalize = False
 
         if not daal_check_version((2024, "P", 400)) and self.assume_centered:
@@ -184,30 +183,24 @@ class IncrementalEmpiricalCovariance(IntelEstimator, BaseEstimator):
             )
 
     def _onedal_partial_fit(self, X, queue=None, check_input=True):
-
         first_pass = not hasattr(self, "n_samples_seen_") or self.n_samples_seen_ == 0
 
+        use_raw_input = get_config().get("use_raw_input", False) is True
+        # never check input when using raw input
+        check_input &= use_raw_input is False
         # finite check occurs on onedal side
         if check_input:
             if sklearn_check_version("1.2"):
                 self._validate_params()
 
-            if sklearn_check_version("1.0"):
-                X = validate_data(
-                    self,
-                    X,
-                    dtype=[np.float64, np.float32],
-                    reset=first_pass,
-                    copy=self.copy,
-                    force_all_finite=False,
-                )
-            else:
-                X = check_array(
-                    X,
-                    dtype=[np.float64, np.float32],
-                    copy=self.copy,
-                    force_all_finite=False,
-                )
+            X = validate_data(
+                self,
+                X,
+                dtype=[np.float64, np.float32],
+                reset=first_pass,
+                copy=self.copy,
+                ensure_all_finite=False,
+            )
 
         onedal_params = {
             "method": "dense",
@@ -235,18 +228,12 @@ class IncrementalEmpiricalCovariance(IntelEstimator, BaseEstimator):
 
         check_is_fitted(self)
         location = self.location_
-        if sklearn_check_version("1.0"):
-            X = validate_data(
-                self,
-                X_test,
-                dtype=[np.float64, np.float32],
-                reset=False,
-            )
-        else:
-            X = check_array(
-                X_test,
-                dtype=[np.float64, np.float32],
-            )
+        X = validate_data(
+            self,
+            X_test,
+            dtype=[np.float64, np.float32],
+            reset=False,
+        )
 
         if "numpy" not in xp.__name__:
             location = xp.asarray(location, device=X_test.device)
@@ -286,7 +273,7 @@ class IncrementalEmpiricalCovariance(IntelEstimator, BaseEstimator):
 
         Returns
         -------
-        self : object
+        self : IncrementalEmpiricalCovariance
             Returns the instance itself.
         """
         return dispatch(
@@ -302,7 +289,7 @@ class IncrementalEmpiricalCovariance(IntelEstimator, BaseEstimator):
 
     def fit(self, X, y=None):
         """
-        Fit the model with X, using minibatches of size batch_size.
+        Fit the model with X, using minibatches of size ``batch_size``.
 
         Parameters
         ----------
@@ -315,7 +302,7 @@ class IncrementalEmpiricalCovariance(IntelEstimator, BaseEstimator):
 
         Returns
         -------
-        self : object
+        self : IncrementalEmpiricalCovariance
             Returns the instance itself.
         """
 
@@ -334,23 +321,19 @@ class IncrementalEmpiricalCovariance(IntelEstimator, BaseEstimator):
         if hasattr(self, "_onedal_estimator"):
             self._onedal_estimator._reset()
 
-        if sklearn_check_version("1.2"):
-            self._validate_params()
+        use_raw_input = get_config().get("use_raw_input", False) is True
+        if not use_raw_input:
+            if sklearn_check_version("1.2"):
+                self._validate_params()
 
-        # finite check occurs on onedal side
-        if sklearn_check_version("1.0"):
+            # finite check occurs on onedal side
             X = validate_data(
                 self,
                 X,
                 dtype=[np.float64, np.float32],
                 copy=self.copy,
-                force_all_finite=False,
-            )
-        else:
-            X = check_array(
-                X, dtype=[np.float64, np.float32], copy=self.copy, force_all_finite=False
+                ensure_all_finite=False,
             )
-            self.n_features_in_ = X.shape[1]
 
         self.batch_size_ = self.batch_size if self.batch_size else 5 * self.n_features_in_
 
@@ -363,14 +346,13 @@ class IncrementalEmpiricalCovariance(IntelEstimator, BaseEstimator):
             X_batch = X[batch]
             self._onedal_partial_fit(X_batch, queue=queue, check_input=False)
 
-        self._onedal_finalize_fit(queue=queue)
+        self._onedal_finalize_fit()
 
         return self
 
     # expose sklearnex pairwise_distances if mahalanobis distance eventually supported
     def mahalanobis(self, X):
-        if sklearn_check_version("1.0"):
-            self._check_feature_names(X, reset=False)
+        check_feature_names(self, X, reset=False)
 
         xp, _ = get_namespace(X)
         precision = self.get_precision()

{scikit_learn_intelex-2025.2.0.data → scikit_learn_intelex-2025.5.0.data}/data/Lib/site-packages/sklearnex/decomposition/pca.py

@@ -18,6 +18,8 @@ import logging
 
 from daal4py.sklearn._utils import daal_check_version
 
+from .._utils import PatchableEstimator
+
 if daal_check_version((2024, "P", 100)):
     import numbers
     from math import sqrt
@@ -33,6 +35,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
+    from ..utils.validation import validate_data
 
     if sklearn_check_version("1.1") and not sklearn_check_version("1.2"):
         from sklearn.utils import check_scalar
@@ -44,13 +47,8 @@ if daal_check_version((2024, "P", 100)):
 
     from onedal.decomposition import PCA as onedal_PCA
 
-    if sklearn_check_version("1.6"):
-        from sklearn.utils.validation import validate_data
-    else:
-        validate_data = _sklearn_PCA._validate_data
-
     @control_n_jobs(decorated_methods=["fit", "transform", "fit_transform"])
-    class PCA(_sklearn_PCA):
+    class PCA(PatchableEstimator, _sklearn_PCA):
         __doc__ = _sklearn_PCA.__doc__
 
         if sklearn_check_version("1.2"):
@@ -182,18 +180,12 @@ if daal_check_version((2024, "P", 100)):
             )
 
         def _onedal_transform(self, X, queue=None):
-            if sklearn_check_version("1.0"):
-                X = validate_data(
-                    self,
-                    X,
-                    dtype=[np.float64, np.float32],
-                    reset=False,
-                )
-            else:
-                X = check_array(
-                    X,
-                    dtype=[np.float64, np.float32],
-                )
+            X = validate_data(
+                self,
+                X,
+                dtype=[np.float64, np.float32],
+                reset=False,
+            )
             self._validate_n_features_in_after_fitting(X)
 
             return self._onedal_estimator.predict(X, queue=queue)