def main():
DEVICE = torch.device('cuda:{}'.format(args.d))
torch.backends.cudnn.benchmark = True
net = create_network()
net.to(DEVICE)
criterion = config.create_loss_function().to(DEVICE)
optimizer = config.create_optimizer(net.parameters())
lr_scheduler = config.create_lr_scheduler(optimizer)
ds_train = create_train_dataset(args.batch_size)
ds_val = create_test_dataset(args.batch_size)
TrainAttack = config.create_attack_method(DEVICE)
EvalAttack = config.create_evaluation_attack_method(DEVICE)
now_epoch = 0
if args.auto_continue:
args.resume = os.path.join(config.model_dir, 'last.checkpoint')
if args.resume is not None and os.path.isfile(args.resume):
now_epoch = load_checkpoint(args.resume, net, optimizer, lr_scheduler)
while True:
if now_epoch > config.num_epochs:
break
now_epoch = now_epoch + 1
descrip_str = 'Training epoch:{}/{} -- lr:{}'.format(
now_epoch, config.num_epochs,
lr_scheduler.get_lr()[0])
train_one_epoch(net,
ds_train,
optimizer,
criterion,
DEVICE,
descrip_str,
TrainAttack,
adv_coef=args.adv_coef)
if config.eval_interval > 0 and now_epoch % config.eval_interval == 0:
eval_one_epoch(net, ds_val, DEVICE, EvalAttack)
lr_scheduler.step()
save_checkpoint(now_epoch,
net,
optimizer,
lr_scheduler,
file_name=os.path.join(
config.model_dir,
'epoch-{}.checkpoint'.format(now_epoch)))
def main():
model = create_network().to(device)
optimizer = optim.SGD(model.parameters(),
lr=args.lr,
momentum=args.momentum,
weight_decay=args.weight_decay)
EvalAttack = config.create_evaluation_attack_method(device)
now_train_time = 0
for epoch in range(1, args.epochs + 1):
# adjust learning rate for SGD
adjust_learning_rate(optimizer, epoch)
s_time = time()
descrip_str = 'Training epoch: {}/{}'.format(epoch, args.epochs)
# adversarial training
train(args, model, device, train_loader, optimizer, epoch, descrip_str)
now_train_time += time() - s_time
acc, advacc = eval_one_epoch(model, test_loader, device, EvalAttack)
# save checkpoint
if epoch % args.save_freq == 0:
torch.save(
model.state_dict(),
os.path.join(config.model_dir,
'model-wideres-epoch{}.pt'.format(epoch)))
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
'--resume',
'--resume',
default='log/models/last.checkpoint',
type=str,
metavar='PATH',
help='path to latest checkpoint (default:log/last.checkpoint)')
parser.add_argument('-d', type=int, default=0, help='Which gpu to use')
args = parser.parse_args()
device = 'cuda' if torch.cuda.is_available() else 'cpu'
torch.backends.cudnn.benchmark = True
net = create_network()
net.to(device)
ds_val = create_test_dataset(512)
attack_method = config.create_evaluation_attack_method(device)
if os.path.isfile(args.resume):
load_checkpoint(args.resume, net)
print('Evaluating')
clean_acc, adv_acc = eval_one_epoch(net, ds_val, device, attack_method)
print('clean acc -- {} adv acc -- {}'.format(clean_acc, adv_acc))
def main():
device = 'cuda' if torch.cuda.is_available() else 'cpu'
torch.backends.cudnn.benchmark = True
net = create_network()
net.to(device)
criterion = config.create_loss_function().to(device)
optimizer = config.create_optimizer(net.parameters())
lr_scheduler = config.create_lr_scheduler(optimizer)
ds_train = create_train_dataset(args.batch_size)
ds_val = create_test_dataset(args.batch_size)
train_attack = config.create_attack_method(device)
eval_attack = config.create_evaluation_attack_method(device)
now_epoch = 0
if args.auto_continue:
args.resume = os.path.join(config.model_dir, 'last.checkpoint')
if args.resume is not None and os.path.isfile(args.resume):
now_epoch = load_checkpoint(args.resume, net, optimizer, lr_scheduler)
for i in range(now_epoch, config.num_epochs):
# if now_epoch > config.num_epochs:
# break
# now_epoch = now_epoch + 1
descrip_str = 'Training epoch:{}/{} -- lr:{}'.format(i, config.num_epochs,
lr_scheduler.get_last_lr()[0])
train_one_epoch(net, ds_train, optimizer, criterion, device,
descrip_str, train_attack, adv_coef=args.adv_coef)
if config.eval_interval > 0 and i % config.eval_interval == 0:
eval_one_epoch(net, ds_val, device, eval_attack)
lr_scheduler.step()
save_checkpoint(i, net, optimizer, lr_scheduler,
file_name=os.path.join(config.model_dir, 'epoch-{}.checkpoint'.format(i)))
break
now_epoch = now_epoch + 1
descrip_str = 'Training epoch:{}/{} -- lr:{}'.format(
now_epoch, config.num_epochs,
lr_scheduler.get_lr()[0])
s_time = time.time()
acc, yofoacc = train_one_epoch(net, ds_train, optimizer, criterion,
LayerOneTrainer, config.K, DEVICE,
descrip_str)
now_train_time = now_train_time + time.time() - s_time
tb_train_dic = {'Acc': acc, 'YofoAcc': yofoacc}
print(tb_train_dic)
writer.add_scalars('Train', tb_train_dic, now_epoch)
if config.val_interval > 0 and now_epoch % config.val_interval == 0:
acc, advacc = eval_one_epoch(net, ds_val, DEVICE, EvalAttack)
tb_val_dic = {'Acc': acc, 'AdvAcc': advacc}
writer.add_scalars('Val', tb_val_dic, now_epoch)
tb_val_dic['time'] = now_train_time
log_str = json.dumps(tb_val_dic)
with open('time.log', 'a') as f:
f.write(log_str + '\n')
lr_scheduler.step()
lyaer_one_optimizer_lr_scheduler.step()
save_checkpoint(now_epoch,
net,
optimizer,
lr_scheduler,
file_name=os.path.join(
config.model_dir,
import os
parser = argparse.ArgumentParser()
parser.add_argument(
'--resume',
'--resume',
default='../ckpts/full-epoch32.checkpoint',
type=str,
metavar='PATH',
help='path to latest checkpoint (default:../ckpts/full-epoch32.checkpoint)'
)
parser.add_argument('-d', type=int, default=0, help='Which gpu to use')
args = parser.parse_args()
DEVICE = torch.device('cuda:{}'.format(args.d))
torch.backends.cudnn.benchmark = True
net = create_network()
net.to(DEVICE)
ds_val = create_test_dataset(512)
AttackMethod = config.create_evaluation_attack_method(DEVICE)
if os.path.isfile(args.resume):
load_checkpoint(args.resume, net)
print('Evaluating')
clean_acc, adv_acc = eval_one_epoch(net, ds_val, DEVICE, AttackMethod)
print('clean acc -- {} adv acc -- {}'.format(clean_acc, adv_acc))
ds_train = create_train_dataset(args.batch_size)
ds_val = create_test_dataset(args.batch_size)
TrainAttack = config.create_attack_method(DEVICE)
EvalAttack = config.create_evaluation_attack_method(DEVICE)
now_epoch = 0
if args.auto_continue:
args.resume = os.path.join(config.model_dir, 'last.checkpoint')
if args.resume is not None and os.path.isfile(args.resume):
now_epoch = load_checkpoint(args.resume, net, optimizer,lr_scheduler)
while True:
if now_epoch > config.num_epochs:
break
now_epoch = now_epoch + 1
descrip_str = 'Training epoch:{}/{} -- lr:{}'.format(now_epoch, config.num_epochs,
lr_scheduler.get_lr()[0])
train_one_epoch(net, ds_train, optimizer, criterion, DEVICE,
descrip_str, TrainAttack, adv_coef = args.adv_coef)
if config.val_interval > 0 and now_epoch % config.val_interval == 0:
eval_one_epoch(net, ds_val, DEVICE, EvalAttack)
lr_scheduler.step()
save_checkpoint(now_epoch, net, optimizer, lr_scheduler,
file_name = os.path.join(config.model_dir, 'epoch-{}.checkpoint'.format(now_epoch)))
break
now_epoch = now_epoch + 1
descrip_str = 'Training epoch:{}/{} -- lr:{}'.format(
now_epoch, config.num_epochs,
lr_scheduler.get_lr()[0])
train_one_epoch(
net,
ds_train,
optimizer,
criterion,
DEVICE,
descrip_str,
)
if config.val_interval > 0 and now_epoch % config.val_interval == 0:
eval_one_epoch(
net,
ds_val,
DEVICE,
)
lr_scheduler.step()
save_checkpoint(now_epoch,
net,
optimizer,
lr_scheduler,
file_name=os.path.join(
config.model_dir,
'epoch-{}.checkpoint'.format(now_epoch)))
# AttackMethod = None)
trainattack = None
train_one_epoch(net=net,
batch_generator=cifar10_training_loader,
optimizer=optimizer,
criterion=loss_function,
DEVICE=torch.device('cuda:{}'.format(0)),
descrip_str=str(epoch) + 'Training',
AttackMethod=trainattack)
print('Learning_rate:', optimizer.param_groups[0]['lr'])
if args.attack:
AttackMethod = config.create_evaluation_attack_method(
torch.device('cuda:{}'.format(0)))
acc = eval_training(epoch)
clean_acc, adv_acc = eval_one_epoch(net, cifar10_test_loader,
torch.device('cuda:{}'.format(0)),
AttackMethod)
print('clean acc -- {} adv acc -- {} in training mode'.format(
clean_acc, adv_acc))
# acc = eval_training(epoch)
# clean_acc, adv_acc_t = eval_one_epoch(net, cifar10_test_loader, torch.device('cuda:{}'.format(0)), AttackMethod)
# print('clean acc -- {} adv acc -- {}'.format(clean_acc, adv_acc_t))
#start to save best performance model after learning rate decay to 0.01
if epoch > settings.MILESTONES2[1] and best_acc < adv_acc:
torch.save(
net.state_dict(),
checkpoint_path.format(net=args.net, epoch=epoch, type='best'))
best_acc = adv_acc
continue
