def loss_cnn(self,
cnn,
x_out,
t_out,
y_out,
x_in,
lam1=1,
lam2=1,
lam3=10): # important!!!============
loss_rec = lam1 * (F.mean_absolute_error(x_out, t_out))
loss_adv = lam2 * y_out # y_out is the loss itself
if self._colormode == 'YUV':
l_t = self.YUV2Gray(t_out)
l_x = self.YUV2Gray(x_out)
elif self._colormode == 'LAB':
l_t = self.Lab2Gray(t_out, x_in)
l_x = self.Lab2Gray(x_out, x_in)
loss_l = lam3 * (F.mean_absolute_error(l_x, l_t))
loss = loss_rec + loss_adv + loss_l
chainer.report(
{
'loss': loss,
"loss_rec": loss_rec,
'loss_adv': loss_adv,
"loss_l": loss_l
}, cnn)
# chainer.report({'loss': loss, "loss_rec": loss_rec,
# 'loss_adv': loss_adv}, cnn)
return loss
def test_invalid_dtype2(self):
x0 = chainer.Variable(
numpy.random.uniform(-1, 1, (4, 3)).astype(numpy.float32))
x1 = chainer.Variable(
numpy.random.uniform(-1, 1, (4, 3)).astype(numpy.float16))
with self.assertRaises(type_check.InvalidType):
functions.mean_absolute_error(x0, x1)
def gene_update_full(self):
a = Variable(self.converter(self.itr_a.next(), self.device))
b = Variable(self.converter(self.itr_b.next(), self.device))
ab = self.generator_ab(a)
ba = self.generator_ba(b)
aba = self.generator_ba(ab)
bab = self.generator_ab(ba)
aa = self.generator_ba(a)
bb = self.generator_ab(b)
ab_disc = self.discriminator_b(ab)
ba_disc = self.discriminator_a(ba)
recon_loss = F.mean_absolute_error(a, aba) + F.mean_absolute_error(
b, bab)
gan_loss = self.loss_hinge_gene(ab_disc) + self.loss_hinge_gene(
ba_disc)
ident_loss = F.mean_absolute_error(a, aa) + F.mean_absolute_error(
b, bb)
loss_gene = recon_loss * 3.0 + gan_loss + ident_loss * 0.5
self.generator_ab.cleargrads()
self.generator_ba.cleargrads()
loss_gene.backward()
self.opt_g_a.update()
self.opt_g_b.update()
chainer.reporter.report({
'loss/g/recon': recon_loss,
'loss/g/ident': ident_loss,
'loss/g/gene': gan_loss
})
def test_invalid_dtype2(self):
x0 = chainer.Variable(
numpy.random.uniform(-1, 1, (4, 3)).astype(numpy.float32))
x1 = chainer.Variable(
numpy.random.uniform(-1, 1, (4, 3)).astype(numpy.float16))
with self.assertRaises(type_check.InvalidType):
functions.mean_absolute_error(x0, x1)
def update_core(self):
xp = self.model.xp
self._iter += 1
batch = self.get_iterator('main').next(
) #img_processed (B,4,H,W), origin (B,3,H,W), mask (B,1,H,W)
batchsize = len(batch)
w_in = self._image_size
zero_f = Variable(xp.zeros((batchsize, 3, w_in, w_in)).astype("f"))
x_train = np.zeros((batchsize, 3, w_in, w_in)).astype("f")
mask_train = np.zeros((batchsize, 3, w_in, w_in)).astype("f")
for i in range(batchsize):
x_train[i, :] = batch[i][0] #original image
mask_train[i, :] = batch[i][1] #0-1 mask of c
x_train = xp.array(x_train)
mask_train = xp.array(mask_train)
mask_b = xp.array(mask_train.astype("bool"))
I_gt = Variable(x_train)
M = Variable(mask_train)
M_b = Variable(mask_b)
I_out = self.model(I_gt, M)
I_comp = F.where(
M_b, I_gt, I_out
) #if an element of Mc_b is True, return the corresponded element of I_gt, otherwise return that of I_out)
fs_I_gt = vgg_extract(self.vgg, I_gt) #feature dict
fs_I_out = vgg_extract(self.vgg, I_out) #feature dict
fs_I_comp = vgg_extract(self.vgg, I_comp) #feature dict
opt_model = self.get_optimizer('model')
L_valid = F.mean_absolute_error(M * I_out, M * I_gt)
L_hole = F.mean_absolute_error((1 - M) * I_out, (1 - M) * I_gt)
L_perceptual = calc_loss_perceptual(fs_I_gt, fs_I_out, fs_I_comp)
L_style = calc_loss_style(fs_I_out, fs_I_comp,
fs_I_gt) #Loss style out and comp
L_tv = calc_loss_tv(I_comp, M, xp=xp)
L_total = L_valid + self._lambda1 * L_hole + self._lambda2 * L_perceptual + \
self._lambda3 * L_style + self._lambda4 * L_tv
self.vgg.cleargrads()
self.model.cleargrads()
L_total.backward()
opt_model.update()
chainer.report({'L_valid': L_valid})
chainer.report({'L_hole': L_hole})
chainer.report({'L_perceptual': L_perceptual})
chainer.report({'L_style': L_style})
chainer.report({'L_tv': L_tv})
def get_loss(self, perm, vgg, target, dis=None, layers=[]):
xp = self.xp
target_ = target[perm]
x, z = self(perm, return_z=True)
losses = []
# x = x.array if hinge and x is None else x # when only update classifier
loss = F.mean_absolute_error(x, target_)
losses.append(backward(loss / loss.array))
# x_resize = x if x.shape[2] == 256 else F.unpooling_2d(x, 2, 2, 0, outsize=(256, 256))
# target_resize = target_ if target_.shape[2] == 256 else F.unpooling_2d(target, 2, 2, 0, outsize=(256, 256))
if vgg is not None:
with chainer.using_config('train', False), chainer.using_config(
'enable_backprop', False):
mean = xp.array([103.939, 116.779, 123.68],
dtype="float32")[None, :, None, None]
target_features = vgg((target_ + 1) * 127.5 - mean,
layers=layers)
mean = xp.array([103.939, 116.779, 123.68],
dtype="float32")[None, :, None, None]
vgg_features = vgg((x + 1) * 127.5 - mean, layers=layers)
for layer in layers:
if layer in ["conv1_1", "conv1_2", "conv2_1", "conv2_2"]:
if self.config.perceptual_type == "l1":
loss = F.mean_absolute_error(target_features[layer],
vgg_features[layer])
elif self.config.perceptual_type == "l2":
loss = F.mean_squared_error(target_features[layer],
vgg_features[layer])
l_per = 1 / loss.array / 10 if self.l_per < 0 or self.l_per > 1000 else self.l_per
losses.append(backward(loss * l_per))
else:
if self.config.perceptual_type == "l1":
loss = F.mean_absolute_error(target_features[layer],
vgg_features[layer])
elif self.config.perceptual_type == "l2":
loss = F.mean_squared_error(target_features[layer],
vgg_features[layer])
l_per = 1 / loss.array / 10 if self.l_per < 0 or self.l_per > 1000 else self.l_per
losses.append(backward(loss * l_per))
chainer.reporter.report({f'loss_{layer}': loss})
# loss += F.mean(F.square(z)) * self.lam
if self.l_emd > 0:
losses.append(backward(self.EMD(self.z.W[perm]) * self.l_emd))
if self.l_re > 0:
losses.append(backward(self.l1_reg() * self.l_re))
if self.l_patch_dis > 0:
losses.append(backward(
self.patch_loss_gen(dis) * self.l_patch_dis))
if self.l_gp > 0:
losses.append(backward(self.gp_loss(x, z) * self.l_gp))
return x, losses
def get_loss(self, perm, vgg, target, dis=None, layers=[]):
xp = self.xp
target_ = target[perm]
x, z = self(perm, return_z=True)
losses = []
loss = F.mean_absolute_error(x, target_)
if self.config.normalize_l1_loss:
losses.append(backward(loss / loss.array))
else:
losses.append(backward(loss))
if vgg is not None:
with chainer.using_config('train', False), chainer.using_config(
'enable_backprop', False):
mean = xp.array([103.939, 116.779, 123.68],
dtype="float32")[None, :, None, None]
target_features = vgg((target_ + 1) * 127.5 - mean,
layers=layers)
mean = xp.array([103.939, 116.779, 123.68],
dtype="float32")[None, :, None, None]
vgg_features = vgg((x + 1) * 127.5 - mean, layers=layers)
for layer in layers:
if layer in ["conv1_1", "conv1_2", "conv2_1", "conv2_2"]:
if self.config.perceptual_type == "l1":
loss = F.mean_absolute_error(target_features[layer],
vgg_features[layer])
elif self.config.perceptual_type == "l2":
loss = F.mean_squared_error(target_features[layer],
vgg_features[layer])
l_per = 1 / loss.array / 10 if self.l_per < 0 or self.l_per > 1000 else self.l_per
losses.append(backward(loss * l_per))
else:
if self.config.perceptual_type == "l1":
loss = F.mean_absolute_error(target_features[layer],
vgg_features[layer])
elif self.config.perceptual_type == "l2":
loss = F.mean_squared_error(target_features[layer],
vgg_features[layer])
l_per = 1 / loss.array / 10 if self.l_per < 0 or self.l_per > 1000 else self.l_per
losses.append(backward(loss * l_per))
chainer.reporter.report({f'loss_{layer}': loss})
if self.l_emd > 0:
losses.append(backward(self.EMD(self.z.W[perm]) * self.l_emd))
if self.l_re > 0:
losses.append(backward(self.l1_reg() * self.l_re))
if self.l_patch_dis > 0:
losses.append(backward(
self.patch_loss_gen(dis) * self.l_patch_dis))
if self.l_gp > 0:
losses.append(backward(self.gp_loss(x, z) * self.l_gp))
return x, losses
def calc_loss_perceptual(hout_dict,hcomp_dict,hgt_dict):
layers = list(hout_dict.keys())
layer_name = layers[0]
loss = F.mean_absolute_error(hout_dict[layer_name],hgt_dict[layer_name])
loss += F.mean_absolute_error(hout_dict[layer_name],hgt_dict[layer_name])
for layer_name in layers[1:]:
loss += F.mean_absolute_error(hcomp_dict[layer_name],hgt_dict[layer_name])
loss += F.mean_absolute_error(hcomp_dict[layer_name],hgt_dict[layer_name])
return loss
def loss_cnn(self, cnn, x_out, t_out, y_out, lam1=1, lam2=1,lam3=10):
loss_rec = lam1*(F.mean_absolute_error(x_out, t_out))
loss_adv = lam2*y_out
l_t,e_t = self.l.calc((t_out-128)/128)
l_x,e_x = self.l.calc((x_out-128)/128)
loss_l = lam3*(F.mean_absolute_error(l_x,l_t))
loss = loss_rec + loss_adv + loss_l
chainer.report({'loss': loss,"loss_rec":loss_rec, 'loss_adv': loss_adv, "loss_l": loss_l }, cnn)
return loss
def gen_loss(self, discriminator, y_convert, y_recon, s, c, si, ci):
fake_convert_feat, fake_convert = discriminator(y_convert, si)
fake_recon_feat, fake_recon = discriminator(y_recon, ci)
real_feat_c, _ = discriminator(c, ci)
real_feat_s, _ = discriminator(s, si)
adv_loss = (self.gen_hinge_loss(fake_convert) +
self.gen_hinge_loss(fake_recon)) * 0.5
recon_loss = F.mean_absolute_error(c, y_recon)
fm_loss = F.mean_absolute_error(fake_convert_feat, real_feat_s)
fm_loss += F.mean_absolute_error(fake_recon_feat, real_feat_c)
return (adv_loss, recon_loss, fm_loss)
def learning_consist(gen_BtoA, gen_AtoB, optgen_BtoA, optgen_AtoB, data, T=5):
a = 10
for time in range(T):
optgen_BtoA.target.cleargrads()
optgen_AtoB.target.cleargrads()
ytemp1 = gen_BtoA(data[1])
ytemp2 = gen_AtoB(data[0])
loss_train = 0.5*a*F.mean_absolute_error(ytemp1,data[1])\
+ 0.5*a*F.mean_absolute_error(ytemp2,data[0])
loss_train.backward()
result = loss_train.data
optgen_BtoA.update()
optgen_AtoB.update()
def calc_loss_tv(Icomp, mask, xp=np):
canvas = mask.data
canvas[:, :, :, :-1] += mask.data[:, :, :, 1:] #mask left overlap
canvas[:, :, :, 1:] += mask.data[:, :, :, :-1] #mask right overlap
canvas[:, :, :-1, :] += mask.data[:, :, 1:, :] #mask up overlap
canvas[:, :, 1:, :] += mask.data[:, :, :-1, :] #mask bottom overlap
P = Variable((xp.sign(canvas - 0.5) + 1.0) *
0.5) #P region (hole mask: 1 pixel dilated region from hole)
return F.mean_absolute_error(
P[:, :, :, 1:] * Icomp[:, :, :, 1:],
P[:, :, :, :-1] * Icomp[:, :, :, :-1]) + F.mean_absolute_error(
P[:, :, 1:, :] * Icomp[:, :, 1:, :],
P[:, :, :-1, :] * Icomp[:, :, :-1, :])
def backward_EG(self, fake_data_encoded, fake_data_random, fake_B_encoded,
real_B_encoded, D, D2, lambda_GAN, lambda_GAN2, mu,
logvar):
lambda_kl = 0.01
lambda_L1 = 10.0
# 1, G(A) should fool D
loss_G_GAN = self.loss_G_GAN(fake_data_encoded, D, lambda_GAN)
loss_G_GAN2 = self.loss_G_GAN(fake_data_random, D2, lambda_GAN2)
# 2. KL loss
if lambda_kl > 0:
kl_element = (((mu**2) + F.exp(logvar)) * -1) + 1 + logvar
loss_kl = F.sum(kl_element) * -0.5 * lambda_kl
else:
loss_kl = 0
# 3, reconstruction |fake_B-real_B|
if lambda_L1 > 0:
loss_G_L1 = F.mean_absolute_error(fake_B_encoded, real_B_encoded)
loss_G_L1 = lambda_L1 * loss_G_L1
else:
loss_G_L1 = 0
loss_G = loss_G_GAN + loss_G_GAN2 + loss_G_L1 + loss_kl
loss_G.backward() # Not unchain_backward for backward_G_alone
chainer.report({
'loss_G_GAN': loss_G_GAN,
'loss_G_GAN2': loss_G_GAN2,
'loss_G_L1': loss_G_L1,
'loss_kl': loss_kl,
'loss_G': loss_G,
})
def calc_loss(self, x, t):
# h = self.encode_model.feature(x)
# print('encode_model_space', h)
xp = backend.get_array_module(x)
VAE_LOSS_SCALE = 1e-5
JOINT_LOSS_WEIGHTS = xp.linspace(10, 1, t.shape[1])
# print(JOINT_LOSS_WEIGHTS)
# action model output
output, z_mu, z_ln_var = self.forward_with_z(x)
# print(t.shape, output.shape, z_mu.shape, z_ln_var.shape)
# MAR of action model
self.mean_abs_error = F.mean_absolute_error(t, output)
self.weighted_joint_error = F.mean(F.squared_error(t, output) * JOINT_LOSS_WEIGHTS)
self.gnll = self.action.negative_log_likelihood(F.concat((z_mu, z_ln_var)), t)
# VAE loss
self.vae_loss_rec, self.vae_loss_kl = self.VAE_loss_func()(self, x, z_mu, z_ln_var, split=True)
self.vae_loss = VAE_LOSS_SCALE * (self.vae_loss_rec + self.vae_loss_kl)
# Total loss
self.total_loss = self.weighted_joint_error + \
self.vae_loss + self.gnll
chainer.report({'mae': self.mean_abs_error}, self)
chainer.report({'gnll': self.gnll}, self)
chainer.report({'weighted': self.weighted_joint_error}, self)
chainer.report({'VAE': self.vae_loss}, self)
chainer.report({'VAE_KL': self.vae_loss_kl}, self)
chainer.report({'VAE_REC': self.vae_loss_rec}, self)
chainer.report({'loss': self.total_loss}, self)
return self.total_loss
def learn(self, batch_state_int, batch_action, batch_reward, batch_done, batch_next_state_int):
batch_state_int, batch_action, batch_reward, batch_done, batch_next_state_int = to_device(
self.network._device_id,
(batch_state_int, batch_action, batch_reward, batch_done, batch_next_state_int))
batch_state = batch_state_int.astype(np.float32) / 255 # [0, 255] -> [0.0, 1.0]
batch_next_state = batch_next_state_int.astype(np.float32) / 255 # [0, 255] -> [0.0, 1.0]
batch_y, batch_q = self._compute_q_y(batch_state, batch_action, batch_reward, batch_done, batch_next_state)
# assert len(batch_q.shape) == 1
# assert len(batch_y.shape) == 1
# assert batch_q.shape[0] == batch_y.shape[0]
# loss = F.mean(F.huber_loss(batch_q, batch_y, delta=1.0, reduce='no'))
loss = F.sum(F.huber_loss(batch_q, batch_y, delta=1.0, reduce='no'))
with chainer.no_backprop_mode():
td_error = F.mean_absolute_error(batch_q, batch_y)
self.network.cleargrads()
loss.backward()
self.optimizer.update()
loss_cpu = to_device(CPU_ID, loss.array)
td_error_cpu = to_device(CPU_ID, td_error.array)
return loss_cpu, td_error_cpu
def update_core(self):
iterator = self.get_iterator('main') # type: Iterator
g_opt = self.get_optimizer('gen') # type: chainer.Optimizer
d_opt = self.get_optimizer('dis') # type: chainer.Optimizer
batch = iterator.next()
batch_size = len(batch)
x1, x2 = self.converter(batch, self.device)
generated = self.gen(x1)
dis_real = self.dis(x1, x2)
dis_fake = self.dis(x1, generated)
g_loss = F.sum(F.softplus(
-dis_fake)) / dis_fake.size + self.lambda_ * F.mean_absolute_error(
generated, x2)
reporter.report({'loss': g_loss}, self.gen)
self.gen.cleargrads()
g_loss.backward()
g_opt.update()
del g_loss
d_loss = F.sum(F.softplus(-dis_real)) / dis_real.size + F.sum(
F.softplus(dis_fake)) / dis_fake.size
reporter.report({'loss': d_loss}, self.dis)
self.dis.cleargrads()
d_loss.backward()
d_opt.update()
del d_loss, dis_fake, dis_real, x1, x2, batch, generated
def pixel_wise_loss(self, x, y):
if self.loss_norm == 1:
return F.mean_absolute_error(x, y)
elif self.loss_norm == 2:
return F.mean_squared_error(x, y)
else:
raise ValueError('Invalid norm {}'.format(self.loss_norm))
def check_fp16_overflow(self, xp):
x0 = chainer.Variable(
xp.full(shape=(64, 1, 16, 16), fill_value=2, dtype=xp.float16))
x1 = chainer.Variable(
xp.full(shape=(64, 1, 16, 16), fill_value=-2, dtype=xp.float16))
loss = functions.mean_absolute_error(x0, x1)
self.assertFalse(xp.isinf(loss.array))
def total_loss_gen(self, dis_fake, x_fake, y_real, lat=None):
"""
Function to compute the total loss of the generator.
"""
# # adversarial loss for generator.
lgen = self.loss_gen(dis_fake=dis_fake)
chainer.reporter.report({'lgen_adv': lgen.array})
loss = lgen + 0
# # loop over the additional loss types.
for lt in self.add_loss_gen:
if lt == 'l1':
# # L1 loss.
#print(y_real.array.max(), x_fake.array.max(), x_fake.array.mean())
loss_l1 = F.mean_absolute_error(y_real, x_fake)
chainer.reporter.report({'loss_l1': loss_l1.array})
loss += self.l1_weight * loss_l1
elif lt == 'decovl':
# # decov loss.
loss_decov = losses.decov_loss(lat)
chainer.reporter.report({'ldecov': loss_decov.array})
loss += self.decovl_weight * loss_decov
else:
m1 = 'Not recognized loss type ({}).'
raise RuntimeError(m1.format(lt))
return loss
def loss_gen(d_fake_result, fake_image, correct_image, lamda):
batchsize, ch, w, h = d_fake_result.data.shape
adversarial_loss = F.mean_squared_error(
d_fake_result,
Variable(xp.ones((batchsize, ch, w, h), dtype=xp.float32)))
consistency_loss = F.mean_absolute_error(correct_image, fake_image)
return adversarial_loss + lamda * consistency_loss
def __call__(self, *args):
"""Computes the loss value for an input and label pair.
It also computes accuracy and stores it to the attribute.
Args:
x: batch of sample data points
t: bath of ground truth points.
It feeds features to the predictor and compare the result with ground truth.
Returns:
~chainer.Variable: Loss value.
"""
self.y = self.predictor(*args[:-1]) # The last argument is the targets (ground truths)
t = args[-1]
if self.last_relu:
self.y = F.relu(self.y)
mae = F.mean_absolute_error(self.y, t)
mse = F.mean_squared_error(self.y, t)
mrae = self.mrae(self.y, t)
self.loss = self.loss_coeffs[0] * mae + self.loss_coeffs[1] * mse \
+ self.loss_coeffs[2] * mrae
if self.calc_sid:
sid = self.sid(F.relu(self.y), t)
if self.loss_coeffs[3] != 0:
self.loss += self.loss_coeffs[3] * sid
else:
sid = -1 # flag of no calculation
reporter.report({'MSE': mse, 'MAE': mae, 'MRAE': mrae, 'SID': sid, 'loss': self.loss}, self)
return self.loss
def __call__(self, input_array, dists, pairs_index, targets):
out = self.predict(input_array, dists, pairs_index)
loss = F.mean_absolute_error(
out, np.concatenate([targets, targets], axis=0))
reporter.report({'loss': loss}, self)
return loss
def update_core(self):
# read data
batch = self._iterators['main'].next()
x, x_real, char = self.converter(batch, self.device)
iteration = self.iteration
# forward
x_fake = self.generator(x, char)
y_real = self.discriminator(x_real)
y_fake = self.discriminator(x_fake)
h_real = self.generator.encode(x_real)
h_fake = self.generator.encode(x_fake)
# compute loss
loss_recon = F.mean_absolute_error(x_real, x_fake)
# update
self.generator.cleargrads()
loss_recon.backward()
self._optimizers['generator'].update()
# report
chainer.reporter.report({'loss/recon': loss_recon})
def calc_loss(fake,real):
loss = 0
for f,r in zip(fake,real):
_,c,h,w=f.shape
loss+=F.mean_absolute_error(f,r) / (c*h*w)
return loss
def __call__(self, x):
f = self.extract(x)
x_recon = self.reconstruct(f)
loss = F.mean_absolute_error(F.scale(
x, self.mask), F.scale(x_recon, self.mask)) * self.loss_const
report({'loss': loss}, self)
return loss
def loss_dec(self, dec, x_out, t_out, y_out, lam1=100, lam2=1):
batchsize, _, w, h = y_out.data.shape
loss_rec = lam1*(F.mean_absolute_error(x_out, t_out))
loss_adv = lam2*F.sum(F.softplus(-y_out)) / batchsize / w / h
loss = loss_rec + loss_adv
chainer.report({'loss': loss}, dec)
return loss
def gen_loss(discriminator, y_fake, x_fake, x, y_label):
fake = discriminator(y_fake, y_label)
loss = F.mean(F.softplus(-fake))
loss += 10 * F.mean_absolute_error(x_fake, x)
return loss
def _loss_predictor_cg(predictor, reconstruct, output, target, d_fake,
loss_config: LossConfig):
b, _, t = d_fake.data.shape
loss_mse = (F.mean_absolute_error(reconstruct, target))
chainer.report({'mse': loss_mse}, predictor)
loss_identity = (F.mean_absolute_error(output, target))
chainer.report({'identity': loss_identity}, predictor)
loss_adv = F.sum(F.softplus(-d_fake)) / (b * t)
chainer.report({'adversarial': loss_adv}, predictor)
loss = loss_config.mse * loss_mse + loss_config.mse / 100 * loss_identity + loss_config.adversarial * loss_adv
chainer.report({'loss': loss}, predictor)
return loss
def loss_enc(self, enc, x_out, t_out, lam1=100, lam2=1):
# batchsize,_,w,h = y_out.data.shape
loss_rec = lam1 * (F.mean_absolute_error(x_out, t_out))
# loss_adv = lam2*F.sum(F.softplus(-y_out)) / batchsize / w / h # これ何だろう
loss = loss_rec # + loss_adv
chainer.report({'loss': loss}, enc)
return loss
def fit(self, X, Y, epochs=30):
self.X = X
self.Y = Y
self.epochs = epochs
o_resnet = optimizers.Adam(alpha=1e-5, beta1=0.1)
o_resnet.setup(self.tgs)
self.loss = []
for epoch in range(1, epochs + 1):
sum_loss = np.float32(0)
for i in range(10):
l = len(X)
image = X[i:i * l:]
mask = Y[i:i * l:]
output = self.ResNet(image, mask)
loss = F.mean_absolute_error(mask, output)
self.ResNet.cleargrads()
loss.backward()
o_resnet.update()
sum_loss += loss.data
print('epoch:', epoch, 'loss:', loss, 'sum_loss_2:', sum_loss)
self.loss.append(sum_loss)
print(self.loss)
def __call__(self, x, t):
y = self.predictor(x)
#print("y_shape:", y.shape)
#print("t_shape:", t.shape)
#loss = F.softmax_cross_entropy(y, t)
loss = F.mean_absolute_error(y, t.astype(np.float32))
chainer.report({'loss': loss}, self)
return loss
def test_backward_non_default_gpu(self):
x0 = chainer.Variable(cuda.to_gpu(self.x0, 1))
x1 = chainer.Variable(cuda.to_gpu(self.x1, 1))
gy = cuda.to_gpu(self.gy, 1)
with cuda.get_device_from_id(0):
y = functions.mean_absolute_error(x0, x1)
y.grad = gy
y.backward()
def _loss_predictor(self, predictor, output, target, d_fake):
b, _, t = d_fake.data.shape
loss_mse = (F.mean_absolute_error(output, target))
chainer.report({'mse': loss_mse}, predictor)
loss_adv = F.sum(F.softplus(-d_fake)) / (b * t)
chainer.report({'adversarial': loss_adv}, predictor)
loss = self.loss_config.mse * loss_mse + self.loss_config.adversarial * loss_adv
chainer.report({'loss': loss}, predictor)
return loss
def check_forward(self, x0_data, x1_data):
x0 = chainer.Variable(x0_data)
x1 = chainer.Variable(x1_data)
loss = functions.mean_absolute_error(x0, x1)
loss_value = cuda.to_cpu(loss.data)
self.assertEqual(loss_value.dtype, numpy.float32)
self.assertEqual(loss_value.shape, ())
# Compute expected value
loss_expect = 0.
for i in numpy.ndindex(self.x0.shape):
loss_expect += abs(self.x0[i] - self.x1[i])
loss_expect /= self.x0.size
self.assertAlmostEqual(loss_expect, loss_value, places=5)
def check_forward(self, x0_data, x1_data):
x0 = chainer.Variable(x0_data)
x1 = chainer.Variable(x1_data)
loss = functions.mean_absolute_error(x0, x1)
loss_value = cuda.to_cpu(loss.data)
assert loss_value.dtype == numpy.float32
assert loss_value.shape == ()
# Compute expected value
loss_expect = 0.
for i in numpy.ndindex(self.x0.shape):
loss_expect += abs(self.x0[i] - self.x1[i])
loss_expect /= self.x0.size
assert round(loss_expect - loss_value, 5) == 0
def __call__(self, x0, x1):
if self.scaler is not None:
x0 = self.scaler.inverse_transform(x0)
x1 = self.scaler.inverse_transform(x1)
return F.mean_absolute_error(x0, x1)
def __call__(self, x_recon, x):
bs = x.shape[0]
d = np.prod(x.shape[1:])
self.loss = F.mean_absolute_error(x_recon, x) / d
return self.loss
def __call__(self, X, Y):
O = self.unet(X)
self.loss = F.mean_absolute_error(X*O, Y)
return self.loss
def forward(self, inputs, device):
x0, x1 = inputs
loss = functions.mean_absolute_error(x0, x1)
return loss,
