J'ai couru le tutoriel TensorFlow avec des commentaires (premier réseau de neurones: le début du problème de classification)

URL de référence: https://www.tensorflow.org/tutorials/keras/classification?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

Préparation du colis

#TensorFlow et tf.importer des keras
import tensorflow as tf
from tensorflow import keras

#Importer la bibliothèque d'aide
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 Fashion-MNIST

Contient 70000 images en noir et blanc dans 10 catégories Chacun est une image basse résolution (28 x 28 pixels) montrant un type de vêtement par feuille, comme illustré dans la figure ci-dessous.

Figure 1. Fashion-MNIST samples (by Zalando, MIT License).

L'image se compose d'un tableau NumPy 28x28 La valeur de chaque pixel est un entier compris entre 0 et 255 L'étiquette est un tableau d'entiers de 0 à 9. Chaque numéro correspond à la classe de vêtements comme indiqué dans le tableau ci-dessous.

fashion_mnist = keras.datasets.fashion_mnist

(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()

Chaque image est classée en une seule étiquette Parce que l'ensemble de données ne contient pas le nom de classe ci-dessus Enregistrez le nom de la classe pour une sortie ultérieure de l'image

class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat', 
               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

Observation des données

print(train_images.shape)
print(test_images.shape)

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

plt.figure()
plt.imshow(train_images[0], cmap=plt.cm.binary)
plt.colorbar()
plt.grid(False)
plt.show()

Prétraitement des données

Mettre à l'échelle les valeurs des données d'image dans la plage de 0 à 1

train_images = train_images / 255.0

test_images = test_images / 255.0

Confirmation des données

plt.figure(figsize=(10,10))
for i in range(25):
    plt.subplot(5,5,i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(train_images[i], cmap=plt.cm.binary)
    plt.xlabel(class_names[train_labels[i]])
plt.show()

Construction de modèles / apprentissage

Construire un modèle

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 de la couche entièrement connectée

Précisez 10 car il sera finalement classé en 10 classes Comme softmax est utilisé comme fonction d'activation, 10 nœuds Indiquez la probabilité que l'image que vous visualisez appartienne à chacune des 10 classes

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

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='sparse_categorical_crossentropy',
              metrics=['accuracy'])

Formation modèle

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

Epoch 1/5
1875/1875 [==============================] - 4s 2ms/step - loss: 0.4964 - accuracy: 0.8259
Epoch 2/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.3725 - accuracy: 0.8656
Epoch 3/5
1875/1875 [==============================] - 3s 2ms/step - loss: 0.3336 - accuracy: 0.8787
Epoch 4/5
1875/1875 [==============================] - 4s 2ms/step - loss: 0.3113 - accuracy: 0.8853
Epoch 5/5
1875/1875 [==============================] - 4s 2ms/step - loss: 0.2925 - accuracy: 0.8922





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

Évaluation

Évaluer le modèle

Évaluer le modèle à l'aide des données de test

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

print('\nTest accuracy:', test_acc)

313/313 - 0s - loss: 0.3479 - accuracy: 0.8780

Test accuracy: 0.878000020980835

Prévoir

Prédire les données de test avec un modèle entraîné

predictions = model.predict(test_images)

Résultat de classification de la première image Sortie comme probabilité

predictions[0]

array([2.1071783e-06, 2.4513878e-07, 3.5516130e-09, 2.4936966e-07,
       6.1619041e-08, 6.4291209e-03, 3.7025956e-08, 2.2654539e-02,
       3.6237492e-07, 9.7091323e-01], dtype=float32)

# `np.argmax`Obtenez la valeur maximale (le numéro de l'étiquette classifiée de l'image) du tableau avec
print(f'predicted label : {np.argmax(predictions[0])}')
#Vérifier les bonnes réponses
print(f'true label : {test_labels[0]}')

predicted label : 9
true label : 9

def plot_image(i, predictions_array, true_label, img):
    """
Afficher l'image avec la probabilité prédite
    """
    predictions_array, true_label, img = predictions_array[i], true_label[i], img[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, true_label):
    """
Créer un graphique à barres des résultats de prédiction
    """
    predictions_array, true_label = predictions_array[i], true_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')

#S'affiche comme la première image des données de test
i = 0
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions, test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions,  test_labels)
plt.show()

#S'affiche comme la 13e image des données de test
i = 12
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions, test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions,  test_labels)
plt.show()

Dessinez avec 15 feuilles de données de test

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, test_labels, test_images)
  plt.subplot(num_rows, 2*num_cols, 2*i+2)
  plot_value_array(i, predictions, test_labels)
plt.show()

Retirez une image des données de test et faites une prédiction

img = test_images[0]

print(img.shape)

(28, 28)

Le modèle tf.keras est conçu pour faire des prédictions sur les lots ou "rassemblements" dans un échantillon. Par conséquent, même si vous utilisez une image, vous devez la répertorier.

#Faire d'une image un membre d'un seul lot
img = (np.expand_dims(img,0))

print(img.shape)

(1, 28, 28)

predictions_single = model.predict(img)

print(predictions_single)

[[2.1071742e-06 2.4513832e-07 3.5515995e-09 2.4936892e-07 6.1618806e-08
  6.4291116e-03 3.7025885e-08 2.2654528e-02 3.6237492e-07 9.7091323e-01]]

plot_value_array(0, predictions_single, test_labels)
_ = plt.xticks(range(10), class_names, rotation=45)

np.argmax(predictions_single[0])

9