Mengurangi ukuran biner LiteRT

Ringkasan

Saat men-deploy model untuk aplikasi machine learning di perangkat (ODML), penting untuk menyadari keterbatasan memori yang tersedia di perangkat seluler. Ukuran biner model sangat berkorelasi dengan jumlah operasi yang digunakan dalam model. LiteRT memungkinkan Anda mengurangi ukuran biner model dengan menggunakan build selektif. Build selektif melewati operasi yang tidak digunakan dalam set model Anda dan menghasilkan library ringkas hanya dengan kernel op dan runtime yang diperlukan agar model berjalan di perangkat seluler Anda.

Build selektif berlaku pada tiga library operasi berikut.

  1. Library operasi bawaan LiteRT
  2. Operasi kustom LiteRT
  3. Pilih library operasi TensorFlow

Tabel di bawah menunjukkan dampak build selektif untuk beberapa kasus penggunaan umum:

Nama Model Domain Arsitektur target Ukuran file AAR
Mobilenet_1.0_224(float) Klasifikasi gambar armeabi-v7a tensorflow-lite.aar (296.635 byte)
arm64-v8a tensorflow-lite.aar (382.892 byte)
SPICE Ekstraksi nada suara armeabi-v7a tensorflow-lite.aar (375.813 byte)
tensorflow-lite-select-tf-ops.aar (1.676.380 byte)
arm64-v8a tensorflow-lite.aar (421.826 byte)
tensorflow-lite-select-tf-ops.aar (2.298.630 byte)
i3d-kinetics-400 Klasifikasi video armeabi-v7a tensorflow-lite.aar (240.085 byte)
tensorflow-lite-select-tf-ops.aar (1.708.597 byte)
arm64-v8a tensorflow-lite.aar (273.713 byte)
tensorflow-lite-select-tf-ops.aar (2.339.697 byte)

Membangun LiteRT secara selektif dengan Bazel

Bagian ini mengasumsikan bahwa Anda telah mendownload kode sumber TensorFlow dan menyiapkan lingkungan pengembangan lokal ke Bazel.

Membangun file AAR untuk project Android

Anda dapat membuat AAR LiteRT kustom dengan memberikan jalur file model Anda sebagai berikut.

sh tensorflow/lite/tools/build_aar.sh \
  --input_models=/a/b/model_one.tflite,/c/d/model_two.tflite \
  --target_archs=x86,x86_64,arm64-v8a,armeabi-v7a

Perintah di atas akan menghasilkan file AAR bazel-bin/tmp/tensorflow-lite.aar untuk operasi bawaan dan kustom LiteRT; dan secara opsional, menghasilkan file AAR bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar jika model Anda berisi operasi TensorFlow Select. Perhatikan bahwa ini membangun AAR "gemuk" dengan beberapa arsitektur yang berbeda; jika Anda tidak memerlukan semuanya, gunakan subset yang sesuai untuk lingkungan deployment Anda.

Membangun dengan operasi kustom

Jika telah mengembangkan model LiteRT dengan operasi kustom, Anda dapat membuatnya dengan menambahkan flag berikut ke perintah build:

sh tensorflow/lite/tools/build_aar.sh \
  --input_models=/a/b/model_one.tflite,/c/d/model_two.tflite \
  --target_archs=x86,x86_64,arm64-v8a,armeabi-v7a \
  --tflite_custom_ops_srcs=/e/f/file1.cc,/g/h/file2.h \
  --tflite_custom_ops_deps=dep1,dep2

Flag tflite_custom_ops_srcs berisi file sumber operasi kustom Anda dan flag tflite_custom_ops_deps berisi dependensi untuk membangun file sumber tersebut. Perhatikan bahwa dependensi ini harus ada di repo TensorFlow.

Penggunaan Lanjutan: Aturan Bazel kustom

Jika project Anda menggunakan Bazel dan Anda ingin menentukan dependensi TFLite kustom untuk sekumpulan model tertentu, Anda dapat menentukan aturan berikut di repositori project Anda:

Untuk model dengan operasi bawaan saja:

load(
    "@org_tensorflow//tensorflow/lite:build_def.bzl",
    "tflite_custom_android_library",
    "tflite_custom_c_library",
    "tflite_custom_cc_library",
)

# A selectively built TFLite Android library.
tflite_custom_android_library(
    name = "selectively_built_android_lib",
    models = [
        ":model_one.tflite",
        ":model_two.tflite",
    ],
)

# A selectively built TFLite C library.
tflite_custom_c_library(
    name = "selectively_built_c_lib",
    models = [
        ":model_one.tflite",
        ":model_two.tflite",
    ],
)

# A selectively built TFLite C++ library.
tflite_custom_cc_library(
    name = "selectively_built_cc_lib",
    models = [
        ":model_one.tflite",
        ":model_two.tflite",
    ],
)

Untuk model dengan Pilih operasi TF:

load(
    "@org_tensorflow//tensorflow/lite/delegates/flex:build_def.bzl",
    "tflite_flex_android_library",
    "tflite_flex_cc_library",
)

# A Select TF ops enabled selectively built TFLite Android library.
tflite_flex_android_library(
    name = "selective_built_tflite_flex_android_lib",
    models = [
        ":model_one.tflite",
        ":model_two.tflite",
    ],
)

# A Select TF ops enabled selectively built TFLite C++ library.
tflite_flex_cc_library(
    name = "selective_built_tflite_flex_cc_lib",
    models = [
        ":model_one.tflite",
        ":model_two.tflite",
    ],
)

Penggunaan Tingkat Lanjut: Membangun library bersama C/C++ kustom

Jika ingin membuat objek bersama C/C++ TFLite kustom Anda sendiri untuk model tertentu, Anda dapat mengikuti langkah-langkah di bawah:

Buat file BUILD sementara dengan menjalankan perintah berikut di direktori root kode sumber TensorFlow:

mkdir -p tmp && touch tmp/BUILD

Membangun objek bersama C kustom

Jika Anda ingin membuat objek bersama C TFLite kustom, tambahkan kode berikut ke file tmp/BUILD:

load(
    "//tensorflow/lite:build_def.bzl",
    "tflite_custom_c_library",
    "tflite_cc_shared_object",
)

tflite_custom_c_library(
    name = "selectively_built_c_lib",
    models = [
        ":model_one.tflite",
        ":model_two.tflite",
    ],
)

# Generates a platform-specific shared library containing the LiteRT C
# API implementation as define in `c_api.h`. The exact output library name
# is platform dependent:
#   - Linux/Android: `libtensorflowlite_c.so`
#   - Mac: `libtensorflowlite_c.dylib`
#   - Windows: `tensorflowlite_c.dll`
tflite_cc_shared_object(
    name = "tensorflowlite_c",
    linkopts = select({
        "//tensorflow:ios": [
            "-Wl,-exported_symbols_list,$(location //tensorflow/lite/c:exported_symbols.lds)",
        ],
        "//tensorflow:macos": [
            "-Wl,-exported_symbols_list,$(location //tensorflow/lite/c:exported_symbols.lds)",
        ],
        "//tensorflow:windows": [],
        "//conditions:default": [
            "-z defs",
            "-Wl,--version-script,$(location //tensorflow/lite/c:version_script.lds)",
        ],
    }),
    per_os_targets = True,
    deps = [
        ":selectively_built_c_lib",
        "//tensorflow/lite/c:exported_symbols.lds",
        "//tensorflow/lite/c:version_script.lds",
    ],
)

Target yang baru ditambahkan dapat dibuat sebagai berikut:

bazel build -c opt --cxxopt=--std=c++17 \
  //tmp:tensorflowlite_c

dan untuk Android (ganti android_arm dengan android_arm64 untuk 64-bit):

bazel build -c opt --cxxopt=--std=c++17 --config=android_arm \
  //tmp:tensorflowlite_c

Membangun objek bersama C++ kustom

Jika Anda ingin membuat objek bersama C++ TFLite kustom, tambahkan kode berikut ke file tmp/BUILD:

load(
    "//tensorflow/lite:build_def.bzl",
    "tflite_custom_cc_library",
    "tflite_cc_shared_object",
)

tflite_custom_cc_library(
    name = "selectively_built_cc_lib",
    models = [
        ":model_one.tflite",
        ":model_two.tflite",
    ],
)

# Shared lib target for convenience, pulls in the core runtime and builtin ops.
# Note: This target is not yet finalized, and the exact set of exported (C/C++)
# APIs is subject to change. The output library name is platform dependent:
#   - Linux/Android: `libtensorflowlite.so`
#   - Mac: `libtensorflowlite.dylib`
#   - Windows: `tensorflowlite.dll`
tflite_cc_shared_object(
    name = "tensorflowlite",
    # Until we have more granular symbol export for the C++ API on Windows,
    # export all symbols.
    features = ["windows_export_all_symbols"],
    linkopts = select({
        "//tensorflow:macos": [
            "-Wl,-exported_symbols_list,$(location //tensorflow/lite:tflite_exported_symbols.lds)",
        ],
        "//tensorflow:windows": [],
        "//conditions:default": [
            "-Wl,-z,defs",
            "-Wl,--version-script,$(location //tensorflow/lite:tflite_version_script.lds)",
        ],
    }),
    per_os_targets = True,
    deps = [
        ":selectively_built_cc_lib",
        "//tensorflow/lite:tflite_exported_symbols.lds",
        "//tensorflow/lite:tflite_version_script.lds",
    ],
)

Target yang baru ditambahkan dapat dibuat sebagai berikut:

bazel build -c opt  --cxxopt=--std=c++17 \
  //tmp:tensorflowlite

dan untuk Android (ganti android_arm dengan android_arm64 untuk 64-bit):

bazel build -c opt --cxxopt=--std=c++17 --config=android_arm \
  //tmp:tensorflowlite

Untuk model dengan operasi Select TF, Anda juga perlu membuat library bersama berikut:

load(
    "@org_tensorflow//tensorflow/lite/delegates/flex:build_def.bzl",
    "tflite_flex_shared_library"
)

# Shared lib target for convenience, pulls in the standard set of TensorFlow
# ops and kernels. The output library name is platform dependent:
#   - Linux/Android: `libtensorflowlite_flex.so`
#   - Mac: `libtensorflowlite_flex.dylib`
#   - Windows: `libtensorflowlite_flex.dll`
tflite_flex_shared_library(
  name = "tensorflowlite_flex",
  models = [
      ":model_one.tflite",
      ":model_two.tflite",
  ],
)

Target yang baru ditambahkan dapat dibuat sebagai berikut:

bazel build -c opt --cxxopt='--std=c++17' \
      --config=monolithic \
      --host_crosstool_top=@bazel_tools//tools/cpp:toolchain \
      //tmp:tensorflowlite_flex

dan untuk Android (ganti android_arm dengan android_arm64 untuk 64-bit):

bazel build -c opt --cxxopt='--std=c++17' \
      --config=android_arm \
      --config=monolithic \
      --host_crosstool_top=@bazel_tools//tools/cpp:toolchain \
      //tmp:tensorflowlite_flex

Membangun LiteRT secara Selektif dengan Docker

Bagian ini mengasumsikan bahwa Anda telah menginstal Docker di komputer lokal dan mendownload Dockerfile LiteRT di sini.

Setelah mendownload Dockerfile di atas, Anda dapat membangun image Docker dengan menjalankan:

docker build . -t tflite-builder -f tflite-android.Dockerfile

Membangun file AAR untuk project Android

Download skrip untuk membangun dengan Docker dengan menjalankan:

curl -o build_aar_with_docker.sh \
  https://raw.githubusercontent.com/tensorflow/tensorflow/master/tensorflow/lite/tools/build_aar_with_docker.sh &&
chmod +x build_aar_with_docker.sh

Kemudian, Anda dapat membuat AAR LiteRT kustom dengan memberikan jalur file model Anda sebagai berikut.

sh build_aar_with_docker.sh \
  --input_models=/a/b/model_one.tflite,/c/d/model_two.tflite \
  --target_archs=x86,x86_64,arm64-v8a,armeabi-v7a \
  --checkpoint=master \
  [--cache_dir=<path to cache directory>]

Flag checkpoint adalah commit, cabang, atau tag repo TensorFlow yang ingin Anda checkout sebelum membangun library; secara default, flag ini adalah cabang rilis terbaru. Perintah di atas akan menghasilkan file AAR tensorflow-lite.aar untuk operasi bawaan dan kustom LiteRT serta secara opsional file AAR tensorflow-lite-select-tf-ops.aar untuk operasi Select TensorFlow di direktori saat ini.

--cache_dir menentukan direktori cache. Jika tidak diberikan, skrip akan membuat direktori bernama bazel-build-cache di bawah direktori kerja saat ini untuk melakukan caching.

Menambahkan file AAR ke project

Tambahkan file AAR dengan mengimpor AAR langsung ke dalam project, atau dengan memublikasikan AAR kustom ke repositori Maven lokal. Perhatikan bahwa Anda harus menambahkan file AAR untuk tensorflow-lite-select-tf-ops.aar juga jika Anda membuatnya.

Build Selektif untuk iOS

Lihat bagian Membangun secara lokal untuk menyiapkan lingkungan build dan mengonfigurasi ruang kerja TensorFlow, lalu ikuti panduan untuk menggunakan skrip build selektif untuk iOS.