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)