|
2022年11月にOpenAIのChatGPTがリリースされて以来、大規模言語モデル（LLM）が非常に人気になりました。それ以来、HuggingFace の Transformer ライブラリや PyTorch などのライブラリのおかげで、これらの言語モデルの使用が爆発的に増加しました。 コンピュータが言語を処理するには、まずテキストをデジタル形式に変換する必要があります。このプロセスはトークン化と呼ばれます。 トークン化は 2 つのプロセスに分かれています。 1. 入力テキストをトークンに分割するトークナイザーはまずテキストを取得し、それを単語、単語の一部、または個々の文字などの小さな部分に分割します。これらの小さなテキストの断片はトークンと呼ばれます。スタンフォードNLPグループ[2]はタグ付けをより厳密に次のように定義しています。 特定の文書内の意味処理の有用な単位としてグループ化された文字列のインスタンス。 2. 各タグにIDを割り当てるトークナイザーはテキストをトークンに分割した後、各トークンにトークン ID と呼ばれる整数を割り当てることができます。たとえば、単語 cat には値 15 が割り当てられているため、入力テキスト内の各 cat トークンは数値 15 で表されます。テキスト トークンをデジタル表現に置き換えるプロセスをエンコーディングと呼びます。同様に、エンコードされたトークンをテキストに戻すプロセスはデコードと呼ばれます。 トークンを表すために単一の数字を使用することには欠点があるため、これらのエンコードをさらに処理して単語埋め込みを作成することはこの記事の範囲外であり、後で説明します。 マーキング方法テキストをトークンに分割する主な方法は 3 つあります。 1. 単語ベース:単語ベースのトークン化は、3 つのトークン化方法の中で最も単純です。トークナイザーは、空白文字ごとに分割するか（「空白ベースのトークナイゼーション」と呼ばれることもあります）、句読点ベースのトークナイゼーション[12]などの同様のルールに従って文を単語に分割します。 たとえば、次の文: Cats are great, but dogs are better! スペースで区切ることができます: ['Cats', 'are', 'great,', 'but', 'dogs', 'are', 'better!'] 句読点を区切ることで、次のように分割できます。 ['Cats', 'are', 'great', ',', 'but', 'dogs', 'are', 'better', '!'] ここで、分割を決定するために使用されるルールが非常に重要であることがわかります。スペース方式では、潜在的に希少なトークンをより適切に表現できます。一方、句読点のカットにより、それほど希少ではない 2 つのトークンがより目立つようになります。句読点は非常に特別な意味を持つ可能性があるため、句読点を完全に削除してはならないことに注意してください。 ' は、単語の複数形と所有格を区別する例です。たとえば、「book's」は本の何らかのプロパティを指しますが、「books」は複数の本を指します。 タグが生成されると、各タグに番号が割り当てられます。タグ付け者がすでに確認したトークンを次に生成するときは、単語に割り当てた番号をそのトークンに割り当てるだけです。例えば、上の文でトークンgreatに値1が割り当てられている場合、後続のgreatのインスタンスにもすべて値1が割り当てられます[3]。 長所と短所: 単語ベースの方法で生成されたトークンは、各トークンに意味情報とコンテキスト情報が含まれているため、非常に有益です。しかし、このアプローチの最大の欠点の 1 つは、非常に類似した単語が完全に別のトークンとして扱われることです。たとえば、「cat」と「cats」の間には接続が存在しないため、別々の単語として扱われます。これは、モデルの語彙内の可能なトークンの数 (モデルが認識するトークンの合計数) が非常に大きくなる可能性があるため、多くの単語を含む大規模なアプリケーションでは問題になります。英語には約 170,000 語の単語があり、いわゆる語彙爆発問題が発生します。一例として、空白ベースのセグメンテーションを使用する TransformerXL トークナイザーが挙げられます。その結果、語彙数は25万語以上になります[4]。 この問題に対処する 1 つの方法は、モデルが学習できるラベルの数に厳しい制限 (例: 10,000) を課すことです。これにより、最も一般的な 10,000 個のトークン以外の単語は語彙外 (OOV) として分類され、トークンの値が数値 (多くの場合 UNK と略記) ではなく UNKNOWN として割り当てられます。これにより、未知の単語が多数存在する場合にパフォーマンスが低下する可能性がありますが、データが主に一般的な単語で構成されている場合は適切なトレードオフになる可能性があります。 [5] 2. 文字ベースのトークナイザー文字ベースのトークン化では、文字、数字、句読点などの特殊文字を含む各文字に基づいてテキストを分割します。これにより語彙のサイズが大幅に削減され、英語は単語ベースのアプローチに必要な170,000以上のトークンではなく、約256のトークンで表現できるようになります[5]。中国語や日本語などの東アジアの言語でさえ、その表記体系には何千もの独自の文字が含まれているにもかかわらず、語彙は大幅に減少しています。 文字ベースのトークナイザーでは、次の文: Cats are great, but dogs are better! 次のように分割されます: ['C', 'a', 't', 's', ' ', 'a', 'r', 'e', ' ', 'g', 'r', 'e', 'a', 't', ',', ' ', 'b', 'u', 't', ' ', 'd', 'o', 'g', 's', ' ', 'a', 'r', 'e', ' ', 'b', 'e', 't', 't', 'e', 'r', '!'`] 長所と短所: 単語ベースの方法と比較すると、文字ベースの方法では語彙のサイズがはるかに小さく、語彙外のトークンがはるかに少なくなります。スペルミスのある単語にフラグを立てることができます (ただし、単語の正しい形式と同じ形式ではありません)。 しかし、このアプローチにはいくつかの欠点もあります。文字ベースの方法を使用して生成された単一のトークンには、ごくわずかな情報しか保存されません。これは、単語ベースのアプローチのトークンとは異なり、意味や文脈上の意味がキャプチャされないためです (特に英語などのアルファベットベースの表記体系を使用する言語の場合)。このアプローチでは、入力テキストをエンコードするために多くの数値が必要になるため、言語モデルに入力できるトークン化された入力のサイズが制限されます。 3. サブワードベースのトークナイザーサブワードベースのトークン化は、単語ベースと文字ベースの両方のアプローチの利点を実現しながら、欠点を最小限に抑えることができます。サブワードベースの方法は、単語内でテキストを分割し、完全な単語ではないものの、意味を持つトークンを作成することで中間的な立場をとります。たとえば、ing と ed という記号は、それ自体は単語ではありませんが、文法的な意味を持っています。 このアプローチでは、単語ベースの方法よりも語彙サイズは小さくなりますが、文字ベースの方法よりも語彙サイズは大きくなります。各トークンに保存される情報量についても同様であり、これも前の 2 つの方法で生成されたトークンの間にあります。 一般的でない単語のみを分割すると、記号間の関係を維持しながら、単語の形や複数形などを構成要素に分解できます。たとえば、cat はデータセット内で非常に一般的な単語である可能性がありますが、 cats はそれほど一般的ではない可能性があります。したがって、cats は cat と s に分割され、cats には他のすべての cats トークンと同じ値が与えられ、s には複数形の意味をエンコードできる別の値が与えられます。もう 1 つの例は、単語のトークン化です。これは、ルート トークンと接尾辞化に分けることができます。このアプローチは、構文的および意味的な類似性を維持することができます[6]。これらの理由から、サブワードベースのタグ付けは、今日の NLP モデルで非常に一般的に使用されています。 正規化と事前トークン化トークン化プロセスには、トークン化パイプラインを構成するいくつかの前処理および後処理の手順が必要です。トークン化方法（サブワードベース、文字ベースなど）はモデルステップ[7]で行われる。 Hugging Face のトランスフォーマー ライブラリのトークナイザーを使用すると、トークン化パイプラインのすべてのステップが自動的に処理されます。パイプライン全体は、Tokenizer と呼ばれるオブジェクトによって実行されます。このセクションでは、NLP タスクを実行するときにほとんどのユーザーが手動で処理する必要のないコードの内部動作について詳しく説明します。また、トークナイザー ライブラリの基本トークナイザー クラスをカスタマイズする手順についても説明します。これにより、必要に応じて特定のタスク専用のトークナイザーを構築できます。 1. 標準化された方法正規化は、テキストをトークンに分割する前にクリーンアップするプロセスです。これには、各文字を小文字に変換する、文字の重複を削除する、不要な空白を削除するなどの手順が含まれます。たとえば、文字列「ThÍs」は「áN exemplise sÉnteNCE」です。正規化プログラムによって実行される手順は異なります。 Hugging Face の Normalizers パッケージには、いくつかの基本的な Normalizers が含まれています。よく使用されるものは次のとおりです。 NFC: 大文字と小文字の変換やアクセントの削除は行いません 小文字: アクセントを削除せずに大文字と小文字を変換します BERT: 大文字と小文字の変換とアクセントの削除 上記の 3 つの方法を比較してみましょう。 from tokenizers.normalizers import NFC, Lowercase, BertNormalizer # Text to normalize text = 'ThÍs is áN ExaMPlé sÉnteNCE' # Instantiate normalizer objects NFCNorm = NFC() LowercaseNorm = Lowercase() BertNorm = BertNormalizer() # Normalize the text print(f'NFC: {NFCNorm.normalize_str(text)}') print(f'Lower: {LowercaseNorm.normalize_str(text)}') print(f'BERT: {BertNorm.normalize_str(text)}') #NFC: ThÍs is áN ExaMPlé sÉnteNCE #Lower: thís is án examplé séntence #BERT: this is an example sentence 以下の例では、NFC のみ不要な空白が削除されていることがわかります。 from transformers import FNetTokenizerFast, CamembertTokenizerFast, \ BertTokenizerFast # Text to normalize text = 'ThÍs is áN ExaMPlé sÉnteNCE' # Instantiate tokenizers FNetTokenizer = FNetTokenizerFast.from_pretrained('google/fnet-base') CamembertTokenizer = CamembertTokenizerFast.from_pretrained('camembert-base') BertTokenizer = BertTokenizerFast.from_pretrained('bert-base-uncased') # Normalize the text print(f'FNet Output: \ {FNetTokenizer.backend_tokenizer.normalizer .normalize_str(text)}') print(f'CamemBERT Output: \ {CamembertTokenizer.backend_tokenizer.normalizer.normalize_str(text)}') print(f'BERT Output: \ {BertTokenizer.backend_tokenizer.normalizer.normalize_str(text)}') #FNet Output: ThÍs is áN ExaMPlé sÉnteNCE #CamemBERT Output: ThÍs is áN ExaMPlé sÉnteNCE #BERT Output: this is an example sentence 2. 事前トークン化事前トークン化ステップは、トークン化された生のテキストの最初のセグメンテーションです。セグメンテーションは、最終的なラベル付けの上限を与えるために実行されます。文は、事前トークン化ステップで複数の単語に分割され、その後、モデリングステップで、タグ付け方法 (サブワードベースの方法など) に従って一部の単語がさらに分割されます。したがって、トークン化前のテキストは、トークン化後に残っている可能性のある最大のトークンを表します。 たとえば、文は、すべてのスペース、すべてのスペースと一部の句読点、またはすべてのスペースとすべての句読点に基づいて分割できます。 基本的な Whitespacesplit プレトークナイザーと、もう少し複雑な BertPreTokenizer の比較を以下に示します。 pre_tokenizers パッケージ。空白の事前トークナイザーの出力では、句読点はそのまま保持され、隣接する単語との接続が維持されます。たとえば、includes: は単一の単語として扱われます。 BERT事前タグ付け機能は句読点を単語として扱います[8]。 from tokenizers.pre_tokenizers import WhitespaceSplit, BertPreTokenizer # Text to normalize text = ("this sentence's content includes: characters, spaces, and " \ "punctuation.") # Define helper function to display pre-tokenized output def print_pretokenized_str(pre_tokens): for pre_token in pre_tokens: print(f'"{pre_token[0]}", ', end='') # Instantiate pre-tokenizers wss = WhitespaceSplit() bpt = BertPreTokenizer() # Pre-tokenize the text print('Whitespace Pre-Tokenizer:') print_pretokenized_str(wss.pre_tokenize_str(text)) #Whitespace Pre-Tokenizer: #"this", "sentence's", "content", "includes:", "characters,", "spaces,", #"and", "punctuation.", print('\n\nBERT Pre-Tokenizer:') print_pretokenized_str(bpt.pre_tokenize_str(text)) #BERT Pre-Tokenizer: #"this", "sentence", "'", "s", "content", "includes", ":", "characters", #",", "spaces", ",", "and", "punctuation", ".", GPT-2 や ALBERT (A Lite BERT) トークナイザーなどの一般的なトークナイザーから、事前トークン化メソッドを直接呼び出すことができます。これらの方法は、トークンを分割するときに空白文字が削除されないという点で、上記の標準の BERT プリトークナイザーとは少し異なります。これらは、スペースが配置されるべき場所を表す特殊文字に置き換えられます。これには、以降の処理中に空白文字を無視できるという利点がありますが、必要に応じて元の文を取得できます。 GPT-2 モデルでは、上にドットがある大文字の G である Ġ 文字が使用されます。 ALBERT モデルではアンダースコア文字が使用されます。 from transformers import AutoTokenizer # Text to pre-tokenize text = ("this sentence's content includes: characters, spaces, and " \ "punctuation.") # Instatiate the pre-tokenizers GPT2_PreTokenizer = AutoTokenizer.from_pretrained('gpt2').backend_tokenizer \ .pre_tokenizer Albert_PreTokenizer = AutoTokenizer.from_pretrained('albert-base-v1') \ .backend_tokenizer.pre_tokenizer # Pre-tokenize the text print('GPT-2 Pre-Tokenizer:') print_pretokenized_str(GPT2_PreTokenizer.pre_tokenize_str(text)) #GPT-2 Pre-Tokenizer: #"this", "Ġsentence", "'s", "Ġcontent", "Ġincludes", ":", "Ġcharacters", ",", #"Ġspaces", ",", "Ġand", "Ġpunctuation", ".", print('\n\nALBERT Pre-Tokenizer:') print_pretokenized_str(Albert_PreTokenizer.pre_tokenize_str(text)) #ALBERT Pre-Tokenizer: #"▁this", "▁sentence's", "▁content", "▁includes:", "▁characters,", "▁spaces,", #"▁and", "▁punctuation.", 以下は、同じ例文に対する BERT 事前トークン化ステップの結果を示しています。返されるオブジェクトは、タプルを含む Python リストです。各タプルはプレトークンに対応しており、最初の要素はプレトークン文字列で、2 番目の要素は元の入力テキスト内の文字列の開始と終了のインデックスを含むタプルです。 from tokenizers.pre_tokenizers import WhitespaceSplit, BertPreTokenizer # Text to pre-tokenize text = ("this sentence's content includes: characters, spaces, and " \ "punctuation.") # Instantiate pre-tokenizer bpt = BertPreTokenizer() # Pre-tokenize the text bpt.pre_tokenize_str(example_sentence) 結果は次のとおりです。 [('this', (0, 4)), ('sentence', (5, 13)), ("'", (13, 14)), ('s', (14, 15)), ('content', (16, 23)), ('includes', (24, 32)), (':', (32, 33)), ('characters', (34, 44)), (',', (44, 45)), ('spaces', (46, 52)), (',', (52, 53)), ('and', (54, 57)), ('punctuation', (58, 69)), ('.', (69, 70))] サブワードトークン化法セグメンテーションと事前トークン化が完了したら、タグのマージを開始できます。トランスフォーマー モデルでは、サブワード ベースのメソッドを実装するために一般的に使用される 3 つの方法があります。これらはすべて、あまり一般的でない単語をより小さなトークンに分割するために、わずかに異なる手法を使用します。 1. バイトペアエンコーディングバイトペアエンコーディングアルゴリズムは、GPTやGPT-2モデル（OpenAI）、BART（Lewisら）などの一般的に使用されているトークナイザーです[9-10]。もともとはテキスト圧縮アルゴリズムとして設計されましたが、言語モデルにおけるトークン化のタスクに非常に適していることがわかりました。 BPEアルゴリズムは、テキスト文字列を参照コーパス（トークン化モデルのトレーニングに使用されるテキスト）に頻繁に出現するサブワード単位に分解します[11]。 BPE モデルのトレーニング方法は次のとおりです。 a) コーパスの構築 入力テキストは正規化および事前トークン化モデルに送られ、クリーンな単語リストが作成されます。これらの単語は BPE モデルに渡され、各単語の頻度が決定され、その数値が単語とともにコーパスと呼ばれるリストに保存されます。 b) 語彙力の構築 次に、コーパス内の単語は個々の文字に分解され、「語彙」と呼ばれる空のリストに追加されます。アルゴリズムは、どの文字ペアを結合できるかを判断するたびに、この語彙を繰り返し追加します。 c) 文字ペアの頻度を調べる 次に、コーパス内の各単語の文字ペアの頻度が記録されます。たとえば、cat という単語には、ca、at、ts という文字のペアが含まれます。すべての単語はこのようにチェックされ、グローバル頻度カウンターに反映されます。任意のタグで CA のインスタンスが見つかると、CA ペアの頻度カウンターが増加します。 d) マージルールを作成する 各文字ペアの頻度がわかると、最も頻繁に使用される文字ペアが語彙に追加されます。語彙表には、記号内のすべての文字と最も一般的な文字のペアが含まれるようになりました。これにより、モデルが使用できるマージ ルールも提供されます。たとえば、モデルが ca が最も一般的な文字ペアであることを学習した場合、モデルはコーパス内の c と a のすべての隣接するインスタンスを結合して ca を取得できることを学習したことになります。これで、残りの手順を 1 つの文字として処理できるようになりました。 手順 c と d を繰り返して、さらに多くの結合ルールを見つけ、語彙にさらに多くの文字ペアを追加します。このプロセスは、語彙サイズがトレーニングの開始時に指定された目標サイズに達するまで継続されます。 以下はBPEアルゴリズムのPython実装です。 class TargetVocabularySizeError(Exception): def __init__(self, message): super().__init__(message) class BPE: '''An implementation of the Byte Pair Encoding tokenizer.''' def calculate_frequency(self, words): ''' Calculate the frequency for each word in a list of words. Take in a list of words stored as strings and return a list of tuples where each tuple contains a string from the words list, and an integer representing its frequency count in the list. Args: words (list): A list of words (strings) in any order. Returns: corpus (list[tuple(str, int)]): A list of tuples where the first element is a string of a word in the words list, and the second element is an integer representing the frequency of the word in the list. ''' freq_dict = dict() for word in words: if word not in freq_dict: freq_dict[word] = 1 else: freq_dict[word] += 1 corpus = [(word, freq_dict[word]) for word in freq_dict.keys()] return corpus def create_merge_rule(self, corpus): ''' Create a merge rule and add it to the self.merge_rules list. Args: corpus (list[tuple(list, int)]): A list of tuples where the first element is a list of a word in the words list (where the elements are the individual characters (or subwords in later iterations) of the word), and the second element is an integer representing the frequency of the word in the list. Returns: None ''' pair_frequencies = self.find_pair_frequencies(corpus) most_frequent_pair = max(pair_frequencies, key=pair_frequencies.get) self.merge_rules.append(most_frequent_pair.split(',')) self.vocabulary.append(most_frequent_pair) def create_vocabulary(self, words): ''' Create a list of every unique character in a list of words. Args: words (list): A list of strings containing the words of the input text. Returns: vocabulary (list): A list of every unique character in the list of input words. ''' vocabulary = list(set(''.join(words))) return vocabulary def find_pair_frequencies(self, corpus): ''' Find the frequency of each character pair in the corpus. Loop through the corpus and calculate the frequency of each pair of adjacent characters across every word. Return a dictionary of each character pair as the keys and the corresponding frequency as the values. Args: corpus (list[tuple(list, int)]): A list of tuples where the first element is a list of a word in the words list (where the elements are the individual characters (or subwords in later iterations) of the word), and the second element is an integer representing the frequency of the word in the list. Returns: pair_freq_dict (dict): A dictionary where the keys are the character pairs from the input corpus and the values are an integer representing the frequency of the pair in the corpus. ''' pair_freq_dict = dict() for word, word_freq in corpus: for idx in range(len(word)-1): char_pair = f'{word[idx]},{word[idx+1]}' if char_pair not in pair_freq_dict: pair_freq_dict[char_pair] = word_freq else: pair_freq_dict[char_pair] += word_freq return pair_freq_dict def get_merged_chars(self, char_1, char_2): ''' Merge the highest score pair and return to the self.merge method. This method is abstracted so that the BPE class can be used as the base class for other Tokenizers, and so the merging method can be easily overwritten. For example, in the BPE algorithm the characters can simply be concatenated and returned. However in the WordPiece algorithm, the # symbols must first be stripped. Args: char_1 (str): The first character in the highest-scoring pair. char_2 (str): The second character in the highest-scoring pair. Returns: merged_chars (str): Merged characters. ''' merged_chars = char_1 + char_2 return merged_chars def initialize_corpus(self, words): ''' Split each word into characters and count the word frequency. Split each word in the input word list on every character. For each word, store the split word in a list as the first element inside a tuple. Store the frequency count of the word as an integer as the second element of the tuple. Create a tuple for every word in this fashion and store the tuples in a list called 'corpus', then return then corpus list. Args: None Returns: corpus (list[tuple(list, int)]): A list of tuples where the first element is a list of a word in the words list (where the elements are the individual characters of the word), and the second element is an integer representing the frequency of the word in the list. ''' corpus = self.calculate_frequency(words) corpus = [([*word], freq) for (word, freq) in corpus] return corpus def merge(self, corpus): ''' Loop through the corpus and perform the latest merge rule. Args: corpus (list[tuple(list, int)]): A list of tuples where the first element is a list of a word in the words list (where the elements are the individual characters (or subwords in later iterations) of the word), and the second element is an integer representing the frequency of the word in the list. Returns: new_corpus (list[tuple(list, int)]): A modified version of the input argument where the most recent merge rule has been applied to merge the most frequent adjacent characters. ''' merge_rule = self.merge_rules[-1] new_corpus = [] for word, word_freq in corpus: new_word = [] idx = 0 while idx < len(word): # If a merge pattern has been found if (len(word) != 1) and (word[idx] == merge_rule[0]) and\ (word[idx+1] == merge_rule[1]): new_word.append(self.get_merged_chars(word[idx],word[idx+1])) idx += 2 # If a merge patten has not been found else: new_word.append(word[idx]) idx += 1 new_corpus.append((new_word, word_freq)) return new_corpus def train(self, words, target_vocab_size): ''' Train the model. Args: words (list[str]): A list of words to train the model on. target_vocab_size (int): The number of words in the vocabulary to be used as the stopping condition when training. Returns: None. ''' self.words = words self.target_vocab_size = target_vocab_size self.corpus = self.initialize_corpus(self.words) self.corpus_history = [self.corpus] self.vocabulary = self.create_vocabulary(self.words) self.vocabulary_size = len(self.vocabulary) self.merge_rules = [] # Iteratively add vocabulary until reaching the target vocabulary size if len(self.vocabulary) > self.target_vocab_size: raise TargetVocabularySizeError(f'Error: Target vocabulary size \ must be greater than the initial vocabulary size \ ({len(self.vocabulary)})') else: while len(self.vocabulary) < self.target_vocab_size: try: self.create_merge_rule(self.corpus) self.corpus = self.merge(self.corpus) self.corpus_history.append(self.corpus) # If no further merging is possible except ValueError: print('Exiting: No further merging is possible') break def tokenize(self, text): ''' Take in some text and return a list of tokens for that text. Args: text (str): The text to be tokenized. Returns: tokens (list): The list of tokens created from the input text. ''' tokens = [*text] for merge_rule in self.merge_rules: new_tokens = [] idx = 0 while idx < len(tokens): # If a merge pattern has been found if (len(tokens) != 1) and (tokens[idx] == merge_rule[0]) and \ (tokens[idx+1] == merge_rule[1]): new_tokens.append(self.get_merged_chars(tokens[idx], tokens[idx+1])) idx += 2 # If a merge patten has not been found else: new_tokens.append(tokens[idx]) idx += 1 tokens = new_tokens return tokens 詳細な使用手順: # Training set words = ['cat', 'cat', 'cat', 'cat', 'cat', 'cats', 'cats', 'eat', 'eat', 'eat', 'eat', 'eat', 'eat', 'eat', 'eat', 'eat', 'eat', 'eating', 'eating', 'eating', 'running', 'running', 'jumping', 'food', 'food', 'food', 'food', 'food', 'food'] # Instantiate the tokenizer bpe = BPE() bpe.train(words, 21) # Print the corpus at each stage of the process, and the merge rule used print(f'INITIAL CORPUS:\n{bpe.corpus_history[0]}\n') for rule, corpus in list(zip(bpe.merge_rules, bpe.corpus_history[1:])): print(f'NEW MERGE RULE: Combine "{rule[0]}" and "{rule[1]}"') print(corpus, end='\n\n') 結果出力 INITIAL CORPUS: [(['c', 'a', 't'], 5), (['c', 'a', 't', 's'], 2), (['e', 'a', 't'], 10), (['e', 'a', 't', 'i', 'n', 'g'], 3), (['r', 'u', 'n', 'n', 'i', 'n', 'g'], 2), (['j', 'u', 'm', 'p', 'i', 'n', 'g'], 1), (['f', 'o', 'o', 'd'], 6)] NEW MERGE RULE: Combine "a" and "t" [(['c', 'at'], 5), (['c', 'at', 's'], 2), (['e', 'at'], 10), (['e', 'at', 'i', 'n', 'g'], 3), (['r', 'u', 'n', 'n', 'i', 'n', 'g'], 2), (['j', 'u', 'm', 'p', 'i', 'n', 'g'], 1), (['f', 'o', 'o', 'd'], 6)] NEW MERGE RULE: Combine "e" and "at" [(['c', 'at'], 5), (['c', 'at', 's'], 2), (['eat'], 10), (['eat', 'i', 'n', 'g'], 3), (['r', 'u', 'n', 'n', 'i', 'n', 'g'], 2), (['j', 'u', 'm', 'p', 'i', 'n', 'g'], 1), (['f', 'o', 'o', 'd'], 6)] NEW MERGE RULE: Combine "c" and "at" [(['cat'], 5), (['cat', 's'], 2), (['eat'], 10), (['eat', 'i', 'n', 'g'], 3), (['r', 'u', 'n', 'n', 'i', 'n', 'g'], 2), (['j', 'u', 'm', 'p', 'i', 'n', 'g'], 1), (['f', 'o', 'o', 'd'], 6)] NEW MERGE RULE: Combine "i" and "n" [(['cat'], 5), (['cat', 's'], 2), (['eat'], 10), (['eat', 'in', 'g'], 3), (['r', 'u', 'n', 'n', 'in', 'g'], 2), (['j', 'u', 'm', 'p', 'in', 'g'], 1), (['f', 'o', 'o', 'd'], 6)] NEW MERGE RULE: Combine "in" and "g" [(['cat'], 5), (['cat', 's'], 2), (['eat'], 10), (['eat', 'ing'], 3), (['r', 'u', 'n', 'n', 'ing'], 2), (['j', 'u', 'm', 'p', 'ing'], 1), (['f', 'o', 'o', 'd'], 6)]
私たちのコードはプロセスを学習するためのものです。実際のアプリケーションでは、トランスフォーマー ライブラリを直接使用できます。 BPE タガーは、トレーニング データに表示される文字のみを認識できます。含まれていない単語が表示された場合、その文字は不明な文字に変換されます。モデルが実際のデータにラベルを付けるために使用される場合。ただし、BPE エラー処理では不明な文字のマーカーが追加されないため、一部の製品モデルがクラッシュする可能性があります。 しかし、 GPT-2 と RoBERTa で使用される BPE タガーにはこの問題はありません。 Unicode 文字に基づいてトレーニング データを分析するのではなく、文字のバイトを分析します。これはバイトレベル BPE と呼ばれ、小さな基本語彙を使用して、モデルが認識する可能性のあるすべての文字にラベルを付けることができます。 2. ワードピースWordPiece は、Google が BERT モデル用に開発したトークン化手法であり、DistilBERT や MobileBERT などの派生モデルで使用されています。 WordPieceアルゴリズムの詳細はまだ公開されていないため、本論文で紹介する方法はHugging Face [12]による説明に基づいています。 WordPiece アルゴリズムは BPE に似ていますが、マージ ルールを決定するために異なるメトリックを使用します。最も頻繁に出現する文字のペアを選択する代わりに、各ペアのスコアが計算され、スコアが最も高いペアによって結合される文字が決定されます。 WordPiece は次のようにトレーニングされます。 a) コーパスの構築 入力テキストは正規化および事前トークン化モデルに送られ、クリーンな単語が作成されます。 b) 語彙の構築 BPE と同様に、コーパス内の単語は個々の文字に分割され、語彙と呼ばれる空のリストに追加されます。ただし、今回は、個々の文字を単純に保存するのではなく、2 つの # 記号をマーカーとして使用して、文字が単語の先頭にあるか、中間/末尾にあるかを判断します。たとえば、単語 cat は BPE では ['c', 'a', 't'] に分割されますが、WordPiece では ['c', '##a', '##t'] のようになります。単語の先頭の c は、単語の途中または末尾の ##c とは異なる扱いを受けます。この語彙は、アルゴリズムがどの文字のペアを結合できるかを決定するたびに繰り返し追加されます。 c) 隣接する文字ペアごとにペアリングスコアを計算する BPE モデルとは異なり、今回は文字ペアごとにスコアが計算されます。コーパス内の隣接する文字のペアをすべて識別します。 「c##a」、「##a##t」などを入力して頻度を計算します。各文字が個別に出現する頻度も決定されます。これらの値がわかれば、次の式に従ってペアリングスコアを計算できます。 このメトリックは、一緒に頻繁に登場するが、単独で、または他のキャラクターと一緒に登場する頻度は低いキャラクターに、より高いスコアを割り当てます。これが WordPiece と BPE の主な違いです。BPE では、個々の文字自体の全体的な頻度は考慮されません。 d) マージルールを作成する 高いスコアは、一緒に頻繁に登場する文字のペアを表します。つまり、c##a のペアリング スコアが高い場合、c と a はコーパス内で単独ではなく一緒に出現することが多いということです。 BPE と同様に、マージ ルールは最高スコアの文字ペアによって決定されますが、今回はスコアは頻度ではなく文字ペアのスコアによって決定されます。 次に、手順 c と d を繰り返して、さらに多くの結合ルールを見つけ、語彙にさらに多くの文字ペアを追加します。このプロセスは、語彙サイズがトレーニングの開始時に指定された目標サイズに達するまで継続されます。 以下は簡単なコード例です。 class WordPiece(BPE): def add_hashes(self, word): ''' Add # symbols to every character in a word except the first. Take in a word as a string and add # symbols to every character except the first. Return the result as a list where each element is a character with # symbols in front, except the first character which is just the plain character. Args: word (str): The word to add # symbols to. Returns: hashed_word (list): A list of the characters with # symbols (except the first character which is just the plain character). ''' hashed_word = [word[0]] for char in word[1:]: hashed_word.append(f'##{char}') return hashed_word def create_merge_rule(self, corpus): ''' Create a merge rule and add it to the self.merge_rules list. Args: corpus (list[tuple(list, int)]): A list of tuples where the first element is a list of a word in the words list (where the elements are the individual characters (or subwords in later iterations) of the word), and the second element is an integer representing the frequency of the word in the list. Returns: None ''' pair_frequencies = self.find_pair_frequencies(corpus) char_frequencies = self.find_char_frequencies(corpus) pair_scores = self.find_pair_scores(pair_frequencies, char_frequencies) highest_scoring_pair = max(pair_scores, key=pair_scores.get) self.merge_rules.append(highest_scoring_pair.split(',')) self.vocabulary.append(highest_scoring_pair) def create_vocabulary(self, words): ''' Create a list of every unique character in a list of words. Unlike the BPE algorithm where each character is stored normally, here a distinction is made by characters that begin a word (unmarked), and characters that are in the middle or end of a word (marked with a '##'). For example, the word 'cat' will be split into ['c', '##a', '##t']. Args: words (list): A list of strings containing the words of the input text. Returns: vocabulary (list): A list of every unique character in the list of input words, marked accordingly with ## to denote if the character was featured in the middle/end of a word, instead of as the first character of the word. ''' vocabulary = set() for word in words: vocabulary.add(word[0]) for char in word[1:]: vocabulary.add(f'##{char}') # Convert to list so the vocabulary can be appended to later vocabulary = list(vocabulary) return vocabulary def find_char_frequencies(self, corpus): ''' Find the frequency of each character in the corpus. Loop through the corpus and calculate the frequency of characters. Note that 'c' and '##c' are different characters, since the first represents a 'c' at the start of a word, and '##c' represents a 'c' in the middle/end of a word. Return a dictionary of each character pair as the keys and the corresponding frequency as the values. Args: corpus (list[tuple(list, int)]): A list of tuples where the first element is a list of a word in the words list (where the elements are the individual characters (or subwords in later iterations) of the word), and the second element is an integer representing the frequency of the word in the list. Returns: pair_freq_dict (dict): A dictionary where the keys are the characters from the input corpus and the values are an integer representing the frequency. ''' char_frequencies = dict() for word, word_freq in corpus: for char in word: if char in char_frequencies: char_frequencies[char] += word_freq else: char_frequencies[char] = word_freq return char_frequencies def find_pair_scores(self, pair_frequencies, char_frequencies): ''' Find the pair score for each character pair in the corpus. Loops through the pair_frequencies dictionary and calculate the pair score for each pair of adjacent characters in the corpus. Store the scores in a dictionary and return it. Args: pair_frequencies (dict): A dictionary where the keys are the adjacent character pairs in the corpus and the values are the frequencies of each pair. char_frequencies (dict): A dictionary where the keys are the characters in the corpus and the values are corresponding frequencies. Returns: pair_scores (dict): A dictionary where the keys are the adjacent character pairs in the input corpus and the values are the corresponding pair score. ''' pair_scores = dict() for pair in pair_frequencies.keys(): char_1 = pair.split(',')[0] char_2 = pair.split(',')[1] denominator = (char_frequencies[char_1]*char_frequencies[char_2]) score = (pair_frequencies[pair]) / denominator pair_scores[pair] = score return pair_scores def get_merged_chars(self, char_1, char_2): ''' Merge the highest score pair and return to the self.merge method. Remove the # symbols as necessary and merge the highest scoring pair then return the merged characters to the self.merge method. Args: char_1 (str): The first character in the highest-scoring pair. char_2 (str): The second character in the highest-scoring pair. Returns: merged_chars (str): Merged characters. ''' if char_2.startswith('##'): merged_chars = char_1 + char_2[2:] else: merged_chars = char_1 + char_2 return merged_chars def initialize_corpus(self, words): ''' Split each word into characters and count the word frequency. Split each word in the input word list on every character. For each word, store the split word in a list as the first element inside a tuple. Store the frequency count of the word as an integer as the second element of the tuple. Create a tuple for every word in this fashion and store the tuples in a list called 'corpus', then return then corpus list. Args: None. Returns: corpus (list[tuple(list, int)]): A list of tuples where the first element is a list of a word in the words list (where the elements are the individual characters of the word), and the second element is an integer representing the frequency of the word in the list. ''' corpus = self.calculate_frequency(words) corpus = [(self.add_hashes(word), freq) for (word, freq) in corpus] return corpus def tokenize(self, text): ''' Take in some text and return a list of tokens for that text. Args: text (str): The text to be tokenized. Returns: tokens (list): The list of tokens created from the input text. ''' # Create cleaned vocabulary list without # and commas to check against clean_vocabulary = [word.replace('#', '').replace(',', '') for word in self.vocabulary] clean_vocabulary.sort(key=lambda word: len(word)) clean_vocabulary = clean_vocabulary[::-1] # Break down the text into the largest tokens first, then smallest remaining_string = text tokens = [] keep_checking = True while keep_checking: keep_checking = False for vocab in clean_vocabulary: if remaining_string.startswith(vocab): tokens.append(vocab) remaining_string = remaining_string[len(vocab):] keep_checking = True if len(remaining_string) > 0: tokens.append(remaining_string) return tokens ワードピースは、BPEアルゴリズムで学習したタグとは大きく異なります。ワードピースは、単独で見えるよりも頻繁に表示されるキャラクターの組み合わせを好むことは明らかです。そのため、MとPはすぐにマージされます。これは、単独ではなくデータセットにのみ存在するためです。 wp = WordPiece() wp.train(words, 30) print(f'INITIAL CORPUS:\n{wp.corpus_history[0]}\n') for rule, corpus in list(zip(wp.merge_rules, wp.corpus_history[1:])): print(f'NEW MERGE RULE: Combine "{rule[0]}" and "{rule[1]}"') print(corpus, end='\n\n') 結果： INITIAL CORPUS: [(['c', '##a', '##t'], 5), (['c', '##a', '##t', '##s'], 2), (['e', '##a', '##t'], 10), (['e', '##a', '##t', '##i', '##n', '##g'], 3), (['r', '##u', '##n', '##n', '##i', '##n', '##g'], 2), (['j', '##u', '##m', '##p', '##i', '##n', '##g'], 1), (['f', '##o', '##o', '##d'], 6)] NEW MERGE RULE: Combine "##m" and "##p" [(['c', '##a', '##t'], 5), (['c', '##a', '##t', '##s'], 2), (['e', '##a', '##t'], 10), (['e', '##a', '##t', '##i', '##n', '##g'], 3), (['r', '##u', '##n', '##n', '##i', '##n', '##g'], 2), (['j', '##u', '##mp', '##i', '##n', '##g'], 1), (['f', '##o', '##o', '##d'], 6)] NEW MERGE RULE: Combine "r" and "##u" [(['c', '##a', '##t'], 5), (['c', '##a', '##t', '##s'], 2), (['e', '##a', '##t'], 10), (['e', '##a', '##t', '##i', '##n', '##g'], 3), (['ru', '##n', '##n', '##i', '##n', '##g'], 2), (['j', '##u', '##mp', '##i', '##n', '##g'], 1), (['f', '##o', '##o', '##d'], 6)] NEW MERGE RULE: Combine "j" and "##u" [(['c', '##a', '##t'], 5), (['c', '##a', '##t', '##s'], 2), (['e', '##a', '##t'], 10), (['e', '##a', '##t', '##i', '##n', '##g'], 3), (['ru', '##n', '##n', '##i', '##n', '##g'], 2), (['ju', '##mp', '##i', '##n', '##g'], 1), (['f', '##o', '##o', '##d'], 6)] NEW MERGE RULE: Combine "ju" and "##mp" [(['c', '##a', '##t'], 5), (['c', '##a', '##t', '##s'], 2), (['e', '##a', '##t'], 10), (['e', '##a', '##t', '##i', '##n', '##g'], 3), (['ru', '##n', '##n', '##i', '##n', '##g'], 2), (['jump', '##i', '##n', '##g'], 1), (['f', '##o', '##o', '##d'], 6)] NEW MERGE RULE: Combine "jump" and "##i" [(['c', '##a', '##t'], 5), (['c', '##a', '##t', '##s'], 2), (['e', '##a', '##t'], 10), (['e', '##a', '##t', '##i', '##n', '##g'], 3), (['ru', '##n', '##n', '##i', '##n', '##g'], 2), (['jumpi', '##n', '##g'], 1), (['f', '##o', '##o', '##d'], 6)] NEW MERGE RULE: Combine "##i" and "##n" [(['c', '##a', '##t'], 5), (['c', '##a', '##t', '##s'], 2), (['e', '##a', '##t'], 10), (['e', '##a', '##t', '##in', '##g'], 3), (['ru', '##n', '##n', '##in', '##g'], 2), (['jumpi', '##n', '##g'], 1), (['f', '##o', '##o', '##d'], 6)] NEW MERGE RULE: Combine "ru" and "##n" [(['c', '##a', '##t'], 5), (['c', '##a', '##t', '##s'], 2), (['e', '##a', '##t'], 10), (['e', '##a', '##t', '##in', '##g'], 3), (['run', '##n', '##in', '##g'], 2), (['jumpi', '##n', '##g'], 1), (['f', '##o', '##o', '##d'], 6)] NEW MERGE RULE: Combine "run" and "##n" [(['c', '##a', '##t'], 5), (['c', '##a', '##t', '##s'], 2), (['e', '##a', '##t'], 10), (['e', '##a', '##t', '##in', '##g'], 3), (['runn', '##in', '##g'], 2), (['jumpi', '##n', '##g'], 1), (['f', '##o', '##o', '##d'], 6)] NEW MERGE RULE: Combine "jumpi" and "##n" [(['c', '##a', '##t'], 5), (['c', '##a', '##t', '##s'], 2), (['e', '##a', '##t'], 10), (['e', '##a', '##t', '##in', '##g'], 3), (['runn', '##in', '##g'], 2), (['jumpin', '##g'], 1), (['f', '##o', '##o', '##d'], 6)] NEW MERGE RULE: Combine "runn" and "##in" [(['c', '##a', '##t'], 5), (['c', '##a', '##t', '##s'], 2), (['e', '##a', '##t'], 10), (['e', '##a', '##t', '##in', '##g'], 3), (['runnin', '##g'], 2), (['jumpin', '##g'], 1), (['f', '##o', '##o', '##d'], 6)] NEW MERGE RULE: Combine "##in" and "##g" [(['c', '##a', '##t'], 5), (['c', '##a', '##t', '##s'], 2), (['e', '##a', '##t'], 10), (['e', '##a', '##t', '##ing'], 3), (['runnin', '##g'], 2), (['jumpin', '##g'], 1), (['f', '##o', '##o', '##d'], 6)] NEW MERGE RULE: Combine "runnin" and "##g" [(['c', '##a', '##t'], 5), (['c', '##a', '##t', '##s'], 2), (['e', '##a', '##t'], 10), (['e', '##a', '##t', '##ing'], 3), (['running'], 2), (['jumpin', '##g'], 1), (['f', '##o', '##o', '##d'], 6)] NEW MERGE RULE: Combine "jumpin" and "##g" [(['c', '##a', '##t'], 5), (['c', '##a', '##t', '##s'], 2), (['e', '##a', '##t'], 10), (['e', '##a', '##t', '##ing'], 3), (['running'], 2), (['jumping'], 1), (['f', '##o', '##o', '##d'], 6)] NEW MERGE RULE: Combine "f" and "##o" [(['c', '##a', '##t'], 5), (['c', '##a', '##t', '##s'], 2), (['e', '##a', '##t'], 10), (['e', '##a', '##t', '##ing'], 3), (['running'], 2), (['jumping'], 1), (['fo', '##o', '##d'], 6)] トレーニングデータが限られているにもかかわらず、モデルはジャンパーという言葉が始まるなど、いくつかの有用なマークアップを学習することができます。最初に、文字列は['ジャンプ、「er」]に分解されます。なぜなら、ジャンプはトレーニングセットの単語の先頭に見られる最大のトークンだからです。次に、文字列ERは単一の文字に分類されます。これは、モデルが文字Eとrを組み合わせることを学んでいないためです。 print(wp.tokenize('jumper')) #['jump', 'e', 'r'] 3。ユニグラムUnigramマーカーは、大きな語彙から始めて、BPEとWordPieceとは異なるアプローチを採用し、目的のサイズに達するまで繰り返し減少します。 Unigramモデルは、文の各単語または文字の確率が考慮される統計的方法を使用します。これらのリストの各要素はマークTと見なすことができ、一連のマークT1、T2、…、TNの確率は次の方程式で与えられます。 a）コーパスの構築 いつものように、クリーンな単語を作成するために、正規化されたモデルと事前にトークン化されたモデルに入力テキストが提供されます b）語彙を構築します ユニグラムモデルの語彙サイズは最初に非常に大きく始まり、その後、希望するサイズに達するまで繰り返し減少します。初期の語彙を構築するには、コーパス内のすべての可能なサブストリングを見つけます。たとえば、コーパスの最初の単語が猫である場合、サブストリング['c'、 'a'、 't'、 's'、 'ca'、 'at'、 'ts'、 'cat'、 'ats']が用語集に追加されます。 c）各マーカーの確率を計算します コーパス内のマーカーの発生数を見つけることにより、マーカーの総出現数でそれらを除算することにより、マーカーの発生の可能性をほぼ計算できます。 d）単語のすべての可能なセグメンテーションを見つけます トレーニングコーパスの単語が猫であると仮定します。これは、次のように分類できます。 ['猫'] （"猫"） [' 猫'] （"猫"） e）コーパスで発生する各セグメンテーションのおおよその確率を計算します 上記の方程式を組み合わせると、各シリーズマーカーの確率が得られます。 セグメント['ca'、 't']は確率スコアが最も高いため、これは単語のマークに使用されるセグメントです。猫という言葉にマークされます['ca'、 't']。トークン化のような長い単語の場合、['トークン'、「iza」、tion]、['token'、 'ization]など、単語全体の複数の位置で分割が発生する可能性があると考えられます。 f）損失を計算します ここでの損失とは、語彙から重要なマークを削除するとモデルのスコアを指します。損失は大幅に増加しますが、それほど重要でないマークを削除すると、損失はあまり増加しません。各マーカーが削除された後にモデルの損失を計算することにより、語彙の最も役に立たないマーカーを見つけることができます。これは、語彙サイズがトレーニングセットコーパスで最も有用なマーカーのみに縮小されるまで、繰り返し繰り返すことができます。 ここの損失計算式は次のとおりです。 語彙を目的のサイズに縮小するのに十分な文字が削除されると、トレーニングが行われ、モデルを使用して単語をマークすることができます。 BPE、WordPiece、およびUnigramの比較トレーニングセットとタグ付けするデータに応じて、一部のトークンザーは他のものよりも優れたパフォーマンスを発揮する場合があります。言語モデルのタガーを選択するときは、特定のユースケースのトレーニングセットを試して、どれが最良の結果を提供するかを確認することをお勧めします。 これらの3つの方法のうち、BPEは現在の言語モデルマーカーの中で最も人気のある選択肢のようです。このような急速に変化する分野では、そのような変化は将来起こる可能性があります。しかし、Sentepeceなどの他のサブワードマーカーは、近年ますます人気が高まっています[13]。 WordPieceはBPEやUnigramよりも多くの単語マーカーを生成しているようですが、モデルの選択に関係なく、すべてのマーカーは語彙の増加に伴いマーカーが少ないようです[14]。 タガーの選択は、モデルで使用するデータセットによって異なります。ここでの提案は、実験のためにBPEまたは文章を試すことです。 後処理トークン化の最後のステップは後処理であり、必要に応じて出力を最終的に変更できます。 Bertはこのステップを使用して、2つのタイプのマークアップを追加します。 [CLS] - このタグは「カテゴリ」の略で、入力テキストの開始をマークするために使用されます。トレーニングされているタスクの1つは分類（したがってタグの名前）であるため、これはBertで必要です。分類タスクに使用されていなくても、このタグはモデルが期待するものです。 [SEP] - このタグは「分離」の略で、入力の文を分離するために使用されます。これは、同じプロンプト[15]で複数の命令を同時に処理するなど、Bertが実行する多くのタスクに役立ちます。 トークンザーライブラリトークン剤ライブラリにより、事前に訓練されたトークンザーを非常に使いやすくします。トークンザークラスをインポートするだけで、from_pretrainedメソッドを呼び出し、トークンザーを使用するモデル名を渡します。モデルのリストについては[16]を参照してください。 from tokenizers import Tokenizer tokenizer = Tokenizer.from_pretrained('bert-base-cased') 次の実装を直接使用できます BertWordPieceTokenizer - The famous Bert tokenizer, using WordPiece CharBPETokenizer - The original BPE ByteLevelBPETokenizer - The byte level version of the BPE SentencePieceBPETokenizer - A BPE implementation compatible with the one used by SentencePiece
こんにちは、カスタムトレーニングには列車方法を使用できます。トレーニングが完了したら、保存方法を使用して訓練されたマーカーを保存して、トレーニングを再度実行する必要がないようにします。 # Import a tokenizer from tokenizers import BertWordPieceTokenizer, CharBPETokenizer, \ ByteLevelBPETokenizer, SentencePieceBPETokenizer # Instantiate the model tokenizer = CharBPETokenizer() # Train the model tokenizer.train(['./path/to/files/1.txt', './path/to/files/2.txt']) # Tokenize some text encoded = tokenizer.encode('I can feel the magic, can you?') # Save the model tokenizer.save('./path/to/directory/my-bpe.tokenizer.json') 完全なカスタムトレーニングプロセスコードは次のとおりです。 from tokenizers import Tokenizer, models, pre_tokenizers, decoders, trainers, \ processors # Initialize a tokenizer tokenizer = Tokenizer(models.BPE()) # Customize pre-tokenization and decoding tokenizer.pre_tokenizer = pre_tokenizers.ByteLevel(add_prefix_space=True) tokenizer.decoder = decoders.ByteLevel() tokenizer.post_processor = processors.ByteLevel(trim_offsets=True) # And then train trainer = trainers.BpeTrainer( vocab_size=20000, min_frequency=2, initial_alphabet=pre_tokenizers.ByteLevel.alphabet() ) tokenizer.train([ "./path/to/dataset/1.txt", "./path/to/dataset/2.txt", "./path/to/dataset/3.txt" ], trainer=trainer) # And Save it tokenizer.save("byte-level-bpe.tokenizer.json", pretty=True) 要約するトークン化されたパイプラインは、言語モデルの重要な部分であり、どのタイプのトークン剤を使用するかを決定する際に慎重に検討する必要があります。抱きしめる顔は私たちのために作業のこの部分を処理しましたが、ラベル付け方法の深い理解は、モデルとさまざまなデータセットで得られたパフォーマンスを微調整するために非常に重要です。 |
