Bantuan melindungi Great Barrier Reef dengan TensorFlow pada Kaggle Bergabung Tantangan

Kurangi ukuran biner TensorFlow Lite

Gambaran

Saat menerapkan model untuk aplikasi pembelajaran mesin di perangkat (ODML), penting untuk menyadari 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 melewati operasi yang tidak digunakan dalam set 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 library operasi berikut.

  1. Pustaka operasi bawaan TensorFlow Lite
  2. Operasi kustom TensorFlow Lite
  3. Pilih perpustakaan 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(mengambang) Klasifikasi gambar armeabi-v7a tensorflow-lite.aar (296.635 byte)
arm64-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)
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)

Masalah/keterbatasan yang diketahui

  1. Selective Build for C API dan versi iOS tidak didukung saat ini.

Bangun TensorFlow Lite secara selektif dengan Bazel

Bagian ini mengasumsikan bahwa Anda telah men-download kode sumber TensorFlow dan mengatur lingkungan pembangunan daerah untuk Bazel.

Buat file AAR untuk proyek Android

Anda dapat membuat AAR TensorFlow Lite kustom dengan menyediakan 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 TensorFlow Lite built-in dan adat ops; dan opsional, menghasilkan file aar bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar jika model Anda mengandung Pilih TensorFlow ops. Perhatikan bahwa ini membangun 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

The tflite_custom_ops_srcs bendera berisi file sumber ops kustom Anda dan tflite_custom_ops_deps bendera mengandung dependensi untuk membangun file-file sumber. Perhatikan bahwa dependensi ini harus ada di repo TensorFlow.

Penggunaan Lanjutan: Aturan Bazel Khusus

Jika proyek Anda menggunakan Bazel dan Anda ingin mendefinisikan dependensi TFLite khusus untuk serangkaian 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 ops Pilih 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 terhadap model yang diberikan, Anda dapat mengikuti langkah-langkah di bawah ini:

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

mkdir -p tmp && touch tmp/BUILD

Membangun objek bersama C khusus

Jika Anda ingin membangun sebuah kustom TFLite C bersama objek, tambahkan berikut ini ke tmp/BUILD berkas:

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++14 \
  //tmp:tensorflowlite_c

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

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

Membangun objek bersama C++ khusus

Jika Anda ingin membangun sebuah kustom TFLite C ++ objek bersama, tambahkan berikut ini ke tmp/BUILD berkas:

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++14 \
  //tmp:tensorflowlite

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

bazel build -c opt --cxxopt=--std=c++14 --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++14' \
      --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++14' \
      --config=android_arm \
      --config=monolithic \
      --host_crosstool_top=@bazel_tools//tools/cpp:toolchain \
      //tmp:tensorflowlite_flex

Secara Selektif Membangun TensorFlow Lite dengan Docker

Bagian ini mengasumsikan bahwa Anda telah menginstal Docker pada komputer lokal Anda dan men-download TensorFlow Lite Dockerfile sini .

Setelah mengunduh Dockerfile di atas, Anda dapat membangun image buruh pelabuhan dengan menjalankan:

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

Buat 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 membuat AAR TensorFlow Lite kustom dengan menyediakan 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>]

The checkpoint bendera komit, cabang atau tag dari repo TensorFlow yang Anda ingin checkout sebelum membangun perpustakaan; secara default ini adalah cabang rilis terbaru. Perintah di atas akan menghasilkan file AAR tensorflow-lite.aar untuk TensorFlow Lite built-in dan ops adat dan opsional file AAR tensorflow-lite-select-tf-ops.aar untuk ops Pilih TensorFlow dalam direktori Anda saat ini.

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

Tambahkan file AAR ke proyek

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