"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". g7-23.jpg

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()

g7-24.jpg

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

"Deep Learning from scratch" Mémo d'auto-apprentissage (n ° 16) J'ai essayé de créer SimpleConvNet avec Keras
"Deep Learning from scratch" Mémo d'auto-apprentissage (n ° 17) J'ai essayé de créer DeepConvNet avec Keras
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 11) CNN
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 19) Augmentation des données
[Deep Learning from scratch] J'ai essayé d'expliquer le décrochage
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 18) One! Miaou! Grad-CAM!
J'ai essayé d'implémenter Perceptron Part 1 [Deep Learning from scratch]
Mémo d'auto-apprentissage "Deep Learning from scratch" (n ° 15) Tutoriel pour débutants TensorFlow
Mémo d'auto-apprentissage "Deep Learning from scratch" (partie 12) Deep learning
J'ai essayé de rendre le deep learning évolutif avec Spark × Keras × Docker
Mémo d'auto-apprentissage "Deep Learning from scratch" (n ° 13) Essayez d'utiliser Google Colaboratory
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 10-2) Valeur initiale du poids
Mémo d'auto-apprentissage "Deep Learning from scratch" (partie 8) J'ai dessiné le graphique du chapitre 6 avec matplotlib
Mémo d'auto-apprentissage "Deep Learning from scratch" (glossaire illisible)
"Deep Learning from scratch" Mémo d'auto-apprentissage (n ° 9) Classe MultiLayerNet
Mémo d'auto-apprentissage «Deep Learning from scratch» (10) Classe MultiLayerNet
[Deep Learning from scratch] J'ai essayé d'implémenter la couche sigmoïde et la couche Relu
J'ai essayé d'extraire le dessin au trait de l'image avec Deep Learning
J'ai essayé de rendre le deep learning évolutif avec Spark × Keras × Docker 2 Multi-host edition
Essayez de créer un réseau de neurones / d'apprentissage en profondeur avec scratch
J'ai essayé d'écrire dans un modèle de langage profondément appris
[Deep Learning from scratch] J'ai essayé d'expliquer la confirmation du gradient d'une manière facile à comprendre.
"Deep Learning from scratch" Mémo d'auto-apprentissage (n ° 14) Exécutez le programme du chapitre 4 sur Google Colaboratory
[Mémo d'apprentissage] Le Deep Learning fait de zéro [Chapitre 7]
Deep learning / Deep learning made from scratch Chapitre 6 Mémo
[Mémo d'apprentissage] Deep Learning fait de zéro [Chapitre 5]
[Mémo d'apprentissage] Le Deep Learning fait de zéro [Chapitre 6]
Deep learning / Deep learning made from scratch Chapitre 7 Mémo
[Mémo d'apprentissage] Deep Learning fait de zéro [~ Chapitre 4]
J'ai essayé de mettre en œuvre un apprentissage en profondeur qui n'est pas profond avec uniquement NumPy
J'ai essayé de déplacer GAN (mnist) avec keras
Deep Learning from scratch ① Chapitre 6 "Techniques liées à l'apprentissage"
Deep Learning from scratch Chapter 2 Perceptron (lecture du mémo)
J'ai essayé d'intégrer Keras dans TFv1.1
[Mémo d'apprentissage] Apprentissage profond à partir de zéro ~ Mise en œuvre de l'abandon ~
Apprentissage profond à partir de zéro
[Python] [Traitement du langage naturel] J'ai essayé le Deep Learning ❷ fait de toutes pièces en japonais ①
J'ai essayé le deep learning
J'ai essayé d'implémenter Cifar10 avec la bibliothèque SONY Deep Learning NNabla [Nippon Hurray]
[Python] J'ai essayé le même calcul que la prédiction de LSTM à partir de zéro [Keras]
[Deep Learning from scratch] J'ai implémenté la couche Affine
J'ai essayé de déplacer l'apprentissage automatique (détection d'objet) avec TouchDesigner
J'ai essayé de créer un pipeline ML avec Cloud Composer
J'ai essayé d'implémenter Grad-CAM avec keras et tensorflow
J'ai essayé de prédire les courses de chevaux en faisant tout, de la collecte de données à l'apprentissage en profondeur
Osez apprendre avec Ruby "Deep Learning from scratch" Importation de fichiers pickle depuis PyCall interdit
J'ai essayé de créer un environnement d'apprentissage automatique avec Python (Mac OS X)
Apprentissage profond à partir de zéro 1 à 3 chapitres
Créez un environnement pour "Deep Learning from scratch" avec Docker
Mayungo's Python Learning Episode 3: J'ai essayé d'imprimer des nombres
J'ai essayé d'implémenter ListNet d'apprentissage de rang avec Chainer
J'ai capturé le projet Toho avec Deep Learning ... je le voulais.
J'ai essayé de faire d'Othello AI que j'ai appris 7,2 millions de mains par apprentissage profond avec Chainer
Un mémo lors de l'exécution de l'exemple de code de Deep Learning créé à partir de zéro avec Google Colaboratory
J'ai essayé d'implémenter Deep VQE
Deep learning / Deep learning made from scratch Chapitre 3 Mémo
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 5 Mémo
J'ai essayé l'apprentissage automatique avec liblinear