scikit-learn-intelex 2025.4.0__py310-none-win_amd64.whl → 2025.6.0__py310-none-win_amd64.whl

scikit_learn_intelex-2025.6.0.data/data/Lib/site-packages/sklearnex/_device_offload.py

@@ -0,0 +1,194 @@
+# ==============================================================================
+# Copyright 2021 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.
+# ==============================================================================
+
+from collections.abc import Callable
+from functools import wraps
+from typing import Any, Union
+
+from onedal._device_offload import _copy_to_usm, _transfer_to_host
+from onedal.utils import _sycl_queue_manager as QM
+from onedal.utils._array_api import _asarray, _is_numpy_namespace
+from onedal.utils._dpep_helpers import dpnp_available
+
+if dpnp_available:
+    import dpnp
+    from onedal.utils._array_api import _convert_to_dpnp
+
+from ._config import config_context, get_config, set_config
+from ._utils import PatchingConditionsChain, get_tags
+from .base import oneDALEstimator
+
+
+def _get_backend(
+    obj: type[oneDALEstimator], method_name: str, *data
+) -> tuple[Union[bool, None], PatchingConditionsChain]:
+    """This function verifies the hardware conditions, data characteristics, and
+    estimator parameters necessary for offloading computation to oneDAL. The status
+    of this patching is returned as a PatchingConditionsChain object along with a
+    boolean flag signaling whether the computation can be offloaded to oneDAL or not.
+    It is assumed that the queue (which determined what hardware to possibly use for
+    oneDAL) has been previously and extensively collected (i.e. the data has already
+    been checked using onedal's SyclQueueManager for queues)."""
+    queue = QM.get_global_queue()
+    cpu_device = queue is None or getattr(queue.sycl_device, "is_cpu", True)
+    gpu_device = queue is not None and getattr(queue.sycl_device, "is_gpu", False)
+
+    if cpu_device:
+        patching_status = obj._onedal_cpu_supported(method_name, *data)
+        return patching_status.get_status(), patching_status
+
+    if gpu_device:
+        patching_status = obj._onedal_gpu_supported(method_name, *data)
+        if (
+            not patching_status.get_status()
+            and (config := get_config())["allow_fallback_to_host"]
+        ):
+            QM.fallback_to_host()
+            return None, patching_status
+        return patching_status.get_status(), patching_status
+
+    raise RuntimeError("Device support is not implemented for the supplied data type.")
+
+
+if "array_api_dispatch" in get_config():
+    _array_api_offload = lambda: get_config()["array_api_dispatch"]
+else:
+    _array_api_offload = lambda: False
+
+
+def dispatch(
+    obj: type[oneDALEstimator],
+    method_name: str,
+    branches: dict[Callable, Callable],
+    *args,
+    **kwargs,
+) -> Any:
+    """Dispatch object method call to oneDAL if conditionally possible.
+    Depending on support conditions, oneDAL will be called, otherwise it will
+    fall back to calling scikit-learn.  Dispatching to oneDAL can be influenced
+    by the 'use_raw_input' or 'allow_fallback_to_host' config parameters.
+
+    Parameters
+    ----------
+    obj : object
+        sklearnex object which inherits from oneDALEstimator and contains
+        ``onedal_cpu_supported`` and ``onedal_gpu_supported`` methods which
+        evaluate oneDAL support.
+
+    method_name : string
+        name of method to be evaluated for oneDAL support
+
+    branches : dict
+        dictionary containing functions to be called. Only keys 'sklearn' and
+        'onedal' are used which should contain the relevant scikit-learn and
+        onedal object methods respectively. All functions should accept the
+        inputs from *args and **kwargs. Additionally, the onedal object method
+        must accept a 'queue' keyword.
+
+    *args : tuple
+        arguments to be supplied to the dispatched method
+
+    **kwargs : dict
+        keyword arguments to be supplied to the dispatched method
+
+    Returns
+    -------
+    unknown : object
+        Returned object dependent on the supplied branches. Implicitly the returned
+        object types should match for the sklearn and onedal object methods.
+    """
+
+    if get_config()["use_raw_input"]:
+        return branches["onedal"](obj, *args, **kwargs)
+
+    # Determine if array_api dispatching is enabled, and if estimator is capable
+    onedal_array_api = _array_api_offload() and get_tags(obj).onedal_array_api
+    sklearn_array_api = _array_api_offload() and get_tags(obj).array_api_support
+
+    # backend can only be a boolean or None, None signifies an unverified backend
+    backend: "bool | None" = None
+
+    # config context needs to be saved, as the sycl_queue_manager interacts with
+    # target_offload, which can regenerate a GPU queue later on. Therefore if a
+    # fallback occurs, then the state of target_offload must be set to default
+    # so that later use of get_global_queue only sends to host. We must modify
+    # the target offload settings, but we must also set the original value at the
+    # end, hence the need of a contextmanager.
+    with QM.manage_global_queue(None, *args):
+        if onedal_array_api:
+            backend, patching_status = _get_backend(obj, method_name, *args)
+            if backend:
+                queue = QM.get_global_queue()
+                patching_status.write_log(queue=queue, transferred_to_host=False)
+                return branches["onedal"](obj, *args, **kwargs, queue=queue)
+            elif sklearn_array_api and backend is False:
+                patching_status.write_log(transferred_to_host=False)
+                return branches["sklearn"](obj, *args, **kwargs)
+
+        # move data to host because of multiple reasons: array_api fallback to host,
+        # non array_api supporing oneDAL code, issues with usm support in sklearn.
+        has_usm_data_for_args, hostargs = _transfer_to_host(*args)
+        has_usm_data_for_kwargs, hostvalues = _transfer_to_host(*kwargs.values())
+
+        hostkwargs = dict(zip(kwargs.keys(), hostvalues))
+        has_usm_data = has_usm_data_for_args or has_usm_data_for_kwargs
+
+        while backend is None:
+            backend, patching_status = _get_backend(obj, method_name, *hostargs)
+
+        if backend:
+            queue = QM.get_global_queue()
+            patching_status.write_log(queue=queue, transferred_to_host=False)
+            return branches["onedal"](obj, *hostargs, **hostkwargs, queue=queue)
+        else:
+            if sklearn_array_api and not has_usm_data:
+                # dpnp fallback is not handled properly yet.
+                patching_status.write_log(transferred_to_host=False)
+                return branches["sklearn"](obj, *args, **kwargs)
+            else:
+                patching_status.write_log()
+                return branches["sklearn"](obj, *hostargs, **hostkwargs)
+
+
+def wrap_output_data(func: Callable) -> Callable:
+    """
+    Converts and moves the output arrays of the decorated function
+    to match the input array type and device.
+    """
+
+    @wraps(func)
+    def wrapper(self, *args, **kwargs) -> Any:
+        result = func(self, *args, **kwargs)
+        if not (len(args) == 0 and len(kwargs) == 0):
+            data = (*args, *kwargs.values())
+
+            usm_iface = getattr(data[0], "__sycl_usm_array_interface__", None)
+            if usm_iface is not None:
+                result = _copy_to_usm(usm_iface["syclobj"], result)
+                if dpnp_available and isinstance(data[0], dpnp.ndarray):
+                    result = _convert_to_dpnp(result)
+                return result
+
+            if get_config().get("transform_output") in ("default", None):
+                input_array_api = getattr(data[0], "__array_namespace__", lambda: None)()
+                if input_array_api and not _is_numpy_namespace(input_array_api):
+                    input_array_api_device = data[0].device
+                    result = _asarray(
+                        result, input_array_api, device=input_array_api_device
+                    )
+        return result
+
+    return wrapper

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/_utils.py

@@ -17,6 +17,7 @@
 import logging
 import os
 import re
+import sys
 import warnings
 from abc import ABC
 
@@ -27,16 +28,19 @@ from daal4py.sklearn._utils import (
 )
 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
+# Not an ideal solution, but this allows for access to the outputs of older
+# sklearnex tag dictionaries in a way similar to the sklearn >=1.6 tag
+# dataclasses via duck-typing. At some point this must be removed for direct
+# use of get_tags in all circumstances, dictated by sklearn support. This is
+# implemented in a way to minimally impact performance.
 
-    BaseForHTMLDocLink = _HTMLDocumentationLinkMixin
+
+if sklearn_check_version("1.6"):
+    from sklearn.utils import get_tags
 else:
-    BaseForHTMLDocLink = ABC
+    from sklearn.base import BaseEstimator
+
+    get_tags = lambda obj: type("Tags", (), BaseEstimator._get_tags(obj))
 
 
 class PatchingConditionsChain(daal4py_PatchingConditionsChain):
@@ -51,7 +55,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(
@@ -141,37 +145,26 @@ def register_hyperparameters(hyperparameters_map):
     return decorator
 
 
-# This abstract class is meant to generate a clickable doc link for classses
-# in sklearnex that are not part of base scikit-learn.
-class IntelEstimator(BaseForHTMLDocLink):
-    @property
-    def _doc_link_module(self) -> str:
-        return "sklearnex"
-
-    @property
-    def _doc_link_template(self) -> str:
-        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}"
-
-
-# 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"
+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
+    )

scikit_learn_intelex-2025.6.0.data/data/Lib/site-packages/sklearnex/base.py

@@ -0,0 +1,109 @@
+# ===============================================================================
+# Copyright contributors to the oneDAL project
+#
+# 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.
+# ===============================================================================
+
+from sklearn.base import BaseEstimator
+
+from daal4py.sklearn._utils import sklearn_check_version
+
+if sklearn_check_version("1.6"):
+    from dataclasses import dataclass, fields
+
+    from sklearn.utils import Tags as _sklearn_Tags
+
+    @dataclass
+    class Tags(_sklearn_Tags):
+        onedal_array_api: bool = False
+
+
+class oneDALEstimator:
+    """Inherited class for all oneDAL-based estimators.
+
+    This class must be inherited before any scikit-learn estimator
+    classes (i.e. those which inherit from scikit-learn's BaseEstimator).
+
+    It enables:
+
+      - dispatching to oneDAL
+      - html documentation
+
+    Notes
+    -----
+    Sklearnex-only estimators must inherit this class directly before
+    BaseEstimator in order to properly render documentation.  Other
+    sklearn classes like Mixins can be before this class in the MRO
+    without any impact on functionality.
+    """
+
+    if sklearn_check_version("1.6"):
+        # Starting in sklearn 1.6, _more_tags is deprecated. An oneDALEstimator
+        # is defined to handle the various versioning issues with the tags and
+        # with the ongoing rollout of sklearn's array_api support. This will make
+        # maintenance easier, and centralize tag changes to a single location.
+
+        def __sklearn_tags__(self) -> Tags:
+            # This convention is unnecessarily restrictive with more performant
+            # alternatives but it best follows sklearn. Subclasses will now only need
+            # to set `onedal_array_api` to True to signify gpu zero-copy support
+            # and maintenance is smaller because of underlying sklearn infrastructure
+            sktags = super().__sklearn_tags__()
+            tag_dict = {
+                field.name: getattr(sktags, field.name) for field in fields(sktags)
+            }
+            return Tags(**tag_dict)
+
+    elif sklearn_check_version("1.3"):
+
+        def _more_tags(self) -> dict[bool]:
+            return {"onedal_array_api": False}
+
+    else:
+        # array_api_support tag was added in sklearn 1.3 via scikit-learn/scikit-learn#26372
+        def _more_tags(self) -> dict[bool, bool]:
+            return {"array_api_support": False, "onedal_array_api": False}
+
+    if sklearn_check_version("1.4"):
+
+        @property
+        def _doc_link_module(self) -> str:
+            return "sklearnex"
+
+        def _doc_link_url_param_generator(self, *_) -> dict[str, str]:
+            return {
+                "estimator_module": "sklearn."
+                + self.__class__.__module__.rsplit(".", 2)[-2],
+                "estimator_name": self.__class__.__name__,
+            }
+
+        def _get_doc_link(self) -> str:
+            # This method is meant to generate a clickable doc link for classses
+            # in sklearnex including those that are not part of base scikit-learn.
+            # It should be inherited before inheriting from a scikit-learn estimator.
+
+            mro = self.__class__.__mro__
+            # The next object in the Estimators MRO after oneDALEstimator should be
+            # the equivalent sklearn estimator, if it is BaseEstimator, it is a
+            # sklearnex-only estimator.
+            url = BaseEstimator._get_doc_link(self)
+            if (
+                url
+                and oneDALEstimator in mro
+                and mro[mro.index(oneDALEstimator) + 1] is BaseEstimator
+            ):
+                module_path, _ = self.__class__.__module__.rsplit(".", 1)
+                class_name = self.__class__.__name__
+                url = f"https://uxlfoundation.github.io/scikit-learn-intelex/latest/non-scikit-algorithms.html#{module_path}.{class_name}"
+
+            return url

{scikit_learn_intelex-2025.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/basic_statistics/basic_statistics.py

@@ -25,22 +25,19 @@ 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 PatchingConditionsChain
+from ..base import oneDALEstimator
+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(oneDALEstimator, BaseEstimator):
     """
     Estimator for basic statistics.
     Allows to compute basic statistics for provided data.
@@ -204,16 +201,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 +218,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.4.0.data → scikit_learn_intelex-2025.6.0.data}/data/Lib/site-packages/sklearnex/basic_statistics/incremental_basic_statistics.py

@@ -25,8 +25,11 @@ 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 PatchingConditionsChain, _add_inc_serialization_note
+from ..base import oneDALEstimator
+from ..utils.validation import validate_data
 
 if sklearn_check_version("1.2"):
     from sklearn.utils._param_validation import Interval, StrOptions
@@ -34,14 +37,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(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
@@ -103,18 +101,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 +127,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 +181,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 +220,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 +249,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 +294,7 @@ class IncrementalBasicStatistics(IntelEstimator, BaseEstimator):
 
         Returns
         -------
-        self : object
+        self : IncrementalBasicStatistics
             Returns the instance itself.
         """
         dispatch(
@@ -320,7 +311,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 +327,7 @@ class IncrementalBasicStatistics(IntelEstimator, BaseEstimator):
 
         Returns
         -------
-        self : object
+        self : IncrementalBasicStatistics
             Returns the instance itself.
         """
         dispatch(