In closure_glyph_segmenter_util segmentation analysis use the probability based cost function when computing total cost.

Author: garretrieger

ift/encoder/closure_glyph_segmenter.cc

@@ -20,12 +20,15 @@
 #include "common/hb_set_unique_ptr.h"
 #include "common/int_set.h"
 #include "common/try.h"
+#include "common/woff2.h"
 #include "ift/encoder/activation_condition.h"
 #include "ift/encoder/candidate_merge.h"
 #include "ift/encoder/glyph_segmentation.h"
 #include "ift/encoder/merge_strategy.h"
+#include "ift/encoder/patch_size_cache.h"
 #include "ift/encoder/segmentation_context.h"
 #include "ift/encoder/subset_definition.h"
+#include "ift/freq/probability_calculator.h"
 #include "ift/glyph_keyed_diff.h"
 
 using absl::btree_map;
@@ -47,7 +50,9 @@ using common::IntSet;
 using common::make_hb_face;
 using common::make_hb_set;
 using common::SegmentSet;
+using common::Woff2;
 using ift::GlyphKeyedDiff;
+using ift::freq::ProbabilityCalculator;
 
 namespace ift::encoder {
 
@@ -588,4 +593,75 @@ ClosureGlyphSegmenter::InitializeSegmentationContext(
   return context;
 }
 
+static StatusOr<double> Woff2SizeOf(hb_face_t* original_face,
+                                    const SubsetDefinition& def) {
+  hb_subset_input_t* input = hb_subset_input_create_or_fail();
+  if (!input) {
+    return absl::InternalError("Failed to create subset input.");
+  }
+  def.ConfigureInput(input, original_face);
+
+  hb_face_t* init_face = hb_subset_or_fail(original_face, input);
+  hb_subset_input_destroy(input);
+  if (!init_face) {
+    return absl::InternalError("Failed to create initial face subset.");
+  }
+
+  FontData init_data(init_face);
+  hb_face_destroy(init_face);
+
+  FontData woff2 = TRY(Woff2::EncodeWoff2(init_data.str()));
+  return (double)woff2.size();
+}
+
+StatusOr<SegmentationCost> ClosureGlyphSegmenter::TotalCost(
+    hb_face_t* original_face, const GlyphSegmentation& segmentation,
+    const ProbabilityCalculator& probability_calculator) const {
+  SubsetDefinition non_ift;
+  non_ift.Union(segmentation.InitialFontSegment());
+
+  std::vector<Segment> segments;
+  for (const auto& def : segmentation.Segments()) {
+    non_ift.Union(def);
+
+    auto P = probability_calculator.ComputeProbability(def);
+    Segment s(def, P);
+    segments.push_back(std::move(s));
+  }
+
+  double init_font_size =
+      TRY(Woff2SizeOf(original_face, segmentation.InitialFontSegment()));
+  double non_ift_font_size = TRY(Woff2SizeOf(original_face, non_ift));
+
+  // TODO(garretrieger): for the total cost we need to also add in the table
+  // keyed patch costs
+  //                     may want to use the IFT compiler to produce the
+  //                     complete encoding then compute table keyed costs from
+  //                     that (in conjunction) with probability calculations.
+  double total_cost = init_font_size;
+
+  // Use highest quality so we get the true cost.
+  PatchSizeCacheImpl patch_sizer(original_face, 11);
+  for (const auto& c : segmentation.Conditions()) {
+    double Pc = TRY(c.Probability(segments, probability_calculator));
+    const GlyphSet& gids = segmentation.GidSegments().at(c.activated());
+    double patch_size = (double)TRY(patch_sizer.GetPatchSize(gids));
+    total_cost += Pc * (patch_size + 75);
+  }
+
+  double ideal_cost = 0.0;
+  double incremental_size =
+      non_ift_font_size / (double)non_ift.codepoints.size();
+  for (unsigned cp : non_ift.codepoints) {
+    double Pcp = probability_calculator.ComputeProbability({cp}).Min();
+    ideal_cost += Pcp * incremental_size;
+  }
+
+  return SegmentationCost{
+      .total_cost = total_cost,
+      .cost_for_non_segmented = non_ift_font_size,
+      .ideal_cost = ideal_cost,
+  };
+}
+
 }  // namespace ift::encoder

ift/encoder/closure_glyph_segmenter.h

@@ -9,9 +9,16 @@
 #include "ift/encoder/merge_strategy.h"
 #include "ift/encoder/segmentation_context.h"
 #include "ift/encoder/subset_definition.h"
+#include "ift/freq/probability_calculator.h"
 
 namespace ift::encoder {
 
+struct SegmentationCost {
+  double total_cost;
+  double cost_for_non_segmented;
+  double ideal_cost;
+};
+
 /*
  * This generates a glyph segmentation of a font which satisifies the closure
  * requirement by utilizing a a font subsetter closure function to detect glyph
@@ -48,6 +55,14 @@ class ClosureGlyphSegmenter {
   absl::StatusOr<SegmentationContext> InitializeSegmentationContext(
       hb_face_t* face, SubsetDefinition initial_segment,
       std::vector<Segment> segments, MergeStrategy merge_strategy) const;
+
+  /*
+   * Computes the total cost (expected number of bytes transferred) for a given
+   * segmentation with respect to the provided frequency data.
+   */
+  absl::StatusOr<SegmentationCost> TotalCost(
+      hb_face_t* original_face, const GlyphSegmentation& segmentation,
+      const freq::ProbabilityCalculator& probability_calculator) const;
 };
 
 }  // namespace ift::encoder

ift/encoder/closure_glyph_segmenter_test.cc

@@ -4,16 +4,20 @@
 #include "common/font_helper.h"
 #include "common/int_set.h"
 #include "gtest/gtest.h"
+#include "ift/encoder/glyph_segmentation.h"
 #include "ift/encoder/merge_strategy.h"
 #include "ift/encoder/subset_definition.h"
+#include "ift/freq/probability_bound.h"
 #include "ift/freq/unicode_frequencies.h"
+#include "ift/freq/unigram_probability_calculator.h"
 
 using common::CodepointSet;
 using common::FontData;
 using common::hb_face_unique_ptr;
 using common::IntSet;
 using common::make_hb_face;
 using ift::freq::UnicodeFrequencies;
+using ift::freq::UnigramProbabilityCalculator;
 
 namespace ift::encoder {
 
@@ -725,6 +729,47 @@ if (s2) then p1
 )");
 }
 
+TEST_F(ClosureGlyphSegmenterTest, TotalCost) {
+  UnicodeFrequencies frequencies{
+      {{' ', ' '}, 100}, {{'a', 'a'}, 95}, {{'b', 'b'}, 1},
+      {{'c', 'c'}, 1},   {{'d', 'd'}, 50}, {{'e', 'e'}, 25},
+  };
+  UnigramProbabilityCalculator calculator(std::move(frequencies));
+
+  // Basic no segment case.
+  GlyphSegmentation segmentation1({'a', 'b', 'c'}, {}, {});
+  auto sc = GlyphSegmentation::GroupsToSegmentation({}, {}, {}, segmentation1);
+  ASSERT_TRUE(sc.ok()) << sc;
+
+  ClosureGlyphSegmenter segmenter;
+  SegmentationCost base_cost =
+      *segmenter.TotalCost(roboto.get(), segmentation1, calculator);
+  ASSERT_GT(base_cost.total_cost, 1000);
+  ASSERT_EQ(base_cost.total_cost, base_cost.cost_for_non_segmented);
+  ASSERT_LT(base_cost.ideal_cost, base_cost.total_cost);
+
+  // Add some patches
+  GlyphSegmentation segmentation2({'a', 'b', 'c'}, {}, {});
+  sc = GlyphSegmentation::GroupsToSegmentation(
+      {
+          {{0}, {100, 101, 102}},
+          {{1}, {103, 104, 105}},
+      },
+      {}, {}, segmentation2);
+  ASSERT_TRUE(sc.ok()) << sc;
+
+  std::vector<SubsetDefinition> segments{
+      {'d'},
+      {'e'},
+  };
+  segmentation2.CopySegments(segments);
+
+  SegmentationCost with_patches_cost =
+      *segmenter.TotalCost(roboto.get(), segmentation2, calculator);
+  ASSERT_GT(with_patches_cost.total_cost, base_cost.total_cost + 400);
+  ASSERT_LT(with_patches_cost.ideal_cost, with_patches_cost.total_cost);
+}
+
 // TODO(garretrieger): add test where or_set glyphs are moved back to unmapped
 // due to found "additional conditions".
 

util/closure_glyph_keyed_segmenter_util.cc

@@ -24,6 +24,7 @@
 #include "ift/encoder/glyph_segmentation.h"
 #include "ift/encoder/merge_strategy.h"
 #include "ift/encoder/subset_definition.h"
+#include "ift/freq/bigram_probability_calculator.h"
 #include "ift/freq/unicode_frequencies.h"
 #include "ift/proto/patch_encoding.h"
 #include "ift/proto/patch_map.h"
@@ -139,8 +140,7 @@ ABSL_FLAG(uint32_t, network_overhead_cost, 75,
           "for each network request.");
 
 // TODO(garretrieger): add additional setting for cost base merging that
-// configures a minimum
-//                     grouping size (in terms of number of codepoints).
+// configures a minimum grouping size (in terms of number of codepoints).
 
 ABSL_FLAG(std::vector<std::string>, optional_feature_tags, {},
           "A list of feature tags which can be optionally added to the font "
@@ -168,6 +168,7 @@ using ift::encoder::GlyphSegmentation;
 using ift::encoder::MergeStrategy;
 using ift::encoder::Segment;
 using ift::encoder::SubsetDefinition;
+using ift::freq::BigramProbabilityCalculator;
 using ift::freq::UnicodeFrequencies;
 using ift::proto::PatchEncoding;
 using ift::proto::PatchMap;
@@ -468,6 +469,63 @@ StatusOr<UnicodeFrequencies> GetFrequencyData(
   return util::LoadFrequenciesFromRiegeli(frequency_data_file.c_str());
 }
 
+// Analysis of segmentation that does not utilize codepoint frequencies.
+static int NonFrequencyAnalysis(hb_face_t* font,
+                                const GlyphSegmentation& segmentation) {
+  auto cost = SegmentationSize(font, segmentation);
+  if (!cost.ok()) {
+    std::cerr << "Failed to compute segmentation cost: " << cost.status()
+              << std::endl;
+    return -1;
+  }
+  auto ideal_cost = IdealSegmentationSize(font, segmentation,
+                                          NumExclusivePatches(segmentation));
+  if (!ideal_cost.ok()) {
+    std::cerr << "Failed to compute ideal segmentation cost: " << cost.status()
+              << std::endl;
+    return -1;
+  }
+
+  std::cerr << std::endl;
+  std::cerr << "glyphs_in_fallback = " << segmentation.UnmappedGlyphs().size()
+            << std::endl;
+  std::cerr << "ideal_cost_bytes = " << *ideal_cost << std::endl;
+  std::cerr << "total_cost_bytes = " << *cost << std::endl;
+
+  double over_ideal_percent =
+      (((double)*cost) / ((double)*ideal_cost) * 100.0) - 100.0;
+  std::cerr << "%_extra_over_ideal = " << over_ideal_percent << std::endl;
+  return 0;
+}
+
+static int AnalysisWithFrequency(hb_face_t* font,
+                                 const GlyphSegmentation& segmentation) {
+  auto freq_data =
+      GetFrequencyData(absl::GetFlag(FLAGS_frequency_data_file), {});
+  if (!freq_data.ok()) {
+    std::cerr << "Failed to load codepoint frequencies: " << freq_data.status()
+              << std::endl;
+    return -1;
+  }
+
+  BigramProbabilityCalculator calculator(std::move(*freq_data));
+
+  ClosureGlyphSegmenter segmenter;
+  auto cost = segmenter.TotalCost(font, segmentation, calculator);
+  if (!cost.ok()) {
+    std::cerr << "Failed to compute cost of segmentation. " << cost.status()
+              << std::endl;
+    return -1;
+  }
+
+  std::cerr << "non_ift_cost_bytes = " << (uint64_t)cost->cost_for_non_segmented
+            << std::endl;
+  std::cerr << "total_cost_bytes = " << (uint64_t)cost->total_cost << std::endl;
+  std::cerr << "ideal_cost_bytes = " << (uint64_t)cost->ideal_cost << std::endl;
+
+  return 0;
+}
+
 int main(int argc, char** argv) {
   absl::SetStderrThreshold(absl::LogSeverityAtLeast::kInfo);
   auto args = absl::ParseCommandLine(argc, argv);
@@ -583,29 +641,9 @@ int main(int argc, char** argv) {
   }
 
   std::cerr << ">> Analysis" << std::endl;
-  auto cost = SegmentationSize(font->get(), *result);
-  if (!cost.ok()) {
-    std::cerr << "Failed to compute segmentation cost: " << cost.status()
-              << std::endl;
-    return -1;
-  }
-  auto ideal_cost =
-      IdealSegmentationSize(font->get(), *result, NumExclusivePatches(*result));
-  if (!ideal_cost.ok()) {
-    std::cerr << "Failed to compute ideal segmentation cost: " << cost.status()
-              << std::endl;
-    return -1;
+  if (FrequenciesAreRequired()) {
+    return AnalysisWithFrequency(font->get(), *result);
+  } else {
+    return NonFrequencyAnalysis(font->get(), *result);
   }
-
-  std::cerr << std::endl;
-  std::cerr << "glyphs_in_fallback = " << result->UnmappedGlyphs().size()
-            << std::endl;
-  std::cerr << "ideal_cost_bytes = " << *ideal_cost << std::endl;
-  std::cerr << "total_cost_bytes = " << *cost << std::endl;
-
-  double over_ideal_percent =
-      (((double)*cost) / ((double)*ideal_cost) * 100.0) - 100.0;
-  std::cerr << "%_extra_over_ideal = " << over_ideal_percent << std::endl;
-
-  return 0;
 }