Przegląd
Podczas wdrażania modeli dla aplikacji ODML na urządzeniu należy pamiętać o ograniczonej pamięci dostępnej na urządzeniach mobilnych. Rozmiary plików binarnych modelu są ściśle powiązane z liczbą operacji używanych w modelu. TensorFlow Lite pozwala zmniejszyć rozmiary plików binarnych modelu przy użyciu selektywnych kompilacji. Kompilacje selektywne pomijają nieużywane operacje w zbiorze modeli i tworzą kompaktową bibliotekę zawierającą wyłącznie środowisko wykonawcze i jądra systemu operacyjnego wymagane do uruchomienia modelu na urządzeniu mobilnym.
Kompilacja selektywna jest stosowana do 3 poniższych bibliotek operacji.
- Wbudowana biblioteka operacji TensorFlow Lite
- Niestandardowe operacje TensorFlow Lite
- Wybierz bibliotekę operacji TensorFlow
W tabeli poniżej przedstawiono wpływ kompilacji selektywnych w niektórych typowych przypadkach użycia:
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 TensorFlow Lite za pomocą Bazel
W tej sekcji zakładamy, że masz pobrane kody źródłowe TensorFlow i skonfigurowano lokalne środowisko programistyczne w Bazel.
Tworzenie plików AAR dla projektu na Androida
Niestandardowe klucze AAR w TensorFlow Lite możesz tworzyć, podając ścieżki do plików modelu w podany niżej 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
na potrzeby wbudowanych i niestandardowych operacji TensorFlow Lite i opcjonalnie wygeneruje plik AAR bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar
, jeśli modele zawierają operacje wyboru TensorFlow. Pamiętaj, że w ten sposób powstanie „gruby” AAR w kilku różnych architekturach. Jeśli nie potrzebujesz ich wszystkich, użyj podzbioru odpowiedniego dla Twojego środowiska wdrożenia.
Kompilacja z niestandardowymi operacjami
Jeśli masz modele Tensorflow Lite z niestandardowymi operacjami, możesz je skompilować, dodając do polecenia kompilacji te flagi:
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, a flaga tflite_custom_ops_deps
zawiera zależności do tworzenia tych plików źródłowych. 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ć niestandardowe zależności TFLite dla danego zestawu modeli, możesz zdefiniować w repozytorium projektu te reguły:
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 utworzyć własne udostępniane obiekty TFLite C/C++ na potrzeby podanych modeli, wykonaj te czynności:
Utwórz tymczasowy plik BUILD, uruchamiając następujące polecenie w katalogu głównym 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 do pliku tmp/BUILD
ten element:
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",
],
)
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
ten element:
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ć te 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 kompilowanie TensorFlow Lite z Dockerem
W tej sekcji zakładamy, że na komputerze lokalnym został zainstalowany Docker, a plik Dockerfile TensorFlow Lite został pobrany stąd.
Po pobraniu powyższego pliku Dockerfile możesz utworzyć obraz Dockera, uruchamiając polecenie:
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ć niestandardową ścieżkę AAR TensorFlow Lite, podając ścieżki do pliku modelu w podany niżej 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 sprawdzić przed utworzeniem bibliotek. Domyślnie jest to najnowsza gałąź. Powyższe polecenie wygeneruje plik AAR tensorflow-lite.aar
na potrzeby wbudowanych i niestandardowych operacji TensorFlow Lite oraz opcjonalnie plik AAR tensorflow-lite-select-tf-ops.aar
dla operacji wyboru TensorFlow w bieżącym katalogu.
Parametr --cache_dir określa katalog pamięci podręcznej. Jeśli nie zostanie podany, skrypt utworzy do buforowania w bieżącym katalogu roboczym katalog o nazwie bazel-build-cache
.
Dodaj pliki AAR do projektu
Dodaj pliki AAR, importując plik AAR bezpośrednio do projektu lub publikując niestandardowe AAR w lokalnym repozytorium Maven. Pamiętaj, że jeśli wygenerujesz plik AAR, musisz też dodać do niego plik tensorflow-lite-select-tf-ops.aar
.
Selektywna kompilacja na iOS
Zapoznaj się z sekcją Tworzenie lokalnie, aby skonfigurować środowisko kompilacji i obszar roboczy TensorFlow, a potem postępuj zgodnie ze wskazówkami w przewodniku, aby użyć skryptu kompilacji selektywnej dla iOS.