บริการเร่งความเร็วสำหรับ Android (เบต้า)

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

การใช้โปรเซสเซอร์พิเศษ เช่น GPU, NPU หรือ DSP สำหรับการเร่งด้วยฮาร์ดแวร์สามารถปรับปรุงประสิทธิภาพการอนุมานได้อย่างมาก (ในบางกรณี การอนุมานเร็วขึ้นถึง 10 เท่า) และประสบการณ์ผู้ใช้แอปพลิเคชัน Android ที่เปิดใช้งาน ML ของคุณ อย่างไรก็ตาม เนื่องจากผู้ใช้ของคุณอาจมีฮาร์ดแวร์และไดรเวอร์ที่หลากหลาย การเลือกการกำหนดค่าการเร่งความเร็วด้วยฮาร์ดแวร์ที่เหมาะสมที่สุดสำหรับอุปกรณ์ของผู้ใช้แต่ละคนจึงอาจเป็นเรื่องที่ท้าทาย นอกจากนี้ การเปิดใช้งานการกำหนดค่าที่ไม่ถูกต้องบนอุปกรณ์สามารถสร้างประสบการณ์ผู้ใช้ที่ไม่ดีเนื่องจากเวลาแฝงสูง หรือในบางกรณีซึ่งเกิดขึ้นไม่บ่อยนัก ข้อผิดพลาดรันไทม์หรือปัญหาความแม่นยำที่เกิดจากความไม่เข้ากันของฮาร์ดแวร์

Acceleration Service สำหรับ Android คือ API ที่ช่วยให้คุณเลือกการกำหนดค่าการเร่งด้วยฮาร์ดแวร์ที่เหมาะสมที่สุดสำหรับอุปกรณ์ผู้ใช้ที่กำหนดและโมเดล .tflite ของคุณ ในขณะเดียวกันก็ลดความเสี่ยงของข้อผิดพลาดรันไทม์หรือปัญหาด้านความแม่นยำให้เหลือน้อยที่สุด

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

จัดเตรียมโมเดล ตัวอย่างข้อมูล และผลลัพธ์ที่คาดหวัง (อินพุตและเอาท์พุต "สีทอง") แล้ว Acceleration Service จะเรียกใช้เกณฑ์มาตรฐานการอนุมาน TFLite ภายในเพื่อให้คำแนะนำด้านฮาร์ดแวร์แก่คุณ

บริการเร่งความเร็วเป็นส่วนหนึ่งของสแต็ก ML ที่กำหนดเองของ Android และทำงานร่วมกับ TensorFlow Lite ในบริการ Google Play

เพิ่มการพึ่งพาให้กับโครงการของคุณ

เพิ่มการอ้างอิงต่อไปนี้ลงในไฟล์ build.gradle ของแอปพลิเคชันของคุณ:

implementation  "com.google.android.gms:play-services-tflite-
acceleration-service:16.0.0-beta01"

Acceleration Service API ทำงานร่วมกับ TensorFlow Lite ในบริการ Google Play หากคุณไม่ได้ใช้รันไทม์ TensorFlow Lite ที่ให้บริการผ่าน Play Services คุณจะต้องอัปเดต การอ้างอิง ของคุณ

วิธีใช้ Acceleration Service API

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

สร้างการกำหนดค่าการเร่งความเร็ว

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

ในขณะนี้ บริการเร่งความเร็วทำให้คุณสามารถประเมินการกำหนดค่า GPU (แปลงเป็นผู้รับมอบสิทธิ์ GPU ในระหว่างเวลาดำเนินการ) ด้วย GpuAccelerationConfig และการอนุมาน CPU (ด้วย CpuAccelerationConfig ) เรากำลังดำเนินการสนับสนุนผู้ได้รับมอบหมายให้เข้าถึงฮาร์ดแวร์อื่นๆ ได้มากขึ้นในอนาคต

การกำหนดค่าการเร่งความเร็ว GPU

สร้างการกำหนดค่าการเร่งความเร็ว GPU ดังต่อไปนี้:

AccelerationConfig accelerationConfig = new GpuAccelerationConfig.Builder()
  .setEnableQuantizedInference(false)
  .build();

คุณต้องระบุว่าโมเดลของคุณใช้การหาปริมาณด้วย setEnableQuantizedInference() หรือไม่

การกำหนดค่าการเร่งความเร็ว CPU

สร้างความเร่ง CPU ดังต่อไปนี้:

AccelerationConfig accelerationConfig = new CpuAccelerationConfig.Builder()
  .setNumThreads(2)
  .build();

ใช้เมธอด setNumThreads() เพื่อกำหนดจำนวนเธรดที่คุณต้องการใช้เพื่อประเมินการอนุมาน CPU

สร้างการกำหนดค่าการตรวจสอบ

การกำหนดค่าการตรวจสอบช่วยให้คุณสามารถกำหนดวิธีที่คุณต้องการให้ Acceleration Service ประเมินการอนุมานได้ คุณจะใช้มันเพื่อผ่าน:

• ตัวอย่างอินพุต
• ผลลัพธ์ที่คาดหวัง
• ตรรกะการตรวจสอบความถูกต้อง

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

สร้าง ValidationConfig ด้วย CustomValidationConfig.Builder ดังนี้:

ValidationConfig validationConfig = new CustomValidationConfig.Builder()
   .setBatchSize(5)
   .setGoldenInputs(inputs)
   .setGoldenOutputs(outputBuffer)
   .setAccuracyValidator(new MyCustomAccuracyValidator())
   .build();

ระบุจำนวนตัวอย่างสีทองด้วย setBatchSize() ส่งอินพุตของตัวอย่างทองคำของคุณโดยใช้ setGoldenInputs() จัดเตรียมเอาต์พุตที่คาดหวังสำหรับอินพุตที่ส่งผ่านด้วย setGoldenOutputs()

คุณสามารถกำหนดเวลาอนุมานสูงสุดได้ด้วย setInferenceTimeoutMillis() (5,000 ms โดยค่าเริ่มต้น) หากการอนุมานใช้เวลานานกว่าเวลาที่คุณกำหนด การกำหนดค่าจะถูกปฏิเสธ

คุณยังสามารถสร้าง AccuracyValidator แบบกำหนดเองได้ดังต่อไปนี้:

class MyCustomAccuracyValidator implements AccuracyValidator {
   boolean validate(
      BenchmarkResult benchmarkResult,
      ByteBuffer[] goldenOutput) {
        for (int i = 0; i < benchmarkResult.actualOutput().size(); i++) {
            if (!goldenOutputs[i]
               .equals(benchmarkResult.actualOutput().get(i).getValue())) {
               return false;
            }
         }
         return true;

   }
}

ตรวจสอบให้แน่ใจว่าได้กำหนดตรรกะการตรวจสอบที่เหมาะกับกรณีการใช้งานของคุณ

โปรดทราบว่าหากข้อมูลการตรวจสอบถูกฝังอยู่ในโมเดลของคุณแล้ว คุณสามารถใช้ EmbeddedValidationConfig ได้

สร้างผลลัพธ์การตรวจสอบ

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

ValidationConfig validationConfig = new CustomValidationConfig.Builder()
   .setBatchSize(5)
   .setGoldenInputs(inputs)
   .setGoldenConfig(customCpuAccelerationConfig)
   [...]
   .build();

ตรวจสอบการกำหนดค่าการเร่งความเร็ว

เมื่อคุณสร้างการกำหนดค่าการเร่งความเร็วและการกำหนดค่าการตรวจสอบความถูกต้องแล้ว คุณสามารถประเมินการกำหนดค่าเหล่านั้นสำหรับโมเดลของคุณได้

ตรวจสอบให้แน่ใจว่ารันไทม์ TensorFlow Lite พร้อม Play Services ได้รับการเริ่มต้นอย่างถูกต้อง และตัวแทน GPU พร้อมใช้งานสำหรับอุปกรณ์โดยการเรียกใช้:

TfLiteGpu.isGpuDelegateAvailable(context)
   .onSuccessTask(gpuAvailable -> TfLite.initialize(context,
      TfLiteInitializationOptions.builder()
        .setEnableGpuDelegateSupport(gpuAvailable)
        .build()
      )
   );

สร้างอินสแตนซ์ AccelerationService โดยการเรียก AccelerationService.create()

จากนั้นคุณสามารถตรวจสอบการกำหนดค่าการเร่งความเร็วสำหรับโมเดลของคุณได้โดยการเรียก validateConfig() :

InterpreterApi interpreter;
InterpreterOptions interpreterOptions = InterpreterApi.Options();
AccelerationService.create(context)
   .validateConfig(model, accelerationConfig, validationConfig)
   .addOnSuccessListener(validatedConfig -> {
      if (validatedConfig.isValid() && validatedConfig.benchmarkResult().hasPassedAccuracyTest()) {
         interpreterOptions.setAccelerationConfig(validatedConfig);
         interpreter = InterpreterApi.create(model, interpreterOptions);
});

คุณยังสามารถตรวจสอบการกำหนดค่าหลายรายการได้โดยการเรียก validateConfigs() และส่งวัตถุ Iterable<AccelerationConfig> เป็นพารามิเตอร์

validateConfig() จะส่งคืน Task< ValidatedAccelerationConfigResult > จาก Task Api ของบริการ Google Play ซึ่งเปิดใช้งานงานแบบอะซิงโครนัส
หากต้องการรับผลลัพธ์จากการเรียกตรวจสอบ ให้เพิ่มการเรียกกลับ addOnSuccessListener()

ใช้การกำหนดค่าที่ได้รับการตรวจสอบแล้วในล่ามของคุณ

หลังจากตรวจสอบว่า ValidatedAccelerationConfigResult ที่ส่งคืนในการเรียกกลับนั้นถูกต้องหรือไม่ คุณสามารถตั้งค่าการกำหนดค่าที่ได้รับการตรวจสอบแล้วเป็นการกำหนดค่าการเร่งความเร็วสำหรับล่ามของคุณที่เรียก interpreterOptions.setAccelerationConfig()

แคชการกำหนดค่า

การกำหนดค่าการเร่งความเร็วที่เหมาะสมที่สุดสำหรับรุ่นของคุณไม่น่าจะเปลี่ยนแปลงบนอุปกรณ์ ดังนั้นเมื่อคุณได้รับการกำหนดค่าการเร่งความเร็วที่น่าพอใจ คุณควรจัดเก็บไว้ในอุปกรณ์และให้แอปพลิเคชันของคุณดึงข้อมูลและใช้เพื่อสร้าง InterpreterOptions ของคุณในระหว่างเซสชันต่อไปนี้ แทนที่จะเรียกใช้การตรวจสอบความถูกต้องอีกครั้ง เมธอด serialize() และ deserialize() ใน ValidatedAccelerationConfigResult ทำให้กระบวนการจัดเก็บและการเรียกค้นข้อมูลง่ายขึ้น

แอปพลิเคชันตัวอย่าง

หากต้องการตรวจสอบการผสานรวมบริการเร่งความเร็ว โปรดดูที่ แอปตัวอย่าง

ข้อจำกัด

บริการเร่งความเร็วมีข้อจำกัดในปัจจุบันดังต่อไปนี้:

• ในขณะนี้รองรับเฉพาะการกำหนดค่าการเร่งความเร็ว CPU และ GPU เท่านั้น
• รองรับเฉพาะ TensorFlow Lite ในบริการ Google Play และคุณไม่สามารถใช้งานได้หากคุณใช้ TensorFlow Lite เวอร์ชันรวม
• ไม่รองรับ ไลบรารีงาน TensorFlow Lite เนื่องจากคุณไม่สามารถเริ่มต้น BaseOptions ได้โดยตรงด้วยวัตถุ ValidatedAccelerationConfigResult
• Acceleration Service SDK รองรับเฉพาะ API ระดับ 22 ขึ้นไป

คำเตือน

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

• ก่อนที่จะออกจากรุ่นเบต้าและเปิดตัวเวอร์ชันเสถียรสำหรับ Acceleration Service API เราจะเผยแพร่ SDK ใหม่ซึ่งอาจมีความแตกต่างบางประการจากรุ่นเบต้าปัจจุบัน หากต้องการใช้บริการเร่งความเร็วต่อไป คุณจะต้องย้ายไปยัง SDK ใหม่นี้และพุชการอัปเดตไปยังแอปของคุณอย่างทันท่วงที การไม่ทำเช่นนั้นอาจทำให้เกิดความเสียหายเนื่องจาก Beta SDK อาจเข้ากันไม่ได้กับบริการ Google Play อีกต่อไปหลังจากผ่านไประยะหนึ่ง

• ไม่มีการรับประกันว่าคุณลักษณะเฉพาะภายใน Acceleration Service API หรือ API โดยรวมจะพร้อมใช้งานโดยทั่วไป มันอาจจะยังคงอยู่ในรุ่นเบต้าอย่างไม่มีกำหนด ถูกปิดตัวลง หรือรวมกับคุณสมบัติอื่น ๆ ในแพ็คเกจที่ออกแบบมาสำหรับผู้ชมนักพัฒนาเฉพาะราย คุณสมบัติบางอย่างที่มี Acceleration Service API หรือ API ทั้งหมดอาจเปิดให้ใช้งานโดยทั่วไปในที่สุด แต่ไม่มีกำหนดการตายตัวสำหรับสิ่งนี้

ข้อกำหนดและความเป็นส่วนตัว

เงื่อนไขการให้บริการ

การใช้ Acceleration Service API อยู่ภายใต้ ข้อกำหนดในการให้บริการของ Google API
นอกจากนี้ ปัจจุบัน Acceleration Service API ยังเป็นรุ่นเบต้า และด้วยเหตุนี้ การใช้ API นี้แสดงว่าคุณรับทราบปัญหาที่อาจเกิดขึ้นตามที่ระบุไว้ในส่วนคำเตือนด้านบน และรับทราบว่าบริการ Acceleration อาจไม่ทำงานตามที่ระบุไว้เสมอไป

ความเป็นส่วนตัว

เมื่อคุณใช้ Acceleration Service API การประมวลผลข้อมูลอินพุต (เช่น รูปภาพ วิดีโอ ข้อความ) จะเกิดขึ้นบนอุปกรณ์โดยสมบูรณ์ และ บริการ Acceleration จะไม่ส่งข้อมูลนั้นไปยังเซิร์ฟเวอร์ของ Google ด้วยเหตุนี้ คุณสามารถใช้ API ของเราเพื่อประมวลผลข้อมูลอินพุตที่ไม่ควรออกจากอุปกรณ์
Acceleration Service API อาจติดต่อกับเซิร์ฟเวอร์ของ Google เป็นครั้งคราวเพื่อรับสิ่งต่างๆ เช่น การแก้ไขข้อบกพร่อง รุ่นที่อัปเดต และข้อมูลความเข้ากันได้ของตัวเร่งความเร็วฮาร์ดแวร์ นอกจากนี้ Acceleration Service API ยังส่งเมตริกเกี่ยวกับประสิทธิภาพและการใช้งาน API ในแอปของคุณไปยัง Google อีกด้วย Google ใช้ข้อมูลเมตริกนี้เพื่อวัดประสิทธิภาพ แก้ไขข้อบกพร่อง บำรุงรักษาและปรับปรุง API และตรวจจับการใช้งานในทางที่ผิดหรือการละเมิด ตามที่อธิบายเพิ่มเติมใน นโยบายความเป็นส่วนตัว ของเรา
คุณมีหน้าที่รับผิดชอบในการแจ้งให้ผู้ใช้ทราบเกี่ยวกับแอปของคุณเกี่ยวกับการประมวลผลข้อมูลเมตริกบริการเร่งความเร็วของ Google ตามที่กฎหมายที่เกี่ยวข้องกำหนด
ข้อมูลที่เรารวบรวมมีดังต่อไปนี้:

• ข้อมูลอุปกรณ์ (เช่น ผู้ผลิต รุ่น เวอร์ชันระบบปฏิบัติการ และบิลด์) และตัวเร่งฮาร์ดแวร์ ML ที่พร้อมใช้งาน (GPU และ DSP) ใช้สำหรับการวินิจฉัยและการวิเคราะห์การใช้งาน
• ข้อมูลแอพ (ชื่อแพ็คเกจ / รหัสบันเดิล, เวอร์ชันแอพ) ใช้สำหรับการวินิจฉัยและการวิเคราะห์การใช้งาน
• การกำหนดค่า API (เช่น รูปแบบรูปภาพและความละเอียด) ใช้สำหรับการวินิจฉัยและการวิเคราะห์การใช้งาน
• ประเภทเหตุการณ์ (เช่น การเริ่มต้น โมเดลการดาวน์โหลด อัปเดต เรียกใช้ การตรวจจับ) ใช้สำหรับการวินิจฉัยและการวิเคราะห์การใช้งาน
• รหัสข้อผิดพลาด ใช้สำหรับการวินิจฉัย
• การวัดประสิทธิภาพ. ใช้สำหรับการวินิจฉัย
• ตัวระบุต่อการติดตั้งที่ไม่ได้ระบุผู้ใช้หรืออุปกรณ์ทางกายภาพโดยไม่ซ้ำกัน ใช้สำหรับการดำเนินการกำหนดค่าระยะไกลและการวิเคราะห์การใช้งาน
• ที่อยู่ IP ของผู้ส่งคำขอเครือข่าย ใช้สำหรับการวินิจฉัยการกำหนดค่าระยะไกล ที่อยู่ IP ที่รวบรวมจะถูกเก็บไว้ชั่วคราว

การสนับสนุนและข้อเสนอแนะ

คุณสามารถให้ข้อเสนอแนะและรับการสนับสนุนผ่านทาง TensorFlow Issue Tracker โปรดรายงานปัญหาและคำขอการสนับสนุนโดยใช้ เทมเพลตปัญหา สำหรับ TensorFlow Lite ในบริการ Google Play