def testExponentialScheduler(self): model = models.LeNet(10, [1, 12, 12], channels=2) cuda = True if cuda: model = model.cuda() lr = 0.1 momentum = 0.9 optimizer = torch.optim.SGD(model.parameters(), lr=lr, momentum=momentum) gamma = 0.9 scheduler = common.train.get_exponential_scheduler( optimizer, batches_per_epoch=len(self.trainset), gamma=gamma) writer = common.summary.SummaryDictWriter() augmentation = None trainer = common.train.NormalTraining(model, self.trainset, self.testset, optimizer, scheduler, augmentation=augmentation, writer=writer, cuda=cuda) trainer.summary_gradients = True epochs = 10 for e in range(epochs): trainer.step(e) self.assertAlmostEqual(scheduler.get_lr()[0], lr * gamma**(e + 1))
def testAdversarialTraining(self): model = models.LeNet(10, [1, 28, 28], channels=12) cuda = True if cuda: model = model.cuda() optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9) scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.1) writer = torch.utils.tensorboard.SummaryWriter('./logs/') augmentation = None epsilon = 0.3 attack = attacks.BatchGradientDescent() attack.max_iterations = 2 attack.base_lr = 0.1 attack.momentum = 0 attack.c = 0 attack.lr_factor = 1.5 attack.normalized = True attack.backtrack = True attack.initialization = attacks.initializations.LInfUniformInitialization(epsilon) attack.norm = attacks.norms.LInfNorm() attack.projection = attacks.projections.SequentialProjections([attacks.projections.LInfProjection(epsilon), attacks.projections.BoxProjection()]) objective = attacks.objectives.UntargetedF0Objective() trainer = common.train.AdversarialTraining(model, self.trainset, self.testset, optimizer, scheduler, attack, objective, fraction=0.5, augmentation=augmentation, writer=writer, cuda=cuda) trainer.summary_gradients = True epochs = 10 trainer.test(-1) for e in range(epochs): trainer.step(e) writer.flush() print(e)
def testTest(self): model = models.LeNet(10, [1, 28, 28], channels=12) if self.cuda: model = model.cuda() model.eval() probabilities = common.test.test(model, self.testset, cuda=self.cuda) eval = common.eval.CleanEvaluation(probabilities, self.testset.dataset.labels) self.assertGreaterEqual(0.05, abs(0.9 - eval.test_error()))
def testCyclicScheduler(self): model = models.LeNet(10, [1, 12, 12], channels=2) cuda = True if cuda: model = model.cuda() lr = 0.1 momentum = 0.9 optimizer = torch.optim.SGD(model.parameters(), lr=lr, momentum=momentum) # should move in triangle between 0.01*lr and lr every two epochs scheduler = common.train.get_cyclic_scheduler(optimizer, batches_per_epoch=len( self.trainset), base_lr=0.01 * lr, max_lr=lr, step_size_factor=2) writer = common.summary.SummaryDictWriter() augmentation = None epoch_lrs = [ (0.01 * lr + lr) / 2, # lr AFTER first epoch (i.e., for e = 0) lr, (0.01 * lr + lr) / 2, 0.01 * lr, (0.01 * lr + lr) / 2, lr, (0.01 * lr + lr) / 2, 0.01 * lr, (0.01 * lr + lr) / 2, lr, (0.01 * lr + lr) / 2, 0.01 * lr, ] trainer = common.train.NormalTraining(model, self.trainset, self.testset, optimizer, scheduler, augmentation=augmentation, writer=writer, cuda=cuda) trainer.summary_gradients = True epochs = 10 for e in range(epochs): trainer.step(e) self.assertAlmostEqual(scheduler.get_lr()[0], epoch_lrs[e])
def testLeNet(self): resolutions = [ [1, 2, 2], [1, 3, 3], [1, 4, 4], [1, 5, 5], [1, 4, 5], [1, 5, 4], [1, 27, 32], [1, 32, 27], [1, 32, 32], [3, 32, 32], ] channels = [1, 2] activations = [ torch.nn.ReLU, torch.nn.Sigmoid, torch.nn.Tanh, ] normalizations = [ True, False ] clamps = [ True, False ] scales_and_whitens = [ (False, False), (True, False), (False, True), ] classes = 10 for resolution in resolutions: for channel in channels: for activation in activations: for normalization in normalizations: for clamp in clamps: for scale_and_whiten in scales_and_whitens: original_model = models.LeNet(classes, resolution, clamp=clamp, scale=scale_and_whiten[0], whiten=scale_and_whiten[1], channels=channel, activation=activation, normalization=normalization) for parameters in original_model.parameters(): parameters.data.zero_() common.state.State.checkpoint(self.filepath, original_model) state = common.state.State.load(self.filepath) loaded_model = state.model for parameters in loaded_model.parameters(): self.assertEqual(torch.sum(parameters).item(), 0)
def testBatchGradientDescentNormalizedBacktrack(self): cuda = True model_file = 'mnist_lenet.pth.tar' if os.path.exists(model_file): state = common.state.State.load(model_file) model = state.model if cuda: model = model.cuda() else: model = models.LeNet(10, [1, 28, 28], channels=12) if cuda: model = model.cuda() optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9) scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 5, 0.1) writer = common.summary.SummaryWriter() augmentation = None trainer = common.train.NormalTraining(model, self.trainset, self.testset, optimizer, scheduler, augmentation=augmentation, writer=writer, cuda=cuda) for e in range(10): trainer.step(e) print(e) common.state.State.checkpoint(model_file, model, optimizer, scheduler, e) model.eval() epsilon = 0.3 writer = torch.utils.tensorboard.SummaryWriter('./logs/') attack = attacks.batch_gradient_descent.BatchGradientDescent() attack.max_iterations = 5 attack.base_lr = 0.1 attack.momentum = 0 attack.c = 0 attack.lr_factor = 1.5 attack.normalized = True attack.backtrack = True attack.initialization = attacks.initializations.LInfUniformInitialization(epsilon) attack.projection = attacks.projections.SequentialProjections([attacks.projections.LInfProjection(epsilon), attacks.projections.BoxProjection()]) attack.norm = attacks.norms.LInfNorm() for b, (images, labels) in enumerate(self.testset): break images = common.torch.as_variable(images, cuda).permute(0, 3, 1, 2) labels = common.torch.as_variable(labels, cuda) objective = attacks.objectives.UntargetedF0Objective() objective.set(labels) attack.run(model, images, objective, writer=writer) writer.flush()
def testModelOptimizer(self): original_model = models.LeNet(10, [1, 32, 32]) original_optimizer = torch.optim.SGD(original_model.parameters(), lr=0.01, momentum=0.9) state = common.state.State(original_model, original_optimizer) state.save(self.filepath) state = common.state.State.load(self.filepath) loaded_model = state.model loaded_optimizer = torch.optim.SGD(original_model.parameters(), lr=0.99, momentum=0.1) loaded_optimizer.load_state_dict(state.optimizer) for param_group in loaded_optimizer.param_groups: self.assertEqual(param_group['lr'], 0.01) self.assertEqual(param_group['momentum'], 0.9)
def create_net(num_classes, dnn='resnet20', **kwargs): ext = None if dnn in ['resnet20', 'resnet56', 'resnet110']: net = models.__dict__[dnn](num_classes=num_classes) elif dnn == 'resnet50': net = torchvision.models.resnet50(num_classes=num_classes) elif dnn == 'resnet101': net = torchvision.models.resnet101(num_classes=num_classes) elif dnn == 'resnet152': net = torchvision.models.resnet152(num_classes=num_classes) elif dnn == 'densenet121': net = torchvision.models.densenet121(num_classes=num_classes) elif dnn == 'densenet161': net = torchvision.models.densenet161(num_classes=num_classes) elif dnn == 'densenet201': net = torchvision.models.densenet201(num_classes=num_classes) elif dnn == 'inceptionv4': net = models.inceptionv4(num_classes=num_classes) elif dnn == 'inceptionv3': net = torchvision.models.inception_v3(num_classes=num_classes) elif dnn == 'vgg16i': # vgg16 for imagenet net = torchvision.models.vgg16(num_classes=num_classes) elif dnn == 'googlenet': net = models.googlenet() elif dnn == 'mnistnet': net = MnistNet() elif dnn == 'fcn5net': net = models.FCN5Net() elif dnn == 'lenet': net = models.LeNet() elif dnn == 'lr': net = models.LinearRegression() elif dnn == 'vgg16': net = models.VGG(dnn.upper()) elif dnn == 'alexnet': #net = models.AlexNet() net = torchvision.models.alexnet() elif dnn == 'lstman4': net, ext = models.LSTMAN4(datapath=kwargs['datapath']) elif dnn == 'lstm': # model = lstm(embedding_dim=args.hidden_size, num_steps=args.num_steps, batch_size=args.batch_size, # vocab_size=vocab_size, num_layers=args.num_layers, dp_keep_prob=args.dp_keep_prob) net = lstmpy.lstm(vocab_size=kwargs['vocab_size'], batch_size=kwargs['batch_size']) else: errstr = 'Unsupport neural network %s' % dnn logger.error(errstr) raise errstr return net, ext
def main(n, max): _, raw_testing_data = tf.keras.datasets.mnist.load_data() model = models.LeNet() activations = [ 'LeNet/conv2d/Relu:0', 'LeNet/conv2d_1/Relu:0', 'LeNet/dense/Relu:0' ] coverage_analyzer = cov_anal.NC(activations) checkpoint_path = "./backup/lenet.ckpt" test_lenet(checkpoint_path=checkpoint_path, model=model, n_elements=n, max_iterations=max, testing_dataset=raw_testing_data, coverage_analyzer=coverage_analyzer)
def testModelOnly(self): original_model = models.LeNet(10, [1, 32, 32]) for parameters in original_model.parameters(): parameters.data.zero_() state = common.state.State(original_model) state.save(self.filepath) state = common.state.State.load(self.filepath) loaded_model = state.model self.assertEqual(loaded_model.__class__.__name__, original_model.__class__.__name__) self.assertListEqual(loaded_model.resolution, original_model.resolution) for parameters in loaded_model.parameters(): self.assertEqual(torch.sum(parameters).item(), 0)
def testModelOptimizerScheduler(self): original_model = models.LeNet(10, [1, 32, 32]) original_optimizer = torch.optim.SGD(original_model.parameters(), lr=0.01, momentum=0.9) original_scheduler = torch.optim.lr_scheduler.StepLR(original_optimizer, step_size=10, gamma=0.9) state = common.state.State(original_model, original_optimizer, original_scheduler) state.save(self.filepath) state = common.state.State.load(self.filepath) loaded_model = state.model loaded_optimizer = torch.optim.SGD(original_model.parameters(), lr=0.99, momentum=0.1) loaded_optimizer.load_state_dict(state.optimizer) loaded_scheduler = torch.optim.lr_scheduler.StepLR(original_optimizer, step_size=10, gamma=0.9) loaded_scheduler.load_state_dict(state.scheduler) self.assertEqual(original_scheduler.step_size, loaded_scheduler.step_size) self.assertEqual(original_scheduler.gamma, loaded_scheduler.gamma)
def train_lenet(N_epochs, batch_size, checkpoint_path): (x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data() train_data = DataLoaderFromArrays(x_train, y_train, one_hot=True, normalization=True) test_data = DataLoaderFromArrays(x_test, y_test, one_hot=True, normalization=True) X_test, Y_test = test_data.get_data() model = models.LeNet() saver = tf.train.Saver() best_test_accurary = 0.0 with tf.Session() as sess: sess.run(tf.global_variables_initializer()) for epoch in range(N_epochs): for i in range(train_data.N_instances // batch_size): batch_x, batch_y = train_data.next_batch(batch_size) sess.run(model.train_op, feed_dict={ model.features: batch_x, model.labels: batch_y }) if i % 50 == 0: loss, accurary = sess.run([model.loss, model.accuracy], feed_dict={ model.features: batch_x, model.labels: batch_y }) print('[Epoch {}] i: {} Loss: {} Accurary: {}'.format( epoch, i, loss, accurary)) test_accurary = sess.run(model.accuracy, feed_dict={ model.features: X_test, model.labels: Y_test }) print('Test Accurary: {}'.format(test_accurary)) if best_test_accurary < test_accurary: saver.save(sess, checkpoint_path) best_test_accurary = test_accurary print('Best Test Accurary: {}'.format(best_test_accurary))
def testNormalTraining(self): model = models.LeNet(10, [1, 28, 28], channels=12) cuda = True if cuda: model = model.cuda() optimizer = torch.optim.SGD(model.parameters(), lr=0.1, momentum=0.9) scheduler = torch.optim.lr_scheduler.StepLR(optimizer, step_size=5, gamma=0.1) writer = torch.utils.tensorboard.SummaryWriter('./logs/') augmentation = None trainer = common.train.NormalTraining(model, self.trainset, self.testset, optimizer, scheduler, augmentation=augmentation, writer=writer, cuda=cuda) trainer.summary_gradients = True epochs = 25 trainer.test(-1) for e in range(epochs): trainer.step(e) writer.flush() print(e)
def get_model(p, X_train=None, Y_train_onehot=None): # make sure data types are right if 'num_layers' in vars(p).keys(): p.num_layers = int(p.num_layers) if 'hidden_size' in vars(p).keys(): p.hidden_size = int(p.hidden_size) # actually look for data if 'mnist' in p.dset: if p.use_conv_special: model = models.Linear_then_conv() elif p.use_conv: model = models.LeNet() elif p.num_layers > 0: model = models.LinearNet(p.num_layers, 28 * 28, p.hidden_size, 10) else: model = models.LinearNet(3, 28 * 28, 256, 10) elif 'cifar10' in p.dset: if p.use_conv_special: model = models.LinearThenConvCifar() elif p.use_conv == 'stacknet': import cnns.stacknet model = cnns.stacknet.StackNet() elif p.use_conv: model = models.Cifar10Conv() elif p.num_layers > 0: model = models.LinearNet(p.num_layers, 32 * 32 * 3, p.hidden_size, 10) else: model = models.LinearNet(3, 32 * 32 * 3, 256, 10) elif p.dset in ['bars', 'noise']: model = models.LinearNet(p.num_layers, 8 * 8, p.hidden_size, 16) if 'siamese' in vars(p).keys() and p.siamese: model = siamese.SiameseNet(model, X_train, Y_train_onehot, p.reps, p.similarity, p.siamese_init, p.train_prototypes, p.prototype_dim) if 'linear' in p.dset: model = models.LinearNet(p.num_layers, p.num_features, p.hidden_size, 1) return model
def create_net(num_classes, dnn='resnet20', **kwargs): ext = None if dnn in ['resnet20', 'resnet56', 'resnet110']: net = models.__dict__[dnn](num_classes=num_classes) elif dnn == 'resnet50': #net = models.__dict__['resnet50'](num_classes=num_classes) net = torchvision.models.resnet50(num_classes=num_classes) elif dnn == 'inceptionv4': net = models.inceptionv4(num_classes=num_classes) elif dnn == 'inceptionv3': net = torchvision.models.inception_v3(num_classes=num_classes) elif dnn == 'vgg16i': # vgg16 for imagenet net = torchvision.models.vgg16(num_classes=num_classes) elif dnn == 'googlenet': net = models.googlenet() elif dnn == 'mnistnet': net = MnistNet() elif dnn == 'fcn5net': net = models.FCN5Net() elif dnn == 'lenet': net = models.LeNet() elif dnn == 'lr': net = models.LinearRegression() elif dnn == 'vgg16': net = models.VGG(dnn.upper()) elif dnn == 'alexnet': net = torchvision.models.alexnet() elif dnn == 'lstman4': net, ext = models.LSTMAN4(datapath=kwargs['datapath']) elif dnn == 'lstm': net = lstmpy.lstm(vocab_size=kwargs['vocab_size'], batch_size=kwargs['batch_size']) else: errstr = 'Unsupport neural network %s' % dnn logger.error(errstr) raise errstr return net, ext
def testLeNet(self): resolutions = [ [1, 2, 2], [1, 3, 3], [1, 4, 4], [1, 5, 5], [1, 4, 5], [1, 5, 4], [1, 27, 32], [1, 32, 27], [1, 32, 32], [3, 32, 32], ] channels = [1, 2] activations = [ torch.nn.ReLU, torch.nn.Sigmoid, torch.nn.Tanh, ] normalizations = [True, False] classes = 10 batch_size = 100 for resolution in resolutions: for channel in channels: for activation in activations: for normalization in normalizations: model = models.LeNet(classes, resolution, clamp=True, channels=channel, activation=activation, normalization=normalization) output = model( torch.autograd.Variable( torch.zeros([batch_size] + resolution))) self.assertEqual(output.size()[0], batch_size) self.assertEqual(output.size()[1], classes)
filenames = ["accuracy_loss", "result", "knn"] filenames = add_to_str_ls(results_folder, filenames, before=True) filenames.append("../weights/weights") for arg in vars(args): add_ = "_" + arg + "=" + str(getattr(args, arg)) filenames = add_to_str_ls(add_, filenames) filenames1 = add_to_str_ls(".csv", filenames[:2]) acc_name, result_name = filenames1 f_name = filenames[-2] + ".txt" weights_name = filenames[-1] + ".pth" ## MODEL if (args.model == "convnet"): network = models.ConvNet(shape=args.shape) if (args.model == "lenet"): network = models.LeNet(shape=args.shape) if (args.model == "gao"): network = models.Gao(shape=args.shape) if (args.model == "jitaree"): network = models.Jitaree(shape=args.shape) if (args.model == "vae"): network = models.VAE(shape=args.shape, batch_size=args.batch) #if (args.model == "waae"): # network = models.WAAE(shape=args.shape) if (args.model == "knn"): network = models.kNN() if (args.model == "xgboost"): network = models.XGBoost() if (not args.model in ["knn", "xgboost"]): if (bool(args.load)): network.load_state_dict(torch.load(weights_name))
from models import * import models import os, sys import time train_dataset = equation_linear_images_dataset_train(cv_set_file='cv_set_linear.p', right_asnwer_chance=.5) test_dataset = equation_linear_images_dataset_cv(cv_set_file='cv_set_linear.p', right_asnwer_chance=.5) train_loader = DataLoader(train_dataset, batch_size=50, shuffle=True, num_workers=16) test_loader = DataLoader(test_dataset, batch_size=50, shuffle=True, num_workers=16) # for i_batch, sample_batched in enumerate(dataloader): # print(sample_batched['feature_vector'].shape) # if i_batch == 3: break model = models.LeNet() model.cuda() summary = repr(model) # model = torch.load('test.pt') print(summary) mod_name = summary.split('\n')[0][:-1] # model name dir = mod_name + "_" + time.strftime("%m-%d-%H:%M") os.makedirs(dir) f = open('./'+ dir + '/' + 'log_' + mod_name + '.log', 'w') f.write(summary + '\n') # if torch.cuda.device_count() > 1: # print("Let's use", torch.cuda.device_count(), "GPUs!") # model = nn.DataParallel(model)
def main(args): # Set GPUs and device os.environ['CUDA_VISIBLE_DEVICES'] = args.visible_gpus device = 'cuda' if torch.cuda.is_available else 'cpu' print('Running on %s' % device) # Set environment torch.manual_seed(args.seed) # Get dataset and define transformations dst = datasets.CIFAR100(args.data_dir, download=True) tp = transforms.Compose([ transforms.Resize(32), transforms.CenterCrop(32), transforms.ToTensor() ]) tt = transforms.ToPILImage() # Construct model and intiaize weights net = models.LeNet().to(device) net.apply(utils.weights_init) # Define criterion criterion = utils.cross_entropy_for_onehot # Get attack data and label gt_data = tp(dst[args.image_idx][0]).to(device) gt_data = gt_data.view(1, *gt_data.size()) gt_image = tt(gt_data[0].cpu()) gt_label = torch.Tensor([dst[args.image_idx][1]]).long().to(device) gt_label = gt_label.view(1, ) gt_onehot_label = utils.label_to_onehot(gt_label, num_classes=100) # Compute original gradient out = net(gt_data) y = criterion(out, gt_onehot_label) dy_dx = torch.autograd.grad(y, net.parameters()) # Share the gradients with other clients original_dy_dx = list((_.detach().clone() for _ in dy_dx)) # Generate dummy data and label dummy_data = torch.randn(gt_data.size()).to(device).requires_grad_(True) dummy_label = torch.randn( gt_onehot_label.size()).to(device).requires_grad_(True) dummy_init_image = tt(dummy_data[0].cpu()) dummy_init_label = torch.argmax(dummy_label, dim=-1) # Define optimizer optimizer = torch.optim.LBFGS([dummy_data, dummy_label]) # Run DLG method dummy_grads, dummy_lbfgs_num_iter, history = \ dlg_method(dummy_data, dummy_label, original_dy_dx, net, criterion, optimizer, tt, max_iters=args.max_iters) # Save model params_path = os.path.join(args.exp_dir, '%04d_params.pkl' % args.image_idx) torch.save(net.state_dict(), params_path) print('Save model parameters to %s' % params_path) # Index computation functions compute_l2norm = lambda x: (x**2).sum().item()**0.5 compute_min = lambda x: x.min().item() compute_max = lambda x: x.max().item() compute_mean = lambda x: x.mean().item() compute_median = lambda x: x.median().item() original_grads_norm = [compute_l2norm(e) for e in original_dy_dx] original_grads_min = [compute_min(e) for e in original_dy_dx] original_grads_max = [compute_max(e) for e in original_dy_dx] original_grads_mean = [compute_mean(e) for e in original_dy_dx] original_grads_median = [compute_median(e) for e in original_dy_dx] dummy_grads_norm = np.array([[compute_l2norm(e) for e in r] for r in dummy_grads]) dummy_grads_min = np.array([[compute_min(e) for e in r] for r in dummy_grads]) dummy_grads_max = np.array([[compute_max(e) for e in r] for r in dummy_grads]) dummy_grads_mean = np.array([[compute_mean(e) for e in r] for r in dummy_grads]) dummy_grads_median = np.array([[compute_median(e) for e in r] for r in dummy_grads]) # Plot and save figures fig_dir = os.path.join(args.exp_dir, 'figures') if not os.path.exists(fig_dir): os.makedirs(fig_dir) img_history = [[tt(hd), hl] for hd, hl in history] utils.plot_history([gt_image, gt_label], [dummy_init_image, dummy_init_label], img_history, title='Image %04d History' % args.image_idx, fig_path=os.path.join( fig_dir, '%04d_history.png' % args.image_idx)) utils.plot_convergency_curve( dummy_grads_norm, original_grads_norm, title='Image %04d L2 Norm Convergency' % args.image_idx, fig_path=os.path.join(fig_dir, '%04d_l2norm.png' % args.image_idx)) utils.plot_convergency_curve( dummy_grads_min, original_grads_min, title='Image %04d Min Value Convergency' % args.image_idx, fig_path=os.path.join(fig_dir, '%04d_min.png' % args.image_idx)) utils.plot_convergency_curve( dummy_grads_max, original_grads_max, title='Image %04d Max Value Convergency' % args.image_idx, fig_path=os.path.join(fig_dir, '%04d_max.png' % args.image_idx)) utils.plot_convergency_curve( dummy_grads_mean, original_grads_mean, title='Image %04d Mean Convergency' % args.image_idx, fig_path=os.path.join(fig_dir, '%04d_mean.png' % args.image_idx)) utils.plot_convergency_curve( dummy_grads_median, original_grads_median, title='Image %04d Median Value Convergency' % args.image_idx, fig_path=os.path.join(fig_dir, '%04d_median.png' % args.image_idx)) compute_mse = lambda x, y: ((x - y)**2).sum().item()**0.5 final_mse = compute_mse(dummy_data, gt_data) converged = final_mse < args.mse_tol print('Converged!! (MSE=%2.6f)' % final_mse if converged else 'Diverged!! (MSE=%2.6f)' % final_mse) # Save MSEs mses = np.array([compute_mse(hd.cuda(), gt_data) for hd, _ in history]) with open(os.path.join(args.exp_dir, '%04d_mses.npy' % args.image_idx), 'wb') as opf: np.save(opf, mses)
def getModel(cls): return models.LeNet(10, [1, 28, 28])
def testAttack(self): model = models.LeNet(10, [1, 28, 28], channels=12) #state = common.state.State.load('mnist_lenet.pth.tar') #model = state.model if self.cuda: model = model.cuda() epsilon = 0.3 attack = attacks.BatchGradientDescent() attack.max_iterations = 2 attack.base_lr = 0.1 attack.momentum = 0 attack.c = 0 attack.lr_factor = 1 attack.normalized = True attack.backtrack = False attack.initialization = attacks.initializations.LInfUniformInitialization( epsilon) attack.norm = attacks.norms.LInfNorm() attack.projection = attacks.projections.SequentialProjections([ attacks.projections.LInfProjection(epsilon), attacks.projections.BoxProjection() ]) objective = attacks.objectives.UntargetedF0Objective() model.eval() attempts = 1 perturbations, adversarial_probabilities, errors = common.test.attack( model, self.adversarialset, attack, objective, attempts=attempts, writer=common.summary.SummaryWriter(), cuda=self.cuda) self.assertEqual(perturbations.shape[0], attempts) self.assertEqual(perturbations.shape[1], self.adversarialset.dataset.images.shape[0]) self.assertEqual(perturbations.shape[2], self.adversarialset.dataset.images.shape[3]) self.assertEqual(perturbations.shape[3], self.adversarialset.dataset.images.shape[1]) self.assertEqual(perturbations.shape[4], self.adversarialset.dataset.images.shape[2]) self.assertEqual(adversarial_probabilities.shape[0], attempts) self.assertEqual(adversarial_probabilities.shape[1], perturbations.shape[1]) self.assertEqual(adversarial_probabilities.shape[2], numpy.max(self.adversarialset.dataset.labels) + 1) perturbations = numpy.transpose(perturbations, (0, 1, 3, 4, 2)) adversarialloader = torch.utils.data.DataLoader( common.datasets.AdversarialDataset( self.adversarialset.dataset.images, perturbations, self.adversarialset.dataset.labels), batch_size=100, shuffle=False) self.assertEqual(len(adversarialloader), attempts * len(self.adversarialset)) clean_probabilities = common.test.test(model, adversarialloader, cuda=self.cuda) adversarial_probabilities = adversarial_probabilities.reshape( adversarial_probabilities.shape[0] * adversarial_probabilities.shape[1], adversarial_probabilities.shape[2]) self.assertTrue( numpy.all( numpy.sum(perturbations.reshape( perturbations.shape[0] * perturbations.shape[1], -1), axis=1) > 0)) numpy.testing.assert_array_almost_equal(clean_probabilities, adversarial_probabilities)
import models name_to_model = { 'LeNet': lambda args: models.LeNet(**args), 'AlexNet': lambda args: models.AlexNet(**args), 'MLP': lambda args: models.MLP(**args), 'ResNet18': lambda args: models.ResNet18(**args), 'PResNet18': lambda args: models.PResNet18(**args), 'Permutation': lambda args: models.TensorPermutation(32, 32, **args), 'ResNet20Original': lambda args: models.resnet20original(), 'MobileNet': lambda args: models.MobileNet(**args), 'ShuffleNet': lambda args: models.ShuffleNetG2(), 'WideResNet28': lambda args: models.WideResNet28(**args), } def get_model(model_config): name = model_config['name'] return name_to_model[name](model_config.get('args', None))
test_loader = torch.utils.data.DataLoader( datasets.MNIST('data', train=False, transform=transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,)) ])), batch_size=args.test_batch_size, shuffle=True, **kwargs) best_acc = 0.0 model_ori = None model_train = None model_test = None # generate the model if args.arch == 'LeNet': model_ori = models.LeNet() if args.cuda: model_ori.cuda() if args.pretrained: model_ori.load_state_dict(torch.load(args.pretrained)) elif args.arch == 'Bin_LeNet': model_train = models.Bin_LeNet_train() model_test = models.Bin_LeNet_test() if args.cuda: model_train = model_train.cuda() model_test = model_test.cuda() if args.pretrained: model_test.load_state_dict(torch.load(args.pretrained))
def getModel(cls): return models.LeNet(10, [1, 28, 28], channels=64)