管道聚合
edit管道聚合
edit管道聚合作用于其他聚合产生的输出，而不是文档集，为输出树添加信息。有许多不同类型的管道聚合，每种聚合从其他聚合中计算不同的信息，但这些类型可以分为两个家族：
- Parent
- 一组管道聚合，它接收其父聚合的输出，并能够计算新的桶或向现有桶添加新的聚合。
- Sibling
- 提供的Pipeline聚合能够处理同级聚合的输出，并能够计算出一个新的聚合，该聚合将与同级聚合处于同一级别。
管道聚合可以通过使用buckets_path参数来引用它们所需的聚合，以指示所需指标的路径。定义这些路径的语法可以在下面的buckets_path语法部分找到。
管道聚合不能有子聚合，但根据类型，它可以在buckets_path中引用另一个管道，从而允许管道聚合被链接。例如，您可以将两个导数链接在一起以计算二阶导数（即导数的导数）。
因为管道聚合仅添加到输出中，当链接管道聚合时，每个管道聚合的输出都将包含在最终输出中。
buckets_path 语法
edit大多数管道聚合需要另一个聚合作为其输入。输入聚合通过buckets_path参数定义，该参数遵循特定格式：
AGG_SEPARATOR = `>` ; METRIC_SEPARATOR = `.` ; AGG_NAME = <the name of the aggregation> ; METRIC = <the name of the metric (in case of multi-value metrics aggregation)> ; MULTIBUCKET_KEY = `[<KEY_NAME>]` PATH = <AGG_NAME><MULTIBUCKET_KEY>? (<AGG_SEPARATOR>, <AGG_NAME> )* ( <METRIC_SEPARATOR>, <METRIC> ) ;
例如，路径 "my_bucket>my_stats.avg" 将指向 "my_stats" 指标中的 avg 值，该指标包含在 "my_bucket" 桶聚合中。
以下是一些更多示例：
-
multi_bucket["foo"]>single_bucket>multi_metric.avg将进入"multi_metric"聚合下的avg指标，该聚合位于多桶聚合"multi_bucket"的"foo"桶中的单桶"single_bucket"下。 -
agg1["foo"]._count将获取多桶聚合"multi_bucket"中"foo"桶的_count指标。
路径是相对于管道聚合的位置的；它们不是绝对路径，路径不能“向上”返回聚合树。例如，这个导数嵌套在一个date_histogram中，并引用了一个“兄弟”度量"the_sum"：
POST /_search
{
"aggs": {
"my_date_histo": {
"date_histogram": {
"field": "timestamp",
"calendar_interval": "day"
},
"aggs": {
"the_sum": {
"sum": { "field": "lemmings" }
},
"the_deriv": {
"derivative": { "buckets_path": "the_sum" }
}
}
}
}
}
buckets_path 也用于兄弟管道聚合，其中聚合是“下一个”到一系列桶，而不是嵌入“内部”它们。例如，max_bucket 聚合使用 buckets_path 来指定嵌入在兄弟聚合中的指标：
POST /_search
{
"aggs": {
"sales_per_month": {
"date_histogram": {
"field": "date",
"calendar_interval": "month"
},
"aggs": {
"sales": {
"sum": {
"field": "price"
}
}
}
},
"max_monthly_sales": {
"max_bucket": {
"buckets_path": "sales_per_month>sales"
}
}
}
}
如果一个兄弟管道聚合引用了一个多桶聚合，例如一个terms聚合，它也有选择多桶中特定键的选项。例如，一个bucket_script可以选择两个特定的桶（通过它们的桶键）来执行计算：
POST /_search
{
"aggs": {
"sales_per_month": {
"date_histogram": {
"field": "date",
"calendar_interval": "month"
},
"aggs": {
"sale_type": {
"terms": {
"field": "type"
},
"aggs": {
"sales": {
"sum": {
"field": "price"
}
}
}
},
"hat_vs_bag_ratio": {
"bucket_script": {
"buckets_path": {
"hats": "sale_type['hat']>sales",
"bags": "sale_type['bag']>sales"
},
"script": "params.hats / params.bags"
}
}
}
}
}
}
特殊路径
edit除了指向一个指标，buckets_path 还可以使用特殊的 "_count" 路径。这指示管道聚合使用文档计数作为其输入。例如，可以计算每个桶中文档计数的导数，而不是特定指标：
POST /_search
{
"aggs": {
"my_date_histo": {
"date_histogram": {
"field": "timestamp",
"calendar_interval": "day"
},
"aggs": {
"the_deriv": {
"derivative": { "buckets_path": "_count" }
}
}
}
}
}
The buckets_path 也可以使用 "_bucket_count" 和路径到多桶聚合，以在该管道聚合中使用该聚合返回的桶数，而不是指标。例如，可以在此处使用 bucket_selector 来过滤掉内部术语聚合没有桶的桶：
POST /sales/_search
{
"size": 0,
"aggs": {
"histo": {
"date_histogram": {
"field": "date",
"calendar_interval": "day"
},
"aggs": {
"categories": {
"terms": {
"field": "category"
}
},
"min_bucket_selector": {
"bucket_selector": {
"buckets_path": {
"count": "categories._bucket_count"
},
"script": {
"source": "params.count != 0"
}
}
}
}
}
}
}
处理agg名称中的点
edit支持另一种语法来处理名称中包含点的聚合或指标，例如 99.9 百分位数。此指标可以称为：
"buckets_path": "my_percentile[99.9]"
处理数据中的间隙
edit现实世界中的数据通常是嘈杂的，有时包含缺失——即数据根本不存在的地方。这可能由多种原因引起，最常见的原因是：
- 落入桶中的文档不包含所需的字段
- 一个或多个桶中没有与查询匹配的文档
- 正在计算的指标无法生成值，可能是因为另一个依赖的桶缺少值。 一些管道聚合有特定的要求必须满足（例如，导数无法计算第一个值，因为没有前一个值，HoltWinters移动平均需要“预热”数据才能开始计算等）
Gap policies 是一种机制，用于告知管道聚合在遇到“间隙”或缺失数据时的期望行为。所有管道聚合都接受 gap_policy 参数。目前有两种间隙策略可供选择：
- skip
- 此选项将缺失数据视为桶不存在。它将跳过该桶并继续使用下一个可用值进行计算。
- insert_zeros
-
此选项将用零 (
0) 替换缺失值，并且管道聚合计算将正常进行。 - keep_values
- 此选项类似于skip，但如果指标提供了一个非空、非NaN的值，则使用此值，否则跳过空桶。
平均桶聚合
edit一个兄弟管道聚合，用于计算兄弟聚合中指定度量的平均值。指定的度量必须是数值类型，且兄弟聚合必须是一个多桶聚合。
语法
edit"avg_bucket": {
"buckets_path": "sales_per_month>sales",
"gap_policy": "skip",
"format": "#,##0.00;(#,##0.00)"
}
参数
edit-
buckets_path -
(必需，字符串)
要平均的桶的路径。有关语法，请参阅
buckets_path语法。 -
gap_policy -
(可选，字符串)
当数据中存在间隙时要应用的策略。有关有效值，请参阅
处理数据中的间隙。默认为
skip。 -
format -
(可选，字符串)
DecimalFormat 模式用于输出值。如果指定，格式化后的值将返回在聚合的
value_as_string属性中。
响应体
edit-
value -
(浮点数)
指定在
buckets_path中的指标的平均值。 -
value_as_string -
(字符串)
聚合的格式化输出值。仅当请求中指定了
format时，才会提供此属性。
示例
edit以下 avg_monthly_sales 聚合使用 avg_bucket 来计算每月的平均销售额：
POST _search
{
"size": 0,
"aggs": {
"sales_per_month": {
"date_histogram": {
"field": "date",
"calendar_interval": "month"
},
"aggs": {
"sales": {
"sum": {
"field": "price"
}
}
}
},
"avg_monthly_sales": {
// tag::avg-bucket-agg-syntax[]
"avg_bucket": {
"buckets_path": "sales_per_month>sales",
"gap_policy": "skip",
"format": "#,##0.00;(#,##0.00)"
}
// end::avg-bucket-agg-syntax[]
}
}
}
请求返回以下响应：
{
"took": 11,
"timed_out": false,
"_shards": ...,
"hits": ...,
"aggregations": {
"sales_per_month": {
"buckets": [
{
"key_as_string": "2015/01/01 00:00:00",
"key": 1420070400000,
"doc_count": 3,
"sales": {
"value": 550.0
}
},
{
"key_as_string": "2015/02/01 00:00:00",
"key": 1422748800000,
"doc_count": 2,
"sales": {
"value": 60.0
}
},
{
"key_as_string": "2015/03/01 00:00:00",
"key": 1425168000000,
"doc_count": 2,
"sales": {
"value": 375.0
}
}
]
},
"avg_monthly_sales": {
"value": 328.33333333333333,
"value_as_string": "328.33"
}
}
}
桶脚本聚合
edit一个父管道聚合，它执行一个脚本，该脚本可以在父多桶聚合中对指定的度量进行每个桶的计算。指定的度量必须是数值类型，并且脚本必须返回一个数值。
语法
edit一个 bucket_script 聚合单独看起来是这样的：
{
"bucket_script": {
"buckets_path": {
"my_var1": "the_sum",
"my_var2": "the_value_count"
},
"script": "params.my_var1 / params.my_var2"
}
}
表55. bucket_script 参数
| Parameter Name | Description | Required | Default Value |
|---|---|---|---|
|
用于此聚合的脚本。脚本可以是内联的、文件或索引的。（更多详情请参见脚本） |
必需 |
|
|
脚本变量及其关联路径的映射，我们希望使用这些路径来获取变量的桶（有关详细信息，请参阅 |
必需 |
|
|
在数据中发现间隙时要应用的策略（更多详情请参见处理数据中的间隙） |
可选 |
|
|
DecimalFormat 模式用于输出值。如果指定，格式化的值将返回在聚合的 |
可选 |
|
以下代码片段计算了每月T恤销售额与总销售额的比率百分比：
POST /sales/_search
{
"size": 0,
"aggs": {
"sales_per_month": {
"date_histogram": {
"field": "date",
"calendar_interval": "month"
},
"aggs": {
"total_sales": {
"sum": {
"field": "price"
}
},
"t-shirts": {
"filter": {
"term": {
"type": "t-shirt"
}
},
"aggs": {
"sales": {
"sum": {
"field": "price"
}
}
}
},
"t-shirt-percentage": {
"bucket_script": {
"buckets_path": {
"tShirtSales": "t-shirts>sales",
"totalSales": "total_sales"
},
"script": "params.tShirtSales / params.totalSales * 100"
}
}
}
}
}
}
以下可能是响应：
{
"took": 11,
"timed_out": false,
"_shards": ...,
"hits": ...,
"aggregations": {
"sales_per_month": {
"buckets": [
{
"key_as_string": "2015/01/01 00:00:00",
"key": 1420070400000,
"doc_count": 3,
"total_sales": {
"value": 550.0
},
"t-shirts": {
"doc_count": 1,
"sales": {
"value": 200.0
}
},
"t-shirt-percentage": {
"value": 36.36363636363637
}
},
{
"key_as_string": "2015/02/01 00:00:00",
"key": 1422748800000,
"doc_count": 2,
"total_sales": {
"value": 60.0
},
"t-shirts": {
"doc_count": 1,
"sales": {
"value": 10.0
}
},
"t-shirt-percentage": {
"value": 16.666666666666664
}
},
{
"key_as_string": "2015/03/01 00:00:00",
"key": 1425168000000,
"doc_count": 2,
"total_sales": {
"value": 375.0
},
"t-shirts": {
"doc_count": 1,
"sales": {
"value": 175.0
}
},
"t-shirt-percentage": {
"value": 46.666666666666664
}
}
]
}
}
}
桶计数 K-S 检验相关性聚合
edit一个兄弟管道聚合，它对提供的分布和配置的兄弟聚合中的文档计数所隐含的分布执行两样本Kolmogorov–Smirnov检验（从现在起称为“K-S检验”）。具体来说，对于某些指标，假设该指标的百分位区间是已知的或已通过聚合计算，那么可以使用范围聚合作为兄弟聚合来计算该指标与该指标在文档子集上的限制之间的分布差异的p值。一个自然的用例是，如果兄弟聚合范围聚合嵌套在术语聚合中，在这种情况下，将比较指标的总体分布与其在每个术语上的限制。
参数
edit-
buckets_path -
(必需，字符串)
包含一组要进行相关性计算的值的桶的路径。必须是
_count路径。 有关语法，请参阅buckets_path语法。 -
alternative - (可选, 列表) 一个字符串值列表，指示要计算的K-S检验的替代假设。 有效值为："greater", "less", "two_sided"。此参数是确定计算K-S检验时使用的K-S统计量的关键。默认值是所有可能的替代假设。
-
fractions -
(可选，列表)
一个双精度列表，表示用于与
buckets_path结果进行比较的样本分布。在典型用法中，这是每个桶中总体文档的比例，与来自兄弟聚合计数的每个桶中的实际文档比例进行比较。默认情况下，假设总体文档在这些桶中均匀分布，如果使用度量的等百分位数来定义桶的端点，它们就会是这种情况。 -
sampling_method -
(可选，字符串)
指示在计算K-S检验时的采样方法。注意，这是对返回值的采样。这决定了用于比较两个样本的累积分布函数（CDF）点。默认是
upper_tail，它强调CDF点的上端。有效选项是：upper_tail、uniform和lower_tail。
语法
edit一个 bucket_count_ks_test 聚合单独看起来是这样的：
示例
edit以下代码片段对字段 version 中的各个项运行 bucket_count_ks_test，将其与均匀分布进行比较。
均匀分布反映了 latency 百分位数桶。未显示的是 latency 指标值的预计算，
这是通过使用
百分位数 聚合完成的。
此示例仅使用延迟的十分位数。
POST correlate_latency/_search?size=0&filter_path=aggregations
{
"aggs": {
"buckets": {
"terms": {
"field": "version",
"size": 2
},
"aggs": {
"latency_ranges": {
"range": {
"field": "latency",
"ranges": [
{ "to": 0 },
{ "from": 0, "to": 105 },
{ "from": 105, "to": 225 },
{ "from": 225, "to": 445 },
{ "from": 445, "to": 665 },
{ "from": 665, "to": 885 },
{ "from": 885, "to": 1115 },
{ "from": 1115, "to": 1335 },
{ "from": 1335, "to": 1555 },
{ "from": 1555, "to": 1775 },
{ "from": 1775 }
]
}
},
"ks_test": {
"bucket_count_ks_test": {
"buckets_path": "latency_ranges>_count",
"alternative": ["less", "greater", "two_sided"]
}
}
}
}
}
}
|
包含范围聚合和桶相关聚合的术语桶。两者都用于计算术语值与延迟的相关性。 |
|
|
对延迟字段的范围聚合。这些范围是根据延迟字段的百分位数创建的。 |
|
|
桶计数 K-S 检验聚合，用于检验桶计数是否来自与 |
以下可能是响应：
{
"aggregations" : {
"buckets" : {
"doc_count_error_upper_bound" : 0,
"sum_other_doc_count" : 0,
"buckets" : [
{
"key" : "1.0",
"doc_count" : 100,
"latency_ranges" : {
"buckets" : [
{
"key" : "*-0.0",
"to" : 0.0,
"doc_count" : 0
},
{
"key" : "0.0-105.0",
"from" : 0.0,
"to" : 105.0,
"doc_count" : 1
},
{
"key" : "105.0-225.0",
"from" : 105.0,
"to" : 225.0,
"doc_count" : 9
},
{
"key" : "225.0-445.0",
"from" : 225.0,
"to" : 445.0,
"doc_count" : 0
},
{
"key" : "445.0-665.0",
"from" : 445.0,
"to" : 665.0,
"doc_count" : 0
},
{
"key" : "665.0-885.0",
"from" : 665.0,
"to" : 885.0,
"doc_count" : 0
},
{
"key" : "885.0-1115.0",
"from" : 885.0,
"to" : 1115.0,
"doc_count" : 10
},
{
"key" : "1115.0-1335.0",
"from" : 1115.0,
"to" : 1335.0,
"doc_count" : 20
},
{
"key" : "1335.0-1555.0",
"from" : 1335.0,
"to" : 1555.0,
"doc_count" : 20
},
{
"key" : "1555.0-1775.0",
"from" : 1555.0,
"to" : 1775.0,
"doc_count" : 20
},
{
"key" : "1775.0-*",
"from" : 1775.0,
"doc_count" : 20
}
]
},
"ks_test" : {
"less" : 2.248673241788478E-4,
"greater" : 1.0,
"two_sided" : 5.791639181800257E-4
}
},
{
"key" : "2.0",
"doc_count" : 100,
"latency_ranges" : {
"buckets" : [
{
"key" : "*-0.0",
"to" : 0.0,
"doc_count" : 0
},
{
"key" : "0.0-105.0",
"from" : 0.0,
"to" : 105.0,
"doc_count" : 19
},
{
"key" : "105.0-225.0",
"from" : 105.0,
"to" : 225.0,
"doc_count" : 11
},
{
"key" : "225.0-445.0",
"from" : 225.0,
"to" : 445.0,
"doc_count" : 20
},
{
"key" : "445.0-665.0",
"from" : 445.0,
"to" : 665.0,
"doc_count" : 20
},
{
"key" : "665.0-885.0",
"from" : 665.0,
"to" : 885.0,
"doc_count" : 20
},
{
"key" : "885.0-1115.0",
"from" : 885.0,
"to" : 1115.0,
"doc_count" : 10
},
{
"key" : "1115.0-1335.0",
"from" : 1115.0,
"to" : 1335.0,
"doc_count" : 0
},
{
"key" : "1335.0-1555.0",
"from" : 1335.0,
"to" : 1555.0,
"doc_count" : 0
},
{
"key" : "1555.0-1775.0",
"from" : 1555.0,
"to" : 1775.0,
"doc_count" : 0
},
{
"key" : "1775.0-*",
"from" : 1775.0,
"doc_count" : 0
}
]
},
"ks_test" : {
"less" : 0.9642895789647244,
"greater" : 4.58718174664754E-9,
"two_sided" : 5.916656831139733E-9
}
}
]
}
}
}
桶相关性聚合
edit一个兄弟管道聚合，它在配置的兄弟多桶聚合上执行相关函数。
参数
edit-
buckets_path -
(必需，字符串)
包含一组要进行相关性分析的值的桶的路径。
有关语法，请参见
buckets_path语法。 -
function -
(必需, 对象) 要执行的相关性函数。
Properties of
function-
count_correlation -
(必填*, 对象) 用于计算计数相关性的配置。此函数旨在确定术语值与给定度量之间的相关性。因此，它需要满足以下要求。
-
The
buckets_pathmust point to a_countmetric. -
The total count of all the
bucket_pathcount values must be less than or equal toindicator.doc_count. -
When utilizing this function, an initial calculation to gather the required
indicatorvalues is required.
Properties of
count_correlation-
indicator -
(必需, 对象) 用于与配置的
bucket_path值进行关联的指标。Properties of
indicator-
doc_count -
(必需, 整数)
最初创建
expectations的文档总数。它必须大于或等于buckets_path中所有值的总和，因为这是术语值相关联的原始数据的超集。 -
expectations -
(必需, 数组)
用于与配置的
bucket_path值进行关联的数字数组。此值的长度必须始终等于bucket_path返回的桶的数量。 -
fractions -
(可选, 数组)
用于平均和计算方差时的分数数组。如果预计算数据和
buckets_path存在已知间隙，则应使用此选项。如果提供了fractions，其长度必须等于expectations。
-
-
The
-
语法
edit一个 bucket_correlation 聚合单独看起来是这样的：
示例
edit以下代码片段将字段 version 中的各个术语与 latency 指标相关联。未显示的是 latency 指标值的预计算，这是通过使用 百分位数 聚合完成的。
此示例仅使用10秒百分位数。
POST correlate_latency/_search?size=0&filter_path=aggregations
{
"aggs": {
"buckets": {
"terms": {
"field": "version",
"size": 2
},
"aggs": {
"latency_ranges": {
"range": {
"field": "latency",
"ranges": [
{ "to": 0.0 },
{ "from": 0, "to": 105 },
{ "from": 105, "to": 225 },
{ "from": 225, "to": 445 },
{ "from": 445, "to": 665 },
{ "from": 665, "to": 885 },
{ "from": 885, "to": 1115 },
{ "from": 1115, "to": 1335 },
{ "from": 1335, "to": 1555 },
{ "from": 1555, "to": 1775 },
{ "from": 1775 }
]
}
},
"bucket_correlation": {
"bucket_correlation": {
"buckets_path": "latency_ranges>_count",
"function": {
"count_correlation": {
"indicator": {
"expectations": [0, 52.5, 165, 335, 555, 775, 1000, 1225, 1445, 1665, 1775],
"doc_count": 200
}
}
}
}
}
}
}
}
}
|
包含范围聚合和桶相关聚合的术语桶。两者都用于计算术语值与延迟的相关性。 |
|
|
对延迟字段的范围聚合。这些范围是根据延迟字段的百分位数创建的。 |
|
|
计算每个范围内术语值数量与先前计算的指标值之间相关性的桶相关聚合。 |
以下可能是响应：
{
"aggregations" : {
"buckets" : {
"doc_count_error_upper_bound" : 0,
"sum_other_doc_count" : 0,
"buckets" : [
{
"key" : "1.0",
"doc_count" : 100,
"latency_ranges" : {
"buckets" : [
{
"key" : "*-0.0",
"to" : 0.0,
"doc_count" : 0
},
{
"key" : "0.0-105.0",
"from" : 0.0,
"to" : 105.0,
"doc_count" : 1
},
{
"key" : "105.0-225.0",
"from" : 105.0,
"to" : 225.0,
"doc_count" : 9
},
{
"key" : "225.0-445.0",
"from" : 225.0,
"to" : 445.0,
"doc_count" : 0
},
{
"key" : "445.0-665.0",
"from" : 445.0,
"to" : 665.0,
"doc_count" : 0
},
{
"key" : "665.0-885.0",
"from" : 665.0,
"to" : 885.0,
"doc_count" : 0
},
{
"key" : "885.0-1115.0",
"from" : 885.0,
"to" : 1115.0,
"doc_count" : 10
},
{
"key" : "1115.0-1335.0",
"from" : 1115.0,
"to" : 1335.0,
"doc_count" : 20
},
{
"key" : "1335.0-1555.0",
"from" : 1335.0,
"to" : 1555.0,
"doc_count" : 20
},
{
"key" : "1555.0-1775.0",
"from" : 1555.0,
"to" : 1775.0,
"doc_count" : 20
},
{
"key" : "1775.0-*",
"from" : 1775.0,
"doc_count" : 20
}
]
},
"bucket_correlation" : {
"value" : 0.8402398981360937
}
},
{
"key" : "2.0",
"doc_count" : 100,
"latency_ranges" : {
"buckets" : [
{
"key" : "*-0.0",
"to" : 0.0,
"doc_count" : 0
},
{
"key" : "0.0-105.0",
"from" : 0.0,
"to" : 105.0,
"doc_count" : 19
},
{
"key" : "105.0-225.0",
"from" : 105.0,
"to" : 225.0,
"doc_count" : 11
},
{
"key" : "225.0-445.0",
"from" : 225.0,
"to" : 445.0,
"doc_count" : 20
},
{
"key" : "445.0-665.0",
"from" : 445.0,
"to" : 665.0,
"doc_count" : 20
},
{
"key" : "665.0-885.0",
"from" : 665.0,
"to" : 885.0,
"doc_count" : 20
},
{
"key" : "885.0-1115.0",
"from" : 885.0,
"to" : 1115.0,
"doc_count" : 10
},
{
"key" : "1115.0-1335.0",
"from" : 1115.0,
"to" : 1335.0,
"doc_count" : 0
},
{
"key" : "1335.0-1555.0",
"from" : 1335.0,
"to" : 1555.0,
"doc_count" : 0
},
{
"key" : "1555.0-1775.0",
"from" : 1555.0,
"to" : 1775.0,
"doc_count" : 0
},
{
"key" : "1775.0-*",
"from" : 1775.0,
"doc_count" : 0
}
]
},
"bucket_correlation" : {
"value" : -0.5759855613334943
}
}
]
}
}
}
桶选择器聚合
edit一个父管道聚合，执行一个脚本来确定当前桶是否会在父多桶聚合中被保留。指定的指标必须是数值型的，并且脚本必须返回一个布尔值。如果脚本语言是expression，则允许返回数值。在这种情况下，0.0将被评估为false，所有其他值将被评估为true。
bucket_selector 聚合，像所有管道聚合一样，在所有其他同级聚合之后执行。这意味着使用 bucket_selector 聚合来过滤响应中返回的桶并不会节省执行聚合的运行时间。
语法
edit一个 bucket_selector 聚合单独看起来是这样的：
{
"bucket_selector": {
"buckets_path": {
"my_var1": "the_sum",
"my_var2": "the_value_count"
},
"script": "params.my_var1 > params.my_var2"
}
}
表56. bucket_selector 参数
| Parameter Name | Description | Required | Default Value |
|---|---|---|---|
|
用于此聚合的脚本。脚本可以是内联的、文件或索引的。（更多详情请参见脚本） |
必需 |
|
|
脚本变量及其关联路径的映射，我们希望使用这些路径来获取变量的桶（有关详细信息，请参阅 |
必需 |
|
|
在数据中发现间隙时要应用的策略（更多详情请参见处理数据中的间隙） |
可选 |
|
以下代码片段仅保留当月总销售额超过200的桶：
POST /sales/_search
{
"size": 0,
"aggs": {
"sales_per_month": {
"date_histogram": {
"field": "date",
"calendar_interval": "month"
},
"aggs": {
"total_sales": {
"sum": {
"field": "price"
}
},
"sales_bucket_filter": {
"bucket_selector": {
"buckets_path": {
"totalSales": "total_sales"
},
"script": "params.totalSales > 200"
}
}
}
}
}
}
以下可能是响应：
{
"took": 11,
"timed_out": false,
"_shards": ...,
"hits": ...,
"aggregations": {
"sales_per_month": {
"buckets": [
{
"key_as_string": "2015/01/01 00:00:00",
"key": 1420070400000,
"doc_count": 3,
"total_sales": {
"value": 550.0
}
},
{
"key_as_string": "2015/03/01 00:00:00",
"key": 1425168000000,
"doc_count": 2,
"total_sales": {
"value": 375.0
}
}
]
}
}
}
桶排序聚合
edit一个父管道聚合，用于对其父多桶聚合的桶进行排序。
可以指定零个或多个排序字段以及相应的排序顺序。
每个桶可以根据其 _key、_count 或其子聚合进行排序。
此外，可以设置参数 from 和 size 以截断结果桶。
与所有管道聚合一样，bucket_sort 聚合是在所有其他非管道聚合之后执行的。
这意味着排序仅适用于从父聚合返回的任何桶。例如，
如果父聚合是 terms 并且其 size 设置为 10，则 bucket_sort 将仅对这 10 个返回的项桶进行排序。
语法
edit一个 bucket_sort 聚合单独看起来是这样的：
{
"bucket_sort": {
"sort": [
{ "sort_field_1": { "order": "asc" } },
{ "sort_field_2": { "order": "desc" } },
"sort_field_3"
],
"from": 1,
"size": 3
}
}
以下代码片段返回按总销售额降序排列的3个月份对应的桶：
POST /sales/_search
{
"size": 0,
"aggs": {
"sales_per_month": {
"date_histogram": {
"field": "date",
"calendar_interval": "month"
},
"aggs": {
"total_sales": {
"sum": {
"field": "price"
}
},
"sales_bucket_sort": {
"bucket_sort": {
"sort": [
{ "total_sales": { "order": "desc" } }
],
"size": 3
}
}
}
}
}
}
以下可能是响应：
{
"took": 82,
"timed_out": false,
"_shards": ...,
"hits": ...,
"aggregations": {
"sales_per_month": {
"buckets": [
{
"key_as_string": "2015/01/01 00:00:00",
"key": 1420070400000,
"doc_count": 3,
"total_sales": {
"value": 550.0
}
},
{
"key_as_string": "2015/03/01 00:00:00",
"key": 1425168000000,
"doc_count": 2,
"total_sales": {
"value": 375.0
}
},
{
"key_as_string": "2015/02/01 00:00:00",
"key": 1422748800000,
"doc_count": 2,
"total_sales": {
"value": 60.0
}
}
]
}
}
}
不排序截断
edit也可以使用这种聚合来截断结果桶，而不进行任何排序。为此，只需使用 from 和/或 size 参数，而不指定 sort。
以下示例简单地截断结果，以便仅返回第二个桶：
POST /sales/_search
{
"size": 0,
"aggs": {
"sales_per_month": {
"date_histogram": {
"field": "date",
"calendar_interval": "month"
},
"aggs": {
"bucket_truncate": {
"bucket_sort": {
"from": 1,
"size": 1
}
}
}
}
}
}
响应:
{
"took": 11,
"timed_out": false,
"_shards": ...,
"hits": ...,
"aggregations": {
"sales_per_month": {
"buckets": [
{
"key_as_string": "2015/02/01 00:00:00",
"key": 1422748800000,
"doc_count": 2
}
]
}
}
}
变化点聚合
edit此功能处于技术预览阶段，可能会在未来的版本中进行更改或移除。Elastic 将努力修复任何问题，但技术预览版中的功能不受官方 GA 功能支持 SLA 的约束。
一个检测指标中的峰值、低谷和变化点的同级管道。 给定由同级多桶聚合提供的值分布， 此聚合指示任何峰值或低谷的桶，以及/或 值分布中最大变化的桶，如果它们在统计上是显著的。
建议使用变化点聚合来检测基于时间的数据变化，不过，您可以使用任何指标来创建桶。
参数
edit-
buckets_path -
(必需，字符串)
包含一组值的路径，用于在其中检测变化点。必须至少有22个分桶值。建议少于1,000个。
有关语法，请参见
buckets_path语法。
语法
edit一个 change_point 聚合单独看起来是这样的：
响应体
edit-
bucket -
(可选, 对象) 表示发现的变化点的桶的值。如果没有找到变化点，则不会返回。桶中的所有聚合也会一并返回。
桶的属性
-
key - (值) 匹配的桶的键。可以是字符串或数字。
-
doc_count - (数字) 桶的文档计数。
-
-
type -
(对象) 找到的变更点类型及其相关值。可能的类型：
-
dip: 在此变更点发生显著下降 -
distribution_change: 值的总体分布发生了显著变化 -
non_stationary: 没有变更点，但值不是来自平稳分布 -
spike: 在此点发生显著峰值 -
stationary: 未找到变更点 -
step_change: 变更表明值分布在统计上显著的上升或下降 -
trend_change: 在此点发生总体趋势变化
-
示例
edit以下示例使用了Kibana样本数据日志数据集。
GET kibana_sample_data_logs/_search
{
"aggs": {
"date":{
"date_histogram": {
"field": "@timestamp",
"fixed_interval": "1d"
},
"aggs": {
"avg": {
"avg": {
"field": "bytes"
}
}
}
},
"change_points_avg": {
"change_point": {
"buckets_path": "date>avg"
}
}
}
}
|
一个日期直方图聚合，创建以一天为间隔的桶。 |
|
|
一个与 |
|
|
变化点检测聚合配置对象。 |
|
|
用于检测变化点的聚合值的路径。在这种情况下，变化点聚合的输入是 |
请求返回的响应类似于以下内容：
累积基数聚合
edit一个父管道聚合，用于在父直方图（或日期直方图）聚合中计算累积基数。指定的指标必须是基数聚合，并且包含的直方图必须将 min_doc_count 设置为 0（histogram 聚合的默认值）。
The cumulative_cardinality agg 对于查找“总数新项”非常有用，例如每天访问您网站的新访客数量。常规的基数聚合会告诉您每天有多少唯一访客，但不会区分“新”访客或“重复”访客。累积基数聚合可以用来确定每天的唯一访客中有多少是“新”访客。
语法
edit一个 cumulative_cardinality 聚合单独看起来是这样的：
{
"cumulative_cardinality": {
"buckets_path": "my_cardinality_agg"
}
}
表58. cumulative_cardinality 参数
| Parameter Name | Description | Required | Default Value |
|---|---|---|---|
|
我们希望找到其累积基数的基数聚合的路径（更多详情请参见 |
必需 |
|
|
DecimalFormat 模式用于输出值。如果指定，格式化的值将返回在聚合的 |
可选 |
|
以下代码片段计算了每日总用户的累积基数：
GET /user_hits/_search
{
"size": 0,
"aggs": {
"users_per_day": {
"date_histogram": {
"field": "timestamp",
"calendar_interval": "day"
},
"aggs": {
"distinct_users": {
"cardinality": {
"field": "user_id"
}
},
"total_new_users": {
"cumulative_cardinality": {
"buckets_path": "distinct_users"
}
}
}
}
}
}
以下可能是响应：
{
"took": 11,
"timed_out": false,
"_shards": ...,
"hits": ...,
"aggregations": {
"users_per_day": {
"buckets": [
{
"key_as_string": "2019-01-01T00:00:00.000Z",
"key": 1546300800000,
"doc_count": 2,
"distinct_users": {
"value": 2
},
"total_new_users": {
"value": 2
}
},
{
"key_as_string": "2019-01-02T00:00:00.000Z",
"key": 1546387200000,
"doc_count": 2,
"distinct_users": {
"value": 2
},
"total_new_users": {
"value": 3
}
},
{
"key_as_string": "2019-01-03T00:00:00.000Z",
"key": 1546473600000,
"doc_count": 3,
"distinct_users": {
"value": 3
},
"total_new_users": {
"value": 4
}
}
]
}
}
}
注意第二天，2019-01-02，有两个不同的用户，但由累积管道聚合生成的total_new_users指标仅增加到三个。这意味着那天只有两个用户中的一个是新用户，另一个已经在之前的一天出现过。这种情况在第三天再次发生，其中三个用户中只有一个完全是新用户。
增量累积基数
editThe cumulative_cardinality agg 将显示自查询时间段开始以来的总数，不同计数。然而，有时查看“增量”计数是有用的。意思是，每天新增多少用户，而不是总数累计计数。
这可以通过在我们的查询中添加一个导数聚合来实现：
GET /user_hits/_search
{
"size": 0,
"aggs": {
"users_per_day": {
"date_histogram": {
"field": "timestamp",
"calendar_interval": "day"
},
"aggs": {
"distinct_users": {
"cardinality": {
"field": "user_id"
}
},
"total_new_users": {
"cumulative_cardinality": {
"buckets_path": "distinct_users"
}
},
"incremental_new_users": {
"derivative": {
"buckets_path": "total_new_users"
}
}
}
}
}
}
以下可能是响应：
{
"took": 11,
"timed_out": false,
"_shards": ...,
"hits": ...,
"aggregations": {
"users_per_day": {
"buckets": [
{
"key_as_string": "2019-01-01T00:00:00.000Z",
"key": 1546300800000,
"doc_count": 2,
"distinct_users": {
"value": 2
},
"total_new_users": {
"value": 2
}
},
{
"key_as_string": "2019-01-02T00:00:00.000Z",
"key": 1546387200000,
"doc_count": 2,
"distinct_users": {
"value": 2
},
"total_new_users": {
"value": 3
},
"incremental_new_users": {
"value": 1.0
}
},
{
"key_as_string": "2019-01-03T00:00:00.000Z",
"key": 1546473600000,
"doc_count": 3,
"distinct_users": {
"value": 3
},
"total_new_users": {
"value": 4
},
"incremental_new_users": {
"value": 1.0
}
}
]
}
}
}
累积和聚合
edit一个父管道聚合，用于计算父直方图（或日期直方图）聚合中指定度量的累积和。指定的度量必须是数值型的，并且包含的直方图必须将 min_doc_count 设置为 0（这是 histogram 聚合的默认值）。
语法
edit一个 cumulative_sum 聚合单独看起来是这样的：
{
"cumulative_sum": {
"buckets_path": "the_sum"
}
}
表59. cumulative_sum 参数
| Parameter Name | Description | Required | Default Value |
|---|---|---|---|
|
我们希望找到累积和的桶的路径（参见 |
必需 |
|
|
DecimalFormat 模式用于输出值。如果指定，格式化的值将返回在聚合的 |
可选 |
|
以下代码片段计算了每月总销售额的累计和：
POST /sales/_search
{
"size": 0,
"aggs": {
"sales_per_month": {
"date_histogram": {
"field": "date",
"calendar_interval": "month"
},
"aggs": {
"sales": {
"sum": {
"field": "price"
}
},
"cumulative_sales": {
"cumulative_sum": {
"buckets_path": "sales"
}
}
}
}
}
}
以下可能是响应：
{
"took": 11,
"timed_out": false,
"_shards": ...,
"hits": ...,
"aggregations": {
"sales_per_month": {
"buckets": [
{
"key_as_string": "2015/01/01 00:00:00",
"key": 1420070400000,
"doc_count": 3,
"sales": {
"value": 550.0
},
"cumulative_sales": {
"value": 550.0
}
},
{
"key_as_string": "2015/02/01 00:00:00",
"key": 1422748800000,
"doc_count": 2,
"sales": {
"value": 60.0
},
"cumulative_sales": {
"value": 610.0
}
},
{
"key_as_string": "2015/03/01 00:00:00",
"key": 1425168000000,
"doc_count": 2,
"sales": {
"value": 375.0
},
"cumulative_sales": {
"value": 985.0
}
}
]
}
}
}
导数聚合
edit一个父管道聚合，用于计算父直方图（或日期直方图）聚合中指定度量的导数。指定的度量必须是数值型的，并且包含的直方图必须将 min_doc_count 设置为 0（histogram 聚合的默认值）。
语法
edit一个 derivative 聚合单独看起来是这样的：
"derivative": {
"buckets_path": "the_sum"
}
表60. derivative 参数
| Parameter Name | Description | Required | Default Value |
|---|---|---|---|
|
我们希望找到导数的桶的路径（参见 |
必需 |
|
|
在数据中发现间隙时要应用的策略（更多详情请参见处理数据中的间隙） |
可选 |
|
|
DecimalFormat 模式用于输出值。如果指定，格式化的值将返回在聚合的 |
可选 |
|
一阶导数
edit以下代码片段计算了每月总销售额的导数：
POST /sales/_search
{
"size": 0,
"aggs": {
"sales_per_month": {
"date_histogram": {
"field": "date",
"calendar_interval": "month"
},
"aggs": {
"sales": {
"sum": {
"field": "price"
}
},
"sales_deriv": {
"derivative": {
"buckets_path": "sales"
}
}
}
}
}
}
以下可能是响应：
{
"took": 11,
"timed_out": false,
"_shards": ...,
"hits": ...,
"aggregations": {
"sales_per_month": {
"buckets": [
{
"key_as_string": "2015/01/01 00:00:00",
"key": 1420070400000,
"doc_count": 3,
"sales": {
"value": 550.0
}
},
{
"key_as_string": "2015/02/01 00:00:00",
"key": 1422748800000,
"doc_count": 2,
"sales": {
"value": 60.0
},
"sales_deriv": {
"value": -490.0
}
},
{
"key_as_string": "2015/03/01 00:00:00",
"key": 1425168000000,
"doc_count": 2,
"sales": {
"value": 375.0
},
"sales_deriv": {
"value": 315.0
}
}
]
}
}
}
二阶导数
edit二阶导数可以通过将导数管道聚合链接到另一个导数管道聚合的结果上来计算，如下例所示，该示例将计算总月销售额的一阶和二阶导数：
POST /sales/_search
{
"size": 0,
"aggs": {
"sales_per_month": {
"date_histogram": {
"field": "date",
"calendar_interval": "month"
},
"aggs": {
"sales": {
"sum": {
"field": "price"
}
},
"sales_deriv": {
"derivative": {
"buckets_path": "sales"
}
},
"sales_2nd_deriv": {
"derivative": {
"buckets_path": "sales_deriv"
}
}
}
}
}
}
以下可能是响应：
{
"took": 50,
"timed_out": false,
"_shards": ...,
"hits": ...,
"aggregations": {
"sales_per_month": {
"buckets": [
{
"key_as_string": "2015/01/01 00:00:00",
"key": 1420070400000,
"doc_count": 3,
"sales": {
"value": 550.0
}
},
{
"key_as_string": "2015/02/01 00:00:00",
"key": 1422748800000,
"doc_count": 2,
"sales": {
"value": 60.0
},
"sales_deriv": {
"value": -490.0
}
},
{
"key_as_string": "2015/03/01 00:00:00",
"key": 1425168000000,
"doc_count": 2,
"sales": {
"value": 375.0
},
"sales_deriv": {
"value": 315.0
},
"sales_2nd_deriv": {
"value": 805.0
}
}
]
}
}
}
单位
edit导数聚合允许指定导数值的单位。这会在响应中返回一个额外的字段normalized_value，该字段以所需的x轴单位报告导数值。在下面的示例中，我们计算每月的总销售额的导数，但要求以每天的销售额单位来表示销售额的导数：
POST /sales/_search
{
"size": 0,
"aggs": {
"sales_per_month": {
"date_histogram": {
"field": "date",
"calendar_interval": "month"
},
"aggs": {
"sales": {
"sum": {
"field": "price"
}
},
"sales_deriv": {
"derivative": {
"buckets_path": "sales",
"unit": "day"
}
}
}
}
}
}
以下可能是响应：
{
"took": 50,
"timed_out": false,
"_shards": ...,
"hits": ...,
"aggregations": {
"sales_per_month": {
"buckets": [
{
"key_as_string": "2015/01/01 00:00:00",
"key": 1420070400000,
"doc_count": 3,
"sales": {
"value": 550.0
}
},
{
"key_as_string": "2015/02/01 00:00:00",
"key": 1422748800000,
"doc_count": 2,
"sales": {
"value": 60.0
},
"sales_deriv": {
"value": -490.0,
"normalized_value": -15.806451612903226
}
},
{
"key_as_string": "2015/03/01 00:00:00",
"key": 1425168000000,
"doc_count": 2,
"sales": {
"value": 375.0
},
"sales_deriv": {
"value": 315.0,
"normalized_value": 11.25
}
}
]
}
}
}
扩展统计桶聚合
edit一个兄弟管道聚合，用于计算兄弟聚合中指定指标的所有桶的各种统计数据。指定的指标必须是数值类型，且兄弟聚合必须是一个多桶聚合。
与stats_bucket聚合相比，此聚合提供了更多统计信息（平方和、标准差等）。
语法
edit一个 extended_stats_bucket 聚合单独看起来是这样的：
{
"extended_stats_bucket": {
"buckets_path": "the_sum"
}
}
表61. extended_stats_bucket 参数
| Parameter Name | Description | Required | Default Value |
|---|---|---|---|
|
我们希望为其计算统计信息的存储桶的路径（有关更多详细信息，请参阅 |
必需 |
|
|
在数据中发现间隙时要应用的策略（更多详情请参见处理数据中的间隙） |
可选 |
|
|
DecimalFormat 模式用于输出值。如果指定，格式化的值将返回在聚合的 |
可选 |
|
|
显示高于/低于平均值的标准差数量 |
可选 |
2 |
以下代码片段计算了每月销售额桶的扩展统计数据：
POST /sales/_search
{
"size": 0,
"aggs": {
"sales_per_month": {
"date_histogram": {
"field": "date",
"calendar_interval": "month"
},
"aggs": {
"sales": {
"sum": {
"field": "price"
}
}
}
},
"stats_monthly_sales": {
"extended_stats_bucket": {
"buckets_path": "sales_per_month>sales"
}
}
}
}
以下可能是响应：
{
"took": 11,
"timed_out": false,
"_shards": ...,
"hits": ...,
"aggregations": {
"sales_per_month": {
"buckets": [
{
"key_as_string": "2015/01/01 00:00:00",
"key": 1420070400000,
"doc_count": 3,
"sales": {
"value": 550.0
}
},
{
"key_as_string": "2015/02/01 00:00:00",
"key": 1422748800000,
"doc_count": 2,
"sales": {
"value": 60.0
}
},
{
"key_as_string": "2015/03/01 00:00:00",
"key": 1425168000000,
"doc_count": 2,
"sales": {
"value": 375.0
}
}
]
},
"stats_monthly_sales": {
"count": 3,
"min": 60.0,
"max": 550.0,
"avg": 328.3333333333333,
"sum": 985.0,
"sum_of_squares": 446725.0,
"variance": 41105.55555555556,
"variance_population": 41105.55555555556,
"variance_sampling": 61658.33333333334,
"std_deviation": 202.74505063146563,
"std_deviation_population": 202.74505063146563,
"std_deviation_sampling": 248.3109609609156,
"std_deviation_bounds": {
"upper": 733.8234345962646,
"lower": -77.15676792959795,
"upper_population" : 733.8234345962646,
"lower_population" : -77.15676792959795,
"upper_sampling" : 824.9552552551645,
"lower_sampling" : -168.28858858849787
}
}
}
}
推理桶聚合
edit一个父管道聚合，它加载一个预训练模型并在父桶聚合的整理结果字段上执行推理。
要使用推理桶聚合，您需要具备与使用获取训练模型API相同的安全权限。
语法
edit一个 inference 聚合单独看起来是这样的：
{
"inference": {
"model_id": "a_model_for_inference",
"inference_config": {
"regression_config": {
"num_top_feature_importance_values": 2
}
},
"buckets_path": {
"avg_cost": "avg_agg",
"max_cost": "max_agg"
}
}
}
表62. inference 参数
| Parameter Name | Description | Required | Default Value |
|---|---|---|---|
|
训练模型的ID或别名。 |
必需 |
- |
|
可选 |
- |
|
|
定义输入聚合的路径，并将聚合名称映射到模型期望的字段名称。
参见 |
必需 |
- |
推理模型的配置选项
edit设置inference_config是可选的，通常不需要，因为预训练模型自带合理的默认值。在聚合的上下文中，可以为两种类型的模型中的每一种覆盖一些选项。
回归模型的配置选项
edit-
num_top_feature_importance_values - (可选，整数) 指定每个文档的 特征重要性值的最大数量。 默认情况下，它为零，不进行特征重要性计算。
分类模型的配置选项
edit-
num_top_classes - (可选, 整数) 指定要返回的顶级类别预测的数量。默认为 0。
-
num_top_feature_importance_values - (可选，整数) 指定每个文档的 特征重要性值的最大数量。默认为0，表示不进行特征重要性计算。
-
prediction_field_type -
(可选, 字符串)
指定要写入的预测字段类型。
有效值为:
string,number,boolean。当提供boolean时1.0转换为true，0.0转换为false。
示例
edit以下代码片段按 client_ip 聚合网络日志，并通过指标和桶子聚合提取多个特征，作为推理聚合的输入，该聚合配置了用于识别可疑客户端IP的训练模型：
GET kibana_sample_data_logs/_search
{
"size": 0,
"aggs": {
"client_ip": {
"composite": {
"sources": [
{
"client_ip": {
"terms": {
"field": "clientip"
}
}
}
]
},
"aggs": {
"url_dc": {
"cardinality": {
"field": "url.keyword"
}
},
"bytes_sum": {
"sum": {
"field": "bytes"
}
},
"geo_src_dc": {
"cardinality": {
"field": "geo.src"
}
},
"geo_dest_dc": {
"cardinality": {
"field": "geo.dest"
}
},
"responses_total": {
"value_count": {
"field": "timestamp"
}
},
"success": {
"filter": {
"term": {
"response": "200"
}
}
},
"error404": {
"filter": {
"term": {
"response": "404"
}
}
},
"error503": {
"filter": {
"term": {
"response": "503"
}
}
},
"malicious_client_ip": {
"inference": {
"model_id": "malicious_clients_model",
"buckets_path": {
"response_count": "responses_total",
"url_dc": "url_dc",
"bytes_sum": "bytes_sum",
"geo_src_dc": "geo_src_dc",
"geo_dest_dc": "geo_dest_dc",
"success": "success._count",
"error404": "error404._count",
"error503": "error503._count"
}
}
}
}
}
}
}
最大桶聚合
edit一个兄弟管道聚合，用于识别在兄弟聚合中具有指定指标最大值的桶，并输出这些桶的值和键。指定的指标必须是数值类型，且兄弟聚合必须是多桶聚合。
语法
edit一个 max_bucket 聚合单独看起来是这样的：
{
"max_bucket": {
"buckets_path": "the_sum"
}
}
表63. max_bucket 参数
| Parameter Name | Description | Required | Default Value |
|---|---|---|---|
|
我们希望找到最大值的桶的路径（更多详情请参见 |
必需 |
|
|
在数据中发现间隙时要应用的策略（更多详情请参见处理数据中的间隙） |
可选 |
|
|
DecimalFormat 模式用于输出值。如果指定，格式化的值将返回在聚合的 |
可选 |
|
以下代码片段计算了每月总销售额的最大值：
POST /sales/_search
{
"size": 0,
"aggs": {
"sales_per_month": {
"date_histogram": {
"field": "date",
"calendar_interval": "month"
},
"aggs": {
"sales": {
"sum": {
"field": "price"
}
}
}
},
"max_monthly_sales": {
"max_bucket": {
"buckets_path": "sales_per_month>sales"
}
}
}
}
以下可能是响应：
{
"took": 11,
"timed_out": false,
"_shards": ...,
"hits": ...,
"aggregations": {
"sales_per_month": {
"buckets": [
{
"key_as_string": "2015/01/01 00:00:00",
"key": 1420070400000,
"doc_count": 3,
"sales": {
"value": 550.0
}
},
{
"key_as_string": "2015/02/01 00:00:00",
"key": 1422748800000,
"doc_count": 2,
"sales": {
"value": 60.0
}
},
{
"key_as_string": "2015/03/01 00:00:00",
"key": 1425168000000,
"doc_count": 2,
"sales": {
"value": 375.0
}
}
]
},
"max_monthly_sales": {
"keys": ["2015/01/01 00:00:00"],
"value": 550.0
}
}
}
最小桶聚合
edit一个兄弟管道聚合，用于识别在兄弟聚合中具有指定指标最小值的桶，并输出这些桶的值和键。指定的指标必须是数值类型，且兄弟聚合必须是多桶聚合。
语法
edit一个 min_bucket 聚合单独看起来是这样的：
{
"min_bucket": {
"buckets_path": "the_sum"
}
}
表64. min_bucket 参数
| Parameter Name | Description | Required | Default Value |
|---|---|---|---|
|
我们希望找到最小值的桶的路径（更多详情请参见 |
必需 |
|
|
在数据中发现间隙时要应用的策略（更多详情请参见处理数据中的间隙） |
可选 |
|
|
DecimalFormat 模式用于输出值。如果指定，格式化的值将返回在聚合的 |
可选 |
|
以下代码片段计算了每月总销售额的最小值：
POST /sales/_search
{
"size": 0,
"aggs": {
"sales_per_month": {
"date_histogram": {
"field": "date",
"calendar_interval": "month"
},
"aggs": {
"sales": {
"sum": {
"field": "price"
}
}
}
},
"min_monthly_sales": {
"min_bucket": {
"buckets_path": "sales_per_month>sales"
}
}
}
}
以下可能是响应：
{
"took": 11,
"timed_out": false,
"_shards": ...,
"hits": ...,
"aggregations": {
"sales_per_month": {
"buckets": [
{
"key_as_string": "2015/01/01 00:00:00",
"key": 1420070400000,
"doc_count": 3,
"sales": {
"value": 550.0
}
},
{
"key_as_string": "2015/02/01 00:00:00",
"key": 1422748800000,
"doc_count": 2,
"sales": {
"value": 60.0
}
},
{
"key_as_string": "2015/03/01 00:00:00",
"key": 1425168000000,
"doc_count": 2,
"sales": {
"value": 375.0
}
}
]
},
"min_monthly_sales": {
"keys": ["2015/02/01 00:00:00"],
"value": 60.0
}
}
}
移动函数聚合
edit给定一个有序的数据序列，移动函数聚合将在数据上滑动一个窗口，并允许用户指定一个自定义脚本，该脚本在每个数据窗口上执行。为了方便起见，预定义了许多常用函数，如最小值/最大值、移动平均值等。
语法
edit一个 moving_fn 聚合单独看起来是这样的：
{
"moving_fn": {
"buckets_path": "the_sum",
"window": 10,
"script": "MovingFunctions.min(values)"
}
}
表65. moving_fn 参数
| Parameter Name | Description | Required | Default Value |
|---|---|---|---|
|
感兴趣指标的路径（更多详情请参见 |
必需 |
|
|
窗口的大小，用于在直方图上“滑动”。 |
必需 |
|
|
应在每个数据窗口上执行的脚本 |
必需 |
|
|
在数据中发现间隙时要应用的策略。请参阅处理数据中的间隙。 |
可选 |
|
|
可选 |
0 |
moving_fn 聚合必须嵌套在 histogram 或 date_histogram 聚合中。它们可以像其他指标聚合一样嵌套：
POST /_search
{
"size": 0,
"aggs": {
"my_date_histo": {
"date_histogram": {
"field": "date",
"calendar_interval": "1M"
},
"aggs": {
"the_sum": {
"sum": { "field": "price" }
},
"the_movfn": {
"moving_fn": {
"buckets_path": "the_sum",
"window": 10,
"script": "MovingFunctions.unweightedAvg(values)"
}
}
}
}
}
}
|
一个名为“my_date_histo”的 |
|
|
一个 |
|
|
最后，我们指定了一个 |
移动平均值是通过首先指定一个字段上的直方图或日期直方图来构建的。然后，您可以选择在其中添加数值度量，例如总和。最后，将moving_fn嵌入到直方图中。然后使用buckets_path参数来“指向”直方图中的一个同级度量（有关buckets_path语法的描述，请参见buckets_path语法）。
上述聚合的一个示例响应可能如下所示：
{
"took": 11,
"timed_out": false,
"_shards": ...,
"hits": ...,
"aggregations": {
"my_date_histo": {
"buckets": [
{
"key_as_string": "2015/01/01 00:00:00",
"key": 1420070400000,
"doc_count": 3,
"the_sum": {
"value": 550.0
},
"the_movfn": {
"value": null
}
},
{
"key_as_string": "2015/02/01 00:00:00",
"key": 1422748800000,
"doc_count": 2,
"the_sum": {
"value": 60.0
},
"the_movfn": {
"value": 550.0
}
},
{
"key_as_string": "2015/03/01 00:00:00",
"key": 1425168000000,
"doc_count": 2,
"the_sum": {
"value": 375.0
},
"the_movfn": {
"value": 305.0
}
}
]
}
}
}
自定义用户脚本
edit移动函数聚合允许用户指定任意脚本来定义自定义逻辑。每次收集到新的数据窗口时，都会调用该脚本。这些值在values变量中提供给脚本。然后，脚本应执行某种计算并输出一个double类型的结果。不允许输出null，但允许输出NaN和+/-Inf。
例如，这个脚本将简单地返回窗口中的第一个值，或者如果没有可用值，则返回NaN：
POST /_search
{
"size": 0,
"aggs": {
"my_date_histo": {
"date_histogram": {
"field": "date",
"calendar_interval": "1M"
},
"aggs": {
"the_sum": {
"sum": { "field": "price" }
},
"the_movavg": {
"moving_fn": {
"buckets_path": "the_sum",
"window": 10,
"script": "return values.length > 0 ? values[0] : Double.NaN"
}
}
}
}
}
}
移位参数
edit默认情况下（使用 shift = 0），用于计算的窗口是排除当前桶的最后 n 个值。
将 shift 增加 1 会将起始窗口位置向右移动 1。
-
要包含当前桶到窗口中，使用
shift = 1。 -
对于居中对齐（
n / 2个值在当前桶之前和之后），使用shift = window / 2。 -
对于右对齐（
n个值在当前桶之后），使用shift = window。
如果窗口的任一边缘移动到数据系列的边界之外，窗口将缩小以仅包含可用值。
预构建函数
edit为了方便起见，已经预先构建了许多函数，并可以在 moving_fn 脚本上下文中使用：
-
max() -
min() -
sum() -
stdDev() -
unweightedAvg() -
linearWeightedAvg() -
ewma() -
holt() -
holtWinters()
这些函数可以从 MovingFunctions 命名空间中获得。例如 MovingFunctions.max()
最大值函数
edit此函数接受一组双精度数，并返回该窗口中的最大值。null 和 NaN 值将被忽略；最大值仅在实际值上计算。如果窗口为空，或者所有值都是 null/NaN，则返回 NaN 作为结果。
POST /_search
{
"size": 0,
"aggs": {
"my_date_histo": {
"date_histogram": {
"field": "date",
"calendar_interval": "1M"
},
"aggs": {
"the_sum": {
"sum": { "field": "price" }
},
"the_moving_max": {
"moving_fn": {
"buckets_path": "the_sum",
"window": 10,
"script": "MovingFunctions.max(values)"
}
}
}
}
}
}
最小值函数
edit此函数接受一组双精度数，并返回该窗口中的最小值。null 和 NaN 值将被忽略；最小值仅在实际值上计算。如果窗口为空，或者所有值都是 null/NaN，则返回 NaN 作为结果。
POST /_search
{
"size": 0,
"aggs": {
"my_date_histo": {
"date_histogram": {
"field": "date",
"calendar_interval": "1M"
},
"aggs": {
"the_sum": {
"sum": { "field": "price" }
},
"the_moving_min": {
"moving_fn": {
"buckets_path": "the_sum",
"window": 10,
"script": "MovingFunctions.min(values)"
}
}
}
}
}
}
求和函数
edit此函数接受一组双精度数，并返回该窗口中值的总和。null 和 NaN 值将被忽略；总和仅在实际值上计算。如果窗口为空，或者所有值都是 null/NaN，则返回 0.0 作为结果。
POST /_search
{
"size": 0,
"aggs": {
"my_date_histo": {
"date_histogram": {
"field": "date",
"calendar_interval": "1M"
},
"aggs": {
"the_sum": {
"sum": { "field": "price" }
},
"the_moving_sum": {
"moving_fn": {
"buckets_path": "the_sum",
"window": 10,
"script": "MovingFunctions.sum(values)"
}
}
}
}
}
}
标准差函数
edit此函数接受一组双精度数和平均值，然后返回该窗口中值的标准差。
null 和 NaN 值将被忽略；总和仅在实际值上计算。如果窗口为空，或者所有值都是
null/NaN，则返回 0.0 作为结果。
POST /_search
{
"size": 0,
"aggs": {
"my_date_histo": {
"date_histogram": {
"field": "date",
"calendar_interval": "1M"
},
"aggs": {
"the_sum": {
"sum": { "field": "price" }
},
"the_moving_sum": {
"moving_fn": {
"buckets_path": "the_sum",
"window": 10,
"script": "MovingFunctions.stdDev(values, MovingFunctions.unweightedAvg(values))"
}
}
}
}
}
}
必须向标准差函数提供avg参数，因为可以在窗口上计算不同风格的平均值（简单、线性加权等）。下面详细介绍的各种移动平均值可以用于计算标准差函数的平均值。
未加权平均函数
edit函数 unweightedAvg 计算窗口中所有值的总和，然后除以窗口的大小。它实际上是窗口的简单算术平均值。简单移动平均不执行任何与时间相关的加权，这意味着来自 simple 移动平均的值往往“滞后”于实际数据。
null 和 NaN 值将被忽略；平均值仅基于实际值计算。如果窗口为空，或者所有值都是 null/NaN，则返回 NaN 作为结果。这意味着用于平均值计算的计数是 null 和 NaN 以外的值的数量。
POST /_search
{
"size": 0,
"aggs": {
"my_date_histo": {
"date_histogram": {
"field": "date",
"calendar_interval": "1M"
},
"aggs": {
"the_sum": {
"sum": { "field": "price" }
},
"the_movavg": {
"moving_fn": {
"buckets_path": "the_sum",
"window": 10,
"script": "MovingFunctions.unweightedAvg(values)"
}
}
}
}
}
}
线性加权平均函数
edit函数 linearWeightedAvg 为序列中的点分配线性权重，使得“较旧”的数据点（例如窗口开始处的那些点）对总平均值的贡献线性减少。线性加权有助于减少数据均值后的“滞后”，因为较旧的点影响较小。
如果窗口为空，或者所有值都是 null/NaN，则返回 NaN 作为结果。
POST /_search
{
"size": 0,
"aggs": {
"my_date_histo": {
"date_histogram": {
"field": "date",
"calendar_interval": "1M"
},
"aggs": {
"the_sum": {
"sum": { "field": "price" }
},
"the_movavg": {
"moving_fn": {
"buckets_path": "the_sum",
"window": 10,
"script": "MovingFunctions.linearWeightedAvg(values)"
}
}
}
}
}
}
ewma 函数
edit函数 ewma（即“单指数”）类似于函数 linearMovAvg，不同之处在于较旧的数据点呈指数级降低重要性，而不是线性降低重要性。重要性衰减的速度可以通过 alpha 设置来控制。较小的值使权重缓慢衰减，从而提供更大的平滑度并考虑更大的窗口部分。较大的值使权重快速衰减，从而减少较旧值对移动平均值的影响。这往往使移动平均值更紧密地跟踪数据，但平滑度较低。
null 和 NaN 值将被忽略；平均值仅基于实际值计算。如果窗口为空，或者所有值都是 null/NaN，则返回 NaN 作为结果。这意味着用于平均值计算的计数是 null 和 NaN 以外的值的数量。
POST /_search
{
"size": 0,
"aggs": {
"my_date_histo": {
"date_histogram": {
"field": "date",
"calendar_interval": "1M"
},
"aggs": {
"the_sum": {
"sum": { "field": "price" }
},
"the_movavg": {
"moving_fn": {
"buckets_path": "the_sum",
"window": 10,
"script": "MovingFunctions.ewma(values, 0.3)"
}
}
}
}
}
}
holt 函数
editThe holt 函数（又名“双指数”）包含第二个指数项，用于跟踪数据的趋势。当数据具有潜在的线性趋势时，单指数表现不佳。双指数模型在内部计算两个值：“水平”和“趋势”。
级别计算类似于ewma，是对数据的一种指数加权视图。不同的是，它使用之前平滑后的值而不是原始值，这使得它能够更接近原始序列。趋势计算则关注当前值与上一个值之间的差异（例如，平滑数据的趋势或斜率）。趋势值也是指数加权的。
值是通过将水平和趋势分量相乘得到的。
null 和 NaN 值将被忽略；平均值仅基于实际值计算。如果窗口为空，或者所有值都是 null/NaN，则返回 NaN 作为结果。这意味着用于平均值计算的计数是 null 和 NaN 以外的值的数量。
表73. holt(double[] values, double alpha) 参数
| Parameter Name | Description |
|---|---|
|
要计算总和的数值窗口 |
|
级别衰减值 |
|
趋势衰减值 |
POST /_search
{
"size": 0,
"aggs": {
"my_date_histo": {
"date_histogram": {
"field": "date",
"calendar_interval": "1M"
},
"aggs": {
"the_sum": {
"sum": { "field": "price" }
},
"the_movavg": {
"moving_fn": {
"buckets_path": "the_sum",
"window": 10,
"script": "MovingFunctions.holt(values, 0.3, 0.1)"
}
}
}
}
}
}
在实践中，alpha 值在 holtMovAvg 中的表现与在 ewmaMovAvg 中非常相似：较小的值会产生更多的平滑和更多的滞后，而较大的值会产生更接近的跟踪和更少的滞后。beta 的值通常很难看出。较小的值强调长期趋势（例如整个系列中的恒定线性趋势），而较大的值强调短期趋势。
holtWinters 函数
editThe holtWinters 函数（又名“三重指数”）包含第三个指数项，用于跟踪数据的季节性方面。因此，此聚合基于三个组件进行平滑处理：“水平”、“趋势”和“季节性”。
水平和趋势的计算与holt相同。季节性计算则考虑当前点与一个周期前的点之间的差异。
Holt-Winters 比其他移动平均线需要更多的手动调整。你需要指定数据的“周期性”：例如，如果你的数据每7天有一个循环趋势，你应该设置 period = 7。同样，如果有一个每月的趋势，你应该设置为 30。目前没有周期性检测功能，尽管这计划在未来增强中实现。
null 和 NaN 值将被忽略；平均值仅基于实际值计算。如果窗口为空，或者所有值都是 null/NaN，则返回 NaN 作为结果。这意味着用于平均值计算的计数是 null 和 NaN 以外的值的数量。
表74. holtWinters(double[] values, double alpha) 参数
| Parameter Name | Description |
|---|---|
|
要计算总和的数值窗口 |
|
级别衰减值 |
|
趋势衰减值 |
|
季节性衰减值 |
|
数据的周期性 |
|
如果希望使用乘法Holt-Winters，则为True；如果希望使用加法Holt-Winters，则为False |
POST /_search
{
"size": 0,
"aggs": {
"my_date_histo": {
"date_histogram": {
"field": "date",
"calendar_interval": "1M"
},
"aggs": {
"the_sum": {
"sum": { "field": "price" }
},
"the_movavg": {
"moving_fn": {
"buckets_path": "the_sum",
"window": 10,
"script": "if (values.length > 5*2) {MovingFunctions.holtWinters(values, 0.3, 0.1, 0.1, 5, false)}"
}
}
}
}
}
}
乘法Holt-Winters通过将每个数据点除以季节性值来工作。如果您的数据中有任何零值，或者数据中存在间隙（因为这会导致除以零），这将是有问题的。为了应对这种情况，mult Holt-Winters将所有值填充一个非常小的量（1*10-10），以使所有值都为非零。这会影响结果，但只是微乎其微。如果您的数据是非零的，或者您希望在遇到零时看到NaN，您可以通过pad: false禁用此行为。
"冷启动"
edit不幸的是，由于Holt-Winters的性质，它需要两个周期的数据来“引导”算法。这意味着您的窗口必须始终至少是您周期大小的两倍。如果不是，将会抛出一个异常。这也意味着Holt-Winters在最初的2 * 周期个桶中不会发出值；当前的算法不进行回溯。
你会注意到在上面的例子中，我们有一个if ()语句检查值的大小。这是为了确保我们在调用holt-winters函数之前有足够的数据（5 * 2，其中5是在holtWintersMovAvg函数中指定的周期）。
移动百分位数聚合
edit给定一个有序的百分位数序列，移动百分位数聚合将滑动一个窗口在这些百分位数上，并允许用户计算累积百分位数。
这从概念上非常类似于移动函数管道聚合， 只不过它作用于百分位数草图而不是实际的桶值。
语法
edit一个 moving_percentiles 聚合单独看起来是这样的：
{
"moving_percentiles": {
"buckets_path": "the_percentile",
"window": 10
}
}
表75. moving_percentiles 参数
| Parameter Name | Description | Required | Default Value |
|---|---|---|---|
|
感兴趣的百分位路径（参见 |
必需 |
|
|
窗口的大小，用于在直方图上“滑动”。 |
必需 |
|
|
可选 |
0 |
moving_percentiles 聚合必须嵌套在 histogram 或 date_histogram 聚合中。它们可以像其他指标聚合一样嵌套：
POST /_search
{
"size": 0,
"aggs": {
"my_date_histo": {
"date_histogram": {
"field": "date",
"calendar_interval": "1M"
},
"aggs": {
"the_percentile": {
"percentiles": {
"field": "price",
"percents": [ 1.0, 99.0 ]
}
},
"the_movperc": {
"moving_percentiles": {
"buckets_path": "the_percentile",
"window": 10
}
}
}
}
}
}
|
一个名为“my_date_histo”的 |
|
|
一个 |
|
|
最后，我们指定了一个 |
移动百分位数是通过首先指定一个字段上的 histogram 或 date_histogram 来构建的。然后在该直方图中添加一个百分位数指标。最后，将 moving_percentiles 嵌入到该直方图中。buckets_path 参数用于“指向”直方图内的百分位数聚合（有关 buckets_path 语法的描述，请参见 buckets_path 语法）。
以下可能是响应：
{
"took": 11,
"timed_out": false,
"_shards": ...,
"hits": ...,
"aggregations": {
"my_date_histo": {
"buckets": [
{
"key_as_string": "2015/01/01 00:00:00",
"key": 1420070400000,
"doc_count": 3,
"the_percentile": {
"values": {
"1.0": 151.0,
"99.0": 200.0
}
}
},
{
"key_as_string": "2015/02/01 00:00:00",
"key": 1422748800000,
"doc_count": 2,
"the_percentile": {
"values": {
"1.0": 10.4,
"99.0": 49.6
}
},
"the_movperc": {
"values": {
"1.0": 151.0,
"99.0": 200.0
}
}
},
{
"key_as_string": "2015/03/01 00:00:00",
"key": 1425168000000,
"doc_count": 2,
"the_percentile": {
"values": {
"1.0": 175.25,
"99.0": 199.75
}
},
"the_movperc": {
"values": {
"1.0": 11.6,
"99.0": 200.0
}
}
}
]
}
}
}
聚合的输出格式继承自引用的percentiles聚合的格式。
移动百分位数管道聚合始终以跳过间隙策略运行。
移动百分位数偏移参数
edit默认情况下（使用 shift = 0），用于计算的窗口是排除当前桶的最后 n 个值。
将 shift 增加 1 会将起始窗口位置向右移动 1。
-
要包含当前桶到窗口中，使用
shift = 1。 -
对于居中对齐（
n / 2个值在当前桶之前和之后），使用shift = window / 2。 -
对于右对齐（
n个值在当前桶之后），使用shift = window。
如果窗口的任一边缘移动到数据系列的边界之外，窗口将缩小以仅包含可用值。
标准化聚合
edit一个父管道聚合，用于计算特定桶值的特定归一化/重缩放值。 无法归一化的值将使用跳过间隙策略跳过。
语法
edit一个 normalize 聚合单独看起来是这样的：
{
"normalize": {
"buckets_path": "normalized",
"method": "percent_of_sum"
}
}
表76. normalize_pipeline 参数
| Parameter Name | Description | Required | Default Value |
|---|---|---|---|
|
我们希望进行归一化的桶的路径（更多详情请参见 |
必需 |
|
|
要应用的特定方法 |
必需 |
|
|
DecimalFormat 模式用于输出值。如果指定，格式化的值将返回在聚合的 |
可选 |
|
方法
edit归一化聚合支持多种方法来转换桶值。每个方法定义将使用以下原始桶值集作为示例：[5, 5, 10, 50, 10, 20]。
- rescale_0_1
-
此方法重新调整数据，使得最小值为零，最大值为1，其余值在此之间线性归一化。
x' = (x - min_x) / (max_x - min_x)
[0, 0, .1111, 1, .1111, .3333]
- rescale_0_100
-
此方法重新调整数据，使得最小值为零，最大值为100，其余值在此之间线性归一化。
x' = 100 * (x - min_x) / (max_x - min_x)
[0, 0, 11.11, 100, 11.11, 33.33]
- percent_of_sum
-
此方法将每个值标准化，使其表示其贡献的总和的百分比。
x' = x / sum_x
[5%, 5%, 10%, 50%, 10%, 20%]
- mean
-
此方法将每个值标准化，使其与平均值的差异进行归一化。
x' = (x - mean_x) / (max_x - min_x)
[4.63, 4.63, 9.63, 49.63, 9.63, 9.63, 19.63]
- z-score
-
此方法标准化，使得每个值表示它相对于标准差离均值的距离
x' = (x - mean_x) / stdev_x
[-0.68, -0.68, -0.39, 1.94, -0.39, 0.19]
- softmax
-
此方法将每个值进行指数化，并相对于原始值的指数和进行归一化。
x' = e^x / sum_e_x
[2.862E-20, 2.862E-20, 4.248E-18, 0.999, 9.357E-14, 4.248E-18]
示例
edit以下代码片段计算每个月的总销售额百分比：
POST /sales/_search
{
"size": 0,
"aggs": {
"sales_per_month": {
"date_histogram": {
"field": "date",
"calendar_interval": "month"
},
"aggs": {
"sales": {
"sum": {
"field": "price"
}
},
"percent_of_total_sales": {
"normalize": {
"buckets_path": "sales",
"method": "percent_of_sum",
"format": "00.00%"
}
}
}
}
}
}
|
|
|
|
|
|
|
|
以下可能是响应：
{
"took": 11,
"timed_out": false,
"_shards": ...,
"hits": ...,
"aggregations": {
"sales_per_month": {
"buckets": [
{
"key_as_string": "2015/01/01 00:00:00",
"key": 1420070400000,
"doc_count": 3,
"sales": {
"value": 550.0
},
"percent_of_total_sales": {
"value": 0.5583756345177665,
"value_as_string": "55.84%"
}
},
{
"key_as_string": "2015/02/01 00:00:00",
"key": 1422748800000,
"doc_count": 2,
"sales": {
"value": 60.0
},
"percent_of_total_sales": {
"value": 0.06091370558375635,
"value_as_string": "06.09%"
}
},
{
"key_as_string": "2015/03/01 00:00:00",
"key": 1425168000000,
"doc_count": 2,
"sales": {
"value": 375.0
},
"percent_of_total_sales": {
"value": 0.38071065989847713,
"value_as_string": "38.07%"
}
}
]
}
}
}
百分比桶聚合
edit一个兄弟管道聚合，用于计算兄弟聚合中指定指标的所有桶的百分位数。指定的指标必须是数值类型，且兄弟聚合必须是一个多桶聚合。
语法
edit一个 percentiles_bucket 聚合单独看起来像这样：
{
"percentiles_bucket": {
"buckets_path": "the_sum"
}
}
表77. percentiles_bucket 参数
| Parameter Name | Description | Required | Default Value |
|---|---|---|---|
|
我们希望找到百分位数的路径（参见 |
必需 |
|
|
在数据中发现间隙时要应用的策略（更多详情请参见处理数据中的间隙） |
可选 |
|
|
DecimalFormat 模式用于输出值。如果指定，格式化的值将返回在聚合的 |
可选 |
|
|
要计算的百分位数列表 |
可选 |
|
|
标志，返回范围作为哈希而不是键值对的数组 |
可选 |
|
以下代码片段计算了每月总销售额的百分位数：
POST /sales/_search
{
"size": 0,
"aggs": {
"sales_per_month": {
"date_histogram": {
"field": "date",
"calendar_interval": "month"
},
"aggs": {
"sales": {
"sum": {
"field": "price"
}
}
}
},
"percentiles_monthly_sales": {
"percentiles_bucket": {
"buckets_path": "sales_per_month>sales",
"percents": [ 25.0, 50.0, 75.0 ]
}
}
}
}
|
|
|
|
|
以下可能是响应：
{
"took": 11,
"timed_out": false,
"_shards": ...,
"hits": ...,
"aggregations": {
"sales_per_month": {
"buckets": [
{
"key_as_string": "2015/01/01 00:00:00",
"key": 1420070400000,
"doc_count": 3,
"sales": {
"value": 550.0
}
},
{
"key_as_string": "2015/02/01 00:00:00",
"key": 1422748800000,
"doc_count": 2,
"sales": {
"value": 60.0
}
},
{
"key_as_string": "2015/03/01 00:00:00",
"key": 1425168000000,
"doc_count": 2,
"sales": {
"value": 375.0
}
}
]
},
"percentiles_monthly_sales": {
"values" : {
"25.0": 375.0,
"50.0": 375.0,
"75.0": 550.0
}
}
}
}
百分位数桶实现
edit百分位数桶返回最接近的输入数据点，该数据点不大于请求的百分位数；它不会在数据点之间进行插值。
百分位数是精确计算的，而不是近似值（与百分位数指标不同）。这意味着实现会维护一个内存中的、排序的数据列表来计算百分位数，然后再丢弃数据。如果你尝试在一个percentiles_bucket中计算数百万个数据点的百分位数，可能会遇到内存压力问题。
序列差分聚合
edit序列差分是一种技术，其中时间序列中的值在不同的时间滞后或周期内从自身中减去。例如，数据点 f(x) = f(xt) - f(xt-n)，其中 n 是所使用的周期。
周期为1相当于没有时间归一化的导数：它仅仅是相邻两点之间的变化。单周期对于去除常数、线性趋势非常有用。
单个周期也用于将数据转换为平稳序列。在这个例子中，道琼斯指数在约250天内绘制。原始数据不是平稳的，这会使其在某些技术中使用变得困难。
通过计算一阶差分，我们对数据进行了去趋势处理（例如，去除常数或线性趋势）。我们可以看到，数据变成了一个平稳序列（例如，一阶差分围绕零随机分布，并且似乎不表现出任何模式/行为）。这种转换揭示了数据集遵循随机游走；当前值是前一个值加减一个随机量。这一见解有助于选择进一步分析的工具。
较大的周期可以用来消除季节性/周期性行为。在这个例子中，旅鼠的种群是使用正弦波 + 恒定的线性趋势 + 随机噪声合成的。正弦波的周期为30天。
一阶差分去除了常数趋势，仅留下一个正弦波。然后对一阶差分应用第30阶差分，以去除周期性行为，留下一个平稳序列，便于进行其他分析。
语法
edit一个 serial_diff 聚合单独看起来像这样：
{
"serial_diff": {
"buckets_path": "the_sum",
"lag": 7
}
}
表78. serial_diff 参数
| Parameter Name | Description | Required | Default Value |
|---|---|---|---|
|
感兴趣指标的路径（更多详情请参见 |
必需 |
|
|
要从当前值中减去的历史桶。例如，滞后为7将从7个桶之前的值中减去当前值。必须是正的非零整数 |
可选 |
|
|
确定在遇到数据间隙时应采取的操作。 |
可选 |
|
|
DecimalFormat 模式用于输出值。如果指定，格式化的值将返回在聚合的 |
可选 |
|
serial_diff 聚合必须嵌套在 histogram 或 date_histogram 聚合中：
POST /_search
{
"size": 0,
"aggs": {
"my_date_histo": {
"date_histogram": {
"field": "timestamp",
"calendar_interval": "day"
},
"aggs": {
"the_sum": {
"sum": {
"field": "lemmings"
}
},
"thirtieth_difference": {
"serial_diff": {
"buckets_path": "the_sum",
"lag" : 30
}
}
}
}
}
}
|
一个名为“my_date_histo”的 |
|
|
一个 |
|
|
最后，我们指定了一个 |
序列差异是通过首先指定一个字段上的 histogram 或 date_histogram 来构建的。然后，您可以选择性地添加普通的指标，例如 sum，在该直方图内部。最后，将 serial_diff 嵌入到直方图中。buckets_path 参数用于“指向”直方图内部的一个同级指标（有关 buckets_path 语法的描述，请参见 buckets_path 语法）。
统计桶聚合
edit一个兄弟管道聚合，用于计算兄弟聚合中指定指标的所有桶的各种统计数据。指定的指标必须是数值类型，且兄弟聚合必须是一个多桶聚合。
语法
edit一个 stats_bucket 聚合单独看起来是这样的：
{
"stats_bucket": {
"buckets_path": "the_sum"
}
}
表79. stats_bucket 参数
| Parameter Name | Description | Required | Default Value |
|---|---|---|---|
|
我们希望为其计算统计信息的存储桶的路径（有关更多详细信息，请参阅 |
必需 |
|
|
在数据中发现间隙时要应用的策略（更多详情请参见处理数据中的间隙） |
可选 |
|
|
DecimalFormat 模式用于输出值。如果指定，格式化的值将返回在聚合的 |
可选 |
|
以下代码片段计算了每月的销售额的统计数据：
POST /sales/_search
{
"size": 0,
"aggs": {
"sales_per_month": {
"date_histogram": {
"field": "date",
"calendar_interval": "month"
},
"aggs": {
"sales": {
"sum": {
"field": "price"
}
}
}
},
"stats_monthly_sales": {
"stats_bucket": {
"buckets_path": "sales_per_month>sales"
}
}
}
}
以下可能是响应：
{
"took": 11,
"timed_out": false,
"_shards": ...,
"hits": ...,
"aggregations": {
"sales_per_month": {
"buckets": [
{
"key_as_string": "2015/01/01 00:00:00",
"key": 1420070400000,
"doc_count": 3,
"sales": {
"value": 550.0
}
},
{
"key_as_string": "2015/02/01 00:00:00",
"key": 1422748800000,
"doc_count": 2,
"sales": {
"value": 60.0
}
},
{
"key_as_string": "2015/03/01 00:00:00",
"key": 1425168000000,
"doc_count": 2,
"sales": {
"value": 375.0
}
}
]
},
"stats_monthly_sales": {
"count": 3,
"min": 60.0,
"max": 550.0,
"avg": 328.3333333333333,
"sum": 985.0
}
}
}
总和桶聚合
edit一个兄弟管道聚合，用于计算兄弟聚合中指定指标在所有桶中的总和。指定的指标必须是数值类型，且兄弟聚合必须是一个多桶聚合。
语法
edit一个 sum_bucket 聚合单独看起来是这样的：
{
"sum_bucket": {
"buckets_path": "the_sum"
}
}
表80. sum_bucket 参数
| Parameter Name | Description | Required | Default Value |
|---|---|---|---|
|
我们希望找到总和的桶的路径（参见 |
必需 |
|
|
在数据中发现间隙时要应用的策略（更多详情请参见处理数据中的间隙） |
可选 |
|
|
DecimalFormat 模式用于输出值。如果指定，格式化后的值将返回在聚合的 |
可选 |
|
以下代码片段计算所有月度销售额桶的总和：
POST /sales/_search
{
"size": 0,
"aggs": {
"sales_per_month": {
"date_histogram": {
"field": "date",
"calendar_interval": "month"
},
"aggs": {
"sales": {
"sum": {
"field": "price"
}
}
}
},
"sum_monthly_sales": {
"sum_bucket": {
"buckets_path": "sales_per_month>sales"
}
}
}
}
以下可能是响应：
{
"took": 11,
"timed_out": false,
"_shards": ...,
"hits": ...,
"aggregations": {
"sales_per_month": {
"buckets": [
{
"key_as_string": "2015/01/01 00:00:00",
"key": 1420070400000,
"doc_count": 3,
"sales": {
"value": 550.0
}
},
{
"key_as_string": "2015/02/01 00:00:00",
"key": 1422748800000,
"doc_count": 2,
"sales": {
"value": 60.0
}
},
{
"key_as_string": "2015/03/01 00:00:00",
"key": 1425168000000,
"doc_count": 2,
"sales": {
"value": 375.0
}
}
]
},
"sum_monthly_sales": {
"value": 985.0
}
}
}