Riduci le dimensioni del programma binario di TensorFlow Lite

Panoramica

Durante il deployment di modelli per applicazioni di machine learning (ODML) on-device, è importante presta attenzione alla memoria limitata disponibile sui dispositivi mobili. Le dimensioni binarie del modello sono strettamente correlate al numero di operazioni utilizzate nel modello. TensorFlow Lite consente di ridurre le dimensioni binarie dei modelli utilizzando build selettive. Le build selettive ignorano le operazioni inutilizzate nel set di modelli e producono una libreria compatta solo con il runtime e i kernel operativi necessari per l'esecuzione del modello sul dispositivo mobile.

La build selettiva si applica alle tre librerie operazioni seguenti.

1. Libreria operazioni integrata di TensorFlow Lite
2. Operazioni personalizzate di TensorFlow Lite
3. Seleziona la libreria operazioni TensorFlow

La tabella seguente mostra l'impatto delle build selettive per alcuni casi d'uso comuni:

Nome modello	Dominio	Architettura di destinazione	Dimensioni file AAR
Mobilenet_1.0_224(float)	Classificazione di immagini	Armeabi-V7a	tensorflow-lite.aar (296.635 byte)
		arm64-v8a	tensorflow-lite.aar (382.892 byte)
SPICE	Estrazione della tonalità sonora	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)
cinetica-i3d-400	Classificazione di 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)

Crea selettivamente TensorFlow Lite con Bazel

In questa sezione si presuppone che tu abbia scaricato i codici sorgente di TensorFlow e configurato l'ambiente di sviluppo locale su Bazel.

Crea file AAR per il progetto Android

Puoi creare AAR di TensorFlow Lite personalizzati fornendo i percorsi dei file del tuo modello come segue.

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

Il comando riportato sopra genererà il file AAR bazel-bin/tmp/tensorflow-lite.aar per le operazioni integrate e personalizzate di TensorFlow Lite e, facoltativamente, genera il file AAR bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar se i modelli contengono operazioni Seleziona operazioni TensorFlow. Tieni presente che ciò crea un AAR "ridotto" con diverse architetture; se non ti servono tutte, utilizza il sottoinsieme appropriato per il tuo ambiente di deployment.

Crea con operazioni personalizzate

Se hai sviluppato modelli TensorFlow Lite con operazioni personalizzate, puoi crearli aggiungendo i seguenti flag al comando 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

Il flag tflite_custom_ops_srcs contiene i file di origine delle operazioni personalizzate e il flag tflite_custom_ops_deps contiene le dipendenze per creare questi file di origine. Tieni presente che queste dipendenze devono esistere nel repository TensorFlow.

Utilizzi avanzati: regole bazel personalizzate

Se il progetto utilizza Bazel e vuoi definire dipendenze TFLite personalizzate per un determinato set di modelli, puoi definire le seguenti regole nel repository del progetto:

Solo per i modelli con operazioni integrate:

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",
    ],
)

Per i modelli con il servizio Select TF Ops (Operazioni TF di tipo Select):

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",
    ],
)

Utilizzi avanzati: creare librerie condivise C/C++ personalizzate

Se vuoi creare oggetti condivisi TFLite C/C++ personalizzati in base ai modelli specificati, segui questi passaggi:

Crea un file BUILD temporaneo eseguendo questo comando nella directory principale del codice sorgente di TensorFlow:

mkdir -p tmp && touch tmp/BUILD

Creazione di oggetti condivisi C personalizzati

Se vuoi creare un oggetto condiviso TFLite C personalizzato, aggiungi quanto segue al 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",
    ],
)

La destinazione appena aggiunta può essere creata come segue:

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

e per Android (sostituisci android_arm con android_arm64 per 64 bit):

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

Creazione di oggetti condivisi C++ personalizzati

Se vuoi creare un oggetto condiviso TFLite C++ personalizzato, aggiungi quanto segue al 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",
    ],
)

La destinazione appena aggiunta può essere creata come segue:

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

e per Android (sostituisci android_arm con android_arm64 per 64 bit):

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

Per i modelli con operazioni Select TF, devi creare anche la seguente libreria condivisa:

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",
  ],
)

La destinazione appena aggiunta può essere creata come segue:

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

e per Android (sostituisci android_arm con android_arm64 per 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

Crea selettivamente TensorFlow Lite con Docker

Questa sezione presuppone che tu abbia installato Docker sulla tua macchina locale e scaricato il Dockerfile di TensorFlow Lite qui.

Dopo aver scaricato il Dockerfile riportato sopra, puoi creare l'immagine Docker eseguendo:

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

Crea file AAR per il progetto Android

Scarica lo script per la creazione con Docker eseguendo:

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

In seguito, potrai creare il file AAR di TensorFlow Lite personalizzato fornendo i percorsi dei file del tuo modello come segue.

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>]

Il flag checkpoint è un commit, un ramo o un tag del repository TensorFlow che vuoi verificare prima di creare le librerie. Per impostazione predefinita, è il ramo di release più recente. Il comando riportato sopra genererà il file AAR tensorflow-lite.aar per le operazioni personalizzate e integrate di TensorFlow Lite e, facoltativamente, il file AAR tensorflow-lite-select-tf-ops.aar per Seleziona operazioni TensorFlow nella directory attuale.

--cache_dir specifica la directory della cache. Se non viene fornito, lo script creerà una directory denominata bazel-build-cache nella directory di lavoro attuale per la memorizzazione nella cache.

Aggiungi file AAR al progetto

Aggiungi i file AAR importando l'AAR direttamente nel tuo progetto o pubblicando il file AAR personalizzato nel tuo repository Maven locale. Tieni presente che devi aggiungere anche i file AAR per tensorflow-lite-select-tf-ops.aar, se lo generi.

Build selettiva per iOS

Consulta la sezione Creazione in locale per impostare l'ambiente di compilazione e l'area di lavoro TensorFlow, quindi segui la guida per utilizzare lo script di compilazione selettivo per iOS.