ホーム » HuggingFace Tokenizers

HuggingFace Tokenizers」カテゴリーアーカイブ

HuggingFace Tokenizers 0.10 : コンポーネント (python)

HuggingFace Tokenizers 0.10 : コンポーネント (python) (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 06/05/2021 (Python v0.10.2)

* 本ページは、HuggingFace Tokenizers の以下のドキュメントを翻訳した上で適宜、補足説明したものです:

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

無料 Web セミナー開催中 クラスキャット主催 人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマに WEB セミナーを定期的に開催しています。
スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • ウェビナー運用には弊社製品「ClassCat® Webinar」を利用しています。
クラスキャットは人工知能・テレワークに関する各種サービスを提供しております :

人工知能研究開発支援 人工知能研修サービス テレワーク & オンライン授業を支援
PoC(概念実証)を失敗させないための支援 (本支援はセミナーに参加しアンケートに回答した方を対象としています。)

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com  ;  WebSite: https://www.classcat.com/  ;  Facebook

 

HuggingFace Tokenizers : コンポーネント (python)

トークナイザーを構築するとき、その動作をカスタマイズするためにこのトークナイザーに様々なタイプのコンポーネントをアタッチできます。このページは殆どの提供されるコンポーネントをリストアップします。

 

Normalizers

Normalizer は入力文字列を特定のユースケースに適するものとしてそれを正規化するための前処理を担当します。正規化の幾つかの一般的な例は Unicode 正規化アルゴリズム (NFD, NFKD, NFC & NFKC)、小文字化 etc… です。トークナイザーの特異性は正規化中にアラインメントを追跡することです。これは生成されたトークンを入力テキストにマップし戻すことを可能にするために必須です。

正規化はオプションです。

名前 説明
NFD NFD unicode 正規化
NFKD NFKD unicode 正規化
NFC NFC unicode 正規化
NKFC NKFC unicode 正規化
Lowercase 総ての大文字を小文字に置き換える 入力: HELLO ὈΔΥΣΣΕΎΣ
出力: hello ὀδυσσεύς
Strip 入力の指定されたサイド (左、右 or 両者) の総ての空白文字を除去します 入力: ” hi “
出力: “hi”
StripAccents ユニコードの総てのアクセント記号を除去します (一貫性のために NFD とともに利用されます) 入力: é
出力: e
Replace カスタム文字列 or regexp を置き換えてそれを与えれた内容で変更します Replace(“a”, “e”) はこのように動作します :
入力: “banana” 出力: “benene”
BertNormalizer オリジナル BERT で使用された Normalizer の実装を提供します。設定可能なオプションは :

  • clean_text
  • handle_chinese_chars
  • strip_accents
  • lowercase
Sequence 複数の normalizer を構成します、これは提供された順序で実行されます Sequence([NFKC(), Lowercase()])

 

事前トークナイザー

PreTokenizer はルールのセットに従って入力を分割する処理をします。この前処理は基礎的なモデルが複数の「分割」に渡りトークンを構築しないことを確実にさせます。例えばトークン内に空白を持つことを望まない場合、これらの空白上で分割する PreTokenizer を持つことができます。

Sequence を使用して複数の PreTokenizer を容易に一緒に組み合わせることができます (下参照)。PreTokenizer はまた丁度 Normalizer が行なうように、文字列を変更することを許容されています。これは正規化の前に分割することが必要な幾つかの複雑なアルゴリズム (e.g. ByteLevel) を可能にするために必要です。

名前 説明
ByteLevel 総てのバイトを可視な文字のセットに再マッピングしながら空白上で分割します。このテクニックは OpenAI により GPT-2 で導入されて幾つかの多かれ少なかれ良い特性を持ちます :

  • それはバイト上にマップしますので、130,000+ ユニコード文字とは対照的に、これを使用するトークナイザーは初期アルファベットとして 256 文字 (バイトが持てる値の数) を必要とするだけです。
  • 前のポイントの結果は、これを使用して未知のトークンを持つ必要がまったくないことです、何故ならば 256 トークンで任意のものを表せるからです (Youhou!! 🎉🎉)
  • 非アスキー文字については、それは完全に可読ではなくなりますが、それでもそれは動作します!
入力: “Hello my friend, how are you?”
出力: “Hello”, “Ġmy”, Ġfriend”, “,”, “Ġhow”, “Ġare”, “Ġyou”, “?”
Whitespace 単語境界上で分割する (次の正規表現を使用します: \w+|[^\w\s]+) 入力: “Hello there!”
出力: “Hello”, “there”, “!”
WhitespaceSplit 任意の空白文字上で分割する 入力: “Hello there!”
出力: “Hello”, “there!”
Punctuation 総ての句読点文字を分離します 入力: “Hello?”
出力: “Hello”, “?”
Metaspace 空白上で分割してそれらを特殊文字 “▁” (U+2581) で置き換えます 入力: “Hello there”
出力: “Hello”, “▁there”
CharDelimiterSplit 指定された文字上で分割します x による例:
入力: “Helloxthere”
出力: “Hello”, “there”
Digits 任意の他の文字から数字を分ける 入力: “Hello123there”
出力: `”Hello”, “123”, “there”`
Split 多目的な事前トークナイザーで、提供されたパターン上と提供された動作に従って分割します。パターンは必要であれば反対にできます。

  • pattern はカスタム文字列か regexp であるべきです。
  • behavior は次の一つであるべきです :
    • removed
    • isolated
    • merged_with_previous
    • merged_with_next
    • contiguous
  • invert はブーリアン・フラグであるべきです。
pattern = ” “, behavior = “isolated”, invert = False による例:
入力: “Hello, how are you?”
出力: `”Hello,”, ” “, “how”, ” “, “are”, ” “, “you?”
Sequence 指定された順序で実行される複数の PreTokenizer を組合せます Sequence([Punctuation(), WhitespaceSplit()])

 

モデル

モデルは実際にトークン化するために使用される中心的なアルゴリズムです、そして従って、それらはトークナイザーの唯一の必須ののコンポーネントです。

名前 説明
WordLevel これは「古典的な」トークン化アルゴリズムです。それはどのような創造 (= fancy) もなく単語を ID に単純にマップさせます。これは利用し理解するために実際に単純であるという優位点を持ちますが、良い被覆率 (= coverage) のためには非常に大規模な語彙を必要とします。
このモデルの利用は PreTokenizer の利用を必要とします。このモデルによりどのような選択も直接なされません、それは単純に入力トークンを ID にマップします。
BPE 最もポピュラーなサブワード・トークン化アルゴリズムの一つです。Byte-Pair-Encoding は文字から始めて、最も頻繁に一緒に見られるそれらをマージしながら新しいトークンを作成することにより動作します。そしてそれは語彙で見る最も頻度の高いペアから新しいトークンを構築するように反復的に動作します。
BPE は複数のサブワード・トークンを使用してそれが決して見ていない単語を構築することができるため、”unk” (unknown) トークンのより少ない機会とともに、より小さい語彙を必要とするだけです。
WordPiece これは BERT のようなモデルで Google により主として使用された、BPE に非常に類似したサブワード・トークン化アルゴリズムです。それは greedy アルゴリズムを使用します、これは最初に長い単語を構築しようとし、単語全体が語彙に存在しないとき複数のトークンに分割します。これは文字から始めて、できる限り大きいトークンを構築する、BPE とは異なります。
それは単語の一部である (i.e. 単語を開始しない) トークンを識別するために有名な ## prefix を使用します。
Unigram Unigram はまたサブワード・トークン化アルゴリズムで、指定されたセンテンスのための確率を最大化するようにサブワード・トークンの最善のセットを特定しようとすることで動作します。これは逐次的に適用されるルールのセットに基づく決定論的ではない方法で BPE とは異なります。代わりに Unigram は最も確率の高いものを選択しながら、トークン化の複数の方法を計算することができます。

 

PostProcessor

パイプライン全体の後、時にトークン化された文字列をモデルに供給する前に “[CLS] My horse is amazing [SEP]” のように幾つかの特殊なトークンを挿入することを望みます。PostProcessor は丁度それを行なうコンポーネントです。

名前 説明
TemplateProcessing 後処理を容易にテンプレート化し、特殊トークンを追加し、そして各シークエンス/特殊トークンのために type_id を指定させましょう。テンプレートは単一シークエンスとシークエンスのペアを表す 2 つの文字列、そして使用する特殊トークンのセットが与えられます。 これらの値を持つテンプレートを指定するときの例 :
single: “[CLS] $A [SEP]”
pair: “[CLS] $A [SEP] $B [SEP]”
特殊トークン:

  • “[CLS]”
  • “[SEP]”

入力: (“I like this”, “but not this”)
出力: “[CLS] I like this [SEP] but not this [SEP]”

 

デコーダ

デコーダはトークナイザーで使用された ID から、どのようにテキストの可読なピースに戻すかを知っています。幾つかの Normalizer と PreTokenizer は例えば戻されるべき特殊文字や識別子を使用します。

名前 説明
ByteLevel ByteLevel PreTokenizer を元に戻します。PreTokenizer は各バイトを表すために可視な Unicode 文字のセットを使用し、バイトレベルでエンコードしますので、このプロセスを反対にして可読なものを再度得るためにデコーダを必要とします。
Metaspace Metaspace PreTokenizer を元に戻します。この PreTokenizer は空白を識別するために特殊な識別子 ▁ を使用しますので、このデコーダはこれらをデコードするのに役立ちます。
WordPiece WordPiece モデルを元に戻します。このモデルはサブワードを続けるために特殊な識別子 ## を使用しますので、このデコーダはこれらをデコードするのに役立ちます。

 

以上



HuggingFace Tokenizers 0.10 : メモリから訓練 (python)

HuggingFace Tokenizers 0.10 : メモリから訓練 (python) (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 06/01/2021 (Python v0.10.2)

* 本ページは、HuggingFace Tokenizers の以下のドキュメントを翻訳した上で適宜、補足説明したものです:

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

無料 Web セミナー開催中 クラスキャット主催 人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマに WEB セミナーを定期的に開催しています。
スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • ウェビナー運用には弊社製品「ClassCat® Webinar」を利用しています。
クラスキャットは人工知能・テレワークに関する各種サービスを提供しております :

人工知能研究開発支援 人工知能研修サービス テレワーク & オンライン授業を支援
PoC(概念実証)を失敗させないための支援 (本支援はセミナーに参加しアンケートに回答した方を対象としています。)

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com  ;  WebSite: https://www.classcat.com/  ;  Facebook

 

HuggingFace Tokenizers : メモリから訓練 (python)

クイックツアー では、テキストファイルを使用してトークナイザーをどのように構築して訓練するかを見ましたが、実際には任意の Python Iterator を利用できます。このセクションではトークナイザーを訓練する幾つかの異なる方法を見ます。

下でリストされる総てのサンプルについて、次のように構築される、同じ TokenizerTrainer を使用します :

from tokenizers import Tokenizer, models, normalizers, pre_tokenizers, decoders, trainers

tokenizer = Tokenizer(models.Unigram())
tokenizer.normalizer = normalizers.NFKC()
tokenizer.pre_tokenizer = pre_tokenizers.ByteLevel()
tokenizer.decoders = decoders.ByteLevel()

trainer = trainers.UnigramTrainer(
    vocab_size=20000,
    initial_alphabet=pre_tokenizers.ByteLevel.alphabet(),
    special_tokens=["<PAD>", "<BOS>", "<EOS>"],
)

このトークナイザーは Unigram モデルに基づきます。それは NFKC Unicode 正規化メソッドを使用して入力を正規化する処理を行ない、そして対応するデコーダとともに ByteLevel 事前トークナイザーを使用します。

ここで使用されるコンポーネントのより多くの情報については、ここ を確認できます。

 

最も基本的な方法

既に多分推測したように、トークナイザーを訓練する最も簡単な方法はリストを使用することによります :

# First few lines of the "Zen of Python" https://www.python.org/dev/peps/pep-0020/
data = [
    "Beautiful is better than ugly."
    "Explicit is better than implicit."
    "Simple is better than complex."
    "Complex is better than complicated."
    "Flat is better than nested."
    "Sparse is better than dense."
    "Readability counts."
]
tokenizer.train_from_iterator(data, trainer=trainer)

Easy, right? ここで iterator として動作する任意のものを利用できます、それはリスト、タプル、あるいは np.Array です。それが文字列を提供する限りどんなものでも動作します。

 

データセット・ライブラリを使用する

世の中に存在する多くのデータセットの一つにアクセスする素晴らしい方法は データセット・ライブラリを利用することです。その詳細については、こちらの公式ドキュメント を確認するべきです。

データセットをロードすることから始めましょう :

import datasets

dataset = datasets.load_dataset(
    "wikitext", "wikitext-103-raw-v1", split="train+test+validation"
)

次のステップはこのデータセットに渡り iterator を構築することです。これを行なう最も簡単な方法は多分 generator を使用することです :

def batch_iterator(batch_size=1000):
    for i in range(0, len(dataset), batch_size):
        yield dataset[i : i + batch_size]["text"]

ここで分かるように、より改良された効率性のためにそれらに渡り一つ一つ iterate する代わりに、訓練するために使用されるサンプルのバッチを実際には提供できます。それにより、ファイルから直接訓練する間に得られたものと非常に類似したパフォーマンスを期待できます。

iterator の準備ができれば、訓練を始める必要があるだけです。進捗バーの外観を改良するため、データセットの全長を指定できます :

tokenizer.train_from_iterator(batch_iterator(), trainer=trainer, length=len(dataset))

And that’s it!

 

gzip ファイルを使用する

Python 内の gzip ファイルは iterator として使用できますので、そのようなファイル上で訓練することは非常に簡単です。

import gzip

with gzip.open("data/my-file.0.gz", "rt") as f:
    tokenizer.train_from_iterator(f, trainer=trainer)

今は複数の gzip ファイルから訓練することを望んだ場合、それはそれほど難しくはありません :

files = ["data/my-file.0.gz", "data/my-file.1.gz", "data/my-file.2.gz"]

def gzip_iterator():
    for path in files:
        with gzip.open(path, "rt") as f:
            for line in f:
                yield line

tokenizer.train_from_iterator(gzip_iterator(), trainer=trainer)

And voilà!

 

以上



HuggingFace Tokenizers 0.10 : トークン化パイプライン (python)

HuggingFace Tokenizers 0.10 : トークン化パイプライン (python) (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 05/30/2021 (Python v0.10.2)

* 本ページは、HuggingFace Tokenizers の以下のドキュメントを翻訳した上で適宜、補足説明したものです:

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

無料 Web セミナー開催中 クラスキャット主催 人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマに WEB セミナーを定期的に開催しています。
スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • ウェビナー運用には弊社製品「ClassCat® Webinar」を利用しています。
クラスキャットは人工知能・テレワークに関する各種サービスを提供しております :

人工知能研究開発支援 人工知能研修サービス テレワーク & オンライン授業を支援
PoC(概念実証)を失敗させないための支援 (本支援はセミナーに参加しアンケートに回答した方を対象としています。)

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com  ;  WebSite: https://www.classcat.com/  ;  Facebook

 

HuggingFace Tokenizers : トークン化パイプライン (python)

encode()encode_batch() を呼び出すとき、入力テキストは次のパイプラインを通過します :

これらのステップの各々の間に加えて、幾つかのトークン id をデコードすることを望むときに何が起きるか、そして
Tokenizer ライブラリが貴方のニーズに応じてそれらのステップの各々をどのようにカスタマイズするかを見ます。もし貴方がそれらのステップに既に馴染みがあり幾つかのコードを見ることにより学習することを望むのであれば、BERT from scratch example にジャンプしてください。

Tokenizer を必要とする例については、Quicktour で訓練されたトークナイザーを利用します、これは次でロードできます :

from tokenizers import Tokenizer

tokenizer = Tokenizer.from_file("data/tokenizer-wiki.json")

 

正規化

正規化は、簡単に言えば、raw 文字列をランダムさを減らすあるいは「クリーン」にするために適用する演算のセットです。一般的な演算は空白を strip し、アクセント付き文字を除去したり、あるいは総てのテキストを小文字化することを含みます。Unicode 正規化 に馴染みがある場合、それは殆どのトークナイザーで適用される非常に一般的な正規化演算でもあります。

各正規化演算は Tokenizers ライブラリでは Normalizer により表され、そして Sequence を使用して幾つかのそれらを連結できます。例としてここに NFD Unicode 正規化を適用してアクセントを除去する normalizer があります :

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

normalizer = normalizers.Sequence([NFD(), StripAccents()])

それを任意の文字列に適用することにより normalizer を手動でテストすることができます。

normalizer.normalize_str("Héllò hôw are ü?")
# "Hello how are u?"

Tokenizer を構築するとき、対応する属性を変更するだけで normalizer をカスタマイズできます。

tokenizer.normalizer = normalizer

もちろん、トークナイザーが正規化を適用する方法を変更する場合、多分それを後でスクラッチから再訓練するべきです。

 

事前トークン化

事前トークン化はテキストを (トークンが訓練の最後になるであろう) 上界を与える小さなオブジェクトに分割する高位です。これを考える良い方法は事前トークン化はテキストを「単語」に分割して、最終的なトークンはそれらの単語の一部となります。

入力を事前トークン化する簡単な方法は空白と句読点上で分割することです、これは Whitespace pre-tokenizer により成されます :

from tokenizers.pre_tokenizers import Whitespace

pre_tokenizer = Whitespace()
pre_tokenizer.pre_tokenize_str("Hello! How are you? I'm fine, thank you.")
# [("Hello", (0, 5)), ("!", (5, 6)), ("How", (7, 10)), ("are", (11, 14)), ("you", (15, 18)),
#  ("?", (18, 19)), ("I", (20, 21)), ("'", (21, 22)), ('m', (22, 23)), ("fine", (24, 28)),
#  (",", (28, 29)), ("thank", (30, 35)), ("you", (36, 39)), (".", (39, 40))]

出力はタプルのリストで、各タプルは一つの単語と元のセンテンス内のその範囲を含みます (これは Encoding の最終的な offsets を決定するために使用されます)。句読点上の分割はこのサンプルの “I’m” のような縮約を分割することに注意してください。

任意の PreTokenizer を一緒に組み合わせることができます。例えば、ここに空白、句読点と数字上で分割し、個々の数字で数字を区切る事前トークナイザーがあります。

from tokenizers import pre_tokenizers
from tokenizers.pre_tokenizers import Digits

pre_tokenizer = pre_tokenizers.Sequence([Whitespace(), Digits(individual_digits=True)])
pre_tokenizer.pre_tokenize_str("Call 911!")
# [("Call", (0, 4)), ("9", (5, 6)), ("1", (6, 7)), ("1", (7, 8)), ("!", (8, 9))]

Quicktour で見たように、対応する属性を変更することだけで Tokenizer の事前トークナイザーをカスタマイズできます。

tokenizer.pre_tokenizer = pre_tokenizer

もちろん、事前トークナイザーの方法を変更する場合、多分トークナイザーを後でスクラッチから再訓練するべきです。

 

モデル

ひとたび入力テキストが正規化されて事前トークン化されれば、Tokenizer は事前トークンにモデルを適用します。これはコーパス上の訓練を必要とするパイプラインの一部です (あるいは事前訓練されたトークナイザーを利用している場合はそれは訓練されています)。

モデルの役割はそれが学習したルールを使用して「単語」をトークンに分割することです、それはまたそれらのトークンをモデルの語彙の対応する ID にマップする責任も負います。

モデルは Tokenizer を初期化するときに一緒に渡されますので、この部分をどのようにカスタマイズするかを貴方は既に知っています。現在、 Tokenizers ライブラリは以下をサポートします :

各モデルとその動作の詳細については、ここ を確認できます。

 

後処理

後処理は潜在的な特殊トークンを追加するような、任意の追加の変換を (それが返される前に) Encoding に遂行するためのトークン化パイプラインの最後のステップです。

クイックツアーで見たように、Tokenizer の後処理を対応する属性を設定することでカスタマイズできます。例えば、入力を BERT モデルに適したものにするためにどのように後処理できるかがここにあります :

from tokenizers.processors import TemplateProcessing

tokenizer.post_processor = TemplateProcessing(
    single="[CLS] $A [SEP]",
    pair="[CLS] $A [SEP] $B:1 [SEP]:1",
    special_tokens=[("[CLS]", 1), ("[SEP]", 2)],
)

事前トークナイザーや normalizer と対照的に、後処理を変更した後でトークナイザーを再訓練する必要はないことに注意してください。

 

まとめ: スクラッチから BERT トークナイザー

BERT トークナイザーを構築するためにこれら総てのピースをまとめましょう。最初に、BERT は WordPiece に依拠しますので、このモデルで新しい Tokenizer をインスタンス化します :

from tokenizers import Tokenizer
from tokenizers.models import WordPiece

bert_tokenizer = Tokenizer(WordPiece(unk_token="[UNK]"))

そして BERT はアクセントを除去して小文字化することによりテキストを前処理することを知っています。unicode normalizer も使用します :

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

bert_tokenizer.normalizer = normalizers.Sequence([NFD(), Lowercase(), StripAccents()])

事前トークナイザーは空白と句読点上で分割するだけです :

from tokenizers.pre_tokenizers import Whitespace

bert_tokenizer.pre_tokenizer = Whitespace()

そして後処理は前のセクションで見たテンプレートを使用します :

from tokenizers.processors import TemplateProcessing

bert_tokenizer.post_processor = TemplateProcessing(
    single="[CLS] $A [SEP]",
    pair="[CLS] $A [SEP] $B:1 [SEP]:1",
    special_tokens=[
        ("[CLS]", 1),
        ("[SEP]", 2),
    ],
)

このトークナイザーを使用してその上でクイックツアーでのように wikitext 上で訓練できます :

from tokenizers.trainers import WordPieceTrainer

trainer = WordPieceTrainer(
    vocab_size=30522, special_tokens=["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]"]
)
files = [f"data/wikitext-103-raw/wiki.{split}.raw" for split in ["test", "train", "valid"]]
bert_tokenizer.train(files, trainer)

bert_tokenizer.save("data/bert-wiki.json")

 

デコード

入力テキストのエンコードに加えて、トークナイザーはまたデコードのための API も持ちます、これはモデルにより生成された ID をテキストに戻します。これはメソッド decode() (一つの予測されたテキストのため) と decode_batch() (予測のバッチのため) により成されます。

デコーダは最初に (トークナイザーの語彙を使用して) ID をトークンに変換し戻し、総ての特殊トークンを除去してから、それらのトークンを空白で結合します :

output = tokenizer.encode("Hello, y'all! How are you 😁 ?")
print(output.ids)
# [1, 27253, 16, 93, 11, 5097, 5, 7961, 5112, 6218, 0, 35, 2]

tokenizer.decode([1, 27253, 16, 93, 11, 5097, 5, 7961, 5112, 6218, 0, 35, 2])
# "Hello , y ' all ! How are you ?"

(WordPiece の “##” のような) 特定の「単語」のサブトークンを表すために特殊文字を追加したモデルを使用した場合、それらを正しく扱うためにデコーダをカスタマイズする必要があります。例えば前の bert_tokenizer を取る場合、デフォルトのデコーダは次を与えます :

output = bert_tokenizer.encode("Welcome to the 🤗 Tokenizers library.")
print(output.tokens)
# ["[CLS]", "welcome", "to", "the", "[UNK]", "tok", "##eni", "##zer", "##s", "library", ".", "[SEP]"]

bert_tokenizer.decode(output.ids)
# "welcome to the tok ##eni ##zer ##s library ."

しかしそれを適切なデコーダに替えることにより、次を得ます :

from tokenizers import decoders

bert_tokenizer.decoder = decoders.WordPiece()
bert_tokenizer.decode(output.ids)
# "welcome to the tokenizers library."
 

以上



HuggingFace Tokenizers 0.10 : Quicktour (python)

HuggingFace Tokenizers 0.10 : Quicktour (python) (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 05/27/2021 (Python v0.10.2)

* 本ページは、HuggingFace Tokenizers の以下のドキュメントを翻訳した上で適宜、補足説明したものです:

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

無料 Web セミナー開催中 クラスキャット主催 人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマに WEB セミナーを定期的に開催しています。
スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • ウェビナー運用には弊社製品「ClassCat® Webinar」を利用しています。
クラスキャットは人工知能・テレワークに関する各種サービスを提供しております :

人工知能研究開発支援 人工知能研修サービス テレワーク & オンライン授業を支援
PoC(概念実証)を失敗させないための支援 (本支援はセミナーに参加しアンケートに回答した方を対象としています。)

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com  ;  WebSite: https://www.classcat.com/  ;  Facebook

 

HuggingFace Tokenizers : Quicktour (python)

Tokenizers ライブラリの機能を素早く見てみましょう。このライブラリは使いやすく超高速な今日最も利用されているトークナイザーの実装を提供します。

それは事前訓練されたトークナイザーをインスタンス化するために利用できますが、スクラッチから構築することからクイックツアーを始めてそれをどのように訓練するかを見ます。

 

スクラッチからトークナイザーを構築する

Tokenizers ライブラリがどれほど速いかを示すため、新しいトークナイザーを wikitext-103 (テキストの 516M) の上で数秒間で訓練しましょう。まず最初に、このデータセットをダウンロードして次で unzip する必要があります :

wget https://s3.amazonaws.com/research.metamind.io/wikitext/wikitext-103-raw-v1.zip
unzip wikitext-103-raw-v1.zip

 

トークナイザーの訓練

このツアーでは、Byte-Pair エンコーディング (BPE) トークナイザーを構築して訓練します。様々なタイプのトークナイザーについてのより多くの情報については、 Transformers ドキュメントのこの ガイド を確認してください。ここでは、トークナイザーの訓練は次によりマージルールを学習することを意味します :

  • 訓練コーパスに存在する総ての文字からトークンとして始めます。
  • トークの最も一般的なペアを識別してそれを一つのトークンにマージします。
  • 語彙 (e.g., トークンの数) が望んだサイズに到達するまで繰り返します。

ライブラリのメイン API はクラス Tokenizer で、ここに BPE モデルでそれをどのようにインスタンス化するかがあります :

from tokenizers import Tokenizer
from tokenizers.models import BPE

tokenizer = Tokenizer(BPE(unk_token="[UNK]"))

トークナイザーを wikitext ファイル上で訓練するには、トレーナー、この場合は BpeTrainer をインスタンス化する必要があります。

from tokenizers.trainers import BpeTrainer

trainer = BpeTrainer(special_tokens=["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]"])

vocab_size や min_frequency のような訓練引数を設定できますが (ここでは 30,000 と 0 のそれらのデフォルト値のままです)、最も重要な部分は後で使う予定の special_tokens を与えることです (それらは訓練の間には全く使われません)、その結果それらは語彙に挿入されます。

Note: special トークンリストを書く順序は重要です : ここでは “[UNK]” は ID 0 を得て、”[CLS]” は ID 1 を得ます、等々。

トークナイザーを直ちに訓練できるでしょうが、それは最適ではありません。入力を単語に分割する事前トークナイザーなしでは、幾つかの単語にオーバーラップするトークンを得るかもしれません : 例えば “it is” トークンを得る可能性があります、何故ならばそれら 2 つの単語はしばしば隣り合って出現するからです。事前トークナイザーの使用は事前トークナイザーにより返される単語よりも大きいトークンがないことを確実にします。ここでは subword BPE tokenizer を訓練することを望みます、そしてホワイトスペースで分割することで可能な最も容易な事前トークナイザーを使用します。

from tokenizers.pre_tokenizers import Whitespace

tokenizer.pre_tokenizer = Whitespace()

今は、使用したい任意のファイルのリストで train() メソッドを単に呼び出すことができます :

files = [f"data/wikitext-103-raw/wiki.{split}.raw" for split in ["test", "train", "valid"]]
tokenizer.train(files, trainer)

これは full wikitext データセット上でトークナイザーを訓練するために数秒しかかからないはずです!総ての configuration と語彙を含む一つのファイルにトークナイザーをセーブするには、単に save() メソッドを使います :

tokenizer.save("data/tokenizer-wiki.json")

そしてそのファイルから from_file() クラスメソッドでトークナイザーを再ロードできます :

tokenizer = Tokenizer.from_file("data/tokenizer-wiki.json")

 

トークナイザーを使用する

トークナイザーを訓練した今、で望む任意のテキスト上で enode() メソッドそれを使用できます :

output = tokenizer.encode("Hello, y'all! How are you 😁 ?")

これはテキスト上でトークナイザーの完全なパイプラインを適用し、エンコーディング・オブジェクトを返します。このパイプラインについて更に学習し、その一部をどのように適用 (or カスタマイズ) するかについては、このページ を調べてください。

そしてこのエンコーディング・オブジェクトは深層学習モデル (or その他) のために必要な総ての属性を持ちます。tokens 属性はテキストのセグメンテーションをトークンで含みます :

print(output.tokens)
# ["Hello", ",", "y", "'", "all", "!", "How", "are", "you", "[UNK]", "?"]

同様に、ids 属性はそれらのトークンのトークナイザーの語彙内の各々のインデックスを含みます :

print(output.ids)
# [27253, 16, 93, 11, 5097, 5, 7961, 5112, 6218, 0, 35]

Tokenizers ライブラリの重要な特徴はそれが完全なアライメント追跡を備えていることです、つまり与えられたトークンに対応する元のセンテンスの一部を常に得ることができます。それらはエンコーディング・オブジェクトの offsets 属性にストアされています。例えば、リストのインデックス 9 のトークンである、出現する “[UNK]” トークンを引き起こしたものを見つけることを望むとすれば、インデックスのオフセットを単に求めることができます :

print(output.offsets[9])
# (26, 27)

そしてそれらは元のセンテンスで絵文字に対応するインデックスです :

sentence = "Hello, y'all! How are you 😁 ?"
sentence[26:27]
# "😁"

 

後処理

トークナイザーが “[CLS]” や “[SEP]” のような特殊トークンを自動的に追加することを望むかもしれません。これを行なうために、post-processor を使用します。TemplateProcessing が最も一般的に使用されます、単一センテンスとセンテンスのペアの処理のために特殊トークンとそれらの ID と一緒に、単にテンプレートを指定しなければなりません。

トークナイザーを構築したとき、特殊トークンのリストの位置 1 と 2 に “[CLS]” と “[SEP]” を設定したので、これはそれらの ID であるはずです。再確認するため、token_to_id() メソッドを使用できます :

tokenizer.token_to_id("[SEP]")
# 2

ここに伝統的な BERT 入力を与える後処理をどのように設定できるかがあります :

from tokenizers.processors import TemplateProcessing

tokenizer.post_processor = TemplateProcessing(
    single="[CLS] $A [SEP]",
    pair="[CLS] $A [SEP] $B:1 [SEP]:1",
    special_tokens=[
        ("[CLS]", tokenizer.token_to_id("[CLS]")),
        ("[SEP]", tokenizer.token_to_id("[SEP]")),
    ],
)

コードのこのスニペットを詳しく調べましょう。最初に単一センテンスのためにテンプレートを指定します : これはフォーム “[CLS] $A [SEP]” を持つべきです、ここで $A はセンテンスを表すします。

そして、センテンスペアのためのテンプレートを指定します、これはフォーム “[CLS] $A [SEP] $B [SEP]” を持つべきです、ここで $A は最初のセンテンスそして $B は 2 番目のものを表します。テンプレートで追加された :1 は入力の各パートのために望むタイプ ID を表します : それは総てについて 0 がデフォルトで (それが $A:0 をもたない理由です) そしてここでは 2 番目のセンテンスのトークンと最後の “[SEP]” トークンのためにそれを 1 に設定します。

最後に、使用した特殊トークンとそれらの ID をトークナイザーの語彙で指定します。

これが正しく動作したことを確認するため、前と同じセンテンスをエンコードしてみましょう :

output = tokenizer.encode("Hello, y'all! How are you 😁 ?")
print(output.tokens)
# ["[CLS]", "Hello", ",", "y", "'", "all", "!", "How", "are", "you", "[UNK]", "?", "[SEP]"]

センテンスのペア上の結果を確認するには、2 つのセンテンスを encode() に渡すだけです :

output = tokenizer.encode("Hello, y'all!", "How are you 😁 ?")
print(output.tokens)
# ["[CLS]", "Hello", ",", "y", "'", "all", "!", "[SEP]", "How", "are", "you", "[UNK]", "?", "[SEP]"]

それから各トークンに属する type ID が正しいかを次で確認できます :

print(output.type_ids)
# [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1]

save() でトークナイザーをセーブする場合、post-processor も一緒にセーブされます。

 

バッチで複数センテンスをエンコードする

Tokenizers ライブラリのフルスピードを得るには、encode_batch() メソッドを使用してバッチによりテキストを処理することが最善です :

output = tokenizer.encode_batch(["Hello, y'all!", "How are you 😁 ?"])

そして出力は前にみたもののような Encoding オブジェクトのリストです。メモリに収まる限りは、必要なだけの多くのテキストを処理できます。

センテンスペアのバッチを処理するには、2 つのリストを encode_batch() メソッドに渡します : センテンス A のリストとセンテンス B のリストです :

output = tokenizer.encode_batch(
    [["Hello, y'all!", "How are you 😁 ?"], ["Hello to you too!", "I'm fine, thank you!"]]
)

複数センテンスをエンコードするとき、pad_token とその ID により (前のように token_to_id() によりパディングトークンのための id を再確認できます)、enable_padding() を使用して出力を存在する最長センテンスに自動的にパッドできます :

tokenizer.enable_padding(pad_id=3, pad_token="[PAD]")

総てのサンプルをその特定の数にパッドすることを望む場合、パディングの方向や指定された長さを設定できます (ここでは最長テキストのサイズへのパッドを設定しないままにします)。

output = tokenizer.encode_batch(["Hello, y'all!", "How are you 😁 ?"])
print(output[1].tokens)
# ["[CLS]", "How", "are", "you", "[UNK]", "?", "[SEP]", "[PAD]"]

この場合、トークナイザーによりせいせいされたアテンションマスクはパディングを考慮に入れます :

print(output[1].attention_mask)
# [1, 1, 1, 1, 1, 1, 1, 0]

 

事前訓練されたトークナイザーを使用する

語彙ファイルを持つ限りは事前訓練されたトークナイザーもまた直接利用できます。例えば、ここに古典的な事前訓練された BERT トークナイザーをどのように得るかがあります :

from tokenizers import BertWordPieceTokenizer

tokenizer = BertWordPieceTokenizer("bert-base-uncased-vocab.txt", lowercase=True)

一方でファイル bert-base-uncased-vocab.txt は次でダウンロードしておきます :

wget https://s3.amazonaws.com/models.huggingface.co/bert/bert-base-uncased-vocab.txt
 

以上



HuggingFace Tokenizers 0.10 : 概要 | Python バインディング概要

HuggingFace Tokenizers 0.10 : 概要 | Python バインディング概要 (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 05/20/2021 (Python v0.10.2)

* 本ページは、HuggingFace Tokenizers の以下のドキュメントを翻訳した上で適宜、補足説明したものです:

* サンプルコードの動作確認はしておりますが、必要な場合には適宜、追加改変しています。
* ご自由にリンクを張って頂いてかまいませんが、sales-info@classcat.com までご一報いただけると嬉しいです。

 

無料 Web セミナー開催中 クラスキャット主催 人工知能 & ビジネス Web セミナー

人工知能とビジネスをテーマに WEB セミナーを定期的に開催しています。
スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • ウェビナー運用には弊社製品「ClassCat® Webinar」を利用しています。
クラスキャットは人工知能・テレワークに関する各種サービスを提供しております :

人工知能研究開発支援 人工知能研修サービス テレワーク & オンライン授業を支援
PoC(概念実証)を失敗させないための支援 (本支援はセミナーに参加しアンケートに回答した方を対象としています。)

お問合せ : 本件に関するお問い合わせ先は下記までお願いいたします。

株式会社クラスキャット セールス・マーケティング本部 セールス・インフォメーション
E-Mail:sales-info@classcat.com  ;  WebSite: https://www.classcat.com/  ;  Facebook

 

HuggingFace Tokenizers : 概要

パフォーマンスと多用途性に焦点を置いた、今日最も利用されているトークナイザーの実装を提供します。

 

主要な特徴

  • 今日最も利用されているトークナイザーを使用して、新しい語彙を訓練してトークン化します。
  • Rust 実装のおかげで、非常に高速です (訓練とトークン化の両者で)。サーバの CPU 上で GB のテキストをトークン化するのに 20 秒かかりません。
  • 使いやすく、また極めて多用途性もあります。
  • 研究とプロダクションのために設計されました。
  • 正規化はアラインメント追跡を装備しています。与えられたトークンに対応する元のセンテンスの一部を得ることが常に可能です。
  • 前処理の総てを行ないます : 切り捨て、パディングとモデルが必要な特殊トークンを追加します。

 

バインディング

以下の言語へのバインディングを提供します (more to come!) :

  • Rust (オリジナル実装)
  • Python (訳注 : 本ドキュメント後半で翻訳)
  • Node.js

 

Python を使用するクイック・サンプル

Byte-Pair エンコーディング, WordPiece or Unigram の間でモデルを選択してトークナイザーをインスタンス化します :

from tokenizers import Tokenizer
from tokenizers.models import BPE

tokenizer = Tokenizer(BPE())

どのように事前トークン化 (e.g., 単語に分割する) が成されるかをカスタマイズできます :

from tokenizers.pre_tokenizers import Whitespace

tokenizer.pre_tokenizer = Whitespace()

そしてファイルのセット上でのトークナイザーの訓練は 2 行のコードがかかるだけです :

from tokenizers.trainers import BpeTrainer

trainer = BpeTrainer(special_tokens=["[UNK]", "[CLS]", "[SEP]", "[PAD]", "[MASK]"])
tokenizer.train(files=["wiki.train.raw", "wiki.valid.raw", "wiki.test.raw"], trainer=trainer)

ひとたびトークナイザーが訓練されれば、任意のテキストを 1 行だけでエンコードします :

output = tokenizer.encode("Hello, y'all! How are you 😁 ?")
print(output.tokens)
# ["Hello", ",", "y", "'", "all", "!", "How", "are", "you", "[UNK]", "?"]

更に学習するために python ドキュメントpython クイックツアー を確認してください!

 

HuggingFace Tokenizers : (bindings/python) 概要

提供されているトークナイザー

殆どの一般的なケースをカバーするために幾つかの事前ビルドされたトークナイザーを提供しています。特定の vocab.json と merges.txt ファイルを使用してこれらの一つを容易にロードできます :

from tokenizers import CharBPETokenizer

# Initialize a tokenizer
vocab = "./path/to/vocab.json"
merges = "./path/to/merges.txt"
tokenizer = CharBPETokenizer(vocab, merges)

# And then encode:
encoded = tokenizer.encode("I can feel the magic, can you?")
print(encoded.ids)
print(encoded.tokens)

そしてそれらを同様に単純に訓練できます :

from tokenizers import CharBPETokenizer

# Initialize a tokenizer
tokenizer = CharBPETokenizer()

# Then train it!
tokenizer.train([ "./path/to/files/1.txt", "./path/to/files/2.txt" ])

# Now, let's use it:
encoded = tokenizer.encode("I can feel the magic, can you?")

# And finally save it somewhere
tokenizer.save("./path/to/directory/my-bpe.tokenizer.json")

 

提供されているトークナイザー

  • CharBPETokenizer: オリジナル BPE
  • ByteLevelBPETokenizer: BPE のバイトレベル・バージョン
  • SentencePieceBPETokenizer: SentencePiece で使用されるものと互換な BPE 実装
  • BertWordPieceTokenizer: WordPiece を使用した、有名な Bert トークナイザー

これらの総てが上で説明されたように利用できて訓練できます!

 

貴方自身のものを構築する

提供されるトークナイザーが十分な自由度を与えないときはいつでも、必要な様々な部分をまとめることで、貴方自身のトークナイザーを構築できます。私達がどのように 提供されるトークナイザー を実装したかを確認してそれらを貴方自身のニーズに容易に適応せることができます。

 

バイトレベル BPE を構築する

ここに総ての様々なピースをまとめて、それを単一ファイルにセーブすることによって貴方自身のバイトレベル BPE をどのように構築するかを示すサンプルがあります :

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

今は、このトークナイザーを使用したいとき、これは次のように簡単です :

from tokenizers import Tokenizer

tokenizer = Tokenizer.from_file("byte-level-bpe.tokenizer.json")

encoded = tokenizer.encode("I can feel the magic, can you?")
 

以上



AI導入支援 #2 ウェビナー

スモールスタートを可能としたAI導入支援   Vol.2
[無料 WEB セミナー] [詳細]
「画像認識 AI PoC スターターパック」の紹介
既に AI 技術を実ビジネスで活用し、成果を上げている日本企業も多く存在しており、競争優位なビジネスを展開しております。
しかしながら AI を導入したくとも PoC (概念実証) だけでも高額な費用がかかり取組めていない企業も少なくないようです。A I導入時には欠かせない PoC を手軽にしかも短期間で認知度を確認可能とするサービの紹介と共に、AI 技術の特性と具体的な導入プロセスに加え運用時のポイントについても解説いたします。
日時:2021年10月13日(水)
会場:WEBセミナー
共催:クラスキャット、日本FLOW(株)
後援:働き方改革推進コンソーシアム
参加費: 無料 (事前登録制)
人工知能開発支援
◆ クラスキャットは 人工知能研究開発支援 サービスを提供しています :
  • テクニカルコンサルティングサービス
  • 実証実験 (プロトタイプ構築)
  • アプリケーションへの実装
  • 人工知能研修サービス
◆ お問合せ先 ◆
(株)クラスキャット
セールス・インフォメーション
E-Mail:sales-info@classcat.com