def main(): # network parameters task_num = 3 lstm_layer = 64 drop = 0.2 r_drop = 0.2 l2_value = 0.001 shared_layer = 576 dense_num = 64 look_back = 30 # number of previous timestamp used for training n_columns = 12 # total columns n_labels = 2 # number of labels split_ratio = 0.8 # train & test data split ratio trainX_list = [] trainy_list = [] testX_list = [] testy_list = [] file_list_train = glob.glob('../data/for_centralTimeAtt/*.csv') for i in range(len(file_list_train)): locals()['dataset' + str(i)] = file_list_train[i] locals()['dataset' + str(i)], locals()['scaled' + str(i)], locals()[ 'scaler' + str(i)] = helper_funcs.load_dataset(locals()['dataset' + str(i)]) locals()['train_X' + str(i)], locals()['train_y' + str(i)], locals()[ 'test_X' + str(i)], locals()['test_y' + str(i)] = helper_funcs.split_dataset( locals()['dataset' + str(i)], locals()['scaled' + str(i)], look_back, n_columns, n_labels, split_ratio) trainX_list.append(locals()['train_X' + str(i)]) trainy_list.append(locals()['train_y' + str(i)]) testX_list.append(locals()['test_X' + str(i)]) testy_list.append(locals()['test_y' + str(i)]) model = build_model(trainX_list, task_num, lstm_layer, drop, r_drop, l2_value, shared_layer, dense_num, n_labels) import time start_time = time.time() # fit network history = model.fit( trainX_list, trainy_list, epochs=100, batch_size=100, validation_split=0.25, # validation_data=(testX_list, testy_list), verbose=2, shuffle=False, callbacks=[ keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=0, patience=20, verbose=2, mode='min') ]) end_time = time.time() print('--- %s seconds ---' % (end_time - start_time)) # make prediction y_pred1, y_pred2, y_pred3 = model.predict(testX_list) #===========================================================================================# # write parameters & results to file # file = open('results/Attention_results(12)_F1.txt', 'w') file = open('TimeStep_30.txt', 'w') file.write('task_num:' + str(task_num) + '\n') file.write('lstm_layer:' + str(lstm_layer) + '\n') file.write('drop:' + str(drop) + '\n') file.write('r_drop:' + str(r_drop) + '\n') file.write('l2_value:' + str(l2_value) + '\n') file.write('shared_layer:' + str(shared_layer) + '\n') file.write('dense_num:' + str(dense_num) + '\n') sum_Smape = 0 sum_Smape_speed = 0 sum_Smape_heartRate = 0 sum_mae = 0 sum_mae_speed = 0 sum_mae_heartRate = 0 # balance accuracy for i in range(len(file_list_train)): locals()['Smape' + str(i)], locals()['mae' + str(i)] = helper_funcs.evaluation( locals()['test_X' + str(i)], locals()['test_y' + str(i)], locals()['y_pred' + str(i + 1)], look_back, n_columns, n_labels, locals()['scaler' + str(i)]) locals()['Smape_speed' + str(i)], locals()['mae_speed' + str(i)] = helper_funcs.evaluation_single( locals()['test_X' + str(i)], locals()['test_y' + str(i)], locals()['y_pred' + str(i + 1)], look_back, n_columns, n_labels, locals()['scaler' + str(i)], 0) locals()['Smape_heartRate' + str(i)], locals()['mae_heartRate' + str(i)] = helper_funcs.evaluation_single( locals()['test_X' + str(i)], locals()['test_y' + str(i)], locals()['y_pred' + str(i + 1)], look_back, n_columns, n_labels, locals()['scaler' + str(i)], 1) file.write('Current file index is: ' + str(i) + '\n') file.write('Smape:' + ' ' + str(locals()['Smape' + str(i)]) + '\n') file.write('Smape_speed:' + ' ' + str(locals()['Smape_speed' + str(i)]) + '\n') file.write('Smape_heartRate:' + ' ' + str(locals()['Smape_heartRate' + str(i)]) + '\n') file.write('mae:' + ' ' + str(locals()['mae' + str(i)]) + '\n') file.write('mae_speed:' + ' ' + str(locals()['mae_speed' + str(i)]) + '\n') file.write('mae_heartRate:' + ' ' + str(locals()['mae_heartRate' + str(i)]) + '\n') file.write('\n') sum_Smape = sum_Smape + locals()['Smape' + str(i)] sum_Smape_speed = sum_Smape_speed + locals()['Smape_speed' + str(i)] sum_Smape_heartRate = sum_Smape_heartRate + locals()['Smape_heartRate' + str(i)] sum_mae = sum_mae + locals()['mae' + str(i)] sum_mae_speed = sum_mae_speed + locals()['mae_speed' + str(i)] sum_mae_heartRate = sum_mae_heartRate + locals()['mae_heartRate' + str(i)] file.write('avg_Smape: ' + str(sum_Smape / len(file_list_train)) + '\n') file.write('avg_sum_Smape_speed: ' + str(sum_Smape_speed / len(file_list_train)) + '\n') file.write('avg_sum_Smape_heartRate: ' + str(sum_Smape_heartRate / len(file_list_train)) + '\n') file.write('avg_mae: ' + str(sum_mae / len(file_list_train)) + '\n') file.write('avg_sum_mae_speed: ' + str(sum_mae_speed / len(file_list_train)) + '\n') file.write('avg_sum_mae_heartRate: ' + str(sum_mae_heartRate / len(file_list_train)) + '\n') file.write('training time:' + str(end_time - start_time))
def main(): # network parameters task_num = 9 lstm_layer = 64 drop = 0.2 r_drop = 0.2 l2_value = 0.001 shared_layer = 576 dense_num = 64 look_back = 20 # number of previous timestamp used for training n_columns = 15 # total columns n_labels = 6 # number of labels split_ratio = 0.8 # train & test data split ratio trainX_list = [] trainy_list = [] testX_list = [] testy_list = [] file_list_train = glob.glob('preprocessed_data/train/*.csv') file_list_test = glob.glob('preprocessed_data/test/*.csv') for i in range(len(file_list_train)): locals()['dataset' + str(i)] = file_list_train[i] locals()['dataset' + str(i)], locals()['scaled' + str(i)], locals()['scaler' + str(i)] = helper_funcs.load_dataset( locals()['dataset' + str(i)]) locals()['train_X' + str(i)], locals()['train_y' + str(i)] = helper_funcs.split_dataset(locals()['scaled' + str(i)], look_back, n_columns, n_labels) trainX_list.append(locals()['train_X' + str(i)]) trainy_list.append(locals()['train_y' + str(i)]) for i in range(len(file_list_test)): locals()['dataset_test' + str(i)] = file_list_test[i] locals()['dataset_test' + str(i)], locals()['scaled_test' + str(i)], locals()['scaler_test' + str(i)] = helper_funcs.load_dataset(locals()['dataset_test' + str(i)]) locals()['test_X' + str(i)], locals()['test_y' + str(i)] = helper_funcs.split_dataset(locals()['scaled_test' + str(i)], look_back, n_columns, n_labels) testX_list.append(locals()['test_X' + str(i)]) testy_list.append(locals()['test_y' + str(i)]) model = build_model(trainX_list,task_num,lstm_layer, drop, r_drop, l2_value, shared_layer, dense_num, n_labels) import time start_time = time.time() # fit network history = model.fit(trainX_list, trainy_list, epochs=300, batch_size=120, validation_split = 0.25, # validation_data=(testX_list, testy_list), verbose=2, shuffle=False, callbacks=[ keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=0, patience=20, verbose=2, mode='min')] ) end_time = time.time() print('--- %s seconds ---' % (end_time - start_time)) # make prediction pred_time = time.time() y_pred1, y_pred2, y_pred3, y_pred4, y_pred5, y_pred6, y_pred7, y_pred8, y_pred9 = model.predict(testX_list) end_pred_time = time.time() #===========================================================================================# # write parameters & results to file # file = open('results/Attention_results(12)_F1.txt', 'w') file = open('time_cost/FATHOMb1.txt', 'w') file.write('task_num:' + str(task_num) + '\n') file.write('lstm_layer:' + str(lstm_layer) + '\n') file.write('drop:' + str(drop) + '\n') file.write('r_drop:' + str(r_drop) + '\n') file.write('l2_value:' + str(l2_value) + '\n') file.write('shared_layer:' + str(shared_layer) + '\n') file.write('dense_num:' + str(dense_num) + '\n') sum_Smape = 0 sum_Smape_PM25 = 0 sum_Smape_PM10 = 0 sum_Smape_NO2 = 0 sum_Smape_CO = 0 sum_Smape_O3 = 0 sum_Smape_SO2 = 0 sum_mae = 0 sum_mae_PM25 = 0 sum_mae_PM10 = 0 sum_mae_NO2 = 0 sum_mae_CO = 0 sum_mae_O3 = 0 sum_mae_SO2 = 0 for i in range(len(file_list_test)): locals()['Smape' + str(i)], locals()['mae' + str(i)] = helper_funcs.evaluation(locals()['test_X' + str(i)], locals()['test_y' + str(i)], locals()['y_pred' + str(i + 1)], look_back, n_columns, n_labels, locals()['scaler_test' + str(i)]) locals()['Smape_PM25' + str(i)], locals()['mae_PM25' + str(i)] = helper_funcs.evaluation_single( locals()['test_X' + str(i)], locals()['test_y' + str(i)], locals()['y_pred' + str(i + 1)], look_back, n_columns, n_labels, locals()['scaler_test' + str(i)], 0) locals()['Smape_PM10' + str(i)], locals()['mae_PM10' + str(i)] = helper_funcs.evaluation_single( locals()['test_X' + str(i)], locals()['test_y' + str(i)], locals()['y_pred' + str(i + 1)], look_back, n_columns, n_labels, locals()['scaler_test' + str(i)], 1) locals()['Smape_NO2' + str(i)], locals()['mae_NO2' + str(i)] = helper_funcs.evaluation_single( locals()['test_X' + str(i)], locals()['test_y' + str(i)], locals()['y_pred' + str(i + 1)], look_back, n_columns, n_labels, locals()['scaler_test' + str(i)], 2) locals()['Smape_CO' + str(i)], locals()['mae_CO' + str(i)] = helper_funcs.evaluation_single( locals()['test_X' + str(i)], locals()['test_y' + str(i)], locals()['y_pred' + str(i + 1)], look_back, n_columns, n_labels, locals()['scaler_test' + str(i)], 3) locals()['Smape_O3' + str(i)], locals()['mae_O3' + str(i)] = helper_funcs.evaluation_single( locals()['test_X' + str(i)], locals()['test_y' + str(i)], locals()['y_pred' + str(i + 1)], look_back, n_columns, n_labels, locals()['scaler_test' + str(i)], 4) locals()['Smape_SO2' + str(i)], locals()['mae_SO2' + str(i)] = helper_funcs.evaluation_single( locals()['test_X' + str(i)], locals()['test_y' + str(i)], locals()['y_pred' + str(i + 1)], look_back, n_columns, n_labels, locals()['scaler_test' + str(i)], 5) file.write('Current file index is: ' + str(i) + '\n') file.write('Smape:' + ' ' + str(locals()['Smape' + str(i)]) + '\n') file.write('Smape_PM25:' + ' ' + str(locals()['Smape_PM25' + str(i)]) + '\n') file.write('Smape_PM10:' + ' ' + str(locals()['Smape_PM10' + str(i)]) + '\n') file.write('Smape_NO2:' + ' ' + str(locals()['Smape_NO2' + str(i)]) + '\n') file.write('Smape_CO:' + ' ' + str(locals()['Smape_CO' + str(i)]) + '\n') file.write('Smape_O3:' + ' ' + str(locals()['Smape_O3' + str(i)]) + '\n') file.write('Smape_SO2:' + ' ' + str(locals()['Smape_SO2' + str(i)]) + '\n') file.write('mae:' + ' ' + str(locals()['mae' + str(i)]) + '\n') file.write('mae_PM25:' + ' ' + str(locals()['mae_PM25' + str(i)]) + '\n') file.write('mae_PM10:' + ' ' + str(locals()['mae_PM10' + str(i)]) + '\n') file.write('mae_NO2:' + ' ' + str(locals()['mae_NO2' + str(i)]) + '\n') file.write('mae_CO:' + ' ' + str(locals()['mae_CO' + str(i)]) + '\n') file.write('mae_O3:' + ' ' + str(locals()['mae_O3' + str(i)]) + '\n') file.write('mae_SO2:' + ' ' + str(locals()['mae_SO2' + str(i)]) + '\n') file.write('\n') sum_Smape = sum_Smape + locals()['Smape' + str(i)] sum_Smape_PM25 = sum_Smape_PM25 + locals()['Smape_PM25' + str(i)] sum_Smape_PM10 = sum_Smape_PM10 + locals()['Smape_PM10' + str(i)] sum_Smape_NO2 = sum_Smape_NO2 + locals()['Smape_NO2' + str(i)] sum_Smape_CO = sum_Smape_CO + locals()['Smape_CO' + str(i)] sum_Smape_O3 = sum_Smape_O3 + locals()['Smape_O3' + str(i)] sum_Smape_SO2 = sum_Smape_SO2 + locals()['Smape_SO2' + str(i)] sum_mae = sum_mae + locals()['mae' + str(i)] sum_mae_PM25 = sum_mae_PM25 + locals()['mae_PM25' + str(i)] sum_mae_PM10 = sum_mae_PM10 + locals()['mae_PM10' + str(i)] sum_mae_NO2 = sum_mae_NO2 + locals()['mae_NO2' + str(i)] sum_mae_CO = sum_mae_CO + locals()['mae_CO' + str(i)] sum_mae_O3 = sum_mae_O3 + locals()['mae_O3' + str(i)] sum_mae_SO2 = sum_mae_SO2 + locals()['mae_SO2' + str(i)] file.write('avg_Smape: ' + str(sum_Smape / len(file_list_test)) + '\n') file.write('avg_Smape_PM25: ' + str(sum_Smape_PM25 / len(file_list_test)) + '\n') file.write('avg_Smape_PM10: ' + str(sum_Smape_PM10 / len(file_list_test)) + '\n') file.write('avg_Smape_NO2: ' + str(sum_Smape_NO2 / len(file_list_test)) + '\n') file.write('avg_Smape_CO: ' + str(sum_Smape_CO / len(file_list_test)) + '\n') file.write('avg_Smape_O3: ' + str(sum_Smape_O3 / len(file_list_test)) + '\n') file.write('avg_Smape_SO2: ' + str(sum_Smape_SO2 / len(file_list_test)) + '\n') file.write('avg_mae: ' + str(sum_mae / len(file_list_test)) + '\n') file.write('avg_mae_PM25: ' + str(sum_mae_PM25 / len(file_list_test)) + '\n') file.write('avg_mae_PM10: ' + str(sum_mae_PM10 / len(file_list_test)) + '\n') file.write('avg_mae_NO2: ' + str(sum_mae_NO2 / len(file_list_test)) + '\n') file.write('avg_mae_CO: ' + str(sum_mae_CO / len(file_list_test)) + '\n') file.write('avg_mae_O3: ' + str(sum_mae_O3 / len(file_list_test)) + '\n') file.write('avg_mae_SO2: ' + str(sum_mae_SO2 / len(file_list_test)) + '\n') file.write('training time:' + str(end_time - start_time)) file.write('prediction time:' + str(end_pred_time - pred_time))
def main(): # network parameters task_num = 1 lstm_layer = 64 drop = 0.2 r_drop = 0.2 l2_value = 0.001 shared_layer = 576 dense_num = 64 look_back = 20 # number of previous timestamp used for training n_columns = 15 # total columns n_labels = 6 # number of labels split_ratio = 0.8 # train & test data split ratio trainX_list = [] trainy_list = [] testX_list = [] testy_list = [] file_list_train = glob.glob( '../preprocessed_data/train/attplot_train/*.csv') file_list_test = glob.glob('../preprocessed_data/test/attplot_test/*.csv') for i in range(len(file_list_train)): locals()['dataset' + str(i)] = file_list_train[i] locals()['dataset' + str(i)], locals()['scaled' + str(i)], locals()[ 'scaler' + str(i)] = helper_funcs.load_dataset(locals()['dataset' + str(i)]) locals()['train_X' + str(i)], locals()['train_y' + str(i)] = helper_funcs.split_dataset( locals()['scaled' + str(i)], look_back, n_columns, n_labels) trainX_list.append(locals()['train_X' + str(i)]) trainy_list.append(locals()['train_y' + str(i)]) for i in range(len(file_list_test)): locals()['dataset_test' + str(i)] = file_list_test[i] locals()['dataset_test' + str(i)], locals()['scaled_test' + str(i)], locals()[ 'scaler_test' + str(i)] = helper_funcs.load_dataset( locals()['dataset_test' + str(i)]) locals()['test_X' + str(i)], locals()['test_y' + str(i)] = helper_funcs.split_dataset( locals()['scaled_test' + str(i)], look_back, n_columns, n_labels) testX_list.append(locals()['test_X' + str(i)]) testy_list.append(locals()['test_y' + str(i)]) model = build_model(trainX_list, task_num, lstm_layer, drop, r_drop, l2_value, shared_layer, dense_num, n_labels) import time start_time = time.time() # fit network history = model.fit( trainX_list, trainy_list, epochs=60, batch_size=120, validation_split=0.25, # validation_data=(testX_list, testy_list), verbose=2, shuffle=False, callbacks=[ keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=0, patience=20, verbose=2, mode='min') ]) end_time = time.time() print('--- %s seconds ---' % (end_time - start_time)) #################### attention plot - input dimension level ################################ attention_vectors = [] ##### Case Study, input_dimension ################ #### axis = 1 is ploting the attention on input_dim, axis = 2 is ploting the attention on TIME_STEP dimension for j in range(10): attention_vector = np.mean(helper_funcs.get_activationsD( model, testX_list[0][0:240, :, :], print_shape_only=True, layer_name='attention_vec')[0], axis=0).squeeze() print('attention =', attention_vector) # assert (np.sum(attention_vector) - 1.0) < 1e-5 attention_vectors.append(attention_vector) print('.....') print(len(attention_vector)) attention_vector_final = np.mean(np.array(attention_vectors), axis=0) print('attention final=', attention_vector_final) print('attention final length=', len(attention_vector_final)) import seaborn as sns import matplotlib.pylab as plt attention_vector_final = np.delete(attention_vector_final, np.s_[9:], axis=1) ax = sns.heatmap(attention_vector_final, cmap='Blues') plt.savefig('input_dim_fangshan(0-240).png', dpi=150) plt.show() # plot part. # import matplotlib.pyplot as plt # import pandas as pd # # # df = pd.DataFrame(attention_vector_final[153], columns=['attention (%)']) # df.to_csv('../results/attention_plot/8153_input_dim_attention2554--.csv') # df.plot(kind='bar',title='Attention Mechanism as ''a function of input'' dimensions.') # # plt.figure(figsize=(100, 100)) # plt.xticks(rotation=90) # plt.savefig('../results/attention_plot-1test.png',dpi=150) # plt.show() ################################# attention plot ends ################################################# y_pred1 = model.predict(testX_list) smape = helper_funcs.evaluation(testX_list[0], testy_list[0], y_pred1, look_back, n_columns, n_labels, locals()['scaler' + str(0)]) print(smape)
def main(): # network parameters task_num = 6 con_layer1 = 128 # for 6 users # con_layer1 = 256 con_layer1_filter = 5 con_layer2 = 64 con_layer2_filter = 4 lstm_layer = 64 drop = 0.2 r_drop = 0.2 l2_value = 0.001 shared_layer = 576 dense_num = 64 look_back = 30 # number of previous timestamp used for training n_columns = 276 # total columns n_labels = 51 # number of labels split_ratio = 0.8 # train & test data split ratio trainX_list = [] trainy_list = [] testX_list = [] testy_list = [] file_list = glob.glob('../data_csv/train/6users/*.csv') for i in range(len(file_list)): locals()['dataset' + str(i)] = file_list[i] locals()['dataset' + str(i)], locals()['scaled' + str(i)], locals()[ 'scaler' + str(i)] = helper_funcs.load_dataset(locals()['dataset' + str(i)]) locals()['train_X' + str(i)], locals()['train_y' + str(i)], locals()[ 'test_X' + str(i)], locals()['test_y' + str(i)] = helper_funcs.split_dataset( locals()['dataset' + str(i)], locals()['scaled' + str(i)], look_back, n_columns, n_labels, split_ratio) trainX_list.append(locals()['train_X' + str(i)]) trainy_list.append(locals()['train_y' + str(i)]) testX_list.append(locals()['test_X' + str(i)]) testy_list.append(locals()['test_y' + str(i)]) model = build_model(trainX_list, task_num, con_layer1, con_layer1_filter, con_layer2, con_layer2_filter, lstm_layer, drop, r_drop, l2_value, shared_layer, dense_num, n_labels) import time start_time = time.time() # fit network history = model.fit( trainX_list, trainy_list, epochs=100, batch_size=60, validation_split=0.25, # validation_data=(testX_list, testy_list), verbose=2, shuffle=False, callbacks=[ keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=0, patience=10, verbose=2, mode='min') ]) end_time = time.time() print('--- %s seconds ---' % (end_time - start_time)) # #################### attention plot - input dimension ################################ # # attention_vectorsd = [] # layer_name_list = ['attention_vecd0','attention_vecd1','attention_vecd2','attention_vecd3','attention_vecd4','attention_vecd5'] # for i in range(len(file_list)): # for j in range(10): # activations = helper_funcs.get_activations(model, locals()['test_X' + str(i)], \ # print_shape_only=True, layer_name=layer_name_list[i]) # attention_vec = np.mean(activations[0], axis=0).squeeze() # print('attention =', attention_vec) # # assert (np.sum(attention_vec) - 1.0) < 1e-5 # attention_vectorsd.append(attention_vec) # # attention_vector_final = np.mean(np.array(attention_vectorsd), axis=0) # print(len(attention_vector_final[0])) # # # plot part. # import matplotlib.pyplot as plt # import pandas as pd # # df = pd.DataFrame(attention_vector_final[26], columns=['attention (%)']) ## attention_vector_final[i], i is the index of test datapoint # df.to_csv('results/attention_plot/input_dim_attention'+str(i)+'.csv') # df.plot(kind='bar',title='Attention Mechanism as ''a function of input'' dimensions.') # # plt.figure(figsize=(100, 100)) # plt.xticks(rotation=90) # # plt.savefig('results/attention_plot/input_dim_attention_plot'+ str(i)+'.png', dpi=150) # plt.show() # # ###################################### attention plot-input dimension ends ######################################### # #################### attention plot - TIME STEP ################################ # # attention_vectorst = [] # for i in range(len(file_list)): # for j in range(10): # activations = helper_funcs.get_activations(model, locals()['test_X' + str(i)], \ # print_shape_only=True, layer_name='attention_vect'+str(i)) # attention_vec = np.mean(activations[0], axis=2).squeeze() # print('attention_vec shape:', attention_vec.shape) # print('attention =', attention_vec) # # assert (np.sum(attention_vec) - 1.0) < 1e-5 # attention_vectorst.append(attention_vec) # # attention_vector_final = np.mean(np.array(attention_vectorst), axis=0) # print('attention_vector_final shape:', attention_vector_final.shape) # # # plot part. # import matplotlib.pyplot as plt # import pandas as pd # # df = pd.DataFrame(attention_vector_final[0], columns=['attention (%)']) # df.to_csv('results/attention_plot/TIME_STEP_attention' + str(i) + '.csv') # df.plot(kind='bar', title='Attention Mechanism as ''a function of input'' dimensions.') # # plt.figure(figsize=(100, 100)) # plt.xticks(rotation=90) # plt.savefig('results/attention_plot/TIME_STEP_attention_plot' + str(i) + '.png', dpi=150) # plt.show() # # ###################################### attention plot-TIME STEP ends ######################################### # make prediction # y_pred1,y_pred2,y_pred3,y_pred4,y_pred5,y_pred6,y_pred7,y_pred8,y_pred9,y_pred10,y_pred11,y_pred12,y_pred13,y_pred14,y_pred15,y_pred16,y_pred17,y_pred18,y_pred19,y_pred20,y_pred21,y_pred22,y_pred23,y_pred24,y_pred25,y_pred26,y_pred27 \ # , y_pred28,y_pred29,y_pred30,y_pred31,y_pred32,y_pred33,y_pred34,y_pred35,y_pred36,y_pred37,y_pred38,y_pred39,y_pred40 = model.predict(testX_list) # print (len(y_pred1)) y_pred1, y_pred2, y_pred3, y_pred4, y_pred5, y_pred6 = model.predict( testX_list) # y_pred1, y_pred2, y_pred3, y_pred4, y_pred5, y_pred6,y_pred7,y_pred8,y_pred9,y_pred10,y_pred11,y_pred12 = model.predict(testX_list) #===========================================================================================# # write parameters & results to file # file = open('results/Attention_results(12)_F1.txt', 'w') file = open('TimeStep_30.txt', 'w') file.write('task_num:' + str(task_num) + '\n') file.write('con_layer1:' + str(con_layer1) + '\n') file.write('con_layer1_filter:' + str(con_layer1_filter) + '\n') file.write('con_layer2:' + str(con_layer2) + '\n') file.write('con_layer2_filter:' + str(con_layer2_filter) + '\n') file.write('lstm_layer:' + str(lstm_layer) + '\n') file.write('drop:' + str(drop) + '\n') file.write('r_drop:' + str(r_drop) + '\n') file.write('l2_value:' + str(l2_value) + '\n') file.write('shared_layer:' + str(shared_layer) + '\n') file.write('dense_num:' + str(dense_num) + '\n') sum_bacc = 0 sum_TPR = 0 Num_tp = 0 Num_fn = 0 Num_fp = 0 Num_tn = 0 sum_precision = 0 sum_F1 = 0 # balance accuracy for i in range(len(file_list)): locals()['Bacc' + str(i)] = helper_funcs.evaluation( locals()['test_X' + str(i)], locals()['test_y' + str(i)], locals()['y_pred' + str(i + 1)], look_back, n_columns, n_labels, locals()['scaler' + str(i)]) sum_bacc = sum_bacc + (locals()['Bacc' + str(i)])[3] sum_TPR = sum_TPR + (locals()['Bacc' + str(i)])[1] Num_tp = Num_tp + (locals()['Bacc' + str(i)])[4] Num_fn = Num_fn + (locals()['Bacc' + str(i)])[5] Num_fp = Num_fp + (locals()['Bacc' + str(i)])[6] Num_tn = Num_tn + (locals()['Bacc' + str(i)])[7] sum_precision = sum_precision + (locals()['Bacc' + str(i)])[8] sum_F1 = sum_F1 + (locals()['Bacc' + str(i)])[9] file.write('Accuracy:' + ' ' + str((locals()['Bacc' + str(i)])[0]) + ' ') file.write('TPR:' + ' ' + str((locals()['Bacc' + str(i)])[1]) + ' ') file.write('TNR:' + ' ' + str((locals()['Bacc' + str(i)])[2]) + ' ') file.write('Bacc:' + ' ' + str((locals()['Bacc' + str(i)])[3]) + '\n') file.write('TP No.:' + ' ' + str((locals()['Bacc' + str(i)])[4]) + '\n') file.write('FN No.:' + ' ' + str((locals()['Bacc' + str(i)])[5]) + '\n') file.write('FP No.:' + ' ' + str((locals()['Bacc' + str(i)])[6]) + '\n') file.write('TN No.:' + ' ' + str((locals()['Bacc' + str(i)])[7]) + '\n') file.write('Precision:' + ' ' + str((locals()['Bacc' + str(i)])[8]) + '\n') file.write('F1:' + ' ' + str((locals()['Bacc' + str(i)])[9]) + '\n') file.write('avg_bacc: ' + str(sum_bacc / len(file_list)) + '\n') file.write('avg_TPR: ' + str(sum_TPR / len(file_list)) + '\n') file.write('avg_precision: ' + str(sum_precision / len(file_list)) + '\n') file.write('avg_F1: ' + str(sum_F1 / len(file_list)) + '\n') file.write('sum_Num_tp: ' + str(Num_tp) + '\n') file.write('sum_Num_fn: ' + str(Num_fn) + '\n') file.write('sum_Num_fp: ' + str(Num_fp) + '\n') file.write('sum_Num_tn: ' + str(Num_tn) + '\n') file.write('training time:' + str(end_time - start_time))
def main(): look_back = 10 # number of previous timestamp used for training n_columns = 12 # total columns n_labels = 6 # number of labels split_ratio = 0.8 # train & test data split ratio file_list_train = glob.glob('data/data_user/*.csv') file = open('results/Single_MLP_1.txt', 'w') sum_Smape = 0 sum_Smape_speed = 0 sum_Smape_heartRate = 0 sum_mae = 0 sum_mae_speed = 0 sum_mae_heartRate = 0 for i in range(len(file_list_train)): locals()['dataset' + str(i)] = file_list_train[i] locals()['dataset' + str(i)], locals()['scaled' + str(i)], locals()[ 'scaler' + str(i)] = helper_funcs.load_dataset( locals()['dataset' + str(i)]) locals()['train_X' + str(i)], locals()['train_y' + str(i)], locals()['test_X' + str(i)], locals()[ 'test_y' + str(i)] = helper_funcs.split_dataset(locals()['dataset' + str(i)], locals()['scaled' + str(i)], look_back, n_columns, n_labels, split_ratio) model = build_model(locals()['train_X' + str(i)]) import time start_time = time.time() # fit network history = model.fit(locals()['train_X' + str(i)], locals()['train_y' + str(i)], epochs=200, batch_size=100, validation_data=(locals()['test_X' + str(i)], locals()['test_y' + str(i)]), verbose=2, shuffle=False, callbacks=[ keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=0, patience=10, verbose=2, mode='min')] ) end_time = time.time() print('--- %s seconds ---' % (end_time - start_time)) # plot history # plt.plot(history.history['loss'], label='train') # plt.plot(history.history['val_loss'], label='test') # plt.legend() # plt.show() # make a prediction y_predict = model.predict(locals()['test_X' + str(i)]) # results = helper_funcs.evaluation(locals()['test_X' + str(i)], locals()['test_y' + str(i)], y_predict, look_back, n_columns, n_labels, locals()['scaler' + str(i)]) locals()['Smape' + str(i)], locals()['mae' + str(i)] = helper_funcs.evaluation(locals()['test_X' + str(i)], locals()['test_y' + str(i)], y_predict, look_back, n_columns, n_labels, locals()['scaler' + str(i)]) locals()['Smape_speed' + str(i)], locals()['mae_speed' + str(i)] = helper_funcs.evaluation_single( locals()['test_X' + str(i)], locals()['test_y' + str(i)], y_predict, look_back, n_columns, n_labels, locals()['scaler' + str(i)], 0) locals()['Smape_heartRate' + str(i)], locals()['mae_heartRate' + str(i)] = helper_funcs.evaluation_single( locals()['test_X' + str(i)], locals()['test_y' + str(i)], y_predict, look_back, n_columns, n_labels, locals()['scaler' + str(i)], 1) file.write('Current file index is: ' + str(i) + '\n') file.write('Smape:' + ' ' + str(locals()['Smape' + str(i)]) + '\n') file.write('Smape_speed:' + ' ' + str(locals()['Smape_speed' + str(i)]) + '\n') file.write('Smape_heartRate:' + ' ' + str(locals()['Smape_heartRate' + str(i)]) + '\n') file.write('mae:' + ' ' + str(locals()['mae' + str(i)]) + '\n') file.write('mae_speed:' + ' ' + str(locals()['mae_speed' + str(i)]) + '\n') file.write('mae_heartRate:' + ' ' + str(locals()['mae_heartRate' + str(i)]) + '\n') file.write('\n') sum_Smape = sum_Smape + locals()['Smape' + str(i)] sum_Smape_speed = sum_Smape_speed + locals()['Smape_speed' + str(i)] sum_Smape_heartRate = sum_Smape_heartRate + locals()['Smape_heartRate' + str(i)] sum_mae = sum_mae + locals()['mae' + str(i)] sum_mae_speed = sum_mae_speed + locals()['mae_speed' + str(i)] sum_mae_heartRate = sum_mae_heartRate + locals()['mae_heartRate' + str(i)] file.write('avg_Smape: ' + str(sum_Smape / len(file_list_train)) + '\n') file.write('avg_sum_Smape_speed: ' + str(sum_Smape_speed / len(file_list_train)) + '\n') file.write('avg_sum_Smape_heartRate: ' + str(sum_Smape_heartRate / len(file_list_train)) + '\n') file.write('avg_mae: ' + str(sum_mae / len(file_list_train)) + '\n') file.write('avg_sum_mae_speed: ' + str(sum_mae_speed / len(file_list_train)) + '\n') file.write('avg_sum_mae_heartRate: ' + str(sum_mae_heartRate / len(file_list_train)) + '\n') file.write('training time:' + str(end_time - start_time))
def main(): # network parameters task_num = 3 con_layer1 = 128 # for 6 users # con_layer1 = 256 con_layer1_filter = 1 con_layer2 = 64 con_layer2_filter = 4 lstm_layer = 64 drop = 0.2 r_drop = 0.2 l2_value = 0.001 shared_layer = 576 dense_num = 64 look_back = 10 # number of previous timestamp used for training n_columns = 12 # total columns n_labels = 2 # number of labels split_ratio = 0.8 # train & test data split ratio trainX_list = [] trainy_list = [] testX_list = [] testy_list = [] file_list_train = glob.glob('../data/for_centralTimeAtt/*.csv') for i in range(len(file_list_train)): locals()['dataset' + str(i)] = file_list_train[i] locals()['dataset' + str(i)], locals()['scaled' + str(i)], locals()[ 'scaler' + str(i)] = helper_funcs.load_dataset( locals()['dataset' + str(i)]) locals()['train_X' + str(i)], locals()['train_y' + str(i)], locals()['test_X' + str(i)], locals()[ 'test_y' + str(i)] = helper_funcs.split_dataset(locals()['dataset' + str(i)], locals()['scaled' + str(i)], look_back, n_columns, n_labels, split_ratio) trainX_list.append(locals()['train_X' + str(i)]) trainy_list.append(locals()['train_y' + str(i)]) testX_list.append(locals()['test_X' + str(i)]) testy_list.append(locals()['test_y' + str(i)]) model = build_model(trainX_list,task_num,lstm_layer, drop, r_drop, l2_value, shared_layer, dense_num, n_labels) import time start_time = time.time() # fit network history = model.fit(trainX_list, trainy_list, epochs=1, batch_size=120, validation_split = 0.25, # validation_data=(testX_list, testy_list), verbose=2, shuffle=False, callbacks=[ keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=0, patience=20, verbose=2, mode='min')] ) end_time = time.time() print('--- %s seconds ---' % (end_time - start_time)) y_pred1, y_pred2, y_pred3 = model.predict(testX_list) #################### attention plot - TIME STEP level ################################ attention_vectors = [] ##### Case Study, input_dimension ################ #### axis = 1 is ploting the attention on input_dim, axis = 2 is ploting the attention on TIME_STEP dimension for k in range(len(file_list_train)): for j in range(10): attention_vector = np.mean(helper_funcs.get_activationsT(k,model,testX_list[k], print_shape_only=True, layer_name='attention_vect'+str(k))[0], axis=2).squeeze() # print('attention =', attention_vector) # assert (np.sum(attention_vector) - 1.0) < 1e-5 attention_vectors.append(attention_vector) print('.....') print(len(attention_vector)) attention_vector_final = np.mean(np.array(attention_vectors), axis=0) # print('attention final=', attention_vector_final[0]) # print('attention final length=', len(attention_vector_final)) # plot part. import matplotlib.pyplot as plt import pandas as pd df = pd.DataFrame(attention_vector_final[1], columns=['attention (%)']) df.to_csv('TIME_STEP_attention'+str(k)+'.csv') df.plot(kind='bar',title='Attention Mechanism as ''a function of input'' dimensions.') # plt.figure(figsize=(100, 100)) plt.xticks(rotation=90) plt.savefig('TIME_STEP_attention'+str(k)+'.png',dpi=150) plt.show() ################################# attention plot ends ################################################# helper_funcs.evaluation(locals()['test_X' + str(k)], locals()['test_y' + str(k)], locals()['y_pred' + str(k + 1)], look_back, n_columns, n_labels, locals()['scaler' + str(k)])
def main(): # network parameters task_num = 40 con_layer1 = 128 # for 6 users # con_layer1 = 256 con_layer1_filter = 5 con_layer2 = 64 con_layer2_filter = 4 lstm_layer = 64 drop = 0.25 r_drop = 0.25 l2_value = 0.001 shared_layer = 576 dense_num = 64 look_back = 20 # number of previous timestamp used for training n_columns = 276 # total columns n_labels = 51 # number of labels split_ratio = 0.8 # train & test data split ratio trainX_list = [] trainy_list = [] testX_list = [] testy_list = [] file_list = glob.glob('data_csv/train/*.csv') for i in range(len(file_list)): locals()['dataset' + str(i)] = file_list[i] locals()['dataset' + str(i)], locals()['scaled' + str(i)], locals()[ 'scaler' + str(i)] = helper_funcs.load_dataset(locals()['dataset' + str(i)]) locals()['train_X' + str(i)], locals()['train_y' + str(i)], locals()[ 'test_X' + str(i)], locals()['test_y' + str(i)] = helper_funcs.split_dataset( locals()['dataset' + str(i)], locals()['scaled' + str(i)], look_back, n_columns, n_labels, split_ratio) trainX_list.append(locals()['train_X' + str(i)]) trainy_list.append(locals()['train_y' + str(i)]) testX_list.append(locals()['test_X' + str(i)]) testy_list.append(locals()['test_y' + str(i)]) model = build_model(trainX_list, task_num, con_layer1, con_layer1_filter, con_layer2, con_layer2_filter, lstm_layer, drop, r_drop, l2_value, shared_layer, dense_num, n_labels) import time start_time = time.time() # fit network history = model.fit( trainX_list, trainy_list, epochs=100, batch_size=60, validation_split=0.25, # validation_data=(testX_list, testy_list), verbose=2, shuffle=False, callbacks=[ keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=0, patience=20, verbose=2, mode='min') ]) end_time = time.time() print('--- %s seconds ---' % (end_time - start_time)) # make prediction pred_time = time.time() y_pred1,y_pred2,y_pred3,y_pred4,y_pred5,y_pred6,y_pred7,y_pred8,y_pred9,y_pred10,y_pred11,y_pred12,y_pred13,y_pred14,y_pred15,y_pred16,y_pred17,y_pred18,y_pred19,y_pred20,y_pred21,y_pred22,y_pred23,y_pred24,y_pred25,y_pred26,y_pred27 \ , y_pred28,y_pred29,y_pred30,y_pred31,y_pred32,y_pred33,y_pred34,y_pred35,y_pred36,y_pred37,y_pred38,y_pred39,y_pred40 = model.predict(testX_list) # print (len(y_pred1)) # y_pred1, y_pred2, y_pred3, y_pred4, y_pred5, y_pred6 = model.predict(testX_list) # y_pred1, y_pred2, y_pred3, y_pred4, y_pred5, y_pred6,y_pred7,y_pred8,y_pred9,y_pred10,y_pred11,y_pred12 = model.predict(testX_list) pred_end_time = time.time() #===========================================================================================# # write parameters & results to file # file = open('results/Attention_results(12)_F1.txt', 'w') file = open('time_cost/FATHOMb2_40users.txt', 'w') file.write('task_num:' + str(task_num) + '\n') file.write('con_layer1:' + str(con_layer1) + '\n') file.write('con_layer1_filter:' + str(con_layer1_filter) + '\n') file.write('con_layer2:' + str(con_layer2) + '\n') file.write('con_layer2_filter:' + str(con_layer2_filter) + '\n') file.write('lstm_layer:' + str(lstm_layer) + '\n') file.write('drop:' + str(drop) + '\n') file.write('r_drop:' + str(r_drop) + '\n') file.write('l2_value:' + str(l2_value) + '\n') file.write('shared_layer:' + str(shared_layer) + '\n') file.write('dense_num:' + str(dense_num) + '\n') sum_bacc = 0 sum_TPR = 0 Num_tp = 0 Num_fn = 0 Num_fp = 0 Num_tn = 0 sum_precision = 0 sum_F1 = 0 # balance accuracy for i in range(len(file_list)): locals()['Bacc' + str(i)] = helper_funcs.evaluation( locals()['test_X' + str(i)], locals()['test_y' + str(i)], locals()['y_pred' + str(i + 1)], look_back, n_columns, n_labels, locals()['scaler' + str(i)]) sum_bacc = sum_bacc + (locals()['Bacc' + str(i)])[3] sum_TPR = sum_TPR + (locals()['Bacc' + str(i)])[1] Num_tp = Num_tp + (locals()['Bacc' + str(i)])[4] Num_fn = Num_fn + (locals()['Bacc' + str(i)])[5] Num_fp = Num_fp + (locals()['Bacc' + str(i)])[6] Num_tn = Num_tn + (locals()['Bacc' + str(i)])[7] sum_precision = sum_precision + (locals()['Bacc' + str(i)])[8] sum_F1 = sum_F1 + (locals()['Bacc' + str(i)])[9] file.write('Accuracy:' + ' ' + str((locals()['Bacc' + str(i)])[0]) + ' ') file.write('TPR:' + ' ' + str((locals()['Bacc' + str(i)])[1]) + ' ') file.write('TNR:' + ' ' + str((locals()['Bacc' + str(i)])[2]) + ' ') file.write('Bacc:' + ' ' + str((locals()['Bacc' + str(i)])[3]) + '\n') file.write('TP No.:' + ' ' + str((locals()['Bacc' + str(i)])[4]) + '\n') file.write('FN No.:' + ' ' + str((locals()['Bacc' + str(i)])[5]) + '\n') file.write('FP No.:' + ' ' + str((locals()['Bacc' + str(i)])[6]) + '\n') file.write('TN No.:' + ' ' + str((locals()['Bacc' + str(i)])[7]) + '\n') file.write('Precision:' + ' ' + str((locals()['Bacc' + str(i)])[8]) + '\n') file.write('F1:' + ' ' + str((locals()['Bacc' + str(i)])[9]) + '\n') file.write('avg_bacc: ' + str(sum_bacc / len(file_list)) + '\n') file.write('avg_TPR: ' + str(sum_TPR / len(file_list)) + '\n') file.write('avg_precision: ' + str(sum_precision / len(file_list)) + '\n') file.write('avg_F1: ' + str(sum_F1 / len(file_list)) + '\n') file.write('sum_Num_tp: ' + str(Num_tp) + '\n') file.write('sum_Num_fn: ' + str(Num_fn) + '\n') file.write('sum_Num_fp: ' + str(Num_fp) + '\n') file.write('sum_Num_tn: ' + str(Num_tn) + '\n') file.write('training time:' + str(end_time - start_time)) file.write('prediction time:' + str(pred_end_time - pred_time))
def main(): look_back = 20 # number of previous timestamp used for training n_columns = 15 # total columns n_labels = 6 # number of labels split_ratio = 0.8 # train & test data split ratio file_list_train = glob.glob('preprocessed_data/train/*.csv') file_list_test = glob.glob('preprocessed_data/test/*.csv') file = open('results/Single_MLP_2.txt', 'w') sum_Smape = 0 sum_Smape_PM25 = 0 sum_Smape_PM10 = 0 sum_Smape_NO2 = 0 sum_Smape_CO = 0 sum_Smape_O3 = 0 sum_Smape_SO2 = 0 for i in range(len(file_list_train)): locals()['dataset_train' + str(i)], locals()['scaled_train' + str(i)], locals()[ 'scaler_train' + str(i)] = helper_funcs.load_dataset(file_list_train[i]) locals()['dataset_test' + str(i)], locals()['scaled_test' + str(i)], locals()[ 'scaler_test' + str(i)] = helper_funcs.load_dataset(file_list_test[i]) # split into train and test sets locals()['train_X' + str(i)], locals()['train_y' + str(i)] = helper_funcs.split_dataset( locals()['scaled_train' + str(i)], look_back, n_columns, n_labels) locals()['test_X' + str(i)], locals()['test_y' + str(i)] = helper_funcs.split_dataset( locals()['scaled_test' + str(i)], look_back, n_columns, n_labels) model = build_model(locals()['train_X' + str(i)]) import time start_time = time.time() # fit network history = model.fit(locals()['train_X' + str(i)], locals()['train_y' + str(i)], epochs=40, batch_size=120, validation_data=(locals()['test_X' + str(i)], locals()['test_y' + str(i)]), verbose=2, shuffle=False, callbacks=[ keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=0, patience=5, verbose=2, mode='min')] ) end_time = time.time() print('--- %s seconds ---' % (end_time - start_time)) # plot history # plt.plot(history.history['loss'], label='train') # plt.plot(history.history['val_loss'], label='test') # plt.legend() # plt.show() # make a prediction y_predict = model.predict(locals()['test_X' + str(i)]) # results = helper_funcs.evaluation(locals()['test_X' + str(i)], locals()['test_y' + str(i)], y_predict, # look_back, n_columns, n_labels, locals()['scaler' + str(i)]) locals()['Smape' + str(i)] = helper_funcs.evaluation(locals()['test_X' + str(i)], locals()['test_y' + str(i)], y_predict, look_back, n_columns, n_labels, locals()['scaler_test' + str(i)]) locals()['Smape_PM25' + str(i)] = helper_funcs.evaluation_single(locals()['test_X' + str(i)], locals()['test_y' + str(i)], y_predict, look_back, n_columns, n_labels, locals()['scaler_test' + str(i)], 0) locals()['Smape_PM10' + str(i)] = helper_funcs.evaluation_single(locals()['test_X' + str(i)], locals()['test_y' + str(i)], y_predict, look_back, n_columns, n_labels, locals()['scaler_test' + str(i)], 1) locals()['Smape_NO2' + str(i)] = helper_funcs.evaluation_single(locals()['test_X' + str(i)], locals()['test_y' + str(i)], y_predict, look_back, n_columns, n_labels, locals()['scaler_test' + str(i)], 2) locals()['Smape_CO' + str(i)] = helper_funcs.evaluation_single(locals()['test_X' + str(i)], locals()['test_y' + str(i)], y_predict, look_back, n_columns, n_labels, locals()['scaler_test' + str(i)], 3) locals()['Smape_O3' + str(i)] = helper_funcs.evaluation_single(locals()['test_X' + str(i)], locals()['test_y' + str(i)], y_predict, look_back, n_columns, n_labels, locals()['scaler_test' + str(i)], 4) locals()['Smape_SO2' + str(i)] = helper_funcs.evaluation_single(locals()['test_X' + str(i)], locals()['test_y' + str(i)], y_predict, look_back, n_columns, n_labels, locals()['scaler_test' + str(i)], 5) file.write('Current file index is: ' + str(i) + '\n') file.write('Smape:' + ' ' + str(locals()['Smape' + str(i)]) + '\n') file.write('Smape_PM25:' + ' ' + str(locals()['Smape_PM25' + str(i)]) + '\n') file.write('Smape_PM10:' + ' ' + str(locals()['Smape_PM10' + str(i)]) + '\n') file.write('Smape_NO2:' + ' ' + str(locals()['Smape_NO2' + str(i)]) + '\n') file.write('Smape_CO:' + ' ' + str(locals()['Smape_CO' + str(i)]) + '\n') file.write('Smape_O3:' + ' ' + str(locals()['Smape_O3' + str(i)]) + '\n') file.write('Smape_SO2:' + ' ' + str(locals()['Smape_SO2' + str(i)]) + '\n') file.write('\n') sum_Smape = sum_Smape + locals()['Smape' + str(i)] sum_Smape_PM25 = sum_Smape_PM25 + locals()['Smape_PM25' + str(i)] sum_Smape_PM10 = sum_Smape_PM10 + locals()['Smape_PM10' + str(i)] sum_Smape_NO2 = sum_Smape_NO2 + locals()['Smape_NO2' + str(i)] sum_Smape_CO = sum_Smape_CO + locals()['Smape_CO' + str(i)] sum_Smape_O3 = sum_Smape_O3 + locals()['Smape_O3' + str(i)] sum_Smape_SO2 = sum_Smape_SO2 + locals()['Smape_SO2' + str(i)] file.write('avg_Smape: ' + str(sum_Smape / len(file_list_test)) + '\n') file.write('avg_Smape_PM25: ' + str(sum_Smape_PM25 / len(file_list_test)) + '\n') file.write('avg_Smape_PM10: ' + str(sum_Smape_PM10 / len(file_list_test)) + '\n') file.write('avg_Smape_NO2: ' + str(sum_Smape_NO2 / len(file_list_test)) + '\n') file.write('avg_Smape_CO: ' + str(sum_Smape_CO / len(file_list_test)) + '\n') file.write('avg_Smape_O3: ' + str(sum_Smape_O3 / len(file_list_test)) + '\n') file.write('avg_Smape_SO2: ' + str(sum_Smape_SO2 / len(file_list_test)) + '\n') file.write('training time:' + str(end_time - start_time))
def main(): # network parameters task_num = 6 con_layer1 = 128 # for 6 users # con_layer1 = 256 con_layer1_filter = 1 con_layer2 = 64 con_layer2_filter = 4 lstm_layer = 64 drop = 0.2 r_drop = 0.2 l2_value = 0.001 shared_layer = 576 dense_num = 64 look_back = 30 # number of previous timestamp used for training n_columns = 276 # total columns n_labels = 51 # number of labels split_ratio = 0.8 # train & test data split ratio trainX_list = [] trainy_list = [] testX_list = [] testy_list = [] file_list = glob.glob('../data_csv/train/6users/*.csv') for i in range(len(file_list)): locals()['dataset' + str(i)] = file_list[i] locals()['dataset' + str(i)], locals()['scaled' + str(i)], locals()[ 'scaler' + str(i)] = helper_funcs.load_dataset(locals()['dataset' + str(i)]) locals()['train_X' + str(i)], locals()['train_y' + str(i)], locals()[ 'test_X' + str(i)], locals()['test_y' + str(i)] = helper_funcs.split_dataset( locals()['dataset' + str(i)], locals()['scaled' + str(i)], look_back, n_columns, n_labels, split_ratio) trainX_list.append(locals()['train_X' + str(i)]) trainy_list.append(locals()['train_y' + str(i)]) testX_list.append(locals()['test_X' + str(i)]) testy_list.append(locals()['test_y' + str(i)]) model = build_model(trainX_list, task_num, con_layer1, con_layer1_filter, con_layer2, con_layer2_filter, lstm_layer, drop, r_drop, l2_value, shared_layer, dense_num, n_labels) import time start_time = time.time() # fit network history = model.fit( trainX_list, trainy_list, epochs=50, batch_size=60, validation_split=0.25, # validation_data=(testX_list, testy_list), verbose=2, shuffle=False, callbacks=[ keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=0, patience=20, verbose=2, mode='min') ]) end_time = time.time() print('--- %s seconds ---' % (end_time - start_time)) y_pred1, y_pred2, y_pred3, y_pred4, y_pred5, y_pred6 = model.predict( testX_list) # y_pred1,y_pred2,y_pred3,y_pred4,y_pred5,y_pred6,y_pred7,y_pred8,y_pred9,y_pred10,y_pred11,y_pred12,y_pred13,y_pred14,y_pred15,y_pred16,y_pred17,y_pred18,y_pred19,y_pred20,y_pred21,y_pred22,y_pred23,y_pred24,y_pred25,y_pred26,y_pred27 \ # , y_pred28,y_pred29,y_pred30,y_pred31,y_pred32,y_pred33,y_pred34,y_pred35,y_pred36,y_pred37,y_pred38,y_pred39,y_pred40 = model.predict(testX_list) #################### attention plot - TIME STEP level ################################ attention_vectors = [] ##### Case Study, input_dimension ################ #### axis = 1 is ploting the attention on input_dim, axis = 2 is ploting the attention on TIME_STEP dimension for k in range(len(file_list)): for j in range(10): attention_vector = np.mean(helper_funcs.get_activationsT( k, model, testX_list[k][0:20, :, :], print_shape_only=True, layer_name='attention_vect' + str(k))[0], axis=1).squeeze() # print('attention =', attention_vector) # assert (np.sum(attention_vector) - 1.0) < 1e-5 attention_vectors.append(attention_vector) print('.....') print(len(attention_vector)) attention_vector_final = np.mean(np.array(attention_vectors), axis=0) print('attention final=', attention_vector_final) # print('attention final length=', len(attention_vector_final)) import seaborn as sns import matplotlib.pylab as plt # attention_vector_final = np.delete(attention_vector_final, np.s_[225:], axis=1) ax = sns.heatmap(attention_vector_final, cmap="BuPu") plt.savefig('time_dim_heatmap2' + str(k) + '.png', dpi=150) plt.show() # # plot part. # import matplotlib.pyplot as plt # import pandas as pd # # # df = pd.DataFrame(attention_vector_final[1], columns=['attention (%)']) # df.to_csv('../results/attention_plot/TimeAtt1/30_TIME_STEP_attention'+str(k)+'.csv') # df.plot(kind='bar',title='Attention Mechanism as ''a function of input'' dimensions.') # # plt.figure(figsize=(100, 100)) # plt.xticks(rotation=90) # plt.savefig('../results/attention_plot/TimeAtt1/30_TIME_STEP_attention'+str(k)+'.png',dpi=150) # plt.show() ################################# attention plot ends ################################################# helper_funcs.evaluation(locals()['test_X' + str(k)], locals()['test_y' + str(k)], locals()['y_pred' + str(k + 1)], look_back, n_columns, n_labels, locals()['scaler' + str(k)])
def main(): # network parameters task_num = 9 lstm_layer = 64 drop = 0.2 r_drop = 0.2 l2_value = 0.001 shared_layer = 576 dense_num = 64 look_back = 20 # number of previous timestamp used for training n_columns = 15 # total columns n_labels = 6 # number of labels split_ratio = 0.8 # train & test data split ratio # trainX_list = [] # trainy_list = [] # testX_list = [] # testy_list = [] file_list_train = glob.glob('preprocessed_data/train/*.csv') file_list_test = glob.glob('preprocessed_data/test/*.csv') # path = r'data/US/market/merged_data' # allFiles = glob.glob(path + "/*.csv") with open('train_combined.csv', 'wb') as outfile: for i, fname in enumerate(file_list_train): with open(fname, 'rb') as infile: if i != 0: infile.readline() # Throw away header on all but first file # Block copy rest of file from input to output without parsing shutil.copyfileobj(infile, outfile) print(fname + " has been imported.") train_data,scaled,scaler =helper_funcs.load_dataset('train_combined.csv') trainX,trainy = helper_funcs.split_dataset(scaled,look_back,n_columns, n_labels) file = open('results/globalAtt_1.txt', 'w') sum_Smape = 0 sum_Smape_PM25 = 0 sum_Smape_PM10 = 0 sum_Smape_NO2 = 0 sum_Smape_CO = 0 sum_Smape_O3 = 0 sum_Smape_SO2 = 0 for i in range(len(file_list_train)): # train_data = 'data/preprocessed_data/train/bj_huairou.csv' # test_data = 'data/preprocessed_data/test/bj_huairou_201805.csv' # locals()['dataset_train' + str(i)], locals()['scaled_train' + str(i)], locals()[ # 'scaler_train' + str(i)] = helper_funcs.load_dataset(file_list_train[i]) locals()['dataset_test' + str(i)], locals()['scaled_test' + str(i)], locals()[ 'scaler_test' + str(i)] = helper_funcs.load_dataset(file_list_test[i]) # split into train and test sets # locals()['train_X' + str(i)], locals()['train_y' + str(i)] = helper_funcs.split_dataset( # locals()['scaled_train' + str(i)], look_back, n_columns, n_labels) locals()['test_X' + str(i)], locals()['test_y' + str(i)] = helper_funcs.split_dataset( locals()['scaled_test' + str(i)], look_back, n_columns, n_labels) model = build_model(trainX,lstm_layer, drop, r_drop, l2_value, dense_num, n_labels) import time start_time = time.time() # fit network history = model.fit(trainX, trainy, epochs=100, batch_size=120, validation_data=(locals()['test_X' + str(i)], locals()['test_y' + str(i)]), verbose=2, shuffle=False, callbacks=[ keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=0, patience=5, verbose=2, mode='min')] ) end_time = time.time() print('--- %s seconds ---' % (end_time - start_time)) # plot history # plt.plot(history.history['loss'], label='train') # plt.plot(history.history['val_loss'], label='test') # plt.legend() # plt.show() # make a prediction y_predict = model.predict(locals()['test_X' + str(i)]) # results = helper_funcs.evaluation(locals()['test_X' + str(i)], locals()['test_y' + str(i)], y_predict, look_back, n_columns, n_labels, locals()['scaler' + str(i)]) locals()['Smape' + str(i)] = helper_funcs.evaluation(locals()['test_X' + str(i)], locals()['test_y' + str(i)], y_predict, look_back, n_columns, n_labels, locals()['scaler_test' + str(i)]) locals()['Smape_PM25' + str(i)] = helper_funcs.evaluation_single(locals()['test_X' + str(i)], locals()['test_y' + str(i)], y_predict, look_back, n_columns, n_labels, locals()['scaler_test' + str(i)], 0) locals()['Smape_PM10' + str(i)] = helper_funcs.evaluation_single(locals()['test_X' + str(i)], locals()['test_y' + str(i)], y_predict, look_back, n_columns, n_labels, locals()['scaler_test' + str(i)], 1) locals()['Smape_NO2' + str(i)] = helper_funcs.evaluation_single(locals()['test_X' + str(i)], locals()['test_y' + str(i)], y_predict, look_back, n_columns, n_labels, locals()['scaler_test' + str(i)], 2) locals()['Smape_CO' + str(i)] = helper_funcs.evaluation_single(locals()['test_X' + str(i)], locals()['test_y' + str(i)], y_predict, look_back, n_columns, n_labels, locals()['scaler_test' + str(i)], 3) locals()['Smape_O3' + str(i)] = helper_funcs.evaluation_single(locals()['test_X' + str(i)], locals()['test_y' + str(i)], y_predict, look_back, n_columns, n_labels, locals()['scaler_test' + str(i)], 4) locals()['Smape_SO2' + str(i)] = helper_funcs.evaluation_single(locals()['test_X' + str(i)], locals()['test_y' + str(i)], y_predict, look_back, n_columns, n_labels, locals()['scaler_test' + str(i)], 5) file.write('Current file index is: ' + str(i) + '\n') file.write('Smape:' + ' ' + str(locals()['Smape' + str(i)]) + '\n') file.write('Smape_PM25:' + ' ' + str(locals()['Smape_PM25' + str(i)]) + '\n') file.write('Smape_PM10:' + ' ' + str(locals()['Smape_PM10' + str(i)]) + '\n') file.write('Smape_NO2:' + ' ' + str(locals()['Smape_NO2' + str(i)]) + '\n') file.write('Smape_CO:' + ' ' + str(locals()['Smape_CO' + str(i)]) + '\n') file.write('Smape_O3:' + ' ' + str(locals()['Smape_O3' + str(i)]) + '\n') file.write('Smape_SO2:' + ' ' + str(locals()['Smape_SO2' + str(i)]) + '\n') file.write('\n') sum_Smape = sum_Smape + locals()['Smape' + str(i)] sum_Smape_PM25 = sum_Smape_PM25 + locals()['Smape_PM25' + str(i)] sum_Smape_PM10 = sum_Smape_PM10 + locals()['Smape_PM10' + str(i)] sum_Smape_NO2 = sum_Smape_NO2 + locals()['Smape_NO2' + str(i)] sum_Smape_CO = sum_Smape_CO + locals()['Smape_CO' + str(i)] sum_Smape_O3 = sum_Smape_O3 + locals()['Smape_O3' + str(i)] sum_Smape_SO2 = sum_Smape_SO2 + locals()['Smape_SO2' + str(i)] file.write('avg_Smape: ' + str(sum_Smape / len(file_list_test)) + '\n') file.write('avg_Smape_PM25: ' + str(sum_Smape_PM25 / len(file_list_test)) + '\n') file.write('avg_Smape_PM10: ' + str(sum_Smape_PM10 / len(file_list_test)) + '\n') file.write('avg_Smape_NO2: ' + str(sum_Smape_NO2 / len(file_list_test)) + '\n') file.write('avg_Smape_CO: ' + str(sum_Smape_CO / len(file_list_test)) + '\n') file.write('avg_Smape_O3: ' + str(sum_Smape_O3 / len(file_list_test)) + '\n') file.write('avg_Smape_SO2: ' + str(sum_Smape_SO2 / len(file_list_test)) + '\n') file.write('training time:' + str(end_time - start_time))
def main(): # network parameters task_num = 40 con_layer1 = 128 # for 6 users # con_layer1 = 256 con_layer1_filter = 5 con_layer2 = 64 con_layer2_filter = 4 lstm_layer = 64 drop = 0.3 r_drop = 0.3 l2_value = 0.001 shared_layer = 576 dense_num = 64 look_back = 20 # number of previous timestamp used for training n_columns = 276 # total columns n_labels = 51 # number of labels split_ratio = 0.8 # train & test data split ratio train_list = [] # trainy_list = [] # test_list = [] # testy_list = [] file_list = glob.glob('data_csv/train/*.csv') for i in range(len(file_list)): data = load_dataset(file_list[i], 0, 2400) train_list.append(data) result = pd.concat(train_list) # train_dataset = load_dataset(result) train_dataset, scaled_train, scaler_train = min_max(result) # split into train and test sets train_X, train_y = split_dataset(scaled_train, look_back, n_columns, n_labels) model = build_model(train_X, lstm_layer, drop, r_drop, l2_value, dense_num, n_labels) import time start_time = time.time() # fit network history = model.fit( train_X, train_y, epochs=100, batch_size=60, # validation_data=(test_X, test_y), validation_split=0.25, verbose=2, shuffle=False, callbacks=[ keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=0, patience=10, mode='min') ]) end_time = time.time() print('--- %s seconds ---' % (end_time - start_time)) file = open('results/globalAtt_5.txt', 'w') sum_bacc = 0 sum_TPR = 0 Num_tp = 0 Num_fn = 0 Num_fp = 0 Num_tn = 0 sum_precision = 0 sum_F1 = 0 train_time = 0 for i in range(len(file_list)): locals()['dataset_test' + str(i)] = load_dataset( file_list[i], 2400, 3000) locals()['dataset_test' + str(i)], locals()['scaled_test' + str(i)], locals()[ 'scaler_test' + str(i)] = min_max( locals()['dataset_test' + str(i)]) locals()['test_X' + str(i)], locals()['test_y' + str(i)] = split_dataset( locals()['scaled_test' + str(i)], look_back, n_columns, n_labels) y_predict = model.predict(locals()['test_X' + str(i)]) results = helper_funcs.evaluation(locals()['test_X' + str(i)], locals()['test_y' + str(i)], y_predict, look_back, n_columns, n_labels, locals()['scaler_test' + str(i)]) sum_bacc = sum_bacc + results[3] sum_TPR = sum_TPR + results[1] Num_tp = Num_tp + results[4] Num_fn = Num_fn + results[5] Num_fp = Num_fp + results[6] Num_tn = Num_tn + results[7] sum_precision = sum_precision + results[8] sum_F1 = sum_F1 + results[9] train_time = train_time + (end_time - start_time) file.write('Accuracy:' + ' ' + str(results[0]) + ' ') file.write('TPR:' + ' ' + str(results[1]) + ' ') file.write('TNR:' + ' ' + str(results[2]) + ' ') file.write('Bacc:' + ' ' + str(results[3]) + '\n') file.write('FP No.:' + ' ' + str(results[6]) + '\n') file.write('TN No.:' + ' ' + str(results[7]) + '\n') file.write('Precision:' + ' ' + str(results[8]) + '\n') file.write('F1:' + ' ' + str(results[9]) + '\n') file.write('avg_bacc: ' + str(sum_bacc / len(file_list)) + '\n') file.write('avg_TPR: ' + str(sum_TPR / len(file_list)) + '\n') file.write('avg_precision: ' + str(sum_precision / len(file_list)) + '\n') file.write('avg_F1: ' + str(sum_F1 / len(file_list)) + '\n') file.write('sum_Num_tp: ' + str(Num_tp) + '\n') file.write('sum_Num_fn: ' + str(Num_fn) + '\n') file.write('sum_Num_fp: ' + str(Num_fp) + '\n') file.write('sum_Num_tn: ' + str(Num_tn) + '\n') file.write('train_time: ' + str(train_time) + '\n')
def main(): look_back = 20 # number of previous timestamp used for training n_columns = 276 # total columns n_labels = 51 # number of labels split_ratio = 0.8 # train & test data split ratio file_list = glob.glob('data_csv/train/*.csv') file = open('results/Single_MLP_40users3.txt', 'w') sum_bacc = 0 sum_TPR = 0 Num_tp = 0 Num_fn = 0 Num_fp = 0 Num_tn = 0 sum_precision = 0 sum_F1 = 0 train_time = 0 for i in range(len(file_list)): locals()['dataset' + str(i)] = file_list[i] locals()['dataset' + str(i)], locals()['scaled' + str(i)], locals()[ 'scaler' + str(i)] = helper_funcs.load_dataset(locals()['dataset' + str(i)]) # split into train and test sets locals()['train_X' + str(i)], locals()['train_y' + str(i)], locals()[ 'test_X' + str(i)], locals()['test_y' + str(i)] = helper_funcs.split_dataset( locals()['dataset' + str(i)], locals()['scaled' + str(i)], look_back, n_columns, n_labels, split_ratio) model = build_model(locals()['train_X' + str(i)]) import time start_time = time.time() # fit network history = model.fit( locals()['train_X' + str(i)], locals()['train_y' + str(i)], epochs=40, batch_size=60, # validation_data=(test_X, test_y), validation_split=0.25, verbose=2, shuffle=False, callbacks=[ keras.callbacks.EarlyStopping(monitor='val_loss', min_delta=0, patience=10, mode='min') ]) end_time = time.time() print('--- %s seconds ---' % (end_time - start_time)) y_predict = model.predict(locals()['test_X' + str(i)]) results = helper_funcs.evaluation(locals()['test_X' + str(i)], locals()['test_y' + str(i)], y_predict, look_back, n_columns, n_labels, locals()['scaler' + str(i)]) sum_bacc = sum_bacc + results[3] sum_TPR = sum_TPR + results[1] Num_tp = Num_tp + results[4] Num_fn = Num_fn + results[5] Num_fp = Num_fp + results[6] Num_tn = Num_tn + results[7] sum_precision = sum_precision + results[8] sum_F1 = sum_F1 + results[9] train_time = train_time + (end_time - start_time) file.write('Accuracy:' + ' ' + str(results[0]) + ' ') file.write('TPR:' + ' ' + str(results[1]) + ' ') file.write('TNR:' + ' ' + str(results[2]) + ' ') file.write('Bacc:' + ' ' + str(results[3]) + '\n') file.write('FP No.:' + ' ' + str(results[6]) + '\n') file.write('TN No.:' + ' ' + str(results[7]) + '\n') file.write('Precision:' + ' ' + str(results[8]) + '\n') file.write('F1:' + ' ' + str(results[9]) + '\n') file.write('avg_bacc: ' + str(sum_bacc / len(file_list)) + '\n') file.write('avg_TPR: ' + str(sum_TPR / len(file_list)) + '\n') file.write('avg_precision: ' + str(sum_precision / len(file_list)) + '\n') file.write('avg_F1: ' + str(sum_F1 / len(file_list)) + '\n') file.write('sum_Num_tp: ' + str(Num_tp) + '\n') file.write('sum_Num_fn: ' + str(Num_fn) + '\n') file.write('sum_Num_fp: ' + str(Num_fp) + '\n') file.write('sum_Num_tn: ' + str(Num_tn) + '\n') file.write('train_time: ' + str(train_time) + '\n')