Zvogëloni madhësinë binare të LiteRT

Përmbledhje

Kur vendosni modele për aplikacione të të mësuarit automatik në pajisje (ODML), është e rëndësishme të jeni të vetëdijshëm për memorien e kufizuar që është e disponueshme në pajisjet mobile. Madhësitë binare të modelit janë të lidhura ngushtë me numrin e operacioneve të përdorura në model. LiteRT ju mundëson të zvogëloni madhësitë binare të modelit duke përdorur ndërtime selektive. Ndërtimet selektive anashkalojnë operacionet e papërdorura në grupin tuaj të modelit dhe prodhojnë një bibliotekë kompakte vetëm me kohën e ekzekutimit dhe bërthamat e operacioneve të nevojshme që modeli të funksionojë në pajisjen tuaj mobile.

Ndërtimi selektiv zbatohet në tre bibliotekat e mëposhtme të operacioneve.

  1. Biblioteka e integruar e operacioneve LiteRT
  2. Operacione të personalizuara të LiteRT
  3. Zgjidhni bibliotekën e operacioneve TensorFlow

Tabela më poshtë tregon ndikimin e ndërtimeve selektive për disa raste përdorimi të zakonshme:

Emri i modelit Domen Arkitektura e synuar Madhësia(at) e skedarit AAR
Mobilenet_1.0_224 (notues) Klasifikimi i imazheve armeabi-v7a tensorflow-lite.aar (296,635 bajt)
arm64-v8a tensorflow-lite.aar (382,892 bajt)
ERËZA Nxjerrja e lartësisë së zërit armeabi-v7a tensorflow-lite.aar (375,813 bajt)
tensorflow-lite-select-tf-ops.aar (1,676,380 bajt)
arm64-v8a tensorflow-lite.aar (421,826 bajt)
tensorflow-lite-select-tf-ops.aar (2,298,630 bajt)
i3d-kinetikë-400 Klasifikimi i videove armeabi-v7a tensorflow-lite.aar (240,085 bajt)
tensorflow-lite-select-tf-ops.aar (1,708,597 bajt)
arm64-v8a tensorflow-lite.aar (273,713 bajt)
tensorflow-lite-select-tf-ops.aar (2,339,697 bajt)

Ndërtoni në mënyrë selektive LiteRT me Bazel

Ky seksion supozon se keni shkarkuar kodet burimore të TensorFlow dhe keni konfiguruar mjedisin lokal të zhvillimit në Bazel.

Ndërtoni skedarë AAR për projektin Android

Ju mund të ndërtoni AAR-të e personalizuara të LiteRT duke dhënë shtigjet e skedarëve të modelit tuaj si më poshtë.

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

Komanda e mësipërme do të gjenerojë skedarin AAR bazel-bin/tmp/tensorflow-lite.aar për operacionet e integruara dhe të personalizuara të LiteRT; dhe opsionalisht, gjeneron skedarin aar bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar nëse modelet tuaja përmbajnë operacione Select TensorFlow. Vini re se kjo ndërton një AAR "të trashë" me disa arkitektura të ndryshme; nëse nuk ju nevojiten të gjitha, përdorni nëngrupin e përshtatshëm për mjedisin tuaj të vendosjes.

Ndërto me operacione të personalizuara

Nëse keni zhvilluar modele LiteRT me operacione të personalizuara, mund t'i ndërtoni ato duke shtuar flamujt e mëposhtëm në komandën e ndërtimit:

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

Flamuri tflite_custom_ops_srcs përmban skedarët burimorë të operacioneve tuaja të personalizuara dhe flamuri tflite_custom_ops_deps përmban varësi për të ndërtuar ato skedarë burimorë. Vini re se këto varësi duhet të ekzistojnë në depon e TensorFlow.

Përdorime të Avancuara: Rregulla të Personalizuara të Bazelit

Nëse projekti juaj përdor Bazel dhe dëshironi të përcaktoni varësi të personalizuara TFLite për një grup të caktuar modelesh, mund të përcaktoni rregullat e mëposhtme në depon e projektit tuaj:

Vetëm për modelet me operacionet e integruara:

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

Për modelet me operacionet 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",
    ],
)

Përdorime të Avancuara: Ndërtoni biblioteka të përbashkëta C/C++ të personalizuara

Nëse dëshironi të ndërtoni objektet tuaja të përbashkëta TFLite C/C++ të personalizuara drejt modeleve të dhëna, mund të ndiqni hapat e mëposhtëm:

Krijo një skedar të përkohshëm BUILD duke ekzekutuar komandën e mëposhtme në direktorinë rrënjë të kodit burimor të TensorFlow:

mkdir -p tmp && touch tmp/BUILD

Ndërtimi i objekteve të përbashkëta C me porosi

Nëse dëshironi të ndërtoni një objekt të përbashkët TFLite C të personalizuar, shtoni sa vijon në skedarin 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",
    ],
)

Objektivi i shtuar rishtazi mund të ndërtohet si më poshtë:

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

dhe për Android (zëvendësoni android_arm me android_arm64 për 64-bit):

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

Ndërtimi i objekteve të përbashkëta C++ me porosi

Nëse dëshironi të ndërtoni një objekt të përbashkët TFLite C++ të personalizuar, shtoni sa vijon në skedarin 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",
    ],
)

Objektivi i shtuar rishtazi mund të ndërtohet si më poshtë: 

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

dhe për Android (zëvendësoni android_arm me android_arm64 për 64-bit): 

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

Për modelet me operacionet Select TF, duhet të ndërtoni edhe bibliotekën e përbashkët të mëposhtme: 

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

Objektivi i shtuar rishtazi mund të ndërtohet si më poshtë: 

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

dhe për Android (zëvendësoni android_arm me android_arm64 pë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

Ndërtoni në mënyrë selektive LiteRT me Docker

Ky seksion supozon se e keni instaluar Docker në makinën tuaj lokale dhe e keni shkarkuar skedarin LiteRT Docker këtu .

Pas shkarkimit të skedarit Docker të mësipërm, mund të ndërtoni imazhin docker duke ekzekutuar: 

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

Ndërtoni skedarë AAR për projektin Android

Shkarkoni skriptin për ndërtimin me Docker duke ekzekutuar: 

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

Pastaj, mund të ndërtoni AAR-in e personalizuar të LiteRT duke dhënë shtigjet e skedarit të modelit tuaj si më poshtë. 

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

Flamuri i checkpoint është një commit, një degë ose një etiketë e depos TensorFlow që dëshironi të kontrolloni para se të ndërtoni bibliotekat; si parazgjedhje, është dega e versionit më të fundit. Komanda e mësipërme do të gjenerojë skedarin AAR tensorflow-lite.aar për operacionet e integruara dhe të personalizuara të LiteRT dhe opsionalisht skedarin AAR tensorflow-lite-select-tf-ops.aar për operacionet Select TensorFlow në direktorinë tuaj aktuale.

--cache_dir specifikon direktorinë e memorjes së përkohshme. Nëse nuk jepet, skripti do të krijojë një direktori të quajtur bazel-build-cache nën direktorinë aktuale të punës për ruajtjen në memorien e përkohshme.

Shtoni skedarë AAR në projekt

Shtoni skedarë AAR duke e importuar direkt AAR-in në projektin tuaj ose duke e publikuar AAR-in e personalizuar në depon tuaj lokal Maven . Vini re se duhet të shtoni skedarët AAR edhe për tensorflow-lite-select-tf-ops.aar nëse e gjeneroni.

Ndërtim selektiv për iOS

Ju lutemi shihni seksionin Ndërtimi lokal për të konfiguruar mjedisin e ndërtimit dhe për të konfiguruar hapësirën e punës TensorFlow dhe më pas ndiqni udhëzuesin për të përdorur skriptin selektiv të ndërtimit për iOS.