xlnet_sequence_tagging
1.0.0
Kami sedang mengembangkan proyek ini untuk menandai tugas yang selalu dipenuhi NLPER.
Gunakan XLNET untuk tugas berikut
Alarm, kode -kode ini belum selesai. Berhati -hati untuk digunakan.
Misalnya, jalankan scipt menggunakan:
python2.7 /home/dev/Documents/xlnet-master/run_blstm_crf-run_race.py
--use_tpu
--model_config_path /home/dev/Documents/xlnet_models/xlnet_cased_L-12_H-768_A-12/xlnet_config.json
--spiece_model_file /home/dev/Documents/xlnet_models/xlnet_cased_L-12_H-768_A-12/spiece.model
--model_dir /home/dev/Documents/xlnet_models/finetuned/
--data_dir /home/dev/Documents/udify-master/data/ud/xlnet_data/
--do_train True
--save_steps 2
--output_dir /home/dev/Documents/xlnet_models/output_dir https://universaldependencies.org/
Anda dapat menggunakan "find ./ -name *test/dev/train.conll" untuk menemukan semua file conll dan menggunakan xargs untuk menyalinnya ke data_dir
https://github.com/yuchenlin/ontonotes-5.0-ner-bio
Cukup salin file bahasa Inggris ke data_dir menggunakan file skrip python: onotonotes_conll_copyfile.py (Anda mungkin perlu memodifikasi jalur)
PR S dipersilakan! Tolong bantu dengan proyek yang sedang berkembang untuk meningkatkan kekuatan NLP kami!
XLNET adalah metode pembelajaran representasi bahasa baru tanpa pengawasan berdasarkan pada tujuan pemodelan bahasa permutasi umum baru. Selain itu, XLNET menggunakan Transformer-XL sebagai model backbone, menunjukkan kinerja yang sangat baik untuk tugas-tugas bahasa yang melibatkan konteks yang panjang. Secara keseluruhan, XLNET mencapai hasil canggih (SOTA) pada berbagai tugas bahasa hilir termasuk menjawab pertanyaan, inferensi bahasa alami, analisis sentimen, dan peringkat dokumen.
Untuk deskripsi terperinci tentang detail teknis dan hasil eksperimen, silakan merujuk ke makalah kami:
XLNET: pretraining autoregresif umum untuk pemahaman bahasa
Zhilin Yang*, Zihang Dai*, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, Quoc V. Le
(*: Kontribusi yang sama)
Pracetak 2019
Pada 19 Juni 2019, XLNET mengungguli Bert pada 20 tugas dan mencapai hasil canggih pada 18 tugas. Di bawah ini adalah beberapa perbandingan antara Xlnet-Large dan Bert-Large, yang memiliki ukuran model yang sama:
| Model | Akurasi ras | Skuad1.1 em | Skuad2.0 Em |
|---|---|---|---|
| Bert-Large | 72.0 | 84.1 | 78.98 |
| XLNET-BASE | 80.18 | ||
| Xlnet-Large | 81.75 | 88.95 | 86.12 |
Kami menggunakan hasil dev skuad dalam tabel untuk mengecualikan faktor -faktor lain seperti menggunakan data pelatihan tambahan atau teknik augmentasi data lainnya. Lihat papan peringkat pasukan untuk nomor tes.
| Model | IMDB | Yelp-2 | Yelp-5 | Dbpedia | Amazon-2 | Amazon-5 |
|---|---|---|---|---|---|---|
| Bert-Large | 4.51 | 1.89 | 29.32 | 0.64 | 2.63 | 34.17 |
| Xlnet-Large | 3.79 | 1.55 | 27.80 | 0.62 | 2.40 | 32.26 |
Angka di atas adalah tingkat kesalahan.
| Model | Mnli | Qnli | QQP | Rte | SST-2 | Mrpc | Cola | STS-B |
|---|---|---|---|---|---|---|---|---|
| Bert-Large | 86.6 | 92.3 | 91.3 | 70.4 | 93.2 | 88.0 | 60.6 | 90.0 |
| XLNET-BASE | 86.8 | 91.7 | 91.4 | 74.0 | 94.7 | 88.2 | 60.2 | 89.5 |
| Xlnet-Large | 89.8 | 93.9 | 91.8 | 83.8 | 95.6 | 89.2 | 63.6 | 91.8 |
Kami menggunakan hasil dev tunggal dalam tabel untuk mengecualikan faktor-faktor lain seperti pembelajaran multi-tugas atau menggunakan ansambel.
Pada 16 Juli 2019, model -model berikut telah tersedia:
XLNet-Large, Cased : 24-layer, 1024-hidden, 16-headsXLNet-Base, Cased : 12-layer, 768-hidden, 12-heads. Model ini dilatih pada data lengkap (berbeda dari yang ada di koran).Kami hanya merilis model cased untuk saat ini karena pada tugas yang kami pertimbangkan, kami menemukan: (1) untuk pengaturan dasar, model cased dan uncased memiliki kinerja yang sama; (2) Untuk pengaturan besar, model cased sedikit lebih baik dalam beberapa tugas.
Setiap file .zip berisi tiga item:
xlnet_model.ckpt ) yang berisi bobot pra-terlatih (yang sebenarnya 3 file).spiece.model ) yang digunakan untuk tokenisasi (DE).xlnet_config.json ) yang menentukan hiperparameter model.Kami juga berencana untuk terus merilis lebih banyak model pretrained di bawah pengaturan yang berbeda, termasuk:
Untuk menerima pemberitahuan tentang pembaruan, pengumuman, dan rilis baru, kami merekomendasikan berlangganan XLNET di Google Groups.
Pada 19 Juni 2019, basis kode ini telah diuji dengan TensorFlow 1.13.1 di bawah Python2.
XLNet-Large di kertas menggunakan GPU dengan 12GB-16GB RAM, karena GPU 16GB hanya mampu memegang urutan tunggal dengan panjang 512 untuk XLNet-Large . Oleh karena itu, sejumlah besar (mulai dari 32 hingga 128, sama dengan batch_size ) dari GPU diperlukan untuk mereproduksi banyak hasil dalam kertas. Mengingat masalah memori yang disebutkan di atas, menggunakan skrip finetuning default ( run_classifier.py dan run_squad.py ), kami membandingkan ukuran batch maksimum pada GPU 16GB tunggal dengan TensorFlow 1.13.1 :
| Sistem | Panjang seq | Ukuran batch maks |
|---|---|---|
XLNet-Base | 64 | 120 |
| ... | 128 | 56 |
| ... | 256 | 24 |
| ... | 512 | 8 |
XLNet-Large | 64 | 16 |
| ... | 128 | 8 |
| ... | 256 | 2 |
| ... | 512 | 1 |
Dalam kebanyakan kasus, dimungkinkan untuk mengurangi ukuran batch train_batch_size atau panjang urutan maksimum max_seq_length agar sesuai dengan perangkat keras yang diberikan. Penurunan kinerja tergantung pada tugas dan sumber daya yang tersedia.
Kode yang digunakan untuk melakukan finetuning klasifikasi/regresi di run_classifier.py . Ini juga berisi contoh untuk klasifikasi satu-dokumen standar, regresi satu-dokumen, dan klasifikasi pasangan dokumen. Di sini, kami memberikan dua contoh konkret tentang bagaimana run_classifier.py dapat digunakan.
Dari sini, kami mengasumsikan Xlnet-Large dan XLNET-BASE telah diunduh masing-masing $LARGE_DIR dan $BASE_DIR .
Unduh data lem dengan menjalankan skrip ini dan buka paket ke beberapa direktori $GLUE_DIR .
Lakukan finetuning multi-GPU (4 V100) dengan XLNET-Large dengan menjalankan
CUDA_VISIBLE_DEVICES=0,1,2,3 python run_classifier.py
--do_train=True
--do_eval=False
--task_name=sts-b
--data_dir= ${GLUE_DIR} /STS-B
--output_dir=proc_data/sts-b
--model_dir=exp/sts-b
--uncased=False
--spiece_model_file= ${LARGE_DIR} /spiece.model
--model_config_path= ${LARGE_DIR} /xlnet_config.json
--init_checkpoint= ${LARGE_DIR} /xlnet_model.ckpt
--max_seq_length=128
--train_batch_size=8
--num_hosts=1
--num_core_per_host=4
--learning_rate=5e-5
--train_steps=1200
--warmup_steps=120
--save_steps=600
--is_regression=TrueMengevaluasi hasil finetuning dengan satu GPU oleh
CUDA_VISIBLE_DEVICES=0 python run_classifier.py
--do_train=False
--do_eval=True
--task_name=sts-b
--data_dir= ${GLUE_DIR} /STS-B
--output_dir=proc_data/sts-b
--model_dir=exp/sts-b
--uncased=False
--spiece_model_file= ${LARGE_DIR} /spiece.model
--model_config_path= ${LARGE_DIR} /xlnet_config.json
--max_seq_length=128
--eval_batch_size=8
--num_hosts=1
--num_core_per_host=1
--eval_all_ckpt=True
--is_regression=True
# Expected performance: "eval_pearsonr 0.916+ "Catatan :
num_core_per_host menunjukkan jumlah GPU yang akan digunakan.train_batch_size mengacu pada ukuran batch per-gpu.eval_all_ckpt memungkinkan seseorang untuk mengevaluasi semua pos pemeriksaan yang disimpan (frekuensi simpan dikendalikan oleh save_steps ) setelah pelatihan selesai dan memilih model terbaik berdasarkan kinerja dev.data_dir dan output_dir merujuk ke direktori "data mentah" dan "preprosesed tFecords" masing -masing, sedangkan model_dir adalah direktori kerja untuk menyimpan pos pemeriksaan dan acara tensorflow. model_dir harus ditetapkan sebagai folder terpisah ke init_checkpoint .--train_batch_size=32 dan --num_core_per_host=1 , bersama dengan perubahan sesuai dengan init_checkpoint dan model_config_path .train_batch_size dan tingkatkan num_core_per_host untuk menggunakan pengaturan pelatihan yang sama.Unduh dan buka kumpulan dataset IMDB dengan berjalan
wget http://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz
tar zxvf aclImdb_v1.tar.gzLuncurkan instance Google Cloud TPU V3-8 (lihat Tutorial Google Cloud TPU untuk cara mengatur TPU Cloud).
Siapkan jalur bucket google penyimpanan Anda $GS_ROOT dan pindahkan dataset IMDB dan pos pemeriksaan pretrain ke penyimpanan google Anda.
Lakukan tpu finetuning dengan xlnet-large dengan berlari
python run_classifier.py
--use_tpu=True
--tpu= ${TPU_NAME}
--do_train=True
--do_eval=True
--eval_all_ckpt=True
--task_name=imdb
--data_dir= ${IMDB_DIR}
--output_dir= ${GS_ROOT} /proc_data/imdb
--model_dir= ${GS_ROOT} /exp/imdb
--uncased=False
--spiece_model_file= ${LARGE_DIR} /spiece.model
--model_config_path= ${GS_ROOT} / ${LARGE_DIR} /model_config.json
--init_checkpoint= ${GS_ROOT} / ${LARGE_DIR} /xlnet_model.ckpt
--max_seq_length=512
--train_batch_size=32
--eval_batch_size=8
--num_hosts=1
--num_core_per_host=8
--learning_rate=2e-5
--train_steps=4000
--warmup_steps=500
--save_steps=500
--iterations=500
# Expected performance: "eval_accuracy 0.962+ "Catatan :
data_dir dan spiece_model_file keduanya menggunakan jalur lokal daripada jalur penyimpanan Google. Alasannya adalah bahwa preprocessing data sebenarnya dilakukan secara lokal. Oleh karena itu, menggunakan jalur lokal mengarah ke kecepatan preprocessing yang lebih cepat. Kode untuk dataset pasukan termasuk dalam run_squad.py .
Untuk menjalankan kode:
(1) Unduh dataset Squad2.0 ke dalam $SQUAD_DIR oleh:
mkdir -p ${SQUAD_DIR} && cd ${SQUAD_DIR}
wget https://rajpurkar.github.io/SQuAD-explorer/dataset/train-v2.0.json
wget https://rajpurkar.github.io/SQuAD-explorer/dataset/dev-v2.0.json (2) Lakukan preprocessing data menggunakan scripts/prepro_squad.sh .
Ini akan memakan waktu cukup lama untuk memetakan posisi karakter (data mentah) secara akurat ke posisi potongan kalimat (digunakan untuk pelatihan).
Untuk preprocessing paralel yang lebih cepat, silakan merujuk ke bendera --num_proc dan --proc_id di run_squad.py .
(3) Lakukan pelatihan dan evaluasi.
Untuk kinerja terbaik, Xlnet-Large menggunakan panjang urutan 512 dan ukuran batch 48 untuk pelatihan.
Akibatnya, mereproduksi hasil terbaik dengan GPU cukup sulit.
Untuk pelatihan dengan satu TPU V3-8, orang dapat dengan mudah menjalankan scripts/tpu_squad_large.sh setelah tpu dan penyimpanan google telah diatur.
run_squad.py akan secara otomatis melakukan pencarian ambang batas pada set skuad dev dan output skor. Dengan scripts/tpu_squad_large.sh , skor F1 yang diharapkan harus sekitar 88,6 (median dari beberapa kali kami berjalan).
Atau, seseorang dapat menggunakan XLNET-BASE dengan GPU (misalnya tiga V100). Satu set hyper-parameter yang masuk akal dapat ditemukan dalam scripts/gpu_squad_base.sh .
Kode untuk perlombaan tugas pemahaman membaca termasuk dalam run_race.py .
Untuk menjalankan kode:
(1) Unduh dataset balap dari situs web resmi dan buka paket data mentah ke $RACE_DIR .
(2) Lakukan pelatihan dan evaluasi:
script/tpu_race_large_bsz32.sh untuk pengaturan ini.script/tpu_race_large_bsz8.sh ).Contoh menggunakan Google Colab dengan GPU telah disediakan. Perhatikan bahwa karena perangkat keras dibatasi dalam contoh, hasilnya lebih buruk daripada yang terbaik yang bisa kita dapatkan. Ini terutama berfungsi sebagai contoh dan harus dimodifikasi sesuai untuk memaksimalkan kinerja.
Untuk finetuning, kemungkinan Anda akan dapat memodifikasi file yang ada seperti run_classifier.py , run_squad.py dan run_race.py untuk tugas Anda yang ada. Namun, kami juga memberikan abstraksi XLNET untuk memungkinkan penggunaan yang lebih fleksibel. Di bawah ini adalah contoh:
import xlnet
# some code omitted here...
# initialize FLAGS
# initialize instances of tf.Tensor, including input_ids, seg_ids, and input_mask
# XLNetConfig contains hyperparameters that are specific to a model checkpoint.
xlnet_config = xlnet . XLNetConfig ( json_path = FLAGS . model_config_path )
# RunConfig contains hyperparameters that could be different between pretraining and finetuning.
run_config = xlnet . create_run_config ( is_training = True , is_finetune = True , FLAGS = FLAGS )
# Construct an XLNet model
xlnet_model = xlnet . XLNetModel (
xlnet_config = xlnet_config ,
run_config = run_config ,
input_ids = input_ids ,
seg_ids = seg_ids ,
input_mask = input_mask )
# Get a summary of the sequence using the last hidden state
summary = xlnet_model . get_pooled_out ( summary_type = "last" )
# Get a sequence output
seq_out = xlnet_model . get_sequence_output ()
# build your applications based on `summary` or `seq_out`Di bawah ini adalah contoh melakukan tokenisasi di XLNET:
import sentencepiece as spm
from prepro_utils import preprocess_text , encode_ids
# some code omitted here...
# initialize FLAGS
text = "An input text string."
sp_model = spm . SentencePieceProcessor ()
sp_model . Load ( FLAGS . spiece_model_file )
text = preprocess_text ( text , lower = FLAGS . uncased )
ids = encode_ids ( sp_model , text ) di mana FLAGS.spiece_model_file adalah file model kalimat dalam zip yang sama dengan model pretrained, FLAGS.uncased .
Lihat train.py untuk pretraining pada TPU dan train_gpu.py untuk pretraining pada GPU. Pertama, kita perlu melakukan preprocess data teks menjadi TFRECORD.
python data_utils.py
--bsz_per_host=32
--num_core_per_host=16
--seq_len=512
--reuse_len=256
--input_glob= * .txt
--save_dir= ${SAVE_DIR}
--num_passes=20
--bi_data=True
--sp_path=spiece.model
--mask_alpha=6
--mask_beta=1
--num_predict=85 Di mana input_glob mendefinisikan semua file teks input, save_dir adalah direktori output untuk tfrecords, dan sp_path adalah model potongan kalimat. Inilah naskah kami untuk melatih model karya kalimat
spm_train
--input= $INPUT
--model_prefix=sp10m.cased.v3
--vocab_size=32000
--character_coverage=0.99995
--model_type=unigram
--control_symbols= < cls > , < sep > , < pad > , < mask > , < eod >
--user_defined_symbols= < eop > ,.,(,), " ,-,–,£,€
--shuffle_input_sentence
--input_sentence_size=10000000 Simbol khusus digunakan, termasuk control_symbols dan user_defined_symbols . Kami menggunakan <eop> dan <eod> untuk menunjukkan akhir paragraf dan akhir dokumen masing -masing.
File teks input ke data_utils.py harus menggunakan format berikut:
<eop> dapat dimasukkan di akhir garis tertentu (tanpa ruang apa pun) untuk menunjukkan bahwa kalimat yang sesuai mengakhiri paragraf.Misalnya, file input teks bisa:
This is the first sentence.
This is the second sentence and also the end of the paragraph.<eop>
Another paragraph.
Another document starts here.
Setelah preprocessing, kami siap untuk pretrain xlnet. Di bawah ini adalah hiperparameter yang digunakan untuk pretraining xlnet-large:
python train.py
--record_info_dir= $DATA /tfrecords
--train_batch_size=2048
--seq_len=512
--reuse_len=256
--mem_len=384
--perm_size=256
--n_layer=24
--d_model=1024
--d_embed=1024
--n_head=16
--d_head=64
--d_inner=4096
--untie_r=True
--mask_alpha=6
--mask_beta=1
--num_predict=85Di mana kami hanya mencantumkan bendera yang paling penting dan bendera lainnya dapat disesuaikan berdasarkan kasus penggunaan tertentu.
