Bagaimana cara menghitung rata-rata bergerak tanpa menyimpan hitungan dan total data?

Saya mencoba menemukan cara untuk menghitung rata-rata kumulatif bergerak tanpa menyimpan jumlah dan total data yang diterima sejauh ini.

Saya menemukan dua algoritme tetapi keduanya perlu menyimpan hitungan:

• rata-rata baru = ((hitungan lama * data lama) + data berikutnya) / hitungan berikutnya
• rata-rata baru = rata-rata lama + (data berikutnya - rata-rata lama) / hitungan berikutnya

Masalah dengan metode ini adalah bahwa hitungan semakin besar dan mengakibatkan hilangnya presisi dalam rata-rata yang dihasilkan.

Cara pertama menggunakan hitungan lama dan hitungan berikutnya yang jelas terpisah 1. Ini membuat saya berpikir bahwa mungkin ada cara untuk menghapus hitungan tetapi sayangnya saya belum menemukannya. Itu membuat saya sedikit lebih jauh, menghasilkan metode kedua tetapi masih ada hitungan.

Apakah itu mungkin, atau apakah saya hanya mencari yang tidak mungkin?

Anda cukup melakukan:

double approxRollingAverage (double avg, double new_sample) {

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

    return avg;
}

Di mana Njumlah sampel yang ingin Anda ratakan. Perhatikan bahwa perkiraan ini setara dengan rata-rata bergerak eksponensial. Lihat: Hitung rolling / moving average dalam C ++

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

Ini mengasumsikan hitungan hanya diubah oleh satu nilai. Jika diubah oleh nilai M maka:

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

Ini adalah rumus matematika (saya yakin yang paling efisien), percayalah Anda dapat membuat kode lebih lanjut sendiri

Dari blog tentang menjalankan penghitungan varians sampel, di mana mean juga dihitung menggunakan metode Welford :

Sayang sekali kami tidak dapat mengunggah gambar SVG.

Berikut lagi jawabannya korban komentar tentang bagaimana Muis , Abdullah Al-Ageel dan flip jawaban 's adalah semua matematis hal yang sama kecuali ditulis berbeda.

Tentu, kami memiliki analisis José Manuel Ramos yang menjelaskan bagaimana kesalahan pembulatan memengaruhi masing-masing sedikit berbeda, tetapi itu bergantung pada penerapan dan akan berubah berdasarkan bagaimana setiap jawaban diterapkan ke kode.

Namun ada perbedaan yang cukup besar

Ada di Muis 's N, Flip 's k, dan Abdullah Al-Ageel 's n. Abdullah Al-Ageel tidak cukup menjelaskan apa yang nseharusnya, tetapi Ndan kperbedaannya Nadalah " jumlah sampel di mana Anda ingin rata-rata lebih " sedangkan kjumlah nilai sampel. (Meskipun saya ragu apakah memanggil N jumlah sampel itu akurat.)

Dan inilah jawabannya di bawah ini. Ini pada dasarnya adalah rata-rata bergerak tertimbang eksponensial lama yang sama dengan yang lain, jadi jika Anda mencari alternatif, berhentilah di sini.

Rata-rata bergerak tertimbang eksponensial

Mulanya:

average = 0
counter = 0

Untuk setiap nilai:

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

Perbedaannya adalah min(counter, FACTOR)bagiannya. Ini sama dengan mengatakanmin(Flip's k, Muis's N) .

FACTORadalah konstanta yang memengaruhi seberapa cepat rata-rata "mengejar" tren terbaru. Semakin kecil angkanya semakin cepat. ( 1Ini bukan lagi rata-rata dan hanya menjadi nilai terbaru.)

Jawaban ini membutuhkan penghitung berjalan counter. Jika bermasalah, min(counter, FACTOR)bisa diganti dengan just FACTOR, mengubahnya menjadi jawaban Muis . Masalah dengan melakukan ini adalah rata-rata bergerak dipengaruhi oleh apa pun averageyang dimulai. Jika itu diinisialisasi ke0 , nol itu bisa memakan waktu lama untuk bekerja di luar rata-rata.

Bagaimana hasilnya nanti

Jawaban Flip secara komputasi lebih konsisten daripada jawaban Muis.

Menggunakan format angka ganda, Anda bisa melihat masalah pembulatan dalam pendekatan Muis:

Saat Anda membagi dan mengurangi, pembulatan muncul di nilai yang disimpan sebelumnya, mengubahnya.

Namun, pendekatan Flip mempertahankan nilai yang disimpan dan mengurangi jumlah divisi, karenanya, mengurangi pembulatan, dan meminimalkan kesalahan yang disebarkan ke nilai yang disimpan. Menambahkan hanya akan memunculkan pembulatan jika ada sesuatu untuk ditambahkan (ketika N besar, tidak ada yang ditambahkan)

Perubahan tersebut luar biasa ketika Anda membuat rata-rata nilai yang besar cenderung ke nol.

Saya tunjukkan hasilnya menggunakan program spreadsheet:

Pertama, hasil yang diperoleh:

Kolom A dan B masing-masing adalah nilai n dan X_n.

Kolom C adalah pendekatan Flip, dan D adalah pendekatan Muis, hasilnya disimpan dalam mean. Kolom E sesuai dengan nilai media yang digunakan dalam perhitungan.

Grafik yang menunjukkan rata-rata nilai genap adalah yang berikutnya:

Seperti yang Anda lihat, ada perbedaan besar antara kedua pendekatan tersebut.

Contoh penggunaan javascript, sebagai perbandingan:

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

Di Java8:

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

kamu juga punya IntSummaryStatistics, DoubleSummaryStatistics...

Solusi Python yang rapi berdasarkan jawaban di atas:

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)

pemakaian:

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