इस पेज का अनुवाद Cloud Translation API से किया गया है.
Switch to English

TensorFlow Lite मॉडल में मेटाडेटा जोड़ना

TensorFlow Lite मेटाडेटा मॉडल विवरणों के लिए एक मानक प्रदान करता है। मेटाडेटा ज्ञान का एक महत्वपूर्ण स्रोत है कि मॉडल क्या करता है और इसके इनपुट / आउटपुट की जानकारी क्या है। मेटाडेटा में दोनों शामिल हैं

TensorFlow Lite के होस्ट किए गए मॉडल और TensorFlow हब पर प्रकाशित सभी छवि मॉडल मेटाडेटा के साथ आबाद किए गए हैं।

मेटाडेटा उपकरण सेट करें

अपने मॉडल में मेटाडेटा जोड़ने से पहले, आपको TensorFlow को चलाने के लिए पायथन प्रोग्रामिंग वातावरण सेटअप की आवश्यकता होगी। यहां इसे कैसे सेट किया जाए, इस पर एक विस्तृत गाइड है

पायथन प्रोग्रामिंग वातावरण की स्थापना के बाद, आपको अतिरिक्त टूलींग स्थापित करनी होगी:

pip install tflite-support

TensorFlow Lite मेटाडेटा टूलिंग पायथन 2 और पायथन 3 दोनों का समर्थन करता है।

मेटाडेटा जोड़ना

स्कीमा में मॉडल मेटाडेटा के तीन भाग हैं:

  1. मॉडल की जानकारी - मॉडल का समग्र विवरण और साथ ही लाइसेंस की शर्तें जैसे आइटम। ModelMetadata देखें।
  2. इनपुट जानकारी - इनपुट्स और प्री-प्रोसेसिंग का विवरण आवश्यक है जैसे सामान्यीकरण। SubGraphMetadata.input_tensor_metadata देखें।
  3. आउटपुट जानकारी - आउटपुट और पोस्ट-प्रोसेसिंग का विवरण आवश्यक है जैसे कि लेबलिंग के लिए मैपिंग। SubGraphMetadata.output_tensor_metadata देखें।

चूंकि TensorFlow लाइट केवल इस बिंदु पर एक subgraph का समर्थन करता है, TensorFlow लाइट कोड जनरेटर और एंड्रॉयड स्टूडियो एमएल बाइंडिंग सुविधा का उपयोग करेगा ModelMetadata.name और ModelMetadata.description , बजाय SubGraphMetadata.name और SubGraphMetadata.description , जब मेटाडाटा को प्रदर्शित करने और पैदा कोड।

समर्थित इनपुट / आउटपुट प्रकार

इनपुट और आउटपुट के लिए TensorFlow Lite मेटाडेटा को विशिष्ट मॉडल प्रकारों को ध्यान में रखते हुए नहीं बल्कि इनपुट और आउटपुट प्रकारों के साथ डिज़ाइन किया गया है। इससे कोई फर्क नहीं पड़ता कि मॉडल कार्यात्मक रूप से क्या करता है, जब तक कि इनपुट और आउटपुट प्रकार निम्न या संयोजन के होते हैं, यह TensorFlow Lite मेटाडेटा द्वारा समर्थित है:

  • फ़ीचर - संख्या जो अहस्ताक्षरित पूर्णांक या फ्लोट 32 हैं।
  • चित्र - मेटाडेटा वर्तमान में RGB और greyscale छवियों का समर्थन करता है।
  • बाउंडिंग बॉक्स - आयताकार आकार बाउंडिंग बॉक्स। स्कीमा कई प्रकार की योजनाओं का समर्थन करती है

संबंधित फ़ाइलों को पैक करें

TensorFlow Lite मॉडल विभिन्न संबद्ध फाइलों के साथ आ सकते हैं। उदाहरण के लिए, प्राकृतिक भाषा के मॉडल में आमतौर पर शब्द पट्टियां होती हैं जो शब्द आईडी के लिए शब्द के टुकड़े को मैप करती हैं; वर्गीकरण मॉडल में लेबल फाइलें हो सकती हैं जो ऑब्जेक्ट श्रेणियों को इंगित करती हैं। संबंधित फ़ाइलों (यदि वहाँ हैं) के बिना, एक मॉडल अच्छी तरह से काम नहीं करेगा।

संबंधित फाइलें अब मेटाडेटा पायथन लाइब्रेरी के माध्यम से मॉडल के साथ बंडल की जा सकती हैं। नया TensorFlow Lite मॉडल एक ज़िप फ़ाइल बन जाता है जिसमें मॉडल और संबंधित फ़ाइल दोनों होते हैं। इसे सामान्य ज़िप टूल्स के साथ अनपैक किया जा सकता है। यह नया मॉडल प्रारूप समान फ़ाइल एक्सटेंशन, .tflite का उपयोग करता रहता है। यह मौजूदा TFLite ढांचे और दुभाषिया के साथ संगत है। अधिक विवरण के लिए मॉडल में पैक mtadata और संबंधित फ़ाइलों को देखें।

संबंधित फ़ाइल जानकारी मेटाडेटा में पुनर्प्राप्त की जा सकती है। फ़ाइल प्रकार और जहाँ फ़ाइल (यानी ModelMetadata , SubGraphMetadata , और TensorMetadata ) से जुड़ी है, के SubGraphMetadata , TensorFlow Lite Android कोड जनरेटर संबंधित प्री / पोस्ट प्रोसेसिंग को स्वचालित रूप से ऑब्जेक्ट पर लागू कर सकता है। अधिक जानकारी के लिए स्कीमा में प्रत्येक सहयोगी फ़ाइल प्रकार का <Codegen उपयोग> अनुभाग देखें।

सामान्यीकरण और परिमाणीकरण पैरामीटर

मशीन लर्निंग में सामान्यीकरण एक सामान्य डेटा प्रीप्रोसेसिंग तकनीक है। सामान्यीकरण का लक्ष्य मूल्यों के श्रेणी में अंतर को विकृत किए बिना, मूल्यों को एक सामान्य पैमाने पर बदलना है।

मॉडल मात्रा का ठहराव एक ऐसी तकनीक है जो वजन के कम सटीक निरूपण और वैकल्पिक रूप से, भंडारण और गणना दोनों के लिए सक्रियता की अनुमति देती है।

प्रीप्रोसेसिंग और पोस्ट-प्रोसेसिंग के संदर्भ में, सामान्यीकरण और परिमाणीकरण दो स्वतंत्र चरण हैं। यहाँ विवरण हैं।

मानकीकरण परिमाणीकरण

क्रमशः फ्लोट और क्वांट मॉडल के लिए मोबाइलनेट में इनपुट छवि के पैरामीटर मूल्यों का एक उदाहरण।
फ्लोट मॉडल :
- माध्य: 127.5
- एसटीडी: 127.5
मात्रा मॉडल :
- माध्य: 127.5
- एसटीडी: 127.5
फ्लोट मॉडल :
- जीरोप्वाइंट: 0
- पैमाना: 1.0
मात्रा मॉडल :
- जीरोप्वाइंट: 128.0
- स्केल: 0.0078125f




कब करना है?


इनपुट्स : यदि प्रशिक्षण में इनपुट डेटा को सामान्यीकृत किया जाता है, तो अनुमान के इनपुट डेटा को तदनुसार सामान्यीकृत किया जाना चाहिए।
आउटपुट : आउटपुट डेटा को सामान्य रूप से सामान्य नहीं किया जाएगा।
फ्लोट मॉडल को परिमाणीकरण की आवश्यकता नहीं है।
पूर्व / उत्तर प्रसंस्करण में परिमाणित मॉडल को परिमाणीकरण की आवश्यकता हो सकती है या नहीं। यह इनपुट / आउटपुट टेंसर्स के डेटाटाइप पर निर्भर करता है।
- फ्लोट टेंसर्स: पूर्व / पोस्ट प्रसंस्करण में कोई परिमाणीकरण की आवश्यकता नहीं है। क्वांट ऑप और डिक्वांट ऑप को मॉडल ग्राफ में बेक किया जाता है।
- int8 / uint8 दसियों: पूर्व / बाद प्रसंस्करण में मात्रा का ठहराव की जरूरत है।


सूत्र


normalized_input = (इनपुट - माध्य) / std
आदानों के लिए परिमाण :
q = f / scale + zeroPoint
आउटपुट के लिए निर्विवाद करें :
f = (q - zeroPoint) * स्केल

पैरामीटर कहां हैं
मॉडल निर्माता द्वारा भरा गया और NormalizationOptions रूप में मॉडल मेटाडेटा में संग्रहीत किया गया TFLite कनवर्टर द्वारा स्वचालित रूप से भरा, और tflite मॉडल फ़ाइल में संग्रहीत।
मापदंडों को कैसे प्राप्त करें? MetadataExtractor एपीआई के माध्यम से [2] TFLite Tensor API के माध्यम से [1] या MetadataExtractor API के माध्यम से [2]
क्या फ्लोट और क्वांट मॉडल समान मूल्य साझा करते हैं? हां, फ्लोट और क्वांट मॉडल में एक ही नॉर्मलाइजेशन पैरामीटर होते हैं नहीं, फ्लोट मॉडल को परिमाणीकरण की आवश्यकता नहीं है।
क्या TFLite कोड जनरेटर या एंड्रॉइड स्टूडियो एमएल बाइंडिंग स्वचालित रूप से डेटा प्रोसेसिंग में उत्पन्न करता है?
हाँ

हाँ

[१] टेंसोरफ्लो लाइट जावा एपीआई और टेन्सरफ्लो लाइट सी ++ एपीआई
[२] मेटाडेटा एक्सट्रैक्टर लाइब्रेरी

जब uint8 मॉडल के लिए छवि डेटा संसाधित करते हैं, तो सामान्यीकरण और मात्रा का ठहराव कभी-कभी छोड़ दिया जाता है। पिक्सेल मान [0, 255] की सीमा में होने पर ऐसा करना ठीक है। लेकिन सामान्य तौर पर, आपको हमेशा लागू होने पर सामान्यीकरण और परिमाणीकरण मापदंडों के अनुसार डेटा को संसाधित करना चाहिए।

उदाहरण

आप इस बात के उदाहरण पा सकते हैं कि विभिन्न प्रकार के मॉडलों के लिए मेटाडेटा को किस तरह से आबाद किया जाना चाहिए:

छवि वर्गीकरण

यहां स्क्रिप्ट डाउनलोड करें , जो मेटाडेटा को mobilenet_v1_0.75_160_quantized.tflite से आबाद करती है । स्क्रिप्ट को इस तरह से चलाएं:

python ./metadata_writer_for_image_classifier.py \
    --model_file=./model_without_metadata/mobilenet_v1_0.75_160_quantized.tflite \
    --label_file=./model_without_metadata/labels.txt \
    --export_directory=model_with_metadata

अन्य छवि वर्गीकरण मॉडल के लिए मेटाडेटा को पॉप्युलेट करने के लिए, स्क्रिप्ट में इस तरह से मॉडल चश्मा जोड़ें। इस गाइड के बाकी हिस्सों को छवि वर्गीकरण उदाहरण में कुछ प्रमुख वर्गों पर प्रकाश डाला जाएगा ताकि मुख्य तत्वों को चित्रित किया जा सके।

छवि वर्गीकरण उदाहरण में गहरी डुबकी

मॉडल की जानकारी

मेटाडेटा एक नया मॉडल जानकारी बनाकर शुरू होता है:

from tflite_support import flatbuffers
from tflite_support import metadata as _metadata
from tflite_support import metadata_schema_py_generated as _metadata_fb

""" ... """
"""Creates the metadata for an image classifier."""

# Creates model info.
model_meta = _metadata_fb.ModelMetadataT()
model_meta.name = "MobileNetV1 image classifier"
model_meta.description = ("Identify the most prominent object in the "
                          "image from a set of 1,001 categories such as "
                          "trees, animals, food, vehicles, person etc.")
model_meta.version = "v1"
model_meta.author = "TensorFlow"
model_meta.license = ("Apache License. Version 2.0 "
                      "http://www.apache.org/licenses/LICENSE-2.0.")

इनपुट / आउटपुट जानकारी

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

# Creates input info.
input_meta = _metadata_fb.TensorMetadataT()

# Creates output info.
output_meta = _metadata_fb.TensorMetadataT()

छवि इनपुट

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

input_meta.name = "image"
input_meta.description = (
    "Input image to be classified. The expected image is {0} x {1}, with "
    "three channels (red, blue, and green) per pixel. Each value in the "
    "tensor is a single byte between 0 and 255.".format(160, 160))
input_meta.content = _metadata_fb.ContentT()
input_meta.content.contentProperties = _metadata_fb.ImagePropertiesT()
input_meta.content.contentProperties.colorSpace = (
    _metadata_fb.ColorSpaceType.RGB)
input_meta.content.contentPropertiesType = (
    _metadata_fb.ContentProperties.ImageProperties)
input_normalization = _metadata_fb.ProcessUnitT()
input_normalization.optionsType = (
    _metadata_fb.ProcessUnitOptions.NormalizationOptions)
input_normalization.options = _metadata_fb.NormalizationOptionsT()
input_normalization.options.mean = [127.5]
input_normalization.options.std = [127.5]
input_meta.processUnits = [input_normalization]
input_stats = _metadata_fb.StatsT()
input_stats.max = [255]
input_stats.min = [0]
input_meta.stats = input_stats

लेबल आउटपुट

लेबल TENSOR_AXIS_LABELS का उपयोग करके संबंधित फ़ाइल के माध्यम से आउटपुट टेंसर पर मैप किया जा सकता है।

# Creates output info.
output_meta = _metadata_fb.TensorMetadataT()
output_meta.name = "probability"
output_meta.description = "Probabilities of the 1001 labels respectively."
output_meta.content = _metadata_fb.ContentT()
output_meta.content.content_properties = _metadata_fb.FeaturePropertiesT()
output_meta.content.contentPropertiesType = (
    _metadata_fb.ContentProperties.FeatureProperties)
output_stats = _metadata_fb.StatsT()
output_stats.max = [1.0]
output_stats.min = [0.0]
output_meta.stats = output_stats
label_file = _metadata_fb.AssociatedFileT()
label_file.name = os.path.basename("your_path_to_label_file")
label_file.description = "Labels for objects that the model can recognize."
label_file.type = _metadata_fb.AssociatedFileType.TENSOR_AXIS_LABELS
output_meta.associatedFiles = [label_file]

मेटाडेटा फ्लैटबफर्स ​​बनाएँ

निम्न कोड इनपुट और आउटपुट जानकारी के साथ मॉडल जानकारी को जोड़ता है:

# Creates subgraph info.
subgraph = _metadata_fb.SubGraphMetadataT()
subgraph.inputTensorMetadata = [input_meta]
subgraph.outputTensorMetadata = [output_meta]
model_meta.subgraphMetadata = [subgraph]

b = flatbuffers.Builder(0)
b.Finish(
    model_meta.Pack(b),
    _metadata.MetadataPopulator.METADATA_FILE_IDENTIFIER)
metadata_buf = b.Output()

मेटाडेटा और संबंधित फ़ाइलों को मॉडल में पैक करें

एक बार जब मेटाडाटा Flatbuffers बनाई गई है, मेटाडाटा और लेबल फ़ाइल के माध्यम से TFLite फ़ाइल में लिखा जाता है populate विधि:

populator = _metadata.MetadataPopulator.with_model_file(model_file)
populator.load_metadata_buffer(metadata_buf)
populator.load_associated_files(["your_path_to_label_file"])
populator.populate()

आप load_associated_files माध्यम से मॉडल में जितनी चाहें उतनी संबद्ध फाइलें पैक कर सकते हैं। हालांकि, मेटाडेटा में प्रलेखित कम से कम उन फ़ाइलों को पैक करना आवश्यक है। इस उदाहरण में, lable फ़ाइल को पैक करना अनिवार्य है।

मेटाडेटा की कल्पना करें

आप अपने मेटाडेटा की कल्पना करने के लिए नेट्रॉन का उपयोग कर सकते हैं, या आप मेटाडेटाडिसप्लेयर का उपयोग करते हुए एक MetadataDisplayer प्रारूप में TensorFlow Lite मॉडल से मेटाडेटा पढ़ सकते हैं:

displayer = _metadata.MetadataDisplayer.with_model_file(export_model_path)
export_json_file = os.path.join(FLAGS.export_directory,
                    os.path.splitext(model_basename)[0] + ".json")
json_file = displayer.get_metadata_json()
# Optional: write out the metadata as a json file
with open(export_json_file, "w") as f:
  f.write(json_file)

Android Studio, Android Studio ML बाइंडिंग फीचर के माध्यम से मेटाडेटा प्रदर्शित करने का समर्थन करता है।

मेटाडाटा संस्करण

मेटाडेटा स्कीमा को सेमेटिक संस्करण संख्या द्वारा दोनों प्रकारों में विभाजित किया जाता है, जो स्कीमा फ़ाइल के परिवर्तनों को ट्रैक करता है, और फ़्लैटबफ़र्स फ़ाइल पहचान द्वारा, जो कि वास्तविक संस्करण संगतता को इंगित करता है।

सिमेंटिक संस्करण संख्या

मेटाडेटा स्कीमा शब्दार्थ संस्करण संख्या , जैसे कि MAJOR.MINOR.PATCH द्वारा लिया जाता है। यह यहां नियमों के अनुसार स्कीमा परिवर्तन को ट्रैक करता है । संस्करण 1.0.0 बाद जोड़े गए फ़ील्ड का इतिहास देखें।

फ्लैटबफर्स ​​फ़ाइल पहचान

सिमेंटिक संस्करण नियमों का पालन करते हुए अनुकूलता की गारंटी देता है, लेकिन यह वास्तविक असंगति का अर्थ नहीं है। MAJOR नंबर को उछालते समय, इसका मतलब यह नहीं है कि पीछे की संगतता टूट गई है। इसलिए, हम मेटाडेटा स्कीमा की वास्तविक अनुकूलता को दर्शाने के लिए फ्लैटबफर्स ​​फ़ाइल पहचान , file_identifiler का उपयोग करते हैं। फ़ाइल पहचानकर्ता ठीक 4 वर्ण लंबा है। यह एक निश्चित मेटाडेटा स्कीमा के लिए निर्धारित है और उपयोगकर्ताओं द्वारा परिवर्तन के अधीन नहीं है। यदि मेटाडेटा स्कीमा की पिछड़े संगतता को किसी कारण से तोड़ना पड़ता है, तो file_identifier टकराएगा, उदाहरण के लिए, "M001" से "M002"। File_identifiler मेटाडेटा_version की तुलना में बहुत कम बार बदला जाने की उम्मीद है।

न्यूनतम आवश्यक मेटाडेटा पार्सर संस्करण

न्यूनतम आवश्यक मेटाडेटा पार्सर संस्करण मेटाडेटा पार्सर (उत्पन्न फ्लैटबफ़र्स उत्पन्न कोड) का न्यूनतम संस्करण है जो मेटाडेटा फ्लैटबफ़र्स को पूर्ण रूप से पढ़ सकता है। संस्करण प्रभावी रूप से आबादी वाले सभी क्षेत्रों के संस्करणों और फ़ाइल पहचानकर्ता द्वारा दर्शाए गए सबसे छोटे संगत संस्करण के बीच सबसे बड़ा संस्करण संख्या है। न्यूनतम आवश्यक मेटाडाटा पार्सर संस्करण स्वचालित रूप से बसा हुआ है MetadataPopulator जब मेटाडाटा एक TFLite मॉडल में डाला जा रहा है। न्यूनतम आवश्यक मेटाडेटा पार्सर संस्करण का उपयोग करने के तरीके के बारे में अधिक जानकारी के लिए मेटाडेटा एक्सट्रैक्टर देखें।

मॉडल से मेटाडेटा पढ़ें

मेटाडेटा एक्सट्रैक्टर लाइब्रेरी विभिन्न प्लेटफार्मों पर एक मॉडल से मेटाडेटा और संबंधित फ़ाइलों को पढ़ने के लिए सुविधाजनक उपकरण है ( जावा संस्करण और सी ++ संस्करण देखें )। आप फ़्लैटबफ़र्स लाइब्रेरी का उपयोग करके अन्य भाषाओं में अपना मेटाडेटा एक्सट्रैक्टर टूल बना सकते हैं।

जावा में मेटाडेटा पढ़ें

अपने Android ऐप में मेटाडेटा एक्सट्रैक्टर लाइब्रेरी का उपयोग करने के लिए, हम JCenter में होस्ट किए गए TensorFlow Lite मेटाडेटा AAR का उपयोग करने की सलाह देते हैं। इसमें MetadataExtractor एक्स्ट्रेक्टर वर्ग, साथ ही मेटाडेटा स्कीमा और मॉडल स्कीमा के लिए फ्लैटबफर्स ​​जावा बाइंडिंग शामिल हैं।

आप इसे अपने build.gradle निर्भरता में निम्नानुसार निर्दिष्ट कर सकते हैं:

dependencies {
    implementation 'org.tensorflow:tensorflow-lite-metadata:0.0.0-nightly'
}

आप एक ByteBuffer साथ MetadataExtractor ByteBuffer ऑब्जेक्ट को आरम्भ कर सकते हैं जो मॉडल को इंगित करता है:

public MetadataExtractor(ByteBuffer buffer);

ByteBuffer को MetadataExtractor ऑब्जेक्ट के पूरे जीवनकाल के लिए अपरिवर्तित रहना चाहिए। यदि मेटाडेटा मॉडल मेटाडेटा के पहचानकर्ता फ़ाइल मेटाडेटा पार्सर से मेल नहीं खाता है तो यह आरंभन विफल हो सकता है। अधिक जानकारी के लिए मेटाडेटा संस्करण देखें।

मिलान फ़ाइल पहचानकर्ताओं के साथ, मेटाडेटा एक्सट्रैक्टर सफलतापूर्वक सभी पिछले और भविष्य के स्कीमा से उत्पन्न मेटाडेटा को फ़्लैटबफ़र्स के फ़ॉर्वर्ड और बैकवर्ड संगतता तंत्र के कारण पढ़ेगा। हालाँकि, भविष्य के स्कीमा से फ़ील्ड पुराने मेटाडेटा एक्सट्रैक्टर्स द्वारा नहीं निकाले जा सकते हैं। मेटाडेटा का न्यूनतम आवश्यक पार्सर संस्करण मेटाडेटा पार्सर के न्यूनतम संस्करण को इंगित करता है जो मेटाडेटा फ्लैटबफर्स ​​को पूर्ण रूप से पढ़ सकता है। यदि न्यूनतम आवश्यक पार्सर संस्करण की स्थिति पूरी हो गई है, तो आप सत्यापित करने के लिए निम्न विधि का उपयोग कर सकते हैं:

public final boolean isMinimumParserVersionSatisfied();

मेटाडेटा के बिना मॉडल में पास होने की अनुमति है। हालाँकि, मेटाडेटा से पढ़ने वाले तरीकों को लागू करने से रनटाइम त्रुटियाँ हो सकती हैं। आप देख सकते हैं एक मॉडल मेटाडाटा लागू द्वारा है hasMetadata विधि:

public boolean hasMetadata();

MetadataExtractor आपको इनपुट / आउटपुट टेनर्स मेटाडेटा प्राप्त करने के लिए सुविधाजनक कार्य प्रदान करता है। उदाहरण के लिए,

public int getInputTensorCount();
public TensorMetadata getInputTensorMetadata(int inputIndex);
public QuantizationParams getInputTensorQuantizationParams(int inputIndex);
public int[] getInputTensorShape(int inputIndex);
public int getoutputTensorCount();
public TensorMetadata getoutputTensorMetadata(int inputIndex);
public QuantizationParams getoutputTensorQuantizationParams(int inputIndex);
public int[] getoutputTensorShape(int inputIndex);

आप संबंधित फ़ाइलों को उनके नाम के माध्यम से पढ़ सकते हैं getAssociatedFile विधि:

public InputStream getAssociatedFile(String fileName);

हालांकि TensorFlow Lite मॉडल स्कीमा कई सबग्राफ का समर्थन करता है, लेकिन TFLite इंटरप्रेटर वर्तमान में केवल एक ही सबग्राफ का समर्थन करता है। इसलिए, MetadataExtractor अपने तरीकों में इनपुट तर्क के रूप में सबग्राफ इंडेक्स को छोड़ देता है।