def calculate(self) -> pd.Series:
"""
Calculates the simple moving average
:return: Series containing the simple moving average values for each closing price
"""
return momentum.rsi(self._history['Close'], self.__days)
"""
def AddIndicators(df):
# Add Simple Moving Average (SMA) indicators
df["sma7"] = SMAIndicator(close=df["Close"], window=7,
fillna=True).sma_indicator()
df["sma25"] = SMAIndicator(close=df["Close"], window=25,
fillna=True).sma_indicator()
df["sma99"] = SMAIndicator(close=df["Close"], window=99,
fillna=True).sma_indicator()
# Add Bollinger Bands indicator
indicator_bb = BollingerBands(close=df["Close"], window=20, window_dev=2)
df['bb_bbm'] = indicator_bb.bollinger_mavg()
df['bb_bbh'] = indicator_bb.bollinger_hband()
df['bb_bbl'] = indicator_bb.bollinger_lband()
# Add Parabolic Stop and Reverse (Parabolic SAR) indicator
indicator_psar = PSARIndicator(high=df["High"],
low=df["Low"],
close=df["Close"],
step=0.02,
max_step=2,
fillna=True)
df['psar'] = indicator_psar.psar()
# Add Moving Average Convergence Divergence (MACD) indicator
df["MACD"] = macd(close=df["Close"],
window_slow=26,
window_fast=12,
fillna=True) # mazas
# Add Relative Strength Index (RSI) indicator
df["RSI"] = rsi(close=df["Close"], window=14, fillna=True) # mazas
return df
def calculate_rsi(product, **kwargs):
shortened_mfi = []
days = 14
better_start_date = fucking_date.now() - datetime.timedelta(days)
better_end_date = fucking_date.now()
shortened_mfi = client.get_product_historic_rates(product.id,
start=better_start_date,
end=better_end_date,
granularity=86400)
shortened_mfi.reverse()
#time.sleep(1)
shortened_better_data = {
'Open': [x[3] for x in shortened_mfi],
'High': [x[2] for x in shortened_mfi],
'Low': [x[1] for x in shortened_mfi],
'Close': [x[4] for x in shortened_mfi],
'Volume': [x[5] for x in shortened_mfi]
}
shortened_df = pd.notna(
pd.DataFrame([x[1:] for x in shortened_mfi],
columns=['Open', 'High', 'Low', 'Close', 'Volume']))
shortened_rsi_value = \
rsi(pd.Series(data=[x[4] for x in shortened_mfi]), n=len(shortened_mfi)).values[-1]
product.rsi = shortened_rsi_value
def get_state(self, t):
"""
return the state (define state here) given time t
"""
# time feature
d = t - self.window_size
if d <= 0:
state = np.zeros((5, 5))
else:
feature1 = volume.acc_dist_index(
high=self.OHLCV_df[d - 1:t]["High"],
low=self.OHLCV_df[d - 1:t]["Low"],
close=self.OHLCV_df[d - 1:t]["Adj Close"],
volume=self.OHLCV_df[d - 1:t]['Volume'])
feature2 = volatility.average_true_range(
high=self.OHLCV_df[d - 1:t]["High"],
low=self.OHLCV_df[d - 1:t]["Low"],
close=self.OHLCV_df[d - 1:t]["Adj Close"])
feature3 = trend.macd(close=self.OHLCV_df[d - 1:t]["Adj Close"],
n_slow=self.window_size,
n_fast=self.window_size // 2,
fillna=True)
feature4 = momentum.rsi(close=self.OHLCV_df[d - 1:t]["Adj Close"])
feature5 = others.daily_return(
close=self.OHLCV_df[d - 1:t]["Adj Close"])
state = pd.concat(
[feature1, feature2, feature3, feature4, feature5],
axis=1).values[-5:, :]
# block = self.timeseries[d-1:t]
# state = np.diff(np.log(block))
state = state.flatten()
state = np.append(state, (self.inventory, self.cash))
return state
def rsi_cb_pressed(stock_analysis_tool: QMainWindow,
cb: QCheckBox) -> None:
"""
:param stock_analysis_tool:
:param cb:
:return:
"""
if cb.isChecked():
# Add RSI to Display Graph
stock_analysis_tool.df['rsi'] = rsi(
close=stock_analysis_tool.df['close'],
n=stock_analysis_tool.rsi_n)
stock_analysis_tool.df['rsi overbought'] = 70
stock_analysis_tool.df['rsi oversold'] = 30
stock_analysis_tool.add_column_to_graph(column_name='rsi')
stock_analysis_tool.add_column_to_graph(
column_name='rsi overbought',
color=stock_analysis_tool.protected_colors['red'])
stock_analysis_tool.add_column_to_graph(
column_name='rsi oversold',
color=stock_analysis_tool.protected_colors['green'])
else:
# Remove RSI from Display Graph
stock_analysis_tool.remove_column_from_graph(column_name='rsi')
stock_analysis_tool.remove_column_from_graph(
column_name='rsi overbought')
stock_analysis_tool.remove_column_from_graph(
column_name='rsi oversold')
stock_analysis_tool.df = stock_analysis_tool.df.drop("rsi",
axis=1)
stock_analysis_tool.df = stock_analysis_tool.df.drop(
"rsi overbought", axis=1)
stock_analysis_tool.df = stock_analysis_tool.df.drop(
"rsi oversold", axis=1)
def RSI(
nu, df
): #Calcula RSI de un DF. Debe tener el timestamp en columna, no en index
c = df.close
rsi = ta.rsi(c, n=nu)
return rsi
def rsi_time_frame_text_changed(stock_analysis_tool: QMainWindow,
rsi_time_frame_text: QTextEdit):
"""
:param stock_analysis_tool:
:param rsi_time_frame_text:
:return:
"""
text = rsi_time_frame_text.toPlainText()
if text != "":
try:
stock_analysis_tool.rsi_n = int(text)
if 'rsi' in stock_analysis_tool.df.columns:
stock_analysis_tool.df = stock_analysis_tool.df.drop(
"rsi", axis=1)
stock_analysis_tool.df['rsi'] = rsi(
close=stock_analysis_tool.df['close'],
n=stock_analysis_tool.rsi_n)
x = [
datetime.timestamp(date_time)
for date_time in stock_analysis_tool.df.index
]
stock_analysis_tool.data_lines['rsi'].setData(
x, stock_analysis_tool.df['rsi'])
except ValueError:
print("Invalid RSI Input")
def ta_only_forecastMomentum(price_data_csv):
df = pandas.read_csv(filepath_or_buffer=price_data_csv.name,
delimiter=',',
header=0)
df['time'] = pandas.to_datetime(
df.time, unit='s') # gotta convert those dates to a usable format
data_frame = pandas.DataFrame(df).set_index('time').sort_values(
by='time', ascending=True)
# Fast Stochastic Oscillator Check
SMA_Period = 3 # typical SMA period for S.O.
data_frame['Stoch_D'] = momentum.stoch_signal(high=data_frame['high'],
low=data_frame['low'],
close=data_frame['close'],
n=15,
d_n=SMA_Period,
fillna=False)
data_frame['Stoch_K'] = momentum.stoch(high=data_frame['high'],
low=data_frame['low'],
close=data_frame['close'],
n=15,
d_n=SMA_Period,
fillna=False)
data_frame['RSI'] = momentum.rsi(close=data_frame['close'], n=15)
# predict based on signal
signal = data_frame['Stoch_D'].array[-1] + data_frame['Stoch_K'].array[-1]
RSI = data_frame['RSI'].array[-1]
if signal > 160 and RSI > 70: # overbought assets
print(
f"\nSO signal: {signal}\nRSI: {RSI}\nCLOSE: {data_frame['close'].array[-1]}"
)
return {
'signal': 2,
'RSI': RSI,
'SO': signal,
'PRICE': data_frame['close'].array[-1]
}
elif signal < 40 and RSI < 30: # oversold asset
print(
f"\nSO signal: {signal}\nRSI: {RSI}\nCLOSE: {data_frame['close'].array[-1]}"
)
return {
'signal': 0,
'RSI': RSI,
'SO': signal,
'PRICE': data_frame['close'].array[-1]
}
else: # not overbought/sold, should hold the asset
print(
f"\nSO signal: {signal}\nRSI: {RSI}\nCLOSE: {data_frame['close'].array[-1]}"
)
return {
'signal': 1,
'RSI': RSI,
'SO': signal,
'PRICE': data_frame['close'].array[-1]
}
def get_ml_feature(self, symbol, prices=None, cutoff=None):
if prices:
price = prices.get(symbol, 1E10)
vix = prices['^VIX']
else:
price = self.closes[symbol][cutoff]
vix = self.closes['^VIX'][cutoff]
if cutoff:
close = self.closes[symbol][cutoff - DAYS_IN_A_YEAR:cutoff]
high = np.array(
self.hists[symbol].get('High')[cutoff - DAYS_IN_A_YEAR:cutoff])
low = np.array(
self.hists[symbol].get('Low')[cutoff - DAYS_IN_A_YEAR:cutoff])
else:
close = self.closes[symbol][-DAYS_IN_A_YEAR:]
high = np.array(self.hists[symbol].get('High')[-DAYS_IN_A_YEAR:])
low = np.array(self.hists[symbol].get('Low')[-DAYS_IN_A_YEAR:])
# Basic stats
day_range_change = price / np.max(close[-DATE_RANGE:]) - 1
today_change = price / close[-1] - 1
yesterday_change = close[-1] / close[-2] - 1
day_before_yesterday_change = close[-2] / close[-3] - 1
twenty_day_change = price / close[-20] - 1
year_high_change = price / np.max(close) - 1
year_low_change = price / np.min(close) - 1
all_changes = [
close[t + 1] / close[t] - 1 for t in range(len(close) - 1)
if close[t + 1] > 0 and close[t] > 0
]
# Technical indicators
close = np.append(close, price)
high = np.append(high, price)
low = np.append(low, price)
pd_close = pd.Series(close)
pd_high = pd.Series(high)
pd_low = pd.Series(low)
rsi = momentum.rsi(pd_close).values[-1]
macd_rate = trend.macd_diff(pd_close).values[-1] / price
wr = momentum.wr(pd_high, pd_low, pd_close).values[-1]
tsi = momentum.tsi(pd_close).values[-1]
feature = {
'Today_Change': today_change,
'Yesterday_Change': yesterday_change,
'Day_Before_Yesterday_Change': day_before_yesterday_change,
'Twenty_Day_Change': twenty_day_change,
'Day_Range_Change': day_range_change,
'Year_High_Change': year_high_change,
'Year_Low_Change': year_low_change,
'Change_Average': np.mean(all_changes),
'Change_Variance': np.var(all_changes),
'RSI': rsi,
'MACD_Rate': macd_rate,
'WR': wr,
'TSI': tsi,
'VIX': vix
}
return feature
def get_technical_indicators(dataset, key='Close'):
# Create 7 and 21 days Moving Average
dataset['ma7'] = dataset[key].rolling(window=7).mean()
dataset['ma21'] = dataset[key].rolling(window=21).mean()
# Create MACD -> Moving Average Convergence/Divergence (trend and momentum indicator)
dataset['26ema'] = dataset[key].ewm(span=26).mean()
dataset['12ema'] = dataset[key].ewm(span=12).mean()
dataset['MACD'] = (dataset['12ema'] - dataset['26ema'])
# Create Bollinger Bands
# Bollinger Bands are volatility bands placed above and below a moving average. Volatility is based on the standard deviation, which changes as volatility
# increases and decreases. The bands automatically widen when volatility increases and narrow when volatility decreases.
dataset['20std'] = dataset[key].rolling(20).std()
dataset['upper_band'] = dataset['ma21'] + (dataset['20std'] * 2)
dataset['lower_band'] = dataset['ma21'] - (dataset['20std'] * 2)
# Create Exponential moving average
dataset['ema'] = dataset[key].ewm(com=0.5).mean()
# Create Momentum
dataset['momentum_1'] = dataset[key].diff(1)
dataset['momentum_10'] = dataset[key].diff(10)
# close price raw return 1, 10 days horizon
# dataset['returnsClosePrevRaw1'] = dataset['Close'].pct_change(1)
# dataset['returnsClosePrevRaw10'] = dataset['Close'].pct_change(10)
# open price raw return 1, 10 days horizon
# dataset['returnsOpenPrevRaw1'] = dataset['Open'].pct_change(1)
# dataset['returnsOpenPrevRaw10'] = dataset['Open'].pct_change(10)
# Create AROON - identifing when trends are likely to change direction, n=20
dataset['aroon_up_20'] = dataset[key].rolling(20, min_periods=0).apply(lambda x: float(np.argmax(x) + 1) / 20 * 100,
raw=True)
dataset['aroon_down_20'] = dataset[key].rolling(20, min_periods=0).apply(
lambda x: float(np.argmin(x) + 1) / 20 * 100, raw=True)
# Create CCI, Commodity Channel Index
pp = (dataset['High'] + dataset['Low'] + dataset[key]) / 3.0
dataset['cci'] = (pp - pp.rolling(20, min_periods=0).mean()) / (0.015 * pp.rolling(20, min_periods=0).std())
# Create STOCH - Stochastic Oscillator
smin = dataset['Low'].rolling(14, min_periods=0).min()
smax = dataset['High'].rolling(14, min_periods=0).max()
dataset['stoch'] = 100 * (dataset[key] - smin) / (smax - smin)
# Create RSI - Relative Strength Index
dataset['rsi'] = rsi(dataset[key])
# Create ADI - Accumulation/Distribution Index
dataset['adi'] = acc_dist_index(dataset['High'], dataset['Low'], dataset[key], dataset['Volume'])
# Create OBV - On-balance volume
dataset['obv'] = on_balance_volume(dataset[key], dataset['Volume'])
return dataset
def RSI(df, col_name, intervals):
"""
Relative Stock index
"""
from ta.momentum import rsi
from tqdm.auto import tqdm
for interval in tqdm(intervals):
df["rsi_" + str(interval)] = rsi(df[col_name], n=interval)
def on_message_funct(ws, message):
global candle_close_prices # reference global variables
json_message = json.loads(
message
) # takes json message received from websocket and decodes to python
candle = json_message['k'] # unpacking required data
is_candle_closed = candle['x']
close = candle['c']
if is_candle_closed is True: # collecting the required data
candle_close_prices.append(close)
np_candle_close_prices = numpy.array(candle_close_prices)
start_point = len(np_candle_close_prices)
print(start_point)
print('candle closed at {}'.format(close))
print('np_candle_close_prices')
print(np_candle_close_prices)
if start_point > rsi_period: # creating an rsi !!!!!!!!!!!!!!!!
print('URA')
my_rsi = rsi(np_candle_close_prices, rsi_period, False)
last_rsi = my_rsi[0][-1]
print('all rsis are calculated to far')
print(my_rsi)
print('the last rsi is {}'.format(last_rsi))
if last_rsi > rsi_overbought: # execute selling order
if in_position is True:
print('!!!!! SELL !!!!!')
order_succeeded = order(side=SIDE_SELL)
if order_succeeded is True:
in_position = False
else:
print('It is overbought, but you are not in position')
if last_rsi < rsi_oversold: # execute buying order
if in_position is True:
print('It is oversold, but you are already in position')
else:
print('!!!!! BUY !!!!!')
order_succeeded = order(side=SIDE_BUY)
if order_succeeded is True:
in_position = True
def RSI(datos, start, end= '', window = 10, colName = 'Adj Close'):
'''
ENTRADA
datos: Pandas dataframe que contiene al menos una columna de fechas (DATE) y otra
columna numérica
start, end: strings en formato 'YYYY-MM-DD' representando la fecha de inicio
y la fecha final respectivamente
window: Entero que representa la ventan de tiempo a utilizar
colName: String que representa el nombre de la columna con la cual se calculará el indicador
SALIDA
resultado: Dataframe datos con una columna extra conteniendo la información
del indicador
'''
#Localiza la fecha de inicio y revisa si hay suficiente información
indiceInicio=datos[datos['Date']==start].index[0]
if window > indiceInicio + 1:
print 'No hay suficiente historia para esta fecha'
return datos
#Último índice
if end=='':
lastIndex=datos.shape[0] - 1
else:
lastIndex=datos[datos['Date']==end].index[0]
#calcula el indicador
indicador = rsi(datos[colName], window)
#agrega la nueva columna
resultado = deepcopy(datos)
resName = colName + '-RSI-' + str(window)
resultado[resName] = indicador
#Filtra a partir del índice correspondiente a la fecha start
resultado=resultado.iloc[indiceInicio:lastIndex+1,:]
resultado=resultado.reset_index(drop=True)
#añade metadatos
resultado.tipo = 'rsi'
resultado.resName = resName
return resultado
def main():
parser = argparse.ArgumentParser("RSI Alert")
parser.add_argument("coins", type=str, nargs="+")
parser.add_argument("--verbose", "-v", action="count", default=0)
args = parser.parse_args()
log_level = (3 - min(args.verbose, 2)) * 10
logging.basicConfig(level=log_level)
logging.debug(f"{args=}")
iteration = 0
while True:
iteration += 1
print(f"\n-- Iteration {iteration} --\n")
for coin in args.coins:
updating_message = f"Updating {coin}"
logging.info(updating_message)
print(updating_message)
series = yf.download(tickers=f"{coin.upper()}-USD",
period="22h",
interval="1m")
logging.debug(f"{series=}")
closes = series["Close"]
closes = closes.loc[closes != 0]
logging.info(f"Series fetched for {coin=}")
logging.debug(f"{closes=}")
rsi_series = rsi(closes)
logging.info(f"Calculated rsi for {coin=}")
rsi_series = rsi_series.dropna()
logging.debug(f"{rsi_series=}")
last_rsi_val = int(rsi_series.iloc[-1])
logging.info(f"{last_rsi_val=}")
if last_rsi_val < 30 or last_rsi_val > 70:
print(f"-- RSI ALERT for {coin}: {last_rsi_val} --\n")
logging.info(f"RSI value alert for {coin}: {last_rsi_val}")
alert()
time.sleep(60)
def apply_rsi(df, time_period, on_data="close"):
"""
calculate the RSI on specified data type. return df with columns added.
Parameters:
df : pandas dataframe of ohlcv data
time_period : iterable of length 2, specifying the range to vary the window
on_data : str of data to calculate macd indicator on
"""
ensure_correct_data_calculation_choice(on_data)
df_new = pd.DataFrame(index=df.index)
for period in range(time_period[0], time_period[1]):
df_new["RSI_Period_" + str(period)] = rsi(df[on_data],
n=period,
fillna=True)
return df_new
def S_RSI14(self, ticker):
dailydata = self.rawdata.loc[self.rawdata['Symbol'] == ticker]
rsi = momentum.rsi(dailydata.Close, n=14, fillna=True)
if rsi[-1] < 40 or rsi[-1] > 60:
interest = abs(((rsi[-1] / 100 - 0.5) * 2))**(1 / 3)
else:
return 0, ""
if abs(rsi[-1] - 50) > 20:
adj = "Strongly"
else:
adj = "moderately"
if rsi[-1] > 50:
state = "overbought"
else:
state = "oversold"
statement = "{ticker}'s 14 day RSI is indicating that it is {adj} {state}".format(
ticker=ticker, adj=adj, state=state)
return interest, statement
def apply_rsi(self, time_period, on_data="close"):
"""
calculate the RSI on specified data type. return df with columns added.
Parameters:
df : pandas dataframe of ohlcv data
time_period : iterable of length 2, specifying the range to vary the window
on_data : str of data to calculate macd indicator on
"""
assert len(
time_period) == 2, "time_period must have a start and and end"
self._ensure_data_calculation_choice(on_data)
self.rsi = pd.DataFrame(index=self.data.index)
for period in tqdm(range(time_period[0], time_period[1]),
desc="Applying RSI parameters"):
self.rsi["RSI_" + str(period) + "_period"] = rsi(
self.data[on_data], n=period)
def marketChoice(interval):
products = client.get_products()
#market = 'MATICUSDT'
data = products['data']
criptos = []
for elemento in data:
#print(elemento['symbol'], elemento['market'])
if elemento['market'] == 'USDT':
criptos.append(elemento['symbol'])
#print(criptos)
print("Elejimos las USDT")
ascendientes = []
# tickers = client.get_ticker(symbol='OGNUSDT')
for i in criptos:
try:
#print(i)
tickers = client.get_ticker(symbol=i)
#print(tickers)
#print(float(tickers['quoteVolume']))
if float(tickers['quoteVolume']) > 700000: #float(tickers['priceChangePercent']) >= 0.3 and
ascendientes.append([tickers['symbol'], tickers['priceChangePercent']])
except:
pass
#print(len(ascendientes))
print("Tenemos los Ascendientes")
#print(ascendientes)
"""
ascendientes = ['VETUSDT', 'MATICUSDT', 'XLMUSDT', 'BULLUSDT'] #, 'TRXUSDT', 'IOSTUSDT'
#'EOSUSDT'] # , 'ETCUSDT', 'BNBUSDT', 'XLMUSDT', 'MATICUSDT']
"""
markets = []
#ascendientes = ['VETUSDT', 'MATICUSDT', 'BULLUSDT', 'BEARUSDT', 'XLMUSDT', 'TRXUSDT', 'ICXUSDT']
for j, k in ascendientes:
dataset = client.get_klines(symbol=j, interval=interval, limit=20)
data = pd.DataFrame(dataset, dtype=float)
data.pop(1)
data = data.iloc[:, :5]
data = data.rename(
columns={0: "FechaApertura", 2: 'ValorMaximo', 3: 'ValorMinimo', 4: 'Cierre', 5: 'Volumen'})
columns = ['FechaApertura', 'ValorMaximo', 'ValorMinimo', 'Cierre', 'Volumen']
data = data[columns]
#a = len(data.index)
#row = [fecha, maximo, minimo, cierre, volumen]
# print(data.loc[len(data.index)])
#data.loc[len(data.index)] = row
data = pd.DataFrame(data, dtype=float)
valorMaximo = data['ValorMaximo']
valorMinimo = data['ValorMinimo']
cierre = data['Cierre']
volumen = data['Volumen']
fecha = data['FechaApertura']
a = len(data.index) - 1
rsi = momentum.rsi(cierre, n=14, fillna=False)
mfi = momentum.money_flow_index(valorMaximo, valorMinimo, cierre, volumen, n=14, fillna=True)
boll_high = volatility.bollinger_hband(cierre, n=20, ndev=2, fillna=True)
#boll_low = volatility.bollinger_lband(cierre, n=20, ndev=2, fillna=True)
ganancia = abs(((cierre[a] * 100) / boll_high[a]) - 100)
print(j, rsi[a-1], rsi[a], ganancia)
print(j, mfi[a-1], mfi[a], ganancia)
if 28 >= mfi[a] > mfi[a - 1] and ganancia > 0.5 and rsi[a-1] < rsi[a] < 40:
markets.append(j)
print(markets)
if len(markets) != 0:
market = random.choice(markets)
print("Imprime el mercado elegido: " + market)
#### VALIDAMOS LA TABLA PARA LA MONEDA SELECCIONADA
return market
else:
print("No se han encontrado Mercados disponibles")
return False
#validTable(market)
#### CREAMOS UNA INSTANCIA DE LA CLASE DE COMUNICACION CON EL WEBSOCKET
"""se hardcodea el mercado para volver a una tabla donde se quiere seguir"""
#market = ['VETUSDT', 'MATICUSDT', 'XLMUSDT', 'BULLUSDT', 'BEARUSDT']
#market = 'VETUSDT'
#market = random.choice(market)
print("Imprime el mercado elegido: " + market)
#market = 'XLMUSDT'
return market
from ta.momentum import rsi
if __name__ == "__main__":
_rsi14 = rsi(Closes, 14)
def __dataframe(self):
"""Create an comprehensive list of from data.
Args:
None
Returns:
result: dataframe for learning
"""
# Calculate the percentage and real differences between columns
difference = math.Difference(self._ohlcv)
num_difference = difference.actual()
pct_difference = difference.relative()
# Create result to return.
result = pd.DataFrame()
# Add current value columns
result['open'] = self._ohlcv['open']
result['high'] = self._ohlcv['high']
result['low'] = self._ohlcv['low']
result['close'] = self._ohlcv['close']
result['volume'] = self._ohlcv['volume']
# Add columns of differences
result['num_diff_open'] = num_difference['open']
result['num_diff_high'] = num_difference['high']
result['num_diff_low'] = num_difference['low']
result['num_diff_close'] = num_difference['close']
result['pct_diff_open'] = pct_difference['open']
result['pct_diff_high'] = pct_difference['high']
result['pct_diff_low'] = pct_difference['low']
result['pct_diff_close'] = pct_difference['close']
result['pct_diff_volume'] = pct_difference['volume']
# Add date related columns
# result['day'] = self._dates.day
result['weekday'] = self._dates.weekday
# result['week'] = self._dates.week
result['month'] = self._dates.month
result['quarter'] = self._dates.quarter
# result['dayofyear'] = self._dates.dayofyear
# Moving averages
result['ma_open'] = result['open'].rolling(
self._globals['ma_window']).mean()
result['ma_high'] = result['high'].rolling(
self._globals['ma_window']).mean()
result['ma_low'] = result['low'].rolling(
self._globals['ma_window']).mean()
result['ma_close'] = result['close'].rolling(
self._globals['ma_window']).mean()
result['ma_volume'] = result['volume'].rolling(
self._globals['vma_window']).mean()
result['ma_volume_long'] = result['volume'].rolling(
self._globals['vma_window_long']).mean()
result[
'ma_volume_delta'] = result['ma_volume_long'] - result['ma_volume']
# Standard deviation related
result['ma_std_close'] = result['close'].rolling(
self._globals['ma_window']).std()
result['std_pct_diff_close'] = result['pct_diff_close'].rolling(
self._globals['ma_window']).std()
result['bollinger_lband'] = volatility.bollinger_lband(result['close'])
result['bollinger_hband'] = volatility.bollinger_lband(result['close'])
result[
'bollinger_lband_indicator'] = volatility.bollinger_lband_indicator(
result['close'])
result[
'bollinger_hband_indicator'] = volatility.bollinger_hband_indicator(
result['close'])
# Rolling ranges
result['amplitude'] = result['high'] - result['low']
_min = result['low'].rolling(self._globals['week']).min()
_max = result['high'].rolling(self._globals['week']).max()
result['amplitude_medium'] = abs(_min - _max)
_min = result['low'].rolling(2 * self._globals['week']).min()
_max = result['high'].rolling(2 * self._globals['week']).max()
result['amplitude_long'] = abs(_min - _max)
_min = result['volume'].rolling(self._globals['week']).min()
_max = result['volume'].rolling(self._globals['week']).max()
result['vol_amplitude'] = abs(_min - _max)
_min = result['volume'].rolling(2 * self._globals['week']).min()
_max = result['volume'].rolling(2 * self._globals['week']).max()
result['vol_amplitude_long'] = abs(_min - _max)
# Volume metrics
result['force_index'] = volume.force_index(result['close'],
result['volume'])
result['negative_volume_index'] = volume.negative_volume_index(
result['close'], result['volume'])
result['ease_of_movement'] = volume.ease_of_movement(
result['high'], result['low'], result['close'], result['volume'])
result['acc_dist_index'] = volume.acc_dist_index(
result['high'], result['low'], result['close'], result['volume'])
result['on_balance_volume'] = volume.on_balance_volume(
result['close'], result['volume'])
result['on_balance_volume_mean'] = volume.on_balance_volume(
result['close'], result['volume'])
result['volume_price_trend'] = volume.volume_price_trend(
result['close'], result['volume'])
# Calculate the Stochastic values
result['k'] = momentum.stoch(result['high'],
result['low'],
result['close'],
n=self._globals['kwindow'])
result['d'] = momentum.stoch_signal(result['high'],
result['low'],
result['close'],
n=self._globals['kwindow'],
d_n=self._globals['dwindow'])
# Calculate the Miscellaneous values
result['rsi'] = momentum.rsi(result['close'],
n=self._globals['rsiwindow'],
fillna=False)
miscellaneous = math.Misc(self._ohlcv)
result['proc'] = miscellaneous.proc(self._globals['proc_window'])
# Calculate ADX
result['adx'] = trend.adx(result['high'],
result['low'],
result['close'],
n=self._globals['adx_window'])
# Calculate MACD difference
result['macd_diff'] = trend.macd_diff(
result['close'],
n_fast=self._globals['macd_sign'],
n_slow=self._globals['macd_slow'],
n_sign=self._globals['macd_sign'])
# Create series for increasing / decreasing closes (Convert NaNs to 0)
_result = np.nan_to_num(result['pct_diff_close'].values)
_increasing = (_result >= 0).astype(int) * self._buy
_decreasing = (_result < 0).astype(int) * self._sell
result['increasing'] = _increasing + _decreasing
# Stochastic subtraciton
result['k_d'] = pd.Series(result['k'].values - result['d'].values)
# Other indicators
result['k_i'] = self._stochastic_indicator(result['k'], result['high'],
result['low'],
result['ma_close'])
result['d_i'] = self._stochastic_indicator(result['d'], result['high'],
result['low'],
result['ma_close'])
result['stoch_i'] = self._stochastic_indicator_2(
result['k'], result['d'], result['high'], result['low'],
result['ma_close'])
result['rsi_i'] = self._rsi_indicator(result['rsi'], result['high'],
result['low'],
result['ma_close'])
result['adx_i'] = self._adx_indicator(result['adx'])
result['macd_diff_i'] = self._macd_diff_indicator(result['macd_diff'])
result['volume_i'] = self._volume_indicator(result['ma_volume'],
result['ma_volume_long'])
# Create time shifted columns
for step in range(1, self._ignore_row_count + 1):
# result['t-{}'.format(step)] = result['close'].shift(step)
result['tpd-{}'.format(step)] = result['close'].pct_change(
periods=step)
# result['tad-{}'.format(step)] = result[
# 'close'].diff(periods=step)
# Mask increasing with
result['increasing_masked'] = _mask(result['increasing'].to_frame(),
result['stoch_i'],
as_integer=True).values
# Get class values for each vector
classes = pd.DataFrame(columns=self._shift_steps)
for step in self._shift_steps:
# Shift each column by the value of its label
classes[step] = result[self._label2predict].shift(-step)
# Remove all undesirable columns from the dataframe
undesired_columns = ['open', 'close', 'high', 'low', 'volume']
for column in undesired_columns:
result = result.drop(column, axis=1)
# Delete the firsts row of the dataframe as it has NaN values from the
# .diff() and .pct_change() operations
result = result.iloc[self._ignore_row_count:]
classes = classes.iloc[self._ignore_row_count:]
# Convert result to float32 to conserve memory
result = result.astype(np.float32)
# Return
return result, classes
def test_rsi2(self):
target = 'RSI'
result = rsi(**self._params)
pd.testing.assert_series_equal(self._df[target].tail(),
result.tail(),
check_names=False)
def RSI(df0):
df = df0
df['rsi'] = rsi(df['close'], 10, fillna=False)
return df
def __dataframe(self):
"""Create vectors from data.
Args:
shift_steps: List of steps
Returns:
result: dataframe for learning
"""
# Calculate the percentage and real differences between columns
difference = math.Difference(self._file_values())
num_difference = difference.actual()
pct_difference = difference.relative()
# Create result to return.
# Make sure it is float16 for efficient computing
result = pd.DataFrame(columns=[
'open', 'high', 'low', 'close', 'volume', 'increasing',
'weekday', 'day', 'dayofyear', 'quarter', 'month', 'num_diff_open',
'num_diff_high', 'num_diff_low', 'num_diff_close', 'pct_diff_open',
'pct_diff_high', 'pct_diff_low', 'pct_diff_close',
'k', 'd', 'rsi', 'adx', 'macd_diff', 'proc',
'ma_open', 'ma_high', 'ma_low', 'ma_close',
'ma_volume', 'ma_volume_long',
'ma_volume_delta']).astype('float16')
# Add current value columns
result['open'] = self._file_values()['open']
result['high'] = self._file_values()['high']
result['low'] = self._file_values()['low']
result['close'] = self._file_values()['close']
result['volume'] = self._file_values()['volume']
# Add columns of differences
result['num_diff_open'] = num_difference['open']
result['num_diff_high'] = num_difference['high']
result['num_diff_low'] = num_difference['low']
result['num_diff_close'] = num_difference['close']
result['pct_diff_open'] = pct_difference['open']
result['pct_diff_high'] = pct_difference['high']
result['pct_diff_low'] = pct_difference['low']
result['pct_diff_close'] = pct_difference['close']
result['pct_diff_volume'] = pct_difference['volume']
# Add date related columns
result['day'] = self.dates().day
result['weekday'] = self.dates().weekday
result['week'] = self.dates().week
result['month'] = self.dates().month
result['quarter'] = self.dates().quarter
result['dayofyear'] = self.dates().dayofyear
# Moving averages
result['ma_open'] = result['open'].rolling(
self._globals['ma_window']).mean()
result['ma_high'] = result['high'].rolling(
self._globals['ma_window']).mean()
result['ma_low'] = result['low'].rolling(
self._globals['ma_window']).mean()
result['ma_close'] = result['close'].rolling(
self._globals['ma_window']).mean()
result['ma_volume'] = result['volume'].rolling(
self._globals['vma_window']).mean()
result['ma_volume_long'] = result['volume'].rolling(
self._globals['vma_window_long']).mean()
result['ma_volume_delta'] = result[
'ma_volume_long'] - result['ma_volume']
# Calculate the Stochastic values
stochastic = math.Stochastic(
self._file_values(), window=self._globals['kwindow'])
result['k'] = stochastic.k()
result['d'] = stochastic.d(window=self._globals['dwindow'])
# Calculate the Miscellaneous values
result['rsi'] = momentum.rsi(
result['close'],
n=self._globals['rsiwindow'],
fillna=False)
miscellaneous = math.Misc(self._file_values())
result['proc'] = miscellaneous.proc(self._globals['proc_window'])
# Calculate ADX
result['adx'] = trend.adx(
result['high'],
result['low'],
result['close'],
n=self._globals['adx_window'])
# Calculate MACD difference
result['macd_diff'] = trend.macd_diff(
result['close'],
n_fast=self._globals['macd_sign'],
n_slow=self._globals['macd_slow'],
n_sign=self._globals['macd_sign'])
# Create series for increasing / decreasing closes (Convert NaNs to 0)
_result = np.nan_to_num(result['pct_diff_close'].values)
_increasing = (_result >= 0).astype(int) * 1
_decreasing = (_result < 0).astype(int) * 0
result['increasing'] = _increasing + _decreasing
# Delete the first row of the dataframe as it has NaN values from the
# .diff() and .pct_change() operations
result = result.iloc[self._ignore_row_count:]
# Return
return result
def AddIndicators(df):
# Add Relative Strength Index (RSI) indicator
df["RSI"] = rsi(close=df["Close"], window=14, fillna=True)
return df
def __dataframe(self):
"""Create an comprehensive list of from data.
Args:
None
Returns:
result: dataframe for learning
"""
# Calculate the percentage and real differences between columns
difference = math.Difference(self._ohlcv)
num_difference = difference.actual()
pct_difference = difference.relative()
# Create result to return.
result = pd.DataFrame()
# Add current value columns
# NOTE Close must be first for correct correlation column dropping
result['close'] = self._ohlcv['close']
result['open'] = self._ohlcv['open']
result['high'] = self._ohlcv['high']
result['low'] = self._ohlcv['low']
result['volume'] = self._ohlcv['volume']
# Add columns of differences
# NOTE Close must be first for correct correlation column dropping
result['num_diff_close'] = num_difference['close']
result['pct_diff_close'] = pct_difference['close']
result['num_diff_open'] = num_difference['open']
result['pct_diff_open'] = pct_difference['open']
result['num_diff_high'] = num_difference['high']
result['pct_diff_high'] = pct_difference['high']
result['num_diff_low'] = num_difference['low']
result['pct_diff_low'] = pct_difference['low']
result['pct_diff_volume'] = pct_difference['volume']
# Add date related columns
# result['day'] = self._dates.day
result['weekday'] = self._dates.weekday
# result['week'] = self._dates.week
result['month'] = self._dates.month
result['quarter'] = self._dates.quarter
# result['dayofyear'] = self._dates.dayofyear
# Moving averages
result['ma_open'] = result['open'].rolling(
self._globals['ma_window']).mean()
result['ma_high'] = result['high'].rolling(
self._globals['ma_window']).mean()
result['ma_low'] = result['low'].rolling(
self._globals['ma_window']).mean()
result['ma_close'] = result['close'].rolling(
self._globals['ma_window']).mean()
result['ma_volume'] = result['volume'].rolling(
self._globals['vma_window']).mean()
result['ma_volume_long'] = result['volume'].rolling(
self._globals['vma_window_long']).mean()
result['ma_volume_delta'] = result[
'ma_volume_long'] - result['ma_volume']
# Standard deviation related
result['ma_std_close'] = result['close'].rolling(
self._globals['ma_window']).std()
result['std_pct_diff_close'] = result['pct_diff_close'].rolling(
self._globals['ma_window']).std()
result['bollinger_lband'] = volatility.bollinger_lband(result['close'])
result['bollinger_hband'] = volatility.bollinger_lband(result['close'])
result['bollinger_lband_indicator'] = volatility.bollinger_lband_indicator(result['close'])
result['bollinger_hband_indicator'] = volatility.bollinger_hband_indicator(result['close'])
# Rolling ranges
result['amplitude'] = result['high'] - result['low']
_min = result['low'].rolling(
self._globals['week']).min()
_max = result['high'].rolling(
self._globals['week']).max()
result['amplitude_medium'] = abs(_min - _max)
_min = result['low'].rolling(
2 * self._globals['week']).min()
_max = result['high'].rolling(
2 * self._globals['week']).max()
result['amplitude_long'] = abs(_min - _max)
_min = result['volume'].rolling(
self._globals['week']).min()
_max = result['volume'].rolling(
self._globals['week']).max()
result['vol_amplitude'] = abs(_min - _max)
_min = result['volume'].rolling(
2 * self._globals['week']).min()
_max = result['volume'].rolling(
2 * self._globals['week']).max()
result['vol_amplitude_long'] = abs(_min - _max)
# Volume metrics
result['force_index'] = volume.force_index(
result['close'], result['volume'])
result['negative_volume_index'] = volume.negative_volume_index(
result['close'], result['volume'])
result['ease_of_movement'] = volume.ease_of_movement(
result['high'], result['low'], result['close'], result['volume'])
result['acc_dist_index'] = volume.acc_dist_index(
result['high'], result['low'], result['close'], result['volume'])
result['on_balance_volume'] = volume.on_balance_volume(
result['close'], result['volume'])
result['on_balance_volume_mean'] = volume.on_balance_volume(
result['close'], result['volume'])
result['volume_price_trend'] = volume.volume_price_trend(
result['close'], result['volume'])
# Calculate the Stochastic values
result['k'] = momentum.stoch(
result['high'],
result['low'],
result['close'],
n=self._globals['kwindow'])
result['d'] = momentum.stoch_signal(
result['high'],
result['low'],
result['close'],
n=self._globals['kwindow'],
d_n=self._globals['dwindow'])
# Calculate the Miscellaneous values
result['rsi'] = momentum.rsi(
result['close'],
n=self._globals['rsiwindow'],
fillna=False)
miscellaneous = math.Misc(self._ohlcv)
result['proc'] = miscellaneous.proc(self._globals['proc_window'])
# Calculate ADX
result['adx'] = trend.adx(
result['high'],
result['low'],
result['close'],
n=self._globals['adx_window'])
# Calculate MACD difference
result['macd_diff'] = trend.macd_diff(
result['close'],
n_fast=self._globals['macd_sign'],
n_slow=self._globals['macd_slow'],
n_sign=self._globals['macd_sign'])
# Create series for increasing / decreasing closes (Convert NaNs to 0)
_result = np.nan_to_num(result['pct_diff_close'].values)
_increasing = (_result >= 0).astype(int) * self._buy
_decreasing = (_result < 0).astype(int) * self._sell
result['increasing'] = _increasing + _decreasing
# Stochastic subtraciton
result['k_d'] = pd.Series(result['k'].values - result['d'].values)
# Other indicators
result['k_i'] = self._stochastic_indicator(
result['k'], result['high'], result['low'], result['ma_close'])
result['d_i'] = self._stochastic_indicator(
result['d'], result['high'], result['low'], result['ma_close'])
result['stoch_i'] = self._stochastic_indicator_2(
result['k'], result['d'],
result['high'], result['low'], result['ma_close'])
result['rsi_i'] = self._rsi_indicator(
result['rsi'], result['high'], result['low'], result['ma_close'])
result['adx_i'] = self._adx_indicator(result['adx'])
result['macd_diff_i'] = self._macd_diff_indicator(result['macd_diff'])
result['volume_i'] = self._volume_indicator(
result['ma_volume'], result['ma_volume_long'])
# Create time shifted columns
for step in range(1, self._ignore_row_count + 1):
result['t-{}'.format(step)] = result['close'].shift(step)
result['tpd-{}'.format(step)] = result[
'close'].pct_change(periods=step)
result['tad-{}'.format(step)] = result[
'close'].diff(periods=step)
# Mask increasing with
result['increasing_masked'] = _mask(
result['increasing'].to_frame(),
result['stoch_i'],
as_integer=True).values
# Get class values for each vector
classes = pd.DataFrame(columns=self._shift_steps)
for step in self._shift_steps:
# Shift each column by the value of its label
if self._binary is True:
# Classes need to be 0 or 1 (One hot encoding)
classes[step] = (
result[self._label2predict].shift(-step) > 0).astype(int)
else:
classes[step] = result[self._label2predict].shift(-step)
# classes[step] = result[self._label2predict].shift(-step)
# Delete the firsts row of the dataframe as it has NaN values from the
# .diff() and .pct_change() operations
ignore = max(max(self._shift_steps), self._ignore_row_count)
result = result.iloc[ignore:]
classes = classes.iloc[ignore:]
# Convert result to float32 to conserve memory
result = result.astype(np.float32)
# Return
return result, classes
def RSI(klines):
rsi = momentum.rsi(klines['close'], n=14)
return rsi.iloc[-1], klines['close'].iloc[-1]
def engineer_data_over_single_interval(df: pd.DataFrame,
indicators: list,
ticker: str = "",
rsi_n: int = 14,
cmo_n: int = 7,
macd_fast: int = 12,
macd_slow: int = 26,
macd_sign: int = 9,
roc_n: int = 12,
cci_n: int = 20,
dpo_n: int = 20,
cmf_n: int = 20,
adx_n: int = 14,
mass_index_low: int = 9,
mass_index_high: int = 25,
trix_n: int = 15,
stochastic_oscillator_n: int = 14,
stochastic_oscillator_sma_n: int = 3,
ultimate_oscillator_short_n: int = 7,
ultimate_oscillator_medium_n: int = 14,
ultimate_oscillator_long_n: int = 28,
ao_short_n: int = 5,
ao_long_n: int = 34,
kama_n: int = 10,
tsi_high_n: int = 25,
tsi_low_n: int = 13,
eom_n: int = 14,
force_index_n: int = 13,
ichimoku_low_n: int = 9,
ichimoku_medium_n: int = 26):
from ta.momentum import rsi, wr, roc, ao, stoch, uo, kama, tsi
from ta.trend import macd, macd_signal, cci, dpo, adx, mass_index, trix, ichimoku_a
from ta.volume import chaikin_money_flow, acc_dist_index, ease_of_movement, force_index
# Momentum Indicators
if Indicators.RELATIVE_STOCK_INDEX in indicators:
Logger.console_log(message="Calculating " +
Indicators.RELATIVE_STOCK_INDEX.value +
" for stock " + ticker,
status=Logger.LogStatus.EMPHASIS)
df[Indicators.RELATIVE_STOCK_INDEX.value] = rsi(close=df['close'],
n=rsi_n)
if Indicators.WILLIAMS_PERCENT_RANGE in indicators:
Logger.console_log(message="Calculating " +
Indicators.WILLIAMS_PERCENT_RANGE.value +
" for stock " + ticker,
status=Logger.LogStatus.EMPHASIS)
df[Indicators.WILLIAMS_PERCENT_RANGE.value] = wr(
df['high'], df['low'], df['close'])
if Indicators.CHANDE_MOMENTUM_OSCILLATOR in indicators:
Logger.console_log(message="Calculating " +
Indicators.CHANDE_MOMENTUM_OSCILLATOR.value +
" for stock " + ticker,
status=Logger.LogStatus.EMPHASIS)
df[Indicators.CHANDE_MOMENTUM_OSCILLATOR.
value] = chande_momentum_oscillator(close_data=df['close'],
period=cmo_n)
if Indicators.RATE_OF_CHANGE in indicators:
Logger.console_log(message="Calculating " +
Indicators.RATE_OF_CHANGE.value + " for stock " +
ticker,
status=Logger.LogStatus.EMPHASIS)
df[Indicators.RATE_OF_CHANGE.value] = roc(close=df['close'], n=roc_n)
if Indicators.STOCHASTIC_OSCILLATOR in indicators:
Logger.console_log(message="Calculating " +
Indicators.STOCHASTIC_OSCILLATOR.value +
" for stock " + ticker,
status=Logger.LogStatus.EMPHASIS)
df[Indicators.STOCHASTIC_OSCILLATOR.value] = stoch(
high=df['high'],
low=df['low'],
close=df['close'],
n=stochastic_oscillator_n,
d_n=stochastic_oscillator_sma_n)
if Indicators.ULTIMATE_OSCILLATOR in indicators:
Logger.console_log(message="Calculating " +
Indicators.ULTIMATE_OSCILLATOR.value +
" for stock " + ticker,
status=Logger.LogStatus.EMPHASIS)
df[Indicators.ULTIMATE_OSCILLATOR.value] = uo(
high=df['high'],
low=df['low'],
close=df['close'],
s=ultimate_oscillator_short_n,
m=ultimate_oscillator_medium_n,
len=ultimate_oscillator_long_n)
if Indicators.AWESOME_OSCILLATOR in indicators:
Logger.console_log(message="Calculating " +
Indicators.AWESOME_OSCILLATOR.value +
" for stock " + ticker,
status=Logger.LogStatus.EMPHASIS)
df[Indicators.AWESOME_OSCILLATOR.value] = ao(high=df['high'],
low=df['low'],
s=ao_short_n,
len=ao_long_n)
if Indicators.KAUFMAN_ADAPTIVE_MOVING_AVERAGE in indicators:
Logger.console_log(message="Calculating " +
Indicators.KAUFMAN_ADAPTIVE_MOVING_AVERAGE.value +
" for stock " + ticker,
status=Logger.LogStatus.EMPHASIS)
df[Indicators.KAUFMAN_ADAPTIVE_MOVING_AVERAGE.value] = kama(
close=df['close'], n=kama_n)
if Indicators.TRUE_STRENGTH_INDEX in indicators:
Logger.console_log(message="Calculating " +
Indicators.TRUE_STRENGTH_INDEX.value +
" for stock " + ticker,
status=Logger.LogStatus.EMPHASIS)
df[Indicators.TRUE_STRENGTH_INDEX.value] = tsi(close=df['close'],
r=tsi_high_n,
s=tsi_low_n)
# Trend Indicator
if Indicators.MOVING_AVERAGE_CONVERGENCE_DIVERGENCE in indicators:
Logger.console_log(
message="Calculating " +
Indicators.MOVING_AVERAGE_CONVERGENCE_DIVERGENCE.value +
" for stock " + ticker,
status=Logger.LogStatus.EMPHASIS)
df[Indicators.MOVING_AVERAGE_CONVERGENCE_DIVERGENCE.value] = macd(close=df['close'],
n_slow=macd_slow,
n_fast=macd_fast) - \
macd_signal(close=df['close'],
n_slow=macd_slow,
n_fast=macd_fast,
n_sign=macd_sign)
if Indicators.COMMODITY_CHANNEL_INDEX in indicators:
Logger.console_log(message="Calculating " +
Indicators.COMMODITY_CHANNEL_INDEX.value +
" for stock " + ticker,
status=Logger.LogStatus.EMPHASIS)
df[Indicators.COMMODITY_CHANNEL_INDEX.value] = cci(high=df['high'],
low=df['low'],
close=df['close'],
n=cci_n)
if Indicators.DETRENDED_PRICE_OSCILLATOR in indicators:
Logger.console_log(message="Calculating " +
Indicators.DETRENDED_PRICE_OSCILLATOR.value +
" for stock " + ticker,
status=Logger.LogStatus.EMPHASIS)
df[Indicators.DETRENDED_PRICE_OSCILLATOR.value] = dpo(
close=df['close'], n=dpo_n)
if Indicators.AVERAGE_DIRECTIONAL_INDEX in indicators:
Logger.console_log(message="Calculating " +
Indicators.AVERAGE_DIRECTIONAL_INDEX.value +
" for stock " + ticker,
status=Logger.LogStatus.EMPHASIS)
df[Indicators.AVERAGE_DIRECTIONAL_INDEX.value] = adx(high=df['high'],
low=df['low'],
close=df['close'],
n=adx_n)
if Indicators.MASS_INDEX in indicators:
Logger.console_log(message="Calculating " +
Indicators.MASS_INDEX.value + " for stock " +
ticker,
status=Logger.LogStatus.EMPHASIS)
df[Indicators.MASS_INDEX.value] = mass_index(high=df['high'],
low=df['low'],
n=mass_index_low,
n2=mass_index_high)
if Indicators.TRIPLE_EXPONENTIALLY_SMOOTHED_MOVING_AVERAGE in indicators:
Logger.console_log(
message="Calculating " +
Indicators.TRIPLE_EXPONENTIALLY_SMOOTHED_MOVING_AVERAGE.value +
" for stock " + ticker,
status=Logger.LogStatus.EMPHASIS)
df[Indicators.TRIPLE_EXPONENTIALLY_SMOOTHED_MOVING_AVERAGE.
value] = trix(close=df['close'], n=trix_n)
if Indicators.ICHIMOKU_A in indicators:
Logger.console_log(message="Calculating " +
Indicators.ICHIMOKU_A.value + " for stock " +
ticker,
status=Logger.LogStatus.EMPHASIS)
df[Indicators.ICHIMOKU_A.value] = ichimoku_a(high=df['high'],
low=df['low'],
n1=ichimoku_low_n,
n2=ichimoku_medium_n)
# Volume Indicator
if Indicators.CHAIKIN_MONEY_FLOW in indicators:
Logger.console_log(message="Calculating " +
Indicators.CHAIKIN_MONEY_FLOW.value +
" for stock " + ticker,
status=Logger.LogStatus.EMPHASIS)
df[Indicators.CHAIKIN_MONEY_FLOW.value] = chaikin_money_flow(
high=df['high'],
low=df['low'],
close=df['close'],
volume=df['volume'],
n=cmf_n)
if Indicators.ACCUMULATION_DISTRIBUTION_INDEX in indicators:
Logger.console_log(message="Calculating " +
Indicators.ACCUMULATION_DISTRIBUTION_INDEX.value +
" for stock " + ticker,
status=Logger.LogStatus.EMPHASIS)
df[Indicators.ACCUMULATION_DISTRIBUTION_INDEX.value] = acc_dist_index(
high=df['high'],
low=df['low'],
close=df['close'],
volume=df['volume'])
if Indicators.EASE_OF_MOVEMENT in indicators:
Logger.console_log(message="Calculating " +
Indicators.EASE_OF_MOVEMENT.value + " for stock " +
ticker,
status=Logger.LogStatus.EMPHASIS)
df[Indicators.EASE_OF_MOVEMENT.value] = ease_of_movement(
high=df['high'], low=df['low'], volume=df['volume'], n=eom_n)
if Indicators.FORCE_INDEX in indicators:
Logger.console_log(message="Calculating " +
Indicators.FORCE_INDEX.value + " for stock " +
ticker,
status=Logger.LogStatus.EMPHASIS)
df[Indicators.FORCE_INDEX.value] = force_index(close=df['close'],
volume=df['volume'],
n=force_index_n)
import pandas as pd
import numpy as np
from ta.momentum import money_flow_index
from ta.momentum import rsi # Relative Strength Index
from ta.momentum import stoch # Stochastic Oscilator
from ta.momentum import uo # Ultimate Oscilator
from ta.momentum import wr #William Percent Range
from ta.trend import macd # Moving Average Convergence/Divergence
# *************************** DATA PREPROCESSING ******************************
# Load Data
df = pd.read_csv('^GSPC.csv')
# Data Augmentation
df['Relative_Strength_Index'] = rsi(df['Close'])
df['Money_Flow_Index'] = money_flow_index(df['High'], df['Low'], df['Close'],
df['Volume'])
df['Stoch_Oscilator'] = stoch(df['High'], df['Low'], df['Close'])
df['Ultimate_Oscilator'] = uo(df['High'], df['Low'], df['Close'])
df['William_Percent'] = wr(df['High'], df['Low'], df['Close'])
df['MACD'] = macd(df['Close'])
# Some indicators require many days in advance before they produce any
# values. So the begining rows of our df may have NaNs. Lets drop them:
df = df.dropna()
# Scaling Data
from sklearn.preprocessing import MinMaxScalern
sc = MinMaxScaler(feature_range=(0, 1))
scaled_df = sc.fit_transform(df.iloc[:, 1:].values)
def get_ml_feature(self, symbol, prices=None, cutoff=None):
feature = {}
if prices:
price = prices.get(symbol, 1E10)
vix = prices['^VIX']
else:
price = self.closes[symbol][cutoff]
vix = self.closes['^VIX'][cutoff]
if cutoff:
close = self.closes[symbol][cutoff - DAYS_IN_A_YEAR:cutoff]
volume = self.volumes[symbol][cutoff - DAYS_IN_A_YEAR:cutoff]
else:
close = self.closes[symbol][-DAYS_IN_A_YEAR:]
volume = self.volumes[symbol][-DAYS_IN_A_YEAR:]
close = np.append(close, price)
# Log returns
feature['Day_1_Return'] = np.log(close[-1] / close[-2])
feature['Day_2_Return'] = np.log(close[-2] / close[-3])
feature['Day_3_Return'] = np.log(close[-3] / close[-4])
feature['Weekly_Return'] = np.log(price / close[-DAYS_IN_A_WEEK])
feature['Monthly_Return'] = np.log(price / close[-DAYS_IN_A_MONTH])
feature['Quarterly_Return'] = np.log(price / close[-DAYS_IN_A_QUARTER])
feature['From_Weekly_High'] = np.log(price /
np.max(close[-DAYS_IN_A_WEEK:]))
feature['From_Weekly_Low'] = np.log(price /
np.min(close[-DAYS_IN_A_WEEK:]))
# Technical indicators
pd_close = pd.Series(close)
feature['RSI'] = momentum.rsi(pd_close).values[-1]
feature['MACD_Rate'] = trend.macd_diff(pd_close).values[-1] / price
feature['TSI'] = momentum.tsi(pd_close).values[-1]
# Markets
feature['VIX'] = vix
# Other numerical factors
# Fit five data points to a second order polynomial
feature['Acceleration'] = (2 * close[-5] - 1 * close[-4] -
2 * close[-3] - 1 * close[-2] +
2 * close[-1]) / 14
feature['Momentum'] = (-2 * close[-5] - 1 * close[-4] + 1 * close[-2] +
2 * close[-1]) / 10
quarterly_returns = [
np.log(close[i] / close[i - 1])
for i in range(-DAYS_IN_A_QUARTER, -1)
]
monthly_returns = quarterly_returns[-DAYS_IN_A_MONTH:]
weekly_returns = quarterly_returns[-DAYS_IN_A_WEEK:]
feature['Monthly_Skewness'] = stats.skew(monthly_returns)
feature['Monthly_Volatility'] = np.std(monthly_returns)
feature['Weekly_Skewness'] = stats.skew(weekly_returns)
feature['Weekly_Volatility'] = np.std(weekly_returns)
feature['Z_Score'] = (
feature['Day_1_Return'] -
np.mean(quarterly_returns)) / np.std(quarterly_returns)
feature['Monthly_Avg_Dollar_Volume'] = np.average(
np.multiply(close[-DAYS_IN_A_MONTH - 1:-1],
volume[-DAYS_IN_A_MONTH:])) / 1E6
return feature
def bar():
history = fx.get_history(instrument=symbol,
timeframe="m1",
quotes_count=300)
# print (history)
if history.size != 0:
df = pd.DataFrame(history)
df = df[[
'Date',
'BidOpen',
'BidHigh',
'BidLow',
'BidClose',
'Volume',
]]
df.rename(columns={
'Date': "datetime",
'BidOpen': "open",
"BidHigh": "high",
"BidLow": "low",
"BidClose": "close",
'Volume': "volume",
},
inplace=True)
df['ema_f_h'] = trend.ema(df.high, periods=34)
df['ema_f_c'] = trend.ema(df.close, periods=34)
df['ema_f_l'] = trend.ema(df.low, periods=34)
df['ema_s_h'] = trend.ema(df.high, periods=144)
df['ema_s_c'] = trend.ema(df.close, periods=144)
df['ema_s_l'] = trend.ema(df.low, periods=144)
df['ema_across'] = np.where(df.ema_f_c > df.ema_s_c, int(1),
int(-1)) # 上穿1，下穿-1
# MACD(df, fast=55, slow=144, n=55)
df["macd"] = trend.MACD(df.close, n_slow=144, n_fast=34,
n_sign=34).macd()
df["macd_signal"] = trend.MACD(df.close,
n_slow=144,
n_fast=34,
n_sign=34).macd_signal()
df['macd_across'] = np.where(df.macd > df.macd_signal, int(1),
int(-1)) # 上穿1，下穿-1
df['rsi'] = momentum.rsi(
df.close,
n=34,
)
df['emarsi'] = trend.ema(df.rsi, periods=34)
df['rsi_postion'] = np.where(df.rsi > df.emarsi, int(1),
int(-1)) # 上穿1，下穿-1
# df['stoch'] = momentum.stoch(high=df["high"],low=df["low"],close=df["close"],n=144)
# df['stoch_signal'] = momentum.stoch_signal(high=df["high"],low=df["low"],close=df["close"],n=144)
# df["stoch_sig"] = np.where(df["stoch"] > df["stoch_signal"], 1, 0)
# df["stoch_sig_shfit"] = df["stoch_sig"].shift(1)
df['cci'] = trend.cci(
df.high,
df.low,
df.close,
n=55,
)
df['emacci'] = trend.ema(df.cci, periods=55)
df['cci_postion'] = np.where(df.cci > df.emacci, int(1),
int(-1)) # 上穿1，下穿-1
# 价格为于快线与慢线之上则为1，快慢线之下则为-1，其它为0
df["close_postion"] = np.where(
(df['close'] > df['ema_f_c']) & (df['close'] > df['ema_s_c']),
int(1),
np.where(
(df['close'] < df['ema_f_c']) & (df['close'] < df['ema_s_c']),
int(-1), int(0)))
return df
def __dataframe(self):
"""Create vectors from data.
Args:
shift_steps: List of steps
Returns:
result: dataframe for learning
"""
# Calculate the percentage and real differences between columns
difference = math.Difference(self._file_values())
num_difference = difference.actual()
pct_difference = difference.relative()
# Create result to return.
# Make sure it is float16 for efficient computing
result = pd.DataFrame(columns=[
'open', 'high', 'low', 'close', 'volume', 'increasing', 'weekday',
'day', 'dayofyear', 'quarter', 'month', 'num_diff_open',
'num_diff_high', 'num_diff_low', 'num_diff_close', 'pct_diff_open',
'pct_diff_high', 'pct_diff_low', 'pct_diff_close', 'k', 'd', 'rsi',
'adx', 'macd_diff', 'proc', 'ma_open', 'ma_high', 'ma_low',
'ma_close', 'ma_volume', 'ma_volume_long', 'ma_volume_delta'
]).astype('float16')
# Add current value columns
result['open'] = self._file_values()['open']
result['high'] = self._file_values()['high']
result['low'] = self._file_values()['low']
result['close'] = self._file_values()['close']
result['volume'] = self._file_values()['volume']
# Add columns of differences
result['num_diff_open'] = num_difference['open']
result['num_diff_high'] = num_difference['high']
result['num_diff_low'] = num_difference['low']
result['num_diff_close'] = num_difference['close']
result['pct_diff_open'] = pct_difference['open']
result['pct_diff_high'] = pct_difference['high']
result['pct_diff_low'] = pct_difference['low']
result['pct_diff_close'] = pct_difference['close']
result['pct_diff_volume'] = pct_difference['volume']
# Add date related columns
result['day'] = self.dates().day
result['weekday'] = self.dates().weekday
result['week'] = self.dates().week
result['month'] = self.dates().month
result['quarter'] = self.dates().quarter
result['dayofyear'] = self.dates().dayofyear
# Moving averages
result['ma_open'] = result['open'].rolling(
self._globals['ma_window']).mean()
result['ma_high'] = result['high'].rolling(
self._globals['ma_window']).mean()
result['ma_low'] = result['low'].rolling(
self._globals['ma_window']).mean()
result['ma_close'] = result['close'].rolling(
self._globals['ma_window']).mean()
result['ma_volume'] = result['volume'].rolling(
self._globals['vma_window']).mean()
result['ma_volume_long'] = result['volume'].rolling(
self._globals['vma_window_long']).mean()
result[
'ma_volume_delta'] = result['ma_volume_long'] - result['ma_volume']
# Calculate the Stochastic values
stochastic = math.Stochastic(self._file_values(),
window=self._globals['kwindow'])
result['k'] = stochastic.k()
result['d'] = stochastic.d(window=self._globals['dwindow'])
# Calculate the Miscellaneous values
result['rsi'] = momentum.rsi(result['close'],
n=self._globals['rsiwindow'],
fillna=False)
miscellaneous = math.Misc(self._file_values())
result['proc'] = miscellaneous.proc(self._globals['proc_window'])
# Calculate ADX
result['adx'] = trend.adx(result['high'],
result['low'],
result['close'],
n=self._globals['adx_window'])
# Calculate MACD difference
result['macd_diff'] = trend.macd_diff(
result['close'],
n_fast=self._globals['macd_sign'],
n_slow=self._globals['macd_slow'],
n_sign=self._globals['macd_sign'])
# Create series for increasing / decreasing closes (Convert NaNs to 0)
_result = np.nan_to_num(result['pct_diff_close'].values)
_increasing = (_result >= 0).astype(int) * 1
_decreasing = (_result < 0).astype(int) * 0
result['increasing'] = _increasing + _decreasing
# Delete the first row of the dataframe as it has NaN values from the
# .diff() and .pct_change() operations
result = result.iloc[self._ignore_row_count:]
# Return
return result
df['ema_across'] = np.where(df.ema_f_c > df.ema_s_c, int(1),
int(-1)) # 上穿1，下穿-1
# MACD(df, fast=55, slow=144, n=55)
df["macd"] = trend.MACD(df.close,
n_slow=144,
n_fast=34,
n_sign=34).macd()
df["macd_signal"] = trend.MACD(df.close,
n_slow=144,
n_fast=34,
n_sign=34).macd_signal()
df['macd_across'] = np.where(df.macd > df.macd_signal, int(1),
int(-1)) # 上穿1，下穿-1
df['rsi'] = momentum.rsi(
df.close,
n=34,
)
df['emarsi'] = trend.ema(df.rsi, periods=34)
df['rsi_postion'] = np.where(df.rsi > df.emarsi, int(1),
int(-1)) # 上穿1，下穿-1
# df['stoch'] = momentum.stoch(high=df["high"],low=df["low"],close=df["close"],n=144)
# df['stoch_signal'] = momentum.stoch_signal(high=df["high"],low=df["low"],close=df["close"],n=144)
# df["stoch_sig"] = np.where(df["stoch"] > df["stoch_signal"], 1, 0)
# df["stoch_sig_shfit"] = df["stoch_sig"].shift(1)
df['cci'] = trend.cci(
df.high,
df.low,
df.close,
n=55,
