Jak obliczyć średnią ruchomą bez zachowywania liczby i sumy danych?

Próbuję znaleźć sposób na obliczenie ruchomej średniej skumulowanej bez przechowywania liczby i łącznych danych, które zostały do ​​tej pory odebrane.

Wymyśliłem dwa algorytmy, ale oba muszą przechowywać liczbę:

• nowa średnia = ((stara liczba * stare dane) + następne dane) / następna liczba
• nowa średnia = stara średnia + (następne dane - stara średnia) / następny licznik

Problem z tymi metodami polega na tym, że liczba staje się coraz większa, co powoduje utratę precyzji w wynikowej średniej.

Pierwsza metoda używa starego liczenia i następnego liczenia, które oczywiście różnią się o 1. To sprawiło, że pomyślałem, że być może istnieje sposób na usunięcie liczby, ale niestety jeszcze go nie znalazłem. To jednak doprowadziło mnie nieco dalej, w wyniku czego powstała druga metoda, ale liczba nadal jest obecna.

Czy to możliwe, czy po prostu szukam niemożliwego?

Możesz po prostu zrobić:

double approxRollingAverage (double avg, double new_sample) {

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

    return avg;
}

Gdzie Njest liczba próbek, dla których chcesz przeprowadzić średnią. Należy zauważyć, że to przybliżenie jest równoważne wykładniczej średniej ruchomej. Zobacz: Obliczanie średniej kroczącej / ruchomej w C ++

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

Zakłada się, że liczba zmieniła się tylko o jedną wartość. W przypadku zmiany wartości M to:

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

To jest wzór matematyczny (uważam, że jest najbardziej efektywny), wierzę, że możesz samodzielnie wykonać dalsze kodowanie

Z bloga na temat przeprowadzania przykładowych obliczeń wariancji, gdzie średnia jest również obliczana metodą Welforda :

Szkoda, że ​​nie możemy przesyłać obrazów SVG.

Oto kolejna odpowiedź zawierająca komentarz dotyczący tego , jak odpowiedź Muis , Abdullah Al-Ageel i Flip są matematycznie tym samym, z wyjątkiem tego , że są napisane inaczej.

Jasne, mamy analizę José Manuela Ramosa wyjaśniającą, jak błędy zaokrąglania wpływają na każdy z nich nieco inaczej, ale jest to zależne od implementacji i zmieni się w zależności od tego, jak każda odpowiedź została zastosowana do kodu.

Jest jednak dość duża różnica

Jest w Muis 's N, flip ' s k, a Abdullah Al-Ageel „s n. Abdullah Al-Ageel nie do końca wyjaśnić, co npowinno być, ale Ni króżnią się tym, że Njest „ liczba próbek, w których mają być średnio ponad ”, a kjest liczba wartości próbki. (Chociaż mam wątpliwości, czy podanie N liczby próbek jest dokładne.)

I tutaj dochodzimy do odpowiedzi poniżej. Zasadniczo jest to ta sama stara wykładnicza ważona średnia krocząca, co pozostałe, więc jeśli szukałeś alternatywy, zatrzymaj się tutaj.

Wykładnicza ważona średnia ruchoma

Początkowo:

average = 0
counter = 0

Dla każdej wartości:

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

Różnica jest min(counter, FACTOR)częścią. To to samo, co mówienie min(Flip's k, Muis's N).

FACTORto stała, która wpływa na to, jak szybko średnia „dogania” najnowszy trend. Im mniejsza liczba, tym szybciej. (W 1tym momencie nie jest już średnią i staje się najnowszą wartością).

Ta odpowiedź wymaga działającego licznika counter. Jeśli jest to problematyczne, min(counter, FACTOR)można je zastąpić just FACTOR, zamieniając je w odpowiedź Muis . Problem z robieniem tego polega na tym, że na średnią ruchomą wpływa to, co averagejest parafowane. Jeśli zostało zainicjowane 0, to zero może zająć dużo czasu, zanim wyjdzie ze średniej.

Jak to się kończy

Odpowiedź Flip jest obliczeniowo bardziej spójna niż odpowiedź Muis.

Używając formatu podwójnej liczby, możesz zobaczyć problem zaokrągleń w podejściu Muis:

Kiedy dzielisz i odejmujesz, zaokrąglenie pojawia się w poprzedniej zapisanej wartości, zmieniając ją.

Jednak podejście odwracania zachowuje przechowywaną wartość i zmniejsza liczbę podziałów, a tym samym zmniejsza zaokrąglenie i minimalizuje błąd propagowany do przechowywanej wartości. Dodanie tylko spowoduje zaokrąglenia, jeśli jest coś do dodania (gdy N jest duże, nie ma nic do dodania)

Te zmiany są niezwykłe, gdy uśredniamy duże wartości, które mają tendencję do zerowania.

Wyniki pokazuję za pomocą arkusza kalkulacyjnego:

Po pierwsze, uzyskane wyniki:

Kolumny A i B to odpowiednio wartości n i X_n.

Kolumna C to podejście Flip, a kolumna D to podejście Muis, wynik przechowywany w średniej. Kolumna E odpowiada średniej wartości użytej w obliczeniach.

Wykres przedstawiający średnią parzystych wartości jest następny:

Jak widać, między oboma podejściami istnieją duże różnice.

Przykład wykorzystujący javascript dla porównania:

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

W Javie8:

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

masz również IntSummaryStatistics, DoubleSummaryStatistics...

Zgrabne rozwiązanie Pythona oparte na powyższych odpowiedziach:

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)

stosowanie:

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