TensorFlow Lite का बाइनरी आकार कम करें

अवलोकन

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

चयनात्मक निर्माण निम्नलिखित तीन संचालन पुस्तकालयों पर लागू होता है।

  1. TensorFlow Lite अंतर्निर्मित ऑप्स लाइब्रेरी
  2. TensorFlow लाइट कस्टम ऑप्स
  3. TensorFlow ऑप्स लाइब्रेरी का चयन करें

नीचे दी गई तालिका कुछ सामान्य उपयोग के मामलों के लिए चयनात्मक बिल्ड के प्रभाव को दर्शाती है:

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

बेज़ेल के साथ चुनिंदा रूप से TensorFlow Lite बनाएं

यह अनुभाग मानता है कि आपने TensorFlow स्रोत कोड डाउनलोड कर लिया है और स्थानीय विकास वातावरण को Bazel पर सेट कर दिया है

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 उत्पन्न करेगा; और वैकल्पिक रूप से, यदि आपके मॉडल में सेलेक्ट टेन्सरफ्लो ऑप्स शामिल हैं, तो aar फ़ाइल bazel-bin/tmp/tensorflow-lite-select-tf-ops.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 \
  --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 रेपो में मौजूद होनी चाहिए।

उन्नत उपयोग: कस्टम बेज़ेल नियम

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

केवल बिल्टिन ऑप्स वाले मॉडलों के लिए:

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

सेलेक्ट टीएफ ऑप्स वाले मॉडलों के लिए:

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

कस्टम सी साझा वस्तुओं का निर्माण

यदि आप एक कस्टम 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 के लिए (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

सेलेक्ट टीएफ ऑप्स वाले मॉडलों के लिए, आपको निम्नलिखित साझा लाइब्रेरी भी बनाने की आवश्यकता है:

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

डॉकर के साथ चुनिंदा रूप से TensorFlow Lite बनाएं

यह अनुभाग मानता है कि आपने अपनी स्थानीय मशीन पर डॉकर स्थापित किया है और यहां TensorFlow Lite Dockerfile डाउनलोड किया है।

उपरोक्त Dockerfile को डाउनलोड करने के बाद, आप चलाकर docker छवि बना सकते हैं:

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

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

डॉकर के साथ निर्माण के लिए स्क्रिप्ट चलाकर डाउनलोड करें:

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 Lite बिल्ट-इन और कस्टम ऑप्स के लिए AAR फ़ाइल tensorflow-lite.aar उत्पन्न करेगा और वैकल्पिक रूप से आपकी वर्तमान निर्देशिका में चयनित TensorFlow ऑप्स के लिए AAR फ़ाइल tensorflow-lite-select-tf-ops.aar उत्पन्न करेगा।

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

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

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

आईओएस के लिए चयनात्मक बिल्ड

कृपया बिल्ड वातावरण स्थापित करने और TensorFlow कार्यक्षेत्र को कॉन्फ़िगर करने के लिए स्थानीय स्तर पर बिल्डिंग अनुभाग देखें और फिर iOS के लिए चयनात्मक बिल्ड स्क्रिप्ट का उपयोग करने के लिए गाइड का पालन करें।