Omnibox - Boost Frequency Scores Based on Number of Matching Pages

components/omnibox/browser/scored_history_match.cc

 // Copyright (c) 2012 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/omnibox/browser/scored_history_match.h"
 
 #include <math.h>
 
 #include <algorithm>
 #include <vector>
@@ skipping 91 matching lines @@
 }
 
 }  // namespace
 
 // static
 bool ScoredHistoryMatch::also_do_hup_like_scoring_;
 float ScoredHistoryMatch::bookmark_value_;
 float ScoredHistoryMatch::typed_value_;
 bool ScoredHistoryMatch::fix_few_visits_bug_;
 bool ScoredHistoryMatch::frequency_uses_sum_;
+OmniboxFieldTrial::NumMatchesScores*
+    ScoredHistoryMatch::num_matches_to_document_specificity_score_ = nullptr;
 size_t ScoredHistoryMatch::max_visits_to_score_;
 bool ScoredHistoryMatch::allow_tld_matches_;
 bool ScoredHistoryMatch::allow_scheme_matches_;
 size_t ScoredHistoryMatch::num_title_words_to_allow_;
 bool ScoredHistoryMatch::hqp_experimental_scoring_enabled_;
 
 // Default topicality threshold.  See GetTopicalityScore() for details.
 float ScoredHistoryMatch::topicality_threshold_ = 0.8f;
 
 // Default HQP relevance buckets. See GetFinalRelevancyScore() for more details
 // on these numbers.
 char ScoredHistoryMatch::hqp_relevance_buckets_str_[] =
     "0.0:400,1.5:600,5.0:900,10.5:1203,15.0:1300,20.0:1399";
 std::vector<ScoredHistoryMatch::ScoreMaxRelevance>*
     ScoredHistoryMatch::hqp_relevance_buckets_ = nullptr;
 
 ScoredHistoryMatch::ScoredHistoryMatch()
     : ScoredHistoryMatch(history::URLRow(),
                          VisitInfoVector(),
                          base::string16(),
                          String16Vector(),
                          WordStarts(),
                          RowWordStarts(),
                          false,
-                         base::Time::Max()) {
-}
+                         1,
+                         base::Time::Max()) {}
 
 ScoredHistoryMatch::ScoredHistoryMatch(
     const history::URLRow& row,
     const VisitInfoVector& visits,
     const base::string16& lower_string,
     const String16Vector& terms_vector,
     const WordStarts& terms_to_word_starts_offsets,
     const RowWordStarts& word_starts,
     bool is_url_bookmarked,
+    size_t num_matching_pages,
     base::Time now)
     : HistoryMatch(row, 0, false, false), raw_score(0) {
   // NOTE: Call Init() before doing any validity checking to ensure that the
   // class is always initialized after an instance has been constructed. In
   // particular, this ensures that the class is initialized after an instance
   // has been constructed via the no-args constructor.
   ScoredHistoryMatch::Init();
 
   // Figure out where each search term appears in the URL and/or page title
   // so that we can score as well as provide autocomplete highlighting.
@@ skipping 97 matching lines @@
         likely_can_inline = true;
         innermost_match = (best_inlineable_prefix->num_components ==
                            best_prefix->num_components);
       }
     }
   }
 
   const float topicality_score = GetTopicalityScore(
       terms_vector.size(), url, terms_to_word_starts_offsets, word_starts);
   const float frequency_score = GetFrequency(now, is_url_bookmarked, visits);
-  raw_score = base::saturated_cast<int>(GetFinalRelevancyScore(
-      topicality_score, frequency_score, *hqp_relevance_buckets_));
+  const float specificity_score =
+      GetDocumentSpecificityScore(num_matching_pages);
+  raw_score = base::saturated_cast<int>(
+      GetFinalRelevancyScore(topicality_score, frequency_score,
+                             specificity_score, *hqp_relevance_buckets_));
 
   if (also_do_hup_like_scoring_ && likely_can_inline) {
     // HistoryURL-provider-like scoring gives any match that is
     // capable of being inlined a certain minimum score.  Some of these
     // are given a higher score that lets them be shown in inline.
     // This test here derives from the test in
     // HistoryURLProvider::PromoteMatchForInlineAutocomplete().
     const bool promote_to_inline =
         (row.typed_count() > 1) || (IsHostOnly() && (row.typed_count() == 1));
     int hup_like_score =
@@ skipping 129 matching lines @@
   if (initialized)
     return;
 
   initialized = true;
   also_do_hup_like_scoring_ = OmniboxFieldTrial::HQPAlsoDoHUPLikeScoring();
   bookmark_value_ = OmniboxFieldTrial::HQPBookmarkValue();
   typed_value_ = OmniboxFieldTrial::HQPTypedValue();
   max_visits_to_score_ = OmniboxFieldTrial::HQPMaxVisitsToScore();
   frequency_uses_sum_ = OmniboxFieldTrial::HQPFreqencyUsesSum();
   fix_few_visits_bug_ = OmniboxFieldTrial::HQPFixFewVisitsBug();
+  num_matches_to_document_specificity_score_ =
+      new OmniboxFieldTrial::NumMatchesScores();
+  (*num_matches_to_document_specificity_score_) =
+      OmniboxFieldTrial::HQPNumMatchesScores();
   allow_tld_matches_ = OmniboxFieldTrial::HQPAllowMatchInTLDValue();
   allow_scheme_matches_ = OmniboxFieldTrial::HQPAllowMatchInSchemeValue();
   num_title_words_to_allow_ = OmniboxFieldTrial::HQPNumTitleWordsToAllow();
 
   InitRawTermScoreToTopicalityScoreArray();
   InitDaysAgoToRecencyScoreArray();
   InitHQPExperimentalParams();
 }
 
 float ScoredHistoryMatch::GetTopicalityScore(
@@ skipping 184 matching lines @@
   // Compute the average weighted value_of_transition and return it.
   // Use |max_visits_to_score_| as the denominator for the average regardless of
   // how many visits there were in order to penalize a match that has
   // fewer visits than kMaxVisitsToScore.
   if (fix_few_visits_bug_)
     return summed_visit_points / ScoredHistoryMatch::max_visits_to_score_;
   return visits.size() * summed_visit_points /
          ScoredHistoryMatch::max_visits_to_score_;
 }
 
+float ScoredHistoryMatch::GetDocumentSpecificityScore(
+    const size_t num_matching_pages) const {
+  // The floating point value below doesn't matter.

[Peter Kasting, 2016/12/06 05:19:30]

I'm not sure that's true.

Since upper_bound() returns the first element greater than the given value, if
the server sends a score of 1.0 or less for a particular number of pages, this
will fail to match.

A more accurate comment would probably be "The floating point value below must
be less than the lowest score the server would send down" or similar, and a
safer value might be -1.

[Mark P, 2016/12/08 00:21:31]

Good point.  I never imagined a field trial specifying a score of less than 1,
but having an appropriate comment and defensive code makes sense.  Who knows
what I'll want in the future?  :-) Done.

+  OmniboxFieldTrial::NumMatchesScores::const_iterator it =
+      std::upper_bound(num_matches_to_document_specificity_score_->begin(),
+                       num_matches_to_document_specificity_score_->end(),
+                       std::pair<size_t, double>{num_matching_pages, 1.0});
+  if (it == num_matches_to_document_specificity_score_->end())
+    return 1.0;
+  return it->second;

[Peter Kasting, 2016/12/06 05:19:30]

Nit: Could use ?:

[Mark P, 2016/12/08 00:21:31]

Done (after reversing the order, as that read better to me).

[Peter Kasting, 2016/12/08 00:51:40]

My concern with the order reversal is that it sort of violates "don't have
'else' with a negated condition, or the 'else' reads like a double-negative". 
Except here the "else" is the ':'.

So I'd put it back the other way, but up to you.

[Mark P, 2016/12/08 04:37:35]

I understand the point, but I find != end to read to me like a positive
(exists), and when I read == end, I have to mentally reverse it (!exists).

+};
+
 // static
 float ScoredHistoryMatch::GetFinalRelevancyScore(
     float topicality_score,
     float frequency_score,
+    float specificity_score,
     const std::vector<ScoreMaxRelevance>& hqp_relevance_buckets) {
   DCHECK(hqp_relevance_buckets.size() > 0);
   DCHECK_EQ(hqp_relevance_buckets[0].first, 0.0);
 
   if (topicality_score == 0)
     return 0;
-  // Here's how to interpret intermediate_score: Suppose the omnibox
-  // has one input term.  Suppose we have a URL for which the omnibox
+  // Here's how to interpret intermediate_score: Suppose the omnibox has one
+  // input term.  Suppose the input matches many documents.  (This implies
+  // specificity_score == 1.0.)  Suppose we have a URL for which the omnibox
   // input term has a single URL hostname hit at a word boundary.  (This
   // implies topicality_score = 1.0.).  Then the intermediate_score for
   // this URL will depend entirely on the frequency_score with
   // this interpretation:
   // - a single typed visit more than three months ago, no other visits -> 0.2
   // - a visit every three days, no typed visits -> 0.706
   // - a visit every day, no typed visits -> 0.916
   // - a single typed visit yesterday, no other visits -> 2.0
   // - a typed visit once a week -> 11.77
   // - a typed visit every three days -> 14.12
   // - at least ten typed visits today -> 20.0 (maximum score)
   //
   // The below code maps intermediate_score to the range [0, 1399].
   // For example:
   // HQP default scoring buckets: "0.0:400,1.5:600,12.0:1300,20.0:1399"
   // We will linearly interpolate the scores between:
   //      0 to 1.5    --> 400 to 600
   //    1.5 to 12.0   --> 600 to 1300
   //    12.0 to 20.0  --> 1300 to 1399
   //       >= 20.0    --> 1399
   //
   // The score maxes out at 1399 (i.e., cannot beat a good inlineable result
   // from HistoryURL provider).
-  const float intermediate_score = topicality_score * frequency_score;
+  const float intermediate_score =
+      topicality_score * frequency_score * specificity_score;
 
   // Find the threshold where intermediate score is greater than bucket.
   size_t i = 1;
   for (; i < hqp_relevance_buckets.size(); ++i) {
     const ScoreMaxRelevance& hqp_bucket = hqp_relevance_buckets[i];
     if (intermediate_score >= hqp_bucket.first) {
       continue;
     }
     const ScoreMaxRelevance& previous_bucket = hqp_relevance_buckets[i - 1];
     const float slope = ((hqp_bucket.second - previous_bucket.second) /
@@ skipping 56 matching lines @@
           base::StringToDouble(it->first, &bucket.first);
       DCHECK(is_valid_intermediate_score);
       bool is_valid_hqp_score = base::StringToInt(it->second, &bucket.second);
       DCHECK(is_valid_hqp_score);
       hqp_buckets->push_back(bucket);
     }
     return true;
   }
   return false;
 }