标签: sliding-window

在解决几何问题时,我遇到了一种称为滑动窗口算法的方法.

无法真正找到任何研究材料/细节.

算法是什么？

使用data.table包实现滑动窗口函数的最佳(最快)方法是什么？

我正在尝试计算滚动中位数但每个日期有多行(由于2个额外的因素),我认为这意味着动物园rollapply函数不起作用.以下是使用naive for循环的示例:

library(data.table)
df <- data.frame(
  id=30000,
  date=rep(as.IDate(as.IDate("2012-01-01")+0:29, origin="1970-01-01"), each=1000),
  factor1=rep(1:5, each=200),
  factor2=1:5,
  value=rnorm(30, 100, 10)
)

dt = data.table(df)
setkeyv(dt, c("date", "factor1", "factor2"))

get_window <- function(date, factor1, factor2) {
  criteria <- data.table(
    date=as.IDate((date - 7):(date - 1), origin="1970-01-01"),
    factor1=as.integer(factor1),
    factor2=as.integer(factor2)
  )
  return(dt[criteria][, value])
}

output <- data.table(unique(dt[, list(date, factor1, factor2)]))[, window_median:=as.numeric(NA)]

for(i in nrow(output):1) {
  print(i)
  output[i, window_median:=median(get_window(date, factor1, factor2))]
}

| time                | company | quote |
+---------------------+---------+-------+
| 0000-00-00 00:00:00 | GOOGLE  |    40 |
| 2012-07-02 21:28:05 | GOOGLE  |    60 |
| 2012-07-02 21:28:51 | SAP     |    60 |
| 2012-07-02 21:29:05 | SAP     |    20 |

如何在MySQL中对此表进行延迟以打印引号的差异,例如:

GOOGLE | 20
SAP    | 40  

我有一个numpy形状(6,2)

[[00,01],
 [10,11],
 [20,21],
 [30,31],
 [40,41],
 [50,51]]

我需要一个步长为1的滑动窗口,窗口大小为3喜欢这个:

[[00,01,10,11,20,21],
 [10,11,20,21,30,31],
 [20,21,30,31,40,41],
 [30,31,40,41,50,51]]

我正在寻找一个numpy解决方案.如果您的解决方案可以参数化原始数组的形状以及窗口大小和步长,那就太好了.

我发现这个相关的答案使用步幅有效的移动平均滤波器,但我没有看到如何指定那里的步长以及如何将窗口从3d折叠到连续的2d数组.这个滚动或滑动窗口迭代器在Python中,但是在Python中,我不确定它的效率如何.此外,它支持元素,但如果每个元素具有多个特征,则最终不会将它们连接在一起.

我正在使用反应式扩展将数据整理到100毫秒的缓冲区:

this.subscription = this.dataService
    .Where(x => !string.Equals("FOO", x.Key.Source))
    .Buffer(TimeSpan.FromMilliseconds(100))
    .ObserveOn(this.dispatcherService)
    .Where(x => x.Count != 0)
    .Subscribe(this.OnBufferReceived);

这很好用.但是,我想要的行为与Buffer操作提供的行为略有不同.基本上,如果收到另一个数据项,我想重置计时器.只有当整个100毫秒没有收到数据时我才能处理它.这开启了永不处理数据的可能性,因此我还应该能够指定最大计数.我会想象一下:

.SlidingBuffer(TimeSpan.FromMilliseconds(100), 10000)

我已经环顾四周,在Rx中找不到这样的东西？任何人都可以确认/否认这个吗？

我正在尝试在序列中扩展匹配匹配算法.我的比赛长20个单位,每个时间点有4个频道.我已经构建了一个封装匹配的模型,我无法弄清楚如何在滑动窗口中使用它来跨更长的序列应用它来查找序列中的匹配.

我有2个(20, 4)输入张量(query和target),我连接,添加,展平,然后应用一个简单的密集层.我在这个阶段有数据来训练100K查询,目标对.

def sum_seqs(seqs):
    return K.sum(seqs, axis=3)

def pad_dims(seq):
    return K.expand_dims(seq, axis=3)

def pad_outshape(in_shape):
    return (in_shape[0], in_shape[1], in_shape[2], 1)


query = Input((20, 4))
query_pad = Lambda(pad_dims, output_shape=pad_outshape, name='gpad')(query)

target = Input((20,4))
target_pad = Lambda(pad_dims, output_shape=pad_outshape)(target)

matching = Concatenate(axis = 3)([query_pad, target_pad])
matching = Lambda(sum_seqs)(matching)

matching = Flatten()(matching)
matching = Dropout(0.1)(matching)
matching = Dense(1, activation = 'sigmoid')(matching)

match_model = Model([query, target], matching)

这非常有效.现在我想使用这个预先训练的模型来搜索target具有不同query序列的更长序列.

它似乎应该是这样的:

long_target = Input((100, 4))

short_target = …

我有一个5000*5000numpy数组,我想要计算大小为25的窗口的Kurtosis.我尝试将scipys自己的kurtosis功能放入generic_filter发现中,ndimage.filters如下所示:

import numpy as np

from scipy.stats import kurtosis
from scipy.ndimage.filters import generic_filter

mat = np.random.random_sample((5000, 5000))

kurtosis_filter = generic_filter(mat, kurtosis, size=25, mode='reflect') 

这永远不会结束,我不确定它会给出正确的答案.所以我的第一个问题是,这是否是使用generic_filterscipy函数的正确方法.如果它恰好是正确的,那么它对我来说太慢了.所以我的下一个问题是,如果有更快的方法来实现这一目标？例如,考虑标准偏差,您可以简单地执行以下操作:

usual_mean = uniform_filter(mat, size=25, mode='reflect')
mean_of_squared = uniform_filter(np.multiply(mat,mat), size=25, mode='reflect')
standard_deviation = (mean_of_squared - np.multiply(usual_mean,usual_mean))**.5

这是非常快速的,简单来自$\sigma ^ 2 = E [(X - \mu)^ 2] = E [X ^ 2] - (E [X])^ 2 $的事实.

我有一个简单的时间序列,我正在努力估计移动窗口内的方差.更具体地说,我无法解决与实现滑动窗口功能的方式有关的一些问题.例如,使用NumPy和窗口大小= 20时:

def rolling_window(a, window):
    shape = a.shape[:-1] + (a.shape[-1] - window + 1, window)
    strides = a.strides + (a.strides[-1],)
    return np.lib.stride_tricks.as_strided(a, shape=shape, strides=strides) 

rolling_window(data, 20)
np.var(rolling_window(data, 20), -1)
datavar=np.var(rolling_window(data, 20), -1)

在这个想法中,也许我错了.有谁知道一个直截了当的方法吗？任何帮助/建议都是最受欢迎的.

我目前正在使用此查询(在SQL Server中)每天计算唯一项目的数量:

SELECT Date, COUNT(DISTINCT item) 
FROM myTable 
GROUP BY Date 
ORDER BY Date

如何对此进行转换以获取过去3天(包括当天)中每个日期的唯一商品数量？

输出应该是一个包含2列的表:一列包含原始表中的所有日期.在第二列,我们有每个日期的唯一项目数.

例如,如果原始表是:

Date        Item  
01/01/2018  A  
01/01/2018  B  
02/01/2018  C  
03/01/2018  C    
04/01/2018  C

根据我上面的查询,我目前获得每天的唯一计数:

Date        count  
01/01/2018  2  
02/01/2018  1  
03/01/2018  1  
04/01/2018  1

我希望得到3天滚动窗口的独特计数:

Date        count  
01/01/2018  2  
02/01/2018  3  (because items ABC on 1st and 2nd Jan)
03/01/2018  3  (because items ABC on 1st,2nd,3rd Jan)    
04/01/2018  1  (because only item C on 2nd,3rd,4th Jan)    

我在Haskell中需要一个高效的滑动窗口函数,所以我写了以下内容:

windows n xz@(x:xs)
  | length v < n = []
  | otherwise = v : windows n xs
  where
    v = take n xz

我的问题是我认为复杂度是O(n*m),其中m是列表的长度,n是窗口大小.你倒计时列表一次take,另一次length,你在基本上mn次列表中.看起来它可能比这更有效,但我对如何使其更加线性感到茫然.任何接受者？