Aide à protéger la Grande barrière de corail avec tensorflow sur Kaggle Rejoignez Défi

Détection d'objets avec TensorFlow Lite Model Maker

Voir sur TensorFlow.org Exécuter dans Google Colab Voir la source sur GitHub Télécharger le cahier

Dans ce carnet COLAB, vous apprendrez comment utiliser le Maker Lite Model tensorflow bibliothèque pour former un modèle de détection d'objet personnalisé capable de détecter des salades dans les images sur un appareil mobile.

Les utilisations de la bibliothèque maquettiste le transfert d' apprentissage pour simplifier le processus de formation d' un modèle tensorflow Lite à l' aide d' un ensemble de données personnalisé. Le recyclage d'un modèle TensorFlow Lite avec votre propre ensemble de données personnalisé réduit la quantité de données d'entraînement requises et réduira la durée de l'entraînement.

Vous utiliserez le jeu de données de salades public, qui a été créé à partir des Ouvrir des images Dataset V4 .

Chaque image de l'ensemble de données contient des objets étiquetés comme l'une des classes suivantes :

  • Bon au four
  • Du fromage
  • salade
  • Fruits de mer
  • Tomate

L'ensemble de données contient les cadres de délimitation spécifiant l'emplacement de chaque objet, ainsi que l'étiquette de l'objet.

Voici un exemple d'image de l'ensemble de données :


Conditions préalables

Installer les packages requis

Commencez par installer les paquets nécessaires, y compris le paquet Maker modèle du repo GitHub et la bibliothèque pycocotools que vous allez utiliser pour l' évaluation.

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

Importez les packages requis.

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)

Préparer le jeu de données

Vous utiliserez le même ensemble de données que le AutoML QuickStart .

L'ensemble de données salades est disponible à l' adresse: gs://cloud-ml-data/img/openimage/csv/salads_ml_use.csv .

Il contient 175 images pour la formation, 25 images pour la validation et 25 images pour les tests. L'ensemble de données a cinq classes: Salad , Seafood de Tomato Baked goods Cheese Seafood , Tomato , Baked goods de Baked goods , Cheese .


L'ensemble de données est fourni au format 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,,
  • Chaque ligne correspond à un objet localisé à l'intérieur d'une image plus grande, chaque objet étant spécifiquement désigné comme données de test, d'apprentissage ou de validation. Vous en apprendrez plus sur ce que cela signifie dans une étape ultérieure de ce cahier.
  • Les trois lignes incluses ici indiquent trois objets distincts situés à l' intérieur de la même image disponible gs://cloud-ml-data/img/openimage/3/2520/3916261642_0a504acd60_o.jpg .
  • Chaque ligne a une étiquette différente: Salad , Seafood de Tomato Seafood , Tomato , etc.
  • Les cadres de délimitation sont spécifiés pour chaque image en utilisant les sommets en haut à gauche et en bas à droite.

Voici une visualisation de ces trois lignes :


Si vous voulez en savoir plus sur la façon de préparer votre propre fichier CSV et les conditions minimales exigées pour la création d' un ensemble de données valides, consultez la préparation de vos données de formation guide pour plus de détails.

Si vous êtes nouveau à Google Cloud, vous pouvez vous demander ce que les gs:// moyen d'URL. Ils sont des URL des fichiers stockés sur Google Cloud Storage (GCS). Si vous faites vos fichiers sur des partenariats public GCS ou authentifiez votre client , Maker modèle peut lire ces fichiers de façon similaire à vos fichiers locaux.

Cependant, vous n'avez pas besoin de conserver vos images sur Google Cloud pour utiliser Model Maker. Vous pouvez utiliser un chemin local dans votre fichier CSV et Model Maker fonctionnera simplement.

Démarrage rapide

Il y a six étapes pour entraîner un modèle de détection d'objets :

Étape 1. Choisissez une architecture de modèle de détection d'objets.

Ce tutoriel utilise le modèle EfficientDet-Lite0. EfficientDet-Lite [0-4] sont une famille de modèles de détection d'objets mobiles / IdO-friendly dérivés de la EfficientDet architecture.

Voici les performances de chaque modèle EfficientDet-Lite par rapport aux autres.

Architecture du modèle Taille (Mo)* Latence (ms)** Précision moyenne***
EfficaceDet-Lite0 4.4 37 25,69 %
EfficaceDet-Lite1 5.8 49 30,55%
EfficaceDet-Lite2 7.2 69 33,97 %
EfficaceDet-Lite3 11.4 116 37,70%
EfficaceDet-Lite4 19,9 260 41,96 %

* Taille des modèles quantifiés entiers.
** Latence mesurée sur le Pixel 4 à l'aide de 4 threads sur le processeur.
*** La précision moyenne est la mAP (précision moyenne moyenne) sur l'ensemble de données de validation COCO 2017.

spec = model_spec.get('efficientdet_lite0')

Étape 2. Chargez l'ensemble de données.

Model Maker prendra les données d'entrée au format CSV. Utilisez la object_detector.DataLoader.from_csv méthode pour charger l'ensemble de données et de les partager dans la formation, validation et images test.

  • Images d'entraînement : ces images sont utilisées pour entraîner le modèle de détection d'objets à reconnaître les ingrédients de la salade.
  • Images de validation : ce sont des images que le modèle n'a pas vues pendant le processus d'entraînement. Vous allez les utiliser pour décider quand vous devez arrêter la formation, afin d' éviter surajustement .
  • Images de test : ces images sont utilisées pour évaluer les performances finales du modèle.

Vous pouvez charger le fichier CSV directement depuis Google Cloud Storage, mais vous n'avez pas besoin de conserver vos images sur Google Cloud pour utiliser Model Maker. Vous pouvez spécifier un fichier CSV local sur votre ordinateur et Model Maker fonctionnera parfaitement.

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

Étape 3. Entraînez le modèle TensorFlow avec les données d'entraînement.

  • Le modèle EfficientDet-Lite0 utilisations epochs = 50 par défaut, ce qui signifie qu'il passera par l'ensemble de données de formation 50 fois. Vous pouvez vérifier la précision de la validation pendant l'entraînement et vous arrêter tôt pour éviter le surapprentissage.
  • Set batch_size = 8 ici , donc vous verrez que cela prend 21 mesures pour passer par les 175 images dans l'ensemble de données de formation.
  • Set train_whole_model=True pour affiner l'ensemble du modèle au lieu de simplement la formation de la couche de tête pour améliorer la précision. Le compromis est que la formation du modèle peut prendre plus de temps.
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

Étape 4. Évaluez le modèle avec les données de test.

Après avoir entraîné le modèle de détection d'objets à l'aide des images de l'ensemble de données d'entraînement, utilisez les 25 images restantes de l'ensemble de données de test pour évaluer les performances du modèle par rapport aux nouvelles données qu'il n'a jamais vues auparavant.

Comme la taille de lot par défaut est de 64, il faudra 1 étape pour parcourir les 25 images de l'ensemble de données de test.

Les paramètres d'évaluation sont les mêmes 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}

Étape 5. Exportez en tant que modèle TensorFlow Lite.

Exportez le modèle de détection d'objet entraîné au format TensorFlow Lite en spécifiant le dossier vers lequel vous souhaitez exporter le modèle quantifié. La technique de quantification post-apprentissage par défaut est la quantification entière.

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

Étape 6. Évaluez le modèle TensorFlow Lite.

Plusieurs facteurs peuvent affecter la précision du modèle lors de l'exportation vers TFLite :

  • Quantification aide diminue la taille du modèle par 4 fois au détriment d' une certaine baisse de précision.
  • Les utilisations du modèle tensorflow d' origine par classe non-max supression (NMS) pour le post-traitement, tandis que le modèle TFLite utilise NMS globales qui est beaucoup plus rapide mais moins précis. Keras génère un maximum de 100 détections tandis que tflite génère un maximum de 25 détections.

Par conséquent, vous devrez évaluer le modèle TFLite exporté et comparer sa précision avec le modèle TensorFlow d'origine.

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}

Vous pouvez télécharger le fichier de modèle TensorFlow Lite à l'aide de la barre latérale gauche de Colab. Faites un clic droit sur le model.tflite fichier et choisissez Download pour le télécharger sur votre ordinateur local.

Ce modèle peut être intégré dans un Android ou une application iOS en utilisant l' API ObjectDetector de la bibliothèque de tâches tensorflow Lite .

Voir l' exemple d' application de détection d'objets TFLite pour plus de détails sur la façon dont le modèle est utilisé dans une application de travail.

(Facultatif) Testez le modèle TFLite sur votre image

Vous pouvez tester le modèle TFLite entraîné à l'aide d'images provenant d'Internet.

  • Remplacez le INPUT_IMAGE_URL ci - dessous avec votre image d'entrée souhaitée.
  • Réglez le DETECTION_THRESHOLD pour changer la sensibilité du modèle. Un seuil inférieur signifie que le modèle captera plus d'objets, mais il y aura également plus de fausses détections. Pendant ce temps, un seuil plus élevé signifie que le modèle ne captera que les objets qu'il a détectés en toute confiance.

Bien que l'exécution du modèle en Python nécessite actuellement une partie du code passe-partout, l'intégration du modèle dans une application mobile ne nécessite que quelques lignes de code.

Chargez le modèle TFLite entraîné et définissez des fonctions de visualisation

Exécuter la détection d'objets et afficher les résultats de la détection

png

(Facultatif) Compiler pour Edge TPU

Maintenant que vous avez un modèle EfficientDet Lite quantifiée, il est possible de compiler et déployer un Coral EdgeTPU .

Étape 1. Installez le compilateur 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) ...

Étape 2. Sélectionnez le nombre de TPU Edge, compilez

Le EdgeTPU a 8 Mo de SRAM pour la mise en cache paramaters modèle ( plus d' info ). Cela signifie que pour les modèles de plus de 8 Mo, le temps d'inférence sera augmenté afin de transférer les paramètres du modèle. Une façon d'éviter cela est modèle Pipelining - diviser le modèle en segments qui peuvent avoir un EdgeTPU dédié. Cela peut améliorer considérablement la latence.

Le tableau ci-dessous peut être utilisé comme référence pour le nombre de TPU Edge à utiliser - les modèles plus grands ne seront pas compilés pour un seul TPU car les tenseurs intermédiaires ne peuvent pas tenir dans la mémoire sur puce.

Architecture du modèle TPU minimal TPU recommandés
EfficaceDet-Lite0 1 1
EfficaceDet-Lite1 1 1
EfficaceDet-Lite2 1 2
EfficaceDet-Lite3 2 2
EfficaceDet-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!

Étape 3. Télécharger, exécuter le modèle

Une fois les modèles compilés, ils peuvent désormais être exécutés sur les EdgeTPU pour la détection d'objets. Tout d'abord, téléchargez le fichier de modèle TensorFlow Lite compilé à l'aide de la barre latérale gauche de Colab. Faites un clic droit sur le model_edgetpu.tflite fichier et choisissez Download pour le télécharger sur votre ordinateur local.

Vous pouvez maintenant exécuter le modèle de la manière que vous préférez. Exemples de détection :

Utilisation avancée

Cette section couvre des sujets d'utilisation avancés tels que l'ajustement du modèle et les hyperparamètres d'entraînement.

Charger le jeu de données

Chargez vos propres données

Vous pouvez télécharger votre propre ensemble de données pour suivre ce didacticiel. Téléchargez votre ensemble de données à l'aide de la barre latérale gauche dans Colab.

Téléverser un fichier

Si vous préférez ne pas télécharger votre jeu de données vers le cloud, vous pouvez également exécuter localement la bibliothèque en suivant le Guide .

Chargez vos données avec un format de données différent

La bibliothèque Maker modèle prend également en charge la object_detector.DataLoader.from_pascal_voc méthode pour charger des données avec PASCAL COV format. makesense.ai et LabelImg sont les outils qui peuvent annoter l'image et enregistrer des annotations sous forme de fichiers XML dans le format de données PASCAL COV:

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

Personnaliser les hyperparamètres du modèle EfficientDet

Les paramètres du modèle et du pipeline d'entraînement que vous pouvez ajuster sont :

  • model_dir : L'emplacement pour enregistrer les fichiers de point de contrôle du modèle. S'il n'est pas défini, un répertoire temporaire sera utilisé.
  • steps_per_execution : Nombre d'étapes par l' exécution de la formation.
  • moving_average_decay : flotteur. La décroissance à utiliser pour maintenir les moyennes mobiles des paramètres entraînés.
  • var_freeze_expr : L'expression régulière pour mapper le nom du préfixe des variables à congeler qui reste le même moyen lors de la formation. Plus précisément, l' utilisation re.match(var_freeze_expr, variable_name) dans la base de code pour cartographier les variables à congeler.
  • tflite_max_detections : entier, 25 par défaut. Le nombre maximum de détections de sortie dans le modèle TFLite.
  • strategy : Une chaîne spécifiant quelle stratégie de distribution à l' utilisation. Les valeurs acceptées sont 'tpu', 'gpus', None. tpu' signifie utiliser TPUStrategy. « gpus » signifie utiliser MirroredStrategy pour le multi-gpus. Si aucun, utilisez TF par défaut avec OneDeviceStrategy.
  • tpu : Cloud TPU à utiliser pour la formation. Il doit s'agir soit du nom utilisé lors de la création du Cloud TPU, soit d'une URL grpc://ip.address.of.tpu:8470.
  • use_xla : Utilisez XLA même si la stratégie n'est pas tpu. Si la stratégie est tpu, utilisez toujours XLA, et ce drapeau n'a aucun effet.
  • profile : Activer le mode de profil.
  • debug : Activer le mode de débogage.

D' autres paramètres peuvent être ajustés sont présentés dans hparams_config.py .

Par exemple, vous pouvez définir la var_freeze_expr='efficientnet' qui fige les variables avec préfixe le nom efficientnet (valeur par défaut est '(efficientnet|fpn_cells|resample_p6)' ). Cela permet au modèle de geler les variables non entraînables et de conserver la même valeur grâce à l'entraînement.

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

Modifier l'architecture du modèle

Vous pouvez modifier l'architecture du modèle en changeant la model_spec . Par exemple, changer le model_spec au modèle EfficientDet-Lite4.

spec = model_spec.get('efficientdet_lite4')

Régler les hyperparamètres d'entraînement

La create fonction est la fonction du pilote que l'utilisation de la bibliothèque maquettiste de créer des modèles. Le model_spec paramètre définit la spécification du modèle. La object_detector.EfficientDetSpec classe est actuellement pris en charge. Le create comprend des fonctions des étapes suivantes:

  1. Crée le modèle pour la détection d'objet selon model_spec .
  2. Entraîne le modèle. Les époques par défaut et la taille du lot par défaut sont définies par les epochs et batch_size variables dans le model_spec objet. Vous pouvez également régler les hyperparamètres de formation comme epochs et batch_size qui affectent la précision du modèle. Par exemple,
  • epochs : Entier, 50 par défaut. Plus d'époques pourraient atteindre une meilleure précision, mais peuvent conduire à un surapprentissage.
  • batch_size : Entier, 64 par défaut. Le nombre d'échantillons à utiliser dans une étape d'apprentissage.
  • train_whole_model : Boolean, False par défaut. Si c'est vrai, entraînez l'ensemble du modèle. Dans le cas contraire, former uniquement les couches qui ne correspondent pas var_freeze_expr .

Par exemple, vous pouvez vous entraîner avec moins d'époques et uniquement la couche de tête. Vous pouvez augmenter le nombre d'époques pour de meilleurs résultats.

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

Exporter vers différents formats

Les formats d'exportation peuvent être un ou une liste des suivants :

Par défaut, il exporte uniquement le fichier modèle Lite tensorflow contenant le modèle de métadonnées afin que vous pouvez ensuite utiliser dans une application ML sur l'appareil. Le fichier d'étiquette est intégré aux métadonnées.

Dans de nombreuses applications ML sur l'appareil, la taille du modèle est un facteur important. Par conséquent, il est recommandé de quantifier le modèle pour le rendre plus petit et potentiellement plus rapide. Comme pour les modèles EfficientDet-Lite, la quantification entière est utilisée pour quantifier le modèle par défaut. S'il vous plaît se référer à la quantification post-formation pour plus de détails.

model.export(export_dir='.')

Vous pouvez également choisir d'exporter d'autres fichiers liés au modèle pour un meilleur examen. Par exemple, exportez à la fois le modèle enregistré et le fichier d'étiquette comme suit :

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

Personnaliser la quantification post-entraînement sur le modèle TensorFlow Lite

Quantification post-formation est une technique de conversion qui permet de réduire la taille du modèle et de la latence d'inférence, tout en améliorant la vitesse d'inférence du processeur et accélérateur matériel, avec une légère dégradation de la précision du modèle. Ainsi, il est largement utilisé pour optimiser le modèle.

La bibliothèque Model Maker applique une technique de quantification post-formation par défaut lors de l'exportation du modèle. Si vous souhaitez personnaliser la quantification post-formation, modèle Maker prend en charge plusieurs options de quantification post-formation en utilisant QuantizationConfig ainsi. Prenons comme exemple la quantification float16. Tout d'abord, définissez la configuration de quantification.

config = QuantizationConfig.for_float16()

Ensuite, nous exportons le modèle TensorFlow Lite avec une telle configuration.

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

Lire la suite

Vous pouvez lire notre détection objet exemple pour apprendre des détails techniques. Pour plus d'informations, veuillez vous référer à: