[PYTHON] Implémenter TensorFlow Lite sur Mac [édition 2019]

Je vais vous expliquer le déroulement jusqu'à l'exécution de TensorFlow Lite sur Mac.

environnement

L'environnement dont le fonctionnement a été confirmé est le suivant. · MacOS Catalina version 10.15 ・ Python 3.7.4 ・ Conda 4.7.12 ・ TensorFlow 1.15.0 ・ Keras 2.2.4

Environnement

Installez Anaconda à partir de l'URL suivante https://www.anaconda.com/distribution/ Double-cliquez sur le package d'installation téléchargé pour le démarrer. Acceptez les conditions d'utilisation, choisissez la destination de sauvegarde et installez. Lancez Jupyter Notebook depuis la maison. Décidez où vous voulez travailler et créez un fichier ipynb avec NOUVEAU → Python3. Lorsque vous ouvrez le fichier, vous serez redirigé vers l'écran où vous pouvez écrire un programme comme celui-ci. J'écrirai le programme ici. Ensuite, installez le package pour faire fonctionner TensorFlow. Créez un nouvel environnement en sélectionnant "Enviroments" → "Créer". Non requis lors de l'utilisation de base (root). Modifiez les critères de recherche sur "Non installé" et recherchez "flux tensoriel". Sélectionnez ensuite "keras" et "tensorflow" du package qui apparaît et cliquez sur Appliquer. Démarrez Jupyter comme précédemment et écrivez et exécutez le programme comme suit. L'exécution est "contrôle + Entrée" ou "Maj + Entrée". Vous pouvez voir qu'il n'y a pas d'erreurs. L'utilisation est à peu près comme ça.

Postscript Faites également installer nomkl, matplotlib et oreiller. nomkl semble empêcher le noyau de mourir lors de l'exécution de tensorflow. matplotlib est utilisé pour afficher des images. oreiller est utilisé pour charger des images.

Construire un modèle

Pour générer un modèle TensorFlow Lite, vous devez d'abord créer un modèle TensorFlow. Cette fois, nous utiliserons un ensemble de données appelé cifar10. https://www.cs.toronto.edu/~kriz/cifar.html cifar10 est un ensemble de données étiqueté avec 60 000 images. Il est divisé en avions, voitures, oiseaux, chats, cerfs, chiens, grenouilles, chevaux, bateaux et camions. Nous allons former cela et créer un modèle qui peut classer les images.

Vous trouverez ci-dessous le code pour entraîner l'image. Le nombre d'époques étant fixé à 20, cela prend beaucoup de temps.

"""
Importer les bibliothèques requises et pré-traiter les images
"""
from keras.models import Sequential
from keras.layers.convolutional import Conv2D
from keras.layers.pooling import MaxPool2D
from keras.layers.core import Dense,Activation,Dropout,Flatten
from keras.datasets import cifar10
from keras.utils import np_utils

 #Télécharger cifar10
(x_train,y_train),(x_test,y_test)=cifar10.load_data()

#Image 0-Normaliser dans la plage de 1
x_train=x_train.astype('float32')/255.0
x_test=x_test.astype('float32')/255.0

#Une étiquette de réponse correcte-Convertir en expression chaude
y_train=np_utils.to_categorical(y_train,10)
y_test=np_utils.to_categorical(y_test,10)

"""
Créer un modèle pour TensorFlow
"""
model=Sequential()

model.add(Conv2D(32,(3,3),padding='same',input_shape=(32,32,3)))
model.add(Activation('relu'))
model.add(Conv2D(32,(3,3),padding='same'))
model.add(Activation('relu'))
model.add(MaxPool2D(pool_size=(2,2)))
model.add(Dropout(0.25))

model.add(Conv2D(64,(3,3),padding='same'))
model.add(Activation('relu'))
model.add(Conv2D(64,(3,3),padding='same'))
model.add(Activation('relu'))
model.add(MaxPool2D(pool_size=(2,2)))
model.add(Dropout(0.25))

model.add(Flatten())
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(10,activation='softmax'))

model.compile(optimizer='adam',loss='categorical_crossentropy',metrics=['accuracy'])

history=model.fit(x_train,y_train,batch_size=128,nb_epoch=20,verbose=1,validation_split=0.1)

#Enregistrer le modèle et le poids
json_string=model.to_json()
open('cifar10_cnn.json',"w").write(json_string)
model.save_weights('cifar10_cnn.h5')
model.save('cifar10_cnn_model.h5')

#Voir le modèle
model.summary()

#Évaluation
score=model.evaluate(x_test,y_test,verbose=0)
print('Test loss:',score[0])
print('Test accuracy:',score[1])

Quand tu cours Je pense que les fichiers "cifar10_cnn.h5" et "cifar10_cnn_model.h5" ont été générés. "Cifar10_cnn.h5" stocke uniquement les poids du modèle et "cifar10_cnn_model.h5" stocke la structure et les poids du modèle. La précision était de 78%. Il semble que la précision peut être améliorée en se référant au site suivant.

Précision 95% avec CIFAR-10-Techniques pour améliorer la précision avec CNN- Atteignez 90% de la précision de validation CIFAR-10 avec un réseau neuronal convolutif à 10 couches

Classer réellement les images

La classification des images sera effectuée à l'aide du modèle enregistré. Tout d'abord, préparez l'image à prédire.

Créez un dossier selon la hiérarchie écrite dans le code, placez-y l'image et exécutez le code suivant.

"""
Prédisez en utilisant les images que vous avez prises
"""
from keras.models import model_from_json
import matplotlib.pyplot as plt
from keras.preprocessing.image import img_to_array, load_img
from tensorflow.python.keras.models import load_model

#Chargement d'image
temp_img=load_img("./images/airplane1.jpeg ",target_size=(32,32))

#Convertir l'image en tableau 0-Normalisé par 1
temp_img_array=img_to_array(temp_img)
temp_img_array=temp_img_array.astype('float32')/255.0
temp_img_array=temp_img_array.reshape((1,32,32,3))

#Charger des modèles et des poids formés
json_string=open('cifar10_cnn.json').read()
model=model_from_json(json_string)
model.compile(optimizer='adam',loss='categorical_crossentropy',metrics=['accuracy'])
model.load_weights('cifar10_cnn.h5')
# model = load_model('cifar10_cnn_model.h5')

#Voir le modèle
model.summary()

#Anticiper l'image
img_pred=model.predict_classes(temp_img_array)
print('\npredict_classes=',img_pred)
print('model=',model)

plt.imshow(temp_img)
plt.title('pred:{}'.format(img_pred))
plt.show()

"""
0 - airplane
1 - automobile
2 - bird
3 - cat
4 - deer
5 - dog
6 - frog
7 - horse
8 - ship
9 - truck
"""

Si tout se passe bien, l'image et le numéro d'index seront affichés. ↑ comme ça Vous pouvez voir que le numéro d'index et l'image correspondent. La classification des images est réussie.

Convertir en modèle pour TensorFlow Lite

Ensuite, convertissez le modèle que vous venez de générer pour TensorFlow Lite.

#Modèle Keras existant(cifar10_cnn_model.h5)À partir du modèle pour TensorFlow Lite(cifar10_cnn.tflite)Créer

import tensorflow as tf

if __name__ == '__main__':
    converter = tf.lite.TFLiteConverter.from_keras_model_file("cifar10_cnn_model.h5")
    tflite_model = converter.convert()
    open("cifar10_cnn.tflite", "wb").write(tflite_model)

L'exécution de ce code générera "cifar10_cnn.tflite". Ceci est le modèle pour TensorFlow Lite.

Utilisons ce modèle pour classer les images.

#Identifiez le genre à partir de l'image d'entrée à l'aide du modèle pour TensorFlow Lite

import tensorflow as tf
import numpy as np
from keras.models import model_from_json
import matplotlib.pyplot as plt
from keras.preprocessing.image import img_to_array, load_img
from tensorflow.python.keras.models import load_model

if __name__ == '__main__':
    # prepara input image
    #Chargement d'image
    temp_img=load_img("./images/dog1.jpeg ",target_size=(32,32))

    #Convertir l'image en tableau 0-Normalisé par 1
    temp_img_array=img_to_array(temp_img)
    img=temp_img_array.astype('float32')/255.0
    img=temp_img_array.reshape((1,32,32,3))

    # load model
    interpreter = tf.lite.Interpreter(model_path="cifar10_cnn.tflite")
    interpreter.allocate_tensors()
    input_details = interpreter.get_input_details()
    output_details = interpreter.get_output_details()

    # set input tensor
    interpreter.set_tensor(input_details[0]['index'], img)

    # run
    interpreter.invoke()

    # get outpu tensor
    probs = interpreter.get_tensor(output_details[0]['index'])

    # print result
    result = np.argmax(probs[0])
    score = probs[0][result]
    print("Index d'image prévu:{} [{:.2f}]".format(result, score)) 
    
    plt.imshow(temp_img)
    plt.title('pred:{}'.format(img_pred))
    plt.show()

"""
0 - airplane
1 - automobile
2 - bird
3 - cat
4 - deer
5 - dog
6 - frog
7 - horse
8 - ship
9 - truck
"""

Si cela fonctionne également, l'image et le numéro d'index seront affichés.

Comparaison de Tensorflow et Tensorflow Lite

La comparaison suivante dépend des données de l'image, veuillez donc l'utiliser comme référence uniquement. Nous avons mesuré le temps nécessaire pour prédire l'image.

Modèle pour keras
Temps écoulé: 0.8839559555053711
Temps écoulé: 0.6288352012634277
Temps écoulé: 0.5877768993377686
Temps écoulé: 0.5789699554443359
Temps écoulé: 0.5908827781677246
Temps écoulé: 0.7207329273223877
Temps écoulé: 0.7104830741882324
Temps écoulé: 0.6035618782043457
Temps écoulé: 0.5244758129119873
Temps écoulé: 0.5348677635192871
Temps écoulé moyen: 0.636454225

Modèle pour Tensorflow Lite
Temps écoulé: 0.27948904037475586
Temps écoulé: 0.05380606651306152
Temps écoulé: 0.022572994232177734
Temps écoulé: 0.06809115409851074
Temps écoulé: 0.07050800323486328
Temps écoulé: 0.06940007209777832
Temps écoulé: 0.12052798271179199
Temps écoulé: 0.17615199089050293
Temps écoulé: 0.12544798851013184
Temps écoulé: 0.027255773544311523
Temps écoulé moyen: 0.101325107

Tensorflow Lite est plus rapide, n'est-ce pas? Cependant, il existe une différence de précision.

Le chat était la seule image imprévisible dans le modèle Keras. D'un autre côté, dans le modèle de Tensorflow Lite, l'avion, l'oiseau, le chat et la grenouille ne pouvaient pas être prédits. Le modèle converti pour Tensorflow Lite semble être considérablement moins précis.

Lorsqu'il était exécuté sur un modèle MNIST avec une précision de 99,4%, il était également prévisible pour les keras et Tensorflow Lite. Lors de l'utilisation de TensorflowLite, il semble nécessaire de préparer un modèle avec une précision assez élevée.

référence

Échantillon officiel de Tensorflow Lite non adapté aux débutants Construisons CNN avec Keras et classifions les images de CIFAR-10