Zmniejsz rozmiar pliku binarnego LiteRT

Omówienie

Podczas wdrażania modeli dla aplikacji ODML na urządzeniu warto pamiętaj o ograniczonej pamięci dostępnej w urządzeniach mobilnych. Rozmiary plików binarnych modelu są ściśle powiązane z liczbą operacji używanych w model atrybucji. LiteRT pozwala zmniejszyć rozmiary plików binarnych modelu za pomocą wybrane selektywne kompilacje. Selektywne kompilacje pomijają nieużywane operacje w zbiorze modeli i stworzyć kompaktową bibliotekę zawierającą wyłącznie środowisko wykonawcze i jądra systemu wymagane do działania model do uruchomienia na urządzeniu mobilnym.

Kompilacja selektywna jest stosowana do 3 poniższych bibliotek operacji.

  1. Wbudowana biblioteka operacji LiteRT
  2. Operacje niestandardowe LiteRT
  3. Wybierz bibliotekę operacji TensorFlow

Tabela poniżej pokazuje wpływ kompilacji selektywnych w niektórych typowych zastosowaniach przypadki:

Nazwa modelu Domena Docelowa architektura Rozmiary plików AAR
Mobilenet_1.0_224(float) Klasyfikacja obrazów Armeabi-V7a tensorflow-lite.aar (296 635 bajtów)
Arm64-V8a tensorflow-lite.aar (382 892 bajty)
SPICE Wyodrębnianie tonu dźwięku Armeabi-V7a Tensorflow-lite.aar (375 813 bajtów)
tensorflow-lite-select-tf-ops.aar (1 676 380 bajtów)
Arm64-V8a Tensorflow-lite.aar (421 826 bajtów)
tensorflow-lite-select-tf-ops.aar (2 298 630 bajtów)
i3d-kinetics-400 Klasyfikacja wideo Armeabi-V7a tensorflow-lite.aar (240 085 bajtów)
tensorflow-lite-select-tf-ops.aar (1 708 597 bajtów)
Arm64-V8a Tensorflow-lite.aar (273 713 bajtów)
tensorflow-lite-select-tf-ops.aar (2 339 697 bajtów)

Selektywne tworzenie LiteRT w Bazel

W tej sekcji zakładamy, że masz pobrane kody źródłowe TensorFlow i ustawione stymulowanie lokalnego rozwoju na Bazel.

Tworzenie plików AAR dla projektu na Androida

Niestandardowe AAR LiteRT możesz tworzyć, podając ścieżki do plików modelu w następujący sposób.

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

Powyższe polecenie wygeneruje plik AAR bazel-bin/tmp/tensorflow-lite.aar dla wbudowanych i niestandardowych operacji LiteRT; i opcjonalnie generuje AAR plik bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar, jeśli modele zawierają Wybierz operacje TensorFlow. Pamiętaj, że w ten sposób powstaje „tkanka tłuszczowa”, AAR z kilkoma różnymi architektury; Jeśli nie potrzebujesz ich wszystkich, użyj podzbioru odpowiedniego dla do środowiska wdrożenia.

Kompilacja z niestandardowymi operacjami

Jeśli masz modele LiteRT z niestandardowymi operacjami, możesz je tworzyć dodając te flagi do polecenia kompilacji:

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

Flaga tflite_custom_ops_srcs zawiera pliki źródłowe niestandardowych operacji oraz flaga tflite_custom_ops_deps zawiera zależności potrzebne do utworzenia tych źródeł . Pamiętaj, że te zależności muszą istnieć w repozytorium TensorFlow.

Zastosowania zaawansowane: niestandardowe reguły Bazelu

Jeśli Twój projekt korzysta z usługi Bazel i chcesz zdefiniować niestandardowy TFLite dla danego zbioru modeli, możesz zdefiniować następujące reguły w repozytorium projektu:

Tylko w przypadku modeli z wbudowanymi operacjami:

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

W przypadku modeli z wyborem operacji 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",
    ],
)

Zastosowania zaawansowane: tworzenie niestandardowych bibliotek udostępnionych w C/C++

Jeśli chcesz tworzyć własne obiekty udostępniane w TFLite C/C++, dla podanych modeli, możesz wykonać następujące czynności:

Utwórz tymczasowy plik BUILD, uruchamiając następujące polecenie w katalogu głównym katalogu kodu źródłowego TensorFlow:

mkdir -p tmp && touch tmp/BUILD

Tworzenie niestandardowych obiektów udostępnianych C

Jeśli chcesz utworzyć niestandardowy udostępniony obiekt TFLite C, dodaj poniższy kod do Plik 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",
    ],
)

Nowo dodany cel może być skonstruowany w ten sposób:

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

oraz na Androida (zastąp android_arm ciągiem android_arm64 w wersji 64-bitowej):

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

Tworzenie niestandardowych obiektów udostępnianych w C++

Jeśli chcesz utworzyć niestandardowy obiekt udostępniany w TFLite C++, dodaj: do pliku 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",
    ],
)

Nowo dodany cel może być skonstruowany w ten sposób:

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

oraz na Androida (zastąp android_arm ciągiem android_arm64 w wersji 64-bitowej):

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

W przypadku modeli z operacjami Select TF musisz też utworzyć zasoby wspólne:

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

Nowo dodany cel może być skonstruowany w ten sposób:

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

oraz na Androida (zastąp android_arm ciągiem android_arm64 w wersji 64-bitowej):

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

Selektywne tworzenie LiteRT przy użyciu Dockera

W tej sekcji zakładamy, że zainstalowano Dockera na komputerze lokalnym pobrano plik Dockerfile LiteRT tutaj.

Po pobraniu powyższego pliku Dockerfile możesz utworzyć obraz Dockera przez bieg:

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

Tworzenie plików AAR dla projektu na Androida

Pobierz skrypt do kompilacji za pomocą Dockera, uruchamiając polecenie:

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

Następnie możesz utworzyć niestandardowy pakiet AAR LiteRT, przesyłając plik z modelem ścieżek w następujący sposób.

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

Flaga checkpoint to zatwierdzenie, gałąź lub tag repozytorium TensorFlow, który chcesz zapłacić przed utworzeniem bibliotek; domyślnie jest to najnowsza wersja gałąź wydania. Polecenie powyżej wygeneruje plik AAR tensorflow-lite.aar na potrzeby wbudowanych i niestandardowych operacji LiteRT i opcjonalnie pliku AAR tensorflow-lite-select-tf-ops.aar na potrzeby wyboru operacji TensorFlow w bieżącym katalogu.

Parametr --cache_dir określa katalog pamięci podręcznej. Jeśli nie zostanie podany, skrypt zostanie utwórz katalog o nazwie bazel-build-cache w bieżącym katalogu roboczym dla buforowanie.

Dodaj pliki AAR do projektu

Dodaj pliki AAR, bezpośrednio importując je do projektu lub publikowania niestandardowe powiadomienie o stanie AAR u lokalnego Maven. . Notatka musisz dodać pliki AAR dla tensorflow-lite-select-tf-ops.aar jako jeśli ją wygenerujesz.

Selektywna kompilacja na iOS

Informacje o tym, jak to zrobić, znajdziesz w sekcji dotyczącej kompilacji lokalnych. utwórz środowisko kompilacji i skonfiguruj obszar roboczy TensorFlow, a następnie postępuj zgodnie z przewodnik po korzystaniu z funkcji selektywnych skrypt kompilacji na iOS.