Indice de Force Relative en python pandas

Il est important de noter qu'il existe différentes façons de définir le RSI. Il est communément défini dans au moins deux façons: à l'aide d'une moyenne mobile simple SMA) comme ci-dessus, ou en utilisant une moyenne mobile exponentielle (EMA). Voici un extrait de code qui calcule les deux définitions de la RSI et des parcelles pour la comparaison. Je suis en supprimant la première ligne après la prise de la différence, car il est toujours NaN, par définition.

Noter que lors de l'utilisation de l'EMA attention: étant donné qu'il comprend une mémoire depuis le début des données, le résultat dépend de l'endroit où vous commencez à! Pour cette raison, généralement, les gens vont ajouter des données au début, de 100 pas de temps, et puis couper les 100 premières valeurs RSI.

Dans le graphique ci-dessous, on peut voir la différence entre le RSI est calculée à l'aide de SMA et de l'EMA: le SMA on a tendance à être plus sensibles. Note que le RSI est basé sur l'EMA a sa première valeur finie au premier pas de temps (qui est la deuxième étape de la période, en raison de l'abandon du premier rang), alors que le RSI basé sur des SMA a sa première valeur finie à la 14ème étape. C'est parce que par défaut rolling_mean() ne renvoie une valeur finie une fois il y a assez de valeurs pour remplir la fenêtre.

import pandas
import pandas.io.data
import datetime
import matplotlib.pyplot as plt

# Window length for moving average
window_length = 14

# Dates
start = datetime.datetime(2010, 1, 1)
end = datetime.datetime(2013, 1, 27)

# Get data
data = pandas.io.data.DataReader('AAPL', 'yahoo', start, end)
# Get just the close
close = data['Adj Close']
# Get the difference in price from previous step
delta = close.diff()
# Get rid of the first row, which is NaN since it did not have a previous 
# row to calculate the differences
delta = delta[1:] 

# Make the positive gains (up) and negative gains (down) Series
up, down = delta.copy(), delta.copy()
up[up < 0] = 0
down[down > 0] = 0

# Calculate the EWMA
roll_up1 = pandas.stats.moments.ewma(up, window_length)
roll_down1 = pandas.stats.moments.ewma(down.abs(), window_length)

# Calculate the RSI based on EWMA
RS1 = roll_up1 / roll_down1
RSI1 = 100.0 - (100.0 / (1.0 + RS1))

# Calculate the SMA
roll_up2 = pandas.rolling_mean(up, window_length)
roll_down2 = pandas.rolling_mean(down.abs(), window_length)

# Calculate the RSI based on SMA
RS2 = roll_up2 / roll_down2
RSI2 = 100.0 - (100.0 / (1.0 + RS2))

# Compare graphically
plt.figure()
RSI1.plot()
RSI2.plot()
plt.legend(['RSI via EWMA', 'RSI via SMA'])
plt.show()

OriginalL'auteur

Moi aussi j'avais cette question et qui travaille en bas de la rolling_apply chemin qui Jev a pris. Cependant, quand j'ai testé mes résultats, ils n'ont pas le match contre le stock commercial de cartographie des programmes que j'utilise, comme StockCharts.com ou thinkorswim. J'ai donc fait quelques recherches et découvert que lorsque Welles Wilder créé le RSI, il a utilisé une technique de lissage désormais dénommée Wilder Lissage. Les services commerciaux au-dessus de l'utilisation Wilder Lissage plutôt que d'une moyenne mobile simple de calculer la moyenne des gains et des pertes.

Je suis nouveau sur Python (et les Pandas), alors je me demandais si il ya une façon brillante de refactoriser le pour boucle ci-dessous pour le rendre plus rapide. Peut-être que quelqu'un d'autre commentaire sur cette possibilité.

J'espère que vous trouverez ce utile.

Plus d'info ici.

def get_rsi_timeseries(prices, n=14):
# RSI = 100 - (100 /(1 + RS))
# where RS = (Wilder-smoothed n-period average of gains /Wilder-smoothed n-period average of -losses)
# Note that losses above should be positive values
# Wilder-smoothing = ((previous smoothed avg * (n-1)) + current value to average) /n
# For the very first "previous smoothed avg" (aka the seed value), we start with a straight average.
# Therefore, our first RSI value will be for the n+2nd period:
#     0: first delta is nan
#     1:
#     ...
#     n: lookback period for first Wilder smoothing seed value
#     n+1: first RSI
# First, calculate the gain or loss from one price to the next. The first value is nan so replace with 0.
deltas = (prices-prices.shift(1)).fillna(0)
# Calculate the straight average seed values.
# The first delta is always zero, so we will use a slice of the first n deltas starting at 1,
# and filter only deltas > 0 to get gains and deltas < 0 to get losses
avg_of_gains = deltas[1:n+1][deltas > 0].sum() / n
avg_of_losses = -deltas[1:n+1][deltas < 0].sum() / n
# Set up pd.Series container for RSI values
rsi_series = pd.Series(0.0, deltas.index)
# Now calculate RSI using the Wilder smoothing method, starting with n+1 delta.
up = lambda x: x if x > 0 else 0
down = lambda x: -x if x < 0 else 0
i = n+1
for d in deltas[n+1:]:
avg_of_gains = ((avg_of_gains * (n-1)) + up(d)) / n
avg_of_losses = ((avg_of_losses * (n-1)) + down(d)) / n
if avg_of_losses != 0:
rs = avg_of_gains / avg_of_losses
rsi_series[i] = 100 - (100 / (1 + rs))
else:
rsi_series[i] = 100
i += 1
return rsi_series

OriginalL'auteur

def RSI(series):
delta = series.diff()
u = delta * 0 
d = u.copy()
i_pos = delta > 0
i_neg = delta < 0
u[i_pos] = delta[i_pos]
d[i_neg] = delta[i_neg]
rs = moments.ewma(u, span=27) / moments.ewma(d, span=27)
return 100 - 100 / (1 + rs)

OriginalL'auteur