bert
1.0.0
***** Baru 11 Maret 2020: Model Bert yang lebih kecil *****
Ini adalah pelepasan 24 model Bert yang lebih kecil (hanya bahasa Inggris, tidak dibagi, dilatih dengan masking wordpiece) yang dirujuk pada siswa yang dibaca dengan baik belajar lebih baik: tentang pentingnya model kompak pra-pelatihan.
Kami telah menunjukkan bahwa resep BerT standar (termasuk arsitektur model dan tujuan pelatihan) efektif pada berbagai ukuran model, di luar Bert-Base dan Bert-Large. Model BerT yang lebih kecil dimaksudkan untuk lingkungan dengan sumber daya komputasi terbatas. Mereka dapat disesuaikan dengan cara yang sama seperti model Bert asli. Namun, mereka paling efektif dalam konteks distilasi pengetahuan, di mana label fine-tuning diproduksi oleh guru yang lebih besar dan lebih akurat.
Tujuan kami adalah untuk memungkinkan penelitian di lembaga -lembaga dengan sumber daya komputasi yang lebih sedikit dan mendorong masyarakat untuk mencari arahan alternatif inovasi untuk meningkatkan kapasitas model.
Anda dapat mengunduh semua 24 dari sini, atau secara individual dari tabel di bawah ini:
| H = 128 | H = 256 | H = 512 | H = 768 | |
|---|---|---|---|---|
| L = 2 | 2/128 (Bert-Tiny) | 2/256 | 2/512 | 2/768 |
| L = 4 | 4/128 | 4/256 (Bert-Mini) | 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) |
Perhatikan bahwa model BERT-BASE dalam rilis ini hanya disertakan untuk kelengkapan; Itu dilatih ulang di bawah rezim yang sama dengan model aslinya.
Berikut adalah skor lem yang sesuai pada set tes:
| Model | Skor | Cola | SST-2 | Mrpc | STS-B | QQP | Mnli-m | Mnli-mm | Qnli (v2) | Rte | Wnli | KAPAK |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| Bert-Tiny | 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 |
| Bert-Mini | 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 |
| Bert-Small | 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 |
| Bert-Medium | 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 |
Untuk setiap tugas, kami memilih hiperparameter penyempurnaan terbaik dari daftar di bawah ini, dan dilatih untuk 4 zaman:
Jika Anda menggunakan model ini, silakan mengutip makalah berikut:
@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}
}
***** Baru 31 Mei 2019: Model Masking Seluruh Kata *****
Ini adalah rilis beberapa model baru yang merupakan hasil dari peningkatan kode pra-pemrosesan.
Dalam kode pra-pemrosesan asli, kami secara acak memilih token Wordpiece untuk menutupi. Misalnya:
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
Teknik baru ini disebut seluruh kata masking. Dalam hal ini, kami selalu menutupi semua token yang sesuai dengan kata sekaligus. Tingkat masking keseluruhan tetap sama.
Whole Word Masked Input: the man [MASK] up , put his basket on [MASK] [MASK] [MASK] ' s head
Pelatihannya identik - kami masih memprediksi setiap token kata -kata bertopeng secara mandiri. Peningkatan tersebut berasal dari fakta bahwa tugas prediksi asli terlalu 'mudah' untuk kata -kata yang telah dibagi menjadi beberapa kata.
Ini dapat diaktifkan selama pembuatan data dengan meneruskan bendera --do_whole_word_mask=True to create_pretraining_data.py .
Model pra-terlatih dengan masking seluruh kata dihubungkan di bawah ini. Data dan pelatihan sebaliknya identik, dan model memiliki struktur dan kosa kata yang identik dengan model asli. Kami hanya menyertakan model Bert-Large. Saat menggunakan model-model ini, harap jelaskan di koran bahwa Anda menggunakan seluruh varian kata masking Bert-Large.
BERT-Large, Uncased (Whole Word Masking) : 24-layer, 1024-hidden, 16-heads, 340m parameter
BERT-Large, Cased (Whole Word Masking) : 24-layer, 1024-Hidden, 16-heads, parameter 340m
| Model | Skuad 1.1 F1/Em | Akurasi multi -nli |
|---|---|---|
| Bert-Large, Uncased (asli) | 91.0/84.3 | 86.05 |
| Bert-Large, Uncased (seluruh kata masking) | 92.8/86.7 | 87.07 |
| Bert-Large, Cased (Asli) | 91.5/84.8 | 86.09 |
| Bert-Large, Cased (seluruh kata masking) | 92.9/86.7 | 86.46 |
***** Baru 7 Februari 2019: Modul TFHUB *****
Bert telah diunggah ke TensorFlow Hub. Lihat run_classifier_with_tfhub.py untuk contoh cara menggunakan modul hub TF, atau jalankan contoh di browser di colab.
***** Baru 23 November 2018: Model multibahasa yang tidak dinormalisasi + Thailand + Mongolian *****
Kami mengunggah model multibahasa baru yang tidak melakukan normalisasi pada input (tidak ada casing yang lebih rendah, pengupasan aksen, atau normalisasi unicode), dan juga termasuk Thailand dan Mongolia.
Disarankan untuk menggunakan versi ini untuk mengembangkan model multibahasa, terutama pada bahasa dengan huruf non-Latin.
Ini tidak memerlukan perubahan kode, dan dapat diunduh di sini:
BERT-Base, Multilingual Cased : 104 Bahasa, 12-Layer, 768-Hidden, 12-Heads, Parameter 110m***** Baru 15 November 2018: SOTA Squad 2.0 System *****
Kami merilis perubahan kode untuk mereproduksi sistem 83% F1 Squad 2.0 kami, yang saat ini berada di posisi pertama di papan peringkat sebesar 3%. Lihat bagian Skuad 2.0 dari Readme untuk detailnya.
***** Baru 5 November 2018: Pytorch Pihak Ketiga dan Versi Chainer dari Bert tersedia *****
Peneliti NLP dari HuggingFace membuat versi Pytorch dari Bert yang tersedia yang kompatibel dengan pos pemeriksaan pra-terlatih kami dan dapat mereproduksi hasil kami. Sosuke Kobayashi juga membuat versi chainer dari Bert tersedia (terima kasih!) Kami tidak terlibat dalam pembuatan atau pemeliharaan implementasi Pytorch, jadi harap arahkan pertanyaan apa pun kepada penulis repositori itu.
***** Baru 3 November 2018: Model multibahasa dan Cina tersedia *****
Kami telah membuat dua model Bert baru tersedia:
BERT-Base, Multilingual (tidak disarankan, gunakan Multilingual Cased sebagai gantinya) : 102 bahasa, 12-lapis, 768-tersembunyi, 12-head, parameter 110mBERT-Base, Chinese : Cina disederhanakan dan tradisional, 12-lapis, 768-tersembunyi, 12-heads, parameter 110m Kami menggunakan tokenisasi berbasis karakter untuk Tokoh, dan tokenisasi Wordpiece untuk semua bahasa lain. Kedua model harus bekerja di luar kotak tanpa perubahan kode. Kami memang memperbarui implementasi BasicTokenizer di tokenization.py untuk mendukung tokenisasi karakter Cina, jadi harap perbarui jika Anda membayar. Namun, kami tidak mengubah Tokenisasi API.
Untuk lebih lanjut, lihat readme multibahasa.
***** Akhiri Informasi Baru *****
Bert , atau b ncoder r e ncoder dari t ransformers, adalah metode baru representasi bahasa pra-pelatihan yang memperoleh hasil canggih pada beragam tugas pemrosesan bahasa alami (NLP).
Makalah akademik kami yang menjelaskan Bert secara detail dan memberikan hasil lengkap pada sejumlah tugas dapat ditemukan di sini: https://arxiv.org/abs/1810.04805.
Untuk memberikan beberapa angka, berikut adalah hasilnya pada skuad v1.1 Tugas menjawab pertanyaan:
| Skuad v1.1 Leaderboard (8 Okt 2018) | Uji Em | Tes F1 |
|---|---|---|
| Ensemble Tempat Pertama - Bert | 87.4 | 93.2 |
| 2nd Place Ensemble - Nlnet | 86.0 | 91.7 |
| Model tunggal tempat pertama - Bert | 85.1 | 91.8 |
| Tempat ke -2 Model tunggal - nlnet | 83.5 | 90.1 |
Dan beberapa tugas inferensi bahasa alami:
| Sistem | Multinli | Pertanyaan NLI | BARANG CURIAN |
|---|---|---|---|
| Bert | 86.7 | 91.1 | 86.3 |
| Openai GPT (Prep. SOTA) | 82.2 | 88.1 | 75.0 |
Ditambah banyak tugas lainnya.
Selain itu, hasil ini semuanya diperoleh dengan hampir tidak ada desain arsitektur jaringan saraf khusus tugas.
Jika Anda sudah tahu apa Bert dan Anda hanya ingin memulai, Anda dapat mengunduh model pra-terlatih dan menjalankan penyesuaian canggih hanya dalam beberapa menit.
Bert adalah metode representasi bahasa pra-pelatihan, yang berarti bahwa kami melatih model "pemahaman bahasa" tujuan umum pada corpus teks besar (seperti Wikipedia), dan kemudian menggunakan model itu untuk tugas NLP hilir yang kami pedulikan (seperti pertanyaan menjawab). Bert mengungguli metode sebelumnya karena ini adalah sistem pertama yang tidak diawasi , dalam dua arah untuk NLP pra-pelatihan.
Tanpa pengawasan berarti bahwa Bert dilatih hanya menggunakan corpus teks biasa, yang penting karena sejumlah besar data teks biasa tersedia untuk umum di web dalam banyak bahasa.
Representasi pra-terlatih juga dapat bebas konteks atau kontekstual , dan representasi kontekstual selanjutnya dapat menjadi searah atau dua arah . Model bebas konteks seperti Word2Vec atau Glove menghasilkan representasi "kata embedding" tunggal untuk setiap kata dalam kosakata, sehingga bank akan memiliki perwakilan yang sama dalam bank deposit dan river bank . Model kontekstual sebaliknya menghasilkan representasi dari setiap kata yang didasarkan pada kata lain dalam kalimat.
Bert dibangun di atas karya baru-baru ini dalam representasi kontekstual pra-pelatihan-termasuk pembelajaran urutan semi-diawasi, pra-pelatihan generatif, elmo, dan ulmfit-tetapi yang terpenting model ini semuanya searah atau dua arah dangkal . Ini berarti bahwa setiap kata hanya dikontekstualisasikan menggunakan kata -kata di kirinya (atau kanan). Misalnya, dalam kalimat I made a bank deposit representasi bank secara searah hanya didasarkan pada I made a deposit tetapi tidak. Beberapa pekerjaan sebelumnya menggabungkan representasi dari model konteks kiri dan konteks kanan yang terpisah, tetapi hanya dengan cara "dangkal". Bert mewakili "bank" menggunakan konteks kiri dan kanannya - I made a ... deposit - mulai dari bagian paling bawah dari jaringan saraf yang dalam, sehingga sangat dua arah .
Bert menggunakan pendekatan sederhana untuk ini: kami menutupi 15% dari kata -kata dalam input, menjalankan seluruh urutan melalui encoder transformator dua arah yang dalam, dan kemudian memprediksi hanya kata -kata bertopeng. Misalnya:
Input: the man went to the [MASK1] . he bought a [MASK2] of milk.
Labels: [MASK1] = store; [MASK2] = gallon
Untuk mempelajari hubungan antar kalimat, kami juga melatih tugas sederhana yang dapat dihasilkan dari korpus monolingual: diberi dua kalimat A dan B , adalah B aktual berikutnya yang datang setelah A , atau hanya kalimat acak dari korpus ?
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
Kami kemudian melatih model besar (transformator 12-layer ke 24-layer) pada corpus besar (Wikipedia + bookcorpus) untuk waktu yang lama (langkah pembaruan 1M), dan itu Bert.
Menggunakan Bert memiliki dua tahap: pra-pelatihan dan penyesuaian .
Pra-pelatihan cukup mahal (empat hari pada 4 hingga 16 Cloud TPU), tetapi merupakan prosedur satu kali untuk setiap bahasa (model saat ini hanya bahasa Inggris, tetapi model multibahasa akan dirilis dalam waktu dekat). Kami merilis sejumlah model pra-terlatih dari kertas yang sudah dilatih sebelumnya di Google. Sebagian besar peneliti NLP tidak perlu melatih model mereka sendiri dari awal.
Fine-tuning tidak mahal. Semua hasil dalam kertas dapat direplikasi paling banyak 1 jam pada TPU awan tunggal, atau beberapa jam pada GPU, mulai dari model pra-terlatih yang sama persis. Skuad, misalnya, dapat dilatih dalam waktu sekitar 30 menit pada TPU awan tunggal untuk mencapai skor DEV F1 sebesar 91,0%, yang merupakan sistem satu-of-the-art sistem tunggal.
Aspek penting lainnya dari Bert adalah dapat disesuaikan dengan banyak jenis tugas NLP dengan sangat mudah. Dalam makalah ini, kami menunjukkan hasil canggih pada tingkat kalimat (mis. (Misalnya, skuad) Tugas tanpa modifikasi khusus tugas.
Kami merilis yang berikut:
BERT-Base dan BERT-Large dari Kertas.Semua kode dalam repositori ini berfungsi di luar kotak dengan CPU, GPU, dan Cloud TPU.
Kami merilis model BERT-Base dan BERT-Large dari kertas. Uncased berarti bahwa teks telah lebih rendah sebelum tokenisasi Wordpiece, misalnya, John Smith menjadi john smith . Model Uncased juga menghilangkan penanda aksen. Cased berarti bahwa kasus sebenarnya dan penanda aksen dipertahankan. Biasanya, model Uncased lebih baik kecuali Anda tahu bahwa informasi kasus penting untuk tugas Anda (misalnya, pengenalan entitas yang disebutkan atau penandaan sebagian).
Semua model ini dirilis dengan lisensi yang sama dengan kode sumber (Apache 2.0).
Untuk informasi tentang model multibahasa dan Cina, lihat readme multibahasa.
Saat menggunakan model cased, pastikan untuk lulus --do_lower=False ke skrip pelatihan. (Atau lulus do_lower_case=False langsung ke FullTokenizer jika Anda menggunakan skrip Anda sendiri.)
Tautan ke model ada di sini (klik kanan, 'Simpan tautan sebagai ...' pada namanya):
BERT-Large, Uncased (Whole Word Masking) : 24-layer, 1024-hidden, 16-heads, 340m parameterBERT-Large, Cased (Whole Word Masking) : 24-layer, 1024-Hidden, 16-heads, parameter 340mBERT-Base, Uncased : 12-Layer, 768-Hidden, 12-Heads, 110m ParameterBERT-Large, Uncased : 24-Layer, 1024-Hidden, 16-Heads, 340m ParameterBERT-Base, Cased : 12-layer, 768-hidden, 12-heads, parameter 110mBERT-Large, Cased : 24-Layer, 1024-Hidden, 16-Heads, 340m ParameterBERT-Base, Multilingual Cased (New, recommended) : 104 bahasa, 12-lapis, 768-tersembunyi, 12-heads, parameter 110mBERT-Base, Multilingual Uncased (Orig, not recommended) (tidak disarankan, gunakan Multilingual Cased sebagai gantinya) : 102 bahasa, 12-lapis, 768 tersembunyi, 12-head, parameter 110mBERT-Base, Chinese : Cina disederhanakan dan tradisional, 12-lapis, 768-tersembunyi, 12-heads, parameter 110mSetiap file .zip berisi tiga item:
bert_model.ckpt ) yang berisi bobot terlatih (yang sebenarnya 3 file).vocab.txt ) untuk memetakan wordpiece ke Word ID.bert_config.json ) yang menentukan hiperparameter model. PENTING : Semua hasil di atas kertas disesuaikan dengan satu awan TPU, yang memiliki RAM 64GB. Saat ini tidak mungkin untuk memproduksi ulang sebagian besar hasil BERT-Large di atas kertas menggunakan GPU dengan 12GB-16GB RAM, karena ukuran batch maksimum yang dapat pas dalam memori terlalu kecil. Kami sedang berupaya menambahkan kode ke repositori ini yang memungkinkan ukuran batch efektif yang jauh lebih besar pada GPU. Lihat bagian tentang masalah di luar memori untuk lebih jelasnya.
Kode ini diuji dengan TensorFlow 1.11.0. Itu diuji dengan Python2 dan Python3 (tetapi lebih menyeluruh dengan Python2, karena inilah yang digunakan secara internal di Google).
Contoh-contoh fine-tuning yang menggunakan BERT-Base harus dapat berjalan pada GPU yang memiliki setidaknya 12GB RAM menggunakan hyperparameters yang diberikan.
Sebagian besar contoh di bawah ini mengasumsikan bahwa Anda akan menjalankan pelatihan/evaluasi pada mesin lokal Anda, menggunakan GPU seperti Titan X atau GTX 1080.
Namun, jika Anda memiliki akses ke TPU cloud yang ingin Anda latih, cukup tambahkan flag berikut ke run_classifier.py atau run_squad.py :
--use_tpu=True
--tpu_name=$TPU_NAME
Silakan lihat tutorial Google Cloud TPU untuk cara menggunakan Cloud TPU. Atau, Anda dapat menggunakan notebook Google Colab "Bert Finetuning dengan Cloud TPU".
Pada TPU cloud, model pretrained dan direktori output harus di Google Cloud Storage. Misalnya, jika Anda memiliki ember bernama some_bucket , Anda dapat menggunakan bendera berikut sebagai gantinya:
--output_dir=gs://some_bucket/my_output_dir/
File model pra-terlatih yang belum di-zip juga dapat ditemukan di folder penyimpanan cloud Google gs://bert_models/2018_10_18 . Misalnya:
export BERT_BASE_DIR=gs://bert_models/2018_10_18/uncased_L-12_H-768_A-12
Sebelum menjalankan contoh ini, Anda harus mengunduh data lem dengan menjalankan skrip ini dan membongkarnya ke beberapa direktori $GLUE_DIR . Selanjutnya, unduh pos pemeriksaan BERT-Base dan unzip ke beberapa direktori $BERT_BASE_DIR .
Contoh kode ini menyempurnakan BERT-Base pada corpus Microsoft Research Paraphrase Corpus (MRPC), yang hanya berisi 3.600 contoh dan dapat menyempurnakan dalam beberapa menit pada sebagian besar 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/Anda harus melihat output seperti ini:
***** Eval results *****
eval_accuracy = 0.845588
eval_loss = 0.505248
global_step = 343
loss = 0.505248
Ini berarti bahwa akurasi set dev adalah 84,55%. Set kecil seperti MRPC memiliki varian tinggi dalam akurasi set dev, bahkan ketika mulai dari pos pemeriksaan pra-pelatihan yang sama. Jika Anda menjalankan kembali beberapa kali (pastikan untuk menunjuk ke output_dir yang berbeda), Anda akan melihat hasil antara 84% dan 88%.
Beberapa model pra-terlatih lainnya diimplementasikan di luar rak di run_classifier.py , sehingga harus langsung mengikuti contoh-contoh tersebut untuk menggunakan Bert untuk setiap tugas klasifikasi satu kalimat atau pasangan kalimat.
CATATAN: Anda mungkin melihat pesan Running train on CPU . Ini benar -benar berarti bahwa itu berjalan pada sesuatu selain TPU cloud, yang termasuk GPU.
Setelah Anda melatih classifier Anda, Anda dapat menggunakannya dalam mode inferensi dengan menggunakan perintah --Do_predict = True. Anda perlu memiliki file bernama test.tsv di folder input. Output akan dibuat dalam file yang disebut test_results.tsv di folder output. Setiap baris akan berisi output untuk setiap sampel, kolom adalah probabilitas kelas.
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/ Dataset Penjawab pertanyaan Stanford (Skuad) adalah pertanyaan populer yang menjawab dataset benchmark. Bert (pada saat rilis) memperoleh hasil canggih pada skuad dengan hampir tidak ada modifikasi arsitektur jaringan khusus tugas atau augmentasi data. Namun, memang membutuhkan data semi-kompleks pra-pemrosesan dan pasca-pemrosesan untuk menangani (a) sifat panjang variabel paragraf konteks skuad, dan (b) anotasi jawaban tingkat karakter yang digunakan untuk pelatihan skuad. Pemrosesan ini diimplementasikan dan didokumentasikan dalam run_squad.py .
Untuk menjalankan di skuad, Anda harus terlebih dahulu mengunduh dataset. Situs web skuad tampaknya tidak menautkan ke dataset v1.1 lagi, tetapi file yang diperlukan dapat ditemukan di sini:
Unduh ini ke beberapa direktori $SQUAD_DIR .
Skuad canggih hasil dari makalah saat ini tidak dapat direproduksi pada GPU 12GB-16GB karena kendala memori (pada kenyataannya, bahkan ukuran batch 1 tampaknya tidak sesuai dengan GPU 12GB menggunakan BERT-Large ). Namun, model BERT-Base yang cukup kuat dapat dilatih pada GPU dengan hiperparameter ini:
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/ Prediksi set dev akan disimpan ke dalam file yang disebut predictions.json di output_dir :
python $SQUAD_DIR /evaluate-v1.1.py $SQUAD_DIR /dev-v1.1.json ./squad/predictions.jsonYang seharusnya menghasilkan output seperti ini:
{ " f1 " : 88.41249612335034, " exact_match " : 81.2488174077578} Anda akan melihat hasil yang mirip dengan 88,5% yang dilaporkan di koran untuk BERT-Base .
Jika Anda memiliki akses ke TPU cloud, Anda dapat berlatih dengan BERT-Large . Berikut adalah satu set hiperparameter (sedikit berbeda dari kertas) yang secara konsisten memperoleh sekitar 90,5% -91,0% F1 sistem tunggal yang dilatih hanya pada skuad:
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_NAMEMisalnya, satu menjalankan acak dengan parameter ini menghasilkan skor dev berikut:
{ " f1 " : 90.87081895814865, " exact_match " : 84.38978240302744}Jika Anda menyempurnakan satu zaman tentang triviaqa sebelum hasilnya akan lebih baik, tetapi Anda perlu mengubah triviaqa menjadi format Skuad JSON.
Model ini juga diimplementasikan dan didokumentasikan dalam run_squad.py .
Untuk menjalankan di Squad 2.0, Anda harus pertama -tama harus mengunduh dataset. File yang diperlukan dapat ditemukan di sini:
Unduh ini ke beberapa direktori $SQUAD_DIR .
Di Cloud TPU Anda dapat menjalankan dengan Bert-Large sebagai berikut:
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=TrueKami menganggap Anda telah menyalin semuanya dari direktori output ke direktori lokal yang disebut ./squad/. Prediksi set dev awal akan berada di ./squad/predictions.json dan perbedaan antara skor tidak ada jawaban ("") dan jawaban non-nol terbaik untuk setiap pertanyaan adalah dalam file ./squad/null_odds.json
Jalankan skrip ini untuk menyetel ambang batas untuk memprediksi jawaban nol versus non-nol:
python $ squad_dir/evaluate-v2.0.py $ squad_dir/dev-v2.0.json ./squad/predictions.json ---na-prob-file ./squad/null_odds.json
Asumsikan output skrip "Best_f1_thresh" thresh. (Nilai khas adalah antara -1.0 dan -5.0). Anda sekarang dapat menjalankan kembali model untuk menghasilkan prediksi dengan ambang turunan atau sebagai alternatif Anda dapat mengekstrak jawaban yang sesuai dari ./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= $THRESHSemua percobaan di koran disesuaikan dengan TPU cloud, yang memiliki RAM perangkat 64GB. Oleh karena itu, saat menggunakan GPU dengan RAM 12GB-16GB, Anda cenderung mengalami masalah out-of-memory jika Anda menggunakan hiperparameter yang sama yang dijelaskan dalam makalah.
Faktor -faktor yang mempengaruhi penggunaan memori adalah:
max_seq_length : Model yang dirilis dilatih dengan panjang urutan hingga 512, tetapi Anda dapat menyempurnakan dengan panjang urutan maksimal yang lebih pendek untuk menghemat memori yang substansial. Ini dikendalikan oleh bendera max_seq_length dalam kode contoh kami.
train_batch_size : Penggunaan memori juga berbanding lurus dengan ukuran batch.
Jenis Model, BERT-Base vs BERT-Large : Model BERT-Large membutuhkan memori secara signifikan lebih banyak daripada BERT-Base .
Pengoptimal : Pengoptimal default untuk Bert adalah Adam, yang membutuhkan banyak memori tambahan untuk menyimpan vektor m dan v Beralih ke pengoptimal yang lebih efisien memori dapat mengurangi penggunaan memori, tetapi juga dapat mempengaruhi hasilnya. Kami belum bereksperimen dengan pengoptimal lain untuk menyempurnakan.
Menggunakan skrip pelatihan default ( run_classifier.py dan run_squad.py ), kami membandingkan ukuran batch maksimum pada Titan X GPU tunggal (12GB RAM) dengan TensorFlow 1.11.0:
| Sistem | Panjang seq | Ukuran batch maks |
|---|---|---|
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 |
Sayangnya, ukuran batch maksimal ini untuk BERT-Large sangat kecil sehingga mereka benar-benar akan membahayakan akurasi model, terlepas dari tingkat pembelajaran yang digunakan. Kami sedang bekerja untuk menambahkan kode ke repositori ini yang akan memungkinkan ukuran batch efektif yang jauh lebih besar untuk digunakan pada GPU. Kode akan didasarkan pada satu (atau keduanya) dari teknik berikut:
Akumulasi Gradien : Sampel dalam minibatch biasanya independen sehubungan dengan perhitungan gradien (tidak termasuk normalisasi batch, yang tidak digunakan di sini). Ini berarti bahwa gradien beberapa minibatch yang lebih kecil dapat diakumulasikan sebelum melakukan pembaruan berat, dan ini akan persis setara dengan satu pembaruan yang lebih besar.
CHECKPOINTING GRADIEN : Penggunaan utama memori GPU/TPU selama pelatihan DNN caching aktivasi menengah di pass depan yang diperlukan untuk perhitungan yang efisien di pass mundur. "Gradient Checkpointing" memperdagangkan memori untuk menghitung waktu dengan menghitung ulang aktivasi dengan cara yang cerdas.
Namun, ini tidak diimplementasikan dalam rilis saat ini.
Dalam kasus-kasus tertentu, daripada menyempurnakan seluruh model pra-terlatih ujung ke ujung, dapat bermanfaat untuk memperoleh embedding kontekstual pra-terlatih , yang merupakan representasi kontekstual tetap dari masing-masing token input yang dihasilkan dari lapisan tersembunyi pre pre model -terlatih. Ini juga harus mengurangi sebagian besar masalah di luar memori.
Sebagai contoh, kami menyertakan skrip extract_features.py yang dapat digunakan seperti ini:
# 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 Ini akan membuat file JSON (satu baris per baris input) yang berisi aktivasi BerT dari masing-masing lapisan transformator yang ditentukan berdasarkan layers (-1 adalah lapisan tersembunyi terakhir dari transformator, dll.)
Perhatikan bahwa skrip ini akan menghasilkan file output yang sangat besar (secara default, sekitar 15kb untuk setiap token input).
Jika Anda perlu mempertahankan keselarasan antara kata -kata asli dan token (untuk memproyeksikan label pelatihan), lihat bagian tokenisasi di bawah ini.
Catatan: Anda dapat melihat pesan seperti Could not find trained model in model_dir: /tmp/tmpuB5g5c, running initialization to predict. Pesan ini diharapkan, itu hanya berarti bahwa kami menggunakan API init_from_checkpoint() daripada API model yang disimpan. Jika Anda tidak menentukan pos pemeriksaan atau menentukan pos pemeriksaan yang tidak valid, skrip ini akan mengeluh.
Untuk tugas-tugas tingkat kalimat (atau pasangan kalimat), tokenisasi sangat sederhana. Cukup ikuti kode contoh di run_classifier.py dan extract_features.py . Prosedur dasar untuk tugas tingkat kalimat adalah:
Instantiate Sebuah tokenizer = tokenization.FullTokenizer
Tokenize teks mentah dengan tokens = tokenizer.tokenize(raw_text) .
Potong ke panjang urutan maksimum. (Anda dapat menggunakan hingga 512, tetapi Anda mungkin ingin menggunakan lebih pendek jika memungkinkan untuk alasan memori dan kecepatan.)
Tambahkan token [CLS] dan [SEP] di tempat yang tepat.
Tugas tingkat kata dan level rentang (misalnya, Skuad dan NER) lebih kompleks, karena Anda perlu menjaga keselarasan antara teks input dan teks output Anda sehingga Anda dapat memproyeksikan label pelatihan Anda. Skuad adalah contoh yang sangat kompleks karena label input berbasis karakter , dan paragraf skuad seringkali lebih panjang dari panjang urutan maksimum kami. Lihat kode di run_squad.py untuk menunjukkan bagaimana kami menangani ini.
Sebelum kami menggambarkan resep umum untuk menangani tugas-tugas tingkat kata, penting untuk memahami apa yang sebenarnya dilakukan tokenizer kami. Ini memiliki tiga langkah utama:
Normalisasi Teks : Konversi semua karakter whitespace ke spasi, dan (untuk model Uncased ) meremehkan input dan menelanjangi penanda aksen. Misalnya, John Johanson's, → john johanson's, .
Pembelahan tanda baca : Pisahkan semua karakter tanda baca di kedua sisi (yaitu, tambahkan spasi putih di sekitar semua karakter tanda baca). Karakter tanda baca didefinisikan sebagai (a) apa pun dengan kelas P* unicode, (b) karakter non-huruf/angka/ruang ASCII (misalnya, karakter seperti $ yang secara teknis bukan tanda baca). Misalnya, john johanson's, → john johanson ' s ,
Tokenisasi Wordpiece : Terapkan tokenisasi whitespace ke output dari prosedur di atas, dan terapkan tokenisasi wordpiece untuk setiap token secara terpisah. (Implementasi kami secara langsung didasarkan pada yang dari tensor2tensor , yang ditautkan). Misalnya, john johanson ' s , → john johan ##son ' s ,
Keuntungan dari skema ini adalah "kompatibel" dengan sebagian besar tokenizer Inggris yang ada. Misalnya, bayangkan Anda memiliki tugas penandaan sebagian yang terlihat seperti ini:
Input: John Johanson 's house
Labels: NNP NNP POS NN
Output tokenisasi akan terlihat seperti ini:
Tokens: john johan ##son ' s house
Yang terpenting, ini akan menjadi output yang sama seolah -olah teks mentahnya adalah John Johanson's house (tanpa ruang sebelum 's .
Jika Anda memiliki representasi pra-diwaspadai dengan anotasi level kata, Anda dapat dengan mudah tokenize setiap kata input secara mandiri, dan secara deterministik mempertahankan penyelarasan asli-untuk diwaspadai:
### 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] Sekarang orig_to_tok_map dapat digunakan untuk memproyeksikan labels ke representasi tokenized.
Ada skema tokenisasi bahasa Inggris yang umum yang akan menyebabkan sedikit ketidaksesuaian antara bagaimana Bert dilatih sebelumnya. Misalnya, jika tokenisasi input Anda membagi kontraksi seperti do n't , ini akan menyebabkan ketidakcocokan. Jika dimungkinkan untuk melakukannya, Anda harus melakukan pra-proses data Anda untuk mengubah ini kembali ke teks yang tampak mentah, tetapi jika tidak mungkin, ketidakcocokan ini kemungkinan bukan masalah besar.
Kami merilis kode untuk melakukan "LM bertopeng" dan "prediksi kalimat berikutnya" pada corpus teks yang sewenang -wenang. Perhatikan bahwa ini bukan kode yang tepat yang digunakan untuk kertas (kode asli ditulis dalam C ++, dan memiliki beberapa kompleksitas tambahan), tetapi kode ini menghasilkan data pra-pelatihan seperti yang dijelaskan dalam makalah.
Inilah cara menjalankan pembuatan data. Input adalah file teks biasa, dengan satu kalimat per baris. (Adalah penting bahwa ini adalah kalimat aktual untuk tugas "prediksi kalimat berikutnya"). Dokumen dibatasi oleh garis kosong. Output adalah satu set tf.train.Example S serial ke dalam format file TFRecord .
Anda dapat melakukan segmentasi kalimat dengan toolkit NLP di luar rak seperti Spacy. Skrip create_pretraining_data.py akan menggabungkan segmen sampai mencapai panjang urutan maksimum untuk meminimalkan limbah komputasi dari bantalan (lihat skrip untuk lebih jelasnya). Namun, Anda mungkin ingin dengan sengaja menambahkan sedikit noise ke data input Anda (misalnya, secara acak memotong 2% dari segmen input) untuk membuatnya lebih kuat untuk input non-esensial selama penyetelan fine.
Script ini menyimpan semua contoh untuk seluruh file input dalam memori, jadi untuk file data besar Anda harus mengarahkan file input dan memanggil skrip beberapa kali. (Anda dapat melewati file glob ke run_pretraining.py , misalnya, tf_examples.tf_record* .)
max_predictions_per_seq adalah jumlah maksimum prediksi LM bertopeng per urutan. Anda harus mengatur ini ke sekitar max_seq_length * masked_lm_prob (skrip tidak melakukan itu secara otomatis karena nilai yang tepat perlu diteruskan ke kedua skrip).
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 Inilah cara menjalankan pra-pelatihan. Jangan sertakan init_checkpoint jika Anda pra-pelatihan dari awal. Konfigurasi model (termasuk ukuran vocab) ditentukan dalam bert_config_file . Kode demo ini hanya pra-kereta untuk sejumlah kecil langkah (20), tetapi dalam praktiknya Anda mungkin ingin mengatur num_train_steps ke 1000 langkah atau lebih. Parameter max_seq_length dan max_predictions_per_seq diteruskan ke run_pretraining.py harus sama dengan 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-5Ini akan menghasilkan output seperti ini:
***** 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
Perhatikan bahwa karena file sample_text.txt kami sangat kecil, contoh pelatihan ini akan mengatasi data itu hanya dalam beberapa langkah dan menghasilkan angka akurasi yang tidak realistis.
vocab_size di bert_config.json . Jika Anda menggunakan kosakata yang lebih besar tanpa mengubah ini, Anda mungkin akan mendapatkan NANS saat berlatih tentang GPU atau TPU karena akses yang tidak dicentang di luar batas.max_seq_length yang berbeda.BERT-Base pada satu preemptible cloud TPU V2, yang membutuhkan waktu sekitar 2 minggu dengan biaya sekitar $ 500 USD (berdasarkan harga pada Oktober 2018) . Anda harus menurunkan ukuran batch ketika hanya berlatih pada TPU awan tunggal, dibandingkan dengan apa yang digunakan di koran. Disarankan untuk menggunakan ukuran batch terbesar yang cocok dengan memori TPU. Kami tidak akan dapat merilis dataset pra-diproses yang digunakan dalam makalah. Untuk Wikipedia, pra-pemrosesan yang disarankan adalah mengunduh dump terbaru, mengekstrak teks dengan WikiExtractor.py , dan kemudian menerapkan pembersihan yang diperlukan untuk mengubahnya menjadi teks biasa.
Sayangnya para peneliti yang mengumpulkan BookCorpus tidak lagi tersedia untuk diunduh publik. Dataset Proyek Guttenberg adalah koleksi buku lama yang agak lebih kecil (200m) yang merupakan domain publik.
Common Crawl adalah koleksi teks yang sangat besar, tetapi Anda mungkin harus melakukan pra-pemrosesan dan pembersihan yang substansial untuk mengekstraksi korpus yang dapat digunakan untuk Bert pra-pelatihan.
This repository does not include code for learning a new WordPiece vocabulary. 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
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.
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.
See the section on out-of-memory issues for more information.
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.
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.
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.
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.
All code and models are released under the Apache 2.0 license. Lihat file LICENSE untuk informasi lebih lanjut.
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] ).
