บริการ AAccelerated สำหรับ Android (เบต้า)

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

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

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

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

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

เพิ่มทรัพยากร Dependency ลงในโปรเจ็กต์

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

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

AAccelerated Service API ใช้งานได้กับ LiteRT ใน Google Play บริการ หากคุณ ยังไม่ได้ใช้รันไทม์ LiteRT ที่ให้บริการผ่านบริการ Google Play คุณ คุณจะต้องอัปเดตdependencies

วิธีใช้ Acceleration Service API

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

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

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

ขณะที่บริการการเร่งความเร็วช่วยให้คุณประเมิน 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 การอนุมาน

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

การกําหนดค่าการตรวจสอบช่วยให้คุณกําหนดวิธีที่ต้องการการเร่งความเร็วได้ บริการในการประเมินการอนุมาน คุณจะใช้ฟีเจอร์เหล่านี้เพื่อผ่าน

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

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

สร้าง ValidationConfig กับ CustomValidationConfig.Builder ดังนี้

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

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

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

หรือคุณจะสร้าง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;

   }
}

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

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

สร้างเอาต์พุตการตรวจสอบ

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

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

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

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

ตรวจสอบว่ารันไทม์ของ LiteRT พร้อมบริการ Google Play ถูกต้อง เริ่มต้นแล้ว และผู้รับมอบสิทธิ์ 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> จากบริการ Google Play Task API ซึ่งเปิดใช้ งานที่ไม่พร้อมกัน
หากต้องการรับผลลัพธ์จากการโทรเพื่อตรวจสอบความถูกต้อง ให้เพิ่ม addOnSuccessListener() Callback

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

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

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

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

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

ตรวจสอบการผสานรวมภายในบริการ Acceleration ได้ที่ ตัวอย่างแอป

ข้อจำกัด

บริการ Acceleration มีข้อจำกัดดังต่อไปนี้

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

คำเตือน

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

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

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

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

ข้อกำหนดในการให้บริการ

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

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

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

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

การสนับสนุนและความคิดเห็น

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