def get_style_loss(self, preds, targets): '''takes a list of pred and target feat maps and calculate the mse loss of the mean and std ''' assert (len(preds) == len(targets)) style_loss = 0. for p_feat, t_feat in zip(preds, targets): assert (p_feat.size() == t_feat.size()) assert (t_feat.requires_grad == False) p_mean, p_std = get_mean_std(p_feat) t_mean, t_std = get_mean_std(t_feat) style_loss += self.mse_loss(p_mean, t_mean) + self.mse_loss( p_std, t_std) return style_loss
def get_opt(): opt = parse_opts() if opt.root_path is not None: opt.train_data1 = opt.root_path +'/'+ opt.train_data1 opt.train_data2 = opt.root_path + '/' + opt.train_data2 # opt.val_data = opt.root_path + '/' + opt.val_data opt.test_data = opt.root_path + '/' + opt.test_data # opt.result_path = opt.root_path + '/' + opt.result_path opt.mean, opt.std = get_mean_std(opt.value_scale) opt.arch = '{}-{}'.format(opt.model, opt.mission) opt.begin_epoch = 1 # opt.mean, opt.std = get_mean_std(opt.value_scale, dataset=opt.mean_dataset) opt.n_input_channels = 3 if opt.distributed: # opt.dist_rank = int(os.environ["OMPI_COMM_WORLD_RANK"]) # opt.dist_rank = 0 # 单个机器 if opt.dist_rank == 0: print(opt) with (opt.result_path / 'opts.json').open('w') as opt_file: json.dump(vars(opt), opt_file, default=json_serial) else: print(opt) with (opt.result_path / 'opts.json').open('w') as opt_file: json.dump(vars(opt), opt_file, default=json_serial) return opt
def create_datasets(data_path, input_size, rgb=False): """ Args: - data_path: (string) Path to the directory that contains the 'test' and 'train' data directories. - input_size: (w, h) Size of input image. The images will be resized to this size. - rgb: (boolean) Flag indicating if input images are RGB or grayscale. If False, images will be converted to grayscale. Returns: - train_dataloader: Dataloader for the training dataset. - test_dataloader: Dataloader for the testing/validation dataset. """ train_data_path = osp.join(data_path, 'train') test_data_path = osp.join(data_path, 'test') train_mean, train_std = utils.get_mean_std(train_data_path, input_size, rgb) test_mean, test_std = utils.get_mean_std(test_data_path, input_size, rgb) """ TRAIN DATA TRANSFORMS """ train_data_tforms = [] train_data_tforms.append(transforms.Resize(size=max(input_size))) train_data_tforms.append(transforms.CenterCrop(size=input_size)) if not rgb: train_data_tforms.append(transforms.Grayscale()) train_data_tforms.append(transforms.RandomHorizontalFlip(p=0.5)) train_data_tforms.append(transforms.ToTensor()) train_data_tforms.append(transforms.Normalize(train_mean, train_std)) train_data_tforms = transforms.Compose(train_data_tforms) """ TEST/VALIDATION DATA TRANSFORMS """ test_data_tforms = [] test_data_tforms.append(transforms.Resize(size=max(input_size))) test_data_tforms.append(transforms.CenterCrop(size=input_size)) if not rgb: test_data_tforms.append(transforms.Grayscale()) test_data_tforms.append(transforms.ToTensor()) test_data_tforms.append(transforms.Normalize(test_mean, test_std)) test_data_tforms = transforms.Compose(test_data_tforms) """ DATASET LOADERS """ # Creating dataset loaders using the tranformations specified above. train_dset = datasets.ImageFolder(root=osp.join(data_path, 'train'), transform=train_data_tforms) test_dset = datasets.ImageFolder(root=osp.join(data_path, 'test'), transform=test_data_tforms) return train_dset, test_dset
def train(self): self.m_std_train = { 'f1': { 0: get_mean_std(self.data[:self.train_size, 0]), 1: get_mean_std(self.data[:self.train_size, 1]), 2: get_mean_std(self.data[:self.train_size, 2]), 3: get_mean_std(self.data[:self.train_size, 3]), 4: get_mean_std(self.data[:self.train_size, 4]) }, 'f2': { 0: get_mean_std(self.data[:self.train_size, 0]), 1: get_mean_std(self.data[:self.train_size, 1]), 2: get_mean_std(self.data[:self.train_size, 2]), 3: get_mean_std(self.data[:self.train_size, 3]), 4: get_mean_std(self.data[:self.train_size, 4]) } } return self.m_std_train
def _load_mean_std(self, dataset): full_path = os.path.join(self.data_dir, self.mean_std_file) # If mean and std have not been generated yet if os.path.isfile(full_path): mean_std = np.load(full_path) self.mean = mean_std.item().get('mean') self.std = mean_std.item().get('std') else: self.mean, self.std = get_mean_std(dataset, size=(32, 32), channels=3) np.save(os.path.join(self.data_dir, self.mean_std_file), { 'mean': self.mean, 'std': self.std })
def retrieve_spatial_temporal_transforms(opt): opt.mean, opt.std = get_mean_std(opt.value_scale, dataset=opt.mean_dataset) normalize = get_normalize_method(opt.mean, opt.std, opt.no_mean_norm, opt.no_std_norm) spatial_transform = [Resize(opt.sample_size), CenterCrop(opt.sample_size), ToTensor(), ScaleValue(opt.value_scale), normalize] spatial_transform = Compose(spatial_transform) temporal_transform = [] if opt.sample_t_stride > 1: temporal_transform.append(TemporalSubsampling(opt.sample_t_stride)) temporal_transform.append( TemporalNonOverlappingWindow(opt.sample_duration)) temporal_transform = TemporalCompose(temporal_transform) return spatial_transform, temporal_transform
def create_datasets(data_path, input_size, rgb=False): """ This function creates and returns a training data loader and a testing/validation data loader. The dataloader should also perform some pre-processing steps on each of the datasets. Most of this function is implemented for you, you will only need to add a few additional lines. A data loader in pyTorch is a class inherited from the torch.utils.data.Dataset abstract class. In this project we will use the ImageFolder data loader. See http://pytorch.org/docs/master/torchvision/datasets.html#imagefolder for details. Although you don't need to for this project, you can also create your own custom data loader by inheriting from the abstract class and implementing the __len__() and __getitem__() methods as described in http://pytorch.org/tutorials/beginner/data_loading_tutorial.html As mentioned, the data loader should perform any necessary pre-processing steps on the data (images) and targets (labels). In pyTorch, this is done with 'transforms', which can be composed (chained together) as shown in http://pytorch.org/tutorials/beginner/data_loading_tutorial.html#transforms. While that example implements its own transforms, for this project the built-in transforms in torchvision.transforms should suffice. See http://pytorch.org/docs/master/torchvision/transforms.html for the list of available built-in transforms. Args: - data_path: (string) Path to the directory that contains the 'test' and 'train' data directories. - input_size: (w, h) Size of input image. The images will be resized to this size. - rgb: (boolean) Flag indicating if input images are RGB or grayscale. If False, images will be converted to grayscale. Returns: - train_dataloader: Dataloader for the training dataset. - test_dataloader: Dataloader for the testing/validation dataset. """ train_data_path = osp.join(data_path, 'train') test_data_path = osp.join(data_path, 'test') # Below variables are provided for your convenience. You may or may not need # all of them. train_mean, train_std = utils.get_mean_std(train_data_path, input_size, rgb) test_mean, test_std = utils.get_mean_std(test_data_path, input_size, rgb) """ TRAIN DATA TRANSFORMS """ train_data_tforms = [] train_data_tforms.append(transforms.Resize(size=max(input_size))) train_data_tforms.append(transforms.CenterCrop(size=input_size)) if not rgb: train_data_tforms.append(transforms.Grayscale()) ####################################################################### # TODO: YOUR CODE HERE # ####################################################################### # TODO Add a transformation to you train_data_tforms that left-right mirrors # the image randomly. Which transonformation should you add? # pass train_data_tforms.append(transforms.RandomHorizontalFlip(p=0.5)) # train_data_tforms.append(transforms.RandomAffine(degrees=(-30, 30))) # Do not move the position of the below line (leave it between the left-right # mirroring and normalization tranformations. train_data_tforms.append(transforms.ToTensor()) # TODO Add a transformation to your train_data_tforms that normalizes the # tensor by subtracting mean and dividing by std. You may use train_mean, # test_mean, train_std, or test_std values that are already calculated for # you. Which mean and std should you use to normalize the data? # pass train_data_tforms.append(transforms.Normalize(train_mean, train_std)) ####################################################################### # END OF YOUR CODE # ####################################################################### train_data_tforms = transforms.Compose(train_data_tforms) """ TEST/VALIDATION DATA TRANSFORMS """ test_data_tforms = [] test_data_tforms.append(transforms.Resize(size=max(input_size))) test_data_tforms.append(transforms.CenterCrop(size=input_size)) if not rgb: test_data_tforms.append(transforms.Grayscale()) test_data_tforms.append(transforms.ToTensor()) ####################################################################### # TODO: YOUR CODE HERE # ####################################################################### # TODO Add a transformation to your test_data_tforms that normalizes the # tensor by subtracting mean and dividing by std. You may use train_mean, # test_mean, train_std, or test_std values that are already calculated for # you. Which mean and std should you use to normalize the data? # pass test_data_tforms.append(transforms.Normalize(test_mean, test_std)) ####################################################################### # END OF YOUR CODE # ####################################################################### test_data_tforms = transforms.Compose(test_data_tforms) """ DATASET LOADERS """ # Creating dataset loaders using the tranformations specified above. train_dset = datasets.ImageFolder(root=osp.join(data_path, 'train'), transform=train_data_tforms) test_dset = datasets.ImageFolder(root=osp.join(data_path, 'test'), transform=test_data_tforms) return train_dset, test_dset
'VGG19', 'VGG19_bn', 'ResNet18', 'DenseNet3_40', 'MobileNet', 'LeNet' ]: model = Network().construct(args.model, row) else: raise Exception('Unknown model argument: {}'.format(args.model)) # state_dict = torch.load(model_weights_path, map_location=lambda storage, loc: storage) # if 'model' in state_dict.keys(): # state_dict = state_dict['model'] # model.load_state_dict(state_dict, strict=True) # model = model.to(device) # model = model.eval() mean, std = get_mean_std(args.dataset) pad = int((row.padded_im_size - row.im_size) / 2) transform = transforms.Compose([ transforms.Pad(pad), transforms.ToTensor(), transforms.Normalize(mean, std) ]) if args.dataset in ['MNIST', 'FashionMNIST', 'CIFAR10', 'CIFAR100']: full_dataset = getattr(datasets, args.dataset) subset_dataset = get_subset_dataset( full_dataset=full_dataset, examples_per_class=args.examples_per_class, epc_seed=row.epc_seed, root=osp.join(args.dataset_root, args.dataset), train=True, transform=transform,
# Load trained model state_dict = torch.load(model_path, map_location=lambda storage, loc: storage) model.load_state_dict(state_dict, strict=False) model = model.to(device) gpus = torch.cuda.device_count() if gpus > 1: print("Let's use", gpus, "GPUs!") model = nn.DataParallel(model, device_ids=range(gpus)) # In[5]: #%% Dataset # Transform mean, std = get_mean_std(dataset) pad = int((row.padded_im_size - row.im_size) / 2) transform = transforms.Compose([ transforms.Pad(pad), transforms.ToTensor(), transforms.Normalize(mean, std) ]) # Subsampled dataset full_dataset = getattr(datasets, dataset) subset_dataset = get_subset_dataset(full_dataset=full_dataset, examples_per_class=examples_per_class, epc_seed=row.epc_seed, root='data/', train=True, transform=transform,
required=True, help='choose middle domain: direct, emboss, grey, sharp, lowpass') parser.add_argument('-net', type=str, required=True, help='net type') parser.add_argument('-b', type=int, default=256, help='batch size for dataloader') parser.add_argument('-lr', type=float, default=0.1, help='initial learning rate') args = parser.parse_args() net = get_network(args) CIFAR100_TRAIN_MEAN, CIFAR100_TRAIN_STD = get_mean_std(args) wandb.config.update({ "net": args.net, "batch_size": args.b, "lr": args.lr, "path": args.domain }) #data preprocessing: cifar100_training_loader = get_training_dataloader(CIFAR100_TRAIN_MEAN, CIFAR100_TRAIN_STD, num_workers=16, batch_size=args.b, domain=args.domain, shuffle=True)
def AdaIn(self, content_feat, style_feat): assert (content_feat.size() == style_feat.size()) c_mean, c_std = get_mean_std(content_feat) s_mean, s_std = get_mean_std(style_feat) norm_content_feat = (content_feat - c_mean) / c_std * s_std + s_mean return norm_content_feat
def train(model, optimizer, scheduler, dataloaders, criterion, device, num_epochs=100, args=None, dataset_sizes={ 'train': 5e4, 'test': 1e4 }, images_dir=None, ckpt_dir=None): logger = logging.getLogger('train') loss_list = {'train': list(), 'test': list()} acc_list = {'train': list(), 'test': list()} assert images_dir is not None assert ckpt_dir is not None loss_image_path = osp.join(images_dir, 'loss.png') acc_image_path = osp.join(images_dir, 'acc.png') model.train() full_eigenspectrums = list() epoch_eigenspectrums = list() full_eigenspectrums_path = osp.join(ckpt_dir, 'training_eigenspectrum_full.npy') C = config.num_classes valid_layers = get_valid_layers(model) for epoch in range(num_epochs): logger.info('epoch: %d' % epoch) with torch.enable_grad(): for batch, truth in dataloaders['train']: batch = batch.to(device) truth = truth.to(device) optimizer.zero_grad() output = model(batch) loss = criterion(output, truth) loss.backward() optimizer.step() scheduler.step() # updates finished for epochs mean, std = get_mean_std(args.dataset) pad = int((config.padded_im_size - config.im_size) / 2) transform = transforms.Compose([ transforms.Pad(pad), transforms.ToTensor(), transforms.Normalize(mean, std) ]) if args.dataset in ['MNIST', 'FashionMNIST', 'CIFAR10', 'CIFAR100']: full_dataset = getattr(datasets, args.dataset) subset_dataset = get_subset_dataset( full_dataset=full_dataset, examples_per_class=args.examples_per_class, epc_seed=config.epc_seed, root=osp.join(args.dataset_root, args.dataset), train=True, transform=transform, download=True) elif args.dataset in ['STL10', 'SVHN']: full_dataset = getattr(datasets, args.dataset) subset_dataset = get_subset_dataset( full_dataset=full_dataset, examples_per_class=args.examples_per_class, epc_seed=config.epc_seed, root=osp.join(args.dataset_root, args.dataset), split='train', transform=transform, download=True) else: raise Exception('Unknown dataset: {}'.format(args.dataset)) loader = data.DataLoader(dataset=subset_dataset, drop_last=False, batch_size=args.batch_size) Hess = FullHessian(crit='CrossEntropyLoss', loader=loader, device=device, model=model, num_classes=C, hessian_type='Hessian', init_poly_deg=64, poly_deg=128, spectrum_margin=0.05, poly_points=1024, SSI_iters=128) Hess_eigval, \ Hess_eigval_density = Hess.LanczosLoop(denormalize=True) full_eigenspectrums.append(Hess_eigval) full_eigenspectrums.append(Hess_eigval_density) for layer_name, _ in model.named_parameters(): if layer_name not in valid_layers: continue Hess = LayerHessian(crit='CrossEntropyLoss', loader=loader, device=device, model=model, num_classes=C, layer_name=layer_name, hessian_type='Hessian', init_poly_deg=64, poly_deg=128, spectrum_margin=0.05, poly_points=1024, SSI_iters=128) Hess_eigval, \ Hess_eigval_density = Hess.LanczosLoop(denormalize=True) layerwise_eigenspectrums_path = osp.join( ckpt_dir, 'training_eigenspectrums_epoch_{}_layer_{}.npz'.format( epoch, layer_name)) np.savez(layerwise_eigenspectrums_path, eigval=Hess_eigval, eigval_density=Hess_eigval_density) for phase in ['train', 'test']: stats = evaluate_model(model, criterion, dataloaders[phase], device, dataset_sizes[phase]) loss_list[phase].append(stats['loss']) acc_list[phase].append(stats['acc']) logger.info('{}:'.format(phase)) logger.info('\tloss:{}'.format(stats['loss'])) logger.info('\tacc :{}'.format(stats['acc'])) if phase == 'test': plt.clf() plt.plot(loss_list['test'], label='test_loss') plt.plot(loss_list['train'], label='train_loss') plt.legend() plt.savefig(loss_image_path) plt.clf() plt.plot(acc_list['test'], label='test_acc') plt.plot(acc_list['train'], label='train_acc') plt.legend() plt.savefig(acc_image_path) plt.clf() full_eigenspectrums = np.array(full_eigenspectrums) assert full_eigenspectrums.shape[0] % 2 == 0 assert full_eigenspectrums.shape[0] // 2 == num_epochs np.save(full_eigenspectrums_path, full_eigenspectrums) return full_eigenspectrums