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.
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.
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 à.
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
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.
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".
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
SGD RMSprop Adagrad Adadelta Adam Adamax Nadam TFOptimizer
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.
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.CategoricalAccuracy、tf.keras.metrics.SparseCategoricalAccuracyConvertissez 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()])
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.
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 Documentation、KerasAPIref
Partie 14 ← → Partie 16 Cliquez ici pour la liste des mémos, etc. Glossaire illisible
Recommended Posts