xlnet_sequence_tagging
1.0.0
เรากำลังพัฒนาโครงการนี้สำหรับการติดแท็กงานที่ NLPER ตรงกับเสมอ
ใช้ xlnet สำหรับงานต่อไปนี้
สัญญาณเตือนรหัสเหล่านี้ยังไม่เสร็จ ระมัดระวังในการใช้
ตัวอย่างเช่นรัน Scipts โดยใช้:
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://universaldencies.org/
คุณสามารถใช้ "find ./ -name *test/dev/train.conll" เพื่อค้นหาไฟล์ conll ทั้งหมดและใช้ xargs เพื่อคัดลอกไปยัง data_dir
https://github.com/yuchenlin/ontonotes-5.0-ner-bio
เพียงคัดลอกไฟล์ภาษาอังกฤษไปยัง data_dir โดยใช้ไฟล์สคริปต์ Python: onotonotes_conll_copyfile.py (คุณอาจต้องแก้ไขเส้นทาง)
ยินดีต้อนรับ PR ! โปรดช่วยในโครงการพัฒนาเพื่อเพิ่มพลัง NLP ของเรา!
XLNET เป็นวิธีการเรียนรู้การเป็นตัวแทนภาษาที่ไม่ได้รับการดูแลใหม่โดยใช้วัตถุประสงค์การสร้างแบบจำลองภาษาการเปลี่ยนแปลงทั่วไปแบบใหม่ นอกจากนี้ XLNET ยังใช้ Transformer-XL เป็นโมเดล Backbone ซึ่งแสดงประสิทธิภาพที่ยอดเยี่ยมสำหรับงานภาษาที่เกี่ยวข้องกับบริบทที่ยาวนาน โดยรวมแล้ว XLNET บรรลุผลการศึกษาที่ทันสมัย (SOTA) ในงานภาษาดาวน์สตรีมต่างๆรวมถึงการตอบคำถามการอนุมานภาษาธรรมชาติการวิเคราะห์ความเชื่อมั่นและการจัดอันดับเอกสาร
สำหรับคำอธิบายโดยละเอียดเกี่ยวกับรายละเอียดทางเทคนิคและผลการทดลองโปรดดูเอกสารของเรา:
XLNET: การเตรียมการโดยอัตโนมัติเพื่อความเข้าใจภาษาทั่วไป
Zhilin Yang*, Zihang Dai*, Yiming Yang, Jaime Carbonell, Ruslan Salakhutdinov, Quoc V. Le
(*: การมีส่วนร่วมที่เท่าเทียมกัน)
Preprint 2019
ณ วันที่ 19 มิถุนายน 2019 XLNET มีประสิทธิภาพเหนือกว่าเบิร์ตในงาน 20 งานและบรรลุผลที่ทันสมัยในงาน 18 งาน ด้านล่างนี้เป็นการเปรียบเทียบระหว่าง XLNET-Large และ Bert-Large ซึ่งมีขนาดโมเดลที่คล้ายกัน:
| แบบอย่าง | ความแม่นยำในการแข่งขัน | Squad1.1 em | Squad2.0 em |
|---|---|---|---|
| เบิร์ตขนาดใหญ่ | 72.0 | 84.1 | 78.98 |
| xlnet-base | 80.18 | ||
| ขนาดใหญ่ xlnet | 81.75 | 88.95 | 86.12 |
เราใช้ผลการพัฒนาของทีมในตารางเพื่อแยกปัจจัยอื่น ๆ เช่นการใช้ข้อมูลการฝึกอบรมเพิ่มเติมหรือเทคนิคการเพิ่มข้อมูลอื่น ๆ ดูกระดานผู้นำสำหรับหมายเลขทดสอบ
| แบบอย่าง | IMDB | ตะโกน -2 | Yelp-5 | DBPEDIA | Amazon-2 | Amazon-5 |
|---|---|---|---|---|---|---|
| เบิร์ตขนาดใหญ่ | 4.51 | 1.89 | 29.32 | 0.64 | 2.63 | 34.17 |
| ขนาดใหญ่ xlnet | 3.79 | 1.55 | 27.80 | 0.62 | 2.40 | 32.26 |
ตัวเลขข้างต้นคืออัตราข้อผิดพลาด
| แบบอย่าง | mnli | qnli | qqp | rte | SST-2 | MRPC | โคล่า | STS-B |
|---|---|---|---|---|---|---|---|---|
| เบิร์ตขนาดใหญ่ | 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 | 89.8 | 93.9 | 91.8 | 83.8 | 95.6 | 89.2 | 63.6 | 91.8 |
เราใช้ผลลัพธ์ dev งานเดียวในตารางเพื่อแยกปัจจัยอื่น ๆ เช่นการเรียนรู้หลายงานหรือการใช้วงดนตรี
ณ วันที่ 16 กรกฎาคม 2019 มีรุ่นต่อไปนี้:
XLNet-Large, Cased : 24 ชั้น, 1024 ซ่อน, 16 หัวXLNet-Base, Cased : 12-layer, 768 ซ่อน, 12-heads โมเดลนี้ได้รับการฝึกฝนเกี่ยวกับข้อมูลเต็มรูปแบบ (แตกต่างจากรุ่นในกระดาษ)เราปล่อยโมเดล cased เฉพาะตอนนี้เพราะในงานที่เราพิจารณาเราพบว่า: (1) สำหรับการตั้งค่าพื้นฐานโมเดล cased และ uncased มีประสิทธิภาพคล้ายกัน (2) สำหรับการตั้งค่าขนาดใหญ่โมเดล cased จะดีขึ้นเล็กน้อยในบางงาน
ไฟล์. zip แต่ละไฟล์มีสามรายการ:
xlnet_model.ckpt ) ที่มีน้ำหนักที่ได้รับการฝึกอบรมล่วงหน้า (ซึ่งจริง ๆ แล้ว 3 ไฟล์)spiece.model ) ใช้สำหรับ (de) โทเค็นxlnet_config.json ) ซึ่งระบุ hyperparameters ของรุ่นนอกจากนี้เรายังวางแผนที่จะปล่อยโมเดลที่ได้รับการฝึกฝนมาอย่างต่อเนื่องภายใต้การตั้งค่าที่แตกต่างกันรวมถึง:
ในการรับการแจ้งเตือนเกี่ยวกับการอัปเดตการประกาศและการเผยแพร่ใหม่เราขอแนะนำให้สมัครรับข้อมูล XLNET บน Google กลุ่ม
ณ วันที่ 19 มิถุนายน 2019 ฐานรหัสนี้ได้รับการทดสอบด้วย TensorFlow 1.13.1 ภายใต้ Python2
XLNet-Large ผลลัพธ์ในกระดาษโดยใช้ GPU ด้วย RAM 12GB-16GB เนื่องจาก 16GB GPU สามารถจัดลำดับเดียวที่มีความยาว 512 สำหรับ XLNet-Large ดังนั้นจำนวนมาก (ตั้งแต่ 32 ถึง 128 เท่ากับ batch_size ) ของ GPU จึงจำเป็นต้องทำซ้ำผลลัพธ์จำนวนมากในกระดาษ จากปัญหาหน่วยความจำที่กล่าวถึงข้างต้นโดยใช้สคริปต์ finetuning เริ่มต้น ( run_classifier.py และ run_squad.py ) เราเปรียบเทียบขนาดแบทช์สูงสุดบน GPU 16GB เดียวที่มี TensorFlow 1.13.1 :
| ระบบ | ความยาว SEQ | ขนาดแบทช์สูงสุด |
|---|---|---|
XLNet-Base | 64 | 120 |
| - | 128 | 56 |
| - | 256 | 24 |
| - | 512 | 8 |
XLNet-Large | 64 | 16 |
| - | 128 | 8 |
| - | 256 | 2 |
| - | 512 | 1 |
ในกรณีส่วนใหญ่เป็นไปได้ที่จะลดขนาดแบทช์ train_batch_size หรือความยาวลำดับสูงสุด max_seq_length ให้พอดีกับฮาร์ดแวร์ที่กำหนด การลดลงของประสิทธิภาพขึ้นอยู่กับงานและทรัพยากรที่มีอยู่
รหัสที่ใช้ในการดำเนินการจำแนก/การถดถอย finetuning อยู่ใน run_classifier.py นอกจากนี้ยังมีตัวอย่างสำหรับการจำแนกประเภทหนึ่งเอกสารมาตรฐานการถดถอยหนึ่งเอกสารและการจำแนกคู่เอกสาร ที่นี่เรามีตัวอย่างคอนกรีตสองตัวอย่างเกี่ยวกับวิธีการใช้ run_classifier.py
จากที่นี่เราถือว่า XLNET-Large และ Xlnet-base ได้รับการดาวน์โหลดไปยัง $LARGE_DIR และ $BASE_DIR ตามลำดับ
ดาวน์โหลดข้อมูลกาวโดยเรียกใช้สคริปต์นี้และแกะกล่องลงในไดเรกทอรีบางส่วน $GLUE_DIR
ดำเนินการ multi-gpu (4 V100 GPUs) finetuning ด้วย XLNet-large โดยการวิ่ง
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=Trueประเมินผล finetuning ด้วย GPU เดียวโดย
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+ "หมายเหตุ :
num_core_per_host หมายถึงจำนวน GPU ที่จะใช้train_batch_size หมายถึงขนาดแบทช์ต่อ GPUeval_all_ckpt อนุญาตให้หนึ่งสามารถประเมินจุดตรวจสอบที่บันทึกไว้ทั้งหมด (บันทึกความถี่ถูกควบคุมโดย save_steps ) หลังจากการฝึกอบรมเสร็จสิ้นและเลือกโมเดลที่ดีที่สุดตามประสิทธิภาพของ DEVdata_dir และ output_dir อ้างถึงไดเรกทอรีของ "ข้อมูลดิบ" และ "tfrecords ที่ประมวลผลล่วงหน้า" ตามลำดับในขณะที่ model_dir เป็นไดเรกทอรีการทำงานสำหรับการบันทึกจุดตรวจและเหตุการณ์ tensorflow model_dir ควรตั้งค่าเป็นโฟลเดอร์แยกต่างหากเป็น init_checkpoint--train_batch_size=32 และ --num_core_per_host=1 พร้อมกับการเปลี่ยนแปลงใน init_checkpoint และ model_config_pathtrain_batch_size และเพิ่ม num_core_per_host เพื่อใช้การตั้งค่าการฝึกอบรมเดียวกันดาวน์โหลดและแกะชุดข้อมูล IMDB โดยใช้งาน
wget http://ai.stanford.edu/~amaas/data/sentiment/aclImdb_v1.tar.gz
tar zxvf aclImdb_v1.tar.gzเรียกใช้อินสแตนซ์ Google Cloud TPU V3-8 (ดูการสอน Google Cloud TPU สำหรับวิธีการตั้งค่า Cloud TPUs)
ตั้งค่าเส้นทาง Bucket ของ Google Storage Bucket ของคุณ $GS_ROOT และเลื่อนชุดข้อมูล IMDB และจุดตรวจสอบล่วงหน้าไปยังที่เก็บข้อมูล Google ของคุณ
ดำเนินการ tpu finetuning ด้วย xlnet ขนาดใหญ่โดยการวิ่ง
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+ "หมายเหตุ :
data_dir และ spiece_model_file ทั้งคู่ใช้เส้นทางท้องถิ่นแทนที่จะเป็นเส้นทางการจัดเก็บของ Google เหตุผลก็คือการประมวลผลข้อมูลล่วงหน้าจะดำเนินการในเครื่อง ดังนั้นการใช้เส้นทางในท้องถิ่นนำไปสู่ความเร็วการประมวลผลล่วงหน้าที่เร็วขึ้น รหัสสำหรับชุดข้อมูลทีมรวมอยู่ใน run_squad.py
เพื่อเรียกใช้รหัส:
(1) ดาวน์โหลดชุดข้อมูล squad2.0 เป็น $SQUAD_DIR โดย:
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) ดำเนินการประมวลผลข้อมูลล่วงหน้าโดยใช้ scripts/prepro_squad.sh
สิ่งนี้จะใช้เวลาพอสมควรในการแมปตำแหน่งตัวละคร (ข้อมูลดิบ) ไปยังตำแหน่งชิ้นส่วน (ใช้สำหรับการฝึกอบรม)
สำหรับการประมวลผลล่วงหน้าแบบขนานที่เร็วขึ้นโปรดดูที่ธง --num_proc และ --proc_id ใน run_squad.py
(3) ทำการฝึกอบรมและประเมินผล
เพื่อประสิทธิภาพที่ดีที่สุด XLNET-Large ใช้ความยาวลำดับ 512 และขนาดแบทช์ 48 สำหรับการฝึกอบรม
เป็นผลให้การทำซ้ำผลลัพธ์ที่ดีที่สุดกับ GPU นั้นค่อนข้างยาก
สำหรับการฝึกอบรมด้วยหนึ่ง TPU V3-8 หนึ่งสามารถเรียกใช้ scripts/tpu_squad_large.sh หลังจากตั้งค่าทั้ง TPU และ Google ที่เก็บข้อมูลแล้ว
run_squad.py จะทำการค้นหาเกณฑ์โดยอัตโนมัติในชุด dev ของทีมและส่งออกคะแนน ด้วย scripts/tpu_squad_large.sh คะแนน F1 ที่คาดหวังควรอยู่ที่ประมาณ 88.6 (ค่ามัธยฐานของการวิ่งหลายครั้งของเรา)
อีกทางเลือกหนึ่งสามารถใช้ XLNet-base กับ GPU (เช่นสาม V100) พารามิเตอร์ไฮเปอร์ที่เหมาะสมหนึ่งชุดสามารถพบได้ใน scripts/gpu_squad_base.sh
รหัสสำหรับการแข่งขัน Task Task การอ่านจะรวมอยู่ใน run_race.py
เพื่อเรียกใช้รหัส:
(1) ดาวน์โหลดชุดข้อมูลการแข่งขันจากเว็บไซต์อย่างเป็นทางการและแกะข้อมูลดิบเป็น $RACE_DIR
(2) ทำการฝึกอบรมและประเมินผล:
script/tpu_race_large_bsz32.sh สำหรับการตั้งค่านี้script/tpu_race_large_bsz8.sh )มีการจัดเตรียมตัวอย่างของการใช้ Google colab กับ GPU โปรดทราบว่าเนื่องจากฮาร์ดแวร์ถูก จำกัด ในตัวอย่างผลลัพธ์จึงเลวร้ายยิ่งกว่าสิ่งที่ดีที่สุดที่เราจะได้รับ ส่วนใหญ่ทำหน้าที่เป็นตัวอย่างและควรได้รับการแก้ไขเพื่อเพิ่มประสิทธิภาพสูงสุด
สำหรับ Finetuning มีแนวโน้มว่าคุณจะสามารถแก้ไขไฟล์ที่มีอยู่เช่น run_classifier.py , run_squad.py และ run_race.py สำหรับงานของคุณ อย่างไรก็ตามเรายังจัดให้มีนามธรรมของ XLNET เพื่อให้การใช้งานที่ยืดหยุ่นมากขึ้น ด้านล่างเป็นตัวอย่าง:
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`ด้านล่างเป็นตัวอย่างของการทำโทเค็นใน 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 ) โดยที่ FLAGS.spiece_model_file เป็นไฟล์รุ่นประโยคในซิปเดียวกับรุ่น pretrained, FLAGS.uncased เป็นบูลที่ระบุว่าจะทำ uncasing หรือไม่
อ้างถึง train.py สำหรับการเตรียมการใน TPUs และ train_gpu.py สำหรับการเตรียมการใน GPU ก่อนอื่นเราต้องประมวลผลข้อมูลข้อความล่วงหน้าลงใน tfrecords
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 โดยที่ input_glob กำหนดไฟล์ข้อความอินพุตทั้งหมด save_dir เป็นไดเรกทอรีเอาต์พุตสำหรับ tfrecords และ sp_path เป็นโมเดลชิ้นส่วนประโยค นี่คือสคริปต์ของเราในการฝึกอบรมโมเดลชิ้นประโยค
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 มีการใช้สัญลักษณ์พิเศษรวมถึง control_symbols และ user_defined_symbols เราใช้ <eop> และ <eod> เพื่อแสดงถึงจุดสิ้นสุดของวรรคและสิ้นสุดของเอกสารตามลำดับ
ไฟล์ข้อความอินพุตไปยัง data_utils.py ต้องใช้รูปแบบต่อไปนี้:
<eop> สามารถแทรกได้ที่ส่วนท้ายของบางบรรทัด (โดยไม่มีพื้นที่ใด ๆ ) เพื่อระบุว่าประโยคที่เกี่ยวข้องสิ้นสุดวรรคตัวอย่างเช่นไฟล์อินพุตข้อความอาจเป็น:
This is the first sentence.
This is the second sentence and also the end of the paragraph.<eop>
Another paragraph.
Another document starts here.
หลังจากประมวลผลล่วงหน้าเราพร้อมที่จะเตรียม XLNet ด้านล่างนี้คือพารามิเตอร์ไฮเปอร์พารามิเตอร์ที่ใช้สำหรับการปรับแต่ง xlnet ขนาดใหญ่:
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=85ในกรณีที่เราแสดงรายการธงที่สำคัญที่สุดและธงอื่น ๆ เท่านั้นที่สามารถปรับได้ตามกรณีการใช้งานเฉพาะ
