bertダウンロードbertソースコードのダウンロード

バート

***** 2020年3月11日：より小さなバートモデル*****

これは、よく読まれた学生で参照されている24の小さいBertモデル（英語のみ、WordPieceマスキングで訓練された訓練を受けたもの）のリリースです。

標準的なBERTレシピ（モデルアーキテクチャとトレーニングの目的を含む）は、Bert-BaseやBert-Largeを超えて、幅広いモデルサイズに有効であることを示しました。より小さなBERTモデルは、計算リソースが制限された環境を対象としています。それらは、元のBertモデルと同じ方法で微調整できます。ただし、微調整されたラベルがより大きくより正確な教師によって生成される知識の蒸留の文脈で最も効果的です。

私たちの目標は、計算リソースが少ない機関での研究を可能にし、コミュニティがモデル能力の向上に代わるイノベーションの方向を求めるよう奨励することです。

ここから24すべてをダウンロードするか、以下の表から個別にダウンロードできます。

	H = 128	H = 256	H = 512	H = 768
L = 2	2/128（バートタニー）	2/256	2/512	2/768
L = 4	4/128	4/256（バートミニ）	4/512（Bert-Small）	4/768
L = 6	6/128	6/256	6/512	6/768
L = 8	8/128	8/256	8/512（Bert-Medium）	8/768
L = 10	10/128	10/256	10/512	10/768
L = 12	12/128	12/256	12/512	12/768（バートベース）

このリリースのBert-Baseモデルは、完全性のみでのみ含まれていることに注意してください。元のモデルと同じ体制の下で再訓練されました。

テストセットの対応する接着剤スコアは次のとおりです。

モデル	スコア	コーラ	SST-2	MRPC	sts-b	QQP	mnli-m	mnli-mm	Qnli（V2）	rte	wnli	斧
バートタニー	64.2	0.0	83.2	81.1/71.1	74.3/73.6	62.2/83.4	70.2	70.3	81.5	57.2	62.3	21.0
バートミニ	65.8	0.0	85.9	81.1/71.8	75.4/73.3	66.4/86.2	74.8	74.3	84.1	57.9	62.3	26.1
バート・スモール	71.2	27.8	89.7	83.4/76.2	78.8/77.0	68.1/87.0	77.6	77.0	86.4	61.8	62.3	28.6
バートメディアム	73.5	38.0	89.6	86.6/81.6	80.4/78.4	69.6/87.9	80.0	79.1	87.7	62.2	62.3	30.5

各タスクについて、以下のリストから最高の微調整ハイパーパラメーターを選択し、4つのエポックのトレーニングを受けました。

バッチサイズ：8、16、32、64、128
学習率：3E-4、1E-4、5E-5、3E-5

これらのモデルを使用する場合は、次の論文を引用してください。

 @article{turc2019,
  title={Well-Read Students Learn Better: On the Importance of Pre-training Compact Models},
  author={Turc, Iulia and Chang, Ming-Wei and Lee, Kenton and Toutanova, Kristina},
  journal={arXiv preprint arXiv:1908.08962v2 },
  year={2019}
}

*****新しい2019年5月31日：ワードマスキングモデル全体*****

これは、前処理コードの改善の結果であるいくつかの新しいモデルのリリースです。

元の前処理コードでは、ワードピーストークンをランダムにマスクします。例えば：

Input Text: the man jumped up , put his basket on phil ##am ##mon ' s head Original Masked Input: [MASK] man [MASK] up , put his [MASK] on phil [MASK] ##mon ' s head

新しいテクニックは、全体のマスキングと呼ばれます。この場合、一度に単語に対応するすべてのトークンを常にマスクします。全体的なマスキングレートは同じままです。

Whole Word Masked Input: the man [MASK] up , put his basket on [MASK] [MASK] [MASK] ' s head

トレーニングは同一です - まだマスクされた各ワードピーストークンを独立して予測しています。改善は、元の予測タスクが複数のワードピースに分割された単語に対して「簡単」であったという事実に起因します。

これは、Flagを渡すことにより、データ生成中に有効にすることができます--do_whole_word_mask=True create_pretraining_data.pyにtrueになります。

単語マスキング全体を使用した事前に訓練されたモデルを以下にリンクします。それ以外の場合は、データとトレーニングは同一であり、モデルには元のモデルと同じ構造と語彙があります。 Bert-Largeモデルのみが含まれています。これらのモデルを使用する場合は、Bert-Largeの単語マスキングバリアント全体を使用していることを論文で明確にしてください。

BERT-Large, Uncased (Whole Word Masking) ：24層、1024距離、16頭、340mパラメーター
BERT-Large, Cased (Whole Word Masking) ：24層、1024距離、16頭、340mパラメーター

モデル	分隊1.1 f1/em	マルチnli精度
バート・ラージ、覆われている（オリジナル）	91.0/84.3	86.05
Bert-Large、Nocased（全体のワードマスキング）	92.8/86.7	87.07
バート・ラージ、ケース（オリジナル）	91.5/84.8	86.09
Bert-Large、Cased（全体のワードマスキング）	92.9/86.7	86.46

***** 2019年2月7日：TFHUBモジュール*****

BertはTensorflow Hubにアップロードされました。 TFハブモジュールの使用方法の例については、 run_classifier_with_tfhub.py参照してください。

*****新しい2018年11月23日：非正規化された多言語モデル +タイ +モンゴル*****

入力に正規化を実行しない新しい多言語モデル（低いケーシング、アクセントストリッピング、ユニコードの正規化なし）をアップロードし、さらにタイとモンゴル語を含む。

このバージョンを使用して、特にラチン以外のアルファベットを持つ言語で多言語モデルを開発するために使用することをお勧めします。

これにはコードの変更は必要ありません。ここからダウンロードできます。

BERT-Base, Multilingual Cased ：104言語、12層、768層、12頭、110mパラメーター

*****新しい2018年11月15日：Sota Squad 2.0 System *****

コード変更をリリースして、83％F1 Squad 2.0システムを再現しました。これは現在、リーダーボードの1位が3％です。詳細については、READMEのSquad 2.0セクションを参照してください。

***** 2018年11月5日：サードパーティのPytorchおよびChaenerバージョンのBert利用可能*****

HuggingfaceのNLP研究者は、事前に訓練されたチェックポイントと互換性があり、結果を再現できるPytorchバージョンのBertバージョンを利用可能にしました。コバヤシはまた、Bertのチェーンバージョンを利用可能にしました（ありがとう！）Pytorchの実装の作成や維持に関与していなかったので、そのリポジトリの著者に質問してください。

***** 2018年11月3日：多言語および中国のモデルが利用可能*****

2つの新しいBertモデルを利用可能にしました。

BERT-Base, Multilingual （推奨されない、代わりにMultilingual Casedを使用する） ：102言語、12層、768人、12頭、110mパラメーター
BERT-Base, Chinese ：中国語の簡素化された伝統的な12層、768層、12頭、110mパラメーター

中国語にはキャラクターベースのトークン化、および他のすべての言語にワードピーストークン化を使用しています。両方のモデルは、コードを変更せずにすぐに機能する必要があります。漢字のトークン化をサポートするために、 BasicTokenizerの実装をtokenization.pyに更新しました。ただし、トークン化APIは変更しませんでした。

詳細については、多言語のreadmeを参照してください。

*****新しい情報を終了*****

導入

Bert 、またはbRansformers ransformersからの慣習的な概念は、幅広い自然言語処理（NLP）タスクで最先端の結果を得る、事前トレーニング前の言語表現の新しい方法です。

Bertを詳細に説明し、多くのタスクに関する完全な結果を提供する私たちのアカデミックペーパーは、https：//arxiv.org/abs/1810.04805にあります。

いくつかの数字を与えるために、Squad v1.1質問に答えるタスクの結果を次に示します。

Squad V1.1リーダーボード（2018年10月8日）	テストem	F1をテストします
1位のアンサンブル - バート	87.4	93.2
2位のアンサンブル-NLNET	86.0	91.7
1位のシングルモデル-BERT	85.1	91.8
2位のシングルモデル-NLNET	83.5	90.1

そして、いくつかの自然言語の推論タスク：

システム	Multinli	質問nli	みやげ品
バート	86.7	91.1	86.3
Openai gpt（prev。sota）	82.2	88.1	75.0

さらに、他の多くのタスク。

さらに、これらの結果はすべて、タスク固有のニューラルネットワークアーキテクチャの設計がほとんどない状態で得られました。

Bertとは何かを既に知っていて、開始したいだけなら、事前に訓練されたモデルをダウンロードして、わずか数分で最先端の微調整を実行できます。

バートとは何ですか？

バートは、トレーニング前の言語表現の方法です。つまり、大きなテキストコーパス（Wikipediaなど）で汎用の「言語理解」モデルを訓練し、そのモデルを使用して、気にする下流のNLPタスクに使用します（質問のように回答）。 Bertは以前の方法を上回ります。これは、訓練前のNLPのための最初の監視なしで深く双方向性システムであるためです。

監視されていないことは、バートがプレーンテキストコーパスのみを使用して訓練されたことを意味します。これは、多くの言語で膨大な量のプレーンテキストデータがウェブ上で公開されているため、重要です。

事前に訓練された表現は、コンテキストフリーまたはコンテキストのいずれかであり、コンテキスト表現はさらに一方向または双方向にすることができます。 Word2Vecやグローブなどのコンテキストフリーモデルは、語彙の各単語の単一の「単語埋め込み」表現を生成するため、 bank bank depositとriver bankで同じ表現を持っています。代わりに、文脈モデルは、文の他の単語に基づいた各単語の表現を生成します。

Bertは、最近のトレーニング前のコンテキスト表現の作業に基づいて構築されました。これは、半学習シーケンス学習、生成前トレーニング、ELMO、およびULMFITなどですが、重要なことにこれらのモデルはすべて一方向または浅い方向です。これは、各単語がその左（または右）にある単語を使用して文脈化されていることを意味します。たとえば、 I made a bank deposit文では、 bankの一方向の表現はI made a depositではなく作成しただけに基づいています。いくつかの以前の研究では、別の左コンテキストモデルと右コンテキストモデルからの表現を組み合わせていますが、「浅い」方法でのみです。 Bertは、左右のコンテキストの両方を使用して「銀行」を表しています - I made a ... deposit - 深いニューラルネットワークの最下部から始まるので、それは深く双方向です。

Bertはこれに簡単なアプローチを使用します。入力の単語の15％をマスクし、深い双方向トランスエンコーダーを介してシーケンス全体を実行し、マスクされた単語のみを予測します。例えば：

 Input: the man went to the [MASK1] . he bought a [MASK2] of milk.
Labels: [MASK1] = store; [MASK2] = gallon

文の間の関係を学ぶために、任意の単一言語のコーパスから生成できる簡単なタスクについても訓練します。2つの文AとBを与えられると、 B A後に来る実際の次の文、またはコーパスからのランダムな文です。？

 Sentence A: the man went to the store .
Sentence B: he bought a gallon of milk .
Label: IsNextSentence

 Sentence A: the man went to the store .
Sentence B: penguins are flightless .
Label: NotNextSentence

次に、大きなコーパス（Wikipedia + BookCorpus）で大きなモデル（12層から24層変圧器）を長時間（1Mアップデートステップ）訓練し、それはBertです。

BERTの使用には、トレーニング前と微調整の2つの段階があります。

トレーニング前はかなり高価（4〜16クラウドTPUで4日間）ですが、各言語の1回限りの手順です（現在のモデルは英語のみですが、近い将来に多言語モデルがリリースされます）。 Googleで事前に訓練された紙から多くの事前訓練を受けたモデルをリリースしています。ほとんどのNLP研究者は、独自のモデルをゼロから事前に訓練する必要はありません。

微調整は安価です。論文のすべての結果は、1つのクラウドTPUで最大1時間、またはまったく同じ事前に訓練されたモデルから始まるGPUで数時間で複製できます。たとえば、分隊は、単一のクラウドTPUで約30分でトレーニングを行い、91.0％のDEV F1スコアを達成できます。これは、最先端の単一システムです。

Bertのもう1つの重要な側面は、多くの種類のNLPタスクに非常に簡単に適応できることです。論文では、文レベル（例えば、SST-2）、文ペアレベル（例、MultiNli）、単語レベル（例えば、NER）、およびスパンレベルに関する最先端の結果を示します。（例、分隊）タスク固有の変更がほとんどないタスク。

このリポジトリでリリースされたものは何ですか？

以下をリリースしています。

BERTモデルアーキテクチャ用のTensorflowコード（主に標準トランスアーキテクチャです）。
BERT-BaseとBERT-Largeの小文字とCasedバージョンの両方の事前訓練を受けたチェックポイント。
Squad、Multinli、MRPCを含む、紙からの最も重要な微調整実験のプッシュボタン複製のTensorflowコード。

このリポジトリのすべてのコードは、CPU、GPU、およびCloud TPUですぐに機能します。

事前に訓練されたモデル

紙からBERT-BaseおよびBERT-Largeモデルをリリースしています。 Uncasedということは、ワードピーストークン化の前にテキストが低くなっていることを意味します。たとえば、 John Smith john smithになります。また、 Uncasedモデルは、アクセントマーカーも取り除きます。 Cased真のケースとアクセントマーカーが保存されることを意味します。通常、ケース情報がタスクにとって重要であることを知っていない限り、 Uncasedモデルはより優れています（例えば、エンティティ認識またはスピーチの一部のタグ付け）。

これらのモデルはすべて、ソースコード（Apache 2.0）と同じライセンスの下でリリースされます。

多言語および中国のモデルの詳細については、多言語ReadMeを参照してください。

ケース付きモデルを使用する場合は、トレーニングスクリプトに--do_lower=False渡すようにしてください。（または、独自のスクリプトを使用している場合、 do_lower_case=False FullTokenizerに直接falseを渡します。）

モデルへのリンクはここにあります（右クリック、「リンクを...」という名前の上に保存）：

BERT-Large, Uncased (Whole Word Masking) ：24層、1024距離、16頭、340mパラメーター
BERT-Large, Cased (Whole Word Masking) ：24層、1024距離、16頭、340mパラメーター
BERT-Base, Uncased ：12層、768人の隠れ家、12頭、110mパラメーター
BERT-Large, Uncased ：24層、1024層、16頭、340mパラメーター
BERT-Base, Cased ：12層、768距離、12頭、110mパラメーター
BERT-Large, Cased ：24層、1024層、16頭、340mパラメーター
BERT-Base, Multilingual Cased (New, recommended) ：104言語、12層、768層、12頭、110mパラメーター
BERT-Base, Multilingual Uncased (Orig, not recommended) （推奨されない、代わりにMultilingual Casedを使用） ：102言語、12層、768人、12頭、110mパラメーター
BERT-Base, Chinese ：中国語の簡素化された伝統的な12層、768層、12頭、110mパラメーター

各.zipファイルには3つの項目が含まれています。

事前に訓練された重み（実際には3つのファイル）を含むTensorflowチェックポイント（ bert_model.ckpt ）。
wordpieceにワードIDにマッピングするvocabファイル（ vocab.txt ）。
モデルのハイパーパラメーターを指定する構成ファイル（ bert_config.json ）。

バートとの微調整

重要：紙のすべての結果は、64GBのRAMを持つ単一のクラウドTPUで微調整されました。現在、メモリに収まる最大バッチサイズが小さすぎるため、12GB-16GBのRAMを使用してGPUを使用して、紙のほとんどのBERT-Large結果を紙に再現することはできません。このリポジトリにコードを追加することに取り組んでおり、GPUではるかに大きな効果的なバッチサイズを可能にします。詳細については、メモリ外の問題に関するセクションを参照してください。

このコードは、Tensorflow 1.11.0でテストされました。 Python2とPython3でテストされました（ただし、Googleで内部で使用されるものであるため、Python2でより徹底的にテストされました）。

BERT-Base使用する微調整の例は、与えられたハイパーパラメーターを使用して少なくとも12GBのRAMを備えたGPUで実行できる必要があります。

クラウドTPUで微調整

以下の例のほとんどは、Titan XやGTX 1080などのGPUを使用して、ローカルマシンでトレーニング/評価を実行することを前提としています。

ただし、トレーニングしたいクラウドTPUにアクセスできる場合は、次のフラグをrun_classifier.pyまたはrun_squad.pyに追加するだけです。

  --use_tpu=True 
  --tpu_name=$TPU_NAME

クラウドTPUの使用方法については、Google Cloud TPUチュートリアルをご覧ください。または、Google Colab Notebook「Bert Finetuning with Cloud TPU」を使用できます。

Cloud TPUでは、前提条件のモデルと出力ディレクトリはGoogle Cloudストレージ上にある必要があります。たとえば、 some_bucketという名前のバケツがある場合、代わりに次のフラグを使用できます。

  --output_dir=gs://some_bucket/my_output_dir/

解凍された事前に訓練されたモデルファイルは、Googleクラウドストレージフォルダーgs://bert_models/2018_10_18にもあります。例えば：

 export BERT_BASE_DIR=gs://bert_models/2018_10_18/uncased_L-12_H-768_A-12

文（および文章）分類タスク

この例を実行する前に、このスクリプトを実行して接着剤データをダウンロードして、ディレクトリ$GLUE_DIRに解凍する必要があります。次に、 BERT-Baseチェックポイントをダウンロードして、いくつかのディレクトリ$BERT_BASE_DIRに解凍します。

この例コードコードMicrosoft Research Paraphrase Corpus（MRPC）コーパスのBERT-Baseは、3,600の例しか含まれておらず、ほとんどのGPUで数分で微調整できます。

 export BERT_BASE_DIR=/path/to/bert/uncased_L-12_H-768_A-12
export GLUE_DIR=/path/to/glue

python run_classifier.py 
  --task_name=MRPC 
  --do_train=true 
  --do_eval=true 
  --data_dir= $GLUE_DIR /MRPC 
  --vocab_file= $BERT_BASE_DIR /vocab.txt 
  --bert_config_file= $BERT_BASE_DIR /bert_config.json 
  --init_checkpoint= $BERT_BASE_DIR /bert_model.ckpt 
  --max_seq_length=128 
  --train_batch_size=32 
  --learning_rate=2e-5 
  --num_train_epochs=3.0 
  --output_dir=/tmp/mrpc_output/

このような出力が表示されるはずです：

 ***** Eval results *****
  eval_accuracy = 0.845588
  eval_loss = 0.505248
  global_step = 343
  loss = 0.505248

これは、開発セットの精度が84.55％だったことを意味します。 MRPCのような小さなセットは、同じトレーニング前のチェックポイントから開始する場合でも、DEVセットの精度に高いばらつきがあります。複数回再実行すると（別のoutput_dirを指す）、84％から88％の結果が表示されるはずです。

run_classifier.pyで他のいくつかの事前に訓練されたモデルが既製で実装されているため、これらの例に従って、単一文または文章分類タスクにBERTを使用することは簡単です。

注： Running train on CPUメッセージが表示される場合があります。これは本当に、GPUを含むクラウドTPU以外の何かで実行されていることを意味します。

分類器からの予測

分類器をトレーニングしたら、-do_predict = trueコマンドを使用して、推論モードで使用できます。入力フォルダーにtest.tsvという名前のファイルが必要です。出力は、出力フォルダーのtest_results.tsvというファイルで作成されます。各ラインには各サンプルの出力が含まれ、列はクラスの確率です。

 export BERT_BASE_DIR=/path/to/bert/uncased_L-12_H-768_A-12
export GLUE_DIR=/path/to/glue
export TRAINED_CLASSIFIER=/path/to/fine/tuned/classifier

python run_classifier.py 
  --task_name=MRPC 
  --do_predict=true 
  --data_dir= $GLUE_DIR /MRPC 
  --vocab_file= $BERT_BASE_DIR /vocab.txt 
  --bert_config_file= $BERT_BASE_DIR /bert_config.json 
  --init_checkpoint= $TRAINED_CLASSIFIER 
  --max_seq_length=128 
  --output_dir=/tmp/mrpc_output/

分隊1.1

Stanfordの質問Dataset（Squad）は、ベンチマークデータセットに答える人気のある質問です。 Bert（リリースの時点で）は、タスク固有のネットワークアーキテクチャの変更やデータ増強がほとんどなく、チームで最先端の結果を取得します。ただし、（a）分隊のコンテキスト段落の可変性の性質、および（b）分隊トレーニングに使用される文字レベルの回答注釈を扱うために、半複雑なデータの前処理と後処理が必要です。この処理は、 run_squad.pyに実装および文書化されています。

チームで実行するには、最初にデータセットをダウンロードする必要があります。分隊のウェブサイトは、V1.1データセットにはもうリンクしていないようですが、必要なファイルはここにあります。

Train-V1.1.json
dev-v1.1.json
Evaluate-V1.1.py

これらをいくつかのディレクトリ$SQUAD_DIRにダウンロードしてください。

メモリの制約のため、現在、紙の最先端のチームの結果は12GB-16GB GPUで再現できません（実際、バッチサイズ1でさえ、 BERT-Large使用して12GB GPUには適合しないようです）。ただし、これらのハイパーパラメーターを使用して、GPUでかなり強力なBERT-Baseモデルをトレーニングできます。

python run_squad.py 
  --vocab_file= $BERT_BASE_DIR /vocab.txt 
  --bert_config_file= $BERT_BASE_DIR /bert_config.json 
  --init_checkpoint= $BERT_BASE_DIR /bert_model.ckpt 
  --do_train=True 
  --train_file= $SQUAD_DIR /train-v1.1.json 
  --do_predict=True 
  --predict_file= $SQUAD_DIR /dev-v1.1.json 
  --train_batch_size=12 
  --learning_rate=3e-5 
  --num_train_epochs=2.0 
  --max_seq_length=384 
  --doc_stride=128 
  --output_dir=/tmp/squad_base/

DEVセットの予測は、 output_dirのpredictions.jsonというファイルに保存されます：

python $SQUAD_DIR /evaluate-v1.1.py $SQUAD_DIR /dev-v1.1.json ./squad/predictions.json

このような出力を生成するはずです。

{ " f1 " : 88.41249612335034, " exact_match " : 81.2488174077578}

BERT-Baseの論文で報告されている88.5％に似た結果が表示されます。

クラウドTPUにアクセスできる場合は、 BERT-Largeでトレーニングできます。以下は、分隊でのみ訓練された約90.5％-91.0％F1単一システムを一貫して取得するハイパーパラメータ（紙とわずかに異なる）のセットです。

python run_squad.py 
  --vocab_file= $BERT_LARGE_DIR /vocab.txt 
  --bert_config_file= $BERT_LARGE_DIR /bert_config.json 
  --init_checkpoint= $BERT_LARGE_DIR /bert_model.ckpt 
  --do_train=True 
  --train_file= $SQUAD_DIR /train-v1.1.json 
  --do_predict=True 
  --predict_file= $SQUAD_DIR /dev-v1.1.json 
  --train_batch_size=24 
  --learning_rate=3e-5 
  --num_train_epochs=2.0 
  --max_seq_length=384 
  --doc_stride=128 
  --output_dir=gs://some_bucket/squad_large/ 
  --use_tpu=True 
  --tpu_name= $TPU_NAME

たとえば、これらのパラメーターを使用して1つのランダムに実行されると、次のDEVスコアが生成されます。

{ " f1 " : 90.87081895814865, " exact_match " : 84.38978240302744}

Triviaqaで1つのエポックを微調整する前に、結果はさらに良くなりますが、TriviaqaをSquad JSON形式に変換する必要があります。

分隊2.0

このモデルは、 run_squad.pyにも実装および文書化されています。

Squad 2.0で実行するには、最初にデータセットをダウンロードする必要があります。必要なファイルはここにあります：

Train-V2.0.json
dev-v2.0.json
Evaluate-V2.0.py

これらをいくつかのディレクトリ$SQUAD_DIRにダウンロードしてください。

クラウドTPUでは、次のようにBert-Largeで実行できます。

python run_squad.py 
  --vocab_file= $BERT_LARGE_DIR /vocab.txt 
  --bert_config_file= $BERT_LARGE_DIR /bert_config.json 
  --init_checkpoint= $BERT_LARGE_DIR /bert_model.ckpt 
  --do_train=True 
  --train_file= $SQUAD_DIR /train-v2.0.json 
  --do_predict=True 
  --predict_file= $SQUAD_DIR /dev-v2.0.json 
  --train_batch_size=24 
  --learning_rate=3e-5 
  --num_train_epochs=2.0 
  --max_seq_length=384 
  --doc_stride=128 
  --output_dir=gs://some_bucket/squad_large/ 
  --use_tpu=True 
  --tpu_name= $TPU_NAME 
  --version_2_with_negative=True

出力ディレクトリから./squad/というローカルディレクトリまですべてをコピーしたと思います。初期の開発セットの予測は./squad/predictions.jsonで行われ、各質問のスコア（ ""）のスコア（ ""）の違いはファイルにあります。/squad/null_odds.json

このスクリプトを実行して、ヌルと非ヌルの回答を予測するためのしきい値をチューニングします。

python $ squad_dir/evaluate-v2.0.py $ squad_dir/dev-v2.0.json ./squad/predictions.json -na-prob-file ./squad/null_odds.json

スクリプトが「best_f1_thresh」しきい出力を出力すると仮定します。（典型的な値は-1.0から-5.0の間です）。これで、モデルを再実行して派生したしきい値で予測を生成できます。または、。/squad/nbest_predictions.jsonから適切な回答を抽出できます。

python run_squad.py 
  --vocab_file= $BERT_LARGE_DIR /vocab.txt 
  --bert_config_file= $BERT_LARGE_DIR /bert_config.json 
  --init_checkpoint= $BERT_LARGE_DIR /bert_model.ckpt 
  --do_train=False 
  --train_file= $SQUAD_DIR /train-v2.0.json 
  --do_predict=True 
  --predict_file= $SQUAD_DIR /dev-v2.0.json 
  --train_batch_size=24 
  --learning_rate=3e-5 
  --num_train_epochs=2.0 
  --max_seq_length=384 
  --doc_stride=128 
  --output_dir=gs://some_bucket/squad_large/ 
  --use_tpu=True 
  --tpu_name= $TPU_NAME 
  --version_2_with_negative=True 
  --null_score_diff_threshold= $THRESH

メモリ外の問題

紙のすべての実験は、64GBのデバイスRAMを備えたクラウドTPUで微調整されています。したがって、12GB-16GBのRAMでGPUを使用する場合、論文で説明されているのと同じハイパーパラメーターを使用すると、メモリ外の問題に遭遇する可能性があります。

メモリの使用に影響を与える要因は次のとおりです。

max_seq_length ：リリースされたモデルは、最大512までのシーケンス長でトレーニングされましたが、より短いMAXシーケンス長で微調整して実質的なメモリを保存できます。これは、サンプルコードのmax_seq_lengthフラグによって制御されます。
train_batch_size ：メモリ使用量は、バッチサイズにも直接比例します。
モデルタイプ、 BERT-Base vs. BERT-Large ： BERT-Largeモデルには、 BERT-Baseよりもかなり多くのメモリが必要です。
Optimizer ：BertのデフォルトのオプティマイザーはAdamです。これには、 mおよびvベクトルを保存するために多くの追加メモリが必要です。よりメモリ効率的なオプティマイザーに切り替えると、メモリの使用量が減少する可能性がありますが、結果にも影響を与える可能性があります。微調整のための他のオプティマザーを試していません。

デフォルトのトレーニングスクリプト（ run_classifier.pyおよびrun_squad.py ）を使用して、Tensorflow 1.11.0でシングルタイタンX GPU（12GB RAM）の最大バッチサイズをベンチマークしました。

システム	seqの長さ	最大バッチサイズ
`BERT-Base`	64	64
...	128	32
...	256	16
...	320	14
...	384	12
...	512	6
`BERT-Large`	64	12
...	128	6
...	256	2
...	320	1
...	384	0
...	512	0

残念ながら、 BERT-Large用のこれらの最大バッチサイズは非常に小さいため、使用される学習率に関係なく、実際にモデルの精度に害を及ぼします。このリポジトリにコードを追加することに取り組んでおり、GPUではるかに大きな効果的なバッチサイズを使用できるようにします。コードは、次の手法の1つ（または両方）に基づいています。

勾配蓄積：ミニバッチ内のサンプルは、通常、勾配計算に関して独立しています（ここでは使用されていないバッチ正規化を除く）。これは、複数の小さなミニバッチの勾配を蓄積する前に蓄積することができることを意味し、これは単一の大きなアップデートとまったく同じです。
勾配チェックポイント：DNNトレーニング中のGPU/TPUメモリの主要な使用は、バックワードパスでの効率的な計算に必要なフォワードパスの中間アクティブ化をキャッシュすることです。「グラデーションチェックポイント」は、インテリジェントな方法でアクティベーションを再計算することにより、メモリを計算時間と交換します。

ただし、これは現在のリリースには実装されていません。

BERTを使用して固定機能ベクターを抽出します（ELMOなど）

特定の場合、事前に訓練されたモデルエンドツーエンド全体を微調整するのではなく、事前に訓練されたコンテキスト埋め込みを取得することは有益です。 - 訓練されたモデル。これにより、メモリ外の問題のほとんどが軽減されるはずです。

例として、このように使用できるスクリプトextract_features.pyを含めます。

 # Sentence A and Sentence B are separated by the ||| delimiter for sentence
# pair tasks like question answering and entailment.
# For single sentence inputs, put one sentence per line and DON'T use the
# delimiter.
echo ' Who was Jim Henson ? ||| Jim Henson was a puppeteer ' > /tmp/input.txt

python extract_features.py 
  --input_file=/tmp/input.txt 
  --output_file=/tmp/output.jsonl 
  --vocab_file= $BERT_BASE_DIR /vocab.txt 
  --bert_config_file= $BERT_BASE_DIR /bert_config.json 
  --init_checkpoint= $BERT_BASE_DIR /bert_model.ckpt 
  --layers=-1,-2,-3,-4 
  --max_seq_length=128 
  --batch_size=8

これにより、 layersで指定された各変圧器層からのBERTアクティベーションを含むJSONファイル（入力1行ごとに1行）が作成されます（-1はトランスの最終的な隠れ層など）

このスクリプトは、非常に大きな出力ファイルを作成することに注意してください（デフォルトでは、入力トークンごとに約15kb）。

元の単語とトークン化された単語の間のアラインメントを維持する必要がある場合（トレーニングラベルを投影する場合）、以下のトークン化セクションを参照してください。

注： Could not find trained model in model_dir: /tmp/tmpuB5g5c, running initialization to predict.このメッセージが予想されます。これは、保存されたモデルAPIではなくinit_from_checkpoint() APIを使用していることを意味します。チェックポイントを指定したり、無効なチェックポイントを指定しない場合、このスクリプトは文句を言います。

トークン化

文レベルのタスク（または文ペア）タスクの場合、トークン化は非常に簡単です。 run_classifier.pyおよびextract_features.pyのサンプルコードに従ってください。文レベルのタスクの基本的な手順は次のとおりです。

tokenizer = tokenization.FullTokenizerのインスタンスをインスタンスします
tokens = tokenizer.tokenize(raw_text)で生のテキストをトークン化します。
最大シーケンス長に切り捨てます。（最大512を使用できますが、メモリとスピードの理由で可能であれば短い場合はおそらく使用する必要があります。）
[CLS]と[SEP]トークンを適切な場所に追加します。

トレーニングラベルを投影できるように入力テキストと出力テキスト間のアラインメントを維持する必要があるため、単語レベルおよびスパンレベルのタスク（たとえば、分隊やNER）はより複雑です。入力ラベルは文字ベースであり、分隊の段落は最大シーケンス長よりも長いことが多いため、分隊は特に複雑な例です。 run_squad.pyのコードを参照して、これをどのように処理するかを示してください。

単語レベルのタスクを処理するための一般的なレシピを説明する前に、トークネイザーが何をしているのかを正確に理解することが重要です。 3つの主な手順があります。

テキストの正規化：すべての空白文字をスペースに変換し、（ Uncasedモデルの場合）は、入力を除去し、アクセントマーカーを取り除きます。たとえば、 John Johanson's, → john johanson's, 。
句読点の分割：両側のすべての句読点文字を分割します（つまり、すべての句読点の周りに白文学を追加します）。句読文字は、（a） P* unicodeクラスを持つもの、（b）非文字/スペース/スペースASCII文字（たとえば、技術的には句読点ではない$のような文字）として定義されます。たとえば、 john johanson's, → john johanson ' s ,
WordPieceトークン化：上記の手順の出力にWhitespaceトークン化を適用し、各トークンに個別にワードピーストークン化を適用します。（当社の実装は、リンクされているtensor2tensorのものに直接基づいています）。たとえば、 john johanson ' s , → john johan ##son ' s ,

このスキームの利点は、ほとんどの既存の英語トークナーと「互換性がある」ことです。たとえば、このように見えるスピーチの一部のタグ付けタスクがあると想像してください。

 Input:  John Johanson 's   house
Labels: NNP  NNP      POS NN

トークン化された出力は次のようになります：

 Tokens: john johan ##son ' s house

重要なことに、これは生のテキストがJohn Johanson's houseであるかと同じ出力になります（ 'sはスペースがない）。

単語レベルの注釈を使用してトークン化された表現がある場合は、各入力単語を個別にトークン化し、元のトークンからトークン化されたアライメントを決定論的に維持することができます。

 ### Input
orig_tokens = [ "John" , "Johanson" , "'s" ,  "house" ]
labels      = [ "NNP" ,  "NNP" ,      "POS" , "NN" ]

### Output
bert_tokens = []

# Token map will be an int -> int mapping between the `orig_tokens` index and
# the `bert_tokens` index.
orig_to_tok_map = []

tokenizer = tokenization . FullTokenizer (
    vocab_file = vocab_file , do_lower_case = True )

bert_tokens . append ( "[CLS]" )
for orig_token in orig_tokens :
  orig_to_tok_map . append ( len ( bert_tokens ))
  bert_tokens . extend ( tokenizer . tokenize ( orig_token ))
bert_tokens . append ( "[SEP]" )

# bert_tokens == ["[CLS]", "john", "johan", "##son", "'", "s", "house", "[SEP]"]
# orig_to_tok_map == [1, 2, 4, 6]

これで、 orig_to_tok_map使用して、トークン化された表現にlabelsを投影できます。

Bertがどのように事前に訓練されたかの間にわずかな不一致を引き起こす一般的な英語のトークン化スキームがあります。たとえば、入力トークン化がdo n'tような収縮から分割された場合、これは不一致を引き起こします。そうすることができる場合は、データを前処理してこれらを生のように見えるテキストに変換する必要がありますが、不可能な場合は、この不一致は大したことではない可能性があります。

バートとの事前トレーニング

任意のテキストコーパスで「マスクされたLM」と「次の文予測」を行うためのコードをリリースしています。これは、論文に使用された正確なコードではないことに注意してください（元のコードはC ++で記述されており、いくつかの複雑さがありました）が、このコードは論文で説明されているように事前トレーニングデータを生成します。

データ生成の実行方法は次のとおりです。入力は単純なテキストファイルで、1行につき1つの文があります。（これらが「次の文予測」タスクの実際の文になることが重要です）。ドキュメントは空の行で区切られています。出力は、 TFRecordファイル形式にシリアル化されたtf.train.Exampleのセットです。

スペイシーなどの既製のNLPツールキットで文のセグメンテーションを実行できます。 create_pretraining_data.pyスクリプトは、パディングからの計算廃棄物を最小限に抑えるために最大シーケンス長に達するまでセグメントを連結します（詳細については、スクリプトを参照）。ただし、入力データ（たとえば、入力セグメントの2％をランダムに切り捨てる）にわずかな量のノイズを意図的に追加して、微調整中に非強力な入力に対してより堅牢にすることをお勧めします。

このスクリプトは、入力ファイル全体のすべての例をメモリ内に保存するため、大規模なデータファイルの場合、入力ファイルを破棄し、スクリプトを複数回呼び出す必要があります。（ファイルグローブを渡すrun_pretraining.pyができますtf_examples.tf_record*

max_predictions_per_seqは、シーケンスごとにマスクされたLM予測の最大数です。これをAround max_seq_length * masked_lm_probに設定する必要があります（正確な値を両方のスクリプトに渡す必要があるため、スクリプトは自動的に実行されません）。

python create_pretraining_data.py 
  --input_file=./sample_text.txt 
  --output_file=/tmp/tf_examples.tfrecord 
  --vocab_file= $BERT_BASE_DIR /vocab.txt 
  --do_lower_case=True 
  --max_seq_length=128 
  --max_predictions_per_seq=20 
  --masked_lm_prob=0.15 
  --random_seed=12345 
  --dupe_factor=5

トレーニング前の実行方法は次のとおりです。ゼロから事前トレーニングをしている場合は、 init_checkpointを含めないでください。モデル構成（VOCABサイズを含む）は、 bert_config_fileで指定されています。このデモコードは、少数のステップ（20）の前トレインのみをコードしますが、実際には、 num_train_steps 10000ステップ以上に設定する必要があります。 run_pretraining.pyに渡されたmax_seq_lengthおよびmax_predictions_per_seqパラメーターは、 create_pretraining_data.pyと同じでなければなりません。

python run_pretraining.py 
  --input_file=/tmp/tf_examples.tfrecord 
  --output_dir=/tmp/pretraining_output 
  --do_train=True 
  --do_eval=True 
  --bert_config_file= $BERT_BASE_DIR /bert_config.json 
  --init_checkpoint= $BERT_BASE_DIR /bert_model.ckpt 
  --train_batch_size=32 
  --max_seq_length=128 
  --max_predictions_per_seq=20 
  --num_train_steps=20 
  --num_warmup_steps=10 
  --learning_rate=2e-5

これにより、次のような出力が生成されます。

 ***** Eval results *****
  global_step = 20
  loss = 0.0979674
  masked_lm_accuracy = 0.985479
  masked_lm_loss = 0.0979328
  next_sentence_accuracy = 1.0
  next_sentence_loss = 3.45724e-05

sample_text.txtファイルは非常に小さいため、この例はそのデータに数個のステップで過剰になり、非現実的に高い精度数を生成することに注意してください。

トレーニング前のヒントと警告

独自の語彙を使用している場合は、 bert_config.jsonのvocab_size必ず変更してください。これを変更せずに大きな語彙を使用すると、チェックされていないバインドアウトアクセスのためにGPUまたはTPUのトレーニング時にNANSを取得する可能性があります。
タスクに大きなドメイン固有のコーパスが利用可能である場合（例：「映画のレビュー」または「科学論文」）、Bertチェックポイントから始まるコーパスでの事前トレーニングの追加ステップを実行することが有益である可能性があります。
この論文で使用した学習率は1E-4でした。ただし、既存のBERTチェックポイントから開始前のトレーニング前の追加手順を実行している場合は、学習率を小さく使用する必要があります（たとえば、2E-5）。
現在のBertモデルは英語のみですが、近い将来に多くの言語で事前に訓練された多言語モデルをリリースする予定です（うまくいけば2018年11月末までに）。
注意はシーケンスの長さまで2次的であるため、より長いシーケンスは不釣り合いに高価です。言い換えれば、長さ512の64シーケンスのバッチは、長さ128の256シーケンスのバッチよりもはるかに高価です。完全に接続された/畳み込みコストは同じですが、512長さのシーケンスの注意コストははるかに大きいです。したがって、1つの優れたレシピは、たとえば、シーケンス長128の90,000ステップ、次に512のシーケンス長で10,000の追加ステップのために事前訓練することです。非常に長いシーケンスは、位置埋め込みを学習するためにほとんど必要です。かなり速く学んだ。これには、 max_seq_lengthの異なる値で2回データを生成する必要があることに注意してください。
ゼロから事前トレーニングをしている場合は、特にGPUでトレーニング前に計算上高価であることを準備してください。あなたがゼロから事前トレーニングをしている場合、私たちの推奨レシピは、単一の先制クラウドTPU V2のBERT-Baseを事前にトレーニングすることです。。紙で使用されているものと比較して、単一のクラウドTPUでのみトレーニングする場合、バッチサイズを縮小する必要があります。 TPUメモリに収まる最大のバッチサイズを使用することをお勧めします。

トレーニング前のデータ

論文で使用されている事前に処理されたデータセットをリリースすることはできません。ウィキペディアの場合、推奨される前処理は、最新のダンプをダウンロードし、 WikiExtractor.pyでテキストを抽出し、必要なクリーンアップを適用してプレーンテキストに変換することです。

残念ながら、BookCorpusを収集した研究者は、公開ダウンロードに利用できなくなりました。プロジェクトGuttenberg Datasetは、パブリックドメインである古い本のやや小さい（200m単語）コレクションです。

Common Crawlは別の非常に大きなテキストコレクションですが、トレーニング前のBERTの使用可能なコーパスを抽出するために、かなりの前処理とクリーンアップを行う必要がある可能性があります。

新しいワードピースの語彙を学ぶ

このリポジトリには、新しいワードピースの語彙を学習するためのコードは含まれていません。 The reason is that the code used in the paper was implemented in C++ with dependencies on Google's internal libraries. For English, it is almost always better to just start with our vocabulary and pre-trained models. For learning vocabularies of other languages, there are a number of open source options available. However, keep in mind that these are not compatible with our tokenization.py library:

Google's SentencePiece library
tensor2tensor's WordPiece generation script
Rico Sennrich's Byte Pair Encoding library

Using BERT in Colab

If you want to use BERT with Colab, you can get started with the notebook "BERT FineTuning with Cloud TPUs". At the time of this writing (October 31st, 2018), Colab users can access a Cloud TPU completely for free. Note: One per user, availability limited, requires a Google Cloud Platform account with storage (although storage may be purchased with free credit for signing up with GCP), and this capability may not longer be available in the future. Click on the BERT Colab that was just linked for more information.

よくある質問

Is this code compatible with Cloud TPUs? What about GPUs?

Yes, all of the code in this repository works out-of-the-box with CPU, GPU, and Cloud TPU. However, GPU training is single-GPU only.

I am getting out-of-memory errors, what is wrong?

See the section on out-of-memory issues for more information.

Is there a PyTorch version available?

There is no official PyTorch implementation. However, NLP researchers from HuggingFace made a PyTorch version of BERT available which is compatible with our pre-trained checkpoints and is able to reproduce our results. We were not involved in the creation or maintenance of the PyTorch implementation so please direct any questions towards the authors of that repository.

Is there a Chainer version available?

There is no official Chainer implementation. However, Sosuke Kobayashi made a Chainer version of BERT available which is compatible with our pre-trained checkpoints and is able to reproduce our results. We were not involved in the creation or maintenance of the Chainer implementation so please direct any questions towards the authors of that repository.

Will models in other languages be released?

Yes, we plan to release a multi-lingual BERT model in the near future. We cannot make promises about exactly which languages will be included, but it will likely be a single model which includes most of the languages which have a significantly-sized Wikipedia.

Will models larger than `BERT-Large` be released?

So far we have not attempted to train anything larger than BERT-Large . It is possible that we will release larger models if we are able to obtain significant improvements.

What license is this library released under?

All code and models are released under the Apache 2.0 license.詳細については、 LICENSEファイルを参照してください。

How do I cite BERT?

For now, cite the Arxiv paper:

 @article{devlin2018bert,
  title={BERT: Pre-training of Deep Bidirectional Transformers for Language Understanding},
  author={Devlin, Jacob and Chang, Ming-Wei and Lee, Kenton and Toutanova, Kristina},
  journal={arXiv preprint arXiv:1810.04805},
  year={2018}
}

If we submit the paper to a conference or journal, we will update the BibTeX.

免責事項

This is not an official Google product.

連絡先

For help or issues using BERT, please submit a GitHub issue.

For personal communication related to BERT, please contact Jacob Devlin ( [email protected] ), Ming-Wei Chang ( [email protected] ), or Kenton Lee ( [email protected] ).

拡大する