TensorFlow Lite Model Maker를 사용한 객체 감지

TensorFlow.org에서 보기 Google Colab에서 실행 GitHub에서 소스 보기 노트북 다운로드

이 colab 노트북에서는 사용하는 방법을 학습합니다 TensorFlow 라이트 모델 메이커의 모바일 장치에서 이미지 내에서 샐러드를 감지 할 수있는 사용자 지정 개체 탐지 모델을 학습하는 라이브러리를.

모델 메이커 라이브러리를 사용하는 사용자 정의 데이터 집합을 사용하여 TensorFlow 라이트 모델을 훈련하는 과정을 단순화하기 위해 학습 전송합니다. 고유한 사용자 지정 데이터 세트로 TensorFlow Lite 모델을 재훈련하면 필요한 훈련 데이터의 양이 줄어들고 훈련 시간이 단축됩니다.

당신은에서 생성 된 공개 샐러드 데이터 세트, 사용합니다 열기 이미지 데이터 집합 V4를 .

데이터세트의 각 이미지에는 다음 클래스 중 하나로 레이블이 지정된 개체가 포함되어 있습니다.

  • 구운 음식
  • 치즈
  • 샐러드
  • 해물
  • 토마토

데이터세트에는 개체의 레이블과 함께 각 개체의 위치를 ​​지정하는 경계 상자가 포함되어 있습니다.

다음은 데이터세트의 예시 이미지입니다.


전제 조건

필요한 패키지 설치

로부터 모델 메이커 패키지를 포함하여 필요한 패키지 설치하여 시작 GitHub의의의 repo 및 평가를 위해 사용하는거야 pycocotools 라이브러리를.

pip install -q tensorflow==2.5.0
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 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)
2021-08-23 11:11:53.911046: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/numba/core/errors.py:168: UserWarning: Insufficiently recent colorama version found. Numba requires colorama >= 0.3.9
  warnings.warn(msg)
<span class="ansired">---------------------------------------------------------------------------</span>

<span class="ansired">RuntimeError</span>                              Traceback (most recent call last)

<span class="ansired">RuntimeError</span>: module compiled against API version 0xe but this version of numpy is 0xd

데이터세트 준비

여기에서 AutoML의 같은 데이터 세트를 사용합니다 빠른 시작 .

:에서 확인할 수있다 데이터 세트 샐러드 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 클라우드를 처음 사용하는 경우, 당신은 무엇을 궁금해 할 gs:// URL 수단. 그들은에 저장된 파일의 URL에있는 Google 클라우드 스토리지 (GCS). 당신은 GCS 공개에 파일을 만들거나 경우 클라이언트를 인증 , 모델 메이커 마찬가지로 로컬 파일에 해당 파일을 읽을 수 있습니다.

그러나 Model Maker를 사용하기 위해 GCP에 이미지를 보관할 필요는 없습니다. CSV 파일에서 로컬 경로를 사용할 수 있으며 Model Maker는 바로 작동합니다.

빠른 시작

객체 감지 모델을 학습시키는 6단계는 다음과 같습니다.

1단계. 객체 감지 모델 아키텍처를 선택합니다.

이 튜토리얼은 EfficientDet-Lite0 모델을 사용합니다. EfficientDet 라이트 [0-4]을에서 파생 된 모바일 / 만약 IoT 친화적 인 물체 감지 모델의 가족 EfficientDet의 아키텍처.

다음은 각 EfficientDet-Lite 모델의 성능을 서로 비교한 것입니다.

모델 아키텍처 크기(MB)* 지연 시간(ms)** 평균 정밀도***
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%

* 정수 양자화 모델의 크기.
** 지연 시간은 CPU에서 4개의 스레드를 사용하여 Pixel 4에서 측정되었습니다.
*** 평균 정밀도는 COCO 2017 검증 데이터 세트의 mAP(평균 평균 정밀도)입니다.

spec = model_spec.get('efficientdet_lite0')
2021-08-23 11:11:57.988938: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcuda.so.1
2021-08-23 11:11:59.422877: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-23 11:11:59.423892: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1733] Found device 0 with properties: 
pciBusID: 0000:00:05.0 name: Tesla V100-SXM2-16GB computeCapability: 7.0
coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s
2021-08-23 11:11:59.423944: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0
2021-08-23 11:12:01.129910: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublas.so.11
2021-08-23 11:12:01.130052: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublasLt.so.11
2021-08-23 11:12:02.236581: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcufft.so.10
2021-08-23 11:12:02.697693: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcurand.so.10
2021-08-23 11:12:05.042619: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcusolver.so.11
2021-08-23 11:12:06.392340: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcusparse.so.11
2021-08-23 11:12:06.395250: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudnn.so.8
2021-08-23 11:12:06.395450: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-23 11:12:06.396486: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-23 11:12:06.397339: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1871] Adding visible gpu devices: 0
2021-08-23 11:12:06.398424: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F FMA
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
2021-08-23 11:12:06.398989: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-23 11:12:06.399925: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1733] Found device 0 with properties: 
pciBusID: 0000:00:05.0 name: Tesla V100-SXM2-16GB computeCapability: 7.0
coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s
2021-08-23 11:12:06.400039: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-23 11:12:06.400943: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-23 11:12:06.401816: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1871] Adding visible gpu devices: 0
2021-08-23 11:12:06.401901: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudart.so.11.0
2021-08-23 11:12:07.016833: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1258] Device interconnect StreamExecutor with strength 1 edge matrix:
2021-08-23 11:12:07.016871: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1264]      0 
2021-08-23 11:12:07.016880: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1277] 0:   N 
2021-08-23 11:12:07.017125: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-23 11:12:07.018139: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-23 11:12:07.019289: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-23 11:12:07.020206: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1418] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 14646 MB memory) -> physical GPU (device: 0, name: Tesla V100-SXM2-16GB, pci bus id: 0000:00:05.0, compute capability: 7.0)

2단계. 데이터세트를 로드합니다.

Model Maker는 CSV 형식의 입력 데이터를 가져옵니다. 사용 object_detector.DataLoader.from_csv 데이터 집합을로드하고 교육, 검증 및 테스트 이미지로 분할하는 방법을.

  • 훈련 이미지: 이 이미지는 샐러드 재료를 인식하도록 객체 감지 모델을 훈련하는 데 사용됩니다.
  • 검증 이미지: 학습 과정에서 모델이 보지 못한 이미지입니다. 당신이 피하기 위해, 훈련을 중지해야 할 때를 결정하는 데 사용할 수 있습니다 overfitting .
  • 테스트 이미지: 이 이미지는 최종 모델 성능을 평가하는 데 사용됩니다.

Google Cloud Storage에서 직접 CSV 파일을 로드할 수 있지만 Model Maker를 사용하기 위해 Google Cloud에 이미지를 보관할 필요는 없습니다. 컴퓨터에서 로컬 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 여기 그래서 당신은 훈련 데이터 세트에서 175 개 이미지를 이동하는 21 단계를 수행 것을 볼 수 있습니다.
  • 설정 train_whole_model=True 단지의 정확성을 향상시키기 위해 머리 층을 훈련 대신 미세 조정으로 전체 모델. 단점은 모델을 훈련하는 데 시간이 더 오래 걸릴 수 있다는 것입니다.
model = object_detector.create(train_data, model_spec=spec, batch_size=8, train_whole_model=True, validation_data=validation_data)
2021-08-23 11:17:35.980903: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:176] None of the MLIR Optimization Passes are enabled (registered 2)
2021-08-23 11:17:35.996598: I tensorflow/core/platform/profile_utils/cpu_utils.cc:114] CPU Frequency: 2000170000 Hz
Epoch 1/50
2021-08-23 11:18:01.076012: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcudnn.so.8
2021-08-23 11:18:04.598759: I tensorflow/stream_executor/cuda/cuda_dnn.cc:359] Loaded cuDNN version 8100
2021-08-23 11:18:10.208403: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublas.so.11
2021-08-23 11:18:10.555085: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libcublasLt.so.11
21/21 [==============================] - 47s 560ms/step - det_loss: 1.7498 - cls_loss: 1.1207 - box_loss: 0.0126 - reg_l2_loss: 0.0635 - loss: 1.8133 - learning_rate: 0.0090 - gradient_norm: 0.7127 - val_det_loss: 1.6512 - val_cls_loss: 1.0942 - val_box_loss: 0.0111 - val_reg_l2_loss: 0.0635 - val_loss: 1.7148
Epoch 2/50
21/21 [==============================] - 9s 428ms/step - det_loss: 1.5749 - cls_loss: 1.0346 - box_loss: 0.0108 - reg_l2_loss: 0.0635 - loss: 1.6385 - learning_rate: 0.0100 - gradient_norm: 1.1286 - val_det_loss: 1.4898 - val_cls_loss: 0.9810 - val_box_loss: 0.0102 - val_reg_l2_loss: 0.0635 - val_loss: 1.5533
Epoch 3/50
21/21 [==============================] - 8s 399ms/step - det_loss: 1.3834 - cls_loss: 0.8835 - box_loss: 0.0100 - reg_l2_loss: 0.0635 - loss: 1.4470 - learning_rate: 0.0099 - gradient_norm: 1.6548 - val_det_loss: 1.5699 - val_cls_loss: 1.0917 - val_box_loss: 0.0096 - val_reg_l2_loss: 0.0636 - val_loss: 1.6335
Epoch 4/50
21/21 [==============================] - 11s 538ms/step - det_loss: 1.2581 - cls_loss: 0.7808 - box_loss: 0.0095 - reg_l2_loss: 0.0636 - loss: 1.3217 - learning_rate: 0.0099 - gradient_norm: 1.8710 - val_det_loss: 1.3915 - val_cls_loss: 0.9494 - val_box_loss: 0.0088 - val_reg_l2_loss: 0.0636 - val_loss: 1.4551
Epoch 5/50
21/21 [==============================] - 8s 402ms/step - det_loss: 1.1769 - cls_loss: 0.7312 - box_loss: 0.0089 - reg_l2_loss: 0.0636 - loss: 1.2405 - learning_rate: 0.0098 - gradient_norm: 1.8482 - val_det_loss: 1.2240 - val_cls_loss: 0.7897 - val_box_loss: 0.0087 - val_reg_l2_loss: 0.0636 - val_loss: 1.2875
Epoch 6/50
21/21 [==============================] - 8s 377ms/step - det_loss: 1.0785 - cls_loss: 0.6760 - box_loss: 0.0081 - reg_l2_loss: 0.0636 - loss: 1.1421 - learning_rate: 0.0097 - gradient_norm: 1.8346 - val_det_loss: 1.3397 - val_cls_loss: 0.9001 - val_box_loss: 0.0088 - val_reg_l2_loss: 0.0636 - val_loss: 1.4033
Epoch 7/50
21/21 [==============================] - 8s 404ms/step - det_loss: 1.0583 - cls_loss: 0.6720 - box_loss: 0.0077 - reg_l2_loss: 0.0636 - loss: 1.1219 - learning_rate: 0.0096 - gradient_norm: 1.8439 - val_det_loss: 1.2290 - val_cls_loss: 0.8042 - val_box_loss: 0.0085 - val_reg_l2_loss: 0.0636 - val_loss: 1.2926
Epoch 8/50
21/21 [==============================] - 8s 414ms/step - det_loss: 1.0155 - cls_loss: 0.6418 - box_loss: 0.0075 - reg_l2_loss: 0.0636 - loss: 1.0791 - learning_rate: 0.0094 - gradient_norm: 1.9218 - val_det_loss: 1.0643 - val_cls_loss: 0.6600 - val_box_loss: 0.0081 - val_reg_l2_loss: 0.0636 - val_loss: 1.1280
Epoch 9/50
21/21 [==============================] - 9s 427ms/step - det_loss: 0.9576 - cls_loss: 0.6097 - box_loss: 0.0070 - reg_l2_loss: 0.0636 - loss: 1.0212 - learning_rate: 0.0093 - gradient_norm: 1.7768 - val_det_loss: 1.2845 - val_cls_loss: 0.8958 - val_box_loss: 0.0078 - val_reg_l2_loss: 0.0636 - val_loss: 1.3481
Epoch 10/50
21/21 [==============================] - 9s 424ms/step - det_loss: 0.9062 - cls_loss: 0.5775 - box_loss: 0.0066 - reg_l2_loss: 0.0636 - loss: 0.9698 - learning_rate: 0.0091 - gradient_norm: 1.7403 - val_det_loss: 1.0913 - val_cls_loss: 0.7053 - val_box_loss: 0.0077 - val_reg_l2_loss: 0.0636 - val_loss: 1.1549
Epoch 11/50
21/21 [==============================] - 8s 369ms/step - det_loss: 0.9084 - cls_loss: 0.5879 - box_loss: 0.0064 - reg_l2_loss: 0.0636 - loss: 0.9720 - learning_rate: 0.0089 - gradient_norm: 2.0408 - val_det_loss: 1.0173 - val_cls_loss: 0.6315 - val_box_loss: 0.0077 - val_reg_l2_loss: 0.0636 - val_loss: 1.0810
Epoch 12/50
21/21 [==============================] - 8s 371ms/step - det_loss: 0.8794 - cls_loss: 0.5592 - box_loss: 0.0064 - reg_l2_loss: 0.0636 - loss: 0.9430 - learning_rate: 0.0087 - gradient_norm: 1.8005 - val_det_loss: 0.9659 - val_cls_loss: 0.5986 - val_box_loss: 0.0073 - val_reg_l2_loss: 0.0636 - val_loss: 1.0296
Epoch 13/50
21/21 [==============================] - 9s 459ms/step - det_loss: 0.8577 - cls_loss: 0.5512 - box_loss: 0.0061 - reg_l2_loss: 0.0636 - loss: 0.9214 - learning_rate: 0.0085 - gradient_norm: 2.0163 - val_det_loss: 0.9325 - val_cls_loss: 0.5910 - val_box_loss: 0.0068 - val_reg_l2_loss: 0.0636 - val_loss: 0.9961
Epoch 14/50
21/21 [==============================] - 9s 435ms/step - det_loss: 0.8478 - cls_loss: 0.5457 - box_loss: 0.0060 - reg_l2_loss: 0.0636 - loss: 0.9114 - learning_rate: 0.0082 - gradient_norm: 2.0608 - val_det_loss: 0.9593 - val_cls_loss: 0.6255 - val_box_loss: 0.0067 - val_reg_l2_loss: 0.0636 - val_loss: 1.0229
Epoch 15/50
21/21 [==============================] - 9s 441ms/step - det_loss: 0.8186 - cls_loss: 0.5299 - box_loss: 0.0058 - reg_l2_loss: 0.0637 - loss: 0.8823 - learning_rate: 0.0080 - gradient_norm: 2.0593 - val_det_loss: 0.9132 - val_cls_loss: 0.5886 - val_box_loss: 0.0065 - val_reg_l2_loss: 0.0637 - val_loss: 0.9769
Epoch 16/50
21/21 [==============================] - 8s 387ms/step - det_loss: 0.8167 - cls_loss: 0.5315 - box_loss: 0.0057 - reg_l2_loss: 0.0637 - loss: 0.8804 - learning_rate: 0.0077 - gradient_norm: 2.0913 - val_det_loss: 0.9579 - val_cls_loss: 0.6151 - val_box_loss: 0.0069 - val_reg_l2_loss: 0.0637 - val_loss: 1.0215
Epoch 17/50
21/21 [==============================] - 9s 455ms/step - det_loss: 0.8362 - cls_loss: 0.5329 - box_loss: 0.0061 - reg_l2_loss: 0.0637 - loss: 0.8999 - learning_rate: 0.0075 - gradient_norm: 2.2907 - val_det_loss: 0.9857 - val_cls_loss: 0.6500 - val_box_loss: 0.0067 - val_reg_l2_loss: 0.0637 - val_loss: 1.0493
Epoch 18/50
21/21 [==============================] - 10s 512ms/step - det_loss: 0.7982 - cls_loss: 0.5097 - box_loss: 0.0058 - reg_l2_loss: 0.0637 - loss: 0.8618 - learning_rate: 0.0072 - gradient_norm: 2.0724 - val_det_loss: 0.9486 - val_cls_loss: 0.6189 - val_box_loss: 0.0066 - val_reg_l2_loss: 0.0637 - val_loss: 1.0123
Epoch 19/50
21/21 [==============================] - 9s 426ms/step - det_loss: 0.7971 - cls_loss: 0.5132 - box_loss: 0.0057 - reg_l2_loss: 0.0637 - loss: 0.8608 - learning_rate: 0.0069 - gradient_norm: 2.1317 - val_det_loss: 0.8993 - val_cls_loss: 0.5856 - val_box_loss: 0.0063 - val_reg_l2_loss: 0.0637 - val_loss: 0.9629
Epoch 20/50
21/21 [==============================] - 8s 384ms/step - det_loss: 0.7721 - cls_loss: 0.5056 - box_loss: 0.0053 - reg_l2_loss: 0.0637 - loss: 0.8357 - learning_rate: 0.0066 - gradient_norm: 2.3111 - val_det_loss: 0.9005 - val_cls_loss: 0.5803 - val_box_loss: 0.0064 - val_reg_l2_loss: 0.0637 - val_loss: 0.9642
Epoch 21/50
21/21 [==============================] - 8s 407ms/step - det_loss: 0.7479 - cls_loss: 0.4783 - box_loss: 0.0054 - reg_l2_loss: 0.0637 - loss: 0.8116 - learning_rate: 0.0063 - gradient_norm: 2.1176 - val_det_loss: 0.8907 - val_cls_loss: 0.5672 - val_box_loss: 0.0065 - val_reg_l2_loss: 0.0637 - val_loss: 0.9544
Epoch 22/50
21/21 [==============================] - 9s 421ms/step - det_loss: 0.7528 - cls_loss: 0.4944 - box_loss: 0.0052 - reg_l2_loss: 0.0637 - loss: 0.8165 - learning_rate: 0.0060 - gradient_norm: 2.2042 - val_det_loss: 0.9323 - val_cls_loss: 0.5999 - val_box_loss: 0.0066 - val_reg_l2_loss: 0.0637 - val_loss: 0.9960
Epoch 23/50
21/21 [==============================] - 8s 411ms/step - det_loss: 0.7228 - cls_loss: 0.4738 - box_loss: 0.0050 - reg_l2_loss: 0.0637 - loss: 0.7865 - learning_rate: 0.0056 - gradient_norm: 2.2088 - val_det_loss: 0.9609 - val_cls_loss: 0.6336 - val_box_loss: 0.0065 - val_reg_l2_loss: 0.0637 - val_loss: 1.0246
Epoch 24/50
21/21 [==============================] - 8s 394ms/step - det_loss: 0.7517 - cls_loss: 0.4870 - box_loss: 0.0053 - reg_l2_loss: 0.0637 - loss: 0.8154 - learning_rate: 0.0053 - gradient_norm: 2.2922 - val_det_loss: 0.8865 - val_cls_loss: 0.5759 - val_box_loss: 0.0062 - val_reg_l2_loss: 0.0637 - val_loss: 0.9502
Epoch 25/50
21/21 [==============================] - 9s 445ms/step - det_loss: 0.7264 - cls_loss: 0.4772 - box_loss: 0.0050 - reg_l2_loss: 0.0637 - loss: 0.7901 - learning_rate: 0.0050 - gradient_norm: 2.4224 - val_det_loss: 0.8677 - val_cls_loss: 0.5584 - val_box_loss: 0.0062 - val_reg_l2_loss: 0.0637 - val_loss: 0.9314
Epoch 26/50
21/21 [==============================] - 8s 368ms/step - det_loss: 0.7313 - cls_loss: 0.4784 - box_loss: 0.0051 - reg_l2_loss: 0.0637 - loss: 0.7950 - learning_rate: 0.0047 - gradient_norm: 2.3990 - val_det_loss: 0.8848 - val_cls_loss: 0.5795 - val_box_loss: 0.0061 - val_reg_l2_loss: 0.0637 - val_loss: 0.9485
Epoch 27/50
21/21 [==============================] - 9s 438ms/step - det_loss: 0.7442 - cls_loss: 0.4808 - box_loss: 0.0053 - reg_l2_loss: 0.0637 - loss: 0.8079 - learning_rate: 0.0044 - gradient_norm: 2.2786 - val_det_loss: 0.8670 - val_cls_loss: 0.5623 - val_box_loss: 0.0061 - val_reg_l2_loss: 0.0637 - val_loss: 0.9307
Epoch 28/50
21/21 [==============================] - 7s 365ms/step - det_loss: 0.7101 - cls_loss: 0.4650 - box_loss: 0.0049 - reg_l2_loss: 0.0637 - loss: 0.7738 - learning_rate: 0.0040 - gradient_norm: 2.3402 - val_det_loss: 0.9498 - val_cls_loss: 0.6235 - val_box_loss: 0.0065 - val_reg_l2_loss: 0.0637 - val_loss: 1.0135
Epoch 29/50
21/21 [==============================] - 8s 413ms/step - det_loss: 0.7008 - cls_loss: 0.4541 - box_loss: 0.0049 - reg_l2_loss: 0.0637 - loss: 0.7646 - learning_rate: 0.0037 - gradient_norm: 2.4113 - val_det_loss: 0.9092 - val_cls_loss: 0.6099 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9729
Epoch 30/50
21/21 [==============================] - 8s 374ms/step - det_loss: 0.6828 - cls_loss: 0.4551 - box_loss: 0.0046 - reg_l2_loss: 0.0637 - loss: 0.7465 - learning_rate: 0.0034 - gradient_norm: 2.2994 - val_det_loss: 0.9009 - val_cls_loss: 0.6075 - val_box_loss: 0.0059 - val_reg_l2_loss: 0.0637 - val_loss: 0.9646
Epoch 31/50
21/21 [==============================] - 8s 396ms/step - det_loss: 0.7034 - cls_loss: 0.4578 - box_loss: 0.0049 - reg_l2_loss: 0.0637 - loss: 0.7671 - learning_rate: 0.0031 - gradient_norm: 2.5569 - val_det_loss: 0.8762 - val_cls_loss: 0.5866 - val_box_loss: 0.0058 - val_reg_l2_loss: 0.0637 - val_loss: 0.9399
Epoch 32/50
21/21 [==============================] - 8s 405ms/step - det_loss: 0.6809 - cls_loss: 0.4430 - box_loss: 0.0048 - reg_l2_loss: 0.0637 - loss: 0.7446 - learning_rate: 0.0028 - gradient_norm: 2.2210 - val_det_loss: 0.8479 - val_cls_loss: 0.5602 - val_box_loss: 0.0058 - val_reg_l2_loss: 0.0637 - val_loss: 0.9116
Epoch 33/50
21/21 [==============================] - 11s 547ms/step - det_loss: 0.6803 - cls_loss: 0.4439 - box_loss: 0.0047 - reg_l2_loss: 0.0637 - loss: 0.7440 - learning_rate: 0.0025 - gradient_norm: 2.3671 - val_det_loss: 0.8496 - val_cls_loss: 0.5612 - val_box_loss: 0.0058 - val_reg_l2_loss: 0.0637 - val_loss: 0.9133
Epoch 34/50
21/21 [==============================] - 7s 359ms/step - det_loss: 0.6711 - cls_loss: 0.4442 - box_loss: 0.0045 - reg_l2_loss: 0.0637 - loss: 0.7348 - learning_rate: 0.0023 - gradient_norm: 2.3403 - val_det_loss: 0.8600 - val_cls_loss: 0.5694 - val_box_loss: 0.0058 - val_reg_l2_loss: 0.0637 - val_loss: 0.9237
Epoch 35/50
21/21 [==============================] - 8s 357ms/step - det_loss: 0.7048 - cls_loss: 0.4478 - box_loss: 0.0051 - reg_l2_loss: 0.0637 - loss: 0.7685 - learning_rate: 0.0020 - gradient_norm: 2.4493 - val_det_loss: 0.8554 - val_cls_loss: 0.5704 - val_box_loss: 0.0057 - val_reg_l2_loss: 0.0637 - val_loss: 0.9191
Epoch 36/50
21/21 [==============================] - 8s 399ms/step - det_loss: 0.6647 - cls_loss: 0.4287 - box_loss: 0.0047 - reg_l2_loss: 0.0637 - loss: 0.7284 - learning_rate: 0.0018 - gradient_norm: 2.2872 - val_det_loss: 0.8561 - val_cls_loss: 0.5644 - val_box_loss: 0.0058 - val_reg_l2_loss: 0.0637 - val_loss: 0.9198
Epoch 37/50
21/21 [==============================] - 8s 415ms/step - det_loss: 0.6642 - cls_loss: 0.4333 - box_loss: 0.0046 - reg_l2_loss: 0.0637 - loss: 0.7279 - learning_rate: 0.0015 - gradient_norm: 2.3742 - val_det_loss: 0.8689 - val_cls_loss: 0.5745 - val_box_loss: 0.0059 - val_reg_l2_loss: 0.0637 - val_loss: 0.9326
Epoch 38/50
21/21 [==============================] - 9s 421ms/step - det_loss: 0.6635 - cls_loss: 0.4372 - box_loss: 0.0045 - reg_l2_loss: 0.0637 - loss: 0.7272 - learning_rate: 0.0013 - gradient_norm: 2.4729 - val_det_loss: 0.8648 - val_cls_loss: 0.5697 - val_box_loss: 0.0059 - val_reg_l2_loss: 0.0637 - val_loss: 0.9285
Epoch 39/50
21/21 [==============================] - 8s 381ms/step - det_loss: 0.6555 - cls_loss: 0.4249 - box_loss: 0.0046 - reg_l2_loss: 0.0637 - loss: 0.7192 - learning_rate: 0.0011 - gradient_norm: 2.3844 - val_det_loss: 0.8520 - val_cls_loss: 0.5581 - val_box_loss: 0.0059 - val_reg_l2_loss: 0.0637 - val_loss: 0.9157
Epoch 40/50
21/21 [==============================] - 9s 426ms/step - det_loss: 0.6551 - cls_loss: 0.4192 - box_loss: 0.0047 - reg_l2_loss: 0.0637 - loss: 0.7188 - learning_rate: 9.0029e-04 - gradient_norm: 2.2808 - val_det_loss: 0.8558 - val_cls_loss: 0.5631 - val_box_loss: 0.0059 - val_reg_l2_loss: 0.0637 - val_loss: 0.9195
Epoch 41/50
21/21 [==============================] - 8s 395ms/step - det_loss: 0.6549 - cls_loss: 0.4337 - box_loss: 0.0044 - reg_l2_loss: 0.0637 - loss: 0.7186 - learning_rate: 7.2543e-04 - gradient_norm: 2.4308 - val_det_loss: 0.8449 - val_cls_loss: 0.5519 - val_box_loss: 0.0059 - val_reg_l2_loss: 0.0637 - val_loss: 0.9086
Epoch 42/50
21/21 [==============================] - 11s 561ms/step - det_loss: 0.6683 - cls_loss: 0.4417 - box_loss: 0.0045 - reg_l2_loss: 0.0637 - loss: 0.7320 - learning_rate: 5.6814e-04 - gradient_norm: 2.3405 - val_det_loss: 0.8425 - val_cls_loss: 0.5496 - val_box_loss: 0.0059 - val_reg_l2_loss: 0.0637 - val_loss: 0.9062
Epoch 43/50
21/21 [==============================] - 8s 390ms/step - det_loss: 0.6756 - cls_loss: 0.4431 - box_loss: 0.0047 - reg_l2_loss: 0.0637 - loss: 0.7393 - learning_rate: 4.2906e-04 - gradient_norm: 2.6181 - val_det_loss: 0.8418 - val_cls_loss: 0.5496 - val_box_loss: 0.0058 - val_reg_l2_loss: 0.0637 - val_loss: 0.9055
Epoch 44/50
21/21 [==============================] - 8s 414ms/step - det_loss: 0.6391 - cls_loss: 0.4152 - box_loss: 0.0045 - reg_l2_loss: 0.0637 - loss: 0.7028 - learning_rate: 3.0876e-04 - gradient_norm: 2.3177 - val_det_loss: 0.8376 - val_cls_loss: 0.5452 - val_box_loss: 0.0058 - val_reg_l2_loss: 0.0637 - val_loss: 0.9013
Epoch 45/50
21/21 [==============================] - 9s 436ms/step - det_loss: 0.6522 - cls_loss: 0.4257 - box_loss: 0.0045 - reg_l2_loss: 0.0637 - loss: 0.7159 - learning_rate: 2.0774e-04 - gradient_norm: 2.3584 - val_det_loss: 0.8406 - val_cls_loss: 0.5476 - val_box_loss: 0.0059 - val_reg_l2_loss: 0.0637 - val_loss: 0.9043
Epoch 46/50
21/21 [==============================] - 8s 384ms/step - det_loss: 0.6506 - cls_loss: 0.4302 - box_loss: 0.0044 - reg_l2_loss: 0.0637 - loss: 0.7143 - learning_rate: 1.2641e-04 - gradient_norm: 2.3207 - val_det_loss: 0.8422 - val_cls_loss: 0.5480 - val_box_loss: 0.0059 - val_reg_l2_loss: 0.0637 - val_loss: 0.9059
Epoch 47/50
21/21 [==============================] - 9s 433ms/step - det_loss: 0.6298 - cls_loss: 0.4192 - box_loss: 0.0042 - reg_l2_loss: 0.0637 - loss: 0.6935 - learning_rate: 6.5107e-05 - gradient_norm: 2.3190 - val_det_loss: 0.8389 - val_cls_loss: 0.5457 - val_box_loss: 0.0059 - val_reg_l2_loss: 0.0637 - val_loss: 0.9026
Epoch 48/50
21/21 [==============================] - 9s 430ms/step - det_loss: 0.6452 - cls_loss: 0.4232 - box_loss: 0.0044 - reg_l2_loss: 0.0637 - loss: 0.7089 - learning_rate: 2.4083e-05 - gradient_norm: 2.4217 - val_det_loss: 0.8381 - val_cls_loss: 0.5451 - val_box_loss: 0.0059 - val_reg_l2_loss: 0.0637 - val_loss: 0.9018
Epoch 49/50
21/21 [==============================] - 8s 417ms/step - det_loss: 0.6723 - cls_loss: 0.4453 - box_loss: 0.0045 - reg_l2_loss: 0.0637 - loss: 0.7360 - learning_rate: 3.5074e-06 - gradient_norm: 2.3262 - val_det_loss: 0.8362 - val_cls_loss: 0.5435 - val_box_loss: 0.0059 - val_reg_l2_loss: 0.0637 - val_loss: 0.8999
Epoch 50/50
21/21 [==============================] - 8s 409ms/step - det_loss: 0.6715 - cls_loss: 0.4342 - box_loss: 0.0047 - reg_l2_loss: 0.0637 - loss: 0.7352 - learning_rate: 3.4629e-06 - gradient_norm: 2.5055 - val_det_loss: 0.8370 - val_cls_loss: 0.5437 - val_box_loss: 0.0059 - val_reg_l2_loss: 0.0637 - val_loss: 0.9007

4단계. 테스트 데이터로 모델을 평가합니다.

훈련 데이터 세트의 이미지를 사용하여 객체 감지 모델을 훈련한 후 테스트 데이터 세트의 나머지 25개 이미지를 사용하여 이전에 본 적이 없는 새 데이터에 대해 모델이 어떻게 수행되는지 평가합니다.

기본 배치 크기는 64이므로 테스트 데이터 세트의 25개 이미지를 살펴보는 데 1단계가 걸립니다.

평가 지표는 동일 코코 .

model.evaluate(test_data)
1/1 [==============================] - 6s 6s/step
{'AP': 0.20494653,
 'AP50': 0.36424518,
 'AP75': 0.21550791,
 'APs': -1.0,
 'APm': 0.4068788,
 'APl': 0.20514555,
 'ARmax1': 0.16141042,
 'ARmax10': 0.3395588,
 'ARmax100': 0.3877061,
 'ARs': -1.0,
 'ARm': 0.55833334,
 'ARl': 0.3856298,
 'AP_/Baked Goods': 0.06853136,
 'AP_/Salad': 0.50613815,
 'AP_/Cheese': 0.186581,
 'AP_/Seafood': 0.008855937,
 'AP_/Tomato': 0.25462624}

5단계. TensorFlow Lite 모델로 내보냅니다.

양자화된 모델을 내보낼 폴더를 지정하여 훈련된 객체 감지 모델을 TensorFlow Lite 형식으로 내보냅니다. 기본 훈련 후 양자화 기술은 전체 정수 양자화입니다.

model.export(export_dir='.')
2021-08-23 11:26:47.666277: W tensorflow/python/util/util.cc:348] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
2021-08-23 11:27:09.287682: W tensorflow/core/common_runtime/graph_constructor.cc:809] Node 'resample_p7/PartitionedCall' has 1 outputs but the _output_shapes attribute specifies shapes for 3 outputs. Output shapes may be inaccurate.
2021-08-23 11:27:17.129588: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:345] Ignored output_format.
2021-08-23 11:27:17.129646: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:348] Ignored drop_control_dependency.
2021-08-23 11:27:17.129653: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:354] Ignored change_concat_input_ranges.
2021-08-23 11:27:17.130683: I tensorflow/cc/saved_model/reader.cc:38] Reading SavedModel from: /tmp/tmp8rosxezi
2021-08-23 11:27:17.225788: I tensorflow/cc/saved_model/reader.cc:90] Reading meta graph with tags { serve }
2021-08-23 11:27:17.225828: I tensorflow/cc/saved_model/reader.cc:132] Reading SavedModel debug info (if present) from: /tmp/tmp8rosxezi
2021-08-23 11:27:17.225901: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1258] Device interconnect StreamExecutor with strength 1 edge matrix:
2021-08-23 11:27:17.225908: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1264]      
2021-08-23 11:27:17.720909: I tensorflow/cc/saved_model/loader.cc:206] Restoring SavedModel bundle.
2021-08-23 11:27:19.274493: I tensorflow/cc/saved_model/loader.cc:190] Running initialization op on SavedModel bundle at path: /tmp/tmp8rosxezi
2021-08-23 11:27:19.706156: I tensorflow/cc/saved_model/loader.cc:277] SavedModel load for tags { serve }; Status: success: OK. Took 2575477 microseconds.
2021-08-23 11:27:21.161632: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:210] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.
2021-08-23 11:27:22.647277: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-23 11:27:22.647744: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1733] Found device 0 with properties: 
pciBusID: 0000:00:05.0 name: Tesla V100-SXM2-16GB computeCapability: 7.0
coreClock: 1.53GHz coreCount: 80 deviceMemorySize: 15.78GiB deviceMemoryBandwidth: 836.37GiB/s
2021-08-23 11:27:22.647952: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-23 11:27:22.648292: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-23 11:27:22.648533: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1871] Adding visible gpu devices: 0
2021-08-23 11:27:22.648575: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1258] Device interconnect StreamExecutor with strength 1 edge matrix:
2021-08-23 11:27:22.648582: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1264]      0 
2021-08-23 11:27:22.648588: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1277] 0:   N 
2021-08-23 11:27:22.648681: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-23 11:27:22.648981: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-23 11:27:22.649235: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1418] Created TensorFlow device (/job:localhost/replica:0/task:0/device:GPU:0 with 14646 MB memory) -> physical GPU (device: 0, name: Tesla V100-SXM2-16GB, pci bus id: 0000:00:05.0, compute capability: 7.0)
fully_quantize: 0, inference_type: 6, input_inference_type: 3, output_inference_type: 0

6단계. TensorFlow Lite 모델을 평가합니다.

TFLite로 내보낼 때 몇 가지 요인이 모델 정확도에 영향을 줄 수 있습니다.

  • 양자화는 약간의 정밀도 저하의 비용으로 4 배 모델의 크기를 축소하는 데 도움이됩니다.
  • 원래 TensorFlow 모델을 사용하는 클래스마다 비 최대 supression (NMS) 후 처리를 들면, TFLite 모델은 훨씬 빠르지 만 덜 정확 글로벌 NMS를 사용하는 반면. Keras는 최대 100개의 감지를 출력하고 tflite는 최대 25개의 감지를 출력합니다.

따라서 내보낸 TFLite 모델을 평가하고 정확도를 원래 TensorFlow 모델과 비교해야 합니다.

model.evaluate_tflite('model.tflite', test_data)
25/25 [==============================] - 60s 2s/step
{'AP': 0.17693739,
 'AP50': 0.30656606,
 'AP75': 0.20315194,
 'APs': -1.0,
 'APm': 0.45712852,
 'APl': 0.17589222,
 'ARmax1': 0.125332,
 'ARmax10': 0.23722705,
 'ARmax100': 0.25630012,
 'ARs': -1.0,
 'ARm': 0.55833334,
 'ARl': 0.2533212,
 'AP_/Baked Goods': 0.0,
 'AP_/Salad': 0.48429495,
 'AP_/Cheese': 0.17168286,
 'AP_/Seafood': 0.00038080732,
 'AP_/Tomato': 0.22832833}

Colab의 왼쪽 사이드바를 사용하여 TensorFlow Lite 모델 파일을 다운로드할 수 있습니다. 온 마우스 오른쪽 단추로 클릭 model.tflite 파일 선택 Download 로컬 컴퓨터에 다운로드 할 수 있습니다.

이 모델은 안드로이드 또는 사용하여 iOS 앱에 통합 할 수 ObjectDetector의 APITensorFlow 라이트 태스크 라이브러리를 .

참고 항목 TFLite 개체 탐지 샘플 응용 프로그램 모델가 작업 응용 프로그램에서 사용하는 방법에 대한 자세한 내용을.

(선택 사항) 이미지에서 TFLite 모델 테스트

인터넷의 이미지를 사용하여 훈련된 TFLite 모델을 테스트할 수 있습니다.

  • 바꾸기 INPUT_IMAGE_URL 원하는 입력 이미지 아래를.
  • [조정] DETECTION_THRESHOLD 모델의 감도를 변경할 수 있습니다. 임계값이 낮을수록 모델이 더 많은 객체를 픽업하지만 잘못된 감지도 더 많이 발생한다는 의미입니다. 한편, 임계값이 높을수록 모델은 자신 있게 감지한 개체만 픽업합니다.

현재 Python에서 모델을 실행하려면 일부 상용구 코드가 필요하지만 모델을 모바일 앱에 통합하려면 몇 줄의 코드만 있으면 됩니다.

훈련된 TFLite 모델을 로드하고 일부 시각화 기능을 정의합니다.

물체 감지 실행 및 감지 결과 표시

png

(선택 사항) Edge TPU용으로 컴파일

이제 당신은 양자화 EfficientDet 라이트 모델을 가지고, 컴파일하고에 배포 할 수 있습니다 산호 EdgeTPU .

1단계. EdgeTPU 컴파일러 설치

 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  90607      0 --:--:-- --:--:-- --:--:-- 90607
OK
deb https://packages.cloud.google.com/apt coral-edgetpu-stable main
Get:1 https://nvidia.github.io/libnvidia-container/stable/ubuntu18.04/amd64  InRelease [1484 B]
Get:2 https://nvidia.github.io/nvidia-container-runtime/ubuntu18.04/amd64  InRelease [1481 B]
Hit:3 https://nvidia.github.io/nvidia-docker/ubuntu18.04/amd64  InRelease
Ign:4 http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64  InRelease
Hit:5 http://developer.download.nvidia.com/compute/machine-learning/repos/ubuntu1804/x86_64  Release
Hit:6 http://asia-east1.gce.archive.ubuntu.com/ubuntu bionic InRelease
Hit:7 http://asia-east1.gce.archive.ubuntu.com/ubuntu bionic-updates InRelease
Hit:8 http://asia-east1.gce.archive.ubuntu.com/ubuntu bionic-backports InRelease
Get:9 https://packages.cloud.google.com/apt coral-edgetpu-stable InRelease [6722 B]
Get:10 http://security.ubuntu.com/ubuntu bionic-security InRelease [88.7 kB]
Get:12 http://packages.cloud.google.com/apt google-cloud-logging-wheezy InRelease [5483 B]
Hit:13 http://archive.canonical.com/ubuntu bionic InRelease
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 112 kB in 1s (104 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-headers-5.4.0-1043-gcp
  linux-headers-5.4.0-1044-gcp linux-image-5.4.0-1044-gcp
  linux-modules-5.4.0-1044-gcp linux-modules-extra-5.4.0-1044-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 114 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 0s (27.9 MB/s)
Selecting previously unselected package edgetpu-compiler.
(Reading database ... 275858 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는 모델 PARAMATERS에게 (캐싱을 위해 SRAM 8MB의를 가지고 더 많은 정보를 ). 즉, 8MB보다 큰 모델의 경우 모델 매개변수를 통해 전송하기 위해 추론 시간이 늘어납니다. 이를 방지하는 방법 중 하나는 모델 파이프 라인 전용 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

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

Model compiled successfully in 4241 ms.

Input model: model.tflite
Input size: 4.22MiB
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단계. 모델 다운로드, 실행

모델이 컴파일되면 이제 객체 감지를 위해 EdgeTPU에서 실행할 수 있습니다. 먼저 Colab의 왼쪽 사이드바를 사용하여 컴파일된 TensorFlow Lite 모델 파일을 다운로드합니다. 온 마우스 오른쪽 단추로 클릭 model_edgetpu.tflite 파일 선택 Download 로컬 컴퓨터에 다운로드 할 수 있습니다.

이제 원하는 방식으로 모델을 실행할 수 있습니다. 감지의 예는 다음과 같습니다.

고급 사용법

이 섹션에서는 모델 및 훈련 하이퍼파라미터 조정과 같은 고급 사용 주제를 다룹니다.

데이터세트 로드

자신의 데이터 로드

이 자습서를 진행하기 위해 고유한 데이터 세트를 업로드할 수 있습니다. Colab의 왼쪽 사이드바를 사용하여 데이터세트를 업로드하세요.

파일 업로드

클라우드에 데이터 집합을 업로드하지 않으려면, 당신은 또한 로컬에 따라 라이브러리를 실행할 수 있습니다 가이드 .

다른 데이터 형식으로 데이터 로드

모델 메이커 라이브러리는 또한 지원 object_detector.DataLoader.from_pascal_voc 가진로드 데이터에있어서 PASCAL VOC의 포맷. makesense.aiLabelImg는 이미지에 주석을 달고 파스칼 VOC 데이터 형식의 XML 파일로 주석을 저장할 수있는 도구입니다 :

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

EfficientDet 모델 하이퍼파라미터 사용자 지정

조정할 수 있는 모델 및 교육 파이프라인 매개변수는 다음과 같습니다.

  • model_dir : 위치는 모델 검사 점 파일을 저장합니다. 설정하지 않으면 임시 디렉토리가 사용됩니다.
  • steps_per_execution : 교육 실행 당 단계의 수.
  • moving_average_decay : 플로트. 훈련된 매개변수의 이동 평균을 유지하는 데 사용할 감쇠입니다.
  • var_freeze_expr : 변수의 접두사 이름을 매핑하는 정규 표현식은 훈련 기간 동안 동일하게 남아있는 수단을 고정합니다. 보다 구체적인를 사용 re.match(var_freeze_expr, variable_name) 변수를 매핑하는 코드베이스에서 동결된다.
  • tflite_max_detections : 기본적으로 정수, 25. TFLite 모델의 최대 출력 감지 수입니다.
  • strategy , • 문자열 지정하는 유통 전략을 사용한다. 허용되는 값은 'tpu', 'gpus', None입니다. tpu'는 TPUSStrategy를 사용하는 것을 의미합니다. 'gpus'는 다중 GPU에 MirroredStrategy를 사용한다는 의미입니다. None인 경우 OneDeviceStrategy와 함께 TF 기본값을 사용합니다.
  • tpu : 클라우드 TPU 훈련에 사용합니다. Cloud TPU를 만들 때 사용된 이름이거나 grpc://ip.address.of.tpu:8470 URL이어야 합니다.
  • 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 기능은 모델 메이커 라이브러리가 사용하는 모델을 만들 수있는 드라이버 기능입니다. model_spec 매개 변수는 모델 사양을 정의합니다. object_detector.EfficientDetSpec 클래스는 현재 지원됩니다. 가 create 다음 단계의 함수를 포함한다 :

  1. 에있어서, 상기 물체 감지를위한 모델 생성 model_spec .
  2. 모델을 학습시킵니다. 기본 신 (新) 시대와 기본 배치 크기가 설정되어 epochsbatch_size 변수 model_spec 객체입니다. 당신은 조정할 수도 있습니다처럼 훈련하는 하이퍼 epochsbatch_size 모델의 정확성에 영향을 미칩니다. 예를 들어,
  • epochs : 정수, 기본적으로 50. 더 많은 에포크는 더 나은 정확도를 달성할 수 있지만 과적합으로 이어질 수 있습니다.
  • batch_size : 정수, 64 기본적으로. 한 훈련 단계에서 사용할 샘플 수입니다.
  • train_whole_model : 기본적으로 거짓 부울. 참이면 전체 모델을 훈련시킵니다. 그렇지 않으면, 단지 일치하지 않는 층 훈련 var_freeze_expr .

예를 들어, 더 적은 epoch와 헤드 레이어만 사용하여 훈련할 수 있습니다. 더 나은 결과를 위해 Epoch 수를 늘릴 수 있습니다.

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

다른 형식으로 내보내기

내보내기 형식은 다음 중 하나 또는 목록일 수 있습니다.

기본적으로이 모델이 포함에만 TensorFlow 라이트 모델 파일 수출 메타 데이터를 나중에 온 - 디바이스 ML 응용 프로그램에서 사용할 수 있도록합니다. 레이블 파일은 메타데이터에 포함됩니다.

많은 온디바이스 ML 애플리케이션에서 모델 크기는 중요한 요소입니다. 따라서 모델을 더 작게 만들고 더 빠르게 실행할 수 있도록 모델을 양자화하는 것이 좋습니다. EfficientDet-Lite 모델의 경우 기본적으로 모델을 양자화하기 위해 전체 정수 양자화가 사용됩니다. 을 참조하시기 바랍니다 후 교육 양자화 자세한 내용을 위해.

model.export(export_dir='.')

더 나은 검사를 위해 모델과 관련된 다른 파일을 내보내도록 선택할 수도 있습니다. 예를 들어 다음과 같이 저장된 모델과 레이블 파일을 모두 내보냅니다.

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

TensorFlow Lite 모델에서 훈련 후 양자화 사용자 지정

후 교육 양자화는 또한 CPU 및 하드웨어 가속기 추론 속도를 향상시키는 동시에 모델의 정확성에 약간의 저하, 모델의 크기와 추론 대기 시간을 줄일 수 있습니다 변환 기술이다. 따라서 모델을 최적화하는 데 널리 사용됩니다.

Model Maker 라이브러리는 모델을 내보낼 때 기본 훈련 후 양자화 기술을 적용합니다. 당신이 훈련 후 양자화를 사용자 정의하려면, 모델 메이커 사용하여 여러 훈련 후 양자화 옵션 지원 QuantizationConfig을 뿐만 아니라합니다. float16 양자화를 예로 들어 보겠습니다. 먼저 양자화 구성을 정의합니다.

config = QuantizationConfig.for_float16()

그런 다음 이러한 구성으로 TensorFlow Lite 모델을 내보냅니다.

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

더 읽기

당신은 우리의 읽을 수있는 물체 검출 기술 정보를 배우고 예. 자세한 내용은 다음을 참조하십시오.