Wie berechnet man den gleitenden Durchschnitt, ohne die Anzahl und die Datensumme beizubehalten?

Ich versuche einen Weg zu finden, um einen gleitenden kumulativen Durchschnitt zu berechnen, ohne die Anzahl und die Gesamtdaten zu speichern, die bisher empfangen wurden.

Ich habe zwei Algorithmen entwickelt, aber beide müssen die Anzahl speichern:

• neuer Durchschnitt = ((alte Zählung * alte Daten) + nächste Daten) / nächste Zählung
• neuer Durchschnitt = alter Durchschnitt + (nächste Daten - alter Durchschnitt) / nächste Zählung

Das Problem bei diesen Methoden ist, dass die Anzahl immer größer wird, was zu einem Genauigkeitsverlust im resultierenden Durchschnitt führt.

Die erste Methode verwendet die alte und die nächste Zählung, die offensichtlich 1 voneinander entfernt sind. Dies brachte mich zu dem Gedanken, dass es vielleicht eine Möglichkeit gibt, die Zählung zu entfernen, aber leider habe ich sie noch nicht gefunden. Es hat mich zwar ein bisschen weiter gebracht, was zur zweiten Methode führte, aber die Anzahl ist immer noch vorhanden.

Ist es möglich oder suche ich nur das Unmögliche?

Sie können einfach tun:

double approxRollingAverage (double avg, double new_sample) {

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

    return avg;
}

Wo Nist die Anzahl der Stichproben, über die Sie einen Durchschnitt bilden möchten? Beachten Sie, dass diese Annäherung einem exponentiellen gleitenden Durchschnitt entspricht. Siehe: Berechnen Sie den gleitenden / gleitenden Durchschnitt in C ++

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

Dies setzt voraus, dass sich die Anzahl nur um einen Wert ändert. Falls es um M Werte geändert wird, dann:

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

Dies ist die mathematische Formel (ich glaube die effizienteste). Glauben Sie, dass Sie selbst weiteren Code erstellen können

Aus einem Blog über das Ausführen von Stichprobenvarianzberechnungen, in dem der Mittelwert auch nach der Welford-Methode berechnet wird :

Schade, dass wir keine SVG-Bilder hochladen können.

Hier ist noch eine weitere Antwort Angebot Kommentierung wie Muis , Abdullah Al-Ageel und Flip ‚s Antwort sind alle mathematisch die gleiche Sache außer dass sie unterschiedlich geschrieben sind.

Sicher, wir haben José Manuel Ramos 'Analyse, die erklärt, wie sich Rundungsfehler geringfügig voneinander auswirken, aber das hängt von der Implementierung ab und würde sich ändern, je nachdem, wie jede Antwort auf Code angewendet wurde.

Es gibt jedoch einen ziemlich großen Unterschied

Es ist in Muis 's N, Flip ' s k, und Abdullah Al-Ageel ‚s n. Abdullah Al-Ageel nicht ganz erklären , was nsein sollte, aber Nund kunterscheiden sich dadurch , dass Nist „ die Anzahl der Proben , bei denen Sie Durchschnitt wollen über “ , während kdie Anzahl der abgetasteten Werte. (Obwohl ich Zweifel habe, ob das Aufrufen N der Anzahl der Proben korrekt ist.)

Und hier kommen wir zur Antwort unten. Es ist im Wesentlichen der gleiche alte exponentiell gewichtete gleitende Durchschnitt wie die anderen. Wenn Sie also nach einer Alternative suchen, hören Sie hier auf.

Exponentiell gewichteter gleitender Durchschnitt

Anfänglich:

average = 0
counter = 0

Für jeden Wert:

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

Der Unterschied ist der min(counter, FACTOR)Teil. Dies ist das gleiche wie zu sagenmin(Flip's k, Muis's N) .

FACTORist eine Konstante, die beeinflusst, wie schnell der Durchschnitt den neuesten Trend "einholt". Je kleiner die Zahl, desto schneller. ( 1Es ist kein Durchschnitt mehr und wird nur zum neuesten Wert.)

Diese Antwort erfordert den laufenden Zähler counter. Wenn es problematisch ist, min(counter, FACTOR)kann das durch just ersetzt werden FACTOR, was es zu Muis 'Antwort macht. Das Problem dabei ist, dass der gleitende Durchschnitt von allem beeinflusst wird, was averageinitiiert wurde. Wenn es auf initialisiert 0wurde, kann es lange dauern, bis sich diese Null aus dem Durchschnitt herausarbeitet.

Wie es am Ende aussieht

Die Antwort von Flip ist rechnerisch konsistenter als die von Muis.

Bei Verwendung des Doppelnummernformats konnten Sie das Rundungsproblem im Muis-Ansatz erkennen:

Wenn Sie dividieren und subtrahieren, wird im vorherigen gespeicherten Wert eine Rundung angezeigt, die sich ändert.

Der Flip-Ansatz behält jedoch den gespeicherten Wert bei und verringert die Anzahl der Teilungen, wodurch die Rundung verringert und der auf den gespeicherten Wert übertragene Fehler minimiert wird. Wenn Sie nur hinzufügen, werden Rundungen angezeigt, wenn etwas hinzugefügt werden muss (wenn N groß ist, gibt es nichts hinzuzufügen).

Diese Änderungen sind bemerkenswert, wenn Sie einen Mittelwert aus großen Werten erstellen, deren Mittelwert gegen Null tendiert.

Ich zeige Ihnen die Ergebnisse mit einem Tabellenkalkulationsprogramm:

Erstens wurden die Ergebnisse erhalten:

Die Spalten A und B sind die Werte n und X_n.

Die C-Spalte ist der Flip-Ansatz und die D-Spalte ist der Muis-Ansatz, das Ergebnis wird im Mittelwert gespeichert. Die Spalte E entspricht dem bei der Berechnung verwendeten Mittelwert.

Ein Diagramm, das den Mittelwert der geraden Werte zeigt, ist das nächste:

Wie Sie sehen können, gibt es große Unterschiede zwischen beiden Ansätzen.

Ein Beispiel mit Javascript zum Vergleich:

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

Sie haben auch IntSummaryStatistics, DoubleSummaryStatistics...

Eine nette Python-Lösung basierend auf den obigen Antworten:

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)

Verwendung:

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