def exp(model, n_epochs, opu, batch_size, binary_layer, lr, optimizer,
weight_decay, smoke_test, opu_output, opu_input, is_scheduler, dataset,
features_model, milestones):
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(f'- Current torch.device is: {device}')
net, file_name = get_model(model=model,
binary_layer=binary_layer,
n_epochs=n_epochs,
opu_output=opu_output,
opu_input=opu_input,
device=device,
dataset=dataset,
opu=opu)
if features_model is not None:
net = features_loading(net, dataset, device, features_model)
if optimizer == 'SGD':
print(
f'- Optimizer = {optimizer}, Starting lr = {lr}, Momentum = {0.9}, Weight decay = {weight_decay}'
)
optimizer = torch.optim.SGD(params=net.parameters(),
lr=lr,
momentum=0.9,
weight_decay=weight_decay)
else:
print(
f'- Optimizer = {optimizer}, Starting lr = {lr}, Weight decay = {weight_decay}'
)
optimizer = torch.optim.Adam(params=net.parameters(),
lr=lr,
weight_decay=weight_decay)
if smoke_test:
train_samples = 5000
else:
train_samples = None
if dataset == 'cifar10':
train_dl, test_dl = cifar10(batch_size=batch_size,
num_workers=16,
subsample=train_samples)
if dataset == 'cifar100':
train_dl, test_dl = cifar100(batch_size=batch_size,
num_workers=16,
subsample=train_samples)
net = training(net.to(device), train_dl, test_dl, device, n_epochs,
optimizer, is_scheduler, milestones)
train_acc = compute_score(net, train_dl, device)
test_acc = compute_score(net, test_dl, device)
print(f'- Train acc {train_acc:.2f}%, Test acc {test_acc:.2f}%')
return train_acc, test_acc, net, file_name
from utils import compute_score, cifar10, cifar100, get_model
import torch
_, c10_test = cifar10(batch_size=100)
_, c100_test = cifar100(batch_size=100)
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
useless_boolean = None
def acc_and_idx(model, binary_layer, opu, n_epochs, opu_output, opu_input, device, dataset):
net, net_name = get_model(model=model, binary_layer=binary_layer, opu=opu, n_epochs=n_epochs, opu_output=opu_output,
opu_input=opu_input, sign_back=False, device=device, dataset=dataset)
path = 'results/c' + dataset[5:] + '/models/'
net.load_state_dict(torch.load(path + net_name + '.pt'))
net.eval()
if dataset == 'cifar10':
dataloader = c10_test
else:
dataloader = c100_test
acc, indexes = compute_score(net, dataloader, device=device, save_correct_labels=True)
return acc, indexes
# Transfer experiments
print('Transfer')
acc, idx_TA_low = acc_and_idx('VGG16-OPU', True, useless_boolean, 2, 8000, 1024, device, 'cifar10')
print('Fine-tuned, low accuracy, acc', acc)
acc, idx_TA_hig = acc_and_idx('VGG16-OPU', True, useless_boolean, 5, 8000, 1024, device, 'cifar10')
print('Fine-tuned, high accuracy, acc', acc)
acc, idx_baseli = acc_and_idx('VGG-16', False, useless_boolean, 38, 512, 512, device, 'cifar10')
from __future__ import print_function
from keras.preprocessing.image import ImageDataGenerator
from keras.models import Sequential
from keras.layers import Dense, Dropout, Activation, Flatten
from keras.layers import Convolution2D, MaxPooling2D
from utils import cifar10
batch_size = 32
nb_epoch = 200
data_augmentation = True
# The CIFAR10 images are RGB.
img_channels = 3
(X_train, Y_train), (X_test, Y_test), input_shape, nb_classes = cifar10()
model = Sequential()
model.add(Convolution2D(32, 3, 3, border_mode='same',
input_shape=X_train.shape[1:]))
model.add(Activation('relu'))
model.add(Convolution2D(32, 3, 3))
model.add(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))
model.add(Convolution2D(64, 3, 3, border_mode='same'))
model.add(Activation('relu'))
model.add(Convolution2D(64, 3, 3))
model.add(Activation('relu'))
def add_data(self, batch_size):
train_loader, test_loader = cifar10(batch_size)
self.train_loader = train_loader
self.test_loader = test_loader
if __name__ == '__main__':
import pathlib
args = pars_args()
attack_transfer = TransferAttack(model=args.model,
dataset=args.dataset,
n_epochs=args.n_epochs,
opu_output=args.opu_output,
opu_input=args.opu_input,
indexes=args.indexes,
binary_layer=args.binary_layer,
opu=args.opu)
if args.dataset == 'cifar10':
_, test_dl = cifar10(batch_size=100)
else:
_, test_dl = cifar100(batch_size=100)
if args.indexes:
msg = 'Test score={}. With indexes accuracy has to be 100%'
print(
msg.format(
compute_score(attack_transfer.model,
test_dl,
attack_transfer.device,
indexes=torch.load(args.indexes))))
else:
msg = 'Test score={}, to be compared to eps=0 attack'
print(
msg.format(
return args
if __name__ == '__main__':
import pathlib
args = pars_args()
adversarial_attack = AdversarialAttack(args.model, args.dataset,
args.n_epochs, args.step_size,
args.opu_output, args.opu_input,
args.pgd_attacks_iterations,
args.binary_layer, args.save_images,
args.sign_back, args.opu)
if args.dataset == 'cifar10':
_, test_dl = cifar10(
batch_size=100,
num_workers=8) # if it gives trouble remove num_workers
else:
_, test_dl = cifar100(batch_size=100, num_workers=8) # same as above
print(
f'Test score={compute_score(adversarial_attack.model, test_dl, adversarial_attack.device)}, to be compared to eps=0 attack'
)
epsilons = [0, .01, .02, .03, .04, .05]
if args.save_images:
epsilons = epsilons + [
0.06, 0.07, 0.08, 0.09, 0.1
] # images are saved for transfer attack experiments.
accuracies = list()
for eps in epsilons: