标签: aggregation

在OLAP-cubes中,可以对大量聚合数据进行快速查找.这样做的主要原因是一个预先聚合操作中的数据,这些数据易于向上组合(主要是+, - ,mean,std,max,min等等).

如何在clojure中获得这种"反懒惰"行为？

我正在考虑类似的事情

(def world-population {:africa 4e8            ;;this is an aggregation!
                       :africa/liberia 3.4e6
                       :africa/ethiopia 7.4e7
                       ...})

如何更新这样的数据结构并确保实体的父级也更新？有人必须推出自己的ref实现吗？

我是Camel的新手,想知道如何使用Camel实现下面提到的用例,

我们有一个REST Web服务,让我们说它有两个服务操作callA和callB.现在我们在前面有ESB层,在访问这些实际的Web服务URL之前拦截客户端请求.

现在我试图做这样的事情 - 在客户端实际调用的ESB中公开一个URL.在ESB中,我们使用的是Camel的Jetty组件,它只代理此服务调用.所以我们说这个URL是/ my-service/scan /

现在收到此请求@ESB,我想调用这两个REST端点(callA和callB) - >获取它们的响应 - resA和resB - >将它聚合到单个响应对象resScan - >返回到客户端.

我现在所拥有的只是 -

<route id="MyServiceScanRoute">
<from uri="jetty:http://{host}.{port}./my-service/scan/?matchOnUriPrefix=true&amp;bridgeEndpoint=true"/>
<!-- Set service specific headers, monitoring etc. -->  
<!-- Call performScan -->
<to uri="direct:performScan"/>
</route>

<route id="SubRoute_performScan">
<from uri="direct:performScan"/>
<!--  HOW DO I??
Make callA, callB service calls. 
Get their responses resA, resB.
Aggregate these responses to resScan
 -->
</route>

好吧,假设我有一个类,X和X是与其他对象有聚合关系的东西.让假装X是一个足球场.

X满是观众.然而,每个观众对特定活动的行为不同.而不是IF语句,我希望不同的行为在观众类中,以便我可以使用动态绑定.

然而,问题在于观众执行的行为影响"足球场"类.所以我想把"这个"从足球场的课程,通过一种方法传递给观察者课程,以便观众班可以为足球场课程做些什么？

public class SoccerStadium{
    SpecatorInterface s = new Spectator();

    public void SpectatorBehaviour(){
        s.doSomething(this);
    }

    public void doSomethingthingBySpecator(){
    }
}

public class Spectator implements SpecatorInterface{
    public void doSomething(SoccerStadium s){
        s.doSomethingthingBySpecator();
    }
}

我只想这样做,这样我就可以使用动态绑定并改变行为,Specator.doSomething()这样我可以将许多不同类型的SpectatorSuperClass作为传递给SoccerStadium的属性然后具有不同的行为.

编辑:如果我通过Spectator构造函数将体育场的引用传递给Specator,而不是传递this怎么办？

我正在使用一个包含深层嵌套列表的列表列的大型(数百万行)数据表,这些列表没有统一的结构,大小或元素顺序(list(x=1,y=2)并且list(y=2,x=1)可能都存在且应该被视为相同).我需要重复执行任意分组,其中包括数据表中的某些列以及列表列中的数据子集.并非所有行都具有与子集匹配的值.

我提出的方法感觉过于复杂.以下是要点:

• 识别嵌套列表结构中的值.我的方法是使用ul <- unlist(list_col),"展平"嵌套数据结构并构建层次结构名称,以便直接访问每个元素,例如address.country.code.

• 从分组的角度来看,确保相同的未列出数据的排列被认为是相等的.我的方法是通过其值的名称对未列出的向量进行排序,ul[order(names(ul))]并通过引用将结果分配为新的字符向量列.

• 对展平值的子集执行分组.我无法以by=任何方式使用值为列表或向量的列.因此,我必须找到一种方法将唯一的字符向量映射到简单的值.我这样做了digest.

以下是两个主力函数:

# Flatten list column in a data.table
flatten_list_col <- function(dt, col_name, flattened_col_name='props') {

  flatten_props <- function(d) {
    if (length(d) > 0) {
      ul <- unlist(d)
      names <- names(ul)
      if (length(names) > 0) {
        ul[order(names)]          
      } else {
        NA
      }
    } else {
      NA
    }
  }

  flattened <- lapply(dt[[col_name]], flatten_props)
  dt[, as.character(flattened_col_name) := list(flattened), with=F]
} …

你能帮我解决一下如何在R中正确使用聚合函数吗？我有这样的数据:

SPORT   FLOWS
[1,] "Other" "1"  
[2,] "Other" "1"  
[3,] "Other" "1"  
[4,] "Other" "1"  
[5,] "Other2" "1"  
[6,] "Other2" "1"

我需要得到这个:

SPORT   FLOWS
[1,] "Other" "4"
[2,] "Other2" "2"

我发现,它可以用聚合函数完成,但它不起作用..

谢谢你们..我有明确的回答,对我有用..

我对弹性搜索很新,我还没有找到具体的问题.如果已经回答,我会提前道歉,我希望你能指出我正确的方向.

我一直在寻找在NEST中实现以下内容的方法:

"aggs" : {
    "fieldA" : {
        "terms" : {
            "field" : "fieldA"

        }
    },

    "fieldB" : {
        "terms" : {
            "field" : "fieldB"

        }
    }
}

我试过这个:

.Aggregations(q => q.Terms("fieldA", r => r.Field(s => s.fieldA)) && q.Terms("fieldB", r => r.Field(s => s.fieldB)))

还有这个:

.Aggregations(q => q.Terms("fieldA", r => r.Field(s => s.fieldA)))
.Aggregations(q => q.Terms("fieldB", r => r.Field(s => s.fieldB)))

哪两个都失败了.我错过了别的什么吗？

我正在包含超过100,000个前端实例的实例组中构建度量报告系统.对于任何请求,每个实例都有一个响应时间.我需要的是在整个车队中分配各种请求的响应时间.例如[requestType1,requestType2 ... requestType1000]的[Percentile 50,Percentile 90,Percentile 99,Percentile99.9 ...].

每个实例都会收集内部发生的响应时间.所以一分钟之内,一个实例在内存中收集的是各种requestTypes的响应时间列表.例如requestType1 - [1,2,3,4,1,2],requestType2 - [2,2,3,2,1] ......所以我需要做的是处理这些数据并生成最后的结果.

我尝试了很多设计,我的主要痛点是我收集的每个requestType的数据点大小,以及实例之间的通信费用. 我将在下面解释我目前的设计,但我也想知道是否有更好的设计或某些花哨的算法可以聚合直方图？

目前最有希望的是:每个前端实例都会将其数据发送到中间层实例组的随机实例.在这个中间层车队中,每个实例都会聚合它在短时间内获得的所有数据点,例如5秒.(它没有足够的内存来保持更长的时间).然后,中间层实例将通过requestTypes的哈希值将聚合数据分发到后端实例.这意味着所有中间层实例都会将相同requestTypes的数据点发送到同一个后端实例.然后在后端实例中我可以使用第三方的直方图容器(CodaHale的直方图或HdrHistogram)来计算传入数据点的P50,P90,P99 ......我需要中间层实例队列的原因是从前面发送数据 - 最终实例是昂贵的,所以我希望它的所有数据一次发送,但不要100次调用发送到100个不同的后端实例.

我可能会想到这个设计的主要问题是相对较高的复杂性,如果一个后台实例关闭,我可能会丢失某些requestTypes的所有数据.那么对于系统设计部分,任何人都有一些更好的想法？

我想的另一种方法是找到一种奇特的算法来聚合现有的直方图.上面的设计,我得到的数据将是100%准确.但实际上我可以容忍一些错误.例如在CodaHale的直方图和HdrHistogram中,我确信它们实际上并没有保存所有数据点,而是应用了一些高级数学算法以非常低的成本获得相对高精度的结果.我可以在前端或中间层实例中使用直方图库.但问题是虽然我能以低成本获得每个前端实例或中间层实例的[P50,P90,P99 ......],但我找不到聚合它们的方法.因为不同的前端实例可能会处理不同类型的请求,并且对前端实例的请求分配是未知的,所以简单地计算所有P50,P90,P99的平均值会产生很多不准确.那么有没有人有想法,我怎样才能将多个CodaHale的直方图或HdrHistogram聚合在一起？或者是否有任何算法可以帮助将直方图聚合成一个？

================================================== ======================

昨晚我有了一些新想法.由于P50和P90正在测量所有数据的"平均值",我认为在每个中间层实例中计算的所有P50和P90的简单应用加权平均值应该足够好.但是P99,P99.9和P99.99正在测量那些外围数据,因此子集的P99的平均值可能不准确.

但是如果假设中间层实例中的数据是相对随机分布的,那么我可以在每个中间层实例中获得前5%的数据点,并将它们发送到后端.每个中间层数据点的5%合计为总数据点的5%.而且我更有信心,这5%数据的P80接近整体数据P99,这5%数据的P98接近整体数据的P99.9,而5%数据的P99.8接近P99 .99总体数据.

我希望通过这种方式,我只能传输5%的总体数据,但能获得高精度的结果.你觉得这样怎么样？

在指定直方图聚合时,有没有办法将字符串转换为浮点数？因为我有文件的字段是浮点数但是没有被弹性搜索解析,当我尝试使用字符串字段进行求和时它会抛出下一个错误.

ClassCastException[org.elasticsearch.index.fielddata.plain.PagedBytesIndexFieldData 
cannot be cast to org.elasticsearch.index.fielddata.IndexNumericFieldData]}]"

我知道我可以更改映射,但是对于我的用例,如果我在为字段编写聚合时指定类似"script:_value.tofloat()"的内容会更方便.

这是我的代码:

{
"query" : {
    "bool": {"
         must": [
            {"match": { "sensorId":  "D14UD021808ARZC" }},
            {"match": { "variableName": "CAUDAL"}}
        ]
    }
},      
"aggs" : {
    "caudal_per_month" : {
          "date_histogram" : {
                  "field" : "timestamp",
                  "interval" : "month"
          },
          "aggs": {
             "totalmonth": {
                    "sum": {
                        "field": "value",
                        "script" : "_value*1.0"
                    }
             }
         }
    }
}  

}

弹性索引(id,name,dept,status)中的文档集合为{1,pone,d1,m2} {2,ptwo,d1,m2},{3,ptwo,d2,m1}我想查询到通过dept获取结果组的'm2'状态.同样的结果集应包括零计数的记录为{d1:2},{d2:0}.我们如何使用Elastic Search aggs实现它？

 {
   "query": {
        "match": {
           "status": "m2"
        }
    },
    "aggs" : {
        "results" : {
            "terms" : {
               "field" : "dept"
            }
        }
    }
 }

此查询返回'dept'而不计数为{d1:2}.此外,我还希望将0计数的记录设为{d1:2},{d2:0}.谢谢

我有一个五分钟的数据帧:

rng = pd.date_range('1/1/2011', periods=60, freq='5Min')
df = pd.DataFrame(np.random.randn(60, 4), index=rng, columns=['A', 'B', 'C', 'D'])

                            A         B         C         D
2011-01-01 00:00:00  1.287045 -0.621473  0.482130  1.886648
2011-01-01 00:05:00  0.402645 -1.335942 -0.609894 -0.589782
2011-01-01 00:10:00 -0.311789  0.342995 -0.875089 -0.781499
2011-01-01 00:15:00  1.970683  0.471876  1.042425 -0.128274
2011-01-01 00:20:00 -1.900357 -0.718225 -3.168920 -0.355735
2011-01-01 00:25:00  1.128843 -0.097980  1.130860 -1.045019
2011-01-01 00:30:00 -0.261523  0.379652 -0.385604 -0.910902

我想仅重新采样15分钟间隔的数据,但没有聚合成统计数据(我不想要平均值,中位数,stdev).我想在15分钟的时间间隔内进行子采样并得到实际数据.是否存在内置方法这样做？

我的输出是:

                            A         B         C         D                 
2011-01-01 00:00:00  1.287045 -0.621473  0.482130  1.886648                 
2011-01-01 00:15:00  1.970683  0.471876  1.042425 -0.128274                 
2011-01-01 …