ข้อมูลเมตาของ TensorFlow Lite เป็นมาตรฐานสำหรับคำอธิบายโมเดล ข้อมูลเมตาเป็นแหล่งความรู้ที่สำคัญเกี่ยวกับสิ่งที่โมเดลทำและข้อมูลอินพุต/เอาต์พุต ข้อมูลเมตาประกอบด้วยทั้ง
- ชิ้นส่วนที่มนุษย์อ่านได้ซึ่งถ่ายทอดแนวปฏิบัติที่ดีที่สุดเมื่อใช้แบบจำลอง และ
- ชิ้นส่วนที่เครื่องอ่านได้ซึ่งสามารถใช้ประโยชน์จากโปรแกรมสร้างโค้ดได้ เช่น เครื่องสร้างโค้ด Android TensorFlow Lite และคุณลักษณะ Android Studio ML Binding
โมเดลรูปภาพทั้งหมดที่เผยแพร่บน TensorFlow Hub ได้รับการเติมด้วยข้อมูลเมตา
โมเดลที่มีรูปแบบข้อมูลเมตา

ข้อมูลเมตาของโมเดลถูกกำหนดใน metadata_schema.fbs ซึ่งเป็นไฟล์ FlatBuffer ดังแสดงในรูปที่ 1 มันถูกเก็บไว้ในฟิลด์ข้อมูล เมตา ของ สคีมาโมเดล TFLite ภายใต้ชื่อ "TFLITE_METADATA"
บางรุ่นอาจมาพร้อมกับไฟล์ที่เกี่ยวข้อง เช่น ไฟล์ป้ายกำกับการจัดหมวดหมู่ ไฟล์เหล่านี้ต่อท้ายไฟล์โมเดลดั้งเดิมเป็น ZIP โดยใช้ โหมด "ผนวก" ของ ZipFile (โหมด 'a'
) TFLite Interpreter สามารถใช้รูปแบบไฟล์ใหม่ได้เหมือนเดิม ดูข้อมูลเพิ่มเติม ที่แพ็คไฟล์ที่เกี่ยวข้อง
ดูคำแนะนำด้านล่างเกี่ยวกับวิธีการเติม สร้างภาพ และอ่านข้อมูลเมตา
ตั้งค่าเครื่องมือข้อมูลเมตา
ก่อนเพิ่มข้อมูลเมตาให้กับโมเดลของคุณ คุณจะต้องตั้งค่าสภาพแวดล้อมการเขียนโปรแกรม Python สำหรับการรัน TensorFlow มีคำแนะนำโดยละเอียดเกี่ยวกับวิธีการตั้งค่านี้ ที่นี่
หลังจากตั้งค่าสภาพแวดล้อมการเขียนโปรแกรม Python คุณจะต้องติดตั้งเครื่องมือเพิ่มเติม:
pip install tflite-support
เครื่องมือข้อมูลเมตาของ TensorFlow Lite รองรับ Python 3
การเพิ่มข้อมูลเมตาโดยใช้ Flatbuffers Python API
มีสามส่วนในข้อมูลเมตาของโมเดลใน สคีมา :
- ข้อมูลโมเดล - คำอธิบายโดยรวมของโมเดลรวมถึงรายการต่างๆ เช่น เงื่อนไขสิทธิ์การใช้งาน ดู ModelMetadata
- ข้อมูลอินพุต - คำอธิบายของอินพุตและการประมวลผลล่วงหน้าที่จำเป็น เช่น การทำให้เป็นมาตรฐาน ดู SubGraphMetadata.input_tensor_metadata
- ข้อมูลเอาต์พุต - คำอธิบายของเอาต์พุตและขั้นตอนหลังการประมวลผลที่จำเป็น เช่น การแมปกับป้ายกำกับ ดู SubGraphMetadata.output_tensor_metadata
เนื่องจาก TensorFlow Lite รองรับกราฟย่อยเดียวเท่านั้น ณ จุดนี้ ตัว สร้างโค้ด TensorFlow Lite และคุณลักษณะ Android Studio ML Binding จะใช้ ModelMetadata.name
และ ModelMetadata.description
แทน SubGraphMetadata.name
และ SubGraphMetadata.description
เมื่อแสดงข้อมูลเมตาและสร้างโค้ด
รองรับประเภทอินพุต / เอาท์พุต
ข้อมูลเมตาของ TensorFlow Lite สำหรับอินพุตและเอาต์พุตไม่ได้ออกแบบโดยคำนึงถึงประเภทโมเดลเฉพาะ แต่ควรคำนึงถึงประเภทอินพุตและเอาต์พุต ไม่สำคัญว่าโมเดลจะทำงานอะไร ตราบใดที่ประเภทอินพุตและเอาต์พุตประกอบด้วยสิ่งต่อไปนี้หรือหลายสิ่งต่อไปนี้ ข้อมูลเมตาของ TensorFlow Lite รองรับ:
- คุณลักษณะ - ตัวเลขที่เป็นจำนวนเต็มที่ไม่ได้ลงนามหรือ float32
- รูปภาพ - ปัจจุบันข้อมูลเมตารองรับรูปภาพ RGB และระดับสีเทา
- Bounding box - กล่องขอบรูปสี่เหลี่ยมผืนผ้า สคีมารองรับ รูปแบบการกำหนดหมายเลขที่หลากหลาย
แพ็คไฟล์ที่เกี่ยวข้อง
รุ่น TensorFlow Lite อาจมาพร้อมกับไฟล์ที่เกี่ยวข้องต่างกัน ตัวอย่างเช่น โมเดลภาษาธรรมชาติมักจะมีไฟล์คำศัพท์ที่จับคู่ชิ้นส่วนของคำกับรหัสของคำ โมเดลการจัดประเภทอาจมีไฟล์ป้ายกำกับที่ระบุหมวดหมู่ของอ็อบเจ็กต์ หากไม่มีไฟล์ที่เกี่ยวข้อง (ถ้ามี) โมเดลจะทำงานได้ไม่ดี
ไฟล์ที่เกี่ยวข้องสามารถรวมเข้ากับโมเดลผ่านไลบรารี Python ของข้อมูลเมตาได้แล้ว โมเดล TensorFlow Lite ใหม่จะกลายเป็นไฟล์ zip ที่มีทั้งโมเดลและไฟล์ที่เกี่ยวข้อง สามารถแตกไฟล์ด้วยเครื่องมือ zip ทั่วไปได้ รูปแบบรุ่นใหม่นี้ยังคงใช้นามสกุลไฟล์เดิม . .tflite
มันเข้ากันได้กับเฟรมเวิร์ก TFLite และล่ามที่มีอยู่ ดู แพ็คข้อมูลเมตาและไฟล์ที่เกี่ยวข้องลงในโมเดล สำหรับรายละเอียดเพิ่มเติม
ข้อมูลไฟล์ที่เกี่ยวข้องสามารถบันทึกในข้อมูลเมตา ขึ้นอยู่กับประเภทไฟล์และตำแหน่งที่ไฟล์แนบมาด้วย (เช่น ModelMetadata
, SubGraphMetadata
และ TensorMetadata
) ตัวสร้างโค้ด TensorFlow Lite Android อาจใช้การประมวลผลก่อน/หลังที่เกี่ยวข้องโดยอัตโนมัติกับวัตถุ ดู ส่วน <การใช้ Codegen> ของไฟล์เชื่อมโยงแต่ละประเภท ในสคีมาสำหรับรายละเอียดเพิ่มเติม
พารามิเตอร์ Normalization และ quantization
Normalization เป็นเทคนิคทั่วไปในการประมวลผลข้อมูลล่วงหน้าในการเรียนรู้ของเครื่อง เป้าหมายของการทำให้เป็นมาตรฐานคือการเปลี่ยนค่าเป็นมาตราส่วนร่วม โดยไม่บิดเบือนความแตกต่างในช่วงของค่า
การ หาปริมาณแบบจำลอง เป็นเทคนิคที่ช่วยให้การแสดงน้ำหนักที่แม่นยำลดลง และสามารถเลือกเปิดใช้งานได้ทั้งการจัดเก็บและการคำนวณ
ในแง่ของการประมวลผลล่วงหน้าและหลังการประมวลผล การทำให้เป็นมาตรฐานและการหาปริมาณเป็นสองขั้นตอนที่เป็นอิสระ นี่คือรายละเอียด
การทำให้เป็นมาตรฐาน | การหาปริมาณ | |
---|---|---|
ตัวอย่างค่าพารามิเตอร์ของอิมเมจอินพุตใน MobileNet สำหรับโมเดล float และ quant ตามลำดับ | รุ่นลูกลอย : - ค่าเฉลี่ย: 127.5 - มาตรฐาน: 127.5 รุ่นควอน : - ค่าเฉลี่ย: 127.5 - มาตรฐาน: 127.5 | รุ่นลูกลอย : - zeroPoint: 0 - ขนาด: 1.0 รุ่นควอน : - จุดศูนย์: 128.0 - ขนาด:0.0078125f |
เรียกใช้เมื่อใด | อินพุต : หากข้อมูลอินพุตถูกทำให้เป็นมาตรฐานในการฝึก ข้อมูลอินพุตของการอนุมานจะต้องทำให้เป็นมาตรฐานตามนั้น เอาต์พุต : ข้อมูลเอาต์พุตจะไม่ถูกทำให้เป็นมาตรฐานโดยทั่วไป | แบบจำลองโฟล ตไม่ต้องการการหาปริมาณ แบบจำลองเชิงปริมาณ อาจหรือไม่จำเป็นต้องมีการวัดปริมาณในการประมวลผลก่อน/หลัง ขึ้นอยู่กับประเภทข้อมูลของเทนเซอร์อินพุต/เอาต์พุต - เทนเซอร์แบบลอย: ไม่จำเป็นต้องมีการวัดปริมาณในการประมวลผลก่อน/หลัง Quant op และ dequant op ถูกรวมเข้ากับกราฟแบบจำลอง - เทนเซอร์ int8 / uint8: ต้องการการหาปริมาณในการประมวลผลก่อน/หลัง |
สูตร | normalized_input = (อินพุต - ค่าเฉลี่ย) / std | ปริมาณสำหรับอินพุต : q = f / มาตราส่วน + ศูนย์จุด Dequantize สำหรับเอาท์พุต : f = (q - zeroPoint) * มาตราส่วน |
พารามิเตอร์อยู่ที่ไหน | เติมโดยผู้สร้างโมเดลและจัดเก็บไว้ในข้อมูลเมตาของโมเดล เช่น NormalizationOptions | เติมโดยอัตโนมัติโดยตัวแปลง TFLite และเก็บไว้ในไฟล์รุ่น tflite |
จะรับพารามิเตอร์ได้อย่างไร? | ผ่าน MetadataExtractor API [2] | ผ่าน TFLite Tensor API [1] หรือผ่าน MetadataExtractor API [2] |
โมเดล float และ quant มีค่าเท่ากันหรือไม่? | ใช่ โมเดล float และ quant มีพารามิเตอร์ Normalization เหมือนกัน | ไม่ แบบจำลองโฟลตไม่ต้องการการหาปริมาณ |
ตัวสร้างรหัส TFLite หรือการเชื่อมโยง Android Studio ML สร้างขึ้นโดยอัตโนมัติในการประมวลผลข้อมูลหรือไม่ | ใช่ | ใช่ |
[1] TensorFlow Lite Java API และ TensorFlow Lite C++ API
[2] ไลบรารีตัวแยกข้อมูลเมตา
เมื่อประมวลผลข้อมูลรูปภาพสำหรับรุ่น uint8 บางครั้งการนอร์มัลไลซ์เซชันและควอนไทเซชันจะถูกข้ามไป ทำได้เมื่อค่าพิกเซลอยู่ในช่วง [0, 255] แต่โดยทั่วไป คุณควรประมวลผลข้อมูลตามพารามิเตอร์นอร์มัลไลซ์เซชันและควอนไทเซชันเสมอ เมื่อทำได้
ไลบรารีงาน TensorFlow Lite สามารถจัดการการทำให้เป็นมาตรฐานสำหรับคุณ หากคุณตั้งค่า NormalizationOptions
ในข้อมูลเมตา การประมวลผลเชิงปริมาณและการลดปริมาณจะถูกห่อหุ้มไว้เสมอ
ตัวอย่าง
คุณสามารถค้นหาตัวอย่างเกี่ยวกับวิธีการเติมข้อมูลเมตาสำหรับแบบจำลองประเภทต่างๆ ได้ที่นี่:
การจำแนกรูปภาพ
ดาวน์โหลดสคริปต์ ที่นี่ ซึ่งจะเติมข้อมูลเมตาไปที่ 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]
สร้างข้อมูลเมตา Flatbuffers
รหัสต่อไปนี้รวมข้อมูลโมเดลกับข้อมูลอินพุตและเอาต์พุต:
# 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()
แพ็คข้อมูลเมตาและไฟล์ที่เกี่ยวข้องลงในโมเดล
เมื่อสร้างข้อมูลเมตา Flatbuffers แล้ว ข้อมูลเมตาและไฟล์ป้ายกำกับจะถูกเขียนลงในไฟล์ TFLite โดยใช้วิธีการ populate
ข้อมูล:
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 เป็นรูปแบบ 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 Binding
การกำหนดเวอร์ชันข้อมูลเมตา
สคีมาข้อมูลเมตา มีการกำหนดเวอร์ชันทั้งโดยหมายเลขเวอร์ชัน Semantic ซึ่งติดตามการเปลี่ยนแปลงของไฟล์สคีมา และโดยการระบุไฟล์ Flatbuffers ซึ่งระบุถึงความเข้ากันได้ของเวอร์ชันที่แท้จริง
หมายเลขเวอร์ชันความหมาย
สคีมาข้อมูลเมตากำหนดเวอร์ชันโดย หมายเลขเวอร์ชันความหมาย เช่น MAJOR.MINOR.PATCH ติดตามการเปลี่ยนแปลงสคีมาตามกฎ ที่นี่ ดู ประวัติของช่อง ที่เพิ่มหลังจากเวอร์ชัน 1.0.0
การระบุไฟล์ Flatbuffers
การกำหนดเวอร์ชันเชิงความหมายรับประกันความเข้ากันได้หากปฏิบัติตามกฎ แต่ไม่ได้หมายความถึงความไม่ลงรอยกันที่แท้จริง เมื่อเพิ่มจำนวน MAJOR ขึ้น ก็ไม่ได้หมายความว่าความเข้ากันได้แบบย้อนหลังจะเสียหายเสมอไป ดังนั้นเราจึงใช้การ ระบุไฟล์ Flatbuffers file_identifier เพื่อแสดงถึงความเข้ากันได้ที่แท้จริงของสคีมาข้อมูลเมตา ตัวระบุไฟล์มีความยาว 4 อักขระพอดี ได้รับการแก้ไขในสคีมาข้อมูลเมตาบางอย่างและผู้ใช้ไม่สามารถเปลี่ยนแปลงได้ หากต้องใช้งานร่วมกันได้แบบย้อนหลังของสคีมาข้อมูลเมตาด้วยเหตุผลบางประการ file_identifier จะเพิ่มขึ้น ตัวอย่างเช่น จาก “M001” เป็น “M002” File_identifier คาดว่าจะมีการเปลี่ยนแปลงน้อยกว่า metadata_version มาก
เวอร์ชันตัวแยกวิเคราะห์ข้อมูลเมตาขั้นต่ำที่จำเป็น
เวอร์ชันตัวแยกวิเคราะห์ข้อมูลเมตาขั้นต่ำที่จำเป็นคือเวอร์ชัน ต่ำสุดของตัวแยกวิเคราะห์ข้อมูลเมตา (โค้ดที่สร้าง Flatbuffers) ที่สามารถอ่านข้อมูลเมตา Flatbuffers ได้ทั้งหมด เวอร์ชันนี้เป็นหมายเลขเวอร์ชันที่ใหญ่ที่สุดอย่างมีประสิทธิภาพในบรรดาเวอร์ชันของฟิลด์ทั้งหมดที่มีข้อมูล และเวอร์ชันที่เข้ากันได้ที่เล็กที่สุดซึ่งระบุโดยตัวระบุไฟล์ เวอร์ชันตัวแยกวิเคราะห์ข้อมูลเมตาขั้นต่ำที่จำเป็นจะถูกเติมโดยอัตโนมัติโดย MetadataPopulator
เมื่อเติมข้อมูลเมตาลงในโมเดล TFLite ดูตัว แยกข้อมูลเมตา สำหรับข้อมูลเพิ่มเติมเกี่ยวกับวิธีการใช้เวอร์ชันตัวแยกวิเคราะห์ข้อมูลเมตาขั้นต่ำที่จำเป็น
อ่านข้อมูลเมตาจากโมเดล
ไลบรารี Metadata Extractor เป็นเครื่องมือที่สะดวกในการอ่านข้อมูลเมตาและไฟล์ที่เกี่ยวข้องจากโมเดลในแพลตฟอร์มต่างๆ (ดู เวอร์ชัน Java และเวอร์ชัน C++ ) คุณสามารถสร้างเครื่องมือแยกข้อมูลเมตาของคุณเองในภาษาอื่นๆ โดยใช้ไลบรารี Flatbuffers
อ่านข้อมูลเมตาใน Java
ในการใช้ไลบรารี Metadata Extractor ในแอป Android เราขอแนะนำให้ใช้ TensorFlow Lite Metadata AAR ที่โฮสต์ที่ MavenCentral มันมีคลาส MetadataExtractor
เช่นเดียวกับการเชื่อมโยง FlatBuffers Java สำหรับ สคีมาข้อมูลเมตา และส คีมาโมเดล
คุณสามารถระบุสิ่งนี้ในการพึ่งพา build.gradle
ของคุณดังนี้:
dependencies {
implementation 'org.tensorflow:tensorflow-lite-metadata:0.1.0'
}
หากต้องการใช้สแน็ปช็อตตอนกลางคืน ตรวจสอบให้แน่ใจว่าคุณได้เพิ่มที่เก็บส แน็ปช็อต Sonatype
คุณสามารถเริ่มต้นวัตถุ MetadataExtractor
ด้วย ByteBuffer
ที่ชี้ไปที่โมเดล:
public MetadataExtractor(ByteBuffer buffer);
ByteBuffer
จะต้องไม่เปลี่ยนแปลงตลอดอายุของวัตถุ MetadataExtractor
การเริ่มต้นอาจล้มเหลวหากตัวระบุไฟล์ Flatbuffers ของข้อมูลเมตาของโมเดลไม่ตรงกับตัวแยกวิเคราะห์ข้อมูลเมตา ดูการ กำหนดเวอร์ชันข้อมูลเมตา สำหรับข้อมูลเพิ่มเติม
ด้วยตัวระบุไฟล์ที่ตรงกัน ตัวแยกข้อมูลเมตาจะอ่านข้อมูลเมตาที่สร้างจากสคีมาในอดีตและอนาคตได้สำเร็จ เนื่องจากกลไกความเข้ากันได้ของการส่งต่อและย้อนหลังของ Flatbuffers อย่างไรก็ตาม ตัวแยกข้อมูลเมตาที่เก่ากว่าไม่สามารถแยกฟิลด์จากสคีมาในอนาคตได้ เวอร์ชัน parser ที่จำเป็นขั้นต่ำ ของ metadata ระบุเวอร์ชันต่ำสุดของ parser parser ที่สามารถอ่าน metadata Flatbuffers ได้ทั้งหมด คุณสามารถใช้วิธีการต่อไปนี้เพื่อตรวจสอบว่าตรงตามเงื่อนไขเวอร์ชัน parser ขั้นต่ำที่จำเป็นหรือไม่:
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 Interpreter รองรับเพียงกราฟย่อยเดียวเท่านั้น ดังนั้น MetadataExtractor
ละเว้นดัชนีย่อยเป็นอาร์กิวเมนต์อินพุตในเมธอดของมัน
อ่านไฟล์ที่เกี่ยวข้องจากรุ่นต่างๆ
โมเดล TensorFlow Lite ที่มีข้อมูลเมตาและไฟล์ที่เกี่ยวข้องนั้นเป็นไฟล์ zip ที่สามารถแตกไฟล์ด้วยเครื่องมือ 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
คุณยังสามารถอ่านไฟล์ที่เกี่ยวข้องผ่านไลบรารี Metadata Extractor
ใน Java ส่งชื่อไฟล์ไปที่เมธอด MetadataExtractor.getAssociatedFile
:
public InputStream getAssociatedFile(String fileName);
ในทำนองเดียวกัน ใน C++ สามารถทำได้ด้วยวิธี ModelMetadataExtractor::GetAssociatedFile
:
tflite::support::StatusOr<absl::string_view> GetAssociatedFile(
const std::string& filename) const;