LiteRT trong API C và C++ của Dịch vụ Google Play

LiteRT trong môi trường thời gian chạy của Dịch vụ Google Play cho phép bạn chạy các mô hình học máy (ML) mà không cần gói tĩnh các thư viện LiteRT vào ứng dụng. Hướng dẫn này cung cấp hướng dẫn về cách sử dụng API C hoặc C++ cho Dịch vụ Google Play.

Trước khi làm việc với LiteRT trong API C hoặc API C++ của Dịch vụ Google Play, hãy đảm bảo bạn đã cài đặt công cụ xây dựng CMake.

Cập nhật cấu hình bản dựng

(1) Thêm các phần phụ thuộc sau vào mã dự án ứng dụng để truy cập vào API Dịch vụ Play cho LiteRT:

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

Xin lưu ý rằng mặc dù tên gói kết thúc bằng -java, nhưng gói đó cũng chứa các API C và C++.

(2) Sau đó, hãy bật tính năng Prefab để truy cập vào API C từ tập lệnh CMake bằng cách cập nhật khối android của tệp build.gradle của mô-đun:

buildFeatures {
  prefab = true
}

(3) [Chỉ dành cho API C++] Nếu bạn đang sử dụng API C++, hãy sao chép tflite-java-extract-cpp-sdk.gradle vào dự án của bạn, trong thư mục app và thêm nội dung sau vào đầu tập lệnh gradle của ứng dụng (ví dụ: app/build.gradle):

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

Tệp này chứa mã Gradle để tự động giải nén SDK C++ từ tệp AAR cho play-services-tflite-java.

(4) [Chỉ API C++] Nếu bạn đang sử dụng API C++, hãy tìm thư mục chứa tệp cấu hình CMake của ứng dụng (thường là CMakeLists.txt); thư mục đó thường là thư mục app/src/main/cpp. Sau đó, sao chép Findtflite_cc_api.cmake vào dự án của bạn, trong thư mục con Modules mới của thư mục đó. Tệp này chứa mã tìm SDK C++ do tập lệnh Gradle giải nén ở bước trước.

(5) Cuối cùng, bạn cần thêm gói tensorflowlite_jni_gms_client và gói tflite_cc_api cho API C++, cả hai gói này đều được nhập từ AAR dưới dạng phần phụ thuộc trong tập lệnh CMake:

C

``` find_package(tensorflowlite_jni_gms_client REQUIRED CONFIG) # Thiết lập cờ trình biên dịch C/C++ để cho phép sử dụng TFLite trong Dịch vụ Play # (thay vì TFLite thông thường đi kèm với ứng dụng). 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++

``` # Thiết lập TFLite trong phần phụ thuộc API C của Dịch vụ Play (tensorflowlite_jni_gms_client). find_package(tensorflowlite_jni_gms_client REQUIRED CONFIG) # Thiết lập phần phụ thuộc TFLite trong API C++ của Dịch vụ Play (tflite_cc_api). 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) ```

Khởi chạy môi trường thời gian chạy LiteRT

Trước khi gọi API gốc LiteRT, bạn phải khởi chạy thời gian chạy TfLiteNative trong mã Java hoặc Kotlin.

Java

Task tfLiteInitializeTask = TfLiteNative.initialize(context);
      

Kotlin

val tfLiteInitializeTask: Task = TfLiteNative.initialize(context)
        

Khi sử dụng API Tác vụ của Dịch vụ Google Play, TfLiteNative.initialize sẽ tải không đồng bộ môi trường thời gian chạy TFLite từ Dịch vụ Google Play vào quy trình thời gian chạy của ứng dụng. Sử dụng addOnSuccessListener() để đảm bảo tác vụ TfLite.initialize() hoàn tất trước khi thực thi mã truy cập vào các API LiteRT. Sau khi hoàn tất tác vụ, bạn có thể gọi tất cả API gốc TFLite hiện có.

Triển khai mã gốc

Để sử dụng LiteRT trong Dịch vụ Google Play bằng mã C/C++, bạn có thể làm một (hoặc cả hai) việc sau:

  • khai báo các hàm JNI mới để gọi các hàm C hoặc C++ từ mã Java
  • gọi API gốc LiteRT từ mã C hoặc C++ hiện có.

Hàm JNI

Bạn có thể khai báo các hàm JNI mới để cho phép mã Java/Kotlin truy cập vào môi trường thời gian chạy LiteRT được khai báo trong mã C/C++ như sau:

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

So khớp các hàm C hoặc C++ loadModelrunInference sau:

#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

Sau đó, bạn có thể gọi các hàm C/C++ từ mã 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 trong mã gốc

Thêm tệp tiêu đề API thích hợp để đưa LiteRT vào API Dịch vụ Google Play:

C

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

C++

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

Sau đó, bạn có thể sử dụng API LiteRT C hoặc C++ thông thường:

C

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

C++

```c++ // Tải mô hình. auto model = tflite::FlatBufferModel::VerifyAndBuildFromBuffer( model_asset, model_asset_length); ... // Khởi chạy trình diễn giải. BuiltinOpResolver op_resolver; InterpreterBuilder interpreter_builder(*model, op_resolver); interpreter_builder(&interpreter); std::unique_ptr<Interpreter>` interpreter; interpreter_builder(&interpreter); ```

API được hỗ trợ

C

LiteRT với tiêu đề API gốc của Dịch vụ Google Play cung cấp API giống như [API LiteRT C](../../api/tflite/c) thông thường, ngoại trừ các tính năng không dùng nữa hoặc thử nghiệm. Hiện tại, các hàm và loại từ các tiêu đề sau đây đã có sẵn. API TensorFlow Lite để tải và thực thi mô hình: ```none tensorflow/lite/c/c_api.h tensorflow/lite/c/c_api_types.h ``` API tiện ích TensorFlow Lite để xác định các thao tác tuỳ chỉnh và uỷ quyền (ví dụ: để tăng tốc phần cứng): ```none 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 trình bổ trợ uỷ quyền để sử dụng các trình bổ trợ uỷ quyền hiện có: ```none tensorflow/lite/acceleration/configuration/c/gpu_plugin.h tensorflow/lite/acceleration/configuration/c/xnnpack_plugin.h ``` Xin lưu ý rằng các hàm từ tiêu đề `c_api_experimental.h` không được hỗ trợ. Bạn có thể sử dụng các hàm dành riêng cho LiteRT với Dịch vụ Google Play bằng cách thêm `tensorflow/lite/abi/tflite.h`.

C++

LiteRT với tiêu đề API gốc của Dịch vụ Google Play cung cấp cùng một API với [API LiteRT C++](../../api/tflite/cc) thông thường, ngoại trừ các tính năng không dùng nữa hoặc thử nghiệm, cùng với một số ngoại lệ nhỏ được ghi chú ở phần sau của phần này. Bạn có thể sử dụng chức năng từ các tiêu đề sau: ```none 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 ``` Đối với `tensorflow/lite/interpreter.h`, API được hỗ trợ với Dịch vụ Play loại trừ một số thành viên của `tflite::Interpreter` mà LiteRT không cung cấp ABI ổn định: ```c++ 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) ```