[PYTHON] "Deep Learning from scratch" Mémo d'auto-apprentissage (n ° 16) J'ai essayé de créer SimpleConvNet avec Keras
En lisant "Deep Learning from scratch" (écrit par Yasuki Saito, publié par O'Reilly Japan), je noterai les sites auxquels j'ai fait référence. Partie 15 ← → Partie 17
Puisque Google Colab peut être utilisé normalement, je vais essayer le contenu de ce livre avec TensorFlow.
Je pense que j'ai pu couvrir jusqu'au cinquième chapitre du livre en faisant le tutoriel "First Neural Network" pour les débutants sur le site TensorFlow https://www.tensorflow.org/?hl=ja. Donc, je vais essayer de construire l'équivalent de SimpleConvNet dans le chapitre 7 avec keras.
Conv1D ? 2D ? 3D ? Je peux deviner que Conv Nantoka sera utilisé pour le pliage, mais il existe des types tels que 1D 2D 3D, et D est probablement dimensionnel de dimension, donc le traitement d'image peut être effectué en 2D 2D. Cela signifie t-il? Si c'est le cas, c'est bien,
Mais
Qu'est-ce qu'une dimension? Qu'est-ce que la 3D? Je suis inquiet à ce sujet.
1D correspond aux données de séries chronologiques, etc.
Depuis la documentation Keras Lorsque vous utilisez ce calque comme premier calque, input_shape (entier taple ou Aucun. Par exemple, pour 10 vecteurs de 128 dimensions (10, 128), pour un nombre quelconque de vecteurs de 128 dimensions (Aucun, Aucun,) Veuillez préciser 128)).
à propos de ça Il y avait un tel exemple. Résolution des prédictions de séries chronologiques à l'aide de la convolution unidimensionnelle Visualisez la sortie de la couche de convolution unidimensionnelle pour les données de séries chronologiques
2D est une image, etc.
Lorsque vous utilisez cette couche comme première couche du modèle, spécifiez le mot-clé argument input_shape (à l'exclusion des taples entiers et des exemples d'axes). Par exemple, lorsque data_format = "channels_last", input_shape = (128, 128, 3) pour une image RVB 128x128.
La 3D est un espace incluant la hauteur
Lorsque vous utilisez cette couche comme première couche du modèle, spécifiez le mot-clé argument input_shape (sans compter les taples entiers et les exemples d'axes). Par exemple, dans le cas de data_format = "channels_last", le solide monocanal 128x128x128 est input_shape = (128, 128, 128, 1).
Il y avait un tel exemple parce que les données de la direction du mouvement dans l'espace sont également tridimensionnelles. Classification des comportements par capteur d'accélération
Conv2D Convolution2D Paramètres filtres, nombre de filtres de sortie en convolution kernel_size, spécifie la largeur et la hauteur du filtre de convolution. Pour un seul entier, ce sera un noyau carré Vous pouvez spécifier les foulées = (1, 1), les foulées verticales et horizontales pour la convolution, respectivement. Pour un seul entier, la largeur et la hauteur seront des foulées similaires padding = 'valid', spécifiez "valide" ou "même" data_format=None, dilation_rate=(1, 1), groups=1, activation=None, use_bias=True, kernel_initializer='glorot_uniform', bias_initializer='zeros', kernel_regularizer=None, bias_regularizer=None, activity_regularizer=None, kernel_constraint=None, bias_constraint=None, **kwargs
data_format Spécifiez "channel_last" (par défaut) ou "channels_first". Il s'agit de l'ordre des dimensions dans l'entrée. Dans le cas de "channels_last", la forme d'entrée est "(batch, height, width, channels)", et dans le cas de "channels_first", c'est "(batch, channels, height, width)".
Si vous pensez à l'inverse, Keras dit que la forme par défaut de l'entrée channels_last est (lot, hauteur, largeur, canaux).
donc
Il est à noter que les données MNIST gérées par "Deep Learning from scratch" sont (batch, channels, height, width) channels_first. Cependant, même si je spécifie "channels_first" pour ce paramètre, j'obtiens une erreur. Après tout, j'ai décidé de convertir les données en channels_last pour le traitement.
Pour le remplissage, reportez-vous ici → Tensorflow --padding = Différence entre VALID / SAME
SimpleConvNet
Construisons SimpleConvNet avec Keras décrit à partir de la page 229 du livre.
Puisque nous utilisons des données MNIST stockées dans Google Drive, nous définirons le montage du lecteur et le chemin d'accès au dossier sur le lecteur.
from google.colab import drive
drive.mount('/content/drive')
import sys, os
sys.path.append('/content/drive/My Drive/Colab Notebooks/deep_learning/common')
sys.path.append('/content/drive/My Drive/Colab Notebooks/deep_learning/dataset')
#TensorFlow et tf.importer des keras
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
from keras.layers import Dense, Activation, Flatten, Conv2D, MaxPooling2D
#Importer la bibliothèque d'aide
import numpy as np
import matplotlib.pyplot as plt
Lisez les données MNIST enregistrées dans le lecteur.
from mnist import load_mnist
#Lire les données
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=False)
x_train.shape
(60000, 1, 28, 28)
(lot, canaux, hauteur, largeur) channel_first format. Convertissez-le en (lot, hauteur, largeur, canaux) channels_last.
X_train = x_train.transpose(0,2,3,1)
X_test = x_test.transpose(0,2,3,1)
X_train.shape
(60000, 28, 28, 1)
Il est devenu channel_last. De plus, puisque l'étiquette t_train est un objectif entier, utilisez sparse_categorical_crossentropy pour la fonction de perte.
"Deep Learning from scratch" P230 Comme le montre la Figure 7-23, la configuration du réseau est "Convolution --ReLU --Pooling --Affine --ReLU --Affine --Softmax".
J'ai construit cela avec Keras. Puisque relu est utilisé pour la fonction d'activation, he_normal est utilisé comme valeur initiale du poids.
input_shape=(28,28,1)
filter_num = 30
filter_size = 5
filter_stride = 1
pool_size_h=2
pool_size_w=2
pool_stride=2
hidden_size=100
output_size=10
model = keras.Sequential(name="SimpleConvNet")
model.add(Conv2D(filter_num, filter_size, activation="relu", strides=filter_stride, kernel_initializer='he_normal', input_shape=input_shape))
model.add(MaxPooling2D(pool_size=(pool_size_h, pool_size_w),strides=pool_stride))
model.add(Flatten())
model.add(Dense(hidden_size, activation="relu", kernel_initializer='he_normal'))
model.add(keras.layers.Dense(output_size, activation="softmax"))
#Compiler le modèle
model.compile(loss="sparse_categorical_crossentropy",
optimizer="adam",
metrics=["accuracy"])
model.summary()
Model: SimpleConvNet Layer (type) Output Shape Param
conv2d (Conv2D) (None, 24, 24, 30) 780
max_pooling2d (MaxPooling2D) (None, 12, 12, 30) 0
flatten (Flatten) (None, 4320) 0
dense (Dense) (None, 100) 432100
dense_1 (Dense) (None, 10) 1010
Total params: 433,890 Trainable params: 433,890 Non-trainable params: 0
Entraînez le modèle.
model.fit(X_train, t_train, epochs=5, batch_size=128)
Epoch 1/5 469/469 [==============================] - 27s 58ms/step - loss: 0.2050 - accuracy: 0.9404 Epoch 2/5 469/469 [==============================] - 27s 57ms/step - loss: 0.0614 - accuracy: 0.9819 Epoch 3/5 469/469 [==============================] - 26s 56ms/step - loss: 0.0411 - accuracy: 0.9875 Epoch 4/5 469/469 [==============================] - 27s 58ms/step - loss: 0.0315 - accuracy: 0.9903 Epoch 5/5 469/469 [==============================] - 27s 57ms/step - loss: 0.0251 - accuracy: 0.9927 tensorflow.python.keras.callbacks.History at 0x7f5167581748
C'est devenu un taux de précision assez élevé.
#Prédire
predictions = model.predict(X_test)
class_names = ['0', '1', '2', '3', '4',
'5', '6', '7', '8', '9']
def plot_image(i, predictions_array, t_label, img):
predictions_array = predictions_array[i]
img = img[i].reshape((28, 28))
true_label = t_label[i]
plt.grid(False)
plt.xticks([])
plt.yticks([])
plt.imshow(img, cmap=plt.cm.binary)
predicted_label = np.argmax(predictions_array)
if predicted_label == true_label:
color = 'blue'
else:
color = 'red'
plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label],
100*np.max(predictions_array),
class_names[true_label]),
color=color)
def plot_value_array(i, predictions_array, t_label):
predictions_array = predictions_array[i]
true_label = t_label[i]
plt.grid(False)
plt.xticks([])
plt.yticks([])
thisplot = plt.bar(range(10), predictions_array, color="#777777")
plt.ylim([0, 1])
predicted_label = np.argmax(predictions_array)
thisplot[predicted_label].set_color('red')
thisplot[true_label].set_color('blue')
#Affiche les images de test X, les étiquettes prédites et les étiquettes correctes.
#Les prédictions correctes sont affichées en bleu et les mauvaises prédictions sont affichées en rouge.
num_rows = 5
num_cols = 3
num_images = num_rows*num_cols
plt.figure(figsize=(2*2*num_cols, 2*num_rows))
for i in range(num_images):
plt.subplot(num_rows, 2*num_cols, 2*i+1)
plot_image(i, predictions, t_test, X_test)
plt.subplot(num_rows, 2*num_cols, 2*i+2)
plot_value_array(i, predictions, t_test)
plt.show()
J'ai pu identifier correctement le 9e 5, ce qui est assez difficile.
Il existe également un moyen d'écrire en empilant les couches individuellement.
model = keras.Sequential(name="SimpleConvNet")
model.add(keras.Input(shape=input_shape))
model.add(keras.layers.Convolution2D(filter_num, filter_size, strides=filter_stride, kernel_initializer='he_normal'))
model.add(keras.layers.Activation(tf.nn.relu))
model.add(keras.layers.MaxPooling2D(pool_size=(pool_size_h, pool_size_w),strides=pool_stride))
model.add(keras.layers.Flatten())
model.add(keras.layers.Dense(hidden_size))
model.add(keras.layers.Activation(tf.nn.relu))
model.add(keras.layers.Dense(output_size))
model.add(keras.layers.Activation(tf.nn.softmax))
Partie 15 ← → Partie 17 Cliquez ici pour la liste des mémos, etc. Glossaire illisible
Recommended Posts