skpro.base.BaseMetaEstimator#

class skpro.base.BaseMetaEstimator[source]#

Base class for fittable composite meta-objects.

Attributes:

is_fitted: Whether fit has been called.
name: Return the name of the object or estimator.

Methods

`check_is_fitted`()	Check if the estimator has been fitted.
`clone`()	Obtain a clone of the object with same hyper-parameters.
`clone_tags`(estimator[, tag_names])	Clone tags from another estimator as dynamic override.
`create_test_instance`([parameter_set])	Construct Estimator instance if possible.
`create_test_instances_and_names`([parameter_set])	Create list of all test instances and a list of names for them.
`get_class_tag`(tag_name[, tag_value_default])	Get a class tag's value.
`get_class_tags`()	Get class tags from the class and all its parent classes.
`get_config`()	Get config flags for self.
`get_fitted_params`([deep])	Get fitted parameters.
`get_param_defaults`()	Get object's parameter defaults.
`get_param_names`()	Get object's parameter names.
`get_params`([deep])	Get a dict of parameters values for this object.
`get_tag`(tag_name[, tag_value_default, ...])	Get tag value from estimator class and dynamic tag overrides.
`get_tags`()	Get tags from estimator class and dynamic tag overrides.
`get_test_params`([parameter_set])	Return testing parameter settings for the estimator.
`is_composite`()	Check if the object is composite.
`reset`()	Reset the object to a clean post-init state.
`set_config`(**config_dict)	Set config flags to given values.
`set_params`(**kwargs)	Set the object's direct parameters and the parameters of components.
`set_random_state`([random_state, deep, ...])	Set random_state pseudo-random seed parameters for self.
`set_tags`(**tag_dict)	Set dynamic tags to given values.

check_is_fitted()[source]#

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.

Raises:

NotFittedError: If the estimator has not been fitted yet.

clone()[source]#

Obtain a clone of the object with same hyper-parameters.

A clone is a different object without shared references, in post-init state. This function is equivalent to returning sklearn.clone of self.

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)).

clone_tags(estimator, tag_names=None)[source]#

Clone tags from another estimator as dynamic override.

Parameters:

estimatorestimator inheriting from :class:BaseEstimator
tag_namesstr or list of str, default = None: Names of tags to clone. If None then all tags in estimator are used as tag_names.

Returns:

Self: Reference to self.

Notes

Changes object state by setting tag values in tag_set from estimator as dynamic tags in self.

classmethod create_test_instance(parameter_set='default')[source]#

Construct Estimator instance if possible.

Parameters:

parameter_setstr, default=”default”: Name of the set of test parameters to return, for use in tests. If no special parameters are defined for a value, will return “default” set.

Returns:

instanceinstance 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.

classmethod create_test_instances_and_names(parameter_set='default')[source]#

Create list of all test instances and a list of names for them.

Parameters:

parameter_setstr, default=”default”: Name of the set of test parameters to return, for use in tests. If no special parameters are defined for a value, will return “default” set.

Returns:

objslist of instances of cls: i-th instance is cls(**cls.get_test_params()[i])
nameslist 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__}

classmethod get_class_tag(tag_name, tag_value_default=None)[source]#

Get a class tag’s value.

Does not return information from dynamic tags (set via set_tags or clone_tags) that are defined on instances.

Parameters:

tag_namestr: Name of tag value.
tag_value_defaultany: 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.

classmethod get_class_tags()[source]#

Get class tags from the class and all its parent classes.

Retrieves tag: value pairs from _tags class attribute. Does not return information from dynamic tags (set via set_tags or clone_tags) that are defined on instances.

Returns:

collected_tagsdict: Dictionary of class tag name: tag value pairs. Collected from _tags class attribute via nested inheritance.

get_config()[source]#

Get config flags for self.

Returns:

config_dictdict: Dictionary of config name : config value pairs. Collected from _config class attribute via nested inheritance and then any overrides and new tags from _onfig_dynamic object attribute.

get_fitted_params(deep=True)[source]#

Get fitted parameters.

State required:: Requires state to be “fitted”.

Parameters:

deepbool, default=True

Whether to return fitted parameters of components.

If True, will return a dict of parameter name : value for this object, including fitted parameters of fittable components (= BaseEstimator-valued parameters).
If False, will return a dict of parameter name : value for this object, but not include fitted parameters of components.

Returns:

fitted_paramsdict with str-valued keys

Dictionary of fitted parameters, paramname : paramvalue keys-value pairs include:

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

classmethod get_param_defaults()[source]#

Get object’s parameter defaults.

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__.

classmethod get_param_names()[source]#

Get object’s parameter names.

Returns:

param_names: list[str]: Alphabetically sorted list of parameter names of cls.

get_params(deep=True)[source]#

Get a dict of parameters values for this object.

This expands on get_params of standard BaseObject by also retrieving components parameters when deep=True a component’s follows the named object API (either sequence of str, BaseObject tuples or dict[str, BaseObject]).

Parameters:

deepbool, 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.
If False, will return a dict of parameter name : value for this object, but not include parameters of components.

Returns:

dict[str, Any]

Dictionary of parameter name and value pairs. Includes direct parameters and indirect parameters whose values implement get_params or follow the named object API (either sequence of str, BaseObject tuples or dict[str, BaseObject]).

If deep=False the name-value pairs for this object’s direct parameters (you can see these via get_param_names) are returned.
If deep=True then the parameter name-value pairs are returned for direct and component (indirect) parameters.
- When a BaseObject’s direct parameter value implements get_params the component parameters are returned as [direct_param_name]__[component_param_name] for 1st level components. Arbitrary levels of component recursion are supported (if the component has parameter’s whose values are objects that implement get_params). In this case, return parameters follow [direct_param_name]__[component_param_name]__[param_name] format.
- When a BaseObject’s direct parameter value is a sequence of (name, BaseObject) tuples or dict[str, BaseObject] the parameters name and value pairs of all component objects are returned. The parameter naming follows scikit-learn convention of treating named component objects like they are direct parameters; therefore, the names are assigned as [component_param_name]__[param_name].

get_tag(tag_name, tag_value_default=None, raise_error=True)[source]#

Get tag value from estimator class and dynamic tag overrides.

Parameters:

tag_namestr: Name of tag to be retrieved
tag_value_defaultany type, optional; default=None: Default/fallback value if tag is not found
raise_errorbool: whether a ValueError is raised when the tag is not found

Returns:

tag_valueAny: 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.

Raises:

ValueError if raise_error is True i.e. if tag_name is not in
self.get_tags().keys()

get_tags()[source]#

Get tags from estimator class and dynamic tag overrides.

Returns:

collected_tagsdict: 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.

classmethod get_test_params(parameter_set='default')[source]#

Return testing parameter settings for the estimator.

Parameters:

parameter_setstr, default=”default”: Name of the set of test parameters to return, for use in tests. If no special parameters are defined for a value, will return “default” set.

Returns:

paramsdict or list of dict, default = {}: Parameters to create testing instances of the class Each dict are parameters to construct an “interesting” test instance, i.e., MyClass(**params) or MyClass(**params[i]) creates a valid test instance. create_test_instance uses the first (or only) dictionary in params

is_composite()[source]#

Check if the object is composite.

A composite object is an object which contains objects as parameter values.

Returns:

bool: Whether self contains a parameter whose value is a BaseObject, list of (str, BaseObject) tuples or dict[str, BaseObject].

property is_fitted[source]#

Whether fit has been called.

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.

Returns:

bool: Whether the estimator has been fit.

property name[source]#: Return the name of the object or estimator.

reset()[source]#

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:

hyper-parameters = arguments of __init__

object attributes containing double-underscores, i.e., the string “__”

Class and object methods, and class attributes are also unaffected.

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))

set_config(**config_dict)[source]#

Set config flags to given values.

Parameters:

config_dictdict: Dictionary of config name : config value pairs.

Returns:

selfreference to self.

Notes

Changes object state, copies configs in config_dict to self._config_dynamic.

set_params(**kwargs)[source]#

Set the object’s direct parameters and the parameters of components.

Valid parameter keys can be listed with get_params().

Like BaseObject implementation it allows values of indirect parameters of a component to be set when a parameter’s value is an object that implements set_params. This also also expands the functionality to allow parameter to allow the indirect parameters of components to be set when a parameter’s values follow the named object API (either sequence of str, BaseObject tuples or dict[str, BaseObject]).

Returns:

Self: Instance of self.

set_random_state(random_state=None, deep=True, self_policy='copy')[source]#

Set random_state pseudo-random seed parameters for self.

Finds random_state named parameters via estimator.get_params, and sets them to integers derived from random_state via set_params. These integers are sampled from chain hashing via sample_dependent_seed, and guarantee pseudo-random independence of seeded random generators.

Applies to random_state parameters in estimator depending on self_policy, and remaining component estimators if and only if deep=True.

Note: calls set_params even if self does not have a random_state, or none of the components have a random_state parameter. Therefore, set_random_state will reset any scikit-base estimator, even those without a random_state parameter.

Parameters:

random_stateint, RandomState instance or None, default=None

Pseudo-random number generator to control the generation of the random integers. Pass int for reproducible output across multiple function calls.

deepbool, default=True

Whether to set the random state in sub-estimators. If False, will set only self’s random_state parameter, if exists. If True, will set random_state parameters in sub-estimators as well.

self_policystr, one of {“copy”, “keep”, “new”}, default=”copy”

“copy” : estimator.random_state is set to input random_state
“keep” : estimator.random_state is kept as is
“new” : estimator.random_state is set to a new random state,

derived from input random_state, and in general different from it

Returns:

selfreference to self

set_tags(**tag_dict)[source]#

Set dynamic tags to given values.

Parameters:

**tag_dictdict: Dictionary of tag name: tag value pairs.

Returns:

Self: Reference to self.

Notes

Changes object state by setting tag values in tag_dict as dynamic tags in self.