7 दिसंबर को महिला एमएल संगोष्ठी में भाग लें अभी पंजीकरण करें

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

संग्रह की मदद से व्यवस्थित रहें अपनी प्राथमिकताओं के आधार पर, कॉन्टेंट को सेव करें और कैटगरी में बांटें.

अवलोकन

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

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

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

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

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

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

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

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

आप अपने मॉडल फ़ाइल पथ निम्नानुसार प्रदान करके कस्टम TensorFlow Lite AARs बना सकते हैं।

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 है यदि आपके मॉडल में Select TensorFlow ops शामिल हैं। ध्यान दें कि यह कई अलग-अलग आर्किटेक्चर के साथ "वसा" एएआर बनाता है; यदि आपको उन सभी की आवश्यकता नहीं है, तो अपने परिनियोजन परिवेश के लिए उपयुक्त उपसमुच्चय का उपयोग करें।

कस्टम ऑप्स के साथ निर्माण करें

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

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

यदि आपका प्रोजेक्ट 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 ऑप्स वाले मॉडल के लिए:

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 स्रोत कोड की मूल निर्देशिका में निम्न आदेश चलाकर एक अस्थायी बिल्ड फ़ाइल बनाएँ:

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

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

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

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

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

आईओएस के लिए चुनिंदा बिल्ड

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