[PYTHON] "Deep Learning from Grund" Memo zum Selbststudium (Nr. 17) Ich habe versucht, DeepConvNet mit Keras zu erstellen

Während ich "Deep Learning from Grund" (gelesen von Yasuki Saito, veröffentlicht von O'Reilly Japan) lese, werde ich die Websites notieren, auf die ich mich bezog. Teil 16

DeepConvNet Lassen Sie uns DeepConvNet mit Keras erstellen, wie auf Seite 241 des Buches beschrieben.

g8-1.jpg

Ich frage mich, ob es viele Ebenen gibt und es dort tief ist, aber ich bin mir nicht sicher, warum dies die Erkennungsgenauigkeit verbessert.

Aber

Sie können das Beispielskript imitieren und ausführen.

Ich versuchte es.

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, Dropout

#Hilfsbibliothek importieren
import numpy as np
import matplotlib.pyplot as plt

from mnist import load_mnist
#Daten lesen
(x_train, t_train), (x_test, t_test) = load_mnist(flatten=False)
X_train = x_train.transpose(0,2,3,1)
X_test = x_test.transpose(0,2,3,1)
input_shape=(28,28,1)
filter_num = 16
filter_size = 3
filter_stride = 1
filter_num2 = 32
filter_num3 = 64
pool_size_h=2
pool_size_w=2
pool_stride=2
d_rate = 0.5
hidden_size=100
output_size=10

model = keras.Sequential(name="DeepConvNet")
model.add(keras.Input(shape=input_shape))
model.add(Conv2D(filter_num, filter_size, strides=filter_stride, padding="same", activation="relu", kernel_initializer='he_normal'))
model.add(Conv2D(filter_num, filter_size, strides=filter_stride, padding="same", activation="relu", kernel_initializer='he_normal'))
model.add(MaxPooling2D(pool_size=(pool_size_h, pool_size_w),strides=pool_stride))

model.add(Conv2D(filter_num2, filter_size, strides=filter_stride, padding="same", activation="relu", kernel_initializer='he_normal'))
model.add(Conv2D(filter_num2, filter_size, strides=filter_stride, padding="same", activation="relu", kernel_initializer='he_normal'))
model.add(MaxPooling2D(pool_size=(pool_size_h, pool_size_w),strides=pool_stride))

model.add(Conv2D(filter_num3, filter_size, strides=filter_stride, padding="same", activation="relu", kernel_initializer='he_normal'))
model.add(Conv2D(filter_num3, filter_size, strides=filter_stride, padding="same", activation="relu", kernel_initializer='he_normal'))
model.add(MaxPooling2D(pool_size=(pool_size_h, pool_size_w),strides=pool_stride))

model.add(keras.layers.Flatten())
model.add(Dense(hidden_size, activation="relu", kernel_initializer='he_normal')) 
model.add(Dropout(d_rate))
model.add(Dense(output_size))
model.add(Dropout(d_rate))
model.add(Activation("softmax")) 

#Modell kompilieren
model.compile(loss="sparse_categorical_crossentropy", 
              optimizer="adam", 
              metrics=["accuracy"])

Wenn Sie padding = "same" angeben, hat das Ausgabebild dieselbe Größe wie das Eingabebild.

model.summary()

Model: "DeepConvNet" Layer (type)          Output Shape      Param #


conv2d (Conv2D)        (None, 28, 28, 16)    160
conv2d_1 (Conv2D)       (None, 28, 28, 16)    2320
max_pooling2d (MaxPooling2D) (None, 14, 14, 16)    0
conv2d_2 (Conv2D)       (None, 14, 14, 32)    4640
conv2d_3 (Conv2D)       (None, 14, 14, 32)    9248
max_pooling2d_1 (MaxPooling2 (None, 7, 7, 32)     0
conv2d_4 (Conv2D)       (None, 7, 7, 64)     18496
conv2d_5 (Conv2D)       (None, 7, 7, 64)     36928
max_pooling2d_2 (MaxPooling2 (None, 3, 3, 64)     0
flatten (Flatten)       (None, 576)        0
dense (Dense)         (None, 100)        57700
dropout (Dropout)       (None, 100)        0
dense_1 (Dense)        (None, 10)         1010
dropout_1 (Dropout)      (None, 10)        0
activation (Activation)    (None, 10)        0


Total params: 130,502 Trainable params: 130,502 Non-trainable params: 0

model.fit(X_train, t_train,  epochs=5, batch_size=128)
test_loss, test_acc = model.evaluate(X_test,  t_test, verbose=2)
print('\nTest accuracy:', test_acc)

313/313 - 6s - loss: 0.0313 - accuracy: 0.9902 Test accuracy: 0.9901999831199646

Es scheint richtig zu funktionieren.

Teil 16 ← Klicken Sie hier, um eine Liste der Memos usw. anzuzeigen. Unlesbares Glossar

Recommended Posts

"Deep Learning from Grund" Memo zum Selbststudium (Nr. 17) Ich habe versucht, DeepConvNet mit Keras zu erstellen
"Deep Learning from Grund" Memo zum Selbststudium (Nr. 16) Ich habe versucht, SimpleConvNet mit Keras zu erstellen
"Deep Learning from Grund" Memo zum Selbststudium (Nr. 11) CNN
"Deep Learning from Grund" Memo zum Selbststudium (Nr. 19) Datenerweiterung
Ich habe versucht, Dropout zu erklären
Selbststudien-Memo "Deep Learning from Grund" (Nr. 18) Eins! Miau! Grad-CAM!
Ich habe versucht, Perceptron Teil 1 [Deep Learning von Grund auf neu] zu implementieren.
Selbststudien-Memo "Deep Learning from Grund" (Nr. 15) TensorFlow-Anfänger-Tutorial
"Deep Learning from Grund" Memo zum Selbststudium (Teil 12) Deep Learning
Ich habe versucht, Deep Learning mit Spark × Keras × Docker skalierbar zu machen
Selbststudien-Memo "Deep Learning from Grund" (Nr. 13) Verwenden Sie Google Colaboratory
"Deep Learning from Grund" Memo zum Selbststudium (Nr. 10-2) Anfangswert des Gewichts
"Deep Learning from Grund" Memo zum Selbststudium (Teil 8) Ich habe die Grafik in Kapitel 6 mit matplotlib gezeichnet
"Deep Learning from Grund" Memo zum Selbststudium (Nr. 9) MultiLayerNet-Klasse
"Deep Learning from Grund" Memo zum Selbststudium (10) MultiLayerNet-Klasse
[Deep Learning von Grund auf neu] Ich habe versucht, Sigmoid Layer und Relu Layer zu implementieren
Ich habe versucht, die Strichzeichnung mit Deep Learning aus dem Bild zu extrahieren
Ich habe versucht, Deep Learning mit Spark × Keras × Docker 2 Multi-Host-Edition skalierbar zu machen
Versuchen Sie, ein Deep Learning / Neuronales Netzwerk mit Scratch aufzubauen
Ich habe versucht, in einem tief erlernten Sprachmodell zu schreiben
[Deep Learning von Grund auf neu] Ich habe versucht, die Gradientenbestätigung auf leicht verständliche Weise zu erklären.
"Deep Learning from Grund" Memo zum Selbststudium (Nr. 14) Führen Sie das Programm in Kapitel 4 in Google Colaboratory aus
[Lernnotiz] Deep Learning von Grund auf neu gemacht [Kapitel 7]
[Lernnotiz] Deep Learning von Grund auf neu gemacht [Kapitel 5]
[Lernnotiz] Deep Learning von Grund auf neu gemacht [Kapitel 6]
Deep Learning / Deep Learning von Grund auf neu Kapitel 7 Memo
[Lernnotiz] Deep Learning von Grund auf neu gemacht [~ Kapitel 4]
Ich habe versucht, Deep Learning zu implementieren, das nicht nur mit NumPy tiefgreifend ist
Ich habe versucht, GAN (mnist) mit Keras zu bewegen
Deep Learning von Grund auf neu ① Kapitel 6 "Lerntechniken"
Deep Learning von Grund auf neu Kapitel 2 Perceptron (Memo lesen)
Ich habe versucht, Keras in TFv1.1 zu integrieren
[Lernnotiz] Deep Learning von Grund auf ~ Implementierung von Dropout ~
Deep Learning von Grund auf neu
[Python] [Verarbeitung natürlicher Sprache] Ich habe Deep Learning ausprobiert (auf Japanisch von Grund auf neu erstellt)
Ich habe versucht, tief zu lernen
Ich habe versucht, Cifar10 mit der SONY Deep Learning Library NNabla [Nippon Hurra] zu implementieren.
[Python] Ich habe die gleiche Berechnung versucht wie die Vorhersage von LSTM von Grund auf [Keras]
[Deep Learning von Grund auf neu] Ich habe die Affine-Ebene implementiert
Ich habe versucht, eine ML-Pipeline mit Cloud Composer zu erstellen
Ich habe versucht, Grad-CAM mit Keras und Tensorflow zu implementieren
Ich habe versucht, Pferderennen vorherzusagen, indem ich alles von der Datenerfassung bis zum tiefen Lernen getan habe
Wagen Sie es, mit Ruby zu lernen "Deep Learning from Grund von Grund auf neu" Importieren von Pickle-Dateien aus verbotenem PyCall
Ich habe versucht, mit Python (Mac OS X) eine Umgebung für maschinelles Lernen zu erstellen.
Erstellen Sie mit Docker eine Umgebung für "Deep Learning von Grund auf neu"
Mayungos Python Learning Episode 3: Ich habe versucht, Zahlen zu drucken
Ich habe versucht, ListNet of Rank Learning mit Chainer zu implementieren
Ich habe das Toho-Projekt mit Deep Learning aufgenommen ... ich wollte.
Ich habe versucht, Othello AI zu machen, dass ich 7,2 Millionen Hände durch tiefes Lernen mit Chainer gelernt habe
Ein Memo bei der Ausführung des Beispielcodes von Deep Learning, der mit Google Colaboratory von Grund auf neu erstellt wurde
Deep Learning / Deep Learning von Grund auf neu 2 Kapitel 4 Memo
Ich habe versucht, Deep VQE zu implementieren
Deep Learning / Deep Learning von Null 2 Kapitel 5 Memo
[Python] Ein Memo, das ich versucht habe, mit Asyncio zu beginnen
Tiefes Lernen von Grund auf neu (Kostenberechnung)
Ich habe mit ChainerRL Deep Enforcement Learning (Double DQN) ausprobiert
Ich las "Das Lernen mit Python von der Einführung bis zur Praxis stärken", Kapitel 1
Deep Learning / Deep Learning von Null 2 Kapitel 7 Memo