Mengurangi ukuran biner LiteRT

Ringkasan

Saat men-deploy model untuk aplikasi machine learning (ODML) di perangkat, menyadari keterbatasan memori yang tersedia di perangkat seluler. Ukuran biner model berkorelasi erat dengan jumlah operasi yang digunakan dalam model transformer. Dengan LiteRT, Anda dapat mengurangi ukuran biner model menggunakan build selektif. Build selektif melewati operasi yang tidak digunakan di set model Anda dan menghasilkan pustaka yang ringkas dengan hanya runtime dan {i>kernel<i} operasi yang diperlukan untuk untuk menjalankan model di perangkat seluler Anda.

Build selektif berlaku pada tiga library operasi berikut.

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

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

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 menetapkan pengembangan lokal lingkungan kami untuk Bazel.

Membuat file AAR untuk project Android

Anda dapat mem-build AAR LiteRT kustom dengan menyediakan jalur file model 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 aar file bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar jika model Anda berisi Pilih TensorFlow Ops. Perhatikan bahwa tindakan ini akan membentuk "lemak" AAR dengan beberapa arsitektur; jika Anda tidak membutuhkan semuanya, gunakan {i>subset<i} yang sesuai untuk lingkungan deployment Anda.

Membangun aplikasi dengan operasi kustom

Jika Anda telah mengembangkan model LiteRT dengan operasi kustom, Anda dapat membangunnya 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 dari operasi kustom Anda dan flag tflite_custom_ops_deps berisi dependensi untuk membangun sumber . Perhatikan bahwa dependensi ini harus ada di repo TensorFlow.

Penggunaan Lanjutan: Aturan Bazel Kustom

Jika proyek Anda menggunakan Bazel dan Anda ingin mendefinisikan TFLite khusus dependensi untuk kumpulan model tertentu, Anda bisa menentukan repositori project:

Hanya untuk model dengan operasi bawaan:

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 Lanjutan: Membangun library bersama C/C++ kustom

Jika Anda ingin membangun objek bersama TFLite C/C++ khusus untuk model yang diberikan, Anda dapat mengikuti langkah-langkah berikut:

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

mkdir -p tmp && touch tmp/BUILD

Membangun objek bersama kustom C

Jika Anda ingin membuat objek bersama TFLite C khusus, 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 TFLite C++ kustom, tambahkan 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 TF Pilih, Anda juga perlu membangun perpustakaan bersama:

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 Anda dan mendownload Dockerfile LiteRT di sini.

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

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

Membuat file AAR untuk project Android

Download skrip untuk membangun aplikasi menggunakan 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 mem-build AAR LiteRT kustom dengan menyediakan file model 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 Anda ingin melakukan checkout sebelum membangun {i>library<i}; secara {i>default<i}, ini adalah yang 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 TensorFlow Select di direktori Anda saat ini.

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

Menambahkan file AAR ke project

Tambahkan file AAR dengan mengimpor AAR secara langsung ke project, atau dengan memublikasikan AAR kustom ke Maven lokal Anda repositori yang baru. Catatan Anda harus menambahkan file AAR untuk tensorflow-lite-select-tf-ops.aar sebagai baik jika Anda yang membuatnya.

Build Selektif untuk iOS

Lihat bagian Membangun secara lokal untuk mengatur lingkungan build dan konfigurasi TensorFlow workspace, lalu ikuti panduan untuk menggunakan untuk iOS.