Partecipa al simposio Women in ML il 7 dicembre Registrati ora

Riduci le dimensioni binarie di TensorFlow Lite

Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Panoramica

Quando si distribuiscono modelli per applicazioni ODML (On-Device Machine Learning), è importante essere consapevoli della 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 del modello utilizzando build selettive. Le build selettive ignorano le operazioni non utilizzate nel set di modelli e producono una libreria compatta con solo il runtime e i kernel operativi necessari per l'esecuzione del modello sul dispositivo mobile.

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

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

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

Nome del modello Dominio Architettura di destinazione Dimensioni file AAR
Mobilenet_1.0_224(flottante) Classificazione delle immagini armeabi-v7a tensorflow-lite.aar (296.635 byte)
arm64-v8a tensorflow-lite.aar (382.892 byte)
SPEZIA Estrazione del tono sonoro 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-cinetica-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)

Costruisci in modo selettivo TensorFlow Lite con Bazel

Questa sezione 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

È possibile creare AAR TensorFlow Lite 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 TensorFlow Lite; e facoltativamente, genera il file bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar se i tuoi modelli contengono Select TensorFlow ops. Si noti che questo crea un AAR "grasso" con diverse architetture; se non ti servono tutti, usa il sottoinsieme appropriato per il tuo ambiente di distribuzione.

Costruisci con operazioni personalizzate

Se hai sviluppato modelli Tensorflow Lite con operazioni personalizzate, puoi costruirli 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 tue operazioni personalizzate e il flag tflite_custom_ops_deps contiene le dipendenze per creare quei file di origine. Tieni presente che queste dipendenze devono esistere nel repository TensorFlow.

Usi avanzati: regole Bazel personalizzate

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

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

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

Se desideri creare i tuoi oggetti condivisi TFLite C/C++ personalizzati per i modelli indicati, puoi seguire i passaggi seguenti:

Crea un file BUILD temporaneo eseguendo il comando seguente nella directory principale 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 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",
    ],
)

Il target appena aggiunto può essere costruito 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 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 costruito 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 le operazioni Select TF, è necessario 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",
  ],
)

Il target appena aggiunto può essere costruito 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 in modo selettivo TensorFlow Lite con Docker

Questa sezione presuppone che tu abbia installato Docker sul tuo computer locale e scaricato il TensorFlow Lite Dockerfile qui .

Dopo aver scaricato il Dockerfile sopra, puoi creare l'immagine della finestra mobile eseguendo:

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

Crea file AAR per il progetto Android

Scarica lo script per la compilazione 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

Quindi, puoi creare l'AAR TensorFlow Lite 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 del checkpoint è un commit, un ramo o un tag del repository TensorFlow che vuoi controllare 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 TensorFlow Lite e, facoltativamente, il file AAR tensorflow-lite-select-tf-ops.aar per le operazioni di selezione TensorFlow 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.

Aggiungi file AAR al progetto

Aggiungi file AAR importando direttamente l'AAR nel tuo progetto o pubblicando l'AAR personalizzato nel tuo repository Maven locale . Nota 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 configurare l'ambiente di compilazione e configurare l'area di lavoro TensorFlow, quindi segui la guida per utilizzare lo script di compilazione selettiva per iOS.