คำตอบสั้นๆ: เพื่อเพิ่มประสิทธิภาพของโมเดล AI ให้เลือกข้อจำกัดหลักหนึ่งข้อ (เช่น ความหน่วง ต้นทุน หน่วยความจำ คุณภาพ ความเสถียร หรือปริมาณงาน) จากนั้นสร้างค่าพื้นฐานที่เชื่อถือได้ก่อนที่จะเปลี่ยนแปลงสิ่งใดๆ เริ่มจากการกำจัดปัญหาคอขวดในกระบวนการทำงานก่อน จากนั้นจึงค่อยปรับปรุงในส่วนที่มีความเสี่ยงต่ำ เช่น ความแม่นยำแบบผสมและการประมวลผลแบบกลุ่ม หากคุณภาพคงที่ จึงค่อยไปปรับปรุงเครื่องมือคอมไพเลอร์/รันไทม์ และลดขนาดโมเดลผ่านการควอนไทเซชันหรือการกลั่นเมื่อจำเป็นเท่านั้น
ประเด็นสำคัญ:
ข้อจำกัด: เลือกตัวชี้วัดเป้าหมายหนึ่งหรือสองตัว การปรับให้เหมาะสมเป็นเรื่องของการแลกเปลี่ยนผลประโยชน์ ไม่ใช่การได้มาซึ่งผลลัพธ์โดยไม่ต้องเสียค่าใช้จ่ายใดๆ
การวัดผล: ทดสอบประสิทธิภาพการทำงานจริงด้วยค่า p50/p95/p99, อัตราการประมวลผล, การใช้ทรัพยากร และค่าสูงสุดของหน่วยความจำ
ขั้นตอนการทำงาน: แก้ไขปัญหาการแบ่งคำ การโหลดข้อมูล การประมวลผลล่วงหน้า และการจัดกลุ่มข้อมูลก่อนที่จะเริ่มประมวลผลโมเดล
การให้บริการ: ใช้การแคช การจัดกลุ่มข้อมูลอย่างรอบคอบ การปรับแต่งการทำงานพร้อมกัน และคอยตรวจสอบความหน่วงเวลาอย่างใกล้ชิด
มาตรการป้องกัน: เรียกใช้ข้อความแจ้งเตือนสำคัญ ตัวชี้วัดงาน และตรวจสอบแบบสุ่มหลังจากการเปลี่ยนแปลงประสิทธิภาพทุกครั้ง
🔗 วิธีการประเมินโมเดล AI อย่างมีประสิทธิภาพ
เกณฑ์สำคัญและขั้นตอนในการตัดสินโมเดลอย่างยุติธรรมและน่าเชื่อถือ
🔗 วิธีวัดประสิทธิภาพ AI ด้วยตัวชี้วัดที่แท้จริง
ใช้เกณฑ์มาตรฐาน ความหน่วง ต้นทุน และสัญญาณคุณภาพเพื่อเปรียบเทียบ
🔗 วิธีทดสอบโมเดล AI ก่อนนำไปใช้
งานจริง ขั้นตอนการทดสอบเชิงปฏิบัติ: การแบ่งข้อมูล กรณีทดสอบความเครียด และการติดตามผล
🔗 วิธีใช้ AI ในการสร้างเนื้อหา
เปลี่ยนไอเดียให้เป็นร่างได้เร็วขึ้นด้วยคำแนะนำที่เป็นระบบและการปรับปรุงอย่างต่อเนื่อง
1) ความหมายของคำว่า “ปรับให้เหมาะสมที่สุด” ในทางปฏิบัติ (เพราะแต่ละคนใช้ในความหมายที่แตกต่างกัน) 🧠
เมื่อผู้คนพูดว่า "ปรับแต่งโมเดล AI ให้เหมาะสม" พวกเขาอาจหมายถึง:
-
ทำให้เร็วขึ้น (ลดความหน่วง)
-
ทำให้ราคาถูกลง (ใช้เวลาประมวลผล GPU น้อยลง ค่าใช้จ่ายด้านคลาวด์ลดลง)
-
ทำให้มีขนาดเล็ลง (ใช้หน่วยความจำน้อยลง, การติดตั้งใช้งานบนอุปกรณ์ปลายทาง)
-
ทำให้มีความแม่นยำมากขึ้น (ปรับปรุงคุณภาพ ลดภาพหลอน)
-
ทำให้มีความเสถียรมากขึ้น (ความผันผวนน้อยลง ความล้มเหลวในการผลิตน้อยลง)
-
ทำให้การให้บริการง่ายขึ้น (ปริมาณงาน การจัดกลุ่ม การทำงานที่คาดการณ์ได้)
นี่คือความจริงที่อาจจะน่ารำคาญเล็กน้อย: คุณไม่สามารถเพิ่มประสิทธิภาพทุกอย่างให้สูงสุดได้ในคราวเดียว การเพิ่มประสิทธิภาพก็เหมือนกับการบีบลูกโป่ง – บีบด้านหนึ่งเข้าไป อีกด้านหนึ่งก็จะโป่งออกมา ไม่ใช่ทุกครั้ง แต่ก็บ่อยพอที่คุณควรวางแผนเผื่อไว้สำหรับข้อแลกเปลี่ยน.
ดังนั้นก่อนที่จะลงมือทำอะไรก็ตาม ให้เลือก ข้อจำกัดหลัก:
-
หากคุณให้บริการผู้ใช้แบบเรียลไทม์ คุณย่อมให้ความสำคัญกับ ค่าความหน่วง p95 (เปอร์เซ็นไทล์ของ AWS CloudWatch) และประสิทธิภาพการทำงานในช่วงท้าย (แนวทางปฏิบัติที่ดีที่สุดสำหรับ "ค่าความหน่วงในช่วงท้าย") 📉
-
ถ้าคุณกำลังฝึกฝนอยู่ คุณย่อมใส่ใจเรื่อง เวลาที่ใช้เพื่อให้ได้คุณภาพ และการใช้ GPU ให้เต็มประสิทธิภาพ 🔥
-
ถ้าคุณกำลังจะติดตั้งใช้งานบนอุปกรณ์ต่างๆ คุณย่อมต้องคำนึงถึง RAM และพลังงาน 🔋
2) ตัวอย่างที่ดีของการเพิ่มประสิทธิภาพโมเดล AI ✅
การปรับแต่งที่ดีไม่ได้หมายความถึงแค่ "ใช้การควอนไทเซชันแล้วก็ภาวนา" แต่มันเป็นระบบ ระบบที่ดีที่สุดมักประกอบด้วย:
-
จุดเริ่มต้นที่คุณวางใจได้
หากคุณไม่สามารถทำซ้ำผลลัพธ์ปัจจุบันได้ คุณก็จะไม่รู้ว่าคุณได้ปรับปรุงอะไรไปบ้าง มันง่ายมาก...แต่คนส่วนใหญ่กลับมองข้ามไป แล้วก็ตกอยู่ในวังวนเดิมๆ -
การกำหนดเป้าหมายที่ชัดเจนอย่าง
“เร็วขึ้น” นั้นคลุมเครือ “ลดค่าความหน่วงของ p95 จาก 900 มิลลิวินาที เหลือ 300 มิลลิวินาที โดยคงคะแนนคุณภาพไว้เท่าเดิม” คือเป้าหมายที่แท้จริง -
มาตรการควบคุมคุณภาพ
ทุกความก้าวหน้าด้านประสิทธิภาพมีความเสี่ยงที่จะนำไปสู่คุณภาพที่ลดลงโดยไม่รู้ตัว คุณจำเป็นต้องมีการทดสอบ การประเมิน หรืออย่างน้อยก็ชุดตรวจสอบความถูกต้อง -
การรับรู้ถึงฮาร์ดแวร์
โมเดลที่ "เร็ว" บน GPU ตัวหนึ่ง อาจทำงานช้ามากบน GPU อีกตัวหนึ่ง ส่วน CPU นั้นก็มีความซับซ้อนในแบบของตัวเอง -
การเปลี่ยนแปลงทีละเล็กทีละน้อย ไม่ใช่การเขียนโค้ดใหม่ทั้งหมด
ในคราวเดียว เมื่อคุณเปลี่ยนแปลงห้าอย่างพร้อมกันแล้วประสิทธิภาพดีขึ้น คุณจะไม่รู้ว่าทำไม ซึ่งนั่น...น่ากังวล
การปรับแต่งเสียงควรให้ความรู้สึกเหมือนกับการตั้งสายกีตาร์ – ปรับทีละเล็กทีละน้อย ฟังอย่างตั้งใจ แล้วทำซ้ำ 🎸 ถ้ามันให้ความรู้สึกเหมือนกับการโยนมีดเล่นกล แสดงว่ามีบางอย่างผิดปกติ.
3) ตารางเปรียบเทียบ: ตัวเลือกยอดนิยมสำหรับการปรับแต่งโมเดล AI ให้เหมาะสม 📊
ด้านล่างนี้คือตารางเปรียบเทียบอย่างคร่าวๆ และอาจไม่เรียบร้อยนักของเครื่องมือ/วิธีการเพิ่มประสิทธิภาพที่ใช้กันทั่วไป ไม่ มันไม่ "ยุติธรรม" อย่างสมบูรณ์แบบหรอก เพราะชีวิตจริงก็ไม่ยุติธรรมเช่นกัน.
| เครื่องมือ / ตัวเลือก | ผู้ชม | ราคา | เหตุผลที่มันได้ผล |
|---|---|---|---|
PyTorch torch.compile (เอกสาร PyTorch) |
ชาว PyTorch | ฟรี | การจับภาพกราฟ + เทคนิคคอมไพเลอร์สามารถลดภาระการทำงานได้…บางครั้งมันก็เหมือนเวทมนตร์ ✨ |
| ONNX Runtime (เอกสารประกอบ ONNX Runtime) | ทีมปฏิบัติการ | ฟรีพอใช้ | การเพิ่มประสิทธิภาพการอนุมานที่แข็งแกร่ง รองรับอย่างกว้างขวาง เหมาะสำหรับการให้บริการแบบมาตรฐาน |
| TensorRT (เอกสารประกอบ TensorRT ของ NVIDIA) | การใช้งาน NVIDIA | การส่งเสียงตอบรับแบบเสียเงิน (มักรวมอยู่ในแพ็กเกจ) | การผสานรวมเคอร์เนลที่ทรงประสิทธิภาพ + การจัดการที่แม่นยำ รวดเร็วมากเมื่อคลิกแล้ว |
| DeepSpeed (เอกสาร ZeRO) | ทีมฝึกอบรม | ฟรี | การเพิ่มประสิทธิภาพหน่วยความจำและปริมาณงาน (เช่น Zero-Remote) ให้ความรู้สึกเหมือนเครื่องยนต์เจ็ท |
| FSDP (PyTorch) (เอกสารประกอบ PyTorch FSDP) | ทีมฝึกอบรม | ฟรี | การแบ่งพารามิเตอร์/เกรเดียนต์ ทำให้โมเดลขนาดใหญ่ดูไม่น่ากลัวอีกต่อไป |
| การควอนไทเซชันบิตแซนด์ไบต์ (บิตแซนด์ไบต์) | นักประดิษฐ์ LLM | ฟรี | ขนาดบิตต่ำ ประหยัดหน่วยความจำได้มหาศาล - คุณภาพอาจแตกต่างกันไป แต่โดยรวมแล้วดีมาก 😬 |
| การกลั่น (ฮินตันและคณะ, 2015) | ทีมผลิตภัณฑ์ | “ต้นทุนด้านเวลา” | รูปแบบการเรียนที่มีนักเรียนน้อยกว่าจะสืบทอดพฤติกรรม ซึ่งโดยทั่วไปแล้วให้ผลตอบแทนการลงทุนที่ดีที่สุดในระยะยาว |
| การตัดแต่งกิ่ง (บทช่วยสอนการตัดแต่งกิ่งใน PyTorch) | วิจัย + ผลิต | ฟรี | ช่วยขจัดส่วนที่ไม่จำเป็น ได้ผลดียิ่งขึ้นเมื่อใช้ร่วมกับการฝึกฝนใหม่ |
| Flash Attention / fused kernels (เอกสาร FlashAttention) | ผู้เชี่ยวชาญด้านประสิทธิภาพ | ฟรี | สมาธิเร็วขึ้น ความจำดีขึ้น นี่คือชัยชนะที่แท้จริงสำหรับหุ่นยนต์แปลงร่าง |
| เซิร์ฟเวอร์อนุมาน Triton (การจัดกลุ่มแบบไดนามิก) | ฝ่ายปฏิบัติการ/โครงสร้างพื้นฐาน | ฟรี | การให้บริการการผลิต การประมวลผลแบบกลุ่ม และไปป์ไลน์หลายรูปแบบ - ให้ความรู้สึกแบบองค์กรขนาดใหญ่ |
สารภาพเรื่องการจัดรูปแบบที่แปลกๆ: คำว่า “ราคา” ดูไม่เรียบร้อย เพราะซอฟต์แวร์โอเพนซอร์สก็ยังอาจทำให้คุณเสียเวลาช่วงสุดสัปดาห์ไปกับการแก้ไขข้อผิดพลาด ซึ่งนั่นก็…เป็นราคาอย่างหนึ่ง 😵💫
4) เริ่มต้นด้วยการวัด: ตรวจวัดสัดส่วนอย่างจริงจัง 🔍
ถ้าคุณจะทำเพียงสิ่งเดียวจากคู่มือทั้งหมดนี้ ขอให้ทำสิ่งนี้: วัดให้ถูกต้อง.
จากการทดสอบของผมเอง “ความก้าวหน้าครั้งสำคัญในการปรับปรุงประสิทธิภาพ” มาจากการค้นพบสิ่งง่ายๆ ที่ดูน่าอาย เช่น:
-
ตัวโหลดข้อมูลกำลังทำให้ GPU ขาดแคลนทรัพยากร
-
ปัญหาคอขวดในการประมวลผลล่วงหน้าของ CPU
-
ขนาดแบทช์เล็กเกินไปทำให้เกิดภาระเกินในการเรียกใช้เคอร์เนล
-
กระบวนการแยกคำช้า (ตัวแยกคำอาจเป็นตัวร้ายเงียบๆ)
-
การกระจายตัวของหน่วยความจำ (หมายเหตุเกี่ยวกับตัวจัดสรรหน่วยความจำ CUDA ของ PyTorch)
-
ชั้นเดียวที่ครอบงำการประมวลผล
สิ่งที่ต้องวัด (ชุดขั้นต่ำ)
-
เวลาแฝง (p50, p95, p99) (SRE บนเปอร์เซ็นไทล์ของเวลาแฝง)
-
อัตราการประมวลผล (โทเค็น/วินาที, คำขอ/วินาที)
-
การใช้ประโยชน์จาก GPU (การประมวลผล + หน่วยความจำ)
-
VRAM / RAM สูงสุด
-
ค่าใช้จ่ายต่อ 1,000 โทเค็น (หรือต่อการอนุมาน)
แนวคิดการวิเคราะห์เชิงปฏิบัติ
-
ลองยกตัวอย่างสถานการณ์ที่คุณสนใจ (ไม่ใช่สถานการณ์เกี่ยวกับของเล่น).
-
จดบันทึกทุกอย่างลงในสมุดบันทึกเล็กๆ
ใช่ มันอาจจะน่าเบื่อ...แต่จะช่วยให้คุณหลีกเลี่ยงการหลอกตัวเองในภายหลังได้
(หากคุณต้องการเครื่องมือที่เป็นรูปธรรมเพื่อเริ่มต้น: PyTorch Profiler (เอกสาร torch.profiler) และ Nsight Systems (NVIDIA Nsight Systems) เป็นตัวเลือกที่นิยมใช้กันทั่วไป)
5) การปรับปรุงข้อมูลและการฝึกอบรมให้เหมาะสม: พลังพิเศษที่มองไม่เห็น 📦🚀
ผู้คนมักหมกมุ่นอยู่กับสถาปัตยกรรมของโมเดลจนลืมเรื่องไปป์ไลน์ ในขณะเดียวกัน ไปป์ไลน์ก็กำลังเผาผลาญทรัพยากร GPU ไปครึ่งหนึ่งโดยปริยาย.
ชัยชนะง่ายๆ ที่เห็นผลเร็ว
-
ใช้การคำนวณแบบความแม่นยำผสม (FP16/BF16 ในกรณีที่เสถียร) (PyTorch AMP / torch.amp)
โดยทั่วไปจะเร็วกว่าและมักจะใช้งานได้ดี แต่ควรระวังความผิดปกติทางตัวเลข -
การสะสมค่าความชัน เมื่อขนาดแบทช์มีจำกัด (🤗 คู่มือเร่งความเร็ว)
ช่วยให้การปรับแต่งมีเสถียรภาพโดยไม่ทำให้หน่วยความจำล้น -
การตรวจสอบจุดเปลี่ยนระดับ (torch.utils.checkpoint)
แลกเปลี่ยนการประมวลผลกับหน่วยความจำ ทำให้สามารถใช้งานบริบทขนาดใหญ่ขึ้นได้ -
การสร้างโทเค็นอย่างมีประสิทธิภาพ (🤗 ตัวสร้างโทเค็น)
การสร้างโทเค็นอาจกลายเป็นคอขวดเมื่อใช้งานในระดับใหญ่ มันอาจดูไม่สวยหรู แต่มีความสำคัญ -
การปรับแต่ง Dataloader:
เพิ่มจำนวน worker, ตรึงหน่วยความจำ, การดึงข้อมูลล่วงหน้า - ดูไม่หวือหวาแต่ได้ผลดี 😴➡️💪 (คู่มือการปรับแต่งประสิทธิภาพ PyTorch)
การปรับแต่งอย่างละเอียดที่มีประสิทธิภาพด้านพารามิเตอร์
หากคุณกำลังปรับแต่งโมเดลขนาดใหญ่ วิธีการ PEFT (เช่น อะแดปเตอร์แบบ LoRA) สามารถลดต้นทุนการฝึกอบรมได้อย่างมาก ในขณะที่ยังคงความแข็งแกร่งอย่างน่าประหลาดใจ (🤗 คู่มือ PEFT สำหรับ Transformers, เอกสาร LoRA) นี่เป็นหนึ่งในโมเมนต์ที่ทำให้เราคิดว่า “ทำไมเราไม่ทำแบบนี้มาก่อน?”
6) การปรับแต่งระดับสถาปัตยกรรม: ปรับขนาดโมเดลให้เหมาะสม 🧩
บางครั้ง วิธีที่ดีที่สุดในการปรับปรุงประสิทธิภาพคือ… เลิกใช้โมเดลที่ใหญ่เกินไปสำหรับงานนั้น รู้ไหม มันฟังดูเหมือนการลบหลู่เลยล่ะ 😄.
ตัดสินใจเกี่ยวกับประเด็นพื้นฐานบางประการ:
-
ตัดสินใจว่าคุณต้องการผู้ที่มีความรู้รอบด้าน หรือผู้เชี่ยวชาญเฉพาะด้าน.
-
ควรปรับขนาดหน้าต่างแสดงบริบทให้มีขนาดเท่าที่จำเป็น ไม่ควรให้ใหญ่เกินไป.
-
ใช้โมเดลที่ได้รับการฝึกฝนมาสำหรับงานนั้นๆ (เช่น โมเดลจำแนกประเภทสำหรับงานจำแนกประเภท เป็นต้น).
กลยุทธ์การปรับขนาดองค์กรให้เหมาะสมในทางปฏิบัติ
-
เปลี่ยนไปใช้โครงสร้างพื้นฐานที่เล็กกว่า สำหรับคำขอส่วนใหญ่
จากนั้นจึงส่งต่อ "คำขอที่ซับซ้อน" ไปยังโมเดลที่ใหญ่กว่า -
ใช้การตั้งค่าแบบสองขั้นตอน
ร่างแบบจำลองอย่างรวดเร็ว จากนั้นตรวจสอบหรือแก้ไขแบบจำลองที่แข็งแกร่งกว่า
มันเหมือนกับการเขียนกับเพื่อนที่จู้จี้จุกจิก – น่ารำคาญ แต่ได้ผลดี -
ลดความยาวของผลลัพธ์
โทเค็นผลลัพธ์มีค่าใช้จ่ายทั้งเงินและเวลา หากโมเดลของคุณแสดงข้อมูลเยื้องไป คุณก็ต้องจ่ายค่าความเยื้องนั้น
ฉันเคยเห็นทีมต่างๆ ลดต้นทุนได้อย่างมากด้วยการกำหนดระยะเวลาทำงานให้สั้นลง มันอาจดูเป็นเรื่องเล็กน้อย แต่ได้ผลจริง.
7) การปรับแต่งคอมไพเลอร์และกราฟ: ที่มาของความเร็ว 🏎️
นี่คือเลเยอร์ "ทำให้คอมพิวเตอร์ทำงานได้อย่างชาญฉลาดขึ้น".
เทคนิคทั่วไป:
-
การรวมตัวดำเนินการ (การรวมเคอร์เนล) (NVIDIA TensorRT “การรวมเลเยอร์”)
-
การพับค่าคงที่ (คำนวณค่าคงที่ล่วงหน้า) (การเพิ่มประสิทธิภาพกราฟของ ONNX Runtime)
-
การเลือกเคอร์เนลได้ รับการปรับแต่งให้เหมาะสมกับฮาร์ดแวร์
-
การจับภาพกราฟ เพื่อลดภาระการทำงานของ Python (
torch.compileภาพรวม)
พูดให้เข้าใจง่ายๆ ก็คือ โมเดลของคุณอาจคำนวณเร็ว แต่ใช้งานจริงช้า คอมไพเลอร์ช่วยแก้ไขปัญหาส่วนนี้ได้.
บันทึกย่อเชิงปฏิบัติ (หรือเรียกอีกอย่างว่า รอยแผลเป็น)
-
การปรับแต่งเหล่านี้อาจมีความอ่อนไหวต่อการเปลี่ยนแปลงรูปร่างของแบบจำลอง.
-
บางรุ่นเร่งความเร็วขึ้นมาก บางรุ่นแทบไม่ขยับเลย.
-
บางครั้งคุณอาจเจอปัญหาความเร็วเพิ่มขึ้นและบั๊กแปลกๆ เหมือนมีภูตจิ๋วเข้ามาสิงอยู่ในเกม 🧌
อย่างไรก็ตาม เมื่อมันได้ผล มันก็เป็นหนึ่งในชัยชนะที่ใสสะอาดที่สุด.
8) การลดขนาด การตัดแต่ง การกลั่นกรอง: ลดขนาดลงโดยไม่ต้องร้องไห้ (มากเกินไป) 🪓📉
นี่คือส่วนที่ผู้คนต้องการ...เพราะมันฟังดูเหมือนเป็นการแสดงฟรี มันอาจเป็นเช่นนั้นได้ แต่คุณต้องปฏิบัติต่อมันเหมือนกับการผ่าตัด.
การหาปริมาณ (ค่าถ่วงน้ำหนัก/ค่ากระตุ้นที่มีความแม่นยำต่ำกว่า)
-
เหมาะอย่างยิ่งสำหรับความเร็วในการประมวลผลและหน่วยความจำ
-
ความเสี่ยง: คุณภาพลดลง โดยเฉพาะในกรณีพิเศษ
-
แนวทางปฏิบัติที่ดีที่สุด: ประเมินผลจากชุดข้อมูลทดสอบจริง ไม่ใช่จากความรู้สึกหรือความรู้สึก
รสชาติทั่วไปที่คุณจะได้ยิน:
-
INT8 (มักจะเป็นของแข็ง) (ประเภทควอนไทซ์ของ TensorRT)
-
INT4 / บิตต่ำ (ประหยัดพื้นที่ได้มาก แต่ความเสี่ยงด้านคุณภาพสูงขึ้น) (การควอนไทเซชัน k-บิตของ bitsandbytes)
-
การวัดเชิงปริมาณแบบผสม (ไม่จำเป็นต้องมีความแม่นยำเท่ากันทุกอย่าง)
การตัดแต่ง (ลบพารามิเตอร์)
-
ลบน้ำหนักหรือโครงสร้างที่ไม่สำคัญออก (ตัวอย่างการตัดแต่งใน PyTorch)
-
โดยปกติแล้วจำเป็นต้องมีการฝึกอบรมใหม่เพื่อฟื้นฟูคุณภาพ
-
ได้ผลดีกว่าที่หลายคนคิด...หากทำอย่างระมัดระวัง
การกลั่น (นักเรียนเรียนรู้จากครู)
นี่คือกลไกระยะยาวที่ผมชื่นชอบที่สุด การกลั่นกรองสามารถสร้างแบบจำลองที่เล็กลงแต่มีพฤติกรรมคล้ายคลึงกัน และมักมีความเสถียรมากกว่าการควอนไทเซชันแบบสุดขั้ว (การกลั่นกรองความรู้ในโครงข่ายประสาทเทียม)
เป็นการเปรียบเทียบที่ไม่สมบูรณ์แบบนัก: การกลั่นเปรียบเสมือนการเทซุปที่ซับซ้อนผ่านตัวกรอง แล้วได้...ซุปที่น้อยลง นั่นไม่ใช่หลักการทำซุปที่แท้จริง แต่คุณคงเข้าใจนะ 🍲.
9) การเสิร์ฟและการอนุมาน: สมรภูมิรบที่แท้จริง 🧯
คุณสามารถ "ปรับแต่ง" โมเดลให้เหมาะสมที่สุดได้ แต่การให้บริการก็ยังคงไม่ดีเท่าที่ควร การให้บริการนี่แหละคือจุดที่ความหน่วงและต้นทุนจะส่งผลอย่างแท้จริง.
การเสิร์ฟคือชัยชนะที่สำคัญ
-
การประมวลผลแบบกลุ่ม
ช่วยเพิ่มประสิทธิภาพการทำงาน แต่จะเพิ่มความหน่วงหากใช้มากเกินไป จึงควรปรับสมดุล (การประมวลผลแบบกลุ่มแบบไดนามิกของ Triton) -
การ
แคชข้อความแจ้งเตือนและการนำแคช KV กลับมาใช้ซ้ำนั้นมีประโยชน์อย่างมากสำหรับบริบทที่ใช้ซ้ำ (คำอธิบายแคช KV) -
การสตรีมเอาต์พุต
ผู้ใช้รู้สึกว่าเร็วกว่าแม้ว่าเวลารวมจะใกล้เคียงกันก็ตาม การรับรู้เป็นสิ่งสำคัญ 🙂 -
ลดภาระงานเพิ่มเติมทีละโทเค็น
บางระบบประมวลผลข้อมูลเพิ่มเติมต่อโทเค็น การลดภาระงานเพิ่มเติมเหล่านั้นจะนำมาซึ่งผลลัพธ์ที่ดีเยี่ยม
ระวังค่าความหน่วงของหาง (tail latency)
ค่าเฉลี่ยของคุณอาจดูดีมาก ในขณะที่ค่า p99 ของคุณกลับแย่มาก ผู้ใช้งานส่วนใหญ่มักอยู่ในกลุ่มผู้ใช้งานที่มีปัญหา (กลุ่มผู้ใช้งานที่มีปัญหา" และเหตุผลที่ค่าเฉลี่ยไม่)
10) การปรับแต่งโดยคำนึงถึงฮาร์ดแวร์: จับคู่โมเดลกับเครื่อง 🧰🖥️
การปรับแต่งโดยไม่คำนึงถึงฮาร์ดแวร์ก็เหมือนกับการปรับแต่งรถแข่งโดยไม่ตรวจสอบยาง แน่นอนว่าคุณทำได้ แต่ก็ดูไม่ค่อยสมเหตุสมผลเท่าไหร่.
ข้อควรพิจารณาเกี่ยวกับ GPU
-
แบนด์วิดท์ของหน่วยความจำมักเป็นปัจจัยจำกัด ไม่ใช่พลังการประมวลผลดิบ
-
การผลิตในปริมาณมากอาจช่วยได้ จนกว่ามันจะไม่ได้ผลอีกต่อไป
-
การรวมเคอร์เนลและการเพิ่มประสิทธิภาพความสนใจมีความสำคัญอย่างมากสำหรับ Transformer (FlashAttention: ความสนใจที่แม่นยำซึ่งคำนึงถึง IO)
ข้อควรพิจารณาเกี่ยวกับซีพียู
-
การใช้มัลติเธรด การประมวลผลแบบเวกเตอร์ และการเข้าถึงหน่วยความจำอย่างมีประสิทธิภาพ ล้วนมีความสำคัญอย่างมาก
-
ค่าใช้จ่ายในการแปลงโทเค็นอาจเป็นปัจจัยหลัก (🤗 ตัวแปลงโทเค็นที่ "เร็ว")
-
คุณอาจต้องใช้กลยุทธ์การควอนไทเซชันที่แตกต่างไปจากที่ใช้กับ GPU
ข้อควรพิจารณาสำหรับอุปกรณ์ Edge / อุปกรณ์พกพา
-
การใช้หน่วยความจำกลายเป็นสิ่งสำคัญอันดับหนึ่ง
-
ความแปรปรวนของเวลาแฝงมีความสำคัญ เพราะอุปกรณ์นั้น… อารมณ์แปรปรวน
-
โมเดลขนาดเล็กที่เน้นการใช้งานเฉพาะทางมักจะเอาชนะโมเดลขนาดใหญ่ที่ใช้งานได้ทั่วไปได้
11) หลักเกณฑ์ด้านคุณภาพ: อย่า "ปรับแต่ง" ตัวเองจนกลายเป็นบั๊ก 🧪
ทุกชัยชนะด้านความเร็วควรมาพร้อมกับการตรวจสอบคุณภาพ มิเช่นนั้นคุณจะฉลอง ส่งสินค้า แล้วก็ได้รับข้อความเช่น “ทำไมผู้ช่วยถึงพูดเหมือนโจรสลัดขึ้นมาทันที?” 🏴☠️
หลักเกณฑ์ปฏิบัติที่เป็นรูปธรรม:
-
คำถามมาตรฐาน (ชุดคำถามคงที่ที่คุณใช้ทดสอบเสมอ)
-
ตัวชี้วัดงาน (ความแม่นยำ, F1, BLEU, หรืออื่นๆ ที่เหมาะสม)
-
การตรวจสอบโดยมนุษย์แบบสุ่ม (ใช่แล้ว จริงๆ นะ)
-
เกณฑ์การถดถอย ("อนุญาตให้ลดลงไม่เกิน X%")
นอกจากนี้ ให้ติดตามรูปแบบความล้มเหลวด้วย:
-
การเลื่อนรูปแบบ
-
การเปลี่ยนแปลงพฤติกรรมการปฏิเสธ
-
ความถี่ของอาการประสาทหลอน
-
การขยายความยาวของการตอบสนอง
การปรับปรุงให้เหมาะสมสามารถเปลี่ยนแปลงพฤติกรรมได้ในรูปแบบที่คาดไม่ถึง แปลกประหลาด น่าหงุดหงิด แต่เมื่อมองย้อนกลับไปแล้ว ก็สามารถคาดเดาได้.
12) รายการตรวจสอบ: วิธีการเพิ่มประสิทธิภาพโมเดล AI ทีละขั้นตอน ✅🤖
หากคุณต้องการลำดับขั้นตอนที่ชัดเจนสำหรับ วิธีการเพิ่มประสิทธิภาพโมเดล AIนี่คือขั้นตอนการทำงานที่มักจะช่วยให้ผู้คนเข้าใจและทำตามได้ง่าย:
-
กำหนดความสำเร็จ
เลือกตัวชี้วัดหลัก 1-2 ข้อ (ความหน่วง, ต้นทุน, ปริมาณงาน, คุณภาพ) -
วัดค่าพื้นฐาน
โปรไฟล์ปริมาณงานจริง บันทึกค่า p50/p95 หน่วยความจำ และต้นทุน (โดยใช้PyTorch Profiler) -
แก้ไขปัญหาคอขวดในกระบวนการทำงาน
: การโหลดข้อมูล, การแยกคำ, การประมวลผลล่วงหน้า, การประมวลผลแบบกลุ่ม -
ใช้ประโยชน์จากการประมวลผลที่มีความเสี่ยงต่ำ
เช่น ความแม่นยำแบบผสม การเพิ่มประสิทธิภาพเคอร์เนล และการจัดกลุ่มข้อมูลที่ดีขึ้น -
ลองใช้การปรับแต่งคอมไพเลอร์/รันไทม์
เช่น การจับภาพกราฟ รันไทม์การอนุมาน การรวมตัวดำเนินการ (สอน torch.compileดูบทช่วยและ เอกสาร ONNX Runtime) -
ลดต้นทุนการสร้างแบบจำลอง
กำหนดปริมาณอย่างระมัดระวัง กลั่นกรองหากทำได้ และตัดแต่งหากเหมาะสม -
ปรับแต่ง
ระบบการแคช การทำงานพร้อมกัน การทดสอบโหลด และแก้ไขปัญหาความหน่วงแฝง -
คุณภาพ
ดำเนินการทดสอบการถดถอย และเปรียบเทียบผลลัพธ์แบบเคียงข้างกัน -
ทำซ้ำขั้นตอน
การเปลี่ยนแปลงเล็กน้อย จดบันทึกอย่างชัดเจน แล้วทำซ้ำไปเรื่อยๆ ไม่โอ้อวด แต่ได้ผล
ใช่แล้ว นี่ก็ยังคงเป็น บทความเรื่อง วิธีการเพิ่มประสิทธิภาพโมเดล AI แม้ว่ามันจะฟังดูเหมือน “วิธีการหยุดเหยียบคราด” มากกว่าก็ตาม เพราะมันก็เหมือนกันนั่นแหละ
13) ข้อผิดพลาดทั่วไป (เพื่อที่คุณจะได้ไม่ทำผิดซ้ำเหมือนคนอื่นๆ) 🙃
-
มุ่งเน้นการปรับปรุงก่อนการวัดผล
คุณจะเสียเวลา และสุดท้ายคุณก็จะปรับปรุงในสิ่งที่ผิดพลาดอย่างมั่นใจ… -
การไล่ตามเกณฑ์วัดประสิทธิภาพเพียงอย่างเดียว
เกณฑ์วัดประสิทธิภาพนั้นหลอกลวงด้วยการละเว้นข้อมูลบางอย่าง ปริมาณงานของคุณต่างหากคือความจริง -
การละเลยเรื่อง
หน่วยความจำ ปัญหาเกี่ยวกับหน่วยความจำทำให้เกิดความช้าลง การหยุดทำงาน และการกระตุก (ทำความเข้าใจการใช้งานหน่วยความจำ CUDA ใน PyTorch) -
การควอนไทซ์มากเกินไปเร็วเกินไป การ
ไทซ์แบบบิตต่ำอาจให้ผลลัพธ์ที่น่าทึ่ง แต่ควรเริ่มต้นด้วยขั้นตอนที่ปลอดภัยกว่าก่อน -
ไม่มีแผนย้อนกลับ
หากคุณไม่สามารถย้อนกลับได้อย่างรวดเร็ว การติดตั้งแต่ละครั้งจะกลายเป็นเรื่องเครียด ความเครียดก่อให้เกิดข้อผิดพลาด
หมายเหตุปิดท้าย: วิธีการปรับให้เหมาะสมในแบบฉบับมนุษย์ 😌⚡
การเพิ่มประสิทธิภาพโมเดล AI ไม่ใช่แค่ทางลัดเดียว แต่เป็นกระบวนการหลายขั้นตอน: วัดผล ปรับปรุงไปป์ไลน์ เลือกใช้คอมไพเลอร์และรันไทม์ ปรับแต่งการให้บริการ จากนั้นลดขนาดโมเดลด้วยการควอนไทเซชันหรือการกลั่นกรองหากจำเป็น ทำทีละขั้นตอน รักษามาตรฐานคุณภาพ และอย่าใช้แค่คำว่า "รู้สึกว่าเร็วกว่า" เป็นตัวชี้วัด (ความรู้สึกของคุณนั้นดี แต่ความรู้สึกไม่ใช่เครื่องมือวัดประสิทธิภาพ)
ถ้าอยากได้ข้อสรุปแบบสั้นที่สุด:
-
วัดขนาดก่อนนะคะ 🔍
-
ขั้นตอนต่อไปคือการปรับปรุงกระบวนการทำงานให้มีประสิทธิภาพยิ่งขึ้น 🧵
-
จากนั้นปรับแต่งโมเดลให้เหมาะสม 🧠
-
จากนั้นจึงปรับการเสิร์ฟให้เหมาะสม 🏗️
-
ตรวจสอบคุณภาพอย่างสม่ำเสมอ ✅
และถ้ามันช่วยได้ ลองเตือนตัวเองว่า เป้าหมายไม่ใช่ "โมเดลที่สมบูรณ์แบบ" เป้าหมายคือโมเดลที่เร็ว ราคาไม่แพง และเชื่อถือได้มากพอที่จะทำให้คุณนอนหลับได้อย่างสบายใจ...ในคืนส่วนใหญ่ 😴.
ตัวอย่างในโลกแห่งความเป็นจริง: การเพิ่มประสิทธิภาพระบบสรุปตั๋วสนับสนุน 🎟️⚡
สถานการณ์
ลองนึกภาพทีมพัฒนาซอฟต์แวร์แบบ SaaS ขนาดเล็กทีมหนึ่งใช้โมเดล AI ในการสรุปข้อมูลจากตั๋วขอความช่วยเหลือที่เข้ามา ก่อนที่เจ้าหน้าที่ฝ่ายบริการลูกค้าจะตอบกลับ โมเดลนี้ใช้งานได้ แต่ทำงานช้า เจ้าหน้าที่ต้องรอสรุปนานเกินไป และบริษัทต้องจ่ายค่าประมวลผลมากกว่าที่คาดไว้.
เป้าหมายไม่ใช่การทำให้โมเดล "ดีขึ้น" ในทุกๆ ด้าน ทีมงานเลือกข้อจำกัดหลักเพียงข้อเดียว คือ ลดค่าความหน่วงของ p95 ในขณะที่ยังคงรักษาคุณภาพโดยรวมให้อยู่ในระดับที่ยอมรับได้.
เป้าหมายของพวกเขานั้นชัดเจน:
ลดเวลาแฝงของ p95 จากประมาณ 2.4 วินาที เหลือต่ำกว่า 1.2 วินาที โดยมีข้อผิดพลาดสรุปที่ร้ายแรงไม่เกินหนึ่งรายการในชุดทดสอบ 50 รายการ.
สิ่งที่เวิร์กโฟลว์ต้องการ
เพื่อให้การดำเนินการนี้เป็นไปได้อย่างเป็นรูปธรรม ทีมงานจึงได้รวบรวม:
ชุดทดสอบตั๋วทองคำ 50 ใบ ประกอบด้วยตั๋วแบบสั้น กลาง และไม่เรียบร้อย
รูปแบบการสรุปที่คาดหวัง: 3 ข้อสำคัญ ไม่มีข้อเท็จจริงที่แต่งขึ้น ระบุความเร่งด่วนหากเห็นได้ชัด
ตัวชี้วัดพื้นฐาน: เวลาแฝง p50, p95, p99, จำนวนโทเค็นที่สร้าง, ต้นทุนต่อตั๋ว และจำนวนข้อผิดพลาด
รายการตรวจสอบการรีวิวโดยมนุษย์แบบง่ายๆ
สามารถเข้าถึงบันทึกโมเดล จำนวนโทเค็น และการตั้งค่าชุดงาน/การทำงานพร้อมกันได้
มีตัวเลือกในการย้อนกลับหากคุณภาพลดลง
ส่วนสำคัญคือ พวกเขาไม่ได้เริ่มต้นด้วยการหาปริมาณ (quantisation) ก่อน แต่พวกเขาจะตรวจสอบก่อนว่ากระบวนการทำงานนั้นทำให้เสียเวลาหรือไม่.
ตัวอย่างคำแนะนำ
สำหรับตั๋วแจ้งปัญหาแต่ละรายการ ให้สรุปปัญหาของลูกค้าโดยใช้หัวข้อย่อยสามข้อเท่านั้น.
รวม:
-
ปัญหาหลัก
-
พื้นที่ผลิตภัณฑ์ใด ๆ ที่กล่าวถึง
-
ความเร่งด่วนหรือผลกระทบต่อธุรกิจ (ถ้ามี)
อย่าสร้างรายละเอียดที่ขาดหายไปขึ้นมาเอง หากลูกค้าให้ข้อมูลไม่ครบถ้วน ให้ตอบว่า “ไม่ได้ระบุ”.
สรุปเนื้อหาไม่เกิน 80 คำ.
วิธีการทดสอบ
ทดลองใช้ตั๋ว 50 ใบเดิมกับทั้งระบบเก่าและระบบใหม่.
ในแต่ละรอบการวิ่ง ให้บันทึกข้อมูลดังนี้:
ค่าความหน่วง p50, p95 และ p99
โทเค็นเอาต์พุตเฉลี่ย
ต้นทุนต่อตั๋ว 1,000 ใบ
จำนวนบทสรุปที่มีรายละเอียดที่แต่งขึ้น
จำนวนบทสรุปที่ต้องแก้ไขโดยมนุษย์
จากนั้นลองทดสอบกรณีที่ซับซ้อนบางกรณีดู:
ตั๋วใบหนึ่งที่มีปัญหาแยกกันสามประเด็น
ข้อความจากลูกค้าที่โกรธจัด
ตั๋วที่ไม่ชัดเจน แทบไม่มีรายละเอียดใดๆ
ตั๋วที่มีบันทึกที่คัดลอกมาวางไว้
ตั๋วที่ลูกค้าระบุว่าต้องการยกเลิกบัญชี
วิธีนี้ช่วยตรวจจับข้อผิดพลาดทั่วไปที่เกิดขึ้นเมื่อการปรับปรุงประสิทธิภาพทำให้โมเดลทำงานเร็วขึ้นแต่ขาดความระมัดระวัง.
ผลลัพธ์
ผลลัพธ์ที่แสดงให้เห็นภาพ โดยอิงจากการจับเวลาตั๋วตัวอย่าง 50 ใบ ก่อนและหลังการปรับปรุงประสิทธิภาพ 3 รอบ:
เกณฑ์พื้นฐาน:
เวลาแฝง p95: 2.4 วินาที
เวลาแฝง p99: 3.1 วินาที
ความยาวเฉลี่ยของผลลัพธ์: 142 คำ
การแก้ไขโดยมนุษย์: 11 จาก 50
ข้อผิดพลาดร้ายแรงเกี่ยวกับรายละเอียดที่แต่งขึ้น: 3 จาก 50
หลังจากการปรับปรุงประสิทธิภาพ:
เวลาแฝง p95: 1.1 วินาที
ความหน่วงของ p99: 1.6 วินาที
ความยาวเฉลี่ยของผลลัพธ์: 61 คำ
การแก้ไขโดยมนุษย์: 5 จาก 50
ข้อผิดพลาดร้ายแรงเกี่ยวกับรายละเอียดที่แต่งขึ้น: 1 ใน 50
สิ่งที่เปลี่ยนแปลงไป:
ทีมงานกำหนดความยาวของผลงานสูงสุดไว้ที่ 80 คำ
พวกเขาจัดกลุ่มตั๋วที่มีลำดับความสำคัญต่ำเป็นกลุ่มละ 8 ใบ
พวกเขาแคชบริบทนโยบายผลิตภัณฑ์ซ้ำๆ
พวกเขาเปิดใช้งานโหมดความแม่นยำผสมหลังจากตรวจสอบแล้วว่าคุณภาพคงที่
พวกเขาเลื่อนการปรับค่าเชิงปริมาณไปทำทีหลัง เนื่องจากบรรลุเป้าหมายด้านความหน่วงแล้ว
ในตัวอย่างนี้ ต้นทุนก็ลดลงเช่นกัน เนื่องจากโมเดลสร้างโทเค็นน้อยลง หากระบบเดิมสร้างคำประมาณ 142 คำต่อตั๋ว และระบบใหม่สร้างประมาณ 61 คำ ความยาวของผลลัพธ์ก็ลดลงประมาณ 57% ซึ่งเป็นตัวชี้วัดที่ทีมสามารถตรวจสอบได้โดยตรงจากบันทึก.
อะไรบ้างที่อาจผิดพลาดได้
ข้อผิดพลาดที่น่าดึงดูดใจที่สุดคือการมุ่งเน้นความเร็วเพียงอย่างเดียว การสรุปข้อมูลที่เร็วขึ้นซึ่งสร้างคำสัญญาเรื่องการคืนเงินขึ้นมาเองนั้นไม่ใช่การปรับปรุงที่ดีขึ้น.
ข้อผิดพลาดง่ายๆ อื่นๆ:
ทดสอบเฉพาะตั๋วที่สะอาดเท่านั้น
ไม่สนใจค่าความหน่วงของ p99
ลืมเปรียบเทียบความยาวของผลลัพธ์
การเปลี่ยนการตั้งค่าแบทช์และโมเดลพร้อมกัน
ใช้ค่าความหน่วงเฉลี่ยแทนค่าความหน่วงส่วนท้าย
อ้างว่า “คุณภาพยังคงเหมือนเดิม” โดยไม่มีรายการตรวจสอบเพื่อการประเมิน
กฎการตรวจสอบที่ปลอดภัยกว่านั้นง่ายมาก: หากบทสรุปมากกว่า 2 ใน 50 บทสร้างรายละเอียดสำคัญขึ้นมาเอง ให้ย้อนกลับไปตรวจสอบใหม่.
ข้อคิดที่นำไปใช้ได้จริง
นี่คือตัวอย่างของการปรับปรุงโมเดล AI ที่มีประสิทธิภาพในทางปฏิบัติ: เลือกข้อจำกัดหนึ่งข้อ วัดระบบปัจจุบัน กำจัดส่วนที่ไม่จำเป็นออกก่อน ปรับเปลี่ยนโดยคำนึงถึงความเสี่ยงต่ำ จากนั้นตรวจสอบคุณภาพด้วยการทดสอบที่ดูธรรมดาแต่มีคุณค่า ผลลัพธ์ที่ได้ไม่ใช่แค่โมเดลที่เร็วขึ้น แต่เป็นโมเดลที่เร็วขึ้นและคุณยังคงวางใจได้.
คำถามที่พบบ่อย
การปรับปรุงประสิทธิภาพของโมเดล AI ในทางปฏิบัติหมายความว่าอย่างไร
โดยทั่วไปแล้ว “การปรับให้เหมาะสม” หมายถึงการปรับปรุงข้อจำกัดหลักข้อใดข้อหนึ่ง เช่น ความหน่วงเวลา ต้นทุน การใช้หน่วยความจำ ความแม่นยำ ความเสถียร หรือปริมาณงานที่ให้บริการ ส่วนที่ยากคือการแลกเปลี่ยนกัน – การผลักดันด้านหนึ่งอาจส่งผลเสียต่ออีกด้านหนึ่ง แนวทางที่ได้ผลคือการเลือกเป้าหมายที่ชัดเจน (เช่น ความหน่วงเวลา p95 หรือเวลาในการประมวลผลที่มีคุณภาพ) และปรับให้เหมาะสมไปสู่เป้าหมายนั้น หากไม่มีเป้าหมาย การ “ปรับปรุง” อาจจบลงด้วยความล้มเหลวได้ง่าย.
วิธีเพิ่มประสิทธิภาพโมเดล AI โดยไม่ทำให้คุณภาพลดลงโดยไม่รู้ตัว
จงมองการเปลี่ยนแปลงความเร็วหรือต้นทุนทุกครั้งว่าเป็นสัญญาณบ่งบอกถึงความถดถอยที่อาจเกิดขึ้นโดยไม่รู้ตัว ใช้มาตรการป้องกัน เช่น คำแนะนำที่สำคัญ ตัวชี้วัดงาน และการตรวจสอบโดยมนุษย์อย่างรวดเร็ว กำหนดเกณฑ์ที่ชัดเจนสำหรับความคลาดเคลื่อนที่ยอมรับได้ในด้านคุณภาพ และเปรียบเทียบผลลัพธ์แบบเคียงข้างกัน วิธีนี้จะช่วยป้องกันไม่ให้คำถามที่ว่า “มันเร็วขึ้น” กลายเป็น “ทำไมจู่ๆ มันถึงดูแปลกๆ ในการใช้งานจริง?” หลังจากที่คุณส่งงานไปแล้ว.
สิ่งที่ต้องวัดก่อนเริ่มทำการปรับปรุงประสิทธิภาพ
เริ่มต้นด้วยเปอร์เซ็นไทล์ของความหน่วง (p50, p95, p99), ปริมาณงาน (โทเค็น/วินาที หรือ คำขอ/วินาที), การใช้งาน GPU และ VRAM/RAM สูงสุด ติดตามต้นทุนต่อการอนุมาน หรือต่อ 1,000 โทเค็น หากต้นทุนเป็นข้อจำกัด ทดสอบประสิทธิภาพในสถานการณ์จริงที่คุณให้บริการ ไม่ใช่ในพรอมต์จำลอง การจดบันทึกประสิทธิภาพเล็กๆ น้อยๆ จะช่วยให้คุณหลีกเลี่ยงการคาดเดาและการทำผิดซ้ำซาก.
เพิ่มประสิทธิภาพการฝึกซ้อมได้อย่างรวดเร็วและมีความเสี่ยงต่ำ
ความแม่นยำแบบผสม (FP16/BF16) มักเป็นจุดเริ่มต้นที่เร็วที่สุด แต่ควรระวังความผิดปกติทางตัวเลข หากขนาดแบทช์มีจำกัด การสะสมเกรเดียนต์สามารถช่วยให้การปรับให้เหมาะสมมีเสถียรภาพโดยไม่ทำให้หน่วยความจำหมดเร็ว การตรวจสอบเกรเดียนต์จะแลกเปลี่ยนการคำนวณเพิ่มเติมกับหน่วยความจำที่น้อยลง ทำให้สามารถใช้คอนเท็กซ์ขนาดใหญ่ขึ้นได้ อย่าละเลยการปรับแต่งโทเค็นและการโหลดข้อมูล เพราะอาจทำให้ GPU ทำงานหนักเกินไปโดยไม่รู้ตัว.
ควรใช้ torch.compile, ONNX Runtime หรือ TensorRT เมื่อใด
เครื่องมือเหล่านี้มุ่งเป้าไปที่การลดภาระการทำงาน: การจับภาพกราฟ การรวมเคอร์เนล และการเพิ่มประสิทธิภาพกราฟขณะรันไทม์ พวกมันสามารถเพิ่มความเร็วในการอนุมานได้อย่างเห็นได้ชัด แต่ผลลัพธ์จะแตกต่างกันไปตามรูปร่างของโมเดลและฮาร์ดแวร์ บางการตั้งค่าให้ผลลัพธ์ที่น่าทึ่ง ในขณะที่บางการตั้งค่าแทบไม่มีการเปลี่ยนแปลง ควรคาดหวังถึงความไวต่อการเปลี่ยนแปลงรูปร่างและข้อผิดพลาดเล็กๆ น้อยๆ ที่อาจเกิดขึ้นได้ ควรวัดผลก่อนและหลังการใช้งานจริง.
การแปลงข้อมูลเป็นดิจิทัลคุ้มค่าหรือไม่ และจะหลีกเลี่ยงการแปลงข้อมูลเป็นดิจิทัลมากเกินไปได้อย่างไร
การควอนไทเซชันสามารถลดหน่วยความจำและเพิ่มความเร็วในการประมวลผลได้ โดยเฉพาะอย่างยิ่งกับ INT8 แต่คุณภาพอาจลดลงในกรณีพิเศษ ตัวเลือกที่มีบิตต่ำกว่า (เช่น INT4/k-bit) จะช่วยประหยัดหน่วยความจำได้มากขึ้น แต่ก็มีความเสี่ยงสูงกว่า วิธีที่ปลอดภัยที่สุดคือการทดสอบกับชุดข้อมูลจริงและเปรียบเทียบผลลัพธ์ ไม่ใช่การตัดสินใจจากความรู้สึก เริ่มต้นด้วยขั้นตอนที่ปลอดภัยกว่าก่อน แล้วค่อยลดความแม่นยำลงเมื่อจำเป็นเท่านั้น.
ความแตกต่างระหว่างการตัดแต่งกิ่งและการกลั่นเพื่อลดขนาดโมเดล
การตัดแต่งกิ่งจะกำจัดพารามิเตอร์ที่ “ไร้ประโยชน์” ออกไป และมักต้องฝึกฝนใหม่เพื่อให้ได้คุณภาพกลับคืนมา โดยเฉพาะอย่างยิ่งเมื่อทำอย่างรุนแรง การกลั่นกรองจะฝึกโมเดลนักเรียนขนาดเล็กให้เลียนแบบพฤติกรรมของครูขนาดใหญ่ และอาจให้ผลตอบแทนจากการลงทุนในระยะยาวที่แข็งแกร่งกว่าการแบ่งส่วนแบบสุดขั้ว หากคุณต้องการโมเดลขนาดเล็กที่ทำงานคล้ายกันและคงที่ การกลั่นกรองมักเป็นเส้นทางที่สะอาดกว่า.
วิธีลดต้นทุนและเวลาแฝงในการประมวลผลผ่านการปรับปรุงการให้บริการ
การให้บริการคือจุดที่การเพิ่มประสิทธิภาพเห็นผลได้อย่างชัดเจน: การประมวลผลเป็นกลุ่มช่วยเพิ่มปริมาณงาน แต่หากทำมากเกินไปอาจทำให้ความหน่วงลดลง ดังนั้นจึงต้องปรับแต่งอย่างระมัดระวัง การแคช (การแคชข้อความแจ้งเตือนและการใช้แคช KV ซ้ำ) อาจมีขนาดใหญ่มากเมื่อบริบทซ้ำกัน การส่งออกข้อมูลแบบสตรีมมิ่งช่วยเพิ่มความเร็วที่รับรู้ได้ แม้ว่าเวลารวมจะใกล้เคียงกันก็ตาม นอกจากนี้ควรตรวจสอบค่าใช้จ่ายเพิ่มเติมในแต่ละโทเค็นด้วย เพราะงานเล็กๆ น้อยๆ ต่อโทเค็นจะสะสมเพิ่มขึ้นอย่างรวดเร็ว.
เหตุใดค่าความหน่วงท้ายจึงมีความสำคัญอย่างยิ่งในการปรับแต่งโมเดล AI
ค่าเฉลี่ยอาจดูดีมากในขณะที่ค่า p99 กลับแย่มาก และผู้ใช้มักจะอยู่ในกลุ่มที่มีค่าสูงสุด (tail latency) ค่า p99 มักเกิดจากความผันผวน เช่น การแตกกระจายของหน่วยความจำ การประมวลผลล่วงหน้าของ CPU ที่พุ่งสูงขึ้น การทำงานที่ช้าลงของการแปลงข้อมูลเป็นโทเค็น หรือพฤติกรรมการประมวลผลแบบกลุ่มที่ไม่ดี นั่นเป็นเหตุผลที่คู่มือนี้เน้นที่เปอร์เซ็นไทล์และภาระงานจริง หากคุณปรับแต่งเฉพาะค่า p50 คุณก็ยังอาจส่งมอบประสบการณ์ที่ "รู้สึกช้าแบบสุ่ม" ได้
เอกสารอ้างอิง
-
Amazon Web Services (AWS) - เปอร์เซ็นไทล์ AWS CloudWatch (คำจำกัดความทางสถิติ) - docs.aws.amazon.com
-
Google - การจัดการความล่าช้าของส่วนท้ายระบบในระดับใหญ่ (แนวทางปฏิบัติที่ดีที่สุดสำหรับความล่าช้าของส่วนท้ายระบบ) - sre.google
-
Google - Service Level Objectives (SRE Book) - Latency Percentiles - sre.google
-
PyTorch - torch.compile - docs.pytorch.org
-
PyTorch - FullyShardedDataParallel (FSDP) - docs.pytorch.org
-
PyTorch - เครื่องมือสร้างโปรไฟล์ PyTorch - docs.pytorch.org
-
PyTorch - ความหมายของ CUDA: การจัดการหน่วยความจำ (หมายเหตุเกี่ยวกับตัวจัดสรรหน่วยความจำของ CUDA) - docs.pytorch.org
-
PyTorch - การคำนวณความแม่นยำแบบผสมอัตโนมัติ (torch.amp / AMP) - docs.pytorch.org
-
PyTorch - torch.utils.checkpoint - docs.pytorch.org
-
PyTorch - คู่มือการปรับแต่งประสิทธิภาพ - docs.pytorch.org
-
PyTorch - บทช่วยสอนการตัดแต่งกิ่ง - docs.pytorch.org
-
PyTorch - ทำความเข้าใจการใช้งานหน่วยความจำ CUDA ใน PyTorch - docs.pytorch.org
-
PyTorch - บทช่วยสอน/ภาพรวม torch.compile - docs.pytorch.org
-
ONNX Runtime - เอกสารประกอบการใช้งาน ONNX Runtime - onnxruntime.ai
-
NVIDIA - เอกสารประกอบการใช้งาน TensorRT - docs.nvidia.com
-
NVIDIA - ประเภทข้อมูลแบบควอนไทซ์ของ TensorRT - docs.nvidia.com
-
NVIDIA - Nsight Systems - developer.nvidia.com
-
NVIDIA - Triton Inference Server - การจัดกลุ่มข้อมูลแบบไดนามิก - docs.nvidia.com
-
DeepSpeed - ZeRO Stage 3 - deepspeed.readthedocs.io
-
bitsandbytes (bitsandbytes-foundation) - bitsandbytes - github.com
-
Hugging Face - Accelerate: คู่มือการสะสมค่า Gradient - huggingface.co
-
Hugging Face - เอกสารประกอบการใช้งาน Tokenizers - huggingface.co
-
Hugging Face - Transformers: คู่มือ PEFT - huggingface.co
-
Hugging Face - Transformers: คำอธิบายแคช KV - huggingface.co
-
Hugging Face - Transformers: ตัวแยกคำแบบ "เร็ว" (คลาสตัวแยกคำ) - huggingface.co
-
arXiv - การกลั่นกรองความรู้ในโครงข่ายประสาทเทียม (Hinton et al., 2015) - arxiv.org
-
arXiv - LoRA: การปรับตัวของแบบจำลองภาษาขนาดใหญ่ด้วยอันดับต่ำ - arxiv.org
-
arXiv - FlashAttention: กลไกการให้ความสนใจที่แม่นยำ รวดเร็ว และประหยัดหน่วยความจำ พร้อมการรับรู้การรับส่งข้อมูล - arxiv.org