ホーム » 「HuggingFace Transformers 3.3」タグがついた投稿

タグアーカイブ: HuggingFace Transformers 3.3

HuggingFace Transformers 3.3 : タスクの概要

HuggingFace Transformers 3.3 : タスクの概要 (翻訳/解説)

翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 10/21/2020 (3.3.1)

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

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

 

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

人工知能とビジネスをテーマにウェビナー (WEB セミナー) を定期的に開催しています。スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • Windows PC のブラウザからご参加が可能です。スマートデバイスもご利用可能です。

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

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

 

HuggingFace Transformers : タスクの概要

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

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

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

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

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

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

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

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

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

 

シークエンス分類

シークエンス分類は与えられたクラス数に従ってシークエンスを分類するタスクです。シークエンス分類のサンプルは GLUE データセットで、これはタスクに完全に基づいています。GLUE 分類タスク上でモデルを再調整したいのであれば、run_glue.pyrun_pl_glue.py or run_tf_glue.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. 結果をプリントします。

TensorFlow

from transformers import AutoTokenizer, TFAutoModelForSequenceClassification
import tensorflow as tf
tokenizer = AutoTokenizer.from_pretrained("bert-base-cased-finetuned-mrpc")
model = TFAutoModelForSequenceClassification.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="tf")
not_paraphrase = tokenizer(sequence_0, sequence_1, return_tensors="tf")
paraphrase_classification_logits = model(paraphrase)[0]
not_paraphrase_classification_logits = model(not_paraphrase)[0]
paraphrase_results = tf.nn.softmax(paraphrase_classification_logits, axis=1).numpy()[0]
not_paraphrase_results = tf.nn.softmax(not_paraphrase_classification_logits, axis=1).numpy()[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))}%")

PyTorch

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))}%")

 

Extractive 質問応答

Extractive (抽出可能な) 質問応答は質問が与えられたときテキストから答えを抽出するタスクです。質問応答データセットのサンプルは SQuAD データセットで、これはこのタスクに完全に基づいています。モデルを SQuAD タスク上で再調整したいのであれば、run_squad.pyrun_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']}")

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

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

TensorFlow

from transformers import AutoTokenizer, TFAutoModelForQuestionAnswering
import tensorflow as tf
tokenizer = AutoTokenizer.from_pretrained("bert-large-uncased-whole-word-masking-finetuned-squad")
model = TFAutoModelForQuestionAnswering.from_pretrained("bert-large-uncased-whole-word-masking-finetuned-squad")
text = r"""
HuggingFace 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 HuggingFace Transformers?",
    "What does HuggingFace Transformers provide?",
    "HuggingFace Transformers provides interoperability between which frameworks?",
]
for question in questions:
    inputs = tokenizer(question, text, add_special_tokens=True, return_tensors="tf")
    input_ids = inputs["input_ids"].numpy()[0]
    text_tokens = tokenizer.convert_ids_to_tokens(input_ids)
    answer_start_scores, answer_end_scores = model(inputs)
    answer_start = tf.argmax(
        answer_start_scores, axis=1
    ).numpy()[0]  # Get the most likely beginning of answer with the argmax of the score
    answer_end = (
        tf.argmax(answer_end_scores, axis=1) + 1
    ).numpy()[0]  # 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}")

PyTorch

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"""
HuggingFace 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 HuggingFace Transformers?",
    "What does HuggingFace Transformers provide?",
    "HuggingFace 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]
    text_tokens = tokenizer.convert_ids_to_tokens(input_ids)
    answer_start_scores, answer_end_scores = model(**inputs)
    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}")

 

言語モデリング

言語モデリングはモデルをコーパスに適合させるタスクで、ドメイン固有である可能性があります。総てのポピュラーな 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 参照)。

ここにシークエンスからのマスクを置き換えるために 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.',
  'token': 3944,
  'token_str': 'Ġtool'},
 {'score': 0.11349421739578247,
  'sequence': '<s>HuggingFace is creating a framework that the community uses '
              'to solve NLP tasks.',
  'token': 7208,
  'token_str': 'Ġframework'},
 {'score': 0.05243554711341858,
  'sequence': '<s>HuggingFace is creating a library that the community uses to '
              'solve NLP tasks.',
  'token': 5560,
  'token_str': 'Ġlibrary'},
 {'score': 0.03493533283472061,
  'sequence': <s>HuggingFace is creating a database that the community uses '
              'to solve NLP tasks.',
  'token': 8503,
  'token_str': 'Ġdatabase'},
 {'score': 0.02860250137746334,
  'sequence': '<s>HuggingFace is creating a prototype that the community uses '
              'to solve NLP tasks.',
  'token': 17715,
  'token_str': 'Ġprototype'}]

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

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

TensorFlow

from transformers import TFAutoModelWithLMHead, AutoTokenizer
import tensorflow as tf
tokenizer = AutoTokenizer.from_pretrained("distilbert-base-cased")
model = TFAutoModelWithLMHead.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="tf")
mask_token_index = tf.where(input == tokenizer.mask_token_id)[0, 1]
token_logits = model(input)[0]
mask_token_logits = token_logits[0, mask_token_index, :]
top_5_tokens = tf.math.top_k(mask_token_logits, 5).indices.numpy()

PyTorch

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 (因果関係的) 言語モデリングはトークンのシークエンスに続くトークンを予測するタスクです。この状況では、モデルは左側のコンテキスト (マスクの左側のトークン) にのみ注意を払います。そのような訓練は生成タスクのための特に興味深いです。

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

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

TensorFlow

from transformers import TFAutoModelWithLMHead, AutoTokenizer, tf_top_k_top_p_filtering
import tensorflow as tf
tokenizer = AutoTokenizer.from_pretrained("gpt2")
model = TFAutoModelWithLMHead.from_pretrained("gpt2")
sequence = f"Hugging Face is based in DUMBO, New York City, and "
input_ids = tokenizer.encode(sequence, return_tensors="tf")
# get logits of last hidden state
next_token_logits = model(input_ids)[0][:, -1, :]
# filter
filtered_next_token_logits = tf_top_k_top_p_filtering(next_token_logits, top_k=50, top_p=1.0)
# sample
next_token = tf.random.categorical(filtered_next_token_logits, dtype=tf.int32, num_samples=1)
generated = tf.concat([input_ids, next_token], axis=1)
resulting_string = tokenizer.decode(generated.numpy().tolist()[0])

PyTorch

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

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

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

TensorFlow

from transformers import TFAutoModelWithLMHead, AutoTokenizer
model = TFAutoModelWithLMHead.from_pretrained("xlnet-base-cased")
tokenizer = AutoTokenizer.from_pretrained("xlnet-base-cased")
# Padding text helps XLNet with short prompts - proposed by Aman Rusia in https://github.com/rusiaaman/XLNet-gen#methodology
PADDING_TEXT = """In 1991, the remains of Russian Tsar Nicholas II and his family
(except for Alexei and Maria) are discovered.
The voice of Nicholas's young son, Tsarevich Alexei Nikolaevich, narrates the
remainder of the story. 1883 Western Siberia,
a young Grigori Rasputin is asked by his father and a group of men to perform magic.
Rasputin has a vision and denounces one of the men as a horse thief. Although his
father initially slaps him for making such an accusation, Rasputin watches as the
man is chased outside and beaten. Twenty years later, Rasputin sees a vision of
the Virgin Mary, prompting him to become a priest. Rasputin quickly becomes famous,
with people, even a bishop, begging for his blessing.   """
prompt = "Today the weather is really nice and I am planning on "
inputs = tokenizer.encode(PADDING_TEXT + prompt, add_special_tokens=False, return_tensors="tf")
prompt_length = len(tokenizer.decode(inputs[0], skip_special_tokens=True, clean_up_tokenization_spaces=True))
outputs = model.generate(inputs, max_length=250, do_sample=True, top_p=0.95, top_k=60)
generated = prompt + tokenizer.decode(outputs[0])[prompt_length:]

PyTorch

from transformers import AutoModelWithLMHead, AutoTokenizer
model = AutoModelWithLMHead.from_pretrained("xlnet-base-cased")
tokenizer = AutoTokenizer.from_pretrained("xlnet-base-cased")
# Padding text helps XLNet with short prompts - proposed by Aman Rusia in https://github.com/rusiaaman/XLNet-gen#methodology
PADDING_TEXT = """In 1991, the remains of Russian Tsar Nicholas II and his family
(except for Alexei and Maria) are discovered.
The voice of Nicholas's young son, Tsarevich Alexei Nikolaevich, narrates the
remainder of the story. 1883 Western Siberia,
a young Grigori Rasputin is asked by his father and a group of men to perform magic.
Rasputin has a vision and denounces one of the men as a horse thief. Although his
father initially slaps him for making such an accusation, Rasputin watches as the
man is chased outside and beaten. Twenty years later, Rasputin sees a vision of
the Virgin Mary, prompting him to become a priest. Rasputin quickly becomes famous,
with people, even a bishop, begging for his blessing.   """
prompt = "Today the weather is really nice and I am planning on "
inputs = tokenizer.encode(PADDING_TEXT + prompt, add_special_tokens=False, return_tensors="pt")
prompt_length = len(tokenizer.decode(inputs[0], skip_special_tokens=True, clean_up_tokenization_spaces=True))
outputs = model.generate(inputs, max_length=250, do_sample=True, top_p=0.95, top_k=60)
generated = prompt + tokenizer.decode(outputs[0])[prompt_length:]
print(generated)
Today the weather is really nice and I am planning on anning on taking a nice...... of a great time!...............

テキスト生成は現在 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 (PyTorch), run_pl_ner.py (pytorch-lightning を利用) or run_tf_ner.py (TensorFlow) スクリプトを利用して良いです。

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

  • O, 固有表現外 (= Outside of a named entity)
  • B-MIS, Beginning of a miscellaneous entity right after another miscellaneous entity
  • I-MIS, 種々雑多な (= Miscellaneous) エンティティ
  • 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)

それは 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 してそれをプリントします。

TensorFlow

from transformers import TFAutoModelForTokenClassification, AutoTokenizer
import tensorflow as tf
model = TFAutoModelForTokenClassification.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="tf")
outputs = model(inputs)[0]
predictions = tf.argmax(outputs, axis=2)

PyTorch

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

 

要約

要約はドキュメントや記事をより短いテキストに要約するタスクです。

要約データセットの例は 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) 上でだけ事前訓練されていますが、それは非常に良い結果を生成します。

TensorFlow

from transformers import TFAutoModelWithLMHead, AutoTokenizer
model = TFAutoModelWithLMHead.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="tf", max_length=512)
outputs = model.generate(inputs, max_length=150, min_length=40, length_penalty=2.0, num_beams=4, early_stopping=True)

PyTorch

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)

 

翻訳

翻訳は一つの言語から他のものへテキストを翻訳するタスクです。

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

ここに翻訳を行なうための 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))

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

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

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

TensorFlow

from transformers import TFAutoModelWithLMHead, AutoTokenizer
model = TFAutoModelWithLMHead.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="tf")
outputs = model.generate(inputs, max_length=40, num_beams=4, early_stopping=True)

PyTorch

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 3.3 : 哲学

HuggingFace Transformers 3.3 : 哲学 (翻訳/解説)

翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 10/16/2020 (3.3.1)

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

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

 

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

人工知能とビジネスをテーマにウェビナー (WEB セミナー) を定期的に開催しています。スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • Windows PC のブラウザからご参加が可能です。スマートデバイスもご利用可能です。

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

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

 

HuggingFace Transformers : 哲学

Transformers は以下のための意固地な (= opnionated) ライブラリです :

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

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

  • できる限り容易に高速に利用できるものである :
    • 学習する user-facing 抽象の数を強く制限しました、実際殆ど抽象はなく、モデルを利用するために必要な単に 3 つの標準的なクラス : configuration, modelstokenizer があるだけです。
    • これらのクラス総ては共通の from_pretrained() インスタンス化メソッドを使用することで単純で統一された方法で事前訓練インスタンスから初期化できます、これは Hugging Face ハブ や貴方自身のセーブされたチェックポイント上で提供される事前訓練されたチェックポイントから、 (必要であれば) ダウンロードを処理し、関連するクラス・インスタンスと関連データ (configurations のハイパーパラメータ, tokenizers の語彙とモデルの重み) をキャッシングしてロードします。
    • それら 3 つの基底クラスの上に、ライブラリは 2 つの API を提供します : 与えられたタスク上でモデル (加えて関連する tokenizer と configuration) を素早く使用するための pipeline() そして与えられたモデルを素早く訓練または再調整するための Trainer() / TFTrainer() です。
    • 結果として、このライブラリはニューラルネットのためのビルディング・ブロックのモジュール・ツールボックスでは ありません。ライブラリを拡張 / (その上で) 構築することを望むのであれば、通常の Python/PyTorch/TensorFlow/Keras モジュールを単に利用してそしてモデルロード/セーブのような機能を再利用するためにはライブラリの基底クラスから継承してください。
  • 元のモデルにできる限り近いパフォーマンスを持つ最先端技術のモデルを提供する :
    • 各アーキテクチャ毎に少なくとも一つのサンプルを提供します、これはそのアーキテクチャの公式作者により提供された結果を再生成します。
    • コードは通常は元のコードベースに出来る限り近いです、これはある PyTorch コードは pytorchic ではないかもしれないことを意味します、何故ならばそれは変換された TensorFlow コードの結果そしてその逆である可能性があるからです。

2, 3 の他のゴール :

  • モデルの内部をできる限り一貫性を持って公開する :
    • 単一の 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 つのメソッドを使用して pretrained インスタンスからインスタンス化できてローカルにセーブできます :

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

以上






HuggingFace Transformers 3.3 : クイック・ツアー

HuggingFace Transformers 3.3 : クイック・ツアー (翻訳/解説)

翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 10/15/2020 (3.3.1)

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

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

 

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

人工知能とビジネスをテーマにウェビナー (WEB セミナー) を定期的に開催しています。スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • Windows PC のブラウザからご参加が可能です。スマートデバイスもご利用可能です。

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

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

 

HuggingFace Transformers : クイック・ツアー

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 HuggingFace Transformers library.')

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

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

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) です、これはモデル自身をダウンロードするために使用します。他のタスク上でライブラリを使用していた場合には、モデルのクラスは変わるであろうことに注意してください。タスク要約 チュートリアルはどのクラスがどのタスクのためのに使用されるかを要約しています。

TensorFlow

from transformers import AutoTokenizer, TFAutoModelForSequenceClassification

PyTorch

from transformers import AutoTokenizer, AutoModelForSequenceClassification

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

TensorFlow

model_name = "nlptown/bert-base-multilingual-uncased-sentiment"
# This model only exists in PyTorch, so we use the `from_pt` flag to import that model in TensorFlow.
model = TFAutoModelForSequenceClassification.from_pretrained(model_name, from_pt=True)
tokenizer = AutoTokenizer.from_pretrained(model_name)
classifier = pipeline('sentiment-analysis', model=model, tokenizer=tokenizer)

PyTorch

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 メソッドを使用して作成されます :

TensorFlow

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

PyTorch

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 HuggingFace 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 に指定することができます :

TensorFlow

tf_batch = tokenizer(
    ["We are very happy to show you the HuggingFace Transformers library.", "We hope you don't hate it."],
    padding=True,
    truncation=True,
    return_tensors="tf"
)

PyTorch

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

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

TensorFlow

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

PyTorch

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

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

 

モデルを使用する

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

TensorFlow

tf_outputs = tf_model(tf_batch)

PyTorch

pt_outputs = pt_model(**pt_batch)

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

TensorFlow

print(tf_outputs)
(<tf.Tensor: shape=(2, 2), dtype=float32, numpy=
array([[-4.0832963 ,  4.336414  ],
       [ 0.08181786, -0.04179301]], dtype=float32)>,)

PyTorch

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

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

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

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

TensorFlow

import tensorflow as tf
tf_predictions = tf.nn.softmax(tf_outputs[0], axis=-1)

PyTorch

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

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

TensorFlow

print(tf_predictions)
tf.Tensor(
[[2.2042994e-04 9.9977952e-01]
 [5.3086340e-01 4.6913657e-01]], shape=(2, 2), dtype=float32)

PyTorch

print(pt_predictions)
tensor([[2.2043e-04, 9.9978e-01],
        [5.3086e-01, 4.6914e-01]], grad_fn=)

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

TensorFlow

import tensorflow as tf
tf_outputs = tf_model(tf_batch, labels = tf.constant([1, 0]))

PyTorch

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

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

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

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

それからモデル名の代わりにディレクトリ名を渡すことにより from_pretrained() メソッドを使用してモデルをロードし戻すことができます。HuggingFace 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 重みを返すように (もし貴方がそれらを必要とするならば) モデルに要求することもできます :

TensorFlow

tf_outputs = tf_model(tf_batch, output_hidden_states=True, output_attentions=True)
all_hidden_states, all_attentions = tf_outputs[-2:]

PyTorch

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

 

コードにアクセスする

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

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

TensorFlow

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

PyTorch

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 からモデルをインスタンス化します)。

TensorFlow

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

PyTorch

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 を更新します :

TensorFlow

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

PyTorch

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 3.3 : 概要

HuggingFace Transformers 3.3 概要 (翻訳/解説)

翻訳 : (株)クラスキャット セールスインフォメーション
作成日時 : 10/13/2020 (3.3.1)

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

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

 

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

人工知能とビジネスをテーマにウェビナー (WEB セミナー) を定期的に開催しています。スケジュールは弊社 公式 Web サイト でご確認頂けます。
  • お住まいの地域に関係なく Web ブラウザからご参加頂けます。事前登録 が必要ですのでご注意ください。
  • Windows PC のブラウザからご参加が可能です。スマートデバイスもご利用可能です。

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

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

 

HuggingFace Transformers : 概要

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

  • Transformers は 100+ 言語の分類、情報抽出、質問応答、要約、翻訳、テキスト生成等のテキスト上のタスクを遂行するために数千の事前訓練モデルを提供します。その目的は最先端の NLP を誰でも利用できるように容易にすることです。
  • Transformers はそれらの事前訓練モデルを素早くダウンロードして与えられたテキスト上で利用し、それらを貴方自身のデータセット上で再調整して、それからそれらを私達の モデル・ハブ 上でコミュニティと共有するための API を提供します。同時に、アーキテクチャを定義する各 python モジュールは素早い研究実験を可能にするためスタンドアロンとして利用できて変更できます。
  • Transformers は 2 つの最もポピュラーな深層学習ライブラリ PyTorch と TensorFlow により、それらの間のシームレスな統合によって支援され、その一つでモデルを訓練してから推論のために他方でそれをロードすることを許容します。

 

オンライン・デモ

私達のモデルの殆どを モデルハブ のそれらのページから直接テストすることができます。それらのモデルを利用する推論 API も供給します。

ここに少しのサンプルがあります :

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.ModuleTensorFlow 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 は現在以下のアーキテクチャを提供しています (それらの各々の高位な要約は ここ を参照) :

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

  4. 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.

  5. 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.

  6. 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.

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

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

  9. 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.

  10. 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.

  11. 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.

  12. 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.

  13. 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.

  14. 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.

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

  16. 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**.

  17. 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.

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

  19. 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.

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

  21. 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.

  22. 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.

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

  24. 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.

  25. 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.

  26. 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.

  27. 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.

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

  29. 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.

  30. 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.

  31. Other community models, contributed by the community.

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

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

 

更に学習する

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

 

Citation

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

 

以上






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

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