Introduction à la création d'IA avec Python! Partie 3 J'ai essayé de classer et de prédire les images avec un réseau de neurones convolutifs (CNN)

À propos de cet article

Suite de l'article précédent .

Je voudrais classer les images en utilisant le réseau de neurones convolutifs (CNN). Dans la partie 1 de cet article, nous avons classé des images numériques manuscrites à l'aide d'un réseau de neurones. CNN permet une classification plus précise.

Qu'est-ce qu'un réseau de neurones convolutifs (CNN)?

C'est l'un des modèles d'apprentissage en profondeur les plus couramment utilisés pour travailler avec des images. En plus du réseau de neurones habituel Il est appelé "réseau neuronal convolutif" car il ajoute un processus appelé "convolution".

Qu'est-ce que le "processus de pliage"?

Ces dernières années, la qualité d'image des appareils photo des smartphones est devenue plus élevée et une caméra a plusieurs Mo. Si vous l'utilisez pour cet apprentissage, cela prendra beaucoup de temps car il a trop de capacité. Pour augmenter l'efficacité de l'apprentissage, vous devez réduire la taille de l'image.

Cependant, il ne suffit pas de réduire simplement la capacité. Si vous le réduisez et que les caractéristiques de l'image disparaissent Je ne sais pas ce qu'est l'image et ça n'a pas de sens.

__Folding est le processus de compression tout en conservant les caractéristiques des données d'image d'origine.

Plus précisément, la procédure est la suivante.

1. L'image est décomposée en parties appelées "noyau" dans le "calque de pliage".
2. Créez une "carte des caractéristiques" en multipliant plusieurs "noyaux".
3. Réduisez encore la taille de la «carte des caractéristiques» créée avec la «couche de regroupement».

Enfin, convertissez-le en données de tableau à 1 dimension et Le flux consiste à apprendre avec un réseau de neurones.

À propos de l'environnement de construction

Dans cet article, nous l'exécuterons dans un environnement Google Colaboratory. De plus, la version de tensorflow est la 1.13.1. Si vous souhaitez rétrograder, vous pouvez utiliser la commande suivante. !pip install tensorflow==1.13.1

Importer la bibliothèque

J'utiliserai également tensorflow.keras cette fois.

from tensorflow.keras.datasets import cifar10
from tensorflow.keras.layers import Activation, Dense, Dropout, Conv2D, Flatten, MaxPool2D
from tensorflow.keras.models import Sequential, load_model
from tensorflow.keras.optimizers import Adam
from tensorflow.keras.utils import to_categorical
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

Préparation des données d'image

Les données d'image sont téléchargées avec la bibliothèque cifar10. (train_images, train_labels) est l'image de la formation et l'étiquette correcte (test_images, test_labels) est l'image et l'étiquette correcte pour la vérification.

(train_images, train_labels), (test_images, test_labels) = cifar10.load_data()

Vérifiez la forme du jeu de données. Vous pouvez voir qu'il y a 50 000 images RVB 32 pixels (32 x 32 x 3) pour la formation et 10 000 pour la vérification.

Vérifions également le contenu de l'image.

Étiquette de réponse correcte de l'image ↓

La signification de chaque nombre est la suivante.

Libellé "0": avion Étiquette "1": automobile Étiquette «2»: oiseau Étiquette "3": chat Étiquette «4»: cerf Étiquette «5»: chien Étiquette «6»: grenouille Étiquette "7": cheval Étiquette «8»: navire Étiquette "9": camion

Prétraitement de l'ensemble de données

Le contenu de train_images est le suivant Contient des nombres de 0 à 255. (À cause de RVB) Pour normaliser cela, divisez-le uniformément par 255.

Dans un réseau neuronal normal J'ai dû changer les données d'entraînement en une dimension, Puisqu'il est nécessaire de saisir des données 3D dans le processus de convolution, seul le processus de normalisation est OK.

train_images = train_images.astype('float32')/255.0
test_images = test_images.astype('float32')/255.0

Modifiez également l'étiquette de réponse correcte en expression One-Hot avec to_categorical.

train_labels = to_categorical(train_labels, 10)
test_labels = to_categorical(test_labels, 10)

La modélisation

La modélisation est le code suivant.

model = Sequential()

#Premier processus de convolution (Conv → Conv → Pool → Dropout)
model.add(Conv2D(32, (3, 3), activation='relu', padding='same', input_shape=(32, 32, 3)))
model.add(Conv2D(32, (3, 3), activation='relu', padding='same'))
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

#Deuxième processus de convolution (Conv → Conv → Pool → Dropout)
model.add(Conv2D(64, (3, 3), activation='relu', padding='same'))
model.add(Conv2D(64, (3, 3), activation='relu', padding='same'))
model.add(MaxPool2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

#Classification par réseau de neurones (Flatten → Dense → Dropout → Dense)
model.add(Flatten())
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(10, activation='softmax'))

Je vais expliquer chacun d'eux. Tout d'abord, créez un modèle séquentiel avec `` model = Sequential () ''.

Vient ensuite le processus de convolution. Cette fois, après avoir effectué deux fois le processus de pliage, Je voudrais classer par un réseau de neurones.

Je vais vous expliquer le premier processus de convolution. Tout d'abord, avec model.add (Conv2D (32, (3, 3), activation = 'relu' ', padding =' same ', input_shape = (32, 32, 3))) Créez une couche de convolution. Nous transmettons le nombre de noyaux, la taille du noyau, la fonction d'activation, le remplissage et la taille d'entrée à Conv2D. Le nombre de noyaux est de 32, la taille est de 3x3, la fonction d'activation est relu et le remplissage est le même processus consistant à enfermer la carte de caractéristiques créée dans 0.

La carte des caractéristiques créée par le processus ci-dessus Avec model.add (Conv2D (32, (3, 3), activation = 'relu' ', padding =' same ')) En outre, créez une carte d'entités qui extrait les entités de la couche de convolution.

Vient ensuite la couche de mise en commun. Compressez l'image avec `` model.add (MaxPool2D (pool_size = (2, 2))) ''. MaxPool2D est une méthode appelée MAX pooling. La taille est la taille après compression.

Finalement, model.add (Dropout (0.25)) pour invalider avec abandon, Le premier processus de convolution est terminé.

Faites le même processus encore et ensuite Convertissez en une dimension avec `` model.add (Flatten ()) '' et Effectue une prédiction de classification d'un réseau neuronal normal.

Processus de conversion en modèle TPU

Avant de compiler le modèle Convertissez le modèle créé en modèle TPU.

Vous pouvez compiler et apprendre tel quel, Parce que le réseau de neurones convolutifs nécessite une énorme quantité de calcul Cela prend beaucoup de temps s'il n'est pas traité par TPU.

Suivez les étapes ci-dessous pour convertir.

#Conversion en modèle TPU
import tensorflow as tf
import os
tpu_model = tf.contrib.tpu.keras_to_tpu_model(
    model,
    strategy=tf.contrib.tpu.TPUDistributionStrategy(
        tf.contrib.cluster_resolver.TPUClusterResolver(tpu='grpc://' + os.environ['COLAB_TPU_ADDR'])
    )
)

Compiler le modèle

La fonction de perte convient à la classification categorical_crossentopy, Réglez la fonction d'activation sur Adam (le taux d'apprentissage est de 0,001) et l'indice d'évaluation sur acc (taux de réponse correct).

tpu_model.compile(loss='categorical_crossentropy', optimizer=Adam(lr=0.001), metrics=['acc'])

Apprentissage

Vous apprendrez avec le modèle créé. Lors de l'apprentissage avec le modèle TPU, la première fois prend beaucoup de temps, mais la seconde et les suivantes sont rapides. Si vous vous entraînez avec un modèle normal au lieu du TPU, cela prendra plus de deux fois plus de temps.

history = tpu_model.fit(train_images, train_labels, batch_size=128,
    epochs=20, validation_split=0.1)

Affichage graphique des résultats d'apprentissage

Le taux de réponse correcte semble dépasser 90%. C'est assez précis.

plt.plot(history.history['acc'], label='acc')
plt.plot(history.history['val_acc'], label='val_acc')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(loc='best')
plt.show()

Évaluation de l'apprentissage

Lorsque je l'ai essayé avec les données de vérification, le taux de réponse correct est tombé à 71,2%. S'il s'agit d'une nouvelle image, la précision n'est pas si élevée, il semble donc y avoir place à l'amélioration.

test_loss, test_acc = tpu_model.evaluate(test_images, test_labels)
print('loss: {:.3f}\nacc: {:.3f}'.format(test_loss, test_acc ))

inférence

Enfin, l'inférence. Passez l'image et vérifiez quel type de prédiction est fait. Le TPU de Google Colab est composé de 8 cœurs, Vous devez apprendre par un nombre divisible par 8. Par conséquent, je voudrais définir les données d'entraînement sur 16.

#Affichage de l'image déduite
for i in range(16):
    plt.subplot(2, 8, i+1)
    plt.imshow(test_images[i])
plt.show()

#Affichage de l'étiquette déduite
test_predictions = tpu_model.predict(test_images[0:16])
test_predictions = np.argmax(test_predictions, axis=1)[0:16]
labels = ['airplane', 'automobile', 'bird', 'cat', 'deer',
        'dog', 'frog', 'horse', 'ship', 'truck']
print([labels[n] for n in test_predictions])

L'image est petite et difficile à comprendre, Il semble que vous puissiez le prédire. La prochaine fois, je voudrais prédire les mêmes données d'image avec un CNN appelé ResNet.