La façon la plus efficace de calculer l'exécution d'un écart-type?

La réponse de base est d'accumuler la somme des deux x (appelons cela la "sum_x1') et x² (appelons cela la "sum_x2'), comme vous allez. La valeur de l'écart-type est alors:

stdev = sqrt((sum_x2 / n) - (mean * mean)) 

où

mean = sum_x / n

C'est l'écart-type d'échantillon; vous obtenez l'écart type de population à l'aide de " n "au lieu de" n - 1 " comme le diviseur.

Vous pouvez avoir besoin de vous soucier de la stabilité numérique de la prise de la différence entre les deux grands nombres si vous travaillez avec des échantillons de grande taille. Aller pour les références externes dans d'autres réponses (Wikipedia, etc) pour plus d'informations.

Ici est un littéral pur Python traduction de la Welford, l'algorithme de mise en œuvre de http://www.johndcook.com/standard_deviation.html:

https://github.com/liyanage/python-modules/blob/master/running_stats.py

class RunningStats:

    def __init__(self):
        self.n = 0
        self.old_m = 0
        self.new_m = 0
        self.old_s = 0
        self.new_s = 0

    def clear(self):
        self.n = 0

    def push(self, x):
        self.n += 1

        if self.n == 1:
            self.old_m = self.new_m = x
            self.old_s = 0
        else:
            self.new_m = self.old_m + (x - self.old_m) / self.n
            self.new_s = self.old_s + (x - self.old_m) * (x - self.new_m)

            self.old_m = self.new_m
            self.old_s = self.new_s

    def mean(self):
        return self.new_m if self.n else 0.0

    def variance(self):
        return self.new_s / (self.n - 1) if self.n > 1 else 0.0

    def standard_deviation(self):
        return math.sqrt(self.variance())

Utilisation:

rs = RunningStats()
rs.push(17.0);
rs.push(19.0);
rs.push(24.0);

mean = rs.mean();
variance = rs.variance();
stdev = rs.standard_deviation();

Statistiques::Descriptif est un très décent module Perl pour ces types de calculs:

#!/usr/bin/perl

use strict; use warnings;

use Statistics::Descriptive qw( :all );

my $data = [
    [ 0.01, 0.01, 0.02, 0.04, 0.03 ],
    [ 0.00, 0.02, 0.02, 0.03, 0.02 ],
    [ 0.01, 0.02, 0.02, 0.03, 0.02 ],
    [ 0.01, 0.00, 0.01, 0.05, 0.03 ],
];

my $stat = Statistics::Descriptive::Full->new;
# You also have the option of using sparse data structures

for my $ref ( @$data ) {
    $stat->add_data( @$ref );
    printf "Running mean: %f\n", $stat->mean;
    printf "Running stdev: %f\n", $stat->standard_deviation;
}
__END__

De sortie:

C:\Temp> g
Running mean: 0.022000
Running stdev: 0.013038
Running mean: 0.020000
Running stdev: 0.011547
Running mean: 0.020000
Running stdev: 0.010000
Running mean: 0.020000
Running stdev: 0.012566

Quelle est la taille de votre tableau? Sauf si c'est des milliards d'éléments de long, ne vous inquiétez pas sur la boucle par deux fois. Le code est simple et facile de tester.

Ma préférence serait d'utiliser la numpy tableau de mathématiques de l'extension de convertir votre tableau de tableaux dans un numpy tableau 2D et obtenir l'écart-type directement:

>>> x = [ [ 1, 2, 4, 3, 4, 5 ], [ 3, 4, 5, 6, 7, 8 ] ] * 10
>>> import numpy
>>> a = numpy.array(x)
>>> a.std(axis=0) 
array([ 1. ,  1. ,  0.5,  1.5,  1.5,  1.5])
>>> a.mean(axis=0)
array([ 2. ,  3. ,  4.5,  4.5,  5.5,  6.5])

Si ce n'est pas une option et que vous avez besoin d'un pur Python solution, continuez à lire...

Si votre tableau est

x = [ 
      [ 1, 2, 4, 3, 4, 5 ],
      [ 3, 4, 5, 6, 7, 8 ],
      ....
]

Puis l'écart-type est:

d = len(x[0])
n = len(x)
sum_x = [ sum(v[i] for v in x) for i in range(d) ]
sum_x2 = [ sum(v[i]**2 for v in x) for i in range(d) ]
std_dev = [ sqrt((sx2 - sx**2)/N)  for sx, sx2 in zip(sum_x, sum_x2) ]

Si vous êtes déterminé à boucle à travers votre tableau qu'une seule fois, les cumuls peuvent être combinés.

sum_x  = [ 0 ] * d
sum_x2 = [ 0 ] * d
for v in x:
   for i, t in enumerate(v):
   sum_x[i] += t
   sum_x2[i] += t**2

Ce n'est pas aussi élégant que la liste de compréhension de la solution ci-dessus.

Vous pouvez consulter l'article de Wikipedia sur Écart-Type, en particulier la section sur le Rapide des méthodes de calcul.

Il y a aussi un article que j'ai trouvé qui utilise Python, vous devriez être en mesure d'utiliser le code sans trop de changement: Les Messages Subliminaux - L'Exécution Des Écarts-Types.

Comme la réponse suivante décrit:
Ne pandas/scipy/numpy fournir une norme cumulative fonction d'écart?
Le Python Pandas module contient une méthode pour calculer l'exécution ou la cumulé écart-type.
Pour cela, vous devrez convertir vos données dans une pandas dataframe (ou une série si c'est 1D), mais il existe des fonctions pour que.

Je tiens à exprimer la mise à jour de cette façon:

def running_update(x, N, mu, var):
    '''
        @arg x: the current data sample
        @arg N : the number of previous samples
        @arg mu: the mean of the previous samples
        @arg var : the variance over the previous samples
        @retval (N+1, mu', var') -- updated mean, variance and count
    '''
    N = N + 1
    rho = 1.0/N
    d = x - mu
    mu += rho*d
    var += rho*((1-rho)*d**2 - var)
    return (N, mu, var)

que l'un passe-fonction devrait ressembler à ceci:

def one_pass(data):
    N = 0
    mu = 0.0
    var = 0.0
    for x in data:
        N = N + 1
        rho = 1.0/N
        d = x - mu
        mu += rho*d
        var += rho*((1-rho)*d**2 - var)
        # could yield here if you want partial results
   return (N, mu, var)

noter que c'est le calcul de la variance de l'échantillon (1/N), et non l'estimation non biaisée de la variance de population (qui utilise un 1/(N-1) normalzation facteur). Contrairement à d'autres réponses, la variable, var, qui est suivi de l'exécution de la variance n'augmente pas en proportion du nombre d'échantillons. En tout temps, elle est juste la variance de l'ensemble des échantillons vu jusqu'à présent (il n'y a pas de finale "en divisant par n" dans l'obtention de la variance).

Dans une classe, il devrait ressembler à ceci:

class RunningMeanVar(object):
    def __init__(self):
        self.N = 0
        self.mu = 0.0
        self.var = 0.0
    def push(self, x):
        self.N = self.N + 1
        rho = 1.0/N
        d = x-self.mu
        self.mu += rho*d
        self.var += + rho*((1-rho)*d**2-self.var)
    # reset, accessors etc. can be setup as you see fit

Cela fonctionne aussi pour les pondérée des échantillons:

def running_update(w, x, N, mu, var):
    '''
        @arg w: the weight of the current sample
        @arg x: the current data sample
        @arg mu: the mean of the previous N sample
        @arg var : the variance over the previous N samples
        @arg N : the number of previous samples
        @retval (N+w, mu', var') -- updated mean, variance and count
    '''
    N = N + w
    rho = w/N
    d = x - mu
    mu += rho*d
    var += rho*((1-rho)*d**2 - var)
    return (N, mu, var)