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

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/basic_statistics/basic_statistics.py

@@ -16,35 +16,36 @@
 
 import warnings
 
-import numpy as np
 from scipy.sparse import issparse
 from sklearn.base import BaseEstimator
-from sklearn.utils import check_array
-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.validation import _is_csr
 
+from .._config import get_config
 from .._device_offload import dispatch
 from .._utils import PatchingConditionsChain
 from ..base import oneDALEstimator
-from ..utils.validation import validate_data
+from ..utils._array_api import enable_array_api, get_namespace
+from ..utils.validation import _check_sample_weight, validate_data
 
 if sklearn_check_version("1.2"):
     from sklearn.utils._param_validation import StrOptions
 
 
+@enable_array_api
 @control_n_jobs(decorated_methods=["fit"])
 class BasicStatistics(oneDALEstimator, BaseEstimator):
     """
     Estimator for basic statistics.
-    Allows to compute basic statistics for provided data.
+
+    Compute low order moments and related statistics for given data.
 
     Parameters
     ----------
-    result_options: string or list, default='all'
+    result_options : str or list, default=str('all')
         Used to set statistics to calculate. Possible values are ``'min'``, ``'max'``, ``'sum'``, ``'mean'``, ``'variance'``,
         ``'variation'``, ``sum_squares'``, ``sum_squares_centered'``, ``'standard_deviation'``, ``'second_order_raw_moment'``
         or a list containing any of these values. If set to ``'all'`` then all possible statistics will be
@@ -73,17 +74,13 @@ class BasicStatistics(oneDALEstimator, BaseEstimator):
         second_order_raw_moment_ : ndarray of shape (n_features,)
             Second order moment of each feature over all samples.
 
-    Note
-    ----
+    Notes
+    -----
     Attribute exists only if corresponding result option has been provided.
 
-    Note
-    ----
     Names of attributes without the trailing underscore are
     supported currently but deprecated in 2025.1 and will be removed in 2026.0
 
-    Note
-    ----
     Some results can exhibit small variations due to
     floating point error accumulation and multithreading.
 
@@ -129,30 +126,16 @@ class BasicStatistics(oneDALEstimator, BaseEstimator):
 
     def _save_attributes(self):
         assert hasattr(self, "_onedal_estimator")
-
-        if self.result_options == "all":
-            result_options = onedal_BasicStatistics.get_all_result_options()
-        else:
-            result_options = self.result_options
-
-        if isinstance(result_options, str):
-            setattr(
-                self,
-                result_options + "_",
-                getattr(self._onedal_estimator, result_options),
-            )
-        elif isinstance(result_options, list):
-            for option in result_options:
-                setattr(self, option + "_", getattr(self._onedal_estimator, option))
+        for option in self._onedal_estimator.options:
+            option += "_"
+            setattr(self, option, getattr(self._onedal_estimator, option))
 
     def __getattr__(self, attr):
-        if self.result_options == "all":
-            result_options = onedal_BasicStatistics.get_all_result_options()
-        else:
-            result_options = self.result_options
         is_deprecated_attr = (
-            isinstance(result_options, str) and (attr == result_options)
-        ) or (isinstance(result_options, list) and (attr in result_options))
+            attr in self._onedal_estimator.options
+            if "_onedal_estimator" in self.__dict__
+            else False
+        )
         if is_deprecated_attr:
             warnings.warn(
                 "Result attributes without a trailing underscore were deprecated in version 2025.1 and will be removed in 2026.0"
@@ -198,19 +181,20 @@ class BasicStatistics(oneDALEstimator, BaseEstimator):
         return patching_status
 
     def _onedal_fit(self, X, sample_weight=None, queue=None):
-        if sklearn_check_version("1.2"):
-            self._validate_params()
-
-        X = validate_data(
-            self,
-            X,
-            dtype=[np.float64, np.float32],
-            ensure_2d=False,
-            accept_sparse="csr",
-        )
+        if not get_config()["use_raw_input"]:
+            xp, _ = get_namespace(X, sample_weight)
+            X = validate_data(
+                self,
+                X,
+                dtype=[xp.float64, xp.float32],
+                ensure_2d=False,
+                accept_sparse="csr",
+            )
 
-        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, dtype=[xp.float64, xp.float32]
+                )
 
         onedal_params = {
             "result_options": self.result_options,
@@ -242,6 +226,8 @@ class BasicStatistics(oneDALEstimator, BaseEstimator):
         self : object
             Returns the instance itself.
         """
+        if sklearn_check_version("1.2"):
+            self._validate_params()
         dispatch(
             self,
             "fit",

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/basic_statistics/incremental_basic_statistics.py

@@ -14,10 +14,8 @@
 # limitations under the License.
 # ==============================================================================
 
-import numpy as np
 from sklearn.base import BaseEstimator
-from sklearn.utils import check_array, gen_batches
-from sklearn.utils.validation import _check_sample_weight
+from sklearn.utils import gen_batches
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import sklearn_check_version
@@ -29,7 +27,8 @@ from .._config import get_config
 from .._device_offload import dispatch
 from .._utils import PatchingConditionsChain, _add_inc_serialization_note
 from ..base import oneDALEstimator
-from ..utils.validation import validate_data
+from ..utils._array_api import enable_array_api, get_namespace
+from ..utils.validation import _check_sample_weight, validate_data
 
 if sklearn_check_version("1.2"):
     from sklearn.utils._param_validation import Interval, StrOptions
@@ -38,17 +37,21 @@ import numbers
 import warnings
 
 
+@enable_array_api
 @control_n_jobs(decorated_methods=["partial_fit", "_onedal_finalize_fit"])
 class IncrementalBasicStatistics(oneDALEstimator, 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
-    the entire dataset.
+    Incremental estimator for basic statistics.
+
+    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 the entire dataset.
 
     Parameters
     ----------
-    result_options: string or list, default='all'
-        List of statistics to compute
+    result_options : str or list, default=str('all')
+        List of statistics to compute.
 
     batch_size : int, default=None
         The number of samples to use for each batch. Only used when calling
@@ -88,8 +91,9 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
             Second order moment of each feature over all samples.
 
         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.
+            The number of samples processed by the estimator. Will be reset
+            on new calls to ``fit``, but increments across ``partial_fit``
+            calls.
 
         batch_size_ : int
             Inferred batch size from ``batch_size``.
@@ -97,14 +101,14 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
         n_features_in_ : int
             Number of features seen during ``fit`` or  ``partial_fit``.
 
-    Note
-    ----
+    Notes
+    -----
     Attribute exists only if corresponding result option has been provided.
 
-    Note
-    ----
-    Names of attributes without the trailing underscore are
-    supported currently but deprecated in 2025.1 and will be removed in 2026.0
+    Names of attributes without the trailing underscore are supported
+    currently but deprecated in 2025.1 and will be removed in 2026.0.
+
+    Sparse data formats are not supported. Input dtype must be ``float32`` or ``float64``.
 
     %incremental_serialization_note%
 
@@ -155,12 +159,7 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
         }
 
     def __init__(self, result_options="all", batch_size=None):
-        if result_options == "all":
-            self.result_options = (
-                self._onedal_incremental_basic_statistics.get_all_result_options()
-            )
-        else:
-            self.result_options = result_options
+        self.result_options = result_options
         self._need_to_finalize = False
         self.batch_size = batch_size
 
@@ -173,15 +172,7 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
     _onedal_cpu_supported = _onedal_supported
     _onedal_gpu_supported = _onedal_supported
 
-    def _get_onedal_result_options(self, options):
-        if isinstance(options, list):
-            onedal_options = "|".join(self.result_options)
-        else:
-            onedal_options = options
-        assert isinstance(onedal_options, str)
-        return options
-
-    def _onedal_finalize_fit(self):
+    def _onedal_finalize_fit(self, queue=None):
         assert hasattr(self, "_onedal_estimator")
         self._onedal_estimator.finalize_fit()
         self._need_to_finalize = False
@@ -189,19 +180,20 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
     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 check_input and not get_config()["use_raw_input"]:
+            xp, _ = get_namespace(X)
             X = validate_data(
                 self,
                 X,
-                dtype=[np.float64, np.float32],
+                dtype=[xp.float64, xp.float32],
                 reset=first_pass,
             )
 
-        if not use_raw_input and 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, dtype=[xp.float64, xp.float32]
+                )
 
         if first_pass:
             self.n_samples_seen_ = X.shape[0]
@@ -209,28 +201,25 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
         else:
             self.n_samples_seen_ += X.shape[0]
 
-        onedal_params = {
-            "result_options": self._get_onedal_result_options(self.result_options)
-        }
         if not hasattr(self, "_onedal_estimator"):
             self._onedal_estimator = self._onedal_incremental_basic_statistics(
-                **onedal_params
+                result_options=self.result_options
             )
-        self._onedal_estimator.partial_fit(X, weights=sample_weight, queue=queue)
+
+        self._onedal_estimator.partial_fit(X, sample_weight=sample_weight, queue=queue)
         self._need_to_finalize = True
 
     def _onedal_fit(self, X, sample_weight=None, queue=None):
-        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()
-
-            X = validate_data(self, X, dtype=[np.float64, np.float32])
+        if not get_config()["use_raw_input"]:
+            xp, _ = get_namespace(X, sample_weight)
+            X = validate_data(self, X, dtype=[xp.float64, xp.float32])
 
             if sample_weight is not None:
-                sample_weight = _check_sample_weight(sample_weight, X)
+                sample_weight = _check_sample_weight(
+                    sample_weight, X, dtype=[xp.float64, xp.float32]
+                )
 
-        n_samples, n_features = X.shape
+        _, n_features = X.shape
         if self.batch_size is None:
             self.batch_size_ = 5 * n_features
         else:
@@ -254,11 +243,12 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
         return self
 
     def __getattr__(self, attr):
-        result_options = self.__dict__["result_options"]
         sattr = attr.removesuffix("_")
         is_statistic_attr = (
-            isinstance(result_options, str) and (sattr == result_options)
-        ) or (isinstance(result_options, list) and (sattr in result_options))
+            sattr in self._onedal_estimator.options
+            if "_onedal_estimator" in self.__dict__
+            else False
+        )
         if is_statistic_attr:
             if self._need_to_finalize:
                 self._onedal_finalize_fit()
@@ -266,7 +256,8 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
                 warnings.warn(
                     "Result attributes without a trailing underscore were deprecated in version 2025.1 and will be removed in 2026.0"
                 )
-            return getattr(self._onedal_estimator, sattr)
+                attr += "_"
+            return getattr(self._onedal_estimator, attr)
         if attr in self.__dict__:
             return self.__dict__[attr]
 
@@ -297,6 +288,8 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
         self : IncrementalBasicStatistics
             Returns the instance itself.
         """
+        if sklearn_check_version("1.2") and check_input:
+            self._validate_params()
         dispatch(
             self,
             "partial_fit",
@@ -330,6 +323,8 @@ class IncrementalBasicStatistics(oneDALEstimator, BaseEstimator):
         self : IncrementalBasicStatistics
             Returns the instance itself.
         """
+        if sklearn_check_version("1.2"):
+            self._validate_params()
         dispatch(
             self,
             "fit",

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/cluster/dbscan.py

@@ -14,42 +14,30 @@
 # limitations under the License.
 # ===============================================================================
 
-import numbers
-from abc import ABC
-
 from scipy import sparse as sp
 from sklearn.cluster import DBSCAN as _sklearn_DBSCAN
-from sklearn.utils.validation import _check_sample_weight
 
 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 onedal.utils._array_api import _is_numpy_namespace
 
 from .._config import get_config
 from .._device_offload import dispatch
 from .._utils import PatchingConditionsChain
 from ..base import oneDALEstimator
-from ..utils.validation import validate_data
+from ..utils._array_api import enable_array_api, get_namespace
+from ..utils.validation import _check_sample_weight, validate_data
 
 if sklearn_check_version("1.1") and not sklearn_check_version("1.2"):
-    from sklearn.utils import check_scalar
-
-
-class BaseDBSCAN(oneDALEstimator):
-    def _onedal_dbscan(self, **onedal_params):
-        return onedal_DBSCAN(**onedal_params)
+    import numbers
 
-    def _save_attributes(self):
-        assert hasattr(self, "_onedal_estimator")
-
-        self.labels_ = self._onedal_estimator.labels_
-        self.core_sample_indices_ = self._onedal_estimator.core_sample_indices_
-        self.components_ = self._onedal_estimator.components_
-        self.n_features_in_ = self._onedal_estimator.n_features_in_
+    from sklearn.utils import check_scalar
 
 
+@enable_array_api
 @control_n_jobs(decorated_methods=["fit"])
-class DBSCAN(BaseDBSCAN, _sklearn_DBSCAN):
+class DBSCAN(oneDALEstimator, _sklearn_DBSCAN):
     __doc__ = _sklearn_DBSCAN.__doc__
 
     if sklearn_check_version("1.2"):
@@ -86,9 +74,18 @@ class DBSCAN(BaseDBSCAN, _sklearn_DBSCAN):
         self.p = p
         self.n_jobs = n_jobs
 
+    _onedal_dbscan = staticmethod(onedal_DBSCAN)
+
     def _onedal_fit(self, X, y, sample_weight=None, queue=None):
-        if get_config()["use_raw_input"] is False:
-            X = validate_data(self, X, ensure_all_finite=False)
+        xp, _ = get_namespace(X, y, sample_weight)
+        if not get_config()["use_raw_input"]:
+            X = validate_data(
+                self, X, accept_sparse="csr", dtype=[xp.float64, xp.float32]
+            )
+            if sample_weight is not None:
+                sample_weight = _check_sample_weight(
+                    sample_weight, X, dtype=[xp.float64, xp.float32]
+                )
 
         onedal_params = {
             "eps": self.eps,
@@ -103,7 +100,17 @@ class DBSCAN(BaseDBSCAN, _sklearn_DBSCAN):
         self._onedal_estimator = self._onedal_dbscan(**onedal_params)
 
         self._onedal_estimator.fit(X, y=y, sample_weight=sample_weight, queue=queue)
-        self._save_attributes()
+        if self._onedal_estimator.core_sample_indices_ is None:
+            kwargs = {"dtype": xp.int32}  # always the same
+            if not _is_numpy_namespace(xp):
+                kwargs["device"] = X.device
+            self.core_sample_indices_ = xp.empty((0,), **kwargs)
+        else:
+            self.core_sample_indices_ = self._onedal_estimator.core_sample_indices_
+
+        self.components_ = xp.take(X, self.core_sample_indices_, axis=0)
+        self.labels_ = self._onedal_estimator.labels_
+        self.n_features_in_ = X.shape[1]
 
     def _onedal_supported(self, method_name, *data):
         class_name = self.__class__.__name__
@@ -111,7 +118,7 @@ class DBSCAN(BaseDBSCAN, _sklearn_DBSCAN):
             f"sklearn.cluster.{class_name}.{method_name}"
         )
         if method_name == "fit":
-            X, y, sample_weight = data
+            X = data[0]
             patching_status.and_conditions(
                 [
                     (
@@ -175,10 +182,6 @@ class DBSCAN(BaseDBSCAN, _sklearn_DBSCAN):
         else:
             if self.eps <= 0.0:
                 raise ValueError(f"eps == {self.eps}, must be > 0.0.")
-
-        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,
             "fit",

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/cluster/k_means.py

@@ -334,6 +334,7 @@ if daal_check_version((2023, "P", 200)):
             return X
 
         _transform = support_input_format(_sklearn_KMeans._transform)
+        transform = support_input_format(_sklearn_KMeans.transform)
 
         @wrap_output_data
         def score(self, X, y=None, sample_weight=None):

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/covariance/incremental_covariance.py

@@ -27,6 +27,7 @@ from sklearn.utils.validation import _num_features, check_is_fitted
 
 from daal4py.sklearn._n_jobs_support import control_n_jobs
 from daal4py.sklearn._utils import daal_check_version, sklearn_check_version
+from onedal._device_offload import support_sycl_format
 from onedal.covariance import (
     IncrementalEmpiricalCovariance as onedal_IncrementalEmpiricalCovariance,
 )
@@ -52,9 +53,12 @@ if sklearn_check_version("1.2"):
 @control_n_jobs(decorated_methods=["partial_fit", "fit", "_onedal_finalize_fit"])
 class IncrementalEmpiricalCovariance(oneDALEstimator, 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
-    the entire dataset.
+    Incremental maximum likelihood covariance estimator.
+
+    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
     ----------
@@ -70,8 +74,8 @@ class IncrementalEmpiricalCovariance(oneDALEstimator, BaseEstimator):
     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``, to provide
+        a balance between approximation accuracy and memory consumption.
 
     copy : bool, default=True
         If False, X will be overwritten. ``copy=False`` can be used to
@@ -95,6 +99,10 @@ class IncrementalEmpiricalCovariance(oneDALEstimator, BaseEstimator):
     n_features_in_ : int
         Number of features seen during ``fit`` or ``partial_fit``.
 
+    Notes
+    -----
+    Sparse data formats are not supported. Input dtype must be ``float32`` or ``float64``.
+
     %incremental_serialization_note%
 
     Examples
@@ -224,6 +232,7 @@ class IncrementalEmpiricalCovariance(oneDALEstimator, BaseEstimator):
         return self
 
     @wrap_output_data
+    @support_sycl_format
     def score(self, X_test, y=None):
         xp, _ = get_namespace(X_test)
 

{scikit_learn_intelex-2025.6.1.data → scikit_learn_intelex-2025.8.0.data}/data/Lib/site-packages/sklearnex/decomposition/pca.py

@@ -31,7 +31,7 @@ if daal_check_version((2024, "P", 100)):
     from daal4py.sklearn._utils import sklearn_check_version
 
     from .._device_offload import dispatch, wrap_output_data
-    from .._utils import PatchingConditionsChain
+    from .._utils import PatchingConditionsChain, register_hyperparameters
     from ..base import oneDALEstimator
     from ..utils._array_api import get_namespace
     from ..utils.validation import validate_data
@@ -44,8 +44,11 @@ if daal_check_version((2024, "P", 100)):
 
     from sklearn.decomposition import PCA as _sklearn_PCA
 
+    from onedal._device_offload import support_sycl_format
     from onedal.decomposition import PCA as onedal_PCA
+    from onedal.utils._array_api import _is_numpy_namespace
 
+    @register_hyperparameters({"fit": ("pca", "train")})
     @control_n_jobs(decorated_methods=["fit", "transform", "fit_transform"])
     class PCA(oneDALEstimator, _sklearn_PCA):
         __doc__ = _sklearn_PCA.__doc__
@@ -108,6 +111,10 @@ if daal_check_version((2024, "P", 100)):
                 self.iterated_power = iterated_power
                 self.random_state = random_state
 
+        # guarantee operability with dpnp/dpctl, runs on CPU unless
+        # array_api_dispatch is enabled.
+        score_samples = support_sycl_format(_sklearn_PCA.score_samples)
+
         def fit(self, X, y=None):
             self._fit(X)
             return self
@@ -212,9 +219,17 @@ 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)
+            # sklearn does not properly input check inverse_transform using
+            # ``validate_data`` (as of sklearn 1.7). Yielding the namespace
+            # in this way will conform to sklearn and various inputs without
+            # causing issues with dimensionality checks, array api support,
+            # etc. evaluated in ``validate_data``. This is a special solution.
+            xp = (
+                func()
+                if (func := getattr(X, "__array_namespace__", None))
+                else get_namespace(X)[0]
+            )
 
             mean = self.mean_
             if self.whiten:
@@ -224,12 +239,8 @@ if daal_check_version((2024, "P", 100)):
             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).
+            if not _is_numpy_namespace(xp):
+                # Force matching type to input data if possible
                 components = xp.asarray(components, device=X.device)
                 mean = xp.asarray(mean, device=X.device)
 
@@ -407,6 +418,7 @@ if daal_check_version((2024, "P", 100)):
         transform.__doc__ = _sklearn_PCA.transform.__doc__
         fit_transform.__doc__ = _sklearn_PCA.fit_transform.__doc__
         inverse_transform.__doc__ = _sklearn_PCA.inverse_transform.__doc__
+        score_samples.__doc__ = _sklearn_PCA.score_samples.__doc__
 
 else:
     from daal4py.sklearn.decomposition import PCA