def calc_loss(self, src, db_idx, src_mask=None, trg_mask=None):
src_embeddings = self.src_embedder.embed_sent(src, mask=src_mask)
self.src_encoder.set_input(src)
src_encodings = self.exprseq_pooling(self.src_encoder.transduce(src_embeddings))
trg_batch, trg_mask = self.database[db_idx]
# print("trg_mask=\n",trg_mask)
trg_encodings = self.encode_trg_example(trg_batch, mask=trg_mask)
dim = trg_encodings.dim()
trg_reshaped = dy.reshape(trg_encodings, (dim[0][0], dim[1]))
# ### DEBUG
# trg_npv = trg_reshaped.npvalue()
# for i in range(dim[1]):
# print("--- trg_reshaped {}: {}".format(i,list(trg_npv[:,i])))
# ### DEBUG
prod = dy.transpose(src_encodings) * trg_reshaped
# ### DEBUG
# prod_npv = prod.npvalue()
# for i in range(dim[1]):
# print("--- prod {}: {}".format(i,list(prod_npv[0].transpose()[i])))
# ### DEBUG
id_range = list(range(len(db_idx)))
# This is ugly:
if self.loss_direction == "forward":
prod = dy.transpose(prod)
loss = dy.sum_batches(dy.hinge_batch(prod, id_range))
elif self.loss_direction == "bidirectional":
prod = dy.reshape(prod, (len(db_idx), len(db_idx)))
loss = dy.sum_elems(
dy.hinge_dim(prod, id_range, d=0) + dy.hinge_dim(prod, id_range, d=1))
else:
raise RuntimeError("Illegal loss direction {}".format(self.loss_direction))
return loss
def calc_loss(sents):
dy.renew_cg()
src_fwd = LSTM_SRC_FWD.initial_state()
src_bwd = LSTM_SRC_BWD.initial_state()
trg_fwd = LSTM_TRG_FWD.initial_state()
trg_bwd = LSTM_TRG_BWD.initial_state()
# Encoding
src_reps = encode_sents(LOOKUP_SRC, src_fwd, src_bwd,
[src for src, trg in sents])
trg_reps = encode_sents(LOOKUP_TRG, trg_fwd, trg_bwd,
[trg for src, trg in sents])
# Concatenate the sentence representations to a single matrix
mtx_src = dy.concatenate_cols(src_reps)
mtx_trg = dy.concatenate_cols(trg_reps)
# Do matrix multiplication to get a matrix of dot product similarity scores
sim_mtx = dy.transpose(mtx_src) * mtx_trg
# Calculate the hinge loss over all dimensions
loss = dy.hinge_dim(sim_mtx, list(range(len(sents))), d=1)
return dy.sum_elems(loss)
def calculate_loss(self, words):
dy.renew_cg()
source_embs = [[self.get_embedding(x, SRC) for x in s] for s, t in words]
target_embs = [[self.get_embedding(y, TGT) for y in t] for s, t in words]
source_reps_norm = self.get_normalized_reps(source_embs, self.source_lstm_forward, self.source_lstm_backward)
target_reps_norm = self.get_normalized_reps(target_embs, self.target_lstm_forward, self.target_lstm_backward)
mtx_src = dy.concatenate_cols(source_reps_norm)
mtx_trg = dy.concatenate_cols(target_reps_norm)
similarity_mtx = dy.transpose(mtx_src) * mtx_trg
loss = dy.hinge_dim(similarity_mtx, list(range(len(words))), d=1)
return dy.sum_elems(loss)/(len(words)*len(words))
def calc_loss(sents):
dy.renew_cg()
# Transduce all batch elements with an LSTM
sent_reps = [(LSTM_SRC.transduce([LOOKUP_SRC[x] for x in src])[-1],
LSTM_TRG.transduce([LOOKUP_TRG[y] for y in trg])[-1]) for src, trg in sents]
# Concatenate the sentence representations to a single matrix
mtx_src = dy.concatenate_cols([src for src, trg in sent_reps])
mtx_trg = dy.concatenate_cols([trg for src, trg in sent_reps])
# Do matrix multiplication to get a matrix of dot product similarity scores
sim_mtx = dy.transpose(mtx_src) * mtx_trg
# Calculate the hinge loss over all dimensions
loss = dy.hinge_dim(sim_mtx, list(range(len(sents))), d=1)
return dy.sum_elems(loss)
def calc_loss(sents):
dy.renew_cg()
src_fwd = LSTM_SRC_FWD.initial_state()
src_bwd = LSTM_SRC_BWD.initial_state()
trg_fwd = LSTM_TRG_FWD.initial_state()
trg_bwd = LSTM_TRG_BWD.initial_state()
# Encoding
src_reps = encode_sents(LOOKUP_SRC, src_fwd, src_bwd, [src for src, trg in sents])
trg_reps = encode_sents(LOOKUP_TRG, trg_fwd, trg_bwd, [trg for src, trg in sents])
# Concatenate the sentence representations to a single matrix
mtx_src = dy.concatenate_cols(src_reps)
mtx_trg = dy.concatenate_cols(trg_reps)
# Do matrix multiplication to get a matrix of dot product similarity scores
sim_mtx = dy.transpose(mtx_src) * mtx_trg
# Calculate the hinge loss over all dimensions
loss = dy.hinge_dim(sim_mtx, list(range(len(sents))), d=1)
return dy.sum_elems(loss)
