คู่มือการเริ่มต้นใช้งานเครื่องมือ Hugging Face LLM ฉบับสมบูรณ์

Hugging Face เป็นห้องปฏิบัติการวิจัยและศูนย์กลาง AI ที่สร้างชุมชนนักวิชาการ นักวิจัย และผู้สนใจ ในช่วงเวลาสั้น ๆ Hugging Face ได้ปรากฏตัวอย่างมากมายในพื้นที่ AI เทคยักษ์ใหญ่ รวมถึง Google, Amazon และ Nvidia ได้สนับสนุนสตาร์ทอัพด้าน AI อย่าง Hugging Face ด้วยการลงทุนจำนวนมาก และทำการประเมินมูลค่า $ 4.5 พันล้าน.

ในคู่มือนี้ เราจะแนะนำ Transformer, LLM และวิธีที่ไลบรารี Hugging Face มีบทบาทสำคัญในการส่งเสริมชุมชน AI แบบโอเพ่นซอร์ส นอกจากนี้เรายังจะอธิบายคุณสมบัติที่สำคัญของ Hugging Face รวมถึงไปป์ไลน์ ชุดข้อมูล โมเดล และอื่นๆ อีกมากมาย พร้อมตัวอย่าง Python ที่ใช้งานจริง

หม้อแปลงไฟฟ้าใน NLP

ในปี 2017 มหาวิทยาลัย Cornell ได้ตีพิมพ์รายงานที่ทรงอิทธิพลซึ่งแนะนำ หม้อแปลง. เหล่านี้เป็นโมเดลการเรียนรู้เชิงลึกที่ใช้ใน NLP การค้นพบนี้กระตุ้นให้เกิดการพัฒนาแบบจำลองภาษาขนาดใหญ่เช่น ChatGPT.

โมเดลภาษาขนาดใหญ่หรือ LLM คือระบบ AI ที่ใช้หม้อแปลงเพื่อทำความเข้าใจและสร้างข้อความที่เหมือนมนุษย์ อย่างไรก็ตาม การสร้างโมเดลเหล่านี้มีราคาแพง ซึ่งมักจะต้องใช้เงินหลายล้านดอลลาร์ ซึ่งจำกัดการเข้าถึงของโมเดลเหล่านี้ให้กับบริษัทขนาดใหญ่

กอดหน้าซึ่งเริ่มต้นในปี 2016 โดยมีเป้าหมายเพื่อให้ทุกคนเข้าถึงโมเดล NLP ได้ แม้จะเป็นบริษัทเชิงพาณิชย์ แต่ก็มีทรัพยากรโอเพ่นซอร์สมากมายที่ช่วยให้ผู้คนและองค์กรสามารถสร้างและใช้โมเดลหม้อแปลงได้ในราคาประหยัด การเรียนรู้ของเครื่องเป็นเรื่องเกี่ยวกับการสอนคอมพิวเตอร์ให้ทำงานโดยการจดจำรูปแบบ ในขณะที่การเรียนรู้เชิงลึกซึ่งเป็นชุดย่อยของการเรียนรู้ของเครื่องจะสร้างเครือข่ายที่เรียนรู้อย่างเป็นอิสระ หม้อแปลงไฟฟ้าเป็นสถาปัตยกรรมการเรียนรู้เชิงลึกประเภทหนึ่งที่ใช้ข้อมูลอินพุตได้อย่างมีประสิทธิภาพและยืดหยุ่น ทำให้เป็นตัวเลือกยอดนิยมสำหรับการสร้างแบบจำลองภาษาขนาดใหญ่เนื่องจากใช้เวลาฝึกอบรมน้อยกว่า

การกอดใบหน้าช่วยอำนวยความสะดวกให้กับโครงการ NLP และ LLM ได้อย่างไร

Hugging Face ทำให้การทำงานกับ LLM ง่ายขึ้นโดยนำเสนอ:

1. มีโมเดลที่ผ่านการฝึกอบรมมาแล้วให้เลือกมากมาย
2. เครื่องมือและตัวอย่างเพื่อปรับแต่งโมเดลเหล่านี้ให้ตรงตามความต้องการเฉพาะของคุณ
3. ตัวเลือกการปรับใช้ที่ง่ายดายสำหรับสภาพแวดล้อมต่างๆ

แหล่งข้อมูลที่ยอดเยี่ยมที่มีให้ผ่าน Hugging Face คือ เปิดลีดเดอร์บอร์ด LLM. ทำหน้าที่เป็นแพลตฟอร์มที่ครอบคลุม โดยจะตรวจสอบ จัดอันดับ และประเมินประสิทธิภาพของสเปกตรัมของโมเดลภาษาขนาดใหญ่ (LLM) และแชทบอทอย่างเป็นระบบ โดยให้การวิเคราะห์ที่ชาญฉลาดเกี่ยวกับความก้าวหน้าในโดเมนโอเพ่นซอร์ส

เกณฑ์มาตรฐาน LLM วัดแบบจำลองผ่านตัวชี้วัดสี่ตัว:

• ความท้าทายในการใช้เหตุผล AI2 (25 นัด) — ชุดคำถามเกี่ยวกับหลักสูตรวิทยาศาสตร์ระดับประถมศึกษา
• เฮลลาสแวก (10 ช็อต) — การทดสอบอนุมานสามัญสำนึกว่า แม้ว่าการวัดนี้จะง่ายสำหรับมนุษย์ แต่การวัดนี้ถือเป็นความท้าทายที่สำคัญสำหรับโมเดลที่ล้ำสมัย
• มมส (5-shot) — การประเมินหลายแง่มุมโดยพิจารณาจากความเชี่ยวชาญของโมเดลข้อความใน 57 โดเมนที่หลากหลาย ครอบคลุมคณิตศาสตร์พื้นฐาน กฎหมาย และวิทยาศาสตร์คอมพิวเตอร์ และอื่นๆ อีกมากมาย
• ความจริงQA (0-shot) — เครื่องมือในการตรวจสอบแนวโน้มของแบบจำลองในการสะท้อนข้อมูลที่ผิดทางออนไลน์ที่พบบ่อย

เกณฑ์มาตรฐานซึ่งอธิบายโดยใช้คำศัพท์เช่น "25-shot", "10-shot", "5-shot" และ "0-shot" ระบุจำนวนตัวอย่างทันทีที่แบบจำลองได้รับในระหว่างกระบวนการประเมินผล เพื่อวัดประสิทธิภาพและความสามารถในการใช้เหตุผลในโดเมนต่างๆ ในกระบวนทัศน์ "ไม่กี่ช็อต" แบบจำลองจะได้รับตัวอย่างจำนวนเล็กน้อยเพื่อช่วยชี้แนะการตอบสนอง ในขณะที่การตั้งค่า "0 ช็อต" แบบจำลองจะไม่ได้รับตัวอย่างและต้องอาศัยความรู้ที่มีอยู่แล้วเพียงอย่างเดียวในการตอบสนองอย่างเหมาะสม .

ส่วนประกอบของใบหน้ากอด

ท่อ

'ท่อ' เป็นส่วนหนึ่งของไลบรารีหม้อแปลงของ Hugging Face ซึ่งเป็นฟีเจอร์ที่ช่วยในการใช้งานโมเดลที่ผ่านการฝึกอบรมล่วงหน้าที่มีอยู่ในพื้นที่เก็บข้อมูล Hugging Face ได้อย่างง่ายดาย โดยมี API ที่ใช้งานง่ายสำหรับงานต่างๆ มากมาย รวมถึงการวิเคราะห์ความรู้สึก การตอบคำถาม การสร้างแบบจำลองภาษาที่ปกปิด การจดจำเอนทิตีที่มีชื่อ และการสรุป

ไปป์ไลน์รวมองค์ประกอบ Hugging Face ส่วนกลางสามส่วน:

1. tokenizer: เตรียมข้อความของคุณสำหรับโมเดลโดยแปลงเป็นรูปแบบที่โมเดลสามารถเข้าใจได้
2. รุ่น: นี่คือหัวใจสำคัญของไปป์ไลน์ซึ่งมีการคาดการณ์จริงตามอินพุตที่ประมวลผลไว้ล่วงหน้า
3. โพสต์โปรเซสเซอร์: แปลงการคาดการณ์ดิบของโมเดลให้อยู่ในรูปแบบที่มนุษย์สามารถอ่านได้

ไปป์ไลน์เหล่านี้ไม่เพียงแต่ลดการเขียนโค้ดที่กว้างขวางเท่านั้น แต่ยังนำเสนออินเทอร์เฟซที่ใช้งานง่ายเพื่อทำงาน NLP ต่างๆ ให้สำเร็จอีกด้วย

แอปพลิเคชัน Transformer โดยใช้ไลบรารี Hugging Face

จุดเด่นของไลบรารี Hugging Face คือไลบรารี Transformers ซึ่งช่วยให้งาน NLP ง่ายขึ้นโดยการเชื่อมต่อแบบจำลองกับขั้นตอนก่อนและหลังการประมวลผลที่จำเป็น ซึ่งทำให้กระบวนการวิเคราะห์มีความคล่องตัว ในการติดตั้งและนำเข้าไลบรารี ให้ใช้คำสั่งต่อไปนี้:

pip install -q transformers
from transformers import pipeline

เมื่อทำเช่นนั้น คุณสามารถดำเนินงาน NLP โดยเริ่มจากการวิเคราะห์ความรู้สึก ซึ่งจะจัดหมวดหมู่ข้อความออกเป็นความรู้สึกเชิงบวกหรือเชิงลบ ฟังก์ชันไปป์ไลน์ () อันทรงพลังของไลบรารีทำหน้าที่เป็นฮับที่รวมไปป์ไลน์อื่น ๆ และอำนวยความสะดวกให้กับแอปพลิเคชันเฉพาะงานในโดเมนเสียง การมองเห็น และหลายรูปแบบ

การใช้งานจริง

การจัดประเภทข้อความ

การจัดหมวดหมู่ข้อความกลายเป็นเรื่องง่ายด้วยฟังก์ชันไปป์ไลน์ () ของ Hugging Face ต่อไปนี้คือวิธีที่คุณสามารถเริ่มต้นไปป์ไลน์การจัดหมวดหมู่ข้อความ:

classifier = pipeline("text-classification")

หากต้องการสัมผัสประสบการณ์จริง ให้ป้อนสตริงหรือรายการสตริงลงในไปป์ไลน์ของคุณเพื่อรับการคาดการณ์ ซึ่งสามารถมองเห็นได้อย่างสวยงามโดยใช้ไลบรารี Pandas ของ Python ด้านล่างนี้เป็นตัวอย่าง Python ที่สาธิตสิ่งนี้:

sentences = ["I am thrilled to introduce you to the wonderful world of AI.",
"Hopefully, it won't disappoint you."]
# Get classification results for each sentence in the list
results = classifier(sentences)
# Loop through each result and print the label and score
for i, result in enumerate(results):
print(f"Result {i + 1}:")
print(f" Label: {result['label']}")
print(f" Score: {round(result['score'], 3)}\n")

เอาท์พุต

Result 1: 
Label: POSITIVE 
Score: 1.0 
Result 2: 
Label: POSITIVE 
Score: 0.996 

การรับรู้ชื่อนิติบุคคล (NER)

NER มีบทบาทสำคัญในการแยกวัตถุในโลกแห่งความเป็นจริงที่เรียกว่า 'เอนทิตีที่มีชื่อ' ออกจากข้อความ ใช้ไปป์ไลน์ NER เพื่อระบุเอนทิตีเหล่านี้อย่างมีประสิทธิภาพ:

ner_tagger = pipeline("ner", aggregation_strategy="simple")
text = "Elon Musk is the CEO of SpaceX."
outputs = ner_tagger(text)
print(outputs)

เอาท์พุต

 Elon Musk: PER, SpaceX: ORG 

ตอบคำถาม

การตอบคำถามเกี่ยวข้องกับการแยกคำตอบที่แม่นยำสำหรับคำถามเฉพาะจากบริบทที่กำหนด เริ่มต้นไปป์ไลน์การตอบคำถามและป้อนคำถามและบริบทของคุณเพื่อรับคำตอบที่ต้องการ:

reader = pipeline("question-answering")
text = "Hugging Face is a company creating tools for NLP. It is based in New York and was founded in 2016."
question = "Where is Hugging Face based?"
outputs = reader(question=question, context=text)
print(outputs)

เอาท์พุต

 {'score': 0.998, 'start': 51, 'end': 60, 'answer': 'New York'} 

ฟังก์ชันไปป์ไลน์ของ Hugging Face นำเสนอไปป์ไลน์ที่สร้างไว้ล่วงหน้ามากมายสำหรับงานที่แตกต่างกัน นอกเหนือจากการจัดประเภทข้อความ NER และการตอบคำถาม ด้านล่างนี้คือรายละเอียดเกี่ยวกับชุดย่อยของงานที่มีอยู่:

ตาราง: งานไปป์ไลน์การกอดใบหน้า

สำหรับคำอธิบายโดยละเอียดและงานเพิ่มเติม โปรดดูที่ เอกสารไปป์ไลน์บนเว็บไซต์ของ Hugging Face.

เหตุใด Hugging Face จึงเปลี่ยนความสนใจไปที่ Rust

การกอดใบหน้า Safetensors และ tokenizer GitHub Page

ระบบนิเวศ Hugging Face (HF) เริ่มใช้ Rust ในไลบรารี เช่น ตู้เซฟและโทเค็นไนเซอร์

Hugging Face เพิ่งเปิดตัวเฟรมเวิร์กแมชชีนเลิร์นนิงใหม่ที่เรียกว่า เทียน. ไม่เหมือนกับเฟรมเวิร์กแบบดั้งเดิมที่ใช้ Python ตรงที่ Candle ถูกสร้างด้วย Rust เป้าหมายเบื้องหลังการใช้ Rust คือการเพิ่มประสิทธิภาพและลดความซับซ้อนของประสบการณ์ผู้ใช้ในขณะที่รองรับการทำงานของ GPU

วัตถุประสงค์หลักของ Candle คือการอำนวยความสะดวกในการอนุมานแบบไร้เซิร์ฟเวอร์ ทำให้การปรับใช้ไบนารีน้ำหนักเบาเป็นไปได้ และลบ Python ออกจากปริมาณงานที่ใช้งานจริง ซึ่งบางครั้งอาจทำให้กระบวนการช้าลงเนื่องจากโอเวอร์เฮด เฟรมเวิร์กนี้มาเป็นโซลูชันในการเอาชนะปัญหาที่พบกับเฟรมเวิร์กแมชชีนเลิร์นนิงเต็มรูปแบบ เช่น PyTorch ที่มีขนาดใหญ่และช้าเมื่อสร้างอินสแตนซ์บนคลัสเตอร์

เรามาสำรวจว่าทำไม Rust ถึงกลายเป็นตัวเลือกที่ได้รับความนิยมมากกว่า Python มาก

1. ความเร็วและประสิทธิภาพ – Rust ขึ้นชื่อเรื่องความเร็วอันน่าทึ่ง ซึ่งเหนือกว่า Python ซึ่งแต่เดิมใช้ในเฟรมเวิร์กการเรียนรู้ของเครื่อง บางครั้งประสิทธิภาพของ Python อาจช้าลงเนื่องจาก Global Interpreter Lock (GIL) แต่ Rust ไม่ประสบปัญหานี้ โดยสัญญาว่าจะดำเนินงานได้เร็วขึ้น และต่อมาจะปรับปรุงประสิทธิภาพในโปรเจ็กต์ที่มีการใช้งาน
2. ความปลอดภัย – Rust ให้การรับประกันความปลอดภัยของหน่วยความจำโดยไม่ต้องใช้ตัวรวบรวมขยะ ซึ่งเป็นส่วนสำคัญในการรับรองความปลอดภัยของระบบที่ทำงานพร้อมกัน สิ่งนี้มีบทบาทสำคัญในด้านต่างๆ เช่น ตัวป้องกัน ซึ่งความปลอดภัยในการจัดการโครงสร้างข้อมูลเป็นสิ่งสำคัญอันดับแรก

เซฟเทนเซอร์

เซฟเทนเซอร์ ได้รับประโยชน์จากคุณสมบัติความเร็วและความปลอดภัยของ Rust Safetensors เกี่ยวข้องกับการยักยอกเทนเซอร์ ซึ่งเป็นเอนทิตีทางคณิตศาสตร์ที่ซับซ้อน และการที่มี Rust ช่วยให้มั่นใจได้ว่าการดำเนินการไม่เพียงแต่รวดเร็วเท่านั้น แต่ยังปลอดภัยอีกด้วย หลีกเลี่ยงข้อบกพร่องทั่วไปและปัญหาด้านความปลอดภัยที่อาจเกิดขึ้นจากการจัดการหน่วยความจำที่ไม่ถูกต้อง

tokenizer

โทเค็น จัดการการแบ่งประโยคหรือวลีออกเป็นหน่วยเล็กๆ เช่น คำหรือคำศัพท์ Rust ช่วยในกระบวนการนี้โดยการเร่งเวลาดำเนินการ ทำให้มั่นใจได้ว่ากระบวนการโทเค็นไม่เพียงแต่แม่นยำ แต่ยังรวดเร็วอีกด้วย ช่วยเพิ่มประสิทธิภาพของงานประมวลผลภาษาธรรมชาติ

หัวใจสำคัญของโทเค็นไนเซอร์ของ Hugging Face คือแนวคิดของโทเค็นย่อย ซึ่งสร้างความสมดุลที่ละเอียดอ่อนระหว่างโทเค็นระดับคำและอักขระ เพื่อเพิ่มประสิทธิภาพการเก็บข้อมูลและขนาดคำศัพท์ มันทำงานผ่านการสร้างโทเค็นย่อย เช่น “##ing” และ “##ed” โดยยังคงรักษาความหมายที่สมบูรณ์ในขณะที่หลีกเลี่ยงคำศัพท์ที่มากเกินไป

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

ส่วนประกอบโทเค็น

https://huggingface.co/learn/nlp-course/chapter6/4

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

• นอร์มัลไลเซอร์: ทำการแปลงเริ่มต้นกับสตริงอินพุต โดยใช้การปรับเปลี่ยนที่จำเป็น เช่น การแปลงตัวพิมพ์เล็ก การทำให้เป็นมาตรฐาน Unicode และการแยกส่วน
• พรีโทเคนไนเซอร์: รับผิดชอบในการแบ่งส่วนสตริงอินพุตออกเป็นส่วนล่วงหน้า โดยกำหนดการแยกตามกฎที่กำหนดไว้ล่วงหน้า เช่น การแบ่งเขต
• รุ่น: ดูแลการค้นพบและการสร้างโทเค็นย่อย ปรับให้เข้ากับข้อมูลอินพุตเฉพาะของคุณและนำเสนอความสามารถในการฝึกอบรม
• โพสต์โปรเซสเซอร์: ปรับปรุงคุณสมบัติการก่อสร้างเพื่อรองรับความเข้ากันได้กับโมเดลที่ใช้หม้อแปลงหลายรุ่น เช่น BERT โดยการเพิ่มโทเค็น เช่น [CLS] และ [SEP]

ในการเริ่มต้นใช้งานโทเค็น Hugging Face ให้ติดตั้งไลบรารีโดยใช้คำสั่ง pip install tokenizers และนำเข้าสู่สภาพแวดล้อม Python ของคุณ ไลบรารีสามารถสร้างโทเค็นข้อความจำนวนมากได้ในเวลาอันสั้น จึงช่วยประหยัดทรัพยากรการคำนวณอันมีค่าสำหรับงานที่เข้มข้นมากขึ้น เช่น การฝึกโมเดล

ไลบรารีโทเค็นใช้ สนิม ซึ่งสืบทอดความคล้ายคลึงทางวากยสัมพันธ์ของ C++ ในขณะเดียวกันก็นำเสนอแนวคิดใหม่ในการออกแบบภาษาการเขียนโปรแกรม เมื่อใช้ร่วมกับการเชื่อมโยง Python จะทำให้คุณเพลิดเพลินกับประสิทธิภาพของภาษาระดับล่างขณะทำงานในสภาพแวดล้อม Python

ชุดข้อมูล

ชุดข้อมูลการกอดใบหน้าs

ชุดข้อมูลเป็นรากฐานของโครงการ AI Hugging Face นำเสนอชุดข้อมูลที่หลากหลาย เหมาะสำหรับงาน NLP ที่หลากหลาย และอื่นๆ อีกมากมาย เพื่อใช้งานอย่างมีประสิทธิภาพ การทำความเข้าใจกระบวนการโหลดและวิเคราะห์เป็นสิ่งสำคัญ ด้านล่างนี้เป็นสคริปต์ Python ที่ได้รับการวิจารณ์อย่างดีซึ่งสาธิตวิธีการสำรวจชุดข้อมูลที่มีอยู่ใน Hugging Face:

from datasets import load_dataset
# Load a dataset
dataset = load_dataset('squad')
# Display the first entry
print(dataset[0])

สคริปต์นี้ใช้ฟังก์ชัน load_dataset เพื่อโหลดชุดข้อมูล SQuAD ซึ่งเป็นตัวเลือกยอดนิยมสำหรับงานตอบคำถาม

ใช้ประโยชน์จากโมเดลที่ได้รับการฝึกอบรมล่วงหน้าและนำทุกอย่างมารวมกัน

นางแบบหน้ากอด

โมเดลที่ได้รับการฝึกอบรมล่วงหน้าเป็นแกนหลักของโปรเจ็กต์การเรียนรู้เชิงลึกจำนวนมาก ช่วยให้นักวิจัยและนักพัฒนาสามารถเริ่มต้นความคิดริเริ่มของตนได้อย่างรวดเร็วโดยไม่ต้องเริ่มจากศูนย์ Hugging Face อำนวยความสะดวกในการสำรวจโมเดลที่ได้รับการฝึกล่วงหน้าที่หลากหลาย ดังแสดงในโค้ดด้านล่าง:

from transformers import AutoModelForQuestionAnswering, AutoTokenizer
# Load the pre-trained model and tokenizer
model = AutoModelForQuestionAnswering.from_pretrained('bert-large-uncased-whole-word-masking-finetuned-squad')
tokenizer = AutoTokenizer.from_pretrained('bert-large-uncased-whole-word-masking-finetuned-squad')
# Display the model's architecture
print(model)

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

def get_answer(text, question):
    # Tokenize the input text and question
    inputs = tokenizer(question, text, return_tensors='pt', max_length=512, truncation=True)
    outputs = model(**inputs)
    # Get the start and end scores for the answer
    answer_start = torch.argmax(outputs.start_logits)
    answer_end = torch.argmax(outputs.end_logits) + 1
    answer = tokenizer.convert_tokens_to_string(tokenizer.convert_ids_to_tokens(inputs['input_ids'][0][answer_start:answer_end]))
    return answer

ในข้อมูลโค้ด เรานำเข้าโมดูลที่จำเป็นจากแพ็คเกจ Transformers จากนั้นโหลดโมเดลที่ได้รับการฝึกล่วงหน้าและโทเค็นที่เกี่ยวข้องโดยใช้เมธอด from_pretrained เราเลือกโมเดล BERT ที่ได้รับการปรับแต่งอย่างละเอียดบนชุดข้อมูล SQuAD

เรามาดูกรณีการใช้งานตัวอย่างของฟังก์ชันนี้ โดยที่เรามีข้อความหนึ่งย่อหน้า และเราต้องการแยกคำตอบเฉพาะสำหรับคำถามออกมา:

text = """
The Eiffel Tower, located in Paris, France, is one of the most iconic landmarks in the world. It was designed by Gustave Eiffel and completed in 1889. The tower stands at a height of 324 meters and was the tallest man-made structure in the world at the time of its completion.
"""
question = "Who designed the Eiffel Tower?"
# Get the answer to the question
answer = get_answer(text, question)
print(f"The answer to the question is: {answer}")
# Output: The answer to the question is: Gustave Eiffel

ในสคริปต์นี้ เราสร้างฟังก์ชัน get_answer ที่รับข้อความและคำถาม สร้างโทเค็นอย่างเหมาะสม และใช้โมเดล BERT ที่ได้รับการฝึกล่วงหน้าเพื่อแยกคำตอบออกจากข้อความ โดยสาธิตการใช้งานจริงของไลบรารี Transformers ของ Hugging Face เพื่อสร้างระบบตอบคำถามที่เรียบง่ายแต่ทรงพลัง เพื่อให้เข้าใจแนวคิดได้ดี ขอแนะนำให้ทำการทดลองภาคปฏิบัติโดยใช้ สมุดบันทึก Google Colab.

สรุป

ด้วยเครื่องมือโอเพ่นซอร์สที่หลากหลาย โมเดลที่ได้รับการฝึกอบรมล่วงหน้า และไปป์ไลน์ที่ใช้งานง่าย ช่วยให้ทั้งมืออาชีพและผู้มาใหม่สามารถเจาะลึกเข้าไปในโลกที่กว้างใหญ่ของ AI ได้อย่างง่ายดายและเข้าใจ นอกจากนี้ ความคิดริเริ่มในการบูรณาการ Rust เนื่องจากคุณสมบัติด้านความเร็วและความปลอดภัย ตอกย้ำความมุ่งมั่นของ Hugging Face ในการส่งเสริมนวัตกรรม ในขณะเดียวกันก็รับประกันประสิทธิภาพและความปลอดภัยในแอปพลิเคชัน AI งานพลิกโฉมของ Hugging Face ไม่เพียงแต่ทำให้การเข้าถึงเครื่องมือ AI ระดับสูงเป็นประชาธิปไตยเท่านั้น แต่ยังรักษาสภาพแวดล้อมการทำงานร่วมกันสำหรับการเรียนรู้และการพัฒนาในพื้นที่ AI ซึ่งอำนวยความสะดวกในอนาคตที่ AI สามารถเข้าถึงได้