Comment calculer la moyenne mobile sans garder le nombre et le total des données?

J'essaie de trouver un moyen de calculer une moyenne cumulative mobile sans stocker le nombre et le total des données reçues jusqu'à présent.

J'ai proposé deux algorithmes, mais les deux doivent stocker le décompte:

• nouvelle moyenne = ((ancien décompte * anciennes données) + données suivantes) / prochain décompte
• nouvelle moyenne = ancienne moyenne + (données suivantes - ancienne moyenne) / prochain décompte

Le problème avec ces méthodes est que le nombre augmente de plus en plus, ce qui entraîne une perte de précision dans la moyenne résultante.

La première méthode utilise l'ancien décompte et le décompte suivant qui sont évidemment séparés de 1. Cela m'a fait penser qu'il existe peut-être un moyen de supprimer le décompte, mais malheureusement, je ne l'ai pas encore trouvé. Cela m'a fait un peu plus loin, ce qui a abouti à la deuxième méthode, mais le compte est toujours présent.

Est-ce possible, ou suis-je simplement à la recherche de l'impossible?

Vous pouvez simplement faire:

double approxRollingAverage (double avg, double new_sample) {

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

    return avg;
}

Où Nest le nombre d'échantillons sur lequel vous voulez faire la moyenne. Notez que cette approximation équivaut à une moyenne mobile exponentielle. Voir: Calculer la moyenne mobile / glissante en C ++

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

Cela suppose que le nombre n'a changé que d'une valeur. Dans le cas où il est modifié par des valeurs M alors:

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

C'est la formule mathématique (je crois la plus efficace), croyez que vous pouvez faire plus de code par vous-mêmes

À partir d' un blog sur l'exécution d'échantillons de calculs de variance, où la moyenne est également calculée à l'aide de la méthode de Welford :

Dommage que nous ne puissions pas télécharger d'images SVG.

Voici encore une autre réponse offrant des commentaires sur la façon dont la réponse de Muis , Abdullah Al-Ageel et Flip est mathématiquement la même chose sauf écrite différemment.

Bien sûr, nous avons l' analyse de José Manuel Ramos expliquant comment les erreurs d'arrondi affectent chacune légèrement différemment, mais cela dépend de l'implémentation et changerait en fonction de la façon dont chaque réponse était appliquée au code.

Il y a cependant une assez grande différence

Il est dans Muis 's N, flip ' s k, et Abdullah Al-Ageel de n. Abdullah Al-Ageel n'explique pas tout à fait ce qui ndevrait être, mais Net kdiffère en cela Nest " le nombre d'échantillons sur lesquels vous voulez faire la moyenne " tandis que kle nombre de valeurs échantillonnées. (Bien que je doute de N l' exactitude de l' appel du nombre d'échantillons .)

Et nous arrivons ici à la réponse ci-dessous. C'est essentiellement la même vieille moyenne mobile pondérée exponentielle que les autres, donc si vous cherchez une alternative, arrêtez-vous ici.

Moyenne mobile pondérée exponentielle

Initialement:

average = 0
counter = 0

Pour chaque valeur:

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

La différence est la min(counter, FACTOR)partie. C'est la même chose que de dire min(Flip's k, Muis's N).

FACTORest une constante qui affecte la rapidité avec laquelle la moyenne «rattrape» la dernière tendance. Plus petit est le nombre, plus vite. (À 1ce n'est plus une moyenne et devient juste la dernière valeur.)

Cette réponse nécessite le compteur en cours d'exécution counter. En cas de problème, le min(counter, FACTOR)peut être remplacé par juste FACTOR, ce qui en fait la réponse de Muis . Le problème avec cela est que la moyenne mobile est affectée par tout ce qui averageest initialisé. S'il a été initialisé à 0, ce zéro peut prendre beaucoup de temps pour sortir de la moyenne.

Comment ça finit par ressembler

La réponse de Flip est plus cohérente que celle de Muis.

En utilisant le format de nombre double, vous pouvez voir le problème d'arrondi dans l'approche Muis:

Lorsque vous divisez et soustrayez, un arrondi apparaît dans la valeur stockée précédente, la modifiant.

Cependant, l'approche Flip préserve la valeur stockée et réduit le nombre de divisions, réduisant ainsi l'arrondi et minimisant l'erreur propagée à la valeur stockée. L'ajout ne fera apparaître des arrondis que s'il y a quelque chose à ajouter (lorsque N est grand, il n'y a rien à ajouter)

Ces changements sont remarquables lorsque vous faites une moyenne de grandes valeurs tendant leur moyenne à zéro.

Je vous montre les résultats à l'aide d'un tableur:

Tout d'abord, les résultats obtenus:

Les colonnes A et B sont les valeurs n et X_n, respectivement.

La colonne C est l'approche Flip, et celle D est l'approche Muis, le résultat stocké dans la moyenne. La colonne E correspond à la valeur moyenne utilisée dans le calcul.

Un graphique montrant la moyenne des valeurs paires est le suivant:

Comme vous pouvez le voir, il existe de grandes différences entre les deux approches.

Un exemple utilisant javascript, à titre de comparaison:

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

vous avez aussi IntSummaryStatistics, DoubleSummaryStatistics...

Une solution Python soignée basée sur les réponses ci-dessus:

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)

usage:

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