pred = torch.max(output, 1)[1].cuda().data.squeeze()
else:
pred = torch.max(output, 1)[1].data.squeeze()
all_pred.append(pred)
all_y.append(y.data)
pred = torch.cat(all_pred)
y = torch.cat(all_y)
accuracy_test = score_py3.accuracy(pred, y.data)
f1_test = score_py3.score_f1(pred, y.data)
if Args.show_log:
print('Epoch: %s | Train Accuracy: %.5f | Train F1: %.5f' %
(epoch, accuracy_test, f1_test))
Accuracy.append(accuracy_test)
F1.append(f1_test)
if Args.show_plot:
drawing.draw_result([Accuracy, F1], fig,
['VGG16 Accuracy', 'VGG16 F1'], True)
# save
if f1_test >= Best_result[0]:
Best_result[0] = f1_test
Best_result[1] = pred.data.cpu().numpy() + 1
Best_result[2] = y.data.cpu().numpy() + 1
del x, y, pred, output
if Args.cuda: torch.cuda.empty_cache() # empty GPU memory
print('End Training')
#%% ########## Output and Save ##########
print('>>>>> Save Result')
pre = Best_result[1]
test = Best_result[2]
##### confusion matrix #####
confmat = confusion_matrix(y_true=test, y_pred=pre)
print(confmat)
else:
pred = torch.max(output, 1)[1].data.squeeze()
all_y.append(y)
all_pred.append(pred)
# evaluate
y = torch.cat(all_y)
pred = torch.cat(all_pred)
accuracy = score.accuracy(pred, y)
F1 = score.F1(pred, y)
print('Epoch: %s | test accuracy: %.2f | F1: %.4f' %
(epoch, accuracy, F1))
# drawing
if Args.draw:
F1_list.append(F1)
acc_list.append(accuracy)
drawing.draw_result(acc_list, F1_list, figure, ['Accuracy', 'F1'],
True)
# save model
if F1 == max(F1_list):
print('save model')
save_model = diagnosis.cpu()
torch.save(save_model, '../transformer_models/model1.pkl')
diagnosis = diagnosis.cuda()
del save_model
# empty memory
del x, y, all_pred, all_y, output
if Args.cuda: torch.cuda.empty_cache() # empty GPU memory
# learning rate change
# if epoch % 10 == 9:
# Args.learn_rate *= 0.9
# optimizer = torch.optim.Adam(diagnosis.parameters(), lr=Args.learn_rate) # optimizer
# print('changeing!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
pred = torch.max(output, 1)[1].cuda().data.squeeze()
else:
pred = torch.max(output, 1)[1].data.squeeze()
all_pred.append(pred)
all_y.append(y.data)
pred = torch.cat(all_pred)
y = torch.cat(all_y)
accuracy_test = score_py3.accuracy(pred, y.data)
f1_test = score_py3.score_f1(pred, y.data)
if Args.show_log:
print('Epoch: %s | Train Accuracy: %.5f | Train F1: %.5f' %
(epoch, accuracy_test, f1_test))
Accuracy.append(accuracy_test)
F1.append(f1_test)
if Args.show_plot:
drawing.draw_result([Accuracy, F1], fig,
['CNN Accuracy', 'CNN F1'], True)
# save
if f1_test >= Best_result[0]:
Best_result[0] = f1_test
Best_result[1] = pred.data.cpu().numpy() + 1
Best_result[2] = y.data.cpu().numpy() + 1
del x, y, pred, output
if Args.cuda: torch.cuda.empty_cache() # empty GPU memory
print('End Training')
#%% ########## Output and Save ##########
print('>>>>> Save Result')
pre = Best_result[1]
test = Best_result[2]
##### confusion matrix #####
confmat = confusion_matrix(y_true=test, y_pred=pre)
print(confmat)
else:
pred = torch.max(output, 1)[1].data.squeeze()
all_pred.append(pred)
all_y.append(y.data)
pred = torch.cat(all_pred)
y = torch.cat(all_y)
accuracy_test = score_py3.accuracy(pred, y.data)
f1_test = score_py3.score_f1(pred, y.data)
if Args.show_log:
print('Epoch: %s | Train Accuracy: %.5f | Train F1: %.5f' %
(epoch, accuracy_test, f1_test))
Accuracy.append(accuracy_test)
F1.append(f1_test)
if Args.show_plot:
drawing.draw_result(
[Accuracy, F1], fig,
['Multi_channel_CNN Accuracy', 'Multi_channel_CNN F1'], True)
# save
if f1_test >= Best_result[0]:
Best_result[0] = f1_test
Best_result[1] = pred.data.cpu().numpy() + 1
Best_result[2] = y.data.cpu().numpy() + 1
del x, y, pred, output
if Args.cuda: torch.cuda.empty_cache() # empty GPU memory
print('>>>>> End Training')
# %% ########## Output and Save ##########
print('>>>>> Save Result')
pre = Best_result[1]
test = Best_result[2]
##### confusion matrix #####
confmat = confusion_matrix(y_true=test, y_pred=pre)
else:
pred = torch.max(output, 1)[1].data.squeeze()
all_pred.append(pred)
all_y.append(y.data)
pred = torch.cat(all_pred)
y = torch.cat(all_y)
accuracy_test = score_py3.accuracy(pred, y.data)
f1_test = score_py3.score_f1(pred, y.data)
if Args.show_log:
print('Epoch: %s | Train Accuracy: %.5f | Train F1: %.5f' %
(epoch, accuracy_test, f1_test))
Accuracy.append(accuracy_test)
F1.append(f1_test)
if Args.show_plot:
drawing.draw_result(
[Accuracy, F1], fig,
['CNN_Transformer_LC Accuracy', 'CNN_Transformer_LC F1'], True)
# save
if f1_test >= Best_result[0]:
Best_result[0] = f1_test
Best_result[1] = pred.data.cpu().numpy() + 1
Best_result[2] = y.data.cpu().numpy() + 1
del x, y, pred, input, output
if Args.cuda: torch.cuda.empty_cache() # empty GPU memory
print('>>>>> End Training')
# %% ########## Output and Save ##########
print('>>>>> Save Result')
pre = Best_result[1]
test = Best_result[2]
##### confusion matrix #####
confmat = confusion_matrix(y_true=test, y_pred=pre)
else:
pred = torch.max(output, 1)[1].data.squeeze()
all_pred.append(pred)
all_y.append(y.data)
pred = torch.cat(all_pred)
y = torch.cat(all_y)
accuracy_test = score_py3.accuracy(pred, y.data)
f1_test = score_py3.score_f1(pred, y.data)
if Args.show_log:
print('Epoch: %s | Train Accuracy: %.5f | Train F1: %.5f' %
(epoch, accuracy_test, f1_test))
Accuracy.append(accuracy_test)
F1.append(f1_test)
if Args.show_plot:
drawing.draw_result([Accuracy, F1], fig,
['CNN_BiLSTM_LC Accuracy', 'CNN_BiLSTM_LC F1'],
True)
if f1_test >= Best_result[0]:
Best_result[0] = f1_test
Best_result[1] = pred.data.cpu().numpy() + 1
Best_result[2] = y.data.cpu().numpy() + 1
del x, y, pred, input, output
if Args.cuda: torch.cuda.empty_cache() # empty GPU memory
print('>>>>> End Training')
# %% ########## Output and Save ##########
print('>>>>> Save Result')
pre = Best_result[1]
test = Best_result[2]
##### confusion matrix #####
confmat = confusion_matrix(y_true=test, y_pred=pre)
print(confmat)
# evaluate
y = torch.cat(all_y)
pred1 = torch.cat(all_pred1)
pred2 = torch.cat(all_pred2)
accuracy1 = score.accuracy(pred1, y)
accuracy2 = score.accuracy(pred2, y)
F1_1 = score.F1(pred1, y)
F1_2 = score.F1(pred2, y)
print('Epoch: %s | test accuracy1: %.2f | F1: %.4f | accuracy2: %.2f | F1: %.4f' % (epoch, accuracy1, F1_1, accuracy2, F1_2))
# drawing
if Args.draw:
F1_list1.append(F1_1)
acc_list1.append(accuracy1)
F1_list2.append(F1_2)
acc_list2.append(accuracy2)
drawing.draw_result([acc_list1, F1_list1, acc_list2, F1_list2], figure, ['Accuracy', 'F1', 'Accuracy_LC', 'F1_LC'], True)
# save model
# if F1 == max(F1_list):
# print('save model')
# save_model = diagnosis.cpu()
# torch.save(save_model, '../Model/model1.pkl')
# diagnosis = diagnosis.cuda()
# del save_model
# empty memory
del x, y, all_pred1, all_pred2, all_y, output1, output2
if Args.cuda: torch.cuda.empty_cache() # empty GPU memory
# learning rate change
# if epoch % 10 == 9:
# Args.learn_rate *= 0.9
# optimizer = torch.optim.Adam(diagnosis.parameters(), lr=Args.learn_rate) # optimizer
# print('changeing!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!')
if Args.cuda:
pred = torch.max(output, 1)[1].cuda().data.squeeze()
else:
pred = torch.max(output, 1)[1].data.squeeze()
all_pred.append(pred)
all_y.append(y.data)
pred = torch.cat(all_pred)
y = torch.cat(all_y)
accuracy_test = score_py3.accuracy(pred, y.data)
f1_test = score_py3.score_f1(pred, y.data)
if Args.show_log:
print('Epoch: %s | Train Accuracy: %.5f | Train F1: %.5f' % (epoch, accuracy_test, f1_test))
Accuracy.append(accuracy_test)
F1.append(f1_test)
if Args.show_plot:
drawing.draw_result([Accuracy, F1], fig, ['Resnet Accuracy', 'Resnet F1'], True)
# save
if f1_test >= Best_result[0]:
Best_result[0] = f1_test
Best_result[1] = pred.data.cpu().numpy() + 1
Best_result[2] = y.data.cpu().numpy() + 1
del x, y, pred, output
if Args.cuda: torch.cuda.empty_cache() # empty GPU memory
print('>>>>> End Training')
# %% ########## Output and Save ##########
print('>>>>> Save Result')
pre = Best_result[1]
test = Best_result[2]
##### confusion matrix #####
confmat = confusion_matrix(y_true=test, y_pred=pre)
print(confmat)
all_y = []
all_pred = []
for step, (x, y) in enumerate(data_loader_test):
if Args.cuda:
x, y = x.cuda(), y.cuda()
cnn.eval() # test model
output = cnn(x)
if Args.cuda:
pred = torch.max(output, 1)[1].cuda().data.squeeze()
else:
pred = torch.max(output, 1)[1].data.squeeze()
all_y.append(y)
all_pred.append(pred)
# evaluate
y = torch.cat(all_y)
pred = torch.cat(all_pred)
accuracy = float((pred == y).sum()) / float(y.size(0))
print('Epoch: %s | test accuracy: %.2f' % (epoch, accuracy))
# draw
if Args.show:
Accuracy.append(accuracy)
drawing.draw_result([Accuracy], figure, ['Accuracy'], True)
# empty memory
del x, y, all_y, all_pred, output
if Args.cuda: torch.cuda.empty_cache() # empty GPU memory
print('==>Finish')
if Args.show:
plt.ioff()
plt.show()
pred0 = torch.max(output0, 1)[1].data.squeeze()
pred1 = torch.max(output1, 1)[1].data.squeeze()
pred2 = torch.max(output2, 1)[1].data.squeeze()
all_y.append(y)
all_pred0.append(pred0)
all_pred1.append(pred1)
all_pred2.append(pred2)
# evaluate
y = torch.cat(all_y)
pred0 = torch.cat(all_pred0)
pred1 = torch.cat(all_pred1)
pred2 = torch.cat(all_pred2)
accuracy0 = float((pred0 == y).sum()) / float(y.size(0))
accuracy1 = float((pred1 == y).sum()) / float(y.size(0))
accuracy2 = float((pred2 == y).sum()) / float(y.size(0))
print('Epoch: %s | test accuracy: %.2f %.2f %.2f' % (epoch, accuracy0, accuracy1, accuracy2))
# draw
if Args.show:
Accuracy0.append(accuracy0)
Accuracy1.append(accuracy1)
Accuracy2.append(accuracy2)
drawing.draw_result([Accuracy0, Accuracy1, Accuracy2], figure, ['Original', 'Shuffled', 'Recover'], True)
# empty memory
del x, y, all_y, all_pred0, all_pred1, all_pred2, output0, output1, output2
if Args.cuda: torch.cuda.empty_cache() # empty GPU memory
print('==>Finish')
if Args.show:
plt.ioff()
plt.show()
pred2 = torch.max(output, 1)[1].data.squeeze()
all_pred.append(pred)
all_pred0.append(pred0)
all_pred1.append(pred1)
all_pred2.append(pred2)
all_y.append(y.data)
pred = torch.cat(all_pred)
pred0 = torch.cat(all_pred0)
pred1 = torch.cat(all_pred1)
pred2 = torch.cat(all_pred2)
y = torch.cat(all_y)
F1.append(Testing(pred, y, 'BiLSTM'))
F1_0.append(Testing(pred0, y, 'LC'))
F1_1.append(Testing(pred1, y, 'LC-1'))
F1_2.append(Testing(pred2, y, 'LC+1'))
if Args.show_plot:
drawing.draw_result([F1, F1_0, F1_1, F1_2], fig,
['BiLSTM', 'LC', 'LC-1', 'LC+1'], True)
del x, y, pred, input, output
if Args.cuda: torch.cuda.empty_cache() # empty GPU memory
print('>>>>> End Training')
##### save figure #####
log = pd.DataFrame([F1, F1_0, F1_1, F1_2],
index=['F1', 'F1_0', 'F1_1', 'F1_2'])
log.to_csv('./Result/log.csv')
##### save figure #####
if Args.show_plot:
plt.ioff()
plt.savefig("./Result/result.jpg")
plt.show()
