scikit-base 0.10.1__py3-none-any.whl → 0.12.0__py3-none-any.whl

skbase/base/_base.py

@@ -60,6 +60,7 @@ from copy import deepcopy
 from typing import List
 
 from skbase._exceptions import NotFittedError
+from skbase.base._clone_base import _check_clone, _clone
 from skbase.base._pretty_printing._object_html_repr import _object_html_repr
 from skbase.base._tagmanager import _FlagManager
 
@@ -89,10 +90,11 @@ class BaseObject(_FlagManager):
     def __eq__(self, other):
         """Equality dunder. Checks equal class and parameters.
 
-        Returns True iff result of get_params(deep=False)
+        Returns True iff result of ``get_params(deep=False)``
         results in equal parameter sets.
 
-        Nested BaseObject descendants from get_params are compared via __eq__ as well.
+        Nested BaseObject descendants from ``get_params`` are compared via
+        ``__eq__`` as well.
         """
         from skbase.utils.deep_equals import deep_equals
 
@@ -107,24 +109,33 @@ class BaseObject(_FlagManager):
     def reset(self):
         """Reset the object to a clean post-init state.
 
-        Using reset, runs __init__ with current values of hyper-parameters
-        (result of get_params). This Removes any object attributes, except:
+        Results in setting ``self`` to the state it had directly
+        after the constructor call, with the same hyper-parameters.
+        Config values set by ``set_config`` are also retained.
 
-            - hyper-parameters = arguments of __init__
-            - object attributes containing double-underscores, i.e., the string "__"
+        A ``reset`` call deletes any object attributes, except:
+
+        - hyper-parameters = arguments of ``__init__`` written to ``self``,
+          e.g., ``self.paramname`` where ``paramname`` is an argument of ``__init__``
+        - object attributes containing double-underscores, i.e., the string "__".
+          For instance, an attribute named "__myattr" is retained.
+        - config attributes, configs are retained without change.
+          That is, results of ``get_config`` before and after ``reset`` are equal.
 
         Class and object methods, and class attributes are also unaffected.
 
+        Equivalent to ``clone``, with the exception that ``reset``
+        mutates ``self`` instead of returning a new object.
+
+        After a ``self.reset()`` call,
+        ``self`` is equal in value and state, to the object obtained after
+        a constructor call``type(self)(**self.get_params(deep=False))``.
+
         Returns
         -------
         self
             Instance of class reset to a clean post-init state but retaining
             the current hyper-parameter values.
-
-        Notes
-        -----
-        Equivalent to sklearn.clone but overwrites self. After self.reset()
-        call, self is equal in value to `type(self)(**self.get_params(deep=False))`
         """
         # retrieve parameters to copy them later
         params = self.get_params(deep=False)
@@ -149,19 +160,57 @@ class BaseObject(_FlagManager):
         A clone is a different object without shared references, in post-init state.
         This function is equivalent to returning ``sklearn.clone`` of ``self``.
 
+        Equivalent to constructing a new instance of ``type(self)``, with
+        parameters of ``self``, that is,
+        ``type(self)(**self.get_params(deep=False))``.
+
+        If configs were set on ``self``, the clone will also have the same configs
+        as the original,
+        equivalent to calling ``cloned_self.set_config(**self.get_config())``.
+
+        Also equivalent in value to a call of ``self.reset``,
+        with the exception that ``clone`` returns a new object,
+        instead of mutating ``self`` like ``reset``.
+
         Raises
         ------
         RuntimeError if the clone is non-conforming, due to faulty ``__init__``.
-
-        Notes
-        -----
-        If successful, equal in value to ``type(self)(**self.get_params(deep=False))``.
         """
-        self_clone = _clone(self)
+        # get plugins for cloning, if present (empty by default)
+        clone_plugins = self._get_clone_plugins()
+
+        # clone the object
+        self_clone = _clone(self, base_cls=BaseObject, clone_plugins=clone_plugins)
+
+        # check the clone, if check_clone is set (False by default)
         if self.get_config()["check_clone"]:
             _check_clone(original=self, clone=self_clone)
+
+        # return the clone
         return self_clone
 
+    @classmethod
+    def _get_clone_plugins(cls):
+        """Get clone plugins for BaseObject.
+
+        Can be overridden in subclasses to add custom clone plugins.
+
+        If implemented, must return a list of clone plugins for descendants.
+
+        Plugins are loaded ahead of the default plugins, and are used in the order
+        they are returned.
+        This allows extenders to override the default behaviours, if desired.
+
+        Returns
+        -------
+        list of str
+            List of clone plugins for descendants.
+            Each plugin must inherit from ``BaseCloner``
+            in ``skbase.base._clone_plugins``, and implement
+            the methods ``_check`` and ``_clone``.
+        """
+        return None
+
     @classmethod
     def _get_init_signature(cls):
         """Get class init signature.
@@ -175,7 +224,7 @@ class BaseObject(_FlagManager):
 
         Raises
         ------
-        RuntimeError if cls has varargs in __init__.
+        RuntimeError if ``cls`` has varargs in ``__init__``.
         """
         # fetch the constructor or the original constructor before
         # deprecation wrapping if any
@@ -218,7 +267,7 @@ class BaseObject(_FlagManager):
         Returns
         -------
         param_names: list[str]
-            List of parameter names of cls.
+            List of parameter names of ``cls``.
             If ``sort=False``, in same order as they appear in the class ``__init__``.
             If ``sort=True``, alphabetically ordered.
         """
@@ -238,8 +287,9 @@ class BaseObject(_FlagManager):
         Returns
         -------
         default_dict: dict[str, Any]
-            Keys are all parameters of cls that have a default defined in __init__
-            values are the defaults, as defined in __init__.
+            Keys are all parameters of ``cls`` that have
+            a default defined in ``__init__``.
+            Values are the defaults, as defined in ``__init__``.
         """
         parameters = cls._get_init_signature()
         default_dict = {
@@ -255,9 +305,11 @@ class BaseObject(_FlagManager):
         deep : bool, default=True
             Whether to return parameters of components.
 
-            * If True, will return a dict of parameter name : value for this object,
-              including parameters of components (= BaseObject-valued parameters).
-            * If False, will return a dict of parameter name : value for this object,
+            * If ``True``, will return a ``dict`` of
+              parameter name : value for this object,
+              including parameters of components (= ``BaseObject``-valued parameters).
+            * If ``False``, will return a ``dict``
+              of parameter name : value for this object,
               but not include parameters of components.
 
         Returns
@@ -266,14 +318,14 @@ class BaseObject(_FlagManager):
             Dictionary of parameters, paramname : paramvalue
             keys-value pairs include:
 
-            * always: all parameters of this object, as via `get_param_names`
+            * always: all parameters of this object, as via ``get_param_names``
               values are parameter value for that key, of this object
               values are always identical to values passed at construction
-            * if `deep=True`, also contains keys/value pairs of component parameters
-              parameters of components are indexed as `[componentname]__[paramname]`
-              all parameters of `componentname` appear as `paramname` with its value
-            * if `deep=True`, also contains arbitrary levels of component recursion,
-              e.g., `[componentname]__[componentcomponentname]__[paramname]`, etc
+            * if ``deep=True``, also contains keys/value pairs of component parameters
+              parameters of components are indexed as ``[componentname]__[paramname]``
+              all parameters of ``componentname`` appear as ``paramname`` with its value
+            * if ``deep=True``, also contains arbitrary levels of component recursion,
+              e.g., ``[componentname]__[componentcomponentname]__[paramname]``, etc
         """
         params = {key: getattr(self, key) for key in self.get_param_names()}
 
@@ -302,7 +354,7 @@ class BaseObject(_FlagManager):
         ----------
         **params : dict
             BaseObject parameters, keys must be ``<component>__<parameter>`` strings.
-            __ suffixes can alias full strings, if unique among get_params keys.
+            ``__`` suffixes can alias full strings, if unique among get_params keys.
 
         Returns
         -------
@@ -375,16 +427,18 @@ class BaseObject(_FlagManager):
         ------
         alias_dict: dict with str keys, all keys in valid_params
             values are as in d, with keys replaced by following rule:
-            If key is a __ suffix of exactly one key in valid_params,
-                it is replaced by that key. Otherwise an exception is raised.
-            A __ suffix of a str is any str obtained as suffix from partition by __.
-            Else, i.e., if key is in valid_params or not a __ suffix,
-            the key is replaced by itself, i.e., left unchanged.
+
+            * If key is a ``__`` suffix of exactly one key in ``valid_params``,
+              it is replaced by that key. Otherwise an exception is raised.
+            * A ``__``-suffix of a ``str`` is any ``str`` obtained as suffix
+              from partition by the string ``"__"``.
+              Else, i.e., if key is in valid_params or not a ``__``-suffix,
+              the key is replaced by itself, i.e., left unchanged.
 
         Raises
         ------
-        ValueError if at least one key of d is neither contained in valid_params,
-            nor is it a __ suffix of exactly one key in valid_params
+        ValueError if at least one key of d is neither contained in ``valid_params``,
+            nor is it a ``__``-suffix of exactly one key in ``valid_params``
         """
 
         def _is_suffix(x, y):
@@ -419,39 +473,92 @@ class BaseObject(_FlagManager):
 
     @classmethod
     def get_class_tags(cls):
-        """Get class tags from the class and all its parent classes.
+        """Get class tags from class, with tag level inheritance from parent classes.
+
+        Every ``scikit-base`` compatible object has a dictionary of tags.
+        Tags may be used to store metadata about the object,
+        or to control behaviour of the object.
+
+        Tags are key-value pairs specific to an instance ``self``,
+        they are static flags that are not changed after construction
+        of the object.
+
+        The ``get_class_tags`` method is a class method,
+        and retrieves the value of a tag
+        taking into account only class-level tag values and overrides.
 
-        Retrieves tag: value pairs from _tags class attribute. Does not return
-        information from dynamic tags (set via set_tags or clone_tags)
+        It returns a dictionary with keys being keys of any attribute of ``_tags``
+        set in the class or any of its parent classes.
+
+        Values are the corresponding tag values, with overrides in the following
+        order of descending priority:
+
+        1. Tags set in the ``_tags`` attribute of the class.
+        2. Tags set in the ``_tags`` attribute of parent classes,
+          in order of inheritance.
+
+        Instances can override these tags depending on hyper-parameters.
+
+        To retrieve tags with potential instance overrides, use
+        the ``get_tags`` method instead.
+
+        Does not take into account dynamic tag overrides on instances,
+        set via ``set_tags`` or ``clone_tags``,
         that are defined on instances.
 
+        For including overrides from dynamic tags, use ``get_tags``.
+
         Returns
         -------
         collected_tags : dict
-            Dictionary of class tag name: tag value pairs. Collected from _tags
-            class attribute via nested inheritance.
+            Dictionary of tag name : tag value pairs. Collected from ``_tags``
+            class attribute via nested inheritance. NOT overridden by dynamic
+            tags set by ``set_tags`` or ``clone_tags``.
         """
         return cls._get_class_flags(flag_attr_name="_tags")
 
     @classmethod
     def get_class_tag(cls, tag_name, tag_value_default=None):
-        """Get a class tag's value.
+        """Get class tag value from class, with tag level inheritance from parents.
+
+        Every ``scikit-base`` compatible object has a dictionary of tags.
+        Tags may be used to store metadata about the object,
+        or to control behaviour of the object.
+
+        Tags are key-value pairs specific to an instance ``self``,
+        they are static flags that are not changed after construction
+        of the object.
+
+        The ``get_class_tag`` method is a class method, and retrieves the value of a tag
+        taking into account only class-level tag values and overrides.
+
+        It returns the value of the tag with name ``tag_name`` from the object,
+        taking into account tag overrides, in the following
+        order of descending priority:
 
-        Does not return information from dynamic tags (set via set_tags or clone_tags)
+        1. Tags set in the ``_tags`` attribute of the class.
+        2. Tags set in the ``_tags`` attribute of parent classes,
+          in order of inheritance.
+
+        Does not take into account dynamic tag overrides on instances,
+        set via ``set_tags`` or ``clone_tags``,
         that are defined on instances.
 
+        To retrieve tag values with potential instance overrides, use
+        the ``get_tag`` method instead.
+
         Parameters
         ----------
         tag_name : str
             Name of tag value.
-        tag_value_default : any
+        tag_value_default : any type
             Default/fallback value if tag is not found.
 
         Returns
         -------
         tag_value :
-            Value of the `tag_name` tag in self. If not found, returns
-            `tag_value_default`.
+            Value of the ``tag_name`` tag in ``self``.
+            If not found, returns ``tag_value_default``.
         """
         return cls._get_class_flag(
             flag_name=tag_name,
@@ -460,19 +567,60 @@ class BaseObject(_FlagManager):
         )
 
     def get_tags(self):
-        """Get tags from skbase class and dynamic tag overrides.
+        """Get tags from instance, with tag level inheritance and overrides.
+
+        Every ``scikit-base`` compatible object has a dictionary of tags.
+        Tags may be used to store metadata about the object,
+        or to control behaviour of the object.
+
+        Tags are key-value pairs specific to an instance ``self``,
+        they are static flags that are not changed after construction
+        of the object.
+
+        The ``get_tags`` method returns a dictionary of tags,
+        with keys being keys of any attribute of ``_tags``
+        set in the class or any of its parent classes, or tags set via ``set_tags``
+        or ``clone_tags``.
+
+        Values are the corresponding tag values, with overrides in the following
+        order of descending priority:
+
+        1. Tags set via ``set_tags`` or ``clone_tags`` on the instance,
+          at construction of the instance.
+        2. Tags set in the ``_tags`` attribute of the class.
+        3. Tags set in the ``_tags`` attribute of parent classes,
+          in order of inheritance.
 
         Returns
         -------
         collected_tags : dict
-            Dictionary of tag name : tag value pairs. Collected from _tags
+            Dictionary of tag name : tag value pairs. Collected from ``_tags``
             class attribute via nested inheritance and then any overrides
-            and new tags from _tags_dynamic object attribute.
+            and new tags from ``_tags_dynamic`` object attribute.
         """
         return self._get_flags(flag_attr_name="_tags")
 
     def get_tag(self, tag_name, tag_value_default=None, raise_error=True):
-        """Get tag value from object class and dynamic tag overrides.
+        """Get tag value from instance, with tag level inheritance and overrides.
+
+        Every ``scikit-base`` compatible object has a dictionary of tags.
+        Tags may be used to store metadata about the object,
+        or to control behaviour of the object.
+
+        Tags are key-value pairs specific to an instance ``self``,
+        they are static flags that are not changed after construction
+        of the object.
+
+        The ``get_tag`` method retrieves the value of a single tag
+        with name ``tag_name`` from the instance,
+        taking into account tag overrides, in the following
+        order of descending priority:
+
+        1. Tags set via ``set_tags`` or ``clone_tags`` on the instance,
+          at construction of the instance.
+        2. Tags set in the ``_tags`` attribute of the class.
+        3. Tags set in the ``_tags`` attribute of parent classes,
+          in order of inheritance.
 
         Parameters
         ----------
@@ -481,18 +629,20 @@ class BaseObject(_FlagManager):
         tag_value_default : any type, optional; default=None
             Default/fallback value if tag is not found
         raise_error : bool
-            whether a ValueError is raised when the tag is not found
+            whether a ``ValueError`` is raised when the tag is not found
 
         Returns
         -------
         tag_value : Any
-            Value of the `tag_name` tag in self. If not found, returns an error if
-            `raise_error` is True, otherwise it returns `tag_value_default`.
+            Value of the ``tag_name`` tag in ``self``.
+            If not found, raises an error if
+            ``raise_error`` is True, otherwise it returns ``tag_value_default``.
 
         Raises
         ------
-        ValueError if raise_error is True i.e. if `tag_name` is not in
-        self.get_tags().keys()
+        ValueError, if ``raise_error`` is ``True``.
+            The ``ValueError`` is then raised if ``tag_name`` is
+            not in ``self.get_tags().keys()``.
         """
         return self._get_flag(
             flag_name=tag_name,
@@ -502,7 +652,25 @@ class BaseObject(_FlagManager):
         )
 
     def set_tags(self, **tag_dict):
-        """Set dynamic tags to given values.
+        """Set instance level tag overrides to given values.
+
+        Every ``scikit-base`` compatible object has a dictionary of tags.
+        Tags may be used to store metadata about the object,
+        or to control behaviour of the object.
+
+        Tags are key-value pairs specific to an instance ``self``,
+        they are static flags that are not changed after construction
+        of the object.
+
+        ``set_tags`` sets dynamic tag overrides
+        to the values as specified in ``tag_dict``, with keys being the tag name,
+        and dict values being the value to set the tag to.
+
+        The ``set_tags`` method
+        should be called only in the ``__init__`` method of an object,
+        during construction, or directly after construction via ``__init__``.
+
+        Current tag values can be inspected by ``get_tags`` or ``get_tag``.
 
         Parameters
         ----------
@@ -513,10 +681,6 @@ class BaseObject(_FlagManager):
         -------
         Self
             Reference to self.
-
-        Notes
-        -----
-        Changes object state by setting tag values in tag_dict as dynamic tags in self.
         """
         self._set_flags(flag_attr_name="_tags", **tag_dict)
 
@@ -525,22 +689,39 @@ class BaseObject(_FlagManager):
     def clone_tags(self, estimator, tag_names=None):
         """Clone tags from another object as dynamic override.
 
+        Every ``scikit-base`` compatible object has a dictionary of tags.
+        Tags may be used to store metadata about the object,
+        or to control behaviour of the object.
+
+        Tags are key-value pairs specific to an instance ``self``,
+        they are static flags that are not changed after construction
+        of the object.
+
+        ``clone_tags`` sets dynamic tag overrides
+        from another object, ``estimator``.
+
+        The ``clone_tags`` method
+        should be called only in the ``__init__`` method of an object,
+        during construction, or directly after construction via ``__init__``.
+
+        The dynamic tags are set to the values of the tags in ``estimator``,
+        with the names specified in ``tag_names``.
+
+        The default of ``tag_names`` writes all tags from ``estimator`` to ``self``.
+
+        Current tag values can be inspected by ``get_tags`` or ``get_tag``.
+
         Parameters
         ----------
         estimator : An instance of :class:BaseObject or derived class
         tag_names : str or list of str, default = None
-            Names of tags to clone. If None then all tags in estimator are used
-            as `tag_names`.
+            Names of tags to clone.
+            The default (``None``) clones all tags from ``estimator``.
 
         Returns
         -------
-        Self :
-            Reference to self.
-
-        Notes
-        -----
-        Changes object state by setting tag values in tag_set from estimator as
-        dynamic tags in self.
+        self :
+            Reference to ``self``.
         """
         self._clone_flags(
             estimator=estimator, flag_names=tag_names, flag_attr_name="_tags"
@@ -551,6 +732,17 @@ class BaseObject(_FlagManager):
     def get_config(self):
         """Get config flags for self.
 
+        Configs are key-value pairs of ``self``,
+        typically used as transient flags for controlling behaviour.
+
+        ``get_config`` returns dynamic configs, which override the default configs.
+
+        Default configs are set in the class attribute ``_config`` of
+        the class or its parent classes,
+        and are overridden by dynamic configs set via ``set_config``.
+
+        Configs are retained under ``clone`` or ``reset`` calls.
+
         Returns
         -------
         config_dict : dict
@@ -563,6 +755,17 @@ class BaseObject(_FlagManager):
     def set_config(self, **config_dict):
         """Set config flags to given values.
 
+        Configs are key-value pairs of ``self``,
+        typically used as transient flags for controlling behaviour.
+
+        ``set_config`` sets dynamic configs, which override the default configs.
+
+        Default configs are set in the class attribute ``_config`` of
+        the class or its parent classes,
+        and are overridden by dynamic configs set via ``set_config``.
+
+        Configs are retained under ``clone`` or ``reset`` calls.
+
         Parameters
         ----------
         config_dict : dict
@@ -584,6 +787,21 @@ class BaseObject(_FlagManager):
     def get_test_params(cls, parameter_set="default"):
         """Return testing parameter settings for the skbase object.
 
+        ``get_test_params`` is a unified interface point to store
+        parameter settings for testing purposes. This function is also
+        used in ``create_test_instance`` and ``create_test_instances_and_names``
+        to construct test instances.
+
+        ``get_test_params`` should return a single ``dict``, or a ``list`` of ``dict``.
+
+        Each ``dict`` is a parameter configuration for testing,
+        and can be used to construct an "interesting" test instance.
+        A call to ``cls(**params)`` should
+        be valid for all dictionaries ``params`` in the return of ``get_test_params``.
+
+        The ``get_test_params`` need not return fixed lists of dictionaries,
+        it can also return dynamic or stochastic parameter settings.
+
         Parameters
         ----------
         parameter_set : str, default="default"
@@ -630,11 +848,6 @@ class BaseObject(_FlagManager):
         -------
         instance : instance of the class with default parameters
 
-        Notes
-        -----
-        `get_test_params` can return dict or list of dict.
-        This function takes first or single dict that get_test_params returns, and
-        constructs the object with that.
         """
         if "parameter_set" in inspect.getfullargspec(cls.get_test_params).args:
             params = cls.get_test_params(parameter_set=parameter_set)
@@ -665,11 +878,11 @@ class BaseObject(_FlagManager):
         Returns
         -------
         objs : list of instances of cls
-            i-th instance is cls(**cls.get_test_params()[i])
+            i-th instance is ``cls(**cls.get_test_params()[i])``
         names : list of str, same length as objs
-            i-th element is name of i-th instance of obj in tests
-            convention is {cls.__name__}-{i} if more than one instance
-            otherwise {cls.__name__}
+            i-th element is name of i-th instance of obj in tests.
+            The naming convention is ``{cls.__name__}-{i}`` if more than one instance,
+            otherwise ``{cls.__name__}``
         """
         if "parameter_set" in inspect.getfullargspec(cls.get_test_params).args:
             param_list = cls.get_test_params(parameter_set=parameter_set)
@@ -760,7 +973,7 @@ class BaseObject(_FlagManager):
         -------
         composite: bool
             Whether an object has any parameters whose values
-            are BaseObjects.
+            are ``BaseObject`` descendant instances.
         """
         # walk through method resolution order and inspect methods
         #   of classes and direct parents, "adjacent" classes in mro
@@ -772,7 +985,7 @@ class BaseObject(_FlagManager):
     def _components(self, base_class=None):
         """Return references to all state changing BaseObject type attributes.
 
-        This *excludes* the blue-print-like components passed in the __init__.
+        This *excludes* the blue-print-like components passed in the ``__init__``.
 
         Caution: this method returns *references* and not *copies*.
             Writing to the reference will change the respective attribute of self.
@@ -780,7 +993,7 @@ class BaseObject(_FlagManager):
         Parameters
         ----------
         base_class : class, optional, default=None, must be subclass of BaseObject
-            if not None, sub-sets return dict to only descendants of base_class
+            if not ``None``, sub-sets return dict to only descendants of ``base_class``
 
         Returns
         -------
@@ -990,26 +1203,43 @@ class TagAliaserMixin:
     def get_class_tags(cls):
         """Get class tags from class, with tag level inheritance from parent classes.
 
-        Every ``scikit-base`` compatible class has a set of tags,
-        which are used to store metadata about the object.
+        Every ``scikit-base`` compatible object has a dictionary of tags.
+        Tags may be used to store metadata about the object,
+        or to control behaviour of the object.
 
-        This is a class method, and retrieves tags applicable to the class,
-        with tag level overrides in the following order of decreasing priority:
+        Tags are key-value pairs specific to an instance ``self``,
+        they are static flags that are not changed after construction
+        of the object.
 
-        1. class tags of the class, of which the object is an instance
-        2. class tags of all parent classes, in method resolution order
+        The ``get_class_tags`` method is a class method,
+        and retrieves the value of a tag
+        taking into account only class-level tag values and overrides.
+
+        It returns a dictionary with keys being keys of any attribute of ``_tags``
+        set in the class or any of its parent classes.
+
+        Values are the corresponding tag values, with overrides in the following
+        order of descending priority:
+
+        1. Tags set in the ``_tags`` attribute of the class.
+        2. Tags set in the ``_tags`` attribute of parent classes,
+          in order of inheritance.
 
         Instances can override these tags depending on hyper-parameters.
 
         To retrieve tags with potential instance overrides, use
         the ``get_tags`` method instead.
 
-        Returns
-        -------
+        Does not take into account dynamic tag overrides on instances,
+        set via ``set_tags`` or ``clone_tags``,
+        that are defined on instances.
+
+        For including overrides from dynamic tags, use ``get_tags``.
+
         collected_tags : dict
-            Dictionary of tag name : tag value pairs. Collected from _tags
+            Dictionary of tag name : tag value pairs. Collected from ``_tags``
             class attribute via nested inheritance. NOT overridden by dynamic
-            tags set by set_tags or mirror_tags.
+            tags set by ``set_tags`` or ``clone_tags``.
         """
         collected_tags = super(TagAliaserMixin, cls).get_class_tags()
         collected_tags = cls._complete_dict(collected_tags)
@@ -1019,17 +1249,24 @@ class TagAliaserMixin:
     def get_class_tag(cls, tag_name, tag_value_default=None):
         """Get class tag value from class, with tag level inheritance from parents.
 
-        Every ``scikit-base`` compatible class has a set of tags,
+        Every ``scikit-base`` compatible object has a dictionary of tags,
         which are used to store metadata about the object.
 
-        This is a class method, and retrieves the value of a tag applicable
-        to the class,
-        with tag level overrides in the following order of decreasing priority:
+        The ``get_class_tag`` method is a class method,
+        and retrieves the value of a tag
+        taking into account only class-level tag values and overrides.
 
-        1. class tags of the class, of which the object is an instance
-        2. class tags of all parent classes, in method resolution order
+        It returns the value of the tag with name ``tag_name`` from the object,
+        taking into account tag overrides, in the following
+        order of descending priority:
 
-        Instances can override these tags depending on hyper-parameters.
+        1. Tags set in the ``_tags`` attribute of the class.
+        2. Tags set in the ``_tags`` attribute of parent classes,
+          in order of inheritance.
+
+        Does not take into account dynamic tag overrides on instances,
+        set via ``set_tags`` or ``clone_tags``,
+        that are defined on instances.
 
         To retrieve tag values with potential instance overrides, use
         the ``get_tag`` method instead.
@@ -1044,8 +1281,8 @@ class TagAliaserMixin:
         Returns
         -------
         tag_value :
-            Value of the `tag_name` tag in self. If not found, returns
-            `tag_value_default`.
+            Value of the ``tag_name`` tag in ``self``.
+            If not found, returns ``tag_value_default``.
         """
         cls._deprecate_tag_warn([tag_name])
         return super(TagAliaserMixin, cls).get_class_tag(
@@ -1055,22 +1292,34 @@ class TagAliaserMixin:
     def get_tags(self):
         """Get tags from instance, with tag level inheritance and overrides.
 
-        Every ``scikit-base`` compatible object has a set of tags,
-        which are used to store metadata about the object.
+        Every ``scikit-base`` compatible object has a dictionary of tags.
+        Tags may be used to store metadata about the object,
+        or to control behaviour of the object.
+
+        Tags are key-value pairs specific to an instance ``self``,
+        they are static flags that are not changed after construction
+        of the object.
 
-        This method retrieves all tags as a dictionary, with tag level overrides in the
-        following order of decreasing priority:
+        The ``get_tags`` method returns a dictionary of tags,
+        with keys being keys of any attribute of ``_tags``
+        set in the class or any of its parent classes, or tags set via ``set_tags``
+        or ``clone_tags``.
 
-        1. dynamic tags set at construction, e.g., dependent on hyper-parameters
-        2. class tags of the class, of which the object is an instance
-        3. class tags of all parent classes, in method resolution order
+        Values are the corresponding tag values, with overrides in the following
+        order of descending priority:
+
+        1. Tags set via ``set_tags`` or ``clone_tags`` on the instance,
+          at construction of the instance.
+        2. Tags set in the ``_tags`` attribute of the class.
+        3. Tags set in the ``_tags`` attribute of parent classes,
+          in order of inheritance.
 
         Returns
         -------
         collected_tags : dict
-            Dictionary of tag name : tag value pairs. Collected from _tags
+            Dictionary of tag name : tag value pairs. Collected from ``_tags``
             class attribute via nested inheritance and then any overrides
-            and new tags from _tags_dynamic object attribute.
+            and new tags from ``_tags_dynamic`` object attribute.
         """
         collected_tags = super(TagAliaserMixin, self).get_tags()
         collected_tags = self._complete_dict(collected_tags)
@@ -1079,15 +1328,24 @@ class TagAliaserMixin:
     def get_tag(self, tag_name, tag_value_default=None, raise_error=True):
         """Get tag value from instance, with tag level inheritance and overrides.
 
-        Every ``scikit-base`` compatible object has a set of tags,
-        which are used to store metadata about the object.
+        Every ``scikit-base`` compatible object has a dictionary of tags.
+        Tags may be used to store metadata about the object,
+        or to control behaviour of the object.
 
-        This method retrieves the value of a single tag, with tag level overrides in the
-        following order of decreasing priority:
+        Tags are key-value pairs specific to an instance ``self``,
+        they are static flags that are not changed after construction
+        of the object.
 
-        1. dynamic tags set at construction, e.g., dependent on hyper-parameters
-        2. class tags of the class, of which the object is an instance
-        3. class tags of all parent classes, in method resolution order
+        The ``get_tag`` method retrieves the value of a single tag
+        with name ``tag_name`` from the instance,
+        taking into account tag overrides, in the following
+        order of descending priority:
+
+        1. Tags set via ``set_tags`` or ``clone_tags`` on the instance,
+          at construction of the instance.
+        2. Tags set in the ``_tags`` attribute of the class.
+        3. Tags set in the ``_tags`` attribute of parent classes,
+          in order of inheritance.
 
         Parameters
         ----------
@@ -1096,18 +1354,20 @@ class TagAliaserMixin:
         tag_value_default : any type, optional; default=None
             Default/fallback value if tag is not found
         raise_error : bool
-            whether a ValueError is raised when the tag is not found
+            whether a ``ValueError`` is raised when the tag is not found
 
         Returns
         -------
-        tag_value :
-            Value of the `tag_name` tag in self. If not found, returns an error if
-            raise_error is True, otherwise it returns `tag_value_default`.
+        tag_value : Any
+            Value of the ``tag_name`` tag in ``self``.
+            If not found, raises an error if
+            ``raise_error`` is True, otherwise it returns ``tag_value_default``.
 
         Raises
         ------
-        ValueError if raise_error is True i.e. if tag_name is not in self.get_tags(
-        ).keys()
+        ValueError, if ``raise_error`` is ``True``.
+            The ``ValueError`` is then raised if ``tag_name`` is
+            not in ``self.get_tags().keys()``.
         """
         self._deprecate_tag_warn([tag_name])
         return super(TagAliaserMixin, self).get_tag(
@@ -1117,22 +1377,35 @@ class TagAliaserMixin:
         )
 
     def set_tags(self, **tag_dict):
-        """Set dynamic tags to given values.
+        """Set instance level tag overrides to given values.
+
+        Every ``scikit-base`` compatible object has a dictionary of tags,
+        which are used to store metadata about the object.
+
+        Tags are key-value pairs specific to an instance ``self``,
+        they are static flags that are not changed after construction
+        of the object. They may be used for metadata inspection,
+        or for controlling behaviour of the object.
+
+        ``set_tags`` sets dynamic tag overrides
+        to the values as specified in ``tag_dict``, with keys being the tag name,
+        and dict values being the value to set the tag to.
+
+        The ``set_tags`` method
+        should be called only in the ``__init__`` method of an object,
+        during construction, or directly after construction via ``__init__``.
+
+        Current tag values can be inspected by ``get_tags`` or ``get_tag``.
 
         Parameters
         ----------
-        tag_dict : dict
-            Dictionary of tag name : tag value pairs.
+        **tag_dict : dict
+            Dictionary of tag name: tag value pairs.
 
         Returns
         -------
-        Self :
+        Self
             Reference to self.
-
-        Notes
-        -----
-        Changes object state by setting tag values in tag_dict as dynamic tags
-        in self.
         """
         self._deprecate_tag_warn(tag_dict.keys())
 
@@ -1203,13 +1476,13 @@ class BaseEstimator(BaseObject):
     def __init__(self):
         """Construct BaseEstimator."""
         self._is_fitted = False
-        super(BaseEstimator, self).__init__()
+        super().__init__()
 
     @property
     def is_fitted(self):
-        """Whether `fit` has been called.
+        """Whether ``fit`` has been called.
 
-        Inspects object's `_is_fitted` attribute that should initialize to False
+        Inspects object's ``_is_fitted` attribute that should initialize to ``False``
         during object construction, and be set to True in calls to an object's
         `fit` method.
 
@@ -1218,14 +1491,25 @@ class BaseEstimator(BaseObject):
         bool
             Whether the estimator has been `fit`.
         """
-        return self._is_fitted
+        if hasattr(self, "_is_fitted"):
+            return self._is_fitted
+        else:
+            return False
 
-    def check_is_fitted(self):
+    def check_is_fitted(self, method_name=None):
         """Check if the estimator has been fitted.
 
-        Inspects object's `_is_fitted` attribute that should initialize to False
-        during object construction, and be set to True in calls to an object's
-        `fit` method.
+        Check if ``_is_fitted`` attribute is present and ``True``.
+        The ``is_fitted``
+        attribute should be set to ``True`` in calls to an object's ``fit`` method.
+
+        If not, raises a ``NotFittedError``.
+
+        Parameters
+        ----------
+        method_name : str, optional
+            Name of the method that called this function. If provided, the error
+            message will include this information.
 
         Raises
         ------
@@ -1233,10 +1517,17 @@ class BaseEstimator(BaseObject):
             If the estimator has not been fitted yet.
         """
         if not self.is_fitted:
-            raise NotFittedError(
-                f"This instance of {self.__class__.__name__} has not been fitted yet. "
-                f"Please call `fit` first."
-            )
+            if method_name is None:
+                msg = (
+                    f"This instance of {self.__class__.__name__} has not been fitted "
+                    f"yet. Please call `fit` first."
+                )
+            else:
+                msg = (
+                    f"This instance of {self.__class__.__name__} has not been fitted "
+                    f"yet. Please call `fit` before calling `{method_name}`."
+                )
+            raise NotFittedError(msg)
 
     def get_fitted_params(self, deep=True):
         """Get fitted parameters.
@@ -1261,19 +1552,15 @@ class BaseEstimator(BaseObject):
             Dictionary of fitted parameters, paramname : paramvalue
             keys-value pairs include:
 
-            * always: all fitted parameters of this object, as via `get_param_names`
+            * always: all fitted parameters of this object, as via ``get_param_names``
               values are fitted parameter value for that key, of this object
-            * if `deep=True`, also contains keys/value pairs of component parameters
-              parameters of components are indexed as `[componentname]__[paramname]`
-              all parameters of `componentname` appear as `paramname` with its value
-            * if `deep=True`, also contains arbitrary levels of component recursion,
-              e.g., `[componentname]__[componentcomponentname]__[paramname]`, etc
+            * if ``deep=True``, also contains keys/value pairs of component parameters
+              parameters of components are indexed as ``[componentname]__[paramname]``
+              all parameters of ``componentname`` appear as ``paramname`` with its value
+            * if ``deep=True``, also contains arbitrary levels of component recursion,
+              e.g., ``[componentname]__[componentcomponentname]__[paramname]``, etc
         """
-        if not self.is_fitted:
-            raise NotFittedError(
-                f"estimator of type {type(self).__name__} has not been "
-                "fitted yet, please call fit on data before get_fitted_params"
-            )
+        self.check_is_fitted(method_name="get_fitted_params")
 
         # collect non-nested fitted params of self
         fitted_params = self._get_fitted_params()
@@ -1397,107 +1684,3 @@ class BaseEstimator(BaseObject):
             fitted parameters, keyed by names of fitted parameter
         """
         return self._get_fitted_params_default()
-
-
-# Adapted from sklearn's `_clone_parametrized()`
-def _clone(estimator, *, safe=True):
-    """Construct a new unfitted estimator with the same parameters.
-
-    Clone does a deep copy of the model in an estimator
-    without actually copying attached data. It returns a new estimator
-    with the same parameters that has not been fitted on any data.
-
-    Parameters
-    ----------
-    estimator : {list, tuple, set} of estimator instance or a single \
-            estimator instance
-        The estimator or group of estimators to be cloned.
-    safe : bool, default=True
-        If safe is False, clone will fall back to a deep copy on objects
-        that are not estimators.
-
-    Returns
-    -------
-    estimator : object
-        The deep copy of the input, an estimator if input is an estimator.
-
-    Notes
-    -----
-    If the estimator's `random_state` parameter is an integer (or if the
-    estimator doesn't have a `random_state` parameter), an *exact clone* is
-    returned: the clone and the original estimator will give the exact same
-    results. Otherwise, *statistical clone* is returned: the clone might
-    return different results from the original estimator. More details can be
-    found in :ref:`randomness`.
-    """
-    estimator_type = type(estimator)
-    if estimator_type is dict:
-        return {k: _clone(v, safe=safe) for k, v in estimator.items()}
-    if estimator_type in (list, tuple, set, frozenset):
-        return estimator_type([_clone(e, safe=safe) for e in estimator])
-    elif not hasattr(estimator, "get_params") or isinstance(estimator, type):
-        if not safe:
-            return deepcopy(estimator)
-        else:
-            if isinstance(estimator, type):
-                raise TypeError(
-                    "Cannot clone object. "
-                    + "You should provide an instance of "
-                    + "scikit-learn estimator instead of a class."
-                )
-            else:
-                raise TypeError(
-                    "Cannot clone object '%s' (type %s): "
-                    "it does not seem to be a scikit-learn "
-                    "estimator as it does not implement a "
-                    "'get_params' method." % (repr(estimator), type(estimator))
-                )
-
-    klass = estimator.__class__
-    new_object_params = estimator.get_params(deep=False)
-    for name, param in new_object_params.items():
-        new_object_params[name] = _clone(param, safe=False)
-    new_object = klass(**new_object_params)
-    params_set = new_object.get_params(deep=False)
-
-    # quick sanity check of the parameters of the clone
-    for name in new_object_params:
-        param1 = new_object_params[name]
-        param2 = params_set[name]
-        if param1 is not param2:
-            raise RuntimeError(
-                "Cannot clone object %s, as the constructor "
-                "either does not set or modifies parameter %s" % (estimator, name)
-            )
-
-    # This is an extension to the original sklearn implementation
-    if isinstance(estimator, BaseObject) and estimator.get_config()["clone_config"]:
-        new_object.set_config(**estimator.get_config())
-
-    return new_object
-
-
-def _check_clone(original, clone):
-    from skbase.utils.deep_equals import deep_equals
-
-    self_params = original.get_params(deep=False)
-
-    # check that all attributes are written to the clone
-    for attrname in self_params.keys():
-        if not hasattr(clone, attrname):
-            raise RuntimeError(
-                f"error in {original}.clone, __init__ must write all arguments "
-                f"to self and not mutate them, but {attrname} was not found. "
-                f"Please check __init__ of {original}."
-            )
-
-    clone_attrs = {attr: getattr(clone, attr) for attr in self_params.keys()}
-
-    # check equality of parameters post-clone and pre-clone
-    clone_attrs_valid, msg = deep_equals(self_params, clone_attrs, return_msg=True)
-    if not clone_attrs_valid:
-        raise RuntimeError(
-            f"error in {original}.clone, __init__ must write all arguments "
-            f"to self and not mutate them, but this is not the case. "
-            f"Error on equality check of arguments (x) vs parameters (y): {msg}"
-        )