Android के लिए TensorFlow Lite बनाएं

इस दस्तावेज़ में, TensorFlow Lite की Android लाइब्रेरी बनाने का तरीका बताया गया है. आम तौर पर, आपको स्थानीय स्तर पर TensorFlow Lite Android लाइब्रेरी बनाने की ज़रूरत नहीं होती.

हर रात के स्नैपशॉट का इस्तेमाल करना

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

allprojects {
    repositories {      // should be already there
        mavenCentral()  // should be already there
        maven {         // add this repo to use snapshots
          name 'ossrh-snapshot'
          url 'https://oss.sonatype.org/content/repositories/snapshots'
        }
    }
}

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

...
dependencies {
    ...
    implementation 'org.tensorflow:tensorflow-lite:0.0.0-nightly-SNAPSHOT'
    implementation 'org.tensorflow:tensorflow-lite-gpu:0.0.0-nightly-SNAPSHOT'
    implementation 'org.tensorflow:tensorflow-lite-support:0.0.0-nightly-SNAPSHOT'
    ...
}
...

स्थानीय तौर पर TensorFlow Lite बनाएं

कुछ मामलों में, ऐसा हो सकता है कि आप TensorFlow Lite के लोकल बिल्ड का इस्तेमाल करना चाहें. उदाहरण के लिए, हो सकता है कि आपने एक कस्टम बाइनरी बनाई हो, जिसमें TensorFlow से चुने गए ऑपरेशन शामिल हों या फिर TensorFlow Lite में स्थानीय बदलाव किए जा सकते हैं.

Docker का इस्तेमाल करके बिल्ड एनवायरमेंट सेट अप करें

• Docker फ़ाइल डाउनलोड करें. Docker फ़ाइल डाउनलोड करने का मतलब है कि आप इस बात की सहमति देते हैं कि आपके इस्तेमाल पर, सेवा की ये शर्तें लागू होंगी:

'स्वीकार करने के लिए क्लिक करें' पर क्लिक करने का मतलब है कि आप इस बात से सहमत हैं कि Android Studio और Android नेटिव डेवलपमेंट किट के सभी इस्तेमाल, https://developer.android.com/studio/terms पर उपलब्ध Android सॉफ़्टवेयर डेवलपमेंट किट लाइसेंस के कानूनी समझौते से नियंत्रित किए जाएंगे. Google समय-समय पर इस तरह के यूआरएल को अपडेट या बदल सकता है.

फ़ाइल डाउनलोड करने के लिए, आपको सेवा की शर्तों को स्वीकार करना होगा. स्वीकार करें

• आपके पास Android SDK या एनडीके वर्शन को बदलने का विकल्प भी होता है. डाउनलोड की गई Docker फ़ाइल को किसी खाली फ़ोल्डर में रखें और यह चलाकर अपनी डॉकर इमेज बनाएं:

docker build . -t tflite-builder -f tflite-android.Dockerfile

• अपने मौजूदा फ़ोल्डर को कंटेनर के अंदर /host_direct पर माउंट करके, डॉकर कंटेनर को इंटरैक्टिव तरीके से शुरू करें. ध्यान दें कि /tenorflow_src, कंटेनर के अंदर TensorFlow डेटा स्टोर करने की जगह है:

docker run -it -v $PWD:/host_dir tflite-builder bash

अगर Windows पर PowerShell का इस्तेमाल किया जाता है, तो "$PWD" की जगह "pwd" डालें.

अगर आपको होस्ट पर, TensorFlow का डेटा स्टोर करने की जगह का इस्तेमाल करना है, तो उस होस्ट डायरेक्ट्री को माउंट करें (-vhostDir:/host_dar).

• कंटेनर के अंदर पहुंचने के बाद, अतिरिक्त Android टूल और लाइब्रेरी डाउनलोड करने के लिए, इन को चलाया जा सकता है (ध्यान दें कि आपको लाइसेंस स्वीकार करना पड़ सकता है):

sdkmanager \
  "build-tools;${ANDROID_BUILD_TOOLS_VERSION}" \
  "platform-tools" \
  "platforms;android-${ANDROID_API_LEVEL}"

अब बिल्ड सेटिंग कॉन्फ़िगर करने के लिए, वर्कस्पेस और .bazelrc कॉन्फ़िगर करें सेक्शन पर जाएं.

लाइब्रेरी बनाने के बाद, उन्हें कंटेनर के अंदर /host_direct में कॉपी करें, ताकि उन्हें होस्ट पर ऐक्सेस किया जा सके.

Docker के बिना बिल्ड एनवायरमेंट सेट अप करें

Bazel और Android की ज़रूरी शर्तें इंस्टॉल करें

Bazel, TensorFlow का मुख्य बिल्ड सिस्टम है. इसे बनाने के लिए, आपके सिस्टम पर इसे और Android एनडीके और SDK टूल इंस्टॉल होना चाहिए.

1. Bazel बिल्ड सिस्टम का सबसे नया वर्शन इंस्टॉल करें.
2. नेटिव (C/C++) TensorFlow लाइट कोड बनाने के लिए, Android एनडीके होना ज़रूरी है. फ़िलहाल, हम 25b वर्शन का सुझाव देते हैं, जो यहां देखा जा सकता है.
3. Android SDK और बिल्ड टूल यहां से या Android Studio के हिस्से के तौर पर मिल सकते हैं. TensorFlow Lite बनाने के लिए, बिल्ड टूल एपीआई >= 23 का सुझाव दिया जाता है.

Workspace और .bazelrc को कॉन्फ़िगर करें

TF Lite लाइब्रेरी बनाने के लिए, इसे एक बार कॉन्फ़िगर करना ज़रूरी है. TensorFlow की चेकआउट डायरेक्ट्री में ./configure स्क्रिप्ट चलाएं. जब स्क्रिप्ट आपसे Android बिल्ड के लिए, ./WORKSPACE को इंटरैक्टिव तरीके से कॉन्फ़िगर करने के लिए कहे, तब "हां" में जवाब दें. स्क्रिप्ट नीचे दिए गए एनवायरमेंट वैरिएबल का इस्तेमाल करके सेटिंग कॉन्फ़िगर करने की कोशिश करेगी:

• ANDROID_SDK_HOME
• ANDROID_SDK_API_LEVEL
• ANDROID_NDK_HOME
• ANDROID_NDK_API_LEVEL

अगर ये वैरिएबल सेट नहीं हैं, तो उन्हें स्क्रिप्ट में दिए गए प्रॉम्प्ट में इंटरैक्टिव तरीके से दिया जाना चाहिए. कॉन्फ़िगर होने पर, रूट फ़ोल्डर में .tf_configure.bazelrc फ़ाइल में जो एंट्री होती हैं उनसे मिलती-जुलती एंट्री होनी चाहिए:

build --action_env ANDROID_NDK_HOME="/usr/local/android/android-ndk-r25b"
build --action_env ANDROID_NDK_API_LEVEL="21"
build --action_env ANDROID_BUILD_TOOLS_VERSION="30.0.3"
build --action_env ANDROID_SDK_API_LEVEL="30"
build --action_env ANDROID_SDK_HOME="/usr/local/android/android-sdk-linux"

बनाएं और इंस्टॉल करें

Bazel को सही तरीके से कॉन्फ़िगर करने के बाद, रूट चेकआउट डायरेक्ट्री से TensorFlow Lite AAR बनाने के लिए, यह तरीका अपनाएं:

bazel build -c opt --cxxopt=--std=c++17 --config=android_arm64 \
  --fat_apk_cpu=x86,x86_64,arm64-v8a,armeabi-v7a \
  --define=android_dexmerger_tool=d8_dexmerger \
  --define=android_incremental_dexing_tool=d8_dexbuilder \
  //tensorflow/lite/java:tensorflow-lite

इससे bazel-bin/tensorflow/lite/java/ में एक AAR फ़ाइल जनरेट होगी. ध्यान दें कि यह कई अलग-अलग आर्किटेक्चर के साथ "फ़ैट" वाला एएआर बनाता है. अगर आपको सभी की ज़रूरत नहीं है, तो अपने डिप्लॉयमेंट एनवायरमेंट के हिसाब से सही सबसेट का इस्तेमाल करें.

सिर्फ़ मॉडल के सेट को टारगेट करने वाली छोटी AAR फ़ाइलें बनाई जा सकती हैं, जैसा कि यहां बताया गया है:

bash tensorflow/lite/tools/build_aar.sh \
  --input_models=model1,model2 \
  --target_archs=x86,x86_64,arm64-v8a,armeabi-v7a

अगर कोई मॉडल Tensorflow ops का इस्तेमाल कर रहा है, तो ऊपर दी गई स्क्रिप्ट tensorflow-lite.aar फ़ाइल और विकल्प के तौर पर tensorflow-lite-select-tf-ops.aar फ़ाइल जनरेट करेगी. ज़्यादा जानकारी के लिए, कृपया TensorFlow Lite का बाइनरी साइज़ कम करें सेक्शन देखें.

एएआर को सीधे प्रोजेक्ट में जोड़ें

अपने प्रोजेक्ट में, tensorflow-lite.aar फ़ाइल को libs नाम की डायरेक्ट्री में ले जाएं. नई डायरेक्ट्री से रेफ़रंस देने के लिए, अपने ऐप्लिकेशन की build.gradle फ़ाइल में बदलाव करें और नई लोकल लाइब्रेरी से मौजूदा TensorFlow Lite डिपेंडेंसी बदलें, उदाहरण के लिए:

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

dependencies {
    compile(name:'tensorflow-lite', ext:'aar')
}

AAR को लोकल Maven रिपॉज़िटरी में इंस्टॉल करें

अपनी रूट चेकआउट डायरेक्ट्री से, नीचे दिया गया निर्देश चलाएं:

mvn install:install-file \
  -Dfile=bazel-bin/tensorflow/lite/java/tensorflow-lite.aar \
  -DgroupId=org.tensorflow \
  -DartifactId=tensorflow-lite -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'
}

ध्यान दें कि यहां 0.1.100 वर्शन सिर्फ़ टेस्टिंग/डेवलपमेंट के लिए है. लोकल एएआर इंस्टॉल करके, अपने ऐप्लिकेशन कोड में स्टैंडर्ड TensorFlow Lite Java के अनुमान वाले एपीआई का इस्तेमाल किया जा सकता है.