Classification des images avec TensorFlow Lite Model Maker

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

La bibliothèque de modèles Maker Lite tensorflow simplifie le processus d'adaptation et la conversion d' un modèle de réseau neuronal tensorflow de données d'entrée particulières lors du déploiement de ce modèle pour les applications sur-ML dispositif.

Ce bloc-notes montre un exemple de bout en bout qui utilise cette bibliothèque Model Maker pour illustrer l'adaptation et la conversion d'un modèle de classification d'images couramment utilisé pour classer les fleurs sur un appareil mobile.

Conditions préalables

Pour exécuter cet exemple, nous avons d' abord besoin d'installer plusieurs packages nécessaires, y compris le modèle package Maker que GitHub repo .

pip install -q tflite-model-maker

Importez les packages requis.

import os

import numpy as np

import tensorflow as tf
assert tf.__version__.startswith('2')

from tflite_model_maker import model_spec
from tflite_model_maker import image_classifier
from tflite_model_maker.config import ExportFormat
from tflite_model_maker.config import QuantizationConfig
from tflite_model_maker.image_classifier import DataLoader

import matplotlib.pyplot as plt
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/tensorflow_addons/utils/ensure_tf_install.py:67: UserWarning: Tensorflow Addons supports using Python ops for all Tensorflow versions above or equal to 2.3.0 and strictly below 2.6.0 (nightly versions are not supported). 
 The versions of TensorFlow you are currently using is 2.6.0 and is not supported. 
Some things might work, some things might not.
If you were to encounter a bug, do not file an issue.
If you want to make sure you're using a tested and supported configuration, either change the TensorFlow version or the TensorFlow Addons's version. 
You can find the compatibility matrix in TensorFlow Addon's readme:
https://github.com/tensorflow/addons
  UserWarning,
/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)

Exemple simple de bout en bout

Obtenir le chemin des données

Prenons quelques images pour jouer avec cet exemple simple de bout en bout. Des centaines d'images sont un bon début pour Model Maker, tandis que plus de données pourraient atteindre une meilleure précision.

Downloading data from https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz
228818944/228813984 [==============================] - 3s 0us/step
228827136/228813984 [==============================] - 3s 0us/step

Vous pouvez remplacer image_path avec vos propres dossiers d'image. En ce qui concerne le téléchargement de données vers Colab, vous pouvez trouver le bouton de téléchargement dans la barre latérale gauche illustré dans l'image ci-dessous avec le rectangle rouge. Essayez simplement de télécharger un fichier zip et décompressez-le. Le chemin du fichier racine est le chemin actuel.

Téléverser un fichier

Si vous préférez ne pas télécharger vos images vers le nuage, vous pouvez essayer d'exécuter la bibliothèque locale qui suit le Guide de GitHub.

Exécuter l'exemple

L'exemple se compose simplement de 4 lignes de code comme indiqué ci-dessous, chacune représentant une étape du processus global.

Étape 1. Chargez les données d'entrée spécifiques à une application ML sur l'appareil. Divisez-le en données d'entraînement et en données de test.

data = DataLoader.from_folder(image_path)
train_data, test_data = data.split(0.9)
2021-08-12 11:22:56.386698: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
INFO:tensorflow:Load image with size: 3670, num_label: 5, labels: daisy, dandelion, roses, sunflowers, tulips.
2021-08-12 11:22:56.395523: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 11:22:56.396549: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 11:22:56.398220: I tensorflow/core/platform/cpu_feature_guard.cc:142] This TensorFlow binary is optimized with oneAPI Deep Neural Network Library (oneDNN) to use the following CPU instructions in performance-critical operations:  AVX2 AVX512F FMA
To enable them in other operations, rebuild TensorFlow with the appropriate compiler flags.
2021-08-12 11:22:56.398875: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 11:22:56.400004: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 11:22:56.400967: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 11:22:57.007249: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 11:22:57.008317: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 11:22:57.009214: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 11:22:57.010137: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1510] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 14648 MB memory:  -> device: 0, name: Tesla V100-SXM2-16GB, pci bus id: 0000:00:05.0, compute capability: 7.0

Étape 2. Personnalisez le modèle TensorFlow.

model = image_classifier.create(train_data)
INFO:tensorflow:Retraining the models...
2021-08-12 11:23:00.961952: I tensorflow/compiler/mlir/mlir_graph_optimization_pass.cc:185] None of the MLIR Optimization Passes are enabled (registered 2)
Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
hub_keras_layer_v1v2 (HubKer (None, 1280)              3413024   
_________________________________________________________________
dropout (Dropout)            (None, 1280)              0         
_________________________________________________________________
dense (Dense)                (None, 5)                 6405      
=================================================================
Total params: 3,419,429
Trainable params: 6,405
Non-trainable params: 3,413,024
_________________________________________________________________
None
Epoch 1/5
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/keras/optimizer_v2/optimizer_v2.py:356: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.
  "The `lr` argument is deprecated, use `learning_rate` instead.")
2021-08-12 11:23:04.815901: I tensorflow/stream_executor/cuda/cuda_dnn.cc:369] Loaded cuDNN version 8100
2021-08-12 11:23:05.396630: I tensorflow/core/platform/default/subprocess.cc:304] Start cannot spawn child process: No such file or directory
103/103 [==============================] - 7s 38ms/step - loss: 0.8676 - accuracy: 0.7618
Epoch 2/5
103/103 [==============================] - 4s 41ms/step - loss: 0.6568 - accuracy: 0.8880
Epoch 3/5
103/103 [==============================] - 4s 37ms/step - loss: 0.6238 - accuracy: 0.9111
Epoch 4/5
103/103 [==============================] - 4s 37ms/step - loss: 0.6009 - accuracy: 0.9245
Epoch 5/5
103/103 [==============================] - 4s 37ms/step - loss: 0.5872 - accuracy: 0.9287

Étape 3. Évaluez le modèle.

loss, accuracy = model.evaluate(test_data)
12/12 [==============================] - 2s 45ms/step - loss: 0.5993 - accuracy: 0.9292

Étape 4. Exportez vers le modèle TensorFlow Lite.

Ici, nous exportons tensorflow modèle Lite avec des métadonnées qui fournit une norme pour la description des modèles. Le fichier d'étiquette est intégré aux métadonnées. La technique de quantification post-apprentissage par défaut est la quantification entière pour la tâche de classification d'images.

Vous pouvez le télécharger dans la barre latérale gauche de la même manière que la partie de téléchargement pour votre propre usage.

model.export(export_dir='.')
2021-08-12 11:23:29.239205: W tensorflow/python/util/util.cc:348] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.
INFO:tensorflow:Assets written to: /tmp/tmpg7d7peiv/assets
INFO:tensorflow:Assets written to: /tmp/tmpg7d7peiv/assets
2021-08-12 11:23:32.415310: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 11:23:32.415723: I tensorflow/core/grappler/devices.cc:66] Number of eligible GPUs (core count >= 8, compute capability >= 0.0): 1
2021-08-12 11:23:32.415840: I tensorflow/core/grappler/clusters/single_machine.cc:357] Starting new session
2021-08-12 11:23:32.416303: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 11:23:32.416699: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 11:23:32.417007: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 11:23:32.417414: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 11:23:32.417738: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 11:23:32.418047: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1510] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 14648 MB memory:  -> device: 0, name: Tesla V100-SXM2-16GB, pci bus id: 0000:00:05.0, compute capability: 7.0
2021-08-12 11:23:32.451651: I tensorflow/core/grappler/optimizers/meta_optimizer.cc:1137] Optimization results for grappler item: graph_to_optimize
  function_optimizer: Graph size after: 913 nodes (656), 923 edges (664), time = 17.945ms.
  function_optimizer: function_optimizer did nothing. time = 0.391ms.

2021-08-12 11:23:33.380451: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:351] Ignored output_format.
2021-08-12 11:23:33.380503: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:354] Ignored drop_control_dependency.
2021-08-12 11:23:33.426653: I tensorflow/compiler/mlir/tensorflow/utils/dump_mlir_util.cc:210] disabling MLIR crash reproducer, set env var `MLIR_CRASH_REPRODUCER_DIRECTORY` to enable.
fully_quantize: 0, inference_type: 6, input_inference_type: 3, output_inference_type: 3
WARNING:absl:For model inputs containing unsupported operations which cannot be quantized, the `inference_input_type` attribute will default to the original type.
INFO:tensorflow:Label file is inside the TFLite model with metadata.
INFO:tensorflow:Label file is inside the TFLite model with metadata.
INFO:tensorflow:Saving labels in /tmp/tmpny214hzn/labels.txt
INFO:tensorflow:Saving labels in /tmp/tmpny214hzn/labels.txt
INFO:tensorflow:TensorFlow Lite model exported successfully: ./model.tflite
INFO:tensorflow:TensorFlow Lite model exported successfully: ./model.tflite

Après ces 4 étapes simples, nous pourrions encore utiliser le fichier modèle tensorflow Lite dans des applications sur un dispositif similaire dans la classification d' image application de référence.

Processus détaillé

Actuellement, nous prenons en charge plusieurs modèles tels que les modèles EfficientNet-Lite*, MobileNetV2, ResNet50 en tant que modèles pré-entraînés pour la classification des images. Mais il est très flexible d'ajouter de nouveaux modèles pré-entraînés à cette bibliothèque avec seulement quelques lignes de code.

Ce qui suit parcourt cet exemple de bout en bout étape par étape pour montrer plus de détails.

Étape 1 : Charger les données d'entrée spécifiques à une application de ML sur l'appareil

Le jeu de données de fleurs contient 3670 images appartenant à 5 classes. Téléchargez la version d'archive de l'ensemble de données et décompressez-la.

L'ensemble de données a la structure de répertoire suivante :

flower_photos
|__ daisy
    |______ 100080576_f52e8ee070_n.jpg
    |______ 14167534527_781ceb1b7a_n.jpg
    |______ ...
|__ dandelion
    |______ 10043234166_e6dd915111_n.jpg
    |______ 1426682852_e62169221f_m.jpg
    |______ ...
|__ roses
    |______ 102501987_3cdb8e5394_n.jpg
    |______ 14982802401_a3dfb22afb.jpg
    |______ ...
|__ sunflowers
    |______ 12471791574_bb1be83df4.jpg
    |______ 15122112402_cafa41934f.jpg
    |______ ...
|__ tulips
    |______ 13976522214_ccec508fe7.jpg
    |______ 14487943607_651e8062a1_m.jpg
    |______ ...
image_path = tf.keras.utils.get_file(
      'flower_photos.tgz',
      'https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz',
      extract=True)
image_path = os.path.join(os.path.dirname(image_path), 'flower_photos')

Utilisez DataLoader classe pour les données de charge.

En ce qui concerne from_folder() méthode, on peut charger des données à partir du dossier. Il suppose que les données d'image de la même classe se trouvent dans le même sous-répertoire et que le nom du sous-dossier est le nom de la classe. Actuellement, les images encodées JPEG et les images encodées PNG sont prises en charge.

data = DataLoader.from_folder(image_path)
INFO:tensorflow:Load image with size: 3670, num_label: 5, labels: daisy, dandelion, roses, sunflowers, tulips.
INFO:tensorflow:Load image with size: 3670, num_label: 5, labels: daisy, dandelion, roses, sunflowers, tulips.

Divisez-le en données d'entraînement (80 %), données de validation (10 %, facultatives) et données de test (10 %).

train_data, rest_data = data.split(0.8)
validation_data, test_data = rest_data.split(0.5)

Montrez 25 exemples d'images avec des étiquettes.

plt.figure(figsize=(10,10))
for i, (image, label) in enumerate(data.gen_dataset().unbatch().take(25)):
  plt.subplot(5,5,i+1)
  plt.xticks([])
  plt.yticks([])
  plt.grid(False)
  plt.imshow(image.numpy(), cmap=plt.cm.gray)
  plt.xlabel(data.index_to_label[label.numpy()])
plt.show()

png

Étape 2 : Personnaliser le modèle TensorFlow

Créez un modèle de classificateur d'images personnalisé basé sur les données chargées. Le modèle par défaut est EfficientNet-Lite0.

model = image_classifier.create(train_data, validation_data=validation_data)
INFO:tensorflow:Retraining the models...
INFO:tensorflow:Retraining the models...
Model: "sequential_1"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
hub_keras_layer_v1v2_1 (HubK (None, 1280)              3413024   
_________________________________________________________________
dropout_1 (Dropout)          (None, 1280)              0         
_________________________________________________________________
dense_1 (Dense)              (None, 5)                 6405      
=================================================================
Total params: 3,419,429
Trainable params: 6,405
Non-trainable params: 3,413,024
_________________________________________________________________
None
Epoch 1/5
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/keras/optimizer_v2/optimizer_v2.py:356: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.
  "The `lr` argument is deprecated, use `learning_rate` instead.")
91/91 [==============================] - 7s 59ms/step - loss: 0.8929 - accuracy: 0.7572 - val_loss: 0.6367 - val_accuracy: 0.9091
Epoch 2/5
91/91 [==============================] - 5s 55ms/step - loss: 0.6598 - accuracy: 0.8905 - val_loss: 0.6097 - val_accuracy: 0.9119
Epoch 3/5
91/91 [==============================] - 5s 54ms/step - loss: 0.6221 - accuracy: 0.9141 - val_loss: 0.6016 - val_accuracy: 0.9347
Epoch 4/5
91/91 [==============================] - 5s 59ms/step - loss: 0.6032 - accuracy: 0.9241 - val_loss: 0.5978 - val_accuracy: 0.9318
Epoch 5/5
91/91 [==============================] - 6s 63ms/step - loss: 0.5890 - accuracy: 0.9344 - val_loss: 0.5954 - val_accuracy: 0.9347

Jetez un œil à la structure détaillée du modèle.

model.summary()
Model: "sequential_1"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
hub_keras_layer_v1v2_1 (HubK (None, 1280)              3413024   
_________________________________________________________________
dropout_1 (Dropout)          (None, 1280)              0         
_________________________________________________________________
dense_1 (Dense)              (None, 5)                 6405      
=================================================================
Total params: 3,419,429
Trainable params: 6,405
Non-trainable params: 3,413,024
_________________________________________________________________

Étape 3 : Évaluer le modèle personnalisé

Évaluez le résultat du modèle, obtenez la perte et la précision du modèle.

loss, accuracy = model.evaluate(test_data)
12/12 [==============================] - 2s 37ms/step - loss: 0.6337 - accuracy: 0.9019

Nous avons pu tracer les résultats prédits dans 100 images de test. Les étiquettes prédites de couleur rouge sont les mauvais résultats prédits alors que d'autres sont corrects.

# A helper function that returns 'red'/'black' depending on if its two input
# parameter matches or not.
def get_label_color(val1, val2):
  if val1 == val2:
    return 'black'
  else:
    return 'red'

# Then plot 100 test images and their predicted labels.
# If a prediction result is different from the label provided label in "test"
# dataset, we will highlight it in red color.
plt.figure(figsize=(20, 20))
predicts = model.predict_top_k(test_data)
for i, (image, label) in enumerate(test_data.gen_dataset().unbatch().take(100)):
  ax = plt.subplot(10, 10, i+1)
  plt.xticks([])
  plt.yticks([])
  plt.grid(False)
  plt.imshow(image.numpy(), cmap=plt.cm.gray)

  predict_label = predicts[i][0][0]
  color = get_label_color(predict_label,
                          test_data.index_to_label[label.numpy()])
  ax.xaxis.label.set_color(color)
  plt.xlabel('Predicted: %s' % predict_label)
plt.show()

png

Si la précision ne répond pas à l'exigence de l' application, on peut se référer à Utilisation avancée pour explorer des alternatives telles que la modification d'un modèle plus grand, le réglage des paramètres re-formation , etc.

Étape 4 : Exporter vers le modèle TensorFlow Lite

Convertir le modèle formé à tensorflow format modèle Lite avec des métadonnées afin que vous pouvez ensuite utiliser dans une application ML sur l'appareil. Le fichier d'étiquette et le fichier de vocabulaire sont intégrés dans les métadonnées. Le nom de fichier par défaut TFLite est model.tflite .

Dans de nombreuses applications ML sur appareil, la taille du modèle est un facteur important. Par conséquent, il est recommandé d'appliquer la quantification du modèle pour le rendre plus petit et potentiellement plus rapide. La technique de quantification post-apprentissage par défaut est la quantification entière pour la tâche de classification d'images.

model.export(export_dir='.')
INFO:tensorflow:Assets written to: /tmp/tmpefawktva/assets
INFO:tensorflow:Assets written to: /tmp/tmpefawktva/assets
2021-08-12 11:25:07.871201: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 11:25:07.871638: I tensorflow/core/grappler/devices.cc:66] Number of eligible GPUs (core count >= 8, compute capability >= 0.0): 1
2021-08-12 11:25:07.871768: I tensorflow/core/grappler/clusters/single_machine.cc:357] Starting new session
2021-08-12 11:25:07.872277: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 11:25:07.872639: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 11:25:07.872945: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 11:25:07.873316: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 11:25:07.873619: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 11:25:07.873884: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1510] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 14648 MB memory:  -> device: 0, name: Tesla V100-SXM2-16GB, pci bus id: 0000:00:05.0, compute capability: 7.0
2021-08-12 11:25:07.906980: I tensorflow/core/grappler/optimizers/meta_optimizer.cc:1137] Optimization results for grappler item: graph_to_optimize
  function_optimizer: Graph size after: 913 nodes (656), 923 edges (664), time = 17.977ms.
  function_optimizer: function_optimizer did nothing. time = 0.434ms.

2021-08-12 11:25:08.746578: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:351] Ignored output_format.
2021-08-12 11:25:08.746627: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:354] Ignored drop_control_dependency.
fully_quantize: 0, inference_type: 6, input_inference_type: 3, output_inference_type: 3
WARNING:absl:For model inputs containing unsupported operations which cannot be quantized, the `inference_input_type` attribute will default to the original type.
INFO:tensorflow:Label file is inside the TFLite model with metadata.
INFO:tensorflow:Label file is inside the TFLite model with metadata.
INFO:tensorflow:Saving labels in /tmp/tmp9dnrtkd6/labels.txt
INFO:tensorflow:Saving labels in /tmp/tmp9dnrtkd6/labels.txt
INFO:tensorflow:TensorFlow Lite model exported successfully: ./model.tflite
INFO:tensorflow:TensorFlow Lite model exported successfully: ./model.tflite

Voir exemples d' applications et guides de classification d'images pour plus de détails sur la façon d'intégrer le modèle Lite tensorflow dans les applications mobiles.

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

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

Par défaut, il exporte simplement le modèle TensorFlow Lite avec les métadonnées. Vous pouvez également exporter de manière sélective différents fichiers. Par exemple, exportez uniquement le fichier d'étiquette comme suit :

model.export(export_dir='.', export_format=ExportFormat.LABEL)
INFO:tensorflow:Saving labels in ./labels.txt
INFO:tensorflow:Saving labels in ./labels.txt

Vous pouvez également évaluer le modèle tflite avec la evaluate_tflite méthode.

model.evaluate_tflite('model.tflite', test_data)
{'accuracy': 0.9019073569482289}

Utilisation avancée

La create fonction est la partie critique de cette bibliothèque. Il utilise l' apprentissage de transfert avec un modèle similaire au pré - entraîné tutoriel .

La create la fonction contient les étapes suivantes:

  1. Diviser les données dans la formation, la validation, les données test en fonction du paramètre validation_ratio et test_ratio . La valeur par défaut de validation_ratio et test_ratio sont 0.1 et 0.1 .
  2. Télécharger un vecteur de caractéristiques d'image comme modèle de base de tensorflow Hub. Le modèle pré-entraîné par défaut est EfficientNet-Lite0.
  3. Ajouter une tête de classificateur avec une couche Dropout avec dropout_rate entre la couche de tête et modèle pré-formé. La valeur par défaut dropout_rate est la valeur par défaut dropout_rate valeur de make_image_classifier_lib par tensorflow Hub.
  4. Prétraitez les données d'entrée brutes. Actuellement, les étapes de prétraitement comprennent la normalisation de la valeur de chaque pixel d'image à l'échelle d'entrée du modèle et son redimensionnement à la taille d'entrée du modèle. EfficientNet-Lite0 a l'échelle d'entrée [0, 1] et la taille de l' image d'entrée [224, 224, 3] .
  5. Introduisez les données dans le modèle de classificateur. Par défaut, les paramètres de formation tels que la formation, la taille époques par lots, le taux d' apprentissage, dynamique sont les valeurs par défaut de make_image_classifier_lib par tensorflow Hub. Seul le chef classificateur est formé.

Dans cette section, nous décrivons plusieurs sujets avancés, notamment le passage à un modèle de classification d'images différent, la modification des hyperparamètres d'entraînement, etc.

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)
INFO:tensorflow:Assets written to: /tmp/tmp3tagi8ov/assets
INFO:tensorflow:Assets written to: /tmp/tmp3tagi8ov/assets
2021-08-12 11:33:18.486299: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 11:33:18.486660: I tensorflow/core/grappler/devices.cc:66] Number of eligible GPUs (core count >= 8, compute capability >= 0.0): 1
2021-08-12 11:33:18.486769: I tensorflow/core/grappler/clusters/single_machine.cc:357] Starting new session
2021-08-12 11:33:18.487314: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 11:33:18.487754: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 11:33:18.488070: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 11:33:18.488480: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 11:33:18.488804: I tensorflow/stream_executor/cuda/cuda_gpu_executor.cc:937] successful NUMA node read from SysFS had negative value (-1), but there must be at least one NUMA node, so returning NUMA node zero
2021-08-12 11:33:18.489094: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1510] Created device /job:localhost/replica:0/task:0/device:GPU:0 with 14648 MB memory:  -> device: 0, name: Tesla V100-SXM2-16GB, pci bus id: 0000:00:05.0, compute capability: 7.0
2021-08-12 11:33:18.525503: I tensorflow/core/grappler/optimizers/meta_optimizer.cc:1137] Optimization results for grappler item: graph_to_optimize
  function_optimizer: Graph size after: 913 nodes (656), 923 edges (664), time = 19.663ms.
  function_optimizer: function_optimizer did nothing. time = 0.423ms.
INFO:tensorflow:Label file is inside the TFLite model with metadata.
2021-08-12 11:33:19.358426: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:351] Ignored output_format.
2021-08-12 11:33:19.358474: W tensorflow/compiler/mlir/lite/python/tf_tfl_flatbuffer_helpers.cc:354] Ignored drop_control_dependency.
INFO:tensorflow:Label file is inside the TFLite model with metadata.
INFO:tensorflow:Saving labels in /tmp/tmpyiyio9gh/labels.txt
INFO:tensorflow:Saving labels in /tmp/tmpyiyio9gh/labels.txt
INFO:tensorflow:TensorFlow Lite model exported successfully: ./model_fp16.tflite
INFO:tensorflow:TensorFlow Lite model exported successfully: ./model_fp16.tflite

En Colab, vous pouvez télécharger le modèle nommé model_fp16.tflite dans la barre latérale gauche, même que la partie de téléchargement mentionné ci - dessus.

Changer de modèle

Passez au modèle pris en charge dans cette bibliothèque.

Cette bibliothèque prend désormais en charge les modèles EfficientNet-Lite, MobileNetV2, ResNet50. EfficientNet-Lite sont une famille de modèles de classification des images qui pourraient atteindre une précision l' état de l' art et adapté pour les appareils Edge. Le modèle par défaut est EfficientNet-Lite0.

Nous pourrions changer le modèle à MobileNetV2 en réglant simplement le paramètre model_spec à la spécification du modèle MobileNetV2 en create méthode.

model = image_classifier.create(train_data, model_spec=model_spec.get('mobilenet_v2'), validation_data=validation_data)
INFO:tensorflow:Retraining the models...
INFO:tensorflow:Retraining the models...
Model: "sequential_2"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
hub_keras_layer_v1v2_2 (HubK (None, 1280)              2257984   
_________________________________________________________________
dropout_2 (Dropout)          (None, 1280)              0         
_________________________________________________________________
dense_2 (Dense)              (None, 5)                 6405      
=================================================================
Total params: 2,264,389
Trainable params: 6,405
Non-trainable params: 2,257,984
_________________________________________________________________
None
Epoch 1/5
/tmpfs/src/tf_docs_env/lib/python3.7/site-packages/keras/optimizer_v2/optimizer_v2.py:356: UserWarning: The `lr` argument is deprecated, use `learning_rate` instead.
  "The `lr` argument is deprecated, use `learning_rate` instead.")
91/91 [==============================] - 8s 57ms/step - loss: 0.9474 - accuracy: 0.7486 - val_loss: 0.6713 - val_accuracy: 0.8807
Epoch 2/5
91/91 [==============================] - 5s 54ms/step - loss: 0.7013 - accuracy: 0.8764 - val_loss: 0.6342 - val_accuracy: 0.9119
Epoch 3/5
91/91 [==============================] - 5s 54ms/step - loss: 0.6577 - accuracy: 0.8963 - val_loss: 0.6328 - val_accuracy: 0.9119
Epoch 4/5
91/91 [==============================] - 5s 54ms/step - loss: 0.6245 - accuracy: 0.9176 - val_loss: 0.6445 - val_accuracy: 0.9006
Epoch 5/5
91/91 [==============================] - 5s 55ms/step - loss: 0.6034 - accuracy: 0.9303 - val_loss: 0.6290 - val_accuracy: 0.9091

Évaluez le modèle MobileNetV2 nouvellement formé pour voir la précision et la perte des données de test.

loss, accuracy = model.evaluate(test_data)
12/12 [==============================] - 1s 38ms/step - loss: 0.6723 - accuracy: 0.8883

Passer au modèle dans TensorFlow Hub

De plus, nous pourrions également passer à d'autres nouveaux modèles qui entrent une image et génèrent un vecteur de caractéristiques au format TensorFlow Hub.

Comme Inception V3 modèle à titre d'exemple, on pourrait définir inception_v3_spec qui est un objet de image_classifier.ModelSpec et contient la spécification du modèle V3 Inception.

Nous devons préciser le nom du modèle name , l'URL du modèle Hub tensorflow uri . Pendant ce temps, la valeur par défaut de input_image_shape est [224, 224] . Nous devons changer pour [299, 299] pour le modèle Inception V3.

inception_v3_spec = image_classifier.ModelSpec(
    uri='https://tfhub.dev/google/imagenet/inception_v3/feature_vector/1')
inception_v3_spec.input_image_shape = [299, 299]

Ensuite, en réglant le paramètre model_spec à inception_v3_spec en create la méthode, on pourrait reconvertir le modèle V3 Inception.

Les étapes restantes sont exactement les mêmes et nous pourrions finalement obtenir un modèle InceptionV3 TensorFlow Lite personnalisé.

Changez votre propre modèle personnalisé

Si nous aimerions utiliser le modèle personnalisé qui est pas tensorflow Hub, nous devons créer et exporter ModelSpec dans tensorflow Hub.

Puis commencez à définir ModelSpec objet comme le processus ci - dessus.

Modifier les hyperparamètres d'entraînement

On pourrait aussi changer les hyperparamètres de formation comme epochs , dropout_rate et batch_size qui pourraient affecter la précision du modèle. Les paramètres du modèle que vous pouvez ajuster sont :

  • epochs : plus pourraient obtenir une meilleure époques précision jusqu'à ce qu'il converge , mais une formation trop nombreuses époques peut conduire à surapprentissage.
  • dropout_rate : Le taux de décrochage scolaire, éviter surajustement. Aucun par défaut.
  • batch_size : nombre d'échantillons à utiliser dans une étape de formation. Aucun par défaut.
  • validation_data : Validation des données. Si Aucun, ignore le processus de validation. Aucun par défaut.
  • train_whole_model : Si cela est vrai, le module Hub est formé conjointement avec la couche de classement sur le dessus. Sinon, entraînez uniquement la couche de classification supérieure. Aucun par défaut.
  • learning_rate : Taux d'apprentissage de base. Aucun par défaut.
  • momentum : un flotteur Python transmis à l'optimiseur. Utilisé uniquement lorsque use_hub_library est vrai. Aucun par défaut.
  • shuffle : Boolean, si les données doivent être mélangées. Faux par défaut.
  • use_augmentation : Boolean, l' utilisation augmentation de données pour le prétraitement. Faux par défaut.
  • use_hub_library : Boolean, l' utilisation make_image_classifier_lib de moyeu tensorflow pour recycler le modèle. Ce pipeline d'entraînement pourrait obtenir de meilleures performances pour un ensemble de données compliqué avec de nombreuses catégories. Vrai par défaut.
  • warmup_steps : Nombre d'étapes de warm - up pour le calendrier de warm - up sur le taux d' apprentissage. Si Aucun, le warmup_steps par défaut est utilisé, ce qui correspond au nombre total de pas d'entraînement sur deux époques. Utilisé uniquement lorsque use_hub_library est faux. Aucun par défaut.
  • model_dir : En option, l'emplacement des fichiers de point de contrôle du modèle. Utilisé uniquement lorsque use_hub_library est faux. Aucun par défaut.

Les paramètres par défaut sont Aucun comme les epochs auront les paramètres par défaut concrets dans make_image_classifier_lib de la bibliothèque tensorflow Hub ou train_image_classifier_lib .

Par exemple, nous pourrions nous entraîner avec plus d'époques.

model = image_classifier.create(train_data, validation_data=validation_data, epochs=10)
INFO:tensorflow:Retraining the models...
INFO:tensorflow:Retraining the models...
Model: "sequential_3"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
hub_keras_layer_v1v2_3 (HubK (None, 1280)              3413024   
_________________________________________________________________
dropout_3 (Dropout)          (None, 1280)              0         
_________________________________________________________________
dense_3 (Dense)              (None, 5)                 6405      
=================================================================
Total params: 3,419,429
Trainable params: 6,405
Non-trainable params: 3,413,024
_________________________________________________________________
None
Epoch 1/10
91/91 [==============================] - 7s 57ms/step - loss: 0.8869 - accuracy: 0.7644 - val_loss: 0.6398 - val_accuracy: 0.9006
Epoch 2/10
91/91 [==============================] - 5s 53ms/step - loss: 0.6601 - accuracy: 0.8929 - val_loss: 0.6134 - val_accuracy: 0.9176
Epoch 3/10
91/91 [==============================] - 5s 53ms/step - loss: 0.6273 - accuracy: 0.9121 - val_loss: 0.6068 - val_accuracy: 0.9148
Epoch 4/10
91/91 [==============================] - 5s 53ms/step - loss: 0.6104 - accuracy: 0.9214 - val_loss: 0.6007 - val_accuracy: 0.9205
Epoch 5/10
91/91 [==============================] - 5s 55ms/step - loss: 0.5921 - accuracy: 0.9286 - val_loss: 0.5976 - val_accuracy: 0.9176
Epoch 6/10
91/91 [==============================] - 5s 51ms/step - loss: 0.5745 - accuracy: 0.9409 - val_loss: 0.5940 - val_accuracy: 0.9148
Epoch 7/10
91/91 [==============================] - 4s 49ms/step - loss: 0.5686 - accuracy: 0.9454 - val_loss: 0.5923 - val_accuracy: 0.9148
Epoch 8/10
91/91 [==============================] - 4s 48ms/step - loss: 0.5629 - accuracy: 0.9492 - val_loss: 0.5914 - val_accuracy: 0.9062
Epoch 9/10
91/91 [==============================] - 4s 48ms/step - loss: 0.5592 - accuracy: 0.9485 - val_loss: 0.5892 - val_accuracy: 0.9091
Epoch 10/10
91/91 [==============================] - 4s 48ms/step - loss: 0.5503 - accuracy: 0.9584 - val_loss: 0.5890 - val_accuracy: 0.9176

Évaluez le modèle nouvellement recyclé avec 10 époques d'entraînement.

loss, accuracy = model.evaluate(test_data)
12/12 [==============================] - 1s 32ms/step - loss: 0.6294 - accuracy: 0.9019

Lire la suite

Vous pouvez lire notre classement l' image par exemple pour apprendre les détails techniques. Pour plus d'informations, veuillez vous référer à: