时间序列查询计算使用

Foundry在磁盘上以高度优化的格式缓存时间序列数据以便于时间序列查询。查询这些数据需要使用计算秒数。

时间序列查询以以下方式使用计算：

1. 每个查询有一个固定的计算秒数率。
2. 每个查询还有一个额外的计算秒数测量，这取决于查询读取的时间序列点的数量。

对较大时间序列索引的查询将读取更多的点。以下部分提供了关于如何计算的说明。

计算的测量方式

时间序列数据的存储在Foundry存储下测量。存储时间序列数据不使用任何计算；只有索引时间序列和主动查询数据时才会使用计算。

时间序列查询计算专门用于查询存储在Foundry中的时间序列数据。时间序列查询以两种方式使用计算：

1. 每个查询使用的计算秒数有最低数量。在基于使用的Foundry实例中，每个查询使用4个计算秒数。
2. 查询根据自身考虑的点的数量超出固定的最低成本。查询期间扫描的点数量由被查询的序列的大小和执行逻辑的复杂性驱动，这可能会导致对点进行多次比较/操作。

以下公式从查询中推导出计算秒数：

Copied!
1compute-seconds = 4 + points_scanned / 25000
2# 计算秒数 = 4 + 扫描的点数 / 25000
3# 该公式用于计算操作所需的秒数，其中4是一个常数，points_scanned是扫描点的数量。

调查时间序列查询使用情况

资源管理应用程序允许您深入了解数据集使用信息，并应作为在Foundry平台中调查使用情况的起始点。

用户可以在Foundry中使用多种工具来查询时间序列数据。时间序列查询的使用情况始终与每个工具生成或修改的资源相关联。

• 在Quiver中，时间序列查询将归因于用于启动查询的各个Quiver分析或仪表盘。
• 在Workshop中，查询将附加到启动查询的Workshop应用。当Workshop应用嵌入一个查询时间序列的Quiver组件时，使用情况仍然归属于总体的Workshop应用。
• 对于使用FoundryTS库查询时间序列的变换，这些查询的计算量归因于编写该变换的存储库。

理解使用驱动因素

在按使用合同为Foundry付费时，有三个主要的时间序列查询计算驱动因素：

1. 查询次数

   • 每个查询的最小使用量为4计算秒。这意味着用户执行的查询次数越多，运行查询的Quiver仪表盘越多，以及更多计划的搭建运行FoundryTS查询将使用更多的计算秒。

2. 被查询系列的大小

   • 每个查询在对系列运行时必须扫描所有时间序列点。总体而言，较大的系列需要比相对较小的系列更多的计算来查询。例如，在一个具有10,000,000点的系列上运行查询将比在100,000点的系列上运行查询使用更多的计算。

3. 查询的复杂性

   • 执行与底层系列进行更复杂交互的查询将在该系列上运行更多操作。在运行这些操作时，随着更多点被扫描，查询的使用量将增加。

   有关更多信息和示例，请参见下面的查询复杂性示例部分。

使用时间序列管理使用情况

管理查询总数对于管理时间序列查询的总计算使用量很重要。在Foundry中使用时间序列时，请考虑以下做法：

• 在搭建基于时间序列的分析或仪表盘时，请考虑每次更新必须运行的查询总数。还可以考虑分开更新路径，以便在参数更改时并非所有查询都更新。
• 在运行FoundryTS搭建时，确保适当地设置了计划，以便搭建不会比必要的更频繁地运行。
• 当将时间范围应用于时间序列时，Foundry的时间序列后端将仅读取落在该时间范围内的点。因此，Foundry中的时间序列查询可以基于它们查询的范围进行优化。限制查询的时间范围不需要计算；选择时间范围可以显著减少扫描的总体点数，从而减少查询中使用的计算。
• 为任务选择正确的粒度；并非所有工作流都需要最大粒度的数据。在某些情况下，这意味着为特定工作流进行预聚合。在其他应用案例中，这意味着在不同系列中存储不同的粒度。虽然维护多个最新系列可能会增加索引计算，但存储多个系列的行为不需要计算。因此，持有不同粒度的多个系列可能比总是查询最细粒度系列更便宜。

计算使用量

要预测时间序列查询的成本，请务必始终了解被查询系列的大小。

请考虑以下示例，其中有三个查询针对一个具有100,000点的系列，每个查询扫描系列中的所有点：

Copied!
1series_size: 100,000 points
2minimum_query_usage: 4-compute seconds
3points_per_compute_second: 25,000 points
4total_queries: 3
5
6# 计算总的计算秒数
7compute-seconds = num_queries * minimum_query_usage + total_points / points_per_compute_second
8compute-seconds = 3 queries * 4 compute-seconds + 100,000 points * 3 queries / 25,000 points-per-second
9compute-seconds = 3 * 4 + 300,000 / 25,000
10compute-seconds = 24 compute-seconds

此代码片段计算了一次操作所需的总计算秒数。每次查询至少使用4个计算秒，并且每秒可以处理25,000个点。总共有3次查询，每次查询需处理100,000个点，最终得出总计算时间为24个计算秒。

查询复杂性的示例

当对查询的时间序列应用更多嵌套操作时，时间序列查询的复杂性会增加。

例如，考虑以下FoundryTS代码，该代码将两个时间序列相加，并在1年的时间范围内返回新序列的所有点作为Pandas数据框：

Copied!
1series_1 = N.TimeseriesNode('series_1')  # 创建时间序列节点 series_1
2series_2 = N.TimeseriesNode('series_2')  # 创建时间序列节点 series_2
3result = F.dsl(program='a+b', return_type=float)([series_1, series_2]).time_range(start='2022-01-01', end='2023-01-01')
4# 使用DSL定义程序'a+b'，将series_1和series_2相加，并指定返回类型为浮点数。
5# 然后指定时间范围从2022年1月1日到2023年1月1日。
6result.to_pandas()  # 将结果转换为Pandas数据框格式

Copied!
1{
2  id: dsl-fomula,  // 这是一个DSL公式的ID
3  children: [
4    { id: timeseries },  // 这是第一个时间序列数据的ID
5    { id: timeseries }   // 这是第二个时间序列数据的ID
6  ]
7}

评估 to_pandas 调用将在请求的1年时间范围内扫描 result 时间序列中的点，以及计算结果所需的两个组件序列中的点（在本例中，每个组件序列都有1年的范围）产生成本。

现在，考虑以下应用了更多嵌套操作的 FoundryTS 代码。首先，我们定义一个序列，该序列是另外两个序列的总和。然后，我们将该序列与其7天的滚动平均值进行比较，并将结果中的一年数据加载为一个 Pandas 数据框：

Copied!
1series_1 = N.TimeseriesNode('series_1')
2series_2 = N.TimeseriesNode('series_1')  # 注意：这里可能是个错误，应该是 'series_2'
3intermediate_1 = F.dsl(program='a+b', return_type=float)([series_1, series_2])  # 计算 series_1 和 series_2 的和
4intermediate_2 = intermediate_1.rolling_aggregate('mean', '7d')  # 对 intermediate_1 进行 7 天的滚动平均
5result = F.dsl(program='a-b', return_type=float)([intermediate_1, intermediate_2]).time_range(start='2022-01-01', end='2023-01-01')  # 计算 intermediate_1 和 intermediate_2 的差，并限定时间范围
6result.to_pandas()  # 将结果转换为 Pandas 数据框格式

此代码将以以下形式向Codex进行查询：

Copied!
1{
2  id: dsl-fomula, // DSL公式节点
3  children: [
4    {
5      id: dsl-fomula, // 子节点，DSL公式
6      children: [
7        { id: timeseries }, // 时间序列节点
8        { id: timeseries }  // 时间序列节点
9      ]
10    },
11    {
12      id: rolling-aggregate, // 滚动聚合节点
13      children: [
14        {
15          id: dsl-fomula, // 子节点，DSL公式
16          children: [
17            { id: timeseries }, // 时间序列节点
18            { id: timeseries }  // 时间序列节点
19          ]
20        }
21      ]
22    }
23  ]
24}

此查询树中的每个节点将产生扫描1年范围点以生成最终结果的成本。