Как рассчитать скользящее среднее без учета подсчета и итоговых данных?

Я пытаюсь найти способ вычислить скользящее кумулятивное среднее без сохранения количества и общих данных, полученных на данный момент.

Я придумал два алгоритма, но оба должны хранить счетчик:

• новое среднее значение = ((старое количество * старые данные) + следующие данные) / следующее количество
• новое среднее = старое среднее + (следующие данные - старое среднее) / следующий счет

Проблема с этими методами заключается в том, что счет становится все больше и больше, что приводит к потере точности получаемого среднего.

Первый метод использует старый счетчик и следующий счет, которые, очевидно, разделены на 1. Это заставило меня подумать, что, возможно, есть способ удалить счетчик, но, к сожалению, я его еще не нашел. Это действительно продвинуло меня немного дальше, в результате появился второй метод, но счетчик все еще присутствует.

Возможно ли это, или я просто ищу невозможное?

Вы можете просто сделать:

double approxRollingAverage (double avg, double new_sample) {

    avg -= avg / N;
    avg += new_sample / N;

    return avg;
}

Где Nколичество образцов, по которым вы хотите усреднить. Обратите внимание, что это приближение эквивалентно экспоненциальной скользящей средней. См .: Расчет скользящего / скользящего среднего в C ++

New average = old average * (n-1)/n + new value /n

Предполагается, что счетчик изменился только на одно значение. В случае его изменения на M значения:

new average = old average * (n-len(M))/n + (sum of values in M)/n).

Это математическая формула (я считаю, что она наиболее эффективная), полагаю, вы можете делать дальнейший код самостоятельно.

Из блога о выполнении выборочных расчетов дисперсии, где среднее также вычисляется с использованием метода Велфорда :

Жаль, что мы не можем загружать изображения SVG.

Вот еще один ответ предложение комментарии о том , как MUIS , Абдуллы Аль-Ageel и Флип ответ «сек являются все математически то же самое , за исключением того, написаны по- разному.

Конечно, у нас есть Хосе Мануэль Рамос анализ , объясняющий, как ошибки округления влияют на каждую по-своему, но это зависит от реализации и будет меняться в зависимости от того, как каждый ответ был применен к коду.

Однако есть довольно большая разница

Это в MUIS 's N, Флип ' s k, и Абдулла аль-Ageel «s n. Абдулла Аль-Агил не совсем объясняет, что nдолжно быть, но Nи kотличается в этомN это « число выборок , где вы хотите , чтобы в среднем за » , а kявляется подсчет значений выборки. (Хотя я сомневаюсь в точности N определения количества образцов .)

И вот мы подходим к ответу ниже. По сути, это та же старая экспоненциально взвешенная скользящая средняя, что и другие, поэтому, если вы искали альтернативу, остановитесь прямо здесь.

Экспоненциально взвешенное скользящее среднее

Первоначально:

average = 0
counter = 0

Для каждого значения:

counter += 1
average = average + (value - average) / min(counter, FACTOR)

Разница в том min(counter, FACTOR) . Это то же самое, что сказать min(Flip's k, Muis's N).

FACTOR- константа, которая влияет на то, как быстро среднее значение «догоняет» последний тренд. Чем меньше число, тем быстрее. (Сейчас 1это уже не среднее значение, а просто последнее значение.)

Для этого ответа требуется счетчик хода counter. Если проблематично, его min(counter, FACTOR)можно заменить просто FACTOR, превратив его в ответ Муиса . Проблема с этим заключается в том, что на скользящую среднюю влияют всеaverage инициализировано. Если он был инициализирован0 , этот ноль может занять много времени, чтобы выйти из среднего значения.

Как это в итоге выглядит

Ответ Flip в вычислительном отношении более согласован, чем ответ Muis.

Используя формат двойного числа, вы могли увидеть проблему округления в подходе Muis:

Когда вы делите и вычитаете, округление появляется в предыдущем сохраненном значении, изменяя его.

Однако подход Flip сохраняет сохраненное значение и уменьшает количество делений, следовательно, уменьшает округление и минимизирует ошибку, распространяемую на сохраненное значение. Добавление только приведет к округлению, если есть что добавить (когда N большое, добавлять нечего)

Эти изменения замечательны, когда вы стремитесь к нулю среднего значения больших значений.

Я показываю вам результаты с помощью программы для работы с электронными таблицами:

Во-первых, полученные результаты:

Столбцы A и B представляют собой значения n и X_n соответственно.

Столбец C - это подход Flip, а столбец D - подход Muis, результат сохраняется в виде среднего. Столбец E соответствует среднему значению, используемому в вычислениях.

График, показывающий среднее четных значений, является следующим:

Как видите, между обоими подходами есть большие различия.

Пример использования javascript для сравнения:

https://jsfiddle.net/drzaus/Lxsa4rpz/

function calcNormalAvg(list) {
    // sum(list) / len(list)
    return list.reduce(function(a, b) { return a + b; }) / list.length;
}
function calcRunningAvg(previousAverage, currentNumber, index) {
    // [ avg' * (n-1) + x ] / n
    return ( previousAverage * (index - 1) + currentNumber ) / index;
}

(function(){
  // populate base list
var list = [];
function getSeedNumber() { return Math.random()*100; }
for(var i = 0; i < 50; i++) list.push( getSeedNumber() );

  // our calculation functions, for comparison
function calcNormalAvg(list) {
  	// sum(list) / len(list)
	return list.reduce(function(a, b) { return a + b; }) / list.length;
}
function calcRunningAvg(previousAverage, currentNumber, index) {
  	// [ avg' * (n-1) + x ] / n
	return ( previousAverage * (index - 1) + currentNumber ) / index;
}
  function calcMovingAvg(accumulator, new_value, alpha) {
  	return (alpha * new_value) + (1.0 - alpha) * accumulator;
}

  // start our baseline
var baseAvg = calcNormalAvg(list);
var runningAvg = baseAvg, movingAvg = baseAvg;
console.log('base avg: %d', baseAvg);
  
  var okay = true;
  
  // table of output, cleaner console view
  var results = [];

  // add 10 more numbers to the list and compare calculations
for(var n = list.length, i = 0; i < 10; i++, n++) {
	var newNumber = getSeedNumber();

	runningAvg = calcRunningAvg(runningAvg, newNumber, n+1);
	movingAvg = calcMovingAvg(movingAvg, newNumber, 1/(n+1));

	list.push(newNumber);
	baseAvg = calcNormalAvg(list);

	// assert and inspect
	console.log('added [%d] to list at pos %d, running avg = %d vs. regular avg = %d (%s), vs. moving avg = %d (%s)'
		, newNumber, list.length, runningAvg, baseAvg, runningAvg == baseAvg, movingAvg, movingAvg == baseAvg
	)
results.push( {x: newNumber, n:list.length, regular: baseAvg, running: runningAvg, moving: movingAvg, eqRun: baseAvg == runningAvg, eqMov: baseAvg == movingAvg } );

if(runningAvg != baseAvg) console.warn('Fail!');
okay = okay && (runningAvg == baseAvg);    
}
  
  console.log('Everything matched for running avg? %s', okay);
  if(console.table) console.table(results);
})();

В Java8:

LongSummaryStatistics movingAverage = new LongSummaryStatistics();
movingAverage.accept(new data);
...
average = movingAverage.getAverage();

у вас есть также IntSummaryStatistics, DoubleSummaryStatistics...

Изящное решение Python, основанное на приведенных выше ответах:

class RunningAverage():
    def __init__(self):
        self.average = 0
        self.n = 0
        
    def __call__(self, new_value):
        self.n += 1
        self.average = (self.average * (self.n-1) + new_value) / self.n 
        
    def __float__(self):
        return self.average
    
    def __repr__(self):
        return "average: " + str(self.average)

использование:

x = RunningAverage()
x(0)
x(2)
x(4)
print(x)