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

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

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

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

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

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

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

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

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

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

pip install tflite-support

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

[1] LiteRT Java एपीआई और LiteRT 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()

इमेज इनपुट

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

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 का इस्तेमाल करके, अपने या आपके पास LiteRT मॉडल से मेटाडेटा को JSON फ़ॉर्मैट में पढ़ने का विकल्प है 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)

Android Studio, Android Studio ML के ज़रिए मेटाडेटा दिखाने की सुविधा भी देता है बाइंडिंग सुविधा के बारे में ज़्यादा जानें.

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

मेटाडेटा स्कीमा को सिमैंटिक वर्शनिंग नंबर से वर्शन किया जाता है, जो से बदल दी जाती है. यह जानकारी, सही वर्शन के साथ काम करता है या नहीं.

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

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

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

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

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

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

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

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

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

Android ऐप्लिकेशन में मेटाडेटा एक्सट्रैक्टर लाइब्रेरी का इस्तेमाल करने के लिए, हमारा सुझाव है कि LiteRT मेटाडेटा एएआर को यहां होस्ट किया गया MavenCentral. इसमें MetadataExtractor क्लास के साथ-साथ, FlatBuffers Java शामिल है मेटाडेटा के लिए बाइंडिंग स्कीमा और मॉडल स्कीमा चुनें.

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

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

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

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

public MetadataExtractor(ByteBuffer buffer);

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

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

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

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

मॉडल से संबद्ध फ़ाइलें पढ़ें

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