Riduci le dimensioni binarie LiteRT

Panoramica

Quando esegui il deployment di modelli per le applicazioni di machine learning (ODML) on-device, tieni presente la quantità limitata di memoria disponibile sui dispositivi mobili. Le dimensioni binarie del modello sono strettamente correlate al numero di operazioni utilizzate nella un modello di machine learning. LiteRT consente di ridurre le dimensioni binarie del modello utilizzando selettive. Le build selettive ignorano le operazioni inutilizzate nel set di modelli produrre una libreria compatta con solo il runtime e i kernel operativi necessari per eseguire il modello sul tuo dispositivo mobile.

La build selettiva si applica alle tre librerie operazioni seguenti.

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

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

Nome modello Dominio Architettura di destinazione Dimensioni file AAR
Mobilenet_1.0_224(float) Classificazione delle 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 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 in modo selettivo LiteRT con Bazel

In questa sezione si presuppone che tu abbia scaricato i codici sorgente di TensorFlow e impostato lo sviluppo locale dell'ambiente in modo da Bazel.

Crea file AAR per il progetto Android

Puoi creare AAR LiteRT 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 LiteRT integrate e personalizzate; e, facoltativamente, genera l'AR file bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar se i tuoi modelli contengono Seleziona Operazioni TensorFlow. Tieni presente che in questo modo si crea un "grasso" AAR con diverse architetture; se non ti servono tutti, usa il sottoinsieme appropriato per dell'ambiente di deployment.

Crea con operazioni personalizzate

Se hai sviluppato modelli LiteRT 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 sorgente delle tue operazioni personalizzate e il flag tflite_custom_ops_deps contiene dipendenze per creare queste origini . Tieni presente che queste dipendenze devono esistere nel repository TensorFlow.

Utilizzi avanzati: regole bazel personalizzate

Se il progetto utilizza Bazel e vuoi definire un file TFLite personalizzato per un determinato insieme di modelli, puoi definire le seguenti regole repository di progetti:

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 desideri creare oggetti condivisi TFLite C/C++ personalizzati ai modelli forniti, puoi seguire questi passaggi:

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

mkdir -p tmp && touch tmp/BUILD

Creazione di oggetti condivisi C personalizzati

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

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 desideri creare un oggetto condiviso TFLite C++ personalizzato, aggiungi quanto segue in tmp/BUILD file:

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

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

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

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

Successivamente, potrai creare l'ARL LiteRT personalizzato fornendo il file del modello di questi percorsi nel modo seguente.

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 pagare prima di creare le biblioteche; per impostazione predefinita è la versione più recente ramo di rilascio. Il comando riportato sopra genererà il file AAR tensorflow-lite.aar per operazioni LiteRT integrate e personalizzate e, facoltativamente il file AAR tensorflow-lite-select-tf-ops.aar per le operazioni Selezionate TensorFlow in della directory corrente.

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

Aggiungi file AAR al progetto

I file AAR possono essere aggiunti direttamente all'importazione del file AAR nel progetto oppure pubblicando l'AR personalizzato al tuo Maven locale di archiviazione dei dati. Nota che devi aggiungere i file AAR per tensorflow-lite-select-tf-ops.aar come anche se li generi.

Build selettiva per iOS

Consulta la sezione Creazione in locale per impostare l'ambiente di compilazione e la configurazione dell'area di lavoro TensorFlow, quindi segui le guida all'uso dello strumento selettivo di sviluppo per iOS.