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)
