Comment utiliser Keras ~ De la simple génération de modèle à CNN ~

Que faire dans cet article

En deep learning, la procédure de mise en œuvre diffère selon le backend utilisé. Par conséquent, vous apprendrez à l'utiliser en lisant les documents officiels et en vous référant aux ouvrages de référence qui l'expliquent. Cet article explique comment l'utiliser.

Procédure de mise en œuvre lors de l'utilisation de keras

1. Définissez les données d'entraînement

2. Définissez un réseau de plusieurs couches qui mappe les valeurs d'entrée aux valeurs cibles.

3. Configurez le processus d'apprentissage en sélectionnant la fonction de perte, l'optimiseur et les indicateurs à surveiller.

4. Entraînez les données d'entraînement à plusieurs reprises en appelant la méthode d'ajustement du modèle.

Création de l'environnement python Keras

Créez un nouvel environnement virtuel sur anaconda et installez tensorflow et keras. Désormais, il sera exécuté sur l'environnement créé. Procédez comme suit à l'invite anaconda:

conda create -n keras_env python=3.6 #Créer un environnement virtuel
conda activate keras_env #Environnement de commutation
conda install tensorflow==1.12.0
conda isntall keras==2.2.4

Procédure spécifique

Charger le jeu de données

from keras.datasets import imdb

(train_data, train_labels), (test_data, test_labels) = imdb.load_data(num_words=10000)

Prétraitement des données

Vectorisation des données

Toutes les valeurs d'entrée et cible du réseau neuronal doivent être des ** tenseurs de données à virgule flottante. ** Peu importe les données que vous devez traiter, telles que l'audio, les images, le texte, vous devez d'abord les convertir en tenseurs. Pour vectoriser les étiquettes de classification, utilisez *** encoding one-hot ***.

from keras.utils.np_utils import to_categorical

one_hot_train_labels = to_categorical(train_labels)
one_hot_test_labels = to_categorical(test_labels)

Normalisation des données

Les données d'image sont codées sous la forme d'un entier représentant une valeur d'échelle de gris comprise entre 0 et 255. Pour fournir ces données au réseau de neurones, transtypez-les avec le type float32, puis divisez-le par 255 pour le convertir en virgule flottante dans la plage de 0 à 1. Fournir des fonctionnalités avec différentes plages au réseau est un problème à tout prix. Par conséquent, la normalisation est effectuée pour rendre la plage identique. Le processus de soustraction de la valeur moyenne du montant de la caractéristique et de division par l'écart type est effectué. Ensuite, le centre de la quantité d'entités devient 0 et l'écart type devient 1.

Définition du modèle

Définissez la fonction d'activation et le nombre de neurones pour chaque couche. Ajoutez-les avec ʻadd () `dans l'ordre dans lequel vous voulez les propager.

from keras import models
from keras import layers

model = models.Sequential()
model.add(layers.Dense(16, activation='relu', input_shape=(10000,)))
model.add(layers.Dense(16, activation='relu'))
model.add(layers.Dense(1, activation='sigmoid'))
model.add(Dense(200))
model.add(Activation("relu"))

Compiler le modèle

** Sélectionnez l'optimiseur et la fonction de perte. ** Dans les cas suivants, il est spécifié sous forme de chaîne de caractères, mais cela est possible car il fait partie de keras.

model.compile(optimizer='rmsprop',#Spécification des caractères
              loss='binary_crossentropy',
              metrics=['accuracy'])

** Si vous souhaitez spécifier l'argument de paramètre de l'optimiseur **, spécifiez l'instance de la classe d'optimiseur comme indiqué ci-dessous et appelez la méthode.

from keras import optimizers

model.compile(optimizer=optimizers.RMSprop(lr=0.001),#Spécification de la méthode
              loss='binary_crossentropy',
              metrics=['accuracy'])

** Si vous souhaitez utiliser votre propre fonction de perte ou fonction d'index **, spécifiez un objet fonction comme argument du paramètre de perte ou du paramètre de métrique.

from keras import losses
from keras import metrics

model.compile(optimizer=optimizers.RMSprop(lr=0.001),
              loss=losses.binary_crossentropy,
              metrics=[metrics.binary_accuracy])

Validation des paramètres de l'ensemble de données

Pour surveiller le taux de précision lors de l'entraînement d'un modèle avec des données entièrement nouvelles, créez un ensemble de données de validation à l'aide d'un échantillon mis à part de l'ensemble de données d'entraînement d'origine. Dans ce qui suit, lors du prélèvement de 10000 échantillons.

x_val = x_train[:10000] #Extraction des données de vérification
partial_x_train = x_train[10000:] #

y_val = y_train[:10000] #Extraction des données de vérification des réponses correctes
partial_y_train = y_train[10000:]

k vérification de l'intersection fractionnée

Si le nombre de données est petit, les données de vérification seront assez petites. En conséquence, le score de validation peut varier considérablement en fonction des points de données sélectionnés pour la validation et la formation. Autrement dit, selon la méthode de division de l'ensemble de données de vérification, la dispersion du score de vérification devient élevée, entraînant un surapprentissage. La meilleure façon d'éviter cela est de ** k vérification d'intersection fractionnée **. Je ne vais pas l'expliquer en détail, alors vérifiez-le.

Formation modèle

Entraînez 20 époques en 8 mini-lots. Dans de nombreux cas, x correspond aux données d'apprentissage et y aux données de réponse correctes. Surveillez la valeur de la perte et le taux de réponse correct pour les 10000 échantillons mis de côté. Les données de validation sont transmises en tant qu'argument au paramètre validation_data.

history = model.fit(partial_x_train,
                    partial_y_train,
                    epochs=20,
                    batch_size=8,
                    validation_data=(x_val, y_val))

La méthode fit renvoie la sortie entraînée pour chaque époque et la sortie des données de vérification dans un format de dictionnaire. Cette fois, il est enregistré dans l'objet history. Lorsque vous exécutez le code suivant

history_dict = history.history
history_dict.keys()

dict_keys(['val_acc', 'acc', 'val_loss', 'loss']) Sera.

Tracer les valeurs de perte dans les données de formation et de validation

Tracez la valeur de la perte à l'aide de matplotlib. Puisque l'entraînement est enregistré dans l'objet history, appelez-le à partir d'ici. Ajustez les hyper paramètres en fonction de ce résultat.

import matplotlib.pyplot as plt

acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']

epochs = range(1, len(acc) + 1)

# "bo" is for "blue dot"
plt.plot(epochs, loss, 'bo', label='Training loss')
# b is for "solid blue line"
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()

plt.show()

Procédure de reconnaissance d'image avec CNN

Copie de l'image

Créez un dossier pour enregistrer l'image de formation (train) et un dossier pour enregistrer l'image de validation (validation), et copiez et triez les images collectées pour une utilisation dans l'apprentissage. Le nombre d'images dans les données de vérification est déterminé par le nombre d'images, mais il est recommandé de l'ajuster à environ 20% à 40% du nombre total d'images. Spécifiez le chemin du dossier créé ici dans le chemin du dossier de flow_from_directory () qui apparaît dans le processus de prétraitement ultérieur.

Instanciation CNN

from keras import layers
from keras import models

model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(Dense(2))
model.add(Activation("softmax"))

La forme du tenseur d'entrée de CNN est (image_height, image_width, image_channels). Le troisième argument est le nombre de canaux d'image. Dans le cas des images RVB, le nombre de canaux est de 3. Conv2D (profondeur de la fonction de sortie, taille du filtre) Si l'argument de padding = 'same' est spécifié, la largeur et la hauteur de la sortie sont complétées de sorte qu'elles soient identiques à l'entrée. En passant, vous pouvez vérifier le modèle créé par model.summary (). Dans le cas de la classification d'images, la couche finale est «Dense» (couche entièrement connectée) et le nombre de classes à classer est spécifié dans l'argument. Puisque la sortie est la probabilité de jugement, sélectionnez softmax comme fonction de perte.

Compiler le modèle

Fonction de perte et paramètres d'optimisation.

from keras import optimizers

model.compile(loss='binary_crossentropy',
              optimizer=optimizers.RMSprop(lr=1e-4),
              metrics=['acc'])

Prétraitement des données

Avant que les données puissent être fournies au CNN, elles doivent être correctement traitées comme un tenseur à virgule flottante. La procédure est la suivante,

1. 1. Charger le fichier image
2. Décodez le contenu d'un fichier JPEG en une grille de pixels RVB.
3. 3. Convertissez ces pixels en tenseurs à virgule flottante.
4. Remettez à l'échelle en pixels (0 à 255) et définissez des valeurs dans la plage [0,1]. keras dispose d'un utilitaire qui gère automatiquement les étapes ci-dessus. Vous pouvez utiliser la classe ʻImageDataGenerator` pour configurer un générateur python qui peut convertir automatiquement des fichiers image sur disque en un lot de tenseurs prétraités.

Charger des images à partir d'un répertoire à l'aide d'ImageDataGenerator

from keras.preprocessing.image import ImageDataGenerator

# All images will be rescaled by 1./255
train_datagen = ImageDataGenerator(rescale=1./255)
test_datagen = ImageDataGenerator(rescale=1./255)

train_generator = train_datagen.flow_from_directory(
        # This is the target directory
        train_dir,
        # All images will be resized to 150x150
        target_size=(150, 150),
        batch_size=20,
        # Since we use binary_crossentropy loss, we need binary labels
        class_mode='binary')

validation_generator = test_datagen.flow_from_directory(
        validation_dir,
        target_size=(150, 150),
        batch_size=20,
        class_mode='binary')

Formation modèle

Utilisez la fonction fit_generator () pour entraîner le modèle. steps_per_epoch est le nombre d'étapes à effectuer dans une époque. validation_steps indique combien d'images sont validées à une époque.

history = model.fit_generator(
      train_generator,
      steps_per_epoch=10,
      epochs=30,
      validation_data=validation_generator,
      validation_steps=5)

Stockage en réseau

Utilisez la fonction save () pour sauvegarder les paramètres du réseau formé. Dans keras, il est enregistré sous forme de fichier avec l'extension .h5. Si vous appelez le fichier h5, vous pouvez prédire l'image avec ce paramètre à partir de la prochaine fois.

model.save('cats_and_dogs_small_1.h5')

Graphique du taux de réponse correct

import matplotlib.pyplot as plt

acc = history.history['acc']
val_acc = history.history['val_acc']
loss = history.history['loss']
val_loss = history.history['val_loss']

epochs = range(len(acc))

plt.plot(epochs, acc, 'bo', label='Training acc')
plt.plot(epochs, val_acc, 'b', label='Validation acc')
plt.title('Training and validation accuracy')
plt.legend()

plt.figure()

plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.legend()

plt.show()

Estimation sur le réseau enregistré

Modifiez simplement la partie définie sur model = models.Sequential () comme suit. Spécifiez le chemin du fichier réseau enregistré dans l'argument de load_model. Puisque le réseau formé est utilisé, le système ʻadd () `qui était utilisé au moment de l'apprentissage est inutile. Le modèle entraîné est chargé tel quel.

model=keras.models.load_model('cats_and_dogs_small_1.h5')

référence

https://qiita.com/GushiSnow/items/8c946208de0d6a4e31e7#%E5%85%B7%E4%BD%93%E7%9A%84%E3%81%AA%E5%AE%9F%E8%A3%85%E4%BE%8B https://qiita.com/tsunaki/items/608ff3cd941d82cd656b https://qiita.com/tomo_20180402/items/e8c55bdca648f4877188 https://ymgsapo.com/2019/02/28/keras-dog-and-cat/