def code_test(model_path): from base_model.cifar_resnet18 import cifar_resnet18 from dataset import create_test_dataset ds_val = create_test_dataset() #model_path = '../exps/exp0/checkpoint.pth.tar' net = cifar_resnet18() if model_path is not None: checkpoint = torch.load(model_path) net.load_state_dict(checkpoint['state_dict']) net.cuda() epoch = next(ds_val.epoch_generator()) roboustness = evalRoboustness(net, epoch) print(roboustness) if model_path is not None: s = model_path.split('/')[-1] val_res_path = os.path.join(model_path[:-18], 'r_results.txt') with open(val_res_path, 'a') as f: f.write('\n') json.dump({'Roboustness': roboustness}, f)
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 process_single_epoch(): print('**************') parser = argparse.ArgumentParser() 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(10000) AttackMethod = config.create_evaluation_attack_method(DEVICE) filename = '../ckpts/binary-epoch31.checkpoint' print(filename) if os.path.isfile(filename): load_checkpoint(filename, net) print('Evaluating') clean_acc, adv_acc = my_eval_one_epoch(net, ds_val, DEVICE, AttackMethod) print('clean acc -- {} adv acc -- {}'.format(clean_acc, adv_acc))
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(): 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)))
if __name__ == '__main__': parser = argparse.ArgumentParser() parser.add_argument('--resume', type=str, default='../exps/tradeoff.eps8/checkpoint.pth.tar') parser.add_argument('-d', type=int, default=3) args = parser.parse_args() net_name = args.resume.split('/')[-2] print(net_name) path = os.path.join('../SmoothRes', net_name) if not os.path.exists(path): os.mkdir(path) net = models.resnet18(pretrained=False) net.fc.out_features = 200 net.load_state_dict(torch.load(args.resume)['state_dict']) DEVICE = torch.device('cuda:{}'.format(args.d)) net.to(DEVICE) dl = create_test_dataset(32) #xz_test(dl, 1,net, DEVICE) #test_model(net, dl) #l1_for_without_smooth(net, dl, DEVICE) #l1_for_with_smooth(net, dl, DEVICE) get_result(net, dl, DEVICE, net_name)
lr_scheduler = config.create_lr_scheduler(optimizer) Hamiltonian_func = Hamiltonian(net.layer_one, config.weight_decay) layer_one_optimizer = optim.SGD(net.layer_one.parameters(), lr=lr_scheduler.get_lr()[0], momentum=0.9, weight_decay=5e-4) lyaer_one_optimizer_lr_scheduler = optim.lr_scheduler.MultiStepLR( layer_one_optimizer, milestones=[15, 19], gamma=0.1) LayerOneTrainer = FastGradientLayerOneTrainer(Hamiltonian_func, layer_one_optimizer, config.inner_iters, config.sigma, config.eps) ds_train = create_train_dataset(args.batch_size) ds_val = create_test_dataset(args.batch_size) 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) now_train_time = 0 while True: if now_epoch > config.num_epochs: break now_epoch = now_epoch + 1
if os.path.isfile(args.resume): print("=> loading checkpoint '{}'".format(args.resume)) check_point = torch.load(args.resume) net.load_state_dict(check_point['state_dict']) print('Modeled loaded from {} with metrics:'.format(args.resume)) else: print("=> no checkpoint found at '{}'".format(args.resume)) base_path = os.path.split(args.resume)[0] else: base_path = './' net.eval() criterion = torch.nn.CrossEntropyLoss().cuda() ds_val = create_test_dataset() ds_b = create_benchmark_dataset() if args.val: valacc, valcros, valtv, l1 = val_one_epoch(net, ds_val, criterion, clock) val_file = os.path.join(base_path, 'val.txt') with open(val_file, 'w') as f: print([valacc, valcros, valtv, l1], file=f) if args.bench: results_path = os.path.join(base_path, 'benchmark_results', str(clock.epoch)) test_on_benchmark(net, ds_b, criterion, results_path) if args.smooth: results_path = os.path.join(base_path, 'smooth')
args = parser.parse_args() net_name = args.resume.split('/')[-2] print(net_name) path = os.path.join('../SmoothRes', net_name) if not os.path.exists(path): os.mkdir(path) net = models.resnet18(pretrained=False) net.fc.out_features = 200 net.load_state_dict(torch.load(args.resume)['state_dict']) DEVICE = torch.device('cuda:{}'.format(args.d)) net.to(DEVICE) dl_teacher = create_test_dataset(32) if args.p is None and args.b is None: dl = create_test_dataset(32) if args.b is not None and args.p is None: dl = create_brighness_test_dataset(batch_size = 32, root = './', bright_level = args.b) if args.p is not None and args.b is None: dl = create_saturation_test_dataset(32, root = './', saturation_level = args.p) if args.k is not None: dl = create_patch_test_dataset(32, './', args.k) # style #dl = create_style_test_dataset(32)
linestyle='-.', label='YOPO Robust Error') plt.legend(loc='upper left') plt.show() net = create_network() criterion = nn.CrossEntropyLoss() optimizer = optim.SGD(net.parameters(), lr=1e-2, momentum=0.95, weight_decay=1e-4) # prepare dataset ds_train = create_train_dataset(batch_size) ds_val = create_test_dataset(batch_size) def visualize(time_arr, pgd_clean_err, pgd_robust_err): fig = plt.figure() ax1 = fig.add_subplot(111) ax1.plot(time_arr, pgd_clean_err, color='red', label='PGD Clean Error') ax1.plot(time_arr, pgd_robust_err, color='red', linestyle='-.', label='PGD Robust Error') plt.legend(loc='upper left') plt.show()
window_size = int(arguments['<window_size>']) smoothing_window_size = int(arguments['<smoothing_window_size>']) pickled_model_file = arguments['<pickled_model_file>'] output_file = arguments['<output_file>'] original_pssm = arguments['--original'] exp_pssm = arguments['--exp'] smoothed_pssm = arguments['--smoothed'] exp_smoothed_pssm = arguments['--exp_smoothed'] AAindex = arguments['--aaindex'] secondary_structure = arguments['--secondary_structure'] undersampling = False shuffle = True # Normalizing AAindex. feature.normalize_AAindex() data_filepath = filepath.DataFilepath(data_path_file) protein_holder = create_ProteinHolder(smoothing_window_size, data_filepath) test_dataset, proteinid_index_list = dataset.create_test_dataset(protein_holder, window_size, original_pssm=original_pssm, exp_pssm=exp_pssm, smoothed_pssm=smoothed_pssm, exp_smoothed_pssm=exp_smoothed_pssm, AAindex=AAindex, secondary_structure=secondary_structure, ) pkl_file = open(pickled_model_file, 'rb') clf = pickle.load(pkl_file) pkl_file.close() decision_values = clf.decision_function(test_dataset) if type(decision_values[0]) is list or type(decision_values[0]) is numpy.ndarray: decision_values = map(lambda x: x[0], decision_values) predicted_labels = clf.predict(test_dataset) write_to_output_file(output_file, decision_values, predicted_labels, proteinid_index_list)
break labels = np.array(labels) labels = labels.reshape(-1) np.savetxt(os.path.join(p, 'label.txt'), labels) if __name__ == '__main__': root = '../../data/benchmark/' names = [ 'val', 'style', 'sat1024', 'sat1', 'sat64', 'sat16', 'sat8', 'sat4', 'p2', 'p4', 'p8' ] dl_val = create_test_dataset(batch_size=64) dl_style = create_style_test_dataset(batch_size=64) dl_sat1024 = create_saturation_test_dataset(batch_size=64, saturation_level=1024) dl_sat02 = create_saturation_test_dataset(batch_size=64, saturation_level=1) dl_sat64 = create_saturation_test_dataset(batch_size=64, saturation_level=64) dl_sat16 = create_saturation_test_dataset(batch_size=64, saturation_level=16) dl_sat8 = create_saturation_test_dataset(batch_size=64, saturation_level=8) dl_sat4 = create_saturation_test_dataset(batch_size=64, saturation_level=4) dl_p2 = create_patch_test_dataset(64, k=2) dl_p4 = create_patch_test_dataset(64, k=4) dl_p8 = create_patch_test_dataset(64, k=8)