Android के लिए LiteRT बनाएं

इस दस्तावेज़ में, LiteRT Android लाइब्रेरी को खुद बनाने का तरीका बताया गया है. आम तौर पर, आपको LiteRT 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'
        }
    }
}

अपनी build.gradle फ़ाइल में, डिपेंडेंसी में नाइटली स्नैपशॉट जोड़ें या ज़रूरत के मुताबिक बदलाव करें

...
dependencies {
    ...
    implementation 'org.tensorflow:tensorflow-lite:0.0.0-nightly-SNAPSHOT'
    implementation 'com.google.ai.edge.litert:litert-gpu:0.0.0-nightly-SNAPSHOT'
    implementation 'com.google.ai.edge.litert:litert-support:0.0.0-nightly-SNAPSHOT'
    ...
}
...

LiteRT को स्थानीय तौर पर बनाना

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

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

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

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

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

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

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

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

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

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

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

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

अब आपको WORKSPACE और .bazelrc को कॉन्फ़िगर करें सेक्शन पर जाकर, बिल्ड सेटिंग कॉन्फ़िगर करनी चाहिए.

लाइब्रेरी बनाने के बाद, उन्हें कंटेनर में मौजूद /host_dir फ़ोल्डर में कॉपी किया जा सकता है. इससे, होस्ट पर उन्हें ऐक्सेस किया जा सकता है.

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

Bazel और Android की ज़रूरी शर्तें पूरी करना

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

1. Bazel build system का नया वर्शन इंस्टॉल करें.
2. नेटिव (C/C++) LiteRT कोड बनाने के लिए, Android NDK की ज़रूरत होती है. फ़िलहाल, सुझाया गया वर्शन 25b है. इसे यहां देखा जा सकता है.
   1. Android SDK और बिल्ड टूल यहां से डाउनलोड किए जा सकते हैं. इसके अलावा, इन्हें Android Studio के साथ भी डाउनलोड किया जा सकता है. टूल बनाएं LiteRT बनाने के लिए, API >= 23 वर्शन का इस्तेमाल करने का सुझाव दिया जाता है.

WORKSPACE और .bazelrc कॉन्फ़िगर करना

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

• 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 को सही तरीके से कॉन्फ़िगर करने के बाद, रूट चेकआउट डायरेक्ट्री से LiteRT 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/ में एक एएआर फ़ाइल जनरेट होगी. ध्यान दें कि इससे कई अलग-अलग आर्किटेक्चर वाला "फ़ैट" एएआर बनता है. अगर आपको इन सभी की ज़रूरत नहीं है, तो अपने डिप्लॉयमेंट एनवायरमेंट के लिए सही सबसेट का इस्तेमाल करें.

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

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

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

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

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

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

एएआर को लोकल 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() डिपेंडेंसी हो. साथ ही, स्टैंडर्ड 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'
}

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