Integrate RankerModelLoader with TranslateRanker.

components/translate/core/browser/translate_ranker_impl.cc

+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "components/translate/core/browser/translate_ranker_impl.h"
+
+#include <cmath>
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "base/command_line.h"
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
+#include "base/memory/ptr_util.h"
+#include "base/metrics/histogram_macros.h"
+#include "base/profiler/scoped_tracker.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.h"
+#include "base/task_runner.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "components/metrics/proto/translate_event.pb.h"
+#include "components/translate/core/browser/proto/ranker_model.pb.h"
+#include "components/translate/core/browser/proto/translate_ranker_model.pb.h"
+#include "components/translate/core/browser/ranker_model.h"
+#include "components/translate/core/browser/translate_download_manager.h"
+#include "components/translate/core/browser/translate_prefs.h"
+#include "components/translate/core/browser/translate_url_fetcher.h"
+#include "components/translate/core/common/translate_switches.h"
+#include "components/variations/variations_associated_data.h"
+#include "url/gurl.h"
+
+namespace translate {
+
+namespace {
+
+using chrome_intelligence::RankerModel;
+using chrome_intelligence::RankerModelProto;
+using chrome_intelligence::TranslateRankerModel;
+
+const double kTranslationOfferThreshold = 0.5;
+
+const char kTranslateRankerModelFileName[] = "Translate Ranker Model";
+const char kUmaPrefix[] = "Translate.Ranker";
+const char kUnknown[] = "UNKNOWN";
+
+double Sigmoid(double x) {
+  return 1.0 / (1.0 + exp(-x));
+}
+
+double SafeRatio(int numerator, int denominator) {
+  return denominator ? (numerator / static_cast<double>(denominator)) : 0.0;
+}
+
+double ScoreComponent(const google::protobuf::Map<std::string, float>& weights,
+                      const std::string& key) {
+  auto i = weights.find(base::ToLowerASCII(key));
+  if (i == weights.end())
+    i = weights.find(kUnknown);
+  return i == weights.end() ? 0.0 : i->second;
+}
+
+RankerModelStatus ValidateModel(const RankerModel& model) {
+  if (model.proto().model_case() != RankerModelProto::kTranslate)
+    return RankerModelStatus::VALIDATION_FAILED;
+
+  if (model.proto().translate().model_revision_case() !=
+      TranslateRankerModel::kLogisticRegressionModel) {
+    return RankerModelStatus::INCOMPATIBLE;
+  }
+
+  return RankerModelStatus::OK;
+}
+
+}  // namespace
+
+const base::Feature kTranslateRankerQuery{"TranslateRankerQuery",
+                                          base::FEATURE_DISABLED_BY_DEFAULT};
+
+const base::Feature kTranslateRankerEnforcement{
+    "TranslateRankerEnforcement", base::FEATURE_DISABLED_BY_DEFAULT};
+
+#if defined(CWV_IMPLEMENTATION)

[sdefresne, 2017/04/04 09:40:23]

This macro will not be defined when building the file as part of building
ChromeWebView on iOS (the macro is only defined when building the files in
src/ios/web_view and is an implementation detail). Thus this test will always be
false, and the second branch will be taken on iOS, even when building
ChromeWebView on iOS.

All files in components will be built the same way when building both Chrome and
ChromeWebView (i.e. the same build flags, same macro defined, ...). You can
check that by adding #error in that branch of the #if and you'll see that the
build succeed on all iOS bots. The CWV_IMPLEMENTATION is only used to set the
symbol visibility while building the library (like BASE_EXPORT).

If you want this code to behave differently when used from Chrome or
ChromeWebView, then the configuration need to be done at runtime instead of
compile time.

[Roger McFarlane (Chromium), 2017/04/04 17:03:06]

Thanks for clarifying that!

Are you aware of any way to check at run-time whether this is Chrome or
web-view?

[Eugene But (OOO till 7-30), 2017/04/04 18:19:00]

There is no way to check that. //component layer does not and should not know
about chrome and ios_web_view layers.

[Roger McFarlane (Chromium), 2017/04/04 19:16:06]

Fair enough.

Added a member to track whether or not logging is enabled. This is set shortly
after construction by the ios web view translate ranker factory.

+const base::Feature kTranslateRankerLogging{"TranslateRankerLogging",
+                                            base::FEATURE_DISABLED_BY_DEFAULT};
+#else
+const base::Feature kTranslateRankerLogging{"TranslateRankerLogging",
+                                            base::FEATURE_ENABLED_BY_DEFAULT};
+#endif
+
+TranslateRankerFeatures::TranslateRankerFeatures() {}
+
+TranslateRankerFeatures::TranslateRankerFeatures(int accepted,
+                                                 int denied,
+                                                 int ignored,
+                                                 const std::string& src,
+                                                 const std::string& dst,
+                                                 const std::string& cntry,
+                                                 const std::string& locale)
+    : accepted_count(accepted),
+      denied_count(denied),
+      ignored_count(ignored),
+      total_count(accepted_count + denied_count + ignored_count),
+      src_lang(src),
+      dst_lang(dst),
+      country(cntry),
+      app_locale(locale),
+      accepted_ratio(SafeRatio(accepted_count, total_count)),
+      denied_ratio(SafeRatio(denied_count, total_count)),
+      ignored_ratio(SafeRatio(ignored_count, total_count)) {}
+
+TranslateRankerFeatures::TranslateRankerFeatures(const TranslatePrefs& prefs,
+                                                 const std::string& src,
+                                                 const std::string& dst,
+                                                 const std::string& locale)
+    : TranslateRankerFeatures(prefs.GetTranslationAcceptedCount(src),
+                              prefs.GetTranslationDeniedCount(src),
+                              prefs.GetTranslationIgnoredCount(src),
+                              src,
+                              dst,
+                              prefs.GetCountry(),
+                              locale) {}
+
+TranslateRankerFeatures::~TranslateRankerFeatures() {}
+
+void TranslateRankerFeatures::WriteTo(std::ostream& stream) const {
+  stream << "src_lang='" << src_lang << "', "
+         << "dst_lang='" << dst_lang << "', "
+         << "country='" << country << "', "
+         << "app_locale='" << app_locale << "', "
+         << "accept_count=" << accepted_count << ", "
+         << "denied_count=" << denied_count << ", "
+         << "ignored_count=" << ignored_count << ", "
+         << "total_count=" << total_count << ", "
+         << "accept_ratio=" << accepted_ratio << ", "
+         << "decline_ratio=" << denied_ratio << ", "
+         << "ignore_ratio=" << ignored_ratio;
+}
+
+TranslateRankerImpl::TranslateRankerImpl(const base::FilePath& model_path,
+                                         const GURL& model_url)
+    : weak_ptr_factory_(this) {
+  if (IsQueryEnabled() || IsEnforcementEnabled()) {
+    model_loader_ = base::MakeUnique<RankerModelLoader>(
+        base::Bind(&ValidateModel),
+        base::Bind(&TranslateRankerImpl::OnModelAvailable,
+                   weak_ptr_factory_.GetWeakPtr()),
+        model_path, model_url, kUmaPrefix);
+    model_loader_->Start();
+  }
+}
+
+TranslateRankerImpl::~TranslateRankerImpl() {}
+
+// static
+base::FilePath TranslateRankerImpl::GetModelPath(
+    const base::FilePath& data_dir) {
+  if (data_dir.empty())
+    return base::FilePath();
+
+  // Otherwise, look for the file in data dir.
+  return data_dir.AppendASCII(kTranslateRankerModelFileName);
+}
+
+// static
+GURL TranslateRankerImpl::GetModelURL() {
+  // Allow override of the ranker model URL from the command line.
+  std::string raw_url;
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kTranslateRankerModelURL)) {
+    raw_url =
+        command_line->GetSwitchValueASCII(switches::kTranslateRankerModelURL);
+  } else {
+    // Otherwise take the ranker model URL from the ranker query variation.
+    raw_url = variations::GetVariationParamValueByFeature(
+        kTranslateRankerQuery, switches::kTranslateRankerModelURL);
+  }
+
+  DVLOG(3) << switches::kTranslateRankerModelURL << " = " << raw_url;
+
+  return GURL(raw_url);
+}
+
+bool TranslateRankerImpl::IsLoggingEnabled() {
+  return base::FeatureList::IsEnabled(kTranslateRankerLogging);
+}
+
+bool TranslateRankerImpl::IsQueryEnabled() {
+  return base::FeatureList::IsEnabled(kTranslateRankerQuery);
+}
+
+bool TranslateRankerImpl::IsEnforcementEnabled() {
+  return base::FeatureList::IsEnabled(kTranslateRankerEnforcement);
+}
+
+int TranslateRankerImpl::GetModelVersion() const {
+  return model_ ? model_->proto().translate().version() : 0;
+}
+
+bool TranslateRankerImpl::ShouldOfferTranslation(
+    const TranslatePrefs& translate_prefs,
+    const std::string& src_lang,
+    const std::string& dst_lang) {
+  DCHECK(sequence_checker_.CalledOnValidSequence());
+  // The ranker is a gate in the "show a translation prompt" flow. To retain
+  // the pre-existing functionality, it defaults to returning true in the
+  // absence of a model or if enforcement is disabled. As this is ranker is
+  // subsumed into a more general assist ranker, this default will go away
+  // (or become False).
+  const bool kDefaultResponse = true;
+
+  if (model_loader_)
+    model_loader_->NotifyOfRankerActivity();
+
+  // If we don't have a model, request one and return the default.
+  if (model_ == nullptr) {
+    return kDefaultResponse;
+  }
+
+  SCOPED_UMA_HISTOGRAM_TIMER("Translate.Ranker.Timer.ShouldOfferTranslation");
+
+  // TODO(rogerm): Remove ScopedTracker below once crbug.com/646711 is closed.
+  tracked_objects::ScopedTracker tracking_profile(
+      FROM_HERE_WITH_EXPLICIT_FUNCTION(
+          "646711 translate::TranslateRankerImpl::ShouldOfferTranslation"));
+
+  TranslateRankerFeatures features(
+      translate_prefs, src_lang, dst_lang,
+      TranslateDownloadManager::GetInstance()->application_locale());
+
+  double score = CalculateScore(features);
+
+  DVLOG(2) << "TranslateRankerImpl::ShouldOfferTranslation: "
+           << "Score = " << score << ", Features=[" << features << "]";
+
+  bool result = (score >= kTranslationOfferThreshold);
+
+  UMA_HISTOGRAM_BOOLEAN("Translate.Ranker.QueryResult", result);
+
+  return result;
+}
+
+double TranslateRankerImpl::CalculateScore(
+    const TranslateRankerFeatures& features) {
+  DCHECK(sequence_checker_.CalledOnValidSequence());
+  SCOPED_UMA_HISTOGRAM_TIMER("Translate.Ranker.Timer.CalculateScore");
+  DCHECK(model_ != nullptr);
+  const TranslateRankerModel::LogisticRegressionModel& logit =
+      model_->proto().translate().logistic_regression_model();
+
+  double dot_product =
+      (features.accepted_count * logit.accept_count_weight()) +
+      (features.denied_count * logit.decline_count_weight()) +
+      (features.ignored_count * logit.ignore_count_weight()) +
+      (features.accepted_ratio * logit.accept_ratio_weight()) +
+      (features.denied_ratio * logit.decline_ratio_weight()) +
+      (features.ignored_ratio * logit.ignore_ratio_weight()) +
+      ScoreComponent(logit.source_language_weight(), features.src_lang) +
+      ScoreComponent(logit.dest_language_weight(), features.dst_lang) +
+      ScoreComponent(logit.country_weight(), features.country) +
+      ScoreComponent(logit.locale_weight(), features.app_locale);
+
+  return Sigmoid(dot_product + logit.bias());
+}
+
+void TranslateRankerImpl::FlushTranslateEvents(
+    std::vector<metrics::TranslateEventProto>* events) {
+  DCHECK(sequence_checker_.CalledOnValidSequence());
+  DVLOG(3) << "Flushing translate ranker events.";
+  events->swap(event_cache_);
+  event_cache_.clear();
+}
+
+void TranslateRankerImpl::AddTranslateEvent(
+    const metrics::TranslateEventProto& event) {
+  DCHECK(sequence_checker_.CalledOnValidSequence());
+  if (IsLoggingEnabled()) {
+    DVLOG(3) << "Adding translate ranker event.";
+    event_cache_.push_back(event);
+  }
+}
+
+void TranslateRankerImpl::OnModelAvailable(std::unique_ptr<RankerModel> model) {
+  DCHECK(sequence_checker_.CalledOnValidSequence());
+  model_ = std::move(model);
+}
+
+bool TranslateRankerImpl::CheckModelLoaderForTesting() {
+  return model_loader_ != nullptr;
+}
+
+}  // namespace translate
+
+std::ostream& operator<<(std::ostream& stream,
+                         const translate::TranslateRankerFeatures& features) {
+  features.WriteTo(stream);
+  return stream;
+}