Esempio n. 1
0
    def update(self, batch, eval=False):
        inputs, orig_idx = unpack_batch(batch, self.use_cuda)
        src, src_mask, tgt_in, tgt_out, pos, edits = inputs

        if eval:
            self.model.eval()
        else:
            self.model.train()
            self.optimizer.zero_grad()
        log_probs, edit_logits = self.model(src, src_mask, tgt_in, pos)
        if self.args.get('edit', False):
            assert edit_logits is not None
            loss = self.crit(log_probs.view(-1, self.vocab['char'].size), tgt_out.view(-1), \
                    edit_logits, edits)
        else:
            loss = self.crit(log_probs.view(-1, self.vocab['char'].size),
                             tgt_out.view(-1))
        loss_val = loss.data.item()
        if eval:
            return loss_val

        loss.backward()
        torch.nn.utils.clip_grad_norm_(self.model.parameters(),
                                       self.args['max_grad_norm'])
        self.optimizer.step()
        return loss_val
Esempio n. 2
0
    def update(self, batch, eval=False):
        inputs, orig_idx, word_orig_idx, sentlens, wordlens = unpack_batch(
            batch, self.use_cuda)
        word, word_mask, wordchars, wordchars_mask, upos, xpos, ufeats, pretrained, lemma, head, deprel = inputs

        if eval:
            self.model.eval()
        else:
            self.model.train()
            self.optimizer.zero_grad()
        print("In trainer.update, setting model.training to TRUE")
        self.model.training = True
        print("model.training: ", self.model.training)
        loss, _ = self.model(word, word_mask, wordchars, wordchars_mask, upos,
                             xpos, ufeats, pretrained, lemma, head, deprel,
                             word_orig_idx, sentlens, wordlens)
        loss_val = loss.data.item()
        if eval:
            return loss_val

        loss.backward()
        torch.nn.utils.clip_grad_norm_(self.model.parameters(),
                                       self.args['max_grad_norm'])
        self.optimizer.step()
        return loss_val
Esempio n. 3
0
    def update(self, batch, eval=False):
        inputs, orig_idx = unpack_batch(batch, self.use_cuda)
        src, src_mask, tgt_in, tgt_out = inputs

        if eval:
            self.model.eval()
        else:
            self.model.train()
            self.optimizer.zero_grad()
        log_probs, _ = self.model(src, src_mask, tgt_in)
        loss = self.crit(log_probs.view(-1, self.vocab.size), tgt_out.view(-1))
        loss_val = loss.data.item()
        if eval:
            return loss_val

        loss.backward()
        torch.nn.utils.clip_grad_norm_(self.model.parameters(),
                                       self.args['max_grad_norm'])
        self.optimizer.step()
        return loss_val
Esempio n. 4
0
    def update(self, batch, eval=False):
        inputs, orig_idx, word_orig_idx, sentlens, wordlens = unpack_batch(batch, self.use_cuda)
        word, word_mask, wordchars, wordchars_mask, upos, xpos, ufeats, pretrained, lemma, next_word, prev_word = inputs

        if eval:
            self.model.eval()
        else:
            self.model.train()
            self.optimizer.zero_grad()
        loss, preds = self.model(word, word_mask, wordchars, wordchars_mask, upos, xpos, ufeats,
                                 pretrained, lemma, next_word, prev_word, word_orig_idx, sentlens, wordlens)
        loss_val = loss.data.item()

        if eval:
            return loss_val

        loss.backward()
        torch.nn.utils.clip_grad_norm_(self.model.parameters(), self.args['max_grad_norm'])
        self.optimizer.step()
        return loss_val
Esempio n. 5
0
    def update(self, batch, eval=False):
        inputs, orig_idx, word_orig_idx, char_orig_idx, sentlens, wordlens, charlens, charoffsets = unpack_batch(
            batch, self.use_cuda)
        word, word_mask, wordchars, wordchars_mask, chars, tags = inputs

        if eval:
            self.model.eval()
        else:
            self.model.train()
            self.optimizer.zero_grad()
        loss, _, _ = self.model(word, word_mask, wordchars, wordchars_mask,
                                tags, word_orig_idx, sentlens, wordlens, chars,
                                charoffsets, charlens, char_orig_idx)
        loss_val = loss.data.item()
        if eval:
            return loss_val

        loss.backward()
        torch.nn.utils.clip_grad_norm_(self.model.parameters(),
                                       self.args['max_grad_norm'])
        self.optimizer.step()
        return loss_val
Esempio n. 6
0
    def update(self, dp_batch, lm_batch, eval=False):
        inputs, orig_idx, word_orig_idx, sentlens, wordlens = depparse_unpack(
            dp_batch, self.use_cuda)
        word, word_mask, wordchars, wordchars_mask, upos, xpos, ufeats, pretrained, lemma, head, deprel = inputs

        if eval:
            self.model.eval()
        else:
            self.model.train()
            self.optimizer.zero_grad()

        depparse_loss, _ = self.model(word, word_mask, wordchars,
                                      wordchars_mask, upos, xpos, ufeats,
                                      pretrained, lemma, head, deprel,
                                      word_orig_idx, sentlens, wordlens)

        inputs, orig_idx, word_orig_idx, sentlens, wordlens = lm_unpack(
            lm_batch, self.use_cuda)
        word, word_mask, wordchars, wordchars_mask, upos, xpos, ufeats, pretrained, lemma, next_word, prev_word = inputs

        lm_loss, _ = self.model.lm_forward(word, word_mask, wordchars,
                                           wordchars_mask, upos, xpos, ufeats,
                                           pretrained, lemma, next_word,
                                           prev_word, word_orig_idx, sentlens,
                                           wordlens)
        loss = depparse_loss * self.args['lambd'] + lm_loss
        # print(np.exp(lm_loss.item()))

        if not eval:
            loss.backward()
            torch.nn.utils.clip_grad_norm_(self.model.parameters(),
                                           self.args['max_grad_norm'])
            self.optimizer.step()

        depparse_loss = depparse_loss.item()
        lm_loss = lm_loss.item()
        loss = loss.item()

        return depparse_loss, lm_loss, loss