Google I/O — это обертка! Наверстать упущенное в сеансах TensorFlow Просмотреть сеансы

Обнаружение объектов с помощью 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 --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). Если вы сделаете ваши файлы на ГКС общественности или проверки подлинности клиента , 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 [==============================] - 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 , используя 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://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 имеет 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 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. Загрузите, запустите модель

После того, как модели скомпилированы, их теперь можно запускать на 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. "GPU" означает использование 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)

Читать далее

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