Помогают защитить Большой Барьерный Риф с TensorFlow на Kaggle Присоединяйтесь вызов

Обнаружение объектов с помощью TensorFlow Lite Model Maker

Посмотреть на TensorFlow.org Запускаем в Google Colab Посмотреть исходный код на GitHub Скачать блокнот

В этом colab ноутбуке, вы узнаете , как использовать Maker TensorFlow Lite модель библиотеку для обучения модели обнаружения пользовательских объектов , способной обнаруживать салаты внутри изображений на мобильном устройстве.

Библиотека использует Model Maker ПЕРЕДАЧИ обучения упростить процесс подготовки модели TensorFlow Lite с использованием специального набора данных. Переобучение модели TensorFlow Lite с использованием вашего собственного набора данных сокращает объем необходимых данных для обучения и сокращает время обучения.

Вы будете использовать общедоступную Салаты набор данных, который был создан из открытых изображений Dataset V4 .

Каждое изображение в наборе данных содержит объекты, помеченные как один из следующих классов:

  • Запеченный хорошо
  • Сыр
  • Салат
  • Морепродукты
  • Помидор

Набор данных содержит ограничивающие рамки, указывающие, где находится каждый объект, вместе с меткой объекта.

Вот пример изображения из набора данных:


Предпосылки

Установите необходимые пакеты

Начните с установки необходимых пакетов, включая Maker пакет модели из репозитория GitHub и библиотеки 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 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:168: 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). Если вы сделаете ваши файлы на ГКС общественности или проверки подлинности клиента , Model Maker может прочитать эти файлы так же , как локальные файлы.

Однако вам не нужно хранить изображения в Google Cloud, чтобы использовать Model Maker. Вы можете использовать локальный путь в своем CSV-файле, и Model Maker будет работать.

Быстрый старт

Обучение модели обнаружения объектов состоит из шести шагов:

Шаг 1. Выберите архитектуру модели обнаружения объектов.

В этом руководстве используется модель EfficientDet-Lite0. EfficientDet-Lite [0-4] представляют собой семейство мобильных / IoT безвредных моделей обнаружения объектов , полученных из EfficientDet архитектуры.

Вот производительность каждой модели EfficientDet-Lite по сравнению друг с другом.

Архитектура модели Размер (МБ) * Задержка (мс) ** Средняя точность ***
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 потоков ЦП.
*** Средняя точность - это 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 [==============================] - 52s 594ms/step - det_loss: 1.7623 - cls_loss: 1.1183 - box_loss: 0.0129 - reg_l2_loss: 0.0636 - loss: 1.8259 - learning_rate: 0.0090 - gradient_norm: 0.7842 - val_det_loss: 1.6226 - val_cls_loss: 1.0564 - val_box_loss: 0.0113 - val_reg_l2_loss: 0.0636 - val_loss: 1.6862
Epoch 2/50
21/21 [==============================] - 9s 428ms/step - det_loss: 1.5615 - cls_loss: 1.0107 - box_loss: 0.0110 - reg_l2_loss: 0.0636 - loss: 1.6251 - learning_rate: 0.0100 - gradient_norm: 1.1797 - val_det_loss: 1.6624 - val_cls_loss: 1.1431 - val_box_loss: 0.0104 - val_reg_l2_loss: 0.0636 - val_loss: 1.7260
Epoch 3/50
21/21 [==============================] - 9s 449ms/step - det_loss: 1.3597 - cls_loss: 0.8521 - box_loss: 0.0102 - reg_l2_loss: 0.0636 - loss: 1.4233 - learning_rate: 0.0099 - gradient_norm: 1.8815 - val_det_loss: 1.5798 - val_cls_loss: 1.0834 - val_box_loss: 0.0099 - val_reg_l2_loss: 0.0636 - val_loss: 1.6433
Epoch 4/50
21/21 [==============================] - 9s 428ms/step - det_loss: 1.2037 - cls_loss: 0.7495 - box_loss: 0.0091 - reg_l2_loss: 0.0636 - loss: 1.2673 - learning_rate: 0.0099 - gradient_norm: 1.8449 - val_det_loss: 1.1755 - val_cls_loss: 0.7060 - val_box_loss: 0.0094 - val_reg_l2_loss: 0.0636 - val_loss: 1.2391
Epoch 5/50
21/21 [==============================] - 8s 407ms/step - det_loss: 1.1494 - cls_loss: 0.7072 - box_loss: 0.0088 - reg_l2_loss: 0.0636 - loss: 1.2130 - learning_rate: 0.0098 - gradient_norm: 1.7831 - val_det_loss: 1.1401 - val_cls_loss: 0.6872 - val_box_loss: 0.0091 - val_reg_l2_loss: 0.0636 - val_loss: 1.2037
Epoch 6/50
21/21 [==============================] - 9s 430ms/step - det_loss: 1.0417 - cls_loss: 0.6583 - box_loss: 0.0077 - reg_l2_loss: 0.0636 - loss: 1.1053 - learning_rate: 0.0097 - gradient_norm: 1.8188 - val_det_loss: 1.1230 - val_cls_loss: 0.6873 - val_box_loss: 0.0087 - val_reg_l2_loss: 0.0636 - val_loss: 1.1866
Epoch 7/50
21/21 [==============================] - 9s 444ms/step - det_loss: 1.0045 - cls_loss: 0.6327 - box_loss: 0.0074 - reg_l2_loss: 0.0636 - loss: 1.0681 - learning_rate: 0.0096 - gradient_norm: 1.6745 - val_det_loss: 1.1078 - val_cls_loss: 0.6970 - val_box_loss: 0.0082 - val_reg_l2_loss: 0.0636 - val_loss: 1.1715
Epoch 8/50
21/21 [==============================] - 9s 436ms/step - det_loss: 0.9873 - cls_loss: 0.6281 - box_loss: 0.0072 - reg_l2_loss: 0.0636 - loss: 1.0509 - learning_rate: 0.0094 - gradient_norm: 1.8219 - val_det_loss: 1.0272 - val_cls_loss: 0.6270 - val_box_loss: 0.0080 - val_reg_l2_loss: 0.0636 - val_loss: 1.0908
Epoch 9/50
21/21 [==============================] - 9s 445ms/step - det_loss: 0.9557 - cls_loss: 0.6142 - box_loss: 0.0068 - reg_l2_loss: 0.0636 - loss: 1.0194 - learning_rate: 0.0093 - gradient_norm: 1.9636 - val_det_loss: 0.9905 - val_cls_loss: 0.5984 - val_box_loss: 0.0078 - val_reg_l2_loss: 0.0636 - val_loss: 1.0541
Epoch 10/50
21/21 [==============================] - 9s 418ms/step - det_loss: 0.9154 - cls_loss: 0.5912 - box_loss: 0.0065 - reg_l2_loss: 0.0636 - loss: 0.9790 - learning_rate: 0.0091 - gradient_norm: 1.9094 - val_det_loss: 0.9727 - val_cls_loss: 0.5936 - val_box_loss: 0.0076 - val_reg_l2_loss: 0.0636 - val_loss: 1.0364
Epoch 11/50
21/21 [==============================] - 9s 463ms/step - det_loss: 0.8831 - cls_loss: 0.5672 - box_loss: 0.0063 - reg_l2_loss: 0.0636 - loss: 0.9467 - learning_rate: 0.0089 - gradient_norm: 1.9402 - val_det_loss: 0.9308 - val_cls_loss: 0.5854 - val_box_loss: 0.0069 - val_reg_l2_loss: 0.0637 - val_loss: 0.9945
Epoch 12/50
21/21 [==============================] - 9s 450ms/step - det_loss: 0.8591 - cls_loss: 0.5550 - box_loss: 0.0061 - reg_l2_loss: 0.0637 - loss: 0.9227 - learning_rate: 0.0087 - gradient_norm: 1.8930 - val_det_loss: 0.9465 - val_cls_loss: 0.5955 - val_box_loss: 0.0070 - val_reg_l2_loss: 0.0637 - val_loss: 1.0101
Epoch 13/50
21/21 [==============================] - 9s 461ms/step - det_loss: 0.8448 - cls_loss: 0.5468 - box_loss: 0.0060 - reg_l2_loss: 0.0637 - loss: 0.9085 - learning_rate: 0.0085 - gradient_norm: 1.9581 - val_det_loss: 0.9102 - val_cls_loss: 0.5811 - val_box_loss: 0.0066 - val_reg_l2_loss: 0.0637 - val_loss: 0.9739
Epoch 14/50
21/21 [==============================] - 9s 459ms/step - det_loss: 0.8637 - cls_loss: 0.5531 - box_loss: 0.0062 - reg_l2_loss: 0.0637 - loss: 0.9274 - learning_rate: 0.0082 - gradient_norm: 2.0490 - val_det_loss: 0.9046 - val_cls_loss: 0.5846 - val_box_loss: 0.0064 - val_reg_l2_loss: 0.0637 - val_loss: 0.9682
Epoch 15/50
21/21 [==============================] - 9s 422ms/step - det_loss: 0.8342 - cls_loss: 0.5448 - box_loss: 0.0058 - reg_l2_loss: 0.0637 - loss: 0.8978 - learning_rate: 0.0080 - gradient_norm: 1.9709 - val_det_loss: 0.9097 - val_cls_loss: 0.5803 - val_box_loss: 0.0066 - val_reg_l2_loss: 0.0637 - val_loss: 0.9734
Epoch 16/50
21/21 [==============================] - 8s 415ms/step - det_loss: 0.7923 - cls_loss: 0.5199 - box_loss: 0.0054 - reg_l2_loss: 0.0637 - loss: 0.8559 - learning_rate: 0.0077 - gradient_norm: 2.1667 - val_det_loss: 0.9081 - val_cls_loss: 0.5875 - val_box_loss: 0.0064 - val_reg_l2_loss: 0.0637 - val_loss: 0.9718
Epoch 17/50
21/21 [==============================] - 9s 442ms/step - det_loss: 0.7989 - cls_loss: 0.5229 - box_loss: 0.0055 - reg_l2_loss: 0.0637 - loss: 0.8626 - learning_rate: 0.0075 - gradient_norm: 2.2767 - val_det_loss: 0.9135 - val_cls_loss: 0.6089 - val_box_loss: 0.0061 - val_reg_l2_loss: 0.0637 - val_loss: 0.9772
Epoch 18/50
21/21 [==============================] - 9s 453ms/step - det_loss: 0.7796 - cls_loss: 0.5058 - box_loss: 0.0055 - reg_l2_loss: 0.0637 - loss: 0.8433 - learning_rate: 0.0072 - gradient_norm: 2.1824 - val_det_loss: 0.9539 - val_cls_loss: 0.6266 - val_box_loss: 0.0065 - val_reg_l2_loss: 0.0637 - val_loss: 1.0176
Epoch 19/50
21/21 [==============================] - 10s 500ms/step - det_loss: 0.7637 - cls_loss: 0.4991 - box_loss: 0.0053 - reg_l2_loss: 0.0637 - loss: 0.8274 - learning_rate: 0.0069 - gradient_norm: 2.3608 - val_det_loss: 0.9021 - val_cls_loss: 0.5804 - val_box_loss: 0.0064 - val_reg_l2_loss: 0.0637 - val_loss: 0.9658
Epoch 20/50
21/21 [==============================] - 8s 400ms/step - det_loss: 0.7702 - cls_loss: 0.5084 - box_loss: 0.0052 - reg_l2_loss: 0.0637 - loss: 0.8339 - learning_rate: 0.0066 - gradient_norm: 2.3755 - val_det_loss: 0.9090 - val_cls_loss: 0.6030 - val_box_loss: 0.0061 - val_reg_l2_loss: 0.0637 - val_loss: 0.9727
Epoch 21/50
21/21 [==============================] - 10s 474ms/step - det_loss: 0.7478 - cls_loss: 0.4901 - box_loss: 0.0052 - reg_l2_loss: 0.0637 - loss: 0.8115 - learning_rate: 0.0063 - gradient_norm: 2.3764 - val_det_loss: 0.8813 - val_cls_loss: 0.5748 - val_box_loss: 0.0061 - val_reg_l2_loss: 0.0637 - val_loss: 0.9450
Epoch 22/50
21/21 [==============================] - 8s 402ms/step - det_loss: 0.7447 - cls_loss: 0.4874 - box_loss: 0.0051 - reg_l2_loss: 0.0637 - loss: 0.8084 - learning_rate: 0.0060 - gradient_norm: 2.1873 - val_det_loss: 0.8654 - val_cls_loss: 0.5635 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9291
Epoch 23/50
21/21 [==============================] - 9s 442ms/step - det_loss: 0.7284 - cls_loss: 0.4719 - box_loss: 0.0051 - reg_l2_loss: 0.0637 - loss: 0.7922 - learning_rate: 0.0056 - gradient_norm: 2.2059 - val_det_loss: 0.8880 - val_cls_loss: 0.5950 - val_box_loss: 0.0059 - val_reg_l2_loss: 0.0637 - val_loss: 0.9517
Epoch 24/50
21/21 [==============================] - 9s 416ms/step - det_loss: 0.7396 - cls_loss: 0.4866 - box_loss: 0.0051 - reg_l2_loss: 0.0637 - loss: 0.8033 - learning_rate: 0.0053 - gradient_norm: 2.5020 - val_det_loss: 0.8547 - val_cls_loss: 0.5569 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9184
Epoch 25/50
21/21 [==============================] - 10s 477ms/step - det_loss: 0.7039 - cls_loss: 0.4613 - box_loss: 0.0049 - reg_l2_loss: 0.0637 - loss: 0.7676 - learning_rate: 0.0050 - gradient_norm: 2.1846 - val_det_loss: 0.8550 - val_cls_loss: 0.5496 - val_box_loss: 0.0061 - val_reg_l2_loss: 0.0637 - val_loss: 0.9188
Epoch 26/50
21/21 [==============================] - 9s 426ms/step - det_loss: 0.7109 - cls_loss: 0.4713 - box_loss: 0.0048 - reg_l2_loss: 0.0637 - loss: 0.7747 - learning_rate: 0.0047 - gradient_norm: 2.5184 - val_det_loss: 0.8839 - val_cls_loss: 0.5861 - val_box_loss: 0.0060 - val_reg_l2_loss: 0.0637 - val_loss: 0.9476
Epoch 27/50
21/21 [==============================] - 11s 561ms/step - det_loss: 0.7064 - cls_loss: 0.4606 - box_loss: 0.0049 - reg_l2_loss: 0.0637 - loss: 0.7702 - learning_rate: 0.0044 - gradient_norm: 2.4822 - val_det_loss: 0.8413 - val_cls_loss: 0.5468 - val_box_loss: 0.0059 - val_reg_l2_loss: 0.0637 - val_loss: 0.9051
Epoch 28/50
21/21 [==============================] - 9s 444ms/step - det_loss: 0.7037 - cls_loss: 0.4550 - box_loss: 0.0050 - reg_l2_loss: 0.0637 - loss: 0.7674 - learning_rate: 0.0040 - gradient_norm: 2.3641 - val_det_loss: 0.8477 - val_cls_loss: 0.5532 - val_box_loss: 0.0059 - val_reg_l2_loss: 0.0637 - val_loss: 0.9115
Epoch 29/50
21/21 [==============================] - 9s 454ms/step - det_loss: 0.6791 - cls_loss: 0.4496 - box_loss: 0.0046 - reg_l2_loss: 0.0637 - loss: 0.7428 - learning_rate: 0.0037 - gradient_norm: 2.4684 - val_det_loss: 0.8485 - val_cls_loss: 0.5628 - val_box_loss: 0.0057 - val_reg_l2_loss: 0.0637 - val_loss: 0.9122
Epoch 30/50
21/21 [==============================] - 10s 467ms/step - det_loss: 0.6881 - cls_loss: 0.4535 - box_loss: 0.0047 - reg_l2_loss: 0.0637 - loss: 0.7518 - learning_rate: 0.0034 - gradient_norm: 2.3997 - val_det_loss: 0.8456 - val_cls_loss: 0.5561 - val_box_loss: 0.0058 - val_reg_l2_loss: 0.0637 - val_loss: 0.9093
Epoch 31/50
21/21 [==============================] - 11s 559ms/step - det_loss: 0.6650 - cls_loss: 0.4463 - box_loss: 0.0044 - reg_l2_loss: 0.0637 - loss: 0.7287 - learning_rate: 0.0031 - gradient_norm: 2.4227 - val_det_loss: 0.8436 - val_cls_loss: 0.5548 - val_box_loss: 0.0058 - val_reg_l2_loss: 0.0637 - val_loss: 0.9073
Epoch 32/50
21/21 [==============================] - 9s 464ms/step - det_loss: 0.6795 - cls_loss: 0.4511 - box_loss: 0.0046 - reg_l2_loss: 0.0637 - loss: 0.7432 - learning_rate: 0.0028 - gradient_norm: 2.4587 - val_det_loss: 0.8498 - val_cls_loss: 0.5553 - val_box_loss: 0.0059 - val_reg_l2_loss: 0.0637 - val_loss: 0.9135
Epoch 33/50
21/21 [==============================] - 11s 549ms/step - det_loss: 0.6667 - cls_loss: 0.4483 - box_loss: 0.0044 - reg_l2_loss: 0.0637 - loss: 0.7304 - learning_rate: 0.0025 - gradient_norm: 2.4305 - val_det_loss: 0.8519 - val_cls_loss: 0.5562 - val_box_loss: 0.0059 - val_reg_l2_loss: 0.0637 - val_loss: 0.9156
Epoch 34/50
21/21 [==============================] - 9s 429ms/step - det_loss: 0.6759 - cls_loss: 0.4438 - box_loss: 0.0046 - reg_l2_loss: 0.0637 - loss: 0.7396 - learning_rate: 0.0023 - gradient_norm: 2.5149 - val_det_loss: 0.8356 - val_cls_loss: 0.5420 - val_box_loss: 0.0059 - val_reg_l2_loss: 0.0637 - val_loss: 0.8994
Epoch 35/50
21/21 [==============================] - 10s 476ms/step - det_loss: 0.6564 - cls_loss: 0.4333 - box_loss: 0.0045 - reg_l2_loss: 0.0637 - loss: 0.7201 - learning_rate: 0.0020 - gradient_norm: 2.3304 - val_det_loss: 0.8456 - val_cls_loss: 0.5519 - val_box_loss: 0.0059 - val_reg_l2_loss: 0.0637 - val_loss: 0.9093
Epoch 36/50
21/21 [==============================] - 9s 450ms/step - det_loss: 0.6640 - cls_loss: 0.4361 - box_loss: 0.0046 - reg_l2_loss: 0.0637 - loss: 0.7277 - learning_rate: 0.0018 - gradient_norm: 2.4386 - val_det_loss: 0.8447 - val_cls_loss: 0.5521 - val_box_loss: 0.0059 - val_reg_l2_loss: 0.0637 - val_loss: 0.9084
Epoch 37/50
21/21 [==============================] - 9s 461ms/step - det_loss: 0.6634 - cls_loss: 0.4312 - box_loss: 0.0046 - reg_l2_loss: 0.0637 - loss: 0.7272 - learning_rate: 0.0015 - gradient_norm: 2.5123 - val_det_loss: 0.8233 - val_cls_loss: 0.5399 - val_box_loss: 0.0057 - val_reg_l2_loss: 0.0637 - val_loss: 0.8870
Epoch 38/50
21/21 [==============================] - 9s 420ms/step - det_loss: 0.6433 - cls_loss: 0.4212 - box_loss: 0.0044 - reg_l2_loss: 0.0637 - loss: 0.7070 - learning_rate: 0.0013 - gradient_norm: 2.4591 - val_det_loss: 0.8340 - val_cls_loss: 0.5490 - val_box_loss: 0.0057 - val_reg_l2_loss: 0.0637 - val_loss: 0.8977
Epoch 39/50
21/21 [==============================] - 12s 567ms/step - det_loss: 0.6579 - cls_loss: 0.4355 - box_loss: 0.0044 - reg_l2_loss: 0.0637 - loss: 0.7217 - learning_rate: 0.0011 - gradient_norm: 2.5012 - val_det_loss: 0.8240 - val_cls_loss: 0.5401 - val_box_loss: 0.0057 - val_reg_l2_loss: 0.0637 - val_loss: 0.8878
Epoch 40/50
21/21 [==============================] - 10s 477ms/step - det_loss: 0.6403 - cls_loss: 0.4205 - box_loss: 0.0044 - reg_l2_loss: 0.0637 - loss: 0.7041 - learning_rate: 9.0029e-04 - gradient_norm: 2.3584 - val_det_loss: 0.8211 - val_cls_loss: 0.5376 - val_box_loss: 0.0057 - val_reg_l2_loss: 0.0637 - val_loss: 0.8848
Epoch 41/50
21/21 [==============================] - 10s 482ms/step - det_loss: 0.6682 - cls_loss: 0.4354 - box_loss: 0.0047 - reg_l2_loss: 0.0637 - loss: 0.7319 - learning_rate: 7.2543e-04 - gradient_norm: 2.4202 - val_det_loss: 0.8292 - val_cls_loss: 0.5465 - val_box_loss: 0.0057 - val_reg_l2_loss: 0.0637 - val_loss: 0.8929
Epoch 42/50
21/21 [==============================] - 9s 442ms/step - det_loss: 0.6397 - cls_loss: 0.4240 - box_loss: 0.0043 - reg_l2_loss: 0.0637 - loss: 0.7034 - learning_rate: 5.6814e-04 - gradient_norm: 2.3559 - val_det_loss: 0.8280 - val_cls_loss: 0.5472 - val_box_loss: 0.0056 - val_reg_l2_loss: 0.0637 - val_loss: 0.8917
Epoch 43/50
21/21 [==============================] - 11s 538ms/step - det_loss: 0.6625 - cls_loss: 0.4434 - box_loss: 0.0044 - reg_l2_loss: 0.0637 - loss: 0.7262 - learning_rate: 4.2906e-04 - gradient_norm: 2.4973 - val_det_loss: 0.8254 - val_cls_loss: 0.5446 - val_box_loss: 0.0056 - val_reg_l2_loss: 0.0637 - val_loss: 0.8891
Epoch 44/50
21/21 [==============================] - 9s 462ms/step - det_loss: 0.6455 - cls_loss: 0.4239 - box_loss: 0.0044 - reg_l2_loss: 0.0637 - loss: 0.7093 - learning_rate: 3.0876e-04 - gradient_norm: 2.4282 - val_det_loss: 0.8225 - val_cls_loss: 0.5421 - val_box_loss: 0.0056 - val_reg_l2_loss: 0.0637 - val_loss: 0.8863
Epoch 45/50
21/21 [==============================] - 9s 420ms/step - det_loss: 0.6537 - cls_loss: 0.4256 - box_loss: 0.0046 - reg_l2_loss: 0.0637 - loss: 0.7174 - learning_rate: 2.0774e-04 - gradient_norm: 2.5693 - val_det_loss: 0.8197 - val_cls_loss: 0.5396 - val_box_loss: 0.0056 - val_reg_l2_loss: 0.0637 - val_loss: 0.8834
Epoch 46/50
21/21 [==============================] - 12s 609ms/step - det_loss: 0.6347 - cls_loss: 0.4237 - box_loss: 0.0042 - reg_l2_loss: 0.0637 - loss: 0.6984 - learning_rate: 1.2641e-04 - gradient_norm: 2.4107 - val_det_loss: 0.8182 - val_cls_loss: 0.5383 - val_box_loss: 0.0056 - val_reg_l2_loss: 0.0637 - val_loss: 0.8819
Epoch 47/50
21/21 [==============================] - 8s 416ms/step - det_loss: 0.6312 - cls_loss: 0.4129 - box_loss: 0.0044 - reg_l2_loss: 0.0637 - loss: 0.6949 - learning_rate: 6.5107e-05 - gradient_norm: 2.4160 - val_det_loss: 0.8176 - val_cls_loss: 0.5381 - val_box_loss: 0.0056 - val_reg_l2_loss: 0.0637 - val_loss: 0.8814
Epoch 48/50
21/21 [==============================] - 9s 418ms/step - det_loss: 0.6511 - cls_loss: 0.4257 - box_loss: 0.0045 - reg_l2_loss: 0.0637 - loss: 0.7149 - learning_rate: 2.4083e-05 - gradient_norm: 2.4753 - val_det_loss: 0.8167 - val_cls_loss: 0.5372 - val_box_loss: 0.0056 - val_reg_l2_loss: 0.0637 - val_loss: 0.8804
Epoch 49/50
21/21 [==============================] - 11s 557ms/step - det_loss: 0.6434 - cls_loss: 0.4222 - box_loss: 0.0044 - reg_l2_loss: 0.0637 - loss: 0.7072 - learning_rate: 3.5074e-06 - gradient_norm: 2.4886 - val_det_loss: 0.8144 - val_cls_loss: 0.5355 - val_box_loss: 0.0056 - val_reg_l2_loss: 0.0637 - val_loss: 0.8781
Epoch 50/50
21/21 [==============================] - 9s 450ms/step - det_loss: 0.6468 - cls_loss: 0.4290 - box_loss: 0.0044 - reg_l2_loss: 0.0637 - loss: 0.7105 - learning_rate: 3.4629e-06 - gradient_norm: 2.5216 - val_det_loss: 0.8154 - val_cls_loss: 0.5361 - val_box_loss: 0.0056 - val_reg_l2_loss: 0.0637 - val_loss: 0.8791

Шаг 4. Оцените модель с помощью тестовых данных.

После обучения модели обнаружения объектов с использованием изображений в наборе обучающих данных используйте оставшиеся 25 изображений в тестовом наборе данных, чтобы оценить, как модель работает с новыми данными, которые она никогда раньше не видела.

Поскольку размер пакета по умолчанию составляет 64, потребуется 1 шаг, чтобы просмотреть 25 изображений в тестовом наборе данных.

Метрики оценки такие же , как COCO .

model.evaluate(test_data)
1/1 [==============================] - 7s 7s/step
{'AP': 0.20887084,
 'AP50': 0.33234695,
 'AP75': 0.2289461,
 'APs': -1.0,
 'APm': 0.30317208,
 'APl': 0.20929004,
 'ARmax1': 0.15864305,
 'ARmax10': 0.3290107,
 'ARmax100': 0.3800791,
 'ARs': -1.0,
 'ARm': 0.6333333,
 'ARl': 0.3771005,
 'AP_/Baked Goods': 0.035844196,
 'AP_/Salad': 0.5665846,
 'AP_/Cheese': 0.14119145,
 'AP_/Seafood': 0.047254298,
 'AP_/Tomato': 0.25347966}

Шаг 5. Экспортируйте как модель TensorFlow Lite.

Экспортируйте модель обнаружения обученных объектов в формат TensorFlow Lite, указав, в какую папку вы хотите экспортировать квантованную модель. Методика квантования после обучения по умолчанию - это полное целочисленное квантование.

model.export(export_dir='.')
2021-11-10 12:30:58.531474: 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-11-10 12:31:22.914078: 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-11-10 12:31:30.761990: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:345] Ignored output_format.
2021-11-10 12:31:30.762046: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:348] Ignored drop_control_dependency.
2021-11-10 12:31:30.762053: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:354] 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 [==============================] - 66s 3s/step
{'AP': 0.19853437,
 'AP50': 0.31324583,
 'AP75': 0.21451177,
 'APs': -1.0,
 'APm': 0.32116327,
 'APl': 0.19862841,
 'ARmax1': 0.15239862,
 'ARmax10': 0.26641378,
 'ARmax100': 0.28694072,
 'ARs': -1.0,
 'ARm': 0.69166666,
 'ARl': 0.2817793,
 'AP_/Baked Goods': 0.03118812,
 'AP_/Salad': 0.54991317,
 'AP_/Cheese': 0.12898467,
 'AP_/Seafood': 0.044554457,
 'AP_/Tomato': 0.23803143}

Вы можете загрузить файл модели TensorFlow Lite, используя левую боковую панель Colab. Щелкните правой кнопкой мыши на model.tflite файл и выберите Download , чтобы загрузить его на локальном компьютере.

Эта модель может быть интегрирована в Android или приложение IOS , используя ObjectDetector API из TensorFlow Lite задач библиотеки .

См TFLite объектов пример приложения обнаружения для получения более подробной информации о том , как модель используется в рабочем приложении.

(Необязательно) Протестируйте модель TFLite на своем изображении

Вы можете протестировать обученную модель TFLite, используя изображения из Интернета.

  • Заменить INPUT_IMAGE_URL ниже с нужным входным изображением.
  • Отрегулируйте DETECTION_THRESHOLD для изменения чувствительности модели. Более низкий порог означает, что модель будет захватывать больше объектов, но также будет больше ложных обнаружений. Между тем, более высокий порог означает, что модель будет захватывать только те объекты, которые она уверенно обнаружила.

Хотя в настоящий момент для запуска модели на Python требуется некоторый шаблонный код, для интеграции модели в мобильное приложение требуется всего несколько строк кода.

Загрузите обученную модель TFLite и определите некоторые функции визуализации

Запустить обнаружение объекта и показать результаты обнаружения

PNG

(Необязательно) Компиляция для Edge TPU

Теперь, когда у вас есть квантованная модель EfficientDet Lite, можно скомпилировать и развернуть в Коралловом 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   130k      0 --:--:-- --:--:-- --:--:--  130k
OK
deb https://packages.cloud.google.com/apt coral-edgetpu-stable main
Hit:1 http://us-west1.gce.archive.ubuntu.com/ubuntu bionic InRelease
Hit:2 http://us-west1.gce.archive.ubuntu.com/ubuntu bionic-updates InRelease
Hit:3 http://us-west1.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]
Hit:6 https://nvidia.github.io/nvidia-docker/ubuntu18.04/amd64  InRelease
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
Hit:9 http://security.ubuntu.com/ubuntu bionic-security InRelease
Get:10 http://packages.cloud.google.com/apt google-cloud-logging-wheezy InRelease [5483 B]
Hit:11 http://archive.canonical.com/ubuntu bionic InRelease
Get:12 https://packages.cloud.google.com/apt coral-edgetpu-stable InRelease [6722 B]
Get:13 https://packages.cloud.google.com/apt eip-cloud-bionic InRelease [5419 B]
Get:15 https://packages.cloud.google.com/apt coral-edgetpu-stable/main amd64 Packages [2327 B]
Fetched 21.4 kB in 1s (20.5 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 113 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 (7050 kB/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 имеет 8 МБ ОЗУ для кэширования модели PARAMATERS ( подробнее ). Это означает, что для моделей размером более 8 МБ время вывода будет увеличено для передачи параметров модели. Один из способов избежать этого является модель 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 4871 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 (ах) для обнаружения объектов. Сначала загрузите скомпилированный файл модели TensorFlow Lite, используя левую боковую панель Colab. Щелкните правой кнопкой мыши на model_edgetpu.tflite файл и выберите Download , чтобы загрузить его на локальном компьютере.

Теперь вы можете запустить модель желаемым образом. Примеры обнаружения включают:

Расширенное использование

В этом разделе рассматриваются расширенные темы использования, такие как настройка модели и гиперпараметры обучения.

Загрузите набор данных

Загрузите свои собственные данные

Вы можете загрузить свой собственный набор данных для работы с этим руководством. Загрузите свой набор данных с помощью левой боковой панели в Colab.

Загрузить файл

Если вы предпочитаете не загружать свой набор данных в облаке, вы можете также локально запустить библиотеку, следуя руководство .

Загрузите свои данные с другим форматом данных

Библиотека Maker Модель также поддерживает object_detector.DataLoader.from_pascal_voc метод для загрузки данных с PASCAL ЛОС формата. makesense.ai и LabelImg являются инструментами , которые могут аннотировать изображения и сохранить аннотации как файлы XML в формате PASCAL VOC данных:

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 : Float. Распад, используемый для поддержания скользящих средних обучаемых параметров.
  • var_freeze_expr : Регулярное выражение для сопоставления префиксов переменных , которые будет заморожено , что означает неизменный во время тренировки. Более конкретно, использование re.match(var_freeze_expr, variable_name) в кодовую для отображения переменных , которые будут заморожены.
  • tflite_max_detections : целое число, 25 по умолчанию. Максимальное количество выходных обнаружений в модели TFLite.
  • strategy : Строка , определяющая распределение которых стратегию использования. Допустимые значения: tpu, gpus, None. tpu 'означает использование TPUStrategy. "gpus" означает использование MirroredStrategy для нескольких графических процессоров. Если нет, используйте 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 и batch_size переменных в model_spec объекта. Вы также можете настроить учебные гиперпараметры как epochs и batch_size , которые влияют на точность модели. Например,
  • epochs : Integer, 50 по умолчанию. Чем больше эпох, тем выше точность, но это может привести к переобучению.
  • batch_size : Integer, 64 по умолчанию. Количество образцов для использования на одном этапе обучения.
  • train_whole_model : Boolean, ложный по умолчанию. Если это правда, обучите всю модель. В противном случае, только поезд слоев , которые не соответствуют var_freeze_expr .

Например, вы можете тренироваться с меньшим количеством эпох и только на уровне головы. Вы можете увеличить количество эпох для лучших результатов.

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

Экспорт в разные форматы

Форматы экспорта могут быть одним или списком из следующих:

По умолчанию он экспортирует только файл модели TensorFlow Lite , содержащий модель метаданных , так что вы можете позже использовать в качестве на устройстве приложения ML. Файл метки встроен в метаданные.

Во многих приложениях машинного обучения на устройстве размер модели является важным фактором. Поэтому рекомендуется квантовать модель, чтобы сделать ее меньше и потенциально быстрее. Что касается моделей EfficientDet-Lite, по умолчанию для квантования модели используется полное целочисленное квантование. Пожалуйста , обратитесь к пост-тренировочного квантования для более детальной информации.

model.export(export_dir='.')

Вы также можете экспортировать другие файлы, связанные с моделью, для лучшего изучения. Например, экспорт сохраненной модели и файла этикетки следующим образом:

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

Настроить квантование после обучения на модели TensorFlow Lite

После обучения квантования является метод преобразования , который может уменьшить размер модели и логического вывода задержки, а также для повышения скорости процессора и аппаратный ускоритель логического вывода, с небольшим ухудшением точности модели. Таким образом, он широко используется для оптимизации модели.

Библиотека Model Maker применяет стандартную технику квантования после обучения при экспорте модели. Если вы хотите настроить пост-тренировочное квантование, Model Maker поддерживает несколько вариантов после обучения с использованием квантования QuantizationConfig , а также. В качестве примера возьмем квантование float16. Сначала определите конфигурацию квантования.

config = QuantizationConfig.for_float16()

Затем мы экспортируем модель TensorFlow Lite с такой конфигурацией.

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

Подробнее

Вы можете прочитать наше обнаружение объекта пример , чтобы узнать технические подробности. Для получения дополнительной информации, пожалуйста, обратитесь к: