ข้อมูลเมตา LiteRT ระบุมาตรฐานสำหรับคำอธิบายโมเดล ข้อมูลเมตาเป็นแหล่งสำคัญของความรู้เกี่ยวกับสิ่งที่โมเดลทำและ ข้อมูลอินพุต / เอาต์พุต ข้อมูลเมตาประกอบด้วย
- ส่วนที่มนุษย์อ่านได้ซึ่งสื่อถึงแนวทางปฏิบัติแนะนำเมื่อใช้โมเดล และ
- ส่วนที่เครื่องอ่านได้ซึ่งโปรแกรมสร้างโค้ดนำไปใช้ประโยชน์ได้ เช่น โค้ด Android LiteRT โปรแกรมสร้าง และการเชื่อมโยง ML สำหรับ Android Studio ฟีเจอร์
โมเดลรูปภาพทั้งหมดที่เผยแพร่ใน Kaggle ระบบได้ป้อนข้อมูลโมเดล ข้อมูลเมตา
โมเดลที่มีรูปแบบข้อมูลเมตา
![model_with_metadata](https://ai.google.dev/edge/litert/images/convert/model_with_metadata.png?hl=th)
ข้อมูลเมตาของโมเดลกำหนดไว้ใน
metadata_schema.fbs
CANNOT TRANSLATE
FlatBuffer
ดังที่แสดงในรูปที่ 1 ข้อมูลนี้ถูกจัดเก็บไว้ใน
ข้อมูลเมตา
ของโมเดล TFLite
สคีมา
ภายใต้ชื่อ "TFLITE_METADATA"
บางรุ่นอาจมาพร้อมกับไฟล์ที่เกี่ยวข้อง
เช่น ป้ายกำกับการแยกประเภท
ไฟล์
ไฟล์เหล่านี้ต่อกันที่ส่วนท้ายของไฟล์โมเดลต้นฉบับเป็นไฟล์ ZIP
โดยใช้ ZipFile "ต่อท้าย"
โหมด (โหมด 'a'
) TFLite
ล่ามจะใช้รูปแบบไฟล์ใหม่ได้เหมือนเดิม ดูแพ็ก
ไฟล์ที่เกี่ยวข้องสำหรับข้อมูลเพิ่มเติม
ดูวิธีการด้านล่างเกี่ยวกับวิธีป้อนข้อมูล แสดงข้อมูลผ่านภาพ และอ่านข้อมูลเมตา
ตั้งค่าเครื่องมือข้อมูลเมตา
คุณจะต้องเขียนโปรแกรม Python ก่อนที่จะเพิ่มข้อมูลเมตาลงในโมเดลของคุณ การตั้งค่าสภาพแวดล้อมสำหรับการเรียกใช้ TensorFlow เรามีคำแนะนำโดยละเอียดเกี่ยวกับวิธี ให้ตั้งค่าที่นี่
หลังจากตั้งค่าสภาพแวดล้อมในการเขียนโปรแกรม Python แล้ว คุณจะต้องติดตั้ง เครื่องมือเพิ่มเติม:
pip install tflite-support
เครื่องมือข้อมูลเมตาของ LiteRT รองรับ Python 3
การเพิ่มข้อมูลเมตาโดยใช้ Flatbuffers Python API
ข้อมูลเมตาของโมเดลแบ่งออกเป็น 3 ส่วนในส่วน สคีมา:
- ข้อมูลรุ่น - คำอธิบายโดยรวมของโมเดลรวมถึงสินค้า
เช่น ข้อกำหนดใบอนุญาต โปรดดู
ModelMetadata
- ข้อมูลอินพุต - คำอธิบายของอินพุตและการประมวลผลล่วงหน้า
เช่น การปรับให้สอดคล้องตามมาตรฐาน โปรดดู
SubGraphMetadata.input_tensor_metadata
- ข้อมูลเอาต์พุต - คำอธิบายของเอาต์พุตและ การประมวลผลภายหลังที่จำเป็น เช่น การแมปกับป้ายกำกับ โปรดดู SubGraphMetadata.output_tensor_metadata
- ข้อมูลอินพุต - คำอธิบายของอินพุตและการประมวลผลล่วงหน้า
เช่น การปรับให้สอดคล้องตามมาตรฐาน โปรดดู
SubGraphMetadata.input_tensor_metadata
เนื่องจากในขณะนี้ LiteRT รองรับเฉพาะกราฟย่อยแบบเดี่ยว
โปรแกรมสร้างรหัส LiteRT
และการเชื่อมโยง ML สำหรับ Android Studio
ฟีเจอร์
จะใช้ ModelMetadata.name
และ ModelMetadata.description
แทน
SubGraphMetadata.name
และ SubGraphMetadata.description
เมื่อแสดง
ข้อมูลเมตาและการสร้างโค้ด
ประเภทอินพุต / เอาต์พุตที่รองรับ
ข้อมูลเมตา LiteRT สำหรับอินพุตและเอาต์พุตไม่ได้ออกแบบมาโดยมี ประเภทโมเดลเป็นหลัก แต่จะเป็นประเภทอินพุตและเอาต์พุต ไม่สำคัญว่า โมเดลนั้นจะทำงานได้ ตราบใดที่ประเภทอินพุตและเอาต์พุตประกอบด้วย ต่อไปนี้หรือชุดค่าผสมต่อไปนี้ TensorFlow รองรับ ข้อมูลเมตา Lite:
- ฟีเจอร์ - ตัวเลขที่เป็นจำนวนเต็มที่ไม่มีเครื่องหมายหรือ Float32
- รูปภาพ - ปัจจุบันข้อมูลเมตารองรับรูปภาพ RGB และโทนสีเทา
- กล่องล้อมรอบ - กรอบล้อมรอบรูปทรงสี่เหลี่ยมผืนผ้า สคีมารองรับ ตัวเลขที่หลากหลาย แผนการ
บรรจุไฟล์ที่เกี่ยวข้อง
โมเดล LiteRT อาจมาพร้อมกับไฟล์ต่างๆ ที่เกี่ยวข้อง ตัวอย่างเช่น โมเดลภาษาธรรมชาติมักจะมีไฟล์คำศัพท์ที่เชื่อมชิ้นส่วนคำกับคำ รหัส; โมเดลการจัดประเภทอาจมีไฟล์ป้ายกำกับที่ระบุหมวดหมู่ออบเจ็กต์ หากไม่มีไฟล์ที่เกี่ยวข้อง (หากมี) โมเดลจะทำงานได้ไม่ดี
สามารถรวมไฟล์ที่เชื่อมโยงเข้ากับโมเดลผ่านข้อมูลเมตาได้แล้ว
ไลบรารี Python โมเดล LiteRT ใหม่จะกลายเป็นไฟล์ ZIP ที่มี
ทั้งโมเดลและไฟล์ที่เกี่ยวข้อง สามารถคลายการบีบอัดด้วยไฟล์ ZIP ทั่วไป
และเครื่องมือการประมาณที่กำหนดได้เอง รูปแบบโมเดลใหม่นี้ยังคงใช้นามสกุลไฟล์เดิม .tflite
ทั้งนี้
ใช้ได้กับเฟรมเวิร์ก TFLite และล่ามที่มีอยู่ ดูข้อมูลเมตาของแพ็ก
และไฟล์ที่เกี่ยวข้องลงใน
รุ่น เพื่อดูรายละเอียดเพิ่มเติม
ข้อมูลไฟล์ที่เกี่ยวข้องสามารถบันทึกไว้ในข้อมูลเมตาได้ ขึ้นอยู่กับ
ประเภทไฟล์และตำแหน่งที่จะแนบไฟล์ (เช่น ModelMetadata
,
SubGraphMetadata
และ TensorMetadata
) รหัส LiteRT Android
โปรแกรมสร้างอาจใช้ก่อน/หลังที่สอดคล้องกัน
ไปยังออบเจ็กต์โดยอัตโนมัติ โปรดดู<การใช้งาน Codegen> ส่วนของ
แต่ละไฟล์ที่เชื่อมโยง
ประเภท
ในสคีมาเพื่อดูรายละเอียดเพิ่มเติม
พารามิเตอร์การปรับมาตรฐานและการวัดปริมาณ
การปรับให้สอดคล้องตามมาตรฐานเป็นเทคนิคการประมวลผลข้อมูลล่วงหน้าที่พบบ่อยในแมชชีนเลิร์นนิง คือการเปลี่ยนค่าให้เป็นขนาดที่ใช้กันทั่วไป โดยไม่ เพื่อให้ช่วงของค่าแตกต่างกัน
การวัดจํานวนโมเดลเป็นเทคนิคหนึ่ง ที่ทำให้สามารถลดความแม่นยำในการแสดงน้ำหนักและเลือก สำหรับทั้งพื้นที่เก็บข้อมูลและการคำนวณ
ในแง่ของการประมวลผลล่วงหน้าและหลังการประมวลผล การแปลงเป็นมาตรฐานและการวัดปริมาณ เป็น 2 ขั้นตอนที่แยกจากกัน ตามรายละเอียดดังนี้
การปรับให้สอดคล้องตามมาตรฐาน | การกำหนดปริมาณ | |
---|---|---|
ตัวอย่างของ ค่าพารามิเตอร์ของ ภาพอินพุตใน MobileNet สำหรับแบบลอยและ โมเดลเชิงปริมาณ ตามลำดับ |
โมเดลแบบลอย: - ค่าเฉลี่ย: 127.5 - STD: 127.5 รูปแบบจำนวน: - ค่าเฉลี่ย: 127.5 - STD: 127.5 |
โมเดลแบบลอย: - ZeroPoint: 0 - สเกล: 1.0 รูปแบบจำนวน: - ZeroPoint: 128.0 - สเกล:0.0078125f |
เรียกใช้เมื่อใด |
อินพุต: หากเป็นอินพุต ข้อมูลจะได้รับการปรับให้เป็นมาตรฐานใน การฝึกอบรม, อินพุต ข้อมูลความต้องการในการอนุมาน จะถูกทำให้เป็นมาตรฐาน ตามนั้น เอาต์พุต: เอาต์พุต ข้อมูลจะไม่ และการปรับให้สอดคล้องตามมาตรฐานโดยทั่วไป |
โมเดลแบบลอยไม่
ไม่จำเป็นต้องใช้ปริมาณ แบบจำลองที่มีขนาดอาจ หรือไม่จำเป็นต้อง การวัดปริมาณในช่วงก่อน/หลัง การประมวลผล แล้วแต่กรณี เกี่ยวกับประเภทข้อมูลของ Tensor อินพุต/เอาต์พุต - Tensor จำนวนลอยตัว: ไม่ การวัดปริมาณในช่วงก่อน/หลัง จำเป็นต้องประมวลผล Quant การดำเนินการที่แบ่งออกเป็นส่วนๆ คือ ในโมเดล กราฟ - int8/uint8 tensor: ต้องมีการวัดปริมาณใน ก่อน/หลังการประมวลผล |
สูตร |
standardized_input = (input - ค่าเฉลี่ย) / std |
ปรับขนาดอินพุต:
q = f / สเกล + zeroPoint วัดปริมาณสำหรับ เอาต์พุต: f = (q - ZeroPoint) * มาตราส่วน |
ตัวกรอง พารามิเตอร์ |
ป้อนข้อมูลโดยผู้สร้างโมเดล
และจัดเก็บไว้ในโมเดล
เป็นข้อมูลเมตา
NormalizationOptions |
เติมโดยอัตโนมัติโดย ตัวแปลง TFLite และ เก็บไว้ในโมเดล tflite |
วิธีใช้ พารามิเตอร์ | ผ่าน
API ของ MetadataExtractor
[2]
|
ผ่าน TFLite
Tensor API [1] หรือ
ผ่านทาง
API MetadataExtractor รายการ
[2] |
ทำจำนวนลอยตัวและเป็นจำนวน โมเดลต่างๆ มีการใช้งาน | ใช่ ทศนิยมและเชิงปริมาณ มีโมเดลที่เหมือนกัน การปรับให้สอดคล้องตามมาตรฐาน พารามิเตอร์ | ไม่ โมเดลแบบลอยมี ไม่จำเป็นต้องใช้ปริมาณ |
รหัส TFLite Generator หรือ Android การเชื่อมโยง ML ของ Studio สร้างโดยอัตโนมัติ ในการประมวลผลข้อมูลได้อย่างไร | ติดต่อ |
ติดต่อ |
[1] LiteRT Java
API
และ 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.")
ข้อมูลอินพุต / เอาต์พุต
ส่วนนี้จะแสดงวิธีอธิบายลายเซ็นอินพุตและเอาต์พุตของโมเดล โปรแกรมสร้างโค้ดอัตโนมัติอาจใช้ข้อมูลเมตานี้เพื่อสร้างช่วงก่อนและหลัง รหัสการประมวลผล วิธีสร้างข้อมูลอินพุตหรือเอาต์พุตเกี่ยวกับ tensor มีดังนี้
# Creates input info.
input_meta = _metadata_fb.TensorMetadataT()
# Creates output info.
output_meta = _metadata_fb.TensorMetadataT()
อินพุตรูปภาพ
รูปภาพเป็นประเภทอินพุตทั่วไปสำหรับแมชชีนเลิร์นนิง ข้อมูลเมตา LiteRT สนับสนุนข้อมูลอย่างเช่น พื้นที่สีและข้อมูลการประมวลผลล่วงหน้า เช่น การแปลงเป็นรูปแบบมาตรฐาน ขนาดของรูปภาพไม่จำเป็นต้องมีข้อกำหนดด้วยตนเอง เนื่องจากมีอยู่แล้วโดยรูปร่างของ Tensor อินพุตและสามารถ อนุมานโดยอัตโนมัติได้
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 เอาต์พุตผ่านไฟล์ที่เชื่อมโยงได้โดยใช้
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 เพื่อแสดงภาพ
หรือคุณจะอ่านข้อมูลเมตาจากโมเดล 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 ด้วย การเชื่อมโยง ฟีเจอร์
การกำหนดเวอร์ชันข้อมูลเมตา
ข้อมูลเมตา สคีมา จะมีเวอร์ชันทั้งสองด้วยหมายเลขการกำหนดเวอร์ชันความหมาย ซึ่งติดตามการเปลี่ยนแปลงของ และตัวระบุไฟล์ 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 โปรดดู
เครื่องมือแยกข้อมูลเมตาสำหรับข้อมูลเพิ่มเติมเกี่ยวกับวิธี
และใช้เวอร์ชันโปรแกรมแยกวิเคราะห์ข้อมูลเมตาขั้นต่ำที่จำเป็น
อ่านข้อมูลเมตาจากโมเดล
ไลบรารีตัวแยกข้อมูลเมตาเป็นเครื่องมือที่สะดวกในการอ่านข้อมูลเมตาและ ไฟล์ที่เกี่ยวข้องจากโมเดลในแพลตฟอร์มต่างๆ (โปรดดูแท็ก Java เวอร์ชัน และ C++ เวอร์ชัน) คุณสามารถสร้างเครื่องมือแยกข้อมูลเมตาของคุณเองในภาษาอื่นๆ ได้โดยใช้ ไลบรารี Flatbuffers
อ่านข้อมูลเมตาใน Java
หากต้องการใช้ไลบรารีตัวแยกข้อมูลเมตาในแอป Android เราขอแนะนำให้ใช้
AAR ของข้อมูลเมตา LiteRT โฮสต์ที่
MavenCentral.
มีคลาส MetadataExtractor
รวมถึง FlatBuffers Java
การเชื่อมโยงของข้อมูลเมตา
สคีมา
และโมเดล
สคีมา
คุณสามารถระบุการทำงานนี้ในทรัพยากร Dependency ของ build.gradle
ได้ดังนี้
dependencies {
implementation 'org.tensorflow:tensorflow-lite-metadata:0.1.0'
}
หากต้องการใช้สแนปชอตยามค่ำคืน ให้ตรวจสอบว่าคุณได้เพิ่มสแนปชอต Sponatype แล้ว ที่เก็บ
คุณสามารถเริ่มต้นออบเจ็กต์ MetadataExtractor
ด้วย ByteBuffer
ที่ชี้
กับโมเดล:
public MetadataExtractor(ByteBuffer buffer);
ByteBuffer
ต้องไม่มีการเปลี่ยนแปลงตลอดอายุการใช้งานของ
MetadataExtractor
ออบเจ็กต์ การเริ่มต้นอาจล้มเหลวหากไฟล์ Flatbuffers
ตัวระบุของข้อมูลเมตาของโมเดลไม่ตรงกับโปรแกรมแยกวิเคราะห์ข้อมูลเมตา โปรดดู
การกำหนดเวอร์ชันข้อมูลเมตาเพื่อดูข้อมูลเพิ่มเติม
เมื่อมีตัวระบุไฟล์ที่ตรงกัน เครื่องมือแยกข้อมูลเมตาจะอ่านได้สำเร็จ ที่สร้างขึ้นจากสคีมาทั้งหมดในอดีตและอนาคตเนื่องจาก Flatbuffers กลไกความเข้ากันได้แบบส่งต่อและย้อนหลัง อย่างไรก็ตาม ช่องในอนาคต ไม่สามารถดึงข้อมูลสคีมาโดยเครื่องมือแยกข้อมูลเมตาเวอร์ชันเก่า ขั้นต่ำที่จำเป็น เวอร์ชันโปรแกรมแยกวิเคราะห์ของข้อมูลเมตา ระบุเวอร์ชันขั้นต่ำของโปรแกรมแยกวิเคราะห์ข้อมูลเมตาที่อ่านข้อมูลเมตาได้ แฟลตบัฟเฟอร์โดยสมบูรณ์ คุณสามารถใช้วิธีต่อไปนี้ เพื่อยืนยันว่า เป็นไปตามเงื่อนไขของเวอร์ชันโปรแกรมแยกวิเคราะห์ที่จำเป็น
public final boolean isMinimumParserVersionSatisfied();
ระบบอนุญาตให้ส่งต่อโมเดลโดยไม่มีข้อมูลเมตา แต่การเรียกใช้เมธอดที่
ที่อ่านจากข้อมูลเมตาจะทำให้เกิดข้อผิดพลาดรันไทม์ คุณสามารถตรวจสอบว่าโมเดลมี
ข้อมูลเมตาโดยการเรียกใช้เมธอด hasMetadata
:
public boolean hasMetadata();
MetadataExtractor
มีฟังก์ชันที่สะดวกในการรับฟังก์ชัน
Tensor อินพุต/เอาต์พุต ข้อมูลเมตา ตัวอย่างเช่น
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 ที่มีข้อมูลเมตาและไฟล์ที่เกี่ยวข้อง 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
คุณยังสามารถอ่านไฟล์ที่เกี่ยวข้องผ่านไลบรารีตัวแยกข้อมูลเมตาได้อีกด้วย
ใน Java ให้ส่งชื่อไฟล์ไปยัง MetadataExtractor.getAssociatedFile
วิธีการ:
public InputStream getAssociatedFile(String fileName);
ในทำนองเดียวกัน ใน C++ สามารถทำได้โดยใช้เมธอด
ModelMetadataExtractor::GetAssociatedFile
:
tflite::support::StatusOr<absl::string_view> GetAssociatedFile(
const std::string& filename) const;