Add 'preprocess merging' configuration to the segmenter config.

When enabled this merges adjacent segments below a given probability threshold before any other processing (such as closure analysis) occurs. Can be used to speed up segmenter and merging analysis by premerging low probability segments.

Author: garretrieger

ift/encoder/closure_glyph_segmenter.cc

@@ -24,6 +24,7 @@
 #include "ift/encoder/glyph_segmentation.h"
 #include "ift/encoder/merge_strategy.h"
 #include "ift/encoder/merger.h"
+#include "ift/encoder/segment.h"
 #include "ift/encoder/segmentation_context.h"
 #include "ift/encoder/subset_definition.h"
 #include "ift/encoder/types.h"
@@ -191,6 +192,67 @@ struct SegmentOrdering {
   }
 };
 
+static std::vector<Segment> PreGroupSegments(
+  const btree_map<SegmentSet, MergeStrategy>& merge_groups,
+  const std::vector<SegmentOrdering>& ordering,
+  const std::vector<SubsetDefinition>& subset_definitions,
+  std::vector<uint32_t>& segment_index_map
+) {
+  segment_index_map.resize(subset_definitions.size());
+  std::vector<Segment> segments;
+
+  unsigned i = 0;
+  unsigned last_group_index = 0;
+  auto merge_group_it = merge_groups.begin();
+  auto ordering_it = ordering.begin();
+
+  while (ordering_it != ordering.end())  {
+    const auto& o = *ordering_it;
+    if (o.group_index != last_group_index && merge_group_it != merge_groups.end()) {
+      merge_group_it++;
+    }
+
+    const MergeStrategy* strategy = nullptr;
+    if (merge_group_it != merge_groups.end()) {
+      strategy = &(merge_group_it->second);
+    }
+
+    Segment segment = Segment{subset_definitions[o.original_index], o.probability};
+    if (strategy == nullptr ||
+        strategy->PreClosureGroupSize() <= 1 ||
+        o.probability.Max() > strategy->PreClosureProbabilityThreshold()) {
+      segment_index_map[o.original_index] = i;
+    } else {
+      uint32_t remaining = strategy->PreClosureGroupSize() - 1;
+      while (remaining > 0) {
+        ordering_it++;
+        if (ordering_it == ordering.end() ||
+            ordering_it->group_index != last_group_index) {
+          // Not consuming this item.
+          ordering_it--;
+          break;
+        }
+
+        segment.Definition().Union(subset_definitions[ordering_it->original_index]);
+        segment_index_map[ordering_it->original_index] = i;
+
+        remaining--;
+      }
+
+      if (strategy->UseCosts()) {
+        segment.SetProbability(strategy->ProbabilityCalculator()->ComputeProbability(segment.Definition()));
+      }
+    }
+
+    last_group_index = o.group_index;
+    segments.push_back(segment);
+    ordering_it++;
+    i++;
+  }
+
+  return segments;
+}
+
 // Converts the input subset definitions to a sorted list of segments, remaps
 // the merge_groups segment set keys to reflect the ordering changes.
 static StatusOr<std::vector<Segment>> ToOrderedSegments(
@@ -266,16 +328,12 @@ static StatusOr<std::vector<Segment>> ToOrderedSegments(
   std::sort(ordering.begin(), ordering.end());
 
   // maps from index in subset_definitions to the new ordering.
-  std::vector<uint32_t> segment_index_map(subset_definitions.size());
-  std::vector<Segment> segments;
-  unsigned i = 0;
-  for (const auto& ordering : ordering) {
-    segments.push_back(Segment{subset_definitions[ordering.original_index],
-                               ordering.probability});
-    segment_index_map[ordering.original_index] = i++;
-  }
+  std::vector<uint32_t> segment_index_map;
+  std::vector<Segment> segments = PreGroupSegments(merge_groups, ordering, subset_definitions, segment_index_map);
+  VLOG(0) << segments.size() << " segments after pregrouping.";
 
   btree_map<SegmentSet, MergeStrategy> new_merge_groups;
+  group_index = 0;
   for (auto& [segments, strategy] : merge_groups) {
     SegmentSet remapped;
     SegmentSet remapped_full;
@@ -287,6 +345,10 @@ static StatusOr<std::vector<Segment>> ToOrderedSegments(
       remapped_full.insert(s_prime);
     }
 
+
+    VLOG(0) << "  Merge group " << group_index << " has " << remapped.size() << " segments.";
+    group_index++;
+
     if (!new_merge_groups.insert(std::make_pair(remapped, std::move(strategy)))
              .second) {
       return absl::InvalidArgumentError(

ift/encoder/closure_glyph_segmenter_test.cc

@@ -1427,6 +1427,77 @@ if (s0 AND s2) then p2
 )");
 }
 
+
+TEST_F(ClosureGlyphSegmenterTest, MultipleMergeGroups_PreGrouping) {
+  UnicodeFrequencies freq{
+    {{' ', ' '}, 100},
+    {{'d', 'd'}, 100},
+    {{'a', 'a'}, 60},
+    {{'e', 'e'}, 30},
+    {{'b', 'b'}, 29},
+    {{'f', 'f'}, 28},
+    {{'c', 'c'}, 10},
+    {{'g', 'g'}, 9},
+    {{'h', 'h'}, 5},
+    {{'i', 'i'}, 1}, // 8
+  };
+
+  MergeStrategy costs = *MergeStrategy::CostBased(std::move(freq), 0, 1);
+  costs.SetPreClosureProbabilityThreshold(0.55);
+  costs.SetPreClosureGroupSize(3);
+
+  btree_map<SegmentSet, MergeStrategy> merge_groups{
+      {{0, 1, 2, 3, 4, 5, 6, 7, 8}, costs},
+      {{7, 8}, MergeStrategy::Heuristic(1)},
+  };
+
+  auto segmentation = segmenter.CodepointToGlyphSegments(roboto.get(), {},
+                                                         {
+                                                             {'a'},
+                                                             {'b'},
+                                                             {'c'},
+                                                             {'d'},
+                                                             {'e'},
+                                                             {'f'},
+                                                             {'g'},
+                                                             {'h'},
+                                                             {'i'},
+                                                         },
+                                                         merge_groups, false);
+  ASSERT_TRUE(segmentation.ok()) << segmentation.status();
+
+  // f + i would normally be a good merge, but here it's skipped since it
+  // spans merge groups.
+  std::vector<SubsetDefinition> expected_segments = {
+      // Group 1
+      {'d'},
+      {'a'},
+      {'e', 'b', 'f'}, // pre merge
+      {'c', 'g'},      // pre merge
+      // Shared
+      {'h'},
+      {'i'},
+  };
+  ASSERT_EQ(segmentation->Segments(), expected_segments);
+  ASSERT_EQ(segmentation->ToString(),
+            R"(initial font: { gid0 }
+p0: { gid72 }
+p1: { gid69 }
+p2: { gid70, gid73, gid74 }
+p3: { gid71, gid75 }
+p4: { gid76 }
+p5: { gid77 }
+p6: { gid444, gid446 }
+if (s0) then p0
+if (s1) then p1
+if (s2) then p2
+if (s3) then p3
+if (s4) then p4
+if (s5) then p5
+if (s2 AND s5) then p6
+)");
+}
+
 // TODO(garretrieger): test that segments are excluded by init font segment. ie.
 // if a segment is present in the init font then it should be cleared out in the
 // segmentation.

ift/encoder/merge_strategy.h

@@ -145,6 +145,22 @@ class MergeStrategy {
     return init_font_merge_probability_threshold_;
   }
 
+  uint32_t PreClosureGroupSize() const {
+    return pre_closure_group_size_;
+  }
+
+  double PreClosureProbabilityThreshold() const {
+    return pre_closure_probability_threshold_;
+  }
+
+  void SetPreClosureGroupSize(uint32_t value) {
+    pre_closure_group_size_ = value;
+  }
+
+  void SetPreClosureProbabilityThreshold(double value) {
+    pre_closure_probability_threshold_ = value;
+  }
+
   void SetInitFontMergeThreshold(std::optional<double> value) {
     init_font_merge_threshold_ = value;
   }
@@ -187,6 +203,9 @@ class MergeStrategy {
   std::optional<double> init_font_merge_probability_threshold_ = std::nullopt;
   bool use_patch_merges_ = false;
 
+  uint32_t pre_closure_group_size_ = 1;
+  double pre_closure_probability_threshold_ = 0.0;
+
   std::shared_ptr<freq::ProbabilityCalculator> probability_calculator_;
 };
 

util/closure_glyph_keyed_segmenter_util.cc

@@ -142,7 +142,7 @@ static Status Main(const std::vector<char*> args) {
       TRY(config_util.ConfigToMergeGroups(config, font_codepoints, segments));
 
   ClosureGlyphSegmenter segmenter(config.brotli_quality(),
-                                  config.brotli_quality_for_init_font_merge());
+                                  config.brotli_quality_for_initial_font_merging());
   GlyphSegmentation segmentation = TRY(segmenter.CodepointToGlyphSegments(
       font.get(), init_segment, segments, merge_groups,
       config.move_fallback_glyphs_into_initial_font()));

util/generate_table_keyed_config.cc

@@ -81,22 +81,6 @@ static StatusOr<SegmentationPlan> LoadSegmentationPlan(const char* path) {
 int main(int argc, char** argv) {
   auto args = absl::ParseCommandLine(argc, argv);
 
-  if (args.size() <= 1) {
-    std::cerr << "Usage:" << std::endl
-              << "generate_table_keyed_config <initial font subset fil> "
-                 "<table keyed subset 1 file> [... <table keyed subset file n>]"
-              << std::endl
-              << std::endl
-              << "Where a subset file lists one codepoint per line in "
-                 "hexadecimal format: 0xXXXX"
-              << std::endl
-              << std::endl
-              << "If you don't want the config to contain an initial codepoint "
-                 "set, pass an empty file as the first argument."
-              << std::endl;
-    return -1;
-  }
-
   SegmentationPlan config;
   CodepointSet init_codepoints;
 
@@ -115,6 +99,20 @@ int main(int argc, char** argv) {
 
     CodepointSet empty;
     sets.push_back(empty);
+  } else if (args.size() <= 1) {
+    std::cerr << "Usage:" << std::endl
+              << "generate_table_keyed_config <initial font subset file> "
+                 "<table keyed subset 1 file> [... <table keyed subset file n>]"
+              << std::endl
+              << std::endl
+              << "Where a subset file lists one codepoint per line in "
+                 "hexadecimal format: 0xXXXX"
+              << std::endl
+              << std::endl
+              << "If you don't want the config to contain an initial codepoint "
+                 "set, pass an empty file as the first argument."
+              << std::endl;
+    return -1;
   }
 
   for (size_t i = 1; i < args.size(); i++) {