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 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 update_core(self): gen = self.models['gen'] dis = self.models['dis'] gen_optimizer = self.get_optimizer('opt_gen') dis_optimizer = self.get_optimizer('opt_dis') xp = gen.xp x_real, y_real = self.get_batch(xp) # First, sample data from G through langevin dynamics batchsize = len(x_real) # x_fake, y_fake = self._generete_samples(n_gen_samples=batchsize) if self.conditional: y_fake = sample_categorical(gen.n_classes, batchsize, xp=gen.xp) else: y_fake = None if args.sampling_space == 'pixel': x_fake = gen(batchsize, y=y_fake) x_fake = sampler.langevin(x_fake, y_fake, dis) elif args.sampling_space == 'latent': x_fake, _ = latent_sampler.langevin(batchsize, gen, dis, y_fake=y_fake) # Then, update energy critic for i in range(self.n_dis): dis_real = dis(x_real, y=y_real) dis_fake = dis(x_fake, y=y_fake) x_fake.unchain_backward() loss_dis = self.loss_dis(dis_fake=dis_fake, dis_real=dis_real) dis.cleargrads() loss_dis.backward() dis_optimizer.update() chainer.reporter.report({'loss_dis': loss_dis})
def gen_images(gen, n=50000, batchsize=100): ims = [] xp = gen.xp # start_time = time.time() # print('Start!') for i in range(0, n, batchsize): if i % 2500 == 2500 - batchsize: print(str(i) + " generated") 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) x = sampler.langevin(x, y, dis) elif args.sampling_space == 'latent': x, _ = latent_sampler.langevin(batchsize, gen, dis, y_fake=y, eval=True) x = chainer.cuda.to_cpu(x.data) x = np.asarray(np.clip(x * 127.5 + 127.5, 0.0, 255.0), dtype=np.uint8) ims.append(x) ims = np.asarray(ims) _, _, _, h, w = ims.shape ims = ims.reshape((n, 3, h, w)) # stop_time = time.time() # print('Stop! Time: '+str(stop_time-start_time)) return ims
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 _generete_samples(self, gen, n_gen_samples=None): if n_gen_samples is None: n_gen_samples = self.n_gen_samples if self.conditional: y = sample_categorical(gen.n_classes, n_gen_samples, xp=gen.xp) else: y = None x_fake = gen(n_gen_samples, y=y) return x_fake, y
def _generete_samples(self, n_gen_samples=None): if n_gen_samples is None: n_gen_samples = self.n_gen_samples gen = self.models['gen'] if self.conditional: y = sample_categorical(gen.n_classes, n_gen_samples, xp=gen.xp) else: y = None x_fake, out1, out2, out3 = gen(n_gen_samples, y=y) return x_fake, y, out1, out2, out3
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 __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, 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_y(self, batchsize=64): return sample_categorical(self.n_classes, batchsize, distribution="uniform", 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