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

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

ทุกรุ่นภาพเผยแพร่บน 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 3

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

มีสามส่วนกับเมตาดาต้าในรูปแบบที่มี สคี :

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

ตั้งแต่ TensorFlow Lite สนับสนุนเฉพาะ subgraph เดียวในจุดนี้ เครื่องกำเนิดไฟฟ้ารหัส TensorFlow Lite และ คุณลักษณะ Android สตูดิโอ ML ผูกพัน จะใช้ ModelMetadata.name และ ModelMetadata.description แทน SubGraphMetadata.name และ SubGraphMetadata.description เมื่อแสดง metadata และสร้างรหัส

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

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

  • คุณลักษณะ - ตัวเลขที่เป็นจำนวนเต็มที่ไม่ได้ลงนามหรือ float32
  • รูปภาพ - ปัจจุบันข้อมูลเมตารองรับรูปภาพ RGB และระดับสีเทา
  • Bounding box - ขอบกล่องทรงสี่เหลี่ยม คีมาสนับสนุน ความหลากหลายของรูปแบบการนับ

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

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

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

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

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

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

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

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

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

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




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


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


สูตร


normalized_input = (อินพุต - ค่าเฉลี่ย) / std
quantize สำหรับปัจจัยการผลิต:
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 ในข้อมูลเมตา การประมวลผลเชิงปริมาณและการลดปริมาณจะถูกห่อหุ้มไว้เสมอ

ตัวอย่าง

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

การจำแนกรูปภาพ

ดาวน์โหลดสคริปต์ที่ นี่ ซึ่ง populates ข้อมูลเมตา 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 สตูดิโอยังสนับสนุนเมตาดาต้าที่แสดงผ่าน คุณลักษณะ Android สตูดิโอ ML เข้าเล่ม

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

สคีเมตาดาต้า เป็น versioned ทั้งด้วยจำนวนเวอร์ชันหมายซึ่งติดตามการเปลี่ยนแปลงของไฟล์สคีมาและโดยการระบุไฟล์ Flatbuffers ซึ่งบ่งชี้ว่าการทำงานร่วมกันรุ่นที่แท้จริง

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

สคีข้อมูลเมตา versioned โดย จำนวนเวอร์ชันหมาย เช่น MAJOR.MINOR.PATCH จะติดตามการเปลี่ยนแปลงสคีตามกฎที่ นี่ ดู ประวัติศาสตร์ของสาขา เพิ่มหลังจากเวอร์ชัน 1.0.0

การระบุไฟล์ Flatbuffers

การกำหนดเวอร์ชันเชิงความหมายรับประกันความเข้ากันได้หากทำตามกฎ แต่ไม่ได้หมายความถึงความไม่ลงรอยกันที่แท้จริง เมื่อเพิ่มจำนวน MAJOR ขึ้น ก็ไม่ได้หมายความว่าความเข้ากันได้แบบย้อนหลังจะใช้งานไม่ได้เสมอไป ดังนั้นเราจึงใช้ บัตรประจำตัวไฟล์ Flatbuffers , file_identifier เพื่อแสดงถึงความเข้ากันได้ที่แท้จริงของสคีเมตาดาต้า ตัวระบุไฟล์มีความยาว 4 อักขระพอดี ได้รับการแก้ไขในสคีมาข้อมูลเมตาบางอย่างและผู้ใช้ไม่สามารถเปลี่ยนแปลงได้ หากต้องใช้งานร่วมกันได้แบบย้อนหลังของสคีมาข้อมูลเมตาด้วยเหตุผลบางประการ file_identifier จะเพิ่มขึ้น ตัวอย่างเช่น จาก “M001” เป็น “M002” File_identifier คาดว่าจะมีการเปลี่ยนแปลงน้อยกว่า metadata_version มาก

เวอร์ชันตัวแยกวิเคราะห์ข้อมูลเมตาขั้นต่ำที่จำเป็น

จำเป็นขั้นต่ำรุ่นเมตาดาต้าแยกวิเคราะห์ เป็นรุ่นต่ำสุดของการแยกวิเคราะห์เมตาดาต้า (Flatbuffers ที่สร้างรหัส) ที่สามารถอ่านข้อมูลเมตาใน Flatbuffers เต็ม เวอร์ชันนี้เป็นหมายเลขเวอร์ชันที่ใหญ่ที่สุดอย่างมีประสิทธิภาพในบรรดาเวอร์ชันของฟิลด์ทั้งหมดที่มีข้อมูล และเวอร์ชันที่เข้ากันได้ที่เล็กที่สุดซึ่งระบุโดยตัวระบุไฟล์ รุ่นขั้นต่ำที่จำเป็นเมตาดาต้าแยกวิเคราะห์เป็นประชากรโดยอัตโนมัติโดย MetadataPopulator เมื่อเมตาดาต้าที่มีประชากรในรูปแบบ TFLite ดู ระบายเมตาดาต้า สำหรับข้อมูลเพิ่มเติมเกี่ยวกับวิธีการขั้นต่ำที่จำเป็นรุ่นเมตาดาต้า parser ถูกนำมาใช้

อ่านข้อมูลเมตาจากโมเดล

ห้องสมุด Metadata Extractor เป็นเครื่องมือที่สะดวกในการอ่านข้อมูลเมตาและไฟล์ที่เกี่ยวข้องจากรุ่นข้ามแพลตฟอร์มที่แตกต่างกัน (ดู รุ่น Java และ C ++ รุ่น ) คุณสามารถสร้างเครื่องมือแยกข้อมูลเมตาของคุณเองในภาษาอื่นๆ โดยใช้ไลบรารี Flatbuffers

อ่านข้อมูลเมตาใน Java

การใช้ไลบรารี Metadata ดูดใน app 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 เต็ม คุณสามารถใช้วิธีการต่อไปนี้เพื่อตรวจสอบว่าตรงตามเงื่อนไขเวอร์ชัน 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 รุ่น สนับสนุน subgraphs หลาย TFLite ล่ามปัจจุบันเท่านั้นสนับสนุน subgraph เดียว ดังนั้น MetadataExtractor ละเว้นดัชนี subgraph เป็นอาร์กิวเมนต์ป้อนข้อมูลในวิธีการของ

อ่านไฟล์ที่เกี่ยวข้องจากรุ่นต่างๆ

โมเดล 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;