def calc_loss(self, mlp_dec_state, ref_action):
"""
Label Smoothing is implemented with reference to Section 7 of the paper
"Rethinking the Inception Architecture for Computer Vision"
(https://arxiv.org/pdf/1512.00567.pdf)
"""
scores = self.get_scores(mlp_dec_state)
if self.label_smoothing == 0.0:
# single mode
if not xnmt.batcher.is_batched(ref_action):
return dy.pickneglogsoftmax(scores, ref_action)
# minibatch mode
else:
return dy.pickneglogsoftmax_batch(scores, ref_action)
else:
log_prob = dy.log_softmax(scores)
if not xnmt.batcher.is_batched(ref_action):
pre_loss = -dy.pick(log_prob, ref_action)
else:
pre_loss = -dy.pick_batch(log_prob, ref_action)
ls_loss = -dy.mean_elems(log_prob)
loss = ((1 - self.label_smoothing) *
pre_loss) + (self.label_smoothing * ls_loss)
return loss
def calc_loss(
self, x: dy.Expression,
y: Union[numbers.Integral,
List[numbers.Integral]]) -> dy.Expression:
scores = self.calc_scores(x)
if self.label_smoothing == 0.0:
# single mode
if not batchers.is_batched(y):
loss = dy.pickneglogsoftmax(scores, y)
# minibatch mode
else:
loss = dy.pickneglogsoftmax_batch(scores, y)
else:
log_prob = dy.log_softmax(scores)
if not batchers.is_batched(y):
pre_loss = -dy.pick(log_prob, y)
else:
pre_loss = -dy.pick_batch(log_prob, y)
ls_loss = -dy.mean_elems(log_prob)
loss = ((1 - self.label_smoothing) *
pre_loss) + (self.label_smoothing * ls_loss)
return loss
def cross_entropy_loss(self, scores, next_words):
if self.label_smoothing:
log_softmax = dy.log_softmax(scores)
return -dy.pick_batch(log_softmax, next_words) * (1 - self.label_smoothing) \
- dy.mean_elems(log_softmax) * self.label_smoothing
else:
return dy.pickneglogsoftmax_batch(scores, next_words)
def calc_loss(
self, x: dy.Expression,
y: Union[numbers.Integral,
List[numbers.Integral]]) -> dy.Expression:
if self.can_loss_be_derived_from_scores():
scores = self.calc_scores(x)
# single mode
if not batchers.is_batched(y):
loss = dy.pickneglogsoftmax(scores, y)
# minibatch mode
else:
loss = dy.pickneglogsoftmax_batch(scores, y)
else:
log_prob = self.calc_log_probs(x)
if not batchers.is_batched(y):
loss = -dy.pick(log_prob, y)
else:
loss = -dy.pick_batch(log_prob, y)
if self.label_smoothing > 0:
ls_loss = -dy.mean_elems(log_prob)
loss = ((1 - self.label_smoothing) *
loss) + (self.label_smoothing * ls_loss)
return loss
def pick_cos_prox(pred, gold):
def l2_normalize(x):
epsilon = np.finfo(float).eps * dy.ones(pred.dim()[0])
norm = dy.sqrt(dy.sum_elems(dy.square(x)))
sign = dy.cdiv(x, dy.bmax(dy.abs(x), epsilon))
return dy.cdiv(dy.cmult(sign, dy.bmax(dy.abs(x), epsilon)), dy.bmax(norm, epsilon[0]))
y_true = l2_normalize(pred)
y_pred = l2_normalize(gold)
return dy.mean_elems(dy.cmult(y_true, y_pred))
def cross_entropy_loss(self, score, next_word, cur_word): if self.__ls: log_prob = dy.log_softmax(score) if self.__lm is None: loss = - dy.pick_batch(log_prob, next_word) * (1 - self.__ls_eps) - \ dy.mean_elems(log_prob) * self.__ls_eps else: loss = - dy.pick_batch(log_prob, next_word) * (1 - self.__ls_eps) - \ dy.dot_product(self.__lm.next_expr(cur_word), log_prob) * self.__ls_eps else: loss = dy.pickneglogsoftmax(score, next_word) return loss
def GetPOSIT(self, qvecs, sims, w2v_sims, matches):
qscores = []
for qtok in range(len(qvecs)):
# Basic matches, max-sim, average-kmax-sim, exact match
svec = dy.concatenate(sims[qtok])
sim = dy.kmax_pooling(dy.transpose(svec), 1)[0]
sim5 = dy.mean_elems(dy.kmax_pooling(dy.transpose(svec), 5)[0])
wvec = dy.concatenate(w2v_sims[qtok])
wsim = dy.kmax_pooling(dy.transpose(wvec), 1)[0]
wsim5 = dy.mean_elems(dy.kmax_pooling(dy.transpose(wvec), 5)[0])
mvec = dy.concatenate(matches[qtok])
msim = dy.kmax_pooling(dy.transpose(mvec), 1)[0]
msim5 = dy.mean_elems(dy.kmax_pooling(dy.transpose(mvec), 5)[0])
layer1 = (self.W_term1.expr() *
dy.concatenate(
[sim, sim5,
wsim, wsim5,
msim, msim5
]) +
self.b_term1.expr())
qscores.append(self.W_term.expr() * utils.leaky_relu(layer1))
return qscores
def cross_entropy_loss(self, s, nw, cw):
"""Calculates the cross-entropy
"""
if self.ls:
log_prob = dy.log_softmax(s)
if self.lm is None:
loss = - dy.pick_batch(log_prob, nw) * (1 - self.ls_eps) - \
dy.mean_elems(log_prob) * self.ls_eps
else:
loss = - dy.pick_batch(log_prob, nw) * (1 - self.ls_eps) - \
dy.dot_product(self.lm_e, log_prob) * self.ls_eps
else:
loss = dy.pickneglogsoftmax_batch(s, nw)
return loss
def mean(x, dim=None, include_batch_dim=False):
if isinstance(x, list):
return dy.average(x)
head_shape, batch_size = x.dim()
if dim is None:
# warning: dynet only implement 2 or lower dims for mean_elems
x = dy.mean_elems(x)
if include_batch_dim and batch_size > 1:
return dy.mean_batches(x)
else:
return x
else:
if dim == -1:
dim = len(head_shape) - 1
return dy.mean_dim(x, d=[dim], b=include_batch_dim)
def calc_loss(self, mlp_dec_state, ref_action):
scores = self.get_scores(mlp_dec_state)
if self.label_smoothing == 0.0:
# single mode
if not xnmt.batcher.is_batched(ref_action):
return dy.pickneglogsoftmax(scores, ref_action)
# minibatch mode
else:
return dy.pickneglogsoftmax_batch(scores, ref_action)
else:
log_prob = dy.log_softmax(scores)
if not xnmt.batcher.is_batched(ref_action):
pre_loss = -dy.pick(log_prob, ref_action)
else:
pre_loss = -dy.pick_batch(log_prob, ref_action)
ls_loss = -dy.mean_elems(log_prob)
loss = ((1 - self.label_smoothing) *
pre_loss) + (self.label_smoothing * ls_loss)
return loss
def __call__(self, x):
# mean = x.mean(-1, keepdim=True)
mean = dy.mean_elems(x)
# std = x.std(-1, keepdim=True)
std = dy.std(x)
return self.a_2 * (x - mean) / (std + self.eps) + self.b_2
def mse_loss(predictions, target):
diff = predictions - target
square = dy.square(diff)
mean = dy.mean_elems(square)
return mean
def calc_loss(self, policy_reward, results={}):
"""
Calc policy networks loss.
"""
assert len(policy_reward) == len(self.states), "There should be a reward for every action taken"
batch_size = self.states[0].dim()[1]
loss = {}
# Calculate the baseline loss of the reinforce loss for each timestep:
# b = W_b * s + b_b
# R = r - b
# Also calculate the baseline loss
# b = r_p (predicted)
# loss_b = squared_distance(r_p - r_r)
rewards = []
baseline_loss = []
units = np.zeros(batch_size)
for i, state in enumerate(self.states):
r_p = self.baseline.transform(dy.nobackprop(state))
rewards.append(policy_reward[i] - r_p)
if self.valid_pos[i] is not None:
r_p = dy.pick_batch_elems(r_p, self.valid_pos[i])
r_r = dy.pick_batch_elems(policy_reward[i], self.valid_pos[i])
units[self.valid_pos[i]] += 1
else:
r_r = policy_reward[i]
units += 1
baseline_loss.append(dy.sum_batches(dy.squared_distance(r_p, r_r)))
loss["rl_baseline"] = losses.LossExpr(dy.esum(baseline_loss), units)
# Z Normalization
# R = R - mean(R) / std(R)
rewards = dy.concatenate(rewards, d=0)
r_dim = rewards.dim()
if self.z_normalization:
rewards_shape = dy.reshape(rewards, (r_dim[0][0], r_dim[1]))
rewards_mean = dy.mean_elems(rewards_shape)
rewards_std = dy.std_elems(rewards_shape) + 1e-20
rewards = (rewards - rewards_mean.value()) / rewards_std.value()
rewards = dy.nobackprop(rewards)
# Calculate Confidence Penalty
if self.confidence_penalty:
loss["rl_confpen"] = self.confidence_penalty.calc_loss(self.policy_lls)
# Calculate Reinforce Loss
# L = - sum([R-b] * pi_ll)
reinf_loss = []
units = np.zeros(batch_size)
for i, (policy, action) in enumerate(zip(self.policy_lls, self.actions)):
reward = dy.pick(rewards, i)
ll = dy.pick_batch(policy, action)
if self.valid_pos[i] is not None:
ll = dy.pick_batch_elems(ll, self.valid_pos[i])
reward = dy.pick_batch_elems(reward, self.valid_pos[i])
units[self.valid_pos[i]] += 1
else:
units += 1
reinf_loss.append(dy.sum_batches(dy.cmult(ll, reward)))
loss["rl_reinf"] = losses.LossExpr(-dy.esum(reinf_loss), units)
# Pack up + return
return losses.FactoredLossExpr(loss)
newSeason.append(newSeason[0])
newLevels.append(1 * dy.cdiv(y[0], newSeason[0]))
#perform smoothing
for i in range(1, len(df)):
newLevels.append(levelSm * dy.cdiv(y[i], newSeason[i]) +
(1 - levelSm) * newLevels[i - 1])
newSeason.append(seasonSm * dy.cdiv(y[i], newLevels[i]) +
(1 - seasonSm) * newSeason[i])
s = dy.concatenate(newSeason)
l = dy.concatenate(newLevels)
#penalize sudden level changes (should be scale independent - it is dependent)\
#should penalize 2nd derivative
l_log_diff = dy.log(dy.cdiv(l[1:], l[0:l.dim()[0][0] - 1]))
l_penalty = l_log_diff[1:] - l_log_diff[0:l_log_diff.dim()[0][0] - 1]
level_loss = dy.mean_elems(dy.square(l_penalty)) * 10
print(level_loss.value())
preds = []
outputs = []
#wez y i usun sezonowosc i level
for i in range(n, len(df) - h):
inputs = y[i - n:i] #n okresy
curr_season = s[i - n:i]
inputs = dy.cdiv(inputs, l[i])
inputs = dy.cdiv(inputs, curr_season)
inputs = dy.log(inputs)
reseasonalize = s[i + 1] #poprzedni okres +1 krok
preds.append(dy.exp(fcstr(inputs)) * l[i] * reseasonalize)
outputs.append(y[i + 1]) #+1 krok