บันทึกวันที่! Google I / O ส่งคืนวันที่ 18-20 พฤษภาคม ลงทะเบียนตอนนี้
หน้านี้ได้รับการแปลโดย Cloud Translation API
Switch to English

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

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

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

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

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

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

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

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

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

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

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

pip install tflite-support

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

การเพิ่มข้อมูลเมตา

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

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

แพ็คไฟล์ที่เกี่ยวข้อง

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

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

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

พารามิเตอร์ Normalization และ Quantization

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

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

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

นอร์มัลไลเซชัน ปริมาณ

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




เมื่อใดควรเรียกใช้?


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


สูตร


normalized_input = (อินพุต - ค่าเฉลี่ย) / std
ปริมาณสำหรับอินพุต :
q = f / สเกล + zeroPoint
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] แต่โดยทั่วไปคุณควรประมวลผลข้อมูลตามพารามิเตอร์ normalization และ quantization เสมอเมื่อทำได้

ตัวอย่าง

คุณสามารถดูตัวอย่างวิธีการเติมข้อมูลเมตาสำหรับโมเดลประเภทต่างๆได้ที่นี่:

การจำแนกภาพ

ดาวน์โหลดสคริปต์ ที่นี่ ซึ่งจะเติมข้อมูลเมตาไปยัง 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

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

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