Exemple de code et exécution

J'ai ajouté quelques commentaires à l'exemple de code sur le site officiel.

import tensorflow as tf

# (1)Téléchargez le jeu de données d'images numériques manuscrites (MNIST) et stockez-le dans une variable
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# (2)Normalisation des données (prétraitement des données d'entrée)
x_train, x_test = x_train / 255.0, x_test / 255.0

# (3)Construire un modèle NN
model = tf.keras.models.Sequential([
  tf.keras.layers.Flatten(input_shape=(28, 28)),
  tf.keras.layers.Dense(128, activation='relu'),
  tf.keras.layers.Dropout(0.2),
  tf.keras.layers.Dense(10, activation='softmax')
])

# (4)Compilation de modèles (y compris les paramètres de formation)
model.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['accuracy'])

# (5)Modèle de formation (apprentissage / formation)
model.fit(x_train, y_train, epochs=5)

# (6)Évaluation du modèle
model.evaluate(x_test,  y_test, verbose=2)

Dans le programme court ci-dessus, nous procédons comme suit:

--Télécharger l'ensemble de données d'images numériques manuscrites et les stocker dans chaque variable (préparation des données) -- * _ train: données pour la formation (pour l'apprentissage, la formation) -- * _ test: Données de test (évaluation)
Pour plus de détails sur ces données, voir le deuxième "~ Regardons de plus près les données d'entrée ~ / items / 2c969ca4675d5a3691ef) ».

• Normalisation des données (pré-traitement des données d'entrée) --Convertir les valeurs entières comprises entre 0 et 255 en valeurs réelles comprises entre 0,0 et 1,0 --Construction d'un modèle de réseau neuronal pour l'apprentissage automatique
• Les détails ici seront expliqués dans la partie 7 "~ Comprendre les types de calques / fonctions d'activation ~". --Compilation du modèle (y compris les paramètres liés à l'apprentissage)
• Les détails ici seront expliqués dans la partie 8 "~ Sélection d'un algorithme d'optimisation et d'une fonction de perte ~". --Modèle de formation utilisant les données de formation (* _ train) (→ ** Modèle formé ** terminé) --Évaluation du modèle à l'aide des données de test (* _test) (exécution de la classification d'image par modèle formé et correspondance des réponses (notation))

Le résultat de l'exécution du programme est le suivant.

Résultat d'exécution

Train on 60000 samples
Epoch 1/5
60000/60000 [==============================] - 5s 82us/sample - loss: 0.2992 - accuracy: 0.9134
Epoch 2/5
60000/60000 [==============================] - 5s 78us/sample - loss: 0.1457 - accuracy: 0.9561
Epoch 3/5
60000/60000 [==============================] - 5s 78us/sample - loss: 0.1096 - accuracy: 0.9659
Epoch 4/5
60000/60000 [==============================] - 5s 78us/sample - loss: 0.0876 - accuracy: 0.9730
Epoch 5/5
60000/60000 [==============================] - 5s 80us/sample - loss: 0.0757 - accuracy: 0.9765
10000/10000 - 0s - loss: 0.0766 - accuracy: 0.9762
[0.07658648554566316, 0.9762]

En termes de sens ...

• Entraînement sur 60000 échantillons: Nous nous entraînerons à l'aide de 60 000 images de texte manuscrites. ―― ʻEpoch x / 5: C'est le xème apprentissage sur 5 fois au total. --5s 82us / échantillon --loss: 0.2992 --précision: 0.9134`: Il a fallu 82 $ \ mu $ secondes par image, et environ 5 secondes pour l'ensemble (60 000 images). La performance du modèle formé de cette manière (évaluée à l'aide des données d'apprentissage) était de 0,2992 pour la valeur de la fonction de perte (perte) et de 0,9134 pour le taux de réponse correct (précision).
• Le taux de réponse correct de 0,9134 signifie que les images de 60 000 $ \ times 0,9134 = 54 804 $ peuvent être correctement classées de 0 à 9, et les images restantes de 60 000-54 804 $ = 5 196 $ sont mal classées. Interpréter. --10000 / 10000 --0s --perte: 0,0766 - précision: 0,9762: J'ai testé la prédiction de classification avec 10 000 images à tester (distinctes de celle utilisée pour la formation). Le test a duré 0 seconde, avec une note de fonction de perte de 0,0766 et un taux de réponse correcte de 0,9762.

Quel est le taux de réponse correct (précision)?

Aussi appelé «précision» ou «taux de réponse correct». Affiche le pourcentage d'images correctement classées. Par exemple, si 98 images sur 100 peuvent être classées correctement, le taux de réponse correct sera 98 $ / 100 = 0,98 $ (= 98%).

Le pourcentage de réponses correctes varie de 0,0 à 1,0, et plus la valeur ** est élevée (plus proche de 1,0), meilleur est le modèle ** (lorsqu'il est évalué à l'aide de données non utilisées pour la formation).

Quelle est la valeur de la fonction de perte (perte)?

Il y a une partie où la supériorité ou l'infériorité du modèle (classifieur) ne peut pas être mesurée uniquement du point de vue du taux de réponse correct. Par exemple, supposons que vous souhaitiez classer (prédire) une image (la réponse correcte est "3") en utilisant deux modèles différents comme suit.

Pour cette image, le modèle A prédit "3" et le modèle B prédit également "3". Puisque la bonne réponse est «3», le taux de réponse correct est de 1,0 ** pour les deux modèles. En ne regardant que cet ** indice de taux de réponse correcte **, les deux modèles sont également bons.

Cependant, la prédiction du modèle A est "** 8 est de 10%, la confiance de 3 est de 90%, et 3 est sélectionné **", tandis que la prédiction du modèle B est "*". * 8 correspond à 45%, 3 correspond à 55% et 3 correspond à la sortie ** "Et si?

** Même avec le même taux de réponse correcte de 1,0 **, on peut dire que le modèle A est supérieur.

Cependant, cela ne peut pas être pris en compte dans l'indice de taux de réponse correct. Celle pour l'évaluer est la ** fonction de perte **, et la valeur évaluée par la fonction de perte est ** perte **.

La classification des nombres manuscrits traitée ici appartient au type de "** problème de classification multi-classes **", et l'indice de ** erreur d'entropie croisée ** (entropie croisée) est souvent utilisé pour la fonction de perte de ce problème. Je vais. L'entropie croisée est calculée en utilisant chaque valeur de la couche de sortie du réseau neuronal et les données de réponse correctes). Les détails sont expliqués dans la partie 8 "~ Sélection d'un algorithme d'optimisation et d'une fonction de perte ~".

Fondamentalement, la valeur de la fonction de perte prend une valeur de 0,0 ou plus, et ** plus la valeur de la fonction de perte est petite (plus proche de 0,0), meilleur est le modèle **. La valeur de la fonction de perte peut dépasser 1,0.

la prochaine fois

―― La prochaine fois, je voudrais expliquer les données d'entraînement (x_train, y_train) et les données de test (x_test, y_test) et les visualiser à l'aide de matplotlib.