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

scikit_learn_intelex-2025.9.0.data/data/Lib/site-packages/sklearnex/preview/covariance/covariance.py

@@ -0,0 +1,260 @@
+# ===============================================================================
+# Copyright 2023 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ===============================================================================
+
+import warnings
+from functools import partial
+
+import numpy as np
+import scipy.sparse as sp
+from sklearn.base import clone
+from sklearn.covariance import EmpiricalCovariance as _sklearn_EmpiricalCovariance
+from sklearn.utils.validation import check_array, 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 daal4py.sklearn.metrics import pairwise_distances
+from onedal._device_offload import support_input_format, support_sycl_format
+from onedal.covariance import EmpiricalCovariance as onedal_EmpiricalCovariance
+from onedal.utils._array_api import _is_numpy_namespace
+from sklearnex import config_context
+
+from ..._config import get_config
+from ..._device_offload import dispatch, wrap_output_data
+from ..._utils import PatchingConditionsChain, register_hyperparameters
+from ...base import oneDALEstimator
+from ...utils._array_api import _pinvh, enable_array_api, get_namespace, log_likelihood
+from ...utils.validation import assert_all_finite, validate_data
+
+# This is a temporary workaround for issues with sklearnex._device_offload._get_host_inputs
+# passing kwargs with sycl queues with other host data will cause failures
+_mahalanobis = support_input_format(partial(pairwise_distances, metric="mahalanobis"))
+
+
+@enable_array_api
+@register_hyperparameters({"fit": ("covariance", "compute")})
+@control_n_jobs(decorated_methods=["fit", "mahalanobis"])
+class EmpiricalCovariance(oneDALEstimator, _sklearn_EmpiricalCovariance):
+    __doc__ = _sklearn_EmpiricalCovariance.__doc__
+
+    if sklearn_check_version("1.2"):
+        _parameter_constraints: dict = {
+            **_sklearn_EmpiricalCovariance._parameter_constraints,
+        }
+
+    def _set_covariance(self, covariance):
+        if not get_config()["use_raw_input"]:
+            if sklearn_check_version("1.6"):
+                covariance = check_array(covariance, ensure_all_finite=False)
+            else:
+                covariance = check_array(covariance, force_all_finite=False)
+            assert_all_finite(covariance)
+        # set covariance
+        self.covariance_ = covariance
+        # set precision
+        if self.store_precision:
+            self.precision_ = _pinvh(covariance, check_finite=False)
+        else:
+            self.precision_ = None
+
+    def _save_attributes(self):
+        assert hasattr(self, "_onedal_estimator")
+        if not daal_check_version((2024, "P", 400)) and self.assume_centered:
+            xp, _ = get_namespace(self._onedal_estimator.location_)
+            location = self._onedal_estimator.location_[None, :]
+            self._onedal_estimator.covariance_ += xp.dot(location.T, location)
+            self._onedal_estimator.location_ = xp.zeros_like(
+                self._onedal_estimator.location_
+            )
+        self._set_covariance(self._onedal_estimator.covariance_)
+        self.location_ = self._onedal_estimator.location_
+
+    _onedal_covariance = staticmethod(onedal_EmpiricalCovariance)
+
+    def _onedal_fit(self, X, queue=None):
+        if not get_config()["use_raw_input"]:
+            xp, _ = get_namespace(X)
+            X = validate_data(self, X, dtype=[xp.float64, xp.float32])
+
+        if X.shape[0] == 1:
+            warnings.warn(
+                "Only one sample available. You may want to reshape your data array"
+            )
+
+        self._onedal_estimator = self._onedal_covariance(
+            method="dense", bias=True, assume_centered=self.assume_centered
+        )
+        self._onedal_estimator.fit(X, queue=queue)
+        self._save_attributes()
+
+    def _onedal_supported(self, method_name, *data):
+        class_name = self.__class__.__name__
+        patching_status = PatchingConditionsChain(
+            f"sklearn.covariance.{class_name}.{method_name}"
+        )
+        if method_name in ["fit", "mahalanobis"]:
+            (X,) = data
+            patching_status.and_conditions(
+                [
+                    (not sp.issparse(X), "X is sparse. Sparse input is not supported."),
+                ]
+            )
+            return patching_status
+        raise RuntimeError(f"Unknown method {method_name} in {self.__class__.__name__}")
+
+    _onedal_cpu_supported = _onedal_supported
+    _onedal_gpu_supported = _onedal_supported
+
+    def get_precision(self):
+        # use array API-enabled version
+        if self.store_precision:
+            precision = self.precision_
+        else:
+            precision = _pinvh(self.covariance_, check_finite=False)
+        return precision
+
+    def fit(self, X, y=None):
+        if sklearn_check_version("1.2"):
+            self._validate_params()
+        dispatch(
+            self,
+            "fit",
+            {
+                "onedal": self.__class__._onedal_fit,
+                "sklearn": _sklearn_EmpiricalCovariance.fit,
+            },
+            X,
+        )
+
+        return self
+
+    @wrap_output_data
+    @support_sycl_format
+    def score(self, X_test, y=None):
+
+        check_is_fitted(self)
+        # Only covariance evaluated for get_namespace due to dpnp/dpctl
+        # support without array_api_dispatch
+        xp, _ = get_namespace(X_test, self.covariance_)
+
+        X = validate_data(
+            self,
+            X_test,
+            dtype=[xp.float64, xp.float32],
+            reset=False,
+        )
+
+        location = self.location_
+        precision = self.get_precision()
+
+        est = clone(self)
+        est.set_params(assume_centered=True)
+
+        # test_cov is a numpy array, but calculated on device
+        test_cov = est.fit(X - self.location_).covariance_
+        if not _is_numpy_namespace(xp):
+            test_cov = xp.asarray(test_cov, device=X.device)
+        res = log_likelihood(test_cov, self.get_precision())
+
+        return res
+
+    @wrap_output_data
+    @support_sycl_format
+    def error_norm(self, comp_cov, norm="frobenius", scaling=True, squared=True):
+        # equivalent to the sklearn implementation but written for array API
+        # in the case of numpy-like inputs it will use sklearn's version instead.
+        # This can be deprecated if/when sklearn makes the equivalent array API enabled.
+        # This includes a validate_data call and an unusual call to get_namespace in
+        # order to also support dpnp/dpctl without array_api_dispatch.
+        check_is_fitted(self)
+        # Only covariance evaluated for get_namespace due to dpnp/dpctl
+        # support without array_api_dispatch
+        xp, _ = get_namespace(comp_cov, self.covariance_)
+        c_cov = validate_data(
+            self,
+            comp_cov,
+            dtype=[xp.float64, xp.float32],
+            reset=False,
+        )
+
+        if _is_numpy_namespace(xp):
+            # must be done this way is it does not inherit from sklearn
+            return _sklearn_EmpiricalCovariance.error_norm(
+                self, c_cov, norm=norm, scaling=scaling, squared=squared
+            )
+
+        # compute the error
+        error = c_cov - self.covariance_
+        # compute the error norm
+        if norm == "frobenius":
+            squared_norm = xp.matmul(xp.reshape(error, (-1)), xp.reshape(error, (-1)))
+        elif norm == "spectral":
+            squared_norm = xp.max(xp.linalg.svdvals(xp.matmul(error.T, error)))
+        else:
+            raise NotImplementedError("Only spectral and frobenius norms are implemented")
+        # optionally scale the error norm
+        if scaling:
+            squared_norm = squared_norm / error.shape[0]
+        # finally get either the squared norm or the norm
+        if squared:
+            result = squared_norm
+        else:
+            result = xp.sqrt(squared_norm)
+
+        return result
+
+    # expose sklearnex pairwise_distances if mahalanobis distance eventually supported
+    @support_sycl_format
+    def mahalanobis(self, X):
+        # This must be done as ```support_input_format``` is insufficient for array API
+        # support when attributes are non-numpy.
+        check_is_fitted(self)
+        precision = self.get_precision()
+        loc = self.location_[None, :]
+        xp, _ = get_namespace(X, precision, loc)
+        # do not check dtype, done in pairwise_distances
+        X_in = validate_data(self, X, reset=False)
+
+        if not _is_numpy_namespace(xp) and isinstance(X_in, np.ndarray):
+            # corrects issues with respect to dpnp/dpctl support without array_api_dispatch
+            X_in = X
+            loc = xp.asarray(loc, device=X.device)
+            precision = xp.asarray(precision, device=X.device)
+
+        with config_context(assume_finite=True):
+            try:
+                dist = _mahalanobis(X_in, loc, VI=precision)
+
+            except ValueError as e:
+                # Throw the expected sklearn error in an n_feature length violation
+                if "Incompatible dimension for X and Y matrices: X.shape[1] ==" in str(e):
+                    raise ValueError(
+                        f"X has {_num_features(X)} features, but {self.__class__.__name__} "
+                        f"is expecting {self.n_features_in_} features as input."
+                    ) from None
+                else:
+                    raise e
+
+        if not _is_numpy_namespace(xp):
+            dist = xp.asarray(dist, device=X.device)
+
+        return (xp.reshape(dist, (-1,))) ** 2
+
+    fit.__doc__ = _sklearn_EmpiricalCovariance.fit.__doc__
+    mahalanobis.__doc__ = _sklearn_EmpiricalCovariance.mahalanobis.__doc__
+    error_norm.__doc__ = _sklearn_EmpiricalCovariance.error_norm.__doc__
+    score.__doc__ = _sklearn_EmpiricalCovariance.score.__doc__
+    get_precision.__doc__ = _sklearn_EmpiricalCovariance.get_precision.__doc__
+    _set_covariance.__doc__ = _sklearn_EmpiricalCovariance._set_covariance.__doc__

scikit_learn_intelex-2025.9.0.data/data/Lib/site-packages/sklearnex/preview/decomposition/incremental_pca.py

@@ -0,0 +1,406 @@
+# ===============================================================================
+# Copyright 2024 Intel Corporation
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+# ===============================================================================
+
+import numpy as np
+import scipy.sparse as sp
+from sklearn.decomposition import IncrementalPCA as _sklearn_IncrementalPCA
+from sklearn.utils import check_array, gen_batches
+from sklearn.utils.validation import check_is_fitted
+
+from daal4py.sklearn._n_jobs_support import control_n_jobs
+from daal4py.sklearn._utils import sklearn_check_version
+from onedal.decomposition import IncrementalPCA as onedal_IncrementalPCA
+
+from ..._config import get_config
+from ..._device_offload import dispatch, wrap_output_data
+from ..._utils import PatchingConditionsChain, _add_inc_serialization_note
+from ...base import oneDALEstimator
+from ...utils._array_api import enable_array_api, get_namespace
+from ...utils.validation import validate_data
+
+if sklearn_check_version("1.2"):
+    from sklearn.utils._param_validation import StrOptions
+
+
+@enable_array_api
+@control_n_jobs(
+    decorated_methods=["fit", "partial_fit", "transform", "_onedal_finalize_fit"]
+)
+class IncrementalPCA(oneDALEstimator, _sklearn_IncrementalPCA):
+    __doc__ = _sklearn_IncrementalPCA.__doc__
+
+    if sklearn_check_version("1.2"):
+        _parameter_constraints: dict = {
+            **_sklearn_IncrementalPCA._parameter_constraints,
+            "svd_solver": [StrOptions({"auto", "covariance_eigh", "onedal_svd"})],
+        }
+
+    def __init__(
+        self,
+        n_components=None,
+        *,
+        whiten=False,
+        copy=True,
+        batch_size=None,
+        svd_solver="auto",
+    ):
+        super().__init__(
+            n_components=n_components, whiten=whiten, copy=copy, batch_size=batch_size
+        )
+        self.svd_solver = svd_solver
+        self._need_to_finalize = False
+        # Note: use of the onedal_svd solver will cause partial result to grow proportionally
+        # to the input data and for that reason is not the default, which is contrary
+        # to the scikit-learn implementation.
+
+    _onedal_incremental_pca = staticmethod(onedal_IncrementalPCA)
+
+    def _set_n_components(self, n_components, n_samples, n_features, first_pass):
+        # extracted from sklearn's ``IncrementalPCA.partial_fit``. This is a
+        # maintenance burden that cannot be easily separated from sklearn.
+        if n_components is None:
+            if self._components_ is None:
+                self._n_components_ = min(n_samples, n_features)
+            else:
+                self._n_components_ = self.components_.shape[0]
+        elif not 1 <= n_components <= n_features:
+            raise ValueError(
+                "n_components=%r invalid for n_features=%d, need "
+                "more rows than columns for IncrementalPCA "
+                "processing" % (self.n_components, n_features)
+            )
+        elif n_components > n_samples and (
+            not sklearn_check_version("1.6") or first_pass
+        ):
+            raise ValueError(
+                "n_components=%r must be less or equal to "
+                "the batch number of samples "
+                "%d" % (self.n_components, n_samples)
+                + (
+                    " for the first partial_fit call."
+                    if sklearn_check_version("1.6")
+                    else ""
+                )
+            )
+        else:
+            self._n_components_ = n_components
+
+        # the private variables are used to not trigger _onedal_finalize_fit
+        if (self._components_ is not None) and (
+            self._components_.shape[0] != self._n_components_
+        ):
+            raise ValueError(
+                "Number of input features has changed from %i "
+                "to %i between calls to partial_fit! Try "
+                "setting n_components to a fixed value."
+                % (self.components_.shape[0], self.n_components_)
+            )
+
+    def _compute_noise_variance(self, n_sf_min, xp):
+        # generally replicates capability seen in sklearn.PCA._fit_full
+        explained_variance = self._onedal_estimator.explained_variance_
+        if self._n_components_ < n_sf_min:
+            if explained_variance.shape[0] == n_sf_min:
+                return xp.mean(explained_variance[self._n_components_ :])
+            elif explained_variance.shape[0] < n_sf_min:
+                # replicates capability seen in sklearn.PCA._fit_truncated
+                # this is necessary as oneDAL will fit only to self.n_components
+                # which leads to self.explained_variance_ not containing the
+                # full information (and therefore can't replicate
+                # sklearn.PCA._fit_full)
+                resid_var = xp.sum(self._onedal_estimator.var_) - xp.sum(
+                    explained_variance
+                )
+                return resid_var / (n_sf_min - self._n_components_)
+        else:
+            return 0.0
+
+    def _onedal_transform(self, X, queue=None):
+        # does not batch out data like sklearn's ``IncrementalPCA.transform``
+        if self._need_to_finalize:
+            self._onedal_finalize_fit()
+        if not get_config()["use_raw_input"]:
+            xp, _ = get_namespace(X)
+            X = validate_data(self, X, dtype=[xp.float64, xp.float32], reset=False)
+        return self._onedal_estimator.predict(X, queue=queue)
+
+    def _onedal_fit_transform(self, X, queue=None):
+        X = self._onedal_fit(X, queue=queue)
+        return self._onedal_estimator.predict(X, queue=queue)
+
+    def _onedal_partial_fit(self, X, check_input=True, queue=None):
+        first_pass = not hasattr(self, "components_")
+        if first_pass:
+            self._components_ = None
+
+        if check_input:
+            if not get_config()["use_raw_input"]:
+                xp, _ = get_namespace(X)
+                X = validate_data(
+                    self, X, dtype=[xp.float64, xp.float32], reset=first_pass
+                )
+            else:
+                self.n_features_in_ = X.shape[1]
+
+        n_samples, n_features = X.shape
+
+        self._set_n_components(self.n_components, n_samples, n_features, first_pass)
+
+        if not hasattr(self, "n_samples_seen_"):
+            self.n_samples_seen_ = n_samples
+        else:
+            self.n_samples_seen_ += n_samples
+
+        onedal_params = {
+            "n_components": self._n_components_,
+            "whiten": self.whiten,
+            "method": "svd" if self.svd_solver == "onedal_svd" else "cov",
+        }
+
+        if not hasattr(self, "_onedal_estimator"):
+            self._onedal_estimator = self._onedal_incremental_pca(**onedal_params)
+        self._onedal_estimator.partial_fit(X, queue=queue)
+        self._need_to_finalize = True
+
+    def _onedal_finalize_fit(self):
+        assert hasattr(self, "_onedal_estimator")
+        self._onedal_estimator.finalize_fit()
+        xp, _ = get_namespace(
+            self._onedal_estimator.explained_variance_,
+            self._onedal_estimator.singular_values_,
+        )
+
+        # set attributes needed for transform
+        self._mean_ = self._onedal_estimator.mean_
+        self._components_ = self._onedal_estimator.components_
+        # oneDAL PCA eigenvalues are not guaranteed to be >=0 and must be clipped.
+        # This is likely due to accumulated numerical error in the oneDAL calculation.
+        self._explained_variance_ = xp.clip(
+            self._onedal_estimator.explained_variance_, 0.0, None
+        )
+
+        # set other attributes
+        self.singular_values_ = self._onedal_estimator.singular_values_
+        # NOTE: This covers up a numerical accuracy issue in oneDAL online PCA which
+        # can yield NaN values for singular values. Replace in place using array API
+        self.singular_values_[...] = xp.where(
+            xp.isnan(self.singular_values_), 0, self.singular_values_
+        )
+        self.explained_variance_ratio_ = self._onedal_estimator.explained_variance_ratio_
+        self.var_ = self._onedal_estimator.var_
+
+        # calculate the noise variance
+        self.noise_variance_ = self._compute_noise_variance(
+            min(self.n_samples_seen_, self.n_features_in_), xp
+        )
+
+        self._need_to_finalize = False
+
+    def _onedal_fit(self, X, queue=None):
+        # Taken from sklearn for conformance purposes
+        self.components_ = None
+
+        if not get_config()["use_raw_input"]:
+            if sklearn_check_version("1.2"):
+                self._validate_params()
+            xp, _ = get_namespace(X)
+            X = validate_data(self, X, dtype=[xp.float64, xp.float32], copy=self.copy)
+        else:
+            self.n_features_in_ = X.shape[1]
+
+        n_samples, n_features = X.shape
+
+        if self.batch_size is None:
+            self.batch_size_ = 5 * n_features
+        else:
+            self.batch_size_ = self.batch_size
+
+        self.n_samples_seen_ = 0
+        if hasattr(self, "_onedal_estimator"):
+            self._onedal_estimator._reset()
+
+        for batch in gen_batches(
+            n_samples, self.batch_size_, min_batch_size=self.n_components or 0
+        ):
+            X_batch = X[batch, ...]
+            self._onedal_partial_fit(X_batch, queue=queue)
+
+        self._onedal_finalize_fit()
+
+        return X
+
+    def _onedal_cpu_supported(self, method_name, *data):
+        patching_status = PatchingConditionsChain(
+            f"sklearn.decomposition.{self.__class__.__name__}.{method_name}"
+        )
+        X = data[0]
+        if "fit" in method_name:
+            patching_status.and_conditions(
+                [(not sp.issparse(X), "Sparse input is not supported")]
+            )
+        else:
+            patching_status.and_conditions(
+                [
+                    (not sp.issparse(X), "Sparse input is not supported"),
+                    (hasattr(self, "_onedal_estimator"), "oneDAL model was not trained"),
+                ]
+            )
+        return patching_status
+
+    def _onedal_gpu_supported(self, method_name, *data):
+        patching_status = PatchingConditionsChain(
+            f"sklearn.decomposition.{self.__class__.__name__}.{method_name}"
+        )
+        # onedal_svd doesn't exist for GPU
+        X = data[0]
+        if "fit" in method_name:
+            patching_status.and_conditions(
+                [
+                    (not sp.issparse(X), "Sparse input is not supported"),
+                    (self.svd_solver != "onedal_svd", "onedal_svd not supported on GPU"),
+                ]
+            )
+        else:
+            patching_status.and_conditions(
+                [
+                    (not sp.issparse(X), "Sparse input is not supported"),
+                    (hasattr(self, "_onedal_estimator"), "oneDAL model was not trained"),
+                ]
+            )
+        return patching_status
+
+    def partial_fit(self, X, y=None, check_input=True):
+        if sklearn_check_version("1.2") and check_input:
+            self._validate_params()
+
+        dispatch(
+            self,
+            "partial_fit",
+            {
+                "onedal": self.__class__._onedal_partial_fit,
+                "sklearn": _sklearn_IncrementalPCA.partial_fit,
+            },
+            X,
+            check_input=check_input,
+        )
+        return self
+
+    def fit(self, X, y=None):
+        if sklearn_check_version("1.2"):
+            self._validate_params()
+
+        dispatch(
+            self,
+            "fit",
+            {
+                "onedal": self.__class__._onedal_fit,
+                "sklearn": _sklearn_IncrementalPCA.fit,
+            },
+            X,
+        )
+        return self
+
+    @wrap_output_data
+    def transform(self, X):
+        check_is_fitted(self)
+        return dispatch(
+            self,
+            "transform",
+            {
+                "onedal": self.__class__._onedal_transform,
+                "sklearn": _sklearn_IncrementalPCA.transform,
+            },
+            X,
+        )
+
+    @wrap_output_data
+    def fit_transform(self, X, y=None, **fit_params):
+        if sklearn_check_version("1.2"):
+            self._validate_params()
+        return dispatch(
+            self,
+            "fit_transform",
+            {
+                "onedal": self.__class__._onedal_fit_transform,
+                "sklearn": _sklearn_IncrementalPCA.fit_transform,
+            },
+            X,
+        )
+
+    # set properties for deleting the onedal_estimator model if:
+    # n_components_, components_, mean_ or explained_variance_ are
+    # changed. This assists in speeding up multiple uses of onedal
+    # transform as a model must now only be generated once.
+
+    @property
+    def n_components_(self):
+        if hasattr(self, "_onedal_estimator") and self._need_to_finalize:
+            self._onedal_finalize_fit()
+        return self._n_components_
+
+    @n_components_.setter
+    def n_components_(self, value):
+        if hasattr(self, "_onedal_estimator"):
+            self._onedal_estimator.n_components_ = value
+            self._onedal_estimator._onedal_model = None
+        self._n_components_ = value
+
+    @property
+    def components_(self):
+        if hasattr(self, "_onedal_estimator") and self._need_to_finalize:
+            self._onedal_finalize_fit()
+        return self._components_
+
+    @components_.setter
+    def components_(self, value):
+        if hasattr(self, "_onedal_estimator"):
+            self._onedal_estimator.components_ = value
+            self._onedal_estimator._onedal_model = None
+        self._components_ = value
+
+    @property
+    def mean_(self):
+        if hasattr(self, "_onedal_estimator") and self._need_to_finalize:
+            self._onedal_finalize_fit()
+        return self._mean_
+
+    @mean_.setter
+    def mean_(self, value):
+        if hasattr(self, "_onedal_estimator"):
+            self._onedal_estimator.mean_ = value
+            self._onedal_estimator._onedal_model = None
+        self._mean_ = value
+
+    @property
+    def explained_variance_(self):
+        if hasattr(self, "_onedal_estimator") and self._need_to_finalize:
+            self._onedal_finalize_fit()
+        return self._explained_variance_
+
+    @explained_variance_.setter
+    def explained_variance_(self, value):
+        if hasattr(self, "_onedal_estimator"):
+            self._onedal_estimator.explained_variance_ = value
+            self._onedal_estimator._onedal_model = None
+        self._explained_variance_ = value
+
+    __doc__ = _add_inc_serialization_note(
+        _sklearn_IncrementalPCA.__doc__ + "\n" + r"%incremental_serialization_note%"
+    )
+    fit.__doc__ = _sklearn_IncrementalPCA.fit.__doc__
+    fit_transform.__doc__ = _sklearn_IncrementalPCA.fit_transform.__doc__
+    transform.__doc__ = _sklearn_IncrementalPCA.transform.__doc__
+    partial_fit.__doc__ = _sklearn_IncrementalPCA.partial_fit.__doc__