การเพิ่มข้อมูลเมตาให้กับโมเดล TensorFlow Lite

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

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

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

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

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

ข้อมูลเมตาของโมเดลถูกกำหนดไว้ใน 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

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

  1. ข้อมูลรุ่น - คำอธิบายโดยรวมของรุ่นตลอดจนรายการต่างๆ เช่น เงื่อนไขใบอนุญาต ดู ModelMetadata
  2. ข้อมูลอินพุต - คำอธิบายของอินพุตและการประมวลผลล่วงหน้าที่จำเป็น เช่น การทำให้เป็นมาตรฐาน ดู SubGraphMetadata.input_tensor_metadata
  3. ข้อมูลเอาท์พุต - คำอธิบายของเอาท์พุตและการประมวลผลภายหลังที่จำเป็น เช่น การแมปกับฉลาก ดู 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 อาจมาพร้อมกับไฟล์ที่เกี่ยวข้องต่างกัน ตัวอย่างเช่น โมเดลภาษาธรรมชาติมักจะมีไฟล์คำศัพท์ที่แมปส่วนของคำกับรหัสคำ โมเดลการจำแนกประเภทอาจมีไฟล์ป้ายกำกับที่ระบุหมวดหมู่ของวัตถุ หากไม่มีไฟล์ที่เกี่ยวข้อง (ถ้ามี) โมเดลจะไม่ทำงานได้ดี

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

ข้อมูลไฟล์ที่เกี่ยวข้องสามารถบันทึกลงในข้อมูลเมตาได้ ขึ้นอยู่กับประเภทไฟล์และตำแหน่งที่แนบไฟล์ (เช่น ModelMetadata , SubGraphMetadata และ TensorMetadata ) ตัวสร้างโค้ด Android TensorFlow Lite อาจใช้การประมวลผลก่อน/หลังที่สอดคล้องกันกับออบเจ็กต์โดยอัตโนมัติ ดู ส่วน <การใช้โค้ดเจน> ของไฟล์ที่เกี่ยวข้องแต่ละประเภท ในสคีมาสำหรับรายละเอียดเพิ่มเติม

พารามิเตอร์การทำให้เป็นมาตรฐานและการหาปริมาณ

การทำให้เป็นมาตรฐานเป็นเทคนิคการประมวลผลข้อมูลล่วงหน้าทั่วไปในการเรียนรู้ของเครื่อง เป้าหมายของการทำให้เป็นมาตรฐานคือการเปลี่ยนค่าให้เป็นระดับทั่วไป โดยไม่บิดเบือนความแตกต่างในช่วงของค่า

การหาปริมาณแบบจำลอง เป็นเทคนิคที่ช่วยให้การแสดงน้ำหนักมีความแม่นยำลดลง และเป็นทางเลือก การเปิดใช้งานทั้งการจัดเก็บและการคำนวณ

ในแง่ของการประมวลผลก่อนและหลังการประมวลผล การทำให้เป็นมาตรฐานและการหาปริมาณเป็นสองขั้นตอนที่แยกจากกัน นี่คือรายละเอียด

การทำให้เป็นมาตรฐาน การหาปริมาณ

ตัวอย่างของค่าพารามิเตอร์ของอิมเมจอินพุตใน MobileNet สำหรับโมเดล float และ quant ตามลำดับ
แบบลอยตัว :
- ค่าเฉลี่ย: 127.5
- มาตรฐาน: 127.5
รุ่นปริมาณ :
- ค่าเฉลี่ย: 127.5
- มาตรฐาน: 127.5
แบบลอยตัว :
- จุดศูนย์: 0
- สเกล: 1.0
รุ่นปริมาณ :
- ศูนย์พอยต์: 128.0
- สเกล:0.0078125f




เมื่อไหร่จะเรียกใช้?


อินพุต : หากข้อมูลอินพุตถูกทำให้เป็นมาตรฐานในการฝึกอบรม ข้อมูลอินพุตของการอนุมานจะต้องได้รับการทำให้เป็นมาตรฐานตามนั้น
เอาท์พุต : ข้อมูลเอาท์พุตจะไม่ถูกทำให้เป็นมาตรฐานโดยทั่วไป
โมเดลโฟลต ไม่จำเป็นต้องมีการวัดปริมาณ
โมเดลเชิงปริมาณ อาจหรือไม่จำเป็นต้องมีการวัดปริมาณในการประมวลผลก่อน/หลัง ขึ้นอยู่กับประเภทข้อมูลของเทนเซอร์อินพุต/เอาท์พุต
- เทนเซอร์แบบลอย: ไม่จำเป็นต้องมีการหาปริมาณในการประมวลผลก่อน/หลัง Quant op และ dequant op จะถูกอบเข้าไปในกราฟแบบจำลอง
- เทนเซอร์ int8/uint8: จำเป็นต้องมีการหาปริมาณในการประมวลผลก่อน/หลัง


สูตร


Normalized_input = (อินพุต - ค่าเฉลี่ย) / มาตรฐาน
ปริมาณสำหรับอินพุต :
q = f / สเกล + จุดศูนย์
แยกส่วนสำหรับเอาต์พุต :
f = (q - zeroPoint) * สเกล

พารามิเตอร์อยู่ที่ไหน
เติมโดยผู้สร้างโมเดลและจัดเก็บไว้ในข้อมูลเมตาของโมเดล เป็น NormalizationOptions เติมโดยอัตโนมัติด้วยตัวแปลง TFLite และจัดเก็บไว้ในไฟล์โมเดล tflite
จะรับพารามิเตอร์ได้อย่างไร? ผ่าน MetadataExtractor API [2] ผ่าน TFLite Tensor API [1] หรือผ่าน MetadataExtractor API [2]
โมเดล float และ quant มีค่าเท่ากันหรือไม่ ใช่ โมเดล float และ quant มีพารามิเตอร์ Normalization เหมือนกัน ไม่ โมเดล float ไม่จำเป็นต้องหาปริมาณ
ตัวสร้างรหัส 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 ซึ่งระบุความเข้ากันได้ของเวอร์ชันที่แท้จริง

หมายเลขเวอร์ชันความหมาย

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

แม้ว่าสคีมา โมเดล 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;