LiteRT-Binärgröße reduzieren

Übersicht

Wenn Sie Modelle für On-Device- Machine Learning (ODML)-Anwendungen bereitstellen, der auf Mobilgeräten zur Verfügung steht. Die binären Größen des Modells stehen in engem Zusammenhang mit der Anzahl der Vorgänge, die im Modell. Mit LiteRT können Sie die binären Größen des Modells reduzieren, indem Sie selektive Builds. Selektive Builds überspringen nicht verwendete Vorgänge in Ihrem Modellsatz und eine kompakte Bibliothek nur mit der Laufzeit und den für die Ausführung auf Ihrem Mobilgerät auszuführen.

Selektive Builds werden auf die folgenden drei Vorgangsbibliotheken angewendet.

  1. Integrierte LiteRT-Vorgangsbibliothek
  2. Benutzerdefinierte LiteRT-Vorgänge
  3. TensorFlow-Vorgangsbibliothek auswählen

Die folgende Tabelle zeigt die Auswirkungen selektiver Builds für einige häufige Anwendungsfälle Cases:

Modellname Domain Zielarchitektur AAR-Dateigröße(n)
Mobilenet_1.0_224(float) Bildklassifizierung Armeabi-V7a tensorflow-lite.aar (296.635 Byte)
arm64-v8a tensorflow-lite.aar (382.892 Byte)
GEWÜRZ Extraktion von Tonhöhen 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 Videoklassifizierung 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)

Selektives Erstellen von LiteRT mit Bazel

In diesem Abschnitt wird davon ausgegangen, dass Sie TensorFlow-Quellcodes heruntergeladen und festgelegt haben. die lokale Entwicklung voranbringen um „Baby“.

AAR-Dateien für Android-Projekt erstellen

Sie können die benutzerdefinierten LiteRT-ARs erstellen, indem Sie die Modelldateipfade angeben wie im Folgenden beschrieben.

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

Mit dem Befehl oben wird die AAR-Datei bazel-bin/tmp/tensorflow-lite.aar generiert. für integrierte LiteRT- und benutzerdefinierte Vorgänge; und generiert optional die aar Datei bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar, wenn Ihre Modelle Folgendes enthalten: Wählen Sie TensorFlow-Vorgänge aus. Beachten Sie, dass dadurch ein „Fett“ AAE mit verschiedenen Architekturen; Sollten Sie nicht alle benötigen, verwenden Sie die für Ihrer Bereitstellungsumgebung.

Build mit benutzerdefinierten Operationen

Wenn Sie LiteRT-Modelle mit benutzerdefinierten Operationen entwickelt haben, können Sie diese erstellen indem Sie dem Befehl „build“ die folgenden Flags hinzufügen:

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

Das Flag tflite_custom_ops_srcs enthält Quelldateien Ihrer benutzerdefinierten Vorgänge und Das Flag tflite_custom_ops_deps enthält Abhängigkeiten zum Erstellen dieser Quelle -Dateien. Diese Abhängigkeiten müssen im TensorFlow-Repository vorhanden sein.

Erweiterte Verwendung: Benutzerdefinierte Bazel-Regeln

Wenn Ihr Projekt Bazel verwendet und Sie ein benutzerdefiniertes TFLite definieren möchten für einen bestimmten Satz Modelle haben, können Sie folgende Regel(n) in Ihrem Projekt-Repository:

Nur für Modelle mit integrierten Operationen:

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

Für Modelle mit TF-Operationen auswählen:

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

Fortgeschrittene Nutzung: Benutzerdefinierte gemeinsam genutzte C/C++ Bibliotheken erstellen

Wenn Sie Ihre eigenen benutzerdefinierten gemeinsamen Objekte in TFLite C/C++ erstellen möchten, Modelle verfügbar, können Sie die folgenden Schritte ausführen:

Erstellen Sie eine temporäre Build-Datei, indem Sie im Stammverzeichnis den folgenden Befehl ausführen: des TensorFlow-Quellcodes an:

mkdir -p tmp && touch tmp/BUILD

Benutzerdefinierte gemeinsam genutzte C-Objekte erstellen

Wenn Sie ein benutzerdefiniertes gemeinsam genutztes TFLite C-Objekt erstellen möchten, fügen Sie Folgendes zu tmp/BUILD-Datei:

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

Das neu hinzugefügte Ziel kann so erstellt werden:

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

und für Android (ersetzen Sie android_arm durch android_arm64 für 64-Bit):

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

Benutzerdefinierte gemeinsam genutzte C++ Objekte erstellen

Wenn Sie ein benutzerdefiniertes gemeinsam genutztes TFLite C++-Objekt erstellen möchten, fügen Sie Folgendes hinzu: in Datei 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",
    ],
)

Das neu hinzugefügte Ziel kann so erstellt werden:

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

und für Android (ersetzen Sie android_arm durch android_arm64 für 64-Bit):

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

Für die Modelle mit "Select TF Ops" müssen Sie außerdem Folgendes erstellen: gemeinsam genutzte Bibliothek verwenden:

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

Das neu hinzugefügte Ziel kann so erstellt werden:

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

und für Android (ersetzen Sie android_arm durch android_arm64 für 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

LiteRT mit Docker selektiv erstellen

In diesem Abschnitt wird vorausgesetzt, dass Sie Docker auf Ihrem lokalen Computer und LiteRT-Dockerfile heruntergeladen hier.

Nachdem Sie das obige Dockerfile heruntergeladen haben, können Sie das Docker-Image erstellen, indem Sie ausgeführt:

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

AAR-Dateien für Android-Projekt erstellen

Laden Sie das Skript zum Erstellen mit Docker herunter, indem Sie folgenden Befehl ausführen:

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

Anschließend können Sie den benutzerdefinierten LiteRT AAR erstellen, indem Sie Ihre Modelldatei bereitstellen. wie im Folgenden dargestellt.

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

Das Flag checkpoint ist ein Commit, ein Zweig oder ein Tag des TensorFlow-Repositorys, das bevor Sie die Bibliotheken erstellen, ist standardmäßig die neueste Release-Zweig. Mit dem Befehl oben wird die AAR-Datei generiert. tensorflow-lite.aar für integrierte LiteRT- und benutzerdefinierte Vorgänge und optional AAR-Datei tensorflow-lite-select-tf-ops.aar für „Select TensorFlow Operationen“ in in Ihrem aktuellen Verzeichnis.

Mit „--cache_dir“ wird das Cache-Verzeichnis angegeben. Wenn Sie nichts angeben, wird das Skript Erstellen Sie ein Verzeichnis mit dem Namen bazel-build-cache im aktuellen Arbeitsverzeichnis für Caching.

AAR-Dateien zum Projekt hinzufügen

Fügen Sie automatisch angewendete Empfehlungen hinzu, indem Sie die automatisch angewendeten Empfehlungen direkt in Ihr oder durch Veröffentlichung den benutzerdefinierten automatisch angewendeten Empfehlungen an Ihr lokales Maven Repository erstellen. Hinweis dass du die AAR-Dateien für tensorflow-lite-select-tf-ops.aar als wenn Sie sie generieren.

Selektiver Build für iOS

Informationen zum Festlegen der Einstellungen finden Sie im Abschnitt Lokal erstellen. die Build-Umgebung einrichten und den TensorFlow-Arbeitsbereich konfigurieren. Leitfaden zur Verwendung der selektiven Build-Script für iOS.