¿Cómo calcular la media móvil sin mantener el recuento y el total de datos?

Estoy tratando de encontrar una manera de calcular un promedio acumulativo móvil sin almacenar el recuento y los datos totales que se reciben hasta ahora.

Se me ocurrieron dos algoritmos, pero ambos necesitan almacenar el recuento:

• nuevo promedio = ((recuento antiguo * datos antiguos) + siguiente dato) / siguiente recuento
• nuevo promedio = promedio anterior + (datos siguientes - promedio anterior) / siguiente recuento

El problema con estos métodos es que el recuento aumenta cada vez más, lo que resulta en una pérdida de precisión en el promedio resultante.

El primer método utiliza el recuento anterior y el siguiente, que obviamente están separados por 1. Esto me hizo pensar que tal vez haya una forma de eliminar el recuento, pero desafortunadamente aún no lo he encontrado. Sin embargo, me llevó un poco más lejos, lo que resultó en el segundo método, pero aún está presente el recuento.

¿Es posible o solo estoy buscando lo imposible?

Simplemente puede hacer:

double approxRollingAverage (double avg, double new_sample) {

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

    return avg;
}

¿Dónde Nestá el número de muestras sobre las que desea promediar? Tenga en cuenta que esta aproximación es equivalente a una media móvil exponencial. Ver: Calcular promedio móvil / móvil en C ++

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

Esto es asumiendo que el recuento solo cambió en un valor. En caso de que sea cambiado por valores M, entonces:

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

Esta es la fórmula matemática (creo que la más eficiente), creo que pueden hacer más código por ustedes mismos

De un blog sobre la ejecución de cálculos de varianza de muestra, donde la media también se calcula utilizando el método de Welford :

Lástima que no podamos subir imágenes SVG.

Aquí hay otra respuesta que ofrece un comentario sobre cómo las respuestas de Muis , Abdullah Al-Ageel y Flip son matemáticamente iguales, excepto que están escritas de manera diferente.

Claro, tenemos el análisis de José Manuel Ramos que explica cómo los errores de redondeo afectan a cada uno de manera ligeramente diferente, pero eso depende de la implementación y cambiaría según la forma en que cada respuesta se aplique al código.

Sin embargo, hay una diferencia bastante grande

Está en Muis 's N, flip ' s k, y Abdullah Al-Ageel 's n. Abdullah Al-Ageel no explica lo que ndebería ser, pero Ny kse diferencian en que Nes " el número de muestras en las que desee promedio a lo largo ", mientras que kes el recuento de los valores muestreados. (Aunque tengo dudas sobre si llamar N al número de muestras es exacto).

Y aquí llegamos a la respuesta a continuación. Es esencialmente el mismo promedio móvil ponderado exponencial de edad que los demás, así que si estaba buscando una alternativa, deténgase aquí.

Media móvil ponderada exponencial

Inicialmente:

average = 0
counter = 0

Por cada valor:

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

La diferencia es la min(counter, FACTOR)parte. Esto es lo mismo que decir min(Flip's k, Muis's N).

FACTORes una constante que afecta la rapidez con que el promedio "se pone al día" con la última tendencia. Cuanto menor sea el número, más rápido. ( 1Ya no es un promedio y simplemente se convierte en el último valor).

Esta respuesta requiere el contador corriente counter. Si es problemático, min(counter, FACTOR)se puede reemplazar con solo FACTOR, convirtiéndolo en la respuesta de Muis . El problema de hacer esto es que la media móvil se ve afectada por lo que averagese inicialice. Si se inicializó en 0, ese cero puede tardar mucho en salir del promedio.

Como termina luciendo

La respuesta de Flip es computacionalmente más consistente que la de Muis.

Usando el formato de doble número, podría ver el problema de redondeo en el enfoque de Muis:

Cuando divide y resta, aparece un redondeo en el valor almacenado anterior y lo cambia.

Sin embargo, el enfoque Flip conserva el valor almacenado y reduce el número de divisiones, por lo tanto, reduce el redondeo y minimiza el error propagado al valor almacenado. Agregar solo traerá redondeos si hay algo que agregar (cuando N es grande, no hay nada que agregar)

Esos cambios son notables cuando haces que una media de valores grandes tiende a cero.

Te muestro los resultados usando un programa de hoja de cálculo:

En primer lugar, los resultados obtenidos:

Las columnas A y B son los valores n y X_n, respectivamente.

La columna C es el enfoque Flip y la D es el enfoque Muis, el resultado almacenado en la media. La columna E corresponde con el valor medio utilizado en el cálculo.

Un gráfico que muestra la media de valores pares es el siguiente:

Como puede ver, existen grandes diferencias entre ambos enfoques.

Un ejemplo usando javascript, a modo de comparación:

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

En Java8:

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

también tienes IntSummaryStatistics, DoubleSummaryStatistics...

Una solución de Python ordenada basada en las respuestas anteriores:

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)

uso:

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