HuggingFace Tokenizers - NLP向け高速トークン化

RustパフォーマンスとユーザーフレンドリーなたいするPythonの組み合わせによる、高速で本番対応のトークナイザー。

HuggingFace Tokenizersを使用する場合

以下の場合、HuggingFace Tokenizersを使用してください：

• 非常に高速なトークン化が必要（テキスト1GBあたり20秒未満）
• カスタムトークナイザーをゼロから訓練する
• アライメント追跡（トークン→元のテキスト位置）を利用したい
• 本番対応のNLPパイプラインを構築している
• 大規模コーパスを効率的にトークン化する必要がある

パフォーマンス:

• 速度: CPUで1GBをトークン化するのに20秒未満
• 実装: Rustコアとして、Python/Node.jsバインディング
• 効率性: 純粋なPython実装より10～100倍高速

代わりに別の選択肢を使用してください:

• SentencePiece: 言語に依存しない。T5/ALBERTで使用
• tiktoken: GPTモデル向けOpenAIのBPEトークナイザー
• transformers AutoTokenizer: 事前訓練済みのロードのみ（内部でこのライブラリを使用）

クイックスタート

インストール

# tokenizersをインストール
pip install tokenizers

# transformersとの統合
pip install tokenizers transformers

事前訓練済みトークナイザーをロード

from tokenizers import Tokenizer

# HuggingFace Hubからロード
tokenizer = Tokenizer.from_pretrained("bert-base-uncased")

# テキストをエンコード
output = tokenizer.encode("Hello, how are you?")
print(output.tokens)  # ['hello', ',', 'how', 'are', 'you', '?']
print(output.ids)     # [7592, 1010, 2129, 2024, 2017, 1029]

# デコードして戻す
text = tokenizer.decode(output.ids)
print(text)  # "hello, how are you?"

カスタムBPEトークナイザーを訓練

from tokenizers import Tokenizer
from tokenizers.models import BPE
from tokenizers.trainers import BpeTrainer
from tokenizers.pre_tokenizers import Whitespace

# BPEモデルでトークナイザーを初期化
tokenizer = Tokenizer(BPE(unk_token="[UNK]"))
tokenizer.pre_tokenizer = Whitespace()

# トレーナーを設定
trainer = BpeTrainer(
    vocab_size=30000,
    special_tokens=["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]"],
    min_frequency=2
)

# ファイルで訓練
files = ["train.txt", "validation.txt"]
tokenizer.train(files, trainer)

# 保存
tokenizer.save("my-tokenizer.json")

訓練時間: 100MBコーパスで約1～2分、1GBで約10～20分

パディング付きバッチエンコーディング

# パディングを有効化
tokenizer.enable_padding(pad_id=3, pad_token="[PAD]")

# バッチをエンコード
texts = ["Hello world", "This is a longer sentence"]
encodings = tokenizer.encode_batch(texts)

for encoding in encodings:
    print(encoding.ids)
# [101, 7592, 2088, 102, 3, 3, 3]
# [101, 2023, 2003, 1037, 2936, 6251, 102]

トークン化アルゴリズム

BPE（Byte-Pair Encoding）

動作方法:

1. 文字レベルの語彙から開始
2. 最も頻繁な文字ペアを検出
3. 新しいトークンにマージし、語彙に追加
4. 語彙サイズに達するまで繰り返す

使用モデル: GPT-2, GPT-3, RoBERTa, BART, DeBERTa

from tokenizers import Tokenizer
from tokenizers.models import BPE
from tokenizers.trainers import BpeTrainer
from tokenizers.pre_tokenizers import ByteLevel

tokenizer = Tokenizer(BPE(unk_token="<|endoftext|>"))
tokenizer.pre_tokenizer = ByteLevel()

trainer = BpeTrainer(
    vocab_size=50257,
    special_tokens=["<|endoftext|>"],
    min_frequency=2
)

tokenizer.train(files=["data.txt"], trainer=trainer)

利点:

• OOV語を適切に処理（部分語に分割）
• 柔軟な語彙サイズ
• 形態論的に豊かな言語に適切

トレードオフ:

• トークン化はマージ順序に依存
• 一般的な単語が予期せず分割されることがある

WordPiece

動作方法:

1. 文字語彙から開始
2. マージペアをスコアリング: frequency(pair) / (frequency(first) × frequency(second))
3. 最も高いスコアを付けたペアをマージ
4. 語彙サイズに達するまで繰り返す

使用モデル: BERT, DistilBERT, MobileBERT

from tokenizers import Tokenizer
from tokenizers.models import WordPiece
from tokenizers.trainers import WordPieceTrainer
from tokenizers.pre_tokenizers import Whitespace
from tokenizers.normalizers import BertNormalizer

tokenizer = Tokenizer(WordPiece(unk_token="[UNK]"))
tokenizer.normalizer = BertNormalizer(lowercase=True)
tokenizer.pre_tokenizer = Whitespace()

trainer = WordPieceTrainer(
    vocab_size=30522,
    special_tokens=["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]"],
    continuing_subword_prefix="##"
)

tokenizer.train(files=["corpus.txt"], trainer=trainer)

利点:

• 意味のあるマージを優先化（高スコア=意味的に関連）
• BERTで成功的に使用（最先端の結果）

トレードオフ:

• 未知の単語は部分語マッチがない場合[UNK]になる
• 語彙を保存、マージルールではない（大きなファイル）

Unigram

動作方法:

1. 大きな語彙から開始（すべての部分文字列）
2. 現在の語彙でコーパスの損失を計算
3. 損失に対する影響が最小のトークンを削除
4. 語彙サイズに達するまで繰り返す

使用モデル: ALBERT, T5, mBART, XLNet（SentencePieceを経由）

from tokenizers import Tokenizer
from tokenizers.models import Unigram
from tokenizers.trainers import UnigramTrainer

tokenizer = Tokenizer(Unigram())

trainer = UnigramTrainer(
    vocab_size=8000,
    special_tokens=["<unk>", "<s>", "</s>"],
    unk_token="<unk>"
)

tokenizer.train(files=["data.txt"], trainer=trainer)

利点:

• 確率的（最も可能性の高いトークン化を検出）
• 単語境界がない言語で適切に機能
• 多様な言語コンテキストを処理

トレードオフ:

• 訓練が計算的にコスト高
• チューニングするハイパーパラメータが多い

トークン化パイプライン

完全なパイプライン: 正規化 → 前トークン化 → モデル → 後処理

正規化

テキストをクリーンアップして標準化：

from tokenizers.normalizers import NFD, StripAccents, Lowercase, Sequence

tokenizer.normalizer = Sequence([
    NFD(),           # Unicode正規化（分解）
    Lowercase(),     # 小文字に変換
    StripAccents()   # アクセント記号を削除
])

# 入力: "Héllo WORLD"
# 正規化後: "hello world"

一般的なノーマライザー:

• NFD, NFC, NFKD, NFKC - Unicode正規化形式
• Lowercase() - 小文字に変換
• StripAccents() - アクセント記号を削除（é → e）
• Strip() - 空白を削除
• Replace(pattern, content) - 正規表現の置換

前トークン化

テキストを単語のような単位に分割：

from tokenizers.pre_tokenizers import Whitespace, Punctuation, Sequence, ByteLevel

# 空白と句読点で分割
tokenizer.pre_tokenizer = Sequence([
    Whitespace(),
    Punctuation()
])

# 入力: "Hello, world!"
# 前トークン化後: ["Hello", ",", "world", "!"]

一般的な前トークナイザー:

• Whitespace() - スペース、タブ、改行で分割
• ByteLevel() - GPT-2スタイルのバイトレベル分割
• Punctuation() - 句読点を分離
• Digits(individual_digits=True) - 数字を個別に分割
• Metaspace() - スペースを▁に置換（SentencePieceスタイル）

後処理

モデル入力用の特殊トークンを追加：

from tokenizers.processors import TemplateProcessing

# BERTスタイル: [CLS] sentence [SEP]
tokenizer.post_processor = TemplateProcessing(
    single="[CLS] $A [SEP]",
    pair="[CLS] $A [SEP] $B [SEP]",
    special_tokens=[
        ("[CLS]", 1),
        ("[SEP]", 2),
    ],
)

一般的なパターン:

# GPT-2: sentence <|endoftext|>
TemplateProcessing(
    single="$A <|endoftext|>",
    special_tokens=[("<|endoftext|>", 50256)]
)

# RoBERTa: <s> sentence </s>
TemplateProcessing(
    single="<s> $A </s>",
    pair="<s> $A </s> </s> $B </s>",
    special_tokens=[("<s>", 0), ("</s>", 2)]
)

アライメント追跡

元のテキスト内のトークン位置を追跡：

output = tokenizer.encode("Hello, world!")

# トークンオフセットを取得
for token, offset in zip(output.tokens, output.offsets):
    start, end = offset
    print(f"{token:10} → [{start:2}, {end:2}): {text[start:end]!r}")

# 出力:
# hello      → [ 0,  5): 'Hello'
# ,          → [ 5,  6): ','
# world      → [ 7, 12): 'world'
# !          → [12, 13): '!'

ユースケース:

• 固有表現抽出（予測をテキストに逆マップ）
• 質問応答（答えのスパンを抽出）
• トークン分類（ラベルを元の位置に整列）

transformersとの統合

AutoTokenizerでロード

from transformers import AutoTokenizer

# AutoTokenizerは自動的に高速トークナイザーを使用
tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")

# 高速トークナイザーを使用しているかをチェック
print(tokenizer.is_fast)  # True

# 基礎となるtokenizers.Tokenizerにアクセス
fast_tokenizer = tokenizer.backend_tokenizer
print(type(fast_tokenizer))  # <class 'tokenizers.Tokenizer'>

カスタムトークナイザーをtransformersに変換

from tokenizers import Tokenizer
from transformers import PreTrainedTokenizerFast

# カスタムトークナイザーを訓練
tokenizer = Tokenizer(BPE())
# ... トークナイザーを訓練 ...
tokenizer.save("my-tokenizer.json")

# transformers用にラップ
transformers_tokenizer = PreTrainedTokenizerFast(
    tokenizer_file="my-tokenizer.json",
    unk_token="[UNK]",
    pad_token="[PAD]",
    cls_token="[CLS]",
    sep_token="[SEP]",
    mask_token="[MASK]"
)

# 任意のtransformersトークナイザーのように使用
outputs = transformers_tokenizer(
    "Hello world",
    padding=True,
    truncation=True,
    max_length=512,
    return_tensors="pt"
)

一般的なパターン

イテレーターから訓練（大規模データセット）

from datasets import load_dataset

# データセットをロード
dataset = load_dataset("wikitext", "wikitext-103-raw-v1", split="train")

# バッチイテレーターを作成
def batch_iterator(batch_size=1000):
    for i in range(0, len(dataset), batch_size):
        yield dataset[i:i + batch_size]["text"]

# トークナイザーを訓練
tokenizer.train_from_iterator(
    batch_iterator(),
    trainer=trainer,
    length=len(dataset)  # プログレスバー用
)

パフォーマンス: 1GBを約10～20分で処理

切り詰めとパディングを有効化

# 切り詰めを有効化
tokenizer.enable_truncation(max_length=512)

# パディングを有効化
tokenizer.enable_padding(
    pad_id=tokenizer.token_to_id("[PAD]"),
    pad_token="[PAD]",
    length=512  # 固定長、またはバッチ最大値の場合はNone
)

# 両方でエンコード
output = tokenizer.encode("This is a long sentence that will be truncated...")
print(len(output.ids))  # 512

マルチプロセッシング

from tokenizers import Tokenizer
from multiprocessing import Pool

# トークナイザーをロード
tokenizer = Tokenizer.from_file("tokenizer.json")

def encode_batch(texts):
    return tokenizer.encode_batch(texts)

# 大規模コーパスを並列に処理
with Pool(8) as pool:
    # コーパスをチャンクに分割
    chunk_size = 1000
    chunks = [corpus[i:i+chunk_size] for i in range(0, len(corpus), chunk_size)]

    # 並列でエンコード
    results = pool.map(encode_batch, chunks)

スピードアップ: 8コアで5～8倍

パフォーマンスベンチマーク

訓練速度

コーパスサイズ	BPE（30k語彙）	WordPiece（30k）	Unigram（8k）
10 MB	15秒	18秒	25秒
100 MB	1.5分	2分	4分
1 GB	15分	20分	40分

ハードウェア: 16コアCPU、英語Wikipediaでテスト

トークン化速度

実装	1GBコーパス	スループット
純粋なPython	約20分	約50 MB/分
HF Tokenizers	約15秒	約4 GB/分
スピードアップ	80倍	80倍

テスト: 英語テキスト、平均文長20語

メモリ使用量

タスク	メモリ
トークナイザーをロード	約10MB
BPEを訓練（30k語彙）	約200MB
100万文をエンコード	約500MB

サポートされるモデル

from_pretrained()経由で利用可能な事前訓練済みトークナイザー：

BERTファミリー:

• bert-base-uncased, bert-large-cased
• distilbert-base-uncased
• roberta-base, roberta-large

GPTファミリー:

• gpt2, gpt2-medium, gpt2-large
• distilgpt2

T5ファミリー:

• t5-small, t5-base, t5-large
• google/flan-t5-xxl

その他:

• facebook/bart-base, facebook/mbart-large-cc25
• albert-base-v2, albert-xlarge-v2
• xlm-roberta-base, xlm-roberta-large

すべてを閲覧: https://huggingface.co/models?library=tokenizers

参考文献

• 訓練ガイド - カスタムトークナイザーを訓練、トレーナーを設定、大規模データセットを処理
• アルゴリズム深掘り - BPE、WordPiece、Unigramを詳細に説明
• パイプラインコンポーネント - ノーマライザー、前トークナイザー、後処理、デコーダー
• Transformers統合 - AutoTokenizer、PreTrainedTokenizerFast、特殊トークン

リソース

• ドキュメント: https://huggingface.co/docs/tokenizers
• GitHub: https://github.com/huggingface/tokenizers ⭐ 9,000+
• バージョン: 0.20.0+
• コース: https://huggingface.co/learn/nlp-course/chapter6/1
• 論文: BPE（Sennrich et al., 2016）、WordPiece（Schuster & Nakajima, 2012）