Come calcolare la media mobile senza mantenere il conteggio e il totale dei dati?

Sto cercando di trovare un modo per calcolare una media cumulativa mobile senza memorizzare il conteggio e i dati totali ricevuti finora.

Ho trovato due algoritmi ma entrambi devono memorizzare il conteggio:

• nuova media = ((vecchio conteggio * vecchi dati) + dati successivi) / conteggio successivo
• nuova media = vecchia media + (dati successivi - vecchia media) / conteggio successivo

Il problema con questi metodi è che il conteggio diventa sempre più grande con conseguente perdita di precisione nella media risultante.

Il primo metodo utilizza il vecchio conteggio e il successivo conteggio che sono ovviamente 1 separati. Questo mi ha fatto pensare che forse c'è un modo per rimuovere il conteggio ma purtroppo non l'ho ancora trovato. Tuttavia, mi ha portato un po 'oltre, risultando nel secondo metodo ma il conteggio è ancora presente.

È possibile o sto solo cercando l'impossibile?

Puoi semplicemente fare:

double approxRollingAverage (double avg, double new_sample) {

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

    return avg;
}

Dov'è Nil numero di campioni su cui vuoi calcolare la media. Nota che questa approssimazione è equivalente a una media mobile esponenziale. Vedi: Calcola la media mobile / mobile in C ++

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

Ciò presuppone che il conteggio sia cambiato solo di un valore. Nel caso in cui venga modificato dai valori M, allora:

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

Questa è la formula matematica (credo la più efficiente), credo che tu possa fare ulteriore codice da solo

Da un blog sull'esecuzione di calcoli della varianza campione, in cui anche la media viene calcolata utilizzando il metodo di Welford :

Peccato che non possiamo caricare immagini SVG.

Ecco un'altra risposta che offre commenti su come Muis , Abdullah Al-Ageel e la risposta di Flip siano matematicamente la stessa cosa tranne che scritte in modo diverso.

Certo, abbiamo José Manuel Ramos analisi di che spiega come gli errori di arrotondamento influiscano su ciascuno in modo leggermente diverso, ma dipende dall'implementazione e cambierebbe in base a come ogni risposta è stata applicata al codice.

C'è tuttavia una differenza piuttosto grande

È in Muis 's N, Flip 's ke Abdullah Al-Ageel 's n. Abdullah Al-Ageel non spiega esattamente cosa ndovrebbe essere, ma Nek differisce in questo Nè " il numero di campioni su cui si desidera fare la media " mentre kè il conteggio dei valori campionati. (Anche se ho dubbi sul fatto che chiamare N il numero di campioni sia accurata.)

E qui arriviamo alla risposta di seguito. È essenzialmente la stessa vecchia media mobile ponderata esponenziale degli altri, quindi se stavi cercando un'alternativa, fermati qui.

Media mobile ponderata esponenziale

inizialmente:

average = 0
counter = 0

Per ogni valore:

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

La differenza è il file min(counter, FACTOR) parte. Questo è come dire min(Flip's k, Muis's N).

FACTORè una costante che influisce sulla velocità con cui la media "raggiunge" l'ultima tendenza. Più piccolo è il numero, più velocemente. (A1 Non è più una media e diventa solo l'ultimo valore.)

Questa risposta richiede il contatore in esecuzione counter. Se problematico, min(counter, FACTOR)può essere sostituito con solo FACTOR, trasformandolo nella risposta di Muis . Il problema con questa operazione è che la media mobile è influenzata da qualsiasi cosaaverage venga inizializzata. Se è stato inizializzato su 0, quello zero può impiegare molto tempo per uscire dalla media.

Come va a finire

La risposta di Flip è computazionalmente più coerente di quella di Muis.

Utilizzando il formato doppio numero, potresti vedere il problema dell'arrotondamento nell'approccio Muis:

Quando si divide e si sottrae, viene visualizzato un arrotondamento nel valore memorizzato precedente, modificandolo.

Tuttavia, l'approccio Flip preserva il valore memorizzato e riduce il numero di divisioni, riducendo quindi l'arrotondamento e minimizzando l'errore propagato al valore memorizzato. L'aggiunta solo farà apparire gli arrotondamenti se c'è qualcosa da aggiungere (quando N è grande, non c'è niente da aggiungere)

Questi cambiamenti sono notevoli quando si fa in modo che una media di valori grandi tenda la loro media a zero.

Ti mostro i risultati utilizzando un programma di fogli di calcolo:

In primo luogo, i risultati ottenuti:

Le colonne A e B sono rispettivamente i valori ne X_n.

La colonna C è l'approccio Flip e quella D è l'approccio Muis, il risultato memorizzato nella media. La colonna E corrisponde al valore medio utilizzato nel calcolo.

Un grafico che mostra la media dei valori pari è il prossimo:

Come puoi vedere, ci sono grandi differenze tra i due approcci.

Un esempio utilizzando javascript, per il confronto:

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

In Java8:

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

hai anche IntSummaryStatistics, DoubleSummaryStatistics...

Una soluzione Python pulita basata sulle risposte precedenti:

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)

utilizzo:

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