By เจมส์ บริกส์, นักวิทยาศาสตร์ข้อมูล

BERT แต่ในอิตาลี — ภาพโดยผู้เขียน

บทความของฉันหลายบทความมุ่งเน้นไปที่ BERT ซึ่งเป็นโมเดลที่มาและครอบงำโลกแห่งการประมวลผลภาษาธรรมชาติ (NLP) และถือเป็นยุคใหม่สำหรับโมเดลภาษา

สำหรับผู้ที่อาจไม่เคยใช้โมเดล Transformers มาก่อน (เช่น BERT คืออะไร) กระบวนการจะมีลักษณะดังนี้:

• pip install transformers
• เริ่มต้นโมเดลหม้อแปลงไฟฟ้าที่ได้รับการฝึกอบรมล่วงหน้า — from_pretrained.
• ทดสอบกับข้อมูลบางอย่าง
• บางที ปรับแต่งโมเดลอย่างละเอียด (ฝึกให้มากกว่านี้)

นี่เป็นแนวทางที่ดี แต่ถ้าเราทำเช่นนี้ เราก็ขาดความเข้าใจเบื้องหลังการสร้างแบบจำลองหม้อแปลงของเราเอง

และหากเราไม่สามารถสร้างโมเดลหม้อแปลงของเราเองได้ เราต้องพึ่งพาโมเดลที่ได้รับการฝึกอบรมล่วงหน้าที่เหมาะกับปัญหาของเรา ซึ่งไม่ได้เป็นเช่นนั้นเสมอไป:

ความคิดเห็นบางส่วนที่ถามเกี่ยวกับโมเดล BERT ที่ไม่ใช่ภาษาอังกฤษ

ดังนั้นในบทความนี้ เราจะสำรวจขั้นตอนที่เราต้องทำเพื่อสร้างโมเดลหม้อแปลงของเราเอง โดยเฉพาะ BERT เวอร์ชันที่พัฒนาเพิ่มเติมที่เรียกว่า RoBERTa

ภาพรวม

 
 
กระบวนการนี้มีอยู่ไม่กี่ขั้นตอน ดังนั้นก่อนที่เราจะเจาะลึก เรามาสรุปสิ่งที่เราต้องทำก่อน โดยรวมแล้วมีสี่ส่วนสำคัญ:

• การรับข้อมูล
• การสร้างโทเค็นไนเซอร์
• การสร้างไปป์ไลน์อินพุต
• ฝึกโมเดล

เมื่อเราผ่านแต่ละส่วนเหล่านี้แล้ว เราจะนำ tokenizer และโมเดลที่เราสร้างขึ้น — และบันทึกทั้งสองส่วนเพื่อให้เราสามารถใช้พวกมันในลักษณะเดียวกับที่เรามักจะทำ from_pretrained.

การรับข้อมูล

 
 
เช่นเดียวกับโปรเจ็กต์การเรียนรู้ของเครื่องอื่นๆ เราต้องการข้อมูล ในแง่ของข้อมูลสำหรับการฝึกโมเดลหม้อแปลง เรามีทางเลือกมากมาย — เราสามารถใช้ข้อมูลข้อความได้เกือบทุกชนิด

และหากมีสิ่งหนึ่งที่เรามีมากมายบนอินเทอร์เน็ต นั่นก็คือข้อมูลข้อความที่ไม่มีโครงสร้าง

ชุดข้อมูลที่ใหญ่ที่สุดชุดหนึ่งในโดเมนข้อความที่คัดลอกมาจากอินเทอร์เน็ตคือชุดข้อมูล OSCAR

ชุดข้อมูล OSCAR มีภาษาต่างๆ มากมาย และกรณีการใช้งานที่ชัดเจนที่สุดประการหนึ่งสำหรับการฝึกอบรมตั้งแต่เริ่มต้นก็คือ เพื่อให้เราสามารถนำ BERT ไปใช้กับภาษาที่ใช้ไม่บ่อยบางภาษา เช่น ภาษาเตลูกูหรือนาวาโฮ

น่าเสียดายที่ภาษาเดียวที่ฉันสามารถพูดได้ทุกระดับความสามารถคือภาษาอังกฤษ - แต่แฟนของฉันเป็นภาษาอิตาลี ดังนั้นเธอ - ลอร่าจะประเมินผลลัพธ์ของโมเดล BERT ที่พูดภาษาอิตาลีของเรา - FiliBERTo

ดังนั้น ในการดาวน์โหลดเซ็กเมนต์ภาษาอิตาลีของชุดข้อมูล OSCAR เราจะใช้ HuggingFace's datasets ไลบรารี — ซึ่งเราสามารถติดตั้งได้ pip install datasets. จากนั้นเราจะดาวน์โหลด OSCAR_IT ด้วย:

ลองมาดูที่ dataset วัตถุ.

เยี่ยมเลย ตอนนี้เรามาจัดเก็บข้อมูลของเราในรูปแบบที่เราสามารถใช้ในการสร้างโทเค็นของเรากันดีกว่า เราจำเป็นต้องสร้างชุดของไฟล์ข้อความธรรมดาที่มีเพียงไฟล์ text คุณลักษณะจากชุดข้อมูลของเรา และเราจะแยกแต่ละส่วน ตัวอย่าง ใช้ขึ้นบรรทัดใหม่ n.

ของเราไปแล้ว data/text/oscar_it ไดเรกทอรีเราจะพบ:

ไดเร็กทอรีที่มีไฟล์ OSCAR แบบข้อความธรรมดาของเรา

การสร้างโทเค็นไนเซอร์

 
 
ต่อไปคือโทเค็นไนเซอร์! เมื่อใช้หม้อแปลง โดยทั่วไปเราจะโหลดโทเค็นไนเซอร์ควบคู่ไปกับโมเดลหม้อแปลงที่เกี่ยวข้อง — โทเค็นเป็นองค์ประกอบสำคัญในกระบวนการนี้

เมื่อสร้างโทเค็นของเรา เราจะป้อนข้อมูล OSCAR ทั้งหมดของเรา ระบุขนาดคำศัพท์ของเรา (จำนวนโทเค็นในโทเค็น) และโทเค็นพิเศษใดๆ

ตอนนี้โทเค็นพิเศษของ RoBERTa มีลักษณะดังนี้:

ดังนั้นเราจึงต้องแน่ใจว่าได้รวมไว้ภายใน special_tokens พารามิเตอร์ของ tokenizer ของเรา train การเรียกวิธีการ

tokenizer ของเราพร้อมแล้ว และเราสามารถบันทึกไฟล์เพื่อใช้ในภายหลังได้:

ตอนนี้เรามีไฟล์สองไฟล์ที่กำหนดไฟล์ใหม่ของเรา ฟิลิเบอร์ทู โทเค็นไนเซอร์:

• ผสาน.txt — ทำการแมปข้อความเริ่มต้นกับโทเค็น
• คำศัพท์.json — จับคู่โทเค็นกับรหัสโทเค็น

และด้วยสิ่งเหล่านั้น เราสามารถก้าวไปสู่การเริ่มต้นโทเค็นไนเซอร์ของเรา เพื่อที่เราจะได้ใช้มันได้เหมือนกับที่เราใช้อย่างอื่น from_pretrained โทเค็นเซอร์

กำลังเริ่มต้น Tokenizer

 
 
ก่อนอื่นเราจะเริ่มต้นโทเค็นไนเซอร์โดยใช้ไฟล์สองไฟล์ที่เราสร้างขึ้นก่อนหน้านี้ — โดยใช้ไฟล์ง่ายๆ from_pretrained:

ตอนนี้ tokenizer ของเราพร้อมแล้ว เราสามารถลองเข้ารหัสข้อความด้วย Tokenizer ได้ เมื่อเข้ารหัสเราใช้สองวิธีเดียวกันกับที่เรามักจะใช้ encode และ  encode_batch.

จากวัตถุการเข้ารหัส tokens เราจะทำการสกัด input_ids และ  attention_mask เทนเซอร์สำหรับใช้กับ FiliBERTo

การสร้างไปป์ไลน์อินพุต

 
 
กระบวนการป้อนข้อมูลของกระบวนการฝึกอบรมของเราเป็นส่วนที่ซับซ้อนมากขึ้นของกระบวนการทั้งหมด ประกอบด้วยเรานำข้อมูลการฝึกอบรม OSCAR ดิบของเรา แปลงข้อมูล และโหลดลงในไฟล์ DataLoader พร้อมสำหรับการฝึกอบรม

การเตรียมข้อมูล

 
 
เราจะเริ่มต้นด้วยตัวอย่างเดียวและดำเนินการตามตรรกะการเตรียมการ

ขั้นแรก เราต้องเปิดไฟล์ของเรา ซึ่งเป็นไฟล์เดียวกับที่เราบันทึกเป็น txt. ไฟล์ก่อนหน้านี้ เราแยกแต่ละรายการตามอักขระขึ้นบรรทัดใหม่ n เนื่องจากสิ่งนี้บ่งบอกถึงตัวอย่างแต่ละรายการ

จากนั้นเราเข้ารหัสข้อมูลของเราโดยใช้ tokenizer — ตรวจสอบให้แน่ใจว่าได้รวมพารามิเตอร์หลักเช่น max_length, paddingและ truncation.

และตอนนี้เราสามารถก้าวไปสู่การสร้างเทนเซอร์ของเราได้แล้ว เราจะฝึกโมเดลของเราผ่านการสร้างแบบจำลองภาษาที่สวมหน้ากาก (MLM) ดังนั้นเราจึงต้องมีเทนเซอร์สามตัว:

• input_ids - ของเรา token_ids โดยมีโทเค็นประมาณ 15% ที่ถูกปกปิดโดยใช้โทเค็นมาส์ก <mask>.
• Attention_mask — เทนเซอร์ของ 1และ 0s ทำเครื่องหมายตำแหน่งของโทเค็น 'ของจริง'/โทเค็นการเสริม - ใช้ในการคำนวณความสนใจ
• ฉลาก - ของเรา token_ids กับ ไม่ กำบัง

หากคุณไม่คุ้นเคยกับ MLM ฉันได้อธิบายไปแล้ว  โปรดคลิกที่นี่เพื่ออ่านรายละเอียดเพิ่มเติม.

Our attention_mask และ  labels เทนเซอร์ก็ถูกดึงออกมาจากของเรา batch.  input_ids เทนเซอร์ต้องการความสนใจมากขึ้น อย่างไรก็ตาม สำหรับเทนเซอร์นี้ เราปกปิดโทเค็นประมาณ 15% โดยกำหนดรหัสโทเค็นให้กับพวกเขา 3.

ในผลลัพธ์สุดท้าย เราจะเห็นส่วนหนึ่งของการเข้ารหัส input_ids เทนเซอร์ รหัสโทเค็นแรกสุดคือ 1 - The [CLS] โทเค็น มีอยู่หลายจุดรอบๆ เทนเซอร์ 3 รหัสโทเค็น — นี่คือสิ่งที่เราเพิ่มเข้ามาใหม่ [MASK] ราชสกุล

การสร้าง DataLoader

 
 
ต่อไปเราจะกำหนดของเรา Dataset คลาส - ซึ่งเราใช้เริ่มต้นเทนเซอร์ที่เข้ารหัสทั้งสามของเราเป็น PyTorch torch.utils.data.Dataset วัตถุ

ในที่สุด .ของเรา dataset ถูกโหลดลงใน PyTorch DataLoader object — ซึ่งเราใช้โหลดข้อมูลลงในโมเดลของเราระหว่างการฝึก

การฝึกโมเดล

 
 
เราต้องการสองสิ่งในการฝึกอบรม ของเรา DataLoader และแบบจำลอง ที่ DataLoader เรามี แต่ไม่มีรุ่น

การเริ่มต้นโมเดล

 
 
สำหรับการฝึกอบรม เราต้องการวัตถุดิบ (ไม่ใช่การฝึกอบรมล่วงหน้า) BERTLMHeadModel. ในการสร้างสิ่งนั้น ก่อนอื่นเราต้องสร้างออบเจ็กต์การตั้งค่า RoBERTa เพื่ออธิบายพารามิเตอร์ที่เราต้องการเริ่มต้น FiliBERTo ด้วย

จากนั้น เรานำเข้าและเริ่มต้นโมเดล RoBERTa ของเราด้วยส่วนหัวของ Language Modeling (LM)

การเตรียมการฝึกอบรม

 
 
ก่อนที่จะเข้าสู่วงจรการฝึกซ้อมของเรา เราจำเป็นต้องจัดเตรียมบางสิ่งก่อน ขั้นแรก เราตั้งค่าการใช้งาน GPU/CPU จากนั้นเราจะเปิดใช้งานโหมดการฝึกอบรมของโมเดลของเรา และสุดท้ายก็เริ่มต้นเครื่องมือเพิ่มประสิทธิภาพของเรา

การฝึกอบรม

 
 
ในที่สุด — ได้เวลาฝึกซ้อม! เราฝึกเหมือนปกติเมื่อฝึกผ่าน PyTorch

หากเราไปที่ Tensorboard เราจะพบกับความสูญเสียเมื่อเวลาผ่านไป ซึ่งดูมีแนวโน้มดี

การสูญเสีย / เวลา — เซสชันการฝึกอบรมหลายเซสชันถูกรวมเข้าด้วยกันในแผนภูมินี้

การทดสอบจริง

 
 
ตอนนี้ก็ถึงเวลาสำหรับการทดสอบจริง เราตั้งค่าไปป์ไลน์ MLM และขอให้ลอร่าประเมินผลลัพธ์ คุณสามารถรับชมวิดีโอรีวิวเวลา 22:44 น. ได้ที่นี่:

ก่อนอื่นเราเริ่มต้น a pipeline วัตถุโดยใช้ 'fill-mask' การโต้แย้ง. จากนั้นเริ่มทดสอบโมเดลของเราดังนี้:

“เซียว อย่างไร เหรอ?” คือคำตอบที่ถูกต้อง! นั่นก็ล้ำหน้าพอๆ กับภาษาอิตาลีของฉันเลย ดังนั้น ส่งต่อให้ลอร่าดีกว่า

เราเริ่มต้นด้วย “บองจิออร์โน มาแล้วเหรอ?” - หรือ “อรุณสวัสดิ์ คุณเป็นยังไงบ้าง”:

คำตอบแรก “buongiorno, chi va?” แปลว่า “วันดี มีใครอยู่บ้าง” — เช่น ไร้สาระ แต่คำตอบที่สองของเรานั้นถูกต้อง!

ต่อไปเป็นวลีที่ยากขึ้นเล็กน้อย “ciao, dove ci incontriamo oggi pomeriggio?” - หรือ “สวัสดีบ่ายนี้เราจะไปเจอกันที่ไหน”:

และเราจะให้ผลลัพธ์ที่เป็นบวกมากขึ้น:

✅ "hi, where do we see each other this afternoon?"
✅ "hi, where do we meet this afternoon?"
❌ "hi, where here we are this afternoon?"
✅ "hi, where are we meeting this afternoon?"
✅ "hi, where do we meet this afternoon?"

สุดท้ายนี้ มีประโยคที่ยากขึ้นอีกประโยคหนึ่ง “cosa sarebbe succio se avessimo scelto un altro giorno?” — หรือ “จะเกิดอะไรขึ้นถ้าเราเลือกวันอื่น?”:

เราคืนคำตอบที่ดีอีกสองสามข้อที่นี่ด้วย:

✅ "what would have happened if we had chosen another day?"
✅ "what would have happened if I had chosen another day?"
✅ "what would have happened if they had chosen another day?"
✅ "what would have happened if you had chosen another day?"
❌ "what would have happened if another day was chosen?"

โดยรวมแล้ว ดูเหมือนว่าโมเดลของเราผ่านการทดสอบของลอร่า และตอนนี้เรามีโมเดลภาษาอิตาลีที่มีความสามารถที่เรียกว่า FiliBERTo!

เพียงเท่านี้สำหรับคำแนะนำการฝึกอบรมโมเดล BERT ตั้งแต่เริ่มต้น!

เราได้ครอบคลุมประเด็นต่างๆ มากมาย ตั้งแต่การรับและการจัดรูปแบบข้อมูลของเรา ไปจนถึงการใช้การสร้างแบบจำลองภาษาเพื่อฝึกฝนโมเดล BERT แบบ Raw ของเรา

ฉันหวังว่าคุณจะสนุกกับบทความนี้! หากคุณมีคำถามใดๆ โปรดแจ้งให้เราทราบผ่านทาง Twitter หรือในความคิดเห็นด้านล่าง หากคุณต้องการเนื้อหาเพิ่มเติมเช่นนี้ ฉันโพสต์ไว้ YouTube เกินไป

ขอขอบคุณสำหรับการอ่าน!

ลด 70%! การประมวลผลภาษาธรรมชาติ: NLP พร้อม Transformers ใน Python

โมเดลหม้อแปลงไฟฟ้าเป็นมาตรฐานโดยพฤตินัยใน NLP สมัยใหม่ พวกเขาได้พิสูจน์ตัวเองแล้วว่าเป็นคนที่แสดงออกมากที่สุด...
 

*ภาพทั้งหมดเป็นของผู้เขียน เว้นแต่จะระบุไว้เป็นอย่างอื่น

 
Bio: เจมส์ บริกส์ เป็นนักวิทยาศาสตร์ข้อมูลที่เชี่ยวชาญด้านการประมวลผลภาษาธรรมชาติและทำงานในภาคการเงินในลอนดอน สหราชอาณาจักร เขายังเป็นที่ปรึกษาอิสระ นักเขียน และผู้สร้างเนื้อหาอีกด้วย คุณสามารถติดต่อผู้เขียนได้ทางอีเมล (jamesscalam94@gmail.com).

Original. โพสต์ใหม่โดยได้รับอนุญาต

ที่เกี่ยวข้อง

• วิธีการใช้ Transformers กับความยาวของข้อความ
• ทำความเข้าใจ BERT กับ Hugging Face
• การสร้างแบบจำลองหัวข้อด้วย BERT