[PYTHON] "Deep Learning from Grund" Memo zum Selbststudium (Nr. 16) Ich habe versucht, SimpleConvNet mit Keras zu erstellen
Während ich "Deep Learning von Grund auf neu" lese (geschrieben von Yasuki Saito, veröffentlicht von O'Reilly Japan), werde ich die Websites notieren, auf die ich verwiesen habe. Teil 15 ← → Teil 17
Da Google Colab normal verwendet werden kann, werde ich den Inhalt dieses Buches mit TensorFlow testen.
Ich glaube, ich konnte das fünfte Kapitel des Buches mit dem Tutorial "First Neural Network" für Anfänger auf der TensorFlow-Website https://www.tensorflow.org/?hl=ja abdecken. Daher werde ich versuchen, das Äquivalent von SimpleConvNet in Kapitel 7 mit Keras zu erstellen.
Conv1D ? 2D ? 3D ? Ich kann mir vorstellen, dass Conv Nantoka zum Falten verwendet wird, aber es gibt Typen wie 1D 2D 3D, und D ist wahrscheinlich dimensional dimensioniert, sodass 2D 2D für die Bildverarbeitung in Ordnung ist. Bedeutet das? Wenn das der Fall ist, ist das in Ordnung,
Aber
Was ist eine Dimension? Was ist 3D? Ich mache mir darüber Sorgen.
1D sind Zeitreihendaten usw.
Aus der Keras-Dokumentation Wenn Sie diese Ebene als erste Ebene verwenden, geben Sie input_shape (Integer Taple oder None) ein. Beispiel: Für 10 128-dimensionale Vektoren (10, 128), für eine beliebige Anzahl von 128-dimensionalen Vektoren (None, None,) Bitte geben Sie 128)) an.
darüber Es gab so ein Beispiel. Lösen von Zeitreihenvorhersagen mithilfe eindimensionaler Faltung Visualisieren Sie die Ausgabe der eindimensionalen Faltungsschicht für Zeitreihendaten
2D ist ein Bild usw.
Wenn Sie diese Ebene als erste Ebene des Modells verwenden, geben Sie das Schlüsselwortargument input_shape an (ausgenommen ganzzahlige Taples und Beispielachsen). Wenn beispielsweise data_format = "channel_last" ist, ist input_shape = (128, 128, 3) für ein 128 x 128 RGB-Bild.
3D ist ein Raum einschließlich Höhe
Wenn Sie diese Ebene als erste Ebene des Modells verwenden, geben Sie das Schlüsselwortargument input_shape an (ohne ganzzahlige Taples und Beispielachsen). Im Fall von data_format = "channel_last" ist der Einzelkanal 128x128x128 solid input_shape = (128, 128, 128, 1).
Es gab ein solches Beispiel, weil die Daten der Bewegungsrichtung im Raum ebenfalls dreidimensional sind. Verhaltensklassifizierung nach Beschleunigungssensor
Conv2D Convolution2D Parameter Filter, Anzahl der Ausgangsfilter in Faltung kernel_size gibt die Breite und Höhe des Faltungsfilters an. Bei einer einzelnen Ganzzahl handelt es sich um einen quadratischen Kernel Sie können Schritte = (1, 1), vertikale und horizontale Schritte für die Faltung angeben. Für eine einzelne Ganzzahl sind Breite und Höhe ähnliche Schritte padding = 'valid', geben Sie entweder "valid" oder "same" an 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 Geben Sie entweder "canal_last" (Standard) oder "channel_first" an. Dies ist die Reihenfolge der Abmessungen in der Eingabe. Im Fall von "channel_last" ist die Eingabeform "(Stapel, Höhe, Breite, Kanäle)" und im Fall von "channel_first" "(Stapel, Kanäle, Höhe, Breite)".
Wenn Sie umgekehrt darüber nachdenken, sagt Keras, dass die Standardform der Eingabe "customers_last" (Stapel, Höhe, Breite, Kanäle) ist.
damit
Es ist zu beachten, dass die MNIST-Daten, die von "Deep Learning von Grund auf neu" verarbeitet werden, (Stapel, Kanäle, Höhe, Breite) channel_first sind. Selbst wenn ich für diesen Parameter "channel_first" angebe, wird eine Fehlermeldung angezeigt. Immerhin habe ich beschlossen, die Daten zur Verarbeitung in channel_last zu konvertieren.
Informationen zum Auffüllen finden Sie hier → Tensorflow - Auffüllen = Unterschied zwischen GÜLTIG / GLEICH
SimpleConvNet
Erstellen wir SimpleConvNet mit Keras, wie auf Seite 229 des Buches beschrieben.
Da wir in Google Drive gespeicherte MNIST-Daten verwenden, definieren wir die Laufwerksbereitstellung und den Pfad zum Ordner auf dem Laufwerk.
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 und tf.Keras importieren
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers
from keras.layers import Dense, Activation, Flatten, Conv2D, MaxPooling2D
#Hilfsbibliothek importieren
import numpy as np
import matplotlib.pyplot as plt
Lesen Sie die im Laufwerk gespeicherten MNIST-Daten.
from mnist import load_mnist
#Daten lesen
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=False)
x_train.shape
(60000, 1, 28, 28)
(Stapel, Kanäle, Höhe, Breite) Es hat das Format channel_first. Konvertieren Sie dies in (Stapel, Höhe, Breite, Kanäle) channel_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)
Es wurde channel_last. Da das Label t_train ein ganzzahliges Ziel ist, verwenden Sie sparse_categorical_crossentropy für die Verlustfunktion.
"Deep Learning von Grund auf neu" P230 Wie in Abbildung 7-23 dargestellt, lautet die Netzwerkkonfiguration "Convolution --ReLU --Pooling --Affine --ReLU --Affine --Softmax".
Ich habe das mit Keras gebaut. Da relu für die Aktivierungsfunktion verwendet wird, wird he_normal als Anfangswert des Gewichts verwendet.
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"))
#Modell kompilieren
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
Trainiere das Modell.
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
Es wurde eine ziemlich hohe Genauigkeitsrate.
#Vorhersagen
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')
#Zeigt X Testbilder, vorhergesagte Beschriftungen und korrekte Beschriftungen an.
#Richtige Vorhersagen werden blau und falsche Vorhersagen rot angezeigt.
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()
Ich konnte die 9. 5 richtig identifizieren, was ziemlich schwierig ist.
Es gibt auch eine Möglichkeit zum Schreiben, indem Ebenen einzeln gestapelt werden.
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))
Teil 15 ← → Teil 17 Klicken Sie hier, um eine Liste der Memos usw. anzuzeigen. Unlesbares Glossar
Recommended Posts