理解 transformers 库 GPT2 的 BBPE 分词算法

在 python 中 ord 是直接获得某个字符的 unicode 码点，所谓码点就是对字符的编号， 比如对于经典的 ascii 字符（基本上是标准英文键盘能够直接打出来的字符以及不可见的控制字符）占据了 unicode 的前 128 个编号。

print(ord("1"),ord("c"),ord(" "))

49 99 32

unicode 涵盖范围很大，包括许多表情：

ord("😄")

128516

对于中文字符，unicode 编码一般也都是比较大的编号

ord("你")

20320

以上都是 10 进制表示，更常见的是用 16 进制并且加上 U+ 符号来说明这是一个 unicode 收录的字符：

f'U+00{ord("你"):X}'

U+004F60

搜索 - SYMBL (◕‿◕) 里也可以找到 "你" 对应的 unicode 的十六进制和十进制写法。

注意 unicode 的 16 进制表示和 utf-8 是无关的，unicode 只是负责对几百万字符贴上一个数字标签，其数值是 抽象层面 的，并不是说计算机里 "你" 的表示就是以上的 4F60 。

utf-8 可以看作是 unicode 的一种具体实现，它是另外一套编号，只不过这个编号是 实现层面 （被称为编码）， 比如中文 "你" 的 utf-8 编码的 16 进制表示如下：

print("你".encode("utf-8"))
"你".encode("utf-8").hex()

b'\xe4\xbd\xa0'
e4bda0

结果里第二行的 16 进制和上文 unicode 码点的 16 进制表示 4F60 是完全不同的（至少这里有三个字节）。而 4F60 对应的 10 进制如下

def utf8int(c):
    return int(c.encode("utf-8").hex(), 16)

utf8int("你")

14990752

（注：讨论 utf-8 的十进制没什么意义，因为它不是连续编号，而 unicode 一般是连续的，但这里是和 unicode 比较）

编码再解码：

print("你".encode("utf-8").decode("utf-8"))

你

不过对于 ascii 字符，unicode 和 utf-8 的十进制表示是一样的：

print(ord("1"),ord("q"),ord(" "))

print(utf8int("1"), utf8int("q"), utf8int(" "))

print("1".encode("utf-8"), "q".encode("utf-8"), " ".encode("utf-8"))

49 113 32
49 113 32
b'1' b'q' b' '

注意最后一行里，对于这些 ascii 可见字符的 utf-8 编码结果，python 直接显示出字符表示而不是像 '\xe4' 这样的十六进制形式。

ascii 中也有不可见字符的，比如 unicode 小于 33 的这些字符：

for i in range(33):
    char = chr(i)
    encoded_char = char.encode('utf-8')
    print(i, encoded_char) 

0 b'\x00'
1 b'\x01'
2 b'\x02'
3 b'\x03'
4 b'\x04'
5 b'\x05'
6 b'\x06'
7 b'\x07'
8 b'\x08'
9 b'\t'
10 b'\n'
11 b'\x0b'
12 b'\x0c'
13 b'\r'
14 b'\x0e'
15 b'\x0f'
16 b'\x10'
17 b'\x11'
18 b'\x12'
19 b'\x13'
20 b'\x14'
21 b'\x15'
22 b'\x16'
23 b'\x17'
24 b'\x18'
25 b'\x19'
26 b'\x1a'
27 b'\x1b'
28 b'\x1c'
29 b'\x1d'
30 b'\x1e'
31 b'\x1f'
32 b' '

除了 \t, \n, \r 经过转义字符而变得"可见" 的字符以及空格，其他都还是保持了 16 进制形式，BBPE 需要对这些 byte 以及 byte 的拼接结果进行保存，如果以这种非字符形式保存会不太方便，于是才有 bytes_to_unicode 函数，使得一个 byte 能表示的 0 到 255 范围内，每个数都能对应一个可见的 unicode 字符，便于字典的保存。

在 GPT2Tokenizer 初始化函数里，定义以下两个变量

self.byte_encoder = bytes_to_unicode()
self.byte_decoder = {v: k for k, v in self.byte_encoder.items()}

bytes_to_unicode 函数实现为：

def bytes_to_unicode():
    bs = (
        list(range(ord("!"), ord("~") + 1)) + list(range(ord("¡"), ord("¬") + 1)) + list(range(ord("®"), ord("ÿ") + 1))
    )
    cs = bs[:]
    n = 0
    for b in range(2**8):
        if b not in bs:
            bs.append(b)
            cs.append(2**8 + n)
            n += 1
    cs = [chr(n) for n in cs]
    return dict(zip(bs, cs))

该函数没有任何依赖，可以拿出来执行：

byte_encoder = bytes_to_unicode()
print(byte_encoder)

{33: '!', 34: '"', 35: '#', 36: '$', 37: '%', 38: '&', 39: "'", 40: '(', 41: ')', 42: '*', 43: '+', 44: ',', 45: '-', 46: '.', 47: '/', 48: '0', 49: '1', 50: '2', 51: '3', 52: '4', 53: '5', 54: '6', 55: '7', 56: '8', 57: '9', 58: ':', 59: ';', 60: '<', 61: '=', 62: '>', 63: '?', 64: '@', 65: 'A', 66: 'B', 67: 'C', 68: 'D', 69: 'E', 70: 'F', 71: 'G', 72: 'H', 73: 'I', 74: 'J', 75: 'K', 76: 'L', 77: 'M', 78: 'N', 79: 'O', 80: 'P', 81: 'Q', 82: 'R', 83: 'S', 84: 'T', 85: 'U', 86: 'V', 87: 'W', 88: 'X', 89: 'Y', 90: 'Z', 91: '[', 92: '\\', 93: ']', 94: '^', 95: '_', 96: '`', 97: 'a', 98: 'b', 99: 'c', 100: 'd', 101: 'e', 102: 'f', 103: 'g', 104: 'h', 105: 'i', 106: 'j', 107: 'k', 108: 'l', 109: 'm', 110: 'n', 111: 'o', 112: 'p', 113: 'q', 114: 'r', 115: 's', 116: 't', 117: 'u', 118: 'v', 119: 'w', 120: 'x', 121: 'y', 122: 'z', 123: '{', 124: '|', 125: '}', 126: '~', 161: '¡', 162: '¢', 163: '£', 164: '¤', 165: '¥', 166: '¦', 167: '§', 168: '¨', 169: '©', 170: 'ª', 171: '«', 172: '¬', 174: '®', 175: '¯', 176: '°', 177: '±', 178: '²', 179: '³', 180: '´', 181: 'µ', 182: '¶', 183: '·', 184: '¸', 185: '¹', 186: 'º', 187: '»', 188: '¼', 189: '½', 190: '¾', 191: '¿', 192: 'À', 193: 'Á', 194: 'Â', 195: 'Ã', 196: 'Ä', 197: 'Å', 198: 'Æ', 199: 'Ç', 200: 'È', 201: 'É', 202: 'Ê', 203: 'Ë', 204: 'Ì', 205: 'Í', 206: 'Î', 207: 'Ï', 208: 'Ð', 209: 'Ñ', 210: 'Ò', 211: 'Ó', 212: 'Ô', 213: 'Õ', 214: 'Ö', 215: '×', 216: 'Ø', 217: 'Ù', 218: 'Ú', 219: 'Û', 220: 'Ü', 221: 'Ý', 222: 'Þ', 223: 'ß', 224: 'à', 225: 'á', 226: 'â', 227: 'ã', 228: 'ä', 229: 'å', 230: 'æ', 231: 'ç', 232: 'è', 233: 'é', 234: 'ê', 235: 'ë', 236: 'ì', 237: 'í', 238: 'î', 239: 'ï', 240: 'ð', 241: 'ñ', 242: 'ò', 243: 'ó', 244: 'ô', 245: 'õ', 246: 'ö', 247: '÷', 248: 'ø', 249: 'ù', 250: 'ú', 251: 'û', 252: 'ü', 253: 'ý', 254: 'þ', 255: 'ÿ', 0: 'Ā', 1: 'ā', 2: 'Ă', 3: 'ă', 4: 'Ą', 5: 'ą', 6: 'Ć', 7: 'ć', 8: 'Ĉ', 9: 'ĉ', 10: 'Ċ', 11: 'ċ', 12: 'Č', 13: 'č', 14: 'Ď', 15: 'ď', 16: 'Đ', 17: 'đ', 18: 'Ē', 19: 'ē', 20: 'Ĕ', 21: 'ĕ', 22: 'Ė', 23: 'ė', 24: 'Ę', 25: 'ę', 26: 'Ě', 27: 'ě', 28: 'Ĝ', 29: 'ĝ', 30: 'Ğ', 31: 'ğ', 32: 'Ġ', 127: 'ġ', 128: 'Ģ', 129: 'ģ', 130: 'Ĥ', 131: 'ĥ', 132: 'Ħ', 133: 'ħ', 134: 'Ĩ', 135: 'ĩ', 136: 'Ī', 137: 'ī', 138: 'Ĭ', 139: 'ĭ', 140: 'Į', 141: 'į', 142: 'İ', 143: 'ı', 144: 'IJ', 145: 'ij', 146: 'Ĵ', 147: 'ĵ', 148: 'Ķ', 149: 'ķ', 150: 'ĸ', 151: 'Ĺ', 152: 'ĺ', 153: 'Ļ', 154: 'ļ', 155: 'Ľ', 156: 'ľ', 157: 'Ŀ', 158: 'ŀ', 159: 'Ł', 160: 'ł', 173: 'Ń'}

以上第一句构造 bs 实际有两个主要部分：

1. 最常用可见字符集（Basic Latin）：

   print(list(range(ord("!"), ord("~") + 1)))
   

   [33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126]
   

   这些字符基本在标准的 PC 键盘上都能打出来：

   print([chr(x) for x in list(range(ord("!"), ord("~") + 1))])
   

   ['!', '"', '#', '$', '%', '&', "'", '(', ')', '*', '+', ',', '-', '.', '/', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', '>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', '[', '\\', ']', '^', '_', '`', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '{', '|', '}', '~']
   

   以上 '\\' 表示的是就是 反斜杠 \ 字符，第一个 \ 是转义

   如上节所说，将这些字符对应的编号转成 16 进制再加上 U+ 就表示这些字符的 unicode 码点

   print([f"U+00{i:X}" for i in list(range(ord("!"), ord("~") + 1))])
   

   ['U+0021', 'U+0022', 'U+0023', 'U+0024', 'U+0025', 'U+0026', 'U+0027', 'U+0028', 'U+0029', 'U+002A', 'U+002B', 'U+002C', 'U+002D', 'U+002E', 'U+002F', 'U+0030', 'U+0031', 'U+0032', 'U+0033', 'U+0034', 'U+0035', 'U+0036', 'U+0037', 'U+0038', 'U+0039', 'U+003A', 'U+003B', 'U+003C', 'U+003D', 'U+003E', 'U+003F', 'U+0040', 'U+0041', 'U+0042', 'U+0043', 'U+0044', 'U+0045', 'U+0046', 'U+0047', 'U+0048', 'U+0049', 'U+004A', 'U+004B', 'U+004C', 'U+004D', 'U+004E', 'U+004F', 'U+0050', 'U+0051', 'U+0052', 'U+0053', 'U+0054', 'U+0055', 'U+0056', 'U+0057', 'U+0058', 'U+0059', 'U+005A', 'U+005B', 'U+005C', 'U+005D', 'U+005E', 'U+005F', 'U+0060', 'U+0061', 'U+0062', 'U+0063', 'U+0064', 'U+0065', 'U+0066', 'U+0067', 'U+0068', 'U+0069', 'U+006A', 'U+006B', 'U+006C', 'U+006D', 'U+006E', 'U+006F', 'U+0070', 'U+0071', 'U+0072', 'U+0073', 'U+0074', 'U+0075', 'U+0076', 'U+0077', 'U+0078', 'U+0079', 'U+007A', 'U+007B', 'U+007C', 'U+007D', 'U+007E']
   

   注意标准的 Basic Latin 字符集有 95 个字符，包括空格，而以上只有 94 个，不包括不可见的空格（编号是 32 ）

   print(len(list(range(ord("!"), ord("~") + 1))))
   

   94
   

2. Latin-1 Supplement

   标准的 Latin-1 Supplement 有 96 个字符，unicode 从 161 到 255，其中有两个是不可见字符，分别是 160 和 173, 以下代码就是避开了这两个符号：

   print(list(range(ord("¡"), ord("¬") + 1)))
   print(list(range(ord("®"), ord("ÿ") + 1)))
   

   [161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172]
   [174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255]
   

   len(range(ord("¡"), ord("¬") + 1)) + len(range(ord("®"), ord("ÿ") + 1))
   

   94
   

因此目前 bs 的值实际就是 unicode 中前 256 个字符里的可见字符集（的编号），共 188 个。但剩下的 256-188 个 byte 值还没有对应的可见字符，于是作者把不在 bs 中的小于 256 的值 idx 都加入到 bs 中，并且将这些值对应的字符设置为 unicode 编码为 idx+256 的字符（放在变量 cs 相应的位置），这是因为 unicode 编号大于 255 的基本都是可见字符了。

最后返回的字典 dict(zip(bs, cs)) 中，原本就可见的 188 个字符的编码到字符的映射是正确的，比如一下几个例子：

for dec in range(33, 40):
    char = byte_encoder[dec]
    print(f"{dec} -> {char}")

33 -> !
34 -> "
35 -> #
36 -> $
37 -> %
38 -> &
39 -> '

但其余的是不正确的，比如以下例子

for dec in [0,1,2,3,4,5,32,33]:
    char = byte_encoder[dec]
    print(f"{dec} -> {char}")

0 -> Ā
1 -> ā
2 -> Ă
3 -> ă
4 -> Ą
5 -> ą
32 -> Ġ
33 -> !

'Ā' 的 unicode 编码应该是 256 ，但这里对应的是 0, 而 32 原本对应的是空格，这里用 'Ġ' 表示。 不过编码对错在这里是不重要的，因为当前的目的只是找到 256 个可见字符来表示一个 byte （8 bit）内的所有可能组合，并以此作为基础词表，任何 utf-8 字符都可以拆分成这些 byte 的拼接。

前文提到过， self.pat 定义如下

import regex as re
# Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
self.pat = re.compile(r"""'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+""")

注意这个是 re 是 regex 库而不是 re 库，regex 支持 ?\p 这类更复杂的正则表达式。

AI 对该表达式的解释是：

用几个例子来说明

pat = re.compile(r"""'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+""")

print(re.findall(pat, "this"))

['this']

空格会在单词之前：

print(re.findall(pat, "it is a dog"))

['it', ' is', ' a', ' dog', '1']

额外的空格被单独抽取出来，数字和英文分开：

print(re.findall(pat, "this   is gpt3"))

['this', '  ', ' is', ' gpt', '3']

所有格被切分：

print(re.findall(pat, "he's"))

['he', "'s"]

中文标点会被切分，但不含标点的连续中文不会被切分：

print(re.findall(pat, "你好，你在用 AI 吗"))

['你好', '，', '你在用', ' AI', '  ', ' 吗']

还有我们最初的例子：

print(re.findall(pat, "朋友，it's a good day."))

['朋友', '，', 'it', "'s", ' a', ' good', ' day', '.']

这么看 re.findall(self.pat, text) 就是一个基础的分词算法，它比 text.split() 考虑了更多的英语语法特点以及通用的标点符号。此外，相比与 text.split() 或者其他会丢弃掉空格的预分词器，这种方式不会丢弃掉空格（或许也不会丢掉任何其他字符），空格本身是一个需要被训练的词。

对于 re.findall 返回的所有分词的结果，先转换成 utf-8 编码，然后从中进行查表

token = "".join(
    self.byte_encoder[b] for b in token.encode("utf-8")
)  

直接打印出 demo 例子的中间过程：

def show_demo_byte(token):
    utf8_rep = token.encode("utf-8")
    print(f"UTF8 Hex of {token} is {utf8_rep}")
    token_list = [byte_encoder[b] for b in utf8_rep]
    _token = "".join(token_list)
    print(f"{token}->{token_list}->{_token}")

demo_tokens =  re.findall(pat, demo_sentence)
for i, x in enumerate(demo_tokens):
    print((i, x))

(0, '朋友')
(1, '，')
(2, 'it')
(3, "'s")
(4, ' a')
(5, ' good')
(6, ' day')
(7, '.')

先看所有的英文部分（键盘可以直接打出的词汇），注意 a, good, day 之前都有空格：

show_demo_byte(demo_tokens[2])
show_demo_byte(demo_tokens[3])
show_demo_byte(demo_tokens[5])
show_demo_byte(demo_tokens[6])
show_demo_byte(demo_tokens[7])

UTF8 Hex of it is b'it'
it->['i', 't']->it
UTF8 Hex of 's is b"'s"
's->["'", 's']->'s
UTF8 Hex of  good is b' good'
 good->['Ġ', 'g', 'o', 'o', 'd']->Ġgood
UTF8 Hex of  day is b' day'
 day->['Ġ', 'd', 'a', 'y']->Ġday
UTF8 Hex of . is b'.'
.->['.']->.

首先看到，这些 token 转换成 utf-8 后的结果是不变的，因为这些字符的 utf-8 和 ascii 码是兼容的。 但经过 byte_encoder 转换，由于空格不可见，作者用 Ġ 替代了，于是得到了以上的结果。

接着查看中文部分：

show_demo_byte(demo_tokens[0])
show_demo_byte(demo_tokens[1])

UTF8 Hex of 朋友 is b'\xe6\x9c\x8b\xe5\x8f\x8b'
朋友->['æ', 'ľ', 'ĭ', 'å', 'ı', 'ĭ']->æľĭåıĭ
UTF8 Hex of ， is b'\xef\xbc\x8c'
，->['ï', '¼', 'Į']->ï¼Į

中文字符的 utf-8 基本是由 3 个 byte 表示。

接着进入到核心的 bpe 函数：

bpe_tokens.extend(bpe_token for bpe_token in self.bpe(token).split(" "))

这里 token 是经过 byte 转换的结果，比如 "朋友" 对应的是 æľĭåıĭ， 后文将以这个例子来说明，

demo_token = "æľĭåıĭ"

完整 bpe 函数如下：

def bpe(self, token):
    if token in self.cache:
        return self.cache[token]
    word = tuple(token)
    pairs = get_pairs(word)

    if not pairs:
        return token

    while True:
        bigram = min(pairs, key=lambda pair: self.bpe_ranks.get(pair, float("inf")))
        if bigram not in self.bpe_ranks:
            break
        first, second = bigram
        new_word = []
        i = 0
        while i < len(word):
            try:
                j = word.index(first, i)
            except ValueError:
                new_word.extend(word[i:])
                break
            else:
                new_word.extend(word[i:j])
                i = j

            if word[i] == first and i < len(word) - 1 and word[i + 1] == second:
                new_word.append(first + second)
                i += 2
            else:
                new_word.append(word[i])
                i += 1
        new_word = tuple(new_word)
        word = new_word
        if len(word) == 1:
            break
        else:
            pairs = get_pairs(word)
    word = " ".join(word)
    self.cache[token] = word
    return word

前两行检查是否已经有缓存，有的话直接返回。接着将 token 转为 tuple 类型：

word = tuple(demo_token)
print(word)

('æ', 'ľ', 'ĭ', 'å', 'ı', 'ĭ')

调用以下的 get_pairs 函数，目的是构造 bigram 集合，也就是相邻字符对的集合，这是为了确定哪些相邻 token 之间需要合并

def get_pairs(word):
    pairs = set()
    prev_char = word[0]
    for char in word[1:]:
        pairs.add((prev_char, char))
        prev_char = char
    return pairs

print(get_pairs(word))

{('å', 'ı'), ('ı', 'ĭ'), ('æ', 'ľ'), ('ĭ', 'å'), ('ľ', 'ĭ')}

接着进入 while 循环，先根据 bpe_ranks 找出各个 bigram 的排序，并找到最小的排序对

bigram = min(pairs, key=lambda pair: self.bpe_ranks.get(pair, float("inf")))
if bigram not in self.bpe_ranks:
    break

第一次循环找到的是：

('æ', 'ľ')

接着又一个 while 循环，目的是用合并后的 'æľ' 取代 word 里原本的这两个相邻 token, 注意，有可能 word 里有多个相同的 bigram, 因此用 while 循环依次替换。

first, second = bigram
new_word = []
i = 0
while i < len(word):
    try:
        j = word.index(first, i)
    except ValueError:
        new_word.extend(word[i:])
        break
    else:
        new_word.extend(word[i:j])
        i = j

    if word[i] == first and i < len(word) - 1 and word[i + 1] == second:
        new_word.append(first + second)
        i += 2
    else:
        new_word.append(word[i])
        i += 1
new_word = tuple(new_word)
word = new_word

因此，第一次循环后， word 应该是

('æľ', 'ĭ', 'å', 'ı', 'ĭ')

最后用空格 concate 后返回（可能是为了 cache 查找更高效？以 tuple 形式返回也可以）

word = " ".join(word)
self.cache[token] = word
return word

如此这般，直到合并的 word 长度为 1 或者找出来的 bigram 不在 bpe_ranks 里，也就无法合并为止。比如最后 "朋友" 这个词的 bbpe 表示为： ['æľ', 'ĭ', 'åı', 'ĭ']

对每个预分词后的 token 都这样处理，然后统一加入到 bpe_tokens 中

bpe_tokens.extend(bpe_token for bpe_token in self.bpe(token).split(" "))

bpe_tokens 的变化：

['æľ', 'ĭ', 'åı', 'ĭ'] # "朋友"
['æľ', 'ĭ', 'åı', 'ĭ', 'ï', '¼', 'Į'] "朋友，"
['æľ', 'ĭ', 'åı', 'ĭ', 'ï', '¼', 'Į', 'it'] # "朋友，it"
['æľ', 'ĭ', 'åı', 'ĭ', 'ï', '¼', 'Į', 'it', "'s"] # "朋友，it's"
['æľ', 'ĭ', 'åı', 'ĭ', 'ï', '¼', 'Į', 'it', "'s", 'Ġa'] # "朋友，it's a" 
...
['æľ', 'ĭ', 'åı', 'ĭ', 'ï', '¼', 'Į', 'it', "'s", 'Ġa', 'Ġgood', 'Ġday', '.'] # "朋友，it's a good day." 

这里可以看到，原本中文的 "朋" 字是有 3 个字节的，分别是 æ ľ ĭ，但经过 bbpe 分词后，前两个字节聚在了一起，和最后一个 byte 分开了，很可能是这两个前缀也常出现在别的中文或其他非 ascii 字节的表示中。

另外， æ 字符的 unicode 由于是大于 255 的，因此它实际由两个 byte 组成：

'æ'.encode("utf-8")

b'\xc3\xa6'

不能直接去用以上方式解码 bbpe 的结果序列，应该先 self.byte_decoder 来解码，将大于 255 的字符表示转换回到小于等于 255 的 byte 范围内才行。