Mengurangi ukuran biner TensorFlow Lite

Ringkasan

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

Build selektif berlaku pada tiga library operasi berikut.

1. Library operasi bawaan TensorFlow Lite
2. Operasi kustom TensorFlow Lite
3. Memilih 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 TensorFlow Lite secara selektif dengan Bazel

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

Membuat file AAR untuk project Android

Anda dapat mem-build AAR TensorFlow Lite 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 kustom dan bawaan TensorFlow Lite; dan secara opsional, menghasilkan file aar bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar jika model Anda berisi operasi Pilih TensorFlow. Perhatikan bahwa tindakan ini akan mem-build AAR "fat" dengan beberapa arsitektur yang berbeda; jika Anda tidak memerlukan semuanya, gunakan subset yang sesuai untuk lingkungan deployment Anda.

Membangun aplikasi dengan operasi kustom

Jika telah mengembangkan model Tensorflow Lite 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 operasi kustom Anda dan tanda 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 ingin menentukan dependensi TFLite kustom untuk rangkaian model tertentu, Anda dapat menentukan aturan berikut di 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 ingin membuat objek bersama TFLite C/C++ kustom sendiri terhadap model tertentu, Anda dapat mengikuti langkah-langkah berikut:

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

mkdir -p tmp && touch tmp/BUILD

Membangun objek bersama kustom C

Jika Anda ingin membuat objek bersama TFLite C 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 TensorFlow Lite 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 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 TF Pilih, Anda juga harus membangun 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 TensorFlow Lite Secara Selektif dengan Docker

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

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

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 TensorFlow Lite kustom dengan menyediakan jalur file model seperti 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>]

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

--cache_dir menentukan direktori cache. Jika tidak disediakan, skrip akan membuat direktori bernama bazel-build-cache pada direktori kerja saat ini untuk caching.

Menambahkan file AAR ke project

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

Build Selektif untuk iOS

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