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