LiteRT बाइनरी का साइज़ कम करें

खास जानकारी

डिवाइस पर मौजूद मशीन लर्निंग (ओडीएमएल) ऐप्लिकेशन के लिए मॉडल डिप्लॉय करते समय, इसलिए, आपको मोबाइल डिवाइसों में उपलब्ध सीमित मेमोरी के बारे में जानकारी होनी चाहिए. मॉडल बाइनरी साइज़, मॉडल. LiteRT की मदद से, मॉडल बाइनरी साइज़ को कम किया जा सकता है. इसके लिए, चुनिंदा बिल्ड. चुनिंदा बिल्ड आपके मॉडल सेट में इस्तेमाल न होने वाली कार्रवाइयों को छोड़ देते हैं और एक ऐसी छोटी लाइब्रेरी बनाएं जिसमें सिर्फ़ रनटाइम और सेशन के लिए, ज़रूरी ऑपरेटर आपके मोबाइल डिवाइस पर चलने वाला मॉडल चुनें.

चुनिंदा बिल्ड नीचे दिए गए तीन ऑपरेशन लाइब्रेरी पर लागू होता है.

  1. LiteRT पर पहले से मौजूद ऑपरेशन लाइब्रेरी
  2. LiteRT कस्टम ऑपरेशन
  3. TensorFlow ops लाइब्रेरी चुनें

नीचे दी गई टेबल में, कुछ सामान्य इस्तेमाल के लिए चुनिंदा बिल्ड के असर के बारे में बताया गया है मामले:

मॉडल का नाम डोमेन टारगेट आर्किटेक्चर एएआर फ़ाइल का(के) साइज़
Mobilenet_1.0_224(float) इमेज की कैटगरी तय करना Armeabi-v7a tensorflow-lite.aar (296,635 बाइट)
आर्म64-v8a tensorflow-lite.aar (382,892 बाइट)
मसाला साउंड पिच निकालने की सुविधा Armeabi-v7a tensorflow-lite.aar (375,813 बाइट)
tensorflow-lite-select-tf-ops.aar (1,676,380 बाइट)
आर्म64-v8a tensorflow-lite.aar (421,826 बाइट)
tensorflow-lite-select-tf-ops.aar (2,298,630 बाइट)
i3d-काइनेटिक्स-400 वीडियो की कैटगरी तय करने वाला मॉडल Armeabi-v7a tensorflow-lite.aar (240,085 बाइट)
tensorflow-lite-select-tf-ops.aar (1,708,597 बाइट)
आर्म64-v8a tensorflow-lite.aar (273,713 बाइट)
tensorflow-lite-select-tf-ops.aar (2,339,697 बाइट)

Basel के साथ LiteRT को चुनिंदा तरीके से बनाएं

इस सेक्शन में यह माना जाता है कि आपने TensorFlow के सोर्स कोड डाउनलोड कर लिए हैं और लोकल डेवलपमेंट के बारे में बताओ एनवायरमेंट से बेज़ल.

Android प्रोजेक्ट के लिए AAR फ़ाइलें बनाएं

मॉडल फ़ाइल पाथ देकर, कस्टम LiteRT AAR बनाए जा सकते हैं के बारे में यहां बताया गया है.

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

ऊपर दिए गए निर्देश से AAR फ़ाइल bazel-bin/tmp/tensorflow-lite.aar जनरेट होगी LiteRT बिल्ट-इन और कस्टम ऑपरेशन के लिए; और वैकल्पिक रूप से, ऐरो जनरेट करता है फ़ाइल bazel-bin/tmp/tensorflow-lite-select-tf-ops.aar, अगर आपके मॉडल में शामिल है TensorFlow ऑपरेशन चुनें. ध्यान दें कि इससे "मोटा" बनता है कई अलग-अलग तरह के एएआर आर्किटेक्चर; अगर आपको सभी की ज़रूरत नहीं है, तो ऐसे सबसेट का इस्तेमाल करें जो डिप्लॉयमेंट एनवायरमेंट की सूची में शामिल करें.

कस्टम ऑपरेशन की मदद से बनाएं

अगर आपने अपनी ज़रूरत के हिसाब से ऑपरेशन वाले LiteRT मॉडल डेवलप किए हैं, तो उन्हें बनाया जा सकता है बिल्ड कमांड में ये फ़्लैग जोड़कर:

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

tflite_custom_ops_srcs फ़्लैग में आपके कस्टम ऑपरेशन की सोर्स फ़ाइलें और tflite_custom_ops_deps फ़्लैग में उन सोर्स को बनाने के लिए डिपेंडेंसी होती है फ़ाइलें शामिल हैं. ध्यान दें कि ये डिपेंडेंसी, TensorFlow के रेपो में मौजूद होनी चाहिए.

बेहतर इस्तेमाल: बेज़ल के लिए पसंद के मुताबिक बनाए गए नियम

अगर आपके प्रोजेक्ट में Basel का इस्तेमाल किया जा रहा है और आपको अपनी पसंद के मुताबिक TFLite तय करना है, तो मॉडल के दिए गए सेट के लिए निर्भरता, तो आप अपने प्रोजेक्ट रिपॉज़िटरी:

सिर्फ़ पहले से मौजूद ऑपरेशन वाले मॉडल के लिए:

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

Select TF ops वाले मॉडल के लिए:

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

बेहतर इस्तेमाल: कस्टम C/C++ शेयर की गई लाइब्रेरी बनाएं

अगर आपको अपनी पसंद के मुताबिक TFLite C/C++ शेयर किए गए ऑब्जेक्ट बनाने हैं, तो तो नीचे दिए गए चरणों का पालन करें:

रूट पर दिए गए निर्देश को चलाकर, कुछ समय के लिए BUILD फ़ाइल बनाएं TensorFlow सोर्स कोड की डायरेक्ट्री:

mkdir -p tmp && touch tmp/BUILD

कस्टम C शेयर ऑब्जेक्ट बनाना

अगर आपको पसंद के मुताबिक TFLite C शेयर किया गया ऑब्जेक्ट बनाना है, तो 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",
    ],
)

जोड़ा गया नया टारगेट इस तरह बनाया जा सकता है:

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

और Android के लिए (android_arm को 64-बिट के लिए android_arm64 से बदलें):

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

कस्टम C++ शेयर किए गए ऑब्जेक्ट बनाना

अगर आपको अपनी पसंद के मुताबिक TFLite C++ का शेयर किया गया ऑब्जेक्ट बनाना है, तो ये चीज़ें जोड़ें 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",
    ],
)

जोड़ा गया नया टारगेट इस तरह बनाया जा सकता है:

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

और Android के लिए (android_arm को 64-बिट के लिए android_arm64 से बदलें):

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

चुनिंदा TF ऑपरेशन वाले मॉडल के लिए, आपको नीचे दी गई चीज़ें भी बनानी होंगी शेयर लाइब्रेरी:

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

जोड़ा गया नया टारगेट इस तरह बनाया जा सकता है:

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

और Android के लिए (android_arm को 64-बिट के लिए android_arm64 से बदलें):

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

Docker की मदद से, LiteRT को चुनिंदा तरीके से बनाएं

इस सेक्शन में यह मान लिया गया है कि आपने Docker अपने कंप्यूटर पर और LiteRT Dockerfile डाउनलोड की गई यहां क्लिक करें.

ऊपर दी गई Dockerfile डाउनलोड करने के बाद, आप Docker इमेज बना सकते हैं. चालू:

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

Android प्रोजेक्ट के लिए AAR फ़ाइलें बनाएं

Docker की मदद से बिल्डिंग बनाने की स्क्रिप्ट डाउनलोड करने के लिए, यह तरीका अपनाएं:

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

इसके बाद, अपनी मॉडल फ़ाइल देकर, पसंद के मुताबिक LiteRT AAR बनाया जा सकता है पाथ को फ़ॉलो कर सकते हैं.

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

checkpoint फ़्लैग, TensorFlow रेपो का टैग, ब्रांच या टैग है आपको लाइब्रेरी बनाने से पहले चेकआउट करना हो; डिफ़ॉल्ट रूप से यह सबसे नया होता है रिलीज़ ब्रांच. ऊपर दिए गए निर्देश से AAR फ़ाइल जनरेट होगी LiteRT बिल्ट-इन और कस्टम ऑपरेशन के लिए tensorflow-lite.aar. ज़रूरी नहीं है चुनिंदा TensorFlow ऑपरेशन के लिए AAR फ़ाइल tensorflow-lite-select-tf-ops.aar आपकी मौजूदा डायरेक्ट्री.

--कैश मेमोरी में, कैश मेमोरी में सेव की गई डायरेक्ट्री को चुना जा सकता है. अगर यह पैरामीटर उपलब्ध नहीं कराया जाता है, तो स्क्रिप्ट इसके लिए मौजूदा काम करने वाली डायरेक्ट्री के तहत bazel-build-cache नाम की एक डायरेक्ट्री बनाएं कैश मेमोरी.

प्रोजेक्ट में AAR फ़ाइलें जोड़ें

AAR फ़ाइलें जोड़ने के लिए, सीधे AAR को अपने या पब्लिश करके आपके स्थानीय Maven के लिए कस्टम AAR डेटा स्टोर करने की जगह. नोट जोड़ें आपको tensorflow-lite-select-tf-ops.aar के लिए AAR फ़ाइलें इस तौर पर जोड़नी होंगी अच्छी तरह से जनरेट किया जा सकता है.

iOS के लिए चुनिंदा बिल्ड

सेट करने के लिए कृपया स्थानीय तौर पर बिल्डिंग सेक्शन देखें बिल्ड एनवायरमेंट को तैयार करें और TensorFlow के फ़ाइल फ़ोल्डर को कॉन्फ़िगर करें. इसके बाद, चुनने के तरीके का इस्तेमाल करने के लिए गाइड iOS के लिए बिल्ड स्क्रिप्ट.