[PYTHON] J'ai essayé d'exécuter le didacticiel TensorFlow avec des commentaires (_TensorFlow_2_0_Introduction pour les débutants)

URL de référence: https://www.tensorflow.org/tutorials/quickstart/beginner?hl=ja

Cible

Faites ce qui suit --Construire un réseau de neurones pour classer les images

• Former le réseau neuronal
• Évaluer les performances du modèle

Préparation du colis

import tensorflow as tf
import numpy as np
import matplotlib.pyplot as plt

#confirmation de tensorflow ver
print(tf.__version__)

2.3.0

Préparez l'ensemble de données

Cette fois, j'utiliserai MNIST

Autres ensembles de données: https://www.tensorflow.org/api_docs/python/tf/keras/datasets?hl=JA

mnist = tf.keras.datasets.mnist

(x_train, y_train), (x_test, y_test) = mnist.load_data()

#Convertir l'échantillon d'un entier en nombre à virgule flottante (convertir 0 à 255 en plage 0 à 1)
x_train, x_test = x_train / 255.0, x_test / 255.0

Downloading data from https://storage.googleapis.com/tensorflow/tf-keras-datasets/mnist.npz
11493376/11490434 [==============================] - 0s 0us/step

#Vérifiez la forme des données
print(x_train.shape)
print(x_test.shape)

(60000, 28, 28)
(10000, 28, 28)

• Données de formation: 60000 feuilles --Données de test: 10000 feuilles

Construire un modèle

Flux de processus

1. 28 ✖️ 28 données 2D lissées en 1D

   tf.keras.layers.Flatten

input_shape = (28, 28) spécifie la forme des données d'entrée

2. Définition de la couche cachée

   tf.keras.layers.Dense

128 est le nombre d'unités (nombre de neurones) activation = 'relu' spécifie la fonction d'activation ReLU Autres fonctions d'activation: https://www.tensorflow.org/api_docs/python/tf/keras/activations?hl=ja

3. Définition du décrochage

Désactivez aléatoirement certains neurones pour éviter le surapprentissage 0,2 désactive 20%

4. Définition de la couche entièrement connectée

Précisez 10 car il sera finalement classé en 10 classes

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

Prédictions pré-apprentissage

Calculez un score appelé «Logit» ou «Log Odds Ratio» pour chaque classe

Visualisez les données prédictives

Est-ce le numéro 5? ??

plt.figure()
plt.imshow(x_train[0] * 255, cmap="gray")
plt.grid(False)
plt.show()

Prédire avec le modèle de pré-formation

predictions = model(x_train[:1]).numpy()
predictions

array([[-0.68039566,  0.24756509,  0.03884459,  0.13278663, -0.09757528,
        -0.41739488, -0.07566899, -0.00817996,  0.17783645,  0.13316259]],
      dtype=float32)

Forme des données à saisir au moment de la prédiction

Notez que la forme ne correspond pas à x_train [0] Le modèle est conçu pour faire des prédictions sur un lot ou «rassembler» dans un échantillon.

print(x_train[0].shape)
print(x_train[:1].shape)

(28, 28)
(1, 28, 28)

Convertir le score en probabilité

predictions_probability = tf.nn.softmax(predictions).numpy()
print(predictions_probability)
#Obtenir l'indice de l'élément maximum à partir de la probabilité prédite
np.argmax(predictions_probability)

[[0.05172387 0.13082756 0.10618253 0.1166411  0.09264173 0.06728384
  0.09469356 0.10130493 0.12201592 0.11668495]]





1

Définition de la fonction de perte

Fonction de perte

Adopte l'entropie croisée

Autres fonctions de perte: https://www.tensorflow.org/api_docs/python/tf/keras/losses?hl=ja

loss_fn = tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True)

loss_fn(y_train[:1], predictions).numpy()

2.6988351

Compiler le modèle

Définir un modèle d'apprentissage

--optimer: optimiseur --Cette fois, spécifiez ʻAdam --Autres algorithmes d'optimisation: https://www.tensorflow.org/api_docs/python/tf/keras/optimizers --loss: fonction de perte --Cette fois, spécifiezentropie croisée --metrics: éléments quantifiés lors de la formation et des tests --Cette fois, spécifiez ʻaccuracy

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

Apprentissage de modèle

Apprenez avec une époque de 5 Époque: combien de fois une donnée d'entraînement est entraînée à plusieurs reprises "

model.fit(x_train, y_train, epochs=5)

Epoch 1/5
1875/1875 [==============================] - 4s 2ms/step - loss: 0.2981 - accuracy: 0.9127
Epoch 2/5
1875/1875 [==============================] - 4s 2ms/step - loss: 0.1435 - accuracy: 0.9572
Epoch 3/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.1079 - accuracy: 0.9671
Epoch 4/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0875 - accuracy: 0.9728
Epoch 5/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.0750 - accuracy: 0.9768





<tensorflow.python.keras.callbacks.History at 0x7f12f819d5c0>

Évaluation des performances du modèle

Calculer la perte et la précision du modèle à l'aide des données de test verbose est une option pour afficher la barre de progression Ce modèle montre un taux de précision de 97% dans les données de test.

model.evaluate(x_test,  y_test, verbose=1)

313/313 [==============================] - 0s 1ms/step - loss: 0.0742 - accuracy: 0.9772





[0.07416515052318573, 0.9771999716758728]

Modifier la sortie du modèle

Lors de la sortie d'une probabilité au lieu d'une valeur numérique

probability_model = tf.keras.Sequential([
  model,
  tf.keras.layers.Softmax()
])

predictions = probability_model(x_test[:5])

#Visualisez et comparez les prédictions et les réponses correctes
for index, prediction in enumerate(predictions):
    print(f'Prédiction:{np.argmax(prediction)}Bonne réponse:{y_test[index]}')
    ax = plt.subplot(3, 3, index + 1)
    plt.imshow(x_test[index] * 255, cmap="gray")
    plt.show()

Prédiction: 7 Bonne réponse: 7

Prédiction: 2 Bonne réponse: 2

Prédiction: 1 Bonne réponse: 1

Prédiction: 0 Bonne réponse: 0

Prédiction: 4 Bonne réponse: 4