Токенизация с помощью Byte-Pair Encoding

Ask a Question Open In Colab Open In Studio Lab

Алгоритм BPE первоначально был разработан для сжатия текстов, а затем использовался OpenAI для токенизации при предварительной подготовке модели GPT. Он используется многими моделями трансформеров, включая GPT, GPT-2, Roberta, Bart и Deberta.

💡 Этот раздел подробно рассматривает BPE и демонстрирует его полную реализацию. Вы можете перейти в конец этой статьи, если вам необходим только поверхностный обзор алгоритма.

Алгоритм обучения

Обучение BPE начинается с вычисления уникального набора слов, используемых в корпусе (после завершения этапов нормализации и предварительной токенизации). В качестве очень простого примера рассмотрим следующий: наш корпус использует эти пять слов:

"hug", "pug", "pun", "bun", "hugs"

Базовый словарь в таком случае будет таким: ["b", "g", "h", "n", "p", "s", "u"]. Для реальных случаев этот базовый словарь будет содержать как минимум все символы ASCII, и, вероятно, также некоторые символы Unicode. Если пример содержит символ, которого нет в учебном корпусе, этот символ будет преобразован в неизвестный токен. Это одна из причин, почему многие модели НЛП очень плохо анализируют контент с помощью эмодзи.

Токенизаторы GPT-2 и RoBERTa (которые довольно похожи) имеют умный способ справиться с этим: они смотрят на слова не как на последовательность Unicode-символов, а как на последовательность байтов. Таким образом, базовый словарь имеет небольшой размер (256), но будет содержать все символы и неизвестных слов в нем не будет. Этот трюк называется byte-level BPE.

Получив этот базовый словарь, мы добавляем новые токены до тех пор, пока не будет достигнут нужный размер словаря. Это производится с помощью обучения слияниям: которые являются правилами для объединения двух элементов существующего словаря в новый. Таким образом, в начале эти слияния будут создавать токены с двумя символами, а затем, по мере продвижения обучения, более длинные подстроки.

На любом шаге во время обучения токенизатора алгоритм BPE будет искать наиболее частую пару существующих токенов (под «парой», здесь мы имеем в виду два последовательных токена одним словом). Эта наиболее частая пара - та, которая будет объединена, так итеративно сливаются наиболее частые пары токенов.

Вернемся к нашему примеру выше и предположим, что частоты наших слов следующие:

("hug", 10), ("pug", 5), ("pun", 12), ("bun", 4), ("hugs", 5)

Слово "hug" было представлено 10 раз в нашем корпусе слов, "pug" 5 раз, "pun" 12 раз, "bun" 4 раза, "hugs" 5 раз.

meaning "hug" was present 10 times in the corpus, "pug" 5 times, "pun" 12 times, "bun" 4 times, and "hugs" 5 times. Мы начинаем обучение, разделяя каждое слово на символы (те, которые формируют наш начальный словарь), чтобы мы могли видеть каждое слово как список токенов:

("h" "u" "g", 10), ("p" "u" "g", 5), ("p" "u" "n", 12), ("b" "u" "n", 4), ("h" "u" "g" "s", 5)

Затем мы посмотрим на пары. Пара ("h", "u") присутствует в словах "hug" и "hugs", всего 15 раз в корпусе. Однако это не самая частая пара: эта честь принадлежит ("u", "g"), которая присутствует в словах "hug", "pug" и "hugs", в общей сложности 20 раз в словаре.

Таким образом, первое правило слияния, выученное токенизатором, - ("u", "g") -> "ug", что означает, что "ug" будет добавлено в словарь, и эта пара должна быть объединена во всех словах корпуса. В конце этого этапа словарь и корпус выглядят следующим образом:

Vocabulary: ["b", "g", "h", "n", "p", "s", "u", "ug"]
Corpus: ("h" "ug", 10), ("p" "ug", 5), ("p" "u" "n", 12), ("b" "u" "n", 4), ("h" "ug" "s", 5)

Сейчас мы имеем пары, которые содержат токены длиннее одного символа: токены ("h", "ug"), например (представлены 15 раз в корпусе). Самые часто встречаемые пары на данном шаге это ("u", "n"), представленные в корпусе 16 раз, следовательно, следующее выученное объединение будет таким: ("u", "n") -> "un". Добавление нового токена приведет к замене (объединению) всех встреченных пар сиволов ("u", "n"):

Vocabulary: ["b", "g", "h", "n", "p", "s", "u", "ug", "un"]
Corpus: ("h" "ug", 10), ("p" "ug", 5), ("p" "un", 12), ("b" "un", 4), ("h" "ug" "s", 5)

Теперь самая часто встречаемая пара это ("h", "ug"), так что мы можем выучить объединение ("h", "ug") -> "hug", которое даст нам первый трехсимвольный токен. После объединения корпус будет выглядеть так:

Vocabulary: ["b", "g", "h", "n", "p", "s", "u", "ug", "un", "hug"]
Corpus: ("hug", 10), ("p" "ug", 5), ("p" "un", 12), ("b" "un", 4), ("hug" "s", 5)

И продолжаем в том же духе, пока не достигнем желаемого размера словаря.

✏️ Теперь ваша очередь! Как вы думаете, каким будет следующее правило слияния?

Алгоритм токенизации

Токенизация следует за процессом обучения в том смысле, что новые входные данные подвергаются токенизации путем применения следующих шагов:

  1. Нормализация
  2. Предварительная токенизация
  3. Разделение слов на отдельные символы
  4. Применение правил слияния, изученных по порядку, к этим частям

Возьмем пример, который мы использовали во время обучения, с тремя выученными правилами слияния:

("u", "g") -> "ug"
("u", "n") -> "un"
("h", "ug") -> "hug"

Слово "bug" будет токенизировано как ["b", "ug"]. Слово "mug", однако, будет токенизировано как ["[UNK]", "ug"], поскольку буква "m" отсутствует в базовом словаре. Аналогично, слово "thug" будет токенизировано как [”[UNK]”, “hug”]: буква “t” отсутствует в базовом словаре, и применение правил слияния приводит сначала к слиянию "u" и "g", а затем к слиянию "h" и "ug".

✏️ Теперь ваша очередь! Как вы думаете, как будет токенизировано слово 'unhug'?

Реализация BPE

Теперь давайте посмотрим на реализацию алгоритма BPE. Это не будет оптимизированная версия, которую вы сможете использовать на большом корпусе; мы просто хотим показать вам код, чтобы вы могли лучше понять алгоритм.

Для начала нам нужен корпус текста, поэтому давайте создадим простой корпус с несколькими предложениями:

corpus = [
    "This is the Hugging Face Course.",
    "This chapter is about tokenization.",
    "This section shows several tokenizer algorithms.",
    "Hopefully, you will be able to understand how they are trained and generate tokens.",
]

Далее нам нужно предварительно токенизировать корпус в слова. Поскольку мы воспроизводим токенизатор BPE (например, GPT-2), для предварительной токенизации мы будем использовать токенизатор gpt2:

from transformers import AutoTokenizer

tokenizer = AutoTokenizer.from_pretrained("gpt2")

Затем мы вычисляем частоты каждого слова в полученном корпусе:

from collections import defaultdict

word_freqs = defaultdict(int)

for text in corpus:
    words_with_offsets = tokenizer.backend_tokenizer.pre_tokenizer.pre_tokenize_str(text)
    new_words = [word for word, offset in words_with_offsets]
    for word in new_words:
        word_freqs[word] += 1

print(word_freqs)
defaultdict(int, {'This': 3, 'Ġis': 2, 'Ġthe': 1, 'ĠHugging': 1, 'ĠFace': 1, 'ĠCourse': 1, '.': 4, 'Ġchapter': 1,
    'Ġabout': 1, 'Ġtokenization': 1, 'Ġsection': 1, 'Ġshows': 1, 'Ġseveral': 1, 'Ġtokenizer': 1, 'Ġalgorithms': 1,
    'Hopefully': 1, ',': 1, 'Ġyou': 1, 'Ġwill': 1, 'Ġbe': 1, 'Ġable': 1, 'Ġto': 1, 'Ġunderstand': 1, 'Ġhow': 1,
    'Ġthey': 1, 'Ġare': 1, 'Ġtrained': 1, 'Ġand': 1, 'Ġgenerate': 1, 'Ġtokens': 1})

Следующий шаг - составление базового словаря, состоящего из всех символов, используемых в корпусе:

alphabet = []

for word in word_freqs.keys():
    for letter in word:
        if letter not in alphabet:
            alphabet.append(letter)
alphabet.sort()

print(alphabet)
[ ',', '.', 'C', 'F', 'H', 'T', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'k', 'l', 'm', 'n', 'o', 'p', 'r', 's',
  't', 'u', 'v', 'w', 'y', 'z', 'Ġ']

Мы также добавилли специальные токены, используемые моделью, в начало нашего словаря. В случае GPT-2 этот специальный токен один: "<|endoftext|>".

vocab = ["<|endoftext|>"] + alphabet.copy()

Теперь нам нужно разделить каждое слово на отдельные символы, чтобы начать обучение:

splits = {word: [c for c in word] for word in word_freqs.keys()}

Теперь, когда мы готовы к обучению, давайте напишем функцию, которая вычисляет частоту каждой пары. Нам нужно использовать это на каждом этапе обучения:

def compute_pair_freqs(splits):
    pair_freqs = defaultdict(int)
    for word, freq in word_freqs.items():
        split = splits[word]
        if len(split) == 1:
            continue
        for i in range(len(split) - 1):
            pair = (split[i], split[i + 1])
            pair_freqs[pair] += freq
    return pair_freqs

Давайте посмотрим на часть этого словаря после первоначальных разбиений:

pair_freqs = compute_pair_freqs(splits)

for i, key in enumerate(pair_freqs.keys()):
    print(f"{key}: {pair_freqs[key]}")
    if i >= 5:
        break
('T', 'h'): 3
('h', 'i'): 3
('i', 's'): 5
('Ġ', 'i'): 2
('Ġ', 't'): 7
('t', 'h'): 3

Теперь, чтобы найти наиболее часто встречающуюся пару, нужно всего лишь сделать быстрый цикл:

best_pair = ""
max_freq = None

for pair, freq in pair_freqs.items():
    if max_freq is None or max_freq < freq:
        best_pair = pair
        max_freq = freq

print(best_pair, max_freq)
('Ġ', 't') 7

Итак, первое слияние, которое нужно выучить, это ('Ġ', 't') -> 'Ġt', и мы добавляем 'Ġt' в словарь:

merges = {("Ġ", "t"): "Ġt"}
vocab.append("Ġt")

Чтобы продолжить, нам нужно применить это объединение в нашем экземпляре splits словаря. Давайте напишем для этого еще одну функцию:

def merge_pair(a, b, splits):
    for word in word_freqs:
        split = splits[word]
        if len(split) == 1:
            continue

        i = 0
        while i < len(split) - 1:
            if split[i] == a and split[i + 1] == b:
                split = split[:i] + [a + b] + split[i + 2 :]
            else:
                i += 1
        splits[word] = split
    return splits

И мы можем посмотреть на результат первого слияния:

splits = merge_pair("Ġ", "t", splits)
print(splits["Ġtrained"])
['Ġt', 'r', 'a', 'i', 'n', 'e', 'd']

Теперь у нас есть все, что нам нужно, чтобы реализовать цикл, в котором мы найдем все необходимые слияния. Будем стремиться к размеру словаря в 50 элементов.

vocab_size = 50

while len(vocab) < vocab_size:
    pair_freqs = compute_pair_freqs(splits)
    best_pair = ""
    max_freq = None
    for pair, freq in pair_freqs.items():
        if max_freq is None or max_freq < freq:
            best_pair = pair
            max_freq = freq
    splits = merge_pair(*best_pair, splits)
    merges[best_pair] = best_pair[0] + best_pair[1]
    vocab.append(best_pair[0] + best_pair[1])

В результате мы выучили 19 правил объединения (начальный словарь имел размер 31: 30 символов алфавита и один специальный токен):

print(merges)
{('Ġ', 't'): 'Ġt', ('i', 's'): 'is', ('e', 'r'): 'er', ('Ġ', 'a'): 'Ġa', ('Ġt', 'o'): 'Ġto', ('e', 'n'): 'en',
 ('T', 'h'): 'Th', ('Th', 'is'): 'This', ('o', 'u'): 'ou', ('s', 'e'): 'se', ('Ġto', 'k'): 'Ġtok',
 ('Ġtok', 'en'): 'Ġtoken', ('n', 'd'): 'nd', ('Ġ', 'is'): 'Ġis', ('Ġt', 'h'): 'Ġth', ('Ġth', 'e'): 'Ġthe',
 ('i', 'n'): 'in', ('Ġa', 'b'): 'Ġab', ('Ġtoken', 'i'): 'Ġtokeni'}

А словарь состоит из специального токена, начального алфавита и всех результатов слияния:

print(vocab)
['<|endoftext|>', ',', '.', 'C', 'F', 'H', 'T', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'k', 'l', 'm', 'n', 'o',
 'p', 'r', 's', 't', 'u', 'v', 'w', 'y', 'z', 'Ġ', 'Ġt', 'is', 'er', 'Ġa', 'Ġto', 'en', 'Th', 'This', 'ou', 'se',
 'Ġtok', 'Ġtoken', 'nd', 'Ġis', 'Ġth', 'Ġthe', 'in', 'Ġab', 'Ġtokeni']

💡 Использование train_new_from_iterator() на том же корпусе не приведет к созданию точно такого же словаря. Это связано с тем, что при выборе наиболее частотной пары мы выбираем первую попавшуюся, в то время как библиотека 🤗 Tokenizers выбирает первую пару, основываясь на ее внутренних ID.

Чтобы обработать новый текст, мы предварительно токенизируем его, разбиваем на части, а затем применяем все изученные правила слияния:

def tokenize(text):
    pre_tokenize_result = tokenizer._tokenizer.pre_tokenizer.pre_tokenize_str(text)
    pre_tokenized_text = [word for word, offset in pre_tokenize_result]
    splits = [[l for l in word] for word in pre_tokenized_text]
    for pair, merge in merges.items():
        for idx, split in enumerate(splits):
            i = 0
            while i < len(split) - 1:
                if split[i] == pair[0] and split[i + 1] == pair[1]:
                    split = split[:i] + [merge] + split[i + 2 :]
                else:
                    i += 1
            splits[idx] = split

    return sum(splits, [])

Мы можем попробовать это на любом тексте, состоящем из символов алфавита:

tokenize("This is not a token.")
['This', 'Ġis', 'Ġ', 'n', 'o', 't', 'Ġa', 'Ġtoken', '.']

⚠ Наша реализация приведет к ошибке, если есть неизвестный символ, так как мы ничего не сделали, чтобы справиться с этой ситуацией. GPT-2 на самом деле не имеет токена для неизвестного символа (невозможно получить неизвестный символ при использовании BPE на уровне байтов), но это может произойти здесь, потому что мы не включили все возможные байты в начальный словарный запас. Этот аспект BPE выходит за рамки этого раздела, поэтому мы опустили детали.

Так устроен алгоритм BPE! Далее мы рассмотрим алгоритм WordPiece.