การวัดประสิทธิภาพ

เครื่องมือการเปรียบเทียบ

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

• เวลาในการเริ่มต้น
• เวลาในการอนุมานของสถานะวอร์มอัพ
• เวลาในการอนุมานของสถานะคงที่
• การใช้งานหน่วยความจำระหว่างเวลาเริ่มต้น
• การใช้งานหน่วยความจำโดยรวม

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

แอปเปรียบเทียบ Android

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

แอปเปรียบเทียบของ Android นี้ไม่มี UI ติดตั้งและเรียกใช้โดยใช้ adb และดึงผลลัพธ์โดยใช้คำสั่ง adb logcat

ดาวน์โหลดหรือสร้างแอป

ดาวน์โหลดแอปเปรียบเทียบ Android ที่สร้างไว้ล่วงหน้าทุกคืนโดยใช้ลิงก์ด้านล่างนี้

• android_aarch64
• android_arm

สำหรับแอปเปรียบเทียบของ Android ที่รองรับ TF Ops ผ่านผู้รับมอบสิทธิ์ Flex ใช้ลิงก์ด้านล่าง

• android_aarch64
• android_arm

นอกจากนี้ คุณยังสร้างแอปจากต้นทางได้โดยทำตามขั้นตอนต่อไปนี้ วิธีการ

เตรียมการเปรียบเทียบ

ก่อนที่จะเรียกใช้แอปเปรียบเทียบ ให้ติดตั้งแอปและส่งไฟล์โมเดลไปยัง ดังนี้

adb install -r -d -g android_aarch64_benchmark_model.apk
adb push your_model.tflite /data/local/tmp

เรียกใช้การเปรียบเทียบ

adb shell am start -S \
  -n org.tensorflow.lite.benchmark/.BenchmarkModelActivity \
  --es args '"--graph=/data/local/tmp/your_model.tflite \
              --num_threads=4"'

graph เป็นพารามิเตอร์ที่ต้องระบุ

• graph: string
  เส้นทางไปยังไฟล์โมเดล TFLite

คุณระบุพารามิเตอร์ที่ไม่บังคับเพิ่มเติมสำหรับการเรียกใช้การเปรียบเทียบได้

• num_threads: int (ค่าเริ่มต้น=1)
  จำนวนเทรดที่จะใช้เพื่อเรียกใช้ล่าม TFLite
• use_gpu: bool (ค่าเริ่มต้น=เท็จ)
  ใช้ GPU Delegate
• use_xnnpack: bool (ค่าเริ่มต้น=false)
  ใช้ ผู้ได้รับมอบสิทธิ์ XNNPACK

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

ดูผลลัพธ์โดยใช้คำสั่ง logcat:

adb logcat | grep "Inference timings"

ผลการเปรียบเทียบจะรายงานดังนี้

... tflite  : Inference timings in us: Init: 5685, First inference: 18535, Warmup (avg): 14462.3, Inference (avg): 14575.2

ไบนารีการเปรียบเทียบแบบเนทีฟ

เครื่องมือการเปรียบเทียบมีให้เป็นไบนารีดั้งเดิม benchmark_model คุณสามารถ เรียกใช้เครื่องมือนี้จากบรรทัดคำสั่งเชลล์บน Linux, Mac อุปกรณ์ที่ฝังและ อุปกรณ์ Android

ดาวน์โหลดหรือสร้างไบนารี

ดาวน์โหลดไบนารีของบรรทัดคำสั่งแบบเนทีฟที่สร้างไว้ล่วงหน้าในเวลากลางคืนโดยทำตามขั้นตอนต่อไปนี้ ลิงก์ด้านล่าง

• linux_x86-64
• linux_aarch64
• linux_arm
• android_aarch64
• android_arm

สําหรับไบนารีที่สร้างไว้ล่วงหน้าทุกคืนซึ่งรองรับ TF Ops ผ่านผู้รับมอบสิทธิ์ Flex ใช้ลิงก์ด้านล่าง

• linux_x86-64
• linux_aarch64
• linux_arm
• android_aarch64
• android_arm

นอกจากนี้คุณยังสร้างไบนารีเปรียบเทียบแบบเนทีฟได้จาก แหล่งที่มา บนคอมพิวเตอร์

bazel build -c opt //tensorflow/lite/tools/benchmark:benchmark_model

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

bazel build -c opt --config=android_arm64 \
  //tensorflow/lite/tools/benchmark:benchmark_model

เรียกใช้การเปรียบเทียบ

หากต้องการเรียกใช้การเปรียบเทียบในคอมพิวเตอร์ ให้เรียกใช้ไบนารีจาก Shell

path/to/downloaded_or_built/benchmark_model \
  --graph=your_model.tflite \
  --num_threads=4

คุณสามารถใช้ชุดเดิม พารามิเตอร์ ตามที่กล่าวไว้ข้างต้นด้วยไบนารีบรรทัดคำสั่งแบบเนทีฟ

กำลังทำโปรไฟล์การดำเนินการของโมเดล

นอกจากนี้ ไบนารีโมเดลการเปรียบเทียบยังช่วยให้คุณสร้างโปรไฟล์การดำเนินการของโมเดลและรับ เวลาดำเนินการของโอเปอเรเตอร์แต่ละรายการ ในการดำเนินการดังกล่าว ให้ส่งต่อธง --enable_op_profiling=true ไปยัง benchmark_model ระหว่างการเรียกใช้ รายละเอียดมีดังนี้ อธิบาย ที่นี่

ไบนารีการเปรียบเทียบแบบเนทีฟสำหรับตัวเลือกประสิทธิภาพหลายรายการในการเรียกใช้ครั้งเดียว

นอกจากนี้ยังมีไบนารี C++ ที่ใช้ง่ายและสะดวกให้กับ เปรียบเทียบตัวเลือกประสิทธิภาพหลายรายการ ในการทำงานเพียงครั้งเดียว ไบนารีนี้สร้างขึ้นโดยอิงตามเครื่องมือเปรียบเทียบที่กล่าวไว้ข้างต้น ที่สามารถเปรียบเทียบตัวเลือกประสิทธิภาพครั้งละ 1 รายการเท่านั้น พวกเขาแชร์ กระบวนการสร้าง/ติดตั้ง/เรียกใช้เดียวกัน แต่ชื่อเป้าหมายของ BUILD ของไบนารีนี้คือ benchmark_model_performance_options และต้องมีพารามิเตอร์เพิ่มเติม พารามิเตอร์ที่สำคัญสำหรับไบนารีนี้ ได้แก่

perf_options_list: string (ค่าเริ่มต้น='ทั้งหมด')
รายการตัวเลือกประสิทธิภาพ TFLite ที่คั่นด้วยคอมมาสำหรับการเปรียบเทียบ

คุณสามารถรับไบนารีที่สร้างไว้ล่วงหน้าสำหรับเครื่องมือนี้ทุกคืนตามที่ระบุไว้ด้านล่าง

• linux_x86-64
• linux_aarch64
• linux_arm
• android_aarch64
• android_arm

แอปเปรียบเทียบใน iOS

ในการเรียกใช้การเปรียบเทียบในอุปกรณ์ iOS คุณจะต้องสร้างแอปจาก source วางไฟล์โมเดล LiteRT ใน benchmark_data ของโครงสร้างซอร์สและแก้ไขไฟล์ benchmark_params.json เหล่านั้น ไฟล์รวมอยู่ในแอป และแอปจะอ่านข้อมูลจากไดเรกทอรี ไปที่เว็บไซต์ เวลา แอปเปรียบเทียบใน iOS

การเปรียบเทียบประสิทธิภาพสำหรับโมเดลที่รู้จักกันดี

ส่วนนี้จะแสดงการเปรียบเทียบประสิทธิภาพ LiteRT เมื่อทำงานได้ดี โมเดลที่รู้จักในอุปกรณ์ Android และ iOS บางรุ่น

การเปรียบเทียบประสิทธิภาพของ Android

ตัวเลขเปรียบเทียบประสิทธิภาพเหล่านี้สร้างขึ้นด้วย ไบนารีการเปรียบเทียบแบบเนทีฟ

สำหรับการเปรียบเทียบ Android กลุ่มความสนใจของ CPU ได้รับการตั้งค่าให้ใช้แกนขนาดใหญ่ในอุปกรณ์ เพื่อลดความแปรปรวน (ดู รายละเอียด)

โดยจะถือว่าโมเดลได้รับการดาวน์โหลดและแตกไฟล์ไปยังไฟล์ ไดเรกทอรี /data/local/tmp/tflite_models ไบนารีการเปรียบเทียบสร้างขึ้นโดยใช้ วิธีการเหล่านี้ และถือว่าอยู่ในไดเรกทอรี /data/local/tmp

วิธีเรียกใช้การเปรียบเทียบ

adb shell /data/local/tmp/benchmark_model \
  --num_threads=4 \
  --graph=/data/local/tmp/tflite_models/${GRAPH} \
  --warmup_runs=1 \
  --num_runs=50

หากต้องการเรียกใช้กับผู้รับมอบสิทธิ์ GPU ให้ตั้งค่า --use_gpu=true

ค่าประสิทธิภาพด้านล่างจะวัดใน Android 10

การเปรียบเทียบประสิทธิภาพของ iOS

ตัวเลขเปรียบเทียบประสิทธิภาพเหล่านี้สร้างขึ้นด้วย แอปเปรียบเทียบสำหรับ iOS

ในการเรียกใช้การเปรียบเทียบสำหรับ iOS ได้มีการแก้ไขแอปเปรียบเทียบให้รวม โมเดลและ benchmark_params.json ได้รับการแก้ไขเพื่อตั้งค่า num_threads เป็น 2 หากต้องการใช้งาน ผู้มอบสิทธิ์ GPU, ตัวเลือก "use_gpu" : "1" และ "gpu_wait_type" : "aggressive" ถูกเพิ่มลงใน benchmark_params.json ด้วยเช่นกัน

ติดตาม LiteRT ภายใน

ติดตาม LiteRT ภายในใน Android

เหตุการณ์ภายในจากล่าม LiteRT ของแอป Android อาจเป็นไปได้ ถ่ายโดย เครื่องมือการติดตามของ Android เป็นเหตุการณ์เดียวกันเมื่อใช้ Android Trace API ดังนั้น เหตุการณ์ที่บันทึกจากโค้ด Java/Kotlin จะมองเห็นพร้อมกันด้วย LiteRT เหตุการณ์ภายใน

ตัวอย่างกิจกรรมมีดังนี้

• การเรียกใช้ผู้ให้บริการ
• การแก้ไขกราฟตามผู้รับมอบสิทธิ์
• การจัดสรร Tensor

คู่มือนี้พูดถึงแอป Android ในบรรดาตัวเลือกต่างๆ สำหรับการจับภาพการติดตาม Studio CPU Profiler และแอป System Tracing โปรดดู เครื่องมือบรรทัดคำสั่ง Perfetto หรือ เครื่องมือบรรทัดคำสั่ง Systrace เพื่อดูตัวเลือกอื่น

การเพิ่มเหตุการณ์การติดตามในโค้ด Java

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

  Trace.beginSection("recognizeImage");
  ...
  // Runs the inference call.
  Trace.beginSection("runInference");
  tflite.run(inputImageBuffer.getBuffer(), outputProbabilityBuffer.getBuffer().rewind());
  Trace.endSection();
  ...
  Trace.endSection();

เปิดใช้การติดตาม LiteRT

หากต้องการเปิดใช้การติดตาม LiteRT ให้ตั้งค่าพร็อพเพอร์ตี้ระบบ Android debug.tflite.trace ถึง 1 ก่อนเริ่มแอป Android

adb shell setprop debug.tflite.trace 1

หากตั้งค่าพร็อพเพอร์ตี้นี้เมื่อเริ่มล่าม LiteRT เหตุการณ์สำคัญ (เช่น การเรียกใช้โอเปอเรเตอร์) จากล่ามจะได้รับการติดตาม

หลังจากที่คุณจับภาพการติดตามทั้งหมดแล้ว ให้ปิดใช้การติดตามโดยการตั้งค่าพร็อพเพอร์ตี้ เป็น 0

adb shell setprop debug.tflite.trace 0

เครื่องมือสร้างโปรไฟล์ CPU ของ Android Studio

จับภาพการติดตามด้วย เครื่องมือสร้างโปรไฟล์ CPU ของ Android Studio โดยทำตามขั้นตอนต่อไปนี้

1. เลือกเรียกใช้ > โปรไฟล์ "แอป" จากเมนูด้านบน

2. คลิกที่ใดก็ได้ในไทม์ไลน์ CPU เมื่อหน้าต่างเครื่องมือสร้างโปรไฟล์ปรากฏขึ้น

3. เลือก "ติดตามการเรียกใช้ระบบ" ระหว่างโหมดการกำหนดโปรไฟล์ของ CPU

   

4. กด "บันทึก"

5. กด "หยุด"

6. ตรวจสอบผลลัพธ์การติดตาม

   

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

แอป System Tracing

จับภาพการติดตามโดยไม่ใช้ Android Studio โดยทำตามขั้นตอนโดยละเอียดใน แอป System Tracing

ในตัวอย่างนี้ เหตุการณ์ TFLite เดียวกันได้รับการบันทึกและบันทึกไว้ใน Perfetto แล้ว หรือรูปแบบ Systrace ขึ้นอยู่กับเวอร์ชันของอุปกรณ์ Android บันทึก เปิดไฟล์การติดตามได้ใน UI ของ Perfetto

ติดตามภายใน LiteRT ใน iOS

เหตุการณ์ภายในจากล่าม LiteRT ของแอป iOS อาจเป็นไปได้ ถ่ายโดย เครื่องมือ เครื่องมือที่รวมอยู่ใน Xcode แอปเหล่านี้คือ iOS signpost ดังนั้น จะเห็นเหตุการณ์ที่บันทึกจากโค้ด Swift/Objective-C ร่วมกัน ด้วยเหตุการณ์ภายในของ LiteRT

ตัวอย่างกิจกรรมมีดังนี้

• การเรียกใช้ผู้ให้บริการ
• การแก้ไขกราฟตามผู้รับมอบสิทธิ์
• การจัดสรร Tensor

เปิดใช้การติดตาม LiteRT

ตั้งค่าตัวแปรสภาพแวดล้อม debug.tflite.trace โดยทำตามขั้นตอนต่อไปนี้

1. เลือกผลิตภัณฑ์ > รูปแบบ > แก้ไข Scheme... จากเมนูด้านบนของ Xcode

2. คลิก "โปรไฟล์" ในแผงด้านซ้าย

3. ยกเลิกการเลือก "ใช้อาร์กิวเมนต์และตัวแปรสภาพแวดล้อมของเรียกใช้การดำเนินการ" ช่องทำเครื่องหมาย

4. เพิ่ม debug.tflite.trace ภายใต้ "ตัวแปรสภาพแวดล้อม"

   

หากคุณต้องการยกเว้นเหตุการณ์ LiteRT เมื่อทำโปรไฟล์แอป iOS ปิดใช้การติดตามโดยนำตัวแปรสภาพแวดล้อมออก

เครื่องมือ XCode

จับภาพการติดตามโดยทำตามขั้นตอนต่อไปนี้

1. เลือกผลิตภัณฑ์ > Profile จากเมนูด้านบนของ Xcode

2. คลิกการบันทึกระหว่างเทมเพลตการทำโปรไฟล์เมื่อเปิดตัวเครื่องมือ

3. กด "เริ่ม"

4. กด "หยุด"

5. คลิก "os_signpost" เพื่อขยายรายการระบบย่อยของ OS Logging

6. คลิก "org.tensorflow.lite" ระบบย่อยของ OS Logging

7. ตรวจสอบผลลัพธ์การติดตาม

   

ในตัวอย่างนี้ คุณสามารถดูลำดับชั้นของเหตุการณ์และสถิติของแต่ละเหตุการณ์ เวลาโอเปอเรเตอร์

การใช้ข้อมูลการติดตาม

ข้อมูลการติดตามจะช่วยให้คุณระบุจุดคอขวดด้านประสิทธิภาพได้

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

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