คู่มือสำหรับผู้เริ่มต้นใช้เครื่องมือ Hugging Face LLM

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

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

ทรานส์ฟอร์เมอร์ใน NLP

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

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

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

วิธีการที่ Hugging ส่งเสริมโครงการ NLP และ LLM

Hugging Face ทำให้ทำงานกับ LLMs ง่ายขึ้นโดยการเสนอบริการต่อไปนี้:

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

ทรัพยากรที่ดีจาก Hugging Face คือ Open LLM Leaderboard ซึ่งเป็นแพลตฟอร์มที่ติดตาม ประเมิน และจัดอันดับโมเดลภาษาขนาดใหญ่และแชทบอทต่างๆ อย่างเป็นระบบ โดยให้การวิเคราะห์ที่มีเหตุผลเกี่ยวกับการพัฒนาที่เกิดขึ้นในโดเมนที่เปิดกว้าง
LLM Benchmarks วัดโมเดลโดยใช้เมตริกสี่ตัว:

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

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

ส่วนประกอบของ Hugging

พายพ์ไลน์

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

พายพ์ไลน์รวมสามส่วนหลักของ Hugging Face:

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

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

การประยุกต์ใช้ทรานส์ฟอร์เมอร์โดยใช้ไลบรารี Hugging

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

pip install -q transformers
from transformers import pipeline

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

การประยุกต์ใช้จริง

การจำแนกประเภทข้อความ

การจำแนกประเภทข้อความเป็นเรื่องที่ง่ายด้วยฟังก์ชัน pipeline() ของ 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'} 

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

ตาราง: งานพายพ์ไลน์ Hugging Face

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

เหตุผลที่ Hugging มุ่งเน้นไปที่ Rust

Hugging face Safetensors and tokenizer GitHub Page

ระบบนิเวศของ Hugging Face (HF) เริ่มใช้ Rust ในไลบรารี เช่น safetensors และ tokenizers

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

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

มาดูกันว่าทำไม Rust จึงกลายเป็นตัวเลือกที่นิยมมากกว่า Python มากขึ้น

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

Safetensors

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

Tokenizer

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

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

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

ส่วนประกอบของการแบ่งคำ

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

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

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

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

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

ชุดข้อมูล

Hugging face datasets

ชุดข้อมูลเป็นพื้นฐานของโครงการ 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['train'][0])

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

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

Hugging Face Models

โมเดลที่ฝึกไว้ล่วงหน้าเป็นรากฐานของหลายโครงการการเรียนรู้ลึก ทำให้นักวิจัยและนักพัฒนาสามารถเริ่มต้นโครงการของตนได้โดยไม่ต้องเริ่มต้นจากศูนย์ 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)

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

import torch

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

ในตัวอย่างโค้ด เราเรียกใช้โมเดลและโทเคไนเซอร์ที่ฝึกไว้ล่วงหน้าโดยใช้ from_pretrained และแสดงสถาปัตยกรรมของโมเดล

มาดูกันว่าคุณสามารถใช้ฟังก์ชันนี้เพื่อตอบคำถามจากข้อความได้อย่างไร:

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 ที่รับข้อความและคำถาม และใช้โมเดลที่ฝึกไว้ล่วงหน้าเพื่อหาคำตอบจากข้อความ ตัวอย่างนี้แสดงให้เห็นถึงการประยุกต์ใช้จริงของไลบรารีทรานส์ฟอร์เมอร์ของ Hugging Face ในการสร้างระบบตอบคำถามที่ง่ายแต่ทรงพลัง คุณสามารถศึกษาเพิ่มเติมด้วย สมุดบันทึก Google Colab

สรุป

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