def get_loss_func(self,x, C=1.0): batchsize = len(self.encode(x)[0]) z=list() mu, ln_var = self.encode(x) for l in six.moves.range(self.sampling_number): z.append(F.gaussian(mu, ln_var)) for iii in range(self.sampling_number): if iii==0: rec_loss=0 z = F.gaussian(mu, ln_var) rec_loss += F.sum(F.bernoulli_nll(x, self.decode(z, sigmoid=False), reduce='no'),axis=1)/(batchsize) loss=rec_loss+F.sum(C * gaussian_kl_divergence(mu, ln_var,reduce='no'),axis=1)/ batchsize loss=F.reshape(loss,[batchsize,1]) else: rec_loss=0 z = F.gaussian(mu, ln_var) rec_loss += F.sum(F.bernoulli_nll(x, self.decode(z, sigmoid=False), reduce='no'),axis=1)/(batchsize) tmp_loss=rec_loss+F.sum(C * gaussian_kl_divergence(mu, ln_var,reduce='no'),axis=1)/ batchsize tmp_loss=F.reshape(tmp_loss,[batchsize,1]) loss=F.concat((loss,tmp_loss),axis=1) importance_weight = F.softmax(loss) self.total_loss=F.sum(importance_weight*loss) return self.total_loss
def check_bernoulli_nll(self, x, y): if self.wrap_x: x = chainer.Variable(x) if self.wrap_y: y = chainer.Variable(y) actual = cuda.to_cpu(F.bernoulli_nll(x, y, self.reduce).data) testing.assert_allclose(self.expect, actual)
def lf(x): mu, ln_var = self.encode(x) mean_mu, mean_sigma = calculate_means(mu, ln_var) batchsize = len(mu.data) std_mu, std_ln_var = generate_std_params(mu) # reconstruction loss rec_loss = 0 kl_loss = 0 for l in six.moves.range(k): z = F.gaussian(mu, ln_var) rec_loss += F.bernoulli_nll(x, self.decode(z, sigmoid=False)) / (k * batchsize) kl_loss += -F.gaussian_nll(z, mu, ln_var) / (k * batchsize) kl_loss += F.gaussian_nll(z, std_mu, std_ln_var) / (k * batchsize) self.rec_loss = rec_loss self.kl_loss = kl_loss self.loss = self.rec_loss + C * self.kl_loss chainer.report( { 'rec_loss': rec_loss, 'kl': self.kl_loss, 'loss': self.loss, 'mu': mean_mu, 'sigma': mean_sigma, }, observer=self ) return self.loss
def lf(x): # x = x.reshape(-1, 3*64*64) mu, ln_var = self.encode(x) batchsize = len(mu.data) # reconstruction loss rec_loss = 0 for _ in range(self.k): z = F.gaussian(mu, ln_var) rec_loss += F.bernoulli_nll(x, self.decode(z, sigmoid=False)) \ / (self.k * batchsize) self.rec_loss = rec_loss # latent loss lat_loss = self.beta * gaussian_kl_divergence(mu, ln_var) / batchsize self.lat_loss = lat_loss self.loss = rec_loss + lat_loss chainer.report( { "rec_loss": rec_loss, "lat_loss": lat_loss, "loss": self.loss }, observer=self) return self.loss
def __call__(self, xs, zs, es): batch_size = xs.shape[0] encoded_zs = self.encoder(xs, es) ys = self.decoder(encoded_zs) d_loss = F.bernoulli_nll(xs, ys) / batch_size t_loss = F.sum(self.discriminator(xs, encoded_zs)) / batch_size return t_loss + d_loss, encoded_zs
def forward(self, inp, target=None, reward=None): self.gru.reset_state() if target is None and reward is None: sample_size = inp return self.sample(sample_size) else: batch_size, seq_len = inp.shape inp = inp.T target = target.T loss = 0 if not target is None and reward is None: for i in range(seq_len): out = self.calc(inp[i]) loss += F.bernoulli_nll(out, target[i]) return loss elif not target is None and not reward is None: for i in range(seq_len): out = self.calc(inp[i]) for j in range(batch_size): loss += -out[j][target[i][j]] * reward[j] return loss / batch_size
def bernoulli_nll(x, y): x = np.array(x, dtype=np.float32) y = np.array(y, dtype=np.float32) loss = F.bernoulli_nll(x, y, reduce='no') plt.plot(loss.data) plt.show() print loss
def update_core(self): batch = self._iterators['main'].next() x = Variable(self.converter(batch, self.device)) xp = cuda.get_array_module(x.data) enc = self.enc opt_enc = self._optimizers['enc'] dec = self.dec opt_dec = self._optimizers['dec'] mu, ln_var = enc(x) batchsize = len(mu.data) rec_loss = 0 k = 10 for l in range(k): z = F.gaussian(mu, ln_var) rec_loss += F.bernoulli_nll(x, dec( z, sigmoid=False)) / (k * batchsize) loss = rec_loss + 1.0 * F.gaussian_kl_divergence(mu, ln_var) / batchsize enc.cleargrads() dec.cleargrads() loss.backward() opt_enc.update() opt_dec.update() chainer.report({'rec_loss': rec_loss}) chainer.report({'loss': loss})
def __call__(self, x, t): # データ数 num_data = x.shape[0] # Forwardとlossの計算 mu, var = self.vae.encoder(x) z = F.gaussian(mu, var) reconst_loss = 0 for i in range(self.k): # MSEで誤差計算を行う if self.loss_function == 'mse': reconst = self.vae.decoder(z, use_sigmoid=True) reconst_loss += F.mean_squared_error(x, reconst) / self.k # その他の場合はベルヌーイ分布により計算 else: # bernoulli_nllがsigmoidを内包しているので学習時はsigmoid=False reconst = self.vae.decoder(z, use_sigmoid=False) reconst_loss += F.bernoulli_nll(x, reconst) / (self.k * num_data) kld = gaussian_kl_divergence(mu, var, reduce='mean') loss = reconst_loss + self.beta * kld # report reporter.report({'loss': loss}, self) reporter.report({'reconst_loss': reconst_loss}, self) reporter.report({'kld': kld}, self) return loss
def free_energy(self, x): #return -(free energy) enc_mu, enc_log_sigma_2 = self.encode(x) kl = F.gaussian_kl_divergence(enc_mu, enc_log_sigma_2) z = F.gaussian(enc_mu, enc_log_sigma_2) dec_mu = self.decode(z) nll = F.bernoulli_nll(x, dec_mu) return nll + kl
def free_energy(self,x): #return -(free energy) enc_mu, enc_log_sigma_2 = self.encode(x) kl = F.gaussian_kl_divergence(enc_mu,enc_log_sigma_2) z = F.gaussian(enc_mu,enc_log_sigma_2) dec_mu = self.decode(z) nll = F.bernoulli_nll(x,dec_mu) return nll+kl
def lf(x): z = self.encode(x) batchsize = len(x.data) # reconstruction loss #self.rec_loss = F.mean_squared_error(x, self.decode(z)) self.rec_loss = F.bernoulli_nll(x, self.decode(z, sigmoid=False)) / (batchsize) # total_loss vanilla AEの場合はreconstruction lossとtotal lossは一緒 self.loss = self.rec_loss return self.loss
def calc_reconst_loss(self, encoder_input, decoder_output): if self.is_gauss_dist: dec_mu, dec_var = decoder_output m_vae = 0.5* (encoder_input - dec_mu)**2 * F.exp(-dec_var) a_vae = 0.5* (log2pi+dec_var) # reconst = F.sum(m_vae + a_vae, axis=1) reconst = F.sum(m_vae + a_vae) else: reconst = F.bernoulli_nll(encoder_input, decoder_output) return reconst
def train(model, epoch0=0): optimizer = optimizers.Adam() optimizer.setup(model) for epoch in xrange(epoch0, n_epoch): logger.print_epoch(epoch) # training perm = np.random.permutation(N_train) for i in xrange(0, N_train, batchsize): x = Variable(xp.asarray(x_train[perm[i:i + batchsize]])) mu, ln_var = model.encode(x) rec_loss = 0 for l in xrange(1): z = F.gaussian(mu, ln_var) rec_loss += F.bernoulli_nll(x, model.decode(z, sigmoid=False)) / batchsize reg_loss = gaussian_kl_divergence(mu, ln_var) / batchsize loss = rec_loss + reg_loss optimizer.zero_grads() loss.backward() loss.unchain_backward() optimizer.update() logger.save_loss(reg_loss.data, rec_loss.data, train=True) # evaluation for i in xrange(0, N_test, batchsize): x = Variable(xp.asarray(x_train[i:i + batchsize]), volatile='on') mu, ln_var = model.encode(x) rec_loss = 0 for l in xrange(1): z = F.gaussian(mu, ln_var) rec_loss += F.bernoulli_nll(x, model.decode(z, sigmoid=False)) / batchsize reg_loss = gaussian_kl_divergence(mu, ln_var) / batchsize loss = rec_loss + reg_loss logger.save_loss(reg_loss.data, rec_loss.data, train=False) logger.epoch_end() logger.terminate() serializer.save(model, optimizer, epoch+1) # everything works well return 0
def update_core(self): vae_optimizer = self.get_optimizer('opt_vae') xp = self.vae.xp batch = self.get_iterator('main').next() batchsize = len(batch) x = chainer.dataset.concat_examples(batch, device=self.device) latent_dist = self.vae.encode(x) # reconstruction loss rec_loss = 0 for _ in range(self.vae.k): reconstructions = self.vae(x, sigmoid=False, mode="sample") rec_loss += F.bernoulli_nll(x, reconstructions) \ / (self.vae.k * batchsize) ### latent loss # latent loss for continuous cont_capacity_loss = 0 if self.vae.is_continuous: mu, ln_var = latent_dist['cont'] kl_cont_loss = gaussian_kl_divergence(mu, ln_var) / batchsize # Anealing loss cont_min, cont_max, cont_num_iters, cont_gamma = \ self.vae.cont_capacity cont_cap_now = (cont_max - cont_min) * self.iteration / float(cont_num_iters) + cont_min cont_cap_now = min(cont_cap_now, cont_max) cont_capacity_loss = cont_gamma * F.absolute(cont_cap_now - kl_cont_loss) # latent loss for discrete disc_capacity_loss = 0 if self.vae.is_discrete: kl_disc_loss = kl_multiple_discrete_loss(latent_dist['disc']) # Anealing loss disc_min, disc_max, disc_num_iters, disc_gamma = \ self.vae.disc_capacity disc_cap_now = (disc_max - disc_min) * self.iteration / float(disc_num_iters) + disc_min disc_cap_now = min(disc_cap_now, disc_max) # Require float conversion here to not end up with numpy float disc_theoretical_max = 0 for disc_dim in self.vae.latent_spec["disc"]: disc_theoretical_max += xp.log(disc_dim) disc_cap_now = min(disc_cap_now, disc_theoretical_max.astype("float32")) disc_capacity_loss = disc_gamma * F.absolute(disc_cap_now - kl_disc_loss) joint_vae_loss = rec_loss + cont_capacity_loss + disc_capacity_loss self.vae.cleargrads() joint_vae_loss.backward() vae_optimizer.update() chainer.reporter.report({"rec_loss": rec_loss, "cont_loss": cont_capacity_loss, "disc_loss": disc_capacity_loss, "vae_loss": joint_vae_loss, }) return
def cost(self, x_var, C=1.0, k=1): mu, ln_var = self.encode(x_var) batchsize = len(mu.data) rec_loss = 0 for l in six.moves.range(k): z = F.gaussian(mu, ln_var) rec_loss += F.bernoulli_nll(x_var, self.decode(z, sigmoid=False)) \ / (k * batchsize) self.rec_loss = rec_loss self.loss = self.rec_loss + C * gaussian_kl_divergence(mu, ln_var) / batchsize return self.loss
def __call__(self, x): x = Variable(x) start = time.time() zm, zv = self.encoder((x,)) z = F.gaussian(zm, zv) y = self.decoder((z,))[0] kl_loss = F.gaussian_kl_divergence(zm, zv) nll_loss = F.bernoulli_nll(x, y) loss = kl_loss + nll_loss return loss
def lf(x, x_next): z = self.encode(x) batchsize = len(z.data) # reconstruction loss loss = 0 for l in six.moves.range(k): loss += F.bernoulli_nll(x_next, self.decode(z, batchsize, sigmoid=False)) \ / (k * batchsize) self.loss = loss chainer.report({'loss': self.loss}, observer=self) return self.loss
def get_loss(self, x, y, train=True): mu, ln_var = self.encode(x, y) batchsize = len(mu.data) # reconstruction loss rec_loss = 0 z = F.gaussian(mu, ln_var) rec_loss += F.bernoulli_nll(y, self.decode(z, x)) / (batchsize) self.rec_loss = rec_loss self.loss = self.rec_loss + F.gaussian_kl_divergence( mu, ln_var) / batchsize return self.loss
def reconstruction_loss(self, x, k): batchsize = len(x) mu, ln_var = self.encode(x) samples = [] loss = 0. for _ in range(k): z = F.gaussian(mu, ln_var) samples.append(z) loss += F.bernoulli_nll(x, self.decode(z)) / (k * batchsize) dist = Distribution(mu, ln_var, samples) return loss, dist
def __call__(self, text, x, t, textlens, xlens): batchsize = text.shape[0] vk = self.text_enc(text) v = vk[:, :self.d, :] k = vk[:, self.d:, :] q = self.audio_enc(x) a = F.matmul(F.transpose(k, (0, 2, 1)), q) a = F.softmax(a / self.xp.sqrt(self.d)) r = F.matmul(v, a) rd = F.concat((r, q)) y = self.audio_dec(rd) loss_bin = 0 for i in range(batchsize): loss_bin += F.mean( F.bernoulli_nll(t[i, :, :xlens[i]], y[i, :, :xlens[i]], 'no')) loss_bin /= batchsize y = F.sigmoid(y) loss_l1 = 0 for i in range(batchsize): loss_l1 += F.mean_absolute_error(t[i, :, :xlens[i]], y[i, :, :xlens[i]]) loss_l1 /= batchsize loss_att = 0 for i in range(batchsize): N = textlens[i] T = xlens[i] def w_fun(n, t): return 1 - np.exp(-((n / (N - 1) - t / (T - 1))**2) / (2 * self.g**2)) w = np.fromfunction(w_fun, (a.shape[1], T), dtype='f') w = self.xp.array(w) loss_att += F.mean(w * a[i, :, :T]) loss_att /= batchsize loss = loss_bin + loss_l1 + loss_att chainer.reporter.report({ 'loss_bin': loss_bin, 'loss_l1': loss_l1, 'loss_att': loss_att, }) return loss, y, a
def update_core(self): vae_optimizer = self.get_optimizer('opt_vae') dis_optimizer = self.get_optimizer('opt_dis') xp = self.vae.xp batch = self.get_iterator('main').next() batchsize = len(batch) x = chainer.dataset.concat_examples(batch, device=self.device) mu, ln_var = self.vae.encode(x) z_sampled = F.gaussian(mu, ln_var) z_shuffled = shuffle_codes(z_sampled) logits_z, probs_z = self.dis(z_sampled) _, probs_z_shuffle = self.dis(z_shuffled) reconstructions = self.vae.decode(z_sampled, sigmoid=False) # reconstruction loss rec_loss = 0 for _ in range(self.vae.k): rec_loss += F.bernoulli_nll(x, reconstructions) \ / (self.vae.k * batchsize) # latent loss lat_loss = self.vae.beta * gaussian_kl_divergence(mu, ln_var) / batchsize tc_loss = F.mean(logits_z[:, 0] - logits_z[:, 1]) factor_vae_loss = rec_loss + lat_loss + self.vae.gamma * tc_loss dis_loss = -(0.5 * F.mean(F.log(probs_z[:, 0])) \ + 0.5 * F.mean(F.log(probs_z_shuffle[:, 1]))) self.vae.cleargrads() self.dis.cleargrads() factor_vae_loss.backward() vae_optimizer.update() # avoid backword duplicate z_sampled.unchain_backward() self.dis.cleargrads() self.vae.cleargrads() dis_loss.backward() dis_optimizer.update() chainer.reporter.report({ "rec_loss": rec_loss, "lat_loss": lat_loss, "tc_loss": tc_loss, "vae_loss": factor_vae_loss, "dis_loss": dis_loss }) return
def lf(x): mu, ln_var = self.encode(x) batchsize = len(mu.data) # reconstruction loss rec_loss = 0 for l in six.moves.range(k): z = F.gaussian(mu, ln_var) rec_loss += F.bernoulli_nll(x, self.decode(z, sigmoid=False)) \ / (k * batchsize) self.rec_loss = rec_loss self.loss = self.rec_loss + \ C * gaussian_kl_divergence(mu, ln_var) / batchsize return self.loss
def lf(self, x, mu, ln_var, split=False): batchsize = len(mu.data) # reconstruction loss rec_loss = 0 for l in range(k): z = F.gaussian(mu, ln_var) rec_loss += F.bernoulli_nll(x, self.decoder_model(z, sigmoid=False)) / (k * batchsize) rec_loss = rec_loss kl_loss = C * F.gaussian_kl_divergence(mu, ln_var) / batchsize loss = rec_loss + kl_loss if split: return rec_loss, kl_loss else: return loss
def lf(x): mu, ln_var = self.encode(x) batchsize = len(mu) # 復元誤差の計算 rec_loss = 0 for l in six.moves.range(k): z = F.gaussian(mu, ln_var) rec_loss += F.bernoulli_nll(x, self.decode(z, sigmoid=False)) / (k * batchsize) self.rec_loss = rec_loss self.loss = self.rec_loss + \ beta * gaussian_kl_divergence(mu, ln_var) / batchsize chainer.report( {'rec_loss': rec_loss, 'loss': self.loss}, observer=self) return self.loss
def __call__(self, x, sigmoid=True): """AutoEncoder""" mu, ln_var = self.encode(x) batchsize = len(mu.data) # reconstruction loss rec_loss = 0 for l in six.moves.range(self.k): z = F.gaussian(mu, ln_var) rec_loss += F.bernoulli_nll(x, self.decode(z, sigmoid=False)) \ / (self.k * batchsize) loss = rec_loss + \ self.C * gaussian_kl_divergence(mu, ln_var) / batchsize chainer.report({'loss': loss}, self) return loss
def __call__(self, x, C=1.0, k=1): mu, ln_var = self.encode(x) mb_size = mu.data.shape[0] # reconstruction loss rec_loss = 0 for l in range(k): z = F.gaussian(mu, ln_var) rec_loss += F.bernoulli_nll(x, self.decode(z, sigmoid=False)) rec_loss /= (k * mb_size) kld_loss = gaussian_kl_divergence(mu, ln_var) / mb_size loss = rec_loss + C * kld_loss return loss, float(rec_loss.data), float(kld_loss.data)
def lf(x): mu, ln_var = self.encode(x) batchsize = len(mu) # reconstruction loss rec_loss = 0 for l in six.moves.range(k): z = F.gaussian(mu, ln_var) rec_loss += F.bernoulli_nll(x, self.decode(z, sigmoid=False)) \ / (k * batchsize) self.rec_loss = rec_loss self.loss = self.rec_loss + \ beta * gaussian_kl_divergence(mu, ln_var) / batchsize chainer.report( {'rec_loss': rec_loss, 'loss': self.loss}, observer=self) return self.loss
def lf(x): in_img = x[0] in_labels = x[1:-1] mask = x[-1] # escape dividing by 0 when there are no labelled data points in the batch non_masked = sum(mask) + 1 mask_flipped = 1 - mask rec_loss = 0 label_loss = 0 label_acc = 0 mu, ln_var = self.encode(in_img) batchsize = len(mu.data) for l in six.moves.range(k): z = F.gaussian(mu, ln_var) out_img = self.decode(z, sigmoid=False) rec_loss += F.bernoulli_nll(in_img, out_img) / (k * batchsize) out_labels = self.predict_label(mu, ln_var, softmax=False) for i in range(self.n_latent): n = self.groups_len[i] - 1 # certain labels should not contribute to the calculation of the label loss values fixed_labels = (cupy.tile(cupy.array([1] + [-100] * n), (batchsize, 1)) * mask_flipped[:, cupy.newaxis]) out_labels[i] = out_labels[ i] * mask[:, cupy.newaxis] + fixed_labels label_acc += F.accuracy(out_labels[i], in_labels[i]) label_loss += F.softmax_cross_entropy( out_labels[i], in_labels[i]) / (k * non_masked) self.rec_loss = self.alpha * rec_loss self.label_loss = self.gamma * label_loss self.label_acc = label_acc kl = gaussian_kl_divergence(mu, ln_var) / (batchsize) self.kl = self.beta * kl self.loss = self.rec_loss + self.label_loss + self.kl return self.loss, self.rec_loss, self.label_loss, self.label_acc, self.kl
def lf(x): # getting the mu and ln_var of the prior of z with the encoder mu, ln_var = self.encode(x) batchsize = len(mu.data) # creating the latent variable z by sampling from the encoder output z = F.gaussian(mu, ln_var) # computing the reconstruction loss self.rec_loss = F.bernoulli_nll(x, self.decode( z, sigmoid=False)) / batchsize #self.rec_loss = F.sigmoid_cross_entropy(x, self.decode(z, sigmoid=False)) # computing the KL divergence self.KL_loss = gaussian_kl_divergence(mu, ln_var) / batchsize # computing the total loss self.loss = self.rec_loss + self.KL_loss # returning the losses separately return [self.rec_loss, self.loss]
def __call__(self, x, t): y = self.ssrn(x) loss_l1 = F.mean_absolute_error(t, y) loss_bin = F.mean(F.bernoulli_nll(t, y, 'no')) loss = loss_l1 + loss_bin chainer.reporter.report( { 'loss_l1': loss_l1, 'loss_bin': loss_bin, } ) return loss, y
def lf(x): mu, ln_var = self.encode(x) batch_size = len(mu.data) # reconstruction loss rec_loss = 0 for l in range(k): z = f.gaussian(mu, ln_var) z.name = "z" rec_loss += f.bernoulli_nll(x, self.decode(z, sigmoid=True)) \ / (k * batch_size) self.rec_loss = rec_loss self.rec_loss.name = "reconstruction error" self.latent_loss = C * gaussian_kl_divergence(mu, ln_var) / batch_size self.latent_loss.name = "latent loss" self.loss = self.rec_loss + self.latent_loss self.loss.name = "loss" return self.loss
def loss_func(self, x, t): y = self.predict(x) # loss = F.sigmoid_cross_entropy(y, t) loss = F.bernoulli_nll(t.astype("f"), y) / len(y) # labelが付いている(t_が1)場合: -log(y_) y_は0となるかも? # 付いていない(t_が0)場合: -log(1-y_) ここでt_,y_ はx, yの要素 # 以上の総和をバッチサイズで割る chainer.reporter.report({'loss': loss}, self) accuracy = self.accuracy(y.data, t) chainer.reporter.report({'accuracy': accuracy[0]}, self) # dataひとつひとつのlabelが完全一致している確率 chainer.reporter.report({'frequent_error': accuracy[1]}, self) # batchの中で最も多く間違って判断したlabel chainer.reporter.report({'acc_66': accuracy[2]}, self) # 66番ラベルの正解率 return loss
def lf(x): self.other_loss = 0. ze = self.encode(x) decoded_x = self.decode(ze, sigmoid=False) batchsize = x.shape[0] # self.rec_loss = F.mean_squared_error(x, decoded_x) self.rec_loss = F.bernoulli_nll(x, decoded_x) / batchsize self.loss = self.rec_loss + self.other_loss chainer.report( { 'rec_loss': self.rec_loss, 'other_loss': self.other_loss, 'loss': self.loss }, observer=self) del self.rec_loss del self.other_loss return self.loss
sum_loss_reconstruction = 0 start_time = time.time() perm = np.random.permutation(N) for i in range(0, N, batchsize): x = chainer.Variable(xp.asarray(x_train[perm[i:i + batchsize]])) y = chainer.Variable(xp.asarray(y_train[perm[i:i + batchsize]].astype(np.float32))) y_label = np.argmax(y_train[perm[i:i + batchsize]], axis=1) # Reconstruction phase z_fake_batch = model.encode(x) _x = model.decode(z_fake_batch, sigmoid=False) loss_reconstruction = F.bernoulli_nll(x, _x) / batchsize # Adversarial phase z_real_batch = utils.sample_z_from_n_2d_gaussian_mixture(batchsize, n_z, y_label, 10, use_gpu) z_real_batch_with_label = F.concat((z_real_batch, y)) p_real_batch = dis(z_real_batch_with_label) z_fake_batch_with_label = F.concat((z_fake_batch, y)) p_fake_batch = dis(z_fake_batch_with_label) loss_dis_real = F.softmax_cross_entropy(p_real_batch, chainer.Variable(xp.zeros(batchsize, dtype=np.int32))) loss_dis_fake = F.softmax_cross_entropy(p_fake_batch, chainer.Variable(xp.ones(batchsize, dtype=np.int32))) loss_dis = loss_dis_fake + loss_dis_real loss_gen = F.softmax_cross_entropy(p_fake_batch, chainer.Variable(xp.zeros(batchsize, dtype=np.int32))) loss_aae = loss_reconstruction + C * loss_gen
def check_bernoulli_nll(self, x_data, y_data): x = chainer.Variable(x_data) y = chainer.Variable(y_data) actual = cuda.to_cpu(F.bernoulli_nll(x, y, self.reduce).data) testing.assert_allclose(self.expect, actual)
def check_invalid_option(self, xp): x = chainer.Variable(xp.asarray(self.x)) y = chainer.Variable(xp.asarray(self.y)) with self.assertRaises(ValueError): F.bernoulli_nll(x, y, 'invalid_option')