Como calcular a média móvel sem manter a contagem e o total de dados?

Estou tentando encontrar uma maneira de calcular uma média cumulativa móvel sem armazenar a contagem e o total de dados recebidos até agora.

Eu vim com dois algoritmos, mas ambos precisam armazenar a contagem:

• nova média = ((contagem antiga * dados antigos) + próximos dados) / próxima contagem
• nova média = média antiga + (próximos dados - média antiga) / próxima contagem

O problema com esses métodos é que a contagem fica cada vez maior, resultando na perda de precisão na média resultante.

O primeiro método usa a contagem antiga e a próxima, que são obviamente 1 de diferença. Isso me fez pensar que talvez haja uma maneira de remover a contagem, mas infelizmente ainda não a encontrei. Isso me levou um pouco mais longe, resultando no segundo método, mas ainda assim a contagem está presente.

É possível ou estou apenas procurando o impossível?

Você pode simplesmente fazer:

double approxRollingAverage (double avg, double new_sample) {

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

    return avg;
}

Onde Nestá o número de amostras das quais você deseja calcular a média. Observe que esta aproximação é equivalente a uma média móvel exponencial. Veja: Calcular a média móvel / móvel em C ++

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

Isso pressupõe que a contagem mudou apenas em um valor. Caso seja alterado por valores M, então:

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

Esta é a fórmula matemática (acredito que seja a mais eficiente), acredite que você pode fazer mais códigos por conta própria

De um blog sobre a execução de cálculos de variação de amostra, onde a média também é calculada usando o método de Welford :

Pena que não podemos fazer upload de imagens SVG.

Aqui está outra resposta que oferece comentários sobre como a resposta de Muis , Abdullah Al-Ageel e Flip são matematicamente a mesma coisa exceto que escritas de forma diferente.

Claro, temos José Manuel Ramos a análise de explicando como os erros de arredondamento afetam cada um de maneira ligeiramente diferente, mas isso depende da implementação e mudaria com base em como cada resposta foi aplicada ao código.

No entanto, há uma grande diferença

Está no Muis 's N, Flip 's ke Abdullah Al-Ageel 's n. Abdullah Al-Ageel não chega a explicar o que ndeveria ser, mas Ne kdiferem em que Né " o número de amostras em que deseja média ao longo ", enquanto ké a contagem de valores amostrados. (Embora eu tenha dúvidas se ligar para N o número de amostras é preciso.)

E aqui chegamos à resposta abaixo. É essencialmente a mesma velha média móvel exponencial ponderada dos outros, então, se você estiver procurando por uma alternativa, pare aqui.

Média móvel exponencial ponderada

Inicialmente:

average = 0
counter = 0

Para cada valor:

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

A diferença é a min(counter, FACTOR)parte. Isso é o mesmo que dizer min(Flip's k, Muis's N).

FACTORé uma constante que afeta a rapidez com que a média "alcança" a tendência mais recente. Quanto menor o número, mais rápido. (Em 1não é mais uma média e apenas se torna o valor mais recente).

Esta resposta requer o contador em execução counter. Se for problemático, o min(counter, FACTOR)pode ser substituído por just FACTOR, transformando-o na resposta de Muis . O problema em fazer isso é que a média móvel é afetada por tudo o que averageé inicializado. Se foi inicializado para0 , esse zero pode levar muito tempo para sair da média.

Como fica parecendo

A resposta de Flip é computacionalmente mais consistente do que a de Muis.

Usando o formato de número duplo, você pode ver o problema de arredondamento na abordagem de Muis:

Quando você divide e subtrai, um arredondamento aparece no valor armazenado anterior, alterando-o.

No entanto, a abordagem Flip preserva o valor armazenado e reduz o número de divisões, portanto, reduzindo o arredondamento e minimizando o erro propagado para o valor armazenado. Adicionar apenas trará arredondamentos se houver algo a adicionar (quando N é grande, não há nada a adicionar)

Essas mudanças são notáveis ​​quando você faz com que uma média de valores grandes tenda a sua média para zero.

Eu mostro os resultados usando um programa de planilha:

Em primeiro lugar, os resultados obtidos:

As colunas A e B são os valores n e X_n, respectivamente.

A coluna C é a abordagem Flip, e a coluna D é a abordagem Muis, o resultado armazenado na média. A coluna E corresponde ao valor médio usado no cálculo.

Um gráfico que mostra a média dos valores pares é o próximo:

Como você pode ver, há grandes diferenças entre as duas abordagens.

Um exemplo usando javascript, para comparação:

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);
})();

Em Java8:

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

você também tem IntSummaryStatistics, DoubleSummaryStatistics...

Uma solução Python bacana com base nas respostas acima:

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)

uso:

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