[🤗 강좌 6.6] Byte-Pair Encoding (BPE) 토큰화

BPE(Byte-Pair Encoding)는 초기에 텍스트를 압축하는 알고리즘으로 개발된 후, GPT 모델을 사전 학습할 때 토큰화를 위해 OpenAI에서 사용되었습니다. GPT, GPT-2, RoBERTa, BART 및 DeBERTa를 포함한 많은 트랜스포머 모델에서 사용됩니다.

💡 이 섹션에서는 전체 구현 과정을 보여주는 것까지를 포함하여 BPE를 심층적으로 다룹니다. 토큰화 알고리즘에 대한 일반적인 개요만을 원하는 경우 이 장을 건너뛰어도 됩니다.

학습 알고리즘

BPE 학습은 정규화 및 사전 토큰화 단계가 완료된 후, 말뭉치에 사용된 고유한 단어 집합을 계산하는 것으로 시작됩니다. 그런 다음 이러한 단어들을 구성하는데 사용된 모든 기호(글자)를 바탕으로 vocabulary를 구축합니다. 아주 간단한 예로서 말뭉치가 다음 다섯 단어를 사용한다고 가정해 봅시다:

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

기본 vocabulary는 ["b", "g", "h", "n", "p", "s", "u"]가 됩니다. 실제로는 기본 vocabulary에는 최소한 모든 ASCII 문자와 일부 유니코드 문자가 포함될 것입니다. 토큰화하는 대상이 학습 말뭉치에 없는 문자를 사용하는 경우 해당 문자는 "알 수 없는 토큰(unknown token)"으로 변환됩니다. 많은 NLP 모델이 이모티콘이 포함된 콘텐츠를 분석하는데 심각한 어려움을 겪는 이유입니다.

GPT-2 및 RoBERTa 토크나이저는 이 문제를 매우 영리하게 처리합니다. 단어를 유니코드 문자가 아닌 바이트 단위로 구성된 것으로 간주합니다. 이 방법으로 기본 vocabulary는 작은 크기(256)를 갖지만 생각할 수 있는 모든 문자들이 여전히 포함될 수 있으며 알 수 없는 토큰으로 변환되지 않습니다. 이 트릭(trick)을 byte-level BPE 라고 합니다.

이 기본 vocabulary를 구한 후, 기존 vocabulary의 두 요소를 새로운 것으로 병합하는 규칙인 merges 를 학습함으로써 원하는 vocabulary 크기에 도달할 때까지 새 토큰을 추가합니다. 따라서 처음에는 이러한 병합으로 두 개의 문자가 있는 토큰이 생성되고 학습이 진행됨에 따라 더 긴 하위 단어(subwords)가 생성됩니다.

토크나이저 학습 과정에서 어떤 단계에서든 BPE 알고리즘은 가장 빈번하게 출현하는 토큰 쌍을 검색합니다(여기서 "쌍"은 한 단어에서 두 개의 연속 토큰을 의미하고 토큰은 처음에는 단일 문자입니다). 검색된 고빈도 토큰 쌍이 병합되며 이러한 과정이 계속 반복됩니다.

이전 예제로 돌아가서 각 단어들의 출현빈도가 다음과 같다고 가정해 봅시다:

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

말뭉치 내에 "hug"가 10번, "pug"가 5번, "pun"이 12번, "bun"이 4번, "hugs"가 5번 출현한다는 의미입니다. 각 단어를 토큰의 목록으로 볼 수 있도록 각 단어를 문자(초기 vocabulary를 구성하는 문자)로 분할하여 학습을 시작합니다:

("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번 출현했습니다. 가장 빈번한 쌍은 아닙니다. 가장 빈번하게 출현하는 쌍은 "hug", "pug" 및 "hugs"에 있는 ("u", "g")이며 총 20번 출현했습니다.

따라서 토크나이저가 학습한 첫 번째 병합 규칙은 ("u", "g") -> "ug"이며, 이는 "ug"가 vocabulary에 추가되고 코퍼스 내의 모든 단어에서 "u"와 "g"가 병합되어야 함을 의미합니다. 이 단계가 끝나면 vocabulary와 말뭉치가 다음과 같이 변경됩니다:

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)

이제 2개의 문자보다 더 긴 토큰이 생성되는 몇 가지 쌍이 코퍼스 내에 존재합니다. 예를 들어, ("h", "ug")(말뭉치에 15번 출현)가 그것입니다. 이 단계에서 가장 빈번하게 출현된 쌍은 ("u", "n")로서 말뭉치에 16번 나타나므로 학습된 두 번째 병합 규칙은 ("u", "n") -> "un"입니다. 이를 vocabulary에 추가하고 기존의 모든 항목을 병합하면 다음과 같이 됩니다:

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"을 학습합니다. 처음으로 3글자로 구성된 토큰이 만들어집니다. 병합 후 코퍼스는 다음과 같습니다.

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)

원하는 vocabulary 크기에 도달할 때까지 이 작업을 계속합니다.

✏️ Now your turn! 다음 병합 규칙은 무엇일까요?

토큰화 알고리즘

토큰화는 다음 단계를 적용하여 새로운 입력을 토큰화한다는 점에서 앞에서 살펴본 학습 프로세스와 밀접하게 연관되어 있습니다:

1. 정규화 (Normalization)

2. 사전 토큰화 (Pre-tokenization)

3. 단어를 개별 문자들로 분할

4. 해당 분할에 순서대로 학습된 병합 규칙 적용

위에서 학습된 3가지 병합 규칙을 적용하여 예를 들어 보겠습니다:

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

"bug"라는 단어는 ["b", "ug"]로 토큰화됩니다. 그러나 "mug"는 기본 vocabulary에 문자 "m"이 없었기 때문에 ["[UNK]", "ug"]로 토큰화됩니다. 마찬가지로 "thug"라는 단어는 ["[UNK]", "hug"]로 토큰화됩니다. 문자 "t"는 기본 vocabulary에 없으며 병합 규칙을 적용하면 먼저 "u"와 "g"가 병합된 다음 "hu"와 "g"가 병합됩니다.

✏️ Now your turn! "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.",
]

다음으로, 위 말뭉치를 단어 단위로 사전 토큰화(pre-tokenize)해야 합니다. GPT-2에서 사용된 BPE 토크나이저를 구현하고 있으므로 사전 토큰화(pre-tokenization)에 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)

다음 단계는 말뭉치에 사용된 모든 문자로 구성된 기본 vocabulary를 구하는 것입니다:

alphabet = []

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

print(alphabet)

추가적으로 해당 vocabulary의 시작 부분에 모델이 사용하는 특수 토큰을 추가합니다. 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)의 일부를 살펴보겠습니다:

pair_freqs = compute_pair_freqs(splits)

for i, key in enumerate(pair_freqs.keys()):
    print(f"{key}: {pair_freqs[key]}")
    if i > 5:
        break

이제 간단한 루프를 이용해서 가장 빈번하게 출현하는 쌍을 찾아보겠습니다:

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') -> 'Ġt'이고 vocabulary에 'Ġ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"])

이제 원하는 모든 병합을 학습할 때까지 반복하는 모듈을 구성할 수 있습니다. Vocabulary의 크기를 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가지 병합 규칙을 학습했습니다(초기 vocabulary의 크기는 알파벳 31 - 30자, 특수 토큰 포함):

print(merges)

그리고 vocabulary는 특수 토큰, 초기 알파벳 및 병합의 모든 결과로 구성됩니다:

print(vocab)

💡 동일한 말뭉치에서 train_new_from_iterator()를 사용하면 똑같은 vocabulary가 도출되지 않습니다. 이는 가장 빈번하게 출현한 쌍을 선택할때 가장 먼저 마주치는 쌍을 선택하는 반면에, 🤗Tokenizers 라이브러리는 내부 IDs를 기반으로 첫 번째 쌍을 선택하기 때문입니다.

새로운 텍스트를 토큰화하기 위해서는 우선 사전 토큰화(pre-tokenize)하고 분할(split)한 다음 학습한 모든 병합 규칙(merge rules)을 적용하면 됩니다:

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.")

⚠️ 예외 처리를 하지 않았기 때문에 알 수 없는 문자(unknown character)가 있으면 구현에서 오류가 발생합니다. GPT-2에는 실제로 알 수 없는 토큰이 없지만(바이트 수준 BPE를 사용할 때 알 수 없는 문자를 얻는 것은 불가능합니다), 여기서는 초기 vocabulary에 가능한 모든 바이트를 포함하지 않았기 때문에 오류가 발생할 수 있습니다. 이 부분은 이 섹션의 범위를 벗어나므로 세부 사항을 생략했습니다.

BPE 알고리즘에 대한 내용이 끝났습니다! 다음으로 WordPiece를 살펴보겠습니다.