Self-adaptive translation mode for Marian (runtime domain adaptation).

CHANGELOG.md

@@ -9,6 +9,7 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 ## [Unreleased]
 
 ### Added
+- Adds `marian-adaptive` and `marian-adaptive-server` executables to enable self-adaptive translation (a.k.a, runtime domain adaptation).
 
 ### Fixed
 - Scripts using PyYAML now use `safe_load`; see https://msg.pyyaml.org/load

CMakeLists.txt

@@ -15,6 +15,7 @@ option(COMPILE_CPU "Compile CPU version" ON)
 option(COMPILE_CUDA "Compile GPU version" ON)
 option(COMPILE_EXAMPLES "Compile examples" OFF)
 option(COMPILE_SERVER "Compile marian-server" OFF)
+option(COMPILE_ADAPTIVE "Compile marian-adaptive. Set COMPILE_SERVER=ON to enable the server mode." OFF)
 option(COMPILE_TESTS "Compile tests" OFF)
 if(APPLE)
   option(USE_APPLE_ACCELERATE "Compile with Apple Accelerate" ON)

scripts/self-adaptive/client_example.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python
+
+# This is an example for using self-adaptive translation in server mode.
+#
+# To run:
+# 1. Start self-adaptive Marian in server mode, e.g.:
+#     ./build/marian-adaptive-server -p 8080 -m model.npz -v vocap.yaml vocab.yaml \
+#         --after-batches 10 --after-epochs 10 --learn-rate 0.1 --mini-batch 15 # other options
+# 2. In a new shell, run this script:
+#     python3 ./scripts/self-adaptive/client_exmaple.py -p 8080
+#
+# For a more extensive example, see https://github.com/marian-cef/marian-examples/tree/master/adaptive
+# or https://github.com/tilde-nlp/runtime-domain-adaptation-tutorial
+
+from __future__ import print_function, unicode_literals, division
+
+import sys
+import time
+import argparse
+import json
+
+from websocket import create_connection
+
+
+def translate(batch, port=8080):
+    ws = create_connection("ws://localhost:{}/translate".format(port))
+    ws.send(batch)
+    result = ws.recv()
+    ws.close()
+    return result.rstrip()
+
+
+def parse_args():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("-p", "--port", type=int, default=8080)
+    return parser.parse_args()
+
+
+if __name__ == "__main__":
+    args = parse_args()
+
+    # List of input sentences separated by a new line character
+    inputs = "this is an example\nthe second sentence\nno context provided"
+    # For each input sentence a list of parallel sentences can be provided as a
+    # list of source and target sentences.
+    contexts = [
+        # Source-side context for the first input sentence
+        ["this is a test\nthese are examples",
+        # Target-side context for the first input sentence
+            "das ist ein test\ndies sind Beispiele"],
+        # Only one example is given as a context for the second input sentence
+        ["the next sentence",
+            "der nächste Satz"],
+        # No context for the third input sentence
+        []
+    ]
+
+    input_data = {'input': inputs, 'context': contexts}
+    input_json = json.dumps(input_data)
+
+    output_json = translate(input_json, port=args.port)
+    output_data = json.loads(output_json)
+    print(output_data['output'])

src/CMakeLists.txt

@@ -104,6 +104,7 @@ set(MARIAN_SOURCES
   translator/nth_element.cpp
   translator/helpers.cpp
   translator/scorers.cpp
+  translator/swappable.cpp
 
   training/graph_group_async.cpp
   training/graph_group_sync.cpp
@@ -129,6 +130,12 @@ set(MARIAN_SOURCES
   $<TARGET_OBJECTS:faiss>
 )
 
+if(COMPILE_ADAPTIVE)
+  set(MARIAN_SOURCES ${MARIAN_SOURCES}
+    data/adaptive_context.cpp
+  )
+endif(COMPILE_ADAPTIVE)
+
 add_library(marian STATIC ${MARIAN_SOURCES})
 
 target_compile_options(marian PRIVATE ${ALL_WARNINGS})
@@ -188,6 +195,7 @@ if(CUDA_FOUND)
     tensors/gpu/add_all.cu
     tensors/gpu/tensor_operators.cu
     tensors/gpu/cudnn_wrappers.cu
+    tensors/gpu/swap.cu
     translator/nth_element.cu
     translator/helpers.cu
     STATIC)
@@ -274,6 +282,18 @@ if (NOT COMPILE_LIBRARY_ONLY)
     set(EXECUTABLES ${EXECUTABLES} marian_server)
   endif(COMPILE_SERVER)
 
+  if(COMPILE_ADAPTIVE)
+    add_executable(marian_adaptive command/marian_adaptive.cpp)
+    set_target_properties(marian_adaptive PROPERTIES OUTPUT_NAME marian-adaptive)
+    set(EXECUTABLES ${EXECUTABLES} marian_adaptive)
+
+    if(COMPILE_SERVER)
+      add_executable(marian_adaptive_server command/marian_adaptive_server.cpp)
+      set_target_properties(marian_adaptive_server PROPERTIES OUTPUT_NAME marian-adaptive-server)
+      set(EXECUTABLES ${EXECUTABLES} marian_adaptive_server)
+    endif(COMPILE_SERVER)
+  endif(COMPILE_ADAPTIVE)
+
   foreach(exec ${EXECUTABLES})
     target_link_libraries(${exec} marian)
     if(CUDA_FOUND)

src/command/marian_adaptive.cpp

@@ -0,0 +1,19 @@
+#include "marian.h"
+
+#include "common/timer.h"
+#include "common/utils.h"
+#include "training/training.h"
+#include "translator/self_adaptive.h"
+
+using namespace marian;
+
+int main(int argc, char **argv) {
+  auto options = parseOptions(argc, argv, cli::mode::selfadaptive);
+  auto task = New<TrainSelfAdaptive>(options);
+
+  timer::Timer timer;
+  task->run();
+  LOG(info, "Total time: {:.5f}s", timer.elapsed());
+
+  return 0;
+}

src/command/marian_adaptive_server.cpp

@@ -0,0 +1,11 @@
+#include "translator/self_adaptive.h"
+#include "translator/server_common.h"
+
+int main(int argc, char **argv) {
+  using namespace marian;
+
+  auto options = parseOptions(argc, argv, cli::mode::selfadaptiveServer);
+  auto task = New<TrainSelfAdaptive>(options);
+
+  return runServer(task, options);
+}

src/command/marian_server.cpp

@@ -1,62 +1,11 @@
-#include "marian.h"
-#include "translator/beam_search.h"
+#include "translator/server_common.h"
 #include "translator/translator.h"
-#include "common/timer.h"
-#include "common/utils.h"
-
-#include "3rd_party/simple-websocket-server/server_ws.hpp"
-
-typedef SimpleWeb::SocketServer<SimpleWeb::WS> WSServer;
 
 int main(int argc, char **argv) {
   using namespace marian;
 
-  // Initialize translation task
   auto options = parseOptions(argc, argv, cli::mode::server, true);
   auto task = New<TranslateService<BeamSearch>>(options);
-  auto quiet = options->get<bool>("quiet-translation");
-
-  // Initialize web server
-  WSServer server;
-  server.config.port = (short)options->get<size_t>("port", 8080);
-
-  auto &translate = server.endpoint["^/translate/?$"];
-
-  translate.on_message = [&task, quiet](Ptr<WSServer::Connection> connection,
-                                        Ptr<WSServer::InMessage> message) {
-    // Get input text
-    auto inputText = message->string();
-    auto sendStream = std::make_shared<WSServer::OutMessage>();
-
-    // Translate
-    timer::Timer timer;
-    auto outputText = task->run(inputText);
-    *sendStream << outputText << std::endl;
-    if(!quiet)
-      LOG(info, "Translation took: {:.5f}s", timer.elapsed());
-
-    // Send translation back
-    connection->send(sendStream, [](const SimpleWeb::error_code &ec) {
-      if(ec)
-        LOG(error, "Error sending message: ({}) {}", ec.value(), ec.message());
-    });
-  };
-
-  // Error Codes for error code meanings
-  // http://www.boost.org/doc/libs/1_55_0/doc/html/boost_asio/reference.html
-  translate.on_error = [](Ptr<WSServer::Connection> /*connection*/,
-                          const SimpleWeb::error_code &ec) {
-    LOG(error, "Connection error: ({}) {}", ec.value(), ec.message());
-  };
-
-  // Start server thread
-  std::thread serverThread([&server]() {
-    server.start([](unsigned short port) {
-      LOG(info, "Server is listening on port {}", port);
-    });
-  });
-
-  serverThread.join();
 
-  return 0;
+  return runServer(task, options);
 }

src/common/config.cpp

@@ -73,7 +73,7 @@ void Config::initialize(ConfigParser const& cp) {
   }
 
   // guess --tsv-fields, i.e. the number of fields in a TSV input, if not set
-  if(get<bool>("tsv") && get<size_t>("tsv-fields") == 0) {
+  if(get<bool>("tsv", false) && get<size_t>("tsv-fields") == 0) {
     size_t tsvFields = 0;
 
     // use the length of --input-types if given