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

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

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

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

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

नीचे दिए गए उदाहरण में, चुने गए विकल्प का इस्तेमाल करके LiteRT मॉडल जनरेट करने का तरीका बताया गया है TensorFlow ऑपरेशन

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 मॉडल का इस्तेमाल किया जा रहा हो जिसे TensorFlow ops चुनने पर, क्लाइंट को LiteRT रनटाइम का भी इस्तेमाल करना होगा, जो इसमें TensorFlow ops की ज़रूरी लाइब्रेरी शामिल है.

Android एएआर

बाइनरी साइज़ को कम करने के लिए, कृपया निर्देशों के मुताबिक अपनी पसंद के मुताबिक AAR फ़ाइलें बनाएं अगला सेक्शन देखें. अगर बाइनरी साइज़ हालांकि, हमारा सुझाव है कि TensorFlow ऑपरेशन के साथ पहले से बने AAR का इस्तेमाल करें पर होस्ट किया गया 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'
}

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

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

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

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

Android एएआर बनाना

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

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

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

यहां से, 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 के लिए हर रात पहले से बने चुनिंदा TF Ops CocoaPods को उपलब्ध कराता है, यह TensorFlowLiteSwift या TensorFlowLiteObjC कोको-पॉड.

ध्यान दें: अगर आपको किसी x86_64 सिम्युलेटर में चुनिंदा TF ऑपरेशन का इस्तेमाल करना है, तो चुनें Ops फ़्रेमवर्क. 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

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

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

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

iOS के लिए चुनिंदा TensorFlow ops के साथ LiteRT को Basel का इस्तेमाल करके बनाया जा सकता है. सबसे पहले, अपने ऐप्लिकेशन की सुरक्षा कुंजियों को कॉन्फ़िगर करने के लिए, iOS बिल्ड निर्देशों का पालन करें बेज़ल वर्कस्पेस और .bazelrc फ़ाइल सही तरीके से मौजूद हैं.

iOS सहायता चालू करके फ़ाइल फ़ोल्डर को कॉन्फ़िगर करने के बाद, कमांड का इस्तेमाल करें, जिससे चुनिंदा TF ops ऐड-ऑन फ़्रेमवर्क बनाया जा सकता है, नियमित 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 प्रोजेक्ट में यह नया फ़्रेमवर्क जोड़ने के लिए, यहां दिए गए निर्देशों का पालन करें: Xcode प्रोजेक्ट में बताए गए मिलते-जुलते चरण सेटिंग सेक्शन में iOS बिल्ड गाइड.

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

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

सी/सी++

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

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

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

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

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

Python

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

मेट्रिक

परफ़ॉर्मेंस

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

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

बाइनरी साइज़

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

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

सीमाएं

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

अपडेट

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