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',