TensorFlow ऑपरेटर चुनें

TensorFlow Lite की बिल्ट-इन ऑपरेटर लाइब्रेरी में, सीमित संख्या में TensorFlow ऑपरेटर इस्तेमाल किए जाते हैं. इसलिए, हर मॉडल में बदलाव नहीं किया जा सकता. ज़्यादा जानकारी के लिए, ऑपरेटर के साथ काम करने की सुविधा देखें.

बदलाव की अनुमति देने के लिए, उपयोगकर्ता अपने TensorFlow Lite मॉडल में कुछ TensorFlow ops के इस्तेमाल को चालू कर सकते हैं. हालांकि, TensorFlow के साथ TensorFlow Lite मॉडल चलाने के लिए, TensorFlow के मुख्य रनटाइम की ज़रूरत होती है. इससे TensorFlow Lite इंटरप्रेटर बाइनरी का साइज़ बढ़ जाता है. Android के लिए, चुनिंदा Tensorflow ऑपरेशन की मदद से, इस समस्या से बचा जा सकता है. जानकारी के लिए, बाइनरी का साइज़ कम करना देखें.

इस दस्तावेज़ में, आपकी पसंद के प्लैटफ़ॉर्म पर TensorFlow ऑपरेशन वाले TensorFlow Lite मॉडल को बदलने और उसे run का तरीका बताया गया है. इसमें परफ़ॉर्मेंस और साइज़ की मेट्रिक और जानी-पहचानी सीमाओं के बारे में भी बताया गया है.

किसी मॉडल को बदलना

नीचे दिए गए उदाहरण में, चुनिंदा TensorFlow ops की मदद से, TensorFlow Lite मॉडल जनरेट करने का तरीका बताया गया है.

import tensorflow as tf

converter = tf.lite.TFLiteConverter.from_saved_model(saved_model_dir)
converter.target_spec.supported_ops = [
  tf.lite.OpsSet.TFLITE_BUILTINS, # enable TensorFlow Lite ops.
  tf.lite.OpsSet.SELECT_TF_OPS # enable TensorFlow ops.
]
tflite_model = converter.convert()
open("converted_model.tflite", "wb").write(tflite_model)

अनुमान चलाएं

ऐसे TensorFlow Lite मॉडल का इस्तेमाल करते समय जिसे TensorFlow के चुनिंदा ऑपरेशन के लिए सपोर्ट के साथ बदला गया है, क्लाइंट को ऐसे TensorFlow Lite रनटाइम का इस्तेमाल करना होगा जिसमें TensorFlow ops की ज़रूरी लाइब्रेरी शामिल हो.

Android एएआर

बाइनरी साइज़ को कम करने के लिए, कृपया अगले सेक्शन में दिए गए निर्देशों के मुताबिक अपनी पसंद के मुताबिक AAR फ़ाइलें बनाएं. अगर बाइनरी साइज़ से जुड़ी समस्या को लेकर चिंता नहीं है, तो हमारा सुझाव है कि आप MavenCentral पर होस्ट किए गए TensorFlow ऑपरेशन के साथ AAR का इस्तेमाल करें.

इसे अपनी build.gradle डिपेंडेंसी में तय करने के लिए, इसे स्टैंडर्ड TensorFlow Lite AAR के साथ इस तरह जोड़ा जा सकता है:

dependencies {
    implementation 'org.tensorflow:tensorflow-lite:0.0.0-nightly-SNAPSHOT'
    // This dependency adds the necessary TF op support.
    implementation 'org.tensorflow:tensorflow-lite-select-tf-ops:0.0.0-nightly-SNAPSHOT'
}

नाइटली स्नैपशॉट का इस्तेमाल करने के लिए, पक्का करें कि आपने Sonatype स्नैपशॉट का डेटा स्टोर करने की जगह जोड़ा हो.

डिपेंडेंसी जोड़ने के बाद, ग्राफ़ के TensorFlow ऑपरेशन को मैनेज करने के लिए, ज़रूरी डेलिगेट उन ग्राफ़ के लिए अपने-आप इंस्टॉल हो जाएंगे जिन्हें इनकी ज़रूरत होती है.

ध्यान दें: TensorFlow ops की डिपेंडेंसी ज़्यादातर बड़ी होती है. इसलिए, हो सकता है कि आप abiFilters सेट अप करके, .gradle फ़ाइल में गै़र-ज़रूरी x86 एबीआई को फ़िल्टर करना चाहें.

android {
    defaultConfig {
        ndk {
            abiFilters 'armeabi-v7a', 'arm64-v8a'
        }
    }
}

Android एएआर बनाना

बाइनरी साइज़ या अन्य ऐडवांस केस को कम करने के लिए, मैन्युअल तरीके से भी लाइब्रेरी बनाई जा सकती है. TensorFlow Lite के काम करने वाले एनवायरमेंट को मानते हुए, चुनिंदा TensorFlow ऑपरेशन वाले Android AAR को इस तरह से बनाएं:

sh tensorflow/lite/tools/build_aar.sh \
  --input_models=/a/b/model_one.tflite,/c/d/model_two.tflite \
  --target_archs=x86,x86_64,arm64-v8a,armeabi-v7a

ऐसा करने पर, TensorFlow Lite बिल्ट-इन और पसंद के मुताबिक बनाई गई कार्रवाइयों के लिए AAR फ़ाइल bazel-bin/tmp/tensorflow-lite.aar जनरेट होगी. साथ ही, TensorFlow ऑपरेशन के लिए AAR फ़ाइल bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar जनरेट होगी. अगर आपके पास काम करने वाला बिल्ड एनवायरमेंट नहीं है, तो docker की मदद से ऊपर फ़ाइलें बनाई जा सकती हैं.

यहां से, AAR फ़ाइलों को सीधे अपने प्रोजेक्ट में इंपोर्ट किया जा सकता है या ज़रूरत के मुताबिक बनाई गई AAR फ़ाइलों को अपनी लोकल Maven रिपॉज़िटरी में पब्लिश किया जा सकता है:

mvn install:install-file \
  -Dfile=bazel-bin/tmp/tensorflow-lite.aar \
  -DgroupId=org.tensorflow \
  -DartifactId=tensorflow-lite -Dversion=0.1.100 -Dpackaging=aar
mvn install:install-file \
  -Dfile=bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar \
  -DgroupId=org.tensorflow \
  -DartifactId=tensorflow-lite-select-tf-ops -Dversion=0.1.100 -Dpackaging=aar

आखिर में, अपने ऐप्लिकेशन के build.gradle में, पक्का करें कि आपके ऐप्लिकेशन पर mavenLocal() डिपेंडेंसी हो. साथ ही, TensorFlow Lite की स्टैंडर्ड डिपेंडेंसी को उस डिपेंडेंसी से बदलें जो TensorFlow के चुनिंदा ऑपरेशन के साथ काम करती है:

allprojects {
    repositories {
        mavenCentral()
        maven {  // Only for snapshot artifacts
            name 'ossrh-snapshot'
            url 'https://oss.sonatype.org/content/repositories/snapshots'
        }
        mavenLocal()
    }
}

dependencies {
    implementation 'org.tensorflow:tensorflow-lite:0.1.100'
    implementation 'org.tensorflow:tensorflow-lite-select-tf-ops:0.1.100'
}

iOS

CocoaPods का इस्तेमाल करना

TensorFlow Lite, arm64 के लिए हर रात के लिए पहले से बने चुनिंदा TF ops CocoaPods उपलब्ध कराता है, जिन पर आप TensorFlowLiteSwift या TensorFlowLiteObjC CocoaPods के साथ निर्भर कर सकते हैं.

ध्यान दें: अगर आपको किसी x86_64 सिम्युलेटर में चुनिंदा TF ऑपरेशन का इस्तेमाल करना है, तो आपके पास चुने गए ऑपरेशन का फ़्रेमवर्क खुद बनाने का विकल्प है. ज़्यादा जानकारी के लिए, Basel + Xcode का इस्तेमाल करना सेक्शन देखें.

# In your Podfile target:
  pod 'TensorFlowLiteSwift'   # or 'TensorFlowLiteObjC'
  pod 'TensorFlowLiteSelectTfOps', '~> 0.0.1-nightly'

pod install चलाने के बाद, आपको एक और लिंकर फ़्लैग देना होगा, ताकि आपके प्रोजेक्ट में चुने गए TF ऑपरेशन फ़्रेमवर्क को ज़बरदस्ती लोड किया जा सके. अपने Xcode प्रोजेक्ट में, Build Settings -> Other Linker Flags पर जाएं और यह जोड़ें:

वर्शन >= 2.9.0 के लिए:

-force_load $(SRCROOT)/Pods/TensorFlowLiteSelectTfOps/Frameworks/TensorFlowLiteSelectTfOps.xcframework/ios-arm64/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps

वर्शन < 2.9.0 के लिए:

-force_load $(SRCROOT)/Pods/TensorFlowLiteSelectTfOps/Frameworks/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps

इसके बाद, अपने iOS ऐप्लिकेशन में, SELECT_TF_OPS की मदद से बदले गए किसी भी मॉडल को चलाया जा सकता है. उदाहरण के लिए, इमेज क्लासिफ़िकेशन वाले iOS ऐप्लिकेशन में बदलाव करके, चुनिंदा TF ऑपरेशन की सुविधा की जांच की जा सकती है.

• मॉडल फ़ाइल को उस फ़ाइल से बदलें जो SELECT_TF_OPS के साथ बदली गई है.
• निर्देश के मुताबिक, Podfile पर TensorFlowLiteSelectTfOps डिपेंडेंसी जोड़ें.
• ऊपर बताए गए तरीके से लिंक करने वाला दूसरा फ़्लैग जोड़ें.
• उदाहरण के तौर पर दिया गया ऐप्लिकेशन चलाएं और देखें कि मॉडल सही तरीके से काम कर रहा है या नहीं.

Basel + Xcode का इस्तेमाल करना

iOS के लिए चुनिंदा TensorFlow Ops के साथ, TensorFlow Lite को iOS के लिए बनाया जा सकता है. इसके लिए, आपको Basel का इस्तेमाल करना होगा. सबसे पहले, अपने Basel Workspace खाते और .bazelrc फ़ाइल को सही तरीके से कॉन्फ़िगर करने के लिए, iOS बिल्ड निर्देशों का पालन करें.

iOS सपोर्ट के साथ फ़ाइल फ़ोल्डर को कॉन्फ़िगर करने के बाद, नीचे दिए गए कमांड का इस्तेमाल करके चुनिंदा TF ऑपरेशन ऐड-ऑन फ़्रेमवर्क बनाया जा सकता है. इसे सामान्य TensorFlowLiteC.framework के सबसे ऊपर जोड़ा जा सकता है. ध्यान दें कि चुनिंदा TF ऑपरेशन फ़्रेमवर्क i386 आर्किटेक्चर के लिए नहीं बनाया जा सकता. इसलिए, आपको i386 को छोड़कर, टारगेट आर्किटेक्चर की सूची साफ़ तौर पर देनी होगी.

bazel build -c opt --config=ios --ios_multi_cpus=arm64,x86_64 \
  //tensorflow/lite/ios:TensorFlowLiteSelectTfOps_framework

इससे bazel-bin/tensorflow/lite/ios/ डायरेक्ट्री में फ़्रेमवर्क जनरेट होगा. इस नए फ़्रेमवर्क को अपने Xcode प्रोजेक्ट में जोड़ने के लिए, iOS बिल्ड गाइड के Xcode प्रोजेक्ट सेटिंग सेक्शन में बताया गया तरीका अपनाएं.

अपने ऐप्लिकेशन प्रोजेक्ट में फ़्रेमवर्क जोड़ने के बाद, आपके ऐप्लिकेशन प्रोजेक्ट में एक और लिंकर फ़्लैग होना चाहिए, ताकि चुने हुए TF ऑपरेशन फ़्रेमवर्क को लोड किया जा सके. अपने Xcode प्रोजेक्ट में, Build Settings -> Other Linker Flags पर जाएं और यह जोड़ें:

-force_load <path/to/your/TensorFlowLiteSelectTfOps.framework/TensorFlowLiteSelectTfOps>

सी/सी++

अगर TensorFlow Lite इंटरप्रेटर को बनाने के लिए, Basel या CMake का इस्तेमाल किया जा रहा है, तो आपके पास TensorFlow Lite Flex की शेयर की गई लाइब्रेरी को लिंक करके, Flex डेलिगेट को चालू करने का विकल्प है. इसे बनाने के लिए, आपको नीचे दिए गए निर्देश का पालन करना होगा.

bazel build -c opt --config=monolithic tensorflow/lite/delegates/flex:tensorflowlite_flex

इस निर्देश से, bazel-bin/tensorflow/lite/delegates/flex में शेयर की गई यह लाइब्रेरी जनरेट होती है.

प्लैटफ़ॉर्म	लाइब्रेरी का नाम
Linux	libtensorflowlite_flex.so
macOS	libtensorflowlite_flex.dylib
Windows	tensorflowlite_flex.dll

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

ध्यान दें: यह सुविधा, वर्शन 2.7 से उपलब्ध है.

Python

चुनिंदा TensorFlow Ops के साथ, TensorFlow Lite, TensorFlow पीआईपी पैकेज के साथ अपने-आप इंस्टॉल हो जाएगा. सिर्फ़ TensorFlow Lite interpreter पीआईपी पैकेज को इंस्टॉल करने का विकल्प भी चुना जा सकता है.

मेट्रिक

परफ़ॉर्मेंस

पहले से मौजूद और चुने गए TensorFlow Ops, दोनों के मिले-जुले रूप का इस्तेमाल करने पर, TensorFlow Lite के सभी ऑप्टिमाइज़ेशन और ऑप्टिमाइज़ किए गए बिल्ट-इन ऑपरेशन उपलब्ध होंगे. साथ ही, इन्हें बदले गए मॉडल के साथ इस्तेमाल किया जा सकेगा.

नीचे दी गई टेबल में बताया गया है कि Pixel 2 पर MobileNet पर अनुमान चलाने में लगने वाला औसत समय क्या है. सूची में दिए गए समय में औसतन 100 रन हैं. ये टारगेट, Android के लिए इन फ़्लैग का इस्तेमाल करके बनाए गए थे: --config=android_arm64 -c opt.

बनाएं	समय (मिलीसेकंड)
सिर्फ़ पहले से मौजूद ऑपरेशन (TFLITE_BUILTIN)	260.7
केवल TF ऑपरेशन का उपयोग किया जा रहा है (SELECT_TF_OPS)	264.5

बाइनरी साइज़

नीचे दी गई टेबल में, हर बिल्ड के लिए TensorFlow Lite की बाइनरी साइज़ की जानकारी दी गई है. ये लक्ष्य --config=android_arm -c opt का उपयोग करके Android के लिए बनाए गए थे.

बनाएं	C++ बाइनरी साइज़	Android APK का आकार
सिर्फ़ पहले से मौजूद ऑपरेशन	796 केबी	561 केबी
पहले से मौजूद ऑपरेशन और TF ऑपरेशन	23.0 एमबी	8.0 एमबी
पहले से मौजूद ऑपरेशन + TF ऑपरेशन (1)	4.1 एमबी	1.8 एमबी

(1) इन लाइब्रेरी को चुनिंदा i3d-kinetics-400 मॉडल के लिए बनाया गया है. इसमें आठ TFLite ऑपरेट और तीन Tensorflow ऑपरेशन हैं. ज़्यादा जानकारी के लिए, कृपया TensorFlow Lite का बाइनरी साइज़ कम करें सेक्शन देखें.

सीमाएं

• काम न करने वाले टाइप: ऐसा हो सकता है कि TensorFlow के कुछ ऑपरेशन, आम तौर पर TensorFlow में मौजूद इनपुट/आउटपुट टाइप के पूरे सेट के साथ काम न करें.

अपडेट

• वर्शन 2.6
  • यह सुविधा ग्राफ़ डिफ़-एट्रिब्यूट पर आधारित ऑपरेटर और HashTable रिसॉर्स के साथ काम करने के लिए बेहतर तरीके से काम करती है.
• वर्शन 2.5
  • आपके पास एक ऑप्टिमाइज़ेशन लागू करने का विकल्प है जिसे ट्रेनिंग के बाद की गिनती कहा जाता है
• वर्शन 2.4
  • हार्डवेयर से तेज़ी से ऐक्सेस करने वाले लोगों के साथ काम करने की क्षमता बेहतर हुई है