PAA#

class PAA(frames=8, frame_size=0)[源代码][源代码]#

分段聚合近似变换器 (PAA)。

PAA [1] 是一种降维技术，它将时间序列分成帧并取它们的均值。此实现提供了两种变体：

1) the original, which takes the desired number of frames and can set the frame size to a fraction to support cases where the time series cannot be divided into the frames equally. 2) a variant that takes the desired frame size and can decrease the frame size of the last frame to support cases where the time series is not evenly divisible into frames.

参数:

框架int, 可选 (默认=8, 如果 frame_size=0 则大于等于1): 变换后的时间序列长度。如果设置了 frame_size ，则忽略此项。
frame_sizeint, 可选 (默认=0, 大于等于0): 计算平均值时所用的帧数长度。如果大于0，则覆盖 frames。

属性:

is_fitted: 是否已调用 fit。

参考文献

[1]

Keogh, E., Chakrabarti, K., Pazzani, M., 和 Mehrotra, S. 降维在大时间序列数据库中快速相似性搜索的应用。知识与信息系统 3, 263-286 (2001). https://doi.org/10.1007/PL00011669

示例

>>> from numpy import arange
>>> from sktime.transformations.series.paa import PAA

>>> X = arange(10)
>>> paa = PAA(frames=3)
>>> paa.fit_transform(X)  
array([1.2, 4.5, 7.8])
>>> paa = PAA(frame_size=3)  
array([1, 4, 7, 9])

方法

`check_is_fitted`()	检查估计器是否已被拟合。
`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`()	获取 self 的配置标志
`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, ...])	为 self 设置 random_state 伪随机种子参数。
`set_tags`(**tag_dict)	将动态标签设置为给定值。
`transform`(X[, y])	转换 X 并返回一个转换后的版本。
`update`(X[, y, update_params])	使用 X 更新转换器，可选地使用 y。

classmethod get_test_params(parameter_set='default')[源代码][源代码]#

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

参数:

参数集str, 默认值=”default”: 要返回的测试参数集的名称，用于测试中。如果没有为某个值定义特殊参数，将返回 "default" 集。目前没有为转换器保留的值。

返回:

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

check_is_fitted()[源代码]#

检查估计器是否已被拟合。

引发:

NotFittedError: 如果估计器尚未拟合。

clone()[源代码]#

获取具有相同超参数的对象副本。

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

引发:

如果克隆不符合规范，由于 __init__ 存在错误，将引发 RuntimeError。

注释

如果成功，值等于 type(self)(**self.get_params(deep=False))。

clone_tags(estimator, tag_names=None)[源代码]#

从另一个估计器克隆标签作为动态覆盖。

参数:

估计器继承自 BaseEstimator 的估计器
标签名称str 或 str 列表, 默认 = None: 要克隆的标签名称。如果为 None，则使用估计器中的所有标签作为 tag_names。

返回:

自我: 自我引用。

注释

通过在 tag_set 中设置标签值，从估计器中将标签作为动态标签设置到 self 中，从而改变对象状态。

classmethod create_test_instance(parameter_set='default')[源代码]#

如果可能，构造估计器实例。

参数:

参数集str, 默认值=”default”: 要返回的测试参数集的名称，用于测试。如果没有为某个值定义特殊参数，将返回 “default” 集。

返回:

实例使用默认参数的类实例

注释

get_test_params 可以返回字典或字典列表。此函数获取 get_test_params 返回的第一个或单个字典，并使用该字典构建对象。

classmethod create_test_instances_and_names(parameter_set='default')[源代码]#

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

参数:

参数集str, 默认值=”default”: 要返回的测试参数集的名称，用于测试。如果没有为某个值定义特殊参数，将返回 “default” 集。

返回:

objscls 实例列表: 第 i 个实例是 cls(**cls.get_test_params()[i])
名称list of str, 与 objs 长度相同: 第i个元素是测试中第i个obj实例的名称，约定为{cls.__name__}-{i}，如果存在多个实例，否则为{cls.__name__}

fit(X, y=None)[源代码]#

将转换器拟合到 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 类型 = 单个时间序列。pd.DataFrame、pd.Series 或 ``np.ndarray``（1D 或 2D）
Panel 类型 = 时间序列集合。pd.DataFrame 带有 2 级行 MultiIndex (实例, 时间)，3D np.ndarray (实例, 变量, 时间)，list 类型的 Series pd.DataFrame
Hierarchical 类型 = 时间序列的分层集合。pd.DataFrame 具有3个或更多级别的行 MultiIndex (hierarchy_1, ..., hierarchy_n, time)

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

y可选，sktime 兼容的数据格式中的数据，默认=None

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

返回:

self估计器的拟合实例

fit_transform(X, y=None)[源代码]#

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

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

状态变化：: 将状态更改为“已拟合”。

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

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

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

参数:

X : 以 sktime 兼容数据容器格式表示的时间序列时间序列

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

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

Series 类型 = 单个时间序列。pd.DataFrame、pd.Series 或 ``np.ndarray``（1D 或 2D）
Panel 类型 = 时间序列集合。pd.DataFrame 带有 2 级行 MultiIndex (实例, 时间)，3D np.ndarray (实例, 变量, 时间)，list 类型的 Series pd.DataFrame
Hierarchical 类型 = 时间序列的分层集合。pd.DataFrame 具有3个或更多级别的行 MultiIndex (hierarchy_1, ..., hierarchy_n, time)

有关数据格式的更多详细信息，请参阅关于 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-row) | | 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

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

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

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

classmethod get_class_tag(tag_name, tag_value_default=None)[源代码]#

获取类标签的值。

不返回在实例上定义的动态标签（通过 set_tags 或 clone_tags 设置）的信息。

参数:

标签名称str: 标签值的名称。
tag_value_default任何: 如果未找到标签，则使用默认/回退值。

返回:

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

classmethod get_class_tags()[源代码]#

从类及其所有父类中获取类标签。

从 _tags 类属性中检索标签：值对。不返回在实例上通过 set_tags 或 clone_tags 设置的动态标签信息。

返回:

collected_tagsdict: 类标签名称字典：标签值对。通过嵌套继承从 _tags 类属性中收集。

get_config()[源代码]#

获取 self 的配置标志

返回:

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

get_fitted_params(deep=True)[源代码]#

获取拟合参数。

状态要求：: 需要状态为“已拟合”。

参数:

深度bool, 默认=True

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

如果为真，将返回此对象的参数名称 : 值的字典，包括可拟合组件的拟合参数（= BaseEstimator 值的参数）。
如果为 False，将返回一个参数名称 : 值的字典，但不包括组件的拟合参数。

返回:

fitted_params带有字符串键的字典

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

always: 此对象的所有拟合参数，通过 get_param_names 获取的值是该键对应的拟合参数值，属于此对象。
如果 deep=True，还包含组件参数的键/值对，组件的参数被索引为 [componentname]__[paramname]，所有 componentname 的参数都以其值的形式显示为 paramname。
如果 deep=True，还包含任意层级的组件递归，例如，[componentname]__[componentcomponentname]__[paramname]，等等。

classmethod get_param_defaults()[源代码]#

获取对象的参数默认值。

返回:

default_dict: dict[str, Any]: 键是 cls 中所有在 __init__ 中定义了默认值的参数，值是 __init__ 中定义的默认值。

classmethod get_param_names(sort=True)[源代码]#

获取对象的参数名称。

参数:

排序bool, 默认=True: 是否按字母顺序返回参数名称（True），或者按它们在类 __init__ 中出现的顺序返回（False）。

返回:

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

get_params(deep=True)[源代码]#

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

参数:

深度bool, 默认=True

是否返回组件的参数。

如果为真，将返回此对象的参数名称 : 值的字典，包括组件的参数（= BaseObject 值的参数）。
如果为 False，将返回此对象的参数名称 : 值的字典，但不包括组件的参数。

返回:

参数带有字符串键的字典

参数的字典，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)[源代码]#

从估计器类获取标签值并动态覆盖标签。

参数:

标签名称str: 要检索的标签名称
tag_value_default任何类型，可选；默认=None: 如果未找到标签，则使用默认/回退值
raise_error布尔值: 当未找到标签时是否引发 ValueError

返回:

tag_value任何: 在 self 中 tag_name 标签的值。如果未找到，如果 raise_error 为 True，则返回错误，否则返回 tag_value_default。

引发:

如果 raise_error 为 True，即如果 tag_name 不在其中，则引发 ValueError。
self.get_tags().keys()

get_tags()[源代码]#

从估计器类获取标签和动态标签覆盖。

返回:

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

inverse_transform(X, y=None)[源代码]#

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

目前假设只有带有标签的变压器: “scitype:transform-input”=”Series”, “scitype:transform-output”=”Series”,

具有一个 inverse_transform。

状态要求：: 需要状态为“已拟合”。

访问自身中的内容：

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

self.is_fitted 必须为 True

参数:

X : 以 sktime 兼容数据容器格式表示的时间序列时间序列

要拟合变换的数据。

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

Series 类型 = 单个时间序列。pd.DataFrame、pd.Series 或 ``np.ndarray``（1D 或 2D）
Panel 类型 = 时间序列集合。pd.DataFrame 带有 2 级行 MultiIndex (实例, 时间)，3D np.ndarray (实例, 变量, 时间)，list 类型的 Series pd.DataFrame
Hierarchical 类型 = 时间序列的分层集合。pd.DataFrame 具有3个或更多级别的行 MultiIndex (hierarchy_1, ..., hierarchy_n, time)

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

y可选，sktime 兼容的数据格式中的数据，默认=None

附加数据，例如，转换的标签。某些转换器需要这些数据，详情请参阅类文档字符串。

返回:

X 的逆变换版本: 与 X 类型相同，并符合 mtype 格式规范

is_composite()[源代码]#

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

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

返回:

composite: bool: 一个对象是否有任何参数的值是 BaseObjects。

property is_fitted[源代码]#: 是否已调用 fit。

classmethod load_from_path(serial)[源代码]#

从文件位置加载对象。

参数:

串行ZipFile(path).open(“object”) 的结果

返回:

反序列化自身，结果输出到 path，通过 cls.save(path)

classmethod load_from_serial(serial)[源代码]#

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

参数:

serial : cls.save(None) 输出的第一个元素输出中的第一个元素

返回:

反序列化自身，结果输出为 serial ，由 cls.save(None) 产生

reset()[源代码]#

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

使用 reset，使用当前的超参数值（get_params 的结果）运行 __init__。这将移除任何对象属性，除了：

超参数 = __init__ 的参数

包含双下划线的对象属性，即字符串”__”

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

返回:

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

注释

等同于 sklearn.clone 但覆盖了 self。在调用 self.reset() 之后，self 的值等于 type(self)(**self.get_params(deep=False))

save(path=None, serialization_format='pickle')[源代码]#

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

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

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

参数:

路径无或文件位置（字符串或路径）: 如果为 None，则将 self 保存到内存对象中；如果为文件位置，则将 self 保存到该文件位置。如果：

path=”estimator” 那么会在当前工作目录下生成一个 zip 文件 estimator.zip。path=”/home/stored/estimator” 那么会在 /home/stored/ 目录下存储一个 zip 文件 estimator.zip。
serialization_format: str, default = “pickle”: 用于序列化的模块。可用的选项是 “pickle” 和 “cloudpickle”。请注意，非默认格式可能需要安装其他软依赖项。

返回:

如果 path 为 None - 内存中序列化的 self
如果 path 是文件位置 - 带有文件引用的 ZipFile

set_config(**config_dict)[源代码]#

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

参数:

config_dictdict

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

显示str, “diagram” (默认), 或 “text”

jupyter 内核如何显示 self 的实例

“diagram” = html 盒子图表示
“text” = 字符串打印输出

print_changed_onlybool, 默认=True

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

警告str, “on” (默认), 或 “off”

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

“on” = 将引发来自 sktime 的警告
“off” = 不会从 sktime 引发警告

后端:并行str, 可选, 默认=”None”

在广播/矢量化时用于并行化的后端，是以下之一

“None”: 按顺序执行循环，简单的列表推导
“loky”, “multiprocessing” 和 “threading”: 使用 joblib.Parallel
“joblib”：自定义和第三方 joblib 后端，例如，spark
“dask”: 使用 dask，需要在环境中安装 dask 包

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

输入转换str，可以是“on”（默认）、“off”或有效的 mtype 字符串

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

"on" - 执行输入检查和转换
"off" - 在将数据传递给内部方法之前，不进行输入检查和转换
有效的 mtype 字符串 - 假设输入已指定 mtype，进行转换但不做检查

输出转换str, 可以是 “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)[源代码]#

设置此对象的参数。

该方法适用于简单的估计器以及复合对象。参数键字符串 <component>__<parameter> 可用于复合对象，即包含其他对象的对象，以访问组件 <component> 中的 <parameter>。如果这使得引用明确，例如没有两个组件的参数名称是 <parameter>，则也可以使用不带 <component>__ 的字符串 <parameter>。

参数:

**参数dict: BaseObject 参数，键必须是 <组件>__<参数> 字符串。如果 get_params 键中唯一，__ 后缀可以别名为完整字符串。

返回:

self引用自身（在参数设置之后）

set_random_state(random_state=None, deep=True, self_policy='copy')[源代码]#

为 self 设置 random_state 伪随机种子参数。

通过 estimator.get_params 查找名为 random_state 的参数，并通过 set_params 将其设置为由 random_state 派生的整数。这些整数通过 sample_dependent_seed 的链哈希采样得到，并保证种子随机生成器的伪随机独立性。

根据 self_policy 应用于 estimator 中的 random_state 参数，并且仅当 deep=True 时，应用于剩余的组件估计器。

注意：即使 self 没有 random_state，或者没有任何组件有 random_state 参数，也会调用 set_params。因此，set_random_state 将重置任何 scikit-base 估计器，即使那些没有 random_state 参数的估计器。

参数:

random_stateint, RandomState 实例或 None, 默认=None

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

深度bool, 默认=True

是否在子估计器中设置随机状态。如果为 False，则仅设置 self 的 random_state 参数（如果存在）。如果为 True，则还会在子估计器中设置 random_state 参数。

self_policystr, 可以是 {“copy”, “keep”, “new”} 之一, 默认=”copy”

“复制”：estimator.random_state 被设置为输入的 random_state
“保持” : estimator.random_state 保持不变
“new” : estimator.random_state 被设置为一个新的随机状态，

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

返回:

self自我引用

set_tags(**tag_dict)[源代码]#

将动态标签设置为给定值。

参数:

**标签字典dict: 标签名称：标签值对的字典。

返回:

自我: 自我引用。

注释

通过在 tag_dict 中设置标签值，将对象状态更改为 self 中的动态标签。

transform(X, y=None)[源代码]#

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

状态要求：: 需要状态为“已拟合”。

访问自身中的内容：

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

self.is_fitted 必须为 True

参数:

X : 以 sktime 兼容数据容器格式表示的时间序列时间序列

要转换的数据。

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

Series 类型 = 单个时间序列。pd.DataFrame、pd.Series 或 ``np.ndarray``（1D 或 2D）
Panel 类型 = 时间序列集合。pd.DataFrame 带有 2 级行 MultiIndex (实例, 时间)，3D np.ndarray (实例, 变量, 时间)，list 类型的 Series pd.DataFrame
Hierarchical 类型 = 时间序列的分层集合。pd.DataFrame 具有3个或更多级别的行 MultiIndex (hierarchy_1, ..., hierarchy_n, time)

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

y可选，sktime 兼容的数据格式中的数据，默认=None

附加数据，例如，转换的标签。某些转换器需要这些数据，详情请参阅类文档字符串。

返回:

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

	transform
X	-output	返回类型
Series	基本元素	pd.DataFrame (1行)
Panel	基本元素	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

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

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

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

update(X, y=None, update_params=True)[源代码]#

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

状态要求：: 需要状态为“已拟合”。

访问自身中的内容：

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

self.is_fitted 必须为 True

写给自己：

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

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

参数:

X : 以 sktime 兼容数据容器格式表示的时间序列时间序列

数据更新转换

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

Series 类型 = 单个时间序列。pd.DataFrame、pd.Series 或 ``np.ndarray``（1D 或 2D）
Panel 类型 = 时间序列集合。pd.DataFrame 带有 2 级行 MultiIndex (实例, 时间)，3D np.ndarray (实例, 变量, 时间)，list 类型的 Series pd.DataFrame
Hierarchical 类型 = 时间序列的分层集合。pd.DataFrame 具有3个或更多级别的行 MultiIndex (hierarchy_1, ..., hierarchy_n, time)

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

y可选，sktime 兼容的数据格式中的数据，默认=None

附加数据，例如，转换的标签。某些转换器需要这些数据，详情请参阅类文档字符串。

返回:

self估计器的拟合实例