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 modele të të mësuarit automatik (ML) pa i bashkuar statistikisht 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 C API ose C++ API të shërbimeve të Google Play, sigurohuni që e keni të instaluar mjetin e ndërtimit CMake .

Përditësoni konfigurimin e ndërtimit tuaj

(1) Shtoni varësitë e mëposhtme në kodin e projektit të aplikacionit tuaj për të aksesuar API-n e shërbimeve 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 mbaron me -java , ajo paketë përmban gjithashtu API-t C dhe C++.

(2) Pastaj, aktivizoni funksionin Prefab për të aksesuar API-n C 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 po përdorni API C++, kopjoni tflite-java-extract-cpp-sdk.gradle në projektin tuaj, në direktorinë 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'

Kjo përmban kodin Gradle për të çpaketuar automatikisht SDK-në C++ nga skedari AAR për play-services-tflite-java .

(4) [Vetëm për API C++] Nëse po përdorni API-n C++, gjeni direktorinë që përmban skedarin e konfigurimit CMake të aplikacionit tuaj (zakonisht CMakeLists.txt ); ajo direktori është normalisht direktoria juaj app/src/main/cpp . Pastaj kopjoni Findtflite_cc_api.cmake në projektin tuaj, në një nën-direktorium të ri Modules të asaj direktorie. Kjo përmban kodin që gjen SDK-në C++ të shpaketuar nga skripti Gradle në hapin e mëparshëm.

(5) Së fundmi, duhet të shtoni paketën tensorflowlite_jni_gms_client , dhe për API-n C++ edhe paketën tflite_cc_api , të cilat të dyja importohen nga AAR, si varësi në skriptin tuaj CMake:

C 

find_package(tensorflowlite_jni_gms_client REQUIRED CONFIG)

# Set up C/C++ compiler flags to enable use of LiteRT in Play services
# (rather than regular LiteRT 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++ 

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

find_package(tensorflowlite_jni_gms_client REQUIRED CONFIG)

# Set up LiteRT 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 LiteRT in Play services
# (rather than regular LiteRT 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ë thirrni API-n LiteRT C ose C++, duhet të inicializoni kohën e ekzekutimit 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 Google Play, TfLiteNative.initialize ngarkon në mënyrë asinkrone kohën e ekzekutimit të LiteRT nga shërbimet Google Play në procesin e ekzekutimit të aplikacionit tuaj. Përdorni addOnSuccessListener() për t'u siguruar që detyra TfLite.initialize() të përfundojë para se të ekzekutojë kodin që qaset në API-të e LiteRT. Pasi detyra të përfundojë me sukses, mund të thirrni të gjitha API-të e disponueshme të LiteRT Native.

Implementimi 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ërën (ose të dyja) nga sa vijon:

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

Funksionet e JNI-së

Ju mund të deklaroni funksione të reja JNI për ta bërë kohën e ekzekutimit LiteRT të deklaruar në kodin C/C++ të arritshme 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 në 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

Pastaj mund të thirrni 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ë kokës së API-t për të përfshirë LiteRT me API-n e shërbimeve Google Play:

C 

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

C++ 

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

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

C 

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

C++ 

  // 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ë e mbështetura

C

Titujt e LiteRT me shërbimet C të API-t të Google Play ofrojnë të njëjtin API si API-ja e rregullt LiteRT C , duke përjashtuar veçoritë që janë të vjetruara ose eksperimentale. Për momentin, funksionet dhe llojet nga titujt e mëposhtëm janë të disponueshme.

API-të e TensorFlow Lite për ngarkimin dhe ekzekutimin e modeleve: 

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

API-të e zgjerimit TensorFlow Lite për përcaktimin e operacioneve dhe delegatëve të personalizuar (p.sh. për përshpejtimin e harduerit): 

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

API-të e shtojcave të delegimit për përdorimin e delegatëve ekzistues: 

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

Ju lutemi vini re se funksionet nga koka 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ë kokën e mëposhtme: 

tensorflow/lite/abi/tflite.h
 .

C++

Titujt e API-t C++ të LiteRT me shërbimet e Google Play ofrojnë të njëjtin API si API-t e rregullt të LiteRT C++ , duke përjashtuar veçoritë që janë të vjetruara ose eksperimentale, dhe me disa përjashtime të vogla të përmendura më vonë në këtë seksion. Funksionaliteti nga titujt e mëposhtëm është i disponueshëm: 

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

Për tensorflow/lite/interpreter.h , API-ja e mbështetur me shërbimet Play përjashton disa anëtarë të tflite::Interpreter për të cilët LiteRT nuk ofron një ABI të qëndrueshëm: 

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)