def evalnet(net, signals, labels, sequences, epoch, plot_result={}):
# net.eval()
confusion_mat = np.zeros((opt.label, opt.label), dtype=int)
for i in range(int(len(sequences) / opt.batchsize)):
signal, label = transformer.batch_generator(
signals, labels,
sequences[i * opt.batchsize:(i + 1) * opt.batchsize])
signal = transformer.ToInputShape(signal, opt, test_flag=True)
signal, label = transformer.ToTensor(signal,
label,
no_cuda=opt.no_cuda)
with torch.no_grad():
out = net(signal)
pred = torch.max(out, 1)[1]
pred = pred.data.cpu().numpy()
label = label.data.cpu().numpy()
for x in range(len(pred)):
confusion_mat[label[x]][pred[x]] += 1
recall, acc, sp, err, k = statistics.report(confusion_mat)
plot_result['test'].append(err)
heatmap.draw(confusion_mat, opt, name='current_test')
print(
'epoch:' + str(epoch), ' macro-prec,reca,F1,err,kappa: ' +
str(statistics.report(confusion_mat)))
return plot_result, confusion_mat
def evalnet(net, signals, stages, epoch, plot_result={}):
# net.eval()
confusion_mat = np.zeros((opt.label, opt.label), dtype=int)
for i, (signal, stage) in enumerate(zip(signals, stages), 1):
signal = transformer.ToInputShape(signal,
opt.model_name,
test_flag=True)
signal, stage = transformer.ToTensor(signal,
stage,
no_cuda=opt.no_cuda)
with torch.no_grad():
out = net(signal)
pred = torch.max(out, 1)[1]
pred = pred.data.cpu().numpy()
stage = stage.data.cpu().numpy()
for x in range(len(pred)):
confusion_mat[stage[x]][pred[x]] += 1
recall, acc, sp, err, k = statistics.result(confusion_mat)
plot_result['test'].append(err)
heatmap.draw(confusion_mat, opt.label_name, opt.label_name, name='test')
print('recall,acc,sp,err,k: ' + str(statistics.result(confusion_mat)))
return plot_result, confusion_mat
def runmodel(eeg):
eeg = eeg.reshape(1,-1)
eeg = transformer.ToInputShape(eeg,opt.model_name,test_flag =True)
eeg = transformer.ToTensor(eeg,no_cuda =opt.no_cuda)
out = net(eeg)
pred = torch.max(out, 1)[1]
pred_stage=pred.data.cpu().numpy()
return pred_stage[0]
def evalnet(net,
signals,
stages,
sequences,
epoch,
plot_result={},
mode='part'):
# net.eval()
if mode == 'part':
transformer.shuffledata(signals, stages)
signals = signals[0:int(len(stages) / 2)]
stages = stages[0:int(len(stages) / 2)]
confusion_mat = np.zeros((5, 5), dtype=int)
for i, sequence in enumerate(sequences, 1):
signal = transformer.ToInputShape(signals[sequence],
opt.model_name,
test_flag=True)
signal, stage = transformer.ToTensor(signal,
stages[sequence],
no_cuda=opt.no_cuda)
with torch.no_grad():
out = net(signal)
pred = torch.max(out, 1)[1]
pred = pred.data.cpu().numpy()
stage = stage.data.cpu().numpy()
for x in range(len(pred)):
confusion_mat[stage[x]][pred[x]] += 1
if mode == 'part':
plot_result['test'].append(statistics.result(confusion_mat)[0])
else:
recall, acc, error = statistics.result(confusion_mat)
plot_result['test'].append(recall)
heatmap.draw(confusion_mat, name='test')
print('test avg_recall:', '%.4f' % recall, 'avg_acc:', '%.4f' % acc,
'error:', '%.4f' % error)
#util.writelog('epoch:'+str(epoch)+' test avg_recall:'+str(round(recall,4))+' avg_acc:'+str(round(acc,4))+' error:'+str(round(error,4)))
return plot_result, confusion_mat
net.load_state_dict(
torch.load('./checkpoints/pretrained/' + opt.model_name + '.pth'))
if not opt.no_cuda:
net.cuda()
plot_result = {'train': [0], 'test': [0]}
confusion_mats = []
for epoch in range(opt.epochs):
t1 = time.time()
confusion_mat = np.zeros((5, 5), dtype=int)
print('fold:', fold + 1, 'epoch:', epoch + 1)
net.train()
for i, sequence in enumerate(train_sequences[fold], 1):
signal = transformer.ToInputShape(signals[sequence],
opt.model_name,
test_flag=False)
signal, stage = transformer.ToTensor(signal,
stages[sequence],
no_cuda=opt.no_cuda)
out = net(signal)
loss = criterion(out, stage)
pred = torch.max(out, 1)[1]
optimizer.zero_grad()
loss.backward()
optimizer.step()
pred = pred.data.cpu().numpy()
stage = stage.data.cpu().numpy()
for x in range(len(pred)):
final_confusion_mat = np.zeros((opt.label, opt.label), dtype=int)
confusion_mat = np.zeros((opt.label, opt.label), dtype=int)
confusion_mats = []
plot_result = {'train': [1.], 'test': [1.]}
for epoch in range(opt.epochs):
t1 = time.time()
np.random.shuffle(train_sequences[fold])
net.train()
for i in range(int(len(train_sequences[fold]) / opt.batchsize)):
signal, label = transformer.batch_generator(
signals, labels,
train_sequences[fold][i * opt.batchsize:(i + 1) *
opt.batchsize])
signal = transformer.ToInputShape(signal, opt, test_flag=False)
signal, label = transformer.ToTensor(signal,
label,
no_cuda=opt.no_cuda)
out = net(signal)
loss = criterion(out, label)
pred = torch.max(out, 1)[1]
optimizer.zero_grad()
loss.backward()
optimizer.step()
pred = pred.data.cpu().numpy()
label = label.data.cpu().numpy()
for x in range(len(pred)):
confusion_mat[label[x]][pred[x]] += 1
