def train_model(final_measurement, k_, te_g): global start_value, end_value, step, valid_results, train_results, test_results global repetions, labels,tic, tr_g, tmp_valid_acc global ini_value, file_name, last_column, numfiles global datasetT, labelsT, namesT global dim_dataT, last_columnT # Added by Ismael global model, scheduler, lr, perclass_meter, classes_number # split train and validation data train_data, valid_data, train_label, valid_label = train_test_split(dataset[:, ini_value:final_measurement, :], labels, test_size=0.2)# 0.3 # test data # test_data = datasetT[:, ini_value:final_measurement, :] # test_label = labelsT #preprocess flat_train_data = train_data.reshape(train_data.shape[0], train_data.shape[1] * last_column) flat_valid_data = valid_data.reshape(valid_data.shape[0], valid_data.shape[1] * last_column) # flat_test_data = test_data.reshape(test_data.shape[0], test_data.shape[1] * last_columnT) scaler = preprocessing.StandardScaler().fit(flat_train_data) flat_train_data = scaler.transform(flat_train_data) scaler1 = preprocessing.StandardScaler().fit(flat_valid_data) flat_valid_data = scaler1.transform(flat_valid_data) # scaler2 = preprocessing.StandardScaler().fit(flat_test_data) # flat_test_data = scaler2.transform(flat_test_data) # cat_train_label = to_categorical(train_label) # cat_test_label = to_categorical(test_label) # Added By Ismael stdd_train_data = flat_train_data.reshape(train_data.shape[0], train_data.shape[1], last_column) stdd_valid_data = flat_valid_data.reshape(valid_data.shape[0], valid_data.shape[1], last_column) # stdd_test_data = flat_test_data.reshape(test_data.shape[0], test_data.shape[1], last_columnT) ## ********** Put here the Convolutive CNN ********** train_h, valid_h, model, scheduler = run_experiment(stdd_train_data, train_label, stdd_valid_data, valid_label, perclass_meter, classes_number, model, final_measurement, lr, scheduler) # cat_valid_label = to_categorical(valid_label) stdd_valid_data = stdd_valid_data.reshape(stdd_valid_data.shape[0], 1, stdd_valid_data.shape[1], stdd_valid_data.shape[2]) #.cuda() preds = model(torch.FloatTensor(stdd_valid_data).cuda()).cpu().detach().numpy() clsf_report = classification_report(valid_label, np.argmax(preds, axis=1)) logging.info("Cassification report table window " + str(final_measurement)) logging.info("\n\n" + clsf_report + "\n\n") train_results[str(final_measurement)] += np.array(train_h)[:, 1].astype(float).tolist() valid_results[str(final_measurement)] += np.array(valid_h)[:, 0].astype(float).tolist() with open(args.save + '/' + "precision_recall_f1score_table_window" + str(final_measurement) + ".txt", 'w+') as f: f.write(clsf_report) f.close() # logging.info("\t\t\n\n USING TEST SET OF WINDOW"+str(final_measurement)+"\n\n") # dset_obj = WinesDataset(stdd_test_data, test_label) # test_queue = torch.utils.data.DataLoader(dset_obj, sampler=torchdata.sampler.RandomSampler(dset_obj), # pin_memory=True, num_workers=2) # infer(test_queue, model, nn.CrossEntropyLoss(), classes_number) # h = testing_csv_list(perclass_meter,labels,args.save,final_measurement return 0
def run_experiment_with_hold_out_validation(idx, arg_lr, perclass_metter, final_measurement, arg_scheduler, train_results, test_results, etime): """ Run experiment with holdout cross-validation :return: """ global start_value, end_value, step global labels, tic, file_name, repetions, labels_ global ini_value, last_column, numfiles global tr_labels, tr_names, te_dataset, te_labels, te_names global ttvar, ngr, ncl, sizeT, train_set, test_set, flat_train_data, train_label, test_label, train_data, test_data logging.info("Running window " + str(final_measurement) + " with holdout cross-validation") model = None # repetitions = 10 # repetitions # for k in range(repetions): train_data, test_data, train_label, test_label = train_test_split( dataset[:, ini_value:final_measurement, :], labels, test_size=0.2) # Data shuffle train_data, train_label = sklearn.utils.shuffle(train_data, train_label) test_data, test_label = sklearn.utils.shuffle(test_data, test_label) # #preprocess flat_train_data = train_data.reshape(train_data.shape[0], train_data.shape[1] * last_column) flat_test_data = test_data.reshape(test_data.shape[0], test_data.shape[1] * last_column) scaler = preprocessing.StandardScaler().fit(flat_train_data) flat_train_data = scaler.transform(flat_train_data) flat_test_data = scaler.transform(flat_test_data) ## UNCOMMENT BEFORE LATER train_data_stdd = flat_train_data.reshape(train_data.shape[0], train_data.shape[1], train_data.shape[2], 1) test_data_stdd = flat_test_data.reshape(test_data.shape[0], train_data.shape[1], train_data.shape[2], 1) #input_shape_stdd = (train_data.shape[1],train_data.shape[2],1) # convert class vectors to binary class matrices cat_train_label = keras.utils.to_categorical(train_label, ngr) cat_test_label = keras.utils.to_categorical(test_label, ngr) num_classes = cat_train_label.shape[1] ##Put here the Convolutive CNN # train_data = data_transformer.tranform_sensor_values_to_image(train_data) train_h, valid_h, model, arg_scheduler = run_experiment( train_data_stdd, train_label, test_data_stdd, test_label, perclass_metter, num_classes, model, final_measurement, arg_lr, arg_scheduler) train_results[str(final_measurement)] += np.array(train_h)[:, 1].astype( float).tolist() test_results[str(final_measurement)] += np.array(valid_h)[:, 0].astype( float).tolist() test_data_stdd = test_data_stdd.reshape(test_data_stdd.shape[0], 1, test_data_stdd.shape[1], test_data_stdd.shape[2]) # .cuda() preds = model(torch.FloatTensor( test_data_stdd).cuda()).cpu().detach().numpy() # .cpu() clsf_report = classification_report(test_label, np.argmax(preds, axis=1)) logging.info("Cassification report table window " + str(final_measurement)) logging.info("\n\n" + clsf_report + "\n\n") with open( args.save + '/' + "precision_recall_f1score_table_window" + str(final_measurement) + ".txt", 'w+') as f: f.write(clsf_report) f.close() etime_ = time.time() - tic etime[str(final_measurement)].append(etime_) logging.info("execution time: " + str(etime_)) logging.info("Displyaing partial results:") # Display test results for dict_value in test_results.keys(): logging.info('test2:') mean_acc_test = np.mean(test_results[dict_value]) logging.info(dict_value + ": " + str(mean_acc_test)), return train_results, test_results, etime
def train_model(final_measurement, k_): global start_value, end_value, step, test_results, train_results, etime global repetions, labels, tic, idx_, tmp_test_acc global ini_value, file_name, last_column, numfiles # Added by ismael global model, perclass_meter, lr, scheduler # split train and test data train_data, test_data, train_label, test_label = train_test_split( dataset[:, ini_value:final_measurement, :], labels, test_size=0.2) #preprocess flat_train_data = train_data.reshape(train_data.shape[0], train_data.shape[1] * last_column) flat_test_data = test_data.reshape(test_data.shape[0], test_data.shape[1] * last_column) scaler = preprocessing.StandardScaler().fit(flat_train_data) flat_train_data = scaler.transform(flat_train_data) flat_test_data = scaler.transform(flat_test_data) # Added by Ismael # Re Reshaping the data. train_data = flat_train_data.reshape(train_data.shape[0], train_data.shape[1], train_data.shape[2], 1) test_data = flat_test_data.reshape(test_data.shape[0], train_data.shape[1], train_data.shape[2], 1) #################################################################################################### #cat_train_label = to_categorical(train_label) #cat_test_label = to_categorical(test_label) classes_number = 4 ## ********** Put here the Convolutive CNN ********** train_h, valid_h, model, scheduler = run_experiment( train_data, train_label, test_data, test_label, perclass_meter, classes_number, model, final_measurement, lr, scheduler) train_results[str(final_measurement)] += np.array(train_h)[:, 1].astype( float).tolist() test_results[str(final_measurement)] += np.array(valid_h)[:, 0].astype( float).tolist() # Making Classification report test_data = test_data.reshape(test_data.shape[0], 1, test_data.shape[1], test_data.shape[2]) # .cuda() preds = model(torch.FloatTensor(test_data).cuda()).cpu().detach().numpy() clsf_report = classification_report(test_label, np.argmax(preds, axis=1)) logging.info("Cassification report table window " + str(final_measurement)) logging.info("\n\n" + clsf_report + "\n\n") with open( args.save + '/' + "classification_report_window" + str(final_measurement) + ".txt", 'w+') as f: f.write(clsf_report) f.close() # #creating the model # K.clear_session() # model = models.Sequential() # model.add(layers.Dense(100, activation='relu', input_shape=(flat_train_data.shape[1],))) # model.add(layers.Dense(30, activation='relu', kernel_regularizer=regularizers.l2(0.02))) # model.add(layers.Dense(30, activation='relu', kernel_regularizer=regularizers.l2(0.02))) # model.add(layers.Dense(30, activation='relu', kernel_regularizer=regularizers.l2(0.02))) # model.add(layers.Dense(30, activation='relu', kernel_regularizer=regularizers.l2(0.02))) # model.add(layers.Dense(30, activation='relu', kernel_regularizer=regularizers.l2(0.02))) # model.add(layers.Dense(30, activation='relu', kernel_regularizer=regularizers.l2(0.02))) # model.add(layers.Dense(4, activation='softmax')) # #model.add(layers.Dense(4, activation='linear')) # model.compile(optimizer='rmsprop', # loss='categorical_crossentropy', # metrics=['accuracy']) # history = model.fit(flat_train_data, cat_train_label, epochs = 200, batch_size = round(numfiles*0.2) #10 # , verbose=False) # #testing the trained model # test_loss, test_acc = model.evaluate(flat_test_data, cat_test_label, verbose=False) # train_loss, train_acc = model.evaluate(flat_train_data, cat_train_label, verbose=False) # train_results[str(final_measurement)].append(train_acc) # test_results[str(final_measurement)].append(test_acc) # np.save('test_' + file_name[:-3] + idx_, test_results) # np.save('train_' + file_name[:-3] + idx_, train_results) #Saving the model # if test_acc>tmp_test_acc: # # serialize model to JSON # model_json = model.to_json() # with open('model_'+ file_name[:-3] + idx_ + '.json', 'w') as json_file: # json_file.write(model_json) # # serialize weights to HDF5 # model.save_weights('model_' + file_name[:-3] + idx_ + '.h5') # tmp_test_acc=test_acc ##Loading the saved model # load json and create model # json_file = open('modelB4-8000.json', 'r') # loaded_model_json = json_file.read() # json_file.close() # loaded_model = model_from_json(loaded_model_json) # load weights into new model # loaded_model.load_weights("model.h5") # print("Loaded model from disk") # evaluate loaded model on test data # loaded_model.compile(loss='binary_crossentropy', optimizer='rmsprop', metrics=['accuracy']) # score = loaded_model.evaluate(flat_test_data, cat_test_label, verbose=False) # print("%s: %.2f%%" % (loaded_model.metrics_names[1], score[1]*100)) # return 0