Mémo d'auto-apprentissage "Deep Learning from scratch" (n ° 15) Tutoriel pour débutants TensorFlow

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 14 ← → Partie 16

Puisque Google Colab peut être utilisé normalement, je vais essayer le contenu de ce livre avec TensorFlow.

Tutoriel pour débutants TensorFlow

Site TensorFlow https://www.tensorflow.org/?hl=ja tutoriel pour débutants "First Neural Network" Je l'ai déplacé tel quel.

Vraiment, si vous le copiez et collez dans Colab, cela fonctionnera, vous n'avez donc pas à prendre de notes spéciales. Cependant, il n'y a aucune explication sur le contenu car il s'agit de confirmer que cela fonctionne. Les explications nécessaires semblent être dispersées sur tout le site, mais les débutants risquent de se perdre après avoir fait le didacticiel, ne sachant pas ce qu'ils ont fait maintenant ou quoi faire ensuite.

Ou dis,

Peut-être que ce site n'est pas du tout pour les débutants, mais pour quelqu'un qui a des connaissances en python et neuralnet pour que TensorFlow fonctionne avec Google Colab. En fait, je ne trouve aucune explication sur le réseau neuronal lui-même.

À cet égard, je pense qu'il est nécessaire d'avoir un livre qui accumule les explications dans l'ordre, comme "Deep Learning from scratch".

donc

Comparons le script exécuté dans ce tutoriel avec le contenu de "Deep Learning from scratch" pour découvrir ce que font Keras et TensorFlow.

Construire un modèle

model = keras.Sequential([
    keras.layers.Flatten(input_shape=(28, 28)),
    keras.layers.Dense(128, activation='relu'),
    keras.layers.Dense(10, activation='softmax')
])

Ici, nous construisons modèle séquentiel keras.

type(model)

tensorflow.python.keras.engine.sequential.Sequential

model.summary()

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


flatten (Flatten)      (None, 784)       0
dense (Dense)       (None, 128)      100480
dense_1 (Dense)      (None, 10)      1290


Total params: 101,770 Trainable params: 101,770 Non-trainable params: 0

La sortie (, 784) de la couche d'entrée est Dans la couche dense suivante, le poids de (784, 128) est multiplié par des points et (, 128) est émis. Il est multiplié par points avec le poids de (128, 10) dans la couche dense-1 suivante, et (, 10) est émis.

model.layers

[tensorflow.python.keras.layers.core.Flatten at 0x7faf1e9efac8, tensorflow.python.keras.layers.core.Dense at 0x7faeea73b438, tensorflow.python.keras.layers.core.Dense at 0x7faeea73b710]

Construisez un modèle avec la classe Sequential définie dans le module tensorflow.python.keras.engine.sequential.py. La première couche est la couche d'entrée, qui semble simplement "convertir d'un tableau 2D (28x28 pixels) en un tableau 1D de 28x28 = 784 pixels".

Une fois que les pixels sont unidimensionnels, le réseau aura deux couches tf.keras.layers.Dense. Ces couches sont des couches de neurones étroitement ou entièrement connectés. La première couche dense a 128 nœuds (ou neurones). La deuxième couche, qui est également la dernière couche, est la couche softmax à 10 nœuds. Cette couche renvoie un tableau de 10 probabilités qui totalisent 1. Chaque nœud affiche la probabilité que l'image que vous regardez appartienne à chacune des 10 classes.

Par conséquent, il semble correspondre à la classe de réseau neuronal à deux couches TwoLayerNet expliquée à la page 113 du livre "Deep Learning from scratch". Cependant, la fonction d'activation de la classe TwoLayerNet était la fonction sigmoïde, mais ce modèle séquentiel de Keras spécifie la fonction Relu.

Dense Il semble être une couche entièrement connectée dans le sens où elle est "dense, (...) dense et dense".

"Deep Learning from scratch" P205 Il y avait une connexion entre tous les neurones de la couche adjacente. Cela s'appelle entièrement connecté et nous avons implémenté la couche entièrement connectée sous le nom de couche Affine.

Cela semble correspondre à.

paramètres denses

unités, nombre de dimensions de sortie activation = Aucune, fonction d'activation à utiliser (si non spécifié, la fonction d'activation n'est pas utilisée) use_bias = True, s'il faut utiliser le biais kernel_initializer = 'glorot_uniform', poids initial bias_initializer = 'zeros', valeur initiale du biais kernel_regularizer = Aucun, fonction de régularisation appliquée à la matrice de poids bias_regularizer = Aucun, fonction de régularisation appliquée au biais activity_regularizer = Aucun, fonction de régularisation appliquée à la sortie de la couche (activation) kernel_constraint = Aucun, fonction de contrainte bias_constraint = Aucun, fonction de contrainte **kwargs

Fonction d'activation

softmax elu selu softplus softsign relu tanh sigmoid hard_sigmoid linear

Environ la moitié a été expliquée dans "Deep Learning from scratch". linéaire est la fonction constante de P66.

Valeur initiale du poids

glorot_uniform Valeur par défaut Renvoie l'initialisation par la distribution uniforme de Glorot (distribution uniforme de Xavier).

Depuis la documentation Keras C'est la même chose que la distribution uniforme avec [limit, -limit] comme plage lorsque la limite est sqrt (6 / (fan_in + fan_out)). Où fan_in est le nombre d'unités d'entrée et fant_out est le nombre d'unités de sortie.

glorot_normal Renvoie l'initialisation par la distribution normale de Glorot (avec la distribution normale de Xavier) "Deep Learning from scratch" p182 "Valeur initiale de Xavier" Distribution gaussienne avec $ \ frac {1} {\ sqrt n} $ comme écart-type lorsque le nombre de nœuds dans la couche précédente est n

he_normal Renvoie l'initialisation par distribution normale de He "Deep Learning from scratch" p184 "Valeur initiale de He" Distribution gaussienne avec $ \ sqrt \ frac {2} {n} $ comme écart type lorsque le nombre de nœuds dans la couche précédente est n

random_normal Initialisez les poids selon la distribution normale. S'il est spécifié sous forme de chaîne de caractères, il sera initialisé avec les paramètres moyenne = 0,0, stddev = 0,05 et seed = None (distribution gaussienne avec un écart type de 0,05). Si vous souhaitez définir le paramètre, spécifiez-le avec la fonction comme suit. keras.initializers.RandomNormal(mean=0.0, stddev=0.05, seed=None)

"Deep Learning from scratch" P184 Puisque la fonction sigmoïde et la fonction tanh sont symétriques et peuvent être considérées comme une fonction linéaire près du centre, "Valeur initiale de Xavier" convient. D'autre part, lorsque vous utilisez ReLU, spécialisez-vous dans ReLU. Il est recommandé d'utiliser la valeur initiale. Il s'agit d'un stade précoce recommandé par Kaiming He et al. Valeur-Le nom est également "Valeur initiale de He".

Paramètres pouvant être spécifiés avec la méthode model.compile

model.compile(optimizer='adam', 
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

Lors de la compilation du modèle, adam est spécifié pour l'optimiseur et sparse_categorical_crossentropy est spécifié pour la fonction de perte.

optimizer = 'rmsprop', la valeur par défaut de l'optimiseur est rmsprop perte = Aucune, fonction de perte metrics = Aucun, fonction d'évaluation loss_weights=None, weighted_metrics=None, run_eagerly=None, **kwargs

Optimiseur optimiseur

SGD RMSprop Adagrad Adadelta Adam Adamax Nadam TFOptimizer

Perte de fonction de perte

mean_squared_error mean_absolute_error mean_absolute_percentage_error mean_squared_logarithmic_error squared_hinge hinge categorical_hinge logcosh categorical_crossentropy sparse_categorical_crossentropy binary_crossentropy kullback_leibler_divergence poisson cosine_proximity

mean ~ est la fonction de perte utilisée dans le problème de régression ~ La crossentropie est une fonction de perte utilisée dans les problèmes de classification et est expliquée dans "Deep Learning from scratch" P89. Il semble utiliser categorical_crossentropy lorsque l'étiquette correcte est une expression one-hot, et sparse_categorical_crossentropy quand il s'agit d'une valeur objective d'un entier.

Métriques de la fonction d'évaluation

Selon le commentaire écrit dans la méthode compile

Normalement, utilisez metrics = ['precision'].

à propos de ça. Aussi,

Si vous passez la chaîne "precision" ou "acc", En fonction de la fonction de perte utilisée et de la forme de sortie du modèle, il s'agit de tf.keras.metrics.BinaryAccuracy, tf.keras.metrics.CategoricalAccuracytf.keras.metrics.SparseCategoricalAccuracy Convertissez en l'un des.

à propos de ça.

Alternativement, il semble que vous puissiez spécifier metrics = ['mae'], mais cela semble être pour des problèmes de régression et pour trouver l'erreur absolue moyenne. De plus, il semble que vous puissiez spécifier une fonction de perte, alors ne vous trompez pas.

donc

Convertit la chaîne "precision" ~ en une des ~ tf.keras.metrics.SparseCategoricalAccuracy.

Comme vous pouvez le voir, il semble que la fonction elle-même soit réellement spécifiée, mais si vous la spécifiez avec un identificateur de chaîne de caractères, elle sera convertie. C'est également le cas des fonctions d'optimisation et de perte. Si vous le spécifiez sous forme de chaîne de caractères, ce sera plus facile à comprendre et vous serez moins susceptible de faire une erreur, mais le paramètre sera la valeur par défaut.

Par exemple, si vous spécifiez "adam" dans l'optimiseur, il appelle la classe Adam dans le module tensorflow.python.keras.optimizer_v2.adam.py, mais les paramètres suivants sont définis par défaut. learning_rate=0.001, beta_1=0.9, beta_2=0.999,

"Deep Learning from scratch" P175 Adam définit trois hyper paramètres. L'un est le coefficient d'apprentissage jusqu'à présent (apparu comme α dans l'article). Ces deux derniers sont le coefficient β 1 pour le moment primaire et le coefficient β 2 pour le moment secondaire. Selon l'article, les paramètres standard sont de 0,9 pour β1 et de 0,999 pour β2, et ce paramètre semble fonctionner dans la plupart des cas.

Donc, il semble qu'il n'y ait pas de problème avec la valeur par défaut, mais si vous voulez changer cela, vous devez spécifier la fonction directement.

model.compile(optimizer=keras.optimizers.Adam(0.001, 0.9, 0.999), 
              loss=keras.losses.SparseCategoricalCrossentropy(),
              metrics=[keras.metrics.SparseCategoricalAccuracy()])

Formation modèle

model.fit(train_images, train_labels, epochs=5)

Entraînez-vous (apprenez) avec la méthode model.fit. Spécifiez l'image et l'étiquette des données d'entraînement. epochs Le nombre d'époques est spécifié comme 5. En répétant l'apprentissage 5 fois, lorsque vous l'exécutez réellement, le résultat de l'exécution de 5 lignes sera affiché comme indiqué ci-dessous.

Epoch 1/5 1875/1875 [==============================] - 2s 1ms/step - loss: 1.5450 - accuracy: 0.6806 Epoch 2/5 1875/1875 [==============================] - 2s 1ms/step - loss: 0.7987 - accuracy: 0.8338 Epoch 3/5 1875/1875 [==============================] - 2s 1ms/step - loss: 0.5804 - accuracy: 0.8666 Epoch 4/5 1875/1875 [==============================] - 2s 1ms/step - loss: 0.4854 - accuracy: 0.8804 Epoch 5/5 1875/1875 [==============================] - 2s 1ms/step - loss: 0.4319 - accuracy: 0.8893 tensorflow.python.keras.callbacks.History at 0x7fd89467f550

Les paramètres de la méthode d'ajustement sont les suivants x = Aucun, données d'entraînement (image) y = Aucun, données d'entraînement (libellé) batch_size = Aucun, taille du lot Nombre de données à traiter dans un lot La valeur par défaut est 32 epochs = 1, nombre d'apprentissage verbose = 1, spécification de sortie de journal 0: pas de sortie 1, 2: sortie callbacks=None, validation_split=0., validation_data=None, shuffle=True, class_weight=None, sample_weight=None, initial_epoch=0, steps_per_epoch=None, validation_steps=None, validation_batch_size=None, validation_freq=1, max_queue_size=10, workers=1, use_multiprocessing=False

Comme il existe 60000 données d'entraînement et que la taille de lot par défaut est de 32, iter_per_epoch Le nombre d'itérations est 60000 ÷ 32 = 1875 Si vous traitez par lots (apprenez) 1875 pièces en une seule époque, vous verrez toutes les données d'entraînement. Ceci est répété 5 fois.

Évaluation du taux de réponse correcte

test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose=2)

print('\nTest accuracy:', test_acc)

313/313 - 0s - loss: 0.3390 - accuracy: 0.8781 Test accuracy: 0.8780999779701233

paramètres de la méthode model.evaluate

x = Aucun, données de test (image) y = Aucun, données de test (étiquette) batch_size = Aucun, la taille par défaut du lot est de 32 verbose = 1, spécification de sortie de journal 0: pas de sortie 1, 2: sortie sample_weight=None, steps=None, callbacks=None, max_queue_size=10, workers=1, use_multiprocessing=False, return_dict=False

Renvoie la valeur de perte et le taux de précision des données de test dans le modèle entraîné

Sur le site TensorFlow, je ne sais pas quels sont les paramètres, j'ai donc fait référence à ce site. L'explication ne suffit pas, mais vous pouvez voir ce que vous pouvez spécifier. →Keras DocumentationKerasAPIref

Partie 14 ← → Partie 16 Cliquez ici pour la liste des mémos, etc. Glossaire illisible

Recommended Posts

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» (n ° 11) CNN
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 19) Augmentation des données
Mémo d'auto-apprentissage "Deep Learning from scratch" (partie 12) Deep learning
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 18) One! Miaou! Grad-CAM!
"Deep Learning from scratch" Mémo d'auto-apprentissage (n ° 9) Classe MultiLayerNet
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» (10) Classe MultiLayerNet
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 10-2) Valeur initiale du poids
[Mémo d'apprentissage] Le Deep Learning fait de zéro [Chapitre 7]
[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]
"Deep Learning from scratch" Mémo d'auto-apprentissage (n ° 16) J'ai essayé de créer SimpleConvNet avec Keras
Apprentissage profond à partir de zéro
"Deep Learning from scratch" Mémo d'auto-apprentissage (n ° 14) Exécutez le programme du chapitre 4 sur Google Colaboratory
Deep Learning from scratch Chapter 2 Perceptron (lecture du mémo)
[Mémo d'apprentissage] Apprentissage profond à partir de zéro ~ Mise en œuvre de l'abandon ~
Deep learning / Deep learning from scratch 2 Chapitre 4 Mémo
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 5 Mémo
Apprentissage profond à partir de zéro (calcul des coûts)
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 7 Mémo
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 8 Mémo
Deep learning / Deep learning made from scratch Chapitre 5 Mémo
Deep learning / Deep learning made from scratch Chapitre 4 Mémo
Deep learning / Deep learning from scratch 2 Chapitre 3 Mémo
Mémo d'apprentissage profond créé à partir de zéro
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 6 Mémo
Tutoriel d'apprentissage en profondeur de la construction d'environnement
Mémo d'auto-apprentissage "Deep Learning from scratch" (partie 8) J'ai dessiné le graphique du chapitre 6 avec matplotlib
Apprentissage profond / Apprentissage profond à partir de zéro 2-Essayez de déplacer GRU
"Deep Learning from scratch" avec Haskell (inachevé)
Enregistrement d'apprentissage de la lecture "Deep Learning from scratch"
[Deep Learning from scratch] À propos de l'optimisation des hyper paramètres
Deep Learning from scratch ① Chapitre 6 "Techniques liées à l'apprentissage"
GitHub du bon livre "Deep Learning from scratch"
Résumé Python vs Ruby "Deep Learning from scratch"
Django memo n ° 1 à partir de zéro
[Deep Learning from scratch] J'ai implémenté la couche Affine
Application de Deep Learning 2 à partir de zéro Filtre anti-spam
[Deep Learning from scratch] J'ai essayé d'expliquer le décrochage
[Deep Learning from scratch] Implémentation de la méthode Momentum et de la méthode AdaGrad
Essayez l'apprentissage en profondeur avec TensorFlow
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 1
Un amateur a trébuché dans le Deep Learning ❷ fait à partir de zéro Note: Chapitre 5
Un amateur a trébuché dans le Deep Learning ❷ fait à partir de zéro Note: Chapitre 2
Créez un environnement pour "Deep Learning from scratch" avec Docker
Apprentissage profond / code de travail LSTM
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 3
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 7
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 5
Un amateur a trébuché dans le Deep Learning ❷ fait de zéro Note: Chapitre 1
Un amateur a trébuché dans le Deep Learning ❷ fait à partir de zéro Note: Chapitre 4
Un amateur a trébuché dans le Deep Learning à partir de zéro.
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 2
J'ai essayé d'implémenter Perceptron Part 1 [Deep Learning from scratch]