วิธีการเพิ่มประสิทธิภาพโมเดล AI

วิธีการเพิ่มประสิทธิภาพโมเดล AI

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

ประเด็นสำคัญ:

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

การวัดผล : ทดสอบประสิทธิภาพการทำงานจริงด้วยค่า p50/p95/p99, อัตราการประมวลผล, การใช้ทรัพยากร และค่าสูงสุดของหน่วยความจำ

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

การให้บริการ : ใช้การแคช การจัดกลุ่มข้อมูลอย่างรอบคอบ การปรับแต่งการทำงานพร้อมกัน และคอยตรวจสอบความหน่วงเวลาอย่างใกล้ชิด

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

อินโฟกราฟิกวิธีการเพิ่มประสิทธิภาพโมเดล AI

🔗 วิธีการประเมินโมเดล AI อย่างมีประสิทธิภาพ
เกณฑ์สำคัญและขั้นตอนในการตัดสินโมเดลอย่างยุติธรรมและน่าเชื่อถือ

🔗 วิธีวัดประสิทธิภาพ AI ด้วยตัวชี้วัดที่แท้จริง
ใช้เกณฑ์มาตรฐาน ความหน่วง ต้นทุน และสัญญาณคุณภาพเพื่อเปรียบเทียบ

🔗 วิธีทดสอบโมเดล AI ก่อนนำไปใช้
งานจริง ขั้นตอนการทดสอบเชิงปฏิบัติ: การแบ่งข้อมูล กรณีทดสอบความเครียด และการติดตามผล

🔗 วิธีใช้ AI ในการสร้างเนื้อหา
เปลี่ยนไอเดียให้เป็นร่างได้เร็วขึ้นด้วยคำแนะนำที่เป็นระบบและการปรับปรุงอย่างต่อเนื่อง

1) ความหมายของคำว่า “ปรับให้เหมาะสมที่สุด” ในทางปฏิบัติ (เพราะแต่ละคนใช้ในความหมายที่แตกต่างกัน) 🧠

เมื่อผู้คนพูดว่า "ปรับแต่งโมเดล AI ให้เหมาะสม" พวกเขาอาจหมายถึง:

  • ทำให้เร็วขึ้น (ลดความหน่วง)

  • ทำให้ราคาถูกลง (ใช้เวลาประมวลผล GPU น้อยลง ค่าใช้จ่ายด้านคลาวด์ลดลง)

  • ทำให้มีขนาดเล็ลง (ใช้หน่วยความจำน้อยลง, การติดตั้งใช้งานบนอุปกรณ์ปลายทาง)

  • ทำให้มีความแม่นยำมากขึ้น (ปรับปรุงคุณภาพ ลดภาพหลอน)

  • ทำให้มีความเสถียรมากขึ้น (ความผันผวนน้อยลง ความล้มเหลวในการผลิตน้อยลง)

  • ทำให้การให้บริการง่ายขึ้น (ปริมาณงาน การจัดกลุ่ม การทำงานที่คาดการณ์ได้)

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

ดังนั้นก่อนที่จะลงมือทำอะไรก็ตาม ให้เลือก ข้อจำกัดหลัก :

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) การปรับแต่งคอมไพเลอร์และกราฟ: ที่มาของความเร็ว 🏎️

นี่คือเลเยอร์ "ทำให้คอมพิวเตอร์ทำงานได้อย่างชาญฉลาดขึ้น".

เทคนิคทั่วไป:

พูดให้เข้าใจง่ายๆ ก็คือ โมเดลของคุณอาจคำนวณเร็ว แต่ใช้งานจริงช้า คอมไพเลอร์ช่วยแก้ไขปัญหาส่วนนี้ได้.

บันทึกย่อเชิงปฏิบัติ (หรือเรียกอีกอย่างว่า รอยแผลเป็น)

  • การปรับแต่งเหล่านี้อาจมีความอ่อนไหวต่อการเปลี่ยนแปลงรูปร่างของแบบจำลอง.

  • บางรุ่นเร่งความเร็วขึ้นมาก บางรุ่นแทบไม่ขยับเลย.

  • บางครั้งคุณอาจเจอปัญหาความเร็วเพิ่มขึ้นและบั๊กแปลกๆ เหมือนมีภูตจิ๋วเข้ามาสิงอยู่ในเกม 🧌

อย่างไรก็ตาม เมื่อมันได้ผล มันก็เป็นหนึ่งในชัยชนะที่ใสสะอาดที่สุด.

8) การลดขนาด การตัดแต่ง การกลั่นกรอง: ลดขนาดลงโดยไม่ต้องร้องไห้ (มากเกินไป) 🪓📉

นี่คือส่วนที่ผู้คนต้องการ...เพราะมันฟังดูเหมือนเป็นการแสดงฟรี มันอาจเป็นเช่นนั้นได้ แต่คุณต้องปฏิบัติต่อมันเหมือนกับการผ่าตัด.

การหาปริมาณ (ค่าถ่วงน้ำหนัก/ค่ากระตุ้นที่มีความแม่นยำต่ำกว่า)

  • เหมาะอย่างยิ่งสำหรับความเร็วในการประมวลผลและหน่วยความจำ

  • ความเสี่ยง: คุณภาพลดลง โดยเฉพาะในกรณีพิเศษ

  • แนวทางปฏิบัติที่ดีที่สุด: ประเมินผลจากชุดข้อมูลทดสอบจริง ไม่ใช่จากความรู้สึกหรือความรู้สึก

รสชาติทั่วไปที่คุณจะได้ยิน:

การตัดแต่ง (ลบพารามิเตอร์)

  • ลบน้ำหนักหรือโครงสร้างที่ไม่สำคัญออก ( ตัวอย่างการตัดแต่งใน PyTorch )

  • โดยปกติแล้วจำเป็นต้องมีการฝึกอบรมใหม่เพื่อฟื้นฟูคุณภาพ

  • ได้ผลดีกว่าที่หลายคนคิด...หากทำอย่างระมัดระวัง

การกลั่น (นักเรียนเรียนรู้จากครู)

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

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

9) การเสิร์ฟและการอนุมาน: สมรภูมิรบที่แท้จริง 🧯

คุณสามารถ "ปรับแต่ง" โมเดลให้เหมาะสมที่สุดได้ แต่การให้บริการก็ยังคงไม่ดีเท่าที่ควร การให้บริการนี่แหละคือจุดที่ความหน่วงและต้นทุนจะส่งผลอย่างแท้จริง.

การเสิร์ฟคือชัยชนะที่สำคัญ

  • การประมวลผลแบบกลุ่ม
    ช่วยเพิ่มประสิทธิภาพการทำงาน แต่จะเพิ่มความหน่วงหากใช้มากเกินไป จึงควรปรับสมดุล ( การประมวลผลแบบกลุ่มแบบไดนามิกของ Triton )

  • การ
    แคชข้อความแจ้งเตือนและการนำแคช KV กลับมาใช้ซ้ำนั้นมีประโยชน์อย่างมากสำหรับบริบทที่ใช้ซ้ำ ( คำอธิบายแคช KV )

  • การสตรีมเอาต์พุต
    ผู้ใช้รู้สึกว่าเร็วกว่าแม้ว่าเวลารวมจะใกล้เคียงกันก็ตาม การรับรู้เป็นสิ่งสำคัญ 🙂

  • ลดภาระงานเพิ่มเติมทีละโทเค็น
    บางระบบประมวลผลข้อมูลเพิ่มเติมต่อโทเค็น การลดภาระงานเพิ่มเติมเหล่านั้นจะนำมาซึ่งผลลัพธ์ที่ดีเยี่ยม

ระวังค่าความหน่วงของหาง (tail latency)

ค่าเฉลี่ยของคุณอาจดูดีมาก ในขณะที่ค่า p99 ของคุณกลับแย่มาก ผู้ใช้งานส่วนใหญ่มักอยู่ในกลุ่มผู้ใช้งานที่มีปัญหา (กลุ่ม ผู้ใช้งานที่มีปัญหา" และเหตุผลที่ค่าเฉลี่ยไม่ )

10) การปรับแต่งโดยคำนึงถึงฮาร์ดแวร์: จับคู่โมเดลกับเครื่อง 🧰🖥️

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

ข้อควรพิจารณาเกี่ยวกับ GPU

  • แบนด์วิดท์ของหน่วยความจำมักเป็นปัจจัยจำกัด ไม่ใช่พลังการประมวลผลดิบ

  • การผลิตในปริมาณมากอาจช่วยได้ จนกว่ามันจะไม่ได้ผลอีกต่อไป

  • การรวมเคอร์เนลและการเพิ่มประสิทธิภาพความสนใจมีความสำคัญอย่างมากสำหรับ Transformer ( FlashAttention: ความสนใจที่แม่นยำซึ่งคำนึงถึง IO )

ข้อควรพิจารณาเกี่ยวกับซีพียู

  • การใช้มัลติเธรด การประมวลผลแบบเวกเตอร์ และการเข้าถึงหน่วยความจำอย่างมีประสิทธิภาพ ล้วนมีความสำคัญอย่างมาก

  • ค่าใช้จ่ายในการแปลงโทเค็นอาจเป็นปัจจัยหลัก ( 🤗 ตัวแปลงโทเค็นที่ "เร็ว" )

  • คุณอาจต้องใช้กลยุทธ์การควอนไทเซชันที่แตกต่างไปจากที่ใช้กับ GPU

ข้อควรพิจารณาสำหรับอุปกรณ์ Edge / อุปกรณ์พกพา

  • การใช้หน่วยความจำกลายเป็นสิ่งสำคัญอันดับหนึ่ง

  • ความแปรปรวนของเวลาแฝงมีความสำคัญ เพราะอุปกรณ์นั้น… อารมณ์แปรปรวน

  • โมเดลขนาดเล็กที่เน้นการใช้งานเฉพาะทางมักจะเอาชนะโมเดลขนาดใหญ่ที่ใช้งานได้ทั่วไปได้

11) หลักเกณฑ์ด้านคุณภาพ: อย่า "ปรับแต่ง" ตัวเองจนกลายเป็นบั๊ก 🧪

ทุกชัยชนะด้านความเร็วควรมาพร้อมกับการตรวจสอบคุณภาพ มิเช่นนั้นคุณจะฉลอง ส่งสินค้า แล้วก็ได้รับข้อความเช่น “ทำไมผู้ช่วยถึงพูดเหมือนโจรสลัดขึ้นมาทันที?” 🏴☠️

หลักเกณฑ์ปฏิบัติที่เป็นรูปธรรม:

  • คำถามมาตรฐาน (ชุดคำถามคงที่ที่คุณใช้ทดสอบเสมอ)

  • ตัวชี้วัดงาน (ความแม่นยำ, F1, BLEU, หรืออื่นๆ ที่เหมาะสม)

  • การตรวจสอบโดยมนุษย์แบบสุ่ม (ใช่แล้ว จริงๆ นะ)

  • เกณฑ์การถดถอย ("อนุญาตให้ลดลงไม่เกิน X%")

นอกจากนี้ ให้ติดตามรูปแบบความล้มเหลวด้วย:

  • การเลื่อนรูปแบบ

  • การเปลี่ยนแปลงพฤติกรรมการปฏิเสธ

  • ความถี่ของอาการประสาทหลอน

  • การขยายความยาวของการตอบสนอง

การปรับปรุงให้เหมาะสมสามารถเปลี่ยนแปลงพฤติกรรมได้ในรูปแบบที่คาดไม่ถึง แปลกประหลาด น่าหงุดหงิด แต่เมื่อมองย้อนกลับไปแล้ว ก็สามารถคาดเดาได้.

12) รายการตรวจสอบ: วิธีการเพิ่มประสิทธิภาพโมเดล AI ทีละขั้นตอน ✅🤖

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

  1. กำหนดความสำเร็จ
    เลือกตัวชี้วัดหลัก 1-2 ข้อ (ความหน่วง, ต้นทุน, ปริมาณงาน, คุณภาพ)

  2. วัดค่าพื้นฐาน
    โปรไฟล์ปริมาณงานจริง บันทึกค่า p50/p95 หน่วยความจำ และต้นทุน (โดยใช้ PyTorch Profiler )

  3. แก้ไขปัญหาคอขวดในกระบวนการทำงาน
    : การโหลดข้อมูล, การแยกคำ, การประมวลผลล่วงหน้า, การประมวลผลแบบกลุ่ม

  4. ใช้ประโยชน์จากการประมวลผลที่มีความเสี่ยงต่ำ
    เช่น ความแม่นยำแบบผสม การเพิ่มประสิทธิภาพเคอร์เนล และการจัดกลุ่มข้อมูลที่ดีขึ้น

  5. ลองใช้การปรับแต่งคอมไพเลอร์/รันไทม์
    เช่น การจับภาพกราฟ รันไทม์การอนุมาน การรวมตัวดำเนินการ ( ดูบทช่วย สอน torch.compile และ เอกสาร ONNX Runtime )

  6. ลดต้นทุนการสร้างแบบจำลอง
    กำหนดปริมาณอย่างระมัดระวัง กลั่นกรองหากทำได้ และตัดแต่งหากเหมาะสม

  7. ปรับแต่ง
    ระบบการแคช การทำงานพร้อมกัน การทดสอบโหลด และแก้ไขปัญหาความหน่วงแฝง

  8. คุณภาพ
    ดำเนินการทดสอบการถดถอย และเปรียบเทียบผลลัพธ์แบบเคียงข้างกัน

  9. ทำซ้ำขั้นตอน
    การเปลี่ยนแปลงเล็กน้อย จดบันทึกอย่างชัดเจน แล้วทำซ้ำไปเรื่อยๆ ไม่โอ้อวด แต่ได้ผล

ใช่แล้ว นี่ก็ยังคงเป็น บทความเรื่อง วิธีการเพิ่มประสิทธิภาพโมเดล AI แม้ว่ามันจะฟังดูเหมือน “วิธีการหยุดเหยียบคราด” มากกว่าก็ตาม เพราะมันก็เหมือนกันนั่นแหละ

13) ข้อผิดพลาดทั่วไป (เพื่อที่คุณจะได้ไม่ทำผิดซ้ำเหมือนคนอื่นๆ) 🙃

  • มุ่งเน้นการปรับปรุงก่อนการวัดผล
    คุณจะเสียเวลา และสุดท้ายคุณก็จะปรับปรุงในสิ่งที่ผิดพลาดอย่างมั่นใจ…

  • การไล่ตามเกณฑ์วัดประสิทธิภาพเพียงอย่างเดียว
    เกณฑ์วัดประสิทธิภาพนั้นหลอกลวงด้วยการละเว้นข้อมูลบางอย่าง ปริมาณงานของคุณต่างหากคือความจริง

  • การละเลยเรื่อง
    หน่วยความจำ ปัญหาเกี่ยวกับหน่วยความจำทำให้เกิดความช้าลง การหยุดทำงาน และการกระตุก ( ทำความเข้าใจการใช้งานหน่วยความจำ CUDA ใน PyTorch )

  • การควอนไทซ์มากเกินไปเร็วเกินไป การ
    ไทซ์แบบบิตต่ำอาจให้ผลลัพธ์ที่น่าทึ่ง แต่ควรเริ่มต้นด้วยขั้นตอนที่ปลอดภัยกว่าก่อน

  • ไม่มีแผนย้อนกลับ
    หากคุณไม่สามารถย้อนกลับได้อย่างรวดเร็ว การติดตั้งแต่ละครั้งจะกลายเป็นเรื่องเครียด ความเครียดก่อให้เกิดข้อผิดพลาด

หมายเหตุปิดท้าย: วิธีการปรับให้เหมาะสมในแบบฉบับมนุษย์ 😌⚡

การเพิ่มประสิทธิภาพโมเดล 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 คุณก็ยังอาจส่งมอบประสบการณ์ที่ "รู้สึกช้าแบบสุ่ม" ได้

เอกสารอ้างอิง

  1. Amazon Web Services (AWS) - เปอร์เซ็นไทล์ AWS CloudWatch (คำจำกัดความทางสถิติ) - docs.aws.amazon.com

  2. Google - การจัดการความล่าช้าของส่วนท้ายระบบในระดับใหญ่ (แนวทางปฏิบัติที่ดีที่สุดสำหรับความล่าช้าของส่วนท้ายระบบ) - sre.google

  3. Google - Service Level Objectives (SRE Book) - Latency Percentiles - sre.google

  4. PyTorch - torch.compile - docs.pytorch.org

  5. PyTorch - FullyShardedDataParallel (FSDP) - docs.pytorch.org

  6. PyTorch - เครื่องมือสร้างโปรไฟล์ PyTorch - docs.pytorch.org

  7. PyTorch - ความหมายของ CUDA: การจัดการหน่วยความจำ (หมายเหตุเกี่ยวกับตัวจัดสรรหน่วยความจำของ CUDA) - docs.pytorch.org

  8. PyTorch - การคำนวณความแม่นยำแบบผสมอัตโนมัติ (torch.amp / AMP) - docs.pytorch.org

  9. PyTorch - torch.utils.checkpoint - docs.pytorch.org

  10. PyTorch - คู่มือการปรับแต่งประสิทธิภาพ - docs.pytorch.org

  11. PyTorch - บทช่วยสอนการตัดแต่งกิ่ง - docs.pytorch.org

  12. PyTorch - ทำความเข้าใจการใช้งานหน่วยความจำ CUDA ใน PyTorch - docs.pytorch.org

  13. PyTorch - บทช่วยสอน/ภาพรวม torch.compile - docs.pytorch.org

  14. ONNX Runtime - เอกสารประกอบการใช้งาน ONNX Runtime - onnxruntime.ai

  15. NVIDIA - เอกสารประกอบการใช้งาน TensorRT - docs.nvidia.com

  16. NVIDIA - ประเภทข้อมูลแบบควอนไทซ์ของ TensorRT - docs.nvidia.com

  17. NVIDIA - Nsight Systems - developer.nvidia.com

  18. NVIDIA - Triton Inference Server - การจัดกลุ่มข้อมูลแบบไดนามิก - docs.nvidia.com

  19. DeepSpeed ​​- ZeRO Stage 3 - deepspeed.readthedocs.io

  20. bitsandbytes (bitsandbytes-foundation) - bitsandbytes - github.com

  21. Hugging Face - Accelerate: คู่มือการสะสมค่า Gradient - huggingface.co

  22. Hugging Face - เอกสารประกอบการใช้งาน Tokenizers - huggingface.co

  23. Hugging Face - Transformers: คู่มือ PEFT - huggingface.co

  24. Hugging Face - Transformers: คำอธิบายแคช KV - huggingface.co

  25. Hugging Face - Transformers: ตัวแยกคำแบบ "เร็ว" (คลาสตัวแยกคำ) - huggingface.co

  26. arXiv - การกลั่นกรองความรู้ในโครงข่ายประสาทเทียม (Hinton et al., 2015) - arxiv.org

  27. arXiv - LoRA: การปรับตัวของแบบจำลองภาษาขนาดใหญ่ด้วยอันดับต่ำ - arxiv.org

  28. arXiv - FlashAttention: กลไกการให้ความสนใจที่แม่นยำ รวดเร็ว และประหยัดหน่วยความจำ พร้อมการรับรู้การรับส่งข้อมูล - arxiv.org

ค้นหา AI รุ่นล่าสุดได้ที่ร้านค้าผู้ช่วย AI อย่างเป็นทางการ

เกี่ยวกับเรา

กลับไปที่บล็อก