loss = loss.cpu()
optimizer.step()
losses += loss
# logging
if (i + 1) % 500 == 0:
log.info('accuracy: %d%%' % (correct_cnt // 5))
correct_cnt = 0
log.info('Train time ' + \
time.strftime("%Hh %Mm %Ss", time.gmtime(time.time() - start_time)) + \
', ' + 'Mean loss: %0.4f' % (losses.data.numpy()[0] / i))
# save model
if args.gpu:
model = model.cpu()
state_to_save = model.state_dict()
if args.epoch % 10 == 0:
torch.save(
state_to_save,
os.path.join(args.model_dir, 'epoch%d.dat' % args.epoch))
accuracy = test(args, model, dataset_test, targets_test, log_test)
f_accuracy_train.write('%0.2f\n' %
(100 * correct_cnt_sum / targets.shape[0]))
f_accuracy_test.write('%0.2f\n' % (100 * accuracy))
f_loss.write('%0.4f\n' %
(losses.data.numpy()[0] / targets.shape[0]))
if accuracy > max_accuracy:
max_accuracy = accuracy
overfitting_cnt = 0
torch.save(state_to_save,
os.path.join(args.model_dir, 'best_model.dat'))
def main():
global opt, best_mae_error
#dataset = CIFData(*opt.dataroot)
dataset = h5(*opt.dataroot)
collate_fn = collate_pool
train_loader, val_loader, test_loader = get_train_val_test_loader(
dataset=dataset,collate_fn=collate_fn,batch_size=opt.batch_size,
train_size=opt.train_size, num_workers=opt.workers,
val_size=opt.val_size, test_size=opt.test_size,pin_memory=opt.cuda,
return_test=True)
# obtain target value normalizer
sample_data_list = [dataset[i] for i in
sample(range(len(dataset)), 1000)]
input, sample_target,_ = collate_pool(sample_data_list)
input_1=input[0]
normalizer = Normalizer(sample_target)
s = Normalizer(input_1)
model=NET()
if torch.cuda.is_available():
print('cuda is ok')
model = model.cuda()
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), opt.lr,
momentum=opt.momentum,
weight_decay=opt.weight_decay)
if opt.resume:
if os.path.isfile(opt.resume):
print("=> loading checkpoint '{}'".format(opt.resume))
checkpoint = torch.load(opt.resume)
opt.start_epoch = checkpoint['epoch']
best_mae_error = checkpoint['best_mae_error']
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['optimizer'])
normalizer.load_state_dict(checkpoint['normalizer'])
print("=> loaded checkpoint '{}' (epoch {})".format(opt.resume, checkpoint['epoch']))
else:
print("=> no checkpoint found at '{}'".format(opt.resume))
scheduler = MultiStepLR(optimizer, milestones=opt.lr_milestones,
gamma=0.1)
for epoch in range(opt.start_epoch,opt.epochs):
train(train_loader, model, criterion, optimizer, epoch,normalizer,s)
mae_error = validate(val_loader, model, criterion, normalizer,s)
if mae_error != mae_error:
print('Exit due to NaN')
sys.exit(1)
is_best = mae_error < best_mae_error
best_mae_error = min(mae_error, best_mae_error)
save_checkpoint({
'epoch': epoch + 1,
'state_dict': model.state_dict(),
'best_mae_error': best_mae_error,
'optimizer': optimizer.state_dict(),
'normalizer': normalizer.state_dict(),
'opt': vars(opt)
}, is_best)
# test bset model
print('---------Evaluate Model on Test Set---------------')
best_checkpoint = torch.load('model_best.pth.tar')
model.load_state_dict(best_checkpoint['state_dict'])
validate(test_loader, model, criterion, normalizer, s,test=True)
#print("acc: {}".format(accuracy))
scheduler.step()
test_loss, accuracy, shuffled_accuracy, unshuffled_accuracy = test(
model, train_loader, device, loss_func, False,
args.count_shuffled_unshuffled)
if args.count_shuffled_unshuffled:
accu_shuffled.append(shuffled_accuracy)
accu_unshuffled.append(unshuffled_accuracy)
tot_accu.append(accuracy)
total_loss_ = total_loss * 1.0 / len(train_loader.dataset)
save_path_model = "{}/models/{}.pt".format(
project_path,
"{}_ratio_{}".format(exp_name_, shuffle_ratio))
torch.save(model.state_dict(), save_path_model)
exps_dict["{}_ratio_{:0.2f}".format(
exp_name_, shuffle_ratio)] = save_path_model
#exp_names.append("{}_ratio_{}".format(exp_name_, shuffle_ratio))
#model_file_paths.append(save_path_model)
#print("shuffle ratio {}".format(shuffle_ratio))
print("train loss {}".format(total_loss_))
del total_loss_, total_loss
del model
del model_optimizer
del scheduler
del train_set
del test_set
del train_loader
del test_loader
os.mkdir("{}{}_perturbed_{}".format(project_path, '/runs/',
# test_x, target = Variable(test_x), Variable(target)
test_x, target = test_x.to(device), target.to(device)
output = net(test_x)
_, pred = torch.max(output.data,
1) # 或者pred =output.argmax(dim=1)
# 计算准确率
loss = loss_func(output, target)
test_loss += loss.item()
correct += pred.eq(target.data).sum()
test_loss /= len(test_inputs)
accuracy = float(correct) / float(
len(test_inputs)) # 注意如果不加float accuracy 为0.00 ！！！
save_test_Acc.append(round(accuracy, 2))
save_test_Loss.append(round(test_loss, 2))
torch.save(net.state_dict(), 'params.pkl') # 仅保存和加载模型参数
# 打印 总的损失值 正确的个数 和测试准确率 并写入到acc.txt文件中去
print('Epoch: ', epoch, '| test_loss: %.4f' % test_loss,
'| correct: %d' % correct,
'| test accuracy: %.3f' % accuracy)
f1.write(
'Epoch: %d | test_loss: %.4f | correct: %d | test accuracy: %.3f'
% (epoch, test_loss, correct, accuracy))
f1.write('\n')
f1.flush() # 将缓冲区写入
# plot_with_labels(save_train_Loss, save_train_Acc, save_test_Loss, save_test_Acc)
if accuracy > best_acc:
f3 = open("best_acc.txt", "w")
f3.write("EPOCH=%d,best_acc= %.3f" %
(epoch + 1, accuracy))
f3.close()