ช่วยปกป้อง Great Barrier Reef กับ TensorFlow บน Kaggle เข้าร่วมท้าทาย

การตรวจจับวัตถุด้วย TensorFlow Lite Model Maker

ดูบน TensorFlow.org ทำงานใน Google Colab ดูแหล่งที่มาบน GitHub ดาวน์โหลดโน๊ตบุ๊ค

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

รุ่นชงใช้ห้องสมุดโอนเรียนรู้ที่จะลดความซับซ้อนของกระบวนการของการฝึกอบรมรุ่น TensorFlow Lite โดยใช้ชุดข้อมูลที่กำหนดเอง การฝึกโมเดล TensorFlow Lite ใหม่ด้วยชุดข้อมูลที่คุณกำหนดเองจะช่วยลดปริมาณข้อมูลการฝึกที่จำเป็นและจะย่นระยะเวลาการฝึก

คุณจะได้ใช้สลัดชุดข้อมูลที่เปิดเผยต่อสาธารณชนซึ่งถูกสร้างขึ้นจาก เปิดภาพชุดข้อมูล V4

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

  • อบดี
  • ชีส
  • สลัด
  • อาหารทะเล
  • มะเขือเทศ

ชุดข้อมูลประกอบด้วยกล่องขอบเขตที่ระบุตำแหน่งที่แต่ละวัตถุตั้งอยู่ พร้อมกับป้ายกำกับของวัตถุ

นี่คือภาพตัวอย่างจากชุดข้อมูล:


ข้อกำหนดเบื้องต้น

ติดตั้งแพ็คเกจที่จำเป็น

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

pip install -q --use-deprecated=legacy-resolver tflite-model-maker
pip install -q pycocotools

นำเข้าแพ็คเกจที่จำเป็น

import numpy as np
import os

from tflite_model_maker.config import QuantizationConfig
from tflite_model_maker.config import ExportFormat
from tflite_model_maker import model_spec
from tflite_model_maker import object_detector

import tensorflow as tf
assert tf.__version__.startswith('2')

tf.get_logger().setLevel('ERROR')
from absl import logging
logging.set_verbosity(logging.ERROR)
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/pkg_resources/__init__.py:119: PkgResourcesDeprecationWarning: 0.18ubuntu0.18.04.1 is an invalid version and will not be supported in a future release
  PkgResourcesDeprecationWarning,
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/numba/core/errors.py:154: UserWarning: Insufficiently recent colorama version found. Numba requires colorama >= 0.3.9
  warnings.warn(msg)

เตรียมชุดข้อมูล

ที่นี่คุณจะใช้ชุดเดียวกับ AutoML QuickStart

สลัดชุดข้อมูลที่มีอยู่ที่: gs://cloud-ml-data/img/openimage/csv/salads_ml_use.csv

ประกอบด้วย 175 ภาพสำหรับการฝึกอบรม 25 ภาพสำหรับการตรวจสอบ และ 25 ภาพสำหรับการทดสอบ ชุดข้อมูลที่มีห้าชั้นเรียน: Salad , Seafood , Tomato , Baked goods , Cheese


ชุดข้อมูลมีให้ในรูปแบบ CSV:

TRAINING,gs://cloud-ml-data/img/openimage/3/2520/3916261642_0a504acd60_o.jpg,Salad,0.0,0.0954,,,0.977,0.957,,
VALIDATION,gs://cloud-ml-data/img/openimage/3/2520/3916261642_0a504acd60_o.jpg,Seafood,0.0154,0.1538,,,1.0,0.802,,
TEST,gs://cloud-ml-data/img/openimage/3/2520/3916261642_0a504acd60_o.jpg,Tomato,0.0,0.655,,,0.231,0.839,,
  • แต่ละแถวสอดคล้องกับออบเจ็กต์ที่แปลเป็นภาษาท้องถิ่นในรูปภาพขนาดใหญ่ โดยแต่ละออบเจ็กต์ถูกกำหนดเป็นข้อมูลการทดสอบ ฝึกฝน หรือการตรวจสอบโดยเฉพาะ คุณจะได้เรียนรู้เพิ่มเติมเกี่ยวกับความหมายในขั้นตอนต่อไปในสมุดบันทึกนี้
  • สามบรรทัดรวมอยู่ที่นี่บ่งบอกถึงสามวัตถุที่แตกต่างกันอยู่ภายในภาพเดียวกันที่มีอยู่ใน gs://cloud-ml-data/img/openimage/3/2520/3916261642_0a504acd60_o.jpg
  • แต่ละแถวจะมีป้ายชื่อที่แตกต่างกัน: Salad , Seafood , Tomato ฯลฯ
  • มีการกำหนดกรอบขอบเขตสำหรับแต่ละภาพโดยใช้จุดยอดซ้ายบนและล่างขวา

นี่คือภาพของสามบรรทัดเหล่านี้:


หากคุณต้องการทราบข้อมูลเพิ่มเติมเกี่ยวกับวิธีการเตรียมความพร้อมไฟล์ CSV ของคุณเองและความต้องการขั้นต่ำสำหรับการสร้างชุดข้อมูลที่ถูกต้องให้ดูที่ การจัดเตรียมข้อมูลการฝึกอบรมของคุณ คู่มือสำหรับรายละเอียดเพิ่มเติม

ถ้าคุณยังใหม่กับ Google Cloud คุณอาจสงสัยว่า gs:// หมายถึง URL พวกเขาคือ URL ของไฟล์ที่จัดเก็บไว้ใน Google Cloud Storage (GCS) ถ้าคุณทำไฟล์ของคุณบน GCS สาธารณะหรือ รับรองความถูกต้องของลูกค้า รุ่นชงสามารถอ่านไฟล์เหล่านั้นในทำนองเดียวกันกับไฟล์ในท้องถิ่นของคุณ

อย่างไรก็ตาม คุณไม่จำเป็นต้องเก็บรูปภาพของคุณบน Google Cloud เพื่อใช้ Model Maker คุณสามารถใช้เส้นทางภายในเครื่องในไฟล์ CSV และ Model Maker จะทำงาน

เริ่มต้นอย่างรวดเร็ว

มีหกขั้นตอนในการฝึกโมเดลการตรวจจับวัตถุ:

ขั้นตอนที่ 1 เลือกสถาปัตยกรรมแบบจำลองการตรวจจับวัตถุ

บทช่วยสอนนี้ใช้โมเดล EfficientDet-Lite0 EfficientDet-Lite [0-4] เป็นครอบครัวของ IOT ง่ายรุ่นมือถือ / ตรวจจับวัตถุที่ได้มาจาก EfficientDet สถาปัตยกรรม

นี่คือประสิทธิภาพของ EfficientDet-Lite แต่ละรุ่นเมื่อเปรียบเทียบกัน

สถาปัตยกรรมจำลอง ขนาด(MB)* เวลาในการตอบสนอง (มิลลิวินาที)** ความแม่นยำเฉลี่ย***
EfficientDet-Lite0 4.4 37 25.69%
EfficientDet-Lite1 5.8 49 30.55%
EfficientDet-Lite2 7.2 69 33.97%
EfficientDet-Lite3 11.4 116 37.70%
EfficientDet-Lite4 19.9 260 41.96%

* ขนาดของแบบจำลองเชิงปริมาณจำนวนเต็ม
** เวลาในการตอบสนองวัดบน Pixel 4 โดยใช้ 4 เธรดบน CPU
*** ความแม่นยำเฉลี่ยคือ mAP (ความแม่นยำเฉลี่ยเฉลี่ย) ในชุดข้อมูลการตรวจสอบความถูกต้องของ COCO 2017

spec = model_spec.get('efficientdet_lite0')

ขั้นตอนที่ 2 โหลดชุดข้อมูล

Model Maker จะนำข้อมูลเข้าในรูปแบบ CSV ใช้ object_detector.DataLoader.from_csv วิธีการโหลดชุดและแยกพวกเขาเข้าไปในการฝึกอบรมการตรวจสอบและการทดสอบภาพ

  • ภาพการฝึก: ภาพเหล่านี้ใช้เพื่อฝึกโมเดลการตรวจจับวัตถุให้รู้จักส่วนผสมของสลัด
  • ภาพตรวจสอบความถูกต้อง: ภาพเหล่านี้เป็นภาพที่โมเดลไม่เห็นในระหว่างกระบวนการฝึกอบรม คุณจะใช้พวกเขาในการตัดสินใจเมื่อคุณควรหยุดการฝึกอบรมเพื่อหลีกเลี่ยง อิง
  • ภาพทดสอบ: ภาพเหล่านี้ใช้เพื่อประเมินประสิทธิภาพของโมเดลขั้นสุดท้าย

คุณสามารถโหลดไฟล์ CSV ได้โดยตรงจาก Google Cloud Storage แต่คุณไม่จำเป็นต้องเก็บภาพของคุณบน Google Cloud เพื่อใช้ Model Maker คุณสามารถระบุไฟล์ CSV ในเครื่องบนคอมพิวเตอร์ของคุณ และ Model Maker ก็ใช้งานได้ดี

train_data, validation_data, test_data = object_detector.DataLoader.from_csv('gs://cloud-ml-data/img/openimage/csv/salads_ml_use.csv')

ขั้นตอนที่ 3 ฝึกโมเดล TensorFlow ด้วยข้อมูลการฝึก

  • EfficientDet-Lite0 รูปแบบการใช้งาน epochs = 50 โดยค่าเริ่มต้นซึ่งหมายความว่ามันจะไปถึงชุดการฝึกอบรมครั้งที่ 50 คุณสามารถดูความถูกต้องของการตรวจสอบระหว่างการฝึกและหยุดแต่เนิ่นๆ เพื่อหลีกเลี่ยงการใส่มากเกินไป
  • ชุด batch_size = 8 ที่นี่เพื่อให้คุณจะเห็นว่ามันจะใช้เวลา 21 ขั้นตอนที่จะไปผ่าน 175 ภาพในชุดฝึกอบรม
  • ชุด train_whole_model=True เพื่อปรับแต่งรูปแบบทั้งแทนเพียงการฝึกอบรมชั้นหัวเพื่อปรับปรุงความแม่นยำ ข้อเสียคืออาจใช้เวลานานกว่าในการฝึกโมเดล
model = object_detector.create(train_data, model_spec=spec, batch_size=8, train_whole_model=True, validation_data=validation_data)
Epoch 1/50
21/21 [==============================] - 48s 455ms/step - det_loss: 1.7625 - cls_loss: 1.1351 - box_loss: 0.0125 - reg_l2_loss: 0.0635 - loss: 1.8260 - learning_rate: 0.0090 - gradient_norm: 0.7406 - val_det_loss: 1.6586 - val_cls_loss: 1.1076 - val_box_loss: 0.0110 - val_reg_l2_loss: 0.0635 - val_loss: 1.7221
Epoch 2/50
21/21 [==============================] - 9s 452ms/step - det_loss: 1.6224 - cls_loss: 1.0936 - box_loss: 0.0106 - reg_l2_loss: 0.0635 - loss: 1.6860 - learning_rate: 0.0100 - gradient_norm: 0.8392 - val_det_loss: 1.5282 - val_cls_loss: 1.0231 - val_box_loss: 0.0101 - val_reg_l2_loss: 0.0635 - val_loss: 1.5917
Epoch 3/50
21/21 [==============================] - 11s 566ms/step - det_loss: 1.4834 - cls_loss: 1.0031 - box_loss: 0.0096 - reg_l2_loss: 0.0635 - loss: 1.5469 - learning_rate: 0.0099 - gradient_norm: 1.4031 - val_det_loss: 1.7022 - val_cls_loss: 1.2259 - val_box_loss: 0.0095 - val_reg_l2_loss: 0.0636 - val_loss: 1.7657
Epoch 4/50
21/21 [==============================] - 11s 541ms/step - det_loss: 1.2898 - cls_loss: 0.8467 - box_loss: 0.0089 - reg_l2_loss: 0.0636 - loss: 1.3534 - learning_rate: 0.0099 - gradient_norm: 1.8163 - val_det_loss: 1.5550 - val_cls_loss: 1.1171 - val_box_loss: 0.0088 - val_reg_l2_loss: 0.0636 - val_loss: 1.6185
Epoch 5/50
21/21 [==============================] - 20s 970ms/step - det_loss: 1.1272 - cls_loss: 0.7315 - box_loss: 0.0079 - reg_l2_loss: 0.0636 - loss: 1.1908 - learning_rate: 0.0098 - gradient_norm: 1.7106 - val_det_loss: 1.4876 - val_cls_loss: 1.0551 - val_box_loss: 0.0087 - val_reg_l2_loss: 0.0636 - val_loss: 1.5512
Epoch 6/50
21/21 [==============================] - 7s 364ms/step - det_loss: 1.0534 - cls_loss: 0.6823 - box_loss: 0.0074 - reg_l2_loss: 0.0636 - loss: 1.1170 - learning_rate: 0.0097 - gradient_norm: 1.8554 - val_det_loss: 1.1807 - val_cls_loss: 0.7640 - val_box_loss: 0.0083 - val_reg_l2_loss: 0.0636 - val_loss: 1.2443
Epoch 7/50
21/21 [==============================] - 12s 602ms/step - det_loss: 1.0153 - cls_loss: 0.6592 - box_loss: 0.0071 - reg_l2_loss: 0.0636 - loss: 1.0789 - learning_rate: 0.0096 - gradient_norm: 1.8227 - val_det_loss: 1.0752 - val_cls_loss: 0.6828 - val_box_loss: 0.0078 - val_reg_l2_loss: 0.0636 - val_loss: 1.1388
Epoch 8/50
21/21 [==============================] - 11s 519ms/step - det_loss: 0.9751 - cls_loss: 0.6304 - box_loss: 0.0069 - reg_l2_loss: 0.0636 - loss: 1.0387 - learning_rate: 0.0094 - gradient_norm: 1.7939 - val_det_loss: 1.0385 - val_cls_loss: 0.6612 - val_box_loss: 0.0075 - val_reg_l2_loss: 0.0636 - val_loss: 1.1021
Epoch 9/50
21/21 [==============================] - 12s 601ms/step - det_loss: 0.8982 - cls_loss: 0.5847 - box_loss: 0.0063 - reg_l2_loss: 0.0636 - loss: 0.9618 - learning_rate: 0.0093 - gradient_norm: 1.8244 - val_det_loss: 1.0142 - val_cls_loss: 0.6526 - val_box_loss: 0.0072 - val_reg_l2_loss: 0.0636 - val_loss: 1.0778
Epoch 10/50
21/21 [==============================] - 14s 691ms/step - det_loss: 0.9462 - cls_loss: 0.5986 - box_loss: 0.0070 - reg_l2_loss: 0.0636 - loss: 1.0098 - learning_rate: 0.0091 - gradient_norm: 1.9298 - val_det_loss: 0.9879 - val_cls_loss: 0.6335 - val_box_loss: 0.0071 - val_reg_l2_loss: 0.0636 - val_loss: 1.0515
Epoch 11/50
21/21 [==============================] - 11s 519ms/step - det_loss: 0.8871 - cls_loss: 0.5824 - box_loss: 0.0061 - reg_l2_loss: 0.0636 - loss: 0.9507 - learning_rate: 0.0089 - gradient_norm: 1.9898 - val_det_loss: 1.0021 - val_cls_loss: 0.6509 - val_box_loss: 0.0070 - val_reg_l2_loss: 0.0636 - val_loss: 1.0658
Epoch 12/50
21/21 [==============================] - 11s 549ms/step - det_loss: 0.8640 - cls_loss: 0.5624 - box_loss: 0.0060 - reg_l2_loss: 0.0636 - loss: 0.9277 - learning_rate: 0.0087 - gradient_norm: 1.9360 - val_det_loss: 1.0265 - val_cls_loss: 0.6728 - val_box_loss: 0.0071 - val_reg_l2_loss: 0.0636 - val_loss: 1.0901
Epoch 13/50
21/21 [==============================] - 11s 523ms/step - det_loss: 0.8405 - cls_loss: 0.5484 - box_loss: 0.0058 - reg_l2_loss: 0.0636 - loss: 0.9042 - learning_rate: 0.0085 - gradient_norm: 2.1855 - val_det_loss: 1.0291 - val_cls_loss: 0.6903 - val_box_loss: 0.0068 - val_reg_l2_loss: 0.0636 - val_loss: 1.0927
Epoch 14/50
21/21 [==============================] - 12s 572ms/step - det_loss: 0.8082 - cls_loss: 0.5297 - box_loss: 0.0056 - reg_l2_loss: 0.0636 - loss: 0.8718 - learning_rate: 0.0082 - gradient_norm: 1.9138 - val_det_loss: 0.9104 - val_cls_loss: 0.5838 - val_box_loss: 0.0065 - val_reg_l2_loss: 0.0636 - val_loss: 0.9740
Epoch 15/50
21/21 [==============================] - 14s 696ms/step - det_loss: 0.8106 - cls_loss: 0.5221 - box_loss: 0.0058 - reg_l2_loss: 0.0636 - loss: 0.8743 - learning_rate: 0.0080 - gradient_norm: 2.0386 - val_det_loss: 0.9510 - val_cls_loss: 0.6047 - val_box_loss: 0.0069 - val_reg_l2_loss: 0.0636 - val_loss: 1.0146
Epoch 16/50
21/21 [==============================] - 10s 474ms/step - det_loss: 0.7988 - cls_loss: 0.5177 - box_loss: 0.0056 - reg_l2_loss: 0.0636 - loss: 0.8624 - learning_rate: 0.0077 - gradient_norm: 2.1009 - val_det_loss: 0.9642 - val_cls_loss: 0.6307 - val_box_loss: 0.0067 - val_reg_l2_loss: 0.0637 - val_loss: 1.0278
Epoch 17/50
21/21 [==============================] - 12s 601ms/step - det_loss: 0.8057 - cls_loss: 0.5239 - box_loss: 0.0056 - reg_l2_loss: 0.0637 - loss: 0.8694 - learning_rate: 0.0075 - gradient_norm: 2.1718 - val_det_loss: 0.9152 - val_cls_loss: 0.5938 - val_box_loss: 0.0064 - val_reg_l2_loss: 0.0637 - val_loss: 0.9789
Epoch 18/50
21/21 [==============================] - 12s 609ms/step - det_loss: 0.7801 - cls_loss: 0.4993 - box_loss: 0.0056 - reg_l2_loss: 0.0637 - loss: 0.8437 - learning_rate: 0.0072 - gradient_norm: 2.1518 - val_det_loss: 0.9262 - val_cls_loss: 0.5967 - val_box_loss: 0.0066 - val_reg_l2_loss: 0.0637 - val_loss: 0.9899
Epoch 19/50
21/21 [==============================] - 12s 614ms/step - det_loss: 0.7595 - cls_loss: 0.4977 - box_loss: 0.0052 - reg_l2_loss: 0.0637 - loss: 0.8232 - learning_rate: 0.0069 - gradient_norm: 2.3707 - val_det_loss: 0.8870 - val_cls_loss: 0.5698 - val_box_loss: 0.0063 - val_reg_l2_loss: 0.0637 - val_loss: 0.9506
Epoch 20/50
21/21 [==============================] - 13s 632ms/step - det_loss: 0.7826 - cls_loss: 0.5115 - box_loss: 0.0054 - reg_l2_loss: 0.0637 - loss: 0.8463 - learning_rate: 0.0066 - gradient_norm: 2.4091 - val_det_loss: 0.8975 - val_cls_loss: 0.5811 - val_box_loss: 0.0063 - val_reg_l2_loss: 0.0637 - val_loss: 0.9611
Epoch 21/50
21/21 [==============================] - 9s 454ms/step - det_loss: 0.7434 - cls_loss: 0.4903 - box_loss: 0.0051 - reg_l2_loss: 0.0637 - loss: 0.8070 - learning_rate: 0.0063 - gradient_norm: 2.3592 - val_det_loss: 0.8526 - val_cls_loss: 0.5450 - val_box_loss: 0.0062 - val_reg_l2_loss: 0.0637 - val_loss: 0.9163
Epoch 22/50
21/21 [==============================] - 12s 600ms/step - det_loss: 0.7349 - cls_loss: 0.4803 - box_loss: 0.0051 - reg_l2_loss: 0.0637 - loss: 0.7986 - learning_rate: 0.0060 - gradient_norm: 2.3296 - val_det_loss: 0.8977 - val_cls_loss: 0.5602 - val_box_loss: 0.0068 - val_reg_l2_loss: 0.0637 - val_loss: 0.9614
Epoch 23/50
21/21 [==============================] - 12s 591ms/step - det_loss: 0.7190 - cls_loss: 0.4670 - box_loss: 0.0050 - reg_l2_loss: 0.0637 - loss: 0.7826 - learning_rate: 0.0056 - gradient_norm: 2.2218 - val_det_loss: 0.8986 - val_cls_loss: 0.5744 - val_box_loss: 0.0065 - val_reg_l2_loss: 0.0637 - val_loss: 0.9623
Epoch 24/50
21/21 [==============================] - 11s 553ms/step - det_loss: 0.7025 - cls_loss: 0.4588 - box_loss: 0.0049 - reg_l2_loss: 0.0637 - loss: 0.7661 - learning_rate: 0.0053 - gradient_norm: 2.4710 - val_det_loss: 0.8835 - val_cls_loss: 0.5701 - val_box_loss: 0.0063 - val_reg_l2_loss: 0.0637 - val_loss: 0.9472
Epoch 25/50
21/21 [==============================] - 14s 700ms/step - det_loss: 0.7462 - cls_loss: 0.4776 - box_loss: 0.0054 - reg_l2_loss: 0.0637 - loss: 0.8099 - learning_rate: 0.0050 - gradient_norm: 2.5728 - val_det_loss: 0.8594 - val_cls_loss: 0.5605 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9231
Epoch 26/50
21/21 [==============================] - 10s 482ms/step - det_loss: 0.7219 - cls_loss: 0.4731 - box_loss: 0.0050 - reg_l2_loss: 0.0637 - loss: 0.7856 - learning_rate: 0.0047 - gradient_norm: 2.4891 - val_det_loss: 0.8701 - val_cls_loss: 0.5630 - val_box_loss: 0.0061 - val_reg_l2_loss: 0.0637 - val_loss: 0.9338
Epoch 27/50
21/21 [==============================] - 11s 543ms/step - det_loss: 0.6914 - cls_loss: 0.4505 - box_loss: 0.0048 - reg_l2_loss: 0.0637 - loss: 0.7551 - learning_rate: 0.0044 - gradient_norm: 2.3125 - val_det_loss: 0.8986 - val_cls_loss: 0.5850 - val_box_loss: 0.0063 - val_reg_l2_loss: 0.0637 - val_loss: 0.9623
Epoch 28/50
21/21 [==============================] - 13s 630ms/step - det_loss: 0.7018 - cls_loss: 0.4516 - box_loss: 0.0050 - reg_l2_loss: 0.0637 - loss: 0.7655 - learning_rate: 0.0040 - gradient_norm: 2.7033 - val_det_loss: 0.8693 - val_cls_loss: 0.5590 - val_box_loss: 0.0062 - val_reg_l2_loss: 0.0637 - val_loss: 0.9330
Epoch 29/50
21/21 [==============================] - 11s 529ms/step - det_loss: 0.6712 - cls_loss: 0.4463 - box_loss: 0.0045 - reg_l2_loss: 0.0637 - loss: 0.7349 - learning_rate: 0.0037 - gradient_norm: 2.3739 - val_det_loss: 0.8901 - val_cls_loss: 0.5790 - val_box_loss: 0.0062 - val_reg_l2_loss: 0.0637 - val_loss: 0.9538
Epoch 30/50
21/21 [==============================] - 15s 735ms/step - det_loss: 0.6619 - cls_loss: 0.4346 - box_loss: 0.0045 - reg_l2_loss: 0.0637 - loss: 0.7256 - learning_rate: 0.0034 - gradient_norm: 2.3940 - val_det_loss: 0.8855 - val_cls_loss: 0.5565 - val_box_loss: 0.0066 - val_reg_l2_loss: 0.0637 - val_loss: 0.9492
Epoch 31/50
21/21 [==============================] - 10s 499ms/step - det_loss: 0.6752 - cls_loss: 0.4406 - box_loss: 0.0047 - reg_l2_loss: 0.0637 - loss: 0.7389 - learning_rate: 0.0031 - gradient_norm: 2.6153 - val_det_loss: 0.8728 - val_cls_loss: 0.5536 - val_box_loss: 0.0064 - val_reg_l2_loss: 0.0637 - val_loss: 0.9365
Epoch 32/50
21/21 [==============================] - 11s 547ms/step - det_loss: 0.6605 - cls_loss: 0.4393 - box_loss: 0.0044 - reg_l2_loss: 0.0637 - loss: 0.7242 - learning_rate: 0.0028 - gradient_norm: 2.2926 - val_det_loss: 0.8503 - val_cls_loss: 0.5434 - val_box_loss: 0.0061 - val_reg_l2_loss: 0.0637 - val_loss: 0.9140
Epoch 33/50
21/21 [==============================] - 12s 573ms/step - det_loss: 0.6700 - cls_loss: 0.4388 - box_loss: 0.0046 - reg_l2_loss: 0.0637 - loss: 0.7337 - learning_rate: 0.0025 - gradient_norm: 2.4563 - val_det_loss: 0.8520 - val_cls_loss: 0.5442 - val_box_loss: 0.0062 - val_reg_l2_loss: 0.0637 - val_loss: 0.9157
Epoch 34/50
21/21 [==============================] - 12s 596ms/step - det_loss: 0.6754 - cls_loss: 0.4314 - box_loss: 0.0049 - reg_l2_loss: 0.0637 - loss: 0.7391 - learning_rate: 0.0023 - gradient_norm: 2.5527 - val_det_loss: 0.8223 - val_cls_loss: 0.5216 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.8860
Epoch 35/50
21/21 [==============================] - 13s 623ms/step - det_loss: 0.6499 - cls_loss: 0.4243 - box_loss: 0.0045 - reg_l2_loss: 0.0637 - loss: 0.7136 - learning_rate: 0.0020 - gradient_norm: 2.3485 - val_det_loss: 0.8405 - val_cls_loss: 0.5408 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9042
Epoch 36/50
21/21 [==============================] - 12s 574ms/step - det_loss: 0.6290 - cls_loss: 0.4186 - box_loss: 0.0042 - reg_l2_loss: 0.0637 - loss: 0.6927 - learning_rate: 0.0018 - gradient_norm: 2.3488 - val_det_loss: 0.8436 - val_cls_loss: 0.5452 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9073
Epoch 37/50
21/21 [==============================] - 13s 631ms/step - det_loss: 0.6446 - cls_loss: 0.4157 - box_loss: 0.0046 - reg_l2_loss: 0.0637 - loss: 0.7083 - learning_rate: 0.0015 - gradient_norm: 2.3455 - val_det_loss: 0.8361 - val_cls_loss: 0.5410 - val_box_loss: 0.0059 - val_reg_l2_loss: 0.0637 - val_loss: 0.8998
Epoch 38/50
21/21 [==============================] - 12s 595ms/step - det_loss: 0.6640 - cls_loss: 0.4317 - box_loss: 0.0046 - reg_l2_loss: 0.0637 - loss: 0.7277 - learning_rate: 0.0013 - gradient_norm: 2.5982 - val_det_loss: 0.8390 - val_cls_loss: 0.5402 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9027
Epoch 39/50
21/21 [==============================] - 13s 623ms/step - det_loss: 0.6280 - cls_loss: 0.4117 - box_loss: 0.0043 - reg_l2_loss: 0.0637 - loss: 0.6916 - learning_rate: 0.0011 - gradient_norm: 2.3441 - val_det_loss: 0.8396 - val_cls_loss: 0.5415 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9033
Epoch 40/50
21/21 [==============================] - 15s 721ms/step - det_loss: 0.6398 - cls_loss: 0.4240 - box_loss: 0.0043 - reg_l2_loss: 0.0637 - loss: 0.7035 - learning_rate: 9.0029e-04 - gradient_norm: 2.6224 - val_det_loss: 0.8326 - val_cls_loss: 0.5328 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.8963
Epoch 41/50
21/21 [==============================] - 10s 484ms/step - det_loss: 0.6361 - cls_loss: 0.4179 - box_loss: 0.0044 - reg_l2_loss: 0.0637 - loss: 0.6998 - learning_rate: 7.2543e-04 - gradient_norm: 2.4665 - val_det_loss: 0.8264 - val_cls_loss: 0.5282 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.8901
Epoch 42/50
21/21 [==============================] - 13s 654ms/step - det_loss: 0.6565 - cls_loss: 0.4141 - box_loss: 0.0048 - reg_l2_loss: 0.0637 - loss: 0.7202 - learning_rate: 5.6814e-04 - gradient_norm: 2.5693 - val_det_loss: 0.8190 - val_cls_loss: 0.5205 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.8827
Epoch 43/50
21/21 [==============================] - 12s 577ms/step - det_loss: 0.6390 - cls_loss: 0.4156 - box_loss: 0.0045 - reg_l2_loss: 0.0637 - loss: 0.7027 - learning_rate: 4.2906e-04 - gradient_norm: 2.6238 - val_det_loss: 0.8214 - val_cls_loss: 0.5218 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.8851
Epoch 44/50
21/21 [==============================] - 11s 543ms/step - det_loss: 0.6325 - cls_loss: 0.4210 - box_loss: 0.0042 - reg_l2_loss: 0.0637 - loss: 0.6962 - learning_rate: 3.0876e-04 - gradient_norm: 2.5348 - val_det_loss: 0.8233 - val_cls_loss: 0.5214 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.8870
Epoch 45/50
21/21 [==============================] - 14s 712ms/step - det_loss: 0.6318 - cls_loss: 0.4115 - box_loss: 0.0044 - reg_l2_loss: 0.0637 - loss: 0.6955 - learning_rate: 2.0774e-04 - gradient_norm: 2.3124 - val_det_loss: 0.8264 - val_cls_loss: 0.5243 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.8901
Epoch 46/50
21/21 [==============================] - 11s 518ms/step - det_loss: 0.6508 - cls_loss: 0.4240 - box_loss: 0.0045 - reg_l2_loss: 0.0637 - loss: 0.7145 - learning_rate: 1.2641e-04 - gradient_norm: 2.5532 - val_det_loss: 0.8275 - val_cls_loss: 0.5252 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.8912
Epoch 47/50
21/21 [==============================] - 13s 630ms/step - det_loss: 0.6284 - cls_loss: 0.4146 - box_loss: 0.0043 - reg_l2_loss: 0.0637 - loss: 0.6921 - learning_rate: 6.5107e-05 - gradient_norm: 2.5420 - val_det_loss: 0.8269 - val_cls_loss: 0.5248 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.8906
Epoch 48/50
21/21 [==============================] - 11s 539ms/step - det_loss: 0.6273 - cls_loss: 0.4124 - box_loss: 0.0043 - reg_l2_loss: 0.0637 - loss: 0.6910 - learning_rate: 2.4083e-05 - gradient_norm: 2.4386 - val_det_loss: 0.8249 - val_cls_loss: 0.5233 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.8886
Epoch 49/50
21/21 [==============================] - 13s 627ms/step - det_loss: 0.6412 - cls_loss: 0.4040 - box_loss: 0.0047 - reg_l2_loss: 0.0637 - loss: 0.7049 - learning_rate: 3.5074e-06 - gradient_norm: 2.4736 - val_det_loss: 0.8231 - val_cls_loss: 0.5223 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.8868
Epoch 50/50
21/21 [==============================] - 15s 721ms/step - det_loss: 0.6425 - cls_loss: 0.4205 - box_loss: 0.0044 - reg_l2_loss: 0.0637 - loss: 0.7062 - learning_rate: 3.4629e-06 - gradient_norm: 2.4394 - val_det_loss: 0.8218 - val_cls_loss: 0.5215 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.8855

ขั้นตอนที่ 4 ประเมินแบบจำลองด้วยข้อมูลการทดสอบ

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

เนื่องจากขนาดแบทช์เริ่มต้นคือ 64 จะใช้เวลา 1 ขั้นตอนในการดำเนินการกับรูปภาพ 25 รูปในชุดข้อมูลทดสอบ

ตัวชี้วัดการประเมินผลเช่นเดียวกับ COCO

model.evaluate(test_data)
1/1 [==============================] - 7s 7s/step
{'AP': 0.23457745,
 'AP50': 0.38357082,
 'AP75': 0.25038385,
 'APs': -1.0,
 'APm': 0.43640736,
 'APl': 0.234312,
 'ARmax1': 0.1664717,
 'ARmax10': 0.33019942,
 'ARmax100': 0.37375557,
 'ARs': -1.0,
 'ARm': 0.5416667,
 'ARl': 0.37200606,
 'AP_/Baked Goods': 0.07057314,
 'AP_/Salad': 0.53682375,
 'AP_/Cheese': 0.20270571,
 'AP_/Seafood': 0.08837805,
 'AP_/Tomato': 0.2744066}

ขั้นตอนที่ 5. ส่งออกเป็นโมเดล TensorFlow Lite

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

model.export(export_dir='.')
2021-12-02 12:28:49.181926: W tensorflow/python/util/util.cc:368] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
2021-12-02 12:29:09.650356: W tensorflow/core/common_runtime/graph_constructor.cc:803] Node 'resample_p7/PartitionedCall' has 1 outputs but the _output_shapes attribute specifies shapes for 3 outputs. Output shapes may be inaccurate.
2021-12-02 12:29:20.773150: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:363] Ignored output_format.
2021-12-02 12:29:20.773204: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:366] Ignored drop_control_dependency.
2021-12-02 12:29:20.773213: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:372] Ignored change_concat_input_ranges.
fully_quantize: 0, inference_type: 6, input_inference_type: 3, output_inference_type: 0

ขั้นตอนที่ 6 ประเมินโมเดล TensorFlow Lite

มีหลายปัจจัยที่อาจส่งผลต่อความถูกต้องของแบบจำลองเมื่อส่งออกไปยัง TFLite:

  • ควอน ช่วยการหดตัวขนาดรูปแบบโดย 4 ครั้งที่ค่าใช้จ่ายของการลดลงของความถูกต้อง
  • เดิมใช้รูปแบบ TensorFlow ต่อชั้น ไม่ใช่สูงสุดปราบปราม (NMS) สำหรับการโพสต์ในขณะที่รุ่น TFLite ใช้ NMS โลกที่เร็วขึ้นมาก แต่มีความแม่นยำน้อย Keras ส่งออกการตรวจจับสูงสุด 100 รายการ ในขณะที่ tflite ส่งออกการตรวจจับสูงสุด 25 รายการ

ดังนั้น คุณจะต้องประเมินโมเดล TFLite ที่ส่งออกและเปรียบเทียบความถูกต้องกับโมเดล TensorFlow ดั้งเดิม

model.evaluate_tflite('model.tflite', test_data)
25/25 [==============================] - 60s 2s/step
{'AP': 0.22160971,
 'AP50': 0.36216733,
 'AP75': 0.24560829,
 'APs': -1.0,
 'APm': 0.52389216,
 'APl': 0.21991307,
 'ARmax1': 0.16296011,
 'ARmax10': 0.2850546,
 'ARmax100': 0.29889038,
 'ARs': -1.0,
 'ARm': 0.6166667,
 'ARl': 0.29492828,
 'AP_/Baked Goods': 0.06930693,
 'AP_/Salad': 0.5064266,
 'AP_/Cheese': 0.1904948,
 'AP_/Seafood': 0.074257426,
 'AP_/Tomato': 0.26756287}

คุณสามารถดาวน์โหลดไฟล์รุ่น TensorFlow Lite ได้โดยใช้แถบด้านข้างทางซ้ายของ Colab คลิกขวาบน model.tflite ไฟล์และเลือก Download เพื่อดาวน์โหลดไปยังเครื่องคอมพิวเตอร์ของคุณ

รุ่นนี้สามารถรวมเข้ากับ Android หรือ iOS ของแอปโดยใช้ API ObjectDetector ของ Lite ห้องสมุด TensorFlow งาน

ดู TFLite วัตถุแอปตัวอย่างการตรวจสอบ รายละเอียดเพิ่มเติมเกี่ยวกับวิธีการรูปแบบที่ใช้ในแอปทำงาน

(ไม่บังคับ) ทดสอบโมเดล TFLite บนรูปภาพของคุณ

คุณสามารถทดสอบโมเดล TFLite ที่ผ่านการฝึกอบรมโดยใช้รูปภาพจากอินเทอร์เน็ต

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

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

โหลดโมเดล TFLite ที่ผ่านการฝึกอบรมและกำหนดฟังก์ชันการแสดงภาพบางส่วน

เรียกใช้การตรวจจับวัตถุและแสดงผลการตรวจจับ

png

(ไม่บังคับ) คอมไพล์สำหรับ Edge TPU

ตอนนี้คุณมี quantized รุ่น EfficientDet Lite ก็เป็นไปได้ที่จะรวบรวมและปรับใช้กับ ปะการัง EdgeTPU

ขั้นตอนที่ 1. ติดตั้ง EdgeTPU Compiler

 curl https://packages.cloud.google.com/apt/doc/apt-key.gpg | sudo apt-key add -

 echo "deb https://packages.cloud.google.com/apt coral-edgetpu-stable main" | sudo tee /etc/apt/sources.list.d/coral-edgetpu.list

 sudo apt-get update

 sudo apt-get install edgetpu-compiler
% Total    % Received % Xferd  Average Speed   Time    Time     Time  Current
                                 Dload  Upload   Total   Spent    Left  Speed
100  2537  100  2537    0     0   130k      0 --:--:-- --:--:-- --:--:--  130k
OK
deb https://packages.cloud.google.com/apt coral-edgetpu-stable main
Hit:1 http://asia-east1.gce.archive.ubuntu.com/ubuntu bionic InRelease
Hit:2 http://asia-east1.gce.archive.ubuntu.com/ubuntu bionic-updates InRelease
Hit:3 http://asia-east1.gce.archive.ubuntu.com/ubuntu bionic-backports InRelease
Hit:4 https://nvidia.github.io/libnvidia-container/stable/ubuntu18.04/amd64  InRelease
Get:5 https://nvidia.github.io/nvidia-container-runtime/ubuntu18.04/amd64  InRelease [1481 B]
Get:6 https://nvidia.github.io/nvidia-docker/ubuntu18.04/amd64  InRelease [1474 B]
Ign:7 http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64  InRelease
Hit:8 http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64  Release
Get:9 http://packages.cloud.google.com/apt google-cloud-logging-wheezy InRelease [5483 B]
Hit:10 http://archive.canonical.com/ubuntu bionic InRelease
Hit:11 http://security.ubuntu.com/ubuntu bionic-security InRelease
Get:13 https://packages.cloud.google.com/apt coral-edgetpu-stable InRelease [6722 B]
Get:14 https://packages.cloud.google.com/apt eip-cloud-bionic InRelease [5419 B]
Ign:15 https://packages.cloud.google.com/apt coral-edgetpu-stable/main amd64 Packages
Get:15 https://packages.cloud.google.com/apt coral-edgetpu-stable/main amd64 Packages [2327 B]
Fetched 22.9 kB in 1s (18.7 kB/s)




The following packages were automatically installed and are no longer required:
  linux-gcp-5.4-headers-5.4.0-1040 linux-gcp-5.4-headers-5.4.0-1043
  linux-gcp-5.4-headers-5.4.0-1044 linux-gcp-5.4-headers-5.4.0-1049
  linux-headers-5.4.0-1049-gcp linux-image-5.4.0-1049-gcp
  linux-modules-5.4.0-1044-gcp linux-modules-5.4.0-1049-gcp
  linux-modules-extra-5.4.0-1049-gcp
Use 'sudo apt autoremove' to remove them.
The following NEW packages will be installed:
  edgetpu-compiler
0 upgraded, 1 newly installed, 0 to remove and 119 not upgraded.
Need to get 7913 kB of archives.
After this operation, 31.2 MB of additional disk space will be used.
Get:1 https://packages.cloud.google.com/apt coral-edgetpu-stable/main amd64 edgetpu-compiler amd64 16.0 [7913 kB]
Fetched 7913 kB in 1s (11.2 MB/s)
Selecting previously unselected package edgetpu-compiler.
(Reading database ... 283192 files and directories currently installed.)
Preparing to unpack .../edgetpu-compiler_16.0_amd64.deb ...
Unpacking edgetpu-compiler (16.0) ...
Setting up edgetpu-compiler (16.0) ...
Processing triggers for libc-bin (2.27-3ubuntu1.2) ...

ขั้นตอนที่ 2 เลือกจำนวน Edge TPU, คอมไพล์

EdgeTPU มี 8MB ของ SRAM สำหรับแคช PARAMATERS รุ่น ( ข้อมูลเพิ่มเติม ) ซึ่งหมายความว่าสำหรับโมเดลที่มีขนาดใหญ่กว่า 8MB เวลาในการอนุมานจะเพิ่มขึ้นเพื่อถ่ายโอนผ่านพารามิเตอร์ของโมเดล วิธีหนึ่งที่จะหลีกเลี่ยงปัญหานี้เป็น รุ่น Pipelining - แยกรูปแบบเป็นกลุ่มที่สามารถมี EdgeTPU ทุ่มเท สิ่งนี้สามารถปรับปรุงเวลาแฝงได้อย่างมาก

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

สถาปัตยกรรมจำลอง TPU ขั้นต่ำ TPU ที่แนะนำ
EfficientDet-Lite0 1 1
EfficientDet-Lite1 1 1
EfficientDet-Lite2 1 2
EfficientDet-Lite3 2 2
EfficientDet-Lite4 2 3

Edge TPU Compiler version 16.0.384591198
Started a compilation timeout timer of 180 seconds.

Model compiled successfully in 4410 ms.

Input model: model.tflite
Input size: 4.24MiB
Output model: model_edgetpu.tflite
Output size: 5.61MiB
On-chip memory used for caching model parameters: 4.24MiB
On-chip memory remaining for caching model parameters: 3.27MiB
Off-chip memory used for streaming uncached model parameters: 0.00B
Number of Edge TPU subgraphs: 1
Total number of operations: 267
Operation log: model_edgetpu.log

Model successfully compiled but not all operations are supported by the Edge TPU. A percentage of the model will instead run on the CPU, which is slower. If possible, consider updating your model to use only operations supported by the Edge TPU. For details, visit g.co/coral/model-reqs.
Number of operations that will run on Edge TPU: 264
Number of operations that will run on CPU: 3
See the operation log file for individual operation details.
Compilation child process completed within timeout period.
Compilation succeeded!

ขั้นตอนที่ 3 ดาวน์โหลด เรียกใช้ Model

ด้วยโมเดลที่คอมไพล์แล้ว ตอนนี้โมเดลเหล่านี้สามารถรันบน EdgeTPU สำหรับการตรวจจับอ็อบเจกต์ได้ ขั้นแรก ดาวน์โหลดไฟล์โมเดล TensorFlow Lite ที่คอมไพล์แล้วโดยใช้แถบด้านข้างทางซ้ายของ Colab คลิกขวาบน model_edgetpu.tflite ไฟล์และเลือก Download เพื่อดาวน์โหลดไปยังเครื่องคอมพิวเตอร์ของคุณ

ตอนนี้คุณสามารถเรียกใช้โมเดลในลักษณะที่คุณต้องการได้ ตัวอย่างของการตรวจจับ ได้แก่:

การใช้งานขั้นสูง

ส่วนนี้ครอบคลุมหัวข้อการใช้งานขั้นสูง เช่น การปรับโมเดลและไฮเปอร์พารามิเตอร์การฝึก

โหลดชุดข้อมูล

โหลดข้อมูลของคุณเอง

คุณสามารถอัปโหลดชุดข้อมูลของคุณเองเพื่อใช้ในบทช่วยสอนนี้ได้ อัปโหลดชุดข้อมูลของคุณโดยใช้แถบด้านข้างทางซ้ายใน Colab

อัพโหลดไฟล์

หากคุณไม่ต้องการที่จะอัปโหลดชุดข้อมูลของคุณไปยังเมฆคุณยังสามารถเรียกใช้ภายในห้องสมุดโดยทำตาม คำแนะนำ

โหลดข้อมูลของคุณด้วยรูปแบบข้อมูลอื่น

ห้องสมุดชงรุ่นยังสนับสนุน object_detector.DataLoader.from_pascal_voc วิธีการในการโหลดข้อมูลกับ VOC PASCAL รูปแบบ makesense.ai และ LabelImg เป็นเครื่องมือที่สามารถใส่คำอธิบายประกอบภาพและบันทึกคำอธิบายประกอบเป็นไฟล์ XML ในรูปแบบข้อมูล VOC ปาสคาล:

object_detector.DataLoader.from_pascal_voc(image_dir, annotations_dir, label_map={1: "person", 2: "notperson"})

ปรับแต่งไฮเปอร์พารามิเตอร์โมเดล EfficientDet

พารามิเตอร์ pipline ของแบบจำลองและการฝึกอบรมที่คุณสามารถปรับเปลี่ยนได้คือ:

  • model_dir : สถานที่ที่จะบันทึกไฟล์รูปแบบด่าน หากไม่ได้ตั้งค่าไว้ ระบบจะใช้ไดเร็กทอรีชั่วคราว
  • steps_per_execution : จำนวนขั้นตอนการดำเนินการต่อการฝึกอบรม
  • moving_average_decay : โฟลต การสลายตัวเพื่อใช้ในการรักษาค่าเฉลี่ยเคลื่อนที่ของพารามิเตอร์ที่ได้รับการฝึกอบรม
  • var_freeze_expr : การแสดงออกปกติเพื่อ map คำนำหน้าชื่อของตัวแปรที่จะแช่แข็งซึ่งหมายความว่าเหลือเดียวกันระหว่างการฝึกอบรม เฉพาะเจาะจงมากขึ้นใช้ re.match(var_freeze_expr, variable_name) ใน codebase เพื่อแมตัวแปรที่จะแช่แข็ง
  • tflite_max_detections : จำนวนเต็ม 25 โดยค่าเริ่มต้น จำนวนสูงสุดของการตรวจจับเอาต์พุตในรุ่น TFLite
  • strategy : สตริงที่ระบุซึ่งกระจายกลยุทธ์ในการใช้งาน ค่าที่ยอมรับคือ 'tpu', 'gpus', None tpu' หมายถึงการใช้ TPUStrategy 'gpus' หมายถึงการใช้ MirroredStrategy สำหรับ multi-gpus หากไม่มี ให้ใช้ค่าเริ่มต้น TF กับ OneDeviceStrategy
  • tpu : เมฆ TPU ที่จะใช้สำหรับการฝึกอบรม ซึ่งควรเป็นชื่อที่ใช้ในการสร้าง Cloud TPU หรือ URL grpc://ip.address.of.tpu:8470
  • use_xla : ใช้ XLA แม้ว่ากลยุทธ์ไม่ TPU หากกลยุทธ์คือ tpu ให้ใช้ XLA เสมอ และแฟล็กนี้ไม่มีผล
  • profile : เปิดใช้งานโหมดรายละเอียด
  • debug : เปิดใช้งานโหมดการแก้ปัญหา

พารามิเตอร์อื่น ๆ ที่สามารถปรับได้จะแสดงใน hparams_config.py

ตัวอย่างเช่นคุณสามารถตั้งค่า var_freeze_expr='efficientnet' ซึ่งค้างตัวแปรที่มีคำนำหน้าชื่อ efficientnet (ค่าปกติคือ '(efficientnet|fpn_cells|resample_p6)' ) ซึ่งช่วยให้โมเดลสามารถตรึงตัวแปรที่ไม่สามารถฝึกได้และรักษาค่าไว้เหมือนเดิมผ่านการฝึกอบรม

spec = model_spec.get('efficientdet_lite0')
spec.config.var_freeze_expr = 'efficientnet'

เปลี่ยนรูปแบบสถาปัตยกรรม

คุณสามารถเปลี่ยนรูปแบบสถาปัตยกรรมโดยการเปลี่ยน model_spec ยกตัวอย่างเช่นเปลี่ยน model_spec กับรูปแบบ EfficientDet-Lite4

spec = model_spec.get('efficientdet_lite4')

ปรับไฮเปอร์พารามิเตอร์การฝึกอบรม

create ฟังก์ชั่นการทำงานของโปรแกรมควบคุมที่รุ่นใช้ห้องสมุด Maker เพื่อสร้างแบบจำลอง model_spec พารามิเตอร์กำหนดสเปครุ่น object_detector.EfficientDetSpec ระดับปัจจุบันสนับสนุน create ประกอบด้วยฟังก์ชั่นขั้นตอนต่อไปนี้:

  1. สร้างแบบจำลองสำหรับการตรวจจับวัตถุตาม model_spec
  2. ฝึกโมเดล. epochs เริ่มต้นและขนาดชุดเริ่มต้นจะถูกกำหนดโดย epochs และ batch_size ตัวแปรใน model_spec วัตถุ นอกจากนี้คุณยังสามารถปรับแต่ง hyperparameters การฝึกอบรมเช่น epochs และ batch_size ที่มีผลต่อความถูกต้องของรูปแบบ ตัวอย่างเช่น
  • epochs : จำนวนเต็ม 50 โดยค่าเริ่มต้น ยุคที่มากขึ้นสามารถบรรลุความแม่นยำที่ดีขึ้น แต่อาจนำไปสู่การเกินพอดี
  • batch_size : จำนวนเต็ม 64 โดยค่าเริ่มต้น จำนวนตัวอย่างที่จะใช้ในขั้นตอนการฝึกอบรมเดียว
  • train_whole_model : บูลีนเท็จโดยค่าเริ่มต้น ถ้าจริง ฝึกทั้งโมเดล มิฉะนั้นเพียงรถไฟชั้นที่ไม่ตรงกับ var_freeze_expr

ตัวอย่างเช่น คุณสามารถฝึกโดยใช้เวลาน้อยลงและมีเพียงเลเยอร์ส่วนหัวเท่านั้น คุณสามารถเพิ่มจำนวนยุคเพื่อผลลัพธ์ที่ดีขึ้นได้

model = object_detector.create(train_data, model_spec=spec, epochs=10, validation_data=validation_data)

ส่งออกเป็นรูปแบบต่างๆ

รูปแบบการส่งออกสามารถเป็นหนึ่งหรือรายการต่อไปนี้:

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

ในแอปพลิเคชัน ML บนอุปกรณ์จำนวนมาก ขนาดโมเดลเป็นปัจจัยสำคัญ ดังนั้น ขอแนะนำให้คุณวัดปริมาณแบบจำลองเพื่อทำให้มีขนาดเล็กลงและอาจทำงานได้เร็วขึ้น สำหรับโมเดล EfficientDet-Lite การหาจำนวนเต็มจำนวนเต็มจะใช้เพื่อกำหนดปริมาณโมเดลตามค่าเริ่มต้น โปรดดูที่ ควอนโพสต์การฝึกอบรม สำหรับรายละเอียดเพิ่มเติม

model.export(export_dir='.')

คุณยังสามารถเลือกที่จะส่งออกไฟล์อื่นๆ ที่เกี่ยวข้องกับโมเดลเพื่อการตรวจสอบที่ดียิ่งขึ้น ตัวอย่างเช่น การส่งออกทั้งโมเดลที่บันทึกไว้และไฟล์เลเบลดังนี้:

model.export(export_dir='.', export_format=[ExportFormat.SAVED_MODEL, ExportFormat.LABEL])

ปรับแต่งการหาปริมาณหลังการฝึกในรุ่น TensorFlow Lite

โพสต์การฝึกอบรม quantization เป็นเทคนิคการแปลงที่สามารถลดขนาดรูปแบบและแฝงอนุมานในขณะที่ยังมีการปรับปรุงความเร็วของ CPU และการเร่งความเร็วฮาร์ดแวร์อนุมานกับการย่อยสลายเล็ก ๆ น้อย ๆ ในความถูกต้องรูปแบบ ดังนั้นจึงใช้กันอย่างแพร่หลายในการปรับโมเดลให้เหมาะสม

ไลบรารี Model Maker จะใช้เทคนิคการวัดค่าหลังการฝึกเริ่มต้นเมื่อส่งออกโมเดล หากคุณต้องการที่จะปรับแต่งควอนโพสต์การฝึกอบรมรุ่นชงสนับสนุนตัวเลือกการโพสต์การฝึกอบรม quantization ต่างๆโดยใช้ QuantizationConfig เช่นกัน ลองใช้การควอนไทซ์ float16 เป็นตัวอย่าง ขั้นแรก กำหนดการกำหนดค่า quantization

config = QuantizationConfig.for_float16()

จากนั้นเราจะส่งออกโมเดล TensorFlow Lite ด้วยการกำหนดค่าดังกล่าว

model.export(export_dir='.', tflite_filename='model_fp16.tflite', quantization_config=config)

อ่านเพิ่มเติม

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