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

अपने बिल्ड.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 नेटिव डेवलपमेंट किट, Android सॉफ़्टवेयर से नियंत्रित होगी डेवलपमेंट किट लाइसेंस समझौता यहां उपलब्ध है: https://developer.android.com/studio/terms (ऐसे यूआरएल को अपडेट किया जा सकता है या बदला जा सकता है समय-समय पर Google की तरफ़ से).

अभी तक किसी भी व्यक्ति ने चेक इन नहीं किया है इसे डाउनलोड करने के लिए आपको सेवा की शर्तें स्वीकार करनी होंगी फ़ाइल से लिए जाते हैं.

  • आपके पास Android SDK या NDK वर्शन को बदलने का विकल्प भी है. डाउनलोड की गई फ़ाइल को रखें Docker फ़ाइल का इस्तेमाल किसी खाली फ़ोल्डर में करें और इसे चलाकर अपनी डॉकर इमेज बनाएं:
docker build . -t tflite-builder -f tflite-android.Dockerfile
  • अपने मौजूदा फ़ोल्डर को कंटेनर के अंदर /host_ आराम है (ध्यान दें कि /tensorflow_src, TensorFlow है कंटेनर के अंदर रिपॉज़िटरी:
docker run -it -v $PWD:/host_dir tflite-builder bash

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

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

  • कंटेनर के अंदर आने के बाद, डाउनलोड करने के लिए नीचे दिया गया तरीका अपनाएं अतिरिक्त Android टूल और लाइब्रेरी का इस्तेमाल करते हैं (ध्यान दें कि आपको लाइसेंस):
sdkmanager \
  "build-tools;${ANDROID_BUILD_TOOLS_VERSION}" \
  "platform-tools" \
  "platforms;android-${ANDROID_API_LEVEL}"

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

लाइब्रेरी बनाने के बाद, आप उन्हें /host_dr में कॉपी कर सकते हैं ताकि आप उन्हें होस्ट पर ऐक्सेस कर सकें.

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

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

TensorFlow का मुख्य बिल्ड सिस्टम Baज़ल है. इसके साथ बनाने के लिए, आपको इसे और अपने सिस्टम पर Android एनडीके (NDK) और SDK टूल इंस्टॉल करें.

  1. Basel बिल्ड सिस्टम का सबसे नया वर्शन इंस्टॉल करें.
  2. नेटिव (C/C++) LiteRT बनाने के लिए, Android एनडीके (NDK) की ज़रूरत होती है कोड. फ़िलहाल, सुझाया गया वर्शन 25b है, जिसे यहां पढ़ें.
  3. आपको Android SDK टूल और बिल्ड टूल मिल सकते हैं, यहां या वैकल्पिक रूप से Android Studio. बिल्ड LiteRT बनाने के लिए, Tools API >= 23 सुझाया गया वर्शन है.

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

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

  • 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"

बिल्ड और इंस्टॉल करें

Basel के सही तरीके से कॉन्फ़िगर हो जाने के बाद, 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-lite-select-tf-ops.aar फ़ाइल, अगर कोई एक मॉडल इस्तेमाल किया जा रहा है TensorFlow ops. ज़्यादा जानकारी के लिए, कृपया यह देखें litRT बाइनरी साइज़ कम करें सेक्शन.

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

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

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 रिपॉज़िटरी में AAR इंस्टॉल करें

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

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 अनुमान एपीआई.