MSTL#

class MSTL(*, periods: int | Sequence[int] | None = None, windows: int | Sequence[int] | None = None, lmbda: float | str | None = None, iterate: int | None = 2, stl_kwargs: dict[str, int | bool | None] | None = None, return_components: bool = False)[source]#

使用 LOESS 对具有多种季节性的时间序列进行季节-趋势分解。

statsmodels.tsa.seasonal.MSTL 的直接接口，用于 transform，包含 sktime 原生扩展，可在预测管道中使用。

MSTL 可用于执行去季节化或分解

fit 将分解值存储在 self.trend_、self.seasonal_ 和 self.resid_ 中。

如果 return_components=False，则 transform 返回去季节化值的 pd.Series，即趋势加上残差成分。单独的季节性和残差成分可在 self.trend_ 和 self.resid_ 中找到。

如果 return_components=True，则 transform 返回完整的成分分解，在一个 DataFrame 中，列（对于每个输入列）按此顺序排列

  • “trend” - 趋势成分

  • “resid” - 去趋势、去季节化后的残差

  • “seasonal” - 单个季节性总和成分，如果 periods 是 None。

  • “seasonal_<period>” - 季节性成分，其中 <period> 是表示周期性的整数，对于 periods 中的每个元素有一个这样的成分，如果 periods 是整数数组。

MSTL 通过从其成分重构信号来执行 inverse_transform，并且可以在 TransformedTargetForecaster 中用于管道，请参阅以下示例。

  • 如果提供了 periods，转换将执行去季节化，并在预测后重新添加季节性。

  • 如果未提供 periods，且 return_components=False，预测将是纯趋势预测，使用趋势和残差成分的总和。

  • 如果 return_components=True，预测器可以访问所有成分，并可以将不同的预测器应用于不同的成分。

请参阅以下示例了解用法。

对于使用自定义季节性检测算法自动检测季节性，请将 MSTL 与相应的估计器（例如 SeasonalityACF）构建管道。

参数:
endogarray_like

要分解的数据。必须可挤压到 1 维。

periods{int, array_like, None}, 可选

季节性成分的周期性。如果为 None 且 endog 是 pandas Series 或 DataFrame，则尝试从 endog 确定。如果 endog 是 ndarray，则必须提供 periods。

windows{int, array_like, None}, 可选

每个相应周期的季节性平滑器的长度。必须是奇数，通常应 >= 7（默认）。如果为 None，则使用 7 + 4 * np.arange(1, n + 1, 1) 确定默认值，其中 n 是季节性成分的数量。

lmbda{float, str, None}, 可选

在分解之前应用于 endog 的 Box-Cox 变换的 lambda 参数。如果为 None，则不应用任何变换。如果为 auto，将估计一个使对数似然函数最大化的值。

iterateint, 可选

用于细化季节性成分的迭代次数。

stl_kwargsdict, 可选

传递给 STL 的参数。

return_componentsbool, 默认为 False

  • 如果为 False，将仅返回 MSTL 变换后的序列，等同于趋势加残差成分。结果序列的列数与输入相同。

  • 如果为 True，将返回分解的所有成分，

    一个包含 DataFrame 列的多变量序列（对应每个输入列）

    • “trend” - 趋势成分

    • “resid” - 去趋势、去季节化后的残差

    • “seasonal” - 单个季节性总和成分，如果

    periods 是 None。* “seasonal_<period>” - 季节性分量，

    其中 <period> 是一个表示周期的整数，periods 中的每个元素对应一个这样的分量

    所有分量在样本内加起来等于原始序列。

属性：
trend_pd.Series

在 fit 中看到的序列的趋势分量。

resid_pd.Series

在 fit 中看到的序列的残差分量。

seasonal_pd.DataFrame

如果 periods 是 None，则此属性包含一个单列，其中是 fit 中看到的 X 的所有季节性分量之和。如果 periods 是一个整数类型的数组，则此属性包含多个列 seasonal_<period>，每个列对应序列的一个季节性分量。

参考

[1] https://statsmodels.pythonlang.cn/dev/generated/statsmodels.tsa.seasonal.MSTL.html

示例

简单用例：将时间序列分解为趋势、季节性和残差分量 >>> import matplotlib.pyplot as plt # doctest: +SKIP >>> from sktime.datasets import load_airline >>> from sktime.transformations.series.detrend import MSTL >>> X = load_airline() >>> X.index = X.index.to_timestamp() >>> mstl = MSTL(return_components=True) >>> mstl.fit(X) MSTL(…) >>> res = mstl.transform(X) >>> res.plot() # doctest: +SKIP >>> plt.tight_layout() # doctest: +SKIP >>> plt.show() # doctest: +SKIP

MSTL 可以与预测器（forecaster）流水线化，用于多个去季节化预测。以下示例使用一个简单的趋势预测器，应用于使用 MSTL 在周期 2 和 12 进行去季节化的序列。在趋势预测之后，季节性分量会自动添加回预测中。 >>> from sktime.datasets import load_airline >>> from sktime.transformations.series.detrend import MSTL >>> from sktime.forecasting.trend import TrendForecaster >>> >>> mstl_trafo = MSTL(periods=[2, 12]) >>> mstl_deseason_fcst = mstl_trafo * TrendForecaster() >>> y = load_airline() >>> mstl_deseason_fcst.fit(y, fh=[1, 2, 3]) TransformedTargetForecaster(...) >>> y_pred = mstl_deseason_fcst.predict()

MSTL 也可以用于使用完整的分量分解进行预测。为此，在流水线化时设置 return_components=True。流水线中的预测器将接收一个多变量序列，其中分量作为列，即“trend”、“resid”、“seasonal_2”、“seasonal_12”。要对不同的分量应用不同的预测器，请使用 ColumnEnsembleForecaster；要对所有分量应用相同的预测器，只需与预测器进行流水线化即可。以下示例对趋势使用 TrendForecaster，对具有不同季节性的季节性分量使用季节性朴素预测器，对残差使用朴素预测器。 >>> from sktime.datasets import load_airline >>> from sktime.transformations.series.detrend import MSTL >>> from sktime.forecasting.compose import ColumnEnsembleForecaster >>> from sktime.forecasting.naive import NaiveForecaster >>> from sktime.forecasting.trend import TrendForecaster >>> >>> mstl_trafo_comp = MSTL(periods=[2, 12], return_components=True) >>> mstl_component_fcst = mstl_trafo_comp * ColumnEnsembleForecaster( … [ … (“trend”, TrendForecaster(), “trend”), … (“sp2”, NaiveForecaster(strategy=”last”, sp=2), “seasonal_2”), … (“sp12”, NaiveForecaster(strategy=”last”, sp=12), “seasonal_12”), … (“residual”, NaiveForecaster(strategy=”last”), “resid”), … ] … ) >>> y = load_airline() >>> mstl_component_fcst.fit(y, fh=[1, 2, 3]) TransformedTargetForecaster(...) >>> y_pred = mstl_component_fcst.predict()

方法

check_is_fitted([method_name])

检查估计器是否已拟合。

clone (克隆)()

获取具有相同超参数和配置的对象的克隆。

clone_tags(estimator[, tag_names])

将另一个对象的标签作为动态覆盖进行克隆。

create_test_instance([parameter_set])

使用第一个测试参数集构建类的实例。

create_test_instances_and_names([parameter_set])

创建所有测试实例的列表及其名称列表。

fit(X[, y]) (拟合)

将转换器拟合到 X，可选地拟合到 y。

fit_transform(X[, y]) (拟合并转换)

拟合数据，然后对其进行转换。

get_class_tag(tag_name[, tag_value_default]) (获取类标签)

从类获取类标签值，继承父类的标签级别。

get_class_tags (获取类标签列表)()

从类获取类标签列表，继承父类的标签级别。

get_config (获取配置)()

获取自身的配置标志。

get_fitted_params([deep]) (获取拟合参数)

获取拟合参数。

get_param_defaults (获取默认参数)()

获取对象的默认参数。

get_param_names([sort]) (获取参数名称)

获取对象的参数名称。

get_params([deep]) (获取参数)

获取此对象的参数值字典。

get_tag(tag_name[, tag_value_default, ...]) (获取标签)

从实例获取标签值，继承标签级别并应用覆盖。

get_tags (获取标签列表)()

从实例获取标签列表，继承标签级别并应用覆盖。

get_test_params([parameter_set]) (获取测试参数)

返回估计器的测试参数设置。

inverse_transform(X[, y]) (逆转换)

对 X 进行逆转换并返回逆转换后的版本。

is_composite (是否为复合对象)()

检查对象是否由其他 BaseObject 组成。

load_from_path(serial) (从路径加载)

从文件位置加载对象。

load_from_serial(serial) (从序列化加载)

从序列化的内存容器加载对象。

reset (重置)()

将对象重置到干净的初始化后状态。

save([path, serialization_format]) (保存)

将序列化的自身保存到字节类对象或 (.zip) 文件。

set_config(**config_dict) (设置配置)

将配置标志设置为给定值。

set_params(**params) (设置参数)

设置此对象的参数。

set_random_state([random_state, deep, ...]) (设置随机状态)

设置自身的 random_state 伪随机种子参数。

set_tags(**tag_dict) (设置标签)

将实例级别的标签覆盖设置为给定值。

transform(X[, y]) (转换)

转换 X 并返回转换后的版本。

update(X[, y, update_params]) (更新)

使用 X 更新转换器，可选地使用 y。
classmethod get_test_params(parameter_set='default')[source]#

返回估计器的测试参数设置。

参数:
parameter_setstr , default = “default”

要返回的测试参数集的名称，用于测试。如果某个值没有定义特殊参数，则将返回 "default" 集。目前，预测器没有保留值。

返回：
paramsdict or list of dict , default = {}

用于创建类的测试实例的参数 每个字典都是构建“有趣”测试实例的参数，即 MyClass(**params) 或 MyClass(**params[i]) 创建一个有效的测试实例。create_test_instance 使用 `params 中的第一个（或唯一的）字典

check_is_fitted(method_name=None)[source]#

检查估计器是否已拟合。

检查 _is_fitted 属性是否存在且为 True。在调用对象的 fit 方法时，应将 is_fitted 属性设置为 True。

如果没有，则引发 NotFittedError。

参数:
method_namestr, optional

调用此方法的名称。如果提供，错误消息将包含此信息。

引发：
NotFittedError

如果估计器尚未拟合。

clone()[source]#

获取具有相同超参数和配置的对象的克隆。

克隆是具有相同初始化后状态且没有共享引用的不同对象。此函数等同于返回 sklearn.clone 的 self。

等同于使用 self 的参数构造 type(self) 的新实例，即 type(self)(**self.get_params(deep=False))。

如果在 self 上设置了配置，则克隆也将具有与原始对象相同的配置，等同于调用 cloned_self.set_config(**self.get_config())。

其值也等同于调用 self.reset，但不同之处在于 clone 返回一个新对象，而不是像 reset 那样修改 self。

引发：
如果由于 __init__ 故障导致克隆不符合要求，则引发 RuntimeError。
clone_tags(estimator, tag_names=None)[source]#

将另一个对象的标签作为动态覆盖进行克隆。

每个 scikit-base 兼容对象都有一个标签字典。标签可用于存储对象的元数据或控制对象的行为。

标签是特定于实例 self 的键值对，它们是静态标志，在对象构建后不会更改。

clone_tags 从另一个对象 estimator 设置动态标签覆盖。

clone_tags 方法应仅在对象的 __init__ 方法中、构建期间或通过 __init__ 直接构建后调用。

动态标签设置为 estimator 中标签的值，名称在 tag_names 中指定。

tag_names 的默认值将 estimator 中的所有标签写入 self。

当前标签值可以通过 get_tags 或 get_tag 查看。

参数:
estimatorAn instance of :class:BaseObject or derived class
tag_namesstr or list of str, default = None

要克隆的标签名称。默认值 (None) 克隆 estimator 中的所有标签。

返回：
self (自身)

指向 self 的引用。

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

使用第一个测试参数集构建类的实例。

参数:
parameter_setstr, default=”default”

要返回的测试参数集的名称，用于测试。如果某个值没有定义特殊参数，则将返回 “default” 集。

返回：
instanceinstance of the class with default parameters
classmethod create_test_instances_and_names(parameter_set='default')[source]#

创建所有测试实例的列表及其名称列表。

参数:
parameter_setstr, default=”default”

要返回的测试参数集的名称，用于测试。如果某个值没有定义特殊参数，则将返回 “default” 集。

返回：
objslist of instances of cls

第 i 个实例是 cls(**cls.get_test_params()[i])

nameslist of str, same length as objs

第 i 个元素是测试中第 i 个对象的实例名称。如果实例多于一个，命名约定为 "{cls.__name__}-{i}"，否则为 "{cls.__name__}"

fit(X, y=None)[source]#

将转换器拟合到 X，可选地拟合到 y。

状态变化

将状态更改为“已拟合”（fitted）。

写入自身

  • 设置以“_”结尾的拟合模型属性，拟合属性可通过 get_fitted_params 查看。

  • 将 self.is_fitted 标志设置为 True。

  • 如果 self.get_tag("remember_data") 为 True，则将 X 记忆为 self._X，并强制转换为 self.get_tag("X_inner_mtype")。

参数:
Xtime series in sktime compatible data container format

用于拟合和转换的数据。

sktime 中的个体数据格式称为 mtype 规范，每种 mtype 实现一个抽象 scitype。

  • Series scitype = 个体时间序列。pd.DataFrame、pd.Series 或 np.ndarray (1D 或 2D)

  • Panel scitype = 时间序列集合。具有 2 级行 MultiIndex (instance, time) 的 pd.DataFrame，3D np.ndarray (instance, variable, time)，Series 类型的 pd.DataFrame 的 list。

  • Hierarchical scitype = 分层时间序列集合。具有 3 级或更多级行 MultiIndex (hierarchy_1, ..., hierarchy_n, time) 的 pd.DataFrame。

有关数据格式的更多详细信息，请参阅 mtype 术语表。有关用法，请参阅转换器教程 examples/03_transformers.ipynb

yoptional, data in sktime compatible data format, default=None

额外数据，例如用于转换的标签。如果 self.get_tag("requires_y") 为 True，则必须在 fit 中传递，不可选。有关所需格式，请参阅类文档字符串了解详情。

返回：
selfa fitted instance of the estimator
fit_transform(X, y=None)[source]#

拟合数据，然后对其进行转换。

将转换器拟合到 X 和 y，并返回 X 的转换版本。

状态变化

将状态更改为“已拟合”（fitted）。

写入自身： _is_fitted：标志设置为 True。 _X：X，如果 remember_data 标签为 True，则为 X 的强制复制。

如果可能，通过引用强制转换为内部类型或与 update_data 兼容的类型。

模型属性（以“_”结尾）：取决于估计器

参数:
Xtime series in sktime compatible data container format

用于拟合和转换的数据，以及要转换的数据。

sktime 中的个体数据格式称为 mtype 规范，每种 mtype 实现一个抽象 scitype。

  • Series scitype = 个体时间序列。pd.DataFrame、pd.Series 或 np.ndarray (1D 或 2D)

  • Panel scitype = 时间序列集合。具有 2 级行 MultiIndex (instance, time) 的 pd.DataFrame，3D np.ndarray (instance, variable, time)，Series 类型的 pd.DataFrame 的 list。

  • Hierarchical scitype = 分层时间序列集合。具有 3 级或更多级行 MultiIndex (hierarchy_1, ..., hierarchy_n, time) 的 pd.DataFrame。

有关数据格式的更多详细信息，请参阅 mtype 术语表。有关用法，请参阅转换器教程 examples/03_transformers.ipynb

yoptional, data in sktime compatible data format, default=None

额外数据，例如用于转换的标签。如果 self.get_tag("requires_y") 为 True，则必须在 fit 中传递，不可选。有关所需格式，请参阅类文档字符串了解详情。

返回：
X 的转换版本
类型取决于 X 的类型和 scitype:transform-output 标签
X | tf-output (转换输出) | 返回类型 |

|----------|————–|------------------------| | Series | Primitives (基本类型) | pd.DataFrame (1 行) | | Panel (面板) | Primitives | pd.DataFrame | | Series | Series | Series | | Panel | Series | Panel | | Series | Panel | Panel |

返回值中的实例对应于 X 中的实例
表中未列出的组合目前不支持
具体示例

  • 如果 X 是 Series (例如，pd.DataFrame)

并且 transform-output 是 Series，则返回值为相同 mtype 的单个 Series。示例：对单个序列进行去趋势

  • 如果 X 是 Panel (例如，pd-multiindex) 并且 transform-output

是 Series，则返回值为实例数量与 X 相同的 Panel（转换器应用于每个输入的 Series 实例）。示例：面板中的所有序列都单独进行去趋势

  • 如果 X 是 Series 或 Panel 并且 transform-output 是

Primitives，则返回值为行数与 X 中的实例数相同的 pd.DataFrame。示例：返回值的第 i 行包含第 i 个序列的均值和方差。

  • 如果 X 是 Series 并且 transform-output 是 Panel，

则返回值为类型为 pd-multiindex 的 Panel 对象。示例：输出的第 i 个实例是运行在 X 上的第 i 个窗口。

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

从类获取类标签值，继承父类的标签级别。

每个 scikit-base 兼容对象都有一个标签字典，用于存储对象的元数据。

get_class_tag 方法是一个类方法，它仅考虑类级别标签值和覆盖来检索标签的值。

它从对象中返回名称为 tag_name 的标签的值，并考虑标签覆盖，优先级降序如下：

  1. 在类的 _tags 属性中设置的标签。

  2. 在父类的 _tags 属性中设置的标签，

按继承顺序。

不考虑通过 set_tags 或 clone_tags 在实例上设置的动态标签覆盖。

要检索包含潜在实例覆盖的标签值，请改用 get_tag 方法。

参数:
tag_namestr

标签值的名称。

tag_value_defaultany type

如果找不到标签，则为默认/备用值。

返回：
tag_value (标签值)

self 中 tag_name 标签的值。如果找不到，则返回 tag_value_default。

classmethod get_class_tags()[source]#

从类获取类标签列表，继承父类的标签级别。

每个 scikit-base 兼容对象都有一个标签字典。标签可用于存储对象的元数据或控制对象的行为。

标签是特定于实例 self 的键值对，它们是静态标志，在对象构建后不会更改。

get_class_tags 方法是一个类方法，它仅考虑类级别标签值和覆盖来检索标签的值。

它返回一个字典，其键是类或其任何父类中设置的 _tags 属性的任何键。

值是相应的标签值，按优先级降序应用的覆盖顺序如下：

  1. 在类的 _tags 属性中设置的标签。

  2. 在父类的 _tags 属性中设置的标签，

按继承顺序。

实例可以根据超参数覆盖这些标签。

要检索包含潜在实例覆盖的标签，请改用 get_tags 方法。

不考虑通过 set_tags 或 clone_tags 在实例上设置的动态标签覆盖。

对于包含来自动态标签的覆盖，请使用 get_tags。

collected_tagsdict

标签名称: 标签值对的字典。通过嵌套继承从 _tags 类属性收集。不会被通过 set_tags 或 clone_tags 设置的动态标签覆盖。

get_config()[source]#

获取自身的配置标志。

配置是 self 的键值对，通常用作控制行为的临时标志。

get_config 返回动态配置，这些配置会覆盖默认配置。

默认配置在类或其父类的类属性 _config 中设置，并通过 set_config 设置的动态配置会覆盖它们。

在 clone 或 reset 调用下，配置会被保留。

返回：
config_dictdict

配置名称: 配置值对的字典。通过嵌套继承从 _config 类属性收集，然后从 _onfig_dynamic 对象属性获取任何覆盖和新标签。

get_fitted_params(deep=True)[source]#

获取拟合参数。

所需状态

要求状态为“已拟合”（fitted）。

参数:
deepbool, default=True

是否返回组件的拟合参数。

  • 如果为 True，将返回此对象的参数名称: 值字典，包括可拟合组件（= BaseEstimator 值参数）的拟合参数。

  • 如果为 False，将返回此对象的参数名称: 值字典，但不包括组件的拟合参数。

返回：
fitted_paramsdict with str-valued keys

拟合参数字典，paramname : paramvalue 键值对包括

  • 总是：此对象的所有拟合参数，如通过 get_param_names 获取的那样，值是此对象该键的拟合参数值

  • 如果 deep=True，还包含组件参数的键/值对，组件参数的索引为 [componentname]__[paramname]，componentname 的所有参数以其值作为 paramname 显示

  • 如果 deep=True，还包含任意级别的组件递归，例如 [componentname]__[componentcomponentname]__[paramname] 等

classmethod get_param_defaults()[source]#

获取对象的默认参数。

返回：
default_dict: dict[str, Any]

键是 cls 的所有在 __init__ 中定义了默认值的参数。值是在 __init__ 中定义的默认值。

classmethod get_param_names(sort=True)[source]#

获取对象的参数名称。

参数:
sortbool, default=True

是否按字母顺序（True）或按其在类 __init__ 中出现的顺序（False）返回参数名称。

返回：
param_names: list[str]

cls 的参数名称列表。如果 sort=False，则按其在类 __init__ 中出现的相同顺序排列。如果 sort=True，则按字母顺序排列。

get_params(deep=True)[source]#

获取此对象的参数值字典。

参数:
deepbool, default=True

是否返回组件的参数。

  • 如果 True，将返回此对象的参数名称: 值字典，包括组件（= BaseObject 值参数）的参数。

  • 如果 False，将返回此对象的参数名称: 值字典，但不包括组件的参数。

返回：
paramsdict with str-valued keys

参数字典，paramname : paramvalue 键值对包括

  • 总是：此对象的所有参数，如通过 get_param_names 获取的那样，值是此对象该键的参数值，值始终与构造时传递的值相同

  • 如果 deep=True，还包含组件参数的键/值对，组件参数的索引为 [componentname]__[paramname]，componentname 的所有参数以其值作为 paramname 显示

  • 如果 deep=True，还包含任意级别的组件递归，例如 [componentname]__[componentcomponentname]__[paramname] 等

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

从实例获取标签值，继承标签级别并应用覆盖。

每个 scikit-base 兼容对象都有一个标签字典。标签可用于存储对象的元数据或控制对象的行为。

标签是特定于实例 self 的键值对，它们是静态标志，在对象构建后不会更改。

get_tag 方法从实例中检索名称为 tag_name 的单个标签的值，并考虑标签覆盖，优先级降序如下：

  1. 通过 set_tags 或 clone_tags 在实例上设置的标签，

在实例构造时。

  1. 在类的 _tags 属性中设置的标签。

  2. 在父类的 _tags 属性中设置的标签，

按继承顺序。

参数:
tag_namestr

要检索的标签名称

tag_value_defaultany type, optional; default=None

如果找不到标签，则为默认/备用值

raise_errorbool

找不到标签时是否引发 ValueError

返回：
tag_valueAny

self 中 tag_name 标签的值。如果找不到，如果 raise_error 为 True 则引发错误，否则返回 tag_value_default。

引发：
ValueError, 如果 raise_error 为 True。

如果 tag_name 不在 self.get_tags().keys() 中，则会引发 ValueError。

get_tags()[source]#

从实例获取标签列表，继承标签级别并应用覆盖。

每个 scikit-base 兼容对象都有一个标签字典。标签可用于存储对象的元数据或控制对象的行为。

标签是特定于实例 self 的键值对，它们是静态标志，在对象构建后不会更改。

get_tags 方法返回一个标签字典，其键是类或其任何父类中设置的 _tags 的任何属性的键，或者通过 set_tags 或 clone_tags 设置的标签。

值是相应的标签值，按优先级降序应用的覆盖顺序如下：

  1. 通过 set_tags 或 clone_tags 在实例上设置的标签，

在实例构造时。

  1. 在类的 _tags 属性中设置的标签。

  2. 在父类的 _tags 属性中设置的标签，

按继承顺序。

返回：
collected_tagsdict

标签名称: 标签值对的字典。通过嵌套继承从 _tags 类属性收集，然后从 _tags_dynamic 对象属性获取任何覆盖和新标签。

inverse_transform(X, y=None)[source]#

对 X 进行逆转换并返回逆转换后的版本。

当前假设只有具有以下标签的转换器

“scitype:transform-input”=”Series”, “scitype:transform-output”=”Series”,

具有 inverse_transform 方法。

所需状态

要求状态为“已拟合”（fitted）。

访问自身属性

  • 以“_”结尾的拟合模型属性。

  • self.is_fitted，必须为 True

参数:
Xtime series in sktime compatible data container format

用于拟合和转换的数据。

sktime 中的个体数据格式称为 mtype 规范，每种 mtype 实现一个抽象 scitype。

  • Series scitype = 个体时间序列。pd.DataFrame、pd.Series 或 np.ndarray (1D 或 2D)

  • Panel scitype = 时间序列集合。具有 2 级行 MultiIndex (instance, time) 的 pd.DataFrame，3D np.ndarray (instance, variable, time)，Series 类型的 pd.DataFrame 的 list。

  • Hierarchical scitype = 分层时间序列集合。具有 3 级或更多级行 MultiIndex (hierarchy_1, ..., hierarchy_n, time) 的 pd.DataFrame。

有关数据格式的更多详细信息，请参阅 mtype 术语表。有关用法，请参阅转换器教程 examples/03_transformers.ipynb

yoptional, data in sktime compatible data format, default=None

额外数据，例如用于转换的标签。某些转换器需要此参数，详情请参阅类文档字符串。

返回：
X 的逆转换版本

与 X 类型相同，并符合 mtype 格式规范

is_composite()[source]#

检查对象是否由其他 BaseObject 组成。

复合对象是指包含其他对象作为参数的对象。在实例上调用此方法，因为不同实例可能有所不同。

返回：
compositebool

对象是否有任何参数的值是 BaseObject 的派生实例。

property is_fitted[source]#

fit 是否已被调用。

检查对象的 _is_fitted` 属性，该属性在对象构造期间应初始化为 ``False，并在调用对象的 fit 方法时设置为 True。

返回：
bool (布尔值)

估计器是否已 fit (拟合)。

classmethod load_from_path(serial)[source]#

从文件位置加载对象。

参数:
serialresult of ZipFile(path).open(“object)
返回：
反序列化的自身，结果输出到 path，来自 cls.save(path)
classmethod load_from_serial(serial)[source]#

从序列化的内存容器加载对象。

参数:
serial1st element of output of cls.save(None)
返回：
反序列化的自身，结果输出为 serial，来自 cls.save(None)
reset()[source]#

将对象重置到干净的初始化后状态。

结果是将 self 设置为构造函数调用后直接所处的状态，具有相同的超参数。通过 set_config 设置的配置值也会被保留。

reset 调用会删除任何对象属性，除了

  • 超参数 = 写入 self 的 __init__ 参数，例如 self.paramname，其中 paramname 是 __init__ 的参数

  • 包含双下划线的对象属性，即字符串“__”。例如，名为“__myattr”的属性会被保留。

  • 配置属性，配置会不变地保留。也就是说，在 reset 调用之前和之后 get_config 的结果是相等的。

类和对象方法以及类属性也不受影响。

等同于 clone，不同之处在于 reset 修改 self 而不是返回一个新对象。

在调用 self.reset() 后，self 的值和状态与构造函数调用``type(self)(**self.get_params(deep=False))`` 后获得的对象相等。

返回：
self (自身)

将类的实例重置到干净的初始化后状态，但保留当前的超参数值。

save(path=None, serialization_format='pickle')[source]#

将序列化的自身保存到字节类对象或 (.zip) 文件。

行为：如果 path 为 None，则返回内存中的序列化自身；如果 path 是文件位置，则将自身作为 zip 文件存储在该位置

保存的文件是包含以下内容的 zip 文件： _metadata - 包含自身的类，即 type(self) _obj - 序列化的自身。此类使用默认序列化方式 (pickle)。

参数:
pathNone or file location (str or Path)

如果为 None，自身将保存到内存对象；如果为文件位置，自身将保存到该文件位置。如果

  • path=”estimator”，则将在当前工作目录 (cwd) 生成一个 zip 文件 estimator.zip。

  • path=”/home/stored/estimator”，则将在 /home/stored/ 中生成一个 zip 文件 estimator.zip。

存储在 /home/stored/ 中。

serialization_format: str, default = “pickle”

用于序列化的模块。可用选项包括“pickle”和“cloudpickle”。请注意，非默认格式可能需要安装其他软依赖项。

返回：
如果 path 为 None - 内存中的序列化自身
如果 path 为文件位置 - 指向文件的 ZipFile
set_config(**config_dict)[source]#

将配置标志设置为给定值。

参数:
config_dictdict

配置名称: 配置值对的字典。有效的配置、值及其含义如下所示

displaystr, “diagram” (default), or “text”

jupyter 内核如何显示自身实例

  • “diagram” = html 方框图表示

  • “text” = 字符串打印输出

print_changed_onlybool, default=True

打印自身时是否只列出与默认值不同的自身参数（False），还是列出所有参数名称和值（False）。不嵌套，即只影响自身而不影响组件估计器。

warningsstr, “on” (default), or “off”

是否引发警告，仅影响 sktime 中的警告

  • “on” = 将引发 sktime 中的警告

  • “off” = 不会引发 sktime 中的警告

backend:parallelstr, optional, default=”None”

广播/向量化时用于并行化的后端，以下之一：

  • “None”：顺序执行循环，简单的列表推导

  • “loky”、“multiprocessing”和“threading”：使用 joblib.Parallel

  • “joblib”：自定义和第三方 joblib 后端，例如 spark

  • “dask”：使用 dask，需要在环境中安装 dask 包

  • “ray”：使用 ray，需要在环境中安装 ray 包

backend:parallel:paramsdict, optional, default={} (no parameters passed)

作为配置传递给并行化后端的附加参数。有效键取决于 backend:parallel 的值

  • “None”：无附加参数，backend_params 被忽略

  • “loky”、“multiprocessing”和“threading”：默认的 joblib 后端，这里可以传递 joblib.Parallel 的任何有效键，例如 n_jobs，但 backend 除外，它由 backend 直接控制。如果未传递 n_jobs，则默认为 -1，其他参数将默认为 joblib 的默认值。

  • “joblib”：自定义和第三方 joblib 后端，例如 spark。这里可以传递 joblib.Parallel 的任何有效键，例如 n_jobs，在这种情况下，backend 必须作为 backend_params 的一个键传递。如果未传递 n_jobs，则默认为 -1，其他参数将默认为 joblib 的默认值。

  • “dask”：可以传递 dask.compute 的任何有效键，例如 scheduler

  • “ray”：可以传递以下键

    • “ray_remote_args”：ray.init 的有效键字典

    • “shutdown_ray”：布尔值，默认值=True；False 防止 ray 在并行化后

      关闭。

    • “logger_name”：字符串，默认值=“ray”；要使用的日志记录器名称。

    • “mute_warnings”：布尔值，默认值=False；如果为 True，则抑制警告

input_conversionstr, one of “on” (default), “off”, or valid mtype string

控制输入检查和转换，适用于 _fit、_transform、_inverse_transform、_update

  • "on" - 执行输入检查和转换

  • "off" - 在将数据传递给内部方法之前，不执行输入检查和转换

  • 有效的 mtype 字符串 - 输入被假定为指定的 mtype，执行转换但不进行检查

output_conversionstr, one of “on”, “off”, valid mtype string

控制 _transform、_inverse_transform 的输出转换

  • "on" - 如果 input_conversion 为“on”，则执行输出转换

  • "off" - 直接返回 _transform、_inverse_transform 的输出

  • 有效的 mtype 字符串 - 输出转换为指定的 mtype

返回：
selfreference to self.

注意

改变对象状态，将 config_dict 中的配置复制到 self._config_dynamic。

set_params(**params)[source]#

设置此对象的参数。

此方法适用于简单的 skbase 对象以及复合对象。参数键字符串 <component>__<parameter> 可用于复合对象（即包含其他对象的对象），以访问组件 <component> 中的 <parameter>。如果引用明确（例如，没有两个组件的参数名称相同），也可以使用不带 <component>__ 的字符串 <parameter>。

参数:
paramsdict

BaseObject 参数，键必须是 <component>__<parameter> 字符串。如果 __ 后缀在 get_params 键中唯一，则可以作为完整字符串的别名。

返回：
selfreference to self (after parameters have been set)
set_random_state(random_state=None, deep=True, self_policy='copy')[source]#

设置自身的 random_state 伪随机种子参数。

通过 self.get_params 查找名为 random_state 的参数，并通过 set_params 将它们设置为从 random_state 派生的整数。这些整数通过 sample_dependent_seed 从链式哈希中采样，并保证种子随机生成器的伪随机独立性。

根据 self_policy 应用于 self 中的 random_state 参数，并且仅当 deep=True 时应用于其余组件对象。

注意：即使 self 没有 random_state 参数，或者任何组件都没有 random_state 参数，也会调用 set_params。因此，set_random_state 将重置任何 scikit-base 对象，即使是没有 random_state 参数的对象。

参数:
random_stateint, RandomState instance or None, default=None

伪随机数生成器，用于控制随机整数的生成。传递整数可在多次函数调用中获得可重现的输出。

deepbool, default=True

是否在 skbase 对象值参数（即组件估计器）中设置随机状态。

  • 如果为 False，则仅设置 self 的 random_state 参数（如果存在）。

  • 如果为 True，则也会设置组件对象中的 random_state 参数。

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

  • “copy” : 将 self.random_state 设置为输入的 random_state

  • “keep” : 保持 self.random_state 不变

  • “new” : 将 self.random_state 设置为新的随机状态，

从输入的 random_state 派生，并且通常与它不同

返回：
selfreference to self
set_tags(**tag_dict)[source]#

将实例级别的标签覆盖设置为给定值。

每个 scikit-base 兼容对象都有一个标签字典，用于存储对象的元数据。

标签是特定于实例 self 的键值对，它们是静态标志，在对象构造后不会更改。它们可用于元数据检查或控制对象的行为。

set_tags 将动态标签覆盖设置为 tag_dict 中指定的值，其中键是标签名称，字典值是要设置的标签值。

set_tags 方法应仅在对象的 __init__ 方法中、构建期间或通过 __init__ 直接构建后调用。

当前标签值可以通过 get_tags 或 get_tag 查看。

参数:
tag_dictdict

标签名称: 标签值对的字典。

返回：
Self (自身)

指向自身的引用。

transform(X, y=None)[source]#

转换 X 并返回转换后的版本。

所需状态

要求状态为“已拟合”（fitted）。

访问自身属性

  • 以“_”结尾的拟合模型属性。

  • self.is_fitted，必须为 True

参数:
Xtime series in sktime compatible data container format

要转换的数据。

sktime 中的个体数据格式称为 mtype 规范，每种 mtype 实现一个抽象 scitype。

  • Series scitype = 个体时间序列。pd.DataFrame、pd.Series 或 np.ndarray (1D 或 2D)

  • Panel scitype = 时间序列集合。具有 2 级行 MultiIndex (instance, time) 的 pd.DataFrame，3D np.ndarray (instance, variable, time)，Series 类型的 pd.DataFrame 的 list。

  • Hierarchical scitype = 分层时间序列集合。具有 3 级或更多级行 MultiIndex (hierarchy_1, ..., hierarchy_n, time) 的 pd.DataFrame。

有关数据格式的更多详细信息，请参阅 mtype 术语表。有关用法，请参阅转换器教程 examples/03_transformers.ipynb

yoptional, data in sktime compatible data format, default=None

额外数据，例如用于转换的标签。某些转换器需要此参数，详情请参阅类文档字符串。

返回：
X 的转换版本
类型取决于 X 的类型和 scitype:transform-output 标签

transform (转换)

X

-output (输出)

返回类型

Series (序列)

Primitives (基本类型)

pd.DataFrame (1 行)

Panel (面板)

Primitives (基本类型)

pd.DataFrame

Series (序列)

Series (序列)

Series (序列)

Panel (面板)

Series (序列)

Panel (面板)

Series (序列)

Panel (面板)

Panel (面板)
返回值中的实例对应于 X 中的实例
表中未列出的组合目前不支持
具体示例

  • 如果 X 是 Series (例如，pd.DataFrame)

并且 transform-output 是 Series，则返回值为相同 mtype 的单个 Series。示例：对单个序列进行去趋势

  • 如果 X 是 Panel (例如，pd-multiindex) 并且 transform-output

是 Series，则返回值为实例数量与 X 相同的 Panel（转换器应用于每个输入的 Series 实例）。示例：面板中的所有序列都单独进行去趋势

  • 如果 X 是 Series 或 Panel 并且 transform-output 是

Primitives，则返回值为行数与 X 中的实例数相同的 pd.DataFrame。示例：返回值的第 i 行包含第 i 个序列的均值和方差。

  • 如果 X 是 Series 并且 transform-output 是 Panel，

则返回值为类型为 pd-multiindex 的 Panel 对象。示例：输出的第 i 个实例是运行在 X 上的第 i 个窗口。

update(X, y=None, update_params=True)[source]#

使用 X 更新转换器，可选地使用 y。

所需状态

要求状态为“已拟合”（fitted）。

访问自身属性

  • 以“_”结尾的拟合模型属性。

  • self.is_fitted，必须为 True

写入自身

  • 以“_”结尾的拟合模型属性。

  • 如果 remember_data 标签为 True，则通过 update_data 将 self._X 更新为 X 中的值。

参数:
Xtime series in sktime compatible data container format

用于更新转换的数据

sktime 中的个体数据格式称为 mtype 规范，每种 mtype 实现一个抽象 scitype。

  • Series scitype = 个体时间序列。pd.DataFrame、pd.Series 或 np.ndarray (1D 或 2D)

  • Panel scitype = 时间序列集合。具有 2 级行 MultiIndex (instance, time) 的 pd.DataFrame，3D np.ndarray (instance, variable, time)，Series 类型的 pd.DataFrame 的 list。

  • Hierarchical scitype = 分层时间序列集合。具有 3 级或更多级行 MultiIndex (hierarchy_1, ..., hierarchy_n, time) 的 pd.DataFrame。

有关数据格式的更多详细信息，请参阅 mtype 术语表。有关用法，请参阅转换器教程 examples/03_transformers.ipynb

yoptional, data in sktime compatible data format, default=None

额外数据，例如用于转换的标签。某些转换器需要此参数，详情请参阅类文档字符串。

返回：
selfa fitted instance of the estimator