def macd_crossOver(STK_data, fast, slow, signal):
'''
:Argument:
MACD dataframe
:Return type:
MACD with Crossover signal
'''
stock_data = stock(STK_data)
df = stock_data.MACD(fast, slow, signal)
try:
assert isinstance(df, pd.DataFrame) or isinstance(df, pd.Series)
#dataframe
if isinstance(df, pd.Series):
df = df.to_frame()
else:
pass
#1--> indicates buy position
#0 --> indicates sell posotion
df['result'] = np.nan
df['signal'] = np.where(df.MACD > df.MACD_SIGNAL, 1, 0)
df['result'] = np.where((df['signal'] == 1) & (df['MACD_HIST'] >= 0),
1, 0)
except IOError as e:
raise ('Dataframe required {}'.format(e))
finally:
print('*' * 40)
print('MACD signal generated')
print('*' * 40)
return df
def SuperTrend_signal(STK_data, multiplier, period):
'''
:Argument:
MACD dataframe
:Return type:
MACD with Crossover signal
'''
stock_data = stock(STK_data)
df = stock_data.SuperTrend(STK_data, multiplier, period)
try:
assert isinstance(df, pd.DataFrame) or isinstance(df, pd.Series)
#dataframe
if isinstance(df, pd.Series):
df = df.to_frame()
else:
pass
#1--> indicates buy position
#0 --> indicates sell posotion
df = df.fillna(0)
df['signal'] = np.nan
df['signal'] = np.where(stock_data.Close >= df.SuperTrend, 1, 0)
except IOError as e:
raise ('Dataframe required {}'.format(e))
finally:
print('*' * 40)
print('SuperTrend Signal generated')
print('*' * 40)
return df
def RSI_signal(STK_data, period, lw_bound, up_bound):
'''
:Arguments:
df: stock data
:Return type:
signal
'''
stock_data = stock(STK_data)
OHLC = stock_data.OHLC()
df = stock_data.CutlerRSI(OHLC, period)
assert isinstance(df, pd.Series) or isinstance(df, pd.DataFrame)
#convert to dataframe
if isinstance(df, pd.Series):
df = df.to_frame()
else:
pass
#get signal
#1--> indicates buy position
#0 --> indicates sell posotion
df['signal'] = np.zeros(df.shape[0])
pos = 0
for ij in df.loc[:, ['RSI_Cutler_' + str(period)]].values:
print(df.loc[:, ['RSI_Cutler_' + str(period)]].values[pos])
if df.loc[:, ['RSI_Cutler_' + str(period)]].values[pos] >= up_bound:
df['signal'][pos:] = 1 #uptrend
elif df.loc[:, ['RSI_Cutler_' + str(period)]].values[pos] <= lw_bound:
df['signal'][pos:] = 0 #downtrend
pos += 1
print('*' * 40)
print('RSI Signal Generation completed')
print('*' * 40)
return df
def bollinger_band_signal(STK_data, period, deviation, strategy=''):
'''
:Argument:
df:
:Return type:
:bollinger band signal
'''
stock_data = stock(STK_data)
Close = stock_data.Close
df = stock_data.Bolinger_Band(period, deviation)
df = df.fillna(value=0)
assert isinstance(df, pd.DataFrame) or isinstance(df, pd.Series)
#dataframe
if isinstance(df, pd.Series):
df = df.to_frame()
#get signal
#1--> indicates buy position
#0 --> indicates sell posotion
df['signal'] = np.zeros(df.shape[0])
pos = 0
try:
if strategy == '' or strategy == '0' or strategy == '2':
for ii in Close:
print(Close[pos])
if Close[pos] >= df.Upper_band.values[pos]:
df['signal'][pos:] = 0
elif Close[pos] <= df.Lower_band.values[pos]:
df['signal'][pos:] = 1
pos += 1
elif strategy == '1' or strategy == '3':
for ii in Close:
print(Close[pos])
if Close[pos] >= df.Upper_band.values[pos]:
df['signal'][pos:] = 1
elif Close[pos] <= df.Lower_band.values[pos]:
df['signal'][pos:] = 0
pos += 1
else:
raise ('You have entered an incorrect strategy value')
except:
pass
finally:
print('*' * 40)
print('Bollinger Signal Generation completed')
print('*' * 40)
return df
def window(MIN_LAG, MAX_LAG, STEP, STOCK_name, price, next_day):
'''
:Arguments:
MIN_LAG :
MAX_LAG :
STEP :
STOCK_index_ :
price :
:Return:
'''
#get the data we need
data = loc.read_csv(STOCK_name + str('.csv'))
#the stock class
stock_data = stock(data)
#get OHLC, HL_PCT, PCT_CHNG
df_OHLC = pd.concat([stock_data.OHLC(), stock_data.HL_PCT()], axis=1)
#listing...
process_time(df_OHLC)
#extract specific time features
#forecastiing parameter
Day_of_week = [x for x in df_OHLC.DayOfTheWeek.unique()]
#forecast dates ahead minus holidays
def filter_Mexico_holidays(df, nextday):
'''
:Arguments:
df: dataframe
:Nextday:
datetime format
:Return:
List of filtered dates using US calender
'''
import holidays
#holidays in Mexico
us_holidays = holidays.Mexico()
hol_dates = []
dat_frac = list((pd.bdate_range(pd.to_datetime(df_OHLC.index[-1]),
next_day)).date)
#iterate using date index
for ii in range(len(dat_frac)):
print(dat_frac[ii])
if isinstance(us_holidays.get(dat_frac[ii]), str):
hol_dates.append(dat_frac[ii])
if hol_dates == []:
print('No holidays')
else:
for ii in hol_dates:
print('Holiday present on {}'.format(ii))
dat_frac = sorted(
[x for x in set(dat_frac).difference(set(hol_dates))])[1:]
return (dat_frac, hol_dates)
print('*' * 30)
print('Fininshed extracting holidays')
dt_range, hol_dates = filter_Mexico_holidays(df_OHLC, next_day)
trad_days = len(dt_range)
#all series
al_dt = list(df_OHLC.index) + list(dt_range)
#lagged_time series
forecast_window = pd.DataFrame(al_dt, columns=['timestamp'])
forecast_window.set_index('timestamp', inplace=True)
print('Forecast ahead dates created')
'''
Prrice shift
'''
print('Create laggs..')
def lagg(param, df, t_days):
'''
:Arguments:
:param:
feature
:df:
dataframe
:t_days:
forecast window/days ahead
:Return:
values at time t and t+x where x = 1,...,n
'''
df_param_t = list(df[param])
df_param_t_1 = list(df[param].shift(t_days))
df_param_t_plus = list(df.ix[-t_days:, param])
return df_param_t_1, df_param_t_plus
'''
HL_PCT shift
'''
#create laggs for every feature in stock i.e OHLC
df_ = {}
params = [price, 'HL_PCT', 'PCT_CHNG']
'''create a loop here for forecasting each feature'''
for ii in params:
df_['df_{}_t_1'.format(ii)], df_['df_{}_t_plus'.format(ii)] = lagg(
ii, df_OHLC, trad_days)
#lagged
for ii in df_['df_{}_t_plus'.format(params[0])]:
df_['df_{}_t_1'.format(params[0])].append(ii)
for ii in df_['df_{}_t_plus'.format(params[1])]:
df_['df_{}_t_1'.format(params[1])].append(ii)
for ii in df_['df_{}_t_plus'.format(params[2])]:
df_['df_{}_t_1'.format(params[2])].append(ii)
#create the forecast laggs
for ii, val in df_.items():
if len(val) > trad_days:
# if len(val) == len
forecast_window['lagged_' + str('{}'.format(ii))] = val
# else:
# raise('Incorrect data setting.\nDate should be shifted forward..')
forecast_window = forecast_window.dropna()
#convert to stock class
#Exponential laggs for each feature
EWM_m = {}
for w in forecast_window.columns:
for ij in range(MIN_LAG, MAX_LAG, STEP):
EWM_m['{}_{}'.format(w, ij)] = forecast_window[w].ewm(ij).mean()
for p, q in EWM_m.items():
forecast_window['{}'.format(p)] = q
#delta time
time_dt = pd.DataFrame({'timestamp': forecast_window.index})
process_time(time_dt).set_index('timestamp', inplace=True)
#filter weekends from data
time_dt = time_dt.loc[time_dt.DayOfTheWeek.isin(Day_of_week)]
#keep feature columns
time_dt = time_dt.loc[:, [x for x in OHLC_features_]]
forecast_window = pd.concat([forecast_window, time_dt], axis=1)
return (forecast_window, trad_days, dt_range)
UPPER_BOUND = 70
#--------MACD SETTINGS-----------------------
FAST = 12
SLOW = 26
SIGNAL = 9
loc.set_path(path + 'DATASET')
#-------get the data we need------------------
STOK_list = ls_STOK()
Signal_Gen = {}
for ii in range(DATA_LIMIT):
print('{}'.format(STOK_list[ii]))
data = loc.read_csv('{}'.format(STOK_list[ii]) + str('.csv'))
data.index = pd.to_datetime(data.index)
#-----convert to the stock class--------------
stock_data = stock(data)
Fibo_SUP_RES_ = stock_data.fibonacci_pivot_point()
df_RSI = RSI_signal(data,
PERIOD,
lw_bound=LOWER_BOUND,
up_bound=UPPER_BOUND)
df_MACD = macd_crossOver(data, FAST, SLOW, SIGNAL)
df_BB = bollinger_band_signal(data,
PERIOD,
deviation=DEVIATION,
strategy=STRATEGY)
#-----select strategy for saving-------------------
if STRATEGY == '2' or STRATEGY == '3':
df_STrend = SuperTrend_signal(data, MULTIPLIER, PERIOD)
prediction = trading_signal(df_RSI, df_MACD, df_BB, df_STrend,
STRATEGY)
def predict_OHLC(NXT_DAY):
'''
:Arguments:
STOCKLIST: List of downloaded stock in the dataset folder
NXTDAY: nextday to predict
stock_data: stock class
:Return:
Next day Open, High, Low, Close for all stock
'''
#get ojects in the dataset folder and
#strip extension
DIR_OBJ = os.listdir()
STOCK_list_ = []
for x in range(len(DIR_OBJ)):
STOCK_list_.append(DIR_OBJ[x].strip('.csv'))
MIN_LAG = 5
MAX_LAG = 25
STEP = 5
# process_time(df_OHLC)
OHLC_features_ = ['years', #trading year
'days', #trading days
'months', #months
'DayOfTheWeek', #days of week
'time_epoch', #time epoch
'wday_sin', #sine of trading day
'wday_cos', #cosine of trading day
'mday_sin', #sine of days of the month
'mday_cos', #cosine of days of the month
'yday_sin', #sine of day of year
'yday_cos', #cosine of day of year
'month_sin', #sine of month
'month_cos'] #cosine of month
'''
recall later
dt_range = []
for ii in range(1, window):
if list(pd.to_datetime(df_OHLC.index[-1]) + pd.to_timedelta(np.arange(window+1), 'D'))[ii].dayofweek in Day_of_week:
dt_range.append(list(pd.to_datetime(df_OHLC.index[-1]) + pd.to_timedelta(np.arange(window+1), 'D'))[ii])
else:
pass
'''
NXT_open_ = []
NXT_high_ = []
NXT_low_ = []
NXT_close_ = []
for _i_ in range(len(STOCK_list_)):
#get the data we need
data = loc.read_csv(STOCK_list_[_i_] + str('.csv'))
#the stock class
stock_data = stock(data)
#get OHLC
df_OHLC = stock_data.OHLC()
'''listing...'''
process_time(df_OHLC)
#forecastiing parameter
Day_of_week = [x for x in df_OHLC.DayOfTheWeek.unique()]
#NXT_DAY = datetime(2018, 12, 21)
dt_range = pd.bdate_range(pd.to_datetime(df_OHLC.index[-1]), NXT_DAY)[1:]
trad_days = len(dt_range)
#all series
# df_dt = list(df_OHLC.index)
# for ii in list(dt_range):
# df_dt.append(list(ii))
al_dt = list(df_OHLC.index) + list(dt_range)
#lagged_time series
forecast_window = pd.DataFrame({'timestamp': al_dt})
forecast_window.set_index('timestamp', inplace = True)
'''
Get Open High Low Close
'''
for _ix in df_OHLC.columns:
'''extract columns to forecast'''
df_t = list(df_OHLC[_ix])
df_t_1 = list(df_OHLC[_ix].shift(trad_days))
df_t_plus = list(df_OHLC[_ix][-trad_days:])
#lagged
for w in df_t_plus:
df_t_1.append(w)
forecast_window['lagged_'+str('{}days'.format(str('t')))] = df_t_1
forecast_window = forecast_window.dropna()
#convert to stock class
for ij in range(MIN_LAG, MAX_LAG, STEP):
forecast_window['lagged_t_'+str('{}'.format(ij))] = forecast_window.lagged_tdays.ewm(ij).mean()
#delta time
time_dt = pd.DataFrame({'timestamp': forecast_window.index})
process_time(time_dt).set_index('timestamp', inplace = True)
#filter weekends from data
time_dt = time_dt.loc[time_dt.DayOfTheWeek.isin(Day_of_week)]
#keep feature columns
time_dt = time_dt.loc[:, [x for x in OHLC_features_]]
forecast_window = pd.concat([forecast_window, time_dt], axis = 1)
#standardize
X_transform = pd.DataFrame(StandardScaler().fit_transform(forecast_window),
columns = [x for x in forecast_window.columns])
#train test splits
X_train = X_transform.iloc[:-trad_days, 1:]
Y_train = forecast_window.lagged_tdays[:-trad_days].values
X_test = X_transform.iloc[-trad_days:, 1:]
Y_test = forecast_window.lagged_tdays[-trad_days:].values
#model
Regress = RandomForestRegressor(max_depth = 20, random_state = 0,
n_estimators = 100)
#fit model
Regress.fit(X_train, Y_train)
#predict feature
Predic_ = Regress.predict(X_test)
if _ix == 'Open':
NXT_open_.append(Predic_)
elif _ix == 'High':
NXT_high_.append(Predic_)
elif _ix == 'Low':
NXT_low_.append(Predic_)
elif _ix == 'Close':
NXT_close_.append(Predic_)
return pd.DataFrame({'Stocks': STOCK_list_, 'Next_day_Open': NXT_open_,
'Next_day_High': NXT_high_, 'Next_day_Low': NXT_low_,
'Next_day_Close': NXT_close_})