Làm thế nào để tính toán trung bình động mà không cần giữ tổng số và dữ liệu?

Tôi đang cố gắng tìm cách tính giá trị trung bình tích lũy mà không cần lưu trữ dữ liệu đếm và tổng số nhận được cho đến nay.

Tôi đã nghĩ ra hai thuật toán nhưng cả hai đều cần lưu trữ số lượng:

• trung bình mới = ((số cũ * dữ liệu cũ) + dữ liệu tiếp theo) / số lần tiếp theo
• trung bình mới = trung bình cũ + (dữ liệu tiếp theo - trung bình cũ) / số lần tiếp theo

Vấn đề với các phương pháp này là số lượng ngày càng lớn hơn dẫn đến mất độ chính xác trong kết quả trung bình.

Phương pháp đầu tiên sử dụng số cũ và số tiếp theo rõ ràng là cách nhau 1. Điều này khiến tôi nghĩ rằng có lẽ có một cách để loại bỏ số đếm nhưng tiếc là tôi vẫn chưa tìm thấy nó. Tuy nhiên, nó đã đưa tôi đi xa hơn một chút, dẫn đến phương pháp thứ hai nhưng vẫn có số lượng.

Liệu nó có thể, hay tôi chỉ đang tìm kiếm những điều không thể?

Bạn chỉ cần làm:

double approxRollingAverage (double avg, double new_sample) {

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

    return avg;
}

Trong trường hợp Nlà số lượng mẫu mà bạn muốn trên mức trung bình. Lưu ý rằng giá trị gần đúng này tương đương với đường trung bình động theo cấp số nhân. Xem: Tính toán trung bình lăn / di chuyển trong C ++

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

Điều này giả sử số lượng chỉ thay đổi bởi một giá trị. Trong trường hợp nó được thay đổi bởi M giá trị thì:

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

Đây là công thức toán học (tôi tin là công thức hiệu quả nhất), tin rằng bạn có thể tự viết mã thêm

Từ một blog về chạy tính toán phương sai mẫu, nơi giá trị trung bình cũng được tính bằng phương pháp của Welford :

Thật tệ là chúng tôi không thể tải lên hình ảnh SVG.

Đây là một câu trả lời khác đưa ra bình luận về cách mà câu trả lời của Muis , Abdullah Al-Ageel và Flip đều giống nhau về mặt toán học ngoại trừ cách viết khác nhau.

Chắc chắn, chúng tôi có José Manuel Ramos phân tích của giải thích cách các lỗi làm tròn ảnh hưởng đến mỗi lỗi hơi khác nhau, nhưng điều đó phụ thuộc vào việc triển khai và sẽ thay đổi dựa trên cách mỗi câu trả lời được áp dụng cho mã.

Tuy nhiên, có một sự khác biệt khá lớn

Nó có trong Muis 's N, Flip ' s kvà Abdullah Al-Ageel 's n. Abdullah Al-Ageel không hoàn toàn giải thích những gì nnên có, nhưng Nvà kkhác biệt ở chỗ Nlà " số lượng mẫu mà bạn muốn lấy trung bình " trong khi klà số lượng các giá trị được lấy mẫu. (Mặc dù tôi có nghi ngờ về việc gọi N số lượng mẫu có chính xác không.)

Và đây chúng ta cùng đến với câu trả lời dưới đây. Về cơ bản nó giống như đường trung bình động có trọng số theo cấp số nhân cũ như những đường khác, vì vậy nếu bạn đang tìm kiếm một giải pháp thay thế, hãy dừng lại ngay tại đây.

Đường trung bình động có trọng số theo cấp số nhân

Ban đầu:

average = 0
counter = 0

Đối với mỗi giá trị:

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

Sự khác biệt là min(counter, FACTOR)một phần. Điều này cũng giống như nóimin(Flip's k, Muis's N) .

FACTORlà một hằng số ảnh hưởng đến tốc độ trung bình "bắt kịp" xu hướng mới nhất. Số lượng càng nhỏ càng nhanh. ( 1Nó không còn là giá trị trung bình nữa và chỉ trở thành giá trị mới nhất.)

Câu trả lời này yêu cầu bộ đếm đang chạy counter. Nếu có vấn đề, min(counter, FACTOR)có thể được thay thế bằng chỉ FACTOR, biến nó thành câu trả lời của Muis . Vấn đề khi thực hiện điều này là đường trung bình bị ảnh hưởng bởi bất cứ thứ gì averageđược khởi tạo. Nếu nó được khởi tạo thành0 , số 0 đó có thể mất nhiều thời gian để vượt ra khỏi mức trung bình.

Nó kết thúc như thế nào

Câu trả lời của Flip phù hợp hơn về mặt tính toán so với câu trả lời của Muis.

Sử dụng định dạng số kép, bạn có thể thấy vấn đề vòng tròn trong cách tiếp cận Muis:

Khi bạn chia và trừ, một dấu tròn sẽ xuất hiện trong giá trị được lưu trữ trước đó, thay đổi nó.

Tuy nhiên, phương pháp Flip bảo toàn giá trị được lưu trữ và giảm số lần phân chia, do đó, giảm thời gian làm tròn và giảm thiểu lỗi được truyền đến giá trị được lưu trữ. Chỉ thêm sẽ làm xuất hiện vòng tròn nếu có thứ gì đó cần thêm (khi N lớn, không có gì để thêm)

Những thay đổi đó rất đáng chú ý khi bạn tạo ra một giá trị trung bình có xu hướng trung bình của chúng bằng không.

Tôi cho bạn thấy kết quả bằng chương trình bảng tính:

Thứ nhất, kết quả thu được:

Các cột A và B lần lượt là giá trị n và X_n.

Cột C là phương pháp Flip, và cột D là phương pháp Muis, kết quả được lưu trong giá trị trung bình. Cột E tương ứng với giá trị trung bình được sử dụng trong tính toán.

Biểu đồ hiển thị giá trị trung bình của các giá trị chẵn là biểu đồ tiếp theo:

Như bạn có thể thấy, có sự khác biệt lớn giữa cả hai cách tiếp cận.

Một ví dụ sử dụng javascript, để so sánh:

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

Trong Java8:

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

bạn cũng có IntSummaryStatistics, DoubleSummaryStatistics...

Một giải pháp Python gọn gàng dựa trên các câu trả lời trên:

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)

sử dụng:

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