时间序列¶

TimeSeries 是 darts 中的主要类。它表示一个单变量或多变量时间序列，可以是确定性的或随机的。

这些值存储在一个形状为 (时间, 维度, 样本) 的数组中，其中维度是多元序列的维度（或“分量”，或“列”），而样本是随机序列的样本。

定义：

一个 dimensions = 1 的序列是 单变量 的，而一个 dimensions > 1 的序列是 多变量 的。
一个 samples = 1 的序列是 确定性的 ，而一个 samples > 1 的序列是

随机 (或 概率性).

每个系列还存储一个 time_index，其中包含日期时间（pandas.DateTimeIndex）或整数索引（pandas.RangeIndex）。

TimeSeries 保证：

具有单调递增的时间索引，没有空缺（没有缺失的日期）
仅包含数值类型
有不同的组件/列名
具有明确的频率（日期偏移别名用于 DateTimeIndex，或 RangeIndex 的步长）
静态协变量与其组成部分一致，或者没有静态协变量
与其组件保持一致的层次结构，或没有层次结构

TimeSeries 可以包含全局或组件特定的静态协变量数据。在 darts 中，静态协变量指的是可以被某些模型用来帮助提高预测的外部时间不变数据。阅读我们的协变量用户指南和 TimeSeries 文档以获取更多关于协变量的信息。

class darts.timeseries.TimeSeries(xa, copy=True)[源代码]¶

基类：object

从（格式良好的）DataArray 创建一个 TimeSeries。建议使用工厂方法来创建 TimeSeries。

参见

TimeSeries.from_dataframe: 从 pandas.DataFrame 创建。
TimeSeries.from_group_dataframe: 通过 pandas.DataFrame 按组创建多个时间序列。
TimeSeries.from_series: 从 pandas.Series 创建。
TimeSeries.from_values: 从 NumPy ndarray 创建。
TimeSeries.from_times_and_values: 从时间索引和 Numpy ndarray 创建。
TimeSeries.from_csv: 从CSV文件创建。
TimeSeries.from_json: 从 JSON 文件创建。
TimeSeries.from_xarray: 从 xarray.DataArray 创建。

属性

`bottom_level_components`	该系列的底层组件名称，如果系列没有层次结构，则为 None。
`bottom_level_series`	该系列包含此系列中最低级别组件，顺序与它们在系列中出现的顺序相同，如果系列没有层次结构，则为 None。
`columns`	组件的名称，作为 Pandas 索引。
`components`	组件的名称，作为 Pandas 索引。
`dtype`	序列值的数据类型。
`duration`	这个时间序列的持续时间（作为时间增量或整数）。
`freq`	序列的频率。
`freq_str`	序列的频率字符串表示。
`has_datetime_index`	该系列是否使用 DatetimeIndex 进行索引（否则使用 RangeIndex 进行索引）。
`has_hierarchy`	这一系列是否是分层的。
`has_range_index`	该系列是否使用 RangeIndex 进行索引（否则使用 DatetimeIndex 进行索引）。
`has_static_covariates`	该系列是否包含静态协变量。
`hierarchy`	这个时间序列的层次结构（如果有的话）。
`is_deterministic`	该系列是否是确定性的。
`is_probabilistic`	该系列是否是随机的（= 概率性的）。
`is_stochastic`	该系列是否为随机。
`is_univariate`	此系列是否为单变量。
`n_components`	系列中包含的组件（维度）数量。
`n_samples`	系列中包含的样本数量。
`n_timesteps`	序列中的时间步数。
`static_covariates`	返回序列中包含的静态协变量作为 pandas DataFrame。
`time_dim`	此时间序列的时间维度的名称。
`time_index`	这个时间序列的时间索引。
`top_level_component`	此系列的最高层组件名称，如果系列没有层次结构，则为 None。
`top_level_series`	包含此系列单一顶级组件的单变量系列，如果该系列没有层次结构，则为 None。
`width`	“宽度”（= 组件数量）的序列。

方法

`add_datetime_attribute`(attribute[, one_hot, ...])	使用包含时间索引属性的一个（或多个）附加组件构建一个新的系列。
`add_holidays`(country_code[, prov, state, tz])	在当前序列中添加一个二进制单变量组件，该组件在每个对应于所选国家假日的索引处等于1，否则为0。
`all_values`([copy])	返回一个维度为 (时间, 分量, 样本) 的 3-D 数组，包含此系列的所有样本值。
`append`(other)	沿时间轴将另一个序列附加到此序列。
`append_values`(values)	将新值追加到当前 TimeSeries，扩展其时间索引。
`astype`(dtype)	将此系列转换为具有所需数据类型的新系列。
`concatenate`(other[, axis, ignore_time_axis, ...])	沿着给定的轴将另一个时间序列连接到当前时间序列。
`copy`()	复制此系列。
`cumsum`()	返回时间序列沿时间轴的累积和。
`data_array`([copy])	返回此序列的基础 `xarray.DataArray` 表示。
`diff`([n, periods, dropna])	返回一个差分时间序列。
`drop_after`(split_point)	丢弃提供的时间 split_point 之后的所有内容，包括 split_point 本身。
`drop_before`(split_point)	丢弃提供的时间 split_point 之前的所有内容，包括 split_point 本身。
`drop_columns`(col_names)	返回一个新的 `TimeSeries` 实例，其中删除了指定的列/组件。
`end_time`()	系列的结束时间。
`first_value`()	这个单变量序列的第一个值。
`first_values`()	这个潜在多变量序列的初始值。
`from_csv`(filepath_or_buffer[, time_col, ...])	构建一个从单个CSV文件生成的确定性时间序列实例。
`from_dataframe`(df[, time_col, value_cols, ...])	构建一个由 DataFrame 中选定列构建的确定性 TimeSeries 实例。
`from_group_dataframe`(df, group_cols[, ...])	根据DataFrame中的选择列构建一个按时间序列实例分组的列表。
`from_json`(json_str[, static_covariates, ...])	从 `TimeSeries` 的 JSON 字符串表示构建一个系列（使用 `TimeSeries.to_json()` 生成）。
`from_pickle`(path)	读取一个序列化的 `TimeSeries`。
`from_series`(pd_series[, fill_missing_dates, ...])	从 pandas Series 构建一个单变量的确定性序列。
`from_times_and_values`(times, values[, ...])	从时间索引和值数组构建一个序列。
`from_values`(values[, columns, fillna_value, ...])	从值数组构建一个整数索引序列。
`from_xarray`(xa[, fill_missing_dates, freq, ...])	从 xarray DataArray 构建一个 TimeSeries 实例。
`gaps`([mode])	一个用于计算并返回时间序列中间隙的函数。
`get_index_at_point`(point[, after])	将时间轴索引上的一个点转换为范围在 (0, len(series)-1) 内的整数索引。
`get_timestamp_at_point`(point)	将一个点转换为 pandas.Timestamp（如果是 Datetime 索引）或转换为整数（如果是 Int64 索引）。
`has_same_time_as`(other)	检查此系列的时间索引是否与 other 相同。
`head`([size, axis])	返回一个包含前 size 个点的 TimeSeries。
`is_within_range`(ts)	检查给定的时间戳或整数是否在此时间序列的时间间隔内。
`kurtosis`(**kwargs)	返回一个确定性的 `TimeSeries` ，其中包含此随机 `TimeSeries` 的每个分量（在样本上）的峰度。
`last_value`()	这个单变量序列的最后一个值。
`last_values`()	这个潜在的多变量序列的最后值。
`longest_contiguous_slice`([max_gap_size, mode])	返回此确定性序列中不包含大于 max_gap_size 的间隙（连续的全部为 NaN 的值）的最大时间序列切片。
`map`(fn)	将函数 fn 应用于包含此系列值的基础 NumPy 数组。
`max`([axis])	返回一个包含在指定轴上计算的最大值的 `TimeSeries`。
`mean`([axis])	返回一个包含在指定轴上计算的平均值的 `TimeSeries`。
`median`([axis])	返回一个包含沿指定轴计算的中位数的 `TimeSeries`。
`min`([axis])	返回一个包含在指定轴上计算的最小值的 `TimeSeries`。
`pd_dataframe`([copy, suppress_warnings])	返回此时间序列的 Pandas DataFrame 表示。
`pd_series`([copy])	返回此单变量确定性时间序列的 Pandas Series 表示。
`plot`([new_plot, central_quantile, ...])	绘制序列。
`prepend`(other)	前置（即
`prepend_values`(values)	前置（即
`quantile`(quantile, **kwargs)	返回一个确定性的 `TimeSeries` ，其中包含此随机 `TimeSeries` 的每个分量（在样本上）的单一所需分位数。
`quantile_df`([quantile])	返回一个包含每个成分（在样本中）所需单一分位数的 Pandas DataFrame。
`quantile_timeseries`([quantile])	返回一个确定性的 `TimeSeries` ，其中包含此随机 `TimeSeries` 的每个分量（在样本上）的单一所需分位数。
`quantiles_df`([quantiles])	返回一个包含每个分量所需分位数的 Pandas DataFrame（在样本上）。
`random_component_values`([copy])	返回一个形状为 (时间, 组件) 的二维数组，包含从该系列样本中均匀随机抽取的一个样本的值。
`resample`(freq[, method])	使用给定的频率构建一个重新索引的 `TimeSeries`。
`rescale_with_value`(value_at_first_step)	返回一个新的 `TimeSeries`，它是这个序列的倍数，使得第一个值为 value_at_first_step。
`shift`(n)	将此 TimeSeries 的时间轴向左或向右移动 n 个时间步长。
`skew`(**kwargs)	返回一个确定性的 `TimeSeries` ，其中包含此随机 `TimeSeries` 的每个分量（在样本上）的偏度。
`slice`(start_ts, end_ts)	返回一个新的时间序列，开始时间晚于 start_ts，结束时间早于 end_ts。
`slice_intersect`(other)	返回此序列的 `TimeSeries` 切片，其中时间索引已与 other 序列的时间索引相交。
`slice_intersect_times`(other[, copy])	返回此序列的时间索引，其中时间索引已与 other 序列的时间索引相交。
`slice_intersect_values`(other[, copy])	返回此序列的切片值，其中时间索引已与 other 序列的时间索引相交。
`slice_n_points_after`(start_ts, n)	返回一个新的时间序列，从 start_ts`（包含）开始，最多包含 `n 个点。
`slice_n_points_before`(end_ts, n)	返回一个新的时间序列，结束于 end_ts`（包含）并且最多有 `n 个点。
`split_after`(split_point)	在提供的 split_point 之后将系列分成两部分。
`split_before`(split_point)	在提供的 split_point 之前将系列分成两部分。
`stack`(other)	在当前时间序列的顶部（沿组件轴）堆叠另一个具有相同时间索引的单变量或多变量时间序列。
`start_time`()	系列的开始时间。
`static_covariates_values`([copy])	返回一个维度为 (组件, 静态变量) 的二维数组，包含时间序列的静态协变量值。
`std`([ddof])	返回一个确定性的 `TimeSeries` ，其中包含此随机 `TimeSeries` 的每个分量（在样本上）的标准差。
`strip`([how])	返回这个确定性时间序列的 `TimeSeries` 切片，其中在序列的开始和结束处包含 NaN 的条目被移除。
`sum`([axis])	返回一个包含在指定轴上计算的总和的 `TimeSeries`。
`tail`([size, axis])	返回序列的最后 size 个点。
`to_csv`(args, *kwargs)	将这个确定性序列写入CSV文件。
`to_json`()	返回此确定性序列的 JSON 字符串表示。
`to_pickle`(path[, protocol])	将此系列保存为 pickle 格式。
`univariate_component`(index)	检索系列中的一个组件，并将其作为新的单变量 `TimeSeries` 实例返回。
`univariate_values`([copy, sample])	返回一个形状为 (time,) 的 1-D Numpy 数组，包含该单变量序列在一个样本中的值。
`values`([copy, sample])	返回一个形状为 (时间, 组件) 的二维数组，包含该系列在一个样本中的值。
`var`([ddof])	返回一个确定性的 `TimeSeries` ，其中包含此随机 `TimeSeries` 的每个分量（在样本上）的方差。
`window_transform`(transforms[, treat_na, ...])	对 `TimeSeries` 应用移动/滚动、扩展或指数加权窗口变换。
`with_columns_renamed`(col_names, col_names_new)	返回一个新的 `TimeSeries` 实例，带有新的列/组件名称。
`with_hierarchy`(hierarchy)	为 TimeSeries 添加层次结构。
`with_static_covariates`(covariates)	返回一个添加了静态协变量的新 TimeSeries 对象。
`with_times_and_values`(times, values[, ...])	返回一个新的 `TimeSeries` ，类似于当前的这个，但具有新的指定值。
`with_values`(values)	返回一个新的 `TimeSeries` ，类似于当前的这个，但具有新的指定值。

add_datetime_attribute(attribute, one_hot=False, cyclic=False, tz=None)[源代码]¶

使用包含时间索引属性的一个（或多个）附加组件构建一个新的系列。

附加组件通过 attribute 指定，例如 ‘weekday’、’day’ 或 ‘month’。

这仅适用于确定性时间序列（即，由1个样本组成）。

参数

attribute – 一个 pd.DatatimeIndex 属性，将作为新列的基础。
one_hot (bool) – 布尔值，指示是否将指定的属性作为独热编码添加（结果是更多的列）。
cyclic (bool) – 布尔值，指示是否将指定的属性作为循环编码添加。作为one_hot编码的替代方案，只能启用两者之一。（添加2列，分别对应于sin和cos变换）。
tz (Optional[str, None]) – 可选地，在计算属性之前，将时间索引转换为的时区。

返回

通过 attribute 增强的新的 TimeSeries 实例。

返回类型

TimeSeries

add_holidays(country_code, prov=None, state=None, tz=None)[源代码]¶

在当前序列中添加一个二进制单变量组件，该组件在每个对应于所选国家假日的索引处等于1，否则为0。

时间序列的频率是每日。

可用的国家可以在这里找到。

这仅适用于确定性时间序列（即，由1个样本组成）。

参数

country_code (str) – 国家 ISO 代码
prov (str) – 省份
state (str) – 状态
tz (Optional[str, None]) – 可选地，在计算属性之前，将时间索引转换为的时区。

返回

一个新的 TimeSeries 实例，增强了二进制假日组件。

返回类型

TimeSeries

all_values(copy=True)[源代码]¶

返回一个维度为 (时间, 分量, 样本) 的 3-D 数组，包含此系列的所有样本值。

参数: copy (bool) – 是否返回值的副本，否则返回视图。除非你知道自己在做什么，否则请保持为 True。
返回: 构成时间序列的值。
返回类型: numpy.ndarray

append(other)[源代码]¶

沿时间轴将另一个序列附加到此序列。

参数: other (Self) – 第二个时间序列。
返回: 一个新的时间序列，通过将第二个时间序列附加到第一个时间序列获得。
返回类型: TimeSeries

参见

TimeSeries.concatenate: 沿着给定的轴连接另一个序列。
TimeSeries.prepend: 在时间轴上预先添加（即添加到开头）另一个序列。

append_values(values)[源代码]¶

将新值追加到当前 TimeSeries，扩展其时间索引。

参数: values (ndarray) – 一个包含要追加的值的数组。
返回: 一个新的时间序列，附加了新的值
返回类型: TimeSeries

astype(dtype)[源代码]¶

将此系列转换为具有所需数据类型的新系列。

参数: dtype (Union[str, dtype]) – 一个 NumPy dtype（np.float32 或 np.float64）
返回: 具有所需数据类型的 TimeSeries。
返回类型: TimeSeries

property bottom_level_components: Optional[List[str]]¶

该系列的底层组件名称，如果系列没有层次结构，则为 None。

返回类型: Optional[List[str], None]

property bottom_level_series: Optional[List[Self]]¶

该系列包含此系列中最低级别组件，顺序与它们在系列中出现的顺序相同，如果系列没有层次结构，则为 None。

如果存在多个底层组件，返回的序列是多元的。

返回类型: Optional[List[Self], None]

property columns: Index¶

组件的名称，作为 Pandas 索引。

返回类型: Index

property components: Index¶

组件的名称，作为 Pandas 索引。

返回类型: Index

concatenate(other, axis=0, ignore_time_axis=False, ignore_static_covariates=False, drop_hierarchy=True)[源代码]¶

沿着给定的轴将另一个时间序列连接到当前时间序列。

参数

other (TimeSeries) – 另一个要与此连接的时间序列
axis (str or int) – 沿哪个轴拼接时间序列。[‘时间’, ‘组件’ 或 ‘样本’; 默认值: 0 (时间)]
ignore_time_axis (bool, default False) – 当某些时间序列的时间轴变化时忽略错误。请注意，这可能会产生意外的结果。
ignore_static_covariates (bool) – 是否忽略所有静态协变量连接的要求，仅将 series 中第一个 TimeSeries 元素的静态协变量转移到连接后的 TimeSeries 中。仅在 axis=1 时有效。
drop_hierarchy (bool) – 当 axis=1 时，是否丢弃层次结构信息。默认为 True。当为 False 时，层次结构也将被“连接”（通过合并层次结构字典），如果结果序列的组件名称与合并的层次结构不匹配，可能会导致问题。当 axis=0 或 axis=2 时，始终保留第一个序列的层次结构。

返回

连接的时间序列

返回类型

TimeSeries

参见

concatenate: 一个沿着给定轴连接多个序列的函数。

提示

当沿 time 维度连接时，当前序列标记结果序列的开始日期，而另一个序列的时间索引将被忽略。

copy()[源代码]¶

复制此系列。

返回: 此时间序列的副本。
返回类型: TimeSeries

cumsum()[源代码]¶

返回时间序列沿时间轴的累积和。

返回: 一个新的时间序列，包含累积求和的值。
返回类型: TimeSeries

data_array(copy=True)[源代码]¶

返回此序列的基础 xarray.DataArray 表示。

参数: copy – 是否返回序列的副本。除非你知道自己在做什么，否则请保持为 True。
返回: 这个时间序列背后的 xarray DataArray。
返回类型: xarray.DataArray

diff(n=1, periods=1, dropna=True)[源代码]¶

返回一个差分时间序列。这通常用于使时间序列平稳。

参数

n (Optional[int, None]) – 可选地，一个表示差分步数的正整数（默认 = 1）。例如，n=2 计算二阶差分。
periods (Optional[int, None]) – 可选地，用于计算差异的周期数。例如，periods=12 计算时间 t 和时间 t-12 之间的差异。
dropna (Optional[bool, None]) – 是否在每次差分步骤后丢弃缺失值。如果设置为 False，相应的第一个 periods 时间步将被填充为 NaNs。

返回

一个新的时间序列，包含差分后的值。

返回类型

TimeSeries

drop_after(split_point)[源代码]¶

丢弃 split_point 提供的时间之后的所有内容，包括该时间点。时间戳可能不在序列中。如果在，该时间戳将被丢弃。

参数: split_point (Union[Timestamp, float, int]) – 指示截止时间的时戳。
返回: 一个新的 TimeSeries，在 ts 之后。
返回类型: TimeSeries

drop_before(split_point)[源代码]¶

丢弃提供的时间 split_point 之前的所有内容，包括该时间点。时间戳可能不在序列中。如果在序列中，时间戳将被丢弃。

参数: split_point (Union[Timestamp, float, int]) – 指示截止时间的时戳。
返回: 一个新的 TimeSeries，在 ts 之后。
返回类型: TimeSeries

drop_columns(col_names)[源代码]¶

返回一个新的 TimeSeries 实例，其中删除了指定的列/组件。

参数: col_names (Union[List[str], str]) – 要删除的列对应的字符串或字符串列表。
返回: 一个删除了指定列的新 TimeSeries 实例。
返回类型: TimeSeries

property dtype¶: 序列值的数据类型。

property duration: Union[Timedelta, int]¶

这个时间序列的持续时间（作为时间增量或整数）。

返回类型: Union[Timedelta, int]

end_time()[源代码]¶

系列的结束时间。

返回: 包含时间序列最后一次时间的时间戳（如果按 DatetimeIndex 索引），或一个整数（如果按 RangeIndex 索引）
返回类型: Union[pandas.Timestamp, int]

first_value()[源代码]¶

这个单变量序列的第一个值。

返回: 这个单变量确定性时间序列的第一个值
返回类型: float

first_values()[源代码]¶

这个潜在多变量序列的初始值。

返回: 这个确定性时间序列的每个组成部分的第一个值
返回类型: np.ndarray

property freq: Union[DateOffset, int]¶

序列的频率。如果序列使用 pd.DatetimeIndex 索引，则为 pd.DateOffset。如果序列使用 pd.RangeIndex 索引，则为整数（步长）。

返回类型: Union[DateOffset, int]

property freq_str: str¶

序列的频率字符串表示。

返回类型: str

classmethod from_csv(filepath_or_buffer, time_col=None, value_cols=None, fill_missing_dates=False, freq=None, fillna_value=None, static_covariates=None, hierarchy=None, **kwargs)[源代码]¶

构建一个从单个CSV文件生成的确定性时间序列实例。可以使用一列来表示时间（如果不存在，时间索引将是一个RangeIndex），并且可以使用列列表 value_cols 来指示此时间序列的值。

参数

filepath_or_buffer – CSV 文件的路径，或文件对象；与 pandas.read_csv 函数的参数一致
time_col (Optional[str, None]) – 时间列的名称。如果设置，该列将被转换为 pandas DatetimeIndex（如果包含时间戳）或 RangeIndex（如果包含整数）。如果未设置，将使用 pandas RangeIndex。
value_cols (Union[List[str], str, None]) – 表示要从CSV文件中提取的值列的字符串或字符串列表。如果设置为 None，将使用CSV文件中的所有列（除非指定了time_col）
fill_missing_dates (Optional[bool, None]) – 可选地，一个布尔值，指示是否用NaN值填充缺失的日期（或整数索引情况下的索引）。这需要提供一个`freq`或从提供的时间戳推断频率的可能性。更多信息请参见 _fill_missing_dates()。
freq (Union[int, str, None]) – 可选地，一个字符串或整数，表示基础索引的频率。这对于在某些日期缺失且 fill_missing_dates 设置为 True 时填充缺失值很有用。如果是字符串，表示 pandas DatetimeIndex 的频率（有关支持的频率的更多信息，请参见偏移别名）。如果是整数，表示 pandas Index 或 pandas RangeIndex 的步长。
fillna_value (Optional[float, None]) – 可选地，一个数值用于填充缺失值（NaNs）。
static_covariates (Union[Series, DataFrame, None]) – 可选地，添加到 TimeSeries 的一组静态协变量。可以是 pandas Series 或 pandas DataFrame。如果是 Series，索引表示静态变量。协变量全局地 ‘应用于’ TimeSeries 的所有组件。如果是 DataFrame，列表示静态变量，行表示 uni/multivariate TimeSeries 的组件。如果是单行 DataFrame，协变量全局地 ‘应用于’ TimeSeries 的所有组件。如果是多行 DataFrame，行数必须与 TimeSeries 的组件数匹配（在这种情况下，CSV 文件中的列数）。这增加了组件特定静态协变量的控制。
hierarchy (Optional[Dict, None]) – 可选地，一个描述时间序列分组的字典。键是组件名称，对于给定的组件名称 c，其值是一个组件名称列表，表示 c 属于这些组件。例如，如果有一个 total 组件，分为两个部门 d1 和 d2，以及两个区域 r1 和 r2，并且有四个产品 d1r1`（在部门 `d1 和区域 r1），d2r1，d1r2 和 d2r2，层次结构将编码如下。 .. highlight:: python .. code-block:: python
**kwargs – 传递给 pandas.read_csv 函数的可选参数

返回

由输入构建的单变量或多变量确定性时间序列。

返回类型

TimeSeries

classmethod from_dataframe(df, time_col=None, value_cols=None, fill_missing_dates=False, freq=None, fillna_value=None, static_covariates=None, hierarchy=None)[源代码]¶

构建一个由DataFrame列选择构建的确定性TimeSeries实例。一列（或DataFrame索引）必须代表时间，并且一个列列表 value_cols 必须代表该时间序列的值。

参数

df (DataFrame) – DataFrame
time_col (Optional[str, None]) – 时间列的名称。如果设置，该列将被转换为 pandas DatetimeIndex（如果包含时间戳）或 RangeIndex（如果包含整数）。如果未设置，将使用 DataFrame 索引。在这种情况下，DataFrame 必须包含一个索引，该索引是 pandas DatetimeIndex、pandas RangeIndex 或可以转换为 RangeIndex 的 pandas Index。如果索引没有空洞会更好；或者在某些情况下，设置 fill_missing_dates 可以解决这些问题（用 NaN 或提供的 fillna_value 数值填充空洞，如果有的话）。
value_cols (Union[List[str], str, None]) – 表示要从 DataFrame 中提取的值列的字符串或字符串列表。如果设置为 None，将使用整个 DataFrame。
fill_missing_dates (Optional[bool, None]) – 可选地，一个布尔值，指示是否用NaN值填充缺失的日期（或整数索引情况下的索引）。这需要提供一个`freq`或从提供的时间戳推断频率的可能性。更多信息请参见 _fill_missing_dates()。
freq (Union[int, str, None]) – 可选地，一个字符串或整数，表示基础索引的频率。这对于在某些日期缺失且 fill_missing_dates 设置为 True 时填充缺失值很有用。如果是字符串，表示 pandas DatetimeIndex 的频率（有关支持的频率的更多信息，请参见偏移别名）。如果是整数，表示 pandas Index 或 pandas RangeIndex 的步长。
fillna_value (Optional[float, None]) – 可选地，一个数值用于填充缺失值（NaNs）。
static_covariates (Union[Series, DataFrame, None]) – 可选地，添加到 TimeSeries 的一组静态协变量。可以是 pandas Series 或 pandas DataFrame。如果是 Series，索引表示静态变量。协变量全局地 ‘应用’ 于 TimeSeries 的所有组件。如果是 DataFrame，列表示静态变量，行表示 uni/multivariate TimeSeries 的组件。如果是单行 DataFrame，协变量全局地 ‘应用’ 于 TimeSeries 的所有组件。如果是多行 DataFrame，行数必须与 TimeSeries 的组件数匹配（在这种情况下，行数与 value_cols 中的列数相同）。这增加了对组件特定静态协变量的控制。
hierarchy (Optional[Dict, None]) – 可选地，一个描述时间序列分组的字典。键是组件名称，对于给定的组件名称 c，其值是一个组件名称列表，表示 c 属于这些组件。例如，如果有一个 total 组件，分为两个部门 d1 和 d2，以及两个区域 r1 和 r2，并且有四个产品 d1r1`（在部门 `d1 和区域 r1），d2r1，d1r2 和 d2r2，层次结构将编码如下。 .. highlight:: python .. code-block:: python

返回

由输入构建的单变量或多变量确定性时间序列。

返回类型

TimeSeries

classmethod from_group_dataframe(df, group_cols, time_col=None, value_cols=None, static_cols=None, fill_missing_dates=False, freq=None, fillna_value=None, drop_group_cols=None, n_jobs=1, verbose=False)[源代码]¶

构建一个按DataFrame中选定列分组的TimeSeries实例列表。一列（或DataFrame索引）必须表示时间，必须使用列列表`group_cols`通过组提取单个TimeSeries，并且必须使用列列表`value_cols`表示单个时间序列的值。来自列``group_cols``和``static_cols``的值作为静态协变量添加到生成的TimeSeries对象中。这些可以通过`my_series.static_covariates`查看。与`group_cols`不同，`static_cols`仅添加静态值，但不用于提取TimeSeries组。

参数

df (DataFrame) – DataFrame
group_cols (Union[List[str], str]) – 表示要从 DataFrame 中提取单个时间序列组的列的字符串或字符串列表。
time_col (Optional[str, None]) – 时间列的名称。如果设置，该列将被转换为 pandas DatetimeIndex（如果包含时间戳）或 RangeIndex（如果包含整数）。如果未设置，将使用 DataFrame 索引。在这种情况下，DataFrame 必须包含一个索引，该索引是 pandas DatetimeIndex、pandas RangeIndex 或可以转换为 RangeIndex 的 pandas Index。请注意，索引必须表示每个单独时间序列组的实际索引（可以包含非唯一值）。如果索引没有空洞会更好；或者在某些情况下，设置 fill_missing_dates 可以解决这些问题（用 NaN 填充空洞，或者如果有提供 fillna_value 数值，则用该数值填充）。
value_cols (Union[List[str], str, None]) – 表示要从 DataFrame 中提取的值列的字符串或字符串列表。如果设置为 None，将使用整个 DataFrame。
static_cols (Union[List[str], str, None]) – 表示应作为静态协变量附加到生成的 TimeSeries 组的 DataFrame 中的静态变量列的字符串或字符串列表。与 group_cols 不同，DataFrame 不会按这些列分组。请注意，对于每个组，必须有且仅有一个唯一值。
fill_missing_dates (Optional[bool, None]) – 可选地，一个布尔值，指示是否用NaN值填充缺失的日期（或整数索引情况下的索引）。这需要提供一个`freq`或从提供的时间戳推断频率的可能性。更多信息请参见 _fill_missing_dates()。
freq (Union[int, str, None]) – 可选地，一个字符串或整数，表示基础索引的频率。这对于在某些日期缺失且 fill_missing_dates 设置为 True 时填充缺失值很有用。如果是字符串，表示 pandas DatetimeIndex 的频率（有关支持的频率的更多信息，请参见偏移别名）。如果是整数，表示 pandas Index 或 pandas RangeIndex 的步长。
fillna_value (Optional[float, None]) – 可选地，一个数值用于填充缺失值（NaNs）。
drop_group_cols (Union[List[str], str, None]) – 可选地，一个字符串或字符串列表，包含要从静态协变量中排除的 group_cols 列。
n_jobs (Optional[int, None]) – 可选地，一个表示要运行的并行作业数量的整数。其行为与 joblib.Parallel 类中的行为相同。
verbose (Optional[bool, None]) – 可选地，一个布尔值，指示是否显示进度条。

返回

包含 DataFrame 中每个组的单变量或多变量确定性时间序列的列表。

返回类型

List[TimeSeries]

classmethod from_json(json_str, static_covariates=None, hierarchy=None)[源代码]¶

从 TimeSeries 的 JSON 字符串表示构建一个系列（使用 TimeSeries.to_json() 生成）。

目前这仅支持确定性时间序列（即，由1个样本组成）。

参数

json_str (str) – 要转换的 JSON 字符串
static_covariates (Union[Series, DataFrame, None]) – 可选地，添加到 TimeSeries 的一组静态协变量。可以是 pandas Series 或 pandas DataFrame。如果是 Series，索引表示静态变量。协变量全局地 ‘应用’ 于 TimeSeries 的所有组件。如果是 DataFrame，列表示静态变量，行表示 uni/multivariate TimeSeries 的组件。如果是单行 DataFrame，协变量全局地 ‘应用’ 于 TimeSeries 的所有组件。如果是多行 DataFrame，行数必须与 TimeSeries 的组件数匹配（在这种情况下，行数与 value_cols 中的列数相同）。这增加了对组件特定静态协变量的控制。
hierarchy (Optional[Dict, None]) – 可选地，一个描述时间序列分组的字典。键是组件名称，对于给定的组件名称 c，其值是一个组件名称列表，表示 c 属于这些组件。例如，如果有一个 total 组件，分为两个部门 d1 和 d2，以及两个区域 r1 和 r2，并且有四个产品 d1r1`（在部门 `d1 和区域 r1），d2r1，d1r2 和 d2r2，层次结构将编码如下。 .. highlight:: python .. code-block:: python

返回

从JSON字符串转换的时间序列对象

返回类型

TimeSeries

classmethod from_pickle(path)[源代码]¶

读取一个序列化的 TimeSeries。

参数: path (string) – 指向将被加载的 pickle 文件的路径
返回: 从文件加载的时间序列对象
返回类型: TimeSeries

提示

Xarray 文档 [1] 建议不要将 pickle 用作长期数据存储。

引用

1: http://xarray.pydata.org/en/stable/user-guide/io.html#pickle

classmethod from_series(pd_series, fill_missing_dates=False, freq=None, fillna_value=None, static_covariates=None)[源代码]¶

从 pandas Series 构建一个单变量的确定性序列。

该序列必须包含一个索引，该索引要么是 pandas 的 DatetimeIndex，要么是 pandas 的 RangeIndex，或者是可以转换为 RangeIndex 的 pandas 索引。如果索引没有空洞会更好；或者在某些情况下，设置 fill_missing_dates 可以解决这些问题（用 NaN 填充空洞，或者用提供的 fillna_value 数值填充，如果有的话）。

参数

pd_series (Series) – pandas Series 实例。
fill_missing_dates (Optional[bool, None]) – 可选地，一个布尔值，指示是否用NaN值填充缺失的日期（或整数索引情况下的索引）。这需要提供一个`freq`或从提供的时间戳推断频率的可能性。更多信息请参见 _fill_missing_dates()。
freq (Union[int, str, None]) – 可选地，一个字符串或整数，表示基础索引的频率。这对于在某些日期缺失且 fill_missing_dates 设置为 True 时填充缺失值很有用。如果是字符串，表示 pandas DatetimeIndex 的频率（有关支持的频率的更多信息，请参见偏移别名）。如果是整数，表示 pandas Index 或 pandas RangeIndex 的步长。
fillna_value (Optional[float, None]) – 可选地，一个数值用于填充缺失值（NaNs）。
static_covariates (Union[Series, DataFrame, None]) – 可选地，添加到 TimeSeries 的一组静态协变量。可以是 pandas Series 或单行 pandas DataFrame。如果是 Series，索引表示静态变量。如果是 DataFrame，列表示静态变量，单行表示单变量 TimeSeries 组件。

返回

从输入构建的单变量和确定性时间序列。

返回类型

TimeSeries

classmethod from_times_and_values(times, values, fill_missing_dates=False, freq=None, columns=None, fillna_value=None, static_covariates=None, hierarchy=None)[源代码]¶

从时间索引和值数组构建一个序列。

参数

times (Union[DatetimeIndex, RangeIndex, Index]) – 一个 pandas DateTimeIndex、RangeIndex 或可以转换为 RangeIndex 的 Index，表示时间序列的时间轴。如果索引没有空洞会更好；或者在某些情况下，设置 fill_missing_dates 可以解决这些问题（用 NaN 或提供的 fillna_value 数值填充空洞，如果有的话）。
values (ndarray) – 一个用于时间序列的 Numpy 数组。接受二维数组（用于确定性序列）和三维数组（用于概率性序列）。在前一种情况下，维度应为 (时间, 组件)，在后一种情况下，维度应为 (时间, 组件, 样本)。
fill_missing_dates (Optional[bool, None]) – 可选地，一个布尔值，指示是否用NaN值填充缺失的日期（或整数索引情况下的索引）。这需要提供一个`freq`或从提供的时间戳推断频率的可能性。更多信息请参见 _fill_missing_dates()。
freq (Union[int, str, None]) – 可选地，一个字符串或整数，表示基础索引的频率。这对于在某些日期缺失且 fill_missing_dates 设置为 True 时填充缺失值很有用。如果是字符串，表示 pandas DatetimeIndex 的频率（有关支持的频率的更多信息，请参见偏移别名）。如果是整数，表示 pandas Index 或 pandas RangeIndex 的步长。
columns (Union[ForwardRef, ndarray, ForwardRef, ForwardRef, SequenceNotStr, range, None]) – 底层 pandas DataFrame 使用的列。
fillna_value (Optional[float, None]) – 可选地，一个数值用于填充缺失值（NaNs）。
static_covariates (Union[Series, DataFrame, None]) – 可选地，一组要添加到 TimeSeries 的静态协变量。可以是 pandas Series 或 pandas DataFrame。如果是 Series，索引表示静态变量。协变量全局地 ‘应用’ 于 TimeSeries 的所有组件。如果是 DataFrame，列表示静态变量，行表示 uni/multivariate TimeSeries 的组件。如果是单行 DataFrame，协变量全局地 ‘应用’ 于 TimeSeries 的所有组件。如果是多行 DataFrame，行数必须与 TimeSeries 的组件数匹配（在这种情况下，行数与 values 中的列数相同）。这增加了对组件特定静态协变量的控制。
hierarchy (Optional[Dict, None]) – 可选地，一个描述时间序列分组的字典。键是组件名称，对于给定的组件名称 c，其值是一个组件名称列表，表示 c 属于这些组件。例如，如果有一个 total 组件，分为两个部门 d1 和 d2，以及两个区域 r1 和 r2，并且有四个产品 d1r1`（在部门 `d1 和区域 r1），d2r1，d1r2 和 d2r2，层次结构将编码如下。 .. highlight:: python .. code-block:: python

返回

从输入构建的时间序列。

返回类型

TimeSeries

classmethod from_values(values, columns=None, fillna_value=None, static_covariates=None, hierarchy=None)[源代码]¶

从值数组构建一个整数索引的序列。该序列将具有整数索引（RangeIndex）。

参数

values (ndarray) – 一个用于时间序列的 Numpy 数组。接受二维数组（用于确定性序列）和三维数组（用于概率性序列）。在前一种情况下，维度应为 (时间, 组件)，在后一种情况下，维度应为 (时间, 组件, 样本)。
columns (Union[ForwardRef, ndarray, ForwardRef, ForwardRef, SequenceNotStr, range, None]) – 底层 pandas DataFrame 使用的列。
fillna_value (Optional[float, None]) – 可选地，一个数值用于填充缺失值（NaNs）。
static_covariates (Union[Series, DataFrame, None]) – 可选地，一组要添加到 TimeSeries 的静态协变量。可以是 pandas Series 或 pandas DataFrame。如果是 Series，索引表示静态变量。协变量全局地 ‘应用’ 于 TimeSeries 的所有组件。如果是 DataFrame，列表示静态变量，行表示 uni/multivariate TimeSeries 的组件。如果是单行 DataFrame，协变量全局地 ‘应用’ 于 TimeSeries 的所有组件。如果是多行 DataFrame，行数必须与 TimeSeries 的组件数匹配（在这种情况下，行数与 values 中的列数相同）。这增加了对组件特定静态协变量的控制。
hierarchy (Optional[Dict, None]) – 可选地，一个描述时间序列分组的字典。键是组件名称，对于给定的组件名称 c，其值是一个组件名称列表，表示 c 属于这些组件。例如，如果有一个 total 组件，分为两个部门 d1 和 d2，以及两个区域 r1 和 r2，并且有四个产品 d1r1`（在部门 `d1 和区域 r1），d2r1，d1r2 和 d2r2，层次结构将编码如下。 .. highlight:: python .. code-block:: python

返回

从输入构建的时间序列。

返回类型

TimeSeries

classmethod from_xarray(xa, fill_missing_dates=False, freq=None, fillna_value=None)[源代码]¶

返回一个由 xarray DataArray 构建的 TimeSeries 实例。DataArray 的维度必须是 (时间, 组件, 样本)，按此顺序。时间维度可以有任意名称，但组件和样本必须分别命名为 “component” 和 “sample”。

第一个维度（时间）和第二个维度（组件）必须被索引（即，有坐标）。时间必须使用 pandas DatetimeIndex、pandas RangeIndex 或可以转换为 RangeIndex 的 pandas Index 进行索引。如果索引没有空洞会更好；或者在某些情况下，设置 fill_missing_dates 可以解决这些问题（用 NaN 或提供的 fillna_value 数值填充空洞，如果有的话）。

如果两个组件具有相同名称或不是字符串，此方法将通过将形式为“<name>_N”的后缀附加到名称为“name”的第N列来消除组件名称的歧义。静态协变量和层次结构（如果有）中的组件名称不会被消除歧义。

参数

xa (DataArray) – xarray 数据数组
fill_missing_dates (Optional[bool, None]) – 可选地，一个布尔值，指示是否用NaN值填充缺失的日期（或整数索引情况下的索引）。这需要提供一个`freq`或从提供的时间戳推断频率的可能性。更多信息请参见 _fill_missing_dates()。
freq (Union[int, str, None]) – 可选地，一个字符串或整数，表示基础索引的频率。这对于在某些日期缺失且 fill_missing_dates 设置为 True 时填充缺失值很有用。如果是字符串，表示 pandas DatetimeIndex 的频率（有关支持的频率的更多信息，请参见偏移别名）。如果是整数，表示 pandas Index 或 pandas RangeIndex 的步长。
fillna_value (Optional[float, None]) – 可选地，一个数值用于填充缺失值（NaNs）。

返回

由输入构建的单变量或多变量确定性时间序列。

返回类型

TimeSeries

gaps(mode='all')[源代码]¶

一个用于计算并返回时间序列中间隙的函数。仅适用于确定性时间序列（1个样本）。

参数: mode (Literal[‘all’, ‘any’]) – 仅适用于多变量时间序列。模式定义了如何定义间隙。如果任何列中的NaN值应被视为间隙，则设置为’any’。’all’将仅考虑所有列的值均为NaN的周期。默认为’all’。
返回: 一个包含每条间隙（底层DataFrame中所有值为NaN的行）的pandas.DataFrame。该DataFrame包含三列，包括间隙的开始和结束时间戳以及间隙的整数长度（如果序列由DatetimeIndex索引，则以`self.freq`单位表示）。
返回类型: pd.DataFrame

get_index_at_point(point, after=True)[源代码]¶

将时间轴索引上的一个点转换为范围在 (0, len(series)-1) 内的整数索引。

参数

point (Union[Timestamp, float, int]) – 此参数支持3种不同的数据类型：pd.Timestamp、float 和 int。pd.Timestamp 仅适用于索引为 pd.DatetimeIndex 的系列。在这种情况下，如果该时间戳存在于系列时间索引中，则返回的点将是该时间戳的索引。如果它不在时间索引中，如果 after=True`（如果它在系列中存在），则返回下一个时间戳的索引，否则返回前一个时间戳的索引（如果它在系列中存在）。对于 ``float` 类型，参数将被视为时间序列中应位于该点之前的比例。如果是 int 且系列为日期时间索引，则返回 point 的值。如果是 int 且系列为整数索引，则返回 point 在 RangeIndex 中的索引位置（考虑步长）。
after – 如果提供的 pandas 时间戳不在时间序列索引中，是返回下一个时间戳的索引还是前一个时间戳的索引。

返回类型

int

get_timestamp_at_point(point)[源代码]¶

将一个点转换为 pandas.Timestamp（如果是 Datetime 索引）或转换为整数（如果是 Int64 索引）。

参数: point (Union[Timestamp, float, int]) – 此参数支持3种不同的数据类型：float、int 和 pandas.Timestamp。如果是 float，该参数将被视为时间序列中应位于该点之前的比例。如果是 int，该参数将被视为 series 时间索引的整数索引。如果它不是 series 中的有效索引，将引发 ValueError。如果是 pandas.Timestamp，将返回该点，前提是时间戳存在于序列时间索引中，否则将引发 ValueError。
返回类型: Union[Timestamp, int]

property has_datetime_index: bool¶

该系列是否使用 DatetimeIndex 进行索引（否则使用 RangeIndex 进行索引）。

返回类型: bool

property has_hierarchy: bool¶

这一系列是否是分层的。

返回类型: bool

property has_range_index: bool¶

该系列是否使用 RangeIndex 进行索引（否则使用 DatetimeIndex 进行索引）。

返回类型: bool

has_same_time_as(other)[源代码]¶

检查此系列的时间索引是否与 other 相同。

参数: other (Self) – 其他系列
返回: 如果两个时间序列具有相同的索引，则为True，否则为False。
返回类型: bool

property has_static_covariates: bool¶

该系列是否包含静态协变量。

返回类型: bool

head(size=5, axis=0)[源代码]¶

返回一个包含前 size 个点的 TimeSeries。

参数

size (int, default 5) – 保留的点数
axis (str or int, optional, default: 0) – 沿着该轴切片序列

返回

沿着所需轴的前 size 个点的序列。

返回类型

TimeSeries

property hierarchy: Optional[Dict]¶

这个时间序列的层次结构（如果有的话）。如果设置，层次结构被编码为一个字典，其键是各个组成部分，值是这些组成部分在层次结构中的父级集合。

返回类型: Optional[Dict, None]

property is_deterministic: bool¶

该系列是否是确定性的。

返回类型: bool

property is_probabilistic: bool¶

该系列是否是随机的（= 概率性的）。

返回类型: bool

property is_stochastic: bool¶

该系列是否为随机。

返回类型: bool

property is_univariate: bool¶

此系列是否为单变量。

返回类型: bool

is_within_range(ts)[源代码]¶

检查给定的时间戳或整数是否在此时间序列的时间间隔内。如果提供了时间戳，它不需要是序列时间索引的元素。

参数: ts (Union[Timestamp, int]) – 要检查的 `pandas.Timestamp`（如果使用 DatetimeIndex 索引）或整数（如果使用 RangeIndex 索引）。
返回: ts 是否包含在此时间序列的区间内。
返回类型: bool

kurtosis(**kwargs)[源代码]¶

返回一个确定性的 TimeSeries ，其中包含此随机 TimeSeries 的每个分量（在样本上）的峰度。

这仅适用于随机序列（即，包含多个样本）

参数: kwargs – 其他关键字参数会传递给 scipy.stats.kurtosis()
返回: 包含每个成分的峰度的时序数据。
返回类型: TimeSeries

last_value()[源代码]¶

这个单变量序列的最后一个值。

返回: 这个单变量确定性时间序列的最后一个值
返回类型: float

last_values()[源代码]¶

这个潜在的多变量序列的最后值。

返回: 这个确定性时间序列的每个分量的最后值
返回类型: np.ndarray

longest_contiguous_slice(max_gap_size=0, mode='all')[源代码]¶

返回此确定性序列中不包含大于 max_gap_size 的间隙（连续的全部为 NaN 的值）的最大时间序列切片。

此方法仅适用于确定性序列（即，具有1个样本）。

参数

max_gap_size (int) – 指示 TimeSerie 可以包含的最大间隙大小
mode (str) – 仅适用于多变量时间序列。模式定义了如何定义间隙。如果任何列中的NaN值应被视为间隙，则设置为’any’。’all’将仅考虑所有列的值均为NaN的周期。默认为’all’。

返回

一个新的系列，构成了原始数据中最大的一部分，没有或仅有有限的间隔

返回类型

TimeSeries

参见

TimeSeries.gaps: 返回时间序列中的间隙

map(fn)[源代码]¶

将函数 fn 应用于包含此系列值的基础 NumPy 数组。

返回一个新的 TimeSeries 实例。如果 fn 接受 1 个参数，它将简单地应用于形状为 (时间, n_components, n_samples) 的后备数组。如果它接受 2 个参数，它将重复应用于 (ts, value[ts]) 元组，其中 “ts” 表示时间戳值，”value[ts]” 表示在该时间戳的值数组，形状为 (n_components, n_samples)。

参数: fn (Union[Callable[[number], number], Callable[[Union[Timestamp, int], number], number]]) – 一个函数，该函数接受一个 NumPy 数组并返回相同形状的 NumPy 数组；例如，lambda x: x ** 2、lambda x: x / x.shape[0] 或 np.log。它也可以是一个函数，该函数接受一个时间戳和数组，并返回相同形状的新数组；例如，lambda ts, x: x / ts.days_in_month。ts 的类型要么是 `pd.Timestamp`（如果序列使用 DatetimeIndex 索引），要么是整数（如果序列使用 RangeIndex 索引）。
返回: 一个新的 TimeSeries 实例
返回类型: TimeSeries

max(axis=2)[源代码]¶

返回一个包含在指定轴上计算的最大值的 TimeSeries。

如果我们随时间减少（axis=0），结果的 TimeSeries 将具有长度一，并将使用原始 time_index 的第一个条目。如果我们对组件进行计算（axis=1），结果的单个组件将被重命名为“components_max”。当应用于样本（axis=2）时，将返回一个确定性的 TimeSeries。

如果 axis=1，则从序列中丢弃静态协变量和层次结构。

参数: axis (int) – 要减少的轴。默认是计算样本，即 axis=2。
返回: 应用了最大值的新时间序列，作用于指定的轴。
返回类型: TimeSeries

mean(axis=2)[源代码]¶

返回一个包含在指定轴上计算的平均值的 TimeSeries。

如果我们随时间减少（axis=0），结果的 TimeSeries 将具有长度一，并将使用原始 time_index 的第一个条目。如果我们对组件进行计算（axis=1），结果的单个组件将被重命名为“components_mean”。当应用于样本（axis=2）时，将返回一个确定性的 TimeSeries。

如果 axis=1，则从序列中丢弃静态协变量和层次结构。

参数: axis (int) – 要减少的轴。默认是计算样本，即 axis=2。
返回: 应用了指定轴的均值的新时间序列。
返回类型: TimeSeries

median(axis=2)[源代码]¶

返回一个包含沿指定轴计算的中位数的 TimeSeries。

如果我们随时间减少（axis=0），结果的 TimeSeries 将具有长度一，并将使用原始 time_index 的第一个条目。如果我们对组件进行计算（axis=1），结果的单个组件将被重命名为“components_median”。当应用于样本（axis=2）时，将返回一个确定的 TimeSeries。

如果 axis=1，则从序列中丢弃静态协变量和层次结构。

参数: axis (int) – 要减少的轴。默认是计算样本，即 axis=2。
返回: 一个新的 TimeSeries，其中对指定轴应用了中位数。
返回类型: TimeSeries

min(axis=2)[源代码]¶

返回一个包含在指定轴上计算的最小值的 TimeSeries。

如果我们随时间减少（axis=0），结果的 TimeSeries 将具有长度一，并将使用原始 time_index 的第一个条目。如果我们对组件进行计算（axis=1），结果的单个组件将被重命名为“components_min”。当应用于样本（axis=2）时，将返回一个确定性的 TimeSeries。

如果 axis=1，则从序列中丢弃静态协变量和层次结构。

参数: axis (int) – 要减少的轴。默认是计算样本，即 axis=2。
返回: 应用了最小值的新时间序列，沿指定轴。
返回类型: TimeSeries

property n_components: int¶

系列中包含的组件（维度）数量。

返回类型: int

property n_samples: int¶

系列中包含的样本数量。

返回类型: int

property n_timesteps: int¶

序列中的时间步数。

返回类型: int

pd_dataframe(copy=True, suppress_warnings=False)[源代码]¶

返回此时间序列的 Pandas DataFrame 表示。

系列中的每个组件将作为DataFrame中的一列出现。如果系列是随机的，样本将作为数据框的列返回，列名称为’component_s#’（例如，有两个组件和两个样本：’comp0_s0’, ‘comp0_s1’ ‘comp1_s0’ ‘comp1_s1’）。

参数: copy – 是否返回数据框的副本。除非你知道自己在做什么，否则请保持为True。
返回: 此时间序列的 Pandas DataFrame 表示
返回类型: pandas.DataFrame

pd_series(copy=True)[源代码]¶

返回此单变量确定性时间序列的 Pandas Series 表示。

仅适用于确定性的单变量序列（即，由1个样本组成）。

参数: copy – 是否返回序列的副本。除非你知道自己在做什么，否则请保持为 True。
返回: 这个单变量时间序列的 Pandas Series 表示。
返回类型: pandas.Series

plot(new_plot=False, central_quantile=0.5, low_quantile=0.05, high_quantile=0.95, default_formatting=True, label='', max_nr_components=10, ax=None, *args, **kwargs)[源代码]¶

绘制序列。

这是一个围绕 xarray.DataArray.plot() 的包装方法。

参数

new_plot (bool) – 是否生成一个新的轴进行绘图。另请参见参数 ax。
central_quantile (Union[float, str]) – 要绘制的分位数（介于0和1之间）作为“中心”值，如果序列是随机的（即，如果它有多个样本）。这将分别应用于每个组件（即，显示组件边际分布的分位数）。例如，设置 central_quantile=0.5 将绘制每个组件的中位数。central_quantile 也可以设置为 ‘mean’。
low_quantile (Optional[float, None]) – 用于绘制置信区间下限的分位数。类似于 central_quantile，这是分别应用于每个组件的（即显示边缘分布）。如果 confidence_low_quantile 为 None（默认 0.05），则不显示置信区间。
high_quantile (Optional[float, None]) – 用于绘制置信区间上限的分位数。类似于 central_quantile，这是分别应用于每个组件的（即显示边际分布）。如果 high_quantile 为 None（默认值为 0.95），则不显示置信区间。
default_formatting (bool) – 是否使用飞镖默认方案。
label (Union[str, Sequence[str], None]) – 可以是字符串或字符串列表。如果是一个字符串且系列只有一个组件，它将用作该组件的标签。如果是一个字符串且系列有多个组件，它将用作每个组件名称的前缀。如果是一个与系列中组件数量相等的字符串列表，标签将按顺序映射到组件。
max_nr_components (int) – 要绘制的序列的最大组件数量。-1 表示将绘制所有组件。
ax (Optional[Axes, None]) – 可选地，一个用于绘图的轴。如果为 None，并且 new_plot=False，将使用当前轴。如果 new_plot=True，将创建一个新的轴。
alpha – 可选地，为确定性序列设置线性alpha，或为概率性序列设置置信区间alpha。
args – plot() 方法的一些位置参数
kwargs – plot() 方法的一些关键字参数

返回

传递的 ax 轴，如果 new_plot=True 则创建一个新的，或者使用现有的。

返回类型

matplotlib.axes.Axes

prepend(other)[源代码]¶

在时间轴上将另一个序列前置（即添加到此序列的开头）。

参数: other (Self) – 第二个时间序列。
返回: 一个新的时间序列，通过将第二个时间序列附加到第一个时间序列获得。
返回类型: TimeSeries

参见

Timeseries.append: 在时间轴上追加（即添加到末尾）另一个序列。
TimeSeries.concatenate: 沿着给定的轴连接另一个序列。

prepend_values(values)[源代码]¶

在当前 TimeSeries 的开头添加新值（即添加到开头），将其时间索引扩展到过去。

参数: values (ndarray) – 一个包含要在开头前置的值的数组。
返回: 一个新的时间序列，新的值被前置。
返回类型: TimeSeries

quantile(quantile, **kwargs)[源代码]¶

返回一个确定性的 TimeSeries ，其中包含此随机 TimeSeries 的每个分量（在样本上）的单一所需分位数。

新系列中的组件被命名为“<component>_X”，其中“<component>”是与此组件对应的列名，“X”是分位数值。分位数列表示该系列组件的边际分布。

这仅适用于随机序列（即，包含多个样本）

参数

quantile (float) – 所需的百分位数值。该值必须表示为一个分数（介于0和1之间，包括0和1）。例如，0.5 将返回一个包含每个成分（边际）分布中位数的 TimeSeries。
kwargs – 其他关键字参数会传递给 numpy.quantile()

返回

包含每个组件所需分位数的 TimeSeries。

返回类型

TimeSeries

quantile_df(quantile=0.5)[源代码]¶

返回一个包含每个成分（在样本中）所需单一分位数的 Pandas DataFrame。

每个系列组件将作为DataFrame中的一列出现。该列将被命名为“<component>_X”，其中“<component>”是对应于此组件的列名，“X”是分位数值。分位数列表示该系列组件的边际分布。

这仅适用于随机序列（即，包含多个样本）

参数: quantile – 所需的百分位数值。该值必须表示为一个分数（介于0和1之间，包括0和1）。例如，0.5 将返回一个包含每个分量（边际）分布中位数的DataFrame。
返回: 包含每个组件所需分位数的 Pandas DataFrame。
返回类型: pandas.DataFrame

quantile_timeseries(quantile=0.5, **kwargs)[源代码]¶

返回一个确定性的 TimeSeries ，其中包含此随机 TimeSeries 的每个分量（在样本上）的单一所需分位数。

新系列中的组件被命名为“<component>_X”，其中“<component>”是与此组件对应的列名，“X”是分位数值。分位数列表示该系列组件的边际分布。

这仅适用于随机序列（即，包含多个样本）

参数

quantile – 所需的百分位数值。该值必须表示为一个分数（介于0和1之间，包括0和1）。例如，0.5 将返回一个包含每个成分（边际）分布中位数的 TimeSeries。
kwargs – 其他关键字参数会传递给 numpy.quantile()

返回

包含每个组件所需分位数的 TimeSeries。

返回类型

TimeSeries

quantiles_df(quantiles=(0.1, 0.5, 0.9))[源代码]¶

返回一个包含每个分量所需分位数的 Pandas DataFrame（在样本上）。

每个系列组件将作为DataFrame中的一列出现。该列将被命名为“<component>_X”，其中“<component>”是对应于此组件的列名，“X”是分位数值。这些分位数表示该系列组件的边际分布。

这仅适用于随机序列（即，包含多个样本）

参数: quantiles (Tuple[float]) – 包含所需分位数的元组。这些值必须表示为分数（介于0和1之间，包括0和1）。例如，(0.1, 0.5, 0.9) 将返回一个包含每个分量的（边际）分布的第10百分位数、中位数和第90百分位数的DataFrame。
返回: 包含每个组件分位数的 Pandas DataFrame。
返回类型: pandas.DataFrame

random_component_values(copy=True)[源代码]¶

返回一个形状为 (时间, 组件) 的二维数组，包含从该系列样本中均匀随机抽取的一个样本的值。

参数: copy (bool) – 是否返回值的副本，否则返回视图。除非你知道自己在做什么，否则请保持为 True。
返回: 从时间序列中随机抽取的一个样本的组成值。
返回类型: numpy.ndarray

resample(freq, method='pad', **kwargs)[源代码]¶

使用给定的频率构建一个重新索引的 TimeSeries 。提供的方法用于填补重新索引的 TimeSeries 中的空洞，默认使用 ‘pad’ 方法。

参数

freq (str) – 返回的 TimeSeries 中两个相邻条目之间的新时间差。预期为一个 DateOffset 别名。
method (str) – 重新索引的TimeSeries中填充空洞的方法（注意这不会填充已经存在的NaN）： ‘pad’：将最后一个有效观测值向前传播到下一个有效值 ‘backfill’：使用下一个有效观测值进行填充。
kwargs – xarray.resample 方法的一些关键字参数，特别是 offset 或 base，用于指示从何处开始重采样，以避免重采样后的 TimeSeries 的第一个值出现 nan。更多信息，请参阅 xarray resample() 文档。

实际案例

>>> times = pd.date_range(start=pd.Timestamp("20200101233000"), periods=6, freq="15min")
>>> pd_series = pd.Series(range(6), index=times)
>>> ts = TimeSeries.from_series(pd_series)
>>> print(ts.time_index)
DatetimeIndex(['2020-01-01 23:30:00', '2020-01-01 23:45:00',
               '2020-01-02 00:00:00', '2020-01-02 00:15:00',
               '2020-01-02 00:30:00', '2020-01-02 00:45:00'],
               dtype='datetime64[ns]', name='time', freq='15T')
>>> resampled_nokwargs_ts = ts.resample(freq="1h")
>>> print(resampled_nokwargs_ts.time_index)
DatetimeIndex(['2020-01-01 23:00:00', '2020-01-02 00:00:00'],
              dtype='datetime64[ns]', name='time', freq='H')
>>> print(resampled_nokwargs_ts.values())
[[nan]
[ 2.]]
>>> resampled_ts = ts.resample(freq="1h", offset=pd.Timedelta("30min"))
>>> print(resampled_ts.time_index)
DatetimeIndex(['2020-01-01 23:30:00', '2020-01-02 00:30:00'],
              dtype='datetime64[ns]', name='time', freq='H')
>>> print(resampled_ts.values())
[[0.]
[4.]]

返回: 重新索引的时间序列，具有给定的频率。
返回类型: TimeSeries

rescale_with_value(value_at_first_step)[源代码]¶

返回一个新的 TimeSeries ，它是这个序列的倍数，使得第一个值为 value_at_first_step 。（注意：当 value_at_first_step > 1e+24 时，可能会出现数值误差）。

参数: value_at_first_step (float) – 时间序列第一个条目的新值。
返回: 一个新的时间序列，其中第一个值是 value_at_first_step，其他值已相应缩放。
返回类型: TimeSeries

shift(n)[源代码]¶

将此 TimeSeries 的时间轴向左或向右移动 n 个时间步长。

如果 \(n > 0\)，则向未来偏移。如果 \(n < 0\)，则向过去偏移。

例如，使用 \(n=2\) 和 freq=’M’，2013年3月变为2013年5月。使用 \(n=-2\)，2013年3月变为2013年1月。

参数: n (int) – 要移动的时间步数（以 self.freq 为单位）。可以是负数。
返回: 一个新的时间序列，其索引已偏移。
返回类型: TimeSeries

skew(**kwargs)[源代码]¶

返回一个确定性的 TimeSeries ，其中包含此随机 TimeSeries 的每个分量（在样本上）的偏度。

这仅适用于随机序列（即，包含多个样本）

参数: kwargs – 其他关键字参数会传递给 scipy.stats.skew()
返回: 包含每个组件偏斜的时间序列。
返回类型: TimeSeries

slice(start_ts, end_ts)[源代码]¶

返回一个新的时间序列，开始时间晚于 start_ts 且结束时间早于 end_ts。对于具有 DatetimeIndex 的序列，两端都是包含的。对于具有 RangeIndex 的序列，end_ts 是排除的。

start_ts 和 end_ts 不必在序列中。

参数

start_ts (Union[Timestamp, int]) – 指示左侧截断的时间戳。
end_ts (Union[Timestamp, int]) – 指示正确截止时间的戳记。

返回

一个新系列，其索引大于或等于 start_ts 且小于或等于 end_ts。

返回类型

TimeSeries

slice_intersect(other)[源代码]¶

返回此序列的 TimeSeries 切片，其中时间索引已与 other 序列的时间索引相交。

这种方法通常不是对称的。

参数: other (Self) – 其他时间序列
返回: 一个新的系列，包含了这个系列在两个时间序列共同时间跨度内的值。
返回类型: TimeSeries

slice_intersect_times(other, copy=True)[源代码]¶

返回此序列的时间索引，其中时间索引已与 other 序列的时间索引相交。

这种方法通常不是对称的。

参数

other (Self) – 其他时间序列
copy (bool) – 是否返回时间索引的副本，否则返回视图。除非你知道自己在做什么，否则请保持为 True。

返回

这个序列的时间索引，跨越了两个时间序列共同的时段。

返回类型

Union[pd.DatetimeIndex, pd.RangeIndex]

slice_intersect_values(other, copy=False)[源代码]¶

返回此序列的切片值，其中时间索引已与 other 序列的时间索引相交。

这种方法通常不是对称的。

参数

other (Self) – 其他时间序列
copy (bool) – 是否返回值的副本，否则返回视图。除非你知道自己在做什么，否则请保持为 True。

返回

这个系列在两个时间序列共同的时间跨度内的值。

返回类型

np.ndarray

slice_n_points_after(start_ts, n)[源代码]¶

返回一个新的时间序列，从 start_ts`（包含）开始，最多包含 `n 个点。

提供的时间戳将被包含在系列中。

参数

start_ts (Union[Timestamp, int]) – 指示分割时间的的时间戳或索引。
n (int) – 新时间序列的最大长度。

返回

一个新的时间序列，长度最多为 n，从 start_ts 开始

返回类型

TimeSeries

slice_n_points_before(end_ts, n)[源代码]¶

返回一个新的时间序列，结束于 end_ts`（包含）并且最多有 `n 个点。

提供的时间戳将被包含在系列中。

参数

end_ts (Union[Timestamp, int]) – 指示分割时间的的时间戳或索引。
n (int) – 新时间序列的最大长度。

返回

一个新的时间序列，长度最多为 n，结束于 start_ts

返回类型

TimeSeries

split_after(split_point)[源代码]¶

在提供的 split_point 之后将系列分成两部分。

参数: split_point (Union[Timestamp, float, int]) – 时间戳，浮点数或整数。如果是浮点数，表示包含在第一个时间序列中的系列比例（必须在0.0和1.0之间）。如果是整数，表示执行分割后的索引位置。对于由pd.DatetimeIndex索引的时间序列，可以提供pd.Timestamp。在这种情况下，时间戳将包含在第一个时间序列中，但不包含在第二个时间序列中。时间戳本身不必出现在原始时间序列索引中。
返回: 包含两个时间序列的元组。第一个时间序列包含从开始到 split_point 的样本，第二个包含剩余的样本。
返回类型: Tuple[TimeSeries, TimeSeries]

split_before(split_point)[源代码]¶

在提供的 split_point 之前将系列分成两部分。

参数: split_point (Union[Timestamp, float, int]) – 一个时间戳，浮点数或整数。如果是浮点数，表示第一个时间序列中包含的系列比例（必须在0.0和1.0之间）。如果是整数，表示执行分割的索引位置。对于由pd.DatetimeIndex索引的时间序列，可以提供pd.Timestamp。在这种情况下，时间戳将包含在第二个时间序列中，但不包含在第一个时间序列中。时间戳本身不需要出现在原始时间序列索引中。
返回: 包含两个时间序列的元组。第一个时间序列包含从开始到 split_point 的样本，第二个包含剩余的样本。
返回类型: Tuple[TimeSeries, TimeSeries]

stack(other)[源代码]¶

在当前时间序列的顶部（沿组件轴）堆叠另一个具有相同时间索引的单变量或多变量时间序列。

返回一个新的 TimeSeries，它包含 self 和 other 的所有组件。

生成的 TimeSeries 将具有与此 TimeSeries 相同的时间维度名称，并且具有相同数量的样本。

参数: other (Self) – 一个与当前实例具有相同索引和相同样本数量的 TimeSeries 实例。
返回: 一个新的多变量 TimeSeries 实例。
返回类型: TimeSeries

start_time()[源代码]¶

系列的开始时间。

返回: 包含时间序列的第一个时间的时间戳（如果按 DatetimeIndex 索引），或一个整数（如果按 RangeIndex 索引）
返回类型: Union[pandas.Timestamp, int]

property static_covariates: Optional[DataFrame]¶

返回序列中包含的静态协变量作为 pandas DataFrame。列表示静态变量，行表示单变量/多变量序列的组成部分。

返回类型: Optional[DataFrame, None]

static_covariates_values(copy=True)[源代码]¶

返回一个维度为 (组件, 静态变量) 的二维数组，包含时间序列的静态协变量值。

参数: copy (bool) – 是否返回值的副本，否则返回视图。只有当所有值具有相同的dtype时，才能返回视图。除非你知道自己在做什么，否则请保持为True。
返回: 如果该序列有静态协变量，则为静态协变量值，否则为 None。
返回类型: Optional[numpy.ndarray]

std(ddof=1)[源代码]¶

返回一个确定性的 TimeSeries ，其中包含此随机 TimeSeries 的每个分量（在样本上）的标准差。

这仅适用于随机序列（即，包含多个样本）

参数: ddof (int) – “自由度增量”：计算中使用的除数是 N - ddof，其中 N 表示元素的数量。默认情况下，ddof 为 1。
返回: 包含每个成分标准差的TimeSeries。
返回类型: TimeSeries

strip(how='all')[源代码]¶

返回这个确定性时间序列的 TimeSeries 切片，其中在序列开头和结尾包含 NaN 的条目被移除。在第一个非 NaN 条目之后（包括）和最后一个非 NaN 条目之前（包括）的条目不会被移除。

此方法仅适用于确定性序列（即，具有1个样本）。

参数: how (str) – 定义是否应删除在所有组件中包含 `NaN`（’all’）或在任何组件中包含 `NaN`（’any’）的条目。默认值：’all’
返回: 基于原始数据的新系列，其中已移除开头和结尾包含NaN的条目
返回类型: TimeSeries

sum(axis=2)[源代码]¶

返回一个包含在指定轴上计算的总和的 TimeSeries。

如果我们随时间减少（axis=0），结果的 TimeSeries 将具有长度一，并将使用原始 time_index 的第一个条目。如果我们对组件进行计算（axis=1），结果的单个组件将被重命名为“components_sum”。当应用于样本（axis=2）时，将返回一个确定性的 TimeSeries。

如果 axis=1，则从序列中丢弃静态协变量和层次结构。

参数: axis (int) – 要减少的轴。默认是计算样本，即 axis=2。
返回: 应用了求和操作的新时间序列，作用于指定的轴。
返回类型: TimeSeries

tail(size=5, axis=0)[源代码]¶

返回序列的最后 size 个点。

参数

size (int, default: 5) – 保留的点数
axis (str or int, optional, default: 0 (time dimension)) – 我们打算沿其显示记录的轴

返回

沿所需轴的最后大小个点的序列。

返回类型

TimeSeries

property time_dim: str¶

此时间序列的时间维度的名称。

返回类型: str

property time_index: Union[DatetimeIndex, RangeIndex]¶

这个时间序列的时间索引。

返回类型: Union[DatetimeIndex, RangeIndex]

to_csv(*args, **kwargs)[源代码]¶

将这个确定性序列写入CSV文件。有关参数列表，请参阅 pandas.DataFrame.to_csv() [1] 的文档。

引用

1: https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.DataFrame.to_csv.html?highlight=to_csv

to_json()[源代码]¶

返回此确定性序列的 JSON 字符串表示。

目前，此功能仅适用于确定性时间序列（即，由1个样本组成）。

提示

静态协变量不会在 JSON 字符串中返回。使用 TimeSeries.from_json() 时，可以通过输入参数 static_covariates 添加静态协变量。

返回: 表示时间序列的 JSON 字符串
返回类型: str

to_pickle(path, protocol=5)[源代码]¶

将此系列保存为 pickle 格式。

参数

path (string) – 当前对象将被序列化的文件路径
protocol (integer, default highest) – pickling 协议。默认设置在大多数情况下是最好的，只有在遇到向后兼容性问题时才使用它。

提示

Xarray 文档 [1] 建议不要将 pickle 用作长期数据存储。

引用

1: http://xarray.pydata.org/en/stable/user-guide/io.html#pickle

property top_level_component: Optional[str]¶

此系列的最高层组件名称，如果系列没有层次结构，则为 None。

返回类型: Optional[str, None]

property top_level_series: Optional[Self]¶

包含此系列单一顶级组件的单变量系列，如果该系列没有层次结构，则为 None。

返回类型: Optional[Self, None]

univariate_component(index)[源代码]¶

检索系列中的一个组件，并将其作为新的单变量 TimeSeries 实例返回。

这将删除层次结构（如果有），并仅保留相关的静态协变量列。

参数: index (Union[str, int]) – 一个从零开始的整数，表示要检索的组件。如果组件有名称，这可以是一个包含组件名称的字符串。
返回: 一个新的单变量 TimeSeries 实例。
返回类型: TimeSeries

univariate_values(copy=True, sample=0)[源代码]¶

返回一个形状为 (time,) 的 1-D Numpy 数组，包含该单变量序列在一个样本中的值。

参数

copy (bool) – 是否返回值的副本。除非你知道自己在做什么，否则请保持为 True。
sample (int) – 对于随机序列，要返回其值的样本。默认值：0（第一个样本）。

返回

构成时间序列的值保证是单变量的。

返回类型

numpy.ndarray

values(copy=True, sample=0)[源代码]¶

返回一个形状为 (时间, 组件) 的二维数组，包含该系列在一个样本中的值。

参数

copy (bool) – 是否返回值的副本，否则返回视图。除非你知道自己在做什么，否则请保持为 True。
sample (int) – 对于随机序列，要返回其值的样本。默认值：0（第一个样本）。

返回

构成时间序列的值。

返回类型

numpy.ndarray

var(ddof=1)[源代码]¶

返回一个确定性的 TimeSeries ，其中包含此随机 TimeSeries 的每个分量（在样本上）的方差。

这仅适用于随机序列（即，包含多个样本）

参数: ddof (int) – “自由度增量”：计算中使用的除数是 N - ddof，其中 N 表示元素的数量。默认情况下，ddof 为 1。
返回: 包含每个成分方差的时间序列。
返回类型: TimeSeries

property width: int¶

“宽度”（= 组件数量）的序列。

返回类型: int

window_transform(transforms, treat_na=None, forecasting_safe=True, keep_non_transformed=False, include_current=True, keep_names=False)[源代码]¶

对 TimeSeries 应用移动/滚动、扩展或指数加权窗口变换。

参数

transforms (Union[Dict, Sequence[Dict]]) –
一个字典或字典列表。每个字典指定一个不同的窗口变换。

字典可以包含以下键：

"function"

必须的。pandas 内置转换函数之一的名称，或可应用于输入序列的可调用函数。pandas 的函数可以在文档中找到。

"mode"

可选。这是 "function" 将要应用的 pandas 窗口模式的名称。选项包括 “rolling”、”expanding” 和 “ewm”。如果没有提供，Darts 默认使用 “expanding”。用户定义的函数可以使用 “rolling” 或 “expanding” 模式。更多关于 pandas 窗口操作的信息可以在文档中找到。

"components"

可选。指定应在其上应用转换的时间序列组件的字符串或字符串列表。如果未指定，转换将应用于所有组件。

"function_name"

可选。一个字符串，指定作为转换输出名称一部分引用的函数名称。例如，给定一个用户提供的函数转换，在组件“comp”上使用5个滚动窗口大小，默认的转换输出名称是“rolling_udf_5_comp”，其中“udf”指的是“用户定义的函数”。如果指定，“function_name”``将替换默认名称“udf”。同样，“function_name”``将替换输出名称中pandas内置转换函数的名称。

提供的所有其他字典项将被视为窗口模式（即 rolling/ewm/expanding）或该模式下特定函数的键值参数（例如 pandas.DataFrame.rolling.mean/std/max/min... 或 pandas.DataFrame.ewm.mean/std/sum）。这通过提供例如以下内容，允许在配置转换时具有更大的灵活性：
- "window"
  
  “rolling”模式中移动窗口的大小。如果是整数，则为每个窗口使用的固定观测数。如果是偏移量，则为每个窗口的时间周期，数据类型为 pandas.Timedelta 表示固定持续时间。
- "min_periods"
  
  窗口中所需的最小观测数量以获得一个值（否则为NaN）。Darts 重用了 pandas 的默认值，即在“rolling”和“expanding”模式下为1，在“ewm”模式下为0。
- "win_type"
  
  应用于窗口元素的加权类型。如果提供，它应该是 scipy.signal.windows 中的一种。
- "center"
  
  True/False 用于将当前时间步的观测值设置在窗口的中心（当 forecasting_safe 为 True 时，Darts 强制将 "center" 设为 False）。
- "closed"
  
  "right"/"left"/"both"/"neither" 用于指定窗口的右端、左端或两端是否包含在窗口中，或者两者都不包含。Darts 默认使用 pandas 的默认值 "right"。
更多关于可用函数及其参数的信息可以在 Pandas 文档中找到。

对于用户提供的函数，转换字典中的额外关键字参数会被传递给用户定义的函数。默认情况下，Darts 期望用户定义的函数接收 numpy 数组作为输入。这可以通过在转换字典中添加 "raw": False 项来修改。期望函数为每个窗口返回一个单一值。其他可能的配置可以在 pandas.DataFrame.rolling().apply() 文档和 pandas.DataFrame.expanding().apply() 文档中找到。
treat_na (Union[str, int, float, None]) – 指定如何处理由窗口转换在结果时间序列开头添加的缺失值。默认情况下，Darts 将在结果时间序列中保留 NaNs。此参数可以是以下之一： * :"dropna": 截断时间序列并删除包含缺失值的行。如果多个列包含不同数量的缺失值，则仅删除最小数量的行。此操作可能会减少结果时间序列的长度。 * :"bfill" 或 "backfill": 指定应使用最后一个转换的有效观测值填充 NaNs。如果原始时间序列以 NaNs 开头，则保留这些 NaNs。当 forecasting_safe 为 True 时，此选项会返回异常以避免未来观测值污染过去。 * :整数或浮点数: 在这种情况下，NaNs 将填充为此值。所有列将填充相同的提供值。
forecasting_safe (Optional[bool, None]) – 如果为 True，Darts 会确保生成的 TimeSeries 在作为目标或特征用于预测模型时是安全的。窗口转换将不允许在当前时间步计算中包含未来值。默认值为 True。”ewm” 和 “expanding” 模式默认是预测安全的。”rolling” 模式在保证 "center": False 的情况下是预测安全的。
keep_non_transformed (Optional[bool, None]) – False 仅返回转换后的组件，True 返回所有原始组件以及转换后的组件。默认值为 False。如果序列具有层次结构，则必须设置为 False。
include_current (Optional[bool, None]) – True 表示包含当前时间步长在窗口内，False 表示排除它。默认值是 True。
keep_names (Optional[bool, None]) – 转换后的组件是否应保留原始组件名称。如果 keep_non_transformed = True 或转换次数大于 1，则必须设置为 False。

返回

返回一个包含转换后组件的新 TimeSeries 实例。如果 keep_non_transformed 为 True，则结果 TimeSeries 将包含原始的未转换组件以及转换后的组件。如果输入序列是随机的，所有样本都将被相同地转换。转换后的组件命名约定如下：[window_mode]_[function_name]_[window_size（如果提供）]_[min_periods（如果不是默认值）]_[original_comp_name]，例如，rolling_sum_3_comp_0（即，window_mode=rolling，function_name=sum，window_size=3，original_comp_name=comp_0）；ewm_mean_comp_1（即，window_mode=ewm，function_name=mean，original_comp_name=comp_1）；expanding_sum_3_comp_2（即，window_mode=expanding，function_name=sum，window_size=3，original_comp_name=comp_2）。对于用户定义的函数，function_name=udf。

返回类型

TimeSeries

with_columns_renamed(col_names, col_names_new)[源代码]¶

返回一个新的 TimeSeries 实例，带有新的列/组件名称。如果存在层次结构，它还会调整层次结构中的名称。

参数

col_names (Union[List[str], str]) – 字符串或字符串列表，对应于要更改的列名。
col_names_new (Union[List[str], str]) – 字符串或字符串列表，对应于新列名。必须与 col_names 的长度相同。

返回

一个新的 TimeSeries 实例。

返回类型

TimeSeries

with_hierarchy(hierarchy)[源代码]¶

为 TimeSeries 添加层次结构。

参数: hierarchy (Dict[str, Union[str, List[str]]]) – 一个将组件映射到其在层次结构中的父组件列表的字典。单个父组件可以指定为字符串或包含一个字符串的列表。例如，假设系列包含组件 ["total", "a", "b", "x", "y", "ax", "ay", "bx", "by"]，以下字典将编码此图中显示的分组： .. highlight:: python .. code-block:: python

with_static_covariates(covariates)[源代码]¶

返回一个添加了静态协变量的新 TimeSeries 对象。

静态协变量包含附加到时间序列的数据，但这些数据不会随时间变化。

参数: covariates (Union[Series, DataFrame, None]) – 可选地，添加到 TimeSeries 的一组静态协变量。可以是 pandas Series、pandas DataFrame 或 None。如果为 None，则将静态协变量设置为 None。如果是 Series，索引表示静态变量。然后，协变量将全局“应用于”TimeSeries 的所有组件。如果是 DataFrame，列表示静态变量，行表示 uni/multivariate TimeSeries 的组件。如果是单行 DataFrame，协变量将全局“应用于”TimeSeries 的所有组件。如果是多行 DataFrame，行数必须与 TimeSeries 的组件数匹配。这将添加组件特定的静态协变量。

提示

如果有大量的静态协变量变量（即，静态协变量具有非常大的维度），除非协变量已经与序列数据具有相同的 dtype ，否则创建 TimeSeries 对象可能会导致明显的性能损失。

实际案例

>>> import pandas as pd
>>> from darts.utils.timeseries_generation import linear_timeseries
>>> # add global static covariates
>>> static_covs = pd.Series([0., 1.], index=["static_cov_1", "static_cov_2"])
>>> series = linear_timeseries(length=3)
>>> series_new1 = series.with_static_covariates(static_covs)
>>> series_new1.static_covariates
                   static_cov_1  static_cov_2
component
linear              0.0           1.0

>>> # add component specific static covariates
>>> static_covs_multi = pd.DataFrame([[0., 1.], [2., 3.]], columns=["static_cov_1", "static_cov_2"])
>>> series_multi = series.stack(series)
>>> series_new2 = series_multi.with_static_covariates(static_covs_multi)
>>> series_new2.static_covariates
                   static_cov_1  static_cov_2
component
linear              0.0           1.0
linear_1            2.0           3.0

with_times_and_values(times, values, fill_missing_dates=False, freq=None, fillna_value=None)[源代码]¶

返回一个新的 TimeSeries ，类似于当前的这个，但具有新的指定值。

参数

times (Union[DatetimeIndex, RangeIndex, Index]) – 一个 pandas DateTimeIndex、RangeIndex（或可以转换为 RangeIndex 的 Index），表示时间序列的新时间轴。如果索引没有空洞会更好；或者在某些情况下，设置 fill_missing_dates 可以解决这些问题（用 NaN 填充空洞，或者如果提供了 fillna_value 数值，则用该数值填充）。
values (ndarray) – 一个包含新值的 Numpy 数组。它必须具有 times 和组件的维度，但可能包含不同数量的样本。
fill_missing_dates (Optional[bool, None]) – 可选地，一个布尔值，指示是否用NaN值填充缺失的日期（或整数索引情况下的索引）。这需要提供一个`freq`或从提供的时间戳推断频率的可能性。更多信息请参见 _fill_missing_dates()。
freq (Union[int, str, None]) – 可选地，一个字符串或整数，表示基础索引的频率。这对于在某些日期缺失且 fill_missing_dates 设置为 True 时填充缺失值很有用。如果是字符串，表示 pandas DatetimeIndex 的频率（有关支持的频率的更多信息，请参见偏移别名）。如果是整数，表示 pandas Index 或 pandas RangeIndex 的步长。
fillna_value (Optional[float, None]) – 可选地，一个数值用于填充缺失值（NaNs）。

返回

一个新的 TimeSeries，具有新的值和相同的索引、静态协变量和层次结构

返回类型

TimeSeries

with_values(values)[源代码]¶

返回一个新的 TimeSeries ，类似于当前的这个，但具有新的指定值。

参数: values (ndarray) – 一个包含新值的 Numpy 数组。它必须有时间维度和组件维度，但可能包含不同数量的样本。
返回: 一个新的 TimeSeries，具有新的值和相同的索引、静态协变量和层次结构
返回类型: TimeSeries

darts.timeseries.concatenate(series, axis=0, ignore_time_axis=False, ignore_static_covariates=False, drop_hierarchy=True)[源代码]¶

在给定的轴上连接多个 TimeSeries。

axis 可以是一个整数 (0, 1, 2) 来表示 (时间, 组件, 样本)，或者，也可以是一个字符串，表示底层 DataArray 的相应维度。

参数

series (Sequence[TimeSeries]) – 要连接的 TimeSeries 序列
axis (Union[str, int]) – 沿该轴将序列连接。
ignore_time_axis (bool) – 即使某些序列的时间轴不匹配，也允许连接。当沿着组件或样本维度进行连接时，只要序列具有相同的长度，连接就会工作（在这种情况下，结果序列将具有第一个提供的序列的时间轴）。当沿着时间维度进行连接时，即使时间轴不连续，连接也会工作（在这种情况下，结果序列将具有与第一个提供的序列的开始时间相匹配的开始时间）。默认值：False。
ignore_static_covariates (bool) – 是否忽略所有静态协变量连接的要求，仅将 series 中第一个 TimeSeries 元素的静态协变量转移到连接后的 TimeSeries 中。仅在 axis=1 时有效。
drop_hierarchy (bool) – 当 axis=1 时，是否丢弃层次结构信息。默认为 True。当为 False 时，层次结构也将被“连接”（通过合并层次结构字典），如果结果序列的组件名称与合并的层次结构不匹配，可能会导致问题。当 axis=0 或 axis=2 时，始终保留第一个序列的层次结构。

返回

连接系列

返回类型

TimeSeries

附加的实用函数

示例