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

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

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

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

मेटाडेटा प्रारूप के साथ मॉडल

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

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

मेटाडेटा टूल सेट करें

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

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

pip install tflite-support

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

Flatbuffers Python API का उपयोग करके मेटाडेटा जोड़ना

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

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 ), TensorFlow Lite Android कोड जनरेटर स्वचालित रूप से ऑब्जेक्ट पर संबंधित प्री/पोस्ट प्रोसेसिंग लागू कर सकता है। अधिक विवरण के लिए स्कीमा में प्रत्येक सहयोगी फ़ाइल प्रकार का <Codegen उपयोग> अनुभाग देखें।

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

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

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

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

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

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

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

उदाहरण

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

छवि वर्गीकरण

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

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

आप अपने मेटाडेटा की कल्पना करने के लिए नेट्रोन का उपयोग कर सकते हैं, या आप मेटाडेटा डिस्प्लेर का उपयोग करके एक TensorFlow लाइट मॉडल से 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)

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

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

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

सिमेंटिक वर्जनिंग नंबर

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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