Moving average or running mean

Question

Is there a SciPy function or NumPy function or module for Python that calculates the running mean of a 1D array given a specific window

User · Accepted Answer

For a short  fast solution that does the whole thing in one loop  without dependencies  the code below works great   mylist    1  2  3  4  5  6  7  N   3 cumsum  moving aves    0       for i  x in enumerate mylist  1       cumsum append cumsum i-1    x      if i gt  N          moving ave    cumsum i  - cumsum i-N   N          can do stuff with moving ave here         moving aves append moving ave

User · Answer

Python standard library solution This generator-function takes an iterable and a window size N  and yields the average over the current values inside the window   It uses a deque  which is a datastructure similar to a list  but optimized for fast modifications  pop  append  at both endpoints  from collections import deque from itertools import islice  def sliding avg iterable  N               it   iter iterable      window   deque islice it  N               num vals   len window       if num vals  lt  N          msg    window size    exceeds total number of values             raise ValueError msg format N  num vals        N   float N    force floating point division if using Python 2     s   sum window           while True          yield s N         try              nxt   next it          except StopIteration              break         s   s - window popleft     nxt         window append nxt            Here is the function in action   gt  gt  gt  values   range 100   gt  gt  gt  N   5  gt  gt  gt  window avg   sliding avg values  N   gt  gt  gt    gt  gt  gt  next window avg     0   1   2   3   4  5  gt  gt  gt  2 0  gt  gt  gt  next window avg     1   2   3   4   5  5  gt  gt  gt  3 0  gt  gt  gt  next window avg     2   3   4   5   6  5  gt  gt  gt  4 0

User · Answer

You can calculate a running mean with   import numpy as np  def runningMean x  N       y   np zeros  len x         for ctr in range len x             y ctr    np sum x ctr  ctr N        return y N   But it s slow   Fortunately  numpy includes a convolve function which we can use to speed things up  The running mean is equivalent to convolving x with a vector that is N long  with all members equal to 1 N  The numpy implementation of convolve includes the starting transient  so you have to remove the first N-1 points   def runningMeanFast x  N       return np convolve x  np ones  N    N   N-1      On my machine  the fast version is 20-30 times faster  depending on the length of the input vector and size of the averaging window   Note that convolve does include a  same  mode which seems like it should address the starting transient issue   but it splits it between the beginning and end

User · Answer

For educational purposes  let me add two more Numpy solutions  which are slower than the cumsum solution    import numpy as np from numpy lib stride tricks import as strided  def ra strides arr  window           Running average using as strided        n   arr shape 0  - window   1     arr strided   as strided arr  shape  n  window   strides 2 arr strides      return arr strided mean axis 1   def ra add arr  window           Running average using add reduceat        n   arr shape 0  - window   1     indices   np array  0  window  n    np repeat np arange n   2      arr   np append arr  0      return np add reduceat arr  indices     2  window   Functions used  as strided  add reduceat

User · Answer

There are many answers above about calculating a running mean  My answer adds two extra features    ignores nan values  calculates the mean for the N neighboring values NOT including the value of interest itself   This second feature is particularly useful for determining which values differ from the general trend by a certain amount   I use numpy cumsum since it is the most time-efficient method  see Alleo s answer above     N 10   number of points to test on each side of point of interest  best if even padded x   np insert np insert  np insert x  len x   np empty int N 2   np nan   0  np empty int N 2   np nan   0 0  n nan   np cumsum np isnan padded x   cumsum   np nancumsum padded x   window sum   cumsum N 1   - cumsum  - N 1   - x   subtract value of interest from sum of all values within window window n nan   n nan N 1   - n nan  - N 1   - np isnan x  window n values    N - window n nan  movavg    window sum     window n values    This code works for even Ns only  It can be adjusted for odd numbers by changing the np insert of padded x and n nan   Example output  raw in black  movavg in blue     This code can be easily adapted to remove all moving average values calculated from fewer than cutoff   3 non-nan values   window n values    N - window n nan  astype float    dtype must be float to set some values to nan cutoff   3 window n values window n values lt cutoff    np nan movavg    window sum     window n values

User · Answer

Although there are solutions for this question here  please take a look at my solution  It is very simple and working well    import numpy as np dataset   np asarray  1  2  3  4  5  6  7   ma   list   window   3 for t in range 0  len dataset        if t window  lt   len dataset           indices   range t  t window          ma append np average np take dataset  indices    else      ma   np asarray ma

User · Answer

A bit late to the party  but I ve made my own little function that does NOT wrap around the ends or pads with zeroes that are then used to find the average as well  As a further treat is  that it also re-samples the signal at linearly spaced points  Customize the code at will to get other features   The method is a simple matrix multiplication with a normalized Gaussian kernel   def running mean y in  x in  N out 101  sigma 1               Returns running mean as a Bell-curve weighted average at evenly spaced     points  Does NOT wrap signal around  or pad with zeros       Arguments      y in -- y values  the values to be smoothed and re-sampled     x in -- x values for array      Keyword arguments      N out -- NoOf elements in resampled array      sigma --  Width  of Bell-curve in units of param x               N in   size y in         Gaussian kernel     x out   np linspace np min x in   np max x in   N out      x in mesh  x out mesh   np meshgrid x in  x out      gauss kernel   np exp -np square x in mesh - x out mesh     2   sigma  2         Normalize kernel  such that the sum is one along axis 1     normalization   np tile np reshape sum gauss kernel  axis 1    N out  1     1  N in       gauss kernel normalized   gauss kernel   normalization       Perform running average as a linear operation     y out   gauss kernel normalized   y in      return y out  x out   A simple usage on a sinusoidal signal with added normal distributed noise

User · Answer

All the aforementioned solutions are poor because they lack   speed due to a native python instead of a numpy vectorized implementation  numerical stability due to poor use of numpy cumsum  or speed due to O len x    w  implementations as convolutions    Given  import numpy m   10000 x   numpy random rand m  w   1000   Note that x   w  sum   equals x  w-1  sum    So for the first average the numpy cumsum      adds x w    w  via x  w 1    w   and subtracts 0  from x  0    w   This results in x 0 w  mean    Via cumsum  you ll update the second average by additionally add x w 1    w and subtracting x 0    w  resulting in x 1 w 1  mean     This goes on until x -w   mean   is reached   x    numpy insert x  0  0  sliding average   x   w  sum     w   numpy cumsum x  w   - x   -w     w   This solution is vectorized  O m   readable and numerically stable

User · Answer

Another approach to find moving average without using numpy  panda  import itertools sample    2  6  10  8  11  10  list itertools starmap lambda a b  b a                  enumerate itertools accumulate sample   1      will print  2 0  4 0  6 0  6 5  7 4  7 833333333333333

User · Answer

Use Only Python Standard Library  Memory Efficient   Just give another version of using the standard library deque only  It s quite a surprise to me that most of the answers are using pandas or numpy   def moving average iterable  n 3       d   deque maxlen n      for i in iterable          d append i          if len d     n              yield sum d  n  r   moving average  40  30  50  46  39  44   assert list r      40 0  42 0  45 0  43 0    Actually I found another implementation in python docs  def moving average iterable  n 3         moving average  40  30  50  46  39  44   -- gt  40 0 42 0 45 0 43 0       http   en wikipedia org wiki Moving average     it   iter iterable      d   deque itertools islice it  n-1       d appendleft 0      s   sum d      for elem in it          s    elem - d popleft           d append elem          yield s   n   However the implementation seems to me is a bit more complex than it should be  But it must be in the standard python docs for a reason  could someone comment on the implementation of mine and the standard doc

User · Answer

I haven t yet checked how fast this is  but you could try   from collections import deque  cache   deque     keep track of seen values n   10            window size A   xrange 100    some dummy iterable cum sum   0       initialize cumulative sum  for t  val in enumerate A  1       cache append val      cum sum    val     if t  lt  n          avg   cum sum   float t      else                              if window is saturated          cum sum -  cache popleft      subtract oldest value         avg   cum sum   float n

User · Answer

There is a comment by mab buried in one of the answers above which has this method   bottleneck has move mean which is a simple moving average   import numpy as np import bottleneck as bn  a   np arange 10    np random random 10   mva   bn move mean a  window 2  min count 1    min count is a handy parameter that will basically take the moving average up to that point in your array   If you don t set min count  it will equal window  and everything up to window points will be nan

User · Answer

From reading the other answers I don t think this is what the question asked for  but I got here with the need of keeping a running average of a list of values that was growing in size   So if you want to keep a list of values that you are acquiring from somewhere  a site  a measuring device  etc   and the average of the last n values updated  you can use the code bellow  that minimizes the effort of adding new elements   class Running Average object       def   init   self  buffer size 10                       Create a new Running Average object           This object allows the efficient calculation of the average of the last          buffer size  numbers added to it           Examples         --------          gt  gt  gt  a   Running Average 2           gt  gt  gt  a add 1           gt  gt  gt  a get           1 0          gt  gt  gt  a add 1     there are two 1 in buffer          gt  gt  gt  a get           1 0          gt  gt  gt  a add 2     there s a 1 and a 2 in the buffer          gt  gt  gt  a get           1 5          gt  gt  gt  a add 2           gt  gt  gt  a get      now there s only two 2 in the buffer         2 0                     self  buffer size   int buffer size     make sure it s an int         self reset        def add self  new                       Add a new number to the buffer  or replaces the oldest one there                      new   float new     make sure it s a float         n   len self  buffer          if n  lt  self buffer size     still have to had numbers to the buffer              self  buffer append new              if self  average    self  average       if isNaN                    self  average   new    no previous numbers  so it s new              else                  self  average    n    so it s only the sum of numbers                  self  average    new    add new number                  self  average     n 1     divide by new number of numbers          else     buffer full  replace oldest value              old   self  buffer self  index     the previous oldest number              self  buffer self  index    new    replace with new one              self  index    1    update the index and make sure it s                self  index    self buffer size        smaller than buffer size              self  average -  old self buffer size    remove old one                self  average    new self buffer size       and add new one                      weighted by the number of elements       def   call   self                       Return the moving average value  for the lazy ones who don t want         to write  get                       return self  average      def get self                       Return the moving average value                      return self        def reset self                       Reset the moving average           If for some reason you don t want to just create a new one                      self  buffer         could use np empty self buffer size             self  index   0    and use this to keep track of how many numbers          self  average   float  nan      could use np NaN        def get buffer size self                       Return current buffer size                      return self  buffer size      def set buffer size self  buffer size                        gt  gt  gt  a   Running Average 10           gt  gt  gt  for i in range 15                   a add i                       gt  gt  gt  a           9 5          gt  gt  gt  a  buffer    should not access this            10 0  11 0  12 0  13 0  14 0  5 0  6 0  7 0  8 0  9 0           Decreasing buffer size           gt  gt  gt  a buffer size   6          gt  gt  gt  a  buffer    should not access this            9 0  10 0  11 0  12 0  13 0  14 0           gt  gt  gt  a buffer size   2          gt  gt  gt  a  buffer          13 0  14 0           Increasing buffer size           gt  gt  gt  a buffer size   5         Warning  no older data available           gt  gt  gt  a  buffer          13 0  14 0           Keeping buffer size           gt  gt  gt  a   Running Average 10           gt  gt  gt  for i in range 15                   a add i                       gt  gt  gt  a           9 5          gt  gt  gt  a  buffer    should not access this            10 0  11 0  12 0  13 0  14 0  5 0  6 0  7 0  8 0  9 0           gt  gt  gt  a buffer size   10    reorders buffer           gt  gt  gt  a  buffer          5 0  6 0  7 0  8 0  9 0  10 0  11 0  12 0  13 0  14 0                      buffer size   int buffer size            order the buffer so index is zero again          new buffer   self  buffer self  index           new buffer extend self  buffer  self  index           self  index   0         if self  buffer size  lt  buffer size              print  Warning  no older data available       should use Warnings          else              diff   self  buffer size - buffer size             print diff              new buffer   new buffer diff           self  buffer size   buffer size         self  buffer   new buffer      buffer size   property get buffer size  set buffer size    And you can test it with  for example   def graph test N 200       import matplotlib pyplot as plt     values   list range N       values average calculator   Running Average N 2      values averages          for value in values          values average calculator add value          values averages append values average calculator        fig  ax   plt subplots 1  1      ax plot values  label  values       ax plot values averages  label  averages       ax grid       ax set xlim 0  N      ax set ylim 0  N      fig show     Which gives

User · Answer

Instead of numpy or scipy  I would recommend pandas to do this more swiftly   df  data   rolling 3  mean     This takes the moving average  MA  of 3 periods of the column  data   You can also calculate the shifted versions  for example the one that excludes the current cell  shifted one back  can be calculated easily as   df  data   shift periods 1  rolling 3  mean

User · Answer

If you do choose to roll your own  rather than use an existing library  please be conscious of floating point error and try to minimize its effects   class SumAccumulator      def   init   self           self values    0          self count   0      def add  self  val            self values append  val           self count   self count   1         i   self count         while i  amp  0x01              i   i  gt  gt  1             v0   self values pop               v1   self values pop               self values append  v0   v1        def get total self           return sum  reversed self values         def get size  self            return self count   If all your values are roughly the same order of magnitude  then this will help to preserve precision by always adding values of roughly similar magnitudes

User · Answer

I feel this can be elegantly solved using bottleneck  See basic sample below   import numpy as np import bottleneck as bn  a   np random randint 4  1000  size 100  mm   bn move mean a  window 5  min count 1      mm  is the moving mean for  a     window  is the max number of entries to consider for moving mean    min count  is min number of entries to consider for moving mean  e g  for first few elements or if the array has nan values     The good part is Bottleneck helps to deal with nan values and it s also very efficient

User · Answer

A new convolve recipe was merged into Python 3 10  Given  import collections  operator  from itertools import chain  repeat   size   3   1 kernel    1 size    size                                                Code def convolve signal  kernel         See   https   betterexplained com articles intuitive-convolution        convolve data   0 25  0 25  0 25  0 25   -- gt  Moving average  blur        convolve data   1  -1   -- gt  1st finite difference  1st derivative        convolve data   1  -2  1   -- gt  2nd finite difference  2nd derivative      kernel   list reversed kernel       n   len kernel      window   collections deque  0    n  maxlen n      for x in chain signal  repeat 0  n-1            window append x          yield sum map operator mul  kernel  window    Demo list convolve range 1  6   kernel      0 25  0 75  1 5  2 5  3 5  3 0  2 25  1 25    Details A convolution is a general mathematical operation that can be applied to moving averages   This idea is  given some data  you slide a subset of data  window  as a  quot mask quot  or  quot kernel quot  across the data  carrying out a particular mathematical operation over each window   In the case of moving averages  the kernel is the average   This recipe is a simple approach that is almost implemented as a Python module   In time  you can install more itertools  a popular third-party package  to directly use this implementation

User · Answer

I know this is an old question  but here is a solution that doesn t use any extra data structures or libraries  It is linear in the number of elements of the input list and I cannot think of any other way to make it more efficient  actually if anyone knows of a better way to allocate the result  please let me know    NOTE  this would be much faster using a numpy array instead of a list  but I wanted to eliminate all dependencies  It would also be possible to improve performance by multi-threaded execution  The function assumes that the input list is one dimensional  so be careful       Running mean Moving average def running mean l  N       sum   0     result   list  0 for x in l       for i in range  0  N            sum   sum   l i          result i    sum    i 1       for i in range  N  len l             sum   sum - l i-N    l i          result i    sum   N      return result   Example  Assume that we have a list data     1  2  3  4  5  6   on which we want to compute a rolling mean with period of 3  and that you also want a output list that is the same size of the input one  that s most often the case    The first element has index 0  so the rolling mean should be computed on elements of index -2  -1 and 0  Obviously we don t have data -2  and data -1   unless you want to use special boundary conditions   so we assume that those elements are 0  This is equivalent to zero-padding the list  except we don t actually pad it  just keep track of the indices that require padding  from 0 to N-1    So  for the first N elements we just keep adding up the elements in an accumulator   result 0     0   0   1    3    0 333          sum   1    3 result 1     0   1   2    3    1              sum   2    3 result 2     1   2   3    3    2              sum   3    3   From elements N 1 forwards simple accumulation doesn t work  we expect result 3     2   3   4  3   3 but this is different from  sum   4  3   3 333   The way to compute the correct value is to subtract data 0    1 from sum 4  thus giving  sum   4 - 1   9    This happens because currently sum   data 0    data 1    data 2   but it is also true for every i  gt   N because  before the subtraction  sum is data i-N          data i-2    data i-1

User · Answer

This question is now even older than when NeXuS wrote about it last month  BUT I like how his code deals with edge cases  However  because it is a  simple moving average   its results lag behind the data they apply to  I thought that dealing with edge cases in a more satisfying way than NumPy s modes valid  same  and full could be achieved by applying a similar approach to a convolution   based method   My contribution uses a central running average to align its results with their data  When there are too few points available for the full-sized window to be used  running averages are computed from successively smaller windows at the edges of the array   Actually  from successively larger windows  but that s an implementation detail    import numpy as np  def running mean l  N         Also works for the strictly invalid  cases when N is even      if  N  2  2    N          N   N - 1     front   np zeros N  2      back   np zeros N  2       for i in range 1   N  2  2  2           front i  2    np convolve l  i   np ones  i    i  mode    valid       for i in range 1   N  2  2  2           back i  2    np convolve l -i    np ones  i    i  mode    valid       return np concatenate  front  np convolve l  np ones  N    N  mode    valid    back   -1      It s relatively slow because it uses convolve    and could likely be spruced up quite a lot by a true Pythonista  however  I believe that the idea stands

User · Answer

You can use scipy ndimage filters uniform filter1d   import numpy as np from scipy ndimage filters import uniform filter1d N   1000 x   np random random 100000  y   uniform filter1d x  size N    uniform filter1d    gives the output with the same numpy shape  i e  number of points  allows multiple ways to handle the border where  reflect  is the default  but in my case  I rather wanted  nearest    It is also rather quick  nearly 50 times faster than np convolve and 2-5 times faster than the cumsum approach given above     timeit y1   np convolve x  np ones  N    N  mode  same   100 loops  best of 3  9 28 ms per loop   timeit y2   uniform filter1d x  size N  10000 loops  best of 3  191   s per loop   here s 3 functions that let you compare error speed of different implementations   from   future   import division import numpy as np import scipy ndimage filters as ndif def running mean convolve x  N       return np convolve x  np ones N    float N    valid   def running mean cumsum x  N       cumsum   np cumsum np insert x  0  0       return  cumsum N   - cumsum  -N     float N  def running mean uniform filter1d x  N       return ndif uniform filter1d x  N  mode  constant   origin - N  2    - N-1

User · Answer

Update  The example below shows the old pandas rolling mean function which has been removed in recent versions of pandas  A modern equivalent of the function call below would be  In  8   pd Series x  rolling window N  mean   iloc N-1   values Out 8    array   0 49815397   0 49844183   0 49840518        0 49488191          0 49456679   0 49427121       pandas is more suitable for this than NumPy or SciPy   Its function rolling mean does the job conveniently   It also returns a NumPy array when the input is an array   It is difficult to beat rolling mean in performance with any custom pure Python implementation   Here is an example performance against two of the proposed solutions     In  1   import numpy as np  In  2   import pandas as pd  In  3   def running mean x  N               cumsum   np cumsum np insert x  0  0                return  cumsum N   - cumsum  -N     N          In  4   x   np random random 100000   In  5   N   1000  In  6    timeit np convolve x  np ones  N    N  mode  valid   10 loops  best of 3  172 ms per loop  In  7    timeit running mean x  N  100 loops  best of 3  6 72 ms per loop  In  8    timeit pd rolling mean x  N  N-1   100 loops  best of 3  4 74 ms per loop  In  9   np allclose pd rolling mean x  N  N-1    running mean x  N   Out 9   True   There are also nice options as to how to deal with the edge values

User · Answer

With  Aikude s variables  I wrote one-liner   import numpy as np  mylist    1  2  3  4  5  6  7  N   3  mean    np mean mylist x x N   for x in range len mylist -N 1   print mean    gt  gt  gt   2 0  3 0  4 0  5 0  6 0

User · Answer

For a ready-to-use solution  see https   scipy-cookbook readthedocs io items SignalSmooth html  It provides running average with the flat window type  Note that this is a bit more sophisticated than the simple do-it-yourself convolve-method  since it tries to handle the problems at the beginning and the end of the data by reflecting it  which may or may not work in your case       To start with  you could try   a   np random random 100  plt plot a  b   smooth a  window  flat   plt plot b

User · Answer

or module for python that calculates   in my tests at Tradewave net TA-lib always wins   import talib as ta import numpy as np import pandas as pd import scipy from scipy import signal import time as t  PAIR   info primary pair PERIOD   30  def initialize        storage reset       storage elapsed   storage get  elapsed    0 0 0 0 0 0    def cumsum sma array  period       ret   np cumsum array  dtype float      ret period     ret period   - ret  -period      return ret period - 1     period  def pandas sma array  period       return pd rolling mean array  period   def api sma array  period         this method is native to Tradewave and does NOT return an array     return  data PAIR  ma PERIOD    def talib sma array  period       return ta MA array  period   def convolve sma array  period       return np convolve array  np ones  period    period  mode  valid    def fftconvolve sma array  period           return scipy signal fftconvolve          array  np ones  period    period  mode  valid        def tick         close   data PAIR  warmup period  close        t1   t time       sma api   api sma close  PERIOD      t2   t time       sma cumsum   cumsum sma close  PERIOD      t3   t time       sma pandas   pandas sma close  PERIOD      t4   t time       sma talib   talib sma close  PERIOD      t5   t time       sma convolve   convolve sma close  PERIOD      t6   t time       sma fftconvolve   fftconvolve sma close  PERIOD      t7   t time        storage elapsed -1    storage elapsed -1    t2-t1     storage elapsed -2    storage elapsed -2    t3-t2     storage elapsed -3    storage elapsed -3    t4-t3     storage elapsed -4    storage elapsed -4    t5-t4     storage elapsed -5    storage elapsed -5    t6-t5         storage elapsed -6    storage elapsed -6    t7-t6              plot  sma api   sma api        plot  sma cumsum   sma cumsum -5       plot  sma pandas   sma pandas -10       plot  sma talib   sma talib -15       plot  sma convolve   sma convolve -20           plot  sma fftconvolve   sma fftconvolve -25    def stop         log  ticks       s    info max ticks       log  api          5f    storage elapsed -1       log  cumsum       5f    storage elapsed -2       log  pandas       5f    storage elapsed -3       log  talib        5f    storage elapsed -4       log  convolve     5f    storage elapsed -5           log  fft          5f    storage elapsed -6     results    2015-01-31 23 00 00  ticks      744  2015-01-31 23 00 00  api        0 16445  2015-01-31 23 00 00  cumsum     0 03189  2015-01-31 23 00 00  pandas     0 03677  2015-01-31 23 00 00  talib      0 00700     lt  lt  lt  Winner   2015-01-31 23 00 00  convolve   0 04871  2015-01-31 23 00 00  fft        0 22306

User · Answer

UPDATE  more efficient solutions have been proposed  uniform filter1d from scipy being probably the best among the  quot standard quot  3rd-party libraries  and some newer or specialized libraries are available too   You can use np convolve for that  np convolve x  np ones N  N  mode  valid    Explanation The running mean is a case of the mathematical operation of convolution  For the running mean  you slide a window along the input and compute the mean of the window s contents  For discrete 1D signals  convolution is the same thing  except instead of the mean you compute an arbitrary linear combination  i e   multiply each element by a corresponding coefficient and add up the results  Those coefficients  one for each position in the window  are sometimes called the convolution kernel  The arithmetic mean of N values is  x 1   x 2         x N    N  so the corresponding kernel is  1 N  1 N       1 N   and that s exactly what we get by using np ones N  N  Edges The mode argument of np convolve specifies how to handle the edges  I chose the valid mode here because I think that s how most people expect the running mean to work  but you may have other priorities  Here is a plot that illustrates the difference between the modes  import numpy as np import matplotlib pyplot as plt modes     full    same    valid   for m in modes      plt plot np convolve np ones 200   np ones 50  50  mode m    plt axis  -10  251  - 1  1 1    plt legend modes  loc  lower center    plt show

User · Answer

Efficient solution  Convolution is much better than straightforward approach  but  I guess  it uses FFT and thus quite slow  However specially for computing the running mean the following approach works fine  def running mean x  N       cumsum   numpy cumsum numpy insert x  0  0        return  cumsum N   - cumsum  -N     float N    The code to check  In 3   x   numpy random random 100000  In 4   N   1000 In 5    timeit result1   numpy convolve x  numpy ones  N    N  mode  valid   10 loops  best of 3  41 4 ms per loop In 6    timeit result2   running mean x  N  1000 loops  best of 3  1 04 ms per loop   Note that numpy allclose result1  result2  is True  two methods are equivalent  The greater N  the greater difference in time   warning  although cumsum is faster there will be increased floating point error that may cause your results to be invalid incorrect unacceptable  the comments pointed out this floating point error issue here but i am making it more obvious here in the answer      demonstrate loss of precision with only 100 000 points np random seed 42  x   np random randn 100000  1e6 y1   running mean convolve x  10  y2   running mean cumsum x  10  assert np allclose y1  y2  rtol 1e-12  atol 0     the more points you accumulate over the greater the floating point error  so 1e5 points is noticable  1e6 points is more significant  more than 1e6 and you may want to resetting the accumulators  you can cheat by using np longdouble but your floating point error still will get significant for relatively large number of points  around  1e5 but depends on your data  you can plot the error and see it increasing relatively fast the convolve solution is slower but does not have this floating point loss of precision the uniform filter1d solution is faster than this cumsum solution AND does not have this floating point loss of precision

User · Answer

Another solution just using a standard library and deque   from collections import deque import itertools  def moving average iterable  n 3         http   en wikipedia org wiki Moving average     it   iter iterable         create an iterable object from input argument     d   deque itertools islice it  n-1           create deque object by slicing iterable     d appendleft 0      s   sum d      for elem in it          s    elem - d popleft           d append elem          yield s   n    example on how to use it for i in  moving average  40  30  50  46  39  44        print i     40 0   42 0   45 0   43 0

User · Answer

How about a moving average filter  It is also a one-liner and has the advantage  that you can easily manipulate the window type if you need something else than the rectangle  ie  a N-long simple moving average of an array a   lfilter np ones N  N   1   a  N     And with the triangular window applied   lfilter np ones N  scipy signal triang N  N   1   a  N     Note  I usually discard the first N samples as bogus hence  N   at the end  but it is not necessary and the matter of a personal choice only

[python] Moving average or running mean

Examples related to python

Examples related to numpy

Examples related to scipy

Examples related to moving-average