def get_normalized_train_dataset_xy_for_rsi(df, steps_in, steps_out):
# normalize (windowed approach) data
scaler = MinMaxScaler(feature_range=(0, 1))
df = normalize_window(df, "u_rsi-14", "p_in_rsi", scaler)
# add normalized input data to dataframe as normalized output data
df = talib.copy_column(df, "p_in_rsi", "p_out_rsi")
# use exponential smoothing to remove noise from the normalized input data (helps to reduce training loss)
# NOTE: helps to make predictions more precise (needs further testing)...
df = exponential_smooth(df, "p_in_rsi", "p_in_rsi_exp", gamma=0.1)
# convert to [rows, columns] structure
in_values = df["p_in_rsi_exp"].values
out_values = df["p_out_rsi"].values
in_values = in_values.reshape((len(in_values), 1))
out_values = out_values.reshape((len(out_values), 1))
# horizontally stack columns
sequences = np.hstack((in_values, out_values))
# create dataset
x, y = create_dataset_xy_shift(sequences, steps_in, steps_out)
return df, sequences, x, y, scaler
def get_normalized_test_dataset_xy_for_macd_signal(df, steps_in, steps_out,
scaler):
# normalize (non-windowed approach) data using specified scaler
df = normalize_transform(df, "u_macd_signal-12-26-9", "p_in_macd_signal",
scaler)
# add normalized input data to dataframe as normalized output data
df = talib.copy_column(df, "p_in_macd_signal", "p_out_macd_signal")
# use exponential smoothing to remove noise from the normalized input data (helps to reduce training loss)
# NOTE: helps to make predictions more precise (needs further testing)...
df = exponential_smooth(df,
"p_in_macd_signal",
"p_in_macd_signal_exp",
gamma=0.1)
# convert to [rows, columns] structure
in_values = df["p_in_macd_signal_exp"].values
out_values = df["p_out_macd_signal"].values
in_values = in_values.reshape((len(in_values), 1))
out_values = out_values.reshape((len(out_values), 1))
# horizontally stack columns
sequences = np.hstack((in_values, out_values))
# create dataset
x, y = create_dataset_xy_shift(sequences, steps_in, steps_out)
return df, sequences, x, y
def process_equities(symbols, start_date, end_date, reader, model_dir, db_dir,
db_perf_dir, db_predict_dir, plot_predict, plot_ta):
"""
:param symbols: list of equity symbols to fetch, compute and plot
:param start_date: earliest date to fetch
:param end_date: latest date to fetch
:param reader: data reader (e.g. yahoo, stooq, etc.)
:param model_dir: directory location containing model for prediction
:param db_dir: directory location to save processed dataframe
:param db_perf_dir: directory location to save performance dataframe
:param db_predict_dir: directory location to save future prediction dataframe
:param plot_predict: true = plot prediction charts, false = do not plot prediction charts
:param plot_ta: true = plot TA charts, false = do not plot TA charts
:return:
"""
plotter_predict = PAPlot(c.CHART_PREDICT_DIR)
plotter_ta = TAPlot(c.CHART_TA_DIR)
for symbol in symbols:
symbol_name = symbol
# load data
df = reader.load(symbol, start_date, end_date, symbol_name)
# use 'Adj Close' as our close price
df = talib.copy_column(df, "Adj Close", c.CLOSE)
# compute ta
df = compute_ta(df)
# compute performance
df_perf = compute_perf(df, symbol_name)
# compute prediction
df, df_predict = predict_all(df, symbol_name, model_dir, plot_predict,
plotter_predict)
# save all
save_all(symbol_name, df, df_perf, df_predict, db_dir, db_perf_dir,
db_predict_dir)
# plot TA charts
plot_ta_charts(symbol_name, df, plot_ta, plotter_ta)
def process_equities(symbols, start_date, end_date, reader, db_dir, plot_ta):
"""
:param symbols: list of equity symbols to fetch, compute and plot
:param start_date: earliest date to fetch
:param end_date: latest date to fetch
:param reader: data reader (e.g. yahoo, stooq, etc.)
:param db_dir: directory location to save processed dataframe
:param plot_ta: true = plot TA charts, false = do not plot TA charts
:return:
"""
df_all = {}
df_perf_all = pd.DataFrame()
plotter_ta = TAPlot(c.CHART_TA_DIR)
for symbol in symbols:
symbol_name = symbol
# load data
df = reader.load(symbol, start_date, end_date, symbol_name)
# use 'Adj Close' as our close price
df = talib.copy_column(df, "Adj Close", c.CLOSE)
# compute all
df, df_perf = compute_all(df, symbol_name)
# aggregate symbol dataframes
df_all[symbol] = df
df_perf_all = df_perf_all.append(df_perf, ignore_index=True)
# plot TA charts
#plot_ta_charts(symbol_name, df, plot_ta, plotter_ta)
# analyze
analyze(df_all, df_perf_all)
def process_equities(symbols, start_date, end_date, model_dir):
"""
:param symbols: list of equity symbols to fetch, predict and plot
:param start_date: earliest date to fetch
:param end_date: latest date to fetch
:param model_dir: location to save model
:return:
"""
data_reader = YahooDataReader()
plotter = PAPlot(c.CHART_TRAIN_DIR)
for symbol in symbols:
symbol_name = symbol
# load data
df = data_reader.load(symbol, start_date, end_date, symbol_name)
# use 'Adj Close' as our close price
df = talib.copy_column(df, "Adj Close", c.CLOSE)
# train and plot all
train_all(df, symbol, symbol_name, model_dir, plotter)
def process_indices(symbols, start_date, end_date, model_dir):
"""
:param symbols: list of index symbols to fetch, predict and plot
:param start_date: earliest date to fetch
:param end_date: latest date to fetch
:param model_dir: location to save model
:return:
"""
data_reader = StooqDataReader()
plotter = PAPlot(c.CHART_TRAIN_DIR)
for symbol in symbols:
symbol_name = symbol[1:] # strip off the ^ character
# load data
df = data_reader.load(symbol, start_date, end_date, symbol_name)
# use 'Close' (no adjusted close for indices) as our close price
df = talib.copy_column(df, "Close", c.CLOSE)
# train and plot all
train_all(df, symbol, symbol_name, model_dir, plotter)