[PYTHON] Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 19) Augmentation des données
En lisant "Deep Learning from scratch" (écrit par Yasuki Saito, publié par O'Reilly Japan), je noterai les sites auxquels j'ai fait référence. Partie 18 ←
J'ai pu juger raisonnablement bien les chiens et les chats, mais je pense que le taux de réponse correcte est toujours inférieur à 90%, donc je pense que je vais essayer l'augmentation des données décrite à la page 245 du livre. ..
Data Augmentation Ce qui semble facile à faire en élargissant les données Inverser rotation Bouge toi Est-ce là?
Donc, comme je l'ai vu dans GradCAM, il semble que le chat réagit à la posture recroquevillée et le chien répond au nez.
Cela signifie
N'est-il pas possible d'améliorer la précision d'identification des chats en ajoutant une image pivotée ou inversée d'un chat? Si vous agrandissez la zone autour du visage de l'image du chien, la précision d'identification du chien s'améliorera. Que peut-on envisager.
Par conséquent, je voudrais vérifier comment l'ajout de données étendues améliore l'apprentissage.
Tout d'abord, recréez les données d'entraînement et les données de test
Les données utilisées jusqu'à présent sont assez bien faites, simplement parce qu'il est seulement nécessaire de confirmer le fonctionnement du programme. Il n'y a que 100 éléments de données de test.
Je souhaite enregistrer au hasard environ 1000 données de test. Pour le reste des données d'entraînement, fusionnez les images de chiens et de chats, puis réorganisez-les au hasard. Les données étendues seront séparées pour chaque méthode de traitement de chien et de chat, et seront fusionnées avec les données d'entraînement pendant l'apprentissage afin que l'effet puisse être vérifié. Lors de la vérification, non seulement le taux de réponse correct global, mais également le taux de réponse correct pour les chiens et le taux de réponse correct pour les chats sont vérifiés. En outre, vérifiez à quelles caractéristiques de l'image incorrecte répondent GradCAM.
Avec une telle politique, nous avons recréé les données de formation.
def rnd_list(motoarray, toridasi):
#Créer une liste d'entiers de 0 au nombre de données dans le tableau np d'origine
#Après avoir trié au hasard
#Renvoie une liste du nombre d'entiers spécifié et une liste des entiers restants
import random
import numpy as np
kensuu , tate, yoko, channel = motoarray.shape
moto = list(range(0, kensuu))
random.shuffle(moto)
sel = moto[0:toridasi]
nokori=moto[toridasi:]
return sel, nokori
def bunkatu(motoarray, toridasi, lblA):
#données du tableau np
#Dans la liste de numéros spécifiée et le reste de la liste
#Diviser
sel, nokori = rnd_list(motoarray, toridasi)
tsl = []
tsi = []
trl = []
tri = []
for i in sel:
imgA = dogimg[i]
tsl.append(lblA)
tsi.append(imgA)
for i in nokori:
imgA = dogimg[i]
trl.append(lblA)
tri.append(imgA)
return tsl, tsi, trl, tri
def rnd_arry(tri, trl):
#Un tableau d'images et un tableau d'étiquettes
#Trié aléatoirement
#Liste et retour
sel, nokori = rnd_list(tri, 0)
wtri = []
wtrl = []
for i in nokori:
imgA = tri[i]
lblA = trl[i]
wtri.append(imgA)
wtrl.append(lblA)
return wtri, wtrl
#Divisez pour la formation et les tests et intégrez les chiens et les chats
bunkatusuu = 500
ctsl, ctsi, ctrl, ctri = bunkatu(catimg, bunkatusuu, 0)
dtsl, dtsi, dtrl, dtri = bunkatu(dogimg, bunkatusuu, 1)
tri=np.append(ctri, dtri, axis=0)
trl=np.append(ctrl, dtrl, axis=0)
tsi=np.append(ctsi, dtsi, axis=0)
tsl=np.append(ctsl, dtsl, axis=0)
#Trier au hasard
wtri, wtrl = rnd_arry(tri, trl)
wtsi, wtsl = rnd_arry(tsi, tsl)
#enregistrer
dataset = {}
dataset['test_label'] = np.array(wtsl, dtype=np.uint8)
dataset['test_img'] = np.array(wtsi, dtype=np.uint8)
dataset['train_label'] = np.array(wtrl, dtype=np.uint8)
dataset['train_img'] = np.array(wtri, dtype=np.uint8)
import pickle
save_file = '/content/drive/My Drive/Colab Notebooks/deep_learning/dataset/catdog.pkl'
with open(save_file, 'wb') as f:
pickle.dump(dataset, f, -1)
Données d'entraînement 23994 (chien 11997, chat 11997), données de test 1000 (chien 500, chat 500) Est fait.
Si vous saisissez ceci et traitez-le avec DeepConvNet créé dans la partie 18
Epoch 1/10 188/188 [==============================] - 373s 2s/step - loss: 0.7213 - accuracy: 0.5663 Epoch 2/10 188/188 [==============================] - 373s 2s/step - loss: 0.6378 - accuracy: 0.6290 Epoch 3/10 188/188 [==============================] - 373s 2s/step - loss: 0.5898 - accuracy: 0.6713 Epoch 4/10 188/188 [==============================] - 374s 2s/step - loss: 0.5682 - accuracy: 0.6904 Epoch 5/10 188/188 [==============================] - 373s 2s/step - loss: 0.5269 - accuracy: 0.7128 Epoch 6/10 188/188 [==============================] - 374s 2s/step - loss: 0.4972 - accuracy: 0.7300 Epoch 7/10 188/188 [==============================] - 372s 2s/step - loss: 0.4713 - accuracy: 0.7473 Epoch 8/10 188/188 [==============================] - 374s 2s/step - loss: 0.4446 - accuracy: 0.7617 Epoch 9/10 188/188 [==============================] - 373s 2s/step - loss: 0.4318 - accuracy: 0.7665 Epoch 10/10 188/188 [==============================] - 376s 2s/step - loss: 0.4149 - accuracy: 0.7755 32/32 - 4s - loss: 0.3811 - accuracy: 0.8420
Le résultat est un taux de réponse correcte de 84,2%.
Je vérifierai le contenu du résultat
predictions = model.predict(x_test)
#Énumérez les indices de mauvaise appréciation
gohantei = []
kensuu, w = predictions.shape
for i in range(kensuu):
predictions_array = predictions[i]
predicted_label = np.argmax(predictions_array)
true_label = t_test[i]
if predicted_label != true_label:
gohantei.append(i)
print(len(gohantei))
158
Il y a eu 158 faux positifs.
def plot_image(i, predictions, t_label, img):
class_names = ['cat', 'dog']
predictions_array = predictions[i]
img = img[i].reshape((80, 80, 3))
true_label = t_label[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)
num_cols = 10
num_rows = int(len(gohantei) / num_cols ) + 1
plt.figure(figsize=(2*num_cols, 2.5*num_rows))
j = 0
for i in gohantei:
inuneko = t_test[i]
if inuneko == 0:
plt.subplot(num_rows, num_cols, j+1)
plot_image(i, predictions, t_test, x_test)
j +=1
plt.show()
print("J'ai fait une erreur chez le chat",j)
plt.figure(figsize=(2*num_cols, 2.5*num_rows))
j = 0
for i in gohantei:
inuneko = t_test[i]
if inuneko == 1:
plt.subplot(num_rows, num_cols, j+1)
plot_image(i, predictions, t_test, x_test)
j +=1
plt.show()
print("J'ai fait une erreur chez le chien",j)
La répartition des erreurs de jugement était de 109 chats et 49 chiens. Les chats sont deux fois plus mal jugés que les chiens.
En premier lieu, l'apprentissage est-il amélioré par l'ajout de données étendues?
Voyons si les erreurs de jugement sur les chats peuvent être réduites en développant et en ajoutant des données sur les chats.
#Ne sortez que l'image du chat
catdatalist = []
kensuu = len(dataset['train_img'])
for i in range(kensuu):
label = dataset['train_label'][i]
if label == 0:
catdatalist.append(i)
print(len(catdatalist))
11997
#Créer un ensemble de données d'image inversé gauche-droite d'un chat
trl = []
tri = []
lbl = 0
for i in catdatalist:
img = dataset['train_img'][i]
img = img[:, ::-1, :]
trl.append(lbl)
tri.append(img)
catdataset = {}
catdataset['train_label'] = np.array(trl, dtype=np.uint8)
catdataset['train_img'] = np.array(tri, dtype=np.uint8)
tri =np.append(dataset['train_img'], catdataset['train_img'], axis=0)
trl =np.append(dataset['train_label'], catdataset['train_label'], axis=0)
x_train = tri / 255.0
t_train = trl
Entraînez-vous avec les données d'entraînement avec les données de chat inversées ajoutées.
model.fit(x_train, t_train, epochs=10, batch_size=128)
Epoch 1/10 282/282 [==============================] - 571s 2s/step - loss: 0.6604 - accuracy: 0.6783 Epoch 2/10 282/282 [==============================] - 569s 2s/step - loss: 0.5840 - accuracy: 0.7220 Epoch 3/10 282/282 [==============================] - 570s 2s/step - loss: 0.5407 - accuracy: 0.7511 Epoch 4/10 282/282 [==============================] - 572s 2s/step - loss: 0.5076 - accuracy: 0.7689 Epoch 5/10 282/282 [==============================] - 565s 2s/step - loss: 0.4808 - accuracy: 0.7860 Epoch 6/10 282/282 [==============================] - 566s 2s/step - loss: 0.4599 - accuracy: 0.7974 Epoch 7/10 282/282 [==============================] - 563s 2s/step - loss: 0.4337 - accuracy: 0.8115 Epoch 8/10 282/282 [==============================] - 565s 2s/step - loss: 0.4137 - accuracy: 0.8181 Epoch 9/10 282/282 [==============================] - 564s 2s/step - loss: 0.3966 - accuracy: 0.8256 Epoch 10/10 282/282 [==============================] - 565s 2s/step - loss: 0.3759 - accuracy: 0.8331
test_loss, test_acc = model.evaluate(x_test, t_test, verbose=2)
32/32 - 4s - loss: 0.3959 - accuracy: 0.8220
predictions = model.predict(x_test)
#Énumérez les indices de mauvaise appréciation
gohantei = []
kensuu, w = predictions.shape
for i in range(kensuu):
predictions_array = predictions[i]
predicted_label = np.argmax(predictions_array)
true_label = t_test[i]
if predicted_label != true_label:
gohantei.append(i)
print(len(gohantei))
178
def plot_image(i, predictions, t_label, img):
class_names = ['cat', 'dog']
predictions_array = predictions[i]
img = img[i].reshape((80, 80, 3))
true_label = t_label[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)
num_cols = 10
num_rows = int(len(gohantei) / num_cols ) + 1
plt.figure(figsize=(2*num_cols, 2.5*num_rows))
j = 0
for i in gohantei:
inuneko = t_test[i]
if inuneko == 0:
plt.subplot(num_rows, num_cols, j+1)
plot_image(i, predictions, t_test, x_test)
j +=1
plt.show()
print("J'ai fait une erreur chez le chat",j)
plt.figure(figsize=(2*num_cols, 2.5*num_rows))
j = 0
for i in gohantei:
inuneko = t_test[i]
if inuneko == 1:
plt.subplot(num_rows, num_cols, j+1)
plot_image(i, predictions, t_test, x_test)
j +=1
plt.show()
print("J'ai fait une erreur chez le chien",j)
Mauvais chat 28 Mauvais chien 150
Lorsqu'il n'y a pas de données inversées Il y a eu 158 erreurs, 109 erreurs pour les chats et 49 erreurs pour les chiens. Uniquement pour les chats, la précision est grandement améliorée. Cependant, la précision du chien a diminué de ce montant et la précision de l'ensemble a diminué.
L'apprentissage semble être renforcé par l'ajout de données, mais cela signifie-t-il que les effets secondaires sont également importants?
J'ai examiné l'image d'un chat qui est passée d'une erreur à une réponse correcte et l'image d'un chien qui est passée d'une réponse correcte à une erreur.
L'image du chat qui est passée d'une erreur à la bonne réponse La marque rouge est celle qui était erronée la deuxième fois
L'image du chien est passée de correcte à incorrecte La marque jaune était la première erreur
L'image d'un chat assis comme un chien est maintenant correctement jugée, mais l'image d'un chien assis normalement est également considérée comme un "chat"? Aussi, dans un premier temps, une grande copie du visage, qui n'aurait été jugée comme «chien» que par le nez, est jugée comme «chat».
Woom. Je ne sais pas.
Alors, que se passe-t-il si vous apprenez en ajoutant une image inversée du chien? Je l'ai essayé.
J'ai essayé d'apprendre en ajoutant des images inversées de chats et de chiens
En d'autres termes, le nombre de données d'entraînement sera doublé.
Le résultat est
32/32 - 4s - loss: 0.2186 - accuracy: 0.9090
Taux de réponse corrigé amélioré à 90%. Sur les 91 faux positifs, 48 chats confondus avec des chiens 43 chiens confondus avec des chats
Lorsqu'il n'y a pas de données inversées Il y a eu 158 erreurs, 109 erreurs pour les chats et 49 erreurs pour les chiens. Le nombre de chats trompés a été réduit de moitié.
Il semble que l'image de s'asseoir comme un chien et l'image d'une grande copie du visage soient passées d'erreurs à des réponses correctes.
De ce qui précède, pouvons-nous dire ce qui suit?
-Les données d'entraînement sont retournées horizontalement, et même si le nombre de cas est doublé, elles peuvent être utilisées pour l'apprentissage et sont efficaces. ・ Lors de la classification en deux comme dans cet exemple, il est préférable d'avoir le même nombre de données d'entraînement pour les chiens et les chats pour un apprentissage plus impartial.
Cependant, si le nombre de données d'entraînement double, Google Colab manquera également de RAM et plantera. Il semble donc difficile d'augmenter davantage les données, nous mettrons donc fin à la discrimination des données sur les chiens et les chats à ce stade.
Recommended Posts