ตัวแทน LiteRT

ผู้รับมอบสิทธิ์จะเปิดใช้การเร่งฮาร์ดแวร์ของโมเดล LiteRT ได้ ใช้ประโยชน์จาก Accelerator ในอุปกรณ์ เช่น GPU และหน่วยประมวลผลสัญญาณดิจิทัล (DSP).

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

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

Accelerator ต่อไปนี้แต่ละรายการมี API ที่เชื่อมโยง ที่เปิดใช้การคำนวณที่กำหนดเอง เช่น OpenCL หรือ OpenGL ES สำหรับ GPU บนอุปกรณ์เคลื่อนที่ โดยปกติคุณจะมี เขียนโค้ดที่กำหนดเองจำนวนมากเพื่อเรียกใช้โครงข่ายระบบประสาทเทียมผ่านอินเทอร์เฟซเหล่านี้ สิ่งต่างๆ จะซับซ้อนยิ่งขึ้นไปอีกเมื่อคุณพิจารณาว่า Accelerator แต่ละตัวมี ข้อดีและ และจะดำเนินการทั้งหมดในโครงข่ายประสาทไม่ได้ TensorFlow Delegate API ของ Lite ช่วยแก้ปัญหานี้โดยทำหน้าที่เป็นสะพานเชื่อมระหว่าง TFLite และ API ระดับต่ำลงมาเหล่านี้

รันไทม์กับผู้ที่ได้รับมอบสิทธิ์

การเลือกผู้รับมอบสิทธิ์

LiteRT สนับสนุนผู้ที่ได้รับมอบสิทธิ์หลายคน ซึ่งแต่ละคนได้รับการปรับให้เหมาะสมสำหรับ บางแพลตฟอร์มและโมเดลบางประเภท โดยปกติแล้วจะมี ผู้รับมอบสิทธิ์หลายคนที่เกี่ยวข้องกับกรณีการใช้งานของคุณ ขึ้นอยู่กับเกณฑ์สำคัญ 2 ประการดังนี้ แพลตฟอร์ม (Android หรือ iOS) ที่กำหนดเป้าหมาย และประเภทโมเดล (จุดลอยตัวหรือจำนวนที่ลอยอยู่) ที่คุณต้องการเร่งความเร็ว

การมอบสิทธิ์ตามแพลตฟอร์ม

ข้ามแพลตฟอร์ม (Android และ iOS)

  • ผู้รับมอบสิทธิ์ GPU - ตัวแทนของ GPU สามารถใช้ได้ทั้งบน Android และ iOS ทั้งนี้ ได้รับการเพิ่มประสิทธิภาพเพื่อเรียกใช้โมเดลแบบ Float 32 บิตและ 16 บิตที่ GPU พร้อมใช้งาน ทั้งยังรองรับโมเดลที่ควอนซ์แบบ 8 บิตและมี GPU ประสิทธิภาพที่เทียบเท่ากับเวอร์ชันลอยตัว สำหรับรายละเอียดเกี่ยวกับ GPU โปรดดู LiteRT ใน GPU

iOS

  • ผู้รับมอบสิทธิ์ Core ML สำหรับ iPhone และ iPad รุ่นใหม่ๆ - สำหรับ iPhone และ iPad รุ่นใหม่ๆ iPad ที่มี Neural Engine คุณสามารถใช้การมอบสิทธิ์ Core ML เพื่อ เร่งการอนุมานสำหรับโมเดลจุดลอยตัว 32 บิตหรือ 16 บิต Neural เครื่องมือค้นหาพร้อมใช้งานสำหรับอุปกรณ์เคลื่อนที่ Apple ที่ใช้ A12 SoC ขึ้นไป สำหรับ ภาพรวมของผู้รับมอบสิทธิ์ Core ML และคำแนะนำทีละขั้นตอน โปรดดู ผู้แทน LiteRT Core ML

การมอบสิทธิ์ตามประเภทโมเดล

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

ประเภทโมเดล GPU CoreML
จุดลอยตัว (32 บิต) ใช่ ใช่
การวัดปริมาณ Float 16 หลังการฝึก ใช่ ใช่
การวัดช่วงไดนามิกหลังการฝึก ใช่ ไม่ได้
การวัดจำนวนเต็มหลังการฝึก ใช่ ไม่ได้
การฝึกอบรมที่คำนึงถึงปริมาณ ใช่ ไม่ได้

กำลังตรวจสอบประสิทธิภาพ

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

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

เครื่องมือสำหรับการประเมิน

เวลาในการตอบสนองและ หน่วยความจำที่ใช้

เครื่องมือเปรียบเทียบของ LiteRT สามารถใช้กับ ที่เหมาะสมในการประมาณประสิทธิภาพของโมเดล ซึ่งรวมถึงการอนุมานโดยเฉลี่ย เวลาในการตอบสนอง โอเวอร์เฮดการเริ่มต้น การใช้หน่วยความจำ ฯลฯ เครื่องมือนี้สนับสนุน แฟล็กหลายรายการเพื่อหาการกำหนดค่าการมอบสิทธิ์ที่ดีที่สุดสำหรับโมเดลของคุณ สำหรับ สามารถระบุอินสแตนซ์ --gpu_backend=gl ด้วย --use_gpu เพื่อวัด GPU ด้วย OpenGL รายการพารามิเตอร์การมอบสิทธิ์ที่รองรับทั้งหมด ระบุไว้ในรายละเอียด เอกสารประกอบ

ตัวอย่างการเรียกใช้โมเดลที่ควอนไตซ์ที่มี GPU ผ่าน adb มีดังนี้

adb shell /data/local/tmp/benchmark_model \
  --graph=/data/local/tmp/mobilenet_v1_224_quant.tflite \
  --use_gpu=true

คุณสามารถดาวน์โหลดเครื่องมือนี้ในเวอร์ชันที่สร้างไว้ล่วงหน้าสำหรับ Android, ARM 64 บิตได้ สถาปัตยกรรม ที่นี่ (เพิ่มเติม รายละเอียด)

ความถูกต้องและ ความถูกต้อง

ผู้รับมอบสิทธิ์มักจะประมวลผลที่ความแม่นยำต่างจาก CPU ของตน ทั้ง 2 ส่วน ดังนั้นจึงมีข้อดีข้อเสียด้านความแม่นยำ (เล็กน้อย) เกิดขึ้น ที่เกี่ยวข้องกับการใช้ผู้รับมอบสิทธิ์สำหรับการเร่งฮาร์ดแวร์ โปรดทราบว่า ไม่เป็นจริงเสมอ ตัวอย่างเช่น เนื่องจาก GPU ใช้ความแม่นยำของจุดลอยตัวเพื่อ เรียกใช้โมเดลที่เล็กลง ความแม่นยำมากขึ้นเล็กน้อย (เช่น <1% คือการปรับปรุงสูงสุด 5 อันดับแรกในการจัดประเภทรูปภาพ ILSVRC)

LiteRT มีเครื่องมือ 2 ประเภทเพื่อวัดว่าผู้ได้รับมอบสิทธิ์มีความถูกต้องแม่นยำเพียงใด ลักษณะการทำงานของโมเดลหนึ่งๆ ได้แก่ Task-Based และ Task-Agnostic เครื่องมือทั้งหมด ซึ่งอธิบายไว้ในส่วนนี้จะสนับสนุนการมอบสิทธิ์ขั้นสูง พารามิเตอร์ ที่ใช้โดยเครื่องมือการเปรียบเทียบจากส่วนก่อนหน้า โปรดทราบว่า ส่วนย่อยด้านล่างเน้นที่การประเมินที่ได้รับมอบหมาย (ผู้รับมอบสิทธิ์ได้ดำเนินการ เดียวกันกับ CPU หรือไม่) แทนที่จะเป็นการประเมินโมเดล (ตัวโมเดลเองมีประสิทธิภาพดีสำหรับ คืออะไร)

การประเมินตามงาน

LiteRT มีเครื่องมือในการประเมินความถูกต้องสำหรับงาน 2 อย่างที่ใช้รูปภาพ ดังนี้

ไบนารีที่สร้างไว้ล่วงหน้าของเครื่องมือเหล่านี้ (Android, สถาปัตยกรรม ARM 64 บิต) รวมถึง ดูเอกสารประกอบได้ที่นี่

ตัวอย่างด้านล่างแสดงให้เห็นการจัดประเภทรูปภาพ การประเมินผล ด้วย GPU ใน Pixel 4

adb shell /data/local/tmp/run_eval \
  --model_file=/data/local/tmp/mobilenet_quant_v1_224.tflite \
  --ground_truth_images_path=/data/local/tmp/ilsvrc_images \
  --ground_truth_labels=/data/local/tmp/ilsvrc_validation_labels.txt \
  --model_output_labels=/data/local/tmp/model_output_labels.txt \
  --output_file_path=/data/local/tmp/accuracy_output.txt \
  --num_images=0 # Run on all images. \
  --use_gpu=true

ผลลัพธ์ที่คาดไว้คือรายการเมตริก Top-K ตั้งแต่ 1 ถึง 10 ดังนี้

Top-1 Accuracy: 0.733333
Top-2 Accuracy: 0.826667
Top-3 Accuracy: 0.856667
Top-4 Accuracy: 0.87
Top-5 Accuracy: 0.89
Top-6 Accuracy: 0.903333
Top-7 Accuracy: 0.906667
Top-8 Accuracy: 0.913333
Top-9 Accuracy: 0.92
Top-10 Accuracy: 0.923333

การประเมินความรู้ด้านงาน (Task-Agnostic Evaluation)

สําหรับงานที่ไม่มีเครื่องมือประเมินผลในอุปกรณ์ หรือหากคุณ กำลังทดสอบโมเดลที่กำหนดเอง LiteRT มีฟังก์ชันการอนุมาน ความแตกต่าง ของ Google (Android, ไบนารีสถาปัตยกรรมไบนารีของ ARM 64 บิต ที่นี่)

อนุมาน Diff เปรียบเทียบการดำเนินการ LiteRT (ในแง่ของเวลาในการตอบสนองและ ส่วนเบี่ยงเบนของค่าเอาต์พุต) ในการตั้งค่า 2 แบบ

ในการดำเนินการดังกล่าว เครื่องมือจะสร้างข้อมูลเกาส์เชียนแบบสุ่มและส่งผ่านสองข้อมูล ล่าม TFLite - ตัวหนึ่งใช้เคอร์เนล CPU แบบเธร็ดเดี่ยว และอีกตัวหนึ่งกำลังเรียกใช้เคอร์เนลของ CPU แบบเดี่ยว โดยใช้พารามิเตอร์โดยอาร์กิวเมนต์ของผู้ใช้

โดยจะวัดเวลาในการตอบสนองของทั้ง 2 อย่าง รวมถึงความแตกต่างสัมบูรณ์ระหว่าง Tensor เอาต์พุตจากล่ามแต่ละตัว ตามองค์ประกอบ

สำหรับโมเดลที่มี Tensor เอาต์พุตเดียว เอาต์พุตอาจมีลักษณะดังนี้

Num evaluation runs: 50
Reference run latency: avg=84364.2(us), std_dev=12525(us)
Test run latency: avg=7281.64(us), std_dev=2089(us)
OutputDiff[0]: avg_error=1.96277e-05, std_dev=6.95767e-06

ซึ่งหมายความว่าสำหรับ Tensor เอาต์พุตที่ดัชนี 0 องค์ประกอบจาก เอาต์พุตของ CPU แตกต่างจากเอาต์พุตที่มอบสิทธิ์โดยเฉลี่ย 1.96e-05

โปรดทราบว่าการตีความตัวเลขเหล่านี้ต้องอาศัยความรู้ที่ลึกซึ้งยิ่งขึ้นเกี่ยวกับโมเดลและ ความหมายของ Tensor แต่ละเอาต์พุต ถ้าเป็นการถดถอยง่ายๆ ที่ ประเภทคะแนนหรือการฝัง ความแตกต่างควรต่ำ (มิเช่นนั้นเป็น ข้อผิดพลาดกับผู้ได้รับมอบสิทธิ์) แต่เอาต์พุต เช่น "คลาสการตรวจสอบ" รายการหนึ่งจาก โมเดล SSD จะตีความได้ยากกว่า เช่น อาจแสดง ความแตกต่างเมื่อใช้เครื่องมือนี้ แต่ก็อาจไม่ได้หมายความว่ามีอะไรผิดปกติกับ ผู้รับมอบสิทธิ์: พิจารณาชั้นเรียน (ปลอม): "ทีวี (รหัส: 10)", "ตรวจสอบ (รหัส:20)" - ถ้า ผู้ได้รับมอบสิทธิ์ดูไม่เป็นความจริงเล็กน้อย และแสดงออกผ่านหน้าจอทีวี ความแตกต่างของเอาต์พุตสำหรับ tensor นี้อาจสูงแค่ 20-10 = 10