def __call__(self, *args):
x = args[:-1]
t = args[-1]
self.y = None
self.loss = None
self.accuracy = None
self.y = self.predictor(*x)
self.loss = F.softmax_cross_entropy(self.y, t)
if self.stored_variable_list is not None and \
self.fisher_list is not None: # i.e. Stored
for i in range(len(self.variable_list)):
self.loss += self.lam/2. * F.sum(
self.fisher_list[i] *
F.square(self.variable_list[i][1] -
self.stored_variable_list[i]))
reporter.report({'loss': self.loss}, self)
if self.compute_accuracy:
self.accuracy = F.accuracy(self.y, t)
reporter.report({'accuracy': self.accuracy}, self)
return self.loss
python类square()的实例源码
def compute_fisher(self, dataset):
fisher_accum_list = [
np.zeros(var[1].shape) for var in self.variable_list]
for _ in range(self.num_samples):
x, _ = dataset[np.random.randint(len(dataset))]
y = self.predictor(np.array([x]))
prob_list = F.softmax(y)[0].data
class_index = np.random.choice(len(prob_list), p=prob_list)
loss = F.log_softmax(y)[0, class_index]
self.cleargrads()
loss.backward()
for i in range(len(self.variable_list)):
fisher_accum_list[i] += np.square(
self.variable_list[i][1].grad)
self.fisher_list = [
F_accum / self.num_samples for F_accum in fisher_accum_list]
return self.fisher_list
def _lossfun(self,
distribs, vs_pred, log_probs,
vs_pred_old, target_log_probs,
advs, vs_teacher):
prob_ratio = F.exp(log_probs - target_log_probs)
ent = distribs.entropy
prob_ratio = F.expand_dims(prob_ratio, axis=-1)
loss_policy = - F.mean(F.minimum(
prob_ratio * advs,
F.clip(prob_ratio, 1-self.clip_eps, 1+self.clip_eps) * advs))
if self.clip_eps_vf is None:
loss_value_func = F.mean_squared_error(vs_pred, vs_teacher)
else:
loss_value_func = F.mean(F.maximum(
F.square(vs_pred - vs_teacher),
F.square(_elementwise_clip(vs_pred,
vs_pred_old - self.clip_eps_vf,
vs_pred_old + self.clip_eps_vf)
- vs_teacher)
))
loss_entropy = -F.mean(ent)
# Update stats
self.average_loss_policy += (
(1 - self.average_loss_decay) *
(cuda.to_cpu(loss_policy.data) - self.average_loss_policy))
self.average_loss_value_func += (
(1 - self.average_loss_decay) *
(cuda.to_cpu(loss_value_func.data) - self.average_loss_value_func))
self.average_loss_entropy += (
(1 - self.average_loss_decay) *
(cuda.to_cpu(loss_entropy.data) - self.average_loss_entropy))
return (
loss_policy
+ self.value_func_coef * loss_value_func
+ self.entropy_coef * loss_entropy
)
def compute_weighted_value_loss(y, t, weights,
clip_delta=True, batch_accumulator='mean'):
"""Compute a loss for value prediction problem.
Args:
y (Variable or ndarray): Predicted values.
t (Variable or ndarray): Target values.
weights (ndarray): Weights for y, t.
clip_delta (bool): Use the Huber loss function if set True.
batch_accumulator (str): 'mean' will devide loss by batchsize
Returns:
(Variable) scalar loss
"""
assert batch_accumulator in ('mean', 'sum')
y = F.reshape(y, (-1, 1))
t = F.reshape(t, (-1, 1))
if clip_delta:
losses = F.huber_loss(y, t, delta=1.0)
else:
losses = F.square(y - t) / 2
losses = F.reshape(losses, (-1,))
loss_sum = F.sum(losses * weights)
if batch_accumulator == 'mean':
loss = loss_sum / y.shape[0]
elif batch_accumulator == 'sum':
loss = loss_sum
return loss
def _smooth_l1_loss(x, t, in_weight, sigma):
sigma2 = sigma ** 2
diff = in_weight * (x - t)
abs_diff = F.absolute(diff)
flag = (abs_diff.array < (1. / sigma2)).astype(np.float32)
y = (flag * (sigma2 / 2.) * F.square(diff) +
(1 - flag) * (abs_diff - 0.5 / sigma2))
return F.sum(y)
def house_transform(self,z):
vec_t = self.qh_vec_0
for i in range(self.num_trans):
vec_t = F.identity(self.qlin_h_vec_t(vec_t))
vec_t_product = F.matmul(vec_t, vec_t, transb=True)
vec_t_norm_sqr = F.tile(F.sum(F.square(vec_t)), (z.shape[0], z.shape[1]))
z = z - 2*F.matmul(vec_t_product, z)/vec_t_norm_sqr
return z
def house_transform(self,z):
vec_t = self.qh_vec_0
for i in range(self.num_trans):
vec_t = F.identity(self.qlin_h_vec_t(vec_t))
vec_t_product = F.matmul(vec_t, vec_t, transb=True)
vec_t_norm_sqr = F.tile(F.sum(F.square(vec_t)), (z.shape[0], z.shape[1]))
z = z - 2*F.matmul(vec_t_product, z)/vec_t_norm_sqr
return z
def house_transform(self,z):
vec_t = self.qh_vec_0
for i in range(self.num_trans):
vec_t = F.identity(self.qlin_h_vec_t(vec_t))
vec_t_product = F.matmul(vec_t, vec_t, transb=True)
vec_t_norm_sqr = F.tile(F.sum(F.square(vec_t)), (z.shape[0], z.shape[1]))
z = z - 2*F.matmul(vec_t_product, z)/vec_t_norm_sqr
return z
def _smooth_l1_loss(x, t, in_weight, sigma):
sigma2 = sigma ** 2
diff = in_weight * (x - t)
abs_diff = F.absolute(diff)
flag = (abs_diff.array < (1. / sigma2)).astype(np.float32)
y = (flag * (sigma2 / 2.) * F.square(diff) +
(1 - flag) * (abs_diff - 0.5 / sigma2))
return F.sum(y)
def average_loss(self, h, a, t):
## print F.reshape(t, (-1, 1)).data
## print (h-F.reshape(t, (-1, 1))).data
self.loss = F.sum(abs(h - F.reshape(t, (-1,1))))
## self.loss = F.sqrt(F.sum(F.square(h - F.reshape(t, (-1,1)))))
self.loss /= self.n_patches
if self.n_images > 1:
h = F.split_axis(h, self.n_images, 0)
a = F.split_axis(a, self.n_images, 0)
else:
h, a = [h], [a]
self.y = h
self.a = a