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

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.

Fashion MNIST sprite
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.

Label Class
0 T-shirt/top
1 Trouser
2 Pullover
3 Dress
4 Coat
5 Sandal
6 Shirt
7 Sneaker
8 Bag
9 Ankle boot
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()

output_12_0.png

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

output_16_0.png

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

  1. 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

  1. 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()

output_33_0.png

#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()

output_34_0.png

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

output_36_0.png

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)

output_42_0.png

np.argmax(predictions_single[0])
9

Recommended Posts

J'ai couru le tutoriel TensorFlow avec des commentaires (premier réseau de neurones: le début du problème de classification)
J'ai couru le tutoriel TensorFlow avec des commentaires (classification du texte des critiques de films)
J'ai essayé un réseau de neurones convolutifs (CNN) avec un tutoriel TensorFlow sur Cloud9-Classification des images manuscrites-
J'ai essayé d'exécuter le didacticiel TensorFlow avec des commentaires (_TensorFlow_2_0_Introduction pour les débutants)
J'ai couru le réseau neuronal sur le FPGA réel
J'ai essayé le tutoriel MNIST de tensorflow pour les débutants.
J'ai essayé de trouver la moyenne de plusieurs colonnes avec TensorFlow
Depuis que j'ai touché Tensorflow pendant 2 mois, j'ai expliqué le réseau de neurones convolutifs d'une manière facile à comprendre avec 95,04% d'identification «hiragana manuscrite».
First Python 3 ~ Le début de la répétition ~
Modèle de classification simple avec réseau neuronal
Je veux sortir le début du mois prochain avec Python
J'ai essayé le tutoriel TensorFlow 2ème
[TensorFlow] [Keras] Construction d'un réseau neuronal avec Keras
Touchez l'objet du réseau neuronal
Créez un classificateur avec un taux de reconnaissance de l'écriture manuscrite de 99,2% à l'aide du réseau neuronal convolutif TensorFlow
J'ai essayé d'améliorer la précision de mon propre réseau neuronal
Tutoriel TensorFlow J'ai essayé MNIST 3rd
J'ai essayé tensorflow pour la première fois
Persister le réseau de neurones construit avec PyBrain
J'ai essayé la détection d'objets avec YOLO v3 (TensorFlow 2.1) sur le GPU de windows!
J'expliquerai à propos du réseau neuronal "Calcul neuronal différentiel (DNC)" avec mémoire externe.
J'ai résolu le problème le plus profond d'Hiroshi Yuki.
Visualisez la couche interne du réseau neuronal
Vérification de la normalisation des lots avec un réseau neuronal multicouche
J'ai essayé de faire quelque chose comme un chatbot avec le modèle Seq2Seq de TensorFlow
Le 15e temps réel hors ligne, j'ai essayé de résoudre le problème de l'écriture avec python
Apprenez Nim avec Python (dès le début de l'année).
J'ai suivi la mise en place de la commande du (première moitié)
L'histoire de la création d'un réseau neuronal de génération musicale
J'ai mesuré les performances d'un million de documents avec mongoDB
Bilan du premier défi du machine learning avec Keras
J'ai essayé de résoudre le problème avec Python Vol.1
J'ai essayé la méthode la plus simple de classification de documents multi-étiquettes
J'ai essayé de résoudre le problème de F02 comment écrire en temps réel hors ligne avec Python