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

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

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

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

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

यहां दिए गए उदाहरण में, कुछ TensorFlow ऑपरेशंस के साथ LiteRT मॉडल जनरेट करने का तरीका दिखाया गया है.

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 LiteRT ops.
  tf.lite.OpsSet.SELECT_TF_OPS # enable TensorFlow ops.
]
tflite_model = converter.convert()
open("converted_model.tflite", "wb").write(tflite_model)

अनुमान लगाना

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

Android AAR

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

इसे अपनी build.gradle डिपेंडेंसी में शामिल किया जा सकता है. इसके लिए, इसे स्टैंडर्ड LiteRT 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 snapshot repository जोड़ा हो.

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

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

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

Android AAR बनाना

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

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

इससे LiteRT में पहले से मौजूद और कस्टम ऑप्स के लिए, एएआर फ़ाइल bazel-bin/tmp/tensorflow-lite.aar जनरेट होगी. साथ ही, TensorFlow ऑप्स के लिए एएआर फ़ाइल 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() डिपेंडेंसी हो. साथ ही, स्टैंडर्ड LiteRT डिपेंडेंसी को उस डिपेंडेंसी से बदलें जिसमें चुनिंदा 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 का इस्तेमाल करना

LiteRT, arm64 के लिए, हर रात पहले से बनाए गए कुछ टीएफ़ ऑप्स CocoaPods उपलब्ध कराता है. इन पर, TensorFlowLiteSwift या TensorFlowLiteObjC CocoaPods के साथ भरोसा किया जा सकता है.

ध्यान दें: अगर आपको x86_64 सिम्युलेटर में कुछ टीएफ़ ऑपरेशंस का इस्तेमाल करना है, तो आपके पास खुद से ऑपरेशंस का फ़्रेमवर्क बनाने का विकल्प है. ज़्यादा जानकारी के लिए, Bazel + 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 ऐप्लिकेशन में बदलाव किया जा सकता है.

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

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

Bazel का इस्तेमाल करके, iOS के लिए LiteRT बनाया जा सकता है. इसमें TensorFlow के कुछ ऑपरेशंस शामिल होते हैं. सबसे पहले, iOS बिल्ड करने के निर्देशों का पालन करके, अपने Bazel वर्कस्पेस और .bazelrc फ़ाइल को सही तरीके से कॉन्फ़िगर करें.

iOS के साथ काम करने वाले वर्कस्पेस को कॉन्फ़िगर करने के बाद, यहां दी गई कमांड का इस्तेमाल करके, चुनिंदा TF ऑप्स ऐडऑन फ़्रेमवर्क बनाया जा सकता है. इसे सामान्य TensorFlowLiteC.framework के ऊपर जोड़ा जा सकता है. ध्यान दें कि चुनिंदा टीएफ़ ऑप्स फ़्रेमवर्क को 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 प्रोजेक्ट की सेटिंग सेक्शन में दिए गए तरीके का इस्तेमाल करें.

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

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

C/C++

अगर LiteRT इंटरप्रेटर बनाने के लिए Bazel या CMake का इस्तेमाल किया जा रहा है, तो LiteRT Flex delegate की शेयर की गई लाइब्रेरी को लिंक करके, Flex delegate को चालू किया जा सकता है. इसे Bazel की मदद से बनाया जा सकता है. इसके लिए, यह निर्देश इस्तेमाल करें.

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

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

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

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

Python

चुनिंदा TensorFlow ऑपरेशंस के साथ LiteRT, TensorFlow pip पैकेज के साथ अपने-आप इंस्टॉल हो जाएगा. आपके पास सिर्फ़ LiteRT Interpreter pip पैकेज इंस्टॉल करने का विकल्प भी है.

मेट्रिक

परफ़ॉर्मेंस

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

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

बाइनरी का साइज़

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

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

सीमाएं

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

अपडेट

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