Ayuda a proteger la Gran Barrera de Coral con TensorFlow en Kaggle Únete Challenge

Detección de objetos con TensorFlow Lite Model Maker

Ver en TensorFlow.org Ejecutar en Google Colab Ver fuente en GitHub Descargar cuaderno

En este cuaderno colab, aprenderá cómo utilizar el fabricante de TensorFlow Lite Modelo biblioteca para entrenar un modelo de detección de objeto personalizado capaz de detectar ensaladas dentro de imágenes en un dispositivo móvil.

Los usos de la biblioteca de modelo del fabricante de transferencia del aprendizaje para simplificar el proceso de formación de un modelo TensorFlow Lite utilizando un conjunto de datos personalizado. Volver a entrenar un modelo de TensorFlow Lite con su propio conjunto de datos personalizado reduce la cantidad de datos de entrenamiento necesarios y acortará el tiempo de entrenamiento.

Vamos a usar las ensaladas conjunto de datos a disposición del público, que fue creado a partir de las imágenes abiertas conjunto de datos V4 .

Cada imagen del conjunto de datos contiene objetos etiquetados como una de las siguientes clases:

  • Bien horneado
  • Queso
  • Ensalada
  • Mariscos
  • Tomate

El conjunto de datos contiene los cuadros delimitadores que especifican dónde se ubica cada objeto, junto con la etiqueta del objeto.

Aquí hay una imagen de ejemplo del conjunto de datos:


Prerrequisitos

Instale los paquetes requeridos

Lo primero es instalar los paquetes necesarios, incluyendo el paquete del fabricante Modelo de la cesión temporal de GitHub y la biblioteca pycocotools que va a utilizar para la evaluación.

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

Importe los paquetes necesarios.

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)

Prepare el conjunto de datos

Aquí vamos a usar el mismo conjunto de datos como el AutoML inicio rápido .

Las ensaladas conjunto de datos está disponible en: gs://cloud-ml-data/img/openimage/csv/salads_ml_use.csv .

Contiene 175 imágenes para entrenamiento, 25 imágenes para validación y 25 imágenes para prueba. El conjunto de datos consta de cinco clases: Salad , Seafood , Tomato , Baked goods , Cheese .


El conjunto de datos se proporciona en formato 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,,
  • Cada fila corresponde a un objeto localizado dentro de una imagen más grande, con cada objeto designado específicamente como datos de prueba, entrenamiento o validación. Aprenderá más sobre lo que eso significa en una etapa posterior en este cuaderno.
  • Las tres líneas incluidas aquí indican tres objetos individualizados que se encuentren dentro de la misma imagen disponible en gs://cloud-ml-data/img/openimage/3/2520/3916261642_0a504acd60_o.jpg .
  • Cada fila tiene una etiqueta diferente: Salad , Seafood , Tomato , etc.
  • Los cuadros delimitadores se especifican para cada imagen utilizando los vértices superior izquierdo e inferior derecho.

Aquí hay una visualización de estas tres líneas:


Si desea saber más acerca de cómo preparar su propio archivo CSV y los requisitos mínimos para la creación de un conjunto de datos válidos, consulte la los datos de capacitación Preparación de guía para más detalles.

Si usted es nuevo en la nube de Google, usted puede preguntarse lo que el gs:// medios de URL. Son las URL de los archivos almacenados en Google Cloud Storage (GCS). Si usted hace sus archivos en público GCS o autenticar el cliente , Modelo Maker puede leer los archivos de manera similar a los archivos locales.

Sin embargo, no necesita mantener sus imágenes en Google Cloud para usar Model Maker. Puede usar una ruta local en su archivo CSV y Model Maker simplemente funcionará.

Inicio rápido

Hay seis pasos para entrenar un modelo de detección de objetos:

Paso 1. Elija una arquitectura de modelo de detección de objetos.

Este tutorial utiliza el modelo EfficientDet-Lite0. EfficientDet-Lite [0-4] son una familia de modelos de detección de objetos móviles / IO ambiente derivados de la EfficientDet arquitectura.

Aquí está el rendimiento de cada modelo EfficientDet-Lite en comparación con los demás.

Arquitectura modelo Tamaño (MB) * Latencia (ms) ** Precisión media ***
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%

* Tamaño de los modelos enteros cuantificados.
** Latencia medida en Pixel 4 con 4 subprocesos en la CPU.
*** La precisión media es el mAP (precisión media media) del conjunto de datos de validación de COCO 2017.

spec = model_spec.get('efficientdet_lite0')

Paso 2. Cargue el conjunto de datos.

Model Maker tomará los datos de entrada en formato CSV. Usar la object_detector.DataLoader.from_csv método para cargar el conjunto de datos y dividirlas en las imágenes de entrenamiento, validación y pruebas.

  • Imágenes de entrenamiento: estas imágenes se utilizan para entrenar al modelo de detección de objetos para que reconozca los ingredientes de la ensalada.
  • Imágenes de validación: son imágenes que el modelo no vio durante el proceso de entrenamiento. Vamos a usar ellos para decidir cuándo debe dejar la formación, para evitar el sobreajuste .
  • Imágenes de prueba: estas imágenes se utilizan para evaluar el rendimiento del modelo final.

Puede cargar el archivo CSV directamente desde Google Cloud Storage, pero no necesita mantener sus imágenes en Google Cloud para usar Model Maker. Puede especificar un archivo CSV local en su computadora y Model Maker funcionará bien.

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

Paso 3. Entrena el modelo de TensorFlow con los datos de entrenamiento.

  • Los EfficientDet-Lite0 utiliza el modelo epochs = 50 por defecto, lo que significa que va a ir a través de la formación de datos 50 veces. Puede observar la precisión de la validación durante el entrenamiento y detenerse antes para evitar el sobreajuste.
  • Conjunto batch_size = 8 aquí para que vea que toma 21 pasos para ir a través de las 175 imágenes en la formación de datos.
  • Conjunto train_whole_model=True para afinar todo el modelo en lugar de sólo la formación de la capa de la cabeza para mejorar la precisión. La compensación es que puede llevar más tiempo entrenar el modelo.
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

Paso 4. Evalúe el modelo con los datos de prueba.

Después de entrenar el modelo de detección de objetos usando las imágenes en el conjunto de datos de entrenamiento, use las 25 imágenes restantes en el conjunto de datos de prueba para evaluar cómo funciona el modelo con datos nuevos que nunca antes había visto.

Como el tamaño de lote predeterminado es 64, se necesitará 1 paso para revisar las 25 imágenes en el conjunto de datos de prueba.

Las métricas de evaluación son los mismos que 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}

Paso 5. Exportar como modelo de TensorFlow Lite.

Exporte el modelo de detección de objetos entrenado al formato TensorFlow Lite especificando a qué carpeta desea exportar el modelo cuantificado. La técnica de cuantificación posterior al entrenamiento predeterminada es la cuantificación entera completa.

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

Paso 6. Evalúe el modelo de TensorFlow Lite.

Varios factores pueden afectar la precisión del modelo al exportar a TFLite:

  • Cuantización ayuda a reducir el tamaño del modelo en 4 veces a expensas de alguna gota precisión.
  • El original modelo TensorFlow usos por clase supresión no-max (NEM) para el procesamiento posterior, mientras que el modelo utiliza TFLite NMS globales que es mucho más rápido pero menos preciso. Keras genera un máximo de 100 detecciones mientras que tflite genera un máximo de 25 detecciones.

Por lo tanto, tendrá que evaluar el modelo TFLite exportado y comparar su precisión con el modelo TensorFlow original.

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}

Puede descargar el archivo de modelo de TensorFlow Lite con la barra lateral izquierda de Colab. Haga clic en el model.tflite archivo y seleccione Download para descargarlo en su ordenador local.

Este modelo se puede integrar en un Android o una aplicación para iOS usando la API ObjectDetector de la biblioteca de tareas Lite TensorFlow .

Ver la aplicación de ejemplo de detección de objetos TFLite para más detalles sobre cómo se utiliza el modelo en una aplicación de trabajo.

(Opcional) Pruebe el modelo TFLite en su imagen

Puede probar el modelo TFLite entrenado utilizando imágenes de Internet.

  • Vuelva a colocar la INPUT_IMAGE_URL debajo de la imagen de entrada deseada con.
  • Ajustar el DETECTION_THRESHOLD para cambiar la sensibilidad del modelo. Un umbral más bajo significa que el modelo recogerá más objetos, pero también habrá más detección falsa. Mientras tanto, un umbral más alto significa que el modelo solo recogerá objetos que haya detectado con confianza.

Aunque requiere algo de código repetitivo para ejecutar el modelo en Python en este momento, la integración del modelo en una aplicación móvil solo requiere unas pocas líneas de código.

Cargue el modelo TFLite entrenado y defina algunas funciones de visualización

Ejecute la detección de objetos y muestre los resultados de la detección

png

(Opcional) Compilar para Edge TPU

Ahora que tiene un modelo EfficientDet Lite cuantificado, es posible compilar y desplegar a un Coral EdgeTPU .

Paso 1. Instale el compilador 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) ...

Paso 2. Seleccione el número de Edge TPU, compile

El EdgeTPU tiene 8 MB de SRAM para almacenamiento en caché Paramaters modelo ( más info ). Esto significa que para los modelos de más de 8 MB, el tiempo de inferencia aumentará para transferir los parámetros del modelo. Una forma de evitar esto es Modelo tuberias de diferentes tipos - dividir el modelo en segmentos que pueden tener un EdgeTPU dedicado. Esto puede mejorar significativamente la latencia.

La siguiente tabla se puede usar como referencia para la cantidad de Edge TPU que se deben usar; los modelos más grandes no se compilarán para una sola TPU ya que los tensores intermedios no caben en la memoria del chip.

Arquitectura modelo TPU mínimos TPU recomendados
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!

Paso 3. Descargue, ejecute el modelo

Con los modelos compilados, ahora se pueden ejecutar en EdgeTPU para la detección de objetos. Primero, descargue el archivo de modelo compilado de TensorFlow Lite usando la barra lateral izquierda de Colab. Haga clic en el model_edgetpu.tflite archivo y seleccione Download para descargarlo en su ordenador local.

Ahora puede ejecutar el modelo de la forma que prefiera. Los ejemplos de detección incluyen:

Uso avanzado

Esta sección cubre temas de uso avanzado como ajustar el modelo y los hiperparámetros de entrenamiento.

Cargar el conjunto de datos

Cargue sus propios datos

Puede cargar su propio conjunto de datos para trabajar con este tutorial. Sube tu conjunto de datos usando la barra lateral izquierda en Colab.

Subir archivo

Si prefiere no cargar el conjunto de datos a la nube, también puede ejecutar localmente la biblioteca siguiendo la guía .

Cargue sus datos con un formato de datos diferente

La biblioteca Fabricante Modelo también es compatible con la object_detector.DataLoader.from_pascal_voc método para cargar datos con COV PASCAL formato. makesense.ai y LabelImg son las herramientas que pueden anotar la imagen y guardar las anotaciones como archivos XML en formato de datos de COV PASCAL:

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

Personalizar los hiperparámetros del modelo EfficientDet

Los parámetros del modelo y de la línea de entrenamiento que puede ajustar son:

  • model_dir : La ubicación para guardar los archivos de modelo de punto de control. Si no se establece, se utilizará un directorio temporal.
  • steps_per_execution : Número de pasos por la ejecución de entrenamiento.
  • moving_average_decay : flotador. Decaimiento que se utilizará para mantener las medias móviles de los parámetros entrenados.
  • var_freeze_expr : La expresión regular para asignar el nombre del prefijo de variables a congelar los cuales medios restantes de la misma durante el entrenamiento. Más específica, el uso re.match(var_freeze_expr, variable_name) en el código base para asignar las variables a ser congelados.
  • tflite_max_detections : enteros, 25 de forma predeterminada. El número máximo de detecciones de salida en el modelo TFLite.
  • strategy : Una Especificación de cadena que la distribución de estrategia para el uso. Los valores aceptados son 'tpu', 'gpus', None. tpu 'significa utilizar TPUStrategy. 'gpus' significa usar MirroredStrategy para multi-gpus. Si es Ninguno, use TF predeterminado con OneDeviceStrategy.
  • tpu : La nube de TPU que se utilizará para la formación. Debe ser el nombre que se usó al crear Cloud TPU o una url grpc: //ip.address.of.tpu: 8470.
  • use_xla : Uso XLA incluso si la estrategia no es TPU. Si la estrategia es tpu, siempre use XLA, y esta bandera no tiene ningún efecto.
  • profile : Activar el modo de perfil.
  • debug : Activar el modo de depuración.

Otros parámetros que se pueden ajustar se muestran en hparams_config.py .

Por ejemplo, se puede establecer el var_freeze_expr='efficientnet' que congela las variables con el prefijo del nombre efficientnet (por defecto es '(efficientnet|fpn_cells|resample_p6)' ). Esto permite que el modelo congele variables no entrenables y mantenga su valor igual a través del entrenamiento.

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

Cambiar la arquitectura del modelo

Se puede cambiar el modelo de arquitectura cambiando el model_spec . Por ejemplo, cambiar la model_spec al modelo EfficientDet-Lite4.

spec = model_spec.get('efficientdet_lite4')

Ajustar los hiperparámetros de entrenamiento

El create función es la función de controlador que utiliza la biblioteca modelista para crear modelos. El model_spec parámetro define la especificación del modelo. El object_detector.EfficientDetSpec clase es compatible actualmente. El create de función consta de los pasos siguientes:

  1. Crea el modelo para la detección de objetos de acuerdo con model_spec .
  2. Entrena al modelo. Las épocas por defecto y el tamaño de lote predeterminado se establecen por las epochs y batch_size variables en el model_spec objeto. También puede sintonizar los hiperparámetros formación como epochs y batch_size que afectan la exactitud del modelo. Por ejemplo,
  • epochs : Entero, 50 de manera predeterminada. Más épocas podrían lograr una mayor precisión, pero pueden conducir a un sobreajuste.
  • batch_size : Integer, 64 de forma predeterminada. El número de muestras que se utilizarán en un paso de formación.
  • train_whole_model : Boolean, False por defecto. Si es cierto, entrene todo el modelo. De lo contrario, único tren de las capas que no coinciden con var_freeze_expr .

Por ejemplo, puedes entrenar con menos épocas y solo la capa principal. Puede aumentar el número de épocas para obtener mejores resultados.

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

Exportar a diferentes formatos

Los formatos de exportación pueden ser uno o una lista de los siguientes:

Por defecto, se exporta sólo el archivo de modelo TensorFlow Lite contiene el modelo de metadatos para que pueda utilizar más tarde en una aplicación ML en el dispositivo. El archivo de etiqueta está incrustado en metadatos.

En muchas aplicaciones de aprendizaje automático en el dispositivo, el tamaño del modelo es un factor importante. Por lo tanto, se recomienda que cuantifique el modelo para hacerlo más pequeño y potencialmente ejecutar más rápido. En cuanto a los modelos EfficientDet-Lite, la cuantificación entera completa se utiliza para cuantificar el modelo de forma predeterminada. Por favor refiérase a la cuantificación posterior a la formación para obtener más detalles.

model.export(export_dir='.')

También puede optar por exportar otros archivos relacionados con el modelo para un mejor examen. Por ejemplo, exportar tanto el modelo guardado como el archivo de etiqueta de la siguiente manera:

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

Personalice la cuantificación posterior al entrenamiento en el modelo TensorFlow Lite

Después de la formación de cuantificación es una técnica de conversión que puede reducir el tamaño del modelo y la latencia de la inferencia, además de mejorar la velocidad de la CPU y el acelerador de hardware inferencia, con un poco de degradación en la precisión del modelo. Por lo tanto, se usa ampliamente para optimizar el modelo.

La biblioteca Model Maker aplica una técnica de cuantificación posterior al entrenamiento predeterminada al exportar el modelo. Si desea personalizar la cuantificación posterior al entrenamiento, Modelo Maker soporta múltiples opciones después de la formación de cuantificación utilizando QuantizationConfig también. Tomemos como ejemplo la cuantificación de float16. Primero, defina la configuración de cuantificación.

config = QuantizationConfig.for_float16()

Luego exportamos el modelo de TensorFlow Lite con dicha configuración.

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

Lee mas

Usted puede leer nuestra detección de objetos ejemplo para aprender detalles técnicos. Para obtener más información, consulte: