จะคำนวณค่าเฉลี่ยเคลื่อนที่โดยไม่เก็บจำนวนและยอดรวมข้อมูลได้อย่างไร

ฉันกำลังพยายามหาวิธีคำนวณค่าเฉลี่ยสะสมเคลื่อนที่โดยไม่เก็บจำนวนและข้อมูลทั้งหมดที่ได้รับจนถึงตอนนี้

ฉันมีสองอัลกอริทึม แต่ทั้งคู่จำเป็นต้องจัดเก็บการนับ:

• ค่าเฉลี่ยใหม่ = ((จำนวนเก่า * ข้อมูลเก่า) + ข้อมูลถัดไป) / การนับถัดไป
• ค่าเฉลี่ยใหม่ = ค่าเฉลี่ยเก่า + (ข้อมูลถัดไป - ค่าเฉลี่ยเก่า) / การนับถัดไป

ปัญหาของวิธีการเหล่านี้คือจำนวนที่มากขึ้นเรื่อย ๆ ส่งผลให้สูญเสียความแม่นยำในค่าเฉลี่ยที่ได้

วิธีแรกใช้การนับเก่าและการนับถัดไปซึ่งเห็นได้ชัดว่าห่างกัน 1 สิ่งนี้ทำให้ฉันคิดว่าอาจมีวิธีลบการนับ แต่น่าเสียดายที่ฉันยังไม่พบ มันทำให้ฉันได้ไกลขึ้นเล็กน้อยซึ่งส่งผลให้วิธีที่สอง แต่ยังคงมีการนับอยู่

เป็นไปได้หรือฉันแค่ค้นหาสิ่งที่เป็นไปไม่ได้

คุณสามารถทำได้ง่ายๆ:

double approxRollingAverage (double avg, double new_sample) {

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

    return avg;
}

ที่ไหนNเป็นจำนวนตัวอย่างที่คุณต้องการไปกว่าค่าเฉลี่ย โปรดทราบว่าการประมาณนี้เทียบเท่ากับค่าเฉลี่ยเคลื่อนที่เลขชี้กำลัง ดู: คำนวณการหมุน / ค่าเฉลี่ยเคลื่อนที่ใน C ++

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

นี่คือสมมติว่าจำนวนเปลี่ยนแปลงเพียงค่าเดียว ในกรณีที่ค่า M เปลี่ยนแปลงแล้ว:

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

นี่คือสูตรทางคณิตศาสตร์ (ฉันเชื่อว่าเป็นสูตรที่มีประสิทธิภาพมากที่สุด) เชื่อว่าคุณสามารถสร้างรหัสเพิ่มเติมได้ด้วยตัวเอง

จากบล็อกในการทำงานการคำนวณค่าความแปรปรวนของกลุ่มตัวอย่างที่มีค่าเฉลี่ยนอกจากนี้ยังมีการคำนวณโดยใช้วิธีการของ Welford :

เสียดายที่เราไม่สามารถอัปโหลดภาพ SVG ได้

นี่เป็นอีกหนึ่งคำตอบที่นำเสนอความเห็นว่าคำตอบของMuis , Abdullah Al-AgeelและFlipเป็นอย่างไรในทางคณิตศาสตร์เหมือนกันยกเว้นเขียนแตกต่างกัน

แน่นอนว่าเรามีการวิเคราะห์ของJosé Manuel Ramosที่อธิบายว่าข้อผิดพลาดในการปัดเศษส่งผลต่อแต่ละข้อแตกต่างกันเล็กน้อย แต่การใช้งานนั้นขึ้นอยู่กับวิธีการใช้คำตอบแต่ละข้อกับโค้ด

อย่างไรก็ตามมีความแตกต่างที่ค่อนข้างใหญ่

มันอยู่ในMuis 's N, พลิก ' s kและอับดุลลาห์อัล Ageeln 's อับดุลลาห์อัล Ageelไม่ค่อยอธิบายสิ่งที่nควรจะเป็น แต่Nและkแตกต่างกันในที่Nนี้คือ " จำนวนตัวอย่างที่คุณต้องการมากกว่าค่าเฉลี่ย " ในขณะที่kเป็นนับค่าตัวอย่าง (แม้ว่าฉันจะสงสัยว่าการโทรN ไปที่จำนวนกลุ่มตัวอย่างนั้นถูกต้องหรือไม่)

และที่นี่เรามาถึงคำตอบด้านล่าง โดยพื้นฐานแล้วมันเป็นค่าเฉลี่ยเคลื่อนที่แบบถ่วงน้ำหนักเลขชี้กำลังแบบเดิม ๆเช่นเดียวกับค่าอื่น ๆ ดังนั้นหากคุณกำลังมองหาทางเลือกอื่นให้หยุดตรงนี้

ค่าเฉลี่ยเคลื่อนที่ถ่วงน้ำหนักเอกซ์โปเนนเชียล

ในขั้นต้น:

average = 0
counter = 0

สำหรับแต่ละค่า:

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

ความแตกต่างคือmin(counter, FACTOR)ส่วน min(Flip's k, Muis's N)นี้เป็นเช่นเดียวกับการพูดว่า

FACTORคือค่าคงที่ที่มีผลต่อการ "จับ" แนวโน้มล่าสุดโดยเฉลี่ย จำนวนน้อยยิ่งเร็ว ( 1มันไม่ใช่ค่าเฉลี่ยอีกต่อไปและกลายเป็นค่าล่าสุด)

counterคำตอบนี้ต้องทำงานเคาน์เตอร์ หากมีปัญหาmin(counter, FACTOR)สามารถแทนที่ด้วย just FACTORเปลี่ยนเป็นคำตอบของMuis ปัญหาในการทำเช่นนี้คือค่าเฉลี่ยเคลื่อนที่ได้รับผลกระทบจากสิ่งที่averageเริ่มต้น หากเริ่มต้น0เป็นศูนย์นั้นอาจใช้เวลานานในการหาค่าเฉลี่ย

มันจบลงอย่างไร

คำตอบของ Flip มีความสอดคล้องกันในเชิงคำนวณมากกว่า Muis

เมื่อใช้รูปแบบเลขคู่คุณจะเห็นปัญหาการปัดเศษในแนวทาง Muis:

เมื่อคุณหารและลบการปัดเศษจะปรากฏในค่าที่เก็บไว้ก่อนหน้าโดยเปลี่ยนค่านั้น

อย่างไรก็ตามวิธีการ Flip จะรักษาค่าที่จัดเก็บไว้และลดจำนวนหน่วยงานดังนั้นจึงลดการปัดเศษและลดข้อผิดพลาดที่แพร่กระจายไปยังค่าที่จัดเก็บไว้ให้น้อยที่สุด การเพิ่มจะทำให้เกิดการปัดเศษขึ้นหากมีบางสิ่งที่จะเพิ่ม (เมื่อ N มีขนาดใหญ่จะไม่มีอะไรให้เพิ่ม)

การเปลี่ยนแปลงเหล่านี้เป็นสิ่งที่น่าทึ่งเมื่อคุณกำหนดค่านิยมจำนวนมากมักมีค่าเฉลี่ยเป็นศูนย์

ฉันแสดงผลลัพธ์โดยใช้โปรแกรมสเปรดชีต:

ประการแรกผลที่ได้รับ:

คอลัมน์ A และ B คือค่า n และ X_n ตามลำดับ

คอลัมน์ C คือวิธีการพลิกและ D หนึ่งคือแนวทาง Muis ซึ่งเป็นผลลัพธ์ที่เก็บไว้ในค่าเฉลี่ย คอลัมน์ E สอดคล้องกับค่ากลางที่ใช้ในการคำนวณ

กราฟที่แสดงค่าเฉลี่ยของค่าคู่คือกราฟถัดไป:

อย่างที่คุณเห็นมีความแตกต่างอย่างมากระหว่างทั้งสองแนวทาง

ตัวอย่างการใช้จาวาสคริปต์เพื่อเปรียบเทียบ:

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:

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

คุณยังมีIntSummaryStatistics, DoubleSummaryStatistics...

โซลูชัน Python ที่เป็นระเบียบตามคำตอบข้างต้น:

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)

การใช้งาน:

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