Elasticsearch 之 Metrics Aggregations（数值度量聚合）

比眉伴天荒 2021-12-19 01:23 509阅读 0赞

### Metrics Aggregations（数值度量聚合） ###

该系列中的聚合基于以某种方式从正在聚合的文档中提取的值来计算度量。这些值通常从文档的字段中提取(使用字段数据)，但也可以使用脚本生成。

数值度量聚合是一种输出数值的特殊类型的度量聚合。一些聚合输出单个数值度量（例如平均值），称为单值度量聚合，另一些输出多个度量值（例如统计数据），称为多值数值度量聚合。单值与多值数值度量聚合的区别是，他们充当某些桶聚合（比如某些桶聚合可以基于每个桶的数值度量对返回的桶进行排序）的直接子聚合时发挥了不同的作用。

avg aggregation（single-value）

均值聚合–基于文档中的某个字段，计算该值在聚合文档中的均值。这些值可以从文档中的特定数字字段中提取，也可以由提供的脚本生成。

假设数据由学生考试成绩(介于0到100之间)的文档组成，我们可以用以下方法对他们的分数进行平均:

POST /exams/_search?size=0
    { 
        "aggs" : { 
            "avg_grade" : {  "avg" : {  "field" : "grade" } }
        }
    }
    // 输出
    { 
        ...
        "aggregations": { 
            "avg_grade": { 
                "value": 75.0
            }
        }
    }

*  配置参数  
    基于脚本计算平均成绩

POST /exams/_search?size=0
    { 
        "aggs" : { 
            "avg_grade" : { 
                "avg" : { 
                    "script" : { 
                        "source" : "doc.grade.value"
                    }
                }
            }
        }
    }

*  value script

假如这次考试难度超过了学生的平均水平，需要对成绩进行修正。可以通过如下方式获取新的均值：

POST /exams/_search?size=0
    { 
        "aggs" : { 
            "avg_corrected_grade" : { 
                "avg" : { 
                    "field" : "grade",
                    "script" : { 
                        "lang": "painless",
                        "source": "_value * params.correction",
                        "params" : { 
                            "correction" : 1.2
                        }
                    }
                }
            }
        }
    }

*  Missing value

`missing` 参数定义了在文档值缺失情况下的处理方式。默认情况下它们会被忽略，但是也可以认为有某个特定的值。

POST /exams/_search?size=0
    { 
        "aggs" : { 
            "grade_avg" : { 
                "avg" : { 
                    "field" : "grade",
                    "missing": 10 
                }
            }
        }
    }

### 加权均值聚合 ###

用公式可以描述为 ∑(value \* weight) / ∑(weight)

一般说的均值可以认为是的具有隐式权重为一的加权平均值。

##### 权重均值参数 #####

<table> 
 <thead> 
  <tr> 
   <th align="center">参数名称</th> 
   <th align="center">描述</th> 
   <th align="center">是否需要默认值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td align="center">value</td> 
   <td align="center">提供值的字段或脚本的配置</td> 
   <td align="center">必需</td> 
  </tr> 
  <tr> 
   <td align="center">weight</td> 
   <td align="center">提供权重的字段或脚本的配置</td> 
   <td align="center">必需</td> 
  </tr> 
  <tr> 
   <td align="center">format</td> 
   <td align="center">响应数字格式</td> 
   <td align="center">可选</td> 
  </tr> 
  <tr> 
   <td align="center">value_type</td> 
   <td align="center">纯脚本或未映射字段的值的提示</td> 
   <td align="center">可选</td> 
  </tr> 
 </tbody> 
</table>

##### 示例 #####

文档中有一个 grade 字段，值为 0-100，以及一个 weight 字段保存了数字类型的权重，可以通过如下方式计算权重平均值：

POST /exams/_search
    { 
        "size": 0,
        "aggs" : { 
            "weighted_grade": { 
                "weighted_avg": { 
                    "value": { 
                        "field": "grade"
                    },
                    "weight": { 
                        "field": "weight"
                    }
                }
            }
        }
    }
    // 产生响应
    { 
        ...
        "aggregations": { 
            "weighted_grade": { 
                "value": 70.0
            }
        }
    }

### 基数聚合（Cardinality Aggregation） ###

基于文档的某个值，计算文档非重复的个数（去重计数）。用于计算的值可以是特定的字段，也可以通过脚本计算而来。  
注：非精确值

#### 配置参数： ####

*  script：由脚本生成用来计算的 value
 *  precision\_threshold：
 *  missing：文档缺省字段时的默认值

商品种类数

POST /sales/_search?size=0
    { 
        "aggs" : { 
            "type_count" : { 
                "cardinality" : { 
                    "field" : "type"
                }
            }
        }
    }
    
    // 响应
    { 
        ...
        "aggregations" : { 
            "type_count" : { 
                "value" : 3
            }
        }
    }

#### 精度控制 ####

该聚合支持精度阈值选项：

POST /sales/_search?size=0
    { 
        "aggs" : { 
            "type_count" : { 
                "cardinality" : { 
                    "field" : "_doc",
                    "precision_threshold": 100 
                }
            }
        }
    }

> `precision_threshold` 提供了使用内存换精确度的方式，定义一个值，小于该值预计是精确的，超过该值，统计总数会模糊。最大支持 40000，超过该值效果也与其一样。默认 3000。

### 最大值聚合（Max Aggregation) single ###

最大值聚合——基于文档的某个值，求该值在聚合文档中的最大值。用于计算的值可以是特定的数值型字段，也可以通过脚本计算而来。  
最大，最小值基于 double 数据类型， 绝对值超过 2^53 值会是近似值。

POST /sales/_search?size=0
    {
        "aggs" : {
            "max_price" : { "max" : { "field" : "price" } }
        }
    }
    // 响应
    {
        ...
        "aggregations": {
            "max_price": {
                "value": 200.0
            }
        }
    }

##### 配置参数 #####

*  field：用于计算的字段
 *  script：由脚本生成用来计算的 value
 *  missing：文档缺省字段时的默认值

### 最小值聚合 （Min Aggregation）single ###

最小值聚合——基于文档的某个值，求该值在聚合文档中的最小值。  
用于计算的值可以是特定的数值型字段，也可以通过脚本计算而来。

POST /sales/_search?size=0
    { 
        "aggs" : { 
            "min_price" : {  "min" : {  "field" : "price" } }
        }
    }
    // 响应
    { 
        ...
    
        "aggregations": { 
            "min_price": { 
                "value": 10.0
            }
        }
    }

##### 配置参数 #####

*  field：用于计算的字段
 *  script：由脚本生成用来计算的 value
 *  missing：文档缺省字段时的默认值

### 百分比聚合（Percentiles Aggregation）multi-value ###

基于聚合文档中某个数值类型的值，排序，计算在某些百分位处的值。  
用于计算的值可以是特定的数值型字段，也可以通过脚本计算而来。

GET latency/_search
    { 
        "size": 0,
        "aggs" : { 
            "load_time_outlier" : { 
                "percentiles" : { 
                    "field" : "load_time" 
                }
            }
        }
    }
    // 响应
    { 
        ...
    
       "aggregations": { 
          "load_time_outlier": { 
             "values" : { 
                "1.0": 5.0,
                "5.0": 25.0,
                "25.0": 165.0,
                "50.0": 445.0,
                "75.0": 725.0,
                "95.0": 945.0,
                "99.0": 985.0
             }
          }
       }
    }

说明：百分之 99 的值小于等于 985.0。

##### 配置参数 #####

*  field：用于计算的字段
 *  script：由脚本生成用来计算的 value
 *  missing：文档缺省字段时的默认值
 *  keyed：
 *  hdr：
 *  compression：

### 百分比等级聚合（Percentile Ranks Aggregation） ###

用于计算的值可以是特定的数值型字段，也可以通过脚本计算而来。

百分比等级展示观察到的某个数值所在的从小到大排序整体的百分位。如：如果一个值大于等于 95% 的其他值，就可以说它处在 95% 的等级上。

GET latency/_search
    { 
        "size": 0,
        "aggs" : { 
            "load_time_ranks" : { 
                "percentile_ranks" : { 
                    "field" : "load_time", 
                    "values" : [500, 600]
                }
            }
        }
    }
    // 响应
     
    { 
        ...
    
       "aggregations": { 
          "load_time_ranks": { 
             "values" : { 
                "500.0": 55.00000000000001,
                "600.0": 64.0
             }
          }
       }
    }

##### 配置参数 #####

*  field：用于计算的字段
 *  script：由脚本生成用来计算的 value
 *  missing：文档缺省字段时的默认值
 *  keyed：
 *  hdr：
 *  compression：

### Scripted Metric Aggregation ###

基于脚本的权值聚合——用脚本来计算出一个权值。

##### 配置参数 #####

*  init\_script：用于计算的字段
 *  map\_script：由脚本生成用来计算的 value
 *  combine\_script：文档缺省字段时的默认值
 *  reduce\_script：

### 统计聚合（stats aggregation) multi-value ###

统计聚合——基于文档的某个值，计算出一些统计信息（min、max、sum、count、avg）。

用于计算的值可以是特定的数值型字段，也可以通过脚本计算而来。

使用：

POST /exams/_search?size=0
    { 
        "aggs" : { 
            "grades_stats" : {  "stats" : {  "field" : "grade" } }
        }
    }
    
    // 响应
    { 
        ...
    
        "aggregations": { 
            "grades_stats": { 
                "count": 2,
                "min": 50.0,
                "max": 100.0,
                "avg": 75.0,
                "sum": 150.0
            }
        }
    }

##### 配置参数 #####

*  field：用于计算的字段
 *  script：由脚本生成用来计算的 value
 *  value：校正值
 *  missing：文档缺省字段时的默认值

### 求和聚合 ###

求和聚合——基于文档的某个值，求该值在聚合文档中的统计和。

用于计算的值可以是特定的数值型字段，也可以通过脚本计算而来。

使用：统计所有帽子的金额

POST /sales/_search?size=0
    { 
        "query" : { 
            "constant_score" : { 
                "filter" : { 
                    "match" : {  "type" : "hat" }
                }
            }
        },
        "aggs" : { 
            "hat_prices" : {  "sum" : {  "field" : "price" } }
        }
    }
    // 响应
    { 
        ...
        "aggregations": { 
            "hat_prices": { 
               "value": 450.0
            }
        }
    }

##### 配置参数 #####

*  field：用于计算的字段
 *  script：由脚本生成用来计算的 value
 *  value：校正值
 *  missing：文档缺省字段时的默认值

### Top hits Aggregation（最高匹配权值聚合） ###

最高匹配权值聚合——跟踪聚合中相关性最高的文档。

该聚合一般用做 sub-aggregation，以此来聚合每个桶中的最高匹配的文档。

### 值计数聚合 Value Count Aggregation(single-value) ###

值计数聚合——计算聚合文档中某个值的个数。

用于计数的值可以是特定的数值型字段，也可以通过脚本计算而来。

该聚合一般与其它 single-value 聚合联合使用，比如在计算一个字段的平均值的时候，可能还会关注这个平均值是由多少个值计算而来。

POST /sales/_search?size=0
    { 
        "aggs" : { 
            "types_count" : {  "value_count" : {  "field" : "type" } }
        }
    }

##### 配置参数 #####

*  field：用于计算的字段
 *  script：由脚本生成用来计算的 value

### Geo Bounds Aggregation（地理边界聚合） ###

地理边界聚合——基于文档的某个字段（geo-point类型字段），计算出该字段所有地理坐标点的边界（左上角/右下角坐标点）。

使用：

PUT /museums
    { 
        "mappings": { 
            "_doc": { 
                "properties": { 
                    "location": { 
                        "type": "geo_point"
                    }
                }
            }
        }
    }
    
    POST /museums/_doc/_bulk?refresh
    { "index":{ "_id":1}}
    { "location": "52.374081,4.912350", "name": "NEMO Science Museum"}
    { "index":{ "_id":2}}
    { "location": "52.369219,4.901618", "name": "Museum Het Rembrandthuis"}
    { "index":{ "_id":3}}
    { "location": "52.371667,4.914722", "name": "Nederlands Scheepvaartmuseum"}
    { "index":{ "_id":4}}
    { "location": "51.222900,4.405200", "name": "Letterenhuis"}
    { "index":{ "_id":5}}
    { "location": "48.861111,2.336389", "name": "Musée du Louvre"}
    { "index":{ "_id":6}}
    { "location": "48.860000,2.327000", "name": "Musée d'Orsay"}
    
    POST /museums/_search?size=0
    { 
        "query" : { 
            "match" : {  "name" : "musée" }
        },
        "aggs" : { 
            "viewport" : { 
                "geo_bounds" : { 
                    "field" : "location", 
                    "wrap_longitude" : true 
                }
            }
        }
    }

//响应
    { 
        ...
        "aggregations": { 
            "viewport": { 
                "bounds": { 
                    "top_left": { 
                        "lat": 48.86111099738628,
                        "lon": 2.3269999679178
                    },
                    "bottom_right": { 
                        "lat": 48.85999997612089,
                        "lon": 2.3363889567553997
                    }
                }
            }
        }
    }

##### 配置参数 #####

*  field：用于计算的字段（geo-point类型）
 *  wrap\_longitude：是否允许地理边界与国际日界线存在重叠

### Geo Centroid Aggregation（地理重心聚合） ###

地理重心聚合——基于文档的某个字段（geo-point类型字段），计算所有坐标的加权重心。

使用：

POST /museums/_search?size=0
    { 
        "aggs" : { 
            "centroid" : { 
                "geo_centroid" : { 
                    "field" : "location" 
                }
            }
        }
    }
    
    // 响应
    { 
        ...
        "aggregations": { 
            "centroid": { 
                "location": { 
                    "lat": 51.00982963107526,
                    "lon": 3.9662130922079086
                },
                "count": 6
            }
        }
    }

##### 配置参数 #####

*  field：用于计算的字段（geo-point类型）

参考：

1.  [https://www.cnblogs.com/licongyu/p/5515786.html][https_www.cnblogs.com_licongyu_p_5515786.html]
2.  [https://www.elastic.co/guide/en/elasticsearch/reference/6.4/search-aggregations-metrics.html][https_www.elastic.co_guide_en_elasticsearch_reference_6.4_search-aggregations-metrics.html]
3.  xxx

[https_www.cnblogs.com_licongyu_p_5515786.html]: https://www.cnblogs.com/licongyu/p/5515786.html
[https_www.elastic.co_guide_en_elasticsearch_reference_6.4_search-aggregations-metrics.html]: https://www.elastic.co/guide/en/elasticsearch/reference/6.4/search-aggregations-metrics.html