Sayım ve veri toplamını tutmadan hareketli ortalama nasıl hesaplanır?

Şimdiye kadar alınan sayımı ve toplam verileri saklamadan hareketli bir kümülatif ortalamayı hesaplamanın bir yolunu bulmaya çalışıyorum.

İki algoritma buldum ama her ikisinin de sayımı kaydetmesi gerekiyor:

• yeni ortalama = ((eski sayım * eski veri) + sonraki veri) / sonraki sayı
• yeni ortalama = eski ortalama + (sonraki veri - eski ortalama) / sonraki sayı

Bu yöntemlerle ilgili sorun, sayının gittikçe artması ve sonuçta ortaya çıkan ortalamada hassasiyetin kaybolmasıdır.

İlk yöntem, açıkça 1 ayrı olan eski sayımı ve sonraki sayımı kullanır. Bu, sayımı kaldırmanın belki bir yolu olduğunu düşünmeme neden oldu ama maalesef henüz bulamadım. Yine de beni biraz daha ileriye götürdü, ikinci yöntemle sonuçlandı ama yine de sayım var.

Mümkün mü yoksa imkansızı mı arıyorum?

Şunları yapabilirsiniz:

double approxRollingAverage (double avg, double new_sample) {

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

    return avg;
}

Nerede Nortalama over istediğiniz örneklerin sayısıdır. Bu yaklaşımın üstel hareketli ortalamaya eşdeğer olduğuna dikkat edin. Bakınız: C ++ 'da yuvarlanan / hareketli ortalamayı hesaplayın

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

Bu, sayının yalnızca bir değerle değiştiğini varsayar. M değerleri ile değiştirilmesi durumunda:

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

Bu matematiksel formüldür (en verimli olanına inanıyorum), kendi başınıza daha fazla kod yazabileceğinize inanıyorum

Gönderen bir blog ortalama da kullanılarak hesaplanır örnek varyansı hesaplamalar, çalıştıran Welford yöntemini :

Ne yazık ki SVG resimleri yükleyemiyoruz.

İşte nasıl bir başka cevap sunan yorumlanıyorsa Muis , Abdullah Al-Ageel ve Ayaklı 'ın cevabı olan tüm matematiksel olarak aynı şey farklı yazılı hariç.

Elbette, yuvarlama hatalarının her birini nasıl biraz farklı etkilediğini açıklayan José Manuel Ramos'un analizine sahibiz , ancak bu uygulamaya bağlıdır ve her yanıtın koda nasıl uygulandığına bağlı olarak değişecektir.

Ancak oldukça büyük bir fark var

Bu öyle Muis 'ın N, Ayaklı ' ın kve Abdullah Al-Ageel 'ın n. Abdullah Al-Ageel oldukça ne açıklamıyor nolmalı, ama Nve kbu farklılık Nolduğunu " baştan ortalama istediğiniz örneklerin sayısı " ise körneklenmiş değerler sayısıdır. ( N Numune sayısını aramanın doğru olup olmadığına dair şüphelerim olsa da .)

Ve burada aşağıdaki cevaba geliyoruz. Esasen diğerleriyle aynı eski üstel ağırlıklı hareketli ortalamadır , bu yüzden bir alternatif arıyorsanız, burada durun.

Üstel ağırlıklı hareketli ortalama

Başlangıçta:

average = 0
counter = 0

Her değer için:

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

Aradaki fark min(counter, FACTOR)kısımdır. Bu söylemekle aynı şey min(Flip's k, Muis's N).

FACTORortalamanın en son trendi ne kadar hızlı "yakaladığını" etkileyen bir sabittir. Sayı ne kadar küçükse o kadar hızlı. ( 1Artık ortalama değil ve en son değer haline geliyor.)

Bu cevap, çalışan sayaç gerektirir counter. Sorunlu ise min(counter, FACTOR)sadece değiştirilebilir FACTOR, dönüştürerek Muis 'ın cevabı. Bunu yapmanın sorunu, hareketli ortalamanın başlatılan şeyden etkilenmesidir average. Eğer ile başlatılmışsa 0, bu sıfırın ortalamanın dışına çıkması uzun zaman alabilir.

Nasıl görünüyor

Flip'in cevabı sayısal olarak Muis'den daha tutarlıdır.

Çift sayı formatını kullanarak, Muis yaklaşımındaki yuvarlama problemini görebilirsiniz:

Böldüğünüzde ve çıkardığınızda, önceki saklanan değerde onu değiştiren bir yuvarlama görünür.

Bununla birlikte, Flip yaklaşımı saklanan değeri korur ve bölme sayısını azaltır, dolayısıyla yuvarlamayı azaltır ve depolanan değere yayılan hatayı en aza indirir. Yalnızca eklemek, eklenecek bir şey varsa yuvarlamaları getirecektir (N büyük olduğunda, eklenecek bir şey yoktur)

Bu değişiklikler, büyük değerlerin ortalamasını sıfıra çekme eğiliminde olduğunu düşündüğünüzde dikkat çekicidir.

Bir elektronik tablo programı kullanarak size sonuçları gösteriyorum:

İlk olarak, elde edilen sonuçlar:

A ve B sütunları sırasıyla n ve X_n değerleridir.

C sütunu Flip yaklaşımıdır ve D bir Muis yaklaşımıdır, sonuç ortalamada saklanır. E sütunu, hesaplamada kullanılan orta değere karşılık gelir.

Sıradaki çift değerlerin ortalamasını gösteren bir grafiktir:

Gördüğünüz gibi, her iki yaklaşım arasında büyük farklılıklar var.

Karşılaştırma için javascript kullanan bir örnek:

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

Java8'de:

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

ayrıca IntSummaryStatistics, DoubleSummaryStatistics...

Yukarıdaki cevaplara dayalı temiz bir Python çözümü:

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)

kullanımı:

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