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

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

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

मेटाडेटा प्रारूप वाला मॉडल

मॉडल_विथ_मेटाडेटा
चित्र 1. मेटाडेटा और संबंधित फ़ाइलों के साथ TFLite मॉडल।

मॉडल मेटाडेटा को मेटाडेटा_schema.fbs , एक फ़्लैटबफ़र फ़ाइल में परिभाषित किया गया है। जैसा कि चित्र 1 में दिखाया गया है, इसे "TFLITE_METADATA" नाम के तहत TFLite मॉडल स्कीमा के मेटाडेटा फ़ील्ड में संग्रहीत किया जाता है। कुछ मॉडल संबद्ध फ़ाइलों के साथ आ सकते हैं, जैसे वर्गीकरण लेबल फ़ाइलें । इन फ़ाइलों को ज़िपफ़ाइल "एपेंड" मोड ( 'a' मोड) का उपयोग करके ज़िप के रूप में मूल मॉडल फ़ाइल के अंत में जोड़ा जाता है। TFLite इंटरप्रेटर पहले की तरह ही नए फ़ाइल प्रारूप का उपभोग कर सकता है। अधिक जानकारी के लिए संबंधित फ़ाइलें पैक करें देखें।

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

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

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

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

pip install tflite-support

TensorFlow Lite मेटाडेटा टूलींग Python 3 का समर्थन करता है।

फ़्लैटबफ़र्स पायथन एपीआई का उपयोग करके मेटाडेटा जोड़ना

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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




कब आह्वान करें?


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


FORMULA


सामान्यीकृत_इनपुट = (इनपुट - माध्य) / एसटीडी
इनपुट के लिए मात्रा निर्धारित करें :
क्यू = एफ / स्केल + जीरोप्वाइंट
आउटपुट के लिए परिमाणीकरण करें :
एफ = (क्यू - जीरोप्वाइंट) * स्केल

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

हाँ

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

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

यदि आप मेटाडेटा में NormalizationOptions सेट करते हैं तो TensorFlow Lite टास्क लाइब्रेरी आपके लिए सामान्यीकरण को संभाल सकती है। परिमाणीकरण और विखंडन प्रसंस्करण हमेशा संपुटित होता है।

उदाहरण

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

छवि वर्गीकरण

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

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

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

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)

एंड्रॉइड स्टूडियो एंड्रॉइड स्टूडियो एमएल बाइंडिंग सुविधा के माध्यम से मेटाडेटा प्रदर्शित करने का भी समर्थन करता है।

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

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

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

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

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

नियमों का पालन करने पर सिमेंटिक वर्जनिंग अनुकूलता की गारंटी देता है, लेकिन यह वास्तविक असंगति का संकेत नहीं देता है। प्रमुख संख्या को उछालते समय, इसका मतलब यह नहीं है कि पिछली संगतता टूट गई है। इसलिए, हम मेटाडेटा स्कीमा की वास्तविक अनुकूलता को दर्शाने के लिए फ़्लैटबफ़र्स फ़ाइल पहचान , फ़ाइल_आइडेंटिफ़ायर का उपयोग करते हैं। फ़ाइल पहचानकर्ता बिल्कुल 4 अक्षर लंबा है। यह एक निश्चित मेटाडेटा स्कीमा के लिए तय है और उपयोगकर्ताओं द्वारा परिवर्तन के अधीन नहीं है। यदि किसी कारण से मेटाडेटा स्कीमा की पश्चगामी संगतता को तोड़ना पड़ता है, तो फ़ाइल_आइडेंटिफायर बढ़ जाएगा, उदाहरण के लिए, "M001" से "M002"। फ़ाइल_पहचानकर्ता को मेटाडेटा_संस्करण की तुलना में बहुत कम बार बदले जाने की उम्मीद है।

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

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

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

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

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

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

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

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

रात्रिकालीन स्नैपशॉट का उपयोग करने के लिए, सुनिश्चित करें कि आपने सोनाटाइप स्नैपशॉट रिपॉजिटरी जोड़ा है।

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

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 मॉडल अनिवार्य रूप से एक ज़िप फ़ाइल है जिसे संबंधित फ़ाइलें प्राप्त करने के लिए सामान्य ज़िप टूल के साथ अनपैक किया जा सकता है। उदाहरण के लिए, आप 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

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

जावा में, फ़ाइल नाम को MetadataExtractor.getAssociatedFile विधि में पास करें:

public InputStream getAssociatedFile(String fileName);

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

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