[PYTHON] Deep learning 2 appris par l'implémentation (classification d'images)

introduction

Dans la suite de Deep Learning 1, la reconnaissance de caractères manuscrits de mnist sera effectuée. Voir l'article précédent pour la structure de base de l'apprentissage profond.

la mise en oeuvre

Téléchargement et visualisation des données

Cette fois, nous téléchargerons un ensemble de données accessible au public appelé mnist for machine learning pour entraîner et tester le modèle. Vous pouvez également étiqueter l'image que vous avez réellement et la charger. Commençons par télécharger et visualiser les données téléchargées.

import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
a = np.arange(100)
sns.heatmap(a.reshape((10,10)))

En créant une carte thermique, nous avons pu facilement visualiser la séquence. Maintenant, téléchargez les données pour la reconnaissance de caractères manuscrits à partir de mnist et visualisez-les.

from tensorflow.keras.datasets import mnist
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

Vous avez maintenant les images d'entraînement (60000, 28, 28) dans train_images. Cela signifie 60 000 images d'ombre de 28 pixels x 28 pixels. C'est une image en noir et blanc selon la méthode de sortie. Jetons un coup d'œil à l'image à l'intérieur.

sns.heatmap(train_images[1210])
print(train_labels[1210])

Vous pouvez maintenant voir qu'il y a un 5 à l'intérieur de l'image et une étiquette comme 5.

Créons maintenant les données pour apprendre de ces données brutes. Dans une classification multi-classe comme cette fois, l'entrée peut être laissée telle quelle, mais si la sortie est un nombre sur l'étiquette, la précision diminuera considérablement, car c'est une situation où vous vous inquiétez de 7 ou 9 et de la sortie 8 Ça peut être. Par conséquent, la sortie est autant que le nombre d'étiquettes et ce qui est produit est la probabilité que l'entrée soit cette étiquette. Par conséquent, le prétraitement suivant est effectué.

train_x = train_images.reshape(60000,28,28,1)
train_y = np.zeros((60000,10))
test_x = test_images.reshape((10000,28,28,1))
test_y = np.zeros((10000,10))
for i in range(60000):
  train_y[i][train_labels[i]]=1.0
for i in range(10000):
  test_y[i][test_labels[i]]=1.0

Le format d'entrée / sortie est maintenant terminé. À propos, test_images contient 10000 feuilles de données.

Formation du modèle

from keras import layers
from keras import models
from keras import optimizers
model = models.Sequential()
model.add(layers.Conv2D(16,(3,3),padding="same",activation="relu",input_shape = (28,28,1)))
model.add(layers.MaxPooling2D((2,2)))
model.add(layers.Conv2D(32,(3,3),padding="same",activation="relu"))
model.add(layers.MaxPooling2D((2,2)))
model.add(layers.Flatten())
model.add(layers.Dense(128,activation = "relu"))
model.add(layers.Dense(128,activation = "relu"))
model.add(layers.Dense(10,activation = "softmax"))
model.compile(loss = "categorical_crossentropy",optimizer="adam",metrics=["accuracy"])

Un calque qui n'a pas été utilisé la dernière fois est apparu. couches.Conv2D.

Couche pliante

Lors du traitement d'une image dans le domaine du traitement d'image, l'effet de flou peut être obtenu en modifiant sa propre valeur de pixel par la moyenne des valeurs de pixel environnantes. Il existe de nombreux autres processus qui mettent à jour la valeur de tous les pixels par pixels à proximité. C'est facile de faire cela avec un noyau. https://deepage.net/deep_learning/2016/11/07/convolutional_neural_network.html Ce site explique le calque de pliage d'une manière facile à comprendre, mais là encore, c'est comme copier une grande image avec un compte-gouttes spécial sur le papier suivant, et le compte-gouttes aspire la couleur. Parfois, certaines des couleurs autour de moi se mélangent. Transférez ensuite la somme pondérée des sushis sur le papier suivant (pour le moment, cela n'affecte pas les couleurs environnantes). Le noyau représente le poids du compte-gouttes. Ensuite, comme il est difficile de colorer le bord, on appelle zéro padding pour encadrer l'image avec 0 puis effectuer ce travail, et padding = "same" dans le code est bordé de zéro pour ne pas changer la taille de l'image. Cela signifie le prendre. Ici, on peut voir qu'en augmentant le nombre de compte-gouttes, une image ayant un effet différent sur l'image peut être obtenue. Le premier argument de Conv2D correspond au nombre d'images à augmenter. L'argument suivant est la taille du noyau.

pooling Je pense qu'il y a quelque chose d'écrit comme pooling max. Il s'agit d'un type de regroupement et d'une méthode pour réduire la taille des images. 2x2pixel est considéré comme 1pixel, et l'image est rendue plus petite en prenant la valeur maximale en 2x2. Cela facilite la gestion de l'énorme entrée de dimension des images.

softmax C'est la fonction d'activation qui est apparue pour la première fois cette fois, mais dans la classification multi-classes, la somme des derniers vecteurs à 10 dimensions doit être de 1 car c'est la probabilité de chaque étiquette qui doit être sortie. Softmax le fait bien.

categorical_crossentropy Cela n'utilise pas la différence de sortie, mais utilise une entropie croisée adaptée à l'apprentissage dans la plage de 0 à 1. La perte donnée lorsque 1 est jugé égal à 0,1 est supérieure à la perte lorsque 1 est jugé égal à 0,9, ce qui convient à un tel problème de classification.

Entraînement

history = model.fit(train_x,train_y,steps_per_epoch=10,epochs = 10)

Vous pouvez voir que vous vous entraînez maintenant. On peut voir que la précision a augmenté à 95% ou plus à la fin de l'apprentissage sans les données d'entraînement lorsque le journal sort sans rien faire.

À propos, la valeur de retour de model.fit est stockée dans l'historique, mais vous pouvez l'utiliser pour tracer l'état d'apprentissage. Par exemple, si vous souhaitez voir la transition du taux de réponse correct

plt.plot(history.history['accuracy'])

Nous pouvons maintenant visualiser le processus d'apprentissage. Lisez le document Keras et jouez avec le code pour le comprendre.

Vérification

Peu importe combien les données d'entraînement produisent des résultats, elles n'ont aucun sens à moins qu'elles ne puissent être utilisées en dehors des données d'entraînement. Il y avait un moyen de le faire en même temps que la formation, mais cette fois nous vérifierons le modèle après l'apprentissage.

model.evaluate(test_x,test_y)

[Perte, taux de réponse correct]. On peut voir que des résultats similaires sont obtenus avec des données de test.

À la fin

Cette fois, j'ai implémenté le soi-disant réseau de neurones convolutifs sous la forme la plus simple possible. Cependant, étant donné que la taille de l'image est de 28x28, en fait, tout peut être appris sans problème, même dans la couche entièrement connectée, il peut donc être intéressant d'implémenter ce modèle et de voir les résultats. S'il est entièrement combiné, il utilisera du matériel informatique à $ O (n ^ 4) $, donc il ne peut pas gérer de grosses données (100x100 est probablement trop?) (juste à temps).

La prochaine fois, je traiterai du modèle généré. Pour le moment, implémentez un GAN normal avec un code aussi simple que possible à comprendre.