โมดูล 5/5 · สัปดาห์ 13–15 · 27 ชม.

ประเมินโมเดลและ edge

UAT 306 ปัญญาประดิษฐ์สำหรับระบบอากาศยานไร้คนขับ

เวลาเรียนประมาณ 85 นาทีร่าง รอตรวจปรับปรุงล่าสุด 28 กันยายน 2569

บทเรียน

เมื่อเรียนจบโมดูลนี้ ผู้เรียนจะสามารถ

  1. วัดเวลาประมวลผลอย่างถูกหลัก แยกช่วงอุ่นเครื่องและรายงานเปอร์เซ็นไทล์
  2. แยกเวลาของโมเดลออกจากเวลาตั้งแต่รับภาพถึงได้ผล
  3. อธิบายการลดความแม่นของตัวเลขเป็น INT8 และผลต่อขนาดและความคลาดเคลื่อน
  4. วางแผนนำโมเดลไปใช้บนคอมพิวเตอร์บนลำ พร้อมเกณฑ์ยอมรับ

ความรู้พื้นฐานที่ควรมี: UAT 306 โมดูล 1–4 · UAT 315 โมดูล 5 (AI ในงานจริง)

ทำไมต้องรู้

โมเดลที่แม่นบน PC อาจช้าเกินไปบนคอมพิวเตอร์บนลำ หรือหนักเกินกว่าหน่วยความจำจะรับได้ หน่วยความรู้เรื่อง benchmark และแผนใช้งาน edge ของคลังความรู้โดรนย้ำว่าเวลารัน inference เฉพาะโมเดลกับเวลาตั้งแต่รับภาพถึงได้ผลเป็นคนละตัวชี้วัด ต้องระบุส่วนที่จับเวลา การอุ่นเครื่อง จำนวนรอบ เครื่อง runtime และขนาดภาพ และค่า p95 บอกว่าร้อยละ 95 ของตัวอย่างเสร็จภายในเวลานั้น UAT 315 คำนวณระยะที่โดรนเคลื่อนระหว่างประมวลผลแล้ว โมดูลนี้เน้นวิธีวัดและการทำให้โมเดลเล็กลง

วัดเวลาให้ถูก

ครั้งแรก ๆ ที่รันโมเดลมักช้ากว่าปกติมาก เพราะต้องโหลดน้ำหนัก จัดสรรหน่วยความจำ และคอมไพล์ จึงต้องทิ้งช่วง อุ่นเครื่อง (warm-up) ก่อนวัด และรายงาน เปอร์เซ็นไทล์ ไม่ใช่ค่าเฉลี่ยอย่างเดียว เพราะระบบบนโดรนต้องรับมือกับกรณีช้า กฎของ MLPerf Inference ใช้เปอร์เซ็นไทล์ของเวลาหน่วงในการรายงานผลของบางสถานการณ์ เช่น สถานการณ์ single stream ใช้เปอร์เซ็นไทล์ที่ 90 และ multistream ใช้เปอร์เซ็นไทล์ที่ 99

ตัวอย่างที่ 1 ผลของการรวมช่วงอุ่นเครื่อง

เวลาประมวลผล 205 ครั้งบนคอมพิวเตอร์บนลำ ห้าครั้งแรกคือช่วงอุ่นเครื่อง (ข้อมูลจำลอง หน่วยมิลลิวินาที)

import numpy as np

rng = np.random.default_rng(9)
lat = np.r_[rng.normal(180, 20, 5), rng.gamma(20, 1.6, 200) + 10]    # ms
WARMUP = 5
print("first runs:", np.round(lat[:WARMUP]).astype(int))
for name, x in (("including warm-up", lat), ("after warm-up", lat[WARMUP:])):
    p50, p95 = np.percentile(x, [50, 95])
    print(f"{name:<18} n={len(x)}: mean {x.mean():5.1f}, p50 {p50:5.1f}, p95 {p95:5.1f}, max {x.max():6.1f} ms")
p95 = np.percentile(lat[WARMUP:], 95)
print(f"frame rate the model can sustain for 95% of frames: {1000 / p95:.1f} fps")
first runs: [164 185 147 193 203]
including warm-up  n=205: mean  46.1, p50  43.0, p95  59.3, max  202.9 ms
after warm-up      n=200: mean  42.8, p50  42.8, p95  56.4, max   63.4 ms
frame rate the model can sustain for 95% of frames: 17.7 fps

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

กราฟเวลาประมวลผลแต่ละครั้ง 205 ครั้ง ห้าจุดแรกสีชมพูสูงราว 150 ถึง 200 มิลลิวินาที จุดที่เหลือสีฟ้าอยู่ราว 30 ถึง 60 มิลลิวินาที เส้นประสีทองที่ค่า p95 หลังอุ่นเครื่อง
ภาพที่ 1 เวลาประมวลผลแต่ละครั้งและช่วงอุ่นเครื่อง

ลดขนาดโมเดลด้วย INT8

การ quantization แทนน้ำหนักทศนิยม 32 บิตด้วยจำนวนเต็ม 8 บิต Jacob และคณะ (2018) ใช้ความสัมพันธ์ ระหว่างค่าจริง ค่าจำนวนเต็ม ตัวคูณสเกล และจุดศูนย์ แบบสมมาตรใช้ เอกสาร ONNX Runtime อธิบายทั้งแบบสมมาตรและไม่สมมาตร และแบบต่อเทนเซอร์หรือต่อช่อง ขนาดลดลงราวสี่เท่า และฮาร์ดแวร์หลายชนิดคำนวณ INT8 ได้เร็วกว่า แต่ถ้ามีค่าผิดปกติขนาดใหญ่ ตัวคูณสเกลจะหยาบ ค่าส่วนใหญ่จะคลาดเคลื่อนมากขึ้น

ตัวอย่างที่ 2 ค่าผิดปกติหนึ่งค่ากับความคลาดเคลื่อนของ INT8

น้ำหนัก 10,000 ค่าจากการแจกแจงปกติ มีค่าผิดปกติหนึ่งค่าเท่ากับ 0.6 เทียบการใช้ค่าสูงสุดจริงกับการตัดค่าที่ ±0.2 ก่อนหาตัวคูณสเกล

import numpy as np

rng = np.random.default_rng(1)
w = rng.normal(0, 0.05, 10000)
w[0] = 0.6                                      # ค่าผิดปกติ
for name, src in (("scale from max |w|", w), ("clip at +/-0.2 first", np.clip(w, -0.2, 0.2))):
    s = np.abs(src).max() / 127
    q = np.clip(np.round(src / s), -127, 127)
    err = q * s - w
    print(f"{name:<22} scale {s:.5f}: mean |error| {np.abs(err[1:]).mean() * 1e3:.3f}e-3, "
          f"outlier error {abs(err[0]):.3f}")
print(f"size: float32 {w.size * 4 / 1024:.1f} KiB -> int8 {w.size / 1024:.1f} KiB")
scale from max |w|     scale 0.00472: mean |error| 1.186e-3, outlier error 0.000
clip at +/-0.2 first   scale 0.00157: mean |error| 0.392e-3, outlier error 0.400
size: float32 39.1 KiB -> int8 9.8 KiB

เมื่อใช้ค่าสูงสุดจริง ความคลาดเคลื่อนของน้ำหนักส่วนใหญ่มากกว่าเมื่อตัดค่าก่อนราวสามเท่า แต่การตัดค่าทำให้ค่าผิดปกติผิดไปมาก ไม่มีคำตอบเดียว ต้องประเมินความแม่นของโมเดลหลัง quantization บนชุดตรวจสอบเสมอ และตั้งเกณฑ์ยอมรับ เช่น AP ลดลงไม่เกินค่าที่ตกลงไว้

แผนภูมิแท่งสองกลุ่ม กลุ่มแรกความคลาดเคลื่อนเฉลี่ยของน้ำหนักส่วนใหญ่ ใช้ค่าสูงสุดจริงสูงกว่าตัดค่าก่อน กลุ่มที่สองความคลาดเคลื่อนของค่าผิดปกติ ตัดค่าก่อนสูงกว่ามาก
ภาพที่ 2 ความคลาดเคลื่อนของ INT8 สองวิธีหาตัวคูณสเกล

แผนใช้งานบนโดรน

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

ปฏิบัติการประจำโมดูล

ปฏิบัติการ: benchmark และลดขนาดโมเดล

  1. วัดเวลาประมวลผลของโมเดลจากโมดูล 4 บน PC และบนคอมพิวเตอร์บนลำ อย่างน้อย 200 ครั้งหลังอุ่นเครื่อง
  2. รายงาน p50 p95 และค่าสูงสุดด้วยตัวอย่างที่ 1 พร้อมระบุเครื่อง runtime และขนาดภาพ
  3. วัดเวลาทั้งระบบตั้งแต่รับภาพจากกล้องถึงได้ผล เทียบกับเวลาของโมเดล
  4. ส่งออกโมเดลเป็น ONNX แล้วทำ quantization แบบ INT8 เทียบขนาด เวลา และ AP
  5. เขียนแผนใช้งานบนโดรนพร้อมเกณฑ์ยอมรับ

ข้อผิดพลาดที่พบบ่อย

ระวัง

  • รวมช่วงอุ่นเครื่องในการวัด
  • รายงานแต่ค่าเฉลี่ย โดยไม่มีเปอร์เซ็นไทล์
  • วัดแต่เวลาของโมเดล แล้วอ้างว่าเป็นเวลาทั้งระบบ
  • ทำ quantization แล้วไม่ประเมินความแม่นใหม่
  • ไม่ระบุเครื่อง runtime และขนาดภาพ จนเทียบผลไม่ได้

สรุป

  • ทิ้งช่วงอุ่นเครื่อง รายงาน p50 p95 และค่าสูงสุด พร้อมเงื่อนไขการวัด
  • เวลาของโมเดลกับเวลาทั้งระบบเป็นคนละตัวชี้วัด
  • INT8 ลดขนาดราวสี่เท่า แต่ค่าผิดปกติทำให้ตัวคูณสเกลหยาบ ต้องประเมินความแม่นใหม่เสมอ
  • แผนใช้งานบนโดรนต้องมีเกณฑ์เวลา ความแม่น พลังงาน และการรับมือเมื่อประมวลผลไม่ทัน

แบบฝึกตรวจความเข้าใจ

  1. p95 เท่ากับ 50 ms รองรับอัตราเฟรมได้ประมาณเท่าใดสำหรับ 95% ของเฟรม
  2. น้ำหนัก 1 ล้านค่า float32 ใช้หน่วยความจำเท่าใด และ INT8 เท่าใด
  3. ค่าสูงสุดสัมบูรณ์ 1.27 ตัวคูณสเกลแบบสมมาตรเท่าใด
  4. ทำไมไม่ควรรวมช่วงอุ่นเครื่อง
  5. ทำไมต้องวัดเวลาทั้งระบบนอกจากเวลาของโมเดล
เฉลย
  1. fps
  2. ราว 4 MB และ 1 MB
  3. ช่วงแรกช้าผิดปกติจากการโหลดและจัดสรร ทำให้ค่าเฉลี่ยและค่าสูงสุดเพี้ยน
  4. การอ่านภาพ ปรับขนาด และส่งผลออกก็ใช้เวลา ซึ่งอาจมากกว่าเวลาของโมเดล

สรุปสูตรสำคัญ

การลดความแม่นแบบสมมาตร
อัตราเฟรมสูงสุดที่รับได้

แหล่งอ้างอิงหลัก

  1. Jacob, B., Kligys, S., Chen, B., Zhu, M., Tang, M., Howard, A., Adam, H., & Kalenichenko, D. (2018). Quantization and training of neural networks for efficient integer-arithmetic-only inference. In 2018 IEEE/CVF Conference on Computer Vision and Pattern Recognition (pp. 2704–2713). link
  2. Microsoft. Quantize ONNX models. ONNX Runtime documentation. link
  3. MLCommons. MLPerf inference rules. link
  4. Prince, S. J. D. (2023). Understanding deep learning. MIT Press. link

อ่านเพิ่มเติม

ศึกษาหน่วยความรู้ที่กำหนดล่วงหน้า ดูสื่อประกอบ และทำ quiz ประจำโมดูล

ในชั้นเรียน / ภาคสนาม

ปฏิบัติการในห้องแล็บหรือภาคสนามตามใบงาน พร้อม checklist ความปลอดภัย

หลักฐานการเรียนรู้: ใบงานที่ผ่านการตรวจและผล quiz

แบบทดสอบประจำโมดูล

แบบทดสอบนี้ใช้ตรวจความเข้าใจ (formative) ไม่ใช่การสอบเก็บคะแนน

โดเมนความรู้: ปัญญาประดิษฐ์และคอมพิวเตอร์วิทัศน์