fix models base interface (#509)

* fixed models base interface

* update translator

* remove get_primary_loss

xnmt/eval/tasks.py

@@ -90,13 +90,10 @@ def eval(self) -> 'EvalScore':
 
     loss_stats = {k: v/ref_words_cnt for k, v in loss_val.items()}
 
-    try:
-      return LossScore(loss_stats[self.model.get_primary_loss()],
-                       loss_stats=loss_stats,
-                       num_ref_words = ref_words_cnt,
-                       desc=self.desc)
-    except KeyError:
-      raise RuntimeError("Did you wrap your loss calculation with FactoredLossExpr({'primary_loss': loss_value}) ?")
+    return LossScore(sum(loss_stats.values()),
+                     loss_stats=loss_stats,
+                     num_ref_words = ref_words_cnt,
+                     desc=self.desc)
 
 class AccuracyEvalTask(EvalTask, reports.Reportable, Serializable):
   """

xnmt/models/base.py

@@ -1,5 +1,7 @@
 from typing import Optional, Sequence, Union
 
+import dynet as dy
+
 from xnmt import batchers, input_readers, losses, sent
 from xnmt import event_trigger, loss_calculators
 from xnmt.persistence import Serializable, serializable_init
@@ -9,7 +11,7 @@ class TrainableModel(object):
   A template class for a basic trainable model, implementing a loss function.
   """
 
-  def calc_nll(self, *args, **kwargs) -> losses.FactoredLossExpr:
+  def calc_nll(self, *args, **kwargs) -> dy.Expression:
     """Calculate loss based on input-output pairs.
 
     Losses are accumulated only across unmasked timesteps in each batch element.
@@ -20,13 +22,6 @@ def calc_nll(self, *args, **kwargs) -> losses.FactoredLossExpr:
       A (possibly batched) expression representing the loss.
     """
 
-  def get_primary_loss(self) -> str:
-    """
-    Returns:
-      Identifier for primary loss.
-    """
-    raise NotImplementedError("Pick a key for primary loss that is used for dev_loss calculation")
-
 class UnconditionedModel(TrainableModel):
   """
   A template class for trainable model that computes target losses without conditioning on other inputs.
@@ -38,7 +33,7 @@ class UnconditionedModel(TrainableModel):
   def __init__(self, trg_reader: input_readers.InputReader):
     self.trg_reader = trg_reader
 
-  def calc_nll(self, trg: Union[batchers.Batch, sent.Sentence]) -> losses.FactoredLossExpr:
+  def calc_nll(self, trg: Union[batchers.Batch, sent.Sentence]) -> dy.Expression:
     """Calculate loss based on target inputs.
 
     Losses are accumulated only across unmasked timesteps in each batch element.
@@ -64,8 +59,8 @@ def __init__(self, src_reader: input_readers.InputReader, trg_reader: input_read
     self.src_reader = src_reader
     self.trg_reader = trg_reader
 
-  def calc_nll(self, src: Union[batchers.Batch, sent.Sentence], trg: Union[batchers.Batch, sent.Sentence],
-                loss_calculator: loss_calculators.LossCalculator) -> losses.FactoredLossExpr:
+  def calc_nll(self, src: Union[batchers.Batch, sent.Sentence], trg: Union[batchers.Batch, sent.Sentence]) \
+          -> dy.Expression:
     """Calculate loss based on input-output pairs.
 
     Losses are accumulated only across unmasked timesteps in each batch element.

xnmt/models/classifiers.py

@@ -80,9 +80,6 @@ def generate(self, src, forced_trg_ids=None, normalize_scores=False):
                                          score=score))
     return outputs
 
-  def get_primary_loss(self):
-    return "mle"
-
   def get_nobp_state(self, state):
     output_state = state.rnn_state.output()
     return output_state

xnmt/models/language_models.py

@@ -41,9 +41,6 @@ def __init__(self,
   def shared_params(self):
     return [{".src_embedder.emb_dim", ".encoder.input_dim"},]
 
-  def get_primary_loss(self):
-    return "mle"
-
   def calc_nll(self, src, trg):
     if not batchers.is_batched(src):
       src = batchers.ListBatch([src])

xnmt/models/sequence_labelers.py

@@ -51,9 +51,6 @@ def __init__(self,
   def shared_params(self):
     return [{".src_embedder.emb_dim", ".encoder.input_dim"},]
 
-  def get_primary_loss(self):
-    return "mle"
-
   def _encode_src(self, src):
     event_trigger.start_sent(src)
     embeddings = self.src_embedder.embed_sent(src)

xnmt/models/translators.py

@@ -60,9 +60,6 @@ def set_trg_vocab(self, trg_vocab=None):
     """
     self.trg_vocab = trg_vocab
 
-  def get_primary_loss(self) -> str:
-    return "mle"
-
   def get_nobp_state(self, state):
     output_state = state.rnn_state.output()
     if type(output_state) == EnsembleListDelegate:
@@ -358,7 +355,7 @@ def sentence_block_embed(self, embed, x, mask):
     e = dy.reshape(e, (units, length), batch_size=batch)
     return e
 
-  def calc_loss(self, src, trg, loss_cal=None, infer_prediction=False):
+  def calc_loss(self, src, trg, infer_prediction=False):
     event_trigger.start_sent(src)
     if not batchers.is_batched(src):
       src = batchers.mark_as_batch([src])
@@ -491,7 +488,7 @@ def set_trg_vocab(self, trg_vocab=None):
   def calc_nll(self, src: Union[batchers.Batch, sent.Sentence], trg: Union[batchers.Batch, sent.Sentence]) -> dy.Expression:
     sub_losses = collections.defaultdict(list)
     for model in self.models:
-      for loss_name, loss in model.calc_loss(src, trg).expr_factors.items():
+      for loss_name, loss in model.calc_nll(src, trg).expr_factors.items():
         sub_losses[loss_name].append(loss)
     model_loss = FactoredLossExpr()
     for loss_name, losslist in sub_losses.items():