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ësoni konfigurimin tuaj të 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:

find_package(tensorflowlite_jni_gms_client REQUIRED CONFIG)

# 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
        tensorflowlite_jni_gms_client::tensorflowlite_jni_gms_client
        android # other deps for your target
        log)
      

# Set up TFLite in Play services C API (tensorflowlite_jni_gms_client) dependency.

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)
      

Inicializoni kohën e ekzekutimit të LiteRT

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

Task tfLiteInitializeTask = TfLiteNative.initialize(context);
      

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ë:

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

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:

tfLiteHandleTask.onSuccessTask(unused -> {
    TfLiteJni jni = new TfLiteJni();
    jni.loadModel(getAssets(), "add.bin");
    //...
});
    

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:

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

#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++:

TfLiteModel* model = TfLiteModelCreate(model_asset, model_asset_length);
// ...
TfLiteInterpreterOptions* options = TfLiteInterpreterOptionsCreate();
// ...
TfLiteInterpreter* interpreter = TfLiteInterpreterCreate(model, options);
      

  // Load the model.
  auto model = tflite::FlatBufferModel::VerifyAndBuildFromBuffer(
      model_asset, model_asset_length);
  ...
  // Initialize the interpreter.
  BuiltinOpResolver op_resolver;
  InterpreterBuilder interpreter_builder(*model, op_resolver);
  interpreter_builder(&interpreter);
  std::unique_ptr<Interpreter>` interpreter;
  interpreter_builder(&interpreter);
      

API të mbështetura

tensorflow/lite/c/c_api.h
tensorflow/lite/c/c_api_types.h
      

tensorflow/lite/c/c_api_opaque.h
tensorflow/lite/c/common.h
tensorflow/lite/c/builtin_op_data.h
tensorflow/lite/builtin_ops.h
      

tensorflow/lite/acceleration/configuration/c/gpu_plugin.h
tensorflow/lite/acceleration/configuration/c/xnnpack_plugin.h
      

tensorflow/lite/abi/tflite.h

tensorflow/lite/model_builder.h
tensorflow/lite/interpreter_builder.h
tensorflow/lite/interpreter.h
tensorflow/lite/signature_runner.h
tensorflow/lite/acceleration/configuration/delegate_registry.h
tensorflow/lite/kernels/builtin_op_kernels.h
tensorflow/lite/kernels/register.h
tensorflow/lite/tools/verifier.h
      

Interpreter::variables()
Interpreter::nodes_size()
Interpreter::node_and_registration(int node_index)
Interpreter::kTensorsReservedCapacity
Interpreter::kTensorsCapacityHeadroom
Interpreter::OpProfilingString(const TfLiteRegistration&, const TfLiteNode*)
Interpreter::SetExternalContext(TfLiteExternalContextType type, TfLiteExternalContext* ctx)