Enable multi-source input in marian-server

src/command/marian_server.cpp

@@ -14,22 +14,29 @@ int main(int argc, char **argv) {
   // Initialize translation task
   auto options = parseOptions(argc, argv, cli::mode::server, true);
   auto task = New<TranslateService<BeamSearch>>(options);
+  auto inputNum = options->get<std::vector<std::string>>("vocabs").size() - 1;
 
   // Initialize web server
   WSServer server;
   server.config.port = (short)options->get<size_t>("port", 8080);
 
   auto &translate = server.endpoint["^/translate/?$"];
 
-  translate.on_message = [&task](Ptr<WSServer::Connection> connection,
+  translate.on_message = [&task, inputNum](Ptr<WSServer::Connection> connection,
                                  Ptr<WSServer::Message> message) {
     // Get input text
     auto inputText = message->string();
     auto sendStream = std::make_shared<WSServer::SendStream>();
 
     // Translate
     timer::Timer timer;
-    auto outputText = task->run(inputText);
+    std::vector<std::string> inputs;
+    if (inputNum >= 2) {
+      inputs = utils::tsv2lists(inputText, inputNum);
+    } else {
+      inputs = std::vector<std::string>({inputText});
+    }
+    auto outputText = task->run(inputs);
     LOG(info, "Best translation: {}", outputText);
     *sendStream << outputText << std::endl;
     LOG(info, "Translation took: {:.5f}s", timer.elapsed());

src/common/utils.cpp

@@ -13,6 +13,7 @@
 #endif
 #include <codecvt>
 #include <cwctype>
+#include <vector>
 
 namespace marian {
 namespace utils {
@@ -93,6 +94,26 @@ std::string join(const std::vector<std::string>& words, const std::string& del /
   return ss.str();
 }
 
+std::vector<std::string> tsv2lists(const std::string& inputText, int inputNum) {
+    std::string line_;
+    std::vector<std::vector<std::string>> inputLists(inputNum);
+    std::istringstream inputStream(inputText);
+    while (std::getline(inputStream, line_)) {
+      auto items = marian::utils::splitAny(line_, "\t");
+      std::cerr << "Split into " << items.size() << std::endl;
+      for (size_t i = 0; i < items.size(); ++i) {
+        inputLists[i].push_back(items[i]);
+      }
+    }
+
+    std::vector<std::string> inputs;
+    for (auto &inputList : inputLists) {
+      inputs.push_back(marian::utils::join(inputList, "\n"));
+    }
+    return inputs;
+}
+
+
 // escapes a string for passing to popen, which uses /bin/sh to parse its argument string
 static std::string escapeForPOpen(const std::string& arg) {
   // e.g. abc -> 'abc'; my file.txt -> 'my file.txt'; $10 -> '$10'; it's -> 'it'\''s'

src/common/utils.h

@@ -30,6 +30,8 @@ std::vector<std::string> splitAny(const std::string& line,
 
 std::string join(const std::vector<std::string>& words, const std::string& del = " ");
 
+std::vector<std::string> tsv2lists(const std::string& inputText, int inputNum);
+
 std::string exec(const std::string& cmd, const std::vector<std::string>& args = {}, const std::string& arg = "");
 
 std::pair<std::string, int> hostnameAndProcessId();

src/data/text_input.cpp

@@ -23,8 +23,11 @@ const SentenceTuple& TextIterator::dereference() const {
 TextInput::TextInput(std::vector<std::string> inputs,
                      std::vector<Ptr<Vocab>> vocabs,
                      Ptr<Options> options)
-    : DatasetBase(inputs, options), vocabs_(vocabs) {
-  // note: inputs are automatically stored in the inherited variable named paths_, but these are
+    : DatasetBase(inputs, options),
+      vocabs_(vocabs),
+      maxLength_(options_->get<size_t>("max-length")),
+      maxLengthCrop_(options_->get<bool>("max-length-crop")) {
+  // note: inputs are automatically stored in the inherited variable named paths_, but these ar
   // texts not paths!
   for(const auto& text : paths_)
     files_.emplace_back(new std::istringstream(text));
@@ -43,6 +46,9 @@ SentenceTuple TextInput::next() {
     std::string line;
     if(io::getline(dummyStream, line)) {
       Words words = vocabs_[i]->encode(line, /*addEOS =*/ true, /*inference =*/ inference_);
+      if(this->maxLengthCrop_ && words.size() > this->maxLength_) {
+        words.resize(maxLength_);
+      }
       if(words.empty())
         words.push_back(Word::ZERO); // @TODO: What is this for? @BUGBUG: addEOS=true, so this can never happen, right?
       tup.push_back(words);

src/data/text_input.h

@@ -33,6 +33,9 @@ class TextInput : public DatasetBase<SentenceTuple, TextIterator, CorpusBatch> {
 
   size_t pos_{0};
 
+  size_t maxLength_{0};
+  bool maxLengthCrop_{false};
+
 public:
   typedef SentenceTuple Sample;
 

src/models/model_task.h

@@ -1,6 +1,9 @@
 #pragma once
 
 #include <string>
+#include <vector>
+
+#include "common/logging.h"
 
 namespace marian {
 
@@ -10,5 +13,9 @@ struct ModelTask {
 
 struct ModelServiceTask {
   virtual std::string run(const std::string&) = 0;
+  virtual std::string run(const std::vector<std::string>&) {
+    ABORT("Not implemented");
+    return "";
+  }
 };
 }  // namespace marian

src/translator/translator.h

@@ -1,5 +1,8 @@
 #pragma once
 
+#include <iostream>
+#include <string>
+
 #include "data/batch_generator.h"
 #include "data/corpus.h"
 #include "data/shortlist.h"
@@ -189,7 +192,11 @@ class TranslateService : public ModelServiceTask {
   }
 
   std::string run(const std::string& input) override {
-    auto corpus_ = New<data::TextInput>(std::vector<std::string>({input}), srcVocabs_, options_);
+    return run(std::vector<std::string>({input}));
+  }
+
+  std::string run(const std::vector<std::string>& inputs) override {
+    auto corpus_ = New<data::TextInput>(inputs, srcVocabs_, options_);
     data::BatchGenerator<data::TextInput> batchGenerator(corpus_, options_);
 
     auto collector = New<StringCollector>();