add bigram compression to makeqstrdata

Compress common unicode bigrams by making code points in the range
0x80 - 0xbf (inclusive) represent them.  Then, they can be greedily
encoded and the substituted code points handled by the existing Huffman
compression.  Normally code points in the range 0x80-0xbf are not used
in Unicode, so we stake our own claim.  Using the more arguably correct
"Private Use Area" (PUA) would mean that for scripts that only use
code points under 256 we would use more memory for the "values" table.

bigram means "two letters", and is also sometimes called a "digram".
It's nothing to do with "big RAM".  For our purposes, a bigram represents
two successive unicode code points, so for instance in our build on
trinket m0 for english the most frequent are:
['t ', 'e ', 'in', 'd ', ...].

The bigrams are selected based on frequency in the corpus, but the
selection is not necessarily optimal, for these reasons I can think of:
 * Suppose the corpus was just "tea" repeated 100 times.  The
   top bigrams would be "te", and "ea".  However,
   overlap, "te" could never be used.  Thus, some bigrams might actually
   waste space
    * I _assume_ this has to be why e.g., bigram 0x86 "s " is more
      frequent than bigram 0x85 " a" in English for Trinket M0, because
      sequences like "can't add" would get the "t " digram and then
      be unable to use the " a" digram.

 * And generally, if a bigram is frequent then so are its constituents.
   Say that "i" and "n" both encode to just 5 or 6 bits, then the huffman
   code for "in" had better compress to 10 or fewer bits or it's a net
   loss!
    * I checked though!  "i" is 5 bits, "n" is 6 bits (lucky guess)
      but the bigram 0x83 also just 6 bits, so this one is a win of
      5 bits for every "it" minus overhead.  Yay, this round goes to team
      compression.
    * On the other hand, the least frequent bigram 0x9d " n" is 10 bits
      long and its constituent code points are 4+6 bits so there's no
      savings, but there is the cost of the table entry.
    * and somehow 0x9f 'an' is never used at all!

With or without accounting for overlaps, there is some optimum number
of bigrams.  Adding one more bigram uses at least 2 bytes (for the
entry in the bigram table; 4 bytes if code points >255 are in the
source text) and also needs a slot in the Huffman dictionary, so
adding bigrams beyond the optimim number makes compression worse again.

If it's an improvement, the fact that it's not guaranteed optimal
doesn't seem to matter too much.  It just leaves a little more fruit
for the next sweep to pick up.  Perhaps try adding the most frequent
bigram not yet present, until it doesn't improve compression overall.

Right now, de_DE is again the "fullest" build on trinket_m0.  (It's
reclaimed that spot from the ja translation somehow)  This change saves
104 bytes there, increasing free space about 6.8%.  In the larger
(but not critically full) pyportal build it saves 324 bytes.

The specific number of bigrams used (32) was chosen as it is the max
number that fit within the 0x80..0xbf range.  Larger tables would
require the use of 16 bit code points in the de_DE build, losing savings
overall.

(Side note: The most frequent letters in English have been said
to be: ETA OIN SHRDLU; but we have UAC EIL MOPRST in our corpus)

Author: jepler

py/makeqstrdata.py

@@ -100,9 +100,30 @@ def translate(translation_file, i18ns):
             translations.append((original, translation))
         return translations
 
+def frequent_ngrams(corpus, sz, n):
+    return collections.Counter(corpus[i:i+sz] for i in range(len(corpus)-sz)).most_common(n)
+
+def ngrams_to_pua(translation, ngrams):
+    if len(ngrams) > 32:
+        start = 0xe000
+    else:
+        start = 0x80
+    for i, g in enumerate(ngrams):
+        translation = translation.replace(g, chr(start + i))
+    return translation
+
+def pua_to_ngrams(compressed, ngrams):
+    if len(ngrams) > 32:
+        start, end = 0xe000, 0xf8ff
+    else:
+        start, end = 0x80, 0xbf
+    return "".join(ngrams[ord(c) - start] if (start <= ord(c) <= end) else c for c in compressed)
+
 def compute_huffman_coding(translations, qstrs, compression_filename):
     all_strings = [x[1] for x in translations]
     all_strings_concat = "".join(all_strings)
+    ngrams = [i[0] for i in frequent_ngrams(all_strings_concat, 2, 32)]
+    all_strings_concat = ngrams_to_pua(all_strings_concat, ngrams)
     counts = collections.Counter(all_strings_concat)
     cb = huffman.codebook(counts.items())
     values = []
@@ -128,18 +149,20 @@ def compute_huffman_coding(translations, qstrs, compression_filename):
     for i in range(1, max(length_count) + 2):
         lengths.append(length_count.get(i, 0))
     print("// values", values, "lengths", len(lengths), lengths)
-    print("// estimated total memory size", len(lengths) + 2*len(values) + sum(len(cb[u]) for u in all_strings_concat))
+    ngramdata = [ord(ni) for i in ngrams for ni in i]
+    print("// estimated total memory size", len(lengths) + 2*len(values) + 2 * len(ngramdata) + sum((len(cb[u]) + 7)//8 for u in all_strings_concat))
     print("//", values, lengths)
     values_type = "uint16_t" if max(ord(u) for u in values) > 255 else "uint8_t"
     max_translation_encoded_length = max(len(translation.encode("utf-8")) for original,translation in translations)
     with open(compression_filename, "w") as f:
         f.write("const uint8_t lengths[] = {{ {} }};\n".format(", ".join(map(str, lengths))))
         f.write("const {} values[] = {{ {} }};\n".format(values_type, ", ".join(str(ord(u)) for u in values)))
         f.write("#define compress_max_length_bits ({})\n".format(max_translation_encoded_length.bit_length()))
-    return values, lengths
+        f.write("const {} ngrams[] = {{ {} }};\n".format(values_type, ", ".join(str(u) for u in ngramdata)))
+    return values, lengths, ngrams
 
 def decompress(encoding_table, encoded, encoded_length_bits):
-    values, lengths = encoding_table
+    values, lengths, ngrams = encoding_table
     dec = []
     this_byte = 0
     this_bit = 7
@@ -187,14 +210,16 @@ def decompress(encoding_table, encoded, encoded_length_bits):
             searched_length += lengths[bit_length]
 
         v = values[searched_length + bits - max_code]
+        v = pua_to_ngrams(v, ngrams)
         i += len(v.encode('utf-8'))
         dec.append(v)
     return ''.join(dec)
 
 def compress(encoding_table, decompressed, encoded_length_bits, len_translation_encoded):
     if not isinstance(decompressed, str):
         raise TypeError()
-    values, lengths = encoding_table
+    values, lengths, ngrams = encoding_table
+    decompressed = ngrams_to_pua(decompressed, ngrams)
     enc = bytearray(len(decompressed) * 3)
     #print(decompressed)
     #print(lengths)

supervisor/shared/translate.c

@@ -34,6 +34,7 @@
 #include "genhdr/compression.generated.h"
 #endif
 
+#include "py/misc.h"
 #include "supervisor/serial.h"
 
 void serial_write_compressed(const compressed_string_t* compressed) {
@@ -46,10 +47,18 @@ STATIC int put_utf8(char *buf, int u) {
     if(u <= 0x7f) {
         *buf = u;
         return 1;
+    } else if(MP_ARRAY_SIZE(ngrams) <= 64 && u <= 0xbf) {
+        int n = (u - 0x80) * 2;
+        int ret = put_utf8(buf, ngrams[n]);
+        return ret + put_utf8(buf + ret, ngrams[n+1]);
     } else if(u <= 0x07ff) {
         *buf++ = 0b11000000 | (u >> 6);
         *buf   = 0b10000000 | (u & 0b00111111);
         return 2;
+    } else if(MP_ARRAY_SIZE(ngrams) > 64 && u >= 0xe000 && u <= 0xf8ff) {
+        int n = (u - 0xe000) * 2;
+        int ret = put_utf8(buf, ngrams[n]);
+        return ret + put_utf8(buf + ret, ngrams[n+1]);
     } else { // u <= 0xffff)
         *buf++ = 0b11000000 | (u >> 12);
         *buf   = 0b10000000 | ((u >> 6) & 0b00111111);