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

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

  • ऐसे हिस्से जिन्हें कोई भी व्यक्ति आसानी से पढ़ सकता है. ये ऐसे हिस्से होते हैं जो मॉडल इस्तेमाल करते समय सबसे सही तरीके के बारे में बताते हैं और
  • कोड जनरेटर की मदद से, मशीन में पढ़े जा सकने वाले पुर्ज़ों का इस्तेमाल किया जा सकता है. जैसे, TensorFlow Lite Android कोड जनरेटर और Android Studio ML बाइंडिंग की सुविधा.

Kaggle मॉडल पर पब्लिश किए गए सभी इमेज मॉडल, मेटाडेटा से अपने-आप भर जाते हैं.

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

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

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

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

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

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

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

pip install tflite-support

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

फ़्लैटबफ़र Python एपीआई का इस्तेमाल करके मेटाडेटा जोड़ना

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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




कब शुरू करें?

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


फ़ॉर्मूला

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

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

[1] TensorFlow Lite Java API और TensorFlow Lite C++ API.
[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 का इस्तेमाल किया जा सकता है या MetadataDisplayer का इस्तेमाल करके, TensorFlow Lite मॉडल के मेटाडेटा को 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 ML बाइंडिंग सुविधा की मदद से भी मेटाडेटा दिखाया जा सकता है.

मेटाडेटा का वर्शन तय करना

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

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

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

फ़्लैटबफ़र फ़ाइल की पहचान

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

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

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

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

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

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

हमारा सुझाव है कि Android ऐप्लिकेशन में Metadata Extractor लाइब्रेरी का इस्तेमाल करें. इसके लिए, आपको MavenCentral पर होस्ट किया गया TensorFlow Lite Metadata AAR इस्तेमाल करना चाहिए. इसमें MetadataExtractor क्लास के साथ-साथ, मेटाडेटा स्कीमा और मॉडल स्कीमा के लिए FlatBuffers 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 Authenticer सिर्फ़ एक सबग्राफ़ के साथ काम करता है. इसलिए, 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;