Calcul des moyennes locales dans un tableau 1D numpy

au lieu d'indexer, vous pouvez aborder cela avec une perspective de traitement de signal. Vous êtes essentiellement l'exécution d'une convolution discrète de votre signal d'entrée avec un noyau 7-tap où les trois coefficients centraux sont 0 alors que les extrémités sont 1, et puisque vous voulez calculer la moyenne, vous devez multiplier toutes les valeurs par (1/4). Cependant, vous ne calculez pas la convolution de tous les éléments, mais nous y reviendrons plus tard. Une façon est d'utiliser scipy.ndimage.filters.convolve1d pour:

import numpy as np
from scipy.ndimage import filters
d = np.arange(1, 21, dtype=np.float)
ker = (1.0/4.0)*np.array([1,1,0,0,0,1,1], dtype=np.float)
out = filters.convolve1d(d, ker)[3:-3:2]

parce que vous utilisez un noyau 7 tapez, convolution va étendre la sortie de 3 vers la gauche et de 3 vers la droite, donc vous devez vous assurer de recadrer le premier et les trois derniers éléments. Vous aussi vous voulez ignorer tous les autres éléments parce que convolution implique une fenêtre coulissante, mais vous voulez écarter tous les autres éléments de sorte que vous obtenez le résultat que vous voulez.

nous obtenons ceci pour out:

In [47]: out
Out[47]: array([  4.,   6.,   8.,  10.,  12.,  14.,  16.])

pour vérifier si nous avons le bon résultat, essayez quelques exemples de calculs pour chaque élément. Le premier élément est égal à (1+2+6+7)/4 = 4. Le deuxième élément est égal à (3+4+8+9)/4 = 6, et ainsi de suite.

Pour une solution avec moins de maux de tête, essayez numpy.convolvemode=valid drapeau. Cela évite la découpe du rembourrage supplémentaire à gauche et à droite, mais vous aurez encore besoin de sauter tous les autres éléments bien que:

import numpy as np
d = np.arange(1, 21, dtype=np.float)
ker = (1.0/4.0)*np.array([1,1,0,0,0,1,1], dtype=np.float)
out = np.convolve(d, ker, mode='valid')[::2]

Nous avons aussi:

In [59]: out
Out[59]: array([  4.,   6.,   8.,  10.,  12.,  14.,  16.])

enfin, si vous voulez indexer, quelque chose comme ceci peut suffire:

length = len(d[6::2])
out = np.array([(a+b+c+e)/4.0 for (a,b,c,e) in zip(d[::2][:length], d[1::2][:length], d[5::2][:length], d[6::2])])

On obtient:

In [69]: out
Out[69]: array([  4.,   6.,   8.,  10.,  12.,  14.,  16.])

C'est vraiment moche, mais ça marche. La longueur totale de votre signal est régie par le fait que la fin de chaque fenêtre est au 7ème index. La longueur de ce tableau qui contient ces indices dicte la longueur finale de votre signal. Notez également que, pour un élément dans un de la fenêtre, son prochain élément trouvé en ignorant tous les autres éléments jusqu'à la fin du tableau. Il y a 4 de ces séquences au total et nous avons simplement zip sur ces 4 séquences où chaque séquence saute tous les autres éléments, mais il y a un décalage que nous commençons par. La première séquence commence à l'offset 0, l'autre à 1, le suivant à 5 et l'autre à 6. Nous recueillons ces quatre éléments et de moyenne eux, puis sauter sur chacun dans le tableau jusqu'à ce que nous finissons.

BTW, j'ai encore comme la convolution de mieux.