Merge branch 'master' of https://github.com/OpenNMT/OpenNMT-py into cosine_loss

Author: francoishernandez

.travis.yml

@@ -1,7 +1,7 @@
 dist: xenial
 language: python
 python:
-  - "3.5"
+  - "3.6"
 git:
   depth: false
 addons:
@@ -13,7 +13,8 @@ addons:
       - sox
 before_install:
   # Install CPU version of PyTorch.
-  - if [[ $TRAVIS_PYTHON_VERSION == 3.5 ]]; then pip install torch==1.2.0 -f https://download.pytorch.org/whl/cpu/torch_stable.html; fi
+  - if [[ $TRAVIS_PYTHON_VERSION == 3.6 ]]; then pip install torch==1.4.0 -f https://download.pytorch.org/whl/cpu/torch_stable.html; fi
+  - pip install --upgrade setuptools
   - pip install -r requirements.opt.txt
   - python setup.py install   
 env:

onmt/bin/release_model.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python
+import argparse
+import torch
+
+
+def get_ctranslate2_model_spec(opt):
+    """Creates a CTranslate2 model specification from the model options."""
+    is_vanilla_transformer = (
+        opt.encoder_type == "transformer"
+        and opt.decoder_type == "transformer"
+        and opt.position_encoding
+        and opt.enc_layers == opt.dec_layers
+        and getattr(opt, "self_attn_type", "scaled-dot") == "scaled-dot"
+        and getattr(opt, "max_relative_positions", 0) == 0)
+    if not is_vanilla_transformer:
+        return None
+    import ctranslate2
+    num_heads = getattr(opt, "heads", 8)
+    return ctranslate2.specs.TransformerSpec(opt.layers, num_heads)
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Release an OpenNMT-py model for inference")
+    parser.add_argument("--model", "-m",
+                        help="The model path", required=True)
+    parser.add_argument("--output", "-o",
+                        help="The output path", required=True)
+    parser.add_argument("--format",
+                        choices=["pytorch", "ctranslate2"],
+                        default="pytorch",
+                        help="The format of the released model")
+    opt = parser.parse_args()
+
+    model = torch.load(opt.model)
+    if opt.format == "pytorch":
+        model["optim"] = None
+        torch.save(model, opt.output)
+    elif opt.format == "ctranslate2":
+        model_spec = get_ctranslate2_model_spec(model["opt"])
+        if model_spec is None:
+            raise ValueError("This model is not supported by CTranslate2. Go "
+                             "to https://github.com/OpenNMT/CTranslate2 for "
+                             "more information on supported models.")
+        import ctranslate2
+        converter = ctranslate2.converters.OpenNMTPyConverter(opt.model)
+        converter.convert(opt.output, model_spec, force=True)
+
+
+if __name__ == "__main__":
+    main()

onmt/bin/server.py

@@ -2,7 +2,10 @@
 import configargparse
 
 from flask import Flask, jsonify, request
+from waitress import serve
 from onmt.translate import TranslationServer, ServerModelError
+import logging
+from logging.handlers import RotatingFileHandler
 
 STATUS_OK = "ok"
 STATUS_ERROR = "error"
@@ -12,12 +15,22 @@ def start(config_file,
           url_root="./translator",
           host="0.0.0.0",
           port=5000,
-          debug=True):
+          debug=False):
     def prefix_route(route_function, prefix='', mask='{0}{1}'):
         def newroute(route, *args, **kwargs):
             return route_function(mask.format(prefix, route), *args, **kwargs)
         return newroute
 
+    if debug:
+        logger = logging.getLogger("main")
+        log_format = logging.Formatter(
+            "[%(asctime)s %(levelname)s] %(message)s")
+        file_handler = RotatingFileHandler(
+            "debug_requests.log",
+            maxBytes=1000000, backupCount=10)
+        file_handler.setFormatter(log_format)
+        logger.addHandler(file_handler)
+
     app = Flask(__name__)
     app.route = prefix_route(app.route, url_root)
     translation_server = TranslationServer()
@@ -73,6 +86,8 @@ def unload_model(model_id):
     @app.route('/translate', methods=['POST'])
     def translate():
         inputs = request.get_json(force=True)
+        if debug:
+            logger.info(inputs)
         out = {}
         try:
             trans, scores, n_best, _, aligns = translation_server.run(inputs)
@@ -90,7 +105,8 @@ def translate():
         except ServerModelError as e:
             out['error'] = str(e)
             out['status'] = STATUS_ERROR
-
+        if debug:
+            logger.info(out)
         return jsonify(out)
 
     @app.route('/to_cpu/<int:model_id>', methods=['GET'])
@@ -109,8 +125,7 @@ def to_gpu(model_id):
         out['status'] = STATUS_OK
         return jsonify(out)
 
-    app.run(debug=debug, host=host, port=port, use_reloader=False,
-            threaded=True)
+    serve(app, host=host, port=port)
 
 
 def _get_parser():

onmt/decoders/transformer.py

@@ -56,7 +56,7 @@ def __init__(self, d_model, heads, d_ff, dropout, attention_dropout,
 
         if self_attn_type == "scaled-dot":
             self.self_attn = MultiHeadedAttention(
-                heads, d_model, dropout=dropout,
+                heads, d_model, dropout=attention_dropout,
                 max_relative_positions=max_relative_positions)
         elif self_attn_type == "average":
             self.self_attn = AverageAttention(d_model,

onmt/inputters/inputter.py

@@ -822,11 +822,12 @@ def build_dataset_iter(corpus_type, fields, opt, is_train=True, multi=False):
     to iterate over. We implement simple ordered iterator strategy here,
     but more sophisticated strategy like curriculum learning is ok too.
     """
+    dataset_glob = opt.data + '.' + corpus_type + '.[0-9]*.pt'
     dataset_paths = list(sorted(
-        glob.glob(opt.data + '.' + corpus_type + '.[0-9]*.pt')))
+        glob.glob(dataset_glob)))
     if not dataset_paths:
         if is_train:
-            raise ValueError('Training data %s not found' % opt.data)
+            raise ValueError('Training data %s not found' % dataset_glob)
         else:
             return None
     if multi:

onmt/model_builder.py

@@ -190,6 +190,8 @@ def build_base_model(model_opt, fields, gpu, checkpoint=None, gpu_id=None):
         vocab_size = len(tgt_base_field.vocab)
         pad_idx = tgt_base_field.vocab.stoi[tgt_base_field.pad_token]
         generator = CopyGenerator(model_opt.dec_rnn_size, vocab_size, pad_idx)
+        if model_opt.share_decoder_embeddings:
+            generator.linear.weight = decoder.embeddings.word_lut.weight
 
     # Load the model states from checkpoint or initialize them.
     if checkpoint is not None:

onmt/models/model_saver.py

@@ -131,4 +131,5 @@ def _save(self, step, model):
         return checkpoint, checkpoint_path
 
     def _rm_checkpoint(self, name):
-        os.remove(name)
+        if os.path.exists(name):
+            os.remove(name)

onmt/opts.py

@@ -377,7 +377,7 @@ def train_opts(parser):
               help="IP of master for torch.distributed training.")
     group.add('--master_port', '-master_port', default=10000, type=int,
               help="Port of master for torch.distributed training.")
-    group.add('--queue_size', '-queue_size', default=400, type=int,
+    group.add('--queue_size', '-queue_size', default=40, type=int,
               help="Size of queue for each process in producer/consumer")
 
     group.add('--seed', '-seed', type=int, default=-1,

onmt/translate/translation_server.py

@@ -233,6 +233,60 @@ def __init__(self, opt, model_id, preprocess_opt=None, tokenizer_opt=None,
 
         set_random_seed(self.opt.seed, self.opt.cuda)
 
+        if self.preprocess_opt is not None:
+            self.logger.info("Loading preprocessor")
+            self.preprocessor = []
+
+            for function_path in self.preprocess_opt:
+                function = get_function_by_path(function_path)
+                self.preprocessor.append(function)
+
+        if self.tokenizer_opt is not None:
+            self.logger.info("Loading tokenizer")
+
+            if "type" not in self.tokenizer_opt:
+                raise ValueError(
+                    "Missing mandatory tokenizer option 'type'")
+
+            if self.tokenizer_opt['type'] == 'sentencepiece':
+                if "model" not in self.tokenizer_opt:
+                    raise ValueError(
+                        "Missing mandatory tokenizer option 'model'")
+                import sentencepiece as spm
+                sp = spm.SentencePieceProcessor()
+                model_path = os.path.join(self.model_root,
+                                          self.tokenizer_opt['model'])
+                sp.Load(model_path)
+                self.tokenizer = sp
+            elif self.tokenizer_opt['type'] == 'pyonmttok':
+                if "params" not in self.tokenizer_opt:
+                    raise ValueError(
+                        "Missing mandatory tokenizer option 'params'")
+                import pyonmttok
+                if self.tokenizer_opt["mode"] is not None:
+                    mode = self.tokenizer_opt["mode"]
+                else:
+                    mode = None
+                # load can be called multiple times: modify copy
+                tokenizer_params = dict(self.tokenizer_opt["params"])
+                for key, value in self.tokenizer_opt["params"].items():
+                    if key.endswith("path"):
+                        tokenizer_params[key] = os.path.join(
+                            self.model_root, value)
+                tokenizer = pyonmttok.Tokenizer(mode,
+                                                **tokenizer_params)
+                self.tokenizer = tokenizer
+            else:
+                raise ValueError("Invalid value for tokenizer type")
+
+        if self.postprocess_opt is not None:
+            self.logger.info("Loading postprocessor")
+            self.postprocessor = []
+
+            for function_path in self.postprocess_opt:
+                function = get_function_by_path(function_path)
+                self.postprocessor.append(function)
+
         if load:
             self.load()
 
@@ -294,60 +348,6 @@ def load(self):
             raise ServerModelError("Runtime Error: %s" % str(e))
 
         timer.tick("model_loading")
-        if self.preprocess_opt is not None:
-            self.logger.info("Loading preprocessor")
-            self.preprocessor = []
-
-            for function_path in self.preprocess_opt:
-                function = get_function_by_path(function_path)
-                self.preprocessor.append(function)
-
-        if self.tokenizer_opt is not None:
-            self.logger.info("Loading tokenizer")
-
-            if "type" not in self.tokenizer_opt:
-                raise ValueError(
-                    "Missing mandatory tokenizer option 'type'")
-
-            if self.tokenizer_opt['type'] == 'sentencepiece':
-                if "model" not in self.tokenizer_opt:
-                    raise ValueError(
-                        "Missing mandatory tokenizer option 'model'")
-                import sentencepiece as spm
-                sp = spm.SentencePieceProcessor()
-                model_path = os.path.join(self.model_root,
-                                          self.tokenizer_opt['model'])
-                sp.Load(model_path)
-                self.tokenizer = sp
-            elif self.tokenizer_opt['type'] == 'pyonmttok':
-                if "params" not in self.tokenizer_opt:
-                    raise ValueError(
-                        "Missing mandatory tokenizer option 'params'")
-                import pyonmttok
-                if self.tokenizer_opt["mode"] is not None:
-                    mode = self.tokenizer_opt["mode"]
-                else:
-                    mode = None
-                # load can be called multiple times: modify copy
-                tokenizer_params = dict(self.tokenizer_opt["params"])
-                for key, value in self.tokenizer_opt["params"].items():
-                    if key.endswith("path"):
-                        tokenizer_params[key] = os.path.join(
-                            self.model_root, value)
-                tokenizer = pyonmttok.Tokenizer(mode,
-                                                **tokenizer_params)
-                self.tokenizer = tokenizer
-            else:
-                raise ValueError("Invalid value for tokenizer type")
-
-        if self.postprocess_opt is not None:
-            self.logger.info("Loading postprocessor")
-            self.postprocessor = []
-
-            for function_path in self.postprocess_opt:
-                function = get_function_by_path(function_path)
-                self.postprocessor.append(function)
-
         self.load_time = timer.tick()
         self.reset_unload_timer()
         self.loading_lock.set()
@@ -491,6 +491,7 @@ def unload(self):
         del self.translator
         if self.opt.cuda:
             torch.cuda.empty_cache()
+        self.stop_unload_timer()
         self.unload_timer = None
 
     def stop_unload_timer(self):

onmt/utils/logging.py

@@ -17,7 +17,7 @@ def init_logger(log_file=None, log_file_level=logging.NOTSET):
 
     if log_file and log_file != '':
         file_handler = RotatingFileHandler(
-            log_file, maxBytes=1000, backupCount=10)
+            log_file, maxBytes=1000000, backupCount=10)
         file_handler.setLevel(log_file_level)
         file_handler.setFormatter(log_format)
         logger.addHandler(file_handler)