cld3 3.2.4 → 3.2.5

data/ext/cld3/ext/src/language_identifier_features_test.cc

@@ -0,0 +1,261 @@
+/* Copyright 2016 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#include <cmath>
+#include <iostream>
+#include <vector>
+#include <set>
+
+#include "base.h"
+#include "feature_extractor.h"
+#include "language_identifier_features.h"
+#include "nnet_language_identifier.h"
+#include "script_span/generated_ulscript.h"
+#include "cld_3/protos/sentence.pb.h"
+#include "task_context.h"
+#include "utils.h"
+#include "workspace.h"
+
+namespace chrome_lang_id {
+namespace language_identifier_features_test {
+
+static WholeSentenceFeature *cbog_factory() {
+  return new ContinuousBagOfNgramsFunction;
+}
+
+static WholeSentenceFeature *sf_factory() { return new ScriptFeature; }
+
+// Class for calculating the feature weights and ids.
+class FeatureIdWeightCalculator {
+ public:
+  explicit FeatureIdWeightCalculator(TaskContext *context) {
+    if (WholeSentenceFeature::registry() == nullptr) {
+      // Create registry for our WholeSentenceFeature(s).
+      RegisterableClass<WholeSentenceFeature>::CreateRegistry(
+          "sentence feature function", "WholeSentenceFeature", __FILE__,
+          __LINE__);
+    }
+
+    // Register our WholeSentenceFeature(s).
+    // Register ContinuousBagOfNgramsFunction feature function.
+    static WholeSentenceFeature::Registry::Registrar cbog_registrar(
+        WholeSentenceFeature::registry(), "continuous-bag-of-ngrams",
+        "ContinuousBagOfNgramsFunction", __FILE__, __LINE__, cbog_factory);
+
+    // Register Script feature function.
+    static WholeSentenceFeature::Registry::Registrar sf_registrar(
+        WholeSentenceFeature::registry(), "script", "ScriptFeature", __FILE__,
+        __LINE__, sf_factory);
+
+    feature_extractor_.Setup(context);
+    feature_extractor_.Init(context);
+  }
+
+  // Assumes that a single feature is specified and extracts it.
+  void ExtractOnlyFeature(Sentence *sentence,
+                          std::vector<FeatureVector> *features) {
+    CLD3_CHECK(features->size() == 1);
+    WorkspaceSet workspace;
+    workspace.Reset(workspace_registry_);
+    feature_extractor_.Preprocess(&workspace, sentence);
+    feature_extractor_.ExtractFeatures(workspace, *sentence, features);
+    CLD3_CHECK(features->size() == 1);
+  }
+
+  // Returns a map from feature value id to feature value weight.
+  std::unordered_map<int, float> GetFloatFeatureValIdsAndWeights(
+      Sentence *sentence) {
+    std::vector<FeatureVector> feature_vectors(1);  // one feature space
+    ExtractOnlyFeature(sentence, &feature_vectors);
+    const FeatureVector &feature_vector = feature_vectors.at(0);
+
+    // Save the (feature value id, feature value weight) pairs to a map.
+    std::unordered_map<int, float> feature_id_weight;
+    for (int index = 0; index < feature_vector.size(); ++index) {
+      const FloatFeatureValue feature_value =
+          FloatFeatureValue(feature_vector.value(index));
+      feature_id_weight[feature_value.value.id] = feature_value.value.weight;
+    }
+    return feature_id_weight;
+  }
+
+  // Returns the feature value ids.
+  std::set<int> GetFeatureValueIds(Sentence *sentence) {
+    std::vector<FeatureVector> feature_vectors(1);  // one feature space
+    ExtractOnlyFeature(sentence, &feature_vectors);
+    const FeatureVector &feature_vector = feature_vectors.at(0);
+
+    std::set<int> ids;
+    for (int index = 0; index < feature_vector.size(); ++index) {
+      ids.insert(feature_vector.value(index));
+    }
+    return ids;
+  }
+
+ private:
+  // The registry of shared workspaces in the feature extractor.
+  WorkspaceRegistry workspace_registry_;
+  LanguageIdEmbeddingFeatureExtractor feature_extractor_;
+};
+
+// Extracts features and checks that their ids and weights are correct.
+bool ExtractAndCheckFeatures(const string &features, const int id_dim,
+                             const std::vector<string> &expected_char_ngrams,
+                             const std::vector<float> &expected_weights,
+                             Sentence *sentence) {
+  TaskContext context;
+  context.SetParameter("language_identifier_features", features);
+  FeatureIdWeightCalculator calc(&context);
+
+  // Get the feature ids and the corresponding weights.
+  const std::unordered_map<int, float> feature_id_weight =
+      calc.GetFloatFeatureValIdsAndWeights(sentence);
+  if (feature_id_weight.size() != expected_char_ngrams.size()) {
+    std::cout << "  Failure" << std::endl;
+    std::cout << "  Number of expected feature ids: "
+              << expected_char_ngrams.size() << std::endl;
+    std::cout << "  Number of extracted feature ids: "
+              << feature_id_weight.size() << std::endl;
+    return false;
+  }
+
+  // Specifies how close two float values should be to be considered equal.
+  const float epsilon = 0.0001f;
+  bool test_successful = true;
+  for (size_t i = 0; i < expected_char_ngrams.size(); ++i) {
+    const int expected_id =
+        utils::Hash32WithDefaultSeed(expected_char_ngrams.at(i)) % id_dim;
+
+    // Check the ids and the weights.
+    if (feature_id_weight.count(expected_id) == 0) {
+      std::cout << "  Failure" << std::endl;
+      std::cout << "  Feature id " << expected_id << " is missing" << std::endl;
+      test_successful = false;
+    } else {
+      if (std::abs(feature_id_weight.at(expected_id) - expected_weights.at(i)) >
+          epsilon) {
+        std::cout << "  Failure" << std::endl;
+        std::cout << "  Different weight for feature id " << expected_id
+                  << ": expected weight " << expected_weights.at(i)
+                  << ", actual weight " << feature_id_weight.at(expected_id)
+                  << std::endl;
+        test_successful = false;
+      }
+    }
+  }
+
+  if (test_successful) {
+    std::cout << "  Success!" << std::endl;
+  }
+  return test_successful;
+}
+
+// Tests the case when ngram features get equal weight. Returns "true" if the
+// test is successful and "false" otherwise.
+bool TestExtractFeaturesWithEqualWeight() {
+  std::cout << "Running " << __FUNCTION__ << std::endl;
+
+  // The integer id of each char ngram is computed as follows:
+  // utils::Hash32WithDefaultSeed(char ngram) % id_dim.
+  const int id_dim = 100;
+  const string features = "continuous-bag-of-ngrams(id_dim=" +
+                          std::to_string(id_dim) +
+                          ",size=2,include_terminators=true,include_" +
+                          "spaces=false,use_equal_weight=true)";
+  Sentence sentence;
+  sentence.set_text("aa aab");
+  const std::vector<string> expected_char_ngrams{"ab", "b$", "^a", "aa", "a$"};
+  const std::vector<float> expected_weights = {0.2f, 0.2f, 0.2f, 0.2f, 0.2f};
+  return ExtractAndCheckFeatures(features, id_dim, expected_char_ngrams,
+                                 expected_weights, &sentence);
+}
+
+// Tests the case when ngram features get weights equal to their normalized
+// counts. Returns "true" if the test is successful and "false" otherwise.
+bool TestExtractFeaturesWithNonEqualWeight() {
+  std::cout << "Running " << __FUNCTION__ << std::endl;
+
+  // The integer id of each char ngram is computed as follows:
+  // utils::Hash32WithDefaultSeed(char ngram) % id_dim.
+  const int id_dim = 100;
+  const string features = "continuous-bag-of-ngrams(id_dim=" +
+                          std::to_string(id_dim) +
+                          ",size=2,include_terminators=true,include_" +
+                          "spaces=false,use_equal_weight=false)";
+  Sentence sentence;
+  sentence.set_text("aa aab");
+  const std::vector<string> expected_char_ngrams{"ab", "b$", "^a", "aa", "a$"};
+  const std::vector<float> expected_weights{0.1428f, 0.1428f, 0.2857f, 0.2857f,
+                                            0.1428f};
+  return ExtractAndCheckFeatures(features, id_dim, expected_char_ngrams,
+                                 expected_weights, &sentence);
+}
+
+// Tests the feature Script.
+bool TestScriptFeature() {
+  std::cout << "Running " << __FUNCTION__ << std::endl;
+
+  bool test_successful = true;
+  TaskContext context;
+  context.SetParameter("language_identifier_features", "script");
+  FeatureIdWeightCalculator calc(&context);
+
+  // Check the script of the English sentence.
+  Sentence sentence;
+  sentence.set_text("food");
+  std::set<int> feature_val_ids = calc.GetFeatureValueIds(&sentence);
+  if (feature_val_ids.size() != 1 ||
+      feature_val_ids.count(chrome_lang_id::CLD2::ULScript_Latin) == 0) {
+    test_successful = false;
+    std::cout << "  Failure for input: " << sentence.text() << std::endl;
+  }
+
+  // Check the script of a Chinese sentence.
+  sentence.set_text("字");
+  feature_val_ids = calc.GetFeatureValueIds(&sentence);
+  if (feature_val_ids.size() != 1 ||
+      feature_val_ids.count(chrome_lang_id::CLD2::ULScript_Hani) == 0) {
+    test_successful = false;
+    std::cout << "  Failure for input: " << sentence.text() << std::endl;
+  }
+
+  // Check the script of a Korean sentence.
+  sentence.set_text("워드");
+  feature_val_ids = calc.GetFeatureValueIds(&sentence);
+  if (feature_val_ids.size() != 1 ||
+      feature_val_ids.count(chrome_lang_id::CLD2::NUM_ULSCRIPTS) == 0) {
+    test_successful = false;
+    std::cout << "  Failure for input: " << sentence.text() << std::endl;
+  }
+
+  if (test_successful) {
+    std::cout << "  Success!" << std::endl;
+  }
+  return test_successful;
+}
+
+}  // namespace language_identifier_features_test
+}  // namespace chrome_lang_id
+
+// Runs the feature extraction tests.
+int main(int argc, char **argv) {
+  const bool tests_successful =
+      chrome_lang_id::language_identifier_features_test::
+          TestExtractFeaturesWithEqualWeight() &&
+      chrome_lang_id::language_identifier_features_test::
+          TestExtractFeaturesWithNonEqualWeight() &&
+      chrome_lang_id::language_identifier_features_test::TestScriptFeature();
+  return tests_successful ? 0 : 1;
+}

data/ext/cld3/ext/src/language_identifier_main.cc

@@ -0,0 +1,54 @@
+/* Copyright 2016 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#include <iostream>
+#include <string>
+
+#include "base.h"
+#include "nnet_language_identifier.h"
+
+using chrome_lang_id::NNetLanguageIdentifier;
+
+// Runs a neural net model for language identification.
+int main(int argc, char **argv) {
+  NNetLanguageIdentifier lang_id(/*min_num_bytes=*/0,
+                                 /*max_num_bytes=*/1000);
+
+  const std::vector<std::string> texts{"This text is written in English.",
+                                       "Text in deutscher Sprache verfasst."};
+  for (const std::string &text : texts) {
+    const NNetLanguageIdentifier::Result result = lang_id.FindLanguage(text);
+    std::cout << "text: " << text << std::endl
+              << "  language: " << result.language << std::endl
+              << "  probability: " << result.probability << std::endl
+              << "  reliable: " << result.is_reliable << std::endl
+              << "  proportion: " << result.proportion << std::endl
+              << std::endl;
+  }
+
+  const std::string &text =
+      "This piece of text is in English. Този текст е на Български.";
+  std::cout << "text: " << text << std::endl;
+  const std::vector<NNetLanguageIdentifier::Result> results =
+      lang_id.FindTopNMostFreqLangs(text, /*num_langs*/ 3);
+  for (const NNetLanguageIdentifier::Result &result : results) {
+    std::cout << "  language: " << result.language << std::endl
+              << "  probability: " << result.probability << std::endl
+              << "  reliable: " << result.is_reliable << std::endl
+              << "  proportion: " << result.proportion << std::endl
+              << std::endl;
+  }
+  return 0;
+}

data/ext/cld3/ext/src/nnet_lang_id_test.cc

@@ -0,0 +1,254 @@
+/* Copyright 2016 Google Inc. All Rights Reserved.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+==============================================================================*/
+
+#include <cmath>
+#include <iostream>
+#include <string>
+#include <utility>
+#include <vector>
+
+#include "base.h"
+#include "nnet_lang_id_test_data.h"
+#include "nnet_language_identifier.h"
+
+namespace chrome_lang_id {
+namespace nnet_lang_id_test {
+
+// Tests the model on all supported languages. Returns "true" if the test is
+// successful and "false" otherwise.
+// TODO(abakalov): Add a test for random input that should be labeled as
+// "unknown" due to low confidence.
+bool TestPredictions() {
+  std::cout << "Running " << __FUNCTION__ << std::endl;
+
+  // (gold language, sample text) pairs used for testing.
+  const std::vector<std::pair<std::string, std::string>> gold_lang_text = {
+      {"af", NNetLangIdTestData::kTestStrAF},
+      {"ar", NNetLangIdTestData::kTestStrAR},
+      {"az", NNetLangIdTestData::kTestStrAZ},
+      {"be", NNetLangIdTestData::kTestStrBE},
+      {"bg", NNetLangIdTestData::kTestStrBG},
+      {"bn", NNetLangIdTestData::kTestStrBN},
+      {"bs", NNetLangIdTestData::kTestStrBS},
+      {"ca", NNetLangIdTestData::kTestStrCA},
+      {"ceb", NNetLangIdTestData::kTestStrCEB},
+      {"cs", NNetLangIdTestData::kTestStrCS},
+      {"cy", NNetLangIdTestData::kTestStrCY},
+      {"da", NNetLangIdTestData::kTestStrDA},
+      {"de", NNetLangIdTestData::kTestStrDE},
+      {"el", NNetLangIdTestData::kTestStrEL},
+      {"en", NNetLangIdTestData::kTestStrEN},
+      {"eo", NNetLangIdTestData::kTestStrEO},
+      {"es", NNetLangIdTestData::kTestStrES},
+      {"et", NNetLangIdTestData::kTestStrET},
+      {"eu", NNetLangIdTestData::kTestStrEU},
+      {"fa", NNetLangIdTestData::kTestStrFA},
+      {"fi", NNetLangIdTestData::kTestStrFI},
+      {"fil", NNetLangIdTestData::kTestStrFIL},
+      {"fr", NNetLangIdTestData::kTestStrFR},
+      {"ga", NNetLangIdTestData::kTestStrGA},
+      {"gl", NNetLangIdTestData::kTestStrGL},
+      {"gu", NNetLangIdTestData::kTestStrGU},
+      {"ha", NNetLangIdTestData::kTestStrHA},
+      {"hi", NNetLangIdTestData::kTestStrHI},
+      {"hmn", NNetLangIdTestData::kTestStrHMN},
+      {"hr", NNetLangIdTestData::kTestStrHR},
+      {"ht", NNetLangIdTestData::kTestStrHT},
+      {"hu", NNetLangIdTestData::kTestStrHU},
+      {"hy", NNetLangIdTestData::kTestStrHY},
+      {"id", NNetLangIdTestData::kTestStrID},
+      {"ig", NNetLangIdTestData::kTestStrIG},
+      {"is", NNetLangIdTestData::kTestStrIS},
+      {"it", NNetLangIdTestData::kTestStrIT},
+      {"iw", NNetLangIdTestData::kTestStrIW},
+      {"ja", NNetLangIdTestData::kTestStrJA},
+      {"jv", NNetLangIdTestData::kTestStrJV},
+      {"ka", NNetLangIdTestData::kTestStrKA},
+      {"kk", NNetLangIdTestData::kTestStrKK},
+      {"km", NNetLangIdTestData::kTestStrKM},
+      {"kn", NNetLangIdTestData::kTestStrKN},
+      {"ko", NNetLangIdTestData::kTestStrKO},
+      {"la", NNetLangIdTestData::kTestStrLA},
+      {"lo", NNetLangIdTestData::kTestStrLO},
+      {"lt", NNetLangIdTestData::kTestStrLT},
+      {"lv", NNetLangIdTestData::kTestStrLV},
+      {"mg", NNetLangIdTestData::kTestStrMG},
+      {"mi", NNetLangIdTestData::kTestStrMI},
+      {"mk", NNetLangIdTestData::kTestStrMK},
+      {"ml", NNetLangIdTestData::kTestStrML},
+      {"mn", NNetLangIdTestData::kTestStrMN},
+      {"mr", NNetLangIdTestData::kTestStrMR},
+      {"ms", NNetLangIdTestData::kTestStrMS},
+      {"mt", NNetLangIdTestData::kTestStrMT},
+      {"my", NNetLangIdTestData::kTestStrMY},
+      {"ne", NNetLangIdTestData::kTestStrNE},
+      {"nl", NNetLangIdTestData::kTestStrNL},
+      {"no", NNetLangIdTestData::kTestStrNO},
+      {"ny", NNetLangIdTestData::kTestStrNY},
+      {"pa", NNetLangIdTestData::kTestStrPA},
+      {"pl", NNetLangIdTestData::kTestStrPL},
+      {"pt", NNetLangIdTestData::kTestStrPT},
+      {"ro", NNetLangIdTestData::kTestStrRO},
+      {"ru", NNetLangIdTestData::kTestStrRU},
+      {"si", NNetLangIdTestData::kTestStrSI},
+      {"sk", NNetLangIdTestData::kTestStrSK},
+      {"sl", NNetLangIdTestData::kTestStrSL},
+      {"so", NNetLangIdTestData::kTestStrSO},
+      {"sq", NNetLangIdTestData::kTestStrSQ},
+      {"sr", NNetLangIdTestData::kTestStrSR},
+      {"st", NNetLangIdTestData::kTestStrST},
+      {"su", NNetLangIdTestData::kTestStrSU},
+      {"sv", NNetLangIdTestData::kTestStrSV},
+      {"sw", NNetLangIdTestData::kTestStrSW},
+      {"ta", NNetLangIdTestData::kTestStrTA},
+      {"te", NNetLangIdTestData::kTestStrTE},
+      {"tg", NNetLangIdTestData::kTestStrTG},
+      {"th", NNetLangIdTestData::kTestStrTH},
+      {"tr", NNetLangIdTestData::kTestStrTR},
+      {"uk", NNetLangIdTestData::kTestStrUK},
+      {"ur", NNetLangIdTestData::kTestStrUR},
+      {"uz", NNetLangIdTestData::kTestStrUZ},
+      {"vi", NNetLangIdTestData::kTestStrVI},
+      {"yi", NNetLangIdTestData::kTestStrYI},
+      {"yo", NNetLangIdTestData::kTestStrYO},
+      {"zh", NNetLangIdTestData::kTestStrZH},
+      {"zu", NNetLangIdTestData::kTestStrZU}};
+
+  NNetLanguageIdentifier lang_id(/*min_num_bytes=*/0,
+                                 /*max_num_bytes=*/1000);
+
+  // Iterate over all the test instances, make predictions and check that they
+  // are correct.
+  int num_wrong = 0;
+  for (const auto &test_instance : gold_lang_text) {
+    const std::string &expected_lang = test_instance.first;
+    const std::string &text = test_instance.second;
+
+    const NNetLanguageIdentifier::Result result = lang_id.FindLanguage(text);
+    if (result.language != expected_lang) {
+      ++num_wrong;
+      std::cout << "  Misclassification: " << std::endl;
+      std::cout << "    Text: " << text << std::endl;
+      std::cout << "    Expected language: " << expected_lang << std::endl;
+      std::cout << "    Predicted language: " << result.language << std::endl;
+    }
+  }
+
+  if (num_wrong == 0) {
+    std::cout << "  Success!" << std::endl;
+    return true;
+  } else {
+    std::cout << "  Failure: " << num_wrong << " wrong predictions"
+              << std::endl;
+    return false;
+  }
+}
+
+// Tests the model on input containing multiple languages of different scripts.
+// Returns "true" if the test is successful and "false" otherwise.
+bool TestMultipleLanguagesInInput() {
+  std::cout << "Running " << __FUNCTION__ << std::endl;
+
+  // Text containing snippets in English and Bulgarian.
+  const std::string text =
+      "This piece of text is in English. Този текст е на Български.";
+
+  // Expected language spans in the input text, corresponding respectively to
+  // Bulgarian and English.
+  const std::string expected_bg_span = " Този текст е на Български ";
+  const std::string expected_en_span = " This piece of text is in English ";
+  const float expected_byte_sum =
+      static_cast<float>(expected_bg_span.size() + expected_en_span.size());
+
+  // Number of languages to query for and the expected byte proportions.
+  const int num_queried_langs = 3;
+  const std::unordered_map<string, float> expected_lang_proportions{
+      {"bg", expected_bg_span.size() / expected_byte_sum},
+      {"en", expected_en_span.size() / expected_byte_sum},
+      {NNetLanguageIdentifier::kUnknown, 0.0}};
+
+  NNetLanguageIdentifier lang_id(/*min_num_bytes=*/0,
+                                 /*max_num_bytes=*/1000);
+  const std::vector<NNetLanguageIdentifier::Result> results =
+      lang_id.FindTopNMostFreqLangs(text, num_queried_langs);
+
+  if (results.size() != expected_lang_proportions.size()) {
+    std::cout << "  Failure" << std::endl;
+    std::cout << "  Wrong number of languages: expected "
+              << expected_lang_proportions.size() << ", obtained "
+              << results.size() << std::endl;
+    return false;
+  }
+
+  // Iterate over the results and check that the correct proportions are
+  // returned for the expected languages.
+  const float epsilon = 0.00001f;
+  for (const NNetLanguageIdentifier::Result &result : results) {
+    if (expected_lang_proportions.count(result.language) == 0) {
+      std::cout << "  Failure" << std::endl;
+      std::cout << "  Incorrect language: " << result.language << std::endl;
+      return false;
+    }
+    if (std::abs(result.proportion -
+                 expected_lang_proportions.at(result.language)) > epsilon) {
+      std::cout << "  Failure" << std::endl;
+      std::cout << "  Language " << result.language << ": expected proportion "
+                << expected_lang_proportions.at(result.language) << ", got "
+                << result.proportion << std::endl;
+      return false;
+    }
+
+    // Skip over undefined language.
+    if (result.language == "und")
+      continue;
+    if (result.byte_ranges.size() != 1) {
+      std::cout << " Should only detect one span containing " << result.language
+                << std::endl;
+      return false;
+    }
+    // Check that specified byte ranges for language are correct.
+    int start_index = result.byte_ranges[0].start_index;
+    int end_index = result.byte_ranges[0].end_index;
+    std::string byte_ranges_text = text.substr(start_index, end_index - start_index);
+    if (result.language == "bg") {
+      if (byte_ranges_text.compare("Този текст е на Български.") != 0) {
+        std::cout << " Incorrect byte ranges returned for Bulgarian " << std::endl;
+        return false;
+      }
+    } else if (result.language == "en") {
+      if (byte_ranges_text.compare("This piece of text is in English. ") != 0) {
+        std::cout << " Incorrect byte ranges returned for English " << std::endl;
+        return false;
+      }
+    } else {
+      std::cout << " Got language other than English or Bulgarian "
+                << std::endl;
+      return false;
+    }
+  }
+  std::cout << "  Success!" << std::endl;
+  return true;
+}
+
+}  // namespace nnet_lang_id_test
+}  // namespace chrome_lang_id
+
+// Runs tests for the language identification model.
+int main(int argc, char **argv) {
+  const bool tests_successful =
+      chrome_lang_id::nnet_lang_id_test::TestPredictions() &&
+      chrome_lang_id::nnet_lang_id_test::TestMultipleLanguagesInInput();
+  return tests_successful ? 0 : 1;
+}