LiteRT në shërbimet e Google Play C dhe C++ API

LiteRT në kohën e ekzekutimit të shërbimeve të Google Play ju lejon të ekzekutoni modelet e mësimit të makinerive (ML) pa bashkuar në mënyrë statike bibliotekat LiteRT në aplikacionin tuaj. Ky udhëzues ofron udhëzime se si të përdorni API-të C ose C++ për shërbimet e Google Play.

Përpara se të punoni me LiteRT në shërbimet e Google Play C API ose C++ API, sigurohuni që të keni të instaluar mjetin e ndërtimit CMake .

Përditëso konfigurimin e ndërtimit

(1) Shtoni varësitë e mëposhtme në kodin e projektit të aplikacionit tuaj për të hyrë në API të shërbimeve të Play për LiteRT:

implementation "com.google.android.gms:play-services-tflite-java:16.4.0"

Vini re se megjithëse emri i paketës përfundon në -java , ajo paketë përmban gjithashtu API-të C dhe C++.

(2) Më pas, aktivizoni funksionin Prefab për të hyrë në C API nga skripti juaj CMake duke përditësuar bllokun android të skedarit build.gradle të modulit tuaj:

buildFeatures {
  prefab = true
}

(3) [Vetëm API C++] Nëse jeni duke përdorur API-në C++, kopjoni tflite-java-extract-cpp-sdk.gradle në projektin tuaj, në drejtorinë e app tuaj dhe shtoni sa vijon në fillim të skriptit gradle të aplikacionit tuaj ( p.sh. app/build.gradle ):

apply from: 'tflite-java-extract-cpp-sdk.gradle'

Ky përmban kodin Gradle për të shpaketuar automatikisht SDK-në e C++ nga skedari AAR për play-services-tflite-java .

(4) [Vetëm API C++] Nëse jeni duke përdorur API-në C++, gjeni direktorinë që përmban skedarin e konfigurimit CMake të aplikacionit tuaj (normalisht CMakeLists.txt ); ajo direktori është normalisht direktoria juaj app/src/main/cpp . Pastaj kopjoni Findtflite_cc_api.cmake në projektin tuaj, në një nëndrejtori të re Modules të asaj direktorie. Ky përmban kodin që gjen SDK-në C++ të zbërthyer nga skripti Gradle në hapin e mëparshëm.

(5) Më në fund duhet të shtoni paketën tensorflowlite_jni_gms_client , dhe për API-në C++ gjithashtu paketën tflite_cc_api , që të dyja importohen nga AAR, si varësi në skriptin tuaj CMake:

C

``` find_package(tensorflowlite_jni_gms_client KËRKOHET CONFIG) # Konfiguro flamujt e përpiluesit C/C++ për të mundësuar përdorimin e TFLite në shërbimet e Play # (në vend të TFLite të zakonshme të bashkuar me aplikacionin). add_compile_definitions(TFLITE_IN_GMSCORE) add_compile_definitions(TFLITE_WITH_STABLE_ABI) target_link_libraries(tflite-jni # objektivi juaj i JNI lib tensorflowlite_jni_gms_client::tensorflowlite_definitions `TFLITE_WITH_STABLE_ABI) target_link_libraries(tflite-jni # objektivi juaj i JNI lib tensorflowlite_jni_gms_client::tensorflowlite_gms_client::tensorflowlite_ps log #jni_g

C++

``` # Konfiguro TFLite në varësinë C API të shërbimeve të Play (tensorflowlite_jni_gms_client). find_package(tensorflowlite_jni_gms_client KËRKOHET CONFIG) # Konfiguro TFLite në varësinë C++ API të shërbimeve të Play (tflite_cc_api). list(PREPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/Modules") find_package(tflite_cc_api MODULE KËRKOHET) include_directories(${tflite_cc_api_INCLUDE_DIR}) add_tpiflite_DIR tflite_cc_api_build) # Konfiguro flamujt e përpiluesit C/C++ për të mundësuar përdorimin e TFLite në shërbimet e Play # (në vend të TFLite të zakonshme të bashkuar me aplikacionin). add_compile_definitions(TFLITE_IN_GMSCORE) add_compile_definitions(TFLITE_WITH_STABLE_ABI) target_link_libraries(tflite-jni # objektivi juaj i JNI lib tflite_cc_api::tflite_cc_api tensorflowlite_jni_gms_client::tensorflowlite_jni_gms_client android # departamente të tjera për regjistrin tuaj të synuar) ```

Inicializoni kohën e ekzekutimit të LiteRT

Përpara se të telefononi LiteRT Native API, duhet të inicializoni kohën e funksionimit TfLiteNative në kodin tuaj Java ose Kotlin.

Java

Task tfLiteInitializeTask = TfLiteNative.initialize(context);
      

Kotlin

val tfLiteInitializeTask: Task = TfLiteNative.initialize(context)
        

Duke përdorur API-në e detyrave të shërbimeve të Google Play, TfLiteNative.initialize ngarkon në mënyrë asinkrone kohën e ekzekutimit TFLite nga shërbimet e Google Play në procesin e ekzekutimit të aplikacionit tuaj. Përdorni addOnSuccessListener() për t'u siguruar që detyra TfLite.initialize() të përfundojë përpara se të ekzekutoni kodin që akseson LiteRT API. Pasi detyra të ketë përfunduar me sukses, mund të thirrni të gjitha API-të e disponueshme TFLite Native.

Zbatimi i kodit vendas

Për të përdorur LiteRT në shërbimet e Google Play me kodin tuaj C/C++, mund të bëni një (ose të dyja) nga sa vijon:

  • deklaroni funksione të reja JNI për të thirrur funksione C ose C++ nga kodi juaj Java
  • telefononi LiteRT Native API nga kodi juaj ekzistues C ose C++.

Funksionet e JNI

Ju mund të deklaroni funksione të reja JNI për ta bërë kohën e ekzekutimit të LiteRT të deklaruar në kodin C/C++ të aksesueshme për kodin tuaj Java/Kotlin si më poshtë:

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

Përputhja e funksioneve të mëposhtme loadModel dhe runInference C ose 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

Më pas mund të telefononi funksionet tuaja C/C++ nga kodi juaj Java/Kotlin:

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 në kodin vendas

Përfshi skedarin e duhur të titullit API për të përfshirë LiteRT me API-në e shërbimeve të Google Play:

C

``` #include "tensorflow/lite/c/c_api.h" ```

C++

``` #include "tensorflow/lite/interpreter.h" #include "tensorflow/lite/model_builder.h" ```

Më pas mund të përdorni API-në e rregullt LiteRT C ose C++:

C

```c++ TfLiteModel* modeli = TfLiteModelCreate(model_pasuria, modeli_pasuria_gjatësia); // ... TfLiteInterpreterOptions* opsionet = TfLiteInterpreterOptionsCreate(); // ... TfLiteInterpreter* interpretuesi = TfLiteInterpreterCreate(modeli, opsionet); ```

C++

```c++ // Ngarko modelin. modeli automatik = tflite::FlatBufferModel::VerifyAndBuildFromBuffer( modeli_pasuria, modeli_pasuria_gjatësia); ... // Inicializoni interpretuesin. BuiltinOpResolver op_resolver; InterpreterBuilder interpreter_builder(*model, op_resolver); ndërtues_përkthyes (&interpretues); std::unique_ptr<Interpreter>` interpretues; ndërtues_përkthyes (&interpretues); ```

API të mbështetura

C

Titujt e API-t Native të shërbimeve LiteRT me Google Play ofrojnë të njëjtën API si [LiteRT C API] (../../api/tflite/c), duke përjashtuar veçoritë që janë të vjetruara ose eksperimentale. Tani për tani funksionet dhe llojet nga titujt e mëposhtëm janë në dispozicion. API-të TensorFlow Lite për ngarkimin dhe ekzekutimin e modeleve: ``` asnjë tensorflow/lite/c/c_api.h tensorflow/lite/c/c_api_types.h ``` API-të shtesë të TensorFlow Lite për përcaktimin e funksioneve të personalizuara dhe delegatëve (p.sh. për përshpejtimin e harduerit): ``` asnjë tensorflow/lite/c/c_api_opaque.h tensorflow/lite/c/common.h tensorflow/lite/c/builtin_op_data.h tensorflow/lite/builtin_ops. h ``` Delegoni API-të shtesë për përdorimin e delegatëve ekzistues: ``` asnjë tensorflow/lite/acceleration/configuration/c/gpu_plugin.h tensorflow/lite/acceleration/configuration/c/xnnpack_plugin.h ``` Ju lutemi, vini re se funksionet nga titulli `c_api_experimental.h` nuk mbështeten. Mund të përdorni funksione specifike për LiteRT me Shërbimet e Google Play duke përfshirë `tensorflow/lite/abi/tflite.h`.

C++

Titujt e API-së vendase të shërbimeve LiteRT me Google Play ofrojnë të njëjtën API si [LiteRT C++ API] (../../api/tflite/cc), duke përjashtuar veçoritë që janë të vjetruara ose eksperimentale, dhe me disa përjashtime të vogla të shënuara më vonë në këtë seksion. Funksionaliteti nga titujt e mëposhtëm është i disponueshëm: ``` asnjë tensorflow/lite/model_builder.h tensorflow/lite/interpreter_builder.h tensorflow/lite/interpreter.h tensorflow/lite/signature_runner.h tensorflow/lite/acceleration/configuration/delegate_regist .h tensorflow/lite/kernels/builtin_op_kernels.h tensorflow/lite/kernels/register.h tensorflow/lite/tools/verifier.h ``` Për `tensorflow/lite/interpreter.h`, API-ja e mbështetur me shërbimet e Play përjashton disa anëtarët e `tflite::Interpreter` për të cilët LiteRT nuk ofron një ABI të qëndrueshme: ```c++ Interpreter::variables() Interpreter::nodes_size() Interpreter::node_and_registration(int node_index) Interpreter::kTensorsReservedCapacity Interpreter::kTensorsCapacityHeadroom Interpreter::OpProfilingLiteRregullimiT*,const. Interpreter::SetExternalContext(TfLiteExternalContextType lloji, TfLiteExternalContext* ctx) ```