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

खास जानकारी

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

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

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

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

मॉडल का नाम डोमेन टारगेट आर्किटेक्चर एएआर फ़ाइल का साइज़
Mobilenet_1.0_224(float) इमेज क्लासिफ़िकेशन armeabi-v7a tensorflow-lite.aar (296,635 बाइट)
arm64-v8a tensorflow-lite.aar (3,82,892 बाइट)
SPICE आवाज़ की पिच का पता लगाना armeabi-v7a tensorflow-lite.aar (3,75,813 बाइट)
tensorflow-lite-select-tf-ops.aar (16,76,380 बाइट)
arm64-v8a tensorflow-lite.aar (4,21,826 बाइट)
tensorflow-lite-select-tf-ops.aar (22,98,630 बाइट)
i3d-kinetics-400 वीडियो का क्लासिफ़िकेशन armeabi-v7a tensorflow-lite.aar (240,085 बाइट)
tensorflow-lite-select-tf-ops.aar (1,708,597 बाइट)
arm64-v8a tensorflow-lite.aar (2,73,713 बाइट)
tensorflow-lite-select-tf-ops.aar (23,39,697 बाइट)

Bazel की मदद से, LiteRT को चुनिंदा तौर पर बनाना

इस सेक्शन में यह माना गया है कि आपने TensorFlow के सोर्स कोड डाउनलोड कर लिए हैं. साथ ही, आपने Bazel के लिए लोकल डेवलपमेंट एनवायरमेंट सेट अप कर लिया है.

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

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

कस्टम ऑप्स का इस्तेमाल करके मॉडल बनाना

अगर आपने कस्टम ऑप्स के साथ 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 के रेपो में मौजूद होनी चाहिए.

एडवांस इस्तेमाल: कस्टम Bazel नियम

अगर आपका प्रोजेक्ट Bazel का इस्तेमाल कर रहा है और आपको मॉडल के किसी सेट के लिए, कस्टम 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++ शेयर किए गए ऑब्जेक्ट बनाने हैं, तो यह तरीका अपनाएं:

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

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 के लिए (64-बिट के लिए android_arm को 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 के लिए (64-बिट के लिए android_arm को android_arm64 से बदलें):

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

Select TF ops वाले मॉडल के लिए, आपको यह शेयर की गई लाइब्रेरी भी बनानी होगी:

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 के लिए (64-बिट के लिए android_arm को 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 रेपो का एक कमिट, ब्रांच या टैग है. आपको लाइब्रेरी बनाने से पहले इसे चेकआउट करना होगा. डिफ़ॉल्ट रूप से, यह रिलीज़ की गई सबसे नई ब्रांच होती है. ऊपर दिए गए निर्देश से, LiteRT में पहले से मौजूद और कस्टम ऑप्स के लिए एएआर फ़ाइल tensorflow-lite.aar जनरेट होगी. साथ ही, आपकी मौजूदा डायरेक्ट्री में TensorFlow के चुने गए ऑप्स के लिए एएआर फ़ाइल tensorflow-lite-select-tf-ops.aar जनरेट होगी. हालांकि, यह ज़रूरी नहीं है.

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

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

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

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

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