Prezantimi i Portalit të Edge të Google AI : Benchmark Edge AI në shkallë. Regjistrohuni për të kërkuar qasje gjatë pamjes paraprake private.

Kjo faqe është përkthyer nga Cloud Translation API.

Zvogëloni madhësinë binare të LiteRT

Vështrim i përgjithshëm

Kur vendosni modele për aplikacionet e mësimit të makinerive në pajisje (ODML), është e rëndësishme të jeni të vetëdijshëm për kujtesën e kufizuar që disponohet në pajisjet celulare. Madhësitë binare të modelit janë të lidhura ngushtë me numrin e funksioneve të përdorura në model. LiteRT ju mundëson të reduktoni madhësitë binare të modelit duke përdorur ndërtime selektive. Ndërtimet selektive kapërcejnë operacionet e papërdorura në grupin tuaj të modeleve dhe prodhojnë një bibliotekë kompakte me vetëm kohën e ekzekutimit dhe kernelët e nevojshëm që modeli të funksionojë në pajisjen tuaj celulare.

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

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

Emri i modelit	Domeni	Arkitektura e synuar	Madhësia(t) e skedarit AAR
Mobilenet_1.0_224 (lundrues)	Klasifikimi i imazheve	armeabi-v7a	tensorflow-lite.aar (296,635 bytes)
Mobilenet_1.0_224 (lundrues)	Klasifikimi i imazheve	krahu64-v8a	tensorflow-lite.aar (382,892 bytes)
EREZE	Nxjerrja e lartësisë së zërit	armeabi-v7a	tensorflow-lite.aar (375,813 bytes) tensorflow-lite-select-tf-ops.aar (1,676,380 bytes)
EREZE	Nxjerrja e lartësisë së zërit	krahu64-v8a	tensorflow-lite.aar (421,826 bytes) tensorflow-lite-select-tf-ops.aar (2,298,630 bytes)
i3d-kinetics-400	Klasifikimi i videos	armeabi-v7a	tensorflow-lite.aar (240,085 bytes) tensorflow-lite-select-tf-ops.aar (1,708,597 bytes)
i3d-kinetics-400	Klasifikimi i videos	krahu64-v8a	tensorflow-lite.aar (273,713 bytes) tensorflow-lite-select-tf-ops.aar (2,339,697 bytes)

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

Ky seksion supozon se ju keni shkarkuar kodet burimore TensorFlow dhe keni vendosur mjedisin e zhvillimit lokal në Bazel.

Ndërtoni skedarë AAR për projektin Android

Ju mund të ndërtoni AAR-të e personalizuara LiteRT duke ofruar 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 funksionet 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ë Ops Select TensorFlow. Vini re se kjo krijon një AAR "të trashë" me disa arkitektura të ndryshme; nëse nuk ju duhen të gjitha, përdorni nëngrupin e përshtatshëm për mjedisin tuaj të vendosjes.

Ndërtoni me opsione të personalizuara

Nëse keni zhvilluar modele LiteRT me funksione 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ë burimi të funksioneve tuaja të personalizuara dhe flamuri tflite_custom_ops_deps përmban varësi për të ndërtuar ato skedarë burimi. Vini re se këto varësi duhet të ekzistojnë në repon e TensorFlow.

Përdorime të avancuara: Rregullat e personalizuara të Bazel

Nëse projekti juaj po 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 funksione të 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 opsionet 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 me porosi C/C++

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

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

mkdir -p tmp && touch tmp/BUILD

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

Nëse dëshironi të ndërtoni një objekt të përbashkët TFLite C, 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 me porosi C++

Nëse dëshironi të ndërtoni një objekt të përbashkët TFLite C++, 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 opsionet Select TF, duhet gjithashtu të ndërtoni 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 që ju keni instaluar Docker në kompjuterin tuaj lokal dhe keni shkarkuar LiteRT Dockerfile këtu .

Pas shkarkimit të skedarit Docker të mësipërm, mund të ndërtoni imazhin e dokerit 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

Më pas, mund të ndërtoni LiteRT AAR të personalizuar duke ofruar shtigjet e skedarit tuaj të modelit 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 checkpoint është një commit, një degë ose një etiketë e depove TensorFlow që dëshironi të kontrolloni përpara se të ndërtoni bibliotekat; si parazgjedhje është dega e fundit e lëshimit. Komanda e mësipërme do të gjenerojë skedarin AAR tensorflow-lite.aar për funksionet e integruara dhe të personalizuara të LiteRT dhe opsionalisht skedarin AAR tensorflow-lite-select-tf-ops.aar për Select TensorFlow ops në drejtorinë tuaj aktuale.

--cache_dir specifikon direktorinë e cache. Nëse nuk ofrohet, skripti do të krijojë një drejtori të quajtur bazel-build-cache nën drejtorinë aktuale të punës për memorie.

Shtoni skedarët AAR në projekt

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

Ndërtim selektiv për iOS

Ju lutemi, shihni seksionin Ndërtimi në nivel 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 e ndërtimit selektiv për iOS.