Riduci le dimensioni binarie LiteRT

Panoramica

Quando distribuisci modelli per applicazioni di machine learning on-device (ODML), è importante tenere presente la memoria limitata disponibile sui dispositivi mobili. Le dimensioni dei file binari del modello sono strettamente correlate al numero di operazioni utilizzate nel modello. LiteRT ti consente di ridurre le dimensioni dei file binari del modello utilizzando build selettive. Le build selettive ignorano le operazioni inutilizzate nel set di modelli e producono una libreria compatta con solo il runtime e i kernel delle operazioni necessari per l'esecuzione del modello sul dispositivo mobile.

La build selettiva si applica alle seguenti tre librerie di operazioni.

  1. Libreria di operazioni integrata LiteRT
  2. LiteRT custom ops
  3. Seleziona la libreria delle operazioni TensorFlow

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

Nome modello Dominio Architettura di destinazione Dimensioni dei 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 dell'intonazione 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 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)

Compilare LiteRT in modo selettivo con Bazel

Questa sezione presuppone che tu abbia scaricato i codici sorgente di TensorFlow e configurato l'ambiente di sviluppo locale per Bazel.

Creare file AAR per il progetto Android

Puoi creare gli AAR LiteRT personalizzati fornendo i percorsi dei file del 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 precedente genererà il file AAR bazel-bin/tmp/tensorflow-lite.aar per le operazioni personalizzate e integrate di LiteRT e, facoltativamente, genererà il file AAR bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar se i tuoi modelli contengono operazioni TensorFlow Select. Tieni presente che viene creato un AAR "fat" 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 LiteRT con operazioni personalizzate, puoi crearli aggiungendo i seguenti flag al comando di compilazione:

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 tuo progetto utilizza Bazel e vuoi definire dipendenze TFLite personalizzate per un determinato insieme di modelli, puoi definire le seguenti regole nel repository del progetto:

Per i modelli con le 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 l'opzione Seleziona operazioni 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",
    ],
)

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

Se vuoi creare i tuoi oggetti condivisi C/C++ TFLite personalizzati per i modelli specificati, segui questi passaggi:

Crea un file BUILD temporaneo eseguendo il seguente comando nella directory principale del codice sorgente TensorFlow:

mkdir -p tmp && touch tmp/BUILD

Creazione di oggetti condivisi C personalizzati

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

Il target appena aggiunto può essere creato nel seguente modo:

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

Il target appena aggiunto può essere creato nel seguente modo:

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 l'opzione Seleziona operazioni TF, devi anche creare 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",
  ],
)

Il target appena aggiunto può essere creato nel seguente modo:

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 LiteRT in modo selettivo con Docker

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

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

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

Creare 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

Poi, puoi creare l'AAR LiteRT personalizzato fornendo i percorsi dei file del 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 estrarre prima di creare le librerie; per impostazione predefinita è l'ultimo ramo di rilascio. Il comando precedente genererà il file AAR tensorflow-lite.aar per le operazioni integrate e personalizzate di LiteRT e, facoltativamente, il file AAR tensorflow-lite-select-tf-ops.aar per le operazioni TensorFlow selezionate nella directory corrente.

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

Aggiungere file AAR al progetto

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

Compilazione selettiva per iOS

Consulta la sezione Creazione locale per configurare l'ambiente di build e configurare lo spazio di lavoro TensorFlow, quindi segui la guida per utilizzare lo script di build selettiva per iOS.