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.
TensorFlow 1.15
MacBook Pro OS : Catalina 10.15 CPU : Intel Core i5 2.3GHz Memory : 8GB 2133MHz
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.
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
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).
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.
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.
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
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.
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
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.
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
La structure des fichiers du modèle d'apprentissage est essentiellement la suivante.
Lors du démarrage de l'apprentissage par transfert, modifiez le contenu du fichier pipeline.config dans celui-ci et utilisez-le.
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)
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.
La façon de nommer le fichier ici est liée à la configuration du fichier de configuration suivant.
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.
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 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.
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.
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.
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
La visualisation des données d'entraînement est essentielle et Tensorboard est très utile pour ce faire.
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.
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.
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).
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.pyexport_tflite_ssd_graph.py** Pour l'essayer sur Android, il sera converti au format ** .tflite, donc ** utilisez ce dernier **.
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 :ʻ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
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.
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
Cela fait longtemps, mais c'est enfin en production.
Tout d'abord, installons "Android Studio". Si vous trouvez d'autres outils plus faciles à utiliser, vous pouvez les utiliser.
Ensuite, téléchargez la collection d'échantillons auprès du responsable.
$ git clone --depth 1 https://github.com/tensorflow/examples.git
Après avoir lancé Android Studio, ouvrez ʻexamples / lite / examples / object_detection / android`.
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 «???».
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
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
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.