Comparaison du code de moyenne mobile exponentielle (EMA) écrit en Python

La moyenne mobile la plus couramment utilisée après la moyenne mobile simple (SMA) est la moyenne mobile exponentielle (EMA). En plus de MACD, qui est célèbre en tant qu'index technique qui utilise l'EMA, il existe également DEMA, TEMA et TriX qui utilisent l'EMA plusieurs fois, et les moyennes mobiles adaptatives telles que AMA, FrAMA et VIDyA utilisent l'EMA comme méthode de calcul. Je vais.

Cette fois, Comparaison des moyennes mobiles de type de filtre IIR avec les pandas et scipy Dans le prolongement de, comparons quelques codes EMA.

Formule EMA

Lors de l'utilisation réelle de l'EMA, la période est entrée en tant que paramètre, mais ici nous utilisons la formule directement pour vérifier les performances de l'EMA lui-même.

En d'autres termes, le paramètre de EMA est $ \ alpha $ dans la formule ci-dessus.

Mise en œuvre par les pandas

Tout d'abord, les données d'entrée doivent être multipliées par EMA À propos du code Python pour une moyenne mobile simple en supposant l'utilisation de Numba Faites-en aussi une promenade aléatoire.

import numpy as np
import pandas as pd

dn = np.random.randint(2, size=100000)*2-1
gwalk = np.cumprod(np.exp(dn*0.01))*100

Dans les pandas, vous pouvez facilement convertir en classe Series et exécuter EMA avec les méthodes ʻewmetmean. Vous pouvez également affecter directement ʻalpha comme paramètre de ʻewm`. «Alpha» est dans la plage de 0 à 1 et il n'y a pas de différence particulière en fonction de la valeur, alors entrez 0,15 ici.

def EMA1(x, alpha):
    return pd.Series(x).ewm(alpha=alpha).mean()

%timeit y1 = EMA1(gwalk, 0.15)

Le temps d'exécution est le suivant.

100 loops, best of 3: 8.62 ms per loop

implémentation scipy par lflter

Comparaison des moyennes mobiles de type de filtre IIR avec les pandas et scipy Il s'agit d'une implémentation utilisant la fonction de filtre de scipy lfilter de la même manière que.

from scipy.signal import lfilter
def EMA2(x, alpha):
    y,zf = lfilter([alpha], [1,alpha-1], x, zi=[x[0]*(1-alpha)])
    return y

%timeit y2 = EMA2(gwalk, 0.15)

Le temps d'exécution est le suivant.

1000 loops, best of 3: 631 µs per loop

Jusqu'à présent, dans l'article précédent, il était dit que scipy était rapide, mais cette fois, il y a une suite.

Implémentation directe de formules à l'aide de Numba

Codez directement la formule EMA. Cependant, s'il est laissé tel quel, il sera très lent, utilisez donc Numba pour l'accélérer.

from numba import jit
@jit(nopython=True)
def EMA3(x, alpha):
    y = np.empty_like(x)
    y[0] = x[0]
    for i in range(1,len(x)):
        y[i] = alpha*x[i] + (1-alpha)*y[i-1]
    return y

%timeit y3 = EMA3(gwalk, 0.15)

Si vous ajoutez nopython = True à l'argument de @ jit et qu'aucune erreur ne se produit, vous pouvez vous attendre à une accélération. En fait, le temps d'exécution est

1000 loops, best of 3: 227 µs per loop

Et plus vite que scipy.

Dans le cas de l'EMA également, l'utilisation de Numba a abouti au codage direct le plus rapide.