def get_inception_metrics(sample, num_inception_images, num_splits=10, prints=True, use_torch=True): if prints: print('Gathering activations...') pool, logits, labels = accumulate_inception_activations( sample, net, num_inception_images) if prints: print('Calculating Inception Score...') IS_mean, IS_std = calculate_inception_score(logits.numpy(), num_splits) if no_fid: FID = 9999.0 else: if prints: print('Calculating means and covariances...') if use_torch: mu, sigma = torch.mean(pool, 0), torch_cov(pool, rowvar=False) else: mu, sigma = np.mean(pool.numpy(), axis=0), np.cov(pool.numpy(), rowvar=False) if prints: print('Covariances calculated, getting FID...') if use_torch: FID = torch_calculate_frechet_distance( mu, sigma, torch.tensor(data_mu), torch.tensor(data_sigma)) FID = float(FID.numpy()) else: FID = numpy_calculate_frechet_distance(mu, sigma, data_mu, data_sigma) # Delete mu, sigma, pool, logits, and labels, just in case del mu, sigma, pool, logits, labels return IS_mean, IS_std, FID
def __init__(self, net): super(WrapInception, self).__init__() self.net = net self.mean = P(torch.tensor([0.485, 0.456, 0.406]).view(1, -1, 1, 1), requires_grad=False) self.std = P(torch.tensor([0.229, 0.224, 0.225]).view(1, -1, 1, 1), requires_grad=False)
def __init__(self): super().__init__() self.alexnet = AlexNet() self.lpips_weights = nn.ModuleList() for channels in self.alexnet.channels: self.lpips_weights.append(Conv1x1(channels, 1)) self._load_lpips_weights() # imagenet normalization for range [-1, 1] self.mu = torch.tensor([-0.03, -0.088, -0.188]).view(1, 3, 1, 1). self.sigma = torch.tensor([0.458, 0.448, 0.450]).view(1, 3, 1, 1).
def __init__(self, ch, which_conv=SNConv2d, name='attention'): super(Attention, self).__init__() # Channel multiplier self.ch = ch self.which_conv = which_conv self.theta = self.which_conv(self.ch, self.ch // 8, kernel_size=1, padding=0, bias=False) self.phi = self.which_conv(self.ch, self.ch // 8, kernel_size=1, padding=0, bias=False) self.g = self.which_conv(self.ch, self.ch // 2, kernel_size=1, padding=0, bias=False) self.o = self.which_conv(self.ch // 2, self.ch, kernel_size=1, padding=0, bias=False) # Learnable gain parameter self.gamma = P(torch.tensor(0.), requires_grad=True)
def debug_image(nets, args, inputs, step): x_src, y_src = inputs.x_src, inputs.y_src x_ref, y_ref = inputs.x_ref, inputs.y_ref x_ref.stop_gradient = True y_ref.stop_gradient = True x_src.stop_gradient = True y_src.stop_gradient = True N = inputs.x_src.size(0) # translate and reconstruct (reference-guided) filename = ospj(args.sample_dir, '%06d_cycle_consistency.jpg' % (step)) translate_and_reconstruct(nets, args, x_src, y_src, x_ref, y_ref, filename) # latent-guided image synthesis y_trg_list = [ porch.tensor(y).repeat(N) for y in range(min(args.num_domains, 5)) ] z_trg_list = porch.randn(args.num_outs_per_domain, 1, args.latent_dim).repeat(1, N, 1) for psi in [0.5, 0.7, 1.0]: filename = ospj(args.sample_dir, '%06d_latent_psi_%.1f.jpg' % (step, psi)) translate_using_latent(nets, args, x_src, y_trg_list, z_trg_list, psi, filename) # reference-guided image synthesis filename = ospj(args.sample_dir, '%06d_reference.jpg' % (step)) translate_using_reference(nets, args, x_src, x_ref, y_ref, filename)
def __init__(self, num_features, eps=1e-5, momentum=0.1, affine=True, track_running_stats=True): super(_BatchNormBase, self).__init__() self.num_features = num_features self.eps = eps self.momentum = momentum self.affine = affine self.track_running_stats = track_running_stats if self.affine: self.weight = Parameter(torch.Ones(num_features)) self.bias = Parameter(torch.Zeros(num_features)) else: self.register_parameter('weight', None) self.register_parameter('bias', None) if self.track_running_stats: self.register_buffer('running_mean', torch.zeros(num_features)) self.register_buffer('running_var', torch.ones(num_features)) self.register_buffer('num_batches_tracked', torch.tensor(0, dtype=torch.long)) else: self.register_parameter('running_mean', None) self.register_parameter('running_var', None) self.register_parameter('num_batches_tracked', None) self.reset_parameters()
def _load_from_state_dict(self, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs): version = local_metadata.get('version', None) if (version is None or version < 2) and self.track_running_stats: # at version 2: added num_batches_tracked buffer # this should have a default value of 0 num_batches_tracked_key = prefix + 'num_batches_tracked' if num_batches_tracked_key not in state_dict: state_dict[num_batches_tracked_key] = torch.tensor(0, dtype=torch.long) super(_BatchNorm, self)._load_from_state_dict( state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs)
def calculate_metrics(nets, args, step, mode): print('Calculating evaluation metrics...') assert mode in ['latent', 'reference'] device = porch.device('cuda' if porch.cuda.is_available() else 'cpu') for name in nets: nets[name].eval() domains = os.listdir(args.val_img_dir) domains.sort() num_domains = len(domains) print('Number of domains: %d' % num_domains) enable_lpips=True # save time to check FID result if enable_lpips: lpips_dict = OrderedDict() for trg_idx, trg_domain in enumerate(domains): src_domains = [x for x in domains if x != trg_domain] if mode == 'reference': path_ref = os.path.join(args.val_img_dir, trg_domain) loader_ref = get_eval_loader(root=path_ref, img_size=args.img_size, batch_size=args.val_batch_size, imagenet_normalize=False, drop_last=True) for src_idx, src_domain in enumerate(src_domains): path_src = os.path.join(args.val_img_dir, src_domain) loader_src = get_eval_loader(root=path_src, img_size=args.img_size, batch_size=args.val_batch_size, imagenet_normalize=False) task = '%s2%s' % (src_domain, trg_domain) path_fake = os.path.join(args.eval_dir, task) shutil.rmtree(path_fake, ignore_errors=True) os.makedirs(path_fake) lpips_values = [] print('Generating images and calculating LPIPS for %s...' % task) for i, x_src in enumerate(tqdm(loader_src, total=len(loader_src))): x_src=porch.varbase_to_tensor(x_src[0]) N = x_src.size(0) y_trg = porch.tensor([trg_idx] * N) masks = nets.fan.get_heatmap(x_src) if args.w_hpf > 0 else None # generate 10 outputs from the same input group_of_images = [] for j in range(args.num_outs_per_domain): if mode == 'latent': z_trg = porch.randn(N, args.latent_dim) s_trg = nets.mapping_network(z_trg, y_trg) else: try: x_ref = next(iter_ref) except: iter_ref = iter(loader_ref) x_ref = next(iter_ref) x_ref=porch.varbase_to_tensor(x_ref[0]) if x_ref.size(0) > N: x_ref = x_ref[:N] s_trg = nets.style_encoder(x_ref, y_trg) x_fake = nets.generator(x_src, s_trg, masks=masks) group_of_images.append(x_fake) # save generated images to calculate FID later for k in range(N): filename = os.path.join( path_fake, '%.4i_%.2i.png' % (i*args.val_batch_size+(k+1), j+1)) utils.save_image(x_fake[k], ncol=1, filename=filename) lpips_value = calculate_lpips_given_images(group_of_images) lpips_values.append(lpips_value) # calculate LPIPS for each task (e.g. cat2dog, dog2cat) lpips_mean = np.array(lpips_values).mean().astype(float) lpips_dict['LPIPS_%s/%s' % (mode, task)] = lpips_mean # delete dataloaders del loader_src if mode == 'reference': del loader_ref del iter_ref # calculate the average LPIPS for all tasks lpips_mean = 0 for _, value in lpips_dict.items(): lpips_mean += value / len(lpips_dict) lpips_dict['LPIPS_%s/mean' % mode] = lpips_mean # report LPIPS values filename = os.path.join(args.eval_dir, 'LPIPS_%.5i_%s.json' % (step, mode)) utils.save_json(lpips_dict, filename) # calculate and report fid values return calculate_fid_for_all_tasks(args, domains, step=step, mode=mode) for name in nets: nets[name].train()
import paddle import paddorch as paddorch import torch import numpy as np x = np.arange(2 * 768).reshape((1, 2, 768)) x_t = torch.repeat_interleave(torch.FloatTensor(x), repeats=4, dim=1) x_p = paddorch.repeat_interleave(paddorch.FloatTensor(x), repeats=4, dim=1) assert np.max(np.abs(x_t.numpy() - x_p.numpy())) < 0.001, "fail match torch" print(paddorch.repeat_interleave(x_p, 2)) y = paddorch.tensor([[1, 2], [3, 4]]) print(paddorch.repeat_interleave(y, 2)) print(paddorch.repeat_interleave(y, 3, dim=1))
def __init__(self, w_hpf, device): super(HighPass, self).__init__() self.filter = porch.varbase_to_tensor( porch.tensor([[-1, -1, -1], [-1, 8., -1], [-1, -1, -1]]).to(device) / w_hpf)