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
