Як обчислити ковзну середню без збереження підрахунку та загальної кількості даних?

Я намагаюся знайти спосіб обчислити ковзаюче середнє значення, що рухається, не зберігаючи підрахунок та загальну кількість даних, отриманих до цих пір.

Я придумав два алгоритми, але обидва повинні зберігати кількість:

• новий середній = ((старий рахунок * старі дані) + наступні дані) / наступний
• новий середній = старий середній + (наступні дані - старе середнє) / наступний підрахунок

Проблема цих методів полягає в тому, що кількість збільшується і збільшується, що призводить до втрати точності в середньому.

Перший метод використовує старий підрахунок та наступний підрахунок, які, очевидно, одна на одну. Це змусило мене подумати, що, можливо, є спосіб зняти лічильник, але, на жаль, я його ще не знайшов. Хоча це мене трохи пішло далі, в результаті чого другий метод, але все ще існує.

Це можливо чи я просто шукаю неможливе?

Ви можете просто зробити:

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).

Це математична формула (я вважаю найефективнішою), вірю, що ви можете зробити подальший код самостійно

З блогу про вибіркові вибіркові дисперсії, де середнє значення також розраховується за методом Велфорда :

Шкода, що ми не можемо завантажити SVG-зображення.

Ось ще одна відповідь, що пропонує коментар до того, як відповіді Муїса , Абдулла Аль-Агееля та Фліпа - це математично одне і те ж, крім написаного по-іншому.

Звичайно, у нас є аналіз Хосе Мануеля Рамоса , який пояснює, як помилки округлення впливають на кожну дещо по-різному, але це залежить від реалізації та зміниться залежно від того, як кожна відповідь була застосована до коду.

Однак є досить велика різниця

Це в MUIS 's N, Фліп ' s k, і Абдулла аль-Ageel «s n. Абдулла аль-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)можна замінити справедливим FACTOR, перетворивши його на відповідь Муїса . Проблема в цьому - ковзаюча середня величина, на яку впливає те, що averageбуло ініціалізовано. Якщо вона була ініціалізована на 0, цей нуль може зайняти багато часу, щоб вийти з середнього рівня.

Як це в підсумку виглядає

Відповідь Фліпа обчислювально більш послідовна, ніж муїська.

Використовуючи формат подвійних чисел, ви можете побачити проблему заокруглення в підході Muis:

Під час ділення та віднімання у попередньому збереженому значенні з'являється округлення, змінюючи його.

Однак підхід Flip зберігає збережене значення та зменшує кількість поділів, отже, зменшуючи округлення та мінімізуючи помилку, поширювану на збережене значення. Додавання лише призведе до заокруглення, якщо є що додати (коли N великий, нема чого додати)

Ці зміни чудові, коли середні великі величини тягнуться до нуля.

Я показую вам результати за допомогою програми електронних таблиць:

По-перше, отримані результати:

Стовпці A і B - це n та X_n значення відповідно.

Стовпець С - це підхід Flip, а D - підхід Муїса, результат зберігається в середньому. Стовпець E відповідає середньому значенню, яке використовується в обчисленні.

Графік, що показує середнє значення парних значень, є наступним:

Як бачите, великі відмінності між обома підходами.

Приклад використання JavaScript для порівняння:

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)