def __init__(self, args):
self.args = args
# Creating data loaders
transform_train = T.Compose([
T.Pad(4, padding_mode='reflect'),
T.RandomCrop(32),
T.RandomHorizontalFlip(),
T.ToTensor()
])
transform_test = T.Compose([T.ToTensor()])
kwargs = {'num_workers': 4, 'pin_memory': True}
train_dataset = datasets.CIFAR10(args.data_root,
train=True,
download=True,
transform=transform_train)
self.train_loader = torch.utils.data.DataLoader(
train_dataset, batch_size=args.batch_size, shuffle=True, **kwargs)
self.val_loader = torch.utils.data.DataLoader(
datasets.CIFAR10(args.data_root,
train=False,
transform=transform_test),
batch_size=args.batch_size,
shuffle=True,
**kwargs)
# Create model, optimizer and scheduler
self.model = models.WRN(depth=32, width=10, num_classes=10)
self.model = torch.nn.DataParallel(self.model).cuda()
self.optimizer = optim.SGD(self.model.parameters(),
args.lr,
momentum=0.9,
weight_decay=args.weight_decay)
self.lr_scheduler = optim.lr_scheduler.MultiStepLR(
self.optimizer, milestones=[70, 90, 100], gamma=0.2)
print('Number of model parameters: {}'.format(
sum([p.data.nelement() for p in self.model.parameters()])))
self.save_path = args.save_path
self.epoch = 0
num_samples = len(train_dataset)
self.epsilon_memory = torch.FloatTensor(num_samples).zero_().cuda()
# resume from checkpoint
ckpt_path = osp.join(args.save_path, 'checkpoint.pth')
if osp.exists(ckpt_path):
self._load_from_checkpoint(ckpt_path)
elif args.restore:
self._load_from_checkpoint(args.restore)
cudnn.benchmark = True
self.attacker = PGDAttackerAdaptive()
self.attacker_test = PGDAttacker(args.attack_eps)
def fetch_dataset(data_name, subset):
dataset = {}
print('fetching data {}...'.format(data_name))
root = './data/{}'.format(data_name)
if data_name == 'MNIST':
dataset['train'] = datasets.MNIST(root=root,
split='train',
subset=subset,
transform=datasets.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307, ),
(0.3081, ))
]))
dataset['test'] = datasets.MNIST(root=root,
split='test',
subset=subset,
transform=datasets.Compose([
transforms.ToTensor(),
transforms.Normalize((0.1307, ),
(0.3081, ))
]))
elif data_name == 'CIFAR10':
dataset['train'] = datasets.CIFAR10(
root=root,
split='train',
subset=subset,
transform=datasets.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465),
(0.2023, 0.1994, 0.2010))
]))
dataset['test'] = datasets.CIFAR10(root=root,
split='test',
subset=subset,
transform=datasets.Compose([
transforms.ToTensor(),
transforms.Normalize(
(0.4914, 0.4822, 0.4465),
(0.2023, 0.1994, 0.2010))
]))
elif data_name in ['PennTreebank', 'WikiText2', 'WikiText103']:
dataset['train'] = eval(
'datasets.{}(root=root, split=\'train\')'.format(data_name))
dataset['test'] = eval(
'datasets.{}(root=root, split=\'test\')'.format(data_name))
else:
raise ValueError('Not valid dataset name')
print('data ready')
return dataset
def _get_maf_original(data_name):
warnings.warn(
'This function should generally not be called because it '
'requires special setup but is kept here in order to reproduce functions if '
'needed.')
if sys.version_info < (3, ):
# Load MNIST from MAF code
maf_path = os.path.join(os.path.dirname(os.path.realpath(__file__)),
'..', '..', 'maf')
sys.path.append(maf_path)
# noinspection PyPackageRequirements
import datasets # maf/datasets/*
# Reset datasets root directory relative to this file
datasets.root = os.path.join(maf_path, 'data') + '/'
# Copied from maf/experiments.py
if data_name == 'mnist':
data = datasets.MNIST(logit=True, dequantize=True)
elif data_name == 'bsds300':
data = datasets.BSDS300()
elif data_name == 'cifar10':
data = datasets.CIFAR10(logit=True, flip=True, dequantize=True)
elif data_name == 'power':
data = datasets.POWER()
elif data_name == 'gas':
data = datasets.GAS()
elif data_name == 'hepmass':
data = datasets.HEPMASS()
elif data_name == 'miniboone':
data = datasets.MINIBOONE()
else:
raise ValueError('Unknown dataset')
# Make a dictionary instead of pickled object for better compatibility
if hasattr(data.trn, 'labels'):
data_dict = dict(
X_train=data.trn.x,
y_train=data.trn.labels,
X_validation=data.val.x,
y_validation=data.val.labels,
X_test=data.tst.x,
y_test=data.tst.labels,
data_name=data_name,
)
else:
data_dict = dict(
X_train=data.trn.x,
X_validation=data.val.x,
X_test=data.tst.x,
data_name=data_name,
)
else:
raise RuntimeError(
'Must create data using Python 2 to load data since MAF is written for '
'Python 2')
return data_dict
def _get_maf_original(data_name):
warnings.warn(
"This function should generally not be called because it "
"requires special setup but is kept here in order to reproduce functions if "
"needed.")
if sys.version_info < (3, ):
# Load MNIST from MAF code
maf_path = os.path.join(os.path.dirname(os.path.realpath(__file__)),
"..", "..", "maf")
sys.path.append(maf_path)
# noinspection PyPackageRequirements
import datasets # maf/datasets/*
# Reset datasets root directory relative to this file
datasets.root = os.path.join(maf_path, "data") + "/"
# Copied from maf/experiments.py
if data_name == "mnist":
data = datasets.MNIST(logit=True, dequantize=True)
elif data_name == "bsds300":
data = datasets.BSDS300()
elif data_name == "cifar10":
data = datasets.CIFAR10(logit=True, flip=True, dequantize=True)
elif data_name == "power":
data = datasets.POWER()
elif data_name == "gas":
data = datasets.GAS()
elif data_name == "hepmass":
data = datasets.HEPMASS()
elif data_name == "miniboone":
data = datasets.MINIBOONE()
else:
raise ValueError("Unknown dataset")
# Make a dictionary instead of pickled object for better compatibility
if hasattr(data.trn, "labels"):
data_dict = dict(
X_train=data.trn.x,
y_train=data.trn.labels,
X_validation=data.val.x,
y_validation=data.val.labels,
X_test=data.tst.x,
y_test=data.tst.labels,
data_name=data_name,
)
else:
data_dict = dict(
X_train=data.trn.x,
X_validation=data.val.x,
X_test=data.tst.x,
data_name=data_name,
)
else:
raise RuntimeError(
"Must create data using Python 2 to load data since MAF is written for "
"Python 2")
return data_dict
def load_data(name):
"""
Loads the dataset. Has to be called before anything else.
:param name: string, the dataset's name
"""
assert isinstance(name, str), 'Name must be a string'
datasets.root = root_data
global data, data_name
if data_name == name:
return
if name == 'mnist':
data = datasets.MNIST(logit=True, dequantize=True)
data_name = name
elif name == 'bsds300':
data = datasets.BSDS300()
data_name = name
elif name == 'cifar10':
data = datasets.CIFAR10(logit=True, flip=True, dequantize=True)
data_name = name
elif name == 'power':
data = POWER()
data_name = name
elif name == 'gas':
data = datasets.GAS()
data_name = name
elif name == 'hepmass':
data = datasets.HEPMASS()
data_name = name
elif name == 'miniboone':
data = datasets.MINIBOONE()
data_name = name
else:
raise ValueError('Unknown dataset')
def getTestDataset(test_dataset='cifar10', batch_size=32):
if test_dataset == 'Imagenet':
testFolder = os.path.join(os.path.dirname(os.path.abspath(__file__)),
'../val/')
print('testFolder', testFolder)
Imagenet = datasets.ImageNet12(trainFolder=None, testFolder=testFolder)
test_loader = Imagenet.getTestLoader(batch_size=batch_size,
num_workers=0)
else:
datasets.BASE_DATA_FOLDER = os.path.join(
os.path.dirname(os.path.abspath(__file__)), '../')
try:
os.mkdir(datasets.BASE_DATA_FOLDER)
except:
pass
cifar10 = datasets.CIFAR10()
test_loader = cifar10.getTestLoader(batch_size=batch_size,
num_workers=0)
return test_loader
def load_data(name,logit=False,dequantize=False,flip = False):
"""
Loads the dataset. Has to be called before anything else.
:param name: string, the dataset's name
"""
assert isinstance(name, str), 'Name must be a string'
# global data
if name == 'mnist':
data = datasets.MNIST(logit=logit, dequantize=dequantize)
elif name == 'bsds300':
data = datasets.BSDS300()
elif name == 'cifar10':
data = datasets.CIFAR10(logit=logit, flip=flip, dequantize=dequantize)
elif name == 'power':
data = datasets.POWER()
elif name == 'gas':
data = datasets.GAS()
elif name == 'hepmass':
data = datasets.HEPMASS()
elif name == 'miniboone':
data = datasets.MINIBOONE()
else:
raise Exception('Unknown dataset')
# get data splits
X_train = data.trn.x
X_val = data.val.x
X_test = data.tst.x
# Convert to float32
X_train = X_train.astype(np.float32)
X_val = X_val.astype(np.float32)
X_test = X_test.astype(np.float32)
return data, X_train, X_val, X_test
# Path of Dataset
if arguments.dataset == 'MNIST':
globals.data_train_images, globals.data_test_images = datasets.MNIST()
elif arguments.dataset == 'JAFFE':
globals.data_train_images, globals.data_test_images = datasets.JAFFE()
elif arguments.dataset == 'Extended-CK+':
globals.data_train_images, globals.data_test_images = datasets.extendedCK()
elif arguments.dataset == 'FEI':
globals.data_train_images, globals.data_test_images = datasets.FEI()
elif arguments.dataset == 'CIFAR-10':
globals.data_train_images, globals.data_test_images = datasets.CIFAR10()
elif arguments.dataset == 'FER-2013':
globals.data_train_images, globals.data_test_images = datasets.FER2013()
# Print training-set path
datasets.printTrainingPath()
# Print test-set path
datasets.printTestPath()
# Print number of classes
datasets.printNumberOfClasses()
# K-Means classes
globals.K = globals.num_classes * 5
def load_datasets(name, root, batch_size):
if name == "mnist":
train_dataset = datasets.MNIST(root=root,
download=True,
train=True,
transform=transforms.Compose([
transforms.Resize(28),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.5], [0.5]),
]))
train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size,
shuffle=True, num_workers=8)
test_dataset = datasets.MNIST(root=root,
download=True,
train=False,
transform=transforms.Compose([
transforms.Resize(28),
transforms.ToTensor(),
transforms.Normalize([0.5], [0.5]),
]))
test_dataloader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size,
shuffle=False, num_workers=8)
return train_dataloader, test_dataloader
elif name == "fmnist":
train_dataset = datasets.FashionMNIST(root=root,
download=True,
train=True,
transform=transforms.Compose([
transforms.Resize(28),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.5], [0.5]),
]))
train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size,
shuffle=True, num_workers=8)
test_dataset = datasets.FashionMNIST(root=root,
download=True,
train=False,
transform=transforms.Compose([
transforms.Resize(28),
transforms.ToTensor(),
transforms.Normalize([0.5], [0.5]),
]))
test_dataloader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size,
shuffle=False, num_workers=8)
return train_dataloader, test_dataloader
elif name == "kmnist":
train_dataset = datasets.KMNIST(root=root,
download=True,
train=True,
transform=transforms.Compose([
transforms.Resize(28),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.5], [0.5]),
]))
train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size,
shuffle=True, num_workers=8)
test_dataset = datasets.KMNIST(root=root,
download=True,
train=False,
transform=transforms.Compose([
transforms.Resize(28),
transforms.ToTensor(),
transforms.Normalize([0.5], [0.5]),
]))
test_dataloader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size,
shuffle=False, num_workers=8)
return train_dataloader, test_dataloader
elif name == "qmnist":
train_dataset = datasets.QMNIST(root=root,
download=True,
train=True,
transform=transforms.Compose([
transforms.Resize(28),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize([0.5], [0.5]),
]))
train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size,
shuffle=True, num_workers=8)
test_dataset = datasets.QMNIST(root=root,
download=True,
what="test50k",
train=False,
transform=transforms.Compose([
transforms.Resize(28),
transforms.ToTensor(),
transforms.Normalize([0.5], [0.5]),
]))
test_dataloader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size,
shuffle=False, num_workers=8)
return train_dataloader, test_dataloader
elif name == "cifar10":
train_dataset = datasets.CIFAR10(root=root,
download=True,
train=True,
transform=transforms.Compose([
transforms.Resize(32),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
]))
train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size,
shuffle=True, num_workers=8)
test_dataset = datasets.CIFAR10(root=root,
download=True,
train=False,
transform=transforms.Compose([
transforms.Resize(32),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
]))
test_dataloader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size,
shuffle=False, num_workers=8)
return train_dataloader, test_dataloader
elif name == "cifar100":
train_dataset = datasets.CIFAR100(root=root,
download=True,
train=True,
transform=transforms.Compose([
transforms.Resize(32),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
]))
train_dataloader = torch.utils.data.DataLoader(train_dataset, batch_size=batch_size,
shuffle=True, num_workers=8)
test_dataset = datasets.CIFAR100(root=root,
download=True,
train=False,
transform=transforms.Compose([
transforms.Resize(32),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
]))
test_dataloader = torch.utils.data.DataLoader(test_dataset, batch_size=batch_size,
shuffle=False, num_workers=8)
return train_dataloader, test_dataloader
def load_data(name,
data_trn=None,
data_val=None,
labels_trn=None,
labels_val=None):
"""
Loads the dataset. Has to be called before anything else.
:param name: string, the dataset's name
"""
assert isinstance(name, str), 'Name must be a string'
datasets.root = root_data
global data, data_name
if data_name == name:
return
if name == 'custom':
# from maf.datasets import mnist
from datasets import custom
data = custom.CUSTOM(data_trn,
data_val,
labels_trn,
labels_val,
logit=True,
dequantize=False)
data_name = name
elif name == 'mnist':
# from maf.datasets import mnist
from datasets import mnist
data = mnist.MNIST(logit=True, dequantize=True)
data_name = name
elif name == 'bsds300':
data = datasets.BSDS300()
data_name = name
elif name == 'cifar10':
data = datasets.CIFAR10(logit=True, flip=True, dequantize=True)
data_name = name
elif name == 'power':
data = datasets.POWER()
data_name = name
elif name == 'gas':
data = datasets.GAS()
data_name = name
elif name == 'hepmass':
data = datasets.HEPMASS()
data_name = name
elif name == 'miniboone':
from datasets import miniboone
data = miniboone.MINIBOONE()
data_name = name
else:
raise ValueError('Unknown dataset')
os.mkdir(cifar10modelsFolder)
except:pass
epochsToTrainCIFAR = 1
USE_BATCH_NORM = True
AFFINE_BATCH_NORM = True
TRAIN_TEACHER_MODEL = True
TRAIN_SMALLER_MODEL = False
TRAIN_SMALLER_QUANTIZED_MODEL = False
TRAIN_DISTILLED_MODEL = False
TRAIN_DIFFERENTIABLE_QUANTIZATION = False
CHECK_PM_QUANTIZATION = True
batch_size = 25
cifar10 = datasets.CIFAR10()
train_loader, test_loader = cifar10.getTrainLoader(batch_size), cifar10.getTestLoader(batch_size)
# Teacher model
model_name = 'cifar10_teacher'
teacherModelPath = os.path.join(cifar10modelsFolder, model_name)
teacherModel = convForwModel.ConvolForwardNet(**convForwModel.teacherModelSpec,
useBatchNorm=USE_BATCH_NORM,
useAffineTransformInBatchNorm=AFFINE_BATCH_NORM)
if USE_CUDA: teacherModel = teacherModel.cuda()
if not model_name in cifar10Manager.saved_models:
cifar10Manager.add_new_model(model_name, teacherModelPath,
arguments_creator_function={**convForwModel.teacherModelSpec,
'useBatchNorm':USE_BATCH_NORM,
'useAffineTransformInBatchNorm':AFFINE_BATCH_NORM})
if TRAIN_TEACHER_MODEL:
import itertools
# Disable interactive backend to train on a remote machine
import matplotlib
matplotlib.use('Agg')
import numpy as np
import pandas as pd
from tqdm import tqdm
import datasets
from utils import create_and_train
# Dataset definition
cifar = datasets.CIFAR10()
training = cifar.get_named_batches('data_batch_1')
validation = cifar.get_named_batches('data_batch_5')
def simple_create_and_train(regularization, learning_rate, iterations,
plot_name):
return create_and_train(training, validation, iterations, 50,
regularization, learning_rate, 0.99, 0.8,
plot_name)
def coarse_search():
# Parameter search space
regularization = [0.001, 0.005, 0.01, 0.05, 0.1, 0.3, 0.5]
initial_learning_rate = [0.5, 0.3, 0.1, 0.05, 0.01, 0.005, 0.001]
batch_size = 4
if (__name__ == '__main__'):
parser = argparse.ArgumentParser(description='Taming VAEs experiments')
parser.add_argument('--data',
dest='dataset',
default=None,
help='Dataset to be used')
args = parser.parse_args()
if (args.dataset.lower() == 'mnist'):
data_set = datasets.MNIST('./data/mnist/',
download=True,
transform=torchvision.transforms.ToTensor())
elif (args.dataset.lower() == 'cifar10'):
data_set = datasets.CIFAR10(
'./data/cifar10/',
download=True,
transform=torchvision.transforms.ToTensor())
elif (args.dataset.lower() == 'celeba'):
data_set = datasets.CELEBA('./data/celeba/',
transform=torchvision.transforms.ToTensor())
loader = torch.utils.data.DataLoader(data_set,
batch_size=batch_size,
shuffle=True,
drop_last=True)
for batch in loader:
print(batch.size())
break
def fetch_dataset(data_name):
print('fetching data {}...'.format(data_name))
if (data_name == 'MNIST'):
train_dir = './data/{}/train'.format(data_name)
test_dir = './data/{}/test'.format(data_name)
train_dataset = datasets.MNIST(root=train_dir,
train=True,
download=True,
transform=transforms.ToTensor())
if (normalize):
stats = make_stats(train_dataset, batch_size=128)
train_transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize(stats)])
test_transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize(stats)])
else:
train_transform = transforms.Compose([transforms.ToTensor()])
test_transform = transforms.Compose([transforms.ToTensor()])
train_dataset.transform = train_transform
test_dataset = datasets.MNIST(root=test_dir,
train=False,
download=True,
transform=test_transform)
elif (data_name == 'EMNIST' or data_name == 'EMNIST_byclass'
or data_name == 'EMNIST_bymerge' or data_name == 'EMNIST_balanced'
or data_name == 'EMNIST_letters' or data_name == 'EMNIST_digits'
or data_name == 'EMNIST_mnist'):
train_dir = './data/{}/train'.format(data_name.split('_')[0])
test_dir = './data/{}/test'.format(data_name.split('_')[0])
transform = transforms.Compose([transforms.ToTensor()])
split = 'balanced' if len(
data_name.split('_')) == 1 else data_name.split('_')[1]
train_dataset = datasets.EMNIST(root=train_dir,
split=split,
branch=branch,
train=True,
download=True,
transform=transform)
test_dataset = datasets.EMNIST(root=test_dir,
split=split,
branch=branch,
train=False,
download=True,
transform=transform)
elif (data_name == 'FashionMNIST'):
train_dir = './data/{}/train'.format(data_name)
test_dir = './data/{}/test'.format(data_name)
transform = transforms.Compose([transforms.ToTensor()])
train_dataset = datasets.FashionMNIST(root=train_dir,
train=True,
download=True,
transform=transform)
test_dataset = datasets.FashionMNIST(root=test_dir,
train=False,
download=True,
transform=transform)
elif (data_name == 'CIFAR10'):
train_dir = './data/{}/train'.format(data_name)
test_dir = './data/{}/validation'.format(data_name)
train_dataset = datasets.CIFAR10(train_dir,
train=True,
transform=transforms.ToTensor(),
download=True)
if (normalize):
stats = make_stats(train_dataset, batch_size=128)
train_transform = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(stats)
])
test_transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize(stats)])
else:
train_transform = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor()
])
test_transform = transforms.Compose([transforms.ToTensor()])
train_dataset.transform = train_transform
test_dataset = datasets.CIFAR10(test_dir,
train=False,
transform=test_transform,
download=True)
elif (data_name == 'CIFAR100'):
train_dir = './data/{}/train'.format(data_name)
test_dir = './data/{}/validation'.format(data_name)
train_dataset = datasets.CIFAR100(train_dir,
branch=branch,
train=True,
transform=transforms.ToTensor(),
download=True)
if (normalize):
stats = make_stats(train_dataset, batch_size=128)
train_transform = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize(stats)
])
test_transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize(stats)])
else:
train_transform = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor()
])
test_transform = transforms.Compose([transforms.ToTensor()])
train_dataset.transform = train_transform
test_dataset = datasets.CIFAR100(test_dir,
branch=branch,
train=False,
transform=test_transform,
download=True)
elif (data_name == 'SVHN'):
train_dir = './data/{}/train'.format(data_name)
test_dir = './data/{}/validation'.format(data_name)
train_dataset = datasets.SVHN(train_dir,
split='train',
transform=transforms.ToTensor(),
download=True)
if (normalize):
stats = make_stats(train_dataset, batch_size=128)
train_transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize(stats)])
test_transform = transforms.Compose(
[transforms.ToTensor(),
transforms.Normalize(stats)])
else:
train_transform = transforms.Compose([transforms.ToTensor()])
test_transform = transforms.Compose([transforms.ToTensor()])
train_dataset.transform = train_transform
test_dataset = datasets.SVHN(test_dir,
split='test',
transform=test_transform,
download=True)
elif (data_name == 'ImageNet'):
train_dir = './data/{}/train'.format(data_name)
test_dir = './data/{}/validation'.format(data_name)
train_dataset = datasets.ImageFolder(train_dir,
transform=transforms.ToTensor())
if (normalize):
stats = make_stats(train_dataset, batch_size=128)
train_transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize(stats)
])
test_transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize(stats)
])
else:
train_transform = transforms.Compose(
[transforms.Resize((224, 224)),
transforms.ToTensor()])
test_transform = transforms.Compose(
[transforms.Resize((224, 224)),
transforms.ToTensor()])
train_dataset.transform = train_transform
test_dataset = datasets.ImageFolder(test_dir, transform=test_transform)
elif (data_name == 'CUB2011'):
train_dir = './data/{}/train'.format(data_name.split('_')[0])
test_dir = './data/{}/validation'.format(data_name.split('_')[0])
train_dataset = datasets.CUB2011(train_dir,
transform=transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor()
]),
download=True)
if (normalize):
stats = make_stats(train_dataset, batch_size=128)
train_transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize(stats)
])
test_transform = transforms.Compose([
transforms.Resize((224, 224)),
transforms.ToTensor(),
transforms.Normalize(stats)
])
else:
train_transform = transforms.Compose(
[transforms.Resize((224, 224)),
transforms.ToTensor()])
test_transform = transforms.Compose(
[transforms.Resize((224, 224)),
transforms.ToTensor()])
train_dataset.transform = train_transform
test_dataset = datasets.CUB2011(test_dir,
transform=test_transform,
download=True)
elif (data_name == 'WheatImage' or data_name == 'WheatImage_binary'
or data_name == 'WheatImage_six'):
train_dir = './data/{}/train'.format(data_name.split('_')[0])
test_dir = './data/{}/validation'.format(data_name.split('_')[0])
label_mode = 'six' if len(
data_name.split('_')) == 1 else data_name.split('_')[1]
train_dataset = datasets.WheatImage(train_dir,
label_mode=label_mode,
transform=transforms.Compose([
transforms.Resize((224, 288)),
transforms.ToTensor()
]))
if (normalize):
stats = make_stats(train_dataset, batch_size=128)
train_transform = transforms.Compose([
transforms.Resize((224, 288)),
transforms.RandomHorizontalFlip(),
transforms.RandomVerticalFlip(),
transforms.ToTensor(),
transforms.Normalize(stats)
])
test_transform = transforms.Compose([
transforms.Resize((224, 288)),
transforms.ToTensor(),
transforms.Normalize(stats)
])
else:
train_transform = transforms.Compose([
transforms.Resize((224, 288)),
transforms.RandomHorizontalFlip(),
transforms.RandomVerticalFlip(),
transforms.ToTensor()
])
test_transform = transforms.Compose(
[transforms.Resize((224, 288)),
transforms.ToTensor()])
train_dataset.transform = train_transform
test_dataset = datasets.WheatImage(test_dir,
label_mode=label_mode,
transform=test_transform)
elif (data_name == 'CocoDetection'):
train_dir = './data/Coco/train2017'
train_ann = './data/Coco/annotations/instances_train2017.json'
test_dir = './data/Coco/val2017'
test_ann = './data/Coco/annotations/instances_val2017.json'
transform = transforms.Compose(
[transforms.Resize((224, 224)),
transforms.ToTensor()])
train_dataset = datasets.CocoDetection(train_dir,
train_ann,
transform=transform)
test_dataset = datasets.CocoDetection(test_dir,
test_ann,
transform=transform)
elif (data_name == 'CocoCaptions'):
train_dir = './data/Coco/train2017'
train_ann = './data/Coco/annotations/captions_train2017.json'
test_dir = './data/Coco/val2017'
test_ann = './data/Coco/annotations/captions_val2017.json'
transform = transforms.Compose(
[transforms.Resize((224, 224)),
transforms.ToTensor()])
train_dataset = datasets.CocoCaptions(train_dir,
train_ann,
transform=transform)
test_dataset = datasets.CocoCaptions(test_dir,
test_ann,
transform=transform)
elif (data_name == 'VOCDetection'):
train_dir = './data/VOC/VOCdevkit'
test_dir = './data/VOC/VOCdevkit'
transform = transforms.Compose(
[transforms.Resize((224, 224)),
transforms.ToTensor()])
train_dataset = datasets.VOCDetection(train_dir,
'trainval',
transform=transform)
test_dataset = datasets.VOCDetection(test_dir,
'test',
transform=transform)
elif (data_name == 'VOCSegmentation'):
train_dir = './data/VOC/VOCdevkit'
test_dir = './data/VOC/VOCdevkit'
transform = transforms.Compose(
[transforms.Resize((224, 224)),
transforms.ToTensor()])
train_dataset = datasets.VOCSegmentation(train_dir,
'trainval',
transform=transform)
test_dataset = datasets.VOCSegmentation(test_dir,
'test',
transform=transform)
elif (data_name == 'MOSI' or data_name == 'MOSI_binary'
or data_name == 'MOSI_five' or data_name == 'MOSI_seven'
or data_name == 'MOSI_regression'):
train_dir = './data/{}'.format(data_name.split('_')[0])
test_dir = './data/{}'.format(data_name.split('_')[0])
label_mode = 'five' if len(
data_name.split('_')) == 1 else data_name.split('_')[1]
train_dataset = datasets.MOSI(train_dir,
split='trainval',
label_mode=label_mode,
download=True)
stats = make_stats(train_dataset, batch_size=1)
train_transform = transforms.Compose([transforms.Normalize(stats)])
test_transform = transforms.Compose([transforms.Normalize(stats)])
train_dataset.transform = train_transform
test_dataset = datasets.MOSI(test_dir,
split='test',
label_mode=label_mode,
download=True,
transform=test_transform)
elif (data_name == 'Kodak'):
train_dataset = None
transform = transforms.Compose([transforms.ToTensor()])
test_dir = './data/{}'.format(data_name)
train_dataset = datasets.ImageFolder(test_dir, transform)
test_dataset = datasets.ImageFolder(test_dir, transform)
elif (data_name == 'UCID'):
train_dataset = None
transform = transforms.Compose([transforms.ToTensor()])
test_dir = './data/{}'.format(data_name)
train_dataset = datasets.ImageFolder(test_dir, transform)
test_dataset = datasets.ImageFolder(test_dir, transform)
else:
raise ValueError('Not valid dataset name')
print('data ready')
return train_dataset, test_dataset
tucker_reconstruction = tl.tucker_to_tensor((core,tucker_factors))
Tucker_reconstructions[j] = tucker_reconstruction
Cores[j] = core
return Cores
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
classifier = torch.load('./saved/resnet50_cifar10.pth')
num_classes = 10
model = coreModel()
tl.set_backend('pytorch')
batch_size = 64
train_set,test_set = datasets.CIFAR10(root = '/home/taejoon/data/CIFAR10',normalize = False)
train_loader = torch.utils.data.DataLoader(train_set,batch_size = batch_size,shuffle = True)
test_loader = torch.utils.data.DataLoader(test_set, batch_size=batch_size, shuffle=False)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr = 1e-4)
model.eval()
model = model.to(device)
running_loss = 0.0
attack= torchattacks.PGD(classifier, eps= float(8/255.0))
train_loss_epoch = []
train_acc_epoch = []
epoches = 50
for epoch in range(1,epoches):
total_loss = 0
#%% Read Data
print('Using the MNIST dataset.')
data_train, data_test = datasets.MNIST(True)
num_index = [1, 3, 5, 7, 2, 0, 13, 15, 17, 4] # save 0,1,2,3,4,5,6,7,8,9
axis = 2
data = data_train.data[:1000]
data = np.array(data)[:, np.newaxis, ...]
# networks
data_loader_train = torch.utils.data.DataLoader(dataset=data_train, batch_size=Args.batch_size, shuffle=True)
data_loader_test = torch.utils.data.DataLoader(dataset=data_test, batch_size=Args.batch_size, shuffle=True)
cnn0 = models.CNN_MNIST1().cuda() if Args.cuda else models.CNN_MNIST1()
cnn1 = models.CNN_MNIST1().cuda() if Args.cuda else models.CNN_MNIST1()
cnn2 = models.CNN_MNIST1().cuda() if Args.cuda else models.CNN_MNIST1()
elif datasets_name == 'CIFAR-10':
print('Using the CIFAR-10 dataset.')
data_train, data_test = datasets.CIFAR10(True)
num_index = [0, 1, 2, 3, 4] # save 0,1,2,3,4,5,6,7,8,9
axis = 2
data = data_train.data[:1000]
data = np.array(data).transpose(0, 3, 1, 2)
# networks
data_loader_train = torch.utils.data.DataLoader(dataset=data_train, batch_size=Args.batch_size, shuffle=True)
data_loader_test = torch.utils.data.DataLoader(dataset=data_test, batch_size=Args.batch_size, shuffle=True)
cnn0 = models.CNN_CIFAR10().cuda() if Args.cuda else models.CNN_CIFAR10()
cnn1 = models.CNN_CIFAR10().cuda() if Args.cuda else models.CNN_CIFAR10()
cnn2 = models.CNN_CIFAR10().cuda() if Args.cuda else models.CNN_CIFAR10()
#%% Shuffle and Recover
data_shuffled, index0 = processing.shuffle(data, axis=axis)
index0 = np.array(index0) # change to ndarray
best_index = [float('inf'), []]
# direct greed
import torchvision form torchvision import models,transforms,datasets import torch DATA_PATH='./data' BATCH=128 transform_train = transforms.Compose([ transforms.RandomCrop(32, padding=4), transforms.RandomHorizontalFlip(), transforms.ToTensor(), transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),]) transform_test=transforms.Compose([ transforms.ToTensor(), transforms.Normalize((0.4914,0.4822,0.4465),(0.2023,0.1994,0.2010)),]) train_dataset = datasets.CIFAR10(DATA_PATH, train=True, transform=transform_train, download=True) val_dataset = datasets.CIFAR10(DATA_PATH, train=False, transform=transform_val, download=True) train_loader = torch.utils.data.DataLoader(train_dataset, BATCH_SIZE, True,num_workers=4) val_loader = torch.utils.data.DataLoader(val_dataset, BATCH_SIZE, False,num_workes=4)
def main(args):
if args.autoencoder == 'True':
autoencoder = torch.load('./saved/DAE_cifar10.pth')
else:
autoencoder = None
classifier = torch.load('./saved/resnet50_cifar10.pth')
global device
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# device = torch.device("cpu")
model = DecompNet(classifier,
Autoencoder=autoencoder,
decomposition=args.decomposition)
train_set, test_set = datasets.CIFAR10(root='/home/taejoon/data/CIFAR10',
normalize=False)
num_classes = 10
batch_size = 64
test_loader = torch.utils.data.DataLoader(test_set, batch_size=batch_size)
criterion = nn.CrossEntropyLoss()
global rank
rank = int(args.rank)
tucker_rank = [3, rank, rank]
total_loss = 0
clean_acc = 0
adv_acc = 0
adv_clf_acc = 0
cp_acc = 0
tucker_acc = 0
tl.set_backend('pytorch')
if args.attack == "BPDA":
attack = torchattacks.PGD(model, eps=float(Fraction(args.eps)))
elif args.attack == "EoT":
attack = torchattacks.APGD(model, eps=float(Fraction(args.eps)))
model.eval()
# attack_classifier = torchattacks.PGD(classifier,eps = float(Fraction(args.eps)))
for i, (images, labels) in enumerate(test_loader):
images, labels = images.to(device), labels.to(device)
preds = model(images)
_, prediction = preds.max(dim=1, keepdim=False)
clean_acc += (prediction == labels).sum()
adversarial_images = attack(images, labels)
preds = model(adversarial_images)
_, prediction = preds.max(dim=1, keepdim=False)
adv_acc += (prediction == labels).sum()
# advs = attack_classifier(images,labels)
# preds = model(advs)
# _,prediction = preds.max(dim = 1,keepdim = False)
# adv_clf_acc += (prediction == labels).sum()
#
# advs = advs.detach().cpu()
# Tucker_reconstructions = torch.zeros_like(advs)
# for j,adv in enumerate(advs):
# core,tucker_factors = tucker(adv,ranks = tucker_rank,init = 'random', tol = 1e-4, random_state=np.random.RandomState())
# tucker_reconstruction = tl.tucker_to_tensor((core,tucker_factors))
# Tucker_reconstructions[j] = tucker_reconstruction
# # Tucker_reconstructions = torch.from_numpy(Tucker_reconstructions).to(device,dtype = torch.float)
# Tucker_reconstructions = Tucker_reconstructions.to(device)
# preds2 = classifier(Tucker_reconstructions)
# _,prediction = preds2.max(dim = 1,keepdim = False)
# tucker_acc += (prediction == labels).sum()
# pdb.set_trace()
if (i % 5 == 0):
print("method %s # data %f, clean_acc %f, adv_acc %f" %
(args.decomposition,
(i + 1) * batch_size, clean_acc, adv_acc))
clean_acc = float(clean_acc) / len(test_set)
adv_acc = float(adv_acc) / len(test_set)
print("method %s # data %f, clean_acc %f, adv_acc %f" %
(args.decomposition, (i + 1) * batch_size, clean_acc, adv_acc))
print("rank %s autoencoder %s" % (args.rank, args.autoencoder))
f = open("./result/whitebox_1.txt", 'a')
data = "Attack Method : " + args.attack + "\n"
data += "Decomposition method : " + args.decomposition + "\n"
data += "Autoencoder : " + args.autoencoder + "\n"
data += "epsilon : " + args.eps + "\n"
data += "rank : " + str(rank) + "\n"
data += "clean : " + str(clean_acc) + " adv_acc : " + str(adv_acc) + "\n"
data += "=" * 50
f.write(data + '\n')
def __init__(self, args):
self.args = args
self.loader_train = args.loader_train
self.loader_test = args.loader_test
if args.split_test is not None:
self.split_test = args.split_test
if args.split_train is not None:
self.split_train = args.split_train
else:
self.split_train = 1.0
self.split_test = 0.0
self.dataset_train = args.dataset_train
if args.dataset_test is not None:
self.dataset_test = args.dataset_test
else:
self.dataset_test = self.dataset_train
self.resolution = (args.resolution_wide, args.resolution_high)
self.filename_test = args.filename_test
self.filename_train = args.filename_train
# TODO: Put sane catch methods in place.
if args.batch_size is not None:
self.batch_size = args.batch_size
else:
raise (Exception("Batch size not set"))
if args.nthreads is not None:
self.nthreads = args.nthreads
else:
raise (Exception("Number of threads not set"))
if self.dataset_train == 'lsun':
self.dataset_train = datasets.LSUN(
db_path=args.dataroot,
classes=['bedroom_train'],
transform=transforms.Compose([
transforms.Scale(self.resolution),
transforms.CenterCrop(self.resolution),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
]))
elif self.dataset_train == 'cifar10':
self.dataset_train = datasets.CIFAR10(
root=self.args.dataroot,
train=True,
download=True,
transform=transforms.Compose([
transforms.Scale(self.resolution),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
]))
elif self.dataset_train == 'filelist':
self.dataset_train = datasets.FileList(
self.filename_train,
None,
split_train=self.split_train,
split_test=self.split_test,
train=True,
transform_train=transforms.Compose([transforms.ToTensor()]),
transform_test=transforms.Compose([
#transforms.Scale(self.resolution),
#transforms.CenterCrop(self.resolution),
# transforms.ToTensor(),
# transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
]),
loader_train=self.loader_train,
loader_test=self.loader_test,
)
elif self.dataset_train == 'data':
self.dataset_train = datasets.data(
self.filename_train,
None,
split_train=self.split_train,
split_test=self.split_test,
train=True,
transform_train=transforms.Compose([transforms.ToTensor()]),
transform_test=transforms.Compose([
#transforms.Scale(self.resolution),
#transforms.CenterCrop(self.resolution),
# transforms.ToTensor(),
# transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
]),
loader_train=self.loader_train,
loader_test=self.loader_test,
)
#c110 = data['c110']
#c120 = data['c120']
#c440 = data['c440']
#c111 = data['c111']
#c121 = data['c121']
#c441 = data['c441']
#composition = data['composition']
#metadata = [c110, c120, c440, c111, c121, c441]
#z = np.append(z[:], metadata)
#z = torch.from_numpy(z)
elif self.dataset_train == 'metalist':
self.dataset_train = datasets.MetaList(
self.filename_train,
None,
split_train=self.split_train,
split_test=self.split_test,
train=True,
transform_train=transforms.Compose([transforms.ToTensor()]),
transform_test=transforms.Compose([]),
loader_train=self.loader_train,
loader_test=self.loader_test,
)
elif self.dataset_train == 'metadata':
self.dataset_train = datasets.MetaList(
self.filename_train,
None,
split_train=self.split_train,
split_test=self.split_test,
train=True,
transform_train=transforms.Compose([transforms.ToTensor()]),
transform_test=transforms.Compose([]),
loader_train=self.loader_train,
loader_test=self.loader_test,
)
elif self.dataset_train == 'composition':
self.dataset_train = datasets.data(
self.filename_train,
None,
split_train=self.split_train,
split_test=self.split_test,
train=True,
transform_train=transform.Compose([transforms.ToTensor()]),
transform_test=transforms.Compose([]),
loader_train=self.loader_train,
loader_test=self.loader_test,
)
#c110 = data['c110']
#c120 = data['c120']
#c440 = data['c440']
#c111 = data['c111']
#c121 = data['c121']
#c441 = data['c441']
#composition = data['composition']
#metadata = [c110, c120, c440, c111, c121, c441]
#z = np.append(z[:], metadata)
#z = torch.from_numpy(z)
elif self.dataset_train == 'folderlist':
self.dataset_train = datasets.FileList(
self.filename_train,
None,
self.split_train,
self.split_test,
train=True,
transform_train=transforms.Compose([
transforms.Scale(self.resolution),
transforms.CenterCrop(self.resolution),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
]),
transform_test=transforms.Compose([
transforms.Scale(self.resolution),
transforms.CenterCrop(self.resolution),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
]),
loader_train=self.loader_train,
loader_test=self.loader_test,
)
else:
raise (Exception("Unknown Dataset"))
if self.dataset_test == 'lsun':
self.dataset_val = datasets.LSUN(
db_path=args.dataroot,
classes=['bedroom_val'],
transform=transforms.Compose([
transforms.Scale(self.resolution),
transforms.CenterCrop(self.resolution),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
]))
elif self.dataset_test == 'cifar10':
self.dataset_val = datasets.CIFAR10(
root=self.args.dataroot,
train=False,
download=True,
transform=transforms.Compose([
transforms.Scale(self.resolution),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
]))
elif self.dataset_test == 'filelist':
self.dataset_val = datasets.FileList(
self.filename_test,
None,
self.split_train,
self.split_test,
train=True,
transform_train=transforms.Compose([
#transforms.Scale(self.resolution),
#transforms.CenterCrop(self.resolution),
transforms.ToTensor(),
#transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
]),
loader_train=self.loader_train,
loader_test=self.loader_test,
)
elif self.dataset_test == 'testdata':
self.dataset_val = datasets.testdata(
self.filename_test,
None,
self.split_train,
self.split_test,
train=True,
transform_train=transforms.Compose([
#transforms.Scale(self.resolution),
#transforms.CenterCrop(self.resolution),
transforms.ToTensor(),
#transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
]),
loader_train=self.loader_train,
loader_test=self.loader_test,
)
elif self.dataset_test == 'metalist':
self.dataset_val = datasets.MetaList(
self.filename_test,
None,
self.split_train,
self.split_test,
train=True,
transform_train=transforms.Compose([
#transforms.Scale(self.resolution),
#transforms.CenterCrop(self.resolution),
transforms.ToTensor(),
#transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
]),
loader_train=self.loader_train,
loader_test=self.loader_test,
)
elif self.dataset_test == 'folderlist':
self.dataset_test = datasets.FileList(
self.filename_test,
None,
self.split_train,
self.split_test,
train=True,
transform_train=transforms.Compose([
# transforms.Scale(self.resolution),
# transforms.CenterCrop(self.resolution),
transforms.ToTensor(),
# transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
]),
loader_train=self.loader_train,
loader_test=self.loader_test,
)
else:
raise (Exception("Unknown Dataset"))
def main(args):
classifier = torch.load('./saved/resnet50_cifar10.pth')
model = blackbox(classifier)
train_set, test_set = datasets.CIFAR10(root='/home/taejoon/data/CIFAR10',
normalize=False)
num_classes = 10
batch_size = 64
test_loader = torch.utils.data.DataLoader(test_set, batch_size=batch_size)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
# device = torch.device("cpu")
if args.attack == 'FGSM':
attack = torchattacks.FGSM(model, eps=float(Fraction(args.eps)))
elif args.attack == 'PGD':
attack = torchattacks.PGD(model, eps=float(Fraction(args.eps)))
elif args.attack == 'DeepFool':
attack = torchattacks.DeepFool(model)
elif args.attack == 'CW':
attack = torchattacks.CW(model, kappa=50)
elif args.attack == 'EOT':
attack = torchattacks.APGD(model, eps=float(Fraction(args.eps)))
# print (dict(torchattacks))
model = model.to(device)
model.eval()
criterion = nn.CrossEntropyLoss()
total_loss = 0
clean_acc = 0
adv_acc = 0
cp_acc = 0
tucker_acc = 0
cp_rank = int(args.cp_rank)
tucker_rank = [3, int(args.tucker_rank), int(args.tucker_rank)]
for i, (images, labels) in enumerate(test_loader):
images = images.to(device)
labels = labels.to(device)
preds = model(images)
_, prediction = preds.max(dim=1, keepdim=False)
clean_acc += (prediction == labels).sum()
adversarial_images = attack(images, labels)
preds = model(adversarial_images)
_, prediction = preds.max(dim=1, keepdim=False)
adv_acc += (prediction == labels).sum()
adversarial_images = adversarial_images.detach().cpu().numpy()
# Cp_reconstructions = np.zeros_like(adversarial_images)
Tucker_reconstructions = np.zeros_like(adversarial_images)
for j, adv in enumerate(adversarial_images):
# factors = tl.decomposition.parafac(adv,rank = cp_rank,init = 'random',tol = 1e-4,random_state = np.random.RandomState())
# cp_reconstruction = tl.kruskal_to_tensor(factors)
# Cp_reconstructions[j] = cp_reconstruction
core, tucker_factors = tucker(adv,
ranks=tucker_rank,
init='random',
tol=1e-4,
random_state=np.random.RandomState())
tucker_reconstruction = tl.tucker_to_tensor((core, tucker_factors))
Tucker_reconstructions[j] = tucker_reconstruction
# Cp_reconstructions = torch.from_numpy(Cp_reconstructions).to(device,dtype = torch.float)
# preds = model(Cp_reconstructions)
# _,prediction = preds.max(dim = 1,keepdim = False)
# cp_acc += (prediction == labels).sum()
Tucker_reconstructions = torch.from_numpy(Tucker_reconstructions).to(
device, dtype=torch.float)
preds = model(Tucker_reconstructions)
_, prediction = preds.max(dim=1, keepdim=False)
tucker_acc += (prediction == labels).sum()
# if (i%25==0):
# print ("# data %f, clean_acc %f, adv_acc %f, cp_acc %f, tucker_acc %f" %((i+1)*batch_size,clean_acc,adv_acc,cp_acc,tucker_acc))
if (i % 5 == 0):
print("# data %f, clean_acc %f, adv_acc %f, tucker_acc %f" %
((i + 1) * batch_size, clean_acc, adv_acc, tucker_acc))
clean_acc = float(clean_acc) / len(test_set)
adv_acc = float(adv_acc) / len(test_set)
# cp_acc = float(cp_acc)/len(test_set)
tucker_acc = float(tucker_acc) / len(test_set)
print("loss", total_loss, "adv acc", adv_acc, "tucker acc", tucker_acc)
f = open("./result/20200706.txt", 'a')
data = "Attack Method : " + args.attack + "\n"
data += "epsilon : " + args.eps + "\n"
data += "cp_rank : " + str(cp_rank) + ", tucker_rank : " + str(
tucker_rank) + "\n"
# data += "clean : " + str(clean_acc) + " adv_acc : " + str(adv_acc) + " cp_acc : " + str(cp_acc) + " tucker_acc : " + str(tucker_acc) + "\n"
data += "clean : " + str(clean_acc) + " adv_acc : " + str(
adv_acc) + " cp_acc : " + "None" + " tucker_acc : " + str(
tucker_acc) + "\n"
data += "=" * 50
f.write(data + '\n')
Manager = model_manager.ModelManager(manager_path,
args.manager,
create_new_model_manager=create_new)
modelsFolder = os.path.join(SAVED_MODELS_FOLDER, args.data)
try:
os.mkdir(modelsFolder)
except:
pass
epochsToTrainCIFAR = args.epochs
USE_BATCH_NORM = True
AFFINE_BATCH_NORM = True
if args.data == 'cifar10':
data = datasets.CIFAR10()
elif args.data == 'cifar100':
data = datasets.CIFAR100()
if args.test_memory:
if not args.train_teacher:
model = convForwModel.ConvolForwardNet(
**smallerModelSpecs[args.stModel],
activation=args.stud_act,
numBins=args.num_bins,
useBatchNorm=USE_BATCH_NORM,
useAffineTransformInBatchNorm=AFFINE_BATCH_NORM)
else:
model = convForwModel.ConvolForwardNet(
**convForwModel.teacherModelSpec,
useBatchNorm=USE_BATCH_NORM,
useAffineTransformInBatchNorm=AFFINE_BATCH_NORM)
print('==> Preparing data..')
transform_train = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
transform_val = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
trainset = datasets.CIFAR10(root='./data/cifar10',
type='train+val',
transform=transform_train)
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=args.train_batch_size,
shuffle=True,
num_workers=2)
testset = datasets.CIFAR10(root='./data/cifar10',
type='test',
transform=transform_val)
testloader = torch.utils.data.DataLoader(testset,
batch_size=100,
shuffle=False,
num_workers=2)
print('==> Initializing model...')
import copy
def __mkdir(path):
if not os.path.exists(path):
os.mkdir(path)
datasets.BASE_DATA_FOLDER = 'data'
batch_size = 50
epochsToTrainCIFAR = 100
TRAIN_TEACHER_MODEL = False
TRAIN_DISTILLED_MODEL = True
TRAIN_SMALLER_MODEL = True
TRAIN_DISTILLED_QUANTIZED_MODEL = True
cifar10 = datasets.CIFAR10() #-> will be saved in /home/saved_datasets/cifar10
train_loader, test_loader = cifar10.getTrainLoader(batch_size), cifar10.getTestLoader(batch_size)
import cnn_models.conv_forward_model as convForwModel
import cnn_models.help_fun as cnn_hf
teacherModel = convForwModel.ConvolForwardNet(**convForwModel.teacherModelSpec, useBatchNorm=True, useAffineTransformInBatchNorm=True)
#convForwModel.train_model(teacherModel, train_loader, test_loader, epochs_to_train=20)
import cnn_models.conv_forward_model as convForwModel
import cnn_models.help_fun as cnn_hf
import model_manager
model_manager_path = 'model_manager_cifar10.tst'
model_save_path ='models'
__mkdir(model_save_path)
if os.path.exists(model_manager_path):
print('==> Preparing data..')
transform_train = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
transform_val = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
trainset = datasets.CIFAR10(root='./data/cifar10',
type='train',
transform=transform_train)
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=args.train_batch_size,
shuffle=True,
num_workers=2)
valset = datasets.CIFAR10(root='./data/cifar10',
type='val',
transform=transform_val)
valloader = torch.utils.data.DataLoader(valset,
batch_size=100,
shuffle=False,
num_workers=2)
print('==> Initializing model...')
print('==> Preparing data..')
transform_train = transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
transform_val = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
])
trainset = datasets.CIFAR10(root='/home/victorfang/dataset/cifar10',
type='train',
transform=transform_train)
trainset = torchvision.datasets.CIFAR100(
root='/home/victorfang/dataset/cifar100',
train=True,
transform=transform_train)
trainloader = torch.utils.data.DataLoader(trainset,
batch_size=args.train_batch_size,
shuffle=True,
num_workers=2)
valset = datasets.CIFAR10(root='/home/victorfang/dataset/cifar10',
type='val',
transform=transform_val)
valset = torchvision.datasets.CIFAR100(
root='/home/victorfang/dataset/cifar100',
