Création d'un modèle de discrimination d'image (cifar10) à l'aide d'un réseau neuronal convolutif

introduction

Je suis fumio, un débutant en apprentissage automatique. Je me consacre quotidiennement au plaisir de la programmation et de l'apprentissage par apprentissage automatique.

J'apprends «Apprendre de la suppression de la mosaïque: un apprentissage profond de pointe» écrit par koshian2. Afin d'approfondir ma compréhension de ce que j'ai appris, je voudrais résumer un exemple d'application du réseau neuronal convolutif (CNN) à la discrimination d'image. https://qiita.com/koshian2/items/aefbe4b26a7a235b5a5e

Les principaux points sont les suivants.

• Comprendre la structure des réseaux de neurones convolutifs.
• Convolution de couche + 1 couche Dense Créer un total de 10 couches de modèle de réseau neuronal à convolution.
• Le modèle détermine l'ensemble de données CIFAR-10.

Structure de réseau de neurones convolutifs

Le réseau de neurones convolutifs (CNN) est un réseau de propagation directe qui comprend deux types de couches, la couche convolutive et la couche de regroupement, et est appliqué à la reconnaissance d'images.

• Un réseau neuronal de type à propagation directe n'a pas de connexion en boucle avec le réseau, et le signal se propage uniquement dans une direction telle que couche d'entrée → couche intermédiaire → couche de sortie. D'autre part, les réseaux de neurones récursifs sont à l'opposé et réversibles.

Charger le jeu de données

cifar10.ipynb

import matplotlib.pyplot as plt

cifar_classes = ["airplane", "automobile", "bird", "cat", "deer", "dog", "frog", "horse", "ship", "truck"]

(X_train, y_train),(X_test,y_test) = tf.keras.datasets.cifar10.load_data()
print(X_train.shape,y_train.shape)
print(X_test.shape,y_test.shape)

Downloading data from https://www.cs.toronto.edu/~kriz/cifar-10-python.tar.gz 170500096/170498071 [==============================] - 13s 0us/step (50000, 32, 32, 3) (50000, 1) (10000, 32, 32, 3) (10000, 1)

Lisez directement à partir de l'ensemble de données Keras. Si vous vérifiez les dimensions des données d'entraînement, vous pouvez voir qu'il s'agit de 50 000 données 32 x 32 x 3. Puisqu'il s'agit d'une image couleur, elle est tridimensionnelle.

cifar10.ipynb

fig = plt.figure(figsize=(14,14))
for i in range(100):
  ax = plt.subplot(10,10,i+1)
  ax.imshow(X_train[i])
  ax.axis('off')
  ax.set_title(cifar_classes[y_train[i,0]])

L'image ressemble à ceci. C'est déjà flou depuis le début, mais je peux comprendre la signification de chaque nom et photo. Cependant, vous pouvez voir que certains types sont difficiles à distinguer (cerf et cheval, automobile et camion, etc.).

Qu'est-ce que la mutualisation

Le regroupement dans CNN fait référence à la compression et au sous-échantillonnage des informations. Il est généralement appliqué comme couche de regroupement après la couche convolutionnelle. Les principaux effets sont les suivants.

1. Peut gérer des changements de position minute
2. Le surapprentissage peut être supprimé dans une certaine mesure
3. Le coût de calcul peut être réduit

La sortie dans la couche de regroupement peut être rendue constante même si la position de l'entité correspondant au changement de position en 1. est légèrement déviée. En d'autres termes, si vous prenez un numéro manuscrit comme exemple, vous pouvez lui faire reconnaître qu'il s'agit du même numéro même s'il est légèrement mal aligné.

Créer un modèle de réseau neuronal à 10 couches

Afin de faire cette discrimination CIFAR-10, nous allons créer un modèle avec 9 couches de convolution + 1 couche de couches entièrement connectées pour un total de 10 couches.

• Convitation (Conv) 64ch-> Normalisation des lots (BN) -> Activation (ReLU)) répétition x3-> Mise en commun
• (Conv 128ch -> BN -> ReLU) repeat x3 -> Pooling
• (Conv 256ch -> BN -> ReLU) repeat x3
• Global Average Pooling -> Dense 10 -> Softmax

Créez des modèles dans cet ordre. ReLU est utilisé comme fonction d'activation.

cifar10.ipynb

inputs = layers.Input((32,32,3))
x = inputs

for ch in [64, 128, 256]:
    for i in range(3):
        x = layers.Conv2D(ch, 3, padding="same")(x)
        x = layers.BatchNormalization()(x)
        x = layers.ReLU()(x)
    if ch != 256:
        x = layers.AveragePooling2D()(x)
        
x = layers.GlobalAveragePooling2D()(x)
x = layers.Dense(10, activation="softmax")(x)
model = tf.keras.models.Model(inputs, x)
model.summary()

conv2d_12 (Conv2D) (None, 8, 8, 256) 590080
batch_normalization_12 (Batc (None, 8, 8, 256) 1024
re_lu_12 (ReLU) (None, 32, 32, 256) 0
average_pooling2d_3 (Average (None, 8, 8, 256) 0
global_average_pooling2d_1 ( (None, 256) 0
dense_1 (Dense) (None, 10) 2570

Je n'ai extrait que la dernière partie qui est sortie. Les dimensions changent comme suit. (None,32,32,3)→(None,32,32,64)→(None, 16, 16, 128) →(None, 8, 8, 256)→(None, 256)→(None, 10) Vous pouvez voir que la cote est divisée par deux lors du passage à travers la couche de regroupement.

Préparation du jeu de données

cifar10.ipynb

X_train = X_train.astype(np.float32) / 255.0
X_test = X_test.astype(np.float32) / 255.0
y_train = y_train.astype(np.float32)
y_test = y_test.astype(np.float32)

Ensuite, puisque les données d'origine sont de type unit8 et échelle [0,255], convertissez le type de données en float32 et l'échelle en [0,1].

Apprentissage de modèle

cifar10.ipynb

model.fit(X_train,y_train, validation_data=(X_test, y_test),epochs=10)

Cela peut prendre un certain temps selon les spécifications du PC (les spécifications de mon PC ont pris environ 10 minutes pour chaque époque). Par conséquent, nous vous recommandons de continuer avec l'aide de Google Colab. 　 L'image ci-dessous est le résultat prévu et la bonne réponse. Ce qui est écrit en rouge est incorrect. Je n'ai pris l'époque que 10 fois, donc le taux de réponse erroné était d'environ 38%.

Le programme complet est ici. https://github.com/Fumio-eisan/cifar10_20200308