Google Play services के रनटाइम में LiteRT की मदद से, अपने ऐप्लिकेशन में LiteRT लाइब्रेरी को स्टैटिक तौर पर बंडल किए बिना, मशीन लर्निंग (एमएल) मॉडल चलाए जा सकते हैं. इस गाइड में, Google Play services के लिए C या C++ एपीआई इस्तेमाल करने का तरीका बताया गया है.
Google Play services के C API या C++ API में LiteRT का इस्तेमाल करने से पहले, पक्का करें कि आपने CMake बिल्ड टूल इंस्टॉल किया हो.
अपना बिल्ड कॉन्फ़िगरेशन अपडेट करना
(1) LiteRT के लिए Play services API को ऐक्सेस करने के लिए, अपने ऐप्लिकेशन प्रोजेक्ट कोड में ये डिपेंडेंसी जोड़ें:
implementation "com.google.android.gms:play-services-tflite-java:16.4.0"
ध्यान दें कि पैकेज का नाम -java
पर खत्म होता है, लेकिन उस पैकेज में C और C++ एपीआई भी शामिल होते हैं.
(2) इसके बाद, अपनी CMake स्क्रिप्ट से C API को ऐक्सेस करने के लिए, Prefab सुविधा चालू करें. इसके लिए, अपने मॉड्यूल की build.gradle फ़ाइल के Android ब्लॉक को अपडेट करें:
buildFeatures {
prefab = true
}
(3) [सिर्फ़ C++ एपीआई के लिए] अगर C++ एपीआई का इस्तेमाल किया जा रहा है, तो tflite-java-extract-cpp-sdk.gradle को अपने प्रोजेक्ट की app
डायरेक्ट्री में कॉपी करें. इसके बाद, अपने ऐप्लिकेशन की gradle स्क्रिप्ट (उदाहरण के लिए, app/build.gradle
) की शुरुआत में यह जोड़ें:
apply from: 'tflite-java-extract-cpp-sdk.gradle'
इसमें Gradle कोड शामिल है, ताकि play-services-tflite-java
के लिए AAR फ़ाइल से C++ SDK टूल अपने-आप अनपैक हो जाए.
(4) [सिर्फ़ C++ एपीआई के लिए] अगर C++ एपीआई का इस्तेमाल किया जा रहा है, तो वह डायरेक्ट्री ढूंढें जिसमें आपके ऐप्लिकेशन की CMake कॉन्फ़िगरेशन फ़ाइल (आम तौर पर CMakeLists.txt
) होती है. आम तौर पर, वह डायरेक्ट्री आपकी app/src/main/cpp
डायरेक्ट्री होती है. इसके बाद, Findtflite_cc_api.cmake को अपने प्रोजेक्ट में कॉपी करें. साथ ही, उस डायरेक्ट्री की नई Modules
सबडायरेक्ट्री में चिपकाएं.
इसमें वह कोड होता है जो पिछले चरण में, Gradle स्क्रिप्ट से अनपैक किए गए C++ SDK टूल को ढूंढता है.
(5) आपको आखिर में पैकेज tensorflowlite_jni_gms_client
जोड़ना होगा. साथ ही, C++ API के लिए पैकेज tflite_cc_api
भी जोड़ना होगा. दोनों पैकेज, CMake स्क्रिप्ट में डिपेंडेंसी के तौर पर AAR से इंपोर्ट किए जाते हैं:
C
``` find_package(tensorflowlite_jni_gms_client REQUIRED CONFIG) # Set up C/C++ compiler flags to enable the use of TFLite in Play services # (rather than regular TFLite bundled with the app). add_compile_definitions(TFLITE_IN_GMSCORE) add_compile_definitions(TFLITE_WITH_STABLE_ABI) target_link_libraries(tflite-jni # your JNI lib target tensorflowlite_jni_gms_client::tensorflowlite_jni_gms_client android # other deps for your target log) ```C++
``` # Play services C API (tensorflowlite_jni_gms_client) की डिपेंडेंसी में TFLite सेट अप करें. find_package(tensorflowlite_jni_gms_client REQUIRED CONFIG) # Set up TFLite in Play services C++ API (tflite_cc_api) dependency. list(PREPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/Modules") find_package(tflite_cc_api REQUIRED MODULE) include_directories(${tflite_cc_api_INCLUDE_DIR}) add_subdirectory(${tflite_cc_api_DIR} tflite_cc_api_build) # Set up C/C++ compiler flags to enable use of TFLite in Play services # (rather than regular TFLite bundled with the app). add_compile_definitions(TFLITE_IN_GMSCORE) add_compile_definitions(TFLITE_WITH_STABLE_ABI) target_link_libraries(tflite-jni # your JNI lib target tflite_cc_api::tflite_cc_api tensorflowlite_jni_gms_client::tensorflowlite_jni_gms_client android # other deps for your target log) ```LiteRT रनटाइम को शुरू करना
LiteRT नेटिव एपीआई को कॉल करने से पहले, आपको अपने Java या Kotlin कोड में TfLiteNative
रनटाइम को शुरू करना होगा.
Java
Task tfLiteInitializeTask = TfLiteNative.initialize(context);
Kotlin
val tfLiteInitializeTask: Task= TfLiteNative.initialize(context)
Google Play services के Task API का इस्तेमाल करके, TfLiteNative.initialize
Google Play services से TFLite रनटाइम को ऐप्लिकेशन की रनटाइम प्रोसेस में, एक साथ लोड करता है. addOnSuccessListener()
का इस्तेमाल करके, यह पक्का करें कि LiteRT APIs को ऐक्सेस करने वाले कोड को लागू करने से पहले, TfLite.initialize()
टास्क पूरा हो जाए. टास्क पूरा होने के बाद, सभी उपलब्ध TFLite नेटिव एपीआई को ट्रिगर किया जा सकता है.
नेटिव कोड लागू करना
अपने C/C++ कोड के साथ Google Play services में LiteRT का इस्तेमाल करने के लिए, इनमें से कोई एक (या दोनों) तरीका अपनाएं:
- अपने Java कोड से C या C++ फ़ंक्शन को कॉल करने के लिए, नए JNI फ़ंक्शन का एलान करना
- अपने मौजूदा C या C++ कोड से LiteRT नेटिव एपीआई को कॉल करें.
JNI फ़ंक्शन
C/C++ कोड में बताए गए LiteRT रनटाइम को अपने Java/Kotlin कोड में ऐक्सेस करने के लिए, नए JNI फ़ंक्शन का एलान किया जा सकता है. इसके लिए, यह तरीका अपनाएं:
Java
package com.google.samples.gms.tflite.c; public class TfLiteJni { static { System.loadLibrary("tflite-jni"); } public TfLiteJni() { /**/ }; public native void loadModel(AssetManager assetManager, String assetName); public native float[] runInference(float[] input); // For example. }
Kotlin
package com.google.samples.gms.tflite.c class TfLiteJni() { companion object { init { System.loadLibrary("tflite-jni") } } external fun loadModel(assetManager: AssetManager, assetName: String) external fun runInference(input: FloatArray): FloatArray // For example. }
नीचे दिए गए loadModel
और runInference
C या C++ फ़ंक्शन से मैच करने वाले:
#ifdef __cplusplus
extern "C" {
#endif
void Java_com_google_samples_gms_tflite_c_loadModel(
JNIEnv *env, jobject tflite_jni, jobject asset_manager, jstring asset_name){
//...
}
jfloatArray Java_com_google_samples_gms_tflite_c_TfLiteJni_runInference(
JNIEnv* env, jobject tfliteJni, jfloatArray input) {
//...
}
#ifdef __cplusplus
} // extern "C".
#endif
इसके बाद, अपने Java/Kotlin कोड से C/C++ फ़ंक्शन को कॉल किया जा सकता है:
Java
tfLiteHandleTask.onSuccessTask(unused -> { TfLiteJni jni = new TfLiteJni(); jni.loadModel(getAssets(), "add.bin"); //... });
Kotlin
tfLiteHandleTask.onSuccessTask { val jni = TfLiteJni() jni.loadModel(assets, "add.bin") // ... }
नेटिव कोड में LiteRT
Google Play services API के साथ LiteRT को शामिल करने के लिए, सही एपीआई हेडर फ़ाइल शामिल करें:
C
``` #include "tensorflow/lite/c/c_api.h" ```C++
``` #include "tensorflow/lite/interpreter.h" #include "tensorflow/lite/model_builder.h" ```इसके बाद, सामान्य LiteRT C या C++ API का इस्तेमाल किया जा सकता है: