ตัวแทน LiteRT

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

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

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

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

รันไทม์ที่มีการมอบสิทธิ์

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

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

ผู้รับมอบสิทธิ์ตามแพลตฟอร์ม

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

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

iOS

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

ผู้รับมอบสิทธิ์ตามประเภทโมเดล

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

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

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

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

LiteRT มีเครื่องมือ 2 ประเภทเพื่อวัดความแม่นยำของลักษณะการทำงานของตัวแทนสำหรับโมเดลที่กำหนด ได้แก่ อิงตามงานและไม่ขึ้นกับงาน เครื่องมือทั้งหมดที่อธิบายไว้ในส่วนนี้รองรับพารามิเตอร์การมอบสิทธิ์ขั้นสูง ที่ใช้โดยเครื่องมือเปรียบเทียบจากส่วนก่อนหน้า โปรดทราบว่าส่วนย่อยด้านล่างนี้มุ่งเน้นไปที่การประเมินตัวแทน (ตัวแทนทำงานเหมือนกับ 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

การประเมินที่ไม่ขึ้นอยู่กับงาน

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

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

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

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

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

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 จะแตกต่างจากเอาต์พุตของ Delegate โดยเฉลี่ย 1.96e-05

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