层级时间序列协调

一套后处理层级时间序列协调转换器。这些转换器适用于任何包含 hierarchy 的 TimeSeries（例如，一个预测）。

hierarchy 是一个字典，将层级中的每个组件映射到其父组件。可以使用例如 TimeSeries.with_hierarchy() 方法将其添加到 TimeSeries 中。

class darts.dataprocessing.transformers.reconciliation.BottomUpReconciliator(name='BaseDataTransformer', n_jobs=1, verbose=False, parallel_params=False, mask_components=True)[source]

基类：BaseDataTransformer

执行自下而上的协调，定义见此处。

属性

name

数据转换器的名称。

方法

apply_component_mask(series[, ...])

从 series 中提取由 component_mask 指定的组件。

set_n_jobs(value)

设置转换器在处理多个 TimeSeries 时使用的处理器数量。

set_verbose(value)

设置详细模式状态。

stack_samples(vals)

从 TimeSeries 或 TimeSeries 的 array_values 创建一个形状为 (n_timesteps * n_samples, n_components) 的数组。

transform(series, *args[, component_mask, ...])

通过调用用户实现的 ts_transform 方法转换（一系列）时间序列。

ts_transform(series, params, *args, **kwargs)

当调用 transform() 时将应用于每个时间序列的函数。

unapply_component_mask(series, vals[, ...])

将之前通过 apply_component_mask 方法中 component_mask 移除的组件添加回来。

unstack_samples(vals[, n_timesteps, ...])

将 stack_samples 返回的 2D 数组重塑回形状为 (n_timesteps, n_components, n_samples) 的数组；这“撤销”了 stack_samples 的重塑。

get_projection_matrix

数据转换器的抽象类。

所有派生类都必须实现静态方法 ts_transform()；然后可以通过调用 transform() 方法将此实现的方法应用于 TimeSeries 或 Sequence[TimeSeries] 输入。在内部，transform() 会并行化应用于传递给它的所有 TimeSeries 输入上的 func:ts_transform。有关如何在用户定义类中实现此方法的更多详细信息，请参阅 func:ts_transform 方法文档。

需要先拟合（fit）然后才能调用 transform() 的数据转换器应改为派生自 FittableDataTransformer。可逆的数据转换器应改为派生自 InvertibleDataTransformer。既可拟合又可逆的转换器应继承自 FittableDataTransformer 和 InvertibleDataTransformer。

所有数据转换器都可以存储固定参数，这些参数会自动传递给 func:ts_transform；数据转换器对象的固定参数是派生类在调用 super().__init__ 之前在 __init__ 方法中定义的所有属性。然后可以通过 params 字典参数在 func:ts_transform 方法中访问固定参数值。更具体地说，params[‘fixed’] 存储一个包含所有固定参数值的字典，其中键就是每个固定参数的属性名称（例如，self._my_param 固定参数属性通过 params[‘fixed’][‘_my_param’] 访问）。

从 FittableDataTransformer 继承的数据转换器也可以存储拟合参数和固定参数；请参阅 FittableDataTransformer 文档了解更多详细信息。

注意：ts_transform() 方法被设计为静态方法而非实例方法，以便在缩放器实例存储大量数据时也能实现高效并行化。使用实例方法意味着通过多个进程复制实例的数据，这很容易引入瓶颈并抵消并行化带来的好处。

参数

  • name (str) – 数据转换器的名称

  • n_jobs (int) – 并行运行的作业数量。仅当输入为 Sequence[TimeSeries] 时才会创建并行作业，并行处理不同 TimeSeries 的操作。默认为 1（顺序执行）。将参数设置为 -1 表示使用所有可用的处理器。注意：对于少量数据，并行化开销可能最终增加总所需时间。

  • verbose (bool) – 可选，是否打印操作进度。

  • parallel_params (Union[bool, Sequence[str]]) – 可选，指定哪些固定参数（即在派生类的 __init__ 中初始化但在调用 super().__init__ 之前初始化的属性）在不同并行作业中取不同的值。由 parallel_params 指定的固定参数被假定为一个值的 Sequence，这些值应在每个并行作业中用于该参数；此 Sequence 的长度应等于并行作业的数量。如果 parallel_params=True，则每个固定参数在每个并行作业中都将取不同的值。如果 parallel_params=False，则每个固定参数在每个并行作业中都将取相同的值。如果 parallel_params 是固定属性名称的 Sequence，则只有指定的属性名称将在不同并行作业之间取不同的值。

  • mask_components (bool) – 可选，是否自动将任何提供的 component_mask`s 应用于传递给 `transform、fit、inverse_transform 或 fit_transform 的 TimeSeries 输入。如果为 True，则任何指定的 component_mask 将在传递给调用方法之前应用于每个输入时间序列；掩码组件也将在返回的 TimeSeries 中自动“取消掩码”。如果为 False，则 component_mask（如果提供）将作为关键字参数传递，但不会自动应用于输入时间序列。有关更多详细信息，请参阅 apply_component_mask。

示例

>>> from darts.dataprocessing.transformers import BaseDataTransformer
>>> from darts.utils.timeseries_generation import linear_timeseries
>>>
>>> class SimpleTransform(BaseDataTransformer):
>>>
>>>         def __init__(self, a):
>>>             self._a = a
>>>             super().__init__()
>>>
>>>         @staticmethod
>>>         def ts_transform(series, params, **kwargs):
>>>             a = params['fixed']['_a']
>>>             b = kwargs.pop('b')
>>>             return a*series + b
>>>
>>> series = linear_timeseries(length=5)
>>> print(series)
<TimeSeries (DataArray) (time: 5, component: 1, sample: 1)>
array([[[0.  ]],

[[0.25]],

[[0.5 ]],

[[0.75]],

[[1. ]]])

坐标： * time (time) datetime64[ns] 2000-01-01 2000-01-02 … 2000-01-05 * component (component) object ‘linear’ 没有坐标的维度：sample .. 属性：static_covariates

None

hierarchy

None

>>> series = SimpleTransform(a=2).transform(series, b=3)
>>> print(series)
<TimeSeries (DataArray) (time: 5, component: 1, sample: 1)>
array([[[3. ]],

[[3.5]],

[[4. ]],

[[4.5]],

[[5. ]]])

坐标： * time (time) datetime64[ns] 2000-01-01 2000-01-02 … 2000-01-05 * component (component) object ‘linear’ 没有坐标的维度：sample .. 属性：static_covariates

None

hierarchy

None

属性

name

数据转换器的名称。

方法

apply_component_mask(series[, ...])

从 series 中提取由 component_mask 指定的组件。

set_n_jobs(value)

设置转换器在处理多个 TimeSeries 时使用的处理器数量。

set_verbose(value)

设置详细模式状态。

stack_samples(vals)

从 TimeSeries 或 TimeSeries 的 array_values 创建一个形状为 (n_timesteps * n_samples, n_components) 的数组。

transform(series, *args[, component_mask, ...])

通过调用用户实现的 ts_transform 方法转换（一系列）时间序列。

ts_transform(series, params, *args, **kwargs)

当调用 transform() 时将应用于每个时间序列的函数。

unapply_component_mask(series, vals[, ...])

将之前通过 apply_component_mask 方法中 component_mask 移除的组件添加回来。

unstack_samples(vals[, n_timesteps, ...])

将 stack_samples 返回的 2D 数组重塑回形状为 (n_timesteps, n_components, n_samples) 的数组；这“撤销”了 stack_samples 的重塑。

get_projection_matrix
static apply_component_mask(series, component_mask=None, return_ts=False)

从 series 中提取由 component_mask 指定的组件。

参数

  • series (TimeSeries) – 输入到转换器的时间序列。

  • component_mask (Optional[ndarray, None]) – 可选，一个形状为 (n_components, 1) 的 np.ndarray 布尔掩码，指定要从 series 中提取哪些组件。series 的第 i 个组件仅在 component_mask[i] = True 时保留。如果未指定，则不执行掩码。

  • return_ts (bool) – 可选，指定应返回 TimeSeries 而非 np.ndarray。

返回

TimeSeries（如果 return_ts = True）或 np.ndarray（如果 return_ts = False），仅包含由 component_mask 指定的剩余组件。

返回类型

masked

static get_projection_matrix(series)[source]
property name

数据转换器的名称。

set_n_jobs(value)

设置转换器在处理多个 TimeSeries 时使用的处理器数量。

参数

value (int) – 新的 n_jobs 值。设置为 -1 表示使用所有可用核心。

set_verbose(value)

设置详细模式状态。

True 表示启用缩放器操作进度的详细报告，False 表示不提供额外信息。

参数

value (bool) – 新的详细模式状态。

static stack_samples(vals)

从 TimeSeries 或 TimeSeries 的 array_values 创建一个形状为 (n_timesteps * n_samples, n_components) 的数组。

返回数组的每一列对应于时间序列的一个组件（维度），并且由该组件关联的所有样本连接而成。更具体地说，第 i 列由连接 [component_i_sample_1, component_i_sample_2, …, component_i_sample_n] 构成。

当实现一个应用于时间序列中每个时间步长的完全相同变化的转换时，堆叠非常有用。在这种情况下，每个组件的样本可以堆叠到单个列中，然后将转换应用于每个列，从而将转换对该组件的所有样本进行“向量化”；然后可以使用 unstack_samples 方法重塑输出。对于依赖于 time_index 或观察值的 temporal ordering 的转换，不应使用堆叠。

参数

vals (Union[ndarray, TimeSeries]) – 要“堆叠”的形状为 (n_timesteps, n_components, n_samples) 的 Timeseries 或 np.ndarray。

返回

形状为 (n_timesteps * n_samples, n_components) 的 np.ndarray，其中第 i 列由 vals 中第 i 个组件的所有样本连接而成。

返回类型

stacked

transform(series, *args, component_mask=None, series_idx=None, **kwargs)

通过调用用户实现的 ts_transform 方法转换（一系列）时间序列。

如果输入数据是 Sequence[TimeSeries]，此函数负责并行化序列中多个时间序列的转换。此外，如果在实例化 BaseDataTransformer 时将 mask_components 属性设置为 True，则任何提供的 component_mask`s 将自动应用于每个输入的 `TimeSeries；有关组件掩码的更多详细信息，请参阅“注意”。

任何额外指定的 *args 和 **kwargs 会自动传递给 ts_transform。

参数

  • series (Union[TimeSeries, Sequence[TimeSeries]]) – 要转换的（一系列）时间序列。

  • args – 每次调用 ts_transform() 方法的附加位置参数。

  • component_mask (Optional[np.ndarray] = None) – 可选，一个长度为 series.n_components 的 1-D 布尔 np.ndarray，指定转换应考虑底层 series 的哪些组件。如果在实例化 BaseDataTransformer 时将 mask_components 属性设置为 True，则组件掩码将自动应用于每个 TimeSeries 输入。否则，component_mask 将作为附加关键字参数提供给 ts_transform。有关更多详细信息，请参阅“注意”。

  • series_idx (Union[int, Sequence[int], None]) – 可选，每个时间序列在其用于拟合转换器的时间序列中的索引（位置）（以检索适当的转换器参数）。

  • kwargs – 每次调用 ts_transform() 方法的附加关键字参数。

返回

转换后的数据。

返回类型

Union[TimeSeries, List[TimeSeries]]

注意

如果在实例化 BaseDataTransformer 时将 mask_components 属性设置为 True，则任何提供的 component_mask`s 将自动应用于 transform 的每个 `TimeSeries 输入；component_mask`s 只是形状为 `(series.n_components,) 的布尔数组，指定 series 的哪些组件应该使用 ts_transform 进行转换，哪些不应该。如果 component_mask[i] 为 True，则 series 的第 i 个组件将由 ts_transform 转换。反之，如果 component_mask[i] 为 False，则在将其传递给 ts_transform 之前，将从 series 中删除第 i 个组件；在转换此掩码系列后，未转换的第 i 个组件将被“添加回”到输出中。请注意，自动 component_mask`ing 只能在 `ts_transform 不改变每个时间序列中的时间步长数量时执行；如果改变，则转换后的组件和未转换的组件将无法沿组件轴重新连接。

如果在实例化 BaseDataTransformer 时将 mask_components 设置为 False，则任何提供的 component_masks 将作为关键字参数传递给 ts_transform；用户可以手动指定如何将 component_mask 应用于每个时间序列。

static ts_transform(series, params, *args, **kwargs)[source]

当调用 transform() 时将应用于每个时间序列的函数。

此方法未在基类中实现，必须在派生类中实现。

函数必须将 TimeSeries 对象作为第一个参数，并将包含转换的固定参数和/或拟合参数的字典作为第二个参数；然后，此函数应返回一个转换后的 TimeSeries 对象。

params 字典可以包含最多两个键

1. params[‘fixed’] 存储转换的固定参数（即在派生类 __init__ 方法中定义但在调用 super().__init__ 之前定义的属性）；params[‘fixed’] 本身也是一个字典，其键是固定参数属性的名称。例如，如果在派生类中将 _my_fixed_param 定义为属性，则可以通过 params[‘fixed’][‘_my_fixed_param’] 访问此固定参数值。2. 如果转换继承自 FittableDataTransformer 类，则 params[‘fitted’] 将存储转换的拟合参数；拟合参数就是 ts_fit 函数返回的输出（无论输出是什么）。有关拟合参数的更多详细信息，请参阅 FittableDataTransformer。

传递给 transform 方法的任何位置参数/关键字参数都将作为位置参数/关键字参数传递给 ts_transform；因此，如果位置参数/关键字参数传递给 transform，ts_transform 也应接受 *args 和/或 **kwargs。请注意，如果 BaseDataTransformer 的 mask_components 属性设置为 False，则提供给 transform 的 component_mask 将作为附加关键字参数传递给 ts_transform。

BaseDataTransformer 类包含一些在实现 ts_transform 函数时可能证明有用的辅助方法

1. apply_component_mask 和 unapply_component_mask 方法，分别应用于和“取消应用” component_mask`s 到 `TimeSeries；如果 BaseDataTransformer 的 mask_component 属性设置为 True，这些方法会在 transform 中自动调用，但如果您将 mask_components 设置为 False 并希望手动指定如何将 component_mask`s 应用于 `TimeSeries，您可能需要手动调用它们。2. stack_samples 方法，它沿着组件轴堆叠 TimeSeries 中的所有样本，以便 TimeSeries 的形状从 (n_timesteps, n_components, n_samples) 变为 (n_timesteps, n_components * n_samples)。如果正在实现一个点对点转换（即在时间 t 处的转换值仅取决于该时间 t 处时间序列的值），这种堆叠非常有用。转换后，可以使用 unstack_samples 方法“取消堆叠”堆叠的时间序列。

参数

  • series (TimeSeries) – 要转换的时间序列。

  • params (Mapping[str, Any]) – 包含转换函数参数的字典。固定参数（即在调用 super.__init__() 之前在转换的最底层类中定义的属性）存储在 ‘fixed’ 键下。如果转换继承自 FittableDataTransformer 类，则转换的拟合参数（即 ts_fit 返回的值）存储在 ‘fitted’ 键下。

  • args – 调用 transform 时除 series 外提供的任何位置参数。

  • kwargs – 提供给 transform 的任何附加关键字参数。注意，如果 BaseDataTransformer 的 mask_component 属性设置为 False，则 component_mask 将作为关键字参数传递。

注意

此方法被设计为静态方法而非实例方法，以便在缩放器实例存储大量数据时也能实现高效并行化。使用实例方法意味着通过多个进程复制实例的数据，这很容易引入瓶颈并抵消并行化带来的好处。

返回类型

TimeSeries

static unapply_component_mask(series, vals, component_mask=None)

将之前通过 apply_component_mask 方法中 component_mask 移除的组件添加回来。

参数

  • series (Union[TimeSeries, Sequence[TimeSeries]]) – 输入到转换器的时间序列。

  • vals (Union[ndarray, Sequence[ndarray], TimeSeries, Sequence[TimeSeries]]) – 要“取消掩码”的 np.ndarray 或 TimeSeries。

  • component_mask (Optional[ndarray, None]) – 可选，一个形状为 (n_components, 1) 的 np.ndarray 布尔掩码，指定从 series 中提取了哪些组件。如果给定，则将 vals 插回原始数组的列中。如果未指定，则不执行“取消掩码”。

返回

TimeSeries（如果 vals 是 TimeSeries）或 np.ndarray（如果 vals 是 np.ndarray），其中之前由 component_mask 移除的组件现已“添加回”。

返回类型

unmasked

static unstack_samples(vals, n_timesteps=None, n_samples=None, series=None)

将 stack_samples 返回的 2D 数组重塑回形状为 (n_timesteps, n_components, n_samples) 的数组；这“撤销”了 stack_samples 的重塑。必须指定 n_components、n_samples 或 series 中的至少一个。

参数

  • vals (ndarray) – 要“取消堆叠”的形状为 (n_timesteps * n_samples, n_components) 的 np.ndarray。

  • n_timesteps (Optional[int, None]) – 可选，最初传递给 stack_samples 的数组中的时间步长数量。如果指定了 series，则不需要提供。

  • n_samples (Optional[int, None]) – 可选，最初传递给 stack_samples 的数组中的样本数量。如果指定了 series，则不需要提供。

  • series (Optional[TimeSeries, None]) – 可选，用于创建 vals 的 TimeSeries 对象；从这个对象推断 n_samples。

返回

形状为 (n_timesteps, n_components, n_samples) 的 np.ndarray。

返回类型

unstacked

class darts.dataprocessing.transformers.reconciliation.MinTReconciliator(method='ols')[source]

基类：FittableDataTransformer

MinT 协调器。

这实现了 [1] 中提出的 MinT 协调方法，并在 [2] 中进行了总结。

参数

method –

此参数可以采用四个不同的值，决定如何估计预测误差的协方差矩阵 W（对应于 [2] 中的 Wh）。

  • ols 使用 W = I。此选项仅查看层级，而忽略提供给 fit() 的时间序列值。

  • wls_struct 使用 W = diag(S1)，其中 S1 是一个大小为 n 的向量，值在 0 到 m 之间，表示每个 n 个组件组成的基组件数量。此选项仅查看层级，而忽略提供给 fit() 的时间序列值。

  • wls_var 使用 W = diag(W1)，其中 W1 是预测残差方差的时间平均值。此方法假定提供给 fit() 的时间序列包含预测残差（确定性时间序列）。

  • mint_cov 计算 W 作为每个组件残差的经验协方差矩阵，残差样本取自时间。此方法假定提供给 fit() 的时间序列包含预测残差（确定性时间序列），并且要求残差是线性独立的。

  • wls_val 使用 W = diag(V1)，其中 V1 是组件值的时间平均值。此方法假定提供给 fit() 的时间序列包含实际值的示例（例如，训练时间序列或预测）。[2] 中未介绍此方法。

参考文献

1

通过最小化迹对分层和分组时间序列进行最优预测协调

2(1,2,3)

https://otexts.com/fpp3/reconciliation.html#the-mint-optimal-reconciliation-approach

属性

name

数据转换器的名称。

方法

apply_component_mask(series[, ...])

从 series 中提取由 component_mask 指定的组件。

fit(series, *args[, component_mask])

通过调用用户实现的 ts_fit 方法，将转换器拟合到（一系列）TimeSeries。

fit_transform(series, *args[, component_mask])

将转换器拟合到（一系列）时间序列并返回转换后的输入。

get_matrices(series, method)

根据指定的协调方法返回 G 矩阵。

set_n_jobs(value)

设置转换器在处理多个 TimeSeries 时使用的处理器数量。

set_verbose(value)

设置详细模式状态。

stack_samples(vals)

从 TimeSeries 或 TimeSeries 的 array_values 创建一个形状为 (n_timesteps * n_samples, n_components) 的数组。

transform(series, *args[, component_mask, ...])

通过调用用户实现的 ts_transform 方法转换（一系列）时间序列。

ts_fit(series, params, *args, **kwargs)

当调用 fit() 时将应用于每个时间序列的函数。

ts_transform(series, params, *args, **kwargs)

当调用 transform() 时将应用于每个时间序列的函数。

unapply_component_mask(series, vals[, ...])

将之前通过 apply_component_mask 方法中 component_mask 移除的组件添加回来。

unstack_samples(vals[, n_timesteps, ...])

将 stack_samples 返回的 2D 数组重塑回形状为 (n_timesteps, n_components, n_samples) 的数组；这“撤销”了 stack_samples 的重塑。
static apply_component_mask(series, component_mask=None, return_ts=False)

从 series 中提取由 component_mask 指定的组件。

参数

  • series (TimeSeries) – 输入到转换器的时间序列。

  • component_mask (Optional[ndarray, None]) – 可选，一个形状为 (n_components, 1) 的 np.ndarray 布尔掩码，指定要从 series 中提取哪些组件。series 的第 i 个组件仅在 component_mask[i] = True 时保留。如果未指定，则不执行掩码。

  • return_ts (bool) – 可选，指定应返回 TimeSeries 而非 np.ndarray。

返回

TimeSeries（如果 return_ts = True）或 np.ndarray（如果 return_ts = False），仅包含由 component_mask 指定的剩余组件。

返回类型

masked

fit(series, *args, component_mask=None, **kwargs)

通过调用用户实现的 ts_fit 方法，将转换器拟合到（一系列）TimeSeries。

ts_fit 返回的拟合参数存储在 self._fitted_params 属性中。如果将 Sequence[TimeSeries] 作为 series 数据传递，将发生以下两种情况之一

1. 如果 global_fit 属性设置为 False，则将为 Sequence 中的每个 TimeSeries 单独拟合一套不同的参数。在这种情况下，此函数会自动将此拟合过程并行化应用于传递的所有多个 TimeSeries。2. 如果 global_fit 属性设置为 True，则所有 TimeSeries 对象将用于拟合一套参数。

参数

  • series (Union[TimeSeries, Sequence[TimeSeries]]) – 用于拟合转换器的（一系列）时间序列。

  • args – ts_fit() 方法的附加位置参数。

  • component_mask (Optional[np.ndarray] = None) – 可选，一个长度为 series.n_components 的 1-D 布尔 np.ndarray，指定转换应拟合到底层 series 的哪些组件。

  • kwargs – ts_fit() 方法的附加关键字参数。

返回

拟合好的转换器。

返回类型

FittableDataTransformer

fit_transform(series, *args, component_mask=None, **kwargs)

将转换器拟合到（一系列）时间序列并返回转换后的输入。

参数

  • series (Union[TimeSeries, Sequence[TimeSeries]]) – 要转换的（一系列）时间序列。

  • args – 传递给 ts_transform() 和 ts_fit() 方法的附加位置参数。

  • component_mask (Optional[np.ndarray] = None) – 可选，一个长度为 series.n_components 的 1-D 布尔 np.ndarray，指定转换应拟合和应用于底层 series 的哪些组件。

  • kwargs – 传递给 ts_transform() 和 ts_fit() 方法的附加关键字参数。

返回

转换后的数据。

返回类型

Union[TimeSeries, Sequence[TimeSeries]]

static get_matrices(series, method)[source]

根据指定的协调方法返回 G 矩阵。

property name

数据转换器的名称。

set_n_jobs(value)

设置转换器在处理多个 TimeSeries 时使用的处理器数量。

参数

value (int) – 新的 n_jobs 值。设置为 -1 表示使用所有可用核心。

set_verbose(value)

设置详细模式状态。

True 表示启用缩放器操作进度的详细报告，False 表示不提供额外信息。

参数

value (bool) – 新的详细模式状态。

static stack_samples(vals)

从 TimeSeries 或 TimeSeries 的 array_values 创建一个形状为 (n_timesteps * n_samples, n_components) 的数组。

返回数组的每一列对应于时间序列的一个组件（维度），并且由该组件关联的所有样本连接而成。更具体地说，第 i 列由连接 [component_i_sample_1, component_i_sample_2, …, component_i_sample_n] 构成。

当实现一个应用于时间序列中每个时间步长的完全相同变化的转换时，堆叠非常有用。在这种情况下，每个组件的样本可以堆叠到单个列中，然后将转换应用于每个列，从而将转换对该组件的所有样本进行“向量化”；然后可以使用 unstack_samples 方法重塑输出。对于依赖于 time_index 或观察值的 temporal ordering 的转换，不应使用堆叠。

参数

vals (Union[ndarray, TimeSeries]) – 要“堆叠”的形状为 (n_timesteps, n_components, n_samples) 的 Timeseries 或 np.ndarray。

返回

形状为 (n_timesteps * n_samples, n_components) 的 np.ndarray，其中第 i 列由 vals 中第 i 个组件的所有样本连接而成。

返回类型

stacked

transform(series, *args, component_mask=None, series_idx=None, **kwargs)

通过调用用户实现的 ts_transform 方法转换（一系列）时间序列。

如果输入数据是 Sequence[TimeSeries]，此函数负责并行化序列中多个时间序列的转换。此外，如果在实例化 BaseDataTransformer 时将 mask_components 属性设置为 True，则任何提供的 component_mask`s 将自动应用于每个输入的 `TimeSeries；有关组件掩码的更多详细信息，请参阅“注意”。

任何额外指定的 *args 和 **kwargs 会自动传递给 ts_transform。

参数

  • series (Union[TimeSeries, Sequence[TimeSeries]]) – 要转换的（一系列）时间序列。

  • args – 每次调用 ts_transform() 方法的附加位置参数。

  • component_mask (Optional[np.ndarray] = None) – 可选，一个长度为 series.n_components 的 1-D 布尔 np.ndarray，指定转换应考虑底层 series 的哪些组件。如果在实例化 BaseDataTransformer 时将 mask_components 属性设置为 True，则组件掩码将自动应用于每个 TimeSeries 输入。否则，component_mask 将作为附加关键字参数提供给 ts_transform。有关更多详细信息，请参阅“注意”。

  • series_idx (Union[int, Sequence[int], None]) – 可选，每个时间序列在其用于拟合转换器的时间序列中的索引（位置）（以检索适当的转换器参数）。

  • kwargs – 每次调用 ts_transform() 方法的附加关键字参数。

返回

转换后的数据。

返回类型

Union[TimeSeries, List[TimeSeries]]

注意

如果在实例化 BaseDataTransformer 时将 mask_components 属性设置为 True，则任何提供的 component_mask`s 将自动应用于 transform 的每个 `TimeSeries 输入；component_mask`s 只是形状为 `(series.n_components,) 的布尔数组，指定 series 的哪些组件应该使用 ts_transform 进行转换，哪些不应该。如果 component_mask[i] 为 True，则 series 的第 i 个组件将由 ts_transform 转换。反之，如果 component_mask[i] 为 False，则在将其传递给 ts_transform 之前，将从 series 中删除第 i 个组件；在转换此掩码系列后，未转换的第 i 个组件将被“添加回”到输出中。请注意，自动 component_mask`ing 只能在 `ts_transform 不改变每个时间序列中的时间步长数量时执行；如果改变，则转换后的组件和未转换的组件将无法沿组件轴重新连接。

如果在实例化 BaseDataTransformer 时将 mask_components 设置为 False，则任何提供的 component_masks 将作为关键字参数传递给 ts_transform；用户可以手动指定如何将 component_mask 应用于每个时间序列。

static ts_fit(series, params, *args, **kwargs)[source]

当调用 fit() 时将应用于每个时间序列的函数。

如果 global_fit 属性设置为 False，则 ts_fit 应接受一个 TimeSeries 作为第一个参数，并返回一组拟合到此单个 TimeSeries 的参数。反之，如果 global_fit 属性设置为 True，则 ts_fit 应接受一个 Sequence[TimeSeries] 并返回一组拟合到所有提供的 TimeSeries 的参数。所有这些参数将存储在 self._fitted_params 中，之后可在转换步骤中使用。

无论 global_fit 属性设置为 True 还是 False，ts_fit 还应接受一个固定参数值的字典作为第二个参数（即 params[‘fixed’] 包含数据转换器的固定参数）。

传递给 fit 方法的任何附加位置参数和/或关键字参数将作为位置参数/关键字参数传递给 ts_fit。

此方法未在基类中实现，必须在派生类中实现。

如果在派生类中添加了更多输入参数，则应相应地重新定义 _fit_iterator()，以生成此函数所需的参数（有关更多详细信息，请参阅 _fit_iterator()）。

参数

  • (Union[TimeSeries (series) – 拟合缩放器所依据的 TimeSeries。

  • Sequence[TimeSeries]]) – 拟合缩放器所依据的 TimeSeries。

注意

此方法被设计为静态方法而非实例方法，以便在缩放器实例存储大量数据时也能实现高效并行化。使用实例方法意味着通过多个进程复制实例的数据，这很容易引入瓶颈并抵消并行化带来的好处。

返回类型

ndarray

static ts_transform(series, params, *args, **kwargs)[source]

当调用 transform() 时将应用于每个时间序列的函数。

此方法未在基类中实现，必须在派生类中实现。

函数必须将 TimeSeries 对象作为第一个参数，并将包含转换的固定参数和/或拟合参数的字典作为第二个参数；然后，此函数应返回一个转换后的 TimeSeries 对象。

params 字典可以包含最多两个键

1. params[‘fixed’] 存储转换的固定参数（即在派生类 __init__ 方法中定义但在调用 super().__init__ 之前定义的属性）；params[‘fixed’] 本身也是一个字典，其键是固定参数属性的名称。例如，如果在派生类中将 _my_fixed_param 定义为属性，则可以通过 params[‘fixed’][‘_my_fixed_param’] 访问此固定参数值。2. 如果转换继承自 FittableDataTransformer 类，则 params[‘fitted’] 将存储转换的拟合参数；拟合参数就是 ts_fit 函数返回的输出（无论输出是什么）。有关拟合参数的更多详细信息，请参阅 FittableDataTransformer。

传递给 transform 方法的任何位置参数/关键字参数都将作为位置参数/关键字参数传递给 ts_transform；因此，如果位置参数/关键字参数传递给 transform，ts_transform 也应接受 *args 和/或 **kwargs。请注意，如果 BaseDataTransformer 的 mask_components 属性设置为 False，则提供给 transform 的 component_mask 将作为附加关键字参数传递给 ts_transform。

BaseDataTransformer 类包含一些在实现 ts_transform 函数时可能证明有用的辅助方法

1. apply_component_mask 和 unapply_component_mask 方法，分别应用于和“取消应用” component_mask`s 到 `TimeSeries；如果 BaseDataTransformer 的 mask_component 属性设置为 True，这些方法会在 transform 中自动调用，但如果您将 mask_components 设置为 False 并希望手动指定如何将 component_mask`s 应用于 `TimeSeries，您可能需要手动调用它们。2. stack_samples 方法，它沿着组件轴堆叠 TimeSeries 中的所有样本，以便 TimeSeries 的形状从 (n_timesteps, n_components, n_samples) 变为 (n_timesteps, n_components * n_samples)。如果正在实现一个点对点转换（即在时间 t 处的转换值仅取决于该时间 t 处时间序列的值），这种堆叠非常有用。转换后，可以使用 unstack_samples 方法“取消堆叠”堆叠的时间序列。

参数

  • series (TimeSeries) – 要转换的时间序列。

  • params (Mapping[str, Any]) – 包含转换函数参数的字典。固定参数（即在调用 super.__init__() 之前在转换的最底层类中定义的属性）存储在 ‘fixed’ 键下。如果转换继承自 FittableDataTransformer 类，则转换的拟合参数（即 ts_fit 返回的值）存储在 ‘fitted’ 键下。

  • args – 调用 transform 时除 series 外提供的任何位置参数。

  • kwargs – 提供给 transform 的任何附加关键字参数。注意，如果 BaseDataTransformer 的 mask_component 属性设置为 False，则 component_mask 将作为关键字参数传递。

注意

此方法被设计为静态方法而非实例方法，以便在缩放器实例存储大量数据时也能实现高效并行化。使用实例方法意味着通过多个进程复制实例的数据，这很容易引入瓶颈并抵消并行化带来的好处。

返回类型

TimeSeries

static unapply_component_mask(series, vals, component_mask=None)

将之前通过 apply_component_mask 方法中 component_mask 移除的组件添加回来。

参数

  • series (Union[TimeSeries, Sequence[TimeSeries]]) – 输入到转换器的时间序列。

  • vals (Union[ndarray, Sequence[ndarray], TimeSeries, Sequence[TimeSeries]]) – 要“取消掩码”的 np.ndarray 或 TimeSeries。

  • component_mask (Optional[ndarray, None]) – 可选，一个形状为 (n_components, 1) 的 np.ndarray 布尔掩码，指定从 series 中提取了哪些组件。如果给定，则将 vals 插回原始数组的列中。如果未指定，则不执行“取消掩码”。

返回

TimeSeries（如果 vals 是 TimeSeries）或 np.ndarray（如果 vals 是 np.ndarray），其中之前由 component_mask 移除的组件现已“添加回”。

返回类型

unmasked

static unstack_samples(vals, n_timesteps=None, n_samples=None, series=None)

将 stack_samples 返回的 2D 数组重塑回形状为 (n_timesteps, n_components, n_samples) 的数组；这“撤销”了 stack_samples 的重塑。必须指定 n_components、n_samples 或 series 中的至少一个。

参数

  • vals (ndarray) – 要“取消堆叠”的形状为 (n_timesteps * n_samples, n_components) 的 np.ndarray。

  • n_timesteps (Optional[int, None]) – 可选，最初传递给 stack_samples 的数组中的时间步长数量。如果指定了 series，则不需要提供。

  • n_samples (Optional[int, None]) – 可选，最初传递给 stack_samples 的数组中的样本数量。如果指定了 series，则不需要提供。

  • series (Optional[TimeSeries, None]) – 可选，用于创建 vals 的 TimeSeries 对象；从这个对象推断 n_samples。

返回

形状为 (n_timesteps, n_components, n_samples) 的 np.ndarray。

返回类型

unstacked

class darts.dataprocessing.transformers.reconciliation.TopDownReconciliator(name='FittableDataTransformer', n_jobs=1, verbose=False, parallel_params=False, mask_components=True, global_fit=False)[source]

基类：FittableDataTransformer

执行自上而下的协调，定义见此处。

此估计器基于提供给 fit() 方法的 TimeSeries 计算比例（基组件相对于顶部组件的比例）。如果提供了历史时间序列，则将使用历史比例。

属性

name

数据转换器的名称。

方法

apply_component_mask(series[, ...])

从 series 中提取由 component_mask 指定的组件。

fit(series, *args[, component_mask])

通过调用用户实现的 ts_fit 方法，将转换器拟合到（一系列）TimeSeries。

fit_transform(series, *args[, component_mask])

将转换器拟合到（一系列）时间序列并返回转换后的输入。

set_n_jobs(value)

设置转换器在处理多个 TimeSeries 时使用的处理器数量。

set_verbose(value)

设置详细模式状态。

stack_samples(vals)

从 TimeSeries 或 TimeSeries 的 array_values 创建一个形状为 (n_timesteps * n_samples, n_components) 的数组。

transform(series, *args[, component_mask, ...])

通过调用用户实现的 ts_transform 方法转换（一系列）时间序列。

ts_fit(series, params, *args, **kwargs)

当调用 fit() 时将应用于每个时间序列的函数。

ts_transform(series, params, *args, **kwargs)

当调用 transform() 时将应用于每个时间序列的函数。

unapply_component_mask(series, vals[, ...])

将之前通过 apply_component_mask 方法中 component_mask 移除的组件添加回来。

unstack_samples(vals[, n_timesteps, ...])

将 stack_samples 返回的 2D 数组重塑回形状为 (n_timesteps, n_components, n_samples) 的数组；这“撤销”了 stack_samples 的重塑。

get_projection_matrix

可拟合（fittable）转换器的基类。

所有派生类必须实现静态方法 ts_transform() 和 ts_fit()。拟合和转换函数必须在转换器初始化期间传入。此类负责在可能的情况下并行化涉及多个 TimeSeries 的操作。

参数

  • name (str) – 数据转换器的名称

  • n_jobs (int) – 并行运行的作业数。只有当 Sequence[TimeSeries] 作为输入传递给方法时，才会创建并行作业，并行处理不同的 TimeSeries。默认为 1（顺序执行）。将参数设置为 -1 表示使用所有可用处理器。注意：对于少量数据，并行化开销可能会增加所需的总时间。

  • verbose (bool) – 可选，是否打印操作进度。

  • parallel_params (Union[bool, Sequence[str]]) – 可选，指定哪些固定参数（即在派生类的 __init__ 中初始化但在调用 super().__init__ 之前初始化的属性）在不同并行作业中取不同的值。由 parallel_params 指定的固定参数被假定为一个值的 Sequence，这些值应在每个并行作业中用于该参数；此 Sequence 的长度应等于并行作业的数量。如果 parallel_params=True，则每个固定参数在每个并行作业中都将取不同的值。如果 parallel_params=False，则每个固定参数在每个并行作业中都将取相同的值。如果 parallel_params 是固定属性名称的 Sequence，则只有指定的属性名称将在不同并行作业之间取不同的值。

  • mask_components (bool) – 可选，是否自动将任何提供的 component_mask 应用于传递给 transform、fit、inverse_transform 或 fit_transform 的 TimeSeries 输入。如果为 True，任何指定的 component_mask 将在传递给被调用的方法之前应用于每个输入时间序列；屏蔽的组件也将在返回的 TimeSeries 中自动“取消屏蔽”（unmasked）。如果为 False，则 component_mask（如果提供）将作为关键字参数传递，但不会自动应用于输入时间序列。更多详情请参阅 BaseDataTransformer 的 apply_component_mask 方法。

  • global_fit (bool) – 可选，传递给 fit() 方法的所有 TimeSeries 是否应用于拟合一个单一参数集，或者是否应独立地为每个提供的 TimeSeries 拟合不同的参数集。如果为 True，则将 Sequence[TimeSeries] 传递给 ts_fit，并使用所有提供的 TimeSeries 拟合一个单一参数集。如果为 False，则每个 TimeSeries 将单独传递给 ts_fit，并且为每次拟合操作生成一组不同的拟合参数。更多详情请参阅 ts_fit。

注意

如果 global_fit 为 False 且 fit 使用包含 n 个不同 TimeSeries 的 Sequence 调用，则将拟合 n 组参数。当随后使用 Series[TimeSeries] 调用 transform 和/或 inverse_transform 时，第 i 组拟合参数值将传递给 ts_transform/ts_inverse_transform 以转换此序列中的第 i 个 TimeSeries。相反，如果 global_fit 为 True，则当 fit 提供 Sequence[TimeSeries] 时，只会生成一个单一拟合值集。因此，如果随后将 Sequence[TimeSeries] 传递给 transform/inverse_transform，这些 TimeSeries 中的每一个都将使用完全相同的拟合参数集进行转换。

请注意，如果可逆*且*可拟合的数据转换器需要进行全局拟合，则数据转换器类应首先继承自 FittableDataTransformer，然后继承自 InvertibleDataTransformer。换句话说，MyTransformer(FittableDataTransformer, InvertibleDataTransformer) 是正确的，但 MyTransformer(InvertibleDataTransformer, FittableDataTransformer) 是**不**正确的。如果未正确实现，则 global_fit 参数将无法正确传递给 FittableDataTransformer 的构造函数。

ts_transform() 和 ts_fit() 方法被设计为静态方法而不是实例方法，以便在缩放器实例存储非可忽略量的数据时也能实现高效并行化。使用实例方法意味着通过多个进程复制实例的数据，这很容易引入瓶颈并抵消并行化带来的好处。

示例

>>> from darts.dataprocessing.transformers import FittableDataTransformer
>>> from darts.utils.timeseries_generation import linear_timeseries
>>>
>>> class SimpleRangeScaler(FittableDataTransformer):
>>>
>>>     def __init__(self, scale, position):
>>>         self._scale = scale
>>>         self._position = position
>>>         super().__init__()
>>>
>>>     @staticmethod
>>>     def ts_transform(series, params):
>>>         vals = series.all_values(copy=False)
>>>         fit_params = params['fitted']
>>>         unit_scale = (vals - fit_params['position'])/fit_params['scale']
>>>         fix_params = params['fixed']
>>>         rescaled = fix_params['_scale'] * unit_scale + fix_params['_position']
>>>         return series.from_values(rescaled)
>>>
>>>     @staticmethod
>>>     def ts_fit(series, params):
>>>         vals = series.all_values(copy=False)
>>>         scale = vals.max() - vals.min()
>>>         position = vals[0]
>>>         return {'scale': scale, 'position': position}
>>>
>>> series = linear_timeseries(length=5, start_value=1, end_value=5)
>>> print(series)
<TimeSeries (DataArray) (time: 5, component: 1, sample: 1)>
array([[[1.]],

[[2.]],

[[3.]],

[[4.]],

[[5.]]])

坐标： * time (time) datetime64[ns] 2000-01-01 2000-01-02 … 2000-01-05 * component (component) object ‘linear’ 没有坐标的维度：sample .. 属性：static_covariates

None

hierarchy

None

>>> series = SimpleRangeScaler(scale=2, position=-1).fit_transform(series)
>>> print(series)
<TimeSeries (DataArray) (time: 5, component: 1, sample: 1)>
array([[[-1. ]],

[[-0.5]],

[[ 0. ]],

[[ 0.5]],

[[ 1. ]]])

坐标：* time (time) int64 0 1 2 3 4 * component (component) <U1 '0' 没有坐标的维度：sample .. 属性:: static_covariates

None

hierarchy

None

属性

name

数据转换器的名称。

方法

apply_component_mask(series[, ...])

从 series 中提取由 component_mask 指定的组件。

fit(series, *args[, component_mask])

通过调用用户实现的 ts_fit 方法，将转换器拟合到（一系列）TimeSeries。

fit_transform(series, *args[, component_mask])

将转换器拟合到（一系列）时间序列并返回转换后的输入。

set_n_jobs(value)

设置转换器在处理多个 TimeSeries 时使用的处理器数量。

set_verbose(value)

设置详细模式状态。

stack_samples(vals)

从 TimeSeries 或 TimeSeries 的 array_values 创建一个形状为 (n_timesteps * n_samples, n_components) 的数组。

transform(series, *args[, component_mask, ...])

通过调用用户实现的 ts_transform 方法转换（一系列）时间序列。

ts_fit(series, params, *args, **kwargs)

当调用 fit() 时将应用于每个时间序列的函数。

ts_transform(series, params, *args, **kwargs)

当调用 transform() 时将应用于每个时间序列的函数。

unapply_component_mask(series, vals[, ...])

将之前通过 apply_component_mask 方法中 component_mask 移除的组件添加回来。

unstack_samples(vals[, n_timesteps, ...])

将 stack_samples 返回的 2D 数组重塑回形状为 (n_timesteps, n_components, n_samples) 的数组；这“撤销”了 stack_samples 的重塑。

get_projection_matrix
静态 apply_component_mask(series, component_mask=None, return_ts=False)

从 series 中提取由 component_mask 指定的组件。

参数

  • series (TimeSeries) – 输入到转换器的时间序列。

  • component_mask (Optional[ndarray, None]) – 可选，一个形状为 (n_components, 1) 的 np.ndarray 布尔掩码，指定要从 series 中提取哪些组件。series 的第 i 个组件仅在 component_mask[i] = True 时保留。如果未指定，则不执行掩码。

  • return_ts (bool) – 可选，指定应返回 TimeSeries 而非 np.ndarray。

返回

TimeSeries（如果 return_ts = True）或 np.ndarray（如果 return_ts = False），仅包含由 component_mask 指定的剩余组件。

返回类型

masked

fit(series, *args, component_mask=None, **kwargs)

通过调用用户实现的 ts_fit 方法，将转换器拟合到（一系列）TimeSeries。

ts_fit 返回的拟合参数存储在 self._fitted_params 属性中。如果将 Sequence[TimeSeries] 作为 series 数据传递，将发生以下两种情况之一

1. 如果 global_fit 属性设置为 False，则将为 Sequence 中的每个 TimeSeries 单独拟合一套不同的参数。在这种情况下，此函数会自动将此拟合过程并行化应用于传递的所有多个 TimeSeries。2. 如果 global_fit 属性设置为 True，则所有 TimeSeries 对象将用于拟合一套参数。

参数

  • series (Union[TimeSeries, Sequence[TimeSeries]]) – 用于拟合转换器的（一系列）时间序列。

  • args – ts_fit() 方法的附加位置参数

  • component_mask (Optional[np.ndarray] = None) – 可选，一个长度为 series.n_components 的 1-D 布尔 np.ndarray，指定转换应拟合到底层 series 的哪些组件。

  • kwargs – ts_fit() 方法的附加关键字参数

返回

拟合好的转换器。

返回类型

FittableDataTransformer

fit_transform(series, *args, component_mask=None, **kwargs)

将转换器拟合到（一系列）时间序列并返回转换后的输入。

参数

  • series (Union[TimeSeries, Sequence[TimeSeries]]) – 要转换的（一系列）时间序列。

  • args – 传递给 ts_transform() 和 ts_fit() 方法的附加位置参数。

  • component_mask (Optional[np.ndarray] = None) – 可选，一个长度为 series.n_components 的 1-D 布尔 np.ndarray，指定转换应拟合和应用于底层 series 的哪些组件。

  • kwargs – 传递给 ts_transform() 和 ts_fit() 方法的附加关键字参数。

返回

转换后的数据。

返回类型

Union[TimeSeries, Sequence[TimeSeries]]

静态 get_projection_matrix(series)[source]
属性 name

数据转换器的名称。

set_n_jobs(value)

设置转换器在处理多个 TimeSeries 时使用的处理器数量。

参数

value (int) – 新的 n_jobs 值。设置为 -1 表示使用所有可用核心。

set_verbose(value)

设置详细模式状态。

True 表示启用缩放器操作进度的详细报告，False 表示不提供额外信息。

参数

value (bool) – 新的详细模式状态。

静态 stack_samples(vals)

从 TimeSeries 或 TimeSeries 的 array_values 创建一个形状为 (n_timesteps * n_samples, n_components) 的数组。

返回数组的每一列对应于时间序列的一个组件（维度），并且由该组件关联的所有样本连接而成。更具体地说，第 i 列由连接 [component_i_sample_1, component_i_sample_2, …, component_i_sample_n] 构成。

当实现一个应用于时间序列中每个时间步长的完全相同变化的转换时，堆叠非常有用。在这种情况下，每个组件的样本可以堆叠到单个列中，然后将转换应用于每个列，从而将转换对该组件的所有样本进行“向量化”；然后可以使用 unstack_samples 方法重塑输出。对于依赖于 time_index 或观察值的 temporal ordering 的转换，不应使用堆叠。

参数

vals (Union[ndarray, TimeSeries]) – 要“堆叠”的形状为 (n_timesteps, n_components, n_samples) 的 Timeseries 或 np.ndarray。

返回

形状为 (n_timesteps * n_samples, n_components) 的 np.ndarray，其中第 i 列由 vals 中第 i 个组件的所有样本连接而成。

返回类型

stacked

transform(series, *args, component_mask=None, series_idx=None, **kwargs)

通过调用用户实现的 ts_transform 方法转换（一系列）时间序列。

如果输入数据是 Sequence[TimeSeries]，此函数负责并行化序列中多个时间序列的转换。此外，如果在实例化 BaseDataTransformer 时将 mask_components 属性设置为 True，则任何提供的 component_mask`s 将自动应用于每个输入的 `TimeSeries；有关组件掩码的更多详细信息，请参阅“注意”。

任何额外指定的 *args 和 **kwargs 会自动传递给 ts_transform。

参数

  • series (Union[TimeSeries, Sequence[TimeSeries]]) – 要转换的（一系列）时间序列。

  • args – 每次调用 ts_transform() 方法的附加位置参数

  • component_mask (Optional[np.ndarray] = None) – 可选，一个长度为 series.n_components 的 1-D 布尔 np.ndarray，指定转换应考虑底层 series 的哪些组件。如果在实例化 BaseDataTransformer 时将 mask_components 属性设置为 True，则组件掩码将自动应用于每个 TimeSeries 输入。否则，component_mask 将作为附加关键字参数提供给 ts_transform。有关更多详细信息，请参阅“注意”。

  • series_idx (Union[int, Sequence[int], None]) – 可选，每个时间序列在其用于拟合转换器的时间序列中的索引（位置）（以检索适当的转换器参数）。

  • kwargs – 每次调用 ts_transform() 方法的附加关键字参数

返回

转换后的数据。

返回类型

Union[TimeSeries, List[TimeSeries]]

注意

如果在实例化 BaseDataTransformer 时将 mask_components 属性设置为 True，则任何提供的 component_mask`s 将自动应用于 transform 的每个 `TimeSeries 输入；component_mask`s 只是形状为 `(series.n_components,) 的布尔数组，指定 series 的哪些组件应该使用 ts_transform 进行转换，哪些不应该。如果 component_mask[i] 为 True，则 series 的第 i 个组件将由 ts_transform 转换。反之，如果 component_mask[i] 为 False，则在将其传递给 ts_transform 之前，将从 series 中删除第 i 个组件；在转换此掩码系列后，未转换的第 i 个组件将被“添加回”到输出中。请注意，自动 component_mask`ing 只能在 `ts_transform 不改变每个时间序列中的时间步长数量时执行；如果改变，则转换后的组件和未转换的组件将无法沿组件轴重新连接。

如果在实例化 BaseDataTransformer 时将 mask_components 设置为 False，则任何提供的 component_masks 将作为关键字参数传递给 ts_transform；用户可以手动指定如何将 component_mask 应用于每个时间序列。

静态 ts_fit(series, params, *args, **kwargs)[source]

当调用 fit() 时将应用于每个时间序列的函数。

如果 global_fit 属性设置为 False，则 ts_fit 应接受一个 TimeSeries 作为第一个参数，并返回一组拟合到此单个 TimeSeries 的参数。反之，如果 global_fit 属性设置为 True，则 ts_fit 应接受一个 Sequence[TimeSeries] 并返回一组拟合到所有提供的 TimeSeries 的参数。所有这些参数将存储在 self._fitted_params 中，之后可在转换步骤中使用。

无论 global_fit 属性设置为 True 还是 False，ts_fit 都应接受一个固定参数值的字典作为第二个参数（即 `params['fixed'] 包含数据转换器的固定参数）。

传递给 fit 方法的任何附加位置参数和/或关键字参数将作为位置参数/关键字参数传递给 ts_fit。

此方法未在基类中实现，必须在派生类中实现。

如果在派生类中添加了更多输入参数，则应相应地重新定义 _fit_iterator()，以生成此函数所需的参数（有关更多详细信息，请参阅 _fit_iterator()）。

参数

  • (Union[TimeSeries (series) – 拟合缩放器所依据的 TimeSeries。

  • Sequence[TimeSeries]]) – 拟合缩放器所依据的 TimeSeries。

注意

此方法被设计为静态方法而非实例方法，以便在缩放器实例存储大量数据时也能实现高效并行化。使用实例方法意味着通过多个进程复制实例的数据，这很容易引入瓶颈并抵消并行化带来的好处。

返回类型

ndarray

静态 ts_transform(series, params, *args, **kwargs)[source]

当调用 transform() 时将应用于每个时间序列的函数。

此方法未在基类中实现，必须在派生类中实现。

函数必须将 TimeSeries 对象作为第一个参数，并将包含转换的固定参数和/或拟合参数的字典作为第二个参数；然后，此函数应返回一个转换后的 TimeSeries 对象。

params 字典可以包含最多两个键

1. params[‘fixed’] 存储转换的固定参数（即在派生类 __init__ 方法中定义但在调用 super().__init__ 之前定义的属性）；params[‘fixed’] 本身也是一个字典，其键是固定参数属性的名称。例如，如果在派生类中将 _my_fixed_param 定义为属性，则可以通过 params[‘fixed’][‘_my_fixed_param’] 访问此固定参数值。2. 如果转换继承自 FittableDataTransformer 类，则 params[‘fitted’] 将存储转换的拟合参数；拟合参数就是 ts_fit 函数返回的输出（无论输出是什么）。有关拟合参数的更多详细信息，请参阅 FittableDataTransformer。

传递给 transform 方法的任何位置参数/关键字参数都将作为位置参数/关键字参数传递给 ts_transform；因此，如果位置参数/关键字参数传递给 transform，ts_transform 也应接受 *args 和/或 **kwargs。请注意，如果 BaseDataTransformer 的 mask_components 属性设置为 False，则提供给 transform 的 component_mask 将作为附加关键字参数传递给 ts_transform。

BaseDataTransformer 类包含一些在实现 ts_transform 函数时可能证明有用的辅助方法

1. apply_component_mask 和 unapply_component_mask 方法，分别应用于和“取消应用” component_mask`s 到 `TimeSeries；如果 BaseDataTransformer 的 mask_component 属性设置为 True，这些方法会在 transform 中自动调用，但如果您将 mask_components 设置为 False 并希望手动指定如何将 component_mask`s 应用于 `TimeSeries，您可能需要手动调用它们。2. stack_samples 方法，它沿着组件轴堆叠 TimeSeries 中的所有样本，以便 TimeSeries 的形状从 (n_timesteps, n_components, n_samples) 变为 (n_timesteps, n_components * n_samples)。如果正在实现一个点对点转换（即在时间 t 处的转换值仅取决于该时间 t 处时间序列的值），这种堆叠非常有用。转换后，可以使用 unstack_samples 方法“取消堆叠”堆叠的时间序列。

参数

  • series (TimeSeries) – 要转换的时间序列。

  • params (Mapping[str, Any]) – 包含转换函数参数的字典。固定参数（即在调用 super.__init__() 之前在转换的最底层类中定义的属性）存储在 ‘fixed’ 键下。如果转换继承自 FittableDataTransformer 类，则转换的拟合参数（即 ts_fit 返回的值）存储在 ‘fitted’ 键下。

  • args – 调用 transform 时除 series 外提供的任何位置参数。

  • kwargs – 提供给 transform 的任何附加关键字参数。注意，如果 BaseDataTransformer 的 mask_component 属性设置为 False，则 component_mask 将作为关键字参数传递。

注意

此方法被设计为静态方法而非实例方法，以便在缩放器实例存储大量数据时也能实现高效并行化。使用实例方法意味着通过多个进程复制实例的数据，这很容易引入瓶颈并抵消并行化带来的好处。

返回类型

TimeSeries

静态 unapply_component_mask(series, vals, component_mask=None)

将之前通过 apply_component_mask 方法中 component_mask 移除的组件添加回来。

参数

  • series (Union[TimeSeries, Sequence[TimeSeries]]) – 输入到转换器的时间序列。

  • vals (Union[ndarray, Sequence[ndarray], TimeSeries, Sequence[TimeSeries]]) – 要“取消掩码”的 np.ndarray 或 TimeSeries。

  • component_mask (Optional[ndarray, None]) – 可选，一个形状为 (n_components, 1) 的 np.ndarray 布尔掩码，指定从 series 中提取了哪些组件。如果给定，则将 vals 插回原始数组的列中。如果未指定，则不执行“取消掩码”。

返回

TimeSeries（如果 vals 是 TimeSeries）或 np.ndarray（如果 vals 是 np.ndarray），其中之前由 component_mask 移除的组件现已“添加回”。

返回类型

unmasked

静态 unstack_samples(vals, n_timesteps=None, n_samples=None, series=None)

将 stack_samples 返回的 2D 数组重塑回形状为 (n_timesteps, n_components, n_samples) 的数组；这“撤销”了 stack_samples 的重塑。必须指定 n_components、n_samples 或 series 中的至少一个。

参数

  • vals (ndarray) – 要“取消堆叠”的形状为 (n_timesteps * n_samples, n_components) 的 np.ndarray。

  • n_timesteps (Optional[int, None]) – 可选，最初传递给 stack_samples 的数组中的时间步长数量。如果指定了 series，则不需要提供。

  • n_samples (Optional[int, None]) – 可选，最初传递给 stack_samples 的数组中的样本数量。如果指定了 series，则不需要提供。

  • series (Optional[TimeSeries, None]) – 可选，用于创建 vals 的 TimeSeries 对象；从这个对象推断 n_samples。

返回

形状为 (n_timesteps, n_components, n_samples) 的 np.ndarray。

返回类型

unstacked

上一页

缺失值填充器 (Missing Values Filler)

下一页

缩放器 (Scaler)