[PYTHON] [Pour les débutants] J'ai essayé d'utiliser l'API Tensorflow Object Detection

introduction

Voici Ichi Lab de RHEMS Giken.

Cette fois, en utilisant l'API de détection d'objets de TensorFlow, Détectez l'objet que vous souhaitez reconnaître Je l'ai finalement essayé sur un appareil Android.

De nombreux sites utiles m'ont aidé, Pourtant, il y avait tellement de choses que je ne pouvais pas résoudre en une ou deux pages.

Dans cet article, je vais reprendre les parties sur lesquelles je suis tombé par hasard, je vais donc les décrire. J'espère que le nombre de personnes qui rencontrent des difficultés similaires sera réduit autant que possible.

environnement

TensorFlow 1.15

  1. MacBook Pro OS : Catalina 10.15 CPU : Intel Core i5 2.3GHz Memory : 8GB 2133MHz

  2. MacBook Pro OS : Catalina 10.15 CPU : Intel Core i7 3.5GHz Memory : 16GB 2133MHz

J'ai changé de 1 à 2 pour une raison quelconque en cours de route.

Environnement

Fondamentalement, c'est comme écrit dans la formule ci-dessous.

TensorFlow Object Detection - Installation

Obtenez la dernière source de l'API de détection d'objets avec la commande suivante.

$ git clone --depth 1 https://github.com/tensorflow/models.git

Où définir PYTHONPATH, cela est expliqué dans pwd, mais s'il est décrit en entier, c'est comme suit. (Il existe des conteneurs dont le répertoire racine est «tf» au lieu de «tensorflow», alors vérifiez-le.)

$ export PYTHONPATH=$PYTHONPATH:/tensorflow/models/research:/tensorflow/models/research/slim

Précautions pour la construction d'un environnement

Si vous utilisez Docker pour l'exécuter dans un conteneur, il existe différents types, comme indiqué sur la page officielle ci-dessous. Soyez prudent si vous utilisez latest (dernière version).

Tensorflow - Docker

Parce que, à partir de novembre 2019 au moment de la rédaction de cet article, ** API de détection d'objets est En effet, il ne prend pas en charge TensorFlow 2.0 **.

De même, lors de l'installation avec la commande pip, il est essentiel de vérifier la version de TensorFlow. Si vous souhaitez le vérifier, vous pouvez taper la commande suivante.

$ pip list | grep tensor
tensorboard                        1.15.0     
tensorflow                         1.15.0rc3  
tensorflow-estimator               1.15.1 

Si vous souhaitez changer la version de 2.0 à 1.X, exécutez la commande suivante. (Changé en 1.15 dans cet exemple)

$ pip install tensorflow==1.15.0rc3

Au fait, la différence entre cette version est assez importante, je vais donc l'ajouter, Le TensorFlow officiel a préparé un script qui se convertira automatiquement même si la version est 2.0. Cependant, il est décrit comme «sauf pour contrib» (excluant contrib).

Migrate your TensorFlow 1 code to TensorFlow 2

Si vous exécutez l'API de détection d'objets model_builder_test.py dans TensorFlow 2.0, Il échouera comme suit.

AttributeError: module 'tensorflow' has no attribute 'contrib'

Vous êtes coincé avec une erreur sur contrib. Cela signifie que les scripts de conversion automatique ne peuvent pas être utilisés pour le moment.

Au fait, avez-vous exécuté model_builder_test.py en toute sécurité et il a été affiché comme OK? model_builder_test.py effectue les opérations suivantes dans le répertoire models / research:

$ python object_detection/builders/model_builder_test.py

En cas de succès, OK s'affiche comme indiqué ci-dessous. (Parce qu'il est long, certaines parties sont omises)

Running tests under Python 3.6.8: /usr/local/bin/python
[ RUN      ] ModelBuilderTest.test_create_faster_rcnn_model_from_config_with_example_miner  
...    

[ RUN      ] ModelBuilderTest.test_unknown_ssd_feature_extractor
[       OK ] ModelBuilderTest.test_unknown_ssd_feature_extractor
----------------------------------------------------------------------
Ran 16 tests in 0.313s

Au fait, à l'exception de TensorFlow </ b>, je n'ai eu aucun effet même si je ne me souciais pas de la version, donc Je pense que vous pouvez installer le dernier. C'est tout pour construire l'environnement.

Préparation des données des enseignants

Créez des données d'enseignant pour détecter les objets que vous souhaitez reconnaître. Afin de créer des données d'enseignant, vous devez préparer de nombreuses images que vous souhaitez détecter.

Si vous avez du mal à collecter par vous-même, il existe également un outil pratique appelé google-images-download, donc Si vous êtes intéressé, veuillez le vérifier et l'utiliser.

Maintenant, expliquons les données des enseignants. Les données de l'enseignant sont préparées au format TFRecord </ b> recommandé par TensorFlow. TFRecord est un formulaire simple pour stocker une série d'enregistrements binaires, Les données sont sérialisées (enregistrées en tant que données du tableau) et peuvent être lues en continu. Il existe à peu près deux façons de créer des données au format TFRecord.

  1. Utilisez l'outil d'annotation
  2. Créez le vôtre à partir de la source

Les annotations sont ce que l'on appelle le balisage. Tout en affichant des photos et des vidéos, c'est une tâche d'enseigner "cette partie est celle-ci". J'ai utilisé un outil de Microsoft appelé VoTT </ b> pour cela. VoTT

Précautions lors de l'utilisation de VoTT

  • Sélectionnez ** Enregistrements Tensorflow ** dans les paramètres d'exportation
  • Défini sur Actifs visités uniquement Autre que </ b> dans l'état de l'actif
  • L'apprentissage actif (marque comme un chapeau) peut disparaître lorsque vous appuyez dessus, il n'est donc pas recommandé de l'utiliser beaucoup.
  • Si vous étiquetez un grand nombre d'images, le traitement sera lourd, dans ce cas, il vaut mieux les découper en plusieurs images.

Comme vous pouvez le voir, c'est un outil qui a divers points difficiles à utiliser, mais Il est recommandé à cet égard car il élimine les tracas de la conversion au format TFRecord.

Si vous le faites vous-même à partir de la source

Il est possible de générer un fichier au format TFRecord à partir d'une image avec la bibliothèque fournie par TensorFlow. Cependant, avec le TFRecord généré dans le tutoriel officiel ci-dessous, Le TFRecord généré par VoTT avait des noms d'élément légèrement différents et ne pouvait pas être mélangé et entraîné ensemble. Utilisation de TFRecords et tf.Example

Ce document sera plus utile. using_your_own_dataset.md

L'histoire ici sera longue, alors je l'ai résumée dans un autre article, alors jetez un œil si vous le souhaitez. Notes sur la création de fichiers TFRecord pour la détection d'objets

Apprentissage

L'explication à partir de là est basée sur l'hypothèse que tous les répertoires sont basés sur «modèles / recherche».

Une fois que vous avez le fichier au format TFRecord prêt, il est temps de commencer à apprendre. Ici, apprenons votre propre original basé sur le modèle d'apprentissage existant appelé "apprentissage par transfert". Nous allons procéder à la méthode de création d'un modèle d'apprentissage plus personnalisé. L'apprentissage par transfert utilise des poids appris à l'avance à partir de données à grande échelle. On s'attend à ce que des performances suffisantes puissent être obtenues même avec une petite quantité de données d'entraînement.

Télécharger le modèle d'apprentissage

Tout d'abord, téléchargez le modèle entraîné pour l'apprentissage par transfert. Cette fois, je ne l'ai pas trouvé utilisé dans d'autres articles japonais. Continuons avec le nouveau MobileNet v3.

Le modèle formé peut être téléchargé à partir de la page suivante. Tensorflow detection model zoo
Dans celui-ci, téléchargez celui appelé ssd_mobilenet_v3_large_coco. Veuillez noter que ce modèle ne fonctionnera qu'avec les dernières sources mises à jour vers la mi-octobre 2019.

Placez le modèle téléchargé dans le répertoire ʻobject_detection`. Si vous souhaitez l'exécuter avec une commande, procédez comme suit:

$ wget http://download.tensorflow.org/models/object_detection/ssd_mobilenet_v3_large_coco_2019_08_14.tar.gz  
$ tar zxvf ssd_mobilenet_v3_large_coco_2019_08_14.tar.gz

Structure de fichier de modèle d'apprentissage

La structure des fichiers du modèle d'apprentissage est essentiellement la suivante.

  • checkpoint
  • frozen_inference_graph.pb
  • model.ckpt.data-00000-of-00001
  • model.ckpt.index
  • model.ckpt.meta
  • pipeline.config
  • saved_model /
    • saved_model.pb
    • variables /

Lors du démarrage de l'apprentissage par transfert, modifiez le contenu du fichier pipeline.config dans celui-ci et utilisez-le.

Structure de répertoire et nom de fichier pour la formation et l'évaluation

Cette section décrit le répertoire de fichiers TFRecord préparé. Le fichier TFRecord a des répertoires séparés pour la formation (enseignant) et la vérification. Généralement, le ratio est la formation: la validation est de 8: 2, ce qui signifie que la formation est divisée en 80% des données et les 20% restants sont divisés en validation. (Extrait du livre "Practical Machine Learning with scicit-learn and TensorFlow" P30) Bien sûr, il est possible d'étudier même si vous ne le divisez pas correctement. Voici la structure des répertoires. (Train signifie formation, val signifie validation)

  • test0001 / --label_map (.pbtxt) Fichier d'étiquette
    • train / --Fichier TFRecord (.tfrecord) Fichier de formation
    • val / --Fichier TFRecord (.tfrecord) Fichier de vérification
    • save / --Un répertoire préparé pour enregistrer les données apprises (vide au début)

Les noms de fichier TFRecord doivent être unifiés avec des numéros de série au lieu de numéros séparés. Par exemple, ici, nous le nommons comme suit.

  • hoge0000.tfrecord
  • hoge0001.tfrecord
  • hoge0002.tfrecord
  • ... (etc)

La façon de nommer le fichier ici est liée à la configuration du fichier de configuration suivant.

Modifier le fichier de configuration

Ouvrez pipeline.config dans le modèle entraîné que vous avez téléchargé précédemment. Ici, vous pouvez ajuster divers paramètres tels que la taille du lot, la pondération et l'expansion de l'image, mais nous expliquerons les éléments que vous modifierez souvent. (Extrait de la configuration réelle pour explication)

pipeline.config


model {
    ssd {
        num_classes: 1

num_classes : C'est un paramètre du nombre à classer. Il est écrit relativement en haut du fichier de configuration.

pipeline.config


train_config: {
    batch_size: 32
    num_steps: 10000
    optimizer {
        momentum_optimizer: {
            learning_rate: {
                cosine_decay_learning_rate {
                    total_steps: 10000
                    warmup_steps: 10000
    fine_tune_checkpoint: "./object_detection/ssd_mobilenet_v3_large_coco/model.ckpt"
}

batch_size : Lors de l'utilisation de la méthode de descente de gradient probabiliste, afin de réduire l'effet des valeurs aberrantes Entraînez l'ensemble de données en plusieurs sous-ensembles. Le nombre de données contenues dans chaque sous-ensemble est appelé la taille du lot. Cette valeur est souvent la valeur de 2 à la nième puissance comme il est d'usage dans le domaine de l'apprentissage automatique. Et, plus cette valeur est élevée, plus la charge est appliquée pendant l'apprentissage et, selon l'environnement, le processus peut mourir et ne pas apprendre.

num_steps : Le nombre d'étapes à apprendre. Le nombre d'étapes peut également être spécifié dans la commande lors de l'exécution de l'apprentissage, Autant que j'ai essayé, la spécification de commande a la priorité.

total_steps et warmup_steps: J'enquête car c'est un élément qui n'était pas dans la config d'autres modèles, total_steps doit être supérieur ou égal à warmup_steps. (Si cette condition n'est pas remplie, une erreur se produit et l'apprentissage ne démarre pas)

fine_tune_checkpoint : Spécifie un modèle pour l'apprentissage par transfert. C'est OK si vous écrivez le répertoire contenant le modèle d'apprentissage téléchargé jusqu'à "~ .ckpt". Cet élément n'était pas inclus lors du téléchargement de ssd_mobilenet_v3. C'est pourquoi je l'ai ajouté moi-même. La plupart des modèles ont déjà cet article. Cette ligne est inutile si vous n'effectuez pas d'apprentissage par transfert.

pipeline.config


train_input_reader: {
    tf_record_input_reader {
        input_path: "./object_detection/test0001/train/hoge????.tfrecord"
    }
    label_map_path: "./object_detection/test0001/tf_label_map.pbtxt"
}
eval_input_reader: {
    tf_record_input_reader {
        input_path: "./object_detection/test0001/val/hoge????.tfrecord"
    }
    label_map_path: "./object_detection/test0001/tf_label_map.pbtxt"
}

input_path : Spécifiez le répertoire des fichiers TFRecord préparés pour la formation et la vérification. Par exemple, dans ce cas, nous l'avons nommé avec un numéro de série de hoge0000.tfrecord, alors écrivez-le comme hoge ????. Tfrecord.

label_map_path : Spécifiez l'étiquette préparée. Il n'y a aucun problème avec la même spécification pour le train et l'évaluation.

Commencer à apprendre

Après avoir écrit le fichier de configuration, il est temps de commencer à apprendre. Pour la formation, utilisez le fichier model_main.py situé dans le répertoire ʻobject_detection`. Une description des arguments d'exécution.

  • --model_dir: Spécifiez la destination d'enregistrement des données d'entraînement. Un fichier appelé ".ckpt ~" sera créé dans le répertoire spécifié pendant l'apprentissage.

  • --pipeline_config_path: Spécifiez le fichier de configuration à utiliser. Spécifions le fichier de configuration que vous avez édité précédemment.

  • --num_train_steps: Spécifiez le nombre d'apprentissages. Cette option n'est pas nécessaire si vous souhaitez implémenter le numéro spécifié dans la configuration, Si vous souhaitez vous entraîner à un nombre de fois différent de celui de config, le nombre de fois spécifié ici prévaudra. (Résultat de l'essai réel)

Voici un exemple d'exécution.

$ python object_detection/model_main.py \
--pipeline_config_path="object_detection/ssd_mobilenet_v3_large_coco/pipeline.config" \
--model_dir="./object_detection/test0001/save" \
--alsologtostderr

Comme il existe de nombreuses options et qu'il est difficile d'entrer à chaque fois, il sera plus facile à exécuter si vous en faites un script shell.

#! /bin/bash

PIPELINE_CONFIG_PATH="./object_detection/ssd_mobilenet_v3_large_coco.config"
MODEL_DIR="./object_detection/test0001/save"
NUM_TRAIN_STEPS=10000

cd '/tensorflow/models/research'

python object_detection/model_main.py \
    --pipeline_config_path=$PIPELINE_CONFIG_PATH \
    --model_dir=$MODEL_DIR \
#    --num_train_steps=$NUM_TRAIN_STEPS \
    --alsologtostderr

"Oh, je ne peux pas exécuter la coquille que j'ai faite ...?" Avez-vous oublié de modifier vos autorisations?

$ chmod 775 hoge.sh

Si vous commencez à apprendre mais que le processus meurt au milieu

Si vous pensez que l'apprentissage a commencé, cela peut se produire comme suit.

~ session_manager.py:500] Running local_init_op.
~ session_manager.py:502] Done running local_init_op.
~  basic_session_run_hooks.py:606] Saving checkpoints for 0 into {Enregistrer le point de contrôle Le répertoire spécifié/nom de fichier}.ckpt
Killed

Il y a plusieurs raisons pour lesquelles le processus meurt, Dans les deux cas, il est fort possible que l'environnement d'exploitation soit à court de ressources.

Ici, je vais vous présenter les moyens que j'ai résolus lorsque j'ai vécu ce phénomène.

~ Solution n ° 1. Essayez de modifier les paramètres du moteur Docker ~

C'est une méthode qui peut être utile si vous le faites dans un conteneur Docker. Ouvrez d'abord les paramètres. Sélectionnez Préférences → onglet Avancé </ b> pour augmenter les ressources.

~ Solution n ° 2. Essayez de réduire la taille du lot ~

Ce problème est résolu en définissant pipeline.config.

Quel type de combinaison de paramètres tuera le processus Je pense que cela dépend de l'environnement opérationnel et de la quantité et de la taille des données des enseignants utilisées. Tout d'abord, il peut être résolu en réduisant la valeur de la taille du lot, donc Si vous êtes inquiet ici, essayez-le.

Confirmation des données d'entraînement

Les données d'entraînement seront enregistrées à tout moment dans le répertoire de destination de sauvegarde spécifié lors de l'exécution de model_main.py. Les données seront sauvegardées au moment où «Sauvegarde» s'affiche comme indiqué ci-dessous pendant l'apprentissage. A ce stade, vous pouvez visualiser la situation pendant l'apprentissage avec le Tensorboard décrit ci-dessous.

INFO:tensorflow:Saving 'checkpoint_path' summary for global step 500: object_detection/test0001/save/model.ckpt-500
I1012 08:29:56.544728 139877141301056 estimator.py:2109] Saving 'checkpoint_path' summary for global step 500: object_detection/test0001/save/model.ckpt-500

Tensorboard ~ Visualisation d'apprentissage ~

La visualisation des données d'entraînement est essentielle et Tensorboard est très utile pour ce faire.

Lancer Tensorboard

Vous pouvez démarrer tensorboard avec la commande suivante.

$ tensorboard --logdir=object_detection/test0001/save
  • --logdir : ** Spécifiez ici le répertoire dans lequel vous souhaitez enregistrer les données d'entraînement que vous avez spécifiées lorsque vous avez commencé l'apprentissage. Si vous spécifiez la destination de sauvegarde des résultats d'apprentissage effectués dans le passé, vous pouvez l'afficher à nouveau même une fois l'apprentissage terminé.

Pour voir Tensorboard dans votre navigateur Web, accédez à votre hôte local. Par défaut, le numéro de port est 6006.

http://localhost:6006/

Si vous exécutez dans un environnement de conteneur Docker, assurez-vous d'avoir accès à -p 6006: 6006 lorsque vous exécutez docker run. J'ai les paramètres de port répertoriés dans docker-compose.yml.

Comment lire Tensorboard

Même si vous pouvez visualiser votre apprentissage, c'est douloureux si vous ne comprenez pas comment le regarder. J'ai résumé le contenu de mes recherches, j'espère donc que vous pourrez vous y référer. GRAPHS Le graphique est généré automatiquement à partir du traitement du code source.

article La description
Run Vous pouvez changer le sous-répertoire où se trouve le journal
Upload Télécharger le fichier de modèle Tensorflow
Trace inputs Être chassé par les dépendances de nœud
Color Choisissez une méthode de codage couleur
- Structure :Configuration du modèle (réseau)
- Device :Appareil traité (CPU vs GPU)
- Compute time :temps de traitement
- Memory :utilisation de la mémoire
- TPU Compatibility :Exécuter sur l'unité de traitement du tenseur

SCALARS

article La description
Show data download links Affichez un lien dans lequel vous pouvez enregistrer le graphique. Vous pouvez sélectionner le format CSV ou JSON.
ignore outliners in chart scaling S'il faut mettre à l'échelle le graphique pour éviter les valeurs aberrantes (cocher pour éviter)
Tooltip sorting method Commande de copeaux d'outil
- default :Ordre alphabétique
- descending :Par ordre décroissant de valeur
- ascending :Par ordre croissant de valeur
- nearest :Près du curseur de la souris
Smoothing Lissage du graphique
Horizontal Axis Spécification de l'axe horizontal (axe X) du graphique en traits pointillés
- STEP :Étape (nombre d'exécutions)
- RELATIVE :Temps d'exécution (différence par rapport à la première fois)
- WALL :Heures du jour
- Runs :Afficher / masquer le graphique

Référence: Visualisation de l'apprentissage avec TensorBoard Ensuite, j'expliquerai chacun des principaux graphiques. Avant cela, je vais donner une description des mots que vous devez connaître pour l'explication.

  • IOU :
    IOU est une abréviation pour Intersection (partie commune des régions) sur Union (somme des régions), et est un indice qui indique "combien les deux régions se chevauchent". Plus cette valeur est proche de 1, plus la réponse correcte et l'inférence concordent.
  • Recall :
    Rappel. Pourcentage de ce que vous devriez trouver que vous avez pu trouver correctement. Aussi appelé sensibilité.

Référence: Signification de l'IoU (indice d'évaluation) et rigueur de la valeur Référence: [Pour les débutants] Explication des index d'évaluation des problèmes de classification pour l'apprentissage automatique (taux de réponse correcte, taux de précision, taux de rappel, etc.)

Ce qui suit est un extrait en référence à l'explication des éléments décrits dans ʻobject_detection / metrics / coco_tools.py`.

article La description
Precision/mAP Précision moyenne de la classe qui a fait la moyenne des seuils IOU dans la plage de 5 à 95 en 5 incréments.
Precision/[email protected] Précision moyenne de 50% IOU
Precision/[email protected] Précision moyenne de 75% IOU
Precision/mAP (small) Précision moyenne des petits objets (moins de 32 x 32 px)
Precision/mAP (medium) Précision moyenne des objets de taille moyenne(32×32 px〜96×96 px)
Precision/mAP (large) Précision moyenne des grands objets(96×96 px〜10000×10000 px)
Recall/AR@1 Pourcentage de moyennes trouvées correctement dans une seule détection
Recall/AR@10 Pourcentage de moyennes trouvées correctement dans 10 détections
Recall/AR@100 Pourcentage de moyennes trouvées correctement dans 100 détections
Recall/AR@100 (small) Rappel moyen de petits objets détectés 100 fois
Recall/AR@100 (medium) Rappel moyen des objets moyens détectés 100 fois

IMAGES

Afficher les données d'image. Vous pouvez vérifier la différence entre la réponse correcte des données de vérification et le résultat de l'inférence dans les unités de fichier .ckpt (point de contrôle).

Conversion en graphe d'inférence

Lorsque la formation est terminée, il est enfin temps de convertir les données en un graphe d'inférence. Plus précisément, il convertit le fichier .ckpt créé par apprentissage en un fichier .pb.

Il existe plusieurs sources de conversion dans le répertoire ʻobject_detection`.

  • export_inference_graph.py
  • export_tflite_ssd_graph.py

** Pour l'essayer sur Android, il sera converti au format ** .tflite, donc ** utilisez ce dernier **.

Dans le cas de ʻexport_inference_graph.py`

Une description des arguments d'exécution.

  • --input_type : Pour le graphe d'inférence, spécifiez l'un des trois suivants en fonction de l'utilisateur

    • image_tensor :
      Tenseur 4D [Aucun, Aucun, Aucun, 3] Normalement, vous devez le spécifier.
  • ʻEncoded_image_string_tensor`: tenseur 1D [Aucun] Inclut des images PNG ou JPEG encodées. Si plusieurs images sont fournies, on suppose que les résolutions d'image sont les mêmes.

  • tf_example: tenseur de chaîne à 1 dimension [Aucun] Si plusieurs images sont fournies, y compris des protos d'exemple TF sérialisés, on suppose que les résolutions d'image sont les mêmes.

  • --pipeline_config_path : Spécifiez le fichier de configuration utilisé pendant la formation.

  • --trained_checkpoint_prefix : Spécifiez le fichier "model.ckpt-XXXX" créé comme destination de sauvegarde pour les données d'entraînement. Pour XXXX, spécifiez le dernier (le plus grand) nombre d'étapes d'apprentissage effectuées. Par exemple, s'il est exécuté 10000 fois, ce sera "model.ckpt-10000".

  • --output_directory : Spécifiez le répertoire que vous souhaitez exporter. Dans le répertoire spécifié, un fichier avec exactement la même structure que la structure de fichiers du premier modèle téléchargé sera créé.

Voici un exemple d'exécution.

$ python object_detection/export_inference_graph.py \
--input_type image_tensor \
--pipeline_config_path object_detection/ssd_mobilenet_v3_large_coco/pipeline.config \
--trained_checkpoint_prefix object_detection/test0001/save/model.ckpt-10000 \
--output_directory object_detection/test0001/output

ʻPour export_tflite_ssd_graph.py`

Un programme qui convertit un modèle entraîné en un modèle compatible .tflite. Les arguments sont fondamentalement les mêmes que ʻexport_inference_graph.py. (Il n'y a pas de --input_type`)

Voici un exemple d'exécution.

$ python object_detection/export_tflite_ssd_graph.py \
--pipeline_config_path=object_detection/ssd_mobilenet_v3_large_coco/pipeline.config \
--trained_checkpoint_prefix=object_detection/test0001/save/model.ckpt-10000 \
--output_directory=object_detection/test0001/tflite \
--add_postprocessing_op=true

Deux fichiers, tflite_graph.pb et tflite_graph.pbtxt, sont créés dans le répertoire spécifié par --output_directory.

Convertir au format TensorFlow Lite

Utilisez tflite_convert pour convertir au format tflite. Ce convertisseur doit être inclus dès le début.

Si vous tapez tflite_convert --help, l'utilisation sortira. Puisqu'il existe de nombreuses options à ajouter, je l'ai résumé dans un script shell comme suit. Changez le répertoire qui vous convient. De plus, je reconnais que --input_shapes est probablement une valeur qui correspond à ʻimage_resizer` de la configuration au moment de l'apprentissage, mais il n'y a pas de confirmation ... Les significations des nombres sont (taille du lot, hauteur de l'image d'entrée, largeur de l'image d'entrée, profondeur de l'image d'entrée (canal RVB)).

Converter command line reference

#! /bin/bash

OUTPUT_FILE="object_detection/test0001/tflite/test.tflite"
GRAPH_DEF_FILE="object_detection/test0001/tflite/tflite_graph.pb"
INTERFACE_TYPE="FLOAT"
INPUT_ARRAY="normalized_input_image_tensor"
OUTPUT_ARRAYS="TFLite_Detection_PostProcess,TFLite_Detection_PostProcess:1,TFLite_Detection_PostProcess:2,TFLite_Detection_PostProcess:3"
INPUT_SHAPES="1,300,300,3"

cd '/tensorflow/models/research'

tflite_convert \
    --output_file=$OUTPUT_FILE \
    --graph_def_file=$GRAPH_DEF_FILE \
    --inference_type=$INTERFACE_TYPE \
    --input_arrays=$INPUT_ARRAY \
    --input_shapes=$INPUT_SHAPES \
    --output_arrays=$OUTPUT_ARRAYS \
    --default_ranges_min=0 \
    --default_ranges_max=6 \
    --mean_values=128 \
    --std_dev_values=127 \
    --allow_custom_ops

De plus, j'ai trouvé plusieurs instructions pour installer bazel et toco sur d'autres sites, mais cela n'était possible qu'avec cette ligne de commande sans eux. (J'ai essayé ces méthodes pour être exact, mais le résultat était le même)

À ce stade, si la version de TensorFlow est ** 1.12.0rc0, elle échoue **, Avec ** 1.15.0rc3 **, la même commande exacte ** fonctionnait **.

De plus, la description officielle recommandait l'API Python. Converter command line reference

En fait, exécutez-le sur Android

Cela fait longtemps, mais c'est enfin en production.

Installez Android Studio

Tout d'abord, installons "Android Studio". Si vous trouvez d'autres outils plus faciles à utiliser, vous pouvez les utiliser.

Télécharger un échantillon officiel

Ensuite, téléchargez la collection d'échantillons auprès du responsable.

$ git clone --depth 1 https://github.com/tensorflow/examples.git

Modification de l'échantillon

Après avoir lancé Android Studio, ouvrez ʻexamples / lite / examples / object_detection / android`.

Mettez votre propre fichier tflite

Placez votre test.tflite et labelmap.txt dans le répertoire ʻexamples / lite / examples / object_detection / android / app / src / main / assets. labelmap.txt` est un fichier texte qui répertorie les noms de balises que vous avez marquées.

Par exemple, si vous préparez deux types de noms de balises, «pomme» et «orange», le fichier texte sera comme suit.

labelmap.txt


???
apple
orange

L'important est que la première ligne soit «???».

Modification de DetectorActivity.java

C'est long, mais éditez DetectorActivity.java dans le répertoire ʻexamples / lite / examples / object_detection / android / app / src / main / java / org / tensorflow / lite / examples / detection /`.

DetectorActivity.java


private static final boolean TF_OD_API_IS_QUANTIZED = false; //true->false
private static final String TF_OD_API_MODEL_FILE = "test.tflite"; //detect.tflite -> my tflite
private static final String TF_OD_API_LABELS_FILE = "file:///android_asset/labelmap.txt"; //my txt

Puis éditez build.gradle dans le répertoire ʻexamples / lite / examples / object_detection / android / app /`.

Commentez ce qui suit autour de la ligne 40: (Si vous ne commentez pas ici, il sera remplacé par les exemples de données par défaut lors de la construction)

build.gradle


apply from:'download_model.gradle' //Commenter

Construire

Une fois que vous avez fait cela, tout ce que vous avez à faire est de le créer, de l'exécuter sur votre appareil et de voir! Félicitations si vous pouvez bien l'essayer.

Ci-dessous un site de référence pour Android

Training and serving a realtime mobile object detector in 30 minutes with Cloud TPUs How to Train Your Own Custom Model with Tensorflow Object Detection API and Deploy It into Android with TF Lite Detecting Pikachu on Android using Tensorflow Object Detection

en conclusion

Qu'as-tu pensé? Cela ressemble à une page de résumé sur un autre site, mais À tout le moins, je pense que nous avons couvert pas mal d'informations dont nous pourrions avoir besoin pour utiliser l'API de détection d'objets de TensorFlow.

En particulier, TensorFlow a un comportement détaillé différent selon la version, Puisque les versions des différents sites de référence utilisés à l'époque sont différentes, je pense que beaucoup de gens ont eu la même difficulté.

Il y a encore de nombreuses parties que je ne comprends pas, mais j'espère que cela aide. Merci d'avoir lu le long article.

Recommended Posts