HuggingFace Transformers 4.5 : 利用方法 : 多言語モデル (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 05/14/2021 (4.5.1)

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

• Using Transformers : Multi-lingual models

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

 

 

HuggingFace Transformers : 利用方法 : 多言語モデル

このライブラリで利用可能な殆どのモデルは単一言語モデルです (英語、中国語そしてドイツ語)。幾つかの多言語モデルが利用可能で単一言語モデルとは異なるメカニズムを持ちます。このページはこれらのモデルの使用方法を詳述します。

多言語を現在サポートする 2 つのモデルは BERT と XLM です。

 

XLM

XML は合計 10 の異なるチェックポイントを持ち、その一つだけが単言語です。残りの 9 モデルのチェックポイントは 2 つのカテゴリーに分けられます : 言語埋め込みを利用するチェックポイントと、そうでないものです。

 

XLM & 言語埋め込み

このセクションは以下のチェックポイントが主題です :

• xlm-mlm-ende-1024 (Masked 言語モデリング, 英独)
• xlm-mlm-enfr-1024 (Masked 言語モデリング, 英仏)
• xlm-mlm-enro-1024 (Masked 言語モデリング、英語-ルーマニア語)
• xlm-mlm-xnli15-1024 (Masked 言語モデリング、XNLI 言語)
• xlm-mlm-tlm-xnli15-1024 (Masked 言語モデリング + 翻訳、XNLI 言語)
• xlm-clm-enfr-1024 (因果言語モデリング、英仏)
• xlm-clm-ende-1024 (因果言語モデリング、英独)

これらのチェックポイントは言語埋め込みを必要とします、これは推論時に使用される言語を指定します。これらの言語埋め込みはモデルに渡される入力 id と同じ shape の tensor として表されます。これらの tensor の値は使用される言語に依存してトークナイザーからの lang2id と id2lang 属性を使用して識別可能です。

ここに xlm-clm-enfr-1024 チェックポイントを使用する例があります (因果言語モデリング、英仏) :

import torch
from transformers import XLMTokenizer, XLMWithLMHeadModel
tokenizer = XLMTokenizer.from_pretrained("xlm-clm-enfr-1024")
model = XLMWithLMHeadModel.from_pretrained("xlm-clm-enfr-1024")

このモデル/トークナイザーが処理する様々な言語、そしてこれらの言語の id は lang2id 属性を使用して可視です :

print(tokenizer.lang2id)

{'en': 0, 'fr': 1}

これらの id はモデル・パスの際に言語パラメータを渡すときに使用されるべきです。入力を定義しましょう :

input_ids = torch.tensor([tokenizer.encode("Wikipedia was used to")]) # batch size of 1

今は前に定義された言語 id を使用して言語埋め込みを定義するべきです。input_ids と同じサイズの、適切な言語 id で満たされた tensor を作成することを望みます。英語については、id は 0 です :

language_id = tokenizer.lang2id['en']  # 0
langs = torch.tensor([language_id] * input_ids.shape[1])  # torch.tensor([0, 0, 0, ..., 0])
# We reshape it to be of size (batch_size, sequence_length)
langs = langs.view(1, -1) # is now of shape [1, sequence_length] (we have a batch size of 1)

そしてそれら総てを入力としてモデルに供給できます :

outputs = model(input_ids, langs=langs)

run_generation.py は言語埋め込みを使用して、XLM からの CLM チェックポイントを使用してテキストを生成できます。

 

言語埋め込みなしの XLM

このセクションは以下のチェックポイントが主題です :

• xlm-mlm-17-1280 (Masked 言語モデリング、17 言語)
• xlm-mlm-100-1280 (Masked 言語モデリング、100 言語)

これらのチェックポイントは推論時に言語埋め込みを必要としません。これらのモデルは、前述の XLM チェックポイントとは異なり、一般的なセンテンス表現を持つために使用されます。

 

BERT

BERT は 2 つのチェックポイントを持ちます、これらは多言語タスクのために利用できます :

• bert-base-multilingual-uncased (Masked 言語モデリング + 次文予測, 102 言語)
• bert-base-multilingual-cased (Masked 言語モデリング + 次文予測, 104 言語)

これらのチェックポイントは推論時に言語埋め込みを必要としません。それらはコンテキストで使用される言語を識別してそれに従って推論すべきです。

 

XLM-RoBERTa

XLM-RoBERTa は 2.5TB の新たに作成されたクリーンな 100 言語の CommonCrawl データ上で訓練されました。それは分類、シークエンス・ラベリングと質問応答のような下流タスク上で mBERT や XLM のような以前にリリースされた多言語モデルを越える強力な利益を提供します。

2 つの XLM-RoBERTa チェックポイントが多言語タスクのために利用できます :

• xlm-roberta-base (Masked 言語モデリング、100 言語)
• xlm-roberta-large (Masked 言語モデリング、100 言語)

以上

HuggingFace Transformers 4.5 : 利用方法 : トークナイザーの要点 (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 05/12/2021 (4.5.1)

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

• Using Transformers : Summary of the tokenizers

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

 

 

HuggingFace Transformers : 利用方法 : トークナイザーの要点

このページでは、トークン化をより詳しく調べます。前処理チュートリアル で見たように、テキストのトークン化はそれを単語やサブワードに分割します、これらはそれから検索テーブルを通して id に変換されます。単語やサブワードを id に変換することは簡単ですから、この要点では、テキストを単語やサブワードを分割することにフォーカスします (i.e. テキストのトークン化)。より具体的には、 Transformers で使用されるトークナイザーの 3 つの主要なタイプを見ます : Byte-Pair エンコーディング (BPE)、WordPiece と SentencePiece です、そしてどのトークナイザーがどのモデルにより使用されるかのサンプルを示します。

各モデルページでは、どのトークナイザー・タイプが事前訓練モデルにより使用されたかを知るために関連するトークナイザーのドキュメントを見ることができることに注意してください。例えば、BertTokenizer を見れば、モデルが WordPiece を使用していることを見ることができます。

 

イントロダクション

テキストをより小さいチャンクに分割することは思うよりも困難なタスクで、それを行なうための複数の方法があります。例えば、センテンス “Don’t you love 🤗 Transformers? We sure do.” を見ましょう。テキストをトークン化する単純な方法はそれをスペース (空白) で分割することです、それは次を与えるでしょう :

["Don't", "you", "love", "🤗", "Transformers?", "We", "sure", "do."]

これは良識ある最初のステップですが、トークン “Transformers?” と “do.” を見れば、句読点が単語 “Transformer” と “do” に装着されていることに気付きます、これは最適とは言えません。モデルが単語の異なる表現とそれに続くかもしれない句読記号を学習しなくても良いように句読点を考慮に入れるべきです、それはモデルが学習しなければならない表現の数を爆発させます。句読点を考慮に入れれば、模範となるテキストのトークン化は次を与えます :

["Don", "'", "t", "you", "love", "🤗", "Transformers", "?", "We", "sure", "do", "."]

より良いです。けれども、トークン化が単語 “Don’t” をどのように扱うかは不都合です。”Don’t” は “do not” を表しますので、[“Do”, “n’t”] としてトークン化されるほうがより良いです。これは物事が複雑になり始めるところで、各モデルが自身のトークナイザー・タイプを持つ理由の一部です。テキストのトークン化のために適用するルールに依拠して、同じテキストに対して異なるトークン化された出力が生成されます。事前訓練モデルは、訓練データをトークン化するために使用されたものと同じルールでトークン化された入力を供給する場合に限り、正しく遂行します。

spaCy と Moses は 2 つのポピュラーなルールベースのトークナイザーです。サンプルに適用すると、spaCy と Moses は次のようなものを出力します :

["Do", "n't", "you", "love", "🤗", "Transformers", "?", "We", "sure", "do", "."]

見られるように、スペースと句読点のトークン化に加えて、ルールベースのトークン化がここで使用されています。スペースと句読点のトークン化とルールベースのトークン化は両者とも単語トークン化の例で、センテンスを単語に分割するものとして緩く定義されます。テキストをより小さいチャンクに分割することは最も直観的な方法である一方で、このトークン化方法は大規模なテキストコーパスのためには問題に繋がる可能性があります。この場合、スペースと句読点のトークン化は通常非常に大きな語彙 (使用される総ての一意の単語とトークンのセット) を生成します。E.g., Transformer XL はスペースと句読点トークン化を使用し、267,735 の語彙サイズという結果になります！

そのような大きな語彙サイズはモデルに入力と出力層として巨大な埋め込み行列を持つことを強制します、これは増大するメモリと時間コストの両者を引き起こします。一般に、transformer モデルは 50,000 より大きい語彙サイズは滅多に持ちません、特にそれらが単一の言語上で事前訓練される場合。

それでは単純なスペースと句読点トークン化が不十分であるならば、何故単純に文字でトークン化しないのでしょう？文字のトークン化が非常に単純であり、そしてメモリと時間コストを大きく減じる一方で、それはモデルが意味のある入力表現を学習することを遥かに困難にします。E.g. 文字 “t” のための意味のあるコンテキスト独立な表現を学習することは単語 “today” のためのコンテキスト独立な表現を学習することより遥かに困難です。従って、文字トークン化はしばしばパフォーマンスの損失を伴います。従って、両者の長所を活かすため、transformers モデルは subword (サブワード) トークン化と呼ばれる単語レベルと文字レベルトークン化のハイブリッドを使用します。

 

サブワード・トークン化

サブワード・トークン化アルゴリズムは、頻繁に使用される単語はより小さいサブワードに分割されるべきではないが、稀な単語は意味のあるサブワードに分解されるべきであるという原理に依拠しています。例えば、”annoyingly” は稀な単語と考えられるかもしれず、そして “annoying” と “ly” に分解できるでしょう。スタンドアロンのサブワードとして “annoying” と “ly” の両者はより頻繁に現れる一方で、同時に “annoyingly” の意味は “annoying” と “ly” の合成的な意味により保持されます。これは特にトルコ語のような膠着語で有用です、そこではサブワードを一緒に繋ぐことにより任意に長い複雑な単語 (群) を (殆ど) 形成できます。

サブワード・トークン化はモデルに合理的な語彙サイズを持つことを可能にする一方で、意味のあるコンテキスト独立な表現を学習することができます。更に、サブワード・トークン化はモデルが前に見たことがない単語を既知のサブワードに分解することにより処理することを可能にします。例えば、BertTokenizer は “I have a new GPU!” を次のようにトークン化します :

from transformers import BertTokenizer
tokenizer = BertTokenizer.from_pretrained("bert-base-uncased")
tokenizer.tokenize("I have a new GPU!")

["i", "have", "a", "new", "gp", "##u", "!"]

uncased モデルを考えていますので、センテンスは最初に小文字にされています。[“i”, “have”, “a”, “new”] はトークナイザーの語彙に存在していますが、単語 “gpu” はそうでないことがわかります。その結果、トークナイザーは “gpu” を既知のサブワード : [“gp” と “##u”] に分割します。”##” は (デコードやトークン化の反転のため) トークンの残りはスペースなしで前のものに装着されるべきであることを意味します。

もう一つの例として、XLNetTokenizer トークナイザーは前の典型例としてのテキストを次のようにトークン化します :

from transformers import XLNetTokenizer
tokenizer = XLNetTokenizer.from_pretrained("xlnet-base-cased")
tokenizer.tokenize("Don't you love 🤗 Transformers? We sure do.")

["▁Don", "'", "t", "▁you", "▁love", "▁", "🤗", "▁", "Transform", "ers", "?", "▁We", "▁sure", "▁do", "."]

SentencePiece を見るときこれらの “▁” の意味に戻ります。見れるように、稀な単語 “Transformers” はより頻度の高いサブワード “Transform” と “ers” に分割されています。

今は様々なサブワード・トークン化アルゴリズムがどのように動作するかを見ましょう。これらのトークン化アルゴリズムの総ては (通常は対応するモデルがその上で訓練されたコーパス上で成される) 訓練のある形式に依拠していることに注意してください。

 

バイトペア・エンコーディング (BPE)

バイトペア・エンコーディング (BPE) は Neural Machine Translation of Rare Words with Subword Units (Sennrich et al., 2015) で導入されました。BPE は訓練データを単語に分割する事前トークナイザーに依存しています。事前トークン化はスペース・トークン化のように単純であり得ます、e.g. GPT2, Roberta。より進んだ事前トークン化はルールベースのトークン化を含みます、e.g. XLM, FlauBERT、これは殆どの言語について Moses を使用しています、また GPT は訓練コーパスで各単語の頻度をカウントするために Space と ftfy を使用します。

事前トークン化後、一意の単語のセットが作成されて訓練データで出現した各単語の頻度が決定されます。次に、BPE は一意の単語のセットに出現する総てのシンボルから成るベース語彙を作成します、そしてベース語彙の 2 つのシンボルから新しいシンボルを形成するためのマージルールを学習します。語彙が望まれる語彙サイズを獲得するまでそれを行ないます。望まれる語彙サイズはトークナイザーを訓練する前に定義するハイパーパラメータであることに注意してください。

例として、事前トークン化後、頻度を含む次の単語のセットが定義されたと仮定します :

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

その結果、ベース語彙は [“b”, “g”, “h”, “n”, “p”, “s”, “u”] となります。総ての単語をベース語彙のシンボルに分割し、次を得ます :

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

そして BPE は各可能なシンボル・ペアの頻度をカウントして最も頻繁に出現するシンボル・ペアを選択します。上の例では、”u” が続く “h” は 10 + 5 = 15 回存在します (“hug” の 10 出現で 10 回、”hugs” の 5 出現で 5 回)。けれども、最も頻度の高いシンボル・ペアは “g” が続く “u” で、合計で 10 + 5 + 5 = 20 回出現します。こうして、トークナイザーが学習する最初のマージルールは “g” シンボルが続く “u” シンボル総てを一緒にグループ化することです。次に、”ug” は語彙に追加されます。そして単語のセットは次になります :

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

それから BPE は次の最も一般的なシンボル・ペアを識別します。それは “n” が続く “u” で、16 回出現します。”u”, “n” は “un” にマージされて語彙に追加されます。次に頻度の高いシンボル・ペアは “ug” が続く “h” で、15 回です。再度ペアがマージされて “hug” が語彙に追加できます。

この段階で、語彙は [“b”, “g”, “h”, “n”, “p”, “s”, “u”, “ug”, “un”, “hug”] でそして一意の単語のセットは次のように表されます :

("hug", 10), ("p" "ug", 5), ("p" "un", 12), ("b" "un", 4), ("hug" "s", 5)

バイトペア・エンコーディングがこの時点で停止すると仮定すると、学習されたマージルールが新しい単語に適用されます (それらの新しい単語がベース語彙にないシンボルを含まない限りは)。例えば、単語 “bug” は [“b”, “ug”] にトークン化されますが “mug” は [“<unk>”, “ug”] としてトークン化されます、何故ならばシンボル “m” はベース語彙にないからです。一般には、”m” のような単一文字は “<unk>” シンボルで置き換えられません、何故ならば訓練データは通常は各文字の出現を少なくとも一つは含むからですが、絵文字のような非常に特殊な文字については発生しがちです。

前に述べたように、語彙サイズ、i.e. ベース語彙サイズ + マージの数、は選択するハイパーパラメータです。例えば GPT は 40,478 の語彙サイズを持ちます、何故ならばそれらは 478 ベース文字を持ちそして 40,000 マージの後に訓練を停止することを選択したからです。

 

バイト・レベル BPE

総ての可能なベース文字を含むベース語彙は、総てのユニコード文字がベース文字として考えられる場合などには、非常に大規模になり得ます。より良いベース語彙を持つために、GPT-2 はベース語彙としてバイトを使用します、これは賢いトリックでベース語彙にサイズ 256 であることを強制する一方で、総てのベース文字がその語彙に含まれることを確かなものにします。句読点を扱うための幾つかの追加ルールにより、GPT2 のトークナイザーは <unk> シンボルを必要とすることなく総てのテキストをトークン化できます。GPT-2 は 50,257 の語彙サイズを持ちます、これは 256 バイトのベーストークン、特殊な end-of-text (テキスト終了) トークンと 50,000 マージで学習されたシンボルに相当します。

 

WordPiece

WordPiece は BERT, DistilBERT と Electra のために利用されるサブワード・トークン化アルゴリズムです。このアルゴリズムは Japanese and Korean Voice Search (Schuster et al., 2012) で概説されて BPE に非常に良く似ています。WordPiece は最初に語彙を訓練データに存在する総ての文字を含めるように初期化して既定の数のマージルールを漸進的に学習します。BPE とは対照的に、WordPiece は最も頻度の高いシンボルペアではなく、語彙に追加された訓練データの尤度を最大化するものを選択します。

さてこれは正確には何を意味するのでしょう？前の例を参照すれば、訓練データの尤度を最大化することは、2 番目のシンボルが続く最初のシンボルの確率により除算される (シンボルペアの) 確率が総てのシンボルペアの中で最大であるような、シンボルペアを見つけることと同値です。E.g. “g” が続く “u” は “u”, “g” により除算される “ug” の確率が任意の他のシンボルペアよりも大きい場合にだけマージされます。直観的には、WordPiece は 2 つのシンボルをマージすることにより (それに値するかを確かなものにするために) それが失うものを評価するという点で BPE と僅かに異なります。

 

Unigram

Unigram は Subword Regularization: Improving Neural Network Translation Models with Multiple Subword Candidates (Kudo, 2018) で導入されたサブワード・トークン化アルゴリズムです。BPE や WordPiece とは対照的に、Uniram はベース語彙をシンボルの大規模な数に初期化してより小さい語彙を得るために各シンボルを漸次的に切り捨てていきます。
ベース語彙は例えば総ての事前トークン化された単語と最も一般的な部分文字列に対応できるでしょう。Unigram は transformers のどのモデルについても直接使用されていませんが、SentencePiece とともに利用されています。

各訓練ステップで、現在の語彙と Unigram 言語モデルが与えられて Unigram アルゴリズムは訓練データに渡る損失 (多くの場合、対数尤度として定義されます) を定義します。それから、語彙の各シンボルについて、アルゴリズムはシンボルが語彙から除去されたとすると全体的な損失がどのくらい増加するかを計算します。それから Unigram は損失の増加がもっとも少ないシンボル、つまり訓練データに渡る全体的な損失にもっとも影響を与えないシンボルの p (p は通常は 10% or 20%) パーセントを除去します。このプロセスは語彙が望まれるサイズに達するまで繰り返されます。Unigram アルゴリズムは任意の単語がトークン化できるようにベース文字を常に保持します。

Unigram は (BPE と WordPiece とは対照的に) マージルールに基づかないので、アルゴリズムは訓練後に新しいテキストをトークン化する幾つかの方法を持ちます。例として、訓練された Unigram トークナイザーが以下の語彙を示す場合 :

["b", "g", "h", "n", "p", "s", "u", "ug", "un", "hug"],

“hugs” は [“hug”, “s”], [“h”, “ug”, “s”] or [“h”, “u”, “g”, “s”] の両者としてトークン化できるでしょう。それではどれを選択するのでしょう？Unigram は各可能なトークン化の確率を訓練後に計算できるように、語彙をセーブするのに加えて訓練コーパスの各トークンの確率をセーブします。アルゴリズムは実際い最も尤度の高いトークン化を単純に選択しますが、それらの確率に従って可能なトークン化をサンプリングする可能性も提供します。

これらの確率はその上でトークナイザーが訓練される損失により定義されます。訓練データが単語 $x_{1}, \dots, x_{N}$ から成り、そして単語 $x_{i}$ のための総ての可能なトークン化のセットが $S(x_{i})$ で定義されると仮定すると、全体的な損失は次で定義されます :

\[
\mathcal{L} = -\sum_{i=1}^{N} \log \left ( \sum_{x \in S(x_{i})} p(x) \right )
\]

 

SentencePiece

ここまで説明された総てのトークン化アルゴリズムは同じ問題を持ちます : 単語を分割するために入力テキストがスペースを使用していることが仮定されています。けれども、総ての言語が単語を分割するためにスペースを使用してはいません。一つの可能な解法は言語固有の事前トークナイザーを使用することです、例えば XML は固有の中国語、日本語、そしてタイ語の事前トークナイザーを使用しています。この問題をより一般的に解くため、SentencePiece : A simple and language independent subword tokenizer and detokenizer for Neural Text Processing (Kudo et al., 2018) は入力を raw 入力ストリームとして扱い、スペースを使用する文字のセット内に含めます。それから適切な語彙を構築するために BPE か unigram アルゴリズムを使用します。

XLNetTokenizer は例えば SentencePiece を使用しています、これはまた先の例で何故 “▁” 文字が語彙に含まれていたかです。SentencePiece によるデコードは非常に容易です、何故ならば総てのトークンは連結できて “▁” がスペースで置き換えられるだけからです。SentencePiece を使用するライブラリの総ての transformer モデルはそれを unigram との組合せで利用します。SentencePiece を使用するモデルの例は ALBERT, XLNet, Marian と T5 です。

以上

HuggingFace Transformers 4.5 : 利用方法 : 訓練と再調整 (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 05/11/2021 (4.5.1)

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

• Using Transformers : Training and fine-tuning

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

 

 

HuggingFace Transformers : 利用方法 : 訓練と再調整

• 訳注 : 本ドキュメントの TensorFlow バージョンは こちら をご覧ください。

Transformers の Model クラスは native PyTorch と TensorFlow 2 と互換であるように設計されそしていずれとも共にシームレスに利用可能です。このクイックスタートでは、いずれのフレームワークでも利用可能な標準訓練ツールを使用してモデルをどのように再調整するか (or スクラッチから訓練するか) を示します。含まれる Trainer() クラスをどのように使用するかも示します、これは訓練の複雑さの大半を貴方のために処理します。

このガイドは推論のためにモデルをロードして使用することに既に馴染みがあることを仮定します : そうでないなら タスクの要点 を見てください。貴方が PyTorch か TF2 のいずれかの深層ニューラルネットワークの訓練に馴染みがあることも仮定し、 Transformers の訓練のためのニュアンスとツールに特にフォーカスします。

 

native PyTorch で再調整する

TF で始まらない Transformers の Model クラスは PyTorch モジュールで、つまり推論と最適化の両者のために丁度 PyTorch の任意のモデルのようにそれらを利用できます。

シークエンス分類データセット上で BERT のようなマスク付き言語モデルを再調整する一般的なタスクを考えましょう。モデルを from_pretrained() でインスタンス化するとき、モデルを初期化するために指定されたモデルのモデル configuration と事前訓練重みが使用されます。ライブラリはまた幾つかのタスク固有の最終層や「ヘッド」も含みます、それらの重みは指定された事前訓練モデルに存在しないときはランダムにインスタンス化されます。例えば、BertForSequenceClassification.from_pretrained(‘bert-base-uncased’, num_labels=2) によるモデルのインスタンス化は bert-base-uncased モデルからコピーされたエンコーダ重みとエンコーダの上に 2 の出力サイズを持つランダムに初期化されたシークエンス分類ヘッドで BERT モデルインスタンスを作成します。モデルはデフォルトでは eval モードで初期化されます。それを train モードにするために model.train() を呼び出すことができます。

from transformers import BertForSequenceClassification
model = BertForSequenceClassification.from_pretrained('bert-base-uncased')
model.train()

これは有用です、何故ならばそれは事前訓練された BERT エンコーダを利用して選択するどのようなシークエンス分類データセットの上でもそれを容易に訓練することを許容するからです。任意の PyTorch optimizer を利用できますが、ライブラリはまた AdamW() optimizer も提供します、これは重み減衰に加えて勾配バイアス補正 (= gradient bias correction) を実装しています。

from transformers import AdamW
optimizer = AdamW(model.parameters(), lr=1e-5)

optimizer は特定のパラメータグループのために異なるハイパーパラメータを適用することを許容します。例えば、重み減衰をバイアスと層正規化項以外の総てのパラメータに適用できます :

no_decay = ['bias', 'LayerNorm.weight']
optimizer_grouped_parameters = [
    {'params': [p for n, p in model.named_parameters() if not any(nd in n for nd in no_decay)], 'weight_decay': 0.01},
    {'params': [p for n, p in model.named_parameters() if any(nd in n for nd in no_decay)], 'weight_decay': 0.0}
]
optimizer = AdamW(optimizer_grouped_parameters, lr=1e-5)

今は __call__() を使用して単純なダミー訓練バッチをセットアップすることができます。これは BatchEncoding() インスタンスを返します、これはモデルに渡す必要があるかもしれない総てを準備します。

from transformers import BertTokenizer
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
text_batch = ["I love Pixar.", "I don't care for Pixar."]
encoding = tokenizer(text_batch, return_tensors='pt', padding=True, truncation=True)
input_ids = encoding['input_ids']
attention_mask = encoding['attention_mask']

分類モデルを labels 引数で呼び出すとき、最初の返される要素は予測と渡されたラベルの間の交差エントロピー損失です。optimizer を既にセットアップしていますので、それから backwards パスを行ない重みを更新することができます :

labels = torch.tensor([1,0]).unsqueeze(0)
outputs = model(input_ids, attention_mask=attention_mask, labels=labels)
loss = outputs.loss
loss.backward()
optimizer.step()

代わりに、単にロジットを得て損失を貴方自身で計算することもできます。次は前のサンプルと同値です :

from torch.nn import functional as F
labels = torch.tensor([1,0])
outputs = model(input_ids, attention_mask=attention_mask)
loss = F.cross_entropy(outputs.logits, labels)
loss.backward()
optimizer.step()

もちろん、通常のようにモデルと入力上で to(‘cuda’) を呼び出して GPU 上で訓練することができます。

2, 3 の学習率スケジューリング・ツールも提供します。以下によって、スケジューラのセットアップができます、これは num_warmup_steps の間ウォームアップしてから訓練の終わりまでに 0 に線形に減衰します。

from transformers import get_linear_schedule_with_warmup
scheduler = get_linear_schedule_with_warmup(optimizer, num_warmup_steps, num_train_steps)

それから行なわなければならないことの総ては optimizer.step() の後で scheduler.step() を呼び出すことです。

loss.backward()
optimizer.step()
scheduler.step()

下で議論されるように、Trainer() を使用することを強く勧めます、これは混合精度と容易な tensorboard ロギングのような機能とともに Transformers モデルを訓練する可動部を便利に処理します。

 

エンコーダを凍結する

場合によっては、事前訓練されたエンコーダの重みを凍結し続けてヘッド層の重みだけを最適化することに関心があるかもしれません。そのためには、エンコーダ・パラメータ上で単純に requires_grad 属性を False に設定します、これはライブラリの任意のタスク固有モデル上 base_model サブモジュールでアクセスできます :

for param in model.base_model.parameters():
    param.requires_grad = False

 

native TensorFlow 2 で再調整する

モデルはまた TensorFlow 2 でもネイティブに訓練できます。ちょうど PyTorch でのように、TensorFlow モデルは事前訓練モデルからエンコーダの重みをロードするために from_pretrained() でインスタンス化できます。

from transformers import TFBertForSequenceClassification
model = TFBertForSequenceClassification.from_pretrained('bert-base-uncased')

GLUE からの MRPC データセット をロードするために tensorflow_datasets を使用しましょう。それから MRPC をトークン化してそれを TensorFlow Dataset オブジェクトに変換するために組込み glue_convert_examples_to_features() を利用できます。tokenizer はフレームワーク不可知ですので、事前訓練された tokenizer 名に TF を先頭に追加する必要はありません。

from transformers import BertTokenizer, glue_convert_examples_to_features
import tensorflow as tf
import tensorflow_datasets as tfds
tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
data = tfds.load('glue/mrpc')
train_dataset = glue_convert_examples_to_features(data['train'], tokenizer, max_length=128, task='mrpc')
train_dataset = train_dataset.shuffle(100).batch(32).repeat(2)

そしてモデルは任意の Keras モデルとしてコンパイルされて訓練できます :

optimizer = tf.keras.optimizers.Adam(learning_rate=3e-5)
loss = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)
model.compile(optimizer=optimizer, loss=loss)
model.fit(train_dataset, epochs=2, steps_per_epoch=115)

TensorFlow と PyTorch モデル間の緊密な相互運用性により、モデルをセーブしてからそれを PyTorch モデルとして再ロードすることさえできます (or vice-versa) :

from transformers import BertForSequenceClassification
model.save_pretrained('./my_mrpc_model/')
pytorch_model = BertForSequenceClassification.from_pretrained('./my_mrpc_model/', from_tf=True)

 

Trainer

Trainer() と TFTrainer() を通して単純ですが feature-complete な訓練と評価インターフェイスもまた提供します。広範囲の訓練オプションとロギング、勾配集積 (= accumulation) と混合精度のような組込み特徴で任意の Transformers モデルを訓練し、再調整し、そして評価することができます。

from transformers import BertForSequenceClassification, Trainer, TrainingArguments

model = BertForSequenceClassification.from_pretrained("bert-large-uncased")

training_args = TrainingArguments(
    output_dir='./results',          # output directory
    num_train_epochs=3,              # total # of training epochs
    per_device_train_batch_size=16,  # batch size per device during training
    per_device_eval_batch_size=64,   # batch size for evaluation
    warmup_steps=500,                # number of warmup steps for learning rate scheduler
    weight_decay=0.01,               # strength of weight decay
    logging_dir='./logs',            # directory for storing logs
)

trainer = Trainer(
    model=model,                         # the instantiated 🤗 Transformers model to be trained
    args=training_args,                  # training arguments, defined above
    train_dataset=train_dataset,         # training dataset
    eval_dataset=test_dataset            # evaluation dataset
)

今は単純に訓練するために trainer.train() をそして評価するために trainer.evaluate() を呼び出します。貴方自身のモジュールもまた利用できますが、forward から返される最初の引数は最適化することを望む損失でなければなりません。

Trainer() はバッチを順番に並べてそれらをモデルに供給されるように準備するために組込みのデフォルト関数を使用します。必要であれば、貴方自身の collator 関数を渡すために data_collator 引数も使用できます、これは貴方のデータセットにより提供される形式のデータを取りそしてモデルに供給される準備ができたバッチを返します。TFTrainer は渡されたデータセットが tensorflow_datasets からのデータセット・オブジェクトであることを想定していることに注意してください。

損失に加えて追加のメトリクスを計算するために、貴方自身の compute_metrics 関数も定義してそれを Trainer に渡すこともできます。

from sklearn.metrics import accuracy_score, precision_recall_fscore_support

def compute_metrics(pred):
    labels = pred.label_ids
    preds = pred.predictions.argmax(-1)
    precision, recall, f1, _ = precision_recall_fscore_support(labels, preds, average='binary')
    acc = accuracy_score(labels, preds)
    return {
        'accuracy': acc,
        'f1': f1,
        'precision': precision,
        'recall': recall
    }

最後に、指定された logging_dir ディレクトリで tensorboard を起動することにより任意の計算されたメトリクスを含む結果を見ることができます。

以上

HuggingFace Transformers 4.5 : 利用方法 : データの前処理 (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 05/11/2021 (4.5.1)

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

• Using Transformers : Preprocessing data

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

 

 

HuggingFace Transformers : 利用方法 : データの前処理

• 訳注 : 本ドキュメントの TensorFlow バージョンは こちら をご覧ください。

このチュートリアルでは、 Transformers を使用してデータをどのように前処理するかを探求します。このための主要ツールは tokenizer と呼ぶものです。貴方が使用したいモデルに関連する tokenizer クラスを使用するか、あるいは AutoTokenizer クラスで直接それを構築できます。

クイックツアーで見たように、tokenizer は与えられたテキストを最初にトークンと呼ばれる単語 (or 単語の部分、句読点記号, etc.) に分割します。それからそれはそれらから tensor を構築できるようにトークンを数字に変換してそしてそれらをモデルに供給します。それはまたモデルが正しく動作するために想定するかもしれない任意の追加入力も追加します。

Note: 事前訓練モデルを使用する計画を立てているならば、関連する事前訓練 tokenizer を使用することは重要です : それは貴方がそれに与えるテキストを事前訓練コーパスのためのと同じ方法でトークンを分割し、そしてそれはインデックスするために事前訓練の間と同じ 対応トークン (それは通常は語彙と呼称します) を使用します。

与えられたモデルを事前訓練するか再調整する間に使用された語彙を自動的にダウンロードするために、from_pretrained() メソッドを利用できます :

from transformers import AutoTokenizer
tokenizer = AutoTokenizer.from_pretrained('bert-base-cased')

 

Base 使用方法

PreTrainedTokenizer は多くのメソッドを持ちますが、前処理のために覚えておく必要がある唯一のものはその __call__ です : センテンスを tokenizer オブジェクトに供給する必要があるだけです。

encoded_input = tokenizer("Hello, I'm a single sentence!")
print(encoded_input)

{'input_ids': [101, 138, 18696, 155, 1942, 3190, 1144, 1572, 13745, 1104, 159, 9664, 2107, 102],
 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}

これは int のリストへの辞書文字列を返します。input_ids はセンテンスの各トークンに対応するインデックスです。下で attention_mask が何のために使用されるか、そして次のセクション では token_type_ids の目的を見ます。

tokenizer はトークン id のリストを正しいセンテンスでデコードできます :

tokenizer.decode(encoded_input["input_ids"])

"[CLS] Hello, I'm a single sentence! [SEP]"

見れるように、tokenizer はモデルが想定する幾つかの特殊トークンを自動的に追加しました。総てのモデルが特殊トークンを必要とはしません ; 例えば、tokenizer を作成するために bert-base-cased の代わりに `gtp2-medium` を使用した場合、ここで元のものと同じセンテンスを見るでしょう。add_special_tokens=False を渡すことによりこの動作を無効にできます (これは貴方が自身で特殊トークンを追加した場合にのみ勧められます)。

処理することを望む幾つかのセンテンスを持つ場合、リストとしてそれらを tokenizer に送ることにより効率的にこれを行なうことができます :

batch_sentences = ["Hello I'm a single sentence",
                   "And another sentence",
                   "And the very very last one"]
encoded_inputs = tokenizer(batch_sentences)
print(encoded_inputs)

{'input_ids': [[101, 8667, 146, 112, 182, 170, 1423, 5650, 102],
               [101, 1262, 1330, 5650, 102],
               [101, 1262, 1103, 1304, 1304, 1314, 1141, 102]],
 'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0, 0],
                    [0, 0, 0, 0, 0],
                    [0, 0, 0, 0, 0, 0, 0, 0]],
 'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1],
                    [1, 1, 1, 1, 1],
                    [1, 1, 1, 1, 1, 1, 1, 1]]}

再度辞書を取得して、今回は int のリストのリストである値を持っています。

一度に幾つかのセンテンスを tokenizer に送る目的がモデルに供給するバッチを構築することであるならば、貴方は多分以下を望むでしょう :

• バッチで最大長に各センテンスをパッドする。
• モデルが受け取れる最大長に各センテンスを切り捨てる (妥当な場合)。
• tensor を返す。

センテンスのリストを tokenzier に供給するとき以下のオプションを使用してこれの総てを行なうことができます :

batch = tokenizer(batch_sentences, padding=True, truncation=True, return_tensors="pt")
print(batch)

{'input_ids': tensor([[ 101, 8667,  146,  112,  182,  170, 1423, 5650,  102],
                      [ 101, 1262, 1330, 5650,  102,    0,    0,    0,    0],
                      [ 101, 1262, 1103, 1304, 1304, 1314, 1141,  102,    0]]),
 'token_type_ids': tensor([[0, 0, 0, 0, 0, 0, 0, 0, 0],
                           [0, 0, 0, 0, 0, 0, 0, 0, 0],
                           [0, 0, 0, 0, 0, 0, 0, 0, 0]]),
 'attention_mask': tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1],
                           [1, 1, 1, 1, 1, 0, 0, 0, 0],
                           [1, 1, 1, 1, 1, 1, 1, 1, 0]])}

それは文字列キーと tensor 値を持つ辞書を返します。今は attention_mask が何かを総て見ることができます : それはモデルがどのトークンに注意を払うべきか、そしてどれに注意を払うべきでないかを指摘します (何故ならばこの場合それらはパディングを表すからです)。

モデルがそれに関連する最大長を持たない場合には、上のコマンドは警告を投げることに注意してください。それを安全に無視することができます。その種類の警告を投げることを tokenzier にやめさせるために verbose=False を渡すこともできます。

 

センテンスのペアを前処理する

時にモデルにセンテンスのペアを供給する必要があります。例えば、ペアの 2 つのセンテンスが類似しているか分類することを望んだり、コンテキストと質問を取る質問応答モデルについてです。BERT モデルに対しては、入力はこのように表されます : [CLS] Sequence A [SEP] Sequence B [SEP]

2 つの引数として 2 つのセンテンスを供給することによりモデルにより想定される形式でセンテンスのペアをエンコードできます (リストではありません、何故ならば 前に見たように、2 つのセンテンスのリストは 2 つの単一のセンテンスのバッチとして解釈されるからです)。これは再度 int のリストへの辞書文字列を返します :

encoded_input = tokenizer("How old are you?", "I'm 6 years old")
print(encoded_input)

{'input_ids': [101, 1731, 1385, 1132, 1128, 136, 102, 146, 112, 182, 127, 1201, 1385, 102],
 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1],
 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}

これは token_type_ids が何のためであるかを示します : それらはモデルに入力のどの部分が最初のセンテンスに対応しそしてどの部分が 2 番目のセンテンスに対応するかを示します。token_type_ids は総てのモデルにより必要とされたり処理されたりするわけではないことに注意してください。デフォルトでは、tokenizer は関連モデルが想定する入力を返すだけです。return_input_ids か return_token_type_ids を使用してそれらの特別な引数のいずれかの return (or non-return) を強制できます。

取得したトークン id をデコードすれば、特殊トークンが正しく追加されたことを見ます。

tokenizer.decode(encoded_input["input_ids"])

"[CLS] How old are you? [SEP] I'm 6 years old [SEP]"

処理することを望むシークエンスのペアのリストを持つ場合、それらを tokenizer に 2 つのリストとして供給するべきです : 最初のセンテンスのリストと 2 番目のセンテンスのリストです :

batch_sentences = ["Hello I'm a single sentence",
                   "And another sentence",
                   "And the very very last one"]
batch_of_second_sentences = ["I'm a sentence that goes with the first sentence",
                             "And I should be encoded with the second sentence",
                             "And I go with the very last one"]
encoded_inputs = tokenizer(batch_sentences, batch_of_second_sentences)
print(encoded_inputs)

{'input_ids': [[101, 8667, 146, 112, 182, 170, 1423, 5650, 102, 146, 112, 182, 170, 5650, 1115, 2947, 1114, 1103, 1148, 5650, 102],
               [101, 1262, 1330, 5650, 102, 1262, 146, 1431, 1129, 12544, 1114, 1103, 1248, 5650, 102],
               [101, 1262, 1103, 1304, 1304, 1314, 1141, 102, 1262, 146, 1301, 1114, 1103, 1304, 1314, 1141, 102]],
'token_type_ids': [[0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
                   [0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
                   [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1]],
'attention_mask': [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
                   [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
                   [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}

見れるように、それは各値が int のリストのリストであるような辞書を返します。

何がモデルに供給されるかを二重チェックするために、input_ids の各リストを一つずつデコードできます :

for ids in encoded_inputs["input_ids"]:
    print(tokenizer.decode(ids))

[CLS] Hello I'm a single sentence [SEP] I'm a sentence that goes with the first sentence [SEP]
[CLS] And another sentence [SEP] And I should be encoded with the second sentence [SEP]
[CLS] And the very very last one [SEP] And I go with the very last one [SEP]

再度、入力をバッチの最大センテンス長に自動的にパッドし、モデルが受け取れる最大長に切り捨ててそして以下で tensor を直接返すことができます :

batch = tokenizer(batch_sentences, batch_of_second_sentences, padding=True, truncation=True, return_tensors="pt")

 

パディングと切り捨てについて貴方が常に知りたいことの総て

殆どの場合について動作するコマンドを見てきました (バッチを最大センテンス長にパッドし、モデルが受け取れる最大長に切り捨てます)。けれども、API は必要であればより多くのストラテジーをサポートします。このために知る必要がある 3 つの引数は padding, truncation と max_length です。

• padding はパディングを制御します。それは以下であるべき boolean か文字列であり得ます :
  • True or ‘longest’、バッチの最長シークエンスにパッドします (単一シークエンスだけを提供する場合にはパディングをしません)。
  • ‘max_length’、max_length 引数か (max_length が提供されない場合 (max_length=None)) モデルにより受容される最大長により指定される長さにパッドします。単一シークエンスだけを提供する場合、パディングは依然としてそれに適用されます。
  • False or ‘do_not_pad’、シークエンスをパッドしません。前に見たように、これはデフォルトの動作です。

• truncation は切り捨てを制御します。それは以下であるべき boolean か文字列であり得ます :
  • True or ‘only_first’ は max_length 引数か (max_length が提供されない場合 (max_length=None)) モデルにより受容される最大長により指定される最大長に切り捨てます。シークエンスのペア (or シークエンスのペアのバッチ) が提供される場合、ペアの最初のセンテンスだけを切り捨てます。
  • ‘only_second’ は max_length 引数か (max_length が提供されない場合 (max_length=None)) モデルにより受容される最大長により指定される最大長に切り捨てます。これはシークエンスのペア (or シークエンスのペアのバッチ) が提供される場合、ペアの 2 番目のセンテンスだけを切り捨てます。
  • ‘longest_first’ は max_length 引数か (max_length が提供されない場合 (max_length=None)) モデルにより受容される最大長により指定される最大長に切り捨てます。これはトークン毎に切り捨て、適切な長さに達するまでペアの最長のシークエンスからトークンを除去します。
  • False or ‘do_not_truncate’ はシークエンスを切り捨てません。前に見たように、これはデフォルトの動作です。

• max_length はパディング/切り捨ての長さを制御します。それは整数か None であり得て、その場合それはモデルが受容できる最大長をデフォルトとします。モデルは特定の最大入力長を持たない場合、max_length への切り捨て/パディングは無効にされます。

ここにパディングと切り捨てをセットアップするための推奨方法を要約するテーブルがあります。以下のサンプルのいずれかで入力シークエンスのペアを使用する場合、truncation=True を [‘only_first’, ‘only_second’, ‘longest_first’] で選択された STRATEGY で置き換えることができます、i.e. truncation=’only_second’ or truncation= ‘longest_first’ は前に詳述されたようにペアの両者のシークエンスがどのように切り捨てられるかを制御します。

(訳注: テーブルについては 原文 参照)

 

事前にトークン化された入力

tokenizer はまた事前にトークン化された入力も受け取ります。これは固有表現認識 (NER) や品詞タギング (POS タギング) でラベルを計算して予測を抽出することを望むときに特に有用です。

Warning: 事前トークン化は、貴方の入力が既にトークン化されている (その場合にはそれらを tokenizer に渡す必要はありません) ことを意味しませんが、単に単語に分割されています (それはしばしば BPE のような 部分単語トークン化アルゴリズムの最初のステップです)。

事前にトークン化された入力を使用することを望む場合、入力を tokenzier に渡すとき単に is_split_into_words=True を設定します。例えば、以下を持ちます :

encoded_input = tokenizer(["Hello", "I'm", "a", "single", "sentence"], is_split_into_words=True)
print(encoded_input)

{'input_ids': [101, 8667, 146, 112, 182, 170, 1423, 5650, 102],
 'token_type_ids': [0, 0, 0, 0, 0, 0, 0, 0, 0],
 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1]}

tokenizer は add_special_tokens=False を渡さない限り特殊トークンの id を (妥当な場合) 依然として追加することに注意してください。

これはセンテンスのバッチやセンテンスのペアのバッチのために前のように正確に動作します。センテンスのバッチをこのようにエンコードできます :

batch_sentences = [["Hello", "I'm", "a", "single", "sentence"],
                   ["And", "another", "sentence"],
                   ["And", "the", "very", "very", "last", "one"]]
encoded_inputs = tokenizer(batch_sentences, is_split_into_words=True)

あるいこのようにペア・センテンスのバッチ :

batch_of_second_sentences = [["I'm", "a", "sentence", "that", "goes", "with", "the", "first", "sentence"],
                             ["And", "I", "should", "be", "encoded", "with", "the", "second", "sentence"],
                             ["And", "I", "go", "with", "the", "very", "last", "one"]]
encoded_inputs = tokenizer(batch_sentences, batch_of_second_sentences, is_split_into_words=True)

そして前のようにパディング、切り捨てを追加できてそして直接 tensor を返すことができます :

batch = tokenizer(batch_sentences,
                  batch_of_second_sentences,
                  is_split_into_words=True,
                  padding=True,
                  truncation=True,
                  return_tensors="pt")

以上

HuggingFace Transformers 4.5 : 利用方法 : モデルの要点 (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 05/10/2021 (4.5.1)

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

• Using Transformers : Summary of the models

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

 

 

HuggingFace Transformers : 利用方法 : モデルの要点

これは Transformers で利用可能なモデルの要点です。元の transformer モデル に馴染みがあることを仮定しています。優しいイントロダクションのためには annotated transformer を確認してください。ここではモデル間の高位な違いにフォーカスします。それぞれのドキュメントでそれらをより詳細に調べることができます。各タイプのモデルと総ての コミュニティ・モデル のために利用可能なチェックポイントを見るために 事前訓練モデルページ を確認することもできます。

ライブラリのモデルの各一つは以下のカテゴリーの一つに分類されます :

• 自己回帰モデル
• オートエンコーダ・モデル
• sequence-to-sequence モデル
• マルチモーダル・モデル
• 検索ベースの (= Retrieval-based) モデル

自己回帰 (= autoregressive) モデルは古典的な言語モデリング・タスク上で事前訓練されています : 次のトークンを前の総てのものを読んだときに推測します。それらは元の transformer モデルのデコーダに相当し、そして attention ヘッドが後に何があるかではなく前に何があったかだけを見ることができるようにマスクが full センテンスの上で使用されます。これらのモデルは多くのタスク上で再調整されて素晴らしい結果を獲得できますが、最も自然な応用はテキスト生成です。そのようなモデルの典型的な例は GPT です。

※ 訳注: 自己回帰モデルはある時間ステップにおけるモデル出力がそれ以前のモデル出力に依存する確率過程です。

オートエンコーディング・モデルは入力トークンを何らかの方法で破損 (= corrupt) させて元のセンテンスを再構築することを試みることにより事前訓練されます。それらはどのようなマスクもなしで完全な入力にアクセスするという意味で元の transformer モデルのエンコーダに対応します。それらのモデルは通常はセンテンス全体の双方向表現を構築します。それらはテキスト生成のような多くのタスク上で再調整されて素晴らしい結果を獲得できますが、それらの最も自然な応用はセンテンス分類やトークン分類です。そのようなモデルの典型的な例は BERT です。

自己回帰モデルとオートエンコーディング・モデルの唯一の違いはモデルが事前訓練される方法にある ことに注意してください。従って自己回帰とオートエンコーディング・モデルの両者のために同じアーキテクチャが利用できます。与えられたモデルが両者のタイプの事前訓練のために使用されたとき、それが最初に紹介された記事に対応するカテゴリーにそれを入れます。

sequence-to-sequence モデルは、翻訳タスクのためか他のタスクを sequence-to-sequence 問題に変換することにより、元の transformer のエンコーダとデコーダの両者を利用します。それらは多くのタスクに再調整できますが、それらの最も自然な応用は翻訳、要約そして質問応答です。元の transformer モデルは (翻訳のためだけの) そのようなモデルの例で、T5 は他のタスク上で再調整できる例です。

マルチモーダル (多様性)・モデルはテキスト入力を他の種類 (e.g. 画像) と混在させてそして与えられたタスクに対してより固有です。

 

自己回帰モデル

前に言及したように、これらのモデルは元の transformer のデコーダ部に依拠していて各位置でモデルが attention ヘッドの前のトークンだけを見れるように attention マスクを利用します。

 

Original GPT

• All モデルページ : openai-gpt (1) ; モデル文書 : openai-gpt
• Improving Language Understanding by Generative Pre-Training, Alec Radford et al.
  (生成的事前訓練による言語理解の改良)

transformer アーキテクチャに基づく最初の自己回帰モデルです、Book Corpus データセット上で事前訓練されました。

このライブラリは言語モデリングとマルチタスク言語モデリング/多肢選択式分類のためのモデルのバージョンを提供します。

 

GPT-2

• All モデルページ : gpt2 (2,131) ; モデル文書 : gpt2
• Language Models are Unsupervised Multitask Learners, Alec Radford et al.
  (言語モデルは教師なしマルチタスク学習者)

GPT のより大きくてより良いバージョンです、WebText 上で事前訓練されました (3 karma 以上の Reddit の outgoing リンクからの web ページ)。

このライブラリは言語モデリングとマルチタスク言語モデリング/多肢選択式分類のためのモデルのバージョンを提供します。

 

CTRL

• All モデルページ : ctrl (14) ; モデル文書 : ctrl
• CTRL: A Conditional Transformer Language Model for Controllable Generation, Nitish Shirish Keskar et al.
  (CTRL : 制御可能な生成のための条件付き Transformer 言語モデル)

GPT モデルと同じですが、制御コードのアイデアを追加しています。テキストは prompt (empty であり得ます) とテキスト生成に影響を与えるために使用される制御コードの一つ (or 幾つか) から生成されます : wikipedia 記事、本や映画レビューのスタイルで生成します。

このライブラリは言語モデリングのためのモデルのバージョンだけを提供します。

 

Transformer-XL

• All モデルページ : transfo-xl (1) ; モデル文書 : transfo-xl
• Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context, Zihang Dai et al.
  (Transformer-XL: 固定長コンテキストを越える注意深い言語モデル)

通常の GPT モデルと同じですが、2 つの連続するセグメントに対してリカレンス機構を導入します (2 つの連続する入力を持つ通常の RNN に類似しています)。このコンテキストでは、セグメントは数多くの連続するトークン (例えば 512) で、これは複数のドキュメントに渡って広がるかもしれません、そしてセグメントは順番にモデルに供給されます。

基本的には、前のセグメントの隠れ状態は attention スコアを計算するために現在の入力に結合されます。これはモデルに現在のセグメントに加えて前のセグメント内の情報に注意を払うことを許容します。マルチ attention 層をスタックすることにより、受容野 (= receptive field) は複数の前のセグメントに増加できます。

これは位置埋め込みを位置相対的 (= relative) 埋め込みに変更します、(何故ならば通常の位置埋め込みは与えられた位置で現在の入力と現在の隠れ状態の同じ結果を与えるからです) そして attention スコアが計算される方法で何某かの調整を行なう必要があります。

このライブラリは言語モデリングのためのモデルのバージョンだけを提供します。

 

Reformer

• All モデルページ : reformer (4) ; モデル文書 : reformer
• Reformer: The Efficient Transformer, Nikita Kitaev et al .
  (Reformer : 効率的な Transformer)

メモリ使用量と計算時間を削減するために多くのトリックを持つ自己回帰 transformer モデルです。これらのトリックは以下を含みます :

• axial (軸の) 位置エンコーディング を使用します (より詳細は下を見てください)。それは (シークエンス長が非常に大きいとき) 巨大な位置エンコーディング行列を持つことをそれをより小さい行列に分解することにより回避する機構です。
• 伝統的な attention を LSH (local-sensitive hashing) attention により置き換えます (より詳細は下を見てください)。それは attention 層で full 積 query-key を計算することを回避するテクニックです。
• 各層の中間結果をストアすることを、backward パスの間にそれらを得るために可逆な (= reversible) transformer 層を使用するか (次の層の入力から残差を減算することはそれらを与え戻します)、与えられた層内で結果のためにそれらを再計算することにより (それらをストアするよりも非効率的ですがメモリを節約します) 回避します。
• バッチ全体上ではなく chunks により feedforward 演算を計算します。

これらのトリックで、モデルは伝統的な transformer 自己回帰モデルよりも遥かに大きなセンテンスが供給できます。

Note: このモデルはオートエンコーディング設定で非常に上手く利用できるでしょう、けれどもそのような事前訓練のためのチェックポイントはまだありません。

このライブラリは言語モデリングのためのモデルのバージョンだけを提供します。

 

XLNet

• All モデルページ : xlnet (50) ; モデル文書 : xlnet
• XLNet: Generalized Autoregressive Pretraining for Language Understanding, Zhilin Yang et al.
  (XLNet: 言語理解のための一般化された自己回帰事前訓練)

XLNet は伝統的な自己回帰モデルではありませんが、その上で構築される訓練ストラテジーを利用します。それはセンテンスのトークンを並べ替えて (= permute) から、トークン n+1 を予測するために最後の n トークン(s) を使用することをモデルに許容します。これはマスクで成されますので、センテンスは実際には正しい順序でモデルに供給されますが、n+1 のために最初の n トークンをマスクする代わりに、XLNet は 1,…,シークエンス長のある与えられた並べ替え (= permutation) 内の前のトークンを隠すマスクを使用します。

XLNet はまた長期依存性を構築するために Transformer-XL と同じリカレンス機構も利用します。

このライブラリは言語モデリング、トークン分類、センテンス分類、マルチ選択分類と質問応答のためのモデルのバージョンを提供します。

 

オートエンコーディング・モデル

前に言及したように、これらのモデルは元の transformer のエンコーダ部に依拠していてマスクは使用しませんのでモデルは attention ヘッドで総てのトークンを見ることができます。事前訓練については、ターゲットは元のセンテンスで入力はそれらの破損バージョンです。

 

BERT

• All モデルページ : bert (1,351) ; モデル文書 : bert
• BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding, Jacob Devlin et al.
  (BERT: 言語理解のための深層双方向 Transformer の事前訓練)

ランダム・マスキングを使用して入力を破損させます、より正確には、事前訓練の間、トークンの与えられたパーセンテージ (通常は 15%) が以下によりマスクされます :

• 確率 0.8 で特別なマスクトークン
• 確率 0.1 でマスクされたものとは異なるランダムトークン
• 確率 0.1 で同じトークン

モデルは元のセンテンスを予測しなければなりませんが、2 番目の目的を持ちます : 入力は 2 つのセンテンス A と B です (間には分離トークンを伴います)。確率 50% で、センテンスはコーパス内で連続的です、残りの 50% でそれらは関係ありません。モデルはセンテンスが連続的か否かを予測しなければなりません。

このライブラリは言語モデリング (伝統的 or マスク付き)、次文 (= next sentence) 予測、トークン分類、センテンス分類、多肢選択式分類と質問応答のためのモデルのバージョンを提供します。

 

ALBERT

• All モデルページ : albert (132) ; モデル文書 : albert
• ALBERT: A Lite BERT for Self-supervised Learning of Language Representations, Zhenzhong Lan et al.
  (ALBERT : 言語表現の自己教師あり学習のための軽量 BERT)

BERT と同じですが 2, 3 の微調整を伴います :

• 埋め込みサイズ E は理にかなった隠れサイズ H とは異なります、何故ならば埋め込みはコンテキスト独立である (一つの埋め込みベクトルは一つのトークンを表します) 一方で、隠れ状態はコンテキスト依存である (一つの隠れ状態はトークンのシークエンスを表します) からです、従って H >> E を持つことはより論理的です。また、埋め込み行列は巨大です、何故ならばそれは V x E (V は vocab サイズ) であるからです。E < H であれば、それはより少ないパラメータを持ちます。
• 層は (メモリを節約するために) パラメータを共有するグループに分割されます。
• 次文予測はセンテンス順序予測に置き換えられます : 入力では、2 つのセンテンス A と B を持ち (それらは連続的です) A に続いて B か B に続いて A のいずれかを供給します。モデルはそれらが交換されているか否かを予測しなければなりません。

このライブラリはマスク付き言語モデリング、トークン分類、センテンス分類、多肢選択式分類と質問応答のためのモデルのバージョンを提供します。

 

RoBERTa

• All モデルページ : roberta (516) ; モデル文書 : roberta
• RoBERTa: A Robustly Optimized BERT Pretraining Approach, Yinhan Liu et al.
  (RoBERTa: 堅固に最適化された BERT 事前訓練アプローチ)

BERT と同じですが以下のより良い事前訓練トリックを持ちます :

• 動的マスキング : トークンは各エポックで異なってマスクされます、その一方で BERT はそれを一度限り行ないます。
• NSP (次文予測) 損失はなくそして単に 2 センテンスを一緒に置く代わりに、512 トークンに達するまで連続するテキストのチャンクを一緒にまとめます (従ってセンテンスは幾つかのドキュメントに渡るかもしれない順番どおりです)。
• より大規模なバッチで訓練します。
• サブユニットとして文字ではなくバイトを持つ BPE を使用します (ユニコード文字ゆえに)。

このライブラリはマスク付き言語モデリング、トークン分類、センテンス分類、多肢選択式分類と質問応答のためのモデルのバージョンを提供します。

 

DistilBERT

• All モデルページ : distilbert (169) ; モデル文書 : distilbert
• DistilBERT, a distilled version of BERT: smaller, faster, cheaper and lighter, Victor Sanh et al.
  (DistilBERT, BERT の蒸留されたバージョン: より小さく、高速で、低コストでそして軽い)

BERT と同じですがより小さいです。事前訓練された BERT モデルの蒸留により訓練されます、より大きいモデルと同じ確率を予測するために訓練されたことを意味します。実際の目的は以下の組合せです :

• 教師モデルと同じ確率を見つける
• マスクされたトークンを正しく予測する (しかし次文目的ではない)
• 生徒と教師モデルの隠れ状態の間の cos 類似度

このライブラリはマスク付き言語モデリング、トークン分類、センテンス分類と質問応答のためのモデルのバージョンを提供します。

 

ConvBERT

• All モデルページ : convbert (10) ; モデル文書 : convbert
• ConvBERT: Improving BERT with Span-based Dynamic Convolution, Zihang Jiang, Weihao Yu, Daquan Zhou, Yunpeng Chen, Jiashi Feng, Shuicheng Yan.
  (ConvBERT : Span ベースの動的畳込みによる BERT の改良)

BERT とその変種のような事前訓練言語モデルは最近様々な自然言語理解タスクで印象的なパフォーマンスを獲得しています。けれども、 BERT はグローバル自己 attention ブロックに大きく依拠しているため大きなメモリ消費量と計算コストがかかります。総ての attention ヘッドはグローバル視点から attention マップを生成するために入力シークエンス全体の上で問い合わせをしますが、幾つかのヘッドはローカル依存性を学習する必要があるだけであることを観察します、これは計算の冗長性の存在を意味します。そこでローカル依存性を直接モデル化するためにこれらの自己 attention ヘッドを置き換える新しい span ベースの動的畳込みを提案します。新しい畳込みヘッドは、残りの自己 attention ヘッドと一緒に、新しい混合 attention ブロックを形成します、これはグローバルとローカル・コンテキスト学習の両者でより効率的です。この混合 attention 設計を BERT に装備して ConvBERT モデルを構築します。より低い訓練コストとより少ないモデルパラメータで、ConvBERT は様々な下流タスクで BERT とその変種のパフォーマンスを本質的に越えることを実験は示しました。驚くべきことに、ConvBERTbase モデルは ELECTRAbase より 0.7 高い、86.4 GLUE スコアを獲得する一方で、1/4 の訓練コスト未満を使用しています。

このライブラリはマスク付き言語モデリング、トークン分類、センテンス分類と質問応答のためのモデルのバージョンを提供します。

 

XLM

• All モデルページ : xlm (14) ; モデル文書 : xlm
• Cross-lingual Language Model Pretraining, Guillaume Lample and Alexis Conneau
  (交差-lingual 言語モデル事前訓練)

幾つかの言語上で訓練された transformer モデルです。このモデルのための 3 つの異なるタイプの訓練がありそしてライブラリはそれらの総てのためのチェックポイントを提供します :

• 因果 (= Causal) 言語モデリング (CLM)、これは伝統的な自己回帰訓練です (従ってこのモデルは前のセクションにも入れるかもしれません)。各訓練サンプルのために言語の一つが選択され、そしてモデル入力は 256 トークンのセンテンスで、それらの言語の一つで幾つかのドキュメントに渡るかもしれません。
• マスク付き言語モデリング (MLM)、これは RoBERTa のようなものです。各訓練サンプルのために言語の一つが選択され、そしてモデル入力は 256 トークンのセンテンスで、トークンの動的マスクを用い、それらの言語の一つで幾つかのドキュメントに渡るかもしれません。
• MLM と翻訳言語モデリング (TLM) の組合せ。これはランダム・マスキングを伴い、 2 つの異なる言語のセンテンスを連結することから構成されます。マスクされたトークンの一つを予測するため、モデルは言語 1 の周囲のコンテキストと言語 2 で与えられるコンテキストの両者を利用できます。

チェックポイントはそれらの名前で clm, mlm or mlm-tlm を持つことにより事前訓練のためにどの方法が利用されたかを参照します。位置埋め込みの上にモデルは言語埋め込みを持ちます。MLM/CLM を使用して訓練するとき、これは使用される言語の指示 を、そして MLM+TLM を使用して訓練するとき、各パートのために使用される言語の指示をモデルに与えます。

このライブラリは言語モデリング、トークン分類、センテンス分類と質問応答のためのモデルのバージョンを提供します。

 

XLM-RoBERTa

• All モデルページ : xml-roberta (193) ; モデル文書 : xml-roberta
• Unsupervised Cross-lingual Representation Learning at Scale, Alexis Conneau et al.
  (大規模な教師なし交差-lingual 表現学習)

XLM アプローチ上で RoBERTa トリックを利用しますが、翻訳言語モデリング目的は利用しません。それは一つの言語からのセンテンス上のマスク付き言語モデリングだけを使用します。けれども、モデルはより多くの言語 (100) 上で訓練されて言語埋め込みは使用しませんので、入力言語を自身で検出することができます。

このライブラリはマスク付き言語モデリング、トークン分類、センテンス分類、多肢選択式分類と質問応答のためのモデルのバージョンを提供します。

 

FlauBERT

• All モデルページ : flaubert (13) ; モデル文書 : flaubert
• FlauBERT: Unsupervised Language Model Pre-training for French, Hang Le et al.
  (FlauBERT: フランス語のための教師なし言語モデル事前訓練)

RoBERTa のように、センテンス順序予測はありません (従って単に MLB 目的の上で訓練されます)。

このライブラリはマスク付き言語モデリングとセンテンス分類のためのモデルのバージョンを提供します。

 

ELECTRA

• All モデルページ : electra (318) ; モデル文書 : electra
• ELECTRA: Pre-training Text Encoders as Discriminators Rather Than Generators, Kevin Clark et al.
  (ELECTRA: Generator ではなく Discriminator としてテキストエンコーダを事前訓練する)

ELECTRA は別の (小さい) マスク付き言語モデルの使用で事前訓練される transformer モデルです。入力はその言語モデルにより破損されます、それはランダムにマスクされた入力テキストを取りそしてテキストを出力します、その (出力) テキストでは ELECTRA はどのトークンが元のものでありどれが置き換えられたかを予測しなければなりません。GAN 訓練のためのように、その小さい言語モデルは数ステップの間訓練されてから (しかし目的としての元のテキストで、伝統的な GAN 設定でのように ELECTRA モデルを騙したりはしません)、ELECTRA モデルが数ステップの間訓練されます。

このライブラリはマスク付き言語モデリング、トークン分類、センテンス分類のためのモデルのバージョンを提供します。

 

Funnel Transformer

• All モデルページ : funnel (17) ; モデル文書 : funnel
• Funnel-Transformer: Filtering out Sequential Redundancy for Efficient Language Processing, Zihang Dai et al.
  (Funnel-Transformer: 効率的な言語処理のためにシーケンシャルな冗長性をフィルタして除去する)

Funnel Transformer は pooling を使用する transformer モデルで、少し ResNet モデルのようです : 層はブロックでグループ分けされ、そして (最初の一つを除いて) 各ブロックの最初で、隠れ状態はシークエンス次元内でプーリングされます。この方法で、それらの長さは 2 で除算され、これは次の隠れ状態の計算をスピードアップします。総ての事前訓練モデルは 3 つのブロックを持ち、これは最後の隠れ状態は元のシークエンス長の 4 分の 1 のシークエンス長を持つことを意味します。

分類のようなタスクについては、これは問題ではありませんが、マスク付き言語モデリングやトークン分類のようなタスクについては、元の入力と同じシークエンス長を持つ隠れ状態を必要とします。それらの場合には、最後の隠れ状態は入力シークエンス長にアップサンプリングされて 2 つの追加層を通り抜けます。それが各チェックポイントの 2 つのバージョンがある理由です。“-base” でサフィックスされるバージョンは 3 つのブロックだけを含む一方で、そのサフィックスがないバージョンは 3 つのブロックとその追加層を持つアップサンプリング・ヘッドを含みます。

利用可能な事前訓練モデルは ELECTRA と同じ事前訓練目的を使用しています。

このライブラリはマスク付き言語モデリング、トークン分類、センテンス分類、多肢選択式分類と質問応答のためのモデルのバージョンを提供します。

 

Longformer

• All モデルページ : longformer (25) ; モデル文書 : longformer
• Longformer: The Long-Document Transformer, Iz Beltagy et al.
  (Longformer: 長いドキュメント Transformer)

高速にするために attention 行列をスパース行列に置き換えた transformer モデルです。しばしば、ローカル・コンテキスト (e.g. 左右の 2 つのトークンは何でしょう？) は与えられたトークンに対してアクションするために十分です。ある事前選択された入力トークンには依然として global attention が与えられますが、attention 行列はよりパラメータが少ない方法を持ち、スピードアップという結果になります。より多くの情報については ローカル attention セクション を見てください。

その他は RoBERTa と同じ方法で事前訓練されます。

Note: このモデルは自己回帰設定で非常に上手く利用できるでしょう、けれどもそのような事前訓練のためのチェックポイントはまだありません。

このライブラリはマスク付き言語モデリング、トークン分類、センテンス分類、多肢選択式分類と質問応答のためのモデルのバージョンを提供します。

 

Sequence-to-sequence モデル

前に言及したように、これらのモデルは元の transformer のエンコーダとデコーダの両者を保持しています。

 

BART

• All モデルページ : bart (140) ; モデル文書 : bart
• BART: Denoising Sequence-to-Sequence Pre-training for Natural Language Generation, Translation, and Comprehension, Mike Lewis et al.
  (BART: 自然言語生成、翻訳と理解のための Sequence-to-Sequence 事前訓練をノイズ除去する)

エンコーダとデコーダを持つ sequence-to-sequence モデル。エンコーダはトークンの破損バージョンが供給され、デコーダは元のトークンが供給されます (しかし通常の transformer デコーダのように未来の単語を隠すマスクを持ちます)。エンコーダについては、事前訓練タスク上、以下の変換の組合せが適用されます :

• ランダムにトークンをマスクします (BERT のように)
• ランダムにトークンを削除します
• 単一のマスクトークンで k トークンの範囲をマスクします (0 トークンのスパンはマスクトークンの挿入です)
• センテンスを並べ替える
• 特定のトークンで開始されるようにドキュメントを rotate します

このライブラリは条件付き生成とシークエンス分類ためのモデルのバージョンを提供します。

 

Pegasus

• All モデルページ : pegasus (34) ; モデル文書 : pegasus
• PEGASUS: Pre-training with Extracted Gap-sentences for Abstractive Summarization, Jingqing Zhang, Yao Zhao, Mohammad Saleh and Peter J. Liu on Dec 18, 2019.
  (生成型要約のための抽出された Gap-センテンスによる事前訓練)

BART と同じエンコーダ・デコーダモデルを持つ sequence-to-sequence モデルです。Pegasus は 2 つの自己教師あり目的関数上で同時に事前訓練されます : マスク付き言語モデリング (MLM) と Gap センテンス生成 (GSG, Gap Sentence Generation) と呼称される、新しい要約固有の事前訓練目的です。

• MLM: エンコーダ入力トークンはマスクトークンによりランダムに置き換えられてエンコーダにより予測されなければなりません (BERT のように)。
• GSG: エンコーダ入力センテンス全体が 2 番目のマスクトークンにより置き換えられてデコーダに供給されますが、それは通常の自己回帰 transformer デコーダのように未来の単語を隠すために因果マスクを持ちます。

BART と対照的に、Pegasus の事前訓練タスクは意図的に要約に類似しています : 重要なセンテンスはマスクされて残りのセンテンスから一つの出力センテンスとして一緒に生成されます、抽出型要約に類似しています。

このライブラリは要約のために使用されるべき条件付き生成のためのモデルのバージョンを提供します。

 

MarianMT

• All モデルページ : marian (1,354) ; モデル文書 : marian
• Marian: Fast Neural Machine Translation in C++, Marcin Junczys-Dowmunt et al.
  (Marian: C++ の高速なニューラル機械翻訳)

翻訳モデルのためのフレームワークです、BART と同じモデルを使用しています。

このライブラリは条件付き生成のためのモデルのバージョンを提供します。

 

T5

• All モデルページ : t5 (630) ; モデル文書 : t5
• Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer, Colin Raffel et al.
  (統一されたテキスト-to-テキスト Transformer による転移学習の限界の探求)

伝統的な transformer モデルを使用します (位置埋め込みで僅かな変更を伴います、これは各層で学習されます)。総ての NLP タスク上で動作できるように、それは特定のプレフィックスを使用することによりそれらをテキスト-to-テキスト問題に変換します : “summarize: ”, “question: ”, “translate English to German: ” 等々。

事前訓練は教師ありと自己教師あり訓練の両者を含みます。教師あり訓練は GLUE と SuperGLUE ベンチマークにより提供される下流タスク上で実行されます (それらを上で説明されたように text-to-text タスクに変換します)。

自己教師あり訓練はトークンの 15% をランダムに除去してそれらを個別の sentinel (見張り) トークンで置き換えることにより (もし幾つかの連続するトークンが除去のためにマークされる場合、グループ全体が単一の sentinel トークンで置き換えられます)、 破損トークンを利用します。エンコーダの入力は破損センテンスで、デコーダの入力は元のセンテンスでそれからターゲットは sentinel トークンで範囲が定められたドロップアウトされたトークンです。

例えば、センテンス “My dog is very cute .” を持ち、そしてトークン “dog”, “is” と “cute” を取り除くことを決めた場合、エンコーダ入力は “My <x> very <y> .” となりそしてターゲット入力は “<x> dog is <y> cute .<z>” になります。

このライブラリは条件付き生成のためのモデルのバージョンを提供します。

 

MT5

• All モデルページ : mt5 (62) ; モデル文書 : mt5
• mT5: A massively multilingual pre-trained text-to-text transformer, Linting Xue et al.
  (mT5: 大規模に多言語で事前訓練された text-to-text transformer)

モデル・アーキテクチャは T5 と同じです。mT5 の事前訓練目的は T5 の自己教師あり訓練を含みますが、T5 の教師あり訓練は含みません。mT5 は 101 言語上で訓練されています。

このライブラリは条件付き生成のためのモデルのバージョンを提供します。

 

MBart

• All モデルページ : mbart (46) ; モデル文書 : mbart
• Multilingual Denoising Pre-training for Neural Machine Translation by Yinhan Liu, Jiatao Gu, Naman Goyal, Xian Li, Sergey Edunov Marjan Ghazvininejad, Mike Lewis, Luke Zettlemoyer.
  (ニューラル機械翻訳のための多言語ノイズ除去事前訓練)

モデル・アーキテクチャと事前訓練目的は BART と同じですが、MBart は 25 言語上で訓練されてそして教師ありと教師なし機械翻訳が対象とされています。多言語の full テキストをノイズ除去することによる完全な sequence-to-sequence モデルを事前訓練するための最初の方法の一つです。

このライブラリは条件付き生成のためのモデルのバージョンを提供します。

mbart-large-en-ro チェックポイント は英語 -> ルーマニア語翻訳のために利用できます。

mbart-large-cc25 チェックポイントは `examples/seq2seq/` のコードを使用して、他の翻訳と要約タスクのために再調整できますが、再調整なしではそれほど有用ではありません。

 

ProphetNet

• All モデルページ : prophetnet (8) ; モデル文書 : prophetnet
• ProphetNet: Predicting Future N-gram for Sequence-to-Sequence Pre-training, by Yu Yan, Weizhen Qi, Yeyun Gong, Dayiheng Liu, Nan Duan, Jiusheng Chen, Ruofei Zhang, Ming Zhou.
  (ProphetNet: Sequence-to-Sequence 事前訓練のために未来 N-gram を予測する)

ProphetNet は未来 n-gram 予測と呼ばれる、新しい sequence-to-sequence 事前訓練目的を導入します。未来 n-gram 予測では、各時間ステップで前のコンテキスト・トークンに基づいてモデルは (単に単一の次のトークンの代わりに) 次の n トークンを同時に予測します。未来 n-gram 予測はモデルが未来のトークンのために計画して強い局所的な相関性の上で overfitting を回避することを促進します。モデル・アーキテクチャは元の Transformer に基づきますが、デコーダの「標準的な」自己 attention 機構を主要な自己 attention 機構と self と n-stream (predict) 自己attention 機構と置き換えます。

このライブラリは条件付き生成のためのモデルの事前訓練バージョンと要約のための再調整バージョンを提供します。

 

XLM-ProphetNet

• All モデルページ : xprophetnet (0) ; モデル文書 : xprophetnet
• ProphetNet: Predicting Future N-gram for Sequence-to-Sequence Pre-training, by Yu Yan, Weizhen Qi, Yeyun Gong, Dayiheng Liu, Nan Duan, Jiusheng Chen, Ruofei Zhang, Ming Zhou.
  (ProphetNet: Sequence-to-Sequence 事前訓練のために未来 N-gram を予測する)

XLM-ProphetNet のモデル・アーキテクチャと事前訓練目的 は ProphetNet と同じですが、XLM-ProphetNet は交差 lingual データセット XGLUE 上で事前訓練されました。

このライブラリは多言語条件付き生成のためのこのモデルの事前訓練バージョンとヘッドライン生成と質問生成のための再調整バージョンをそれぞれ提供します。

 

マルチモーダル・モデル

ライブラリには一つのマルチモーダル・モデルがあります、これは他のもののような自己教師あり流儀での事前訓練はされません。

 

MMBT

• Supervised Multimodal Bitransformers for Classifying Images and Text, Douwe Kiela et al.
  (画像とテキストを分類するための教師ありマルチモーダル Bitransformers)

マルチモーダル設定で使用される transformers モデルは、予測を行なうためにテキストと画像を連結します。transformer モデルは入力としてトークン化されたテキストの埋め込みと、画像上で事前訓練された resnet の (resnet の最後の多くの特徴から transformer の隠れ状態次元へ通り抜けるための) 線形層を通り抜けた (最後のプーリング層の後の) 最後の活性を取ります。

異なる入力は連結されて、そして位置埋め込みの上に入力ベクトルのどの部分がテキストに対応してどれが画像に対応するかをモデルに知らせるためにセグメント埋め込みが追加されます。

事前訓練モデルは分類のためだけに動作します。

 

Retrieval-based (検索ベース) モデル

幾つかのモデルは、例えばオープンドメインの質問応答のために (事前) 訓練と推論の間にドキュメント検索を利用します。

 

DPR

• All モデルページ : dpr (28) ; モデル文書 : dpr
• Dense Passage Retrieval for Open-Domain Question Answering, Vladimir Karpukhin et al.
  (オープンドメイン質問応答のための Dense Passage 検索)

Dense Passage Retrieval (DPR) – 最先端のオープンドメイン質問応答研究のためのツールとモデルのセットです。

DPR は 3 つのモデルにあります :

• 質問エンコーダ : 質問をベクトルとしてエンコードする
• コンテキスト・エンコーダ : コンテキストをベクトルとしてエンコードする
• リーダー (= Reader) : 関連 (= relevance) スコア (推論された span が実際に質問に答える場合に高い) とともに、検索されたコンテキスト内から質問の答えを抽出する。

DPR のパイプラインはある質問が与えられたときに top k コンテキストを見つけるために検索ステップを使用し、それからそれは回答を得るために質問と検索されたドキュメントとともにリーダーを呼び出します。

 

RAG

• All モデルページ : rag (7) ; モデル文書 : rag
• Retrieval-Augmented Generation for Knowledge-Intensive NLP Tasks, Patrick Lewis, Ethan Perez, Aleksandara Piktus, Fabio Petroni, Vladimir Karpukhin, Naman Goyal, Heinrich Küttler, Mike Lewis, Wen-tau Yih, Tim Rocktäschel, Sebastian Riedel, Douwe Kiela
  (知識集約型 NLP タスクのための Retrieval-Augmented 生成)

Retrieval-augmented 生成 (“RAG”) モデルは事前訓練 dense retrieval (DPR) と Seq2Seq モデルのパワーを結合しています。RAG モデルは docs を取得し、それらを seq2seq モデルに渡してから、出力を生成するために周辺化します。下流タスクに適応するために取得と生成の両者を許容するために、retriever と seq2seq モジュールは事前訓練モデルから初期化され、同時に再調整されます。

2 つのモデル RAG-Token と RAG-Sequence は生成のために利用可能です。

以上

HuggingFace Transformers 4.5 : 利用方法 : タスクの要点 (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 05/06/2021 (4.5.1)

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

• Using Transformers : Summary of the tasks

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

 

 

HuggingFace Transformers : 利用方法 : タスクの要点

• 訳注 : 本ドキュメントの TensorFlow バージョンは こちら をご覧ください。

このページはライブラリを利用するとき最も頻度の高いユースケースを示します。利用可能なモデルはユースケースで多くの異なる configuration と素晴らしい多用途性を可能にします。最も単純なものはここで提示され、質問応答、シークエンス分類、固有表現認識などのようなタスクのための使用方法が紹介されます。

これらのサンプルは自動モデル (= auto-models) を活用します、これらは与えられたチェックポイントに従ってモデルをインスタンス化するクラスで、正しいモデル・アーキテクチャを自動的に選択します。より多くの情報のためには AutoModel ドキュメントを確認してください。より特定的にそしてそれを貴方の特定のユースケースに適応させるために自由にコードを変更してください。

モデルがタスク上で上手く動作するため、それはタスクに対応するチェックポイントからロードされなければなりません。これらのチェックポイントは通常は巨大なデータのコーパス上で事前訓練されて特定のタスク上で再調整されます。これは以下を意味しています :

• 総てのモデルが総てのタスク上で再調整されてはいません。特定のタスク上でモデルを再調整することを望む場合には、examples ディレクトリの run_$TASK.py スクリプトの一つを利用できます。
• 再調整モデルは特定のデータセット上で再調整されました。このデータセットは貴方のユースケースとドメインと重なるかもしれないしそうでないかもしれません。前に述べたように、貴方のモデルを再調整するために examples スクリプトを利用しても良いですし、あるいは貴方自身の訓練スクリプトを作成しても良いです。

タスク上で推論を行なうため、幾つかのメカニズムがライブラリにより利用可能になっています :

• Pipeline : 非常に利用しやすい抽象で、これらは 2 行ほどの少ないコードを必要とするだけです。
• 直接モデル利用 : 抽象度は低いですが、tokenizer (PyTorch/TensorFlow) への直接アクセスと full 推論機能を通してより多くの柔軟性とパワーがあります。

両者のアプローチがここで紹介されます。

Note: ここで提示される総てのタスクは特定のタスク上で再調整された事前訓練 (された) チェックポイントを利用しています。特定のタスク上で再調整されていないチェックポイントのロードはそのタスクのために使用された追加のヘッドではなく base transformer 層だけをロードして、ヘッドの重みをランダムに初期化します。

これはランダム出力を生成します。

 

シークエンス分類

シークエンス分類は与えられたクラス数に従ってシークエンスを分類するタスクです。シークエンス分類のサンプルは GLUE データセットで、これはそのタスクに完全に基づいています。GLUE 分類タスク上でモデルを再調整したいのであれば、run_glue.py, run_tf_glue.py, run_tf_text_classification.py または run_xnli.py スクリプトを利用して良いです。

ここにセンチメント分析を行なうために pipeline を使用するサンプルがあります : シークエンスがポジティブかネガティブかを識別します。それは sst2 上で再調整したモデルを利用します、これは GLUE タスクです。

これは次のように、スコアとともにラベル (“POSITIVE” or “NEGATIVE”) を返します :

from transformers import pipeline
nlp = pipeline("sentiment-analysis")
result = nlp("I hate you")[0]
print(f"label: {result['label']}, with score: {round(result['score'], 4)}")
result = nlp("I love you")[0]
print(f"label: {result['label']}, with score: {round(result['score'], 4)}")

label: NEGATIVE, with score: 0.9991
label: POSITIVE, with score: 0.9999

2 つのシークエンスが互いの言い換え (= paraphrase) であるかを決定するモデルを使用してシークエンス分類を行なうサンプルがここにあります。そのプロセスは以下です :

1. チェックポイント名から tokenizer とモデルをインスタンス化します。モデルは BERT モデルとして識別されてそれをチェックポイントにストアされた重みでロードします。
2. 正しいモデル固有の separator トークン型 id と attention マスクと共に 2 つのセンテンスからシークエンスを構築します (encode() と __call__() がこれを処理します)。
3. シークエンスをモデルに渡してその結果それは 2 つの利用可能なクラスの一つに分類されます : 0 (not a paraphrase) と 1 (is a paraphrase) 。
4. クラスに渡る確率を得るために結果の softmax を計算します。
5. 結果をプリントします。

from transformers import AutoTokenizer, AutoModelForSequenceClassification
import torch
tokenizer = AutoTokenizer.from_pretrained("bert-base-cased-finetuned-mrpc")
model = AutoModelForSequenceClassification.from_pretrained("bert-base-cased-finetuned-mrpc")
classes = ["not paraphrase", "is paraphrase"]
sequence_0 = "The company HuggingFace is based in New York City"
sequence_1 = "Apples are especially bad for your health"
sequence_2 = "HuggingFace's headquarters are situated in Manhattan"
paraphrase = tokenizer(sequence_0, sequence_2, return_tensors="pt")
not_paraphrase = tokenizer(sequence_0, sequence_1, return_tensors="pt")
paraphrase_classification_logits = model(**paraphrase).logits
not_paraphrase_classification_logits = model(**not_paraphrase).logits
paraphrase_results = torch.softmax(paraphrase_classification_logits, dim=1).tolist()[0]
not_paraphrase_results = torch.softmax(not_paraphrase_classification_logits, dim=1).tolist()[0]
# Should be paraphrase
for i in range(len(classes)):
    print(f"{classes[i]}: {int(round(paraphrase_results[i] * 100))}%")
# Should not be paraphrase
for i in range(len(classes)):
    print(f"{classes[i]}: {int(round(not_paraphrase_results[i] * 100))}%")

not paraphrase: 10%
is paraphrase: 90%

not paraphrase: 94%
is paraphrase: 6%

 

Extractive 質問応答

Extractive (抽出可能な) 質問応答は質問が与えられたときテキストから答えを抽出するタスクです。質問応答データセットの例は SQuAD データセットで、これはこのタスクに完全に基づいています。モデルを SQuAD タスク上で再調整したいのであれば、run_qa.py と run_tf_squad.py スクリプトを利用して良いです。

ここに質問応答を行なう pipeline を使用するサンプルがあります : 質問が与えられたときテキストから答えを抽出します。それは SQuAD 上で再調整されたモデルを利用します。

from transformers import pipeline
nlp = pipeline("question-answering")
context = r"""
Extractive Question Answering is the task of extracting an answer from a text given a question. An example of a
question answering dataset is the SQuAD dataset, which is entirely based on that task. If you would like to fine-tune
a model on a SQuAD task, you may leverage the examples/question-answering/run_squad.py script.
"""

これはテキストから抽出された答え、信頼度スコアを “start” と “end” 値と一緒に返します、これらはテキストの抽出された答えの位置です。

result = nlp(question="What is extractive question answering?", context=context)
print(f"Answer: '{result['answer']}', score: {round(result['score'], 4)}, start: {result['start']}, end: {result['end']}")
result = nlp(question="What is a good example of a question answering dataset?", context=context)
print(f"Answer: '{result['answer']}', score: {round(result['score'], 4)}, start: {result['start']}, end: {result['end']}")

Answer: 'the task of extracting an answer from a text given a question.', score: 0.6226, start: 34, end: 96
Answer: 'SQuAD dataset,', score: 0.5053, start: 147, end: 161

ここにモデルと tokenizer を使用した質問応答のサンプルがあります。プロセスは以下のようなものです :

1. チェックポイント名から tokenizer とモデルをインスタンス化します。モデルは BERT モデルとして識別されそしてそれをチェックポイントにストアされた重みでロードします。
2. テキストと幾つかの質問を定義します。
3. 質問に渡り反復してそして正しいモデル固有の separator トークン型 id と attention マスクで、テキストと現在の質問からシークエンスを構築します。
4. このシークエンスをモデルに渡します。これは開始と終了位置の両者のために、シークエンス・トークン全体 (質問とテキスト) に渡るスコアの範囲を出力します。
5. トークンに渡る確率を得るために結果の softmax を計算します。
6. 識別された開始と停止値からトークンを取得して、それらのトークンを文字列に変換します。
7. 結果をプリントします。

from transformers import AutoTokenizer, AutoModelForQuestionAnswering
import torch
tokenizer = AutoTokenizer.from_pretrained("bert-large-uncased-whole-word-masking-finetuned-squad")
model = AutoModelForQuestionAnswering.from_pretrained("bert-large-uncased-whole-word-masking-finetuned-squad")
text = r"""
🤗 Transformers (formerly known as pytorch-transformers and pytorch-pretrained-bert) provides general-purpose
architectures (BERT, GPT-2, RoBERTa, XLM, DistilBert, XLNet…) for Natural Language Understanding (NLU) and Natural
Language Generation (NLG) with over 32+ pretrained models in 100+ languages and deep interoperability between
TensorFlow 2.0 and PyTorch.
"""
questions = [
    "How many pretrained models are available in 🤗 Transformers?",
    "What does 🤗 Transformers provide?",
    "🤗 Transformers provides interoperability between which frameworks?",
]
for question in questions:
    inputs = tokenizer(question, text, add_special_tokens=True, return_tensors="pt")
    input_ids = inputs["input_ids"].tolist()[0]
    outputs = model(**inputs)
    answer_start_scores = outputs.start_logits
    answer_end_scores = outputs.end_logits
    answer_start = torch.argmax(
        answer_start_scores
    )  # Get the most likely beginning of answer with the argmax of the score
    answer_end = torch.argmax(answer_end_scores) + 1  # Get the most likely end of answer with the argmax of the score
    answer = tokenizer.convert_tokens_to_string(tokenizer.convert_ids_to_tokens(input_ids[answer_start:answer_end]))
    print(f"Question: {question}")
    print(f"Answer: {answer}")

Question: How many pretrained models are available in 🤗 Transformers?
Answer: over 32 +
Question: What does 🤗 Transformers provide?
Answer: general - purpose architectures
Question: 🤗 Transformers provides interoperability between which frameworks?
Answer: tensorflow 2 . 0 and pytorch

 

言語モデリング

言語モデリングはモデルをコーパスに適合させるタスク で、ドメイン固有である可能性があります。総てのポピュラーな transformer ベースのモデルは言語モデリングの変種で、e.g. masked 言語モデリングによる BERT、casual 言語モデリングによる GPT-2 を使用して訓練されます。

言語モデリングは事前訓練以外でも有用である可能性があります、例えばモデル分布をドメイン固有にシフトするためです :
非常に大規模なコーパスに渡り訓練された言語モデルを使用し、それを新しいニュース・データセットや科学論文 e.g. LysandreJik/arxiv-nlp に再調整します。

 

Masked 言語モデリング

masked 言語モデリングは masking トークンでシークエンスのトークンをマスクしてモデルに適切なトークンでそのマスクを満たすことを促すタスクです。これはモデルに右側のコンテキスト (マスクの右側のトークン) と左側のコンテキスト (マスクの左側のトークン) の両者に注意を払うことを可能にします。そのような訓練は、SQuAD のような (質問応答、Lewis, Lui, Goyal et al., part 4.2 参照) 双方向コンテキストを必要とするような下流タスクのための強力な基底を作成します。masked 言語モデリング・タスク上でモデルを再調整したい場合には、run_mlm.py スクリプトを活用して良いです。

ここにシークエンスからのマスクを置き換えるために pipeline を使用するサンプルがあります :

from transformers import pipeline
nlp = pipeline("fill-mask")

これはマスクが満たされたシークエンス、信頼度スコア、そして tokenizer 語彙のトークン id を出力します :

from pprint import pprint
pprint(nlp(f"HuggingFace is creating a {nlp.tokenizer.mask_token} that the community uses to solve NLP tasks."))

[{'score': 0.1792745739221573,
  'sequence': '<s>HuggingFace is creating a tool that the community uses to '
              'solve NLP tasks</s>',
  'token': 3944,
  'token_str': 'Ġtool'},
 {'score': 0.11349421739578247,
  'sequence': '<s>HuggingFace is creating a framework that the community uses '
              'to solve NLP tasks.</s>',
  'token': 7208,
  'token_str': 'Ġframework'},
 {'score': 0.05243554711341858,
  'sequence': '<s>HuggingFace is creating a library that the community uses to '
              'solve NLP tasks.</s>',
  'token': 5560,
  'token_str': 'Ġlibrary'},
 {'score': 0.03493533283472061,
  'sequence': '<s>HuggingFace is creating a database that the community uses '
              'to solve NLP tasks.</s>',
  'token': 8503,
  'token_str': 'Ġdatabase'},
 {'score': 0.02860250137746334,
  'sequence': '<s>HuggingFace is creating a prototype that the community uses '
              'to solve NLP tasks.</s>',
  'token': 17715,
  'token_str': 'Ġprototype'}]

ここにモデルと tokenizer を使用して masked 言語モデリングを行なうサンプルがあります。そのプロセスは以下です :

1. チェックポイント名から tokenizer とモデルをインスタンス化します。モデルは DistilBERT モデルとして識別されてチェックポイントにストアされている重みとともにそれをロードします。
2. 単語の代わりに tokenizer.mask_token を配置して、マスクされたトークンを持つシークエンスを定義します。
3. そのシークエンスを ID のリストにエンコードしてそのリスト内のマスクされたトークンの位置を見つけます。
4. マスク・トークンのインデックスにおける予測を取得します : この tensor は語彙と同じサイズを持ち、値は各トークンに帰するスコアです。モデルはそれがそのコンテキストで可能性が高いと判断するトークンにより高いスコアを与えます。
5. PyTorch topk or TensorFlow top_k メソッドを使用してトップ 5 のトークンを取得します。
6. マスク・トークンをトークンで置き換えて、結果をプリントします。

from transformers import AutoModelWithLMHead, AutoTokenizer
import torch
tokenizer = AutoTokenizer.from_pretrained("distilbert-base-cased")
model = AutoModelWithLMHead.from_pretrained("distilbert-base-cased")
sequence = f"Distilled models are smaller than the models they mimic. Using them instead of the large versions would help {tokenizer.mask_token} our carbon footprint."
input = tokenizer.encode(sequence, return_tensors="pt")
mask_token_index = torch.where(input == tokenizer.mask_token_id)[1]
token_logits = model(input).logits
mask_token_logits = token_logits[0, mask_token_index, :]
top_5_tokens = torch.topk(mask_token_logits, 5, dim=1).indices[0].tolist()

これはモデルにより予測された top 5 トークンを伴う 5 シークエンスをプリントします :

for token in top_5_tokens:
    print(sequence.replace(tokenizer.mask_token, tokenizer.decode([token])))

Distilled models are smaller than the models they mimic. Using them instead of the large versions would help reduce our carbon footprint.
Distilled models are smaller than the models they mimic. Using them instead of the large versions would help increase our carbon footprint.
Distilled models are smaller than the models they mimic. Using them instead of the large versions would help decrease our carbon footprint.
Distilled models are smaller than the models they mimic. Using them instead of the large versions would help offset our carbon footprint.
Distilled models are smaller than the models they mimic. Using them instead of the large versions would help improve our carbon footprint.

 

Causal 言語モデリング

Causal (因果) 言語モデリングはトークンのシークエンスに続くトークンを予測するタスクです。この状況では、モデルは左側のコンテキスト (マスクの左側のトークン) にのみ注意を払います。そのような訓練は生成タスクのための特に興味深いです。causal 言語モデリング・タスク上でモデルを再調整したい場合、run_clm.py スクリプトを活用して良いです。

通常、次のトークンは (モデルが入力シークエンスから生成する) 最後の隠れ状態のロジットからサンプリングすることにより予測されます。

ここに tokenizer とモデルを使用して (トークンの入力シークエンスに続く) 次のトークンをサンプリングするために top_k_top_p_filtering() メソッドを利用するサンプルがあります。

from transformers import AutoModelWithLMHead, AutoTokenizer, top_k_top_p_filtering
import torch
from torch.nn import functional as F
tokenizer = AutoTokenizer.from_pretrained("gpt2")
model = AutoModelWithLMHead.from_pretrained("gpt2")
sequence = f"Hugging Face is based in DUMBO, New York City, and"
input_ids = tokenizer.encode(sequence, return_tensors="pt")
# get logits of last hidden state
next_token_logits = model(input_ids).logits[:, -1, :]
# filter
filtered_next_token_logits = top_k_top_p_filtering(next_token_logits, top_k=50, top_p=1.0)
# sample
probs = F.softmax(filtered_next_token_logits, dim=-1)
next_token = torch.multinomial(probs, num_samples=1)
generated = torch.cat([input_ids, next_token], dim=-1)
resulting_string = tokenizer.decode(generated.tolist()[0])

これは元のシークエンスに続く (望ましくは) 首尾一貫した次のトークンを出力します、これは私達のケースでは単語 has です :

print(resulting_string)

Hugging Face is based in DUMBO, New York City, and has

次のセクションでは、この機能がユーザ定義の長さまで複数のトークンを生成するために generate() でどのように活用されるかを示します。

 

テキスト生成

テキスト生成 (a.k.a. open-ended テキスト生成) ではその目標は与えられたテキストからの継続であるテキストの首尾一貫した部分を作成することです。以下のサンプルは GPT-2 がテキストを生成するために pipeline でどのように使用されるかを示します。デフォルトでは総てのモデルはそれらに相当する configuration で設定されているように、pipeline で使用されるとき Top-K サンプリングを適用します (例えば gpt-2 config 参照)。

from transformers import pipeline
text_generator = pipeline("text-generation")
print(text_generator("As far as I am concerned, I will", max_length=50, do_sample=False))

[{'generated_text': 'As far as I am concerned, I will be the first to admit that I am not a fan of the idea of a "free market." I think that the idea of a free market is a bit of a stretch. I think that the idea'}]

ここでは、コンテキスト “As far as I am concerned, I will” からモデルは 50 トークンの合計最大長を持つランダムテキストを生成します。引数 max_length について上で示されたように、PreTrainedModel.generate() のデフォルト引数は pipeline() で直接 override できます。

ここに XLNet とその tokenizer を使用するテキスト生成のサンプルがあります。

from transformers import AutoModelWithLMHead, AutoTokenizer, top_k_top_p_filtering
import torch
from torch.nn import functional as F
tokenizer = AutoTokenizer.from_pretrained("gpt2")
model = AutoModelWithLMHead.from_pretrained("gpt2")
sequence = f"Hugging Face is based in DUMBO, New York City, and"
input_ids = tokenizer.encode(sequence, return_tensors="pt")
# get logits of last hidden state
next_token_logits = model(input_ids).logits[:, -1, :]
# filter
filtered_next_token_logits = top_k_top_p_filtering(next_token_logits, top_k=50, top_p=1.0)
# sample
probs = F.softmax(filtered_next_token_logits, dim=-1)
next_token = torch.multinomial(probs, num_samples=1)
generated = torch.cat([input_ids, next_token], dim=-1)
resulting_string = tokenizer.decode(generated.tolist()[0])

print(generated)

Today the weather is really nice and I am planning on anning on taking a nice...... of a great time!<eop>...............

テキスト生成は現在 PyTorch で GPT-2, OpenAi-GPT, CTRL, XLNet, Transfo-XL と Reformer で、そして殆どのモデルについて TensorFlow でも可能です。上のサンプルで見られるように XLNet と Transfo-XL は上手く動作するためにはしばしばパッドされる必要があります。open-ended テキスト生成のためには GPT-2 は通常は良い選択です、何故ならばそれは causal 言語モデリング目的で数百万の web ページで訓練されたからです。

テキスト生成のための異なるデコーディング・ストラテジーをどのように適用するかのより多くの情報については、ここ のテキスト生成ブログ投稿も参照してください。

 

固有表現認識

固有表現認識 (NER) は例えば人物、組織や位置としてトークンを識別するクラスに従ってトークンを分類するタスクです。固有表現認識データセットの例は CoNLL-2003 データセットで、これはそのタスクに完全に基づいています。NER タスク上でモデルを再調整したいのであれば、run_ner.py スクリプトを利用して良いです。

ここに固有表現認識を行なうために pipeline を使用するサンプルがあります、具体的には、トークンを 9 クラスの一つに属するものとして識別することを試みます :

• O, 固有表現外 (= Outside of a named entity)
• B-MIS, 別の雑多な (= miscellaneous) エンティティの直後の雑多なエンティティの開始
• I-MIS, 種々雑多なエンティティ
• B-PER, 別の人物名の直後の人物名の開始
• I-PER, 人物名
• B-ORG, 別の組織の直後の組織の開始
• I-ORG, 組織
• B-LOC, 別の場所の直後の場所の開始
• I-LOC, 場所

それは dbmdz からの @stefan-it により再調整された、CoNLL-2003 上の再調整モデルを利用します。

from transformers import pipeline
nlp = pipeline("ner")
sequence = "Hugging Face Inc. is a company based in New York City. Its headquarters are in DUMBO, therefore very"
           "close to the Manhattan Bridge which is visible from the window."

これは上で定義された 9 クラスからのエンティティの一つとして識別された総ての単語のリストを出力します。ここに想定される結果があります :

print(nlp(sequence))

[
    {'word': 'Hu', 'score': 0.9995632767677307, 'entity': 'I-ORG'},
    {'word': '##gging', 'score': 0.9915938973426819, 'entity': 'I-ORG'},
    {'word': 'Face', 'score': 0.9982671737670898, 'entity': 'I-ORG'},
    {'word': 'Inc', 'score': 0.9994403719902039, 'entity': 'I-ORG'},
    {'word': 'New', 'score': 0.9994346499443054, 'entity': 'I-LOC'},
    {'word': 'York', 'score': 0.9993270635604858, 'entity': 'I-LOC'},
    {'word': 'City', 'score': 0.9993864893913269, 'entity': 'I-LOC'},
    {'word': 'D', 'score': 0.9825621843338013, 'entity': 'I-LOC'},
    {'word': '##UM', 'score': 0.936983048915863, 'entity': 'I-LOC'},
    {'word': '##BO', 'score': 0.8987102508544922, 'entity': 'I-LOC'},
    {'word': 'Manhattan', 'score': 0.9758241176605225, 'entity': 'I-LOC'},
    {'word': 'Bridge', 'score': 0.990249514579773, 'entity': 'I-LOC'}
]

シークエンス “Hugging Face” のトークンがどのように組織として識別され、そして “New York City”, “DUMBO” と “Manhattan Bridge” が場所として識別されたかに注意してください。

モデルと tokenizer を使用する、固有表現認識を行なうサンプルがここにあります。そのプロセスは以下です :

1. チェックポイント名から tokenizer とモデルをインスタンス化します。モデルは BERT モデルとして識別されてチェックポイントにストアされた重みでそれをロードします。
2. その上でモデルが訓練されたラベルリストを定義します。
3. “Hugging Face” を組織として “New York City” を場所とするような、既知のエンティティでシークエンスを定義します。
4. 単語を予測にマップできるようにトークンに分解します。最初にシーケンスを完全にエンコードしてデコードすることにより小さいハックを利用します、その結果特殊トークンを含む文字列が残ります。
5. そのシークエンスを ID にエンコードします (特殊トークンが自動的に追加されます)。
6. 入力をモデルに渡して最初の出力を得ることにより予測を取得します。これは各トークンのための 9 の可能なクラスに渡る分布という結果になります。各トークンのための最尤クラスを得るために argmax を取ります。
7. 各トークンをその予測と一緒に zip してそれをプリントします。

from transformers import AutoModelForTokenClassification, AutoTokenizer
import torch
model = AutoModelForTokenClassification.from_pretrained("dbmdz/bert-large-cased-finetuned-conll03-english")
tokenizer = AutoTokenizer.from_pretrained("bert-base-cased")
label_list = [
    "O",       # Outside of a named entity
    "B-MISC",  # Beginning of a miscellaneous entity right after another miscellaneous entity
    "I-MISC",  # Miscellaneous entity
    "B-PER",   # Beginning of a person's name right after another person's name
    "I-PER",   # Person's name
    "B-ORG",   # Beginning of an organisation right after another organisation
    "I-ORG",   # Organisation
    "B-LOC",   # Beginning of a location right after another location
    "I-LOC"    # Location
]
sequence = "Hugging Face Inc. is a company based in New York City. Its headquarters are in DUMBO, therefore very" \
           "close to the Manhattan Bridge."
# Bit of a hack to get the tokens with the special tokens
tokens = tokenizer.tokenize(tokenizer.decode(tokenizer.encode(sequence)))
inputs = tokenizer.encode(sequence, return_tensors="pt")
outputs = model(inputs).logits
predictions = torch.argmax(outputs, dim=2)

これは対応する予測にマップされた各トークンのリストを出力します。pipeline とは異なり、ここでは総てのトークンは予測を持ちます、何故ならばそのトークンで特定のエンティティが見つからなかったことを意味する “0” th クラスを除去しないからです。次の配列は出力であるはずです :

print([(token, label_list[prediction]) for token, prediction in zip(tokens, predictions[0].numpy())])

[('[CLS]', 'O'), ('Hu', 'I-ORG'), ('##gging', 'I-ORG'), ('Face', 'I-ORG'), ('Inc', 'I-ORG'), ('.', 'O'), ('is', 'O'), ('a', 'O'), ('company', 'O'), ('based', 'O'), ('in', 'O'), ('New', 'I-LOC'), ('York', 'I-LOC'), ('City', 'I-LOC'), ('.', 'O'), ('Its', 'O'), ('headquarters', 'O'), ('are', 'O'), ('in', 'O'), ('D', 'I-LOC'), ('##UM', 'I-LOC'), ('##BO', 'I-LOC'), (',', 'O'), ('therefore', 'O'), ('very', 'O'), ('##c', 'O'), ('##lose', 'O'), ('to', 'O'), ('the', 'O'), ('Manhattan', 'I-LOC'), ('Bridge', 'I-LOC'), ('.', 'O'), ('[SEP]', 'O')]

 

要約

要約はドキュメントや記事をより短いテキストに要約するタスクです。要約タスク上でモデルを再調整したい場合には、run_summarization.py スクリプトを活用して良いです。

要約データセットの例は CNN / Daily Mail データセットで、これは長いニュース記事から成りそして要約タスクのために作成されました。モデルを要約タスクで再調整したい場合には、この ドキュメント で様々なアプローチが説明されています。

ここに要約を行なうためのパイプラインを使用する例があります。それは CNN / Daily Mail データセット上で再調整された Bart モデルを利用しています。

from transformers import pipeline
summarizer = pipeline("summarization")
ARTICLE = """ New York (CNN)When Liana Barrientos was 23 years old, she got married in Westchester County, New York.
A year later, she got married again in Westchester County, but to a different man and without divorcing her first husband.
Only 18 days after that marriage, she got hitched yet again. Then, Barrientos declared "I do" five more times, sometimes only within two weeks of each other.
In 2010, she married once more, this time in the Bronx. In an application for a marriage license, she stated it was her "first and only" marriage.
Barrientos, now 39, is facing two criminal counts of "offering a false instrument for filing in the first degree," referring to her false statements on the
2010 marriage license application, according to court documents.
Prosecutors said the marriages were part of an immigration scam.
On Friday, she pleaded not guilty at State Supreme Court in the Bronx, according to her attorney, Christopher Wright, who declined to comment further.
After leaving court, Barrientos was arrested and charged with theft of service and criminal trespass for allegedly sneaking into the New York subway through an emergency exit, said Detective
Annette Markowski, a police spokeswoman. In total, Barrientos has been married 10 times, with nine of her marriages occurring between 1999 and 2002.
All occurred either in Westchester County, Long Island, New Jersey or the Bronx. She is believed to still be married to four men, and at one time, she was married to eight men at once, prosecutors say.
Prosecutors said the immigration scam involved some of her husbands, who filed for permanent residence status shortly after the marriages.
Any divorces happened only after such filings were approved. It was unclear whether any of the men will be prosecuted.
The case was referred to the Bronx District Attorney\'s Office by Immigration and Customs Enforcement and the Department of Homeland Security\'s
Investigation Division. Seven of the men are from so-called "red-flagged" countries, including Egypt, Turkey, Georgia, Pakistan and Mali.
Her eighth husband, Rashid Rajput, was deported in 2006 to his native Pakistan after an investigation by the Joint Terrorism Task Force.
If convicted, Barrientos faces up to four years in prison.  Her next court appearance is scheduled for May 18.
"""

要約 pipeline は PretrainedModel.generate() メソッドに依拠していますので、下で示されるように pipeline の PretrainedModel.generate() のデフォルト引数を max_length と min_length のために直接 override することができます。これは次の要約を出力します :

print(summarizer(ARTICLE, max_length=130, min_length=30, do_sample=False))

[{'summary_text': 'Liana Barrientos, 39, is charged with two counts of "offering a false instrument for filing in the first degree" In total, she has been married 10 times, with nine of her marriages occurring between 1999 and 2002. She is believed to still be married to four men.'}]

モデルと tokenizer を使用する要約を行なうサンプルがここにあります。そのプロセスは以下です :

1. チェックポイント名から tokenzier とモデルをインスタンス化します。要約は通常は Bart or T5 のようなエンコーダ-デコーダ・モデルを使用して成されます。
2. 要約されるべき記事を定義します。
3. T5 固有の prefix “summarize: “ を追加します。
4. 要約を生成するために PretrainedModel.generate() メソッドを使用します。

このサンプルでは Google の T5 モデルを利用しています。それは (CNN / Daily Mail を含む) マルチタスク混合データセット上でだけ事前訓練されていますが、それは非常に良い結果を生成します。

from transformers import AutoModelWithLMHead, AutoTokenizer
model = AutoModelWithLMHead.from_pretrained("t5-base")
tokenizer = AutoTokenizer.from_pretrained("t5-base")
# T5 uses a max_length of 512 so we cut the article to 512 tokens.
inputs = tokenizer.encode("summarize: " + ARTICLE, return_tensors="pt", max_length=512)
outputs = model.generate(inputs, max_length=150, min_length=40, length_penalty=2.0, num_beams=4, early_stopping=True)

 

翻訳

翻訳は一つの言語から別のものへテキストを変換するタスクです。翻訳タスク上でモデルを再調整したい場合には、run_translation.py を活用して良いです。

翻訳データセットの例は WMT 英独データセットです、これは入力データとして英語のセンテンスをそしてターゲットデータとして独語のセンテンスを持ちます。翻訳タスク上でモデルを再調整したい場合には、様々なアプローチがこの ドキュメント で説明されます。

ここに翻訳を行なうための pipeline を使用するサンプルがあります。それは T5 モデルを利用しています、これは (WMT を含む) マルチタスク混合データセット上でのみ事前訓練されましたが、印象的な翻訳結果を生成します。

from transformers import pipeline
translator = pipeline("translation_en_to_de")
print(translator("Hugging Face is a technology company based in New York and Paris", max_length=40))

[{'translation_text': 'Hugging Face ist ein Technologieunternehmen mit Sitz in New York und Paris.'}]

翻訳 pipeline は PretrainedModel.generate() メソッドに依拠していますので、上で max_length のために示されたように pipeline で PretrainedModel.generate() のデフォルト引数を直接 override できます。

ここにモデルと tokenizer を使用して翻訳を行なうサンプルがあります。そのプロセスは以下です :

1. チェックポイント名から tokenizer とモデルをインスタンス化します。要約は通常は Bart or T5 のようなエンコーダ-デコーダ・モデルを使用して成されます。
2. 翻訳されるべきセンテンスを定義します。
3. T5 固有のプレフィックス “translate English to German: “ を追加します。
4. 翻訳を遂行するために PretrainedModel.generate() メソッドを使用します。

from transformers import AutoModelWithLMHead, AutoTokenizer
model = AutoModelWithLMHead.from_pretrained("t5-base")
tokenizer = AutoTokenizer.from_pretrained("t5-base")
inputs = tokenizer.encode("translate English to German: Hugging Face is a technology company based in New York and Paris", return_tensors="pt")
outputs = model.generate(inputs, max_length=40, num_beams=4, early_stopping=True)

pipeline サンプルでのように、同じ翻訳を得ます :

print(tokenizer.decode(outputs[0]))

Hugging Face ist ein Technologieunternehmen mit Sitz in New York und Paris.

以上

HuggingFace Transformers 4.5 : Gettiing Started : 用語集 (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 05/06/2021 (4.5.1)

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

• Gettiing Started : Glossary

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

 

 

HuggingFace Transformers : Gettiing Started : 用語集

一般用語

• autoencoding モデル : MLM 参照
  

• autoregressive モデル : CLM 参照
  

• CLM : 因果 (= causal) 言語モデリング、モデルがテキストを順番に読みそして次の単語を予測しなければならない事前訓練タスクです。それは通常はセンテンス全体を読むことにより成されますが、特定の時間ステップで未来のトークンを隠すためにモデル内のマスクを使用します。
  

• 深層学習 : 幾つかの層を持つニューラルネットワークを使用する機械学習アルゴリズム
  

• MLM : masked 言語モデリング、モデルは (通常は幾つかのトークンをランダムにマスクすることにより成される) テキストの破損した (= corrupted) バージョンを見て、元のテキストを予測しなければならない事前訓練タスクです。
  

• multimodal (多様性) : テキストと別の種類の入力 (例えば画像) を結合するタスク。
  

• NLG: 自然言語生成 (= generation)、テキスト生成に関連する総てのタスク (例えば transformer と話す、翻訳)。
  

• NLP : 自然言語処理、「テキストを処理する」と言うための一般的な方法です。
  

• NLU : 自然言語理解 (= understanding)、テキスト内にあるものの理解に関連する総てのタスク (例えばテキスト全体、個々の単語の分類)。
  

• 事前訓練モデル : あるデータ上で事前訓練されたモデル (例えば総ての Wikipedia)。事前訓練方法は自己教師あり目的を含みます、これはテキストを読んで次の単語を予測しようとする (CLM 参照) か、幾つかの単語をマスクしてそれらを予測しようとすることであり得ます (MLM 参照)。
  

• RNN : リカレント・ニューラルネットワーク、テキストを処理するために層に渡るループを使用するタイプのモデル。
  

• self-attention : 入力の各要素は入力のどの別の要素に注意を払うべきかを明らかにします。
  

• seq2seq or sequence-to-sequence : (Bart や T5 のような) 翻訳モデルや要約モデルのように、入力から新しいシークエンスを生成するモデル。
  

• トークン : センテンスの一部、通常は単語ですが、部分単語 (非一般的単語はしばしば部分単語に分割されます) や句読点シンボルでもあり得ます。
  

• transformer : self-attention ベースの深層学習モデル・アーキテクチャ。

 

モデル入力

総てのモデルは異なりますが他のものとの類似性を有します。従って殆どのモデルは同じ入力を用います、これはここで使用サンプルとともに詳述されます。

 

入力 ID

入力 id はしばしば入力としてモデルに渡される唯一の必須パラメータです。それらはトークン・インデックスで、モデルにより入力として使用されるシークエンスを構築するトークンの数値表現です。

各 tokenizer は異なって動作しますが基礎的なメカニズムは同じままです。ここに BERT tokenzier を使用するサンプルがあります、これは WordPiece tokenizer です :

from transformers import BertTokenizer
tokenizer = BertTokenizer.from_pretrained("bert-base-cased")
sequence = "A Titan RTX has 24GB of VRAM"

tokenizer はシークエンスを tokenzier 語彙で利用可能なトークンに分割する処理をします。

tokenized_sequence = tokenizer.tokenize(sequence)

トークンは単語か部分単語のいずれかです。ここでは例えば、”VRAM” はモデル語彙にないので、それは “V”, “RA” と “M” に分割されます。それらのトークンが別々の単語ではなく同じ単語の一部であることを示すために、“RA” と “M” のために double-hash プレフィックスが追加されます。

print(tokenized_sequence)

['A', 'Titan', 'R', '##T', '##X', 'has', '24', '##GB', 'of', 'V', '##RA', '##M']

そしてこれらのトークンはモデルにより理解可能な ID に変換できます。これはセンテンスを直接 tokenizer に供給することにより成されます、これは最高のパフォーマンスのために huggingface/tokenizers の Rust 実装を活用しています。

inputs = tokenizer(sequence)

tokenizer は対応するモデルが正しく動作するために必要な総ての引数を持つ辞書を返します。トークンインデックスはキー “inputs_ids” のもとにあります。

encoded_sequence = inputs["input_ids"]
print(encoded_sequence)

[101, 138, 18696, 155, 1942, 3190, 1144, 1572, 13745, 1104, 159, 9664, 2107, 102]

tokenizer は (関連モデルがそれらに依拠する場合)「特殊トークン」を自動的に追加することに注意してください、これはモデルが時に利用する特殊な ID です。

前の id のシークエンスをデコードする場合、

decoded_sequence = tokenizer.decode(encoded_sequence)

次を見ます :

print(decoded_sequence)

[CLS] A Titan RTX has 24GB of VRAM [SEP]

これは BertModel がその入力に想定する方法であるからです。

 

Attention マスク

attention マスクはシークエンスをまとめてバッチ処理するときに使用されるオプションの引数です。この引数はどのトークンが注意を払われるべきか、そしてどれがそうでないかをモデルに示します。

例えば、これらの 2 つのセンテンスを考えます :

from transformers import BertTokenizer
tokenizer = BertTokenizer.from_pretrained("bert-base-cased")
sequence_a = "This is a short sequence."
sequence_b = "This is a rather long sequence. It is at least longer than the sequence A."
encoded_sequence_a = tokenizer(sequence_a)["input_ids"]
encoded_sequence_b = tokenizer(sequence_b)["input_ids"]

エンコードされたバージョンは異なる長さを持ちます :

len(encoded_sequence_a), len(encoded_sequence_b)

(8, 19)

従って、それらを as-is で同じ tensor に一緒に配置することはできません。最初のシークエンスは 2 番目のものの長さにまでパディングされる必要があるか、あるいは 2 番目のものが最初のものの長さにまで切り捨てられる必要があります。

最初のケースでは、ID のリストはパディング・インデックスにより拡張されます。リストを tokenizer に渡してこのようにパッドすることを求めることができます :

padded_sequences = tokenizer([sequence_a, sequence_b], padding=True)

最初のセンテンスの右側にそれを 2 番目のものと同じ長さにするために 0 が追加されたことを見ることができます。

padded_sequences["input_ids"]

[[101, 1188, 1110, 170, 1603, 4954, 119, 102, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [101, 1188, 1110, 170, 1897, 1263, 4954, 119, 1135, 1110, 1120, 1655, 2039, 1190, 1103, 4954, 138, 119, 102]]

そしてこれは PyTorch や TensorFlow の tensor に変換できます。attention マスクはパディングされたインデックスの位置を示す二値 tensor で、その結果モデルはそれらに注意を払いません。BertTokenizer については、1 は注意すべき値を示し、その一方で 0 はパディングされた値を示します。この attention マスクはキー “attention_mask” のもとで tokenizer により返される辞書内にあります。

padded_sequences["attention_mask"]

[[1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]

 

トークン型 ID

幾つかのモデルの目的はシークエンス分類や質問応答を行なうことです。これらは 2 つの異なるシークエンスが単一の “input_ids” エントリ内に結合されることを必要とします、これは通常は classifier ([CLS]) と separator ([SEP]) トークンのような特殊トークンの助けにより遂行されます。例えば、BERT モデルはその 2 つのシークエンス入力を次のように構築します :

# [CLS] SEQUENCE_A [SEP] SEQUENCE_B [SEP]

そのようなセンテンスを自動的に生成するためにこのように 2 つのセンテンスを tokenizer に (前のように、リストではなく、) 2 つの引数として渡すことにより tokenizer を利用できます :

from transformers import BertTokenizer
tokenizer = BertTokenizer.from_pretrained("bert-base-cased")
sequence_a = "HuggingFace is based in NYC"
sequence_b = "Where is HuggingFace based?"
encoded_dict = tokenizer(sequence_a, sequence_b)
decoded = tokenizer.decode(encoded_dict["input_ids"])

これは次を返します :

print(decoded)

[CLS] HuggingFace is based in NYC [SEP] Where is HuggingFace based? [SEP]

幾つかのモデルについては 1 つのシークエンスがどこで終わりそしてもう 1 つがどこから始まるかを理解するためにこれで十分です。けれども、BERT のような他のモデルはまたトークン型 ID も配備します (セグメント ID とも呼ばれます)。それらはモデルの 2 つのタイプのシークエンスを識別する二値マスクとして表されます。

tokenizer はこのマスクを “token_type_ids” エントリとして返します :

encoded_dict['token_type_ids']

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1]

最初のシークエンス、質問のために使用される「コンテキスト」は 0 で表される総てのトークンを持ち、その一方で「質問」に相当する 2 番目のシークエンスは 1 で表される総てのトークンを持ちます。

XLNetModel のような幾つかのモデルは 2 で表される追加のトークンを使用します。

 

位置 ID

(RNN に) 埋め込まれた各トークンの位置を持つ RNN とは違い、transformer は各トークンの位置を知りません。そのため、トークンのリスト内の各トークンの位置を識別するために位置 ID (position_ids) がモデルにより使用されます。

これらはオプションのパラメータです。position_ids がモデルに渡されない場合、ID は絶対的位置の埋め込みとして自動的に作成されます。

絶対的な位置埋め込みは範囲 [0, config.max_position_embeddings – 1] 内で選択されます。幾つかのモデルは sinusoidal (正弦波) 位置埋め込み or 相対的位置埋め込みのような他のタイプの位置埋め込みを利用します。

 

ラベル

ラベルはオプション引数で、モデルが損失自体を計算するために渡すことができます。これらのラベルはモデルの期待される予測であるべきです : それは予測と期待値 (ラベル) の間の損失を計算するために標準的な損失を利用します。

これらのラベルはモデルヘッドに従って異なります、例えば :

• シークエンス分類モデル (e.g., BertForSequenceClassification) については、モデルはシークエンス全体の期待されるラベルに対応するバッチの各値を持つ次元 (batch_size) の tensor を想定します。
  

• トークン分類モデル (e.g., BertForTokenClassification) については、モデルは各個々のトークンの期待されるラベルに対応する各値を持つ次元 (batch_size, seq_length) の tensor を想定します。
  

• masked 言語モデリング (e.g., BertForMaskedLM) については、モデルは各個々のトークンの期待されるラベルに対応する各値を持つ次元 (batch_size, seq_length) の tensor を想定します : masked トークンのためのトークン ID であるラベルの場合、値は残りのためには無視されます (通常は -100)。
  

• sequence to sequence タスク (e.g., BartForConditionalGeneration, MBartForConditionalGeneration) については、モデルは各入力シークエンスに関連するターゲット・シークエンスに対応する各値を持つ次元 (batch_size, tgt_seq_length) の tensor を想定します。訓練の間、BART と T5 は適切な decoder_input_ids と decoder attention マスク内部的に作成します。それらは通常は供給される必要はありません。これは Encoder-Decoder フレームワークを活用するモデルには当てはまりません。各特定のモデルのラベル上のより多くの情報については各モデルのドキュメントを見てください。

ベースモデル (e.g. BertModel) はラベルを受け取りません、何故ならばこれらはベース transformer モデルで、単純に特徴を出力するだけだからです。

 

Decoder 入力 ID

この入力はエンコーダ・デコーダモデル特有で、デコーダに供給される入力 ID を含みます。これらの入力は翻訳や要約のような、sequence to sequence タスクのために使用されるべきで、通常は各モデルに固有の方法で構築されます。

殆どのエンコーダ・デコーダモデル (BART, T5) はラベルから独自に decoder_input_ids を作成します。そのようなモデルでは、ラベルを渡すことは訓練を扱うために好まれる方法です。

sequence to sequence 訓練のためにそれらが入力 ID をどのように処理するかを見るには各モデルの docs を確認してください。

 

順伝播 Chunking

transformer の各残差 attention ブロックでは self-attention 層には通常は 2 つの順伝播層が続きます。順伝播層の中間の埋め込みサイズはしばしばモデルの隠れサイズよりも大きいです (e.g., bert-base-uncased について)。

サイズ [batch_size, sequence_length] の入力について、中間の順伝播埋め込み層 [batch_size, sequence_length, config.intermediate_size] をストアするために必要なメモリはメモリ使用量の大きな割合を占める可能性があります。Reformer: The Efficient Transformer の著者は、計算が sequence_length 次元から独立であるために、順伝播層 [batch_size, config.hidden_size]_0, …, [batch_size, config.hidden_size]_n の出力埋め込みを個別に計算してそれらを n = sequence_length を持つ [batch_size, sequence_length, config.hidden_size] に後で連結することと数学的に同値であることに気付きました、これは増大する計算時間を削減されるメモリ使用に対してトレードオフしますが、数学的には同値な結果を生成します。

関数 apply_chunking_to_forward() を使用するモデルについては、chunk_size は並列に計算される出力埋め込みの数を定義し、メモリと時間計算量の間のトレードオフを定義します。chunk_size が 0 に設定されている場合、順伝播 chunking は行なわれません。

以上

HuggingFace Transformers 4.5 : Gettiing Started : 哲学 (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 05/05/2021 (4.5.1)

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

• Gettiing Started : Philosophy

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

 

 

HuggingFace Transformers : Gettiing Started : 哲学

Transformers は以下のために構築された自説を曲げない (= opnionated) ライブラリです :

• 大規模な transformer モデルを利用/研究/拡張することを追求する NLP 研究者と教育者
• それらのモデルを再調整して and/or それらをプロダクションでサービス提供することを望むハンズオン実践者
• 事前訓練モデルをダウンロードして与えられた NLP タスクを解くためにそれを利用することを単に望む技術者

ライブラリは 2 つの強力な目標を念頭において設計されました :

• できる限り容易に高速に利用できるものとして :
  • 学習しなければならないユーザ向け抽象の数を強く制限しました、実際に、殆ど抽象はなく、各モデルを利用するために必要な単に 3 つの標準的なクラス : configuration, models と tokenizer があるだけです。
    

  • これらのクラス総ては共通の from_pretrained() インスタンス化メソッドを使用することで単純で統一された方法で事前訓練インスタンスから初期化できます、これは Hugging Face ハブ や貴方自身のセーブされたチェックポイント上で提供される事前訓練されたチェックポイントから、 (必要であれば) ダウンロードを処理し、関連するクラス・インスタンスと関連データ (configurations のハイパーパラメータ, tokenizers の語彙とモデルの重み) をキャッシュしてロードします。
    

  • それら 3 つの基底クラスの上に、ライブラリは 2 つの API を提供します : 与えられたタスク上でモデル (加えて関連する tokenizer と configuration) を素早く使用するための pipeline() そして与えられたモデルを素早く訓練または再調整するための Trainer() / TFTrainer() です。
    

  • 結果として、このライブラリはニューラルネットのためのビルディング・ブロックのモジュール・ツールボックスでは ありません。ライブラリを拡張 / (その上で) 構築することを望むのであれば、通常の Python/PyTorch/TensorFlow/Keras モジュールを単に利用してそしてモデルロード/セーブのような機能を再利用するためにはライブラリの基底クラスから継承してください。

• 元のモデルにできる限り近いパフォーマンスを持つ最先端技術のモデルを提供する :
  • 各アーキテクチャ毎に少なくとも一つのサンプルを提供します、これはそのアーキテクチャの公式作者により提供された結果を再生成します。
    

  • コードは通常は元のコードベースに出来る限り近いです、これはある PyTorch コードは pytorchic ではないかもしれないことを意味します、何故ならばそれは変換された TensorFlow コードの結果そしてその逆である可能性があるからです。

幾つかの他のゴール :

• モデルの内部をできる限り一貫性を持って公開する :
  • 単一の API を使用して、full 隠れ状態と attention 重みへのアクセスを与えます。
  • tokenizer と基底モデルの API はモデル間で容易に切り替えられるように標準化されています。

• これらのモデルを再調整/調査するために見込みのあるツールの主観的な選択を組み入れます :
  • 再調整のため語彙と埋め込みに新しいトークンを追加するための単純で/一貫した方法。
  • transformer ヘッドをマスクして刈り取る (= prune) 単純な方法。

• PyTorch と TensorFlow 2.0 間を容易に切り替え、一つのフレームワークを使用して訓練して他方を使用して推論することを可能にします。

 

主要コンセプト

ライブラリは各モデルに対して 3 つのタイプのクラスを中心に構築されます :

• BertModel のような Model クラス、これは 30+ PyTorch モデル (torch.nn.Module) や Keras モデル (tf.keras.Model) で、ライブラリで提供される事前訓練重みで動作します。
  

• BertConfig のような Configuration クラス、これはモデルを構築するために必要なパラメータ総てをストアします。これらを貴方自身でインスタンス化する必要は必ずしもありません。特に、どのような変更もなしに事前訓練モデルを使用している場合、モデルの作成は configuration のインスタンス化を自動的に処理します (これはモデルの一部です)。
  

• BertTokenizer のような Tokenizer クラス、これは各モデルのための語彙をストアして、モデルに供給されるトークン埋め込みインデックスのリスト内のエンコード/デコード文字列のためのメソッドを提供します。

これらのクラス総ては 2 つのメソッドを使用して事前訓練インスタンスからインスタンス化してローカルにセーブできます :

• from_pretrained() は、ライブラリ自身から提供される (サポートされるモデルは ここ のリストで提供されます) かユーザによりローカルにストアされた事前訓練バージョンから model/configuration/tokenizer をインスタンス化させます。
  

• save_pretrained() は model/configuration/tokenizer をローカルにセーブさせます、その結果それは from_pretrained() を使用して再ロードできます。

以上

HuggingFace Transformers 4.5 : Gettiing Started : クイック・ツアー (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 05/01/2021 (4.5.1)

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

• Gettiing Started : Quick tour

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

 

 

HuggingFace Transformers : Gettiing Started : クイック・ツアー

• 訳注 : 本ドキュメントの TensorFlow バージョンは こちら をご覧ください。

Transformers ライブラリの特徴を素早く見ましょう。ライブラリは、テキストのセンチメントを分析するような自然言語理解 (NLU) タスク、そしてプロンプトを新しいテキストで補完したりもう一つの他の言語に翻訳するような自然言語生成 (NLG) のための事前訓練モデルをダウンロードします。

最初にそれらの事前訓練モデルを推論で素早く利用するためにパイプライン API をどのように容易に活用するかを見ます。それから、もう少し掘り下げてライブラリがそれらのモデルへのアクセスをどのように与えてデータを前処理することを手助けするかを見ます。

 

パイプラインでタスク上で始める

与えられたタスク上で事前訓練モデルを利用する最も容易な方法は pipeline() を使用することです。 Transformers は以下のタスクをすぐに使えるように提供します :

• センチメント解析 : テキストはポジティブ or ネガティブ？
• テキスト生成 (in English) : プロンプトを提示してモデルはそれに続くものを生成します。
• 固有表現認識 (NER) : 入力センテンスで、各単語をそれが表すエンティティ (person, place, etc.) でラベル付けします
• 質問応答 : あるコンテキストと質問とともにモデルを提供します、コンテキストから答えを抽出します。
• マスクされたテキストを埋める : マスクされた単語 (e.g., [MASK] で置き換えられた) を持つテキストが与えられたとき、ブランクを埋めます。
• 要約 : 長いテキストの要約を生成します。
• 翻訳 : テキストを別の言語に翻訳します。
• 特徴抽出 : テキストの tensor 表現を返します。

センチメント解析のためにこれがどのように動作するか見ましょう (他のタスクは タスク要約 で総てカバーされます) :

from transformers import pipeline
classifier = pipeline('sentiment-analysis')

このコマンドを最初にタイプしたとき、事前訓練モデルとその tokenizer がダウンロードされてキャッシュされます。両者を後で見ますが、イントロダクションとして tokenizer のジョブはモデルのためにテキストを前処理することです、これはそれから予測を行なう責任を追います。パイプラインはその総てを一緒にグループ化して、予測を可読にするために後処理します。例えば :

classifier('We are very happy to show you the 🤗 Transformers library.')

That’s encouraging! センテンスのリスト上でそれを利用できます、それは前処理されてからモデルにバッチとして供給され、この一つのように辞書のリストを返します :

results = classifier(["We are very happy to show you the 🤗 Transformers library.",
           "We hope you don't hate it."])
for result in results:
    print(f"label: {result['label']}, with score: {round(result['score'], 4)}")

2 番目のセンテンスがネガティブとして分類されたのを見れますが (それはポジティブかネガティブである必要があります)、そのスコアは公平に中立です。

デフォルトで、このパイプラインのためにダウンロードされるモデルは “distilbert-base-uncased-finetuned-sst-2-english” と呼ばれます。それについてより多くの情報を得るためにその モデルページ を見ることができます。それは DistilBERT アーキテクチャ を使用してセンチメント分析タスクのための SST-2 と呼ばれるデータセット上で再調整されました。

別のモデルを利用することを望むとしましょう ; 例えば、フランス語データ上で訓練された一つです。研究ラボにより多くのデータ上で事前訓練されたモデルを集めた モデルハブ を通して検索できますが、コミュニティ・モデルもまたあります (通常は特定のデータセット上でのそれらの大きなモデルの再調整版です)。タグ “French” と “text-classification” の適用は提案 “nlptown/bert-base-multilingual-uncased-sentiment” を与えます。それをどのように使用するか見ましょう。

pipeline() を使用するためにモデルの名前を直接渡すことができます :

classifier = pipeline('sentiment-analysis', model="nlptown/bert-base-multilingual-uncased-sentiment")

分類器は今では英語、フランス語だけでなく、オランダ語、ドイツ語、イタリア語とスペイン語のテキストも扱うことができます！その名前を事前訓練モデルをセーブしたローカルフォルダで置き換えることもできます (下を見てください)。モデルオブジェクトとその関連する tokenizer を渡すこともできます。

このために 2 つのクラスを必要とします。最初のものは AutoTokenizer で、これは選択したモデルに関連する tokenizer をダウンロードしてそれをインスタンス化するために使用します。2 番目のものは AutoModelForSequenceClassification (or TensorFlow を使用していれば TFAutoModelForSequenceClassification) で、これはモデル自身をダウンロードするために使用します。他のタスク上でライブラリを使用していた場合には、モデルのクラスは変わることに注意してください。タスク要約 チュートリアルはどのクラスがどのタスクのためのに使用されるかを要約しています。

from transformers import AutoTokenizer, AutoModelForSequenceClassification

今では、前に見つけたモデルと tokenizer をダウンロードするためには、単に from_pretrained() メソッドを使用しなければならないだけです (model_name はモデルハブからの任意の他のモデルで自由に置き換えてください) :

model_name = "nlptown/bert-base-multilingual-uncased-sentiment"
model = AutoModelForSequenceClassification.from_pretrained(model_name)
tokenizer = AutoTokenizer.from_pretrained(model_name)
classifier = pipeline('sentiment-analysis', model=model, tokenizer=tokenizer)

貴方のものに類似したあるデータ上で事前訓練されたモデルが見つからない場合には、事前訓練されたモデルを貴方のデータ上で再調整する必要があります。それを行なう サンプル・スクリプト を提供します。ひとたびそれを行なったら、この チュートリアル を使用して、貴方の再調整モデルをハブ上でコミュニティと共有することを忘れないでください

 

Under the hood: 事前訓練モデル

今はそれらのパイプラインを使用するとき中で何が起きるかを見ましょう。見たように、モデルと tokenizer は from_pretrained メソッドを使用して作成されます :

from transformers import AutoTokenizer, AutoModelForSequenceClassification
model_name = "distilbert-base-uncased-finetuned-sst-2-english"
pt_model = AutoModelForSequenceClassification.from_pretrained(model_name)
tokenizer = AutoTokenizer.from_pretrained(model_name)

 

tokenizer を使用する

tokenizer はテキストの前処理の責任を負うと言及しました。最初に、それは与えられたテキストを通常はトークンと呼ばれる単語 (or 単語の部分、句読記号等) に分割します。そのプロセスを管理できる複数のルールがあります (tokenizer 要約 でそれらについて更に学習できます)、これが何故モデルの名前を使用して tokenizer をインスタンス化する必要があるかです、モデルが事前訓練されたときと同じルールを使用することを確実にするためです。

2 番目のステップはそれらのトークンを数字に変換することです、それらから tensor を構築してそれらをモデルに供給できるようにです。これを行なうため、tokenizer は vocab を持ちます、これは from_pretrained メソッドでそれをインスタンス化するときダウンロードする一部です、何故ならばモデルが事前訓練したときと同じ vocab を使用する必要があるからです。

与えられたテキストでこれらのステップを適用するため、単にそれを tokenizer に供給できます :

inputs = tokenizer("We are very happy to show you the 🤗 Transformers library.")

これは整数のリストへの辞書文字列を返します。それは (前に言及されたように) トークンの id だけでなく、モデルに必要な追加引数も含みます。ここでは例えば、attention マスク も持ちます、これはシークエンスのより良い理解を持つためにモデルが利用します :

>>> print(inputs)

{'input_ids': [101, 2057, 2024, 2200, 3407, 2000, 2265, 2017, 1996, 100, 19081, 3075, 1012, 102], 'attention_mask': [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]}

センテンスのリストを tokenizer に直接渡すことができます。ゴールがそれらをモデルにバッチとして送ることならば、それらを総て同じ長さにパッドし、それらをモデルが受け取れる最大長に truncate してそして tensor を返すことを多分望むでしょう。それら総てを tokenizer に指定することができます :

pt_batch = tokenizer(
    ["We are very happy to show you the 🤗 Transformers library.", "We hope you don't hate it."],
    padding=True,
    truncation=True,
    max_length=512,
    return_tensors="pt"
)

パディングは、(それで) モデルが訓練されたパディングトークンで、モデルにより想定されるサイドで自動的に適用されます (この場合、右側)。attention マスクはまたパディングを考慮にいれるために適応されます :

for key, value in pt_batch.items():
    print(f"{key}: {value.numpy().tolist()}")

input_ids: [[101, 2057, 2024, 2200, 3407, 2000, 2265, 2017, 1996, 100, 19081, 3075, 1012, 102], [101, 2057, 3246, 2017, 2123, 1005, 1056, 5223, 2009, 1012, 102, 0, 0, 0]]
attention_mask: [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0]]

tokenizer について ここ で更に学習できます。

 

モデルを使用する

入力が tokenizer によりひとたび前処理されれば、それをモデルに直接送ることができます。言及したように、それはモデルが必要とする関連情報を総て含みます。TensorFlow モデルを使用している場合、辞書キーを tensor に直接渡すことができて、PyTorch モデルについては、 ** を追加することにより辞書をアンパックする必要があります。

pt_outputs = pt_model(**pt_batch)

Transformers では、総ての出力は (潜在的に一つの要素だけを持つ) タプルです。ここでは、単にモデルの最後の活性を持つタプルを得ます。

print(pt_outputs)

(tensor([[-4.0833,  4.3364],
        [ 0.0818, -0.0418]], grad_fn=<AddmmBackward>),)

モデルは単なる最後の活性以上を返すことができます、これは何故出力がタプルであるかです。ここでは最後の活性だけを求めますので、一つの要素を持つタプルを得ます。

Note: 総ての Transformers モデル (PyTorch or TensorFlow) は (SoftMax のような) 最後の活性化関数の 前の モデルの活性を返します、何故ならばこの最後の活性化関数はしばしば損失と融合されるからです。

予測を得るために SoftMax 活性を適用しましょう。

import torch.nn.functional as F
pt_predictions = F.softmax(pt_outputs[0], dim=-1)

前からの数字を得ることを見れます :

print(pt_predictions)

tensor([[2.2043e-04, 9.9978e-01],
        [5.3086e-01, 4.6914e-01]], grad_fn=<SoftmaxBackward>)

ラベルを持つのであれば、それらをモデルに提供できます、それは損失と最後の活性を持つタプルを返します。

import torch
pt_outputs = pt_model(**pt_batch, labels = torch.tensor([1, 0]))

モデルは標準的な torch.nn.Module or tf.keras.Model ですから通常の訓練ループでそれらを使用できます。 Transformers は訓練を手助けする (分散訓練、混合精度等のようなものを処理します) ためにまた Trainer クラス (or TensorFlow を使用していれば TFTrainer) も提供します。より多くの詳細については 訓練チュートリアル を見てください。

貴方のモデルがひとたび再調整されれば、tokenizer で次の方法でそれをセーブできます :

tokenizer.save_pretrained(save_directory)
model.save_pretrained(save_directory)

それからモデル名の代わりにディレクトリ名を渡すことにより from_pretrained() メソッドを使用してモデルをロードし戻すことができます。 Transformers の一つのクールな特徴は PyTorch と TensorFlow 間で容易に切り替えられることです : 前のようにセーブされた任意のモデルは PyTorch か TensorFlow のいずれかでロードし戻すことができます。セーブされた PyTorch モデルを TensorFlow モデル内にロードしている場合には、このように from_pretrained() を使用します :

tokenizer = AutoTokenizer.from_pretrained(save_directory)
model = TFAutoModel.from_pretrained(save_directory, from_pt=True)

そしてセーブされた TensorFlow モデルを PyTorch モデル内にロードしている場合は、次のコードを使用するべきです :

tokenizer = AutoTokenizer.from_pretrained(save_directory)
model = AutoModel.from_pretrained(save_directory, from_tf=True)

最後に、総ての隠れ状態と総ての attention 重みを返すように (もしそれらを必要とするならば) モデルに要求することもできます :

pt_outputs = pt_model(**pt_batch, output_hidden_states=True, output_attentions=True)
all_hidden_states, all_attentions = pt_outputs[-2:]

 

コードにアクセスする

AutoModel と AutoTokenizer クラスは任意の事前訓練モデルで自動的に動作する単なるショートカットです。内部的には、ライブラリはアーキテクチャとクラスの組合せ毎に一つの model クラスを持ちますので、コードは必要であれば容易にアクセスして調整できます。

前のサンプルでは、モデルは “distilbert-base-uncased-finetuned-sst-2-english” と呼ばれました、これはそれが DistilBERT アーキテクチャを使用してることを意味しています。AutoModelForSequenceClassification (or TensorFlow を使用しているなら TFAutoModelForSequenceClassification) が使用されたとき、自動的に作成されるモデルは DistilBertForSequenceClassification です。その特定のモデルに関連する詳細の総てについてのドキュメントを見る、あるいはソースコードをブラウザすることができます。これは auto マジックなしでモデルと tokenizer をどのように直接インスタンス化するかです :

from transformers import DistilBertTokenizer, DistilBertForSequenceClassification
model_name = "distilbert-base-uncased-finetuned-sst-2-english"
model = DistilBertForSequenceClassification.from_pretrained(model_name)
tokenizer = DistilBertTokenizer.from_pretrained(model_name)

 

モデルをカスタマイズする

モデル自身がどのように構築されるかを変更することを望む場合、カスタム configuration クラスを定義することができます。各アーキテクチャはそれ自身の関連 configuration (DistilBERT の場合は DistilBertConfig) を備え、これは任意の隠れ次元、dropout 率等を指定することを可能にします。隠れサイズを変更するような、中心的な変更を行なう場合には、事前訓練モデルを利用することはもはやできませんのでスクラッチから訓練する必要があります。それからこの configuration から直接モデルをインスタンス化するでしょう。

ここでは DistilBERT の事前定義された語彙を利用して (これ故に from_pretrained() メソッドで tokenizer をロードします) モデルをスクラッチから初期化します (これ故に from_pretrained() メソッドを使用する代わりに configuration からモデルをインスタンス化します)。

from transformers import DistilBertConfig, DistilBertTokenizer, DistilBertForSequenceClassification
config = DistilBertConfig(n_heads=8, dim=512, hidden_dim=4*512)
tokenizer = DistilBertTokenizer.from_pretrained('distilbert-base-uncased')
model = DistilBertForSequenceClassification(config)

モデルのヘッド (例えば、ラベル数) を変更するだけの何かについては、ボディのために依然として事前訓練モデルを利用できます。例えば、事前訓練ボディを使用して 10 の異なるラベルのための分類器を定義しましょう。総てのデフォルト値を持つ configuration を作成してラベル数を単に変更することはできるでしょうが、より簡単に、configuration が取る任意の引数を直接 from_pretrained() メソッドに渡すことができてそれはそれでデフォルト configuration を更新します :

from transformers import DistilBertConfig, DistilBertTokenizer, DistilBertForSequenceClassification
model_name = "distilbert-base-uncased"
model = DistilBertForSequenceClassification.from_pretrained(model_name, num_labels=10)
tokenizer = DistilBertTokenizer.from_pretrained(model_name)

以上

HuggingFace Transformers 4.5 : 概要 (翻訳/解説)
翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 04/28/2021 (4.5.1)

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

• README

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

 

 

HuggingFace Transformers : 概要

PyTorch と TensorFlow 2.0 のための最先端の自然言語処理

• Transformers は 100+ 言語の分類、情報抽出、質問応答、要約、翻訳、テキスト生成等のテキスト上のタスクを遂行するために数千の事前訓練モデルを提供します。その目的は最先端の NLP を誰でも容易に利用できるようにすることです。
  

• Transformers はそれらの事前訓練モデルを素早くダウンロードして与えられたテキスト上で利用し、それらを貴方自身のデータセット上で再調整し、それからそれらを私達の モデル・ハブ 上でコミュニティと共有するための API を提供します。同時に、アーキテクチャを定義する各 python モジュールは素早い研究実験を可能にするためスタンドアロンとして利用できて変更できます。
  

• Transformers は 2 つの最もポピュラーな深層学習ライブラリ PyTorch と TensorFlow により、それらの間のシームレスな統合によって支援され、その一つでモデルを訓練してから推論のために他方でそれをロードすることを可能にします。

 

オンライン・デモ

私達のモデルの殆どを モデルハブ のそれらのページから直接テストすることができます。それらのモデルを利用するための プライベートモデル・ホスティング、バージョニング & 推論 API もまた供給します。

ここに幾つかサンプルがあります :

• BERT による Masked 単語補完
• Electra による固有表現認識
• GPT-2 によるテキスト生成
• RoBERTa による自然言語推論
• BART による要約
• DistilBERT による質問応答
• T5 による翻訳

Hugging Face チームにより構築された Write With Transformer はこのレポジトリのテキスト生成機能の公式デモです。

 

クイック・ツアー

与えられたテキスト上でモデルを直ちに利用するため、パイプライン API を提供します。パイプラインは事前訓練されたモデルをそのモデル訓練の間に使用された前処理と一緒にグループ化します。ここにポジティブ vs ネガティブ・テキストを分類するためのパイプラインをどのように素早く利用するかがあります :

>>> from transformers import pipeline

# Allocate a pipeline for sentiment-analysis
>>> classifier = pipeline('sentiment-analysis')
>>> classifier('We are very happy to include pipeline into the transformers repository.')
[{'label': 'POSITIVE', 'score': 0.9978193640708923}]

コードの 2 番目の行はパイプラインで使用された事前訓練モデルをダウンロードしてキャッシュします、3 番目の行はそれを与えられたテキスト上で評価します。ここでは答えは 99.8% の信頼度で「ポジティブ」です。

これは、あるコンテキストから質問応答を抽出できるもののために使用されるパイプラインのもう一つのサンプルです :

>>> from transformers import pipeline

# Allocate a pipeline for question-answering
>>> question_answerer = pipeline('question-answering')
>>> question_answerer({
...     'question': 'What is the name of the repository ?',
...     'context': 'Pipeline have been included in the huggingface/transformers repository'
... })
{'score': 0.5135612454720828, 'start': 35, 'end': 59, 'answer': 'huggingface/transformers'}

答えの最初に、ここで使用される事前訓練モデルは (トークン化されたセンテンスの開始位置と終了位置とともに) その信頼度スコアを返します。このチュートリアル でパイプライン API によりサポートされるタスクについて更に学習できます。

与えられたタスク上で任意の事前訓練されたモデルをダウンロードして利用するには、それらの 3 行のコードを単に必要とするだけです (PyToch バージョン) :

>>> from transformers import AutoTokenizer, AutoModel

>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
>>> model = AutoModel.from_pretrained("bert-base-uncased")

>>> inputs = tokenizer("Hello world!", return_tensors="pt")
>>> outputs = model(**inputs)

or for TensorFlow:

>>> from transformers import AutoTokenizer, TFAutoModel

>>> tokenizer = AutoTokenizer.from_pretrained("bert-base-uncased")
>>> model = TFAutoModel.from_pretrained("bert-base-uncased")

>>> inputs = tokenizer("Hello world!", return_tensors="tf")
>>> outputs = model(**inputs)

tokenizer は事前訓練されたモデルが想定する前処理の総ての責任を負い、そしてテキストの一つ (or リスト) 上で直接呼び出せます (両者のコードサンプルの 4 番目で見れるように)。それは貴方のモデルに直接渡せる辞書を出力します (それは 5 行目で成されます)。

モデル自身は通常の Pytorch nn.Module や TensorFlow tf.keras.Model で (貴方のバックエンドに依拠します)、これらは普通に利用できます。例えば、このチュートリアル は古典的な PyTorch or TensorFlow 訓練ループでそのようなモデルをどのように統合するか、あるいは新しいデータセット上で素早く再調整するために Trainer API をどのように利用するかを説明しています。

 

何故私は transformers を使用するべきでしょう？

1. 使いやすい最先端のモデル :
   • NLU と NLG タスク上の高パフォーマンス。
   • 教育者と実践者のための入門への低い障壁。
   • 学習すべき 3 つのクラスだけを持つ、ユーザが直面する少ない抽象。
   • 事前訓練されたモデルの総てを使用するための統一 API。

2. より低い計算コスト、より小さいカーボンフットプリント (二酸化炭素排出量) :
   • 研究者は常に再訓練する代わりに訓練モデルを共有できます。
   • 実践者は計算時間とプロダクション・コストを減じることができます。
   • 幾つかは100 言語以上の、2,000 超の事前訓練モデルを持つ数十のアーキテクチャ。

3. モデルのライフタイムの総てのパートのために適切なフレームワークを選択する :
   • 3 行のコードで最先端のモデルを訓練します。
   • TF2.0/PyTorch フレームワーク間で単一モデルを自在に移動する。
   • 訓練、評価、プロダクションのための適切なフレームワークをシームレスに選択する。

4. 貴方のニーズにモデルやサンプルを容易にカスタマイズする :
   • 言及されるアーキテクチャの公式著者による結果を再生成するための各アーキテクチャのためのサンプル。
   • できる限り一貫してモデル内部を公開する。
   • モデルファイルは素早い実験のためにライブラリから独立的に利用できる。

 

何故私は transformers を利用しないのでしょう？

• このライブラリはニューラルネットのためのビルディングブロックのモジュール・ツールボックスではありません。研究者が追加の抽象/ファイルに深入りすることなくモデルの各々の上で素早く iterate できるようにように、モデルファイルのコードは意図的な追加の抽象によりリファクタリングされません。
  

• 訓練 API は任意のモデル上で動作することを意図されていませんがライブラリにより提供されるモデルで動作するように最適化されています。一般的な機械学習ループのためには、他のライブラリを利用するべきです。
  

• 私達は可能な限り多くのユースケースを提示する努力をする一方で、examples フォルダ のスクリプトは単なるサンプルです。それらは貴方の特定の問題上でそのままでは動作しないでしょうし、それらを貴方のニーズに適応させるためにコードの数行を変更する必要があることが想定されます。

 

モデル・アーキテクチャ

Transformers により提供される 総てのモデルチェックポイント は huggingface.co モデルハブ からシームレスに統合されていて、そこではそれらは ユーザ と 組織 により直接アップロードされています。

チェックポイントの現在の数 : モデル 10,249 (as of 4/30/2021)

Transformers は現在以下のアーキテクチャを提供しています (それらの各々の高位な要約については ここ を参照) :

1. ALBERT (from Google Research and the Toyota Technological Institute at Chicago) released with the paper ALBERT: A Lite BERT for Self-supervised Learning of Language Representations, by Zhenzhong Lan, Mingda Chen, Sebastian Goodman, Kevin Gimpel, Piyush Sharma, Radu Soricut.

2. BART (from Facebook) released with the paper BART: Denoising Sequence-to-Sequence Pre-training for Natural Language Generation, Translation, and Comprehension by Mike Lewis, Yinhan Liu, Naman Goyal, Marjan Ghazvininejad, Abdelrahman Mohamed, Omer Levy, Ves Stoyanov and Luke Zettlemoyer.

3. BARThez (from École polytechnique) released with the paper BARThez: a Skilled Pretrained French Sequence-to-Sequence Model by Moussa Kamal Eddine, Antoine J.-P. Tixier, Michalis Vazirgiannis.

4. BERT (from Google) released with the paper BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding by Jacob Devlin, Ming-Wei Chang, Kenton Lee and Kristina Toutanova.

5. BERT For Sequence Generation (from Google) released with the paper Leveraging Pre-trained Checkpoints for Sequence Generation Tasks by Sascha Rothe, Shashi Narayan, Aliaksei Severyn.

6. BigBird-RoBERTa (from Google Research) released with the paper Big Bird: Transformers for Longer Sequences by Manzil Zaheer, Guru Guruganesh, Avinava Dubey, Joshua Ainslie, Chris Alberti, Santiago Ontanon, Philip Pham, Anirudh Ravula, Qifan Wang, Li Yang, Amr Ahmed.

7. Blenderbot (from Facebook) released with the paper Recipes for building an open-domain chatbot by Stephen Roller, Emily Dinan, Naman Goyal, Da Ju, Mary Williamson, Yinhan Liu, Jing Xu, Myle Ott, Kurt Shuster, Eric M. Smith, Y-Lan Boureau, Jason Weston.

8. BlenderbotSmall (from Facebook) released with the paper Recipes for building an open-domain chatbot by Stephen Roller, Emily Dinan, Naman Goyal, Da Ju, Mary Williamson, Yinhan Liu, Jing Xu, Myle Ott, Kurt Shuster, Eric M. Smith, Y-Lan Boureau, Jason Weston.

9. BORT (from Alexa) released with the paper Optimal Subarchitecture Extraction For BERT by Adrian de Wynter and Daniel J. Perry.

10. CamemBERT (from Inria/Facebook/Sorbonne) released with the paper CamemBERT: a Tasty French Language Model by Louis Martin*, Benjamin Muller*, Pedro Javier Ortiz Suárez*, Yoann Dupont, Laurent Romary, Éric Villemonte de la Clergerie, Djamé Seddah and Benoît Sagot.

11. ConvBERT (from YituTech) released with the paper ConvBERT: Improving BERT with Span-based Dynamic Convolution by Zihang Jiang, Weihao Yu, Daquan Zhou, Yunpeng Chen, Jiashi Feng, Shuicheng Yan.

12. CPM (from Tsinghua University) released with the paper CPM: A Large-scale Generative Chinese Pre-trained Language Model by Zhengyan Zhang, Xu Han, Hao Zhou, Pei Ke, Yuxian Gu, Deming Ye, Yujia Qin, Yusheng Su, Haozhe Ji, Jian Guan, Fanchao Qi, Xiaozhi Wang, Yanan Zheng, Guoyang Zeng, Huanqi Cao, Shengqi Chen, Daixuan Li, Zhenbo Sun, Zhiyuan Liu, Minlie Huang, Wentao Han, Jie Tang, Juanzi Li, Xiaoyan Zhu, Maosong Sun.

13. CTRL (from Salesforce) released with the paper CTRL: A Conditional Transformer Language Model for Controllable Generation by Nitish Shirish Keskar*, Bryan McCann*, Lav R. Varshney, Caiming Xiong and Richard Socher.

14. DeBERTa (from Microsoft Research) released with the paper DeBERTa: Decoding-enhanced BERT with Disentangled Attention by Pengcheng He, Xiaodong Liu, Jianfeng Gao, Weizhu Chen.

15. DeBERTa-v2 (from Microsoft) released with the paper DeBERTa: Decoding-enhanced BERT with Disentangled Attention by Pengcheng He, Xiaodong Liu, Jianfeng Gao, Weizhu Chen.

16. DeiT (from Facebook) released with the paper Training data-efficient image transformers & distillation through attention by Hugo Touvron, Matthieu Cord, Matthijs Douze, Francisco Massa, Alexandre Sablayrolles, Hervé Jégou.

17. DialoGPT (from Microsoft Research) released with the paper DialoGPT: Large-Scale Generative Pre-training for Conversational Response Generation by Yizhe Zhang, Siqi Sun, Michel Galley, Yen-Chun Chen, Chris Brockett, Xiang Gao, Jianfeng Gao, Jingjing Liu, Bill Dolan.

18. DistilBERT (from HuggingFace), released together with the paper DistilBERT, a distilled version of BERT: smaller, faster, cheaper and lighter by Victor Sanh, Lysandre Debut and Thomas Wolf. The same method has been applied to compress GPT2 into DistilGPT2, RoBERTa into DistilRoBERTa, Multilingual BERT into DistilmBERT and a German version of DistilBERT.

19. DPR (from Facebook) released with the paper Dense Passage Retrieval for Open-Domain Question Answering by Vladimir Karpukhin, Barlas Oğuz, Sewon Min, Patrick Lewis, Ledell Wu, Sergey Edunov, Danqi Chen, and Wen-tau Yih.

20. ELECTRA (from Google Research/Stanford University) released with the paper ELECTRA: Pre-training text encoders as discriminators rather than generators by Kevin Clark, Minh-Thang Luong, Quoc V. Le, Christopher D. Manning.

21. FlauBERT (from CNRS) released with the paper FlauBERT: Unsupervised Language Model Pre-training for French by Hang Le, Loïc Vial, Jibril Frej, Vincent Segonne, Maximin Coavoux, Benjamin Lecouteux, Alexandre Allauzen, Benoît Crabbé, Laurent Besacier, Didier Schwab.

22. Funnel Transformer (from CMU/Google Brain) released with the paper Funnel-Transformer: Filtering out Sequential Redundancy for Efficient Language Processing by Zihang Dai, Guokun Lai, Yiming Yang, Quoc V. Le.

23. GPT (from OpenAI) released with the paper Improving Language Understanding by Generative Pre-Training by Alec Radford, Karthik Narasimhan, Tim Salimans and Ilya Sutskever.

24. GPT-2 (from OpenAI) released with the paper Language Models are Unsupervised Multitask Learners by Alec Radford*, Jeffrey Wu*, Rewon Child, David Luan, Dario Amodei** and Ilya Sutskever**.

25. GPT Neo (from EleutherAI) released in the repository EleutherAI/gpt-neo by Sid Black, Stella Biderman, Leo Gao, Phil Wang and Connor Leahy.

26. I-BERT (from Berkeley) released with the paper I-BERT: Integer-only BERT Quantization by Sehoon Kim, Amir Gholami, Zhewei Yao, Michael W. Mahoney, Kurt Keutzer

27. LayoutLM (from Microsoft Research Asia) released with the paper LayoutLM: Pre-training of Text and Layout for Document Image Understanding by Yiheng Xu, Minghao Li, Lei Cui, Shaohan Huang, Furu Wei, Ming Zhou.

28. LED (from AllenAI) released with the paper Longformer: The Long-Document Transformer by Iz Beltagy, Matthew E. Peters, Arman Cohan.

29. Longformer (from AllenAI) released with the paper Longformer: The Long-Document Transformer by Iz Beltagy, Matthew E. Peters, Arman Cohan.

30. LXMERT (from UNC Chapel Hill) released with the paper LXMERT: Learning Cross-Modality Encoder Representations from Transformers for Open-Domain Question Answering by Hao Tan and Mohit Bansal.

31. M2M100 (from Facebook) released with the paper Beyond English-Centric Multilingual Machine Translation by by Angela Fan, Shruti Bhosale, Holger Schwenk, Zhiyi Ma, Ahmed El-Kishky, Siddharth Goyal, Mandeep Baines, Onur Celebi, Guillaume Wenzek, Vishrav Chaudhary, Naman Goyal, Tom Birch, Vitaliy Liptchinsky, Sergey Edunov, Edouard Grave, Michael Auli, Armand Joulin.

32. MarianMT Machine translation models trained using OPUS data by Jörg Tiedemann. The Marian Framework is being developed by the Microsoft Translator Team.

33. MBart (from Facebook) released with the paper Multilingual Denoising Pre-training for Neural Machine Translation by Yinhan Liu, Jiatao Gu, Naman Goyal, Xian Li, Sergey Edunov, Marjan Ghazvininejad, Mike Lewis, Luke Zettlemoyer.

34. MBart-50 (from Facebook) released with the paper Multilingual Translation with Extensible Multilingual Pretraining and Finetuning by Yuqing Tang, Chau Tran, Xian Li, Peng-Jen Chen, Naman Goyal, Vishrav Chaudhary, Jiatao Gu, Angela Fan.

35. Megatron-BERT (from NVIDIA) released with the paper Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism by Mohammad Shoeybi, Mostofa Patwary, Raul Puri, Patrick LeGresley, Jared Casper and Bryan Catanzaro.

36. Megatron-GPT2 (from NVIDIA) released with the paper Megatron-LM: Training Multi-Billion Parameter Language Models Using Model Parallelism by Mohammad Shoeybi, Mostofa Patwary, Raul Puri, Patrick LeGresley, Jared Casper and Bryan Catanzaro.

37. MPNet (from Microsoft Research) released with the paper MPNet: Masked and Permuted Pre-training for Language Understanding by Kaitao Song, Xu Tan, Tao Qin, Jianfeng Lu, Tie-Yan Liu.

38. MT5 (from Google AI) released with the paper mT5: A massively multilingual pre-trained text-to-text transformer by Linting Xue, Noah Constant, Adam Roberts, Mihir Kale, Rami Al-Rfou, Aditya Siddhant, Aditya Barua, Colin Raffel.

39. Pegasus (from Google) released with the paper PEGASUS: Pre-training with Extracted Gap-sentences for Abstractive Summarization by Jingqing Zhang, Yao Zhao, Mohammad Saleh and Peter J. Liu.

40. ProphetNet (from Microsoft Research) released with the paper ProphetNet: Predicting Future N-gram for Sequence-to-Sequence Pre-training by Yu Yan, Weizhen Qi, Yeyun Gong, Dayiheng Liu, Nan Duan, Jiusheng Chen, Ruofei Zhang and Ming Zhou.

41. Reformer (from Google Research) released with the paper Reformer: The Efficient Transformer by Nikita Kitaev, Łukasz Kaiser, Anselm Levskaya.

42. RoBERTa (from Facebook), released together with the paper a Robustly Optimized BERT Pretraining Approach by Yinhan Liu, Myle Ott, Naman Goyal, Jingfei Du, Mandar Joshi, Danqi Chen, Omer Levy, Mike Lewis, Luke Zettlemoyer, Veselin Stoyanov. ultilingual BERT into DistilmBERT and a German version of DistilBERT.

43. SpeechToTextTransformer (from Facebook), released together with the paper fairseq S2T: Fast Speech-to-Text Modeling with fairseq by Changhan Wang, Yun Tang, Xutai Ma, Anne Wu, Dmytro Okhonko, Juan Pino.

44. SqueezeBert released with the paper SqueezeBERT: What can computer vision teach NLP about efficient neural networks? by Forrest N. Iandola, Albert E. Shaw, Ravi Krishna, and Kurt W. Keutzer.

45. T5 (from Google AI) released with the paper Exploring the Limits of Transfer Learning with a Unified Text-to-Text Transformer by Colin Raffel and Noam Shazeer and Adam Roberts and Katherine Lee and Sharan Narang and Michael Matena and Yanqi Zhou and Wei Li and Peter J. Liu.

46. TAPAS (from Google AI) released with the paper TAPAS: Weakly Supervised Table Parsing via Pre-training by Jonathan Herzig, Paweł Krzysztof Nowak, Thomas Müller, Francesco Piccinno and Julian Martin Eisenschlos.

47. Transformer-XL (from Google/CMU) released with the paper Transformer-XL: Attentive Language Models Beyond a Fixed-Length Context by Zihang Dai*, Zhilin Yang*, Yiming Yang, Jaime Carbonell, Quoc V. Le, Ruslan Salakhutdinov.

48. Vision Transformer (ViT) (from Google AI) released with the paper An Image is Worth 16×16 Words: Transformers for Image Recognition at Scale by Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, Jakob Uszkoreit, Neil Houlsby.

49. Wav2Vec2 (from Facebook AI) released with the paper wav2vec 2.0: A Framework for Self-Supervised Learning of Speech Representations by Alexei Baevski, Henry Zhou, Abdelrahman Mohamed, Michael Auli.

50. XLM (from Facebook) released together with the paper Cross-lingual Language Model Pretraining by Guillaume Lample and Alexis Conneau.

51. XLM-ProphetNet (from Microsoft Research) released with the paper ProphetNet: Predicting Future N-gram for Sequence-to-Sequence Pre-training by Yu Yan, Weizhen Qi, Yeyun Gong, Dayiheng Liu, Nan Duan, Jiusheng Chen, Ruofei Zhang and Ming Zhou.

52. XLM-RoBERTa (from Facebook AI), released together with the paper Unsupervised Cross-lingual Representation Learning at Scale by Alexis Conneau*, Kartikay Khandelwal*, Naman Goyal, Vishrav Chaudhary, Guillaume Wenzek, Francisco Guzmán, Edouard Grave, Myle Ott, Luke Zettlemoyer and Veselin Stoyanov.

53. XLNet (from Google/CMU) released with the paper ​XLNet: Generalized Autoregressive Pretraining for Language Understanding by Zhilin Yang*, Zihang Dai*, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, Quoc V. Le.

54. XLSR-Wav2Vec2 (from Facebook AI) released with the paper Unsupervised Cross-Lingual Representation Learning For Speech Recognition by Alexis Conneau, Alexei Baevski, Ronan Collobert, Abdelrahman Mohamed, Michael Auli.

55. 新しいモデルを寄贈することを望みますか？新しいモデルを追加するプロセスに導く詳細なガイドとテンプレートを追加しました。レポジトリの templates フォルダでそれらを見つけることができます。貴方の PR を始める前にフィードバックを集めるために contributing ガイドライン を確認してそしてメンテナーにコンタクトするか issue をオープンすることを確実にしてください。

各モデルが PyTorch/TensorFlow/Flax の実装を持つか、あるいは Tokenizer により支援された関連する tokenizer を持つかを確認するためには、このテーブル を参照してください。

これらの実装は幾つかのデータセット上でテストされ (examples スクリプト参照) そして元の実装のパフォーマンスに一致するはずです。ドキュメントの Examples セクションでパフォーマンス上の更なる詳細を見つけられます。

 

更に学習する

セクション	説明
ドキュメント	Full API ドキュメントとチュートリアル
タスク要約	Transformers によりサポートされるタスク
前処理チュートリアル	モデルのためにデータを準備するための Tokenizer クラスを使用する
訓練と再調整	PyTorch/TensorFlow 訓練ループと Trainer API で Transformers により提供されるモデルを使用する
クイックツアー: 再調整/使用方法スクリプト	広範囲なタスク上でモデルを再調整するためのサンプル・スクリプト
モデル共有とアップロード	貴方の再調整モデルをアップロードしてコミュニティで共有する
マイグレーション	pytorch-transformers or pytorch-pretrained-bert から Transformers にマイグレートする

 

Citation

(訳注: 原文 を参照してください。)

以上