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)

c1.jpg c2.jpg c3.jpg d1.jpg

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 mae1.jpg mae2.jpg mae3.jpg

L'image du chien est passée de correcte à incorrecte La marque jaune était la première erreur matigai2.jpg matigai3.jpg matigai4.jpg matigai5.jpg

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.

Partie 18

Recommended Posts

Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 19) Augmentation des données
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 11) CNN
Mémo d'auto-apprentissage "Deep Learning from scratch" (partie 12) Deep learning
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 18) One! Miaou! Grad-CAM!
Mémo d'auto-apprentissage "Deep Learning from scratch" (n ° 15) Tutoriel pour débutants TensorFlow
Mémo d'auto-apprentissage "Deep Learning from scratch" (glossaire illisible)
Mémo d'auto-apprentissage «Deep Learning from scratch» (10) Classe MultiLayerNet
Mémo d'auto-apprentissage "Deep Learning from scratch" (n ° 13) Essayez d'utiliser Google Colaboratory
Mémo d'auto-apprentissage «Deep Learning from scratch» (n ° 10-2) Valeur initiale du poids
[Mémo d'apprentissage] Le Deep Learning fait de zéro [Chapitre 7]
Deep learning / Deep learning made from scratch Chapitre 6 Mémo
[Mémo d'apprentissage] Deep Learning fait de zéro [Chapitre 5]
[Mémo d'apprentissage] Le Deep Learning fait de zéro [Chapitre 6]
Deep learning / Deep learning made from scratch Chapitre 7 Mémo
[Mémo d'apprentissage] Deep Learning fait de zéro [~ Chapitre 4]
Apprentissage profond à partir de zéro
"Deep Learning from scratch" Mémo d'auto-apprentissage (n ° 16) J'ai essayé de créer SimpleConvNet avec Keras
"Deep Learning from scratch" Mémo d'auto-apprentissage (n ° 17) J'ai essayé de créer DeepConvNet avec Keras
Deep Learning from scratch Chapter 2 Perceptron (lecture du mémo)
[Mémo d'apprentissage] Apprentissage profond à partir de zéro ~ Mise en œuvre de l'abandon ~
"Deep Learning from scratch" Mémo d'auto-apprentissage (n ° 14) Exécutez le programme du chapitre 4 sur Google Colaboratory
Apprentissage profond à partir de zéro 1 à 3 chapitres
Deep learning / Deep learning from scratch 2 Chapitre 4 Mémo
Deep learning / Deep learning made from scratch Chapitre 3 Mémo
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 5 Mémo
Apprentissage profond à partir de zéro (calcul des coûts)
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 7 Mémo
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 8 Mémo
Deep learning / Deep learning made from scratch Chapitre 5 Mémo
Deep learning / Deep learning made from scratch Chapitre 4 Mémo
Deep learning / Deep learning from scratch 2 Chapitre 3 Mémo
Mémo d'apprentissage profond créé à partir de zéro
Deep Learning / Deep Learning à partir de Zero 2 Chapitre 6 Mémo
Apprentissage profond à partir de zéro (propagation vers l'avant)
Apprentissage profond / Apprentissage profond à partir de zéro 2-Essayez de déplacer GRU
"Deep Learning from scratch" avec Haskell (inachevé)
Pourquoi ModuleNotFoundError: Aucun module nommé'dataset.mnist 'n'apparaît dans "Deep Learning from scratch".
[Windows 10] Construction de l'environnement "Deep Learning from scratch"
Enregistrement d'apprentissage de la lecture "Deep Learning from scratch"
Mémo d'auto-apprentissage "Deep Learning from scratch" (partie 8) J'ai dessiné le graphique du chapitre 6 avec matplotlib
[Deep Learning from scratch] À propos de l'optimisation des hyper paramètres
Deep Learning from scratch ① Chapitre 6 "Techniques liées à l'apprentissage"
GitHub du bon livre "Deep Learning from scratch"
Résumé Python vs Ruby "Deep Learning from scratch"
Django memo n ° 1 à partir de zéro
[Deep Learning from scratch] J'ai implémenté la couche Affine
Application de Deep Learning 2 à partir de zéro Filtre anti-spam
[Deep Learning from scratch] J'ai essayé d'expliquer le décrochage
Apprentissage profond / code de travail LSTM
[Deep Learning from scratch] Implémentation de la méthode Momentum et de la méthode AdaGrad
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 1
Un amateur a trébuché dans le Deep Learning ❷ fait à partir de zéro Note: Chapitre 5
Un amateur a trébuché dans le Deep Learning ❷ fait à partir de zéro Note: Chapitre 2
Créez un environnement pour "Deep Learning from scratch" avec Docker
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 3
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 7
Un amateur a trébuché dans le Deep Learning à partir de zéro Note: Chapitre 5
Un amateur a trébuché dans le Deep Learning ❷ fait de zéro Note: Chapitre 1