web-dev-qa-db-fra.com

Quantifier un modèle de réseau neuronal Keras

Récemment, j'ai commencé à créer des réseaux de neurones avec Tensorflow + Keras et je voudrais essayer la fonctionnalité de quantification disponible dans Tensorflow. Jusqu'à présent, l'expérimentation d'exemples de didacticiels TF a très bien fonctionné et j'ai cet exemple de travail de base (de https://www.tensorflow.org/tutorials/keras/basic_classification ):

import tensorflow as tf
from tensorflow import keras

fashion_mnist = keras.datasets.fashion_mnist
(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()

# fashion mnist data labels (indexes related to their respective labelling in the data set)
class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

# preprocess the train and test images
train_images = train_images / 255.0
test_images = test_images / 255.0

# settings variables
input_shape = (train_images.shape[1], train_images.shape[2])

# create the model layers
model = keras.Sequential([
keras.layers.Flatten(input_shape=input_shape),
keras.layers.Dense(128, activation=tf.nn.relu),
keras.layers.Dense(10, activation=tf.nn.softmax)
])

# compile the model with added settings
model.compile(optimizer=tf.train.AdamOptimizer(),
          loss='sparse_categorical_crossentropy',
          metrics=['accuracy'])

# train the model
epochs = 3
model.fit(train_images, train_labels, epochs=epochs)

# evaluate the accuracy of model on test data
test_loss, test_acc = model.evaluate(test_images, test_labels)
print('Test accuracy:', test_acc)

Maintenant, je voudrais utiliser la quantification dans le processus d'apprentissage et de classification. La documentation de quantification ( https://www.tensorflow.org/performance/quantization ) (la page n'est plus disponible depuis le 15 septembre 2018 cca) suggère d'utiliser ce morceau de code:

loss = tf.losses.get_total_loss()
tf.contrib.quantize.create_training_graph(quant_delay=2000000)
optimizer = tf.train.GradientDescentOptimizer(0.00001)
optimizer.minimize(loss)

Cependant, il ne contient aucune information sur où ce code doit être utilisé ou comment il doit être connecté à un code TF (sans même mentionner un modèle de haut niveau créé avec Keras). Je n'ai aucune idée de la façon dont cette partie de quantification est liée au modèle de réseau neuronal précédemment créé. Le simple fait de l'insérer en suivant le code du réseau neuronal entraîne l'erreur suivante:

Traceback (most recent call last):
  File "so.py", line 41, in <module>
    loss = tf.losses.get_total_loss()
  File "/usr/local/lib/python3.5/dist-packages/tensorflow/python/ops/losses/util.py", line 112, in get_total_loss
    return math_ops.add_n(losses, name=name)
  File "/usr/local/lib/python3.5/dist-packages/tensorflow/python/ops/math_ops.py", line 2119, in add_n
    raise ValueError("inputs must be a list of at least one Tensor with the "
ValueError: inputs must be a list of at least one Tensor with the same dtype and shape

Est-il possible de quantifier un modèle Keras NN de cette manière ou est-ce que je manque quelque chose de basique? Une solution possible qui m'a traversé l'esprit pourrait être d'utiliser l'API TF de bas niveau au lieu de Keras (nécessitant un peu de travail pour construire le modèle), ou peut-être d'essayer d'extraire certaines des méthodes de niveau inférieur des modèles Keras.

pythontensorflowneural-networkkerasquantization
16
sikr_

Comme votre réseau semble assez simple, vous pouvez peut-être utiliser Tensorflow lite .

1
Baptiste Pouthier

Tensorflow lite peut être utilisé pour quantifier le modèle de kéros.

Le code suivant a été écrit pour tensorflow 1.14. Cela pourrait ne pas fonctionner pour les versions antérieures.

Tout d'abord, après avoir entraîné le modèle, vous devez enregistrer votre modèle dans h5

model.fit(train_images, train_labels, epochs=epochs)

# evaluate the accuracy of model on test data
test_loss, test_acc = model.evaluate(test_images, test_labels)
print('Test accuracy:', test_acc)
model.save("model.h5"

Pour charger le modèle de keras, utilisez tf.lite.TFLiteConverter.from_keras_model_file

converter  = tf.lite.TFLiteConverter.from_keras_model_file("model.h5")
tflite_model = converter.convert()
# Save the model to file
with open("tflite_model.tflite", "wb") as output_file:
    output_file.write(tflite_model)

Le modèle enregistré peut être chargé dans python ou dans d'autres plates-formes et langages. Pour utiliser le modèle tflite enregistré, tensorlfow.lite fournit Interpreter . L'exemple suivant de - ici montre comment charger le modèle tflite à partir d'un fichier local en utilisant les scripts python.

import numpy as np
import tensorflow as tf

# Load TFLite model and allocate tensors.
interpreter = tf.lite.Interpreter(model_path="tflite_model.tflite")
interpreter.allocate_tensors()

# Get input and output tensors.
input_details = interpreter.get_input_details()
output_details = interpreter.get_output_details()

# Test model on random input data.
input_shape = input_details[0]['shape']
input_data = np.array(np.random.random_sample(input_shape), dtype=np.float32)
interpreter.set_tensor(input_details[0]['index'], input_data)

interpreter.invoke()

# The function `get_tensor()` returns a copy of the tensor data.
# Use `tensor()` in order to get a pointer to the tensor.
output_data = interpreter.get_tensor(output_details[0]['index'])
print(output_data)
0
Mitiku

Comme mentionné dans d'autres réponses, TensorFlow Lite peut vous aider avec la quantification du réseau.

TensorFlow Lite fournit plusieurs niveaux de support pour la quantification.

La quantification post-entraînement Tensorflow Lite quantifie facilement les poids et les activations après l'entraînement. La formation axée sur la quantification permet la formation de réseaux qui peuvent être quantifiés avec une baisse de précision minimale; ceci n'est disponible que pour un sous-ensemble d'architectures de réseaux de neurones convolutifs.

Donc, d'abord, vous devez décider si vous avez besoin de quantification post-formation ou formation consciente de la quantification . Par exemple, si vous avez déjà enregistré le modèle en tant que fichiers * .h5, vous voudrez probablement suivre les instructions de @ Mitiku et effectuer la quantification post-formation.

Si vous préférez obtenir des performances plus élevées en simulant l'effet de la quantification dans la formation (en utilisant la méthode que vous avez citée dans la question), et votre modèle est dans le sous-ensemble de l'architecture CNN pris en charge par une formation prenant en compte la quantification, cet exemple peut vous aider en termes d'interaction entre Keras et TensorFlow. Fondamentalement, il vous suffit d'ajouter ce code entre la définition du modèle et son ajustement:

sess = tf.keras.backend.get_session()
tf.contrib.quantize.create_training_graph(sess.graph)
sess.run(tf.global_variables_initializer())
0
Jianyu