ดูข้อมูลเพิ่มเติมเกี่ยวกับประกาศจาก I/O ของ Google AI Edge

หน้านี้ได้รับการแปลโดย Cloud Translation API

การเพิ่มข้อมูลเมตาไปยังโมเดล TensorFlow Lite

ข้อมูลเมตาของ TensorFlow Lite ระบุมาตรฐานสำหรับคำอธิบายโมเดล ข้อมูลเมตาคือแหล่งข้อมูลสำคัญของความรู้เกี่ยวกับสิ่งที่โมเดลทำและข้อมูลอินพุต / เอาต์พุต ข้อมูลเมตาประกอบด้วย

ส่วนที่มนุษย์อ่านได้ซึ่งสื่อถึงแนวทางปฏิบัติแนะนำเมื่อใช้โมเดล และ
ส่วนที่เครื่องอ่านได้ซึ่งสามารถใช้ประโยชน์จากโปรแกรมสร้างโค้ด เช่น โปรแกรมสร้างโค้ดสำหรับ Android TensorFlow Lite และฟีเจอร์การเชื่อมโยง ML ของ Android Studio

โมเดลรูปภาพทั้งหมดที่เผยแพร่ใน Kaggle Models ได้รับการสร้างด้วยข้อมูลเมตา

โมเดลที่มีรูปแบบข้อมูลเมตา

รูปที่ 1 โมเดล TFLite ที่มีข้อมูลเมตาและไฟล์ที่เกี่ยวข้อง

ข้อมูลเมตาของโมเดลมีคำจำกัดความอยู่ใน metadata_schema.fbs ซึ่งเป็นไฟล์ FlatBuffer ดังที่แสดงในรูปที่ 1 ข้อมูลนี้ถูกจัดเก็บไว้ในช่องข้อมูลเมตาของสคีมาโมเดล TFLite ภายใต้ชื่อ "TFLITE_METADATA" บางโมเดลอาจมาพร้อมกับไฟล์ที่เกี่ยวข้อง เช่น ไฟล์ป้ายกำกับการแยกประเภท ไฟล์เหล่านี้ต่อกันอยู่ที่ส่วนท้ายของไฟล์โมเดลต้นฉบับเป็นไฟล์ ZIP โดยใช้โหมด"ต่อท้าย" ZipFile (โหมด 'a') ล่าม TFLite จะใช้รูปแบบไฟล์ใหม่ได้ในลักษณะเดิม ดูข้อมูลเพิ่มเติมที่แพ็คไฟล์ที่เกี่ยวข้อง

ดูวิธีการด้านล่างเกี่ยวกับวิธีป้อนข้อมูล แสดงข้อมูลผ่านภาพ และอ่านข้อมูลเมตา

ตั้งค่าเครื่องมือข้อมูลเมตา

ก่อนเพิ่มข้อมูลเมตาลงในโมเดลของคุณ คุณต้องตั้งค่าสภาพแวดล้อมการเขียนโปรแกรม Python สำหรับการเรียกใช้ TensorFlow มีคำแนะนำโดยละเอียดเกี่ยวกับวิธี ตั้งค่านี้ได้ที่นี่

หลังจากตั้งค่าสภาพแวดล้อมการเขียนโปรแกรม Python แล้ว คุณจะต้องติดตั้งเครื่องมือเพิ่มเติม

pip install tflite-support

เครื่องมือข้อมูลเมตาของ TensorFlow Lite รองรับ Python 3

การเพิ่มข้อมูลเมตาโดยใช้ Flatbuffers Python API

ข้อมูลเมตาของโมเดลในสคีมามีอยู่ 3 ส่วนดังนี้

ข้อมูลโมเดล - คำอธิบายโดยรวมของโมเดล รวมถึงรายการต่างๆ เช่น ข้อกำหนดของใบอนุญาต โปรดดู ModelMetadata
1. ข้อมูลอินพุต - คำอธิบายของอินพุตและการประมวลผลที่จำเป็น เช่น การปรับให้เป็นมาตรฐาน โปรดดู SubGraphMetadata.input_tensor_metadata
  1. ข้อมูลเอาต์พุต - คำอธิบายของเอาต์พุตและหลังการประมวลผลที่จำเป็น เช่น การแมปกับป้ายกำกับ โปรดดู SubGraphMetadata.output_tensor_metadata

เนื่องจากตอนนี้ TensorFlow Lite รองรับเฉพาะกราฟย่อยเดี่ยว โปรแกรมสร้างโค้ด TensorFlow Lite และฟีเจอร์การเชื่อมโยง ML ของ Android Studio จะใช้ ModelMetadata.name และ ModelMetadata.description แทน SubGraphMetadata.name และ SubGraphMetadata.description ในการแสดงข้อมูลเมตาและสร้างโค้ด

ประเภทอินพุต / เอาต์พุตที่รองรับ

ข้อมูลเมตาของ TensorFlow Lite สำหรับอินพุตและเอาต์พุตไม่ได้ออกแบบมาโดยคำนึงถึงประเภทโมเดลที่เฉพาะเจาะจง แต่จะออกแบบมาสำหรับประเภทอินพุตและเอาต์พุต โมเดลมีฟังก์ชันการทำงานหรือไม่ ตราบใดที่ประเภทอินพุตและเอาต์พุตประกอบด้วยสิ่งต่อไปนี้หรือชุดค่าผสมต่อไปนี้ ข้อมูลเมตาของ TensorFlow Lite จะรองรับ

ฟีเจอร์ - ตัวเลขที่เป็นจำนวนเต็มที่ไม่มีเครื่องหมายหรือ Float32
รูปภาพ - ปัจจุบันข้อมูลเมตารองรับรูปภาพ RGB และโทนสีเทา
กล่องล้อมรอบ - กรอบล้อมรอบรูปทรงสี่เหลี่ยมผืนผ้า สคีมารองรับรูปแบบตัวเลขที่หลากหลาย

บรรจุไฟล์ที่เกี่ยวข้อง

โมเดล TensorFlow Lite อาจมาพร้อมกับไฟล์ที่เกี่ยวข้องที่แตกต่างกัน ตัวอย่างเช่น โมเดลภาษาที่เป็นธรรมชาติมักจะมีไฟล์คำศัพท์ที่จับคู่ชิ้นส่วนคำกับรหัสคำ ส่วนโมเดลการจัดประเภทอาจมีไฟล์ป้ายกำกับที่ระบุหมวดหมู่ออบเจ็กต์ หากไม่มีไฟล์ที่เกี่ยวข้อง (หากมี) โมเดลจะทำงานได้ไม่ดี

สามารถรวมไฟล์ที่เชื่อมโยงเข้ากับโมเดลผ่านไลบรารีข้อมูลเมตา Python ได้แล้ว โมเดล TensorFlow Lite ใหม่จะกลายเป็นไฟล์ ZIP ที่มีทั้งโมเดลและไฟล์ที่เกี่ยวข้อง สามารถคลายการบีบอัดด้วย เครื่องมือ Zip ทั่วไป รูปแบบโมเดลใหม่นี้ยังคงใช้นามสกุลไฟล์เดิม .tflite โดยเข้ากันได้กับเฟรมเวิร์ก TFLite และล่ามที่มีอยู่ ดูรายละเอียดเพิ่มเติมได้ที่แพ็กข้อมูลเมตาและไฟล์ที่เกี่ยวข้องลงในโมเดล

ข้อมูลไฟล์ที่เกี่ยวข้องสามารถบันทึกไว้ในข้อมูลเมตาได้ เครื่องมือสร้างโค้ดสำหรับ Android ของ TensorFlow Lite อาจใช้การประมวลผลก่อน/หลังที่สอดคล้องกันกับออบเจ็กต์โดยอัตโนมัติ ทั้งนี้ขึ้นอยู่กับประเภทไฟล์และตำแหน่งที่แนบไฟล์ (เช่น ModelMetadata, SubGraphMetadata และ TensorMetadata) ดูรายละเอียดเพิ่มเติมได้ที่ส่วน <การใช้งาน 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 op และ Deวิธีการ จะอยู่ในกราฟโมเดล - int8/uint8 tensor: ต้องการปริมาณในการประมวลผลก่อน/หลัง
สูตร	normalized_input = (input - ค่าเฉลี่ย) / std	กำหนดปริมาณสำหรับอินพุต: q = f / scale + zeroPoint แยกปริมาณสำหรับ เอาต์พุต: f = (q - ZeroPoint) * สเกล
พารามิเตอร์อยู่ตรงไหน	กรอกข้อมูลโดยผู้สร้างโมเดล และจัดเก็บไว้ในข้อมูลเมตาของโมเดล เป็น `NormalizationOptions`	ส่งโดยอัตโนมัติโดย ตัวแปลง TFLite และ จัดเก็บไว้ในไฟล์โมเดล tflite
วิธีหาพารามิเตอร์	ผ่าน `MetadataExtractor` API [2]	ผ่าน TFLite `Tensor` API [1] หรือ ผ่าน `MetadataExtractor` API [2]
โมเดลลอยและแบบจำลองจำนวน มีค่าเหมือนกันไหม	ใช่ โมเดลลอยตัวและแบบจำลองเชิงปริมาณ มีพารามิเตอร์ การทำให้เป็นมาตรฐาน เหมือนกัน	ไม่ โมเดลจำนวนลอยตัว ไม่จำเป็นต้องมีการปรับปริมาณ
โปรแกรมสร้างโค้ด TFLite หรือการเชื่อมโยง Android Studio ML จะสร้าง รหัสโดยอัตโนมัติในการประมวลผลข้อมูลหรือไม่	ใช่	ใช่

[1] TensorFlow Lite Java API และ TensorFlow Lite 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

หากต้องการสร้างข้อมูลเมตาสำหรับโมเดลการจัดประเภทรูปภาพอื่นๆ ให้เพิ่มข้อกำหนดของโมเดล เช่น this ลงในสคริปต์ ส่วนที่เหลือของคู่มือนี้จะเน้นส่วนสำคัญบางส่วนในตัวอย่างการจัดประเภทรูปภาพเพื่อแสดงให้เห็นองค์ประกอบหลัก

เจาะลึกตัวอย่างการจัดประเภทรูปภาพ

ข้อมูลรุ่น

ข้อมูลเมตาจะเริ่มต้นด้วยการสร้างข้อมูลโมเดลใหม่ดังนี้

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

อินพุตรูปภาพ

รูปภาพเป็นประเภทอินพุตทั่วไปสำหรับแมชชีนเลิร์นนิง ข้อมูลเมตาของ TensorFlow Lite รองรับข้อมูลอย่างเช่น พื้นที่สีและข้อมูลก่อนการประมวลผล เช่น การปรับให้สอดคล้องตามมาตรฐาน ขนาดของรูปภาพไม่จำเป็นต้องมีข้อกำหนดด้วยตนเอง เนื่องจากมีการกำหนดโดยรูปร่างของ 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 เพื่อแสดงภาพข้อมูลเมตาหรืออ่านข้อมูลเมตาจากโมเดล 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 ยังรองรับการแสดงข้อมูลเมตาผ่านฟีเจอร์การเชื่อมโยง ML ของ Android Studio ด้วย

การกำหนดเวอร์ชันข้อมูลเมตา

สคีมาข้อมูลเมตาจะมีการกำหนดเวอร์ชันโดยใช้หมายเลขการกำหนดเวอร์ชันความหมาย ซึ่งติดตามการเปลี่ยนแปลงของไฟล์สคีมา และด้วยการระบุไฟล์ 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 ของ TensorFlow Lite ที่โฮสต์ที่ MavenCentral โดยมีคลาส MetadataExtractor และการเชื่อมโยง Java ของ FlatBuffers สำหรับสคีมาข้อมูลเมตาและสคีมาโมเดล

คุณสามารถระบุการทำงานนี้ในทรัพยากร 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);

แม้ว่าสคีมาโมเดล TensorFlow Lite จะรองรับกราฟย่อยหลายรายการ แต่ขณะนี้ตัวล่าม TFLite รองรับเฉพาะกราฟย่อยเดี่ยว ดังนั้น 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

คุณยังสามารถอ่านไฟล์ที่เกี่ยวข้องผ่านไลบรารีตัวแยกข้อมูลเมตาได้อีกด้วย

ใน Java ให้ส่งชื่อไฟล์ลงในเมธอด MetadataExtractor.getAssociatedFile ดังนี้

public InputStream getAssociatedFile(String fileName);

ในทำนองเดียวกัน ใน C++ คุณจะทําได้ด้วยเมธอด ModelMetadataExtractor::GetAssociatedFile:

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