bert
1.0.0
***** ใหม่ 11 มีนาคม 2563: รุ่นเบิร์ตขนาดเล็ก *****
นี่คือการเปิดตัวรุ่นเบิร์ตขนาดเล็ก 24 รุ่น (ภาษาอังกฤษเท่านั้นที่ไม่ได้ฝึกฝนด้วยการปิดบังคำศัพท์) ที่อ้างอิงในนักเรียนที่อ่านดีเรียนรู้ได้ดีขึ้น: ความสำคัญของแบบจำลองการฝึกอบรมก่อนการฝึกอบรม
เราได้แสดงให้เห็นว่าสูตรเบิร์ตมาตรฐาน (รวมถึงสถาปัตยกรรมแบบจำลองและวัตถุประสงค์การฝึกอบรม) มีประสิทธิภาพในขนาดของรุ่นที่หลากหลายนอกเหนือจาก Bert-Base และ Bert-Large แบบจำลองเบิร์ตขนาดเล็กนั้นมีไว้สำหรับสภาพแวดล้อมที่มีทรัพยากรการคำนวณที่ จำกัด พวกเขาสามารถปรับแต่งได้อย่างดีในลักษณะเดียวกับรุ่นเบิร์ตดั้งเดิม อย่างไรก็ตามพวกเขามีประสิทธิภาพมากที่สุดในบริบทของการกลั่นความรู้ซึ่งฉลากการปรับแต่งถูกผลิตโดยครูที่มีขนาดใหญ่และแม่นยำยิ่งขึ้น
เป้าหมายของเราคือการเปิดใช้งานการวิจัยในสถาบันที่มีทรัพยากรการคำนวณน้อยลงและกระตุ้นให้ชุมชนค้นหาทิศทางของนวัตกรรมทางเลือกในการเพิ่มขีดความสามารถของแบบจำลอง
คุณสามารถดาวน์โหลดทั้งหมด 24 ทั้งหมดจากที่นี่หรือเป็นรายบุคคลจากตารางด้านล่าง:
| 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) |
โปรดทราบว่าโมเดล 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 ยุค:
หากคุณใช้โมเดลเหล่านี้โปรดอ้างอิงกระดาษต่อไปนี้:
@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}
}
***** ใหม่ 31 พฤษภาคม 2019: โมเดลการปิดบังคำทั้งหมด *****
นี่คือการเปิดตัวรุ่นใหม่หลายรุ่นซึ่งเป็นผลมาจากการปรับปรุงรหัสการประมวลผลล่วงหน้า
ในรหัสการประมวลผลล่วงหน้าดั้งเดิมเราสุ่มเลือกโทเค็น WordPiece เป็น MASK ตัวอย่างเช่น:
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
การฝึกอบรมนั้นเหมือนกัน - เรายังคงทำนายโทเค็นคำที่สวมหน้ากากแต่ละตัวได้อย่างอิสระ การปรับปรุงมาจากความจริงที่ว่างานการทำนายดั้งเดิมนั้น 'ง่ายเกินไป' สำหรับคำที่ถูกแบ่งออกเป็นคำพูดหลายคำ
สิ่งนี้สามารถเปิดใช้งานระหว่างการสร้างข้อมูลโดยผ่านธง --do_whole_word_mask=True to create_pretraining_data.py
โมเดลที่ผ่านการฝึกอบรมมาก่อนพร้อมการปิดบังคำทั้งหมดมีการเชื่อมโยงด้านล่าง ข้อมูลและการฝึกอบรมนั้นเหมือนกันและแบบจำลองมีโครงสร้างที่เหมือนกันและคำศัพท์สำหรับโมเดลดั้งเดิม เรารวมเฉพาะรุ่น Bert ที่มีขนาดใหญ่ เมื่อใช้โมเดลเหล่านี้โปรดทำให้ชัดเจนในกระดาษที่คุณใช้ตัวแปรการปิดบังคำทั้งหมดของ 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 |
|---|---|---|
| Bert-Large, uncased (ต้นฉบับ) | 91.0/84.3 | 86.05 |
| Bert-Large, uncased (การปิดบังคำทั้งหมด) | 92.8/86.7 | 87.07 |
| Bert-Large, cased (ต้นฉบับ) | 91.5/84.8 | 86.09 |
| Bert-Large, cased (การปิดบังคำทั้งหมด) | 92.9/86.7 | 86.46 |
***** ใหม่ 7 กุมภาพันธ์ 2019: โมดูล tfhub *****
เบิร์ตได้รับการอัปโหลดไปยังฮับ Tensorflow ดู run_classifier_with_tfhub.py สำหรับตัวอย่างของวิธีการใช้โมดูลฮับ TF หรือเรียกใช้ตัวอย่างในเบราว์เซอร์บน colab
***** ใหม่ 23 พฤศจิกายน 2018: โมเดลหลายภาษาที่ไม่ปกติ + ไทย + มองโกเลีย *****
เราอัปโหลดโมเดลหลายภาษาใหม่ซึ่ง ไม่ ได้ทำการทำให้เป็นมาตรฐานในอินพุต (ไม่มีปลอกที่ต่ำกว่าการปอกสำเนียงหรือการทำให้เป็นมาตรฐาน Unicode) และนอกจากนี้ยังรวมถึงไทยและมองโกเลีย
ขอแนะนำให้ใช้รุ่นนี้สำหรับการพัฒนารุ่นหลายภาษาโดยเฉพาะอย่างยิ่งในภาษาที่มีตัวอักษรที่ไม่ใช่ละติน
สิ่งนี้ไม่จำเป็นต้องมีการเปลี่ยนแปลงรหัสใด ๆ และสามารถดาวน์โหลดได้ที่นี่:
BERT-Base, Multilingual Cased : 104 ภาษา, 12-layer, 768 ซ่อน, 12-heads, 110m พารามิเตอร์***** ใหม่ 15 พฤศจิกายน 2018: Sota Squad 2.0 System *****
เราเปิดตัวการเปลี่ยนแปลงรหัสเพื่อทำซ้ำระบบ 83% F1 Squad 2.0 ของเราซึ่งปัจจุบันเป็นอันดับ 1 บนกระดานผู้นำ 3% ดูส่วน Squad 2.0 ของ ReadMe สำหรับรายละเอียด
***** ใหม่ 5 พฤศจิกายน 2018: Pytorch บุคคลที่สามและ Bert เวอร์ชันเชนเนอร์มีให้บริการ *****
นักวิจัย NLP จาก HuggingFace ทำ Bert เวอร์ชัน Pytorch ซึ่งเข้ากันได้กับจุดตรวจสอบที่ผ่านการฝึกอบรมมาก่อนและสามารถทำซ้ำผลลัพธ์ของเราได้ Sosuke Kobayashi ยังทำเบิร์ตรุ่นเชนเนอร์ (ขอบคุณ!) เราไม่ได้มีส่วนร่วมในการสร้างหรือบำรุงรักษาการใช้งาน Pytorch ดังนั้นโปรดส่งคำถามใด ๆ ไปยังผู้เขียนของที่เก็บนั้น
***** ใหม่วันที่ 3 พฤศจิกายน 2018: มีหลายภาษาและภาษาจีนที่มีอยู่ *****
เราได้สร้างแบบจำลองเบิร์ตใหม่สองรุ่น:
BERT-Base, Multilingual (ไม่แนะนำให้ใช้ Multilingual Cased แทน) : 102 ภาษา, 12-layer, 768 ซ่อน, 12-heads, พารามิเตอร์ 110mBERT-Base, Chinese : จีนง่ายและดั้งเดิม, 12 ชั้น, 768 ซ่อน, 12 หัว, พารามิเตอร์ 110m เราใช้โทเค็นที่ใช้ตัวละครสำหรับภาษาจีนและคำพูดคำสำหรับภาษาอื่น ๆ ทั้งหมด ทั้งสองรุ่นควรทำงานนอกกรอบโดยไม่มีการเปลี่ยนแปลงรหัสใด ๆ เราได้อัปเดตการใช้งานของ BasicTokenizer ใน tokenization.py เพื่อสนับสนุน tokenization อักขระจีนดังนั้นโปรดอัปเดตหากคุณแยกมัน อย่างไรก็ตามเราไม่ได้เปลี่ยน Tokenization API
สำหรับข้อมูลเพิ่มเติมให้ดู readme หลายภาษา
***** สิ้นสุดข้อมูลใหม่ *****
bert หรือ b idirectional e ncoder r epresentations จาก t ransformers เป็นวิธีใหม่ของการเป็นตัวแทนภาษาก่อนการฝึกอบรมซึ่งได้รับผลลัพธ์ที่ทันสมัยในงานการประมวลผลภาษาธรรมชาติ (NLP) ที่หลากหลาย
บทความวิชาการของเราซึ่งอธิบายถึงรายละเอียดของเบิร์ตและให้ผลลัพธ์เต็มรูปแบบเกี่ยวกับงานจำนวนมากสามารถพบได้ที่นี่: https://arxiv.org/abs/1810.04805
เพื่อให้ตัวเลขไม่กี่นี่คือผลลัพธ์ของ Squad v1.1 งานตอบคำถาม:
| Squad v1.1 Laderboard (8 ต.ค. 2018) | ทดสอบ em | ทดสอบ F1 |
|---|---|---|
| อันดับที่ 1 - เบิร์ต | 87.4 | 93.2 |
| 2nd Place Ensemble - nlnet | 86.0 | 91.7 |
| อันดับที่ 1 รุ่นเดียว - เบิร์ต | 85.1 | 91.8 |
| อันดับที่ 2 รุ่นเดียว - NlNet | 83.5 | 90.1 |
และงานการอนุมานภาษาธรรมชาติหลายอย่าง:
| ระบบ | มัลติอินลี่ | คำถาม nli | ย้อย |
|---|---|---|---|
| เบิร์ต | 86.7 | 91.1 | 86.3 |
| Openai GPT (ก่อนหน้า SOTA) | 82.2 | 88.1 | 75.0 |
บวกงานอื่น ๆ อีกมากมาย
ยิ่งไปกว่านั้นผลลัพธ์เหล่านี้ทั้งหมดได้มาโดยแทบไม่มีการออกแบบสถาปัตยกรรมเครือข่ายประสาทเฉพาะงาน
หากคุณรู้อยู่แล้วว่าเบิร์ตคืออะไรและคุณแค่ต้องการเริ่มต้นคุณสามารถดาวน์โหลดโมเดลที่ผ่านการฝึกอบรมมาก่อนและเรียกใช้การปรับแต่งที่ล้ำสมัยในเวลาเพียงไม่กี่นาที
เบิร์ตเป็นวิธีการเป็นตัวแทนภาษาก่อนการฝึกอบรมซึ่งหมายความว่าเราฝึกอบรมแบบจำลอง "การทำความเข้าใจภาษา" ที่มีวัตถุประสงค์ทั่วไปในคลังข้อความขนาดใหญ่ (เช่น Wikipedia) จากนั้นใช้แบบจำลองนั้นสำหรับงาน NLP ดาวน์สตรีมที่เราใส่ใจ (เช่นคำถาม ตอบ) เบิร์ตมีประสิทธิภาพเหนือกว่าวิธีการก่อนหน้านี้เพราะเป็นระบบ สองทิศทาง ที่ไม่ได้รับการดูแล และไม่ได้รับการดูแลเป็นครั้งแรกสำหรับ NLP ก่อนการฝึกอบรม
ไม่ได้รับการดูแล หมายความว่าเบิร์ตได้รับการฝึกฝนโดยใช้คลังข้อความธรรมดาเท่านั้นซึ่งมีความสำคัญเนื่องจากข้อมูลข้อความธรรมดาจำนวนมหาศาลนั้นเปิดเผยต่อสาธารณะบนเว็บในหลายภาษา
การเป็นตัวแทนที่ผ่านการฝึกอบรมมาก่อนสามารถ ปราศจากบริบท หรือ บริบท และการเป็นตัวแทนตามบริบทอาจเป็น ทิศทางเดียว หรือ สองทิศทาง โมเดลที่ปราศจากบริบทเช่น Word2vec หรือ Glove สร้างการแสดง "การฝังคำ" เดียวสำหรับแต่ละคำในคำศัพท์ดังนั้น bank จะมีตัวแทนเดียวกันใน bank deposit และ river bank แบบจำลองบริบทแทนที่จะสร้างการแสดงของแต่ละคำที่ขึ้นอยู่กับคำอื่น ๆ ในประโยค
เบิร์ตถูกสร้างขึ้นจากงานล่าสุดในการฝึกอบรมบริบทก่อนการฝึกอบรม-รวมถึงการเรียนรู้ลำดับกึ่งผู้ดูแลการฝึกอบรมก่อนการฝึกอบรม Elmo และ ULMFIT-แต่แบบจำลองเหล่านี้เป็นแบบ ทิศทางเดียว หรือ แบบสองทิศทาง ซึ่งหมายความว่าแต่ละคำมีบริบทโดยใช้คำทางด้านซ้าย (หรือขวา) ตัวอย่างเช่นในประโยค I made a bank deposit การเป็นตัวแทนของ bank ทางทิศทางเดียวนั้นขึ้นอยู่กับการ I made a แต่ไม่ได้ deposit งานก่อนหน้านี้บางชิ้นรวมการเป็นตัวแทนจากโมเดลบริบทซ้ายและบริบทที่ถูกต้องแยกต่างหาก แต่ในลักษณะ "ตื้น" เท่านั้น เบิร์ตแสดงถึง "ธนาคาร" โดยใช้บริบททั้งซ้ายและขวา - I made a ... deposit เริ่มต้นจากด้านล่างสุดของเครือข่ายประสาทลึกดังนั้นจึงเป็น แบบสองทิศทางลึก
เบิร์ตใช้วิธีการง่ายๆสำหรับสิ่งนี้: เราปกปิด 15% ของคำในอินพุตเรียกใช้ลำดับทั้งหมดผ่านตัวเข้ารหัสหม้อแปลงสองทิศทางลึกและจากนั้นทำนายคำที่สวมหน้ากากเท่านั้น ตัวอย่างเช่น:
Input: the man went to the [MASK1] . he bought a [MASK2] of milk.
Labels: [MASK1] = store; [MASK2] = gallon
เพื่อเรียนรู้ความสัมพันธ์ระหว่างประโยคเรายังฝึกอบรมงานง่าย ๆ ซึ่งสามารถสร้างขึ้นได้จากคลังข้อมูลแบบ monolingual: ให้สองประโยค 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
จากนั้นเราฝึกอบรมรุ่นใหญ่ (12 ชั้นถึง 24 ชั้นหม้อแปลง) บนคลังข้อมูลขนาดใหญ่ (Wikipedia + Bookcorpus) เป็นเวลานาน (ขั้นตอนการอัปเดต 1m) และนั่นคือ Bert
การใช้เบิร์ตมีสองขั้นตอน: การฝึกอบรมก่อน และ ปรับแต่ง
การฝึกอบรมล่วงหน้า มีราคาค่อนข้างแพง (สี่วันใน 4 ถึง 16 คลาวด์ TPUs) แต่เป็นขั้นตอนเดียวสำหรับแต่ละภาษา (รุ่นปัจจุบันเป็นภาษาอังกฤษเท่านั้น แต่รุ่นที่พูดได้หลายภาษาจะเปิดตัวในอนาคตอันใกล้) เรากำลังเปิดตัวโมเดลที่ผ่านการฝึกอบรมมาแล้วจำนวนหนึ่งจากกระดาษซึ่งได้รับการฝึกอบรมมาก่อนที่ Google นักวิจัย NLP ส่วนใหญ่ไม่จำเป็นต้องฝึกอบรมแบบจำลองของตัวเองล่วงหน้าตั้งแต่เริ่มต้น
การปรับแต่งมี ราคาไม่แพง ผลลัพธ์ทั้งหมดในกระดาษสามารถทำซ้ำได้อย่างมาก 1 ชั่วโมงในคลาวด์ TPU เดียวหรือไม่กี่ชั่วโมงบน GPU เริ่มต้นจากรุ่นที่ผ่านการฝึกอบรมมาก่อน ตัวอย่างเช่นทีมสามารถได้รับการฝึกฝนในประมาณ 30 นาทีในคลาวด์ TPU เดียวเพื่อให้ได้คะแนน DEV F1 ที่ 91.0%ซึ่งเป็นระบบเดียวที่ทันสมัย
สิ่งสำคัญอื่น ๆ ของเบิร์ตคือมันสามารถปรับให้เข้ากับงาน NLP หลายประเภทได้อย่างง่ายดายมาก ในบทความเราแสดงให้เห็นถึงผลลัพธ์ที่ทันสมัยในระดับประโยค (เช่น SST-2), ระดับประโยคคู่ (เช่น multinli), ระดับคำ (เช่น ner) และระดับขยาย (เช่นทีม) งานที่แทบไม่มีการดัดแปลงเฉพาะงาน
เรากำลังปล่อยสิ่งต่อไปนี้:
BERT-Base และ BERT-Large จากกระดาษรหัสทั้งหมดในที่เก็บนี้ทำงานนอกกรอบด้วย CPU, GPU และ Cloud TPU
เรากำลังปล่อยรุ่น BERT-Base และ BERT-Large จากกระดาษ Uncased หมายความว่าข้อความนั้นได้รับการลดลงก่อนที่คำพูดของคำพูดเช่น John Smith จะกลายเป็น john smith โมเดล Uncased ยังตัดเครื่องหมายสำเนียงใด ๆ ออกมา Cased หมายความว่ากรณีที่แท้จริงและเครื่องหมายสำเนียงจะถูกเก็บรักษาไว้ โดยทั่วไปแล้วโมเดล Uncased จะดีกว่าเว้นแต่คุณจะรู้ว่าข้อมูลกรณีมีความสำคัญสำหรับงานของคุณ (เช่นการจดจำเอนทิตีที่มีชื่อหรือการติดแท็กส่วนหนึ่งของการพูด)
แบบจำลองเหล่านี้ทั้งหมดได้รับการเผยแพร่ภายใต้ใบอนุญาตเดียวกับซอร์สโค้ด (Apache 2.0)
สำหรับข้อมูลเกี่ยวกับโมเดลหลายภาษาและภาษาจีนดู readme หลายภาษา
เมื่อใช้โมเดล cased ตรวจสอบให้แน่ใจว่าผ่าน --do_lower=False กับสคริปต์การฝึกอบรม (หรือผ่าน do_lower_case=False โดยตรงไปยัง FullTokenizer หากคุณใช้สคริปต์ของคุณเอง)
ลิงค์ไปยังรุ่นอยู่ที่นี่ (คลิกขวา 'บันทึกลิงก์เป็น ... ' ในชื่อ):
BERT-Large, Uncased (Whole Word Masking) : 24 ชั้น, 1024 ซ่อน, 16 หัว, พารามิเตอร์ 340mBERT-Large, Cased (Whole Word Masking) : 24 ชั้น, 1024 ซ่อน, 16 หัว, พารามิเตอร์ 340mBERT-Base, Uncased : 12-layer, 768 ซ่อน, 12 หัว, พารามิเตอร์ 110mBERT-Large, Uncased : 24-layer, 1024 ซ่อน, 16 หัว, 340m พารามิเตอร์BERT-Base, Cased : 12-layer, 768 ซ่อน, 12 หัว, พารามิเตอร์ 110mBERT-Large, Cased : 24 ชั้น, 1024 ซ่อน, 16 หัว, 340m พารามิเตอร์BERT-Base, Multilingual Cased (New, recommended) : 104 ภาษา, 12-layer, 768 ซ่อน, 12 หัว, พารามิเตอร์ 110mBERT-Base, Multilingual Uncased (Orig, not recommended) (ไม่แนะนำให้ใช้ Multilingual Cased แทน) : 102 ภาษา, 12-layer, 768 ซ่อน, 12-heads, 110m พารามิเตอร์BERT-Base, Chinese : จีนง่ายและดั้งเดิม, 12 ชั้น, 768 ซ่อน, 12 หัว, พารามิเตอร์ 110mไฟล์. zip แต่ละไฟล์มีสามรายการ:
bert_model.ckpt ) ที่มีน้ำหนักที่ได้รับการฝึกอบรมก่อน (ซึ่งเป็นจริง 3 ไฟล์)vocab.txt ) เพื่อแมปคำ WordPiece ไปยัง Word IDbert_config.json ) ซึ่งระบุ hyperparameters ของรุ่น สำคัญ : ผลลัพธ์ทั้งหมดบนกระดาษได้รับการปรับแต่งอย่างละเอียดบนคลาวด์ TPU เดียวซึ่งมี RAM 64GB ขณะนี้มันเป็นไปไม่ได้ที่จะผลิตผลลัพธ์ส่วนใหญ่ของ BERT-Large บนกระดาษโดยใช้ GPU ที่มี RAM 12GB-16GB เนื่องจากขนาดแบทช์สูงสุดที่พอดีกับหน่วยความจำมีขนาดเล็กเกินไป เรากำลังดำเนินการเพื่อเพิ่มรหัสลงในที่เก็บนี้ซึ่งช่วยให้ขนาดแบทช์ที่มีประสิทธิภาพมากขึ้นบน GPU ดูหัวข้อเกี่ยวกับปัญหานอกหน่วยความจำสำหรับรายละเอียดเพิ่มเติม
รหัสนี้ได้รับการทดสอบด้วย TensorFlow 1.11.0 มันถูกทดสอบด้วย Python2 และ Python3 (แต่อย่างละเอียดยิ่งขึ้นกับ Python2 เนื่องจากนี่คือสิ่งที่ใช้ภายในใน Google)
ตัวอย่างการปรับจูนที่ใช้ BERT-Base ควรจะสามารถทำงานบน GPU ที่มี RAM อย่างน้อย 12GB โดยใช้พารามิเตอร์ที่ได้รับ
ตัวอย่างส่วนใหญ่ด้านล่างสันนิษฐานว่าคุณจะทำการฝึกอบรม/ประเมินผลในเครื่องในเครื่องของคุณโดยใช้ GPU เช่น Titan X หรือ GTX 1080
อย่างไรก็ตามหากคุณสามารถเข้าถึงคลาวด์ TPU ที่คุณต้องการฝึกอบรมเพียงเพิ่มธงต่อไปนี้ใน run_classifier.py หรือ run_squad.py :
--use_tpu=True
--tpu_name=$TPU_NAME
โปรดดูการสอนของ Google Cloud TPU สำหรับวิธีใช้ Cloud TPU หรือคุณสามารถใช้โน้ตบุ๊ก Google Colab "Bert Finetuning กับ Cloud TPUs"
บนคลาวด์ TPUs โมเดลที่ผ่านการฝึกอบรมและไดเรกทอรีเอาท์พุทจะต้องอยู่ในที่เก็บข้อมูลของ Google Cloud ตัวอย่างเช่นหากคุณมีถังชื่อ some_bucket คุณอาจใช้ธงต่อไปนี้แทน:
--output_dir=gs://some_bucket/my_output_dir/
ไฟล์โมเดลที่ผ่านการฝึกอบรมล่วงหน้าที่ได้รับการฝึกอบรมยังสามารถพบได้ในโฟลเดอร์ Google Cloud Storage 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
ตัวอย่างนี้รหัสการปรับ BERT-Base ข้อมูล Paraphrase Corpus (MRPC) ของ Microsoft Research ซึ่งมีเพียง 3,600 ตัวอย่างและสามารถปรับแต่งได้ในเวลาไม่กี่นาทีใน GPUs ส่วนใหญ่
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
ซึ่งหมายความว่าความแม่นยำของชุด Dev คือ 84.55% ชุดขนาดเล็กเช่น MRPC มีความแปรปรวนสูงในความแม่นยำของชุด dev แม้ว่าจะเริ่มต้นจากจุดตรวจสอบก่อนการฝึกอบรมเดียวกัน หากคุณทำงานอีกครั้งหลายครั้ง (ตรวจสอบให้แน่ใจว่าชี้ไปที่ output_dir ที่แตกต่างกัน) คุณควรเห็นผลลัพธ์ระหว่าง 84% ถึง 88%
โมเดลที่ผ่านการฝึกอบรมมาก่อนจะถูกนำไปใช้นอกชั้นวางใน run_classifier.py ดังนั้นจึงควรทำตามตัวอย่างเหล่านั้นเพื่อใช้ Bert สำหรับงานการจำแนกประเภทเดียวหรือการจำแนกประโยคใด ๆ
หมายเหตุ: คุณอาจเห็นข้อความ Running train on CPU นี่หมายความว่ามันทำงานบนสิ่งอื่นนอกเหนือจากคลาวด์ TPU ซึ่งรวมถึง GPU
เมื่อคุณได้รับการฝึกฝนการแยกประเภทของคุณแล้วคุณสามารถใช้ในโหมดการอนุมานได้โดยใช้คำสั่ง -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/ ชุดข้อมูลการตอบคำถาม Stanford (Squad) เป็นชุดข้อมูลการตอบคำถามยอดนิยม เบิร์ต (ในช่วงเวลาของการเปิดตัว) ได้รับผลลัพธ์ที่ล้ำสมัยของทีมที่แทบจะไม่มีการปรับเปลี่ยนสถาปัตยกรรมเครือข่ายเฉพาะงานหรือการเพิ่มข้อมูล อย่างไรก็ตามมันต้องใช้ข้อมูลกึ่งคอมเพล็กซ์ก่อนการประมวลผลและหลังการประมวลผลเพื่อจัดการกับ (a) ลักษณะความยาวตัวแปรของย่อหน้าบริบทของทีมและ (b) คำอธิบายประกอบคำตอบระดับอักขระที่ใช้สำหรับการฝึกอบรมทีม การประมวลผลนี้ถูกนำไปใช้และบันทึกไว้ใน run_squad.py
ในการรันบนทีมคุณจะต้องดาวน์โหลดชุดข้อมูลก่อน ดูเหมือนว่าเว็บไซต์ของทีมจะไม่เชื่อมโยงไปยังชุดข้อมูล v1.1 อีกต่อไป แต่ไฟล์ที่จำเป็นสามารถพบได้ที่นี่:
ดาวน์โหลดเหล่านี้ไปยังไดเรกทอรี $SQUAD_DIR
ทีมที่ล้ำสมัยเป็นผลมาจากกระดาษในปัจจุบันไม่สามารถทำซ้ำได้ใน GPU 12GB-16GB เนื่องจากข้อ จำกัด ของหน่วยความจำ (อันที่จริงแล้วขนาดแบทช์ 1 ดูเหมือนจะไม่พอดีกับ GPU 12GB โดยใช้ BERT-Large ) อย่างไรก็ตามโมเดล BERT-Base ที่แข็งแกร่งพอสมควรสามารถได้รับการฝึกฝนบน GPU ด้วยพารามิเตอร์ไฮเปอร์พารามิเตอร์เหล่านี้:
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 จะถูกบันทึกลงในไฟล์ที่เรียกว่า predictions.json ใน output_dir :
python $SQUAD_DIR /evaluate-v1.1.py $SQUAD_DIR /dev-v1.1.json ./squad/predictions.jsonซึ่งควรสร้างผลลัพธ์เช่นนี้:
{ " f1 " : 88.41249612335034, " exact_match " : 81.2488174077578} คุณควรเห็นผลลัพธ์ที่คล้ายกับ 88.5% ที่รายงานในกระดาษสำหรับ BERT-Base
หากคุณสามารถเข้าถึงคลาวด์ 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ตัวอย่างเช่นหนึ่งการรันแบบสุ่มด้วยพารามิเตอร์เหล่านี้สร้างคะแนน dev ต่อไปนี้:
{ " f1 " : 90.87081895814865, " exact_match " : 84.38978240302744}หากคุณปรับแต่งสำหรับยุคหนึ่งใน Triviaqa ก่อนหน้านี้ผลลัพธ์จะดียิ่งขึ้น แต่คุณจะต้องแปลง Triviaqa เป็นรูปแบบ JSON ของทีม
รุ่นนี้ยังถูกนำไปใช้และบันทึกไว้ใน run_squad.py
ในการเรียกใช้บน Squad 2.0 คุณจะต้องดาวน์โหลดชุดข้อมูลก่อน ไฟล์ที่จำเป็นสามารถพบได้ที่นี่:
ดาวน์โหลดเหล่านี้ไปยังไดเรกทอรี $SQUAD_DIR
บน Cloud 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 และความแตกต่างระหว่างคะแนนของไม่มีคำตอบ ("") และคำตอบที่ไม่ใช่ Null ที่ดีที่สุดสำหรับแต่ละคำถามจะอยู่ในไฟล์./squad/null_odds.json
เรียกใช้สคริปต์นี้เพื่อปรับเกณฑ์สำหรับการทำนายค่า null กับคำตอบที่ไม่ใช่ Null:
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" 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การทดลองทั้งหมดในกระดาษได้รับการปรับแต่งบนคลาวด์ TPU ซึ่งมี RAM อุปกรณ์ 64GB ดังนั้นเมื่อใช้ GPU ที่มี RAM 12GB-16GB คุณมีแนวโน้มที่จะพบปัญหานอกหน่วยความจำหากคุณใช้พารามิเตอร์ไฮเปอร์พารามิเตอร์เดียวกันที่อธิบายไว้ในกระดาษ
ปัจจัยที่มีผลต่อการใช้หน่วยความจำคือ:
max_seq_length : รุ่นที่ปล่อยออกมาได้รับการฝึกฝนด้วยความยาวลำดับสูงถึง 512 แต่คุณสามารถปรับแต่งด้วยความยาวลำดับสูงสุดที่สั้นกว่าเพื่อบันทึกหน่วยความจำที่สำคัญ สิ่งนี้ถูกควบคุมโดยค่าสถานะ max_seq_length ในรหัสตัวอย่างของเรา
train_batch_size : การใช้หน่วยความจำนั้นเป็นสัดส่วนโดยตรงกับขนาดแบทช์
ประเภทของรุ่น, BERT-Base vs. BERT-Large : รุ่น BERT-Large ต้องการหน่วยความจำมากกว่า BERT-Base อย่างมีนัยสำคัญ
Optimizer : เครื่องมือเพิ่มประสิทธิภาพเริ่มต้นสำหรับ Bert คือ Adam ซึ่งต้องใช้หน่วยความจำพิเศษจำนวนมากในการจัดเก็บเวกเตอร์ m และ v การเปลี่ยนไปใช้เครื่องมือเพิ่มประสิทธิภาพที่มีประสิทธิภาพของหน่วยความจำมากขึ้นสามารถลดการใช้หน่วยความจำได้ แต่อาจส่งผลกระทบต่อผลลัพธ์ เรายังไม่ได้ทดลองกับ Optimizers อื่น ๆ สำหรับการปรับแต่ง
การใช้สคริปต์การฝึกอบรมเริ่มต้น ( run_classifier.py และ run_squad.py ) เราได้ทำการเปรียบเทียบขนาดแบทช์สูงสุดใน Titan X GPU (12GB RAM) ด้วย TensorFlow 1.11.0:
| ระบบ | ความยาว 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 รหัสจะขึ้นอยู่กับหนึ่ง (หรือทั้งสอง) ของเทคนิคต่อไปนี้:
การสะสมการไล่ระดับสี : ตัวอย่างใน minibatch มักจะเป็นอิสระในส่วนที่เกี่ยวกับการคำนวณการไล่ระดับสี (ไม่รวมการทำให้เป็นมาตรฐานแบทช์ซึ่งไม่ได้ใช้ที่นี่) ซึ่งหมายความว่าการไล่ระดับสีของ minibatches ขนาดเล็กหลายตัวสามารถสะสมได้ก่อนทำการอัปเดตน้ำหนักและสิ่งนี้จะเทียบเท่ากับการอัปเดตที่ใหญ่กว่าครั้งเดียว
จุดตรวจการไล่ระดับสี : การใช้งานที่สำคัญของหน่วยความจำ GPU/TPU ในระหว่างการฝึกอบรม DNN คือการแคชการเปิดใช้งานระดับกลางในบัตรผ่านไปข้างหน้าซึ่งจำเป็นสำหรับการคำนวณที่มีประสิทธิภาพในการผ่านไปข้างหลัง "จุดตรวจการไล่ระดับสี" แลกเปลี่ยนหน่วยความจำสำหรับการคำนวณเวลาโดยคำนวณการเปิดใช้งานอีกครั้งในวิธีที่ชาญฉลาด
อย่างไรก็ตามสิ่งนี้ไม่ได้ถูกนำไปใช้ในรุ่นปัจจุบัน
ในบางกรณีแทนที่จะปรับแต่งแบบจำลองก่อนการฝึกอบรมก่อนการฝึกอบรมทั้งหมดมันจะเป็นประโยชน์ต่อ การฝังบริบทที่ผ่านการฝึกอบรมมา ก่อน -โมเดลที่ได้รับการฝึกฝน สิ่งนี้ควรลดปัญหาส่วนใหญ่ของหน่วยความจำ
ตัวอย่างเช่นเรารวมสคริปต์ 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 สิ่งนี้จะสร้างไฟล์ JSON (หนึ่งบรรทัดต่อบรรทัดของอินพุต) ที่มีการเปิดใช้งาน BERT จากแต่ละเลเยอร์หม้อแปลงแต่ละชั้นที่ระบุโดย layers (-1 คือเลเยอร์ที่ซ่อนอยู่สุดท้ายของหม้อแปลง ฯลฯ )
โปรดทราบว่าสคริปต์นี้จะสร้างไฟล์เอาต์พุตที่มีขนาดใหญ่มาก (โดยค่าเริ่มต้นประมาณ 15KB สำหรับโทเค็นอินพุตทุกครั้ง)
หากคุณต้องการรักษาการจัดตำแหน่งระหว่างคำดั้งเดิมและคำที่มีโทเค็น (สำหรับฉลากการฝึกอบรม) ให้ดูส่วนโทเค็นด้านล่าง
หมายเหตุ: คุณอาจเห็นข้อความที่ Could not find trained model in model_dir: /tmp/tmpuB5g5c, running initialization to predict. ข้อความนี้คาดว่าจะหมายความว่าเรากำลังใช้ init_from_checkpoint() API มากกว่า API รุ่นที่บันทึกไว้ หากคุณไม่ได้ระบุจุดตรวจหรือระบุจุดตรวจสอบที่ไม่ถูกต้องสคริปต์นี้จะบ่น
สำหรับงานระดับประโยค (หรือคู่ประโยค) งานโทเค็นนั้นง่ายมาก เพียงทำตามรหัสตัวอย่างใน run_classifier.py และ extract_features.py ขั้นตอนพื้นฐานสำหรับงานระดับประโยคคือ:
อินสแตนซ์อินสแตนซ์ของ tokenizer = tokenization.FullTokenizer
tokenize ข้อความดิบด้วย tokens = tokenizer.tokenize(raw_text)
ตัดทอนความยาวลำดับสูงสุด (คุณสามารถใช้มากถึง 512 แต่คุณอาจต้องการใช้สั้นลงหากเป็นไปได้ด้วยเหตุผลหน่วยความจำและความเร็ว)
เพิ่มโทเค็น [CLS] และ [SEP] ในสถานที่ที่เหมาะสม
งานระดับคำและระดับขยาย (เช่นทีมและ ner) มีความซับซ้อนมากขึ้นเนื่องจากคุณจำเป็นต้องรักษาการจัดตำแหน่งระหว่างข้อความอินพุตและข้อความเอาต์พุตของคุณเพื่อให้คุณสามารถฉายฉลากการฝึกอบรมของคุณ ทีมเป็นตัวอย่างที่ซับซ้อนโดยเฉพาะอย่างยิ่งเนื่องจากฉลากอินพุตเป็น ตัวละคร และย่อหน้าของทีมมักจะยาวกว่าความยาวลำดับสูงสุดของเรา ดูรหัสใน run_squad.py เพื่อแสดงวิธีที่เราจัดการกับสิ่งนี้
ก่อนที่เราจะอธิบายสูตรทั่วไปสำหรับการจัดการงานระดับคำเป็นสิ่งสำคัญที่จะต้องเข้าใจว่าโทเค็นของเรากำลังทำอะไรอยู่ มีสามขั้นตอนหลัก:
การทำให้เป็นมาตรฐานของข้อความ : แปลงอักขระช่องว่างทั้งหมดเป็นช่องว่างและ (สำหรับรุ่น Uncased ) ช่วยลดอินพุตและตัดเครื่องหมายสำเนียงออก เช่น John Johanson's, → john johanson's,
การแยกเครื่องหมายวรรคตอน : แยกอักขระเครื่องหมายวรรคตอน ทั้งหมด ทั้งสองด้าน (เช่นเพิ่มช่องว่างรอบตัวอักษรเครื่องหมายวรรคตอนทั้งหมด) อักขระเครื่องหมายวรรคตอนถูกกำหนดเป็น (a) สิ่งใดก็ตามที่มีคลาส P* Unicode, (b) อักขระที่ไม่ใช่ตัวอักษร/หมายเลข/อวกาศ ASCII (เช่นอักขระเช่น $ ซึ่งไม่ใช่วรรคตอนทางเทคนิค) เช่น john johanson's, → john johanson ' s ,
คำพูดของ WordPiece : ใช้ whitespace tokenization กับผลลัพธ์ของขั้นตอนข้างต้นและใช้ tokenization คำพูดกับแต่ละโทเค็นแยกกัน (การใช้งานของเราขึ้นอยู่กับหนึ่งจาก 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 ไปยังการเป็นตัวแทนโทเค็น
มีแผนการโทเค็นภาษาอังกฤษทั่วไปซึ่งจะทำให้เกิดความไม่ตรงกันเล็กน้อยระหว่างวิธีการฝึกอบรมของเบิร์ตก่อน ตัวอย่างเช่นหากอินพุตโทเค็นของคุณแยกการหดตัวออกเช่น do n't สิ่งนี้จะทำให้เกิดความไม่ตรงกัน หากเป็นไปได้ที่จะทำเช่นนั้นคุณควรประมวลผลข้อมูลของคุณล่วงหน้าเพื่อแปลงสิ่งเหล่านี้กลับเป็นข้อความที่ดูดิบ แต่ถ้าเป็นไปไม่ได้ความไม่ตรงกันนี้น่าจะไม่ใช่เรื่องใหญ่
เรากำลังปล่อยรหัสให้ทำ "สวมหน้ากาก LM" และ "การทำนายประโยคถัดไป" ในคลังข้อความโดยพลการ โปรดทราบว่านี่ ไม่ใช่ รหัสที่แน่นอนที่ใช้สำหรับกระดาษ (รหัสต้นฉบับถูกเขียนใน C ++ และมีความซับซ้อนเพิ่มเติมบางอย่าง) แต่รหัสนี้จะสร้างข้อมูลการฝึกอบรมล่วงหน้าตามที่อธิบายไว้ในกระดาษ
นี่คือวิธีเรียกใช้การสร้างข้อมูล อินพุตเป็นไฟล์ข้อความธรรมดาโดยมีหนึ่งประโยคต่อบรรทัด (เป็นสิ่งสำคัญที่เหล่านี้เป็นประโยคจริงสำหรับงาน "การทำนายประโยคถัดไป") เอกสารถูกคั่นด้วยสายเปล่า เอาต์พุตเป็นชุดของ tf.train.Example s serialized เป็นรูปแบบไฟล์ TFRecord
คุณสามารถทำการแบ่งส่วนประโยคด้วยชุดเครื่องมือ NLP นอกชั้นวางเช่น Spacy สคริปต์ create_pretraining_data.py จะต่อกลุ่มส่วนจนกว่าพวกเขาจะถึงความยาวลำดับสูงสุดเพื่อลดขยะจากการคำนวณจากช่องว่าง (ดูสคริปต์สำหรับรายละเอียดเพิ่มเติม) อย่างไรก็ตามคุณอาจต้องการเพิ่มเสียงรบกวนเล็กน้อยให้กับข้อมูลอินพุตของคุณโดยเจตนา (เช่นการตัดทอน 2% ของกลุ่มอินพุต) แบบสุ่ม) เพื่อให้มีความแข็งแกร่งมากขึ้นต่ออินพุตที่ไม่ได้อยู่ในระหว่างการปรับแต่ง
สคริปต์นี้จัดเก็บตัวอย่างทั้งหมดสำหรับไฟล์อินพุตทั้งหมดในหน่วยความจำดังนั้นสำหรับไฟล์ข้อมูลขนาดใหญ่คุณควรให้แผ่นอินพุตและเรียกสคริปต์หลายครั้ง (คุณสามารถส่งผ่านไฟล์ glob ไปยัง run_pretraining.py , เช่น tf_examples.tf_record* .)
max_predictions_per_seq คือจำนวนสูงสุดของการทำนาย LM ที่หน้ากากต่อลำดับ คุณควรตั้งค่าสิ่งนี้เป็นรอบ 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 หากคุณฝึกอบรมล่วงหน้าตั้งแต่เริ่มต้น การกำหนดค่าโมเดล (รวมถึงขนาดคำศัพท์) ถูกระบุใน bert_config_file รหัสสาธิตนี้ก่อนรถไฟสำหรับขั้นตอนจำนวนน้อย (20) แต่ในทางปฏิบัติคุณอาจต้องการตั้ง num_train_steps เป็น 10,000 ขั้นตอนขึ้นไป พารามิเตอร์ max_seq_length และ max_predictions_per_seq ส่งผ่านไปยัง run_pretraining.py ต้องเหมือนกับ 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 ของเรามีขนาดเล็กมากการฝึกอบรมตัวอย่างนี้จะทำให้ข้อมูลนั้นมากเกินไปในไม่กี่ขั้นตอนและสร้างตัวเลขที่มีความแม่นยำสูงอย่างไม่สมจริง
vocab_size ใน bert_config.json หากคุณใช้คำศัพท์ที่ใหญ่ขึ้นโดยไม่ต้องเปลี่ยนสิ่งนี้คุณจะได้รับ NANS เมื่อฝึกอบรมเกี่ยวกับ GPU หรือ TPU เนื่องจากการเข้าถึงที่ไม่ถูกตรวจสอบmax_seq_lengthBERT-Base บนคลาวด์ TPU V2 ก่อนที่จะใช้เวลาประมาณ 2 สัปดาห์ในราคาประมาณ $ 500 USD (ขึ้นอยู่กับราคาในเดือนตุลาคม 2018) . คุณจะต้องลดขนาดแบทช์เมื่อฝึกอบรมเฉพาะบนคลาวด์ TPU เดียวเมื่อเทียบกับสิ่งที่ใช้ในกระดาษ ขอแนะนำให้ใช้ขนาดแบทช์ที่ใหญ่ที่สุดที่เหมาะกับหน่วยความจำ TPU เราจะ ไม่ สามารถปล่อยชุดข้อมูลที่ประมวลผลล่วงหน้าที่ใช้ในกระดาษ สำหรับ Wikipedia การประมวลผลล่วงหน้าที่แนะนำคือการดาวน์โหลดการถ่ายโอนข้อมูลล่าสุดแยกข้อความด้วย WikiExtractor.py จากนั้นใช้การทำความสะอาดที่จำเป็นเพื่อแปลงเป็นข้อความธรรมดา
น่าเสียดายที่นักวิจัยที่เก็บหนังสือ Bookcorpus ไม่สามารถดาวน์โหลดสาธารณะได้อีกต่อไป ชุดข้อมูล Project Guttenberg เป็นคอลเล็กชั่นหนังสือเก่าที่ค่อนข้างเล็กกว่า (200 ม.) ที่เป็นโดเมนสาธารณะ
การรวบรวมข้อมูลทั่วไปเป็นคอลเล็กชั่นข้อความที่มีขนาดใหญ่มาก แต่คุณอาจจะต้องทำการประมวลผลล่วงหน้าและการทำความสะอาดเพื่อแยกคลังข้อมูลที่ใช้งานได้สำหรับ Bert ก่อนการฝึกอบรม
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. ดูไฟล์ LICENSE สำหรับข้อมูลเพิ่มเติม
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] ).
