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

TensorFlow Lite मेटाडेटा, मॉडल के ब्यौरे के लिए एक स्टैंडर्ड उपलब्ध कराता है. मेटाडेटा, मॉडल के काम और इसके इनपुट / आउटपुट की जानकारी के बारे में जानकारी पाने का एक अहम सोर्स है. मेटाडेटा में दोनों शामिल होते हैं

TensorFlow Hub पर पब्लिश किए गए सभी इमेज मॉडल में मेटाडेटा शामिल हो गया है.

मेटाडेटा फ़ॉर्मैट वाला मॉडल

model_with_metadata
पहली इमेज. मेटाडेटा और उससे जुड़ी फ़ाइलों के साथ TFLite मॉडल.

मॉडल मेटाडेटा की जानकारी metadata_schema.fbs, FlatBuffer फ़ाइल में दी गई है. जैसा कि इमेज 1 में दिखाया गया है, इसे TFLite मॉडल स्कीमा के मेटाडेटा फ़ील्ड में, "TFLITE_METADATA" नाम के नीचे स्टोर किया गया है. कुछ मॉडल में, संबंधित फ़ाइलें हो सकती हैं, जैसे कि क्लासिफ़िकेशन लेबल फ़ाइलें. इन फ़ाइलों को ZipFile "append" mode ('a' मोड) का इस्तेमाल करके, ZIP के रूप में ओरिजनल मॉडल फ़ाइल के आखिर में इकट्ठा किया जाता है. TFLite अनुवादक, नए फ़ाइल फ़ॉर्मैट का इस्तेमाल पहले की तरह ही कर सकता है. ज़्यादा जानकारी के लिए, इनसे जुड़ी फ़ाइलें पैक करें देखें.

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

मेटाडेटा टूल सेटअप करना

अपने मॉडल में मेटाडेटा जोड़ने से पहले, आपको TensorFlow चलाने के लिए, Python प्रोग्रामिंग एनवायरमेंट सेटअप करना होगा. इसे सेट अप करने के तरीके के बारे में ज़्यादा जानकारी देने वाली गाइड यहां दी गई है.

Python प्रोग्रामिंग एनवायरमेंट को सेटअप करने के बाद, आपको अन्य टूल इंस्टॉल करने होंगे:

pip install tflite-support

TensorFlow Lite की मेटाडेटा टूलिंग, Python 3 के साथ काम करती है.

फ़्लैटबफ़र Python API का इस्तेमाल करके मेटाडेटा जोड़ना

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

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

फ़िलहाल, TensorFlow Lite सिर्फ़ एक सबग्राफ़ के साथ काम करता है. इसलिए, TensorFlow Lite कोड जनरेटर और Android Studio ML बाइंडिंग सुविधा में मेटाडेटा और कोड जनरेट करते समय, SubGraphMetadata.name और SubGraphMetadata.description के बजाय, ModelMetadata.name और ModelMetadata.description का इस्तेमाल किया जाएगा.

इस्तेमाल किए जा सकने वाले इनपुट / आउटपुट टाइप

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

  • सुविधा - संख्याएं जो बिना हस्ताक्षर वाले पूर्णांक या फ्लोट32 हैं.
  • इमेज - मेटाडेटा फ़िलहाल, आरजीबी और ग्रेस्केल इमेज के साथ काम करता है.
  • बाउंडिंग बॉक्स - आयताकार बाउंडिंग बॉक्स. स्कीमा में कई तरह की नंबरिंग स्कीम काम करती हैं.

इससे जुड़ी फ़ाइलों को पैक करें

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

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

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

नॉर्मलाइज़ेशन और क्वांटाइज़ेशन पैरामीटर

मशीन लर्निंग में डेटा को पहले से प्रोसेस करने की तकनीक को नॉर्मलाइज़ेशन के तौर पर इस्तेमाल किया जाता है. सामान्यीकरण का लक्ष्य, वैल्यू की रेंज में अंतर को हटाए बिना, वैल्यू को सामान्य स्केल में बदलना है.

मॉडल क्वांटाइज़ेशन ऐसी तकनीक है जिससे वज़न को कम सटीक रूप से दिखाया जा सकता है. इसके अलावा, स्टोरेज और कंप्यूटेशन, दोनों को ऐक्टिवेट किया जा सकता है. हालांकि, ऐसा करना ज़रूरी नहीं है.

प्री-प्रोसेसिंग और पोस्ट-प्रोसेसिंग के मामले में, नॉर्मलाइज़ेशन और क्वांटाइज़ेशन, दो अलग-अलग चरण हैं. यह रही पूरी जानकारी.

नॉर्मलाइज़ेशन क्वांटाइज़ेशन

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




कब शुरू करें?

इनपुट: अगर ट्रेनिंग के दौरान इनपुट डेटा को नॉर्मलाइज़ किया जाता है तो अनुमान के इनपुट डेटा को सामान्य तरीके से सामान्य बनाया जाना चाहिए.
आउटपुट: आउटपुट डेटा को सामान्य तौर पर सामान्य नहीं किया जाएगा. 		फ़्लोट मॉडल के लिए क्वांटाइज़ेशन की ज़रूरत नहीं होती.
संख्या के मुताबिक बनाए गए मॉडल को प्री/पोस्ट प्रोसेसिंग में क्वांटाइज़ेशन की ज़रूरत पड़ सकती है या नहीं हो सकता है कि इसकी ज़रूरत न पड़े. यह इनपुट/आउटपुट टेंसर के डेटा टाइप पर निर्भर करता है.
- फ़्लोट टेंसर: प्री/पोस्ट प्रोसेसिंग में क्वांटाइज़ेशन की ज़रूरत नहीं होती. क्वांट ऑप और डिक्वांट ऑप को मॉडल ग्राफ़ में रखा जाता है.
- int8/uint8 tens: प्री/पोस्ट प्रोसेसिंग में क्वांटाइज़ेशन की ज़रूरत होती है.


फ़ॉर्मूला

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

पैरामीटर कहां हैं 		इसे मॉडल क्रिएटर ने भरा और मॉडल मेटाडेटा में NormalizationOptions के तौर पर सेव किया गया है TFLite कन्वर्टर में अपने-आप भर जाता है और tflite मॉडल फ़ाइल में सेव होता है.
पैरामीटर कैसे पाएं? MetadataExtractor एपीआई का इस्तेमाल करके [2] TFLite से Tensor एपीआई [1] या MetadataExtractor एपीआई के ज़रिए [2]
क्या फ़्लोट और क्वांट मॉडल की वैल्यू एक जैसी होती है? हां, फ़्लोट और मात्रा मॉडल में नॉर्मलाइज़ेशन पैरामीटर एक जैसे होते हैं नहीं, फ़्लोट मॉडल के लिए क्वांटाइज़ेशन की ज़रूरत नहीं होती.
क्या TFLite कोड जनरेटर या Android Studio एमएल बाइंडिंग, यह डेटा प्रोसेसिंग में अपने-आप जनरेट करता है?
हां
हां

[1] TensorFlow Lite Java एपीआई और TensorFlow Lite C++ एपीआई.
[2] मेटाडेटा एक्सट्रैक्टर लाइब्रेरी

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()

मेटाडेटा और उससे जुड़ी फ़ाइलों को मॉडल में पैक करना

मेटाडेटा फ़्लैटबफ़र बनाने के बाद, मेटाडेटा और लेबल फ़ाइल को populate तरीके से TFLite फ़ाइल में लिखा जाता है:

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 की मदद से, मॉडल में जितनी चाहें उतनी फ़ाइलें पैक करें. हालांकि, आपको मेटाडेटा में दस्तावेज़ वाली कम से कम फ़ाइलों को पैक करना होगा. इस उदाहरण में, लेबल फ़ाइल को पैक करना ज़रूरी है.

मेटाडेटा को विज़ुअलाइज़ करना

अपने मेटाडेटा को विज़ुअलाइज़ करने के लिए, Netron का इस्तेमाल किया जा सकता है. इसके अलावा, TensorFlow Lite के मॉडल से मिले मेटाडेटा को MetadataDisplayer का इस्तेमाल करके json फ़ॉर्मैट में पढ़ा जा सकता है:

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 एमएल बाइंडिंग की सुविधा के ज़रिए मेटाडेटा भी दिखाया जा सकता है.

मेटाडेटा का वर्शन बनाना

मेटाडेटा स्कीमा को सिमैंटिक वर्शन नंबर, दोनों के आधार पर वर्शन बनाया जाता है. यह वर्शन स्कीमा फ़ाइल में होने वाले बदलावों को ट्रैक करता है. साथ ही, फ़्लैटबफ़र फ़ाइल आइडेंटिफ़ायर से पता चलता है कि वर्शन सही है या नहीं.

सिमैंटिक वर्शन नंबर

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

ftbuffers फ़ाइल की पहचान

सिमैंटिक वर्शनिंग, नियमों का पालन करने पर गारंटी देता है कि यह सही नहीं है. MAJOR संख्या को ऊपर घुमाने पर, इसका यह मतलब नहीं है कि पुराने सिस्टम के साथ काम करने की सुविधा काम नहीं कर रही है. इसलिए, मेटाडेटा स्कीमा के साथ सही तरीके से काम करने के लिए, हम फ़्लैटबफ़र फ़ाइल आइडेंटिफ़िकेशन, file_identifier का इस्तेमाल करते हैं. फ़ाइल आइडेंटिफ़ायर में करीब चार वर्ण होते हैं. यह कुछ मेटाडेटा स्कीमा के लिए तय होता है और उपयोगकर्ता इसमें बदलाव नहीं कर सकते. अगर किसी वजह से मेटाडेटा स्कीमा के पुराने वर्शन के साथ काम करने की सुविधा में गड़बड़ी आती है, तो file_identifier में गड़बड़ी हो सकती है, जैसे कि “M001” से “M002”. File_identifier में, मेटाडेटा के वर्शन की तुलना में कम बार बदलाव होना चाहिए.

कम से कम ज़रूरी मेटाडेटा पार्सर वर्शन

ज़रूरी मेटाडेटा पार्सर वर्शन, मेटाडेटा पार्सर (फ़्लैटबफ़र जनरेट किया गया कोड) का सबसे कम वर्शन होता है. इससे पूरे मेटाडेटा फ़्लैटबफ़र को पढ़ा जा सकता है. यह वर्शन, पॉप्युलेट किए गए सभी फ़ील्ड में से सबसे बड़े वर्शन का नंबर होता है. साथ ही, फ़ाइल आइडेंटिफ़ायर से दिखाया गया सबसे छोटा वर्शन, इस वर्शन के साथ काम करता है. जब मेटाडेटा TFLite मॉडल में अपने-आप भर जाता है, तो मेटाडेटा पार्सर के सबसे ज़रूरी वर्शन की जानकारी, MetadataPopulator से अपने-आप भर जाती है. कम से कम ज़रूरी मेटाडेटा पार्सर वर्शन का इस्तेमाल कैसे किया जाता है, इस बारे में ज़्यादा जानकारी के लिए, मेटाडेटा एक्सट्रैक्टर देखें.

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

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

Java में मेटाडेटा पढ़ें

हमारा सुझाव है कि अपने Android ऐप्लिकेशन में मेटाडेटा एक्सट्रैक्टर लाइब्रेरी का इस्तेमाल करने के लिए, MavenCentral पर होस्ट किए गए TensorFlow Lite Metadata AAR का इस्तेमाल करें. इसमें MetadataExtractor क्लास के साथ-साथ, मेटाडेटा स्कीमा और मॉडल स्कीमा के लिए, ftBuffers Java बाइंडिंग शामिल हैं.

इसे अपनी build.gradle डिपेंडेंसी में इस तरह बताया जा सकता है:

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

हर रात के स्नैपशॉट इस्तेमाल करने के लिए, पक्का करें कि आपने Sonatype स्नैपशॉट रिपॉज़िटरी जोड़ा है.

MetadataExtractor ऑब्जेक्ट को ByteBuffer से शुरू किया जा सकता है, जो मॉडल पर ले जाता है:

public MetadataExtractor(ByteBuffer buffer);

MetadataExtractor ऑब्जेक्ट के पूरे जीवनकाल के लिए ByteBuffer में कोई बदलाव नहीं होना चाहिए. अगर मॉडल मेटाडेटा का फ़्लैटबफ़र फ़ाइल आइडेंटिफ़ायर, मेटाडेटा पार्सर से मेल नहीं खाता है, तो हो सकता है कि प्रोसेस शुरू न हो पाए. ज़्यादा जानकारी के लिए, मेटाडेटा का वर्शन देखें.

मेल खाने वाले फ़ाइल आइडेंटिफ़ायर के साथ, मेटाडेटा इकट्ठा करने वाला टूल, सभी पुराने और आने वाले समय के स्कीमा से जनरेट किए गए मेटाडेटा को पढ़ पाएगा. ऐसा फ़्लैटबफ़र के फ़ॉरवर्ड और पुराने सिस्टम के साथ काम करने के तरीके की वजह से होता है. हालांकि, मेटाडेटा इकट्ठा करने वाले पुराने टूल की मदद से, आने वाले समय के स्कीमा के फ़ील्ड नहीं निकाले जा सकते. मेटाडेटा के ज़रूरी पार्सर वर्शन से, मेटाडेटा पार्सर के कम से कम वर्शन के बारे में पता चलता है जो मेटाडेटा के फ़्लैटबफ़र को पूरा पढ़ सकता है. नीचे दिए गए तरीके का इस्तेमाल करके, यह पुष्टि की जा सकती है कि पार्सर वर्शन की ज़रूरी शर्त पूरी हुई है या नहीं:

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);

हालांकि, TensorFlow Lite मॉडल स्कीमा एक से ज़्यादा सबग्राफ़ के साथ काम करता है, लेकिन TFLite स्किपर, फ़िलहाल सिर्फ़ एक सबग्राफ़ के साथ काम करता है. इसलिए, MetadataExtractor अपने तरीकों में सबग्राफ़ इंडेक्स को इनपुट तर्क के तौर पर शामिल नहीं करता.

मॉडल से जुड़ी हुई फ़ाइलें पढ़ें

मेटाडेटा और उससे जुड़ी फ़ाइलों वाला TensorFlow Lite मॉडल, खास तौर पर एक ZIP फ़ाइल होती है. इसे आम तौर पर इस्तेमाल किए जाने वाले ज़िप टूल से अनपैक किया जा सकता है, ताकि उससे जुड़ी फ़ाइलें देखी जा सकें. उदाहरण के लिए, mobilenet_v1_0.75_160_quantized को अनज़िप किया जा सकता है और मॉडल में लेबल फ़ाइल को इस तरह एक्सट्रैक्ट किया जा सकता है:

$ unzip mobilenet_v1_0.75_160_quantized_1_metadata_1.tflite
Archive:  mobilenet_v1_0.75_160_quantized_1_metadata_1.tflite
 extracting: labels.txt

मेटाडेटा एक्सट्रैक्टर लाइब्रेरी के ज़रिए भी संबंधित फ़ाइलें पढ़ी जा सकती हैं.

Java में, फ़ाइल का नाम MetadataExtractor.getAssociatedFile तरीके में पास करें:

public InputStream getAssociatedFile(String fileName);

इसी तरह, C++ में इस तरीके से ऐसा किया जा सकता है, ModelMetadataExtractor::GetAssociatedFile:

tflite::support::StatusOr<absl::string_view> GetAssociatedFile(
      const std::string& filename) const;