class Processor(object): def __init__(self, seed=999, n_splits=10): self.seed = seed self.n_splits = n_splits import sys sys.path.append( r"C:\Users\Kelvin\CloudStation\MSC COMPUTER SCIENCE\Dissertation\CODE\Dissertation\Dissertation" ) #sys.path.append(r"C:\Users\Kelvi\CloudStation\MSC COMPUTER SCIENCE\Dissertation\CODE\Dissertation\Dissertation") from Models import Models self.models = Models() from sklearn.model_selection import GridSearchCV from sklearn.model_selection import TimeSeriesSplit tscv = TimeSeriesSplit(n_splits) from sklearn.neural_network import MLPClassifier from sklearn.neighbors import KNeighborsClassifier from sklearn.svm import SVC from sklearn.gaussian_process import GaussianProcessClassifier from sklearn.gaussian_process.kernels import RBF from sklearn.tree import DecisionTreeClassifier from sklearn.ensemble import RandomForestClassifier, AdaBoostClassifier from sklearn.naive_bayes import GaussianNB from sklearn.discriminant_analysis import QuadraticDiscriminantAnalysis #self.models.add_model(model = GridSearchCV(estimator=MLPClassifier(random_state=seed), param_grid={}, cv=tscv), model_name = 'Neural Net') #self.models.add_model(model = GridSearchCV(estimator=KNeighborsClassifier(), param_grid={}, cv=tscv), model_name = 'KNN') #self.models.add_model(model = GridSearchCV(estimator=SVC(kernel='linear', random_state=seed), param_grid={}, cv=tscv), model_name = 'Linear SVM') #self.models.add_model(model = GridSearchCV(estimator=SVC(kernel='rbf', random_state=seed), param_grid={}, cv=tscv), model_name = 'RBF SVM') #self.models.add_model(model = GridSearchCV(estimator=GaussianProcessClassifier(random_state=seed), param_grid={}, cv=tscv), model_name = 'Gaussian Process') #self.models.add_model(model = GridSearchCV(estimator=DecisionTreeClassifier(random_state=seed), param_grid={}, cv=tscv), model_name = 'Decision Tree') #self.models.add_model(model = GridSearchCV(estimator=RandomForestClassifier(random_state=seed), param_grid={}, cv=tscv), model_name = 'Random Forest') #self.models.add_model(model = GridSearchCV(estimator=AdaBoostClassifier(random_state=seed), param_grid={}, cv=tscv), model_name = 'AdaBoost') #self.models.add_model(model = GridSearchCV(estimator=GaussianNB(), param_grid={}, cv=tscv), model_name = 'Naive Bayes') ##self.models.add_model(model = GridSearchCV(estimator=QuadraticDiscriminantAnalysis(), param_grid={}, cv=tscv), model_name = 'QDA') self.models.add_model(model=MLPClassifier(random_state=seed), model_name='Neural Net') self.models.add_model(model=KNeighborsClassifier(), model_name='KNN') self.models.add_model(model=SVC(kernel='linear', random_state=seed), model_name='Linear SVM') self.models.add_model(model=SVC(kernel='rbf', random_state=seed), model_name='RBF SVM') self.models.add_model( model=GaussianProcessClassifier(random_state=seed), model_name='Gaussian Process') self.models.add_model(model=DecisionTreeClassifier(random_state=seed), model_name='Decision Tree') self.models.add_model(model=RandomForestClassifier(random_state=seed), model_name='Random Forest') self.models.add_model(model=AdaBoostClassifier(random_state=seed), model_name='AdaBoost') self.models.add_model(model=GaussianNB(), model_name='Naive Bayes') #self.models.add_model(model = QuadraticDiscriminantAnalysis(), model_name = 'QDA') def set_dataset(self, interval=30, no_of_steps=1, window_size=10, interpolation_method='linear', train_start='2009-01-01', train_end='2009-12-31', valid_start='2010-01-01', valid_end='2010-12-31', test_start='2011-01-01', test_end='2011-12-31', dimensions=3): from DB import DB from Dataset import Dataset from Models import Models import matplotlib.pyplot as plt self.interval = interval self.no_of_steps = no_of_steps self.window_size = window_size self.interpolation_method = interpolation_method self.train_start = train_start self.train_end = train_end self.valid_start = valid_start self.valid_end = valid_end self.test_start = test_start self.test_end = test_end self.dimensions = dimensions db = DB(driver='{SQL Server}', server='ENVY15-NOTEBOOK\MSSQL2017', database='DBHKUDissertation', username='******', password='******') #db = DB(driver = '{SQL Server}', server = 'LAPTOP-194NACED\SQL2017', database = 'DBHKUDissertation', username = '******', password = '******') sql = """ select [TradingDatetime] , [Open] , [High] , [Low] , [Close] , [Volume] FROM [DBHKUDissertation].[dbo].[TableStock] where Ticker in ('sh000300') and Interval in (""" + str(interval) + """) """ #df = db.read_sql(sql_string = sql) self.dataset = Dataset(data=db.read_sql(sql_string=sql), no_of_intervals_per_day=240 / interval, no_of_steps=no_of_steps) #print(self.dataset.get_data().head()) #self.dataset.visualize(columns=['Close']) print('created dataset object') self.dataset.interpolate(method=interpolation_method) #print(self.dataset.get_data().head()) print('interpolated') self.dataset.derive_features(window_size) #print(self.dataset.get_data().to_string()) print('derived features') self.dataset.remove_na() print(self.dataset.get_data().head()) print('removed na') #print(self.dataset.get_data().head()) #dataset.get_data().head()['ReturnDummy'].unique() self.dataset.data_splitting(train_start=train_start, train_end=train_end, valid_start=valid_start, valid_end=valid_end, test_start=test_start, test_end=test_end) #print(self.dataset.get_train().head()) print('splitted data') self.dataset.avoid_look_ahead_bias() #print(self.dataset.get_train().head()) print('removed look ahead') #self.dataset.set_X(['MA' + str(window_size), 'MA' + str(window_size * 2), 'MA' + str(window_size * 3), 'MA' + str(window_size * 4), 'MA' + str(window_size * 5), 'BB' + str(window_size), 'BB' + str(window_size * 2), 'BB' + str(window_size * 3), 'RSI' + str(window_size), 'RSI' + str(window_size * 2), 'RSI' + str(window_size * 3), 'STOCHK' + str(window_size), 'STOCHK' + str(window_size * 2), 'STOCHK' + str(window_size * 3), 'STOCHKD' + str(window_size), 'STOCHKD' + str(window_size * 2), 'STOCHKD' + str(window_size * 3)]) self.dataset.set_X([ 'MA' + str(window_size), 'MA' + str(window_size * 2), 'MA' + str(window_size * 3), 'BB' + str(window_size), 'BB' + str(window_size * 2), 'BB' + str(window_size * 3), 'RSI' + str(window_size), 'RSI' + str(window_size * 2), 'RSI' + str(window_size * 3), 'STOCHK' + str(window_size), 'STOCHK' + str(window_size * 2), 'STOCHK' + str(window_size * 3), 'STOCHKD' + str(window_size), 'STOCHKD' + str(window_size * 2), 'STOCHKD' + str(window_size * 3) ]) #print(self.dataset.get_train().head()) print('set X features') self.dataset.set_y(['ReturnDummy']) print('set Y feature') self.dataset.set_X_train() #print(self.dataset.get_X_train().head()) print('set X_train') self.dataset.set_y_train() print('set y_train') self.dataset.set_X_valid() print('set X_valid') self.dataset.set_y_valid() print('set y_valid') self.dataset.set_X_test() print('set X_test') self.dataset.set_y_test() print('set y_test') self.dataset.normalization() print('normalization') self.dataset.dimension_reduction(n_components=dimensions) print('dimension reduction') self.dataset.print_train_test_period() def get_dataset(self): return self.dataset def get_models(self): return self.models def train_validate_test_models(self): from sklearn.utils import column_or_1d from sklearn.metrics import confusion_matrix, precision_score, recall_score, accuracy_score, f1_score, precision_recall_fscore_support, classification_report import matplotlib.pyplot as plt from sklearn.metrics import roc_curve plt.figure(1) for model_name, model in self.models.get_models().items(): print(model_name) #print(model) model.fit(self.dataset.get_X_train(), column_or_1d(self.dataset.get_y_train())) y_pred = model.predict(self.dataset.get_X_test()) #print(accuracy_score(self.dataset.get_y_test(), y_pred)) print(classification_report(self.dataset.get_y_test(), y_pred)) #print(model.best_estimator_) #print(model.best_score_) #print(model.best_params_) #print(model.cv_results_) fpr, tpr, _ = roc_curve(self.dataset.get_y_test(), y_pred) plt.plot(fpr, tpr, label=model_name) plt.plot([0, 1], [0, 1], 'k--') plt.xlabel('False positive rate') plt.ylabel('True positive rate') plt.title('ROC curve') plt.legend(loc='best') plt.show() def train_validate_test_model(self, model_name): from sklearn.utils import column_or_1d from sklearn.metrics import confusion_matrix, precision_score, recall_score, accuracy_score, f1_score, precision_recall_fscore_support, classification_report print(model_name) model = self.models.get_model(model_name=model_name) model.fit(self.dataset.get_X_train(), column_or_1d(self.dataset.get_y_train())) y_train_pred = model.predict(self.dataset.get_X_train()) y_valid_pred = model.predict(self.dataset.get_X_valid()) y_test_pred = model.predict(self.dataset.get_X_test()) print(confusion_matrix(self.dataset.get_y_train(), y_train_pred)) print(confusion_matrix(self.dataset.get_y_valid(), y_valid_pred)) print(confusion_matrix(self.dataset.get_y_test(), y_test_pred)) train_tn, train_fp, train_fn, train_tp = confusion_matrix( self.dataset.get_y_train(), y_train_pred).ravel() valid_tn, valid_fp, valid_fn, valid_tp = confusion_matrix( self.dataset.get_y_valid(), y_valid_pred).ravel() test_tn, test_fp, test_fn, test_tp = confusion_matrix( self.dataset.get_y_test(), y_test_pred).ravel() return accuracy_score( self.dataset.get_y_train(), y_train_pred ), f1_score(self.dataset.get_y_train(), y_train_pred), precision_score( self.dataset.get_y_train(), y_train_pred), recall_score( self.dataset.get_y_train(), y_train_pred ), train_tn, train_fp, train_fn, train_tp, accuracy_score( self.dataset.get_y_valid(), y_valid_pred), f1_score( self.dataset.get_y_valid(), y_valid_pred), precision_score(self.dataset.get_y_valid( ), y_valid_pred), recall_score( self.dataset .get_y_valid(), y_valid_pred ), valid_tn, valid_fp, valid_fn, valid_tp, accuracy_score( self.dataset.get_y_test(), y_test_pred), f1_score( self.dataset.get_y_test(), y_test_pred), precision_score( self.dataset.get_y_test(), y_test_pred), recall_score( self.dataset.get_y_test(), y_test_pred ), test_tn, test_fp, test_fn, test_tp #def objective_function(self # , interval = 30 # , no_of_steps = 1 # , window_size = 10 # , interpolation_method = 'linear' # , train_start = '2009-01-01' # , train_end = '2009-12-31' # , test_start = '2010-01-01' # , test_end = '2010-12-31' # , dimensions = 3 # , model_name = 'RBF SVM'): # self.set_dataset(interval = interval # , no_of_steps = no_of_steps # , window_size = window_size # , interpolation_method = interpolation_method # , train_start = train_start # , train_end = train_end # , test_start = test_start # , test_end = test_end # , dimensions = dimensions) # return self.train_validate_test_model(model_name) def exhaustive_grid_search(self, interval=30, min_no_of_steps=10, max_no_of_steps=101, no_of_steps_interval=5, min_window_size=5, max_window_size=100, window_size_interval=5, interpolation_method='linear', train_start='2009-01-01', train_end='2009-12-31', valid_start='2010-01-01', valid_end='2010-12-31', test_start='2011-01-01', test_end='2011-12-31', dimensions=3, model_name='RBF SVM'): import numpy as np import pandas as pd #import matplotlib.pyplot as plt #from mpl_toolkits.mplot3d import Axes3D #from matplotlib import cm self.model_name = model_name #print(min_no_of_steps) no_of_steps = np.concatenate([[1], np.arange(min_no_of_steps, max_no_of_steps + 1, no_of_steps_interval)]) window_size = np.arange(min_window_size, max_window_size + 1, window_size_interval) #print(no_of_steps) #print(window_size) X, Y = np.meshgrid(no_of_steps, window_size) #print(X) #print(Y) #print(type(X)) X_train_start_date = [] X_train_end_date = [] X_valid_start_date = [] X_valid_end_date = [] X_test_start_date = [] X_test_end_date = [] train_accuracy = np.zeros(X.shape) train_F1 = np.zeros(X.shape) train_precision = np.zeros(X.shape) train_recall = np.zeros(X.shape) train_true_false_ratio = np.zeros(X.shape) train_no_of_true = np.zeros(X.shape) train_no_of_false = np.zeros(X.shape) train_tn = np.zeros(X.shape) train_fp = np.zeros(X.shape) train_fn = np.zeros(X.shape) train_tp = np.zeros(X.shape) valid_accuracy = np.zeros(X.shape) valid_F1 = np.zeros(X.shape) valid_precision = np.zeros(X.shape) valid_recall = np.zeros(X.shape) valid_true_false_ratio = np.zeros(X.shape) valid_no_of_true = np.zeros(X.shape) valid_no_of_false = np.zeros(X.shape) valid_tn = np.zeros(X.shape) valid_fp = np.zeros(X.shape) valid_fn = np.zeros(X.shape) valid_tp = np.zeros(X.shape) test_accuracy = np.zeros(X.shape) test_F1 = np.zeros(X.shape) test_precision = np.zeros(X.shape) test_recall = np.zeros(X.shape) test_true_false_ratio = np.zeros(X.shape) test_no_of_true = np.zeros(X.shape) test_no_of_false = np.zeros(X.shape) test_tn = np.zeros(X.shape) test_fp = np.zeros(X.shape) test_fn = np.zeros(X.shape) test_tp = np.zeros(X.shape) seed = np.zeros(X.shape) n_splits = np.zeros(X.shape) rows = 0 #print(Z) for step_row, window_row in zip(X, Y): columns = 0 for step, window in zip(step_row, window_row): print(step) print(window) self.set_dataset(interval=interval, no_of_steps=step, window_size=window, interpolation_method=interpolation_method, train_start=train_start, train_end=train_end, valid_start=valid_start, valid_end=valid_end, test_start=test_start, test_end=test_end, dimensions=dimensions) train_accuracy[rows, columns], train_F1[rows, columns], train_precision[ rows, columns], train_recall[rows, columns], train_tn[ rows, columns], train_fp[rows, columns], train_fn[ rows, columns], train_tp[rows, columns], valid_accuracy[ rows, columns], valid_F1[rows, columns], valid_precision[ rows, columns], valid_recall[rows, columns], valid_tn[ rows, columns], valid_fp[rows, columns], valid_fn[ rows, columns], valid_tp[rows, columns], test_accuracy[ rows, columns], test_F1[ rows, columns], test_precision[ rows, columns], test_recall[ rows, columns], test_tn[ rows, columns], test_fp[ rows, columns], test_fn[ rows, columns], test_tp[ rows, columns] = self.train_validate_test_model( model_name ) train_no_of_true[rows, columns] = self.dataset.get_y_train_true() train_no_of_false[rows, columns] = self.dataset.get_y_train_false() train_true_false_ratio[ rows, columns] = self.dataset.get_y_train_ratio() valid_no_of_true[rows, columns] = self.dataset.get_y_valid_true() valid_no_of_false[rows, columns] = self.dataset.get_y_valid_false() valid_true_false_ratio[ rows, columns] = self.dataset.get_y_valid_ratio() test_no_of_true[rows, columns] = self.dataset.get_y_test_true() test_no_of_false[rows, columns] = self.dataset.get_y_test_false() test_true_false_ratio[ rows, columns] = self.dataset.get_y_test_ratio() X_train_start_date.append( self.dataset.get_X_train_start_date().strftime( "%Y-%m-%d %H:%M:%S")) X_train_end_date.append( self.dataset.get_X_train_end_date().strftime( "%Y-%m-%d %H:%M:%S")) X_valid_start_date.append( self.dataset.get_X_valid_start_date().strftime( "%Y-%m-%d %H:%M:%S")) X_valid_end_date.append( self.dataset.get_X_valid_end_date().strftime( "%Y-%m-%d %H:%M:%S")) X_test_start_date.append( self.dataset.get_X_test_start_date().strftime( "%Y-%m-%d %H:%M:%S")) X_test_end_date.append( self.dataset.get_X_test_end_date().strftime( "%Y-%m-%d %H:%M:%S")) seed[rows, columns] = self.seed n_splits[rows, columns] = self.n_splits #Z[rows, columns] = self.objective_function(interval = interval # , no_of_steps = step # , window_size = window # , interpolation_method = interpolation_method # , train_start = train_start # , train_end = train_end # , test_start = test_start # , test_end = test_end # , dimensions = dimensions # , model_name = model_name) columns = columns + 1 rows = rows + 1 print(train_accuracy) print(X.reshape(X.size, 1)[:, 0]) print(Y.reshape(Y.size, 1)[:, 0]) print(train_accuracy.reshape(train_accuracy.size, 1)[:, 0]) df = pd.DataFrame(data={ 'interpolation_method': interpolation_method, 'train_start': train_start, 'train_end': train_end, 'valid_start': valid_start, 'valid_end': valid_end, 'test_start': test_start, 'test_end': test_end, 'dimensions': dimensions, 'model_name': model_name, 'no_of_steps': X.reshape(X.size, 1)[:, 0], 'window_size': Y.reshape(Y.size, 1)[:, 0], 'train_accuracy_score': train_accuracy.reshape(train_accuracy.size, 1)[:, 0], 'train_F1_score': train_F1.reshape(train_F1.size, 1)[:, 0], 'train_precision_score': train_precision.reshape(train_precision.size, 1)[:, 0], 'train_recall_score': train_recall.reshape(train_recall.size, 1)[:, 0], 'train_roc_tn': train_tn.reshape(train_tn.size, 1)[:, 0], 'train_roc_fp': train_fp.reshape(train_fp.size, 1)[:, 0], 'train_roc_fn': train_fn.reshape(train_fn.size, 1)[:, 0], 'train_roc_tp': train_tp.reshape(train_tp.size, 1)[:, 0], 'y_train_ratio': train_true_false_ratio.reshape(train_true_false_ratio.size, 1)[:, 0], 'y_train_true': train_no_of_true.reshape(train_no_of_true.size, 1)[:, 0], 'y_train_false': train_no_of_false.reshape(train_no_of_false.size, 1)[:, 0], 'valid_accuracy_score': valid_accuracy.reshape(valid_accuracy.size, 1)[:, 0], 'valid_F1_score': valid_F1.reshape(valid_F1.size, 1)[:, 0], 'valid_precision_score': valid_precision.reshape(valid_precision.size, 1)[:, 0], 'valid_recall_score': valid_recall.reshape(valid_recall.size, 1)[:, 0], 'valid_roc_tn': valid_tn.reshape(valid_tn.size, 1)[:, 0], 'valid_roc_fp': valid_fp.reshape(valid_fp.size, 1)[:, 0], 'valid_roc_fn': valid_fn.reshape(valid_fn.size, 1)[:, 0], 'valid_roc_tp': valid_tp.reshape(valid_tp.size, 1)[:, 0], 'y_valid_ratio': valid_true_false_ratio.reshape(valid_true_false_ratio.size, 1)[:, 0], 'y_valid_true': valid_no_of_true.reshape(valid_no_of_true.size, 1)[:, 0], 'y_valid_false': valid_no_of_false.reshape(valid_no_of_false.size, 1)[:, 0], 'test_accuracy_score': test_accuracy.reshape(test_accuracy.size, 1)[:, 0], 'test_F1_score': test_F1.reshape(test_F1.size, 1)[:, 0], 'test_precision_score': test_precision.reshape(test_precision.size, 1)[:, 0], 'test_recall_score': test_recall.reshape(test_recall.size, 1)[:, 0], 'test_roc_tn': test_tn.reshape(test_tn.size, 1)[:, 0], 'test_roc_fp': test_fp.reshape(test_fp.size, 1)[:, 0], 'test_roc_fn': test_fn.reshape(test_fn.size, 1)[:, 0], 'test_roc_tp': test_tp.reshape(test_tp.size, 1)[:, 0], 'y_test_ratio': test_true_false_ratio.reshape(test_true_false_ratio.size, 1)[:, 0], 'y_test_true': test_no_of_true.reshape(test_no_of_true.size, 1)[:, 0], 'y_test_false': test_no_of_false.reshape(test_no_of_false.size, 1)[:, 0], 'x_train_start_date': X_train_start_date, 'x_train_end_date': X_train_end_date, 'x_valid_start_date': X_valid_start_date, 'x_valid_end_date': X_valid_end_date, 'x_test_start_date': X_test_start_date, 'x_test_end_date': X_test_end_date, 'seed': seed.reshape(seed.size, 1)[:, 0], 'n_splits': n_splits.reshape(n_splits.size, 1)[:, 0], 'interval': interval }, index=np.arange(1, train_accuracy.size + 1)) self.X = X self.Y = Y self.train_accuracy = train_accuracy self.train_F1 = train_F1 self.train_precision = train_precision self.train_recall = train_recall self.train_tn = train_tn self.train_fp = train_fp self.train_fn = train_fn self.train_tp = train_tp self.valid_accuracy = valid_accuracy self.valid_F1 = valid_F1 self.valid_precision = valid_precision self.valid_recall = valid_recall self.valid_tn = valid_tn self.valid_fp = valid_fp self.valid_fn = valid_fn self.valid_tp = valid_tp self.test_accuracy = test_accuracy self.test_F1 = test_F1 self.test_precision = test_precision self.test_recall = test_recall self.test_tn = test_tn self.test_fp = test_fp self.test_fn = test_fn self.test_tp = test_tp self.grid_search_ouput = df return X, Y, train_accuracy, train_F1, train_precision, train_recall, train_tn, train_fp, train_fn, train_tp, valid_accuracy, valid_F1, valid_precision, valid_recall, valid_tn, valid_fp, valid_fn, valid_tp, test_accuracy, test_F1, test_precision, test_recall, test_tn, test_fp, test_fn, test_tp, df def to_sql(self, table_name, if_exists): from DB import DB db = DB(driver='{SQL Server}', server='ENVY15-NOTEBOOK\MSSQL2017', database='DBHKUDissertation', username='******', password='******') #db = DB(driver = '{SQL Server}', server = 'LAPTOP-194NACED\SQL2017', database = 'DBHKUDissertation', username = '******', password = '******') db.to_sql(df=self.grid_search_ouput, table_name=table_name, if_exists=if_exists) def delete_table(self, sql_string): from DB import DB db = DB(driver='{SQL Server}', server='ENVY15-NOTEBOOK\MSSQL2017', database='DBHKUDissertation', username='******', password='******') #db = DB(driver = '{SQL Server}', server = 'LAPTOP-194NACED\SQL2017', database = 'DBHKUDissertation', username = '******', password = '******') db.delete_table(sql_string) def plot_grid_search(self, is_saved, save_path): import matplotlib.pyplot as plt from mpl_toolkits.mplot3d import Axes3D from matplotlib import cm fig = plt.figure(figsize=(15, 9)) #fig = plt.figure() ax = Axes3D(fig) surf = ax.plot_surface(self.X, self.Y, self.valid_accuracy, rstride=2, cstride=2, cmap=cm.coolwarm, linewidth=0.5, antialiased=True) ax.view_init(elev=75, azim=-50) ax.set_title('Steps vs Window Size Optimization\n, model = ' + str(self.model_name) + ', intervale = ' + str(self.interval) + ', dimensions = ' + str(self.dimensions) + '\n, train_start = ' + str(self.train_start) + ', train_end = ' + str(self.train_end) + ', valid_start = ' + str(self.valid_start) + ', valid_end = ' + str(self.valid_end) + ', test_start = ' + str(self.test_start) + ', test_end = ' + str(self.test_end)) ax.set_xlabel('x = no_of_steps') ax.set_ylabel('y = window_size') ax.set_zlabel('f(x, y) = valid_accuracy_score') fig.colorbar(surf, shrink=0.5, aspect=5) plt.grid(True) if is_saved == 1: #filename = save_path + "\" + str(self.model_name) + "_" + str(self.interval) + '_' + str(self.dimensions) + '_' + str(self.train_start) + '_' + str(self.train_end) + '_' + str(self.test_start) + '_' + str(self.test_end) + '.png' filename = save_path + '\\' + str(self.model_name) + "_" + str( self.interval) + '_' + str(self.dimensions) + '_' + str( self.train_start) + '_' + str(self.train_end) + '_' + str( self.valid_start) + '_' + str( self.valid_end) + '_' + str( self.test_start) + '_' + str( self.test_end) + '.png' print(filename) plt.savefig(fname=filename) else: plt.show() def exhaustive_grid_search_models(self, interval=30, min_no_of_steps=5, max_no_of_steps=301, no_of_steps_interval=5, min_window_size=5, max_window_size=51, window_size_interval=5, interpolation_method='linear', train_start='2009-01-01', train_end='2009-12-31', valid_start='2010-01-01', valid_end='2010-12-31', test_start='2011-01-01', test_end='2011-12-31', dimensions=3): for model_name, model in self.models.get_models().items(): print(model_name) X, Y, train_accuracy, train_F1, train_precision, train_recall, train_tn, train_fp, train_fn, train_tp, valid_accuracy, valid_F1, valid_precision, valid_recall, valid_tn, valid_fp, valid_fn, valid_tp, test_accuracy, test_F1, test_precision, test_recall, test_tn, test_fp, test_fn, test_tp, grid_search_df = self.exhaustive_grid_search( interval=interval, min_no_of_steps=min_no_of_steps, max_no_of_steps=max_no_of_steps, no_of_steps_interval=no_of_steps_interval, min_window_size=min_window_size, max_window_size=max_window_size, window_size_interval=window_size_interval, interpolation_method=interpolation_method, train_start=train_start, train_end=train_end, valid_start=valid_start, valid_end=valid_end, test_start=test_start, test_end=test_end, dimensions=dimensions, model_name=model_name) self.to_sql(table_name='GridSearchResult', if_exists='append') self.plot_grid_search( is_saved=1, save_path= r"C:\Users\Kelvin\CloudStation\MSC COMPUTER SCIENCE\Dissertation\CODE\Dissertation\Dissertation\GridSearchImage" )