def eff_k_cond(G, D, trial=100, label=None):
z1 = sample_continuous(128, trial, distribution=G.distribution, xp=xp)
z2 = sample_continuous(128, trial, distribution=G.distribution, xp=xp)
labels = label * xp.ones(trial).astype(xp.int32)
with chainer.using_config('train', False):
f1 = D(G(batchsize=trial, y=labels, z=z1))
f2 = D(G(batchsize=trial, y=labels, z=z2))
nu = distance(f2 - f1)
de_l = distance(z2 - z1)
return cuda.to_cpu(F.max(nu / de_l).data)
def __call__(self, batchsize=64, z=None, y=None, **kwargs):
if z is None:
z = sample_continuous(self.dim_z,
batchsize,
distribution=self.distribution,
xp=self.xp)
if y is None:
y = sample_categorical(
self.n_classes, batchsize, distribution="uniform",
xp=self.xp) if self.n_classes > 0 else None
if (y is not None) and z.shape[0] != y.shape[0]:
raise Exception(
'z.shape[0] != y.shape[0], z.shape[0]={}, y.shape[0]={}'.
format(z.shape[0], y.shape[0]))
h = z
h = self.l1(h)
h = F.reshape(h,
(h.shape[0], -1, self.bottom_width, self.bottom_width))
h = self.block2(h, y, **kwargs)
h = self.block3(h, y, **kwargs)
h = self.block4(h, y, **kwargs)
h = self.block5(h, y, **kwargs)
h = self.block6(h, y, **kwargs)
h = self.block7(h, y, **kwargs)
h = self.b8(h)
h = self.activation(h)
h = F.tanh(self.l8(h))
return h
def __call__(self, batchsize=64, z=None, gamma=None, beta=None, **kwargs):
if z is None:
z = sample_continuous(self.dim_z,
batchsize,
distribution=self.distribution,
xp=self.xp)
if gamma is None:
gamma = [None] * 12
beta = [None] * 12
# この辺は無駄なので，あとで直す
y = self.xp.zeros((1, self.n_classes), dtype="float32")
if self.n_classes > 0:
y[0, 0] = 1
h = z
h = self.l1(h)
h = F.reshape(h, (batchsize, -1, self.bottom_width, self.bottom_width))
if self.normalize_stat:
gamma = [self.normalize(g) * 0.2 + 1 for g in gamma]
beta = [self.normalize(b) * 0.15 for b in beta]
h = self.shift(h, gamma[0], beta[0])
h = self.block2(h, y, None, gamma[1:3], beta[1:3], **kwargs)
h = self.block3(h, y, None, gamma[3:5], beta[3:5], **kwargs)
h = self.block4(h, y, None, gamma[5:7], beta[5:7], **kwargs)
h = self.block5(h, y, None, gamma[7:9], beta[7:9], **kwargs)
h = self.block6(h, y, None, gamma[9:11], beta[9:11], **kwargs)
h = self.b7(h)
h = self.activation(h)
h = F.tanh(self.l7(h))
return h
def make_image(G,
D,
batchsize,
N_update=100,
ot=True,
mode='latent',
k=1,
lr=0.05,
optmode='sgd'):
label = sample_categorical(1000, batchsize, distribution="uniform", xp=xp)
labels = label * xp.ones(batchsize).astype(xp.int32)
zs = sample_continuous(128, batchsize, distribution=G.distribution, xp=xp)
if k != 1:
k = k(labels).data
with chainer.using_config('train', False):
if ot:
z_xp = zs
if optmode == 'sgd':
Opt = chainer.optimizers.SGD(lr)
elif optmode == 'adam':
Opt = chainer.optimizers.Adam(lr, beta1=0.0, beta2=0.9)
T = Transporter_in_latent(G, D, k, Opt, z_xp, labels, mode=mode)
discriminator_optimal_transport_from(z_xp, T, N_update)
tz_y = T.get_z_va().data
y = G(batchsize=batchsize, y=labels, z=tz_y)
else:
y = G(batchsize=batchsize, y=labels, z=zs)
return cuda.to_cpu(y.data)
def __call__(self, x, z=None, save_res=False, add_noise=False, **kwargs):
if z is None and add_noise:
z = sample_continuous(self.dim_z,
len(x),
distribution=self.distribution,
xp=self.xp)
if add_noise:
# # untested format of noise!!
h = z if len(z.shape) == 4 else F.reshape(z, (z.shape[0],
z.shape[1], 1, 1))
else:
h = x
# # save the outputs of each layer if requested.
outs = []
# # loop over the layers and apply convolutions along with the
# # normalizations per layer.
for l in range(1, self.n_layers):
h = getattr(self, 'conv{}'.format(l))(h)
#print('Debugging, encoder step {}: '.format(l), h.shape)
if self.norms[l - 1] is not None:
h = getattr(self, 'norm{}'.format(l))(h)
h = self.activs[l - 1](h)
if save_res:
outs.append(h)
# # last layer:
h = getattr(self, 'conv{}'.format(self.n_layers))(h)
#print('Debugging, encoder step {}: '.format(self.n_layers), h.shape)
if save_res:
outs.append(h)
h = self.activs[-1](h)
if not save_res:
return h
else:
return h, outs
def langevin(batchsize, gen, dis, y_fake, eval=False, given_z=None):
if eval:
Step_lr = args.eval_step_lr
num_steps = args.eval_num_steps
Noise_scale = args.eval_noise_scale
else:
Step_lr = args.step_lr
num_steps = args.num_steps
Noise_scale = args.noise_scale
if given_z is None:
z = sample_continuous(gen.dim_z,
batchsize,
distribution=gen.distribution,
xp=gen.xp)
z = chainer.Variable(z)
else:
z = given_z
x_fake = gen(batchsize, z=z, y=y_fake)
for step in range(num_steps):
energy = dis(x_fake, y=y_fake) * args.temperature
z_grad = chainer.grad(outputs=[energy], inputs=[z])[0]
# pdb.set_trace()
if args.anealing:
step_lr = Step_lr * 0.1**(step // (num_steps / 5))
noise_scale = Noise_scale * 0.1**(step // (num_steps / 5))
else:
step_lr = Step_lr
noise_scale = Noise_scale
z_grad_noise = step_lr/2*z_grad + \
(step_lr**0.5)*cp.random.normal(size=z.shape, loc=0.0, scale=noise_scale)
z = z + z_grad_noise
z.unchain_backward()
x_fake = gen(batchsize, z=z, y=y_fake)
return x_fake, z
def __call__(self, batchsize=64, z=None, y=None):
if z is None:
z = sample_continuous(self.dim_z,
batchsize,
distribution=self.distribution,
xp=self.xp)
if y is None:
y = sample_categorical(
self.n_classes, batchsize, distribution="uniform",
xp=self.xp) if self.n_classes > 0 else None
if (y is not None) and z.shape[0] != y.shape[0]:
raise ValueError('z.shape[0] != y.shape[0]')
h = z
h = self.l1(h)
h = F.reshape(h,
(h.shape[0], -1, self.bottom_width, self.bottom_width))
h = self.block2(h, y)
out1 = h
h = self.block3(h, y)
out2 = h
h = self.block4(h, y)
out3 = h
h = self.b5(h)
h = self.activation(h)
h = F.tanh(self.c5(h))
return h, out1, out2, out3
def __call__(self,
x,
skips=None,
z=None,
save_res=False,
add_noise=False,
**kwargs):
if z is None and add_noise:
z = sample_continuous(self.dim_z,
len(x),
distribution=self.distribution,
xp=self.xp)
if add_noise:
# # untested format of noise!!
h = z if len(z.shape) == 4 else F.reshape(z, (z.shape[0],
z.shape[1], 1, 1))
else:
h = x
# # save the outputs of each layer if requested.
outs = []
# # loop over the layers and apply convolutions along with the
# # normalizations per layer.
for l in range(1, self.n_layers):
if self.skip_enc is not None and self.skip_enc[l] > 0:
# # in this case, we concatenate the skip with our representation.
# # The -1 below, since skips includes a zero-based list of all
# # encoder layer outputs, i.e. skips[0] -> output of 1st
# # encoder layer. To get l^th encoder layer's output -> skips[l-1].
if self.noise_skip:
noise = self.xp.random.normal(loc=0,
scale=self.noise_cov,
size=h.shape).astype("f")
h = F.concat([skips[self.skip_enc[l] - 1] + noise, h])
else:
h = F.concat([skips[self.skip_enc[l] - 1], h])
h = getattr(self, 'tconv{}'.format(l))(h)
if self.norms[l - 1] is not None:
h = getattr(self, 'norm{}'.format(l))(h)
h = self.activs[l - 1](h)
if save_res:
outs.append(h)
# # last layer:
l = self.n_layers
if self.skip_enc is not None and self.skip_enc[l] > 0:
h = F.concat([skips[self.skip_enc[l] - 1], h])
h = getattr(self, 'tconv{}'.format(l))(h)
if save_res:
# # even though the outputs of the previous layers are appened
# # (into outs) after the activation, this is before.
outs.append(h)
h = self.activs[-1](h)
if not save_res:
return h
else:
return h, outs
def gen_eval_images(gen, n=50000, batchsize=100, seeds=1234, langevin_steps=5):
'''
langevin_steps: column
'''
ims = []
xp = gen.xp
xp.random.seed(seeds)
for i in range(0, n, batchsize):
print(i)
config = yaml_utils.Config(yaml.load(open(args.config_path)))
is_conditional = config.updater['args']['conditional']
if is_conditional:
y = sample_categorical(gen.n_classes, batchsize, xp=gen.xp)
else:
y = None
if args.sampling_space == 'pixel':
with chainer.using_config('train', False), chainer.using_config(
'enable_backprop', False):
x = gen(batchsize, y=y)
for j in range(langevin_steps):
x = sampler.langevin(x, y, dis)
nx = chainer.cuda.to_cpu(x.data)
nx = np.asarray(np.clip(nx * 127.5 + 127.5, 0.0, 255.0),
dtype=np.uint8)
ims.append(nx)
elif args.sampling_space == 'latent':
z = Variable(
sample_continuous(gen.dim_z,
batchsize,
distribution=gen.distribution,
xp=gen.xp))
x = gen(batchsize, y=y, z=z)
nx = chainer.cuda.to_cpu(x.data)
nx = np.asarray(np.clip(nx * 127.5 + 127.5, 0.0, 255.0),
dtype=np.uint8)
ims.append(nx)
for j in range(langevin_steps):
x, z = latent_sampler.langevin(batchsize,
gen,
dis,
y_fake=y,
eval=True,
given_z=z)
nx = chainer.cuda.to_cpu(x.data)
nx = np.asarray(np.clip(nx * 127.5 + 127.5, 0.0, 255.0),
dtype=np.uint8)
ims.append(nx)
ims = list(map(list, zip(*ims)))
ims = np.asarray(ims)
_, _, _, h, w = ims.shape
if args.sampling_space == 'latent':
langevin_steps += 1
ims = ims.reshape((n * langevin_steps, 3, h, w))
return ims
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--config_path', type=str, default='configs/base.yml')
parser.add_argument('--gpu', '-g', type=int, default=0)
parser.add_argument('--results_dir', type=str, default='./results/gans')
parser.add_argument('--snapshot', type=str, default='')
parser.add_argument('--rows', type=int, default=5)
parser.add_argument('--columns', type=int, default=5)
parser.add_argument('--classes', type=int, nargs="*", default=None)
parser.add_argument('--dump_z', action='store_true', default=False)
args = parser.parse_args()
np.random.seed(1234)
chainer.cuda.get_device_from_id(args.gpu).use()
config = yaml_utils.Config(yaml.load(open(args.config_path)))
gen = load_models(config)
gen.to_gpu(args.gpu)
chainer.serializers.load_npz(args.snapshot, gen)
out = args.results_dir
classes = tuple(args.classes) if args.classes is not None else np.arange(
0, gen.n_classes, dtype=np.int32)
for c in classes:
z = sample_continuous(128, args.rows * args.columns, xp=gen.xp)
with chainer.using_config('train', False), chainer.using_config(
'enable_backprop', False):
x = gen_images_with_condition(gen,
z=z,
c=c,
n=args.rows * args.columns,
batchsize=args.rows * args.columns)
_, _, h, w = x.shape
x = x.reshape((args.rows, args.columns, 3, h, w))
x = x.transpose(0, 3, 1, 4, 2)
x = x.reshape((args.rows * h, args.columns * w, 3))
save_path = os.path.join(out, '{}.png'.format(str(c)))
if not os.path.exists(out):
os.makedirs(out)
Image.fromarray(x).save(save_path)
# dump latent variables
if args.dump_z:
for i in range(args.rows * args.columns):
np.save(os.path.join(out, 'z_{}-{}.npy'.format(c, i)),
z.get()[i])
def __call__(self, batchsize=64, z=None, y=None, gt=None, **kwargs):
outs = []
fast_losses = []
if z is None:
z = sample_continuous(self.dim_z,
batchsize,
distribution=self.distribution,
xp=self.xp)
if y is None:
y = sample_categorical(
self.n_classes, batchsize, distribution="uniform",
xp=self.xp) if self.n_classes > 0 else None
if (y is not None) and z.shape[0] != y.shape[0]:
raise Exception(
'z.shape[0] != y.shape[0], z.shape[0]={}, y.shape[0]={}'.
format(z.shape[0], y.shape[0]))
# forward calculation without auxiliary network
out_noab = self.forward(z=z, y=y, noAB=True, **kwargs)
out, z, zeta, z_recon = self.forward(z=z,
y=y,
return_zs=True,
**kwargs)
outs.append(out)
# beta1=0, beta2=0.9 <-> initial_t = 100
optimizer = MyAdaGrad(zeta, self.xp, lr=self.fast_alpha())
for _ in range(self.T):
loss = F.sum(self.fast_loss(out, gt))
fast_losses.append(loss)
grads = chainer.grad([loss], [zeta],
enable_double_backprop=True)[0]
# use learned learning rate
# z2 += - F.broadcast_to(self.lr(), grads[0].shape) * grads[0]
zeta += optimizer.calc_update(grads)
# forward run with z2 supply
out = self.forward(z=z, y=y, zeta=zeta)
outs.append(out)
return outs, fast_losses, out_noab, zeta, z_recon
def __call__(self, batchsize=64, z=None, **kwargs):
if z is None:
z = sample_continuous(self.dim_z,
batchsize,
distribution=self.distribution,
xp=self.xp)
h = z
h = self.l1(h)
h = F.reshape(h,
(h.shape[0], -1, self.bottom_width, self.bottom_width))
h = self.block2(h, **kwargs)
h = self.block3(h, **kwargs)
h = self.block4(h, **kwargs)
h = self.block5(h, **kwargs)
h = self.block6(h, **kwargs)
h = self.b7(h)
h = self.activation(h)
h = F.tanh(self.l7(h))
return h
def __call__(self, batchsize=64, z=None, y=None):
if z is None:
z = sample_continuous(self.dim_z, batchsize, distribution=self.distribution, xp=self.xp)
if y is None:
y = sample_categorical(self.n_classes, batchsize, distribution="uniform",
xp=self.xp) if self.n_classes > 0 else None
if (y is not None) and z.shape[0] != y.shape[0]:
raise ValueError('z.shape[0] != y.shape[0]')
print("B0", np.sum(z.data))
print("C2B0", np.sum(self.block2.c2.b.data))
h = z
h = self.l1(h)
h = F.reshape(h, (h.shape[0], -1, self.bottom_width, self.bottom_width))
print("B1", np.sum(h.data))
print("C2B1", np.sum(self.block2.c2.b.data))
h = self.block2(h, y)
print("B2", np.sum(h.data))
print("C2B2", np.sum(self.block2.c2.b.data))
h = self.block3(h, y)
print("B3", np.sum(h.data))
print("C2B3", np.sum(self.block2.c2.b.data))
h = self.block4(h, y)
print("B4", np.sum(h.data))
print("C2B4", np.sum(self.block2.c2.b.data))
h = self.b5(h)
print("B5", np.sum(h.data))
print("C2B5", np.sum(self.block2.c2.b.data))
h = self.activation(h)
print("B6", np.sum(h.data))
print("C2B6", np.sum(self.block2.c2.b.data))
h = F.tanh(self.c5(h))
print("B7", np.sum(h.data))
print("C2B7", np.sum(self.block2.c2.b.data))
return h
def sample_z(self, batchsize=64):
return sample_continuous(self.dim_z,
batchsize,
distribution=self.distribution,
xp=self.xp)
def __call__(self,
batchsize=None,
y=None,
z=None,
mult_until_exec=None,
**kwargs):
if z is None:
z = sample_continuous(self.dim_z,
batchsize,
distribution=self.distribution,
xp=self.xp)
if y is None:
y = sample_categorical(
self.n_classes, batchsize, distribution="uniform",
xp=self.xp) if self.n_classes > 0 else None
activ = self.activation
# # mult_until_exec: If set, we perform the multiplications until that layer.
# # In the product of polynomials, it applies the same rule for *every*
# # polynomial. E.g. if mult_until_exec == 2 it will perform the hadamard
# # products until second order terms in every polynomial.
if mult_until_exec is None:
mult_until_exec = 10000
z = self.prod_poly_FC(z, mult_until_exec, batchsize=batchsize, y=y)
h = z + 0
if self.bottom_width > 1:
h = getattr(self, 'lin0')(h)
h = F.reshape(h,
(h.shape[0], -1, self.bottom_width, self.bottom_width))
# # loop over the layers and get the layers along with the
# # normalizations per layer.
for l in range(1, self.n_l + 1):
if self.skip_rep:
h_hold = h + 0
if self.use_bn and y is None:
h = getattr(self, 'bn{}'.format(l))(h)
elif self.use_bn:
h = getattr(self, 'bn{}'.format(l))(h, y)
h = activ(getattr(self, 'l{}'.format(l))(h))
h = self.return_injected(h, z, l, mult_until_exec=mult_until_exec)
if self.skip_rep:
# # transform the channels of h_hold if required.
h_hold = getattr(self, 'skipch{}'.format(l))(h_hold)
# # upsample if required.
if h_hold.shape[-1] != h.shape[-1]:
h_hold = _upsample(h_hold)
h += h_hold
if self.order_out_poly is not None:
z0 = h + 0
for i in range(1, self.order_out_poly):
h1 = getattr(self, 'oro{}'.format(i + 1))(h)
if self.skip_rep:
# # model3 polynomial.
h += z0 * h1
else:
h = z0 * h1
# # last layer (no activation).
output = getattr(self, 'l{}'.format(self.n_l + 1))(h)
out = self.out_act(output)
return out
