foundryts.functions.interpolate

foundryts.functions.interpolate(before=None, internal=None, after=None, frequency=None, rename_columns_by=None, static_column_name=None)

返回一个函数，该函数将一个或多个时间序列合并为一个时间序列，每个输入序列对应一列。

↗ 插值估计序列中缺失点的值，以便在其他序列中存在该点的时间戳上进行估计。该函数使用配置的插值策略对缺失点的输入序列数据进行重新采样和对齐。

时间序列的插值可以分为三个不同的时间范围：起始、内部和结束。

每个时间范围处理时间序列不同部分的插值缺失值：

起始：对序列的第一个点之前的所有点进行插值。例如，请参阅下面的external_interpolated_series示例中，插值为序列2的第一个点之前创建了一个新点，并用最近的值填充它。
内部：对时间序列中现有数据点之间的值进行插值。例如，请参阅下面的linear_interpolated_series示例中，插值为两个序列的time_extent()中的点估计了值。
结束：对序列的最后一个数据点之后的所有点进行插值。例如，请参阅下面的external_interpolated_series示例中，插值为序列1的最后一个点之后创建了一个新点，并用最近的值填充它。

为了对每个序列应用不同的策略，可以将上述时间范围的每个策略作为列表传递。每个列表元素对应于用于各个输入序列的策略。如果传递单一策略，则对所有输入序列应用相同的策略。

内部插值支持的插值策略：

策略	描述
LINEAR	使用插值时间戳前后两个点的最佳拟合线进行线性插值。
NEAREST	使用输入序列中最接近时间戳的点的值。
PREVIOUS	使用输入时间序列中前一个定义点的值。
NEXT	使用输入时间序列中下一个出现点的值。
NONE	跳过插值。对于没有任何输入序列点存在的时间戳，输出df中将使用空值。

外部插值（起始，结束）支持的插值策略：

策略	描述
NEAREST	取最近定义的点的值（这将是第一个或最后一个点）。
NONE (默认)	从不在第一个点之前和最后一个点之后插值。

可以配置一个非必填频率，以仅在指定频率的时间戳上进行插值。提供频率会完全重新采样输入序列，仅在指定频率下创建和插值点。请参阅下面的interpolated_every_10ns_series和multiple_interpolated_every_10ns_series示例以了解重新采样的输出。

参数:
- before (Union [str , List [str ] ] , 非必填) – 对序列中的第一个点之前的点进行插值的策略，可以是每个序列的列表，使用上面外部插值表中的有效策略（默认是NONE）。
- internal (Union [str , List [str ] ] , 非必填) – 对现有点之间的点进行插值的策略，可以是每个序列的列表，使用上面内部插值表中的有效值（默认是NONE）。
- after (Union [str , List [str ] ] , 非必填) – 对序列中的最后一个点之后的点进行插值的策略，可以是每个序列的列表，使用上面外部插值表中的有效策略（默认是NONE）。
- frequency (Union [str , pandas.Timedelta ] , 非必填) – 插值点的输出频率，值将按相应的赫兹处理，例如‘5ms’，‘1s’（默认没有固定频率，仅对其他序列中存在的时间戳进行插值）
- rename_columns_by (str | Callable [ *[*N.FunctionNode ] , str ] , 非必填) – 元数据键以识别结果中的系列列或返回每个系列名称的可调用对象（默认是系列标识符）。
- static_column_name (str , 非必填) – 值列的静态名称，将覆盖rename_columns_by。
返回: 返回使用配置策略插值的序列的函数。
返回类型: (Union[FunctionNode, NodeCollections]) -> Union[FunctionNode, NodeCollection]

数据框架模式

列名称	类型	描述
timestamp	pandas.Timestamp	点的时间戳
value	Union[float, str]	点的值

注意

不要对枚举序列使用LINEAR插值，否则此操作将失败。

此函数的输出可以是单序列或多序列数据框，仅适用于期望相应输入的其他函数。

另见

scatter()

示例

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
>>> series_1 = F.points((1, 1.0), (101, 2.0), (200, 4.0), (201, 8.0), name="series-1")
# 创建一个名为 series-1 的时间序列，包含四个数据点，分别在时间戳 1、101、200 和 201 处具有值 1.0、2.0、4.0 和 8.0。

>>> series_2 = F.points((2, 11.0), (102, 12.0), (201, 14.0), (202, 18.0), name="series-2")
# 创建另一个名为 series-2 的时间序列，包含四个数据点，分别在时间戳 2、102、201 和 202 处具有值 11.0、12.0、14.0 和 18.0。

>>> series_1.to_pandas()
                    timestamp  value
0 1970-01-01 00:00:00.000000001    1.0
1 1970-01-01 00:00:00.000000101    2.0
2 1970-01-01 00:00:00.000000200    4.0
3 1970-01-01 00:00:00.000000201    8.0
# 将 series_1 转换为 Pandas DataFrame 格式，显示时间戳和对应的值。

>>> series_2.to_pandas()
                    timestamp  value
0 1970-01-01 00:00:00.000000002   11.0
1 1970-01-01 00:00:00.000000102   12.0
2 1970-01-01 00:00:00.000000201   14.0
3 1970-01-01 00:00:00.000000202   18.0
# 将 series_2 转换为 Pandas DataFrame 格式，显示时间戳和对应的值。

>>> nc = NodeCollection([series_1, series_2])
# 创建一个包含 series_1 和 series_2 的节点集合 NodeCollection。

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
>>> linear_interpolated_series = F.interpolate(internal="LINEAR")(nc)
# 使用线性插值法对数据进行插值。`internal="LINEAR"`参数表示使用线性插值方法。
>>> linear_interpolated_series.to_pandas()
# 将插值后的结果转换为 pandas 数据框格式进行查看。
                    timestamp  series-1   series-2
0 1970-01-01 00:00:00.000000001  1.000000        NaN
1 1970-01-01 00:00:00.000000002  1.010000  11.000000
2 1970-01-01 00:00:00.000000101  2.000000  11.990000
3 1970-01-01 00:00:00.000000102  2.020202  12.000000
4 1970-01-01 00:00:00.000000200  4.000000  13.979798
5 1970-01-01 00:00:00.000000201  8.000000  14.000000
6 1970-01-01 00:00:00.000000202       NaN  18.000000
# 以上是插值后的数据，包含两个时间序列 `series-1` 和 `series-2`，其中一些空值通过线性插值填充。

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
>>> nearest_interpolated_series = F.interpolate(internal="NEAREST")(nc)
# 使用最近邻插值法对数据进行插值处理
>>> nearest_interpolated_series.to_pandas()
# 将插值后的数据转换为 pandas 数据框格式进行展示
                    timestamp  series-1  series-2
0 1970-01-01 00:00:00.000000001       1.0       NaN
1 1970-01-01 00:00:00.000000002       1.0      11.0
2 1970-01-01 00:00:00.000000101       2.0      12.0
3 1970-01-01 00:00:00.000000102       2.0      12.0
4 1970-01-01 00:00:00.000000200       4.0      14.0
5 1970-01-01 00:00:00.000000201       8.0      14.0
6 1970-01-01 00:00:00.000000202       NaN      18.0
# 表格显示了时间戳和两个系列的数据，其中某些值通过最近邻插值法填充

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
>>> previous_interpolated_series = F.interpolate(internal="PREVIOUS")(nc)
# 这里使用插值方法 "PREVIOUS" 进行插值计算，返回的结果存储在 previous_interpolated_series 变量中。
# 插值方法 "PREVIOUS" 表示使用前一个已知值进行填充。

>>> previous_interpolated_series.to_pandas()
# 将插值后的结果转换为 Pandas DataFrame 格式，方便查看。

                    timestamp  series-1  series-2
0 1970-01-01 00:00:00.000000001       1.0       NaN
1 1970-01-01 00:00:00.000000002       1.0      11.0
2 1970-01-01 00:00:00.000000101       2.0      11.0
3 1970-01-01 00:00:00.000000102       2.0      12.0
4 1970-01-01 00:00:00.000000200       4.0      12.0
5 1970-01-01 00:00:00.000000201       8.0      14.0
6 1970-01-01 00:00:00.000000202       NaN      18.0
# 结果显示时间戳以及对应的 series-1 和 series-2 的值，其中 NaN 表示缺失值。
# "PREVIOUS" 插值法填充 series-1 中的缺失值，但 series-2 中有些缺失值无法填充，依旧显示为 NaN。

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
>>> next_interpolated_series = F.interpolate(internal="NEXT")(nc)
# 使用插值函数 F.interpolate 对数据进行处理，参数 internal="NEXT" 代表使用下一值填充当前缺失值
>>> next_interpolated_series.to_pandas()
# 将插值后的数据转换为 Pandas DataFrame 格式以便查看
                    timestamp  series-1  series-2
0 1970-01-01 00:00:00.000000001       1.0       NaN
1 1970-01-01 00:00:00.000000002       2.0      11.0
2 1970-01-01 00:00:00.000000101       2.0      12.0
3 1970-01-01 00:00:00.000000102       4.0      12.0
4 1970-01-01 00:00:00.000000200       4.0      14.0
5 1970-01-01 00:00:00.000000201       8.0      14.0
6 1970-01-01 00:00:00.000000202       NaN      18.0
# 数据展示了时间戳与两个数据序列，其中某些值是缺失的

Copied!1
2
3
4
5
6
7
8
9
10
>>> none_interpolated_series = F.interpolate(internal="NONE")(nc) # 跳过任何缺失的数据点
>>> none_interpolated_series.to_pandas()
                    timestamp  series-1  series-2
0 1970-01-01 00:00:00.000000001       1.0       NaN
1 1970-01-01 00:00:00.000000002       NaN      11.0
2 1970-01-01 00:00:00.000000101       2.0       NaN
3 1970-01-01 00:00:00.000000102       NaN      12.0
4 1970-01-01 00:00:00.000000200       4.0       NaN
5 1970-01-01 00:00:00.000000201       8.0      14.0
6 1970-01-01 00:00:00.000000202       NaN      18.0

在这段代码中，F.interpolate(internal="NONE") 函数用于插值处理数据，但设置为 "NONE" 表示跳过任何缺失的数据点，而不是进行插值。结果通过 to_pandas() 方法转换为 Pandas 数据框格式，显示了每个时间戳对应的 series-1 和 series-2 数据，其中缺失值用 NaN 表示。

Copied!1
2
3
4
5
6
7
8
9
10
>>> external_interpolated_series = F.interpolate(before="NEAREST", after="NEAREST")(nc)
>>> external_interpolated_series.to_dataframe()
                    timestamp  series-1  series-2
0 1970-01-01 00:00:00.000000001       1.0      11.0
1 1970-01-01 00:00:00.000000002       NaN      11.0
2 1970-01-01 00:00:00.000000101       2.0       NaN
3 1970-01-01 00:00:00.000000102            12.0
4 1970-01-01 00:00:00.000000200       4.0       NaN
5 1970-01-01 00:00:00.000000201       8.0      14.0
6 1970-01-01 00:00:00.000000202       8.0      18.0

在这个代码片段中，使用 F.interpolate 方法对 nc 数据进行插值处理。插值方法在缺失值之前和之后使用 "NEAREST"，即最近邻插值法。生成的 external_interpolated_series 被转换为数据框格式，其中包含时间戳和两个系列的数据。NaN 表示缺失值。

Copied!1
2
3
4
5
6
7
8
9
10
>>> interpolated_series = F.interpolate(internal=["LINEAR", "NONE"])(nc) # 每个序列使用不同的插值策略
>>> interpolated_series.to_pandas()
                    timestamp  series-1  series-2
0 1970-01-01 00:00:00.000000001  1.000000       NaN
1 1970-01-01 00:00:00.000000002  1.010000      11.0
2 1970-01-01 00:00:00.000000101  2.000000       NaN
3 1970-01-01 00:00:00.000000102  2.020202      12.0
4 1970-01-01 00:00:00.000000200  4.000000       NaN
5 1970-01-01 00:00:00.000000201  8.000000      14.0
6 1970-01-01 00:00:00.000000202       NaN      18.0

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
>>> interpolated_every_10ns_series = F.interpolate(internal="NEAREST", frequency="10ns")(series_1)
>>> interpolated_every_10ns_series.to_pandas()
# 将 series_1 数据以每 10 纳秒为频率进行最近邻插值
# 使用 NEAREST 插值方法，这种方法对于每个插值点选择最近的已知数据点值

                        timestamp  series-1
0  1970-01-01 00:00:00.000000010       1.0
1  1970-01-01 00:00:00.000000020       1.0
2  1970-01-01 00:00:00.000000030       1.0
3  1970-01-01 00:00:00.000000040       1.0
4  1970-01-01 00:00:00.000000050       1.0
5  1970-01-01 00:00:00.000000060       2.0
6  1970-01-01 00:00:00.000000070       2.0
7  1970-01-01 00:00:00.000000080       2.0
8  1970-01-01 00:00:00.000000090       2.0
9  1970-01-01 00:00:00.000000100       2.0
10 1970-01-01 00:00:00.000000110       2.0
11 1970-01-01 00:00:00.000000120       2.0
12 1970-01-01 00:00:00.000000130       2.0
13 1970-01-01 00:00:00.000000140       2.0
14 1970-01-01 00:00:00.000000150       2.0
15 1970-01-01 00:00:00.000000160       4.0
16 1970-01-01 00:00:00.000000170       4.0
17 1970-01-01 00:00:00.000000180       4.0
18 1970-01-01 00:00:00.000000190       4.0
19 1970-01-01 00:00:00.000000200       4.0

在这个代码示例中，interpolated_every_10ns_series 是通过插值函数 F.interpolate 创建的，该函数将 series_1 的数据点以每 10 纳秒为频率进行插值，采用最近邻插值法。最后，通过 to_pandas() 方法将结果转换为 Pandas DataFrame 格式。

Copied!1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
>>> multiple_interpolated_every_10ns_series = F.interpolate(
...     internal="NEAREST", frequency="10ns"
... )(nc)
# 使用F.interpolate进行插值，插值方法为“NEAREST”（最近邻），插值频率为每10纳秒。
>>> multiple_interpolated_every_10ns_series.to_pandas()
# 将插值后的数据转换为pandas DataFrame格式。
                       timestamp  series-1  series-2
0  1970-01-01 00:00:00.000000010       1.0      11.0
1  1970-01-01 00:00:00.000000020       1.0      11.0
2  1970-01-01 00:00:00.000000030       1.0      11.0
3  1970-01-01 00:00:00.000000040       1.0      11.0
4  1970-01-01 00:00:00.000000050       1.0      11.0
5  1970-01-01 00:00:00.000000060       2.0      12.0
6  1970-01-01 00:00:00.000000070       2.0      12.0
7  1970-01-01 00:00:00.000000080       2.0      12.0
8  1970-01-01 00:00:00.000000090       2.0      12.0
9  1970-01-01 00:00:00.000000100       2.0      12.0
10 1970-01-01 00:00:00.000000110       2.0      12.0
11 1970-01-01 00:00:00.000000120       2.0      12.0
12 1970-01-01 00:00:00.000000130       2.0      12.0
13 1970-01-01 00:00:00.000000140       2.0      12.0
14 1970-01-01 00:00:00.000000150       2.0      12.0
15 1970-01-01 00:00:00.000000160       4.0      14.0
16 1970-01-01 00:00:00.000000170       4.0      14.0
17 1970-01-01 00:00:00.000000180       4.0      14.0
18 1970-01-01 00:00:00.000000190       4.0      14.0
19 1970-01-01 00:00:00.000000200       4.0      14.0
# 输出的DataFrame展示了每隔10纳秒插值后的时间戳和对应的数据值。

←

PREVIOUSfoundryts.functions.integral

NEXTfoundryts.functions.last_point

→