blocks|key|984075|text|我猜跟踪你的20个样本，Sum(X%5E2+from+1..20)和Sum(X+from+1..20)，然后在每次迭代中连续重新计算这两个和是不是效率不够高？可以重新计算新的方差，而不需要每次将所有样本相加、平方等。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|984076|如下所示：|984077|Sum(X%5E2+from+2..21)+=+Sum(X%5E2+from+1..20)+-+X_1%5E2+%2B+X_21%5E2
Sum(X+from+2..21)+=+Sum(X+from+1..20)+-+X_1+%2B+X_21|code-block|syntax|javascript|984078|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|L|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|M|8|@]|9|@]|A|$G|H]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

I guess keeping track of your 20 samples, Sum(X^2 from 1..20), and Sum(X from 1..20) and then successively recomputing the two sums at each iteration isn't efficient enough? It's possible to recompute the new variance without adding up, squaring, etc., all of the samples each time.

As in:

<pre><code>Sum(X^2 from 2..21) = Sum(X^2 from 1..20) - X_1^2 + X_21^2
Sum(X from 2..21) = Sum(X from 1..20) - X_1 + X_21
</code></pre>

blocks|key|769069|text|我一直在处理同样的问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|769070|Mean很容易迭代计算，但您需要在循环缓冲区中保存值的完整历史记录。|769071|next_index+=+(index+%2B+1)+%25+window_size;++++//+oldest+x+value+is+at+next_index,+wrapping+if+necessary.

new_mean+=+mean+%2B+(x_new+-+xs[next_index])/window_size;|code-block|syntax|javascript|769072|我已经修改了Welford的算法，它适用于我测试过的所有值。|769073|varSum+=+var_sum+%2B+(x_new+-+mean)+*+(x_new+-+new_mean)+-+(xs[next_index]+-+mean)+*+(xs[next_index]+-+new_mean);

xs[next_index]+=+x_new;
index+=+next_index;|769074|要获得当前方差，只需将varSum除以窗口大小：variance+=+varSum+/+window_size;|offset|length|style|CODE|769075|entityMap^0|0|0|0|0|0|O|W|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|V|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|W|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|X|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|Y|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|Z|8|@$O|10|P|11|Q|R]]|9|@]|A|$]]|$1|S|3|-4|5|6|7|12|8|@]|9|@]|A|$]]]|T|$]]

I have been dealing with the same issue.

Mean is simple to compute iteratively, but you need to keep the complete history of values in a circular buffer.

<pre><code>next_index = (index + 1) % window_size; // oldest x value is at next_index, wrapping if necessary.

new_mean = mean + (x_new - xs[next_index])/window_size;
</code></pre>

I have adapted Welford's algorithm and it works for all the values that I have tested with.

<pre><code>varSum = var_sum + (x_new - mean) * (x_new - new_mean) - (xs[next_index] - mean) * (xs[next_index] - new_mean);

xs[next_index] = x_new;
index = next_index;
</code></pre>

To get the current variance just divide varSum by the window size: <code>variance = varSum / window_size;</code>

blocks|key|769090|text|如果你更喜欢代码而不是文字(很大程度上基于DanS的帖子)：http://calcandstuff.blogspot.se/2014/02/rolling-variance-calculation.html|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|769091|public+IEnumerable+RollingSampleVariance(IEnumerable+data,+int+sampleSize)
{
++++double+mean+=+0;
++++double+accVar+=+0;

++++int+n+=+0;
++++var+queue+=+new+Queue(sampleSize);

++++foreach(var+observation+in+data)
++++{
++++++++queue.Enqueue(observation);
++++++++if+(n+<+sampleSize)
++++++++{
++++++++++++//+Calculating+first+variance
++++++++++++n%2B%2B;
++++++++++++double+delta+=+observation+-+mean;
++++++++++++mean+%2B=+delta+/+n;
++++++++++++accVar+%2B=+delta+*+(observation+-+mean);
++++++++}
++++++++else
++++++++{
++++++++++++//+Adjusting+variance
++++++++++++double+then+=+queue.Dequeue();
++++++++++++double+prevMean+=+mean;
++++++++++++mean+%2B=+(observation+-+then)+/+sampleSize;
++++++++++++accVar+%2B=+(observation+-+prevMean)+*+(observation+-+mean)+-+(then+-+prevMean)+*+(then+-+mean);
++++++++}

++++++++if+(n+==+sampleSize)
++++++++++++yield+return+accVar+/+(sampleSize+-+1);
++++}
}|code-block|syntax|javascript|769092|entityMap|0|LINK|mutability|MUTABLE|url|http://calcandstuff.blogspot.se/2014/02/rolling-variance-calculation.html^0|U|21|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

If you prefer code over words (heavily based on DanS' post):
<a href="http://calcandstuff.blogspot.se/2014/02/rolling-variance-calculation.html" rel="noreferrer">http://calcandstuff.blogspot.se/2014/02/rolling-variance-calculation.html</a>

<pre><code>public IEnumerable RollingSampleVariance(IEnumerable data, int sampleSize)
{
 double mean = 0;
 double accVar = 0;

 int n = 0;
 var queue = new Queue(sampleSize);

 foreach(var observation in data)
 {
 queue.Enqueue(observation);
 if (n &lt; sampleSize)
 {
 // Calculating first variance
 n++;
 double delta = observation - mean;
 mean += delta / n;
 accVar += delta * (observation - mean);
 }
 else
 {
 // Adjusting variance
 double then = queue.Dequeue();
 double prevMean = mean;
 mean += (observation - then) / sampleSize;
 accVar += (observation - prevMean) * (observation - mean) - (then - prevMean) * (then - mean);
 }

 if (n == sampleSize)
 yield return accVar / (sampleSize - 1);
 }
}
</code></pre>

blocks|key|769171|text|我知道这个问题有点老生常谈了，但如果其他人对此感兴趣，请遵循python代码。它的灵感来自于johndcook的博客文章，@Joachim的，@DanS的代码和@Jaime的评论。对于较小的数据窗口大小，下面的代码仍然提供了较小的不精确度。好好享受吧。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|769172|from+__future__+import+division
import+collections
import+math


class+RunningStats:
++++def+__init__(self,+WIN_SIZE=20):
++++++++self.n+=+0
++++++++self.mean+=+0
++++++++self.run_var+=+0
++++++++self.WIN_SIZE+=+WIN_SIZE

++++++++self.windows+=+collections.deque(maxlen=WIN_SIZE)

++++def+clear(self):
++++++++self.n+=+0
++++++++self.windows.clear()

++++def+push(self,+x):

++++++++self.windows.append(x)

++++++++if+self.n+<=+self.WIN_SIZE:
++++++++++++#+Calculating+first+variance
++++++++++++self.n+%2B=+1
++++++++++++delta+=+x+-+self.mean
++++++++++++self.mean+%2B=+delta+/+self.n
++++++++++++self.run_var+%2B=+delta+*+(x+-+self.mean)
++++++++else:
++++++++++++#+Adjusting+variance
++++++++++++x_removed+=+self.windows.popleft()
++++++++++++old_m+=+self.mean
++++++++++++self.mean+%2B=+(x+-+x_removed)+/+self.WIN_SIZE
++++++++++++self.run_var+%2B=+(x+%2B+x_removed+-+old_m+-+self.mean)+*+(x+-+x_removed)

++++def+get_mean(self):
++++++++return+self.mean+if+self.n+else+0.0

++++def+get_var(self):
++++++++return+self.run_var+/+(self.WIN_SIZE+-+1)+if+self.n+>+1+else+0.0

++++def+get_std(self):
++++++++return+math.sqrt(self.get_var())

++++def+get_all(self):
++++++++return+list(self.windows)

++++def+__str__(self):
++++++++return+"Current+window+values:+{}".format(list(self.windows))|code-block|syntax|javascript|769173|entityMap|0|LINK|mutability|MUTABLE|url|https://www.johndcook.com/blog/standard_deviation/^0|1A|9|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@$A|R|B|S|1|T]]|C|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|C|$G|H]]|$1|I|3|-4|5|6|7|V|8|@]|9|@]|C|$]]]|J|$K|$5|L|M|N|C|$O|P]]]]

I know this question is old, but in case someone else is interested here follows the python code. It is inspired by <a href="https://www.johndcook.com/blog/standard_deviation/" rel="noreferrer">johndcook</a> blog post, @Joachim's, @DanS's code and @Jaime comments. The code below still gives small imprecisions for small data windows sizes. Enjoy.

<pre><code>from __future__ import division
import collections
import math


class RunningStats:
 def __init__(self, WIN_SIZE=20):
 self.n = 0
 self.mean = 0
 self.run_var = 0
 self.WIN_SIZE = WIN_SIZE

 self.windows = collections.deque(maxlen=WIN_SIZE)

 def clear(self):
 self.n = 0
 self.windows.clear()

 def push(self, x):

 self.windows.append(x)

 if self.n &lt;= self.WIN_SIZE:
 # Calculating first variance
 self.n += 1
 delta = x - self.mean
 self.mean += delta / self.n
 self.run_var += delta * (x - self.mean)
 else:
 # Adjusting variance
 x_removed = self.windows.popleft()
 old_m = self.mean
 self.mean += (x - x_removed) / self.WIN_SIZE
 self.run_var += (x + x_removed - old_m - self.mean) * (x - x_removed)

 def get_mean(self):
 return self.mean if self.n else 0.0

 def get_var(self):
 return self.run_var / (self.WIN_SIZE - 1) if self.n &gt; 1 else 0.0

 def get_std(self):
 return math.sqrt(self.get_var())

 def get_all(self):
 return list(self.windows)

 def __str__(self):
 return "Current window values: {}".format(list(self.windows))
</code></pre>

blocks|key|769230|text|这只是DanS提供的优秀答案的一个小补充。下面的方程用于从窗口中删除最旧的样本并更新均值和方差。例如，如果您想要在输入数据流的右边缘附近获取较小的窗口(即，只删除最旧的窗口样本，而不添加新样本)，这是很有用的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|769231|window_size+-=+1;+%25+decrease+window+size+by+1+sample
new_mean+=+prev_mean+%2B+(prev_mean+-+x_old)+/+window_size
varSum+=+varSum+-+(prev_mean+-+x_old)+*+(new_mean+-+x_old)|code-block|syntax|javascript|769232|这里，x_old是您希望删除的窗口中最旧的示例。|769233|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

This is just a minor addition to the excellent answer provided by DanS. The following equations are for removing the oldest sample from the window and updating the mean and variance. This is useful, for example, if you want to take smaller windows near the right edge of your input data stream (i.e. just remove the oldest window sample without adding a new sample).

<pre><code>window_size -= 1; % decrease window size by 1 sample
new_mean = prev_mean + (prev_mean - x_old) / window_size
varSum = varSum - (prev_mean - x_old) * (new_mean - x_old)
</code></pre>

Here, x_old is the oldest sample in the window you wish to remove.

I'm trying to find an efficient, numerically stable algorithm to calculate a rolling variance (for instance, a variance over a 20-period rolling window). I'm aware of the <a href="http://en.wikipedia.org/wiki/Algorithms_for_calculating_variance#Online_algorithm" rel="noreferrer">Welford algorithm</a> that efficiently computes the running variance for a stream of numbers (it requires only one pass), but am not sure if this can be adapted for a rolling window. I would also like the solution to avoid the accuracy problems discussed at the top of <a href="http://www.johndcook.com/standard_deviation.html" rel="noreferrer">this article</a> by John D. Cook. A solution in any language is fine.

Rolling variance algorithm

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

我正在尝试找到一种有效的、数值稳定的算法来计算滚动方差(例如，20个周期滚动窗口上的方差)。我知道可以有效地计算数字流的运行方差(它只需要一次遍历)，但不确定这是否适用于滚动窗口。我也想要一个解决方案，以避免约翰·D·库克在顶部讨论的准确性问题。任何语言的解决方案都可以。

问滚动方差算法
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问滚动方差算法EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问滚动方差算法
EN