вычислить экспоненциальную скользящую среднюю в python

Я немного погуглил, и я нашел следующий пример кода (http://osdir.com/ml/python.matplotlib.general/2005-04/msg00044.html):

def ema(s, n):
    """
    returns an n period exponential moving average for
    the time series s

    s is a list ordered from oldest (index 0) to most
    recent (index -1)
    n is an integer

    returns a numeric array of the exponential
    moving average
    """
    s = array(s)
    ema = []
    j = 1

    #get n sma first and calculate the next n period ema
    sma = sum(s[:n]) / n
    multiplier = 2 / float(1 + n)
    ema.append(sma)

    #EMA(current) = ( (Price(current) - EMA(prev) ) x Multiplier) + EMA(prev)
    ema.append(( (s[n] - sma) * multiplier) + sma)

    #now calculate the rest of the values
    for i in s[n+1:]:
        tmp = ( (i - ema[j]) * multiplier) + ema[j]
        j = j + 1
        ema.append(tmp)

    return ema

Я всегда вычисляю EMAs с пандами:

вот пример как это сделать:

import pandas as pd
import numpy as np

def ema(values, period):
    values = np.array(values)
    return pd.ewma(values, span=period)[-1]

values = [9, 5, 10, 16, 5]
period = 5

print ema(values, period)

больше информации о пандах EWMA:

http://pandas.pydata.org/pandas-docs/stable/generated/pandas.ewma.html

мой python немного ржавый (любой может свободно редактировать этот код, чтобы внести исправления, если я как-то испортил синтаксис), но здесь....

def movingAverageExponential(values, alpha, epsilon = 0):

   if not 0 < alpha < 1:
      raise ValueError("out of range, alpha='%s'" % alpha)

   if not 0 <= epsilon < alpha:
      raise ValueError("out of range, epsilon='%s'" % epsilon)

   result = [None] * len(values)

   for i in range(len(result)):
       currentWeight = 1.0

       numerator     = 0
       denominator   = 0
       for value in values[i::-1]:
           numerator     += value * currentWeight
           denominator   += currentWeight

           currentWeight *= alpha
           if currentWeight < epsilon: 
              break

       result[i] = numerator / denominator

   return result

эта функция перемещается назад, от конца списка к началу, вычисляя экспоненциальную скользящую среднюю для каждого значения, работая назад, пока весовой коэффициент для элемента не будет меньше заданного Эпсилона.

В конце функции он меняет значения перед возвратом список (чтобы они были в правильном порядке для вызывающего абонента).

(примечание: если бы я использовал язык, отличный от python, я бы сначала создал полноразмерный пустой массив, а затем заполнил его в обратном порядке, чтобы мне не пришлось его отменять в конце. Но я не думаю, что можно объявить пустой массив в Python. И в списках python добавление намного дешевле, чем добавление, поэтому я построил список в обратном порядке. Пожалуйста, поправьте меня, если я ошибаюсь.)

В аргумент "Альфа" является фактором распада на каждой итерации. Например, если вы использовали Альфа 0,5, то сегодняшнее скользящее среднее значение будет состоять из следующих взвешенных значений:

today:        1.0
yesterday:    0.5
2 days ago:   0.25
3 days ago:   0.125
...etc...

конечно, если у вас есть огромный массив значений, значения от десяти или пятнадцати дней назад не будут вносить большой вклад в сегодняшнее средневзвешенное значение. Аргумент 'epsilon' позволяет установить точку отсечения, ниже которой вы перестанете заботиться о старых значениях (так как их вклад в сегодняшние значение будет незначительным).

вы вызовете функцию примерно так:

result = movingAverageExponential(values, 0.75, 0.0001)

In matplotlib.org примеры (http://matplotlib.org/examples/pylab_examples/finance_work2.html) приведен один хороший пример экспоненциальной скользящей средней (EMA) функции с использованием numpy:

def moving_average(x, n, type):
    x = np.asarray(x)
    if type=='simple':
        weights = np.ones(n)
    else:
        weights = np.exp(np.linspace(-1., 0., n))

    weights /= weights.sum()

    a =  np.convolve(x, weights, mode='full')[:len(x)]
    a[:n] = a[n]
    return a

Я не знаю Python, но для усредняющей части вы имеете в виду экспоненциально затухающий фильтр нижних частот формы

y_new = y_old + (input - y_old)*alpha

где alpha = dt / tau, dt = шаг времени фильтра, tau = постоянная времени фильтра? (переменная-timestep форма этого выглядит следующим образом, просто клип dt / tau, чтобы быть не более 1.0)

y_new = y_old + (input - y_old)*dt/tau

Если вы хотите отфильтровать что-то вроде даты, убедитесь, что вы конвертируете в Количество с плавающей запятой, например # секунд с 1 января 1970.

вы также можете использовать метод фильтра SciPy, потому что EMA является фильтром IIR. Это будет иметь преимущество быть примерно в 64 раза быстрее, чем измеряется в моей системе с помощью timeit на больших наборах данных по сравнению с перечисления() подход.

import numpy as np
from scipy.signal import lfilter

x = np.random.normal(size=1234)
alpha = .1 # smoothing coefficient
zi = [x[0]] # seed the filter state with first value
# filter can process blocks of continuous data if <zi> is maintained
y, zi = lfilter([1.-alpha], [1., -alpha], x, zi=zi)

Я нашел приведенный выше фрагмент кода @earino довольно полезным , но мне нужно было что - то, что могло бы непрерывно сглаживать поток значений, поэтому я рефакторировал его так:

def exponential_moving_average(period=1000):
    """ Exponential moving average. Smooths the values in v over ther period. Send in values - at first it'll return a simple average, but as soon as it's gahtered 'period' values, it'll start to use the Exponential Moving Averge to smooth the values.
    period: int - how many values to smooth over (default=100). """
    multiplier = 2 / float(1 + period)
    cum_temp = yield None  # We are being primed

    # Start by just returning the simple average until we have enough data.
    for i in xrange(1, period + 1):
        cum_temp += yield cum_temp / float(i)

    # Grab the timple avergae
    ema = cum_temp / period

    # and start calculating the exponentially smoothed average
    while True:
        ema = (((yield ema) - ema) * multiplier) + ema

и я использую его так:

def temp_monitor(pin):
    """ Read from the temperature monitor - and smooth the value out. The sensor is noisy, so we use exponential smoothing. """
    ema = exponential_moving_average()
    next(ema)  # Prime the generator

    while True:
        yield ema.send(val_to_temp(pin.read()))

(где pin.read () производит следующее значение, которое я хотел бы использовать).

вот простой пример, который я разработал на основе http://stockcharts.com/school/doku.php?id=chart_school:technical_indicators:moving_averages

обратите внимание, что в отличие от их электронной таблицы, я не вычисляю SMA, и я не жду, чтобы генерировать EMA после 10 образцов. Это означает, что мои значения немного отличаются, но если вы нанесете их на диаграмму, это будет точно после 10 образцов. В течение первых 10 выборок EMA, которую я вычисляю, соответствующим образом сглаживается.

def emaWeight(numSamples):
    return 2 / float(numSamples + 1)

def ema(close, prevEma, numSamples):
    return ((close-prevEma) * emaWeight(numSamples) ) + prevEma

samples = [
22.27, 22.19, 22.08, 22.17, 22.18, 22.13, 22.23, 22.43, 22.24, 22.29,
22.15, 22.39, 22.38, 22.61, 23.36, 24.05, 23.75, 23.83, 23.95, 23.63,
23.82, 23.87, 23.65, 23.19, 23.10, 23.33, 22.68, 23.10, 22.40, 22.17,
]
emaCap = 10
e=samples[0]
for s in range(len(samples)):
    numSamples = emaCap if s > emaCap else s
    e =  ema(samples[s], e, numSamples)
    print e

быстрый способ (копировать-вставить из здесь) следующим образом:

def ExpMovingAverage(values, window):
    """ Numpy implementation of EMA
    """
    weights = np.exp(np.linspace(-1., 0., window))
    weights /= weights.sum()
    a =  np.convolve(values, weights, mode='full')[:len(values)]
    a[:window] = a[window]
    return a

Я использую список и скорость распада в качестве входных данных. Я надеюсь, что эта небольшая функция с двумя строками может помочь вам здесь, учитывая, что глубокая рекурсия не стабильна в python.

def expma(aseries, ratio):
    return sum([ratio*aseries[-x-1]*((1-ratio)**x) for x in range(len(aseries))])