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

खास जानकारी

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

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

1. TensorFlow Lite में पहले से मौजूद ऑपरेशन लाइब्रेरी
2. TensorFlow Lite की पसंद के मुताबिक ऑपरेशन
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 बाइट)

Baज़ल के साथ, TensorFlow Lite को चुनिंदा तरीके से बनाएं

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

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

मॉडल फ़ाइल पाथ की जानकारी देकर, कस्टम TensorFlow Lite 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

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

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

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

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

चुनें कि 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",
    ],
)

बेहतर इस्तेमाल: कस्टम 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 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",
    ],
)

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

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 की मदद से, चुनिंदा TensorFlow Lite बनाएं

इस सेक्शन में मान लिया गया है कि आपने अपने कंप्यूटर पर Docker इंस्टॉल किया है और TensorFlow Lite Dockerfile डाउनलोड किया है. इसके लिए, यहां क्लिक करें.

ऊपर दी गई Dockerfile डाउनलोड करने के बाद, डॉकर इमेज बनाने के लिए, यह काम करें:

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

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

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

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

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

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

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