Android के लिए ऐक्सेलरेशन सेवा (बीटा वर्शन)

हार्डवेयर के लिए जीपीयू, एनपीयू या डीएसपी जैसे खास प्रोसेसर का इस्तेमाल करना एक्सीलरेशन से अनुमान की परफ़ॉर्मेंस काफ़ी बेहतर हो सकती है (10 गुना तक ज़्यादा तेज़ कुछ मामलों में अनुमान) और मशीन लर्निंग की सुविधा वाले Android के उपयोगकर्ता अनुभव का इस्तेमाल करें. हालांकि, हार्डवेयर और ड्राइवरों की विविधता को देखते हुए आपके उपयोगकर्ता इसमें हर उपयोगकर्ता के हिसाब से सबसे सही हार्डवेयर ऐक्सेलरेशन कॉन्फ़िगर करना होता है मुश्किल हो सकता है. इसके अलावा, डिवाइस पर गलत कॉन्फ़िगरेशन को चालू करने से डिवाइस, इंतज़ार का समय ज़्यादा होने या कुछ मामलों में खराब उपयोगकर्ता अनुभव दे सकता है मामलों, रनटाइम की गड़बड़ियों या हार्डवेयर के ठीक से काम न करने की वजह से होने वाली सटीक जानकारी से जुड़ी समस्याओं के बारे में बताया गया है.

Android के लिए Acceleration Service एक ऐसा API है जो आपको किसी उपयोगकर्ता के डिवाइस के लिए, हार्डवेयर से तेज़ी लाने का सबसे अच्छा कॉन्फ़िगरेशन और .tflite मॉडल का इस्तेमाल करता है. इससे रनटाइम की गड़बड़ी या सटीक होने की समस्याओं के जोखिम को कम किया जाता है.

ऐक्सेलरेशन सेवा, उपयोगकर्ता पर अलग-अलग एक्सिलरेशन कॉन्फ़िगरेशन का आकलन करती है LiteRT की मदद से, अंदरूनी अनुमान मानदंड चलाकर डिवाइस मॉडल. यह जांच आम तौर पर कुछ सेकंड में पूरी हो जाती है. यह इस पर निर्भर करता है कि आपकी मॉडल. हर उपयोगकर्ता के डिवाइस पर किसी अनुमान से पहले मानदंड को एक बार चलाया जा सकता है समय, नतीजे को कैश मेमोरी में सेव करें और अनुमान के दौरान इसका इस्तेमाल करें. ये मानदंड चलाए जा रहे हैं आउट-ऑफ़-प्रोसेस; इससे, आपके ऐप्लिकेशन के क्रैश होने का खतरा कम हो जाता है.

अपना मॉडल, डेटा के सैंपल, और अनुमानित नतीजे ("गोल्डन" इनपुट के साथ-साथ आउटपुट) और Acceleration Service एक आंतरिक TFLite अनुमान चलाएगा आपको हार्डवेयर से जुड़े सुझाव देने के लिए बेंचमार्क तय किया गया है.

ऐक्सेलरेशन सेवा, Android के पसंद के मुताबिक बनाए गए एमएल स्टैक का हिस्सा है और यह इनके साथ काम करती है: Google Play सेवाओं में LiteRT.

अपने प्रोजेक्ट में डिपेंडेंसी जोड़ना

अपने ऐप्लिकेशन की create.gradle फ़ाइल में ये डिपेंडेंसी जोड़ें:

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

Acceleration Service API, Google Play में LiteRT के साथ काम करता है सेवाएं. अगर आपको फ़िलहाल, Play सेवाओं से मिले LiteRT रनटाइम का इस्तेमाल नहीं किया जा रहा है, तो आपकी dependencies अपडेट करनी होगी.

Acceleration Service API को इस्तेमाल करने का तरीका

ऐक्सेलरेशन सेवा का इस्तेमाल करने के लिए, सबसे पहले ऐक्सलरेशन कॉन्फ़िगरेशन बनाएं आपको अपने मॉडल के लिए आकलन करना है (जैसे, OpenGL वाला जीपीयू). इसके बाद, आपके मॉडल, कुछ नमूना डेटा और अपेक्षित मॉडल आउटपुट. अंत में अपने दोनों विज्ञापनों को पास करने के लिए validateConfig() को कॉल करें एक्सेलरेटर कॉन्फ़िगरेशन और पुष्टि करने वाला कॉन्फ़िगरेशन.

एक्सेलरेटर कॉन्फ़िगरेशन बनाएं

ऐक्सेलरेशन कॉन्फ़िगरेशन, हार्डवेयर कॉन्फ़िगरेशन के बारे में बताते हैं जिन्हें एक्ज़ीक्यूशन के समय के दौरान डेलिगेट के वोटों में बदल दिया जाता है. इसके बाद, Acceleration Service की मदद से, ये कॉन्फ़िगरेशन अंदरूनी तौर पर इस्तेमाल किए जाएंगे का इस्तेमाल करें.

इस समय ऐक्सेलरेशन सेवा की मदद से, जीपीयू का आकलन किया जा सकता है कॉन्फ़िगरेशन (एक्ज़िक्यूशन के दौरान, जीपीयू डेलिगेट में बदला गया) के साथ GpuAccelerationConfig और सीपीयू अनुमान (इसके साथ) CpuAccelerationConfig). हम इसमें दूसरे हार्डवेयर को ऐक्सेस करने के लिए, ज़्यादा से ज़्यादा डेलिगेट के वोटों की पुष्टि करने पर काम कर रहे हैं आने वाले समय में इस्तेमाल करें.

जीपीयू से तेज़ी लाने का कॉन्फ़िगरेशन

नीचे बताए गए तरीके से जीपीयू एक्सेलरेटर कॉन्फ़िगरेशन बनाएं:

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

आपको यह बताना होगा कि आपका मॉडल, इसके साथ क्वांटाइज़ेशन का इस्तेमाल कर रहा है या नहीं setEnableQuantizedInference().

सीपीयू की रफ़्तार बढ़ाने का कॉन्फ़िगरेशन

इस तरीके से सीपीयू की रफ़्तार बढ़ाएं:

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

इसका इस्तेमाल करें setNumThreads() इस तरीके का इस्तेमाल करके, यह बताएं कि सीपीयू का आकलन करने के लिए, आपको कितने थ्रेड का इस्तेमाल करना है अनुमान.

पुष्टि करने के लिए कॉन्फ़िगरेशन बनाएं

पुष्टि करने वाले कॉन्फ़िगरेशन, आपको यह तय करने में मदद करते हैं कि आपको ऐक्सेलरेशन कैसे चाहिए अनुमानों का आकलन करने की सेवा. इन सुविधाओं का इस्तेमाल करके, ये काम किए जा सकते हैं:

• इनपुट के सैंपल,
• अनुमानित आउटपुट,
• सटीक होने की पुष्टि करने का लॉजिक.

पक्का करें कि उन इनपुट के सैंपल दिए गए हों जिनके लिए आपको अच्छी परफ़ॉर्मेंस मिलने की उम्मीद है आपके मॉडल (जिन्हें “गोल्डन” सैंपल भी कहा जाता है).

किसी प्रॉडक्ट की पिच के लिए ValidationConfig के साथ CustomValidationConfig.Builder यह लेख देखें:

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

गोल्डन सैंपल की संख्या बताएं setBatchSize(). गोल्डन सैंपल के इनपुट पास करने के लिए, इनमें से किसी विकल्प का इस्तेमाल करें setGoldenInputs(). पास किए गए इनपुट के लिए अनुमानित आउटपुट दें setGoldenOutputs().

setInferenceTimeoutMillis() की मदद से, अनुमान लगाने में लगने वाला ज़्यादा से ज़्यादा समय तय किया जा सकता है (डिफ़ॉल्ट रूप से 5000 मि॰से॰). अगर अनुमान में आपके तय किए गए समय से ज़्यादा समय लगता है, कॉन्फ़िगरेशन को अस्वीकार कर दिया जाएगा.

विकल्प के तौर पर, कस्टम 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();

ऐक्सेलरेशन के कॉन्फ़िगरेशन की पुष्टि करें

ऐक्सलरेशन कॉन्फ़िगरेशन और पुष्टि करने वाला कॉन्फ़िगरेशन बनाने के बाद, अपने मॉडल के लिए उनका आकलन कर सकती है.

पक्का करें कि Play Services के रनटाइम के साथ, LiteRT सही तरीके से सेट हो शुरू किया गया और यह कि जीपीयू डेलिगेट को चलाकर डिवाइस के लिए उपलब्ध कराया जा सकता है:

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 services की मदद से Task Api जो चालू करता है एसिंक्रोनस टास्क पर जाएं.
अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है पुष्टि करने वाले कॉल से नतीजा पाने के लिए, addOnSuccessListener() कॉलबैक.

अपने अनुवादक में पुष्टि किए गए कॉन्फ़िगरेशन का इस्तेमाल करें

यह देखने के बाद कि ValidatedAccelerationConfigResult कॉलबैक मान्य है. आपके पास, पुष्टि किए गए कॉन्फ़िगरेशन को ऐक्सलरेशन कॉन्फ़िगरेशन के तौर पर सेट करने का विकल्प है interpreterOptions.setAccelerationConfig() को कॉल करने वाले आपके अनुवादक के लिए.

कॉन्फ़िगरेशन को कैश मेमोरी में सेव करने की सुविधा

इस बात की संभावना कम है कि आपके मॉडल के लिए, सटीक ऐक्सेलरेशन कॉन्फ़िगर किया जाए डिवाइस. इसलिए, एक बार आपको तेज़ी से काम करने वाला कॉन्फ़िगरेशन मिल जाने के बाद, को डिवाइस पर संग्रहित कर देना चाहिए और आपके ऐप्लिकेशन को उसे पुनर्प्राप्त करने और इसका उपयोग करने देगा इसके बजाय, नीचे दिए गए सेशन के दौरान अपना InterpreterOptions बनाएं पुष्टि करने का एक और चरण शुरू किया जा रहा है. इस विकल्प को चुनने पर, serialize() और deserialize() ValidatedAccelerationConfigResult स्टोरेज और वापस पाने की प्रोसेस को आसान बनाता है और भी आसान हो गया है.

सैंपल ऐप्लिकेशन

Acceleration Service के इन-स्टू इंटिग्रेशन की समीक्षा करने के लिए, यहां देखें ऐप्लिकेशन का नमूना.

सीमाएं

Acceleration Service की मौजूदा सीमाएं हैं:

• फ़िलहाल, सिर्फ़ सीपीयू और जीपीयू से डेटा ऐक्सेलरेशन कॉन्फ़िगर किए जा सकते हैं.
• यह सिर्फ़ Google Play सेवाओं में LiteRT का इस्तेमाल करता है, आपको ऐसा नहीं करना चाहिए LiteRT के बंडल किए गए वर्शन का इस्तेमाल करने पर, इसका इस्तेमाल करना चाहिए.
• Acceleration Service SDK टूल की मदद से, सिर्फ़ एपीआई लेवल 22 और उसके बाद के वर्शन पर काम किया जा सकता है.

चेतावनियां

कृपया इन चेतावनियों को ध्यान से पढ़ें, खास तौर पर तब, जब आपको प्रोडक्शन में इस SDK टूल का इस्तेमाल करने के लिए:

• बीटा से बाहर निकलने और स्टेबल वर्शन को रिलीज़ करने से पहले Acceleration Service API, हम नया SDK टूल पब्लिश करेंगे, जिसमें इनमें अंतर है. Google Ads API का इस्तेमाल जारी रखने के लिए, ऐक्सेलरेशन सेवा के लिए, आपको इस नए SDK टूल पर माइग्रेट करना होगा और को समय पर अपडेट करना होगा. ऐसा न करने पर समस्याएं आ सकती हैं, क्योंकि इसके बाद, हो सकता है कि बीटा SDK टूल, Google Play services के साथ काम न करे कभी-कभी.

• इस बात की कोई गारंटी नहीं है कि Acceleration में किसी खास सुविधा के होने की कोई गारंटी नहीं है Service API या एपीआई को आम तौर पर कभी भी उपलब्ध कराया जाएगा. यह बीटा में अनिश्चित समय तक रह सकता है, बंद किया जा सकता है या दूसरे के साथ मिलाया जा सकता है खास डेवलपर ऑडियंस के लिए डिज़ाइन किए गए पैकेज में सुविधाएं शामिल करें. कुछ सूचनाएं मिल रही हैं Acceleration Service API या पूरे एपीआई की सुविधाएं खुद में आखिरकार, यह सामान्य रूप से उपलब्ध हो जाता है, लेकिन इसके लिए कोई तय शेड्यूल नहीं है यह.

शर्तें और निजता

सेवा की शर्तें

Acceleration Service API का इस्तेमाल Google API की शर्तों सेवा.
अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है इसके अलावा, फ़िलहाल Acceleration Service API का बीटा वर्शन उपलब्ध है और, इसलिए, इसका इस्तेमाल करके आप इसमें बताई गई समस्याओं को स्वीकार करते हैं ऊपर दी गई सीमाएं सेक्शन में स्वीकार किया गया है कि Acceleration Service हमेशा वैसे ही काम करेंगे जैसा बताया गया है.

निजता

जब Acceleration Service API का इस्तेमाल किया जाता है, तब इनपुट डेटा की प्रोसेसिंग (जैसे, इमेज, वीडियो, टेक्स्ट), पूरी तरह से डिवाइस पर और ऐक्सेलरेशन सेवा के साथ उपलब्ध होती हैं उस डेटा को Google के सर्वर पर नहीं भेजता. इस वजह से, आप हमारे एपीआई का इस्तेमाल कर सकते हैं का इस्तेमाल करता है, जो डिवाइस में ही नहीं रहना चाहिए.
अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है Acceleration Service API समय-समय पर Google सर्वर से संपर्क कर सकते हैं गड़बड़ी ठीक करने, अपडेट किए गए मॉडल, और हार्डवेयर ऐक्सेलरेटर जैसी चीज़ें पाने के लिए साथ काम करने की जानकारी. Acceleration Service API भी बारे में मेट्रिक भेजते हैं Google को आपके ऐप्लिकेशन में मौजूद एपीआई की परफ़ॉर्मेंस और इस्तेमाल. Google, इस मेट्रिक डेटा का इस्तेमाल, एपीआई की परफ़ॉर्मेंस को मापने, डीबग करने, उनका रखरखाव करने, और उन्हें बेहतर बनाने के लिए किया जाता है. और जैसा कि हमारी निजता सेटिंग में बताया गया है, नीति.
अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है अपने ऐप्लिकेशन के उपयोगकर्ताओं को Google की प्रोसेसिंग के बारे में सूचना देने की ज़िम्मेदारी आपकी है हम ऐसा डेटा प्रोसेस कर सकते हैं जो लागू कानून के हिसाब से ज़रूरी हो.
अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है हम जो डेटा इकट्ठा करते हैं उसमें ये चीज़ें शामिल हैं:

• डिवाइस की जानकारी (जैसे कि मैन्युफ़ैक्चरर, मॉडल, ओएस वर्शन, और बिल्ड) और उपलब्ध एमएल हार्डवेयर ऐक्सेलरेटर (GPU और DSP). इसका इस्तेमाल गड़बड़ी का पता लगाने और इस्तेमाल के आंकड़े.
• ऐप्लिकेशन की जानकारी (पैकेज का नाम / बंडल आईडी, ऐप्लिकेशन का वर्शन). इनके लिए इस्तेमाल होता है और इसके इस्तेमाल के आंकड़े.
• एपीआई कॉन्फ़िगरेशन, जैसे कि इमेज फ़ॉर्मैट और रिज़ॉल्यूशन. इनके लिए इस्तेमाल होता है और इसके इस्तेमाल के आंकड़े.
• इवेंट टाइप, जैसे कि शुरू करना, मॉडल डाउनलोड करना, अपडेट करना, चलाना, पता लगाना. इस डेटा का इस्तेमाल, गड़बड़ी का पता लगाने और उसके इस्तेमाल के आंकड़े देखने के लिए किया जाता है.
• गड़बड़ी के कोड. गड़बड़ी का पता लगाने के लिए इस्तेमाल किया जाता है.
• परफ़ॉर्मेंस मेट्रिक. गड़बड़ी का पता लगाने के लिए इस्तेमाल किया जाता है.
• हर इंस्टॉल करने वाले ऐसे आइडेंटिफ़ायर जो किसी उपयोगकर्ता की खास तौर पर पहचान नहीं करते हैं या फ़िज़िकल डिवाइस. इसका इस्तेमाल रिमोट कॉन्फ़िगरेशन के ऑपरेशन और इस्तेमाल के लिए किया जाता है Analytics.
• नेटवर्क अनुरोध भेजने वाले के आईपी पते. रिमोट कॉन्फ़िगरेशन के लिए इस्तेमाल किया जाता है डाइग्नोस्टिक्स. इकट्ठा किए गए आईपी पतों को कुछ समय के लिए सेव रखा जाता है.

सहायता और सुझाव

TensorFlow के समस्या वाले ट्रैकर की मदद से, सुझाव, शिकायत या राय दी जा सकती है और सहायता भी पाई जा सकती है. कृपया समस्याओं की शिकायत करें और सहायता के अनुरोध करें. इसके लिए, समस्या टेंप्लेट Google Play services में, LiteRT के लिए.