À propos de cet article

En utilisant la «classification» qui est à la base du deep learning, Je voudrais créer un programme qui prédit ce que sont les caractères numériques manuscrits. J'écrirai autant que possible du point de vue d'un débutant.

Qu'est-ce que le Deep Learning?

En termes simples, c'est une technique pour trouver la régularité dans les données en utilisant de grandes quantités de données. Il comprend les trois processus suivants.

Modélisation et compilation
Apprentissage
Raisonnement

Quelle est la classification de l'apprentissage profond?

En gros, il s'agit de prédire __ type de données __ sur la base de données caractéristiques.

Les données caractéristiques sont des images, Les dernières données de séries chronologiques, C'est comme un indice pour faire une prédiction. Nous l'appelons également des quantités de caractéristiques ou des variables explicatives.

Lors de la classification de deux types de motifs tels que «chien» et «chat», on l'appelle __2 classification de classe __. Je pense que le montant de la fonctionnalité dans ce cas sera un grand nombre d'images de chiens et de chats.

De plus, lors de la classification de trois types ou plus de motifs tels que «ensoleillé», «nuageux» et «pluvieux», on parle de __ classification multi-classes __.

Dans cet article, je vais classer les images de nombres manuscrits de 0 à 9 en nombres réels (classification multi-classes).

import

La bibliothèque utilise tensorflow. Si vous n'avez pas tensorflow, veuillez l'installer avec pip install à l'avance. Au fait, cette fois, j'utilise un package appelé keras of tensorflow, mais c'est un package différent des keras indépendants. keras tensorflow ≠ keras indépendants

from tensorflow.keras.datasets import mnist
from tensorflow.keras.layers import Activation, Dense, Dropout
from tensorflow.keras.models import Sequential
from tensorflow.keras.optimizers import SGD
from tensorflow.keras.utils import to_categorical
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline

Télécharger des données numériques manuscrites

Puisque nous prédisons la classification des nombres manuscrits, nous devons en fait préparer des données numériques manuscrites. Il est difficile de l'écrire à la main et de le préparer, mais comme c'est gênant, téléchargeons-le en utilisant une bibliothèque appelée MNIST.

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

Les données téléchargées par MNIST sont divisées en quatre types de données suivants. Données numériques manuscrites à utiliser dans l'apprentissage et données d'étiquette contenant les réponses: (train_images, train_labels) Données numériques manuscrites à utiliser dans le test et les données d'étiquette contenant la réponse: (test_images, test_labels)

Puisqu'il s'appelle train_images, avez-vous des images? Vous pourriez penser, mais le contenu est un tableau. Il y a beaucoup de données d'image exprimées dans un tableau de 28 lignes et 28 colonnes ↓

Et train_labels contient les données de réponse pour cette image. Dans mon environnement, si vous regardez le contenu de train_labels [0], le nombre 5 est inclus. Cela signifie que "l'image (tableau) de train_images [0] est 5."

La structure du contenu de (test_images, test_labels) est la même. La réponse pour test_images [0] est dans test_labels [0].

Dans les étapes qui suivent, vous apprendrez à utiliser (train_images, train_labels) et Le flux consiste à vérifier l'exactitude avec (test_images, test_labels).

En général, les données d'entraînement utilisées dans l'apprentissage automatique sont souvent exprimées sous forme de train, et les données utilisées pour vérifier les résultats d'apprentissage sont souvent exprimées sous forme de test.

Confirmation des données numériques manuscrites

S'il s'agit d'un tableau, ce n'est pas facile pour l'œil humain, donc Convertissez environ 10 images et vérifiez.

for i in range(10):
    plt.subplot(1, 10, i+1)
    plt.imshow(train_images[i], 'gray')
plt.show()

J'ai pu confirmer que quelque chose comme des chiffres manuscrits était inclus. Ensuite, vérifiez les données d'étiquette.

print(train_labels[0:10])

[5 0 4 1 9 2 1 3 1 4] est émis. Il semble que cela corresponde correctement à l'image des nombres manuscrits.

Prétraitement de l'ensemble de données

La lecture des données est terminée, mais elle ne peut pas être prédite telle quelle. Je voudrais formater les données du tableau d'image et répondre aux données d'étiquette afin de pouvoir faire des prédictions. C'est ce qu'on appelle le prétraitement des données et c'est une tâche très importante.

En regardant le blog d'un certain data scientist actif, Il a été écrit que le travail de prétraitement occupe la majeure partie du travail de création d'IA.

Chaque image des images actuelles est un tableau bidimensionnel 28 par 28 ↓

Convertissez-le en un tableau unidimensionnel à l'aide de remodeler ↓ (Parce que 28 × 28 = 784, 784)

train_images = train_images.reshape((train_images.shape[0], 784))
test_images = test_images.reshape((test_images.shape[0], 784))

Vient ensuite le processus de formatage des données d'étiquette. Les données d'étiquette sont converties en "représentation One-Hot". "One-Hot expression" est une méthode d'expression dans laquelle un seul élément est égal à 1 et l'autre à 0. Si la réponse est «5», l'expression sera la suivante. [0,0,0,0,1,0,0,0,0] # 1 est inscrit à la 5e place

Corrigez-le en utilisant to_categorical ↓

train_labels = to_categorical(train_labels)
test_labels = to_categorical(test_labels)

Ceci termine le prétraitement des données.

Créer un modèle

Maintenant que le prétraitement est terminé, il est temps de créer le modèle. Pour le dire simplement, un modèle est comme un dessin de conception. Déclarez le nombre de couches d'entrée, le nombre de couches cachées, le taux d'invalidation d'abandon, le nombre de couches de sortie, la fonction d'activation à utiliser, etc.

model = Sequential()
model.add(Dense(256, activation='sigmoid', input_shape=(784,))) #Couche d'entrée
model.add(Dense(128, activation='sigmoid')) #Couche cachée
model.add(Dropout(rate=0.5)) #Abandonner
model.add(Dense(10, activation='softmax')) #Couche de sortie

Je vais expliquer chacun d'eux.

Modèle de déclaration

Je crée un modèle séquentiel avec `` model = Sequential () ''. Sequential est un modèle de structure dans laquelle plusieurs couches sont empilées. Imaginez un gâteau Milfille.

Couche d'entrée

model.add (Dense (256, activation = 'sigmoid', input_shape = (784,))) est la couche d'entrée. `` Dense '' représente une couche entièrement connectée. Une couche entièrement connectée signifie connecter toutes les unités à la couche suivante. Cette fois, nous créons 256 unités.

`ʻActivation = 'sigmoid'`` est la fonction d'activation à utiliser. En écrivant sigmoïde, vous pouvez utiliser la fonction sigmoïde comme fonction d'activation. En utilisant la fonction d'activation, il est possible de capturer des caractéristiques même dans des données complexes où la séparation linéaire est difficile.

```Input_shape = (784,) `` est le nombre de données entrantes.

Couche cachée

model.add (Dense (128, activation = 'sigmoid')) est un calque caché. La couche cachée permet de capturer des entités complexes. Vous pouvez augmenter le nombre de calques cachés autant que vous le souhaitez, Si vous en faites trop, vous vous retrouverez avec un modèle de prédiction de classification qui ne fonctionne qu'avec les données d'entraînement. Il est également appelé «surapprentissage» ou «ajustement de courbe».

Abandonner

`` model.add (Dropout (rate = 0.5)) '' est un abandon. L'abandon est une technique permettant de désactiver certaines unités pour éviter le surapprentissage. Le taux d'invalidation est déterminé par le taux. On dit généralement que 50% devraient être désactivés. Cependant, cela ne semble pas nécessaire.

Couche de sortie

model.add (Dense (10, activation = 'softmax')) est la couche de sortie. Cette fois, il existe 10 types de classification multi-classes de 0 à 9, donc le nombre d'unités sera de 10. De plus, la fonction soft MAX est utilisée pour la fonction d'activation. On dit que la fonction soft MAX convient à la classification multi-classes où la valeur totale de la classification est 1. Cette fois, je n'utilise que sigmoïde et softmax, mais il semble qu'il existe diverses autres fonctions d'activation.

Compiler le modèle

Ensuite, compilez le modèle créé. Il se termine par la ligne suivante, mais il regorge d'informations importantes.

model.compile(loss='categorical_crossentropy', optimizer=SGD(lr=0.1), metrics=['acc'])

Les trois paramètres suivants sont requis pour la compilation.

Fonction de perte --Fonction d'optimisation
Indice d'évaluation

Qu'est-ce qu'une fonction de perte?

Une fonction qui calcule la __error __ de la valeur prédite du modèle et les données de réponse correctes. Dans la classification multiclasse, une fonction appelée categorical_crossentropy (erreur d'entropie croisée multiclasse) est souvent utilisée. Définissons-le avec `` loss = 'categorical_crossentropy' '.

Qu'est-ce qu'une fonction d'optimisation?

C'est une fonction qui ajuste le poids et le biais de sorte que l'erreur calculée par la fonction de perte s'approche de 0. Les fonctions d'optimisation typiques sont SGD et Adam. Cette fois, j'utiliserai SGD. L'argument lr de SGD représente le taux d'apprentissage. Valeur qui détermine la fréquence à laquelle les pondérations de chaque couche sont mises à jour. Cette fois, réglez 0,1. optimizer=SGD(lr=0.1)

Qu'est-ce qu'un indice d'évaluation?

Un indice pour mesurer les performances d'un modèle. Les principaux indicateurs d'évaluation sont acc et mse. Acc (précision), qui indique le taux de réponse correct, est souvent utilisé dans la classification. Lors de la prédiction de valeurs numériques telles que la régression, on dit que mse est bon. metrics=['acc']

Apprentissage

Maintenant que vous êtes prêt, apprenons. Apprenez à utiliser train_imeges et train_labels. L'apprentissage se fait dans model.fit.

history = model.fit(train_images, train_labels, batch_size=500, 
    epochs=5, validation_split=0.2)

batch_size est un paramètre pour le nombre d'unités de données d'entraînement qui seront utilisées pour l'entraînement. Plus il est grand, plus il apprend vite, mais il consomme de la mémoire.

les époques sont le nombre d'époques à former.

validation_split est le rapport qui sépare les données d'entraînement et les données de validation. S'il est de 0,2, 20% seront utilisés pour les données de vérification.

Une fois exécuté, il ressemblera à ↓. La situation d'apprentissage à chaque époque sera décrite. Quand je vois ça, je me dis "Wow! Je fais de l'IA!" Et je suis très excité.

Ceci est une explication de la situation d'apprentissage. la perte est __ erreur de données de formation __. Plus il est proche de 0, meilleur est le résultat. acc est __ taux d'exactitude des données d'entraînement __. Plus il est proche de 1, meilleur est le résultat. val_loss est __ erreur de données de validation __. Plus il est proche de 0, meilleur est le résultat. val_acc est le taux de réponse correct de validation data. Plus il est proche de 1, meilleur est le résultat.

Si vous augmentez trop le nombre d'époques et que vous surapprenez, perte et acc sont de très bons chiffres val_loss et val_acc sont de mauvais nombres.

Vous devenez un imbécile __ qui ne peut résoudre les questions du passé qu'en exagérant les questions du passé. Définissez le nombre d'époques sur un nombre raisonnable.

En passant, vous pouvez vérifier le résultat de l'apprentissage dans `` history.history ''.

Pour afficher le graphique, utilisez le code suivant.

plt.plot(history.history['acc'], label='acc')
plt.plot(history.history['val_acc'], label='val_acc')
plt.ylabel('accuracy')
plt.xlabel('epoch')
plt.legend(loc='best')
plt.show()

Évaluation des résultats d'apprentissage

Une fois la formation terminée, évaluez à l'aide des données de test. Utilisez model.evaluate pour l'évaluation.

test_loss, test_acc = model.evaluate(test_images, test_labels)
print('loss: {:.3f}\nacc: {:.3f}'.format(test_loss, test_acc ))

Il semble que l'acc (taux de réponse correcte) soit presque le même que le résultat de l'apprentissage ↓

inférence

Enfin, faites des inférences basées sur des données réelles. Cela vous permet d'obtenir les résultats individuels que vous avez prédits.

Afficher l'image à déduire ↓

for i in range(10):
    plt.subplot(1, 10, i+1)
    plt.imshow(test_images[i].reshape((28, 28)), 'gray')
plt.show()

Mettez cette image dans model.predict et faites une inférence. Vous pouvez récupérer le résultat avec np.argmax.

test_predictions = model.predict(test_images[0:10])
test_predictions = np.argmax(test_predictions, axis=1)
print(test_predictions)

Le résultat de sortie est le suivant. [7 2 1 0 4 1 4 9 6 9] Tout semble être correct.

Lorsqu'il fonctionne réellement comme AI, pas test_images Jetez les données que vous souhaitez prédire dans model.predict et faites une prédiction. Si vous enregistrez le modèle, vous n'avez pas besoin de le réapprendre.

Ça fait longtemps, mais c'est tout.

Le prochain article est ↓ https://qiita.com/sw1394/items/f25dea5cf24ce78dbb0c

Introduction à la création d'IA avec Python! Partie 1 J'ai essayé de classer et de prédire le nombre à partir de l'image du numéro manuscrit