इस पेज का अनुवाद Cloud Translation API से किया गया है.

TensorFlow ऑपरेटरों का चयन करें

चूंकि TensorFlow Lite बिलिन ऑपरेटर लाइब्रेरी केवल सीमित संख्या में TensorFlow ऑपरेटरों का समर्थन करती है, प्रत्येक मॉडल परिवर्तनीय नहीं है। विवरण के लिए, ऑपरेटर संगतता देखें।

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

यह दस्तावेज़ बताता है कि आपकी पसंद के प्लेटफ़ॉर्म पर TensorFlow ऑप्स वाले TensorFlow Lite मॉडल को कैसे परिवर्तित और चलाया जाए। यह प्रदर्शन और आकार मेट्रिक्स और ज्ञात सीमाओं पर भी चर्चा करता है।

एक मॉडल कनवर्ट करें

निम्न उदाहरण दिखाता है कि चुनिंदा 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 लाइट मॉडल का उपयोग करते समय, जिसे TensorFlow ऑप्स के लिए समर्थन के साथ परिवर्तित किया गया है, क्लाइंट को TensorFlow लाइट रनटाइम का भी उपयोग करना चाहिए जिसमें TensorFlow ops की आवश्यक लाइब्रेरी शामिल है।

एंड्रॉइड एएआर

बाइनरी आकार को कम करने के लिए, कृपया अपनी खुद की कस्टम एएआर फाइलें बनाएं जैसा कि अगले भाग में निर्देशित है। यदि बाइनरी आकार एक महत्वपूर्ण चिंता का विषय नहीं है, तो हम MavenCentral पर होस्ट किए गए TensorFlow ops के साथ पूर्वनिर्मित AAR का उपयोग करने की सलाह देते हैं।

आप इसे मानक TensorFlow Lite AAR के साथ जोड़कर अपनी build.gradle निर्भरता में निर्दिष्ट कर सकते हैं:

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 ऑप्स को संभालने के लिए आवश्यक प्रतिनिधि को उन ग्राफ़ के लिए स्वचालित रूप से स्थापित किया जाना चाहिए जिनकी उन्हें आवश्यकता होती है।

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

Android AAR . का निर्माण

बाइनरी आकार या अन्य उन्नत मामलों को कम करने के लिए, आप मैन्युअल रूप से पुस्तकालय भी बना सकते हैं। एक काम कर रहे TensorFlow Lite बिल्ड वातावरण को मानते हुए, चुनिंदा TensorFlow ops के साथ 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 ops के लिए AAR फ़ाइल bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar जनरेट करें। यदि आपके पास वर्किंग बिल्ड एनवायरनमेंट नहीं है, तो आप उपरोक्त फाइलों को docker के साथ भी बना सकते हैं।

वहां से, आप या तो सीधे अपनी परियोजना में एएआर फाइलों को आयात कर सकते हैं, या कस्टम एएआर फाइलों को अपने स्थानीय मावेन भंडार में प्रकाशित कर सकते हैं:

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 ops के लिए समर्थन है:

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'
}

आईओएस

CocoaPods का उपयोग करना

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

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

pod install चलाने के बाद, आपको अपने प्रोजेक्ट में चुनिंदा TF ऑप्स फ्रेमवर्क को लोड करने के लिए एक अतिरिक्त लिंकर फ्लैग प्रदान करना होगा। अपने एक्सकोड प्रोजेक्ट में, 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 के साथ परिवर्तित किसी भी मॉडल को चलाने में सक्षम होना चाहिए। उदाहरण के लिए, आप चुनिंदा TF ऑप्स सुविधा का परीक्षण करने के लिए छवि वर्गीकरण iOS ऐप को संशोधित कर सकते हैं।

मॉडल फ़ाइल को SELECT_TF_OPS सक्षम के साथ परिवर्तित फ़ाइल से बदलें।
निर्देश के अनुसार Podfile में TensorFlowLiteSelectTfOps निर्भरता जोड़ें।
ऊपर के रूप में अतिरिक्त लिंकर ध्वज जोड़ें।
उदाहरण ऐप चलाएँ और देखें कि क्या मॉडल सही तरीके से काम करता है।

Bazel + Xcode का उपयोग करना

TensorFlow Lite को iOS के लिए चुनिंदा TensorFlow ops के साथ Bazel का उपयोग करके बनाया जा सकता है। सबसे पहले, अपने Bazel कार्यक्षेत्र और .bazelrc फ़ाइल को सही ढंग से कॉन्फ़िगर करने के लिए iOS बिल्ड निर्देशों का पालन करें।

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

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

यह bazel-bin/tensorflow/lite/ios/ निर्देशिका के तहत ढांचा तैयार करेगा। आप आईओएस बिल्ड गाइड में एक्सकोड प्रोजेक्ट सेटिंग्स सेक्शन के तहत वर्णित समान चरणों का पालन करके इस नए ढांचे को अपने एक्सकोड प्रोजेक्ट में जोड़ सकते हैं।

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

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

सी/सी++

यदि आप TensorFlow Lite दुभाषिया बनाने के लिए Bazel या CMake का उपयोग कर रहे हैं, तो आप TensorFlow Lite Flex प्रतिनिधि साझा लाइब्रेरी को लिंक करके Flex प्रतिनिधि को सक्षम कर सकते हैं। आप इसे निम्न आदेश के रूप में बेज़ल के साथ बना सकते हैं।

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

यह कमांड निम्नलिखित साझा लाइब्रेरी को bazel-bin/tensorflow/lite/delegates/flex में जनरेट करता है।

प्लैटफ़ॉर्म	पुस्तकालय का नाम
लिनक्स	libtensorflowlite_flex.so
मैक ओएस	libtensorflowlite_flex.dylib
खिड़कियाँ	tensorflowlite_flex.dll

ध्यान दें कि जब तक साझा लाइब्रेरी लिंक है तब तक रनटाइम पर दुभाषिया बनाते समय आवश्यक TfLiteDelegate स्वचालित रूप से स्थापित हो जाएगा। प्रतिनिधि उदाहरण को स्पष्ट रूप से स्थापित करना आवश्यक नहीं है जैसा कि आमतौर पर अन्य प्रतिनिधि प्रकारों के साथ आवश्यक होता है।

अजगर

चुनिंदा TensorFlow ops के साथ TensorFlow Lite, TensorFlow pip पैकेज के साथ स्वचालित रूप से इंस्टॉल हो जाएगा। आप केवल TensorFlow Lite Interpreter pip पैकेज को स्थापित करना भी चुन सकते हैं।

मैट्रिक्स

प्रदर्शन

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

निम्न तालिका पिक्सेल 2 पर मोबाइलनेट पर अनुमान चलाने में लगने वाले औसत समय का वर्णन करती है। सूचीबद्ध समय औसतन 100 रन हैं। ये लक्ष्य एंड्रॉइड के लिए झंडे का उपयोग करके बनाए गए थे: --config=android_arm64 -c opt ।

बनाना	समय (मिलीसेकंड)
केवल अंतर्निहित संचालन ( `TFLITE_BUILTIN` )	260.7
केवल TF ऑप्स का उपयोग करना ( `SELECT_TF_OPS` )	264.5

बाइनरी आकार

निम्न तालिका प्रत्येक बिल्ड के लिए TensorFlow Lite के बाइनरी आकार का वर्णन करती है। ये लक्ष्य Android के लिए --config=android_arm -c opt का उपयोग करके बनाए गए थे।

बनाना	सी++ बाइनरी साइज	एंड्रॉइड एपीके आकार
केवल बिल्ट-इन ऑप्स	796 केबी	561 केबी
बिल्ट-इन ऑप्स + TF ऑप्स	23.0 एमबी	8.0 एमबी
बिल्ट-इन ऑप्स + TF ऑप्स (1)	4.1 एमबी	1.8 एमबी

(1) इन पुस्तकालयों को चुनिंदा रूप से i3d-kinetics-400 मॉडल के लिए 8 TFLite बिलिन ऑप्स और 3 Tensorflow ops के साथ बनाया गया है। अधिक विवरण के लिए, कृपया TensorFlow Lite बाइनरी आकार अनुभाग को कम करें देखें।

ज्ञात सीमाएं

असमर्थित प्रकार: कुछ TensorFlow ops इनपुट/आउटपुट प्रकारों के पूरे सेट का समर्थन नहीं कर सकते हैं जो आमतौर पर TensorFlow में उपलब्ध होते हैं।

अपडेट

संस्करण 2.6
- ग्राफडिफ-विशेषता आधारित ऑपरेटरों के लिए समर्थन और हैशटेबल संसाधन आरंभीकरण में सुधार हुआ है।
संस्करण 2.5
- आप एक अनुकूलन लागू कर सकते हैं जिसे प्रशिक्षण के बाद के परिमाणीकरण के रूप में जाना जाता है
संस्करण 2.4
- हार्डवेयर त्वरित प्रतिनिधियों के साथ संगतता में सुधार हुआ है