Przegląd
Podczas wdrażania modeli dla aplikacji uczenia maszynowego (ODML) na urządzeniu należy pamiętać o ograniczonej pamięci dostępnej na urządzeniach mobilnych. Rozmiary binarne modelu są ściśle powiązane z liczbą operacji zastosowanych w modelu. TensorFlow Lite umożliwia zmniejszenie rozmiarów binarnych modelu za pomocą selektywnych kompilacji. Kompilacje selektywne pomijają nieużywane operacje w zestawie modeli i tworzą kompaktową bibliotekę zawierającą tylko środowisko wykonawcze i jądra operacyjne wymagane do uruchomienia modelu na urządzeniu mobilnym.
Kompilacja selektywna ma zastosowanie w następujących trzech bibliotekach operacyjnych.
- Wbudowana biblioteka operacyjna TensorFlow Lite
- Niestandardowe operacje TensorFlow Lite
- Wybierz bibliotekę ops TensorFlow
Poniższa tabela przedstawia wpływ kompilacji selektywnych w niektórych typowych przypadkach użycia:
Nazwa modelu | Domena | Docelowa architektura | Rozmiar pliku AAR |
---|---|---|---|
Mobilenet_1.0_224(pływająca) | Klasyfikacja obrazu | armeabi-v7a | tensorflow-lite.aar (296 635 bajtów) |
ramię64-v8a | tensorflow-lite.aar (382 892 bajtów) | ||
PRZYPRAWA | Ekstrakcja wysokości dźwięku | armeabi-v7a | tensorflow-lite.aar (375 813 bajtów) tensorflow-lite-select-tf-ops.aar (1 676 380 bajtów) |
ramię64-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) |
ramię64-v8a | tensorflow-lite.aar (273 713 bajtów) tensorflow-lite-select-tf-ops.aar (2 339 697 bajtów) |
Selektywnie buduj TensorFlow Lite za pomocą Bazela
W tej sekcji założono, że pobrałeś kody źródłowe TensorFlow i skonfigurowałeś lokalne środowisko programistyczne dla Bazel.
Kompiluj pliki AAR dla projektu na Androida
Możesz zbudować niestandardowe pliki AAR TensorFlow Lite, podając ścieżki 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 TensorFlow Lite; i opcjonalnie generuje plik aar bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar
jeśli Twoje modele zawierają opcję Select TensorFlow ops. Zauważ, że tworzy to „gruby” AAR z kilkoma różnymi architekturami; jeśli nie potrzebujesz ich wszystkich, użyj podzbioru odpowiedniego dla Twojego środowiska wdrażania.
Twórz z niestandardowymi operacjami
Jeśli opracowałeś modele Tensorflow Lite z niestandardowymi operacjami, możesz je zbudować, dodając następujące flagi do polecenia 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
Flaga tflite_custom_ops_srcs
zawiera pliki źródłowe niestandardowych operacji, a flaga tflite_custom_ops_deps
zawiera zależności umożliwiające zbudowanie tych plików źródłowych. Należy pamiętać, że te zależności muszą istnieć w repozytorium TensorFlow.
Zaawansowane zastosowania: Niestandardowe reguły Bazel
Jeśli Twój projekt korzysta z Bazela i chciałbyś zdefiniować niestandardowe zależności TFLite dla danego zestawu modeli, możesz zdefiniować następujące reguły w repozytorium projektu:
Tylko dla modeli z wbudowanymi opsami:
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",
],
)
Dla modeli z opcjami 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",
],
)
Zaawansowane zastosowania: Twórz niestandardowe biblioteki współdzielone C/C++
Jeśli chcesz zbudować własne, niestandardowe obiekty współdzielone TFLite C/C++ dla podanych modeli, możesz wykonać poniższe kroki:
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 współdzielonych w języku C
Jeśli chcesz zbudować niestandardowy obiekt współdzielony TFLite C, dodaj następujące elementy do pliku 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",
],
)
Nowo dodany cel można zbudować w następujący sposób:
bazel build -c opt --cxxopt=--std=c++17 \
//tmp:tensorflowlite_c
i dla Androida (zamień android_arm
na android_arm64
dla wersji 64-bitowej):
bazel build -c opt --cxxopt=--std=c++17 --config=android_arm \
//tmp:tensorflowlite_c
Tworzenie niestandardowych obiektów współdzielonych w języku C++
Jeśli chcesz zbudować niestandardowy obiekt współdzielony TFLite C++, dodaj następujące elementy 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żna zbudować w następujący sposób:
bazel build -c opt --cxxopt=--std=c++17 \
//tmp:tensorflowlite
i dla Androida (zamień android_arm
na android_arm64
dla wersji 64-bitowej):
bazel build -c opt --cxxopt=--std=c++17 --config=android_arm \
//tmp:tensorflowlite
W przypadku modeli z operacjami Select TF musisz także zbudować następującą bibliotekę współdzieloną:
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żna zbudować w następujący sposób:
bazel build -c opt --cxxopt='--std=c++17' \
--config=monolithic \
--host_crosstool_top=@bazel_tools//tools/cpp:toolchain \
//tmp:tensorflowlite_flex
i dla Androida (zamień android_arm
na android_arm64
dla 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
Selektywnie buduj TensorFlow Lite za pomocą Dockera
W tej sekcji założono, że zainstalowałeś Docker na swoim komputerze lokalnym i pobrałeś tutaj plik DockerFlow Lite.
Po pobraniu powyższego pliku Dockerfile możesz zbudować obraz okna dokowanego, uruchamiając:
docker build . -t tflite-builder -f tflite-android.Dockerfile
Kompiluj pliki AAR dla projektu na Androida
Pobierz skrypt do budowania za pomocą Dockera, uruchamiając:
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 zbudować niestandardowy plik AAR TensorFlow Lite, podając ścieżki plików modelu 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 znacznik repozytorium TensorFlow, który chcesz sprawdzić przed zbudowaniem bibliotek; domyślnie jest to gałąź najnowszego wydania. Powyższe polecenie wygeneruje plik AAR tensorflow-lite.aar
dla wbudowanych i niestandardowych operacji TensorFlow Lite oraz opcjonalnie plik AAR tensorflow-lite-select-tf-ops.aar
dla operacji Select TensorFlow w bieżącym katalogu.
--cache_dir określa katalog pamięci podręcznej. Jeśli nie zostanie podany, skrypt utworzy katalog o nazwie bazel-build-cache
w bieżącym katalogu roboczym na potrzeby buforowania.
Dodaj pliki AAR do projektu
Dodaj pliki AAR, bezpośrednio importując plik AAR do swojego projektu lub publikując niestandardowy plik AAR w lokalnym repozytorium Maven . Pamiętaj, że musisz także dodać pliki AAR dla tensorflow-lite-select-tf-ops.aar
, jeśli je wygenerujesz.
Kompilacja selektywna dla iOS
Zapoznaj się z sekcją Budowanie lokalne , aby skonfigurować środowisko kompilacji i obszar roboczy TensorFlow, a następnie postępuj zgodnie z przewodnikiem , aby użyć selektywnego skryptu kompilacji dla systemu iOS.