WindowSummarizer#

class WindowSummarizer(lag_feature=None, n_jobs=-1, target_cols=None, truncate=None)[source]#

用于提取时间序列特征的变换器。

WindowSummarizer 根据提供的窗口汇总器、窗口移动和窗口长度字典将输入时间序列转换为特征。

参数:
n_jobsint, 可选 (默认为 -1)

用于并行应用窗口函数的作业数。-1 表示使用所有处理器。

target_cols: list of str, 可选 (默认为 None)

指定在 X 中对哪些列应用窗口函数。None 将对第一列应用。

lag_feature: dict of str and list, 可选 (默认为包含第一个滞后的字典)

字典，以要使用的函数类型作为键，以参数 window 作为值。对于函数 lag，参数 window 是一个整数或整数列表，表示要使用的 lag 值。对于所有其他函数，参数 window 是一个包含参数 lag 和 window length` 的列表。lag 定义了窗口从过去多久开始，window length 定义了应用函数的窗口长度。对于多个不同的窗口，提供一个列表的列表。

请参考下方使用以下符号表示的逻辑图示

z = 窗口汇总所基于的时间戳。

如果 lag 在 0 和 1-window_length 之间，则属于窗口的一部分，否则不属于窗口。

x = 窗口中被汇总的（其他）时间戳

* = 观察值，过去或未来的，不属于窗口

汇总函数应用于由 x 和可能包含 z 组成的时间窗口。

对于 window = [1, 3]，我们有一个 lag 为 1 且 window_length 为 3，用于选择观察到的最后三天（不包含 z）。汇总函数在此类窗口上应用，如下所示

|---------------------------|
| * * * * * * * * x x x z * |
|---------------------------|

对于 window = [0, 3]，我们有一个 lag 为 0 且 window_length 为 3，用于选择观察到的最后三天（包含 z）。汇总函数在此类窗口上应用，如下所示

|---------------------------|
| * * * * * * * * x x z * * |
|---------------------------|

特殊情况 lag：由于滞后频繁使用且窗口长度是冗余的，你只需要提供 lag 值的列表。因此 window = [1] 将产生第一个滞后

|---------------------------|
| * * * * * * * * * * x z * |
|---------------------------|

而 window = [1, 4] 将产生第一个和第四个滞后

|---------------------------|
| * * * * * * * x * * x z * |
|---------------------------|
key: 可以是自定义函数调用（由用户提供）或者
对应于原生 pandas 窗口函数的字符串

  • “sum”,

  • “mean”,

  • “median”,

  • “std”,

  • “var”,

  • “kurt”,

  • “min”,

  • “max”,

  • “corr”,

  • “cov”,

  • “skew”,

  • “sem”

另请参阅: https://pandas.ac.cn/docs/reference/window.html。

生成的列将以提供的 key 命名，后跟 lag 参数和 window_length（如果不是 lag）。

第二个值 (window): 整数列表

包含 lag 和 window_length 参数的列表。

truncate: str, 可选 (默认为 None)

定义如何处理因在长于剩余数据历史记录的窗口上应用 lag_feature 字典中的函数而产生的 NA。例如，lag 配置 [14, 7] 不能完全应用于目标列的前 20 个观察值。lag_feature [[8, 14], [1, 28]] 不能正确应用于目标列的前 21 或 28 个观察值。处理这些 NA 的可能值

  • None

  • “bfill”

None 将保留生成的 NA，并留给用户选择可以正确处理缺失值观察的估计器；“bfill” 将通过向后填充第一个观察值来填充 NA。

返回值:
X: pd.DataFrame

包含所有已变换的列以及未变换的列。已变换列的原始输入将被丢弃。

self: 对自身的引用
属性:
truncate_startint

有关将特定长度的窗口应用于过去观察值导致的截断的更详细解释，请参见 参数 - truncate 部分。当 truncate 设置为 None 时，Truncate_start 将给出 lag_feature 的所有参数在填充 NA 的观察值中的最大值。

示例

>>> import pandas as pd
>>> from sktime.transformations.series.summarize import WindowSummarizer
>>> from sktime.datasets import load_airline, load_longley
>>> from sktime.forecasting.naive import NaiveForecaster
>>> from sktime.forecasting.base import ForecastingHorizon
>>> from sktime.forecasting.compose import ForecastingPipeline
>>> from sktime.split import temporal_train_test_split
>>> y = load_airline()
>>> kwargs = {
...     "lag_feature": {
...         "lag": [1],
...         "mean": [[1, 3], [3, 6]],
...         "std": [[1, 4]],
...     }
... }
>>> transformer = WindowSummarizer(**kwargs)
>>> y_transformed = transformer.fit_transform(y)

转换多个外生特征列的示例

>>> y, X = load_longley()
>>> y_train, y_test, X_train, X_test = temporal_train_test_split(y, X)
>>> fh = ForecastingHorizon(X_test.index, is_relative=False)
>>> # Example transforming only X
>>> pipe = ForecastingPipeline(
...     steps=[
...         ("a", WindowSummarizer(n_jobs=1, target_cols=["POP", "GNPDEFL"])),
...         ("b", WindowSummarizer(n_jobs=1, target_cols=["GNP"], **kwargs)),
...         ("forecaster", NaiveForecaster(strategy="drift")),
...     ]
... )
>>> pipe_return = pipe.fit(y_train, X_train)
>>> y_pred1 = pipe_return.predict(fh=fh, X=X_test)

转换多个外生特征列以及 y 列的示例

>>> Z_train = pd.concat([X_train, y_train], axis=1)
>>> Z_test = pd.concat([X_test, y_test], axis=1)
>>> pipe = ForecastingPipeline(
...     steps=[
...         ("a", WindowSummarizer(n_jobs=1, target_cols=["POP", "TOTEMP"])),
...         ("b", WindowSummarizer(**kwargs, n_jobs=1, target_cols=["GNP"])),
...         ("forecaster", NaiveForecaster(strategy="drift")),
...     ]
... )
>>> pipe_return = pipe.fit(y_train, Z_train)
>>> y_pred2 = pipe_return.predict(fh=fh, X=Z_test)

方法

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

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

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" 集。

返回值:
paramsdict 或 dict 列表, 默认为 {}

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

check_is_fitted(method_name=None)[source]#

检查估计器是否已拟合。

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

如果不是，则引发 NotFittedError。

参数:
method_namestr, 可选

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

抛出:
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` 设置动态标签覆盖。

只有在对象的 __init__ 方法中，在构造期间，或在通过 __init__` 直接构造后，才应调用 clone_tags 方法。

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

tag_names 的默认设置是将 estimator 中的所有标签写入 self`。

可以通过 get_tags 或 get_tag` 检查当前的标签值。

参数:
estimator:class:BaseObject 或派生类的实例
tag_namesstr 或 str 列表, 默认为 None

要克隆的标签名称。默认设置 (None`) 克隆来自 estimator` 的所有标签。

返回值:
self

对 self` 的引用。

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

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

参数:
parameter_setstr, 默认为“default”

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

返回值:
instance具有默认参数的类实例
classmethod create_test_instances_and_names(parameter_set='default')[source]#

创建所有测试实例的列表以及它们的名称列表。

参数:
parameter_setstr, 默认为“default”

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

返回值:
objscls 实例列表

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

namesstr 列表, 与 objs 长度相同

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

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

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

状态改变

将状态改为“已拟合”。

写入自身

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

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

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

参数:
X符合 sktime 数据容器格式的时间序列

用于拟合变换的数据。

sktime 中的各种数据格式是所谓的 mtype 规范，每种 mtype 实现一个抽象的 scitype`。

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

  • Panel scitype = 时间序列集合。具有两层行 MultiIndex (实例, 时间) 的 pd.DataFrame, 3D np.ndarray (实例, 变量, 时间), Series 类型的 pd.DataFrame 列表。

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

有关数据格式的更多详细信息，请参见 mtype 词汇表。有关用法，请参见变换器教程 examples/03_transformers.ipynb`

y可选, 符合 sktime 数据格式的数据, 默认为 None

附加数据，例如用于变换的标签。如果 self.get_tag("requires_y") 为 True`，则必须在 fit 中传递，不可选。所需格式的详细信息请参见类文档字符串。

返回值:
self估计器的一个已拟合实例
fit_transform(X, y=None)[source]#

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

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

状态改变

将状态改为“已拟合”。

写入自身: _is_fitted : 标志设置为 True。_X : X, X 的强制类型副本，如果 remember_data 标签为 True

可能在可能的情况下强制转换为内部类型或通过引用转换为 update_data 兼容类型

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

参数:
X符合 sktime 数据容器格式的时间序列

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

sktime 中的各种数据格式是所谓的 mtype 规范，每种 mtype 实现一个抽象的 scitype`。

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

  • Panel scitype = 时间序列集合。具有两层行 MultiIndex (实例, 时间) 的 pd.DataFrame, 3D np.ndarray (实例, 变量, 时间), Series 类型的 pd.DataFrame 列表。

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

有关数据格式的更多详细信息，请参见 mtype 词汇表。有关用法，请参见变换器教程 examples/03_transformers.ipynb`

y可选, 符合 sktime 数据格式的数据, 默认为 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。示例：对单个序列进行去趋势

is Series, then the return is Panel with same number of instances as X (the transformer is applied to each input Series instance). Example: all series in the panel are detrended individually

  • 如果 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_default任意类型

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

返回值:
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 在实例上设置的动态标签覆盖。

For including overrides from dynamic tags, use 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]#

获取拟合参数。

所需状态

要求状态为“已拟合”。

参数:
deepbool, 默认为 True

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

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

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

返回值:
fitted_params具有 str 值键的 dict

拟合参数的字典，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]

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

classmethod get_param_names(sort=True)[source]#

获取对象的参数名称。

参数:
sortbool, 默认为 True

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

返回值:
param_names: list[str]

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

get_params(deep=True)[source]#

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

参数:
deepbool, 默认为 True

是否返回组件的参数。

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

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

返回值:
params具有 str 值键的 dict

参数字典，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_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。

所需状态

要求状态为“已拟合”。

在自身中访问

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

  • self.is_fitted, 必须为 True

参数:
X符合 sktime 数据容器格式的时间序列

用于拟合变换的数据。

sktime 中的各种数据格式是所谓的 mtype 规范，每种 mtype 实现一个抽象的 scitype`。

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

  • Panel scitype = 时间序列集合。具有两层行 MultiIndex (实例, 时间) 的 pd.DataFrame, 3D np.ndarray (实例, 变量, 时间), Series 类型的 pd.DataFrame 列表。

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

有关数据格式的更多详细信息，请参见 mtype 词汇表。有关用法，请参见变换器教程 examples/03_transformers.ipynb`

y可选, 符合 sktime 数据格式的数据, 默认为 None

附加数据，例如用于变换的标签。一些变换器需要此项，详细信息请参见类文档字符串。

返回值:
X 的逆变换版本

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

is_composite()[source]#

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

复合对象是包含对象的对象，作为参数。在实例上调用，因为这可能因实例而异。

返回值:
composite: bool

对象是否有任何参数的值是 BaseObject 后代实例。

property is_fitted[source]#

fit 是否已被调用。

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

返回值:
bool

估计器是否已 fit。

classmethod load_from_path(serial)[source]#

从文件位置加载对象。

参数:
serialZipFile(path).open(“object) 的结果
返回值:
cls.save(path) 在 path 处输出的解序列化 self。
classmethod load_from_serial(serial)[source]#

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

参数:
serialcls.save(None) 输出的第一个元素
返回值:
cls.save(None) 输出的解序列化 self，结果为 serial。
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，则返回一个内存中的序列化 self；如果 path 是文件位置，则将 self 以 zip 文件形式存储在该位置

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

参数:
pathNone 或文件位置 (str 或 Path)

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

  • path=”estimator”，则会在当前工作目录下生成一个 zip 文件 estimator.zip。

  • path=”/home/stored/estimator”，则会在 /home/stored/ 中保存一个 zip 文件 estimator.zip。

存储在 /home/stored/ 中。

serialization_format: str，默认为 “pickle”

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

返回值:
如果 path 为 None - 内存中的序列化 self
如果 path 为文件位置 - ZipFile 对象引用该文件
set_config(**config_dict)[source]#

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

参数:
config_dictdict

配置名称 : 配置值对的字典。以下列出了有效的配置、值及其含义

displaystr，“diagram”（默认），或 “text”

jupyter kernel 如何显示 self 的实例

  • “diagram” = HTML 框图表示

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

print_changed_onlybool，默认为 True

打印 self 时是否只列出与默认值不同的 self 参数 (False)，或列出所有参数名称和值 (False)。不嵌套，即仅影响 self 而不影响组件估计器。

warningsstr，“on”（默认），或 “off”

是否触发警告，仅影响来自 sktime 的警告

  • “on” = 将触发来自 sktime 的警告

  • “off” = 将不触发来自 sktime 的警告

backend:parallelstr，可选，默认为 “None”

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

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

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

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

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

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

backend:parallel:paramsdict，可选，默认为 {} (不传递参数)

作为配置传递给并行化后端的附加参数。有效的键取决于 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”：bool，默认为 True；False 会阻止 ray 在并行化后关闭。

      在并行化后关闭。

    • “logger_name”：str，默认为 “ray”；要使用的日志记录器名称。

    • “mute_warnings”：bool，默认为 False；如果为 True，则抑制警告

input_conversionstr，选项之一：“on”（默认）、“off” 或有效的 mtype 字符串

控制 _fit、_transform、_inverse_transform、_update 的输入检查和转换

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

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

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

output_conversionstr，选项之一：“on”、“off”、有效的 mtype 字符串

控制 _transform、_inverse_transform 的输出转换

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

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

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

返回值:
self对自身的引用。

备注

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

set_params(**params)[source]#

设置此对象的参数。

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

参数:
**paramsdict

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

返回值:
self对自身的引用 (参数已设置后)
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 实例或 None，默认为 None

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

deepbool, 默认为 True

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

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

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

self_policystr，选项之一：{“copy”, “keep”, “new”}，默认为 “copy”

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

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

  • “new”：self.random_state 设置为一个新的随机状态，

源自输入的 random_state，并且通常与它不同

返回值:
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 并返回变换后的版本。

所需状态

要求状态为“已拟合”。

在自身中访问

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

  • self.is_fitted, 必须为 True

参数:
X符合 sktime 数据容器格式的时间序列

要转换的数据。

sktime 中的各种数据格式是所谓的 mtype 规范，每种 mtype 实现一个抽象的 scitype`。

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

  • Panel scitype = 时间序列集合。具有两层行 MultiIndex (实例, 时间) 的 pd.DataFrame, 3D np.ndarray (实例, 变量, 时间), Series 类型的 pd.DataFrame 列表。

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

有关数据格式的更多详细信息，请参见 mtype 词汇表。有关用法，请参见变换器教程 examples/03_transformers.ipynb`

y可选, 符合 sktime 数据格式的数据, 默认为 None

附加数据，例如用于变换的标签。一些变换器需要此项，详细信息请参见类文档字符串。

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

转换

X

-输出

返回类型

序列 (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。示例：对单个序列进行去趋势

is Series, then the return is Panel with same number of instances as X (the transformer is applied to each input Series instance). Example: all series in the panel are detrended individually

  • 如果 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。

所需状态

要求状态为“已拟合”。

在自身中访问

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

  • self.is_fitted, 必须为 True

写入自身

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

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

参数:
X符合 sktime 数据容器格式的时间序列

用于更新转换的数据

sktime 中的各种数据格式是所谓的 mtype 规范，每种 mtype 实现一个抽象的 scitype`。

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

  • Panel scitype = 时间序列集合。具有两层行 MultiIndex (实例, 时间) 的 pd.DataFrame, 3D np.ndarray (实例, 变量, 时间), Series 类型的 pd.DataFrame 列表。

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

有关数据格式的更多详细信息，请参见 mtype 词汇表。有关用法，请参见变换器教程 examples/03_transformers.ipynb`

y可选, 符合 sktime 数据格式的数据, 默认为 None

附加数据，例如用于变换的标签。一些变换器需要此项，详细信息请参见类文档字符串。

返回值:
self估计器的一个已拟合实例