Kurangi ukuran biner TensorFlow Lite

Ringkasan

Saat menerapkan model untuk aplikasi pembelajaran mesin di perangkat (ODML), 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 dengan menggunakan build selektif. Build selektif melewatkan operasi yang tidak digunakan dalam kumpulan model Anda dan menghasilkan pustaka ringkas hanya dengan runtime dan kernel op yang diperlukan agar model dapat berjalan di perangkat seluler Anda.

Build selektif berlaku pada tiga pustaka operasi berikut.

1. Pustaka operasi bawaan TensorFlow Lite
2. Operasi khusus TensorFlow Lite
3. Pilih pustaka operasi TensorFlow

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

Nama model	Domain	Arsitektur sasaran	Ukuran file AAR
Mobilenet_1.0_224(mengambang)	Klasifikasi gambar	armeabi-v7a	tensorflow-lite.aar (296.635 byte)
		lengan64-v8a	tensorflow-lite.aar (382.892 byte)
MEMBUMBUI	Ekstraksi nada suara	armeabi-v7a	tensorflow-lite.aar (375.813 byte) tensorflow-lite-select-tf-ops.aar (1.676.380 byte)
		lengan64-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)
		lengan64-v8a	tensorflow-lite.aar (273.713 byte) tensorflow-lite-select-tf-ops.aar (2.339.697 byte)

Catatan: Fitur ini sedang dalam percobaan dan tersedia sejak versi 2.4 dan dapat berubah.

Build TensorFlow Lite secara selektif dengan Bazel

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

Bangun file AAR untuk proyek 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 TensorFlow Lite built-in dan custom ops; dan secara opsional, buat file aar bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar jika model Anda berisi operasi Pilih TensorFlow. Perhatikan bahwa ini membuat AAR "gemuk" dengan beberapa arsitektur berbeda; jika Anda tidak membutuhkan semuanya, gunakan subset yang sesuai untuk lingkungan penerapan Anda.

Bangun dengan operasi khusus

Jika Anda telah mengembangkan model Tensorflow Lite 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 membuat file sumber tersebut. Perhatikan bahwa dependensi ini harus ada di repo TensorFlow.

Penggunaan Lanjutan: Aturan Bazel Khusus

Jika proyek Anda menggunakan Bazel dan Anda ingin menentukan dependensi TFLite khusus untuk kumpulan model tertentu, Anda dapat menentukan aturan berikut di repositori proyek 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 operasi Select 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: Bangun pustaka bersama C/C++ khusus

Jika Anda ingin membuat objek bersama TFLite C/C++ kustom Anda sendiri ke model yang diberikan, Anda dapat mengikuti langkah-langkah di bawah ini:

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

mkdir -p tmp && touch tmp/BUILD

Membangun objek bersama C khusus

Jika Anda ingin membuat objek bersama TFLite C khusus, tambahkan berikut ini 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 dibangun 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++ khusus, tambahkan berikut ini 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 dibangun 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 membangun pustaka 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 dibangun 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

Build TensorFlow Lite secara selektif dengan Docker

Bagian ini mengasumsikan bahwa Anda telah menginstal Docker di mesin lokal Anda dan mengunduh file Docker TensorFlow Lite di sini .

Setelah mengunduh Dockerfile di atas, Anda dapat membuat gambar buruh pelabuhan dengan menjalankan:

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

Bangun file AAR untuk proyek Android

Unduh 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 mem-build AAR TensorFlow Lite kustom dengan menyediakan jalur 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>]

Bendera checkpoint adalah komit, cabang, atau tag dari repo TensorFlow yang ingin Anda periksa sebelum membangun pustaka; secara default ini adalah cabang rilis terbaru. Perintah di atas akan menghasilkan file AAR tensorflow-lite.aar untuk TensorFlow Lite bawaan dan operasi khusus dan secara opsional file AAR tensorflow-lite-select-tf-ops.aar untuk operasi Pilih TensorFlow di direktori Anda saat ini.

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

Tambahkan file AAR ke proyek

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

Build Selektif untuk iOS

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