[PYTHON] "Deep Learning from Grund" Memo zum Selbststudium (Nr. 19) Datenerweiterung
Während ich "Deep Learning from Grund" (gelesen von Yasuki Saito, veröffentlicht von O'Reilly Japan) lese, werde ich die Websites notieren, auf die ich mich bezog. Teil 18 ←
Ich konnte Hunde und Katzen ziemlich gut beurteilen, aber ich bin der Meinung, dass die richtige Antwortrate immer noch unter 90% liegt. Ich denke, ich werde die auf Seite 245 des Buches beschriebene Datenerweiterung ausprobieren. ..
Data Augmentation Was scheint einfach zu sein, wenn man die Daten erweitert Umkehren Drehung Bewegung Ist es da?
Wie ich in GradCAM gesehen habe, scheint die Katze auf die zusammengerollte Haltung und der Hund auf die Nase zu reagieren.
Das bedeutet
Ist es nicht möglich, die Erkennungsgenauigkeit von Katzen durch Hinzufügen eines gedrehten oder invertierten Bildes einer Katze zu verbessern? Wenn Sie den Bereich um das Gesicht des Hundebilds vergrößern, verbessert sich die Erkennungsgenauigkeit des Hundes. Was kann berücksichtigt werden.
Daher möchte ich überprüfen, wie das Hinzufügen erweiterter Daten das Lernen verbessert.
Erstellen Sie zunächst die Trainingsdaten und Testdaten neu
Die bisher verwendeten Daten sind ziemlich gut gemacht, nur weil es nur notwendig ist, den Betrieb des Programms zu bestätigen. Es gibt nur 100 Testdaten.
Ich möchte ungefähr 1000 Testdaten zufällig speichern. Führen Sie für den Rest der Trainingsdaten die Bilder von Hunden und Katzen zusammen und ordnen Sie sie dann zufällig neu an. Die erweiterten Daten werden für jede Hunde- und Katzenverarbeitungsmethode getrennt und während des Lernens mit den Trainingsdaten zusammengeführt, damit der Effekt überprüft werden kann. Bei der Überprüfung wird nicht nur die insgesamt korrekte Antwortrate, sondern auch die korrekte Antwortrate für Hunde und die korrekte Antwortrate für Katzen überprüft. Überprüfen Sie außerdem, auf welche Funktionen des falschen Bildes mit GradCAM reagiert wird.
Mit einer solchen Richtlinie haben wir die Trainingsdaten neu erstellt.
def rnd_list(motoarray, toridasi):
#Erstellen Sie eine Ganzzahlliste von 0 bis zur Anzahl der Daten im ursprünglichen np-Array
#Nach dem zufälligen Sortieren
#Gibt eine Liste der angegebenen Anzahl von Ganzzahlen und eine Liste der verbleibenden Ganzzahlen zurück
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):
#np Array Daten
#In der angegebenen Nummernliste und im Rest der Liste
#Zu teilen
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):
#Eine Reihe von Bildern und eine Reihe von Beschriftungen
#Zufällig sortiert
#Liste und zurück
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
#Teilen Sie für Training und Tests und integrieren Sie Hunde und Katzen
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)
#Nach dem Zufallsprinzip sortieren
wtri, wtrl = rnd_arry(tri, trl)
wtsi, wtsl = rnd_arry(tsi, tsl)
#sparen
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)
Trainingsdaten 23994 (Hund 11997, Katze 11997), Testdaten 1000 (Hund 500, Katze 500) Ist fertig.
Wenn Sie dies eingeben und mit DeepConvNet verarbeiten, das in Teil 18 erstellt wurde
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
Das Ergebnis ist eine korrekte Rücklaufquote von 84,2%.
Ich werde den Inhalt des Ergebnisses überprüfen
predictions = model.predict(x_test)
#Listen Sie die Indizes für Fehleinschätzungen auf
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
Es gab 158 falsch positive Ergebnisse.
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("Ich habe einen Fehler bei der Katze gemacht",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("Ich habe einen Fehler beim Hund gemacht",j)
Die Aufteilung der Fehleinschätzungen betrug 109 Katzen und 49 Hunde. Katzen werden mehr als doppelt so falsch eingeschätzt wie Hunde.
Wird das Lernen in erster Linie durch Hinzufügen erweiterter Daten verbessert?
Mal sehen, ob die Fehleinschätzung von Katzen durch Erweitern und Hinzufügen von Katzendaten verringert werden kann.
#Extrahieren Sie nur Katzenbilder
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
#Erstellen Sie einen invertierten Bilddatensatz einer Katze von links nach rechts
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
Trainieren Sie mit den Trainingsdaten, wobei die invertierten Katzendaten hinzugefügt werden.
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)
#Listen Sie die Indizes für Fehleinschätzungen auf
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("Ich habe einen Fehler bei der Katze gemacht",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("Ich habe einen Fehler beim Hund gemacht",j)
Falsche Katze 28 Falscher Hund 150
Wenn keine invertierten Daten vorhanden sind Es gab 158 Fehler, 109 Fehler für Katzen und 49 Fehler für Hunde. Nur für Katzen ist die Genauigkeit stark verbessert. Die Genauigkeit des Hundes nahm jedoch um diesen Betrag ab, und die Genauigkeit des Ganzen nahm ab.
Das Lernen scheint durch das Hinzufügen von Daten gestärkt zu werden. Bedeutet dies jedoch, dass die Nebenwirkungen ebenfalls groß sind?
Ich untersuchte das Bild einer Katze, die sich von einem Fehler zu einer richtigen Antwort wandelte, und das Bild eines Hundes, der sich von einer richtigen Antwort zu einem Fehler wandelte.
Das Katzenbild, das sich von einem Fehler zur richtigen Antwort geändert hat Die rote Markierung ist diejenige, die beim zweiten Mal falsch war
Hundebild, das sich von richtig zu falsch geändert hat Die gelbe Markierung war der erste Fehler
Das Bild einer Katze, die wie ein Hund sitzt, wird jetzt richtig beurteilt, aber das Bild eines Hundes, der normalerweise sitzt, wird auch als "Katze" beurteilt? Außerdem wird beim ersten Mal eine große Kopie des Gesichts, die nur von der Nase als "Hund" beurteilt worden wäre, als "Katze" beurteilt.
Woom. Ich weiß es nicht.
Was passiert also, wenn Sie lernen, indem Sie ein umgekehrtes Bild des Hundes hinzufügen? Ich versuchte es.
Ich habe versucht zu lernen, indem ich umgekehrte Bilder von Katzen und Hunden hinzugefügt habe
Mit anderen Worten wird die Anzahl der Trainingsdaten verdoppelt.
Ergebnis ist
32/32 - 4s - loss: 0.2186 - accuracy: 0.9090
Die korrigierte Antwortrate verbesserte sich auf 90%. Von den 91 falsch positiven Ergebnissen verwechselten 48 Katzen mit Hunden, 43 Hunde mit Katzen
Wenn keine invertierten Daten vorhanden sind Es gab 158 Fehler, 109 Fehler für Katzen und 49 Fehler für Hunde. Die Anzahl der irrtümlichen Katzen wurde halbiert.
Es scheint, dass sich das Bild des Sitzens wie ein Hund und das Bild einer großen Kopie des Gesichts von Fehlern zu richtigen Antworten geändert haben.
Können wir aus dem Obigen Folgendes sagen?
-Die Trainingsdaten werden horizontal gespiegelt, und selbst wenn sich die Anzahl der Fälle verdoppelt, können sie zum Lernen verwendet werden und sind effektiv. ・ Wenn Sie wie in diesem Beispiel in zwei Klassen einteilen, ist es besser, die gleiche Anzahl von Trainingsdaten für Hunde und Katzen zu haben, um unvoreingenommener zu lernen.
Wenn sich die Anzahl der Trainingsdaten jedoch verdoppelt, geht Google Colab auch der RAM aus und es stürzt ab. Es scheint also schwierig zu sein, die Daten weiter zu erhöhen, daher werden wir die Diskriminierung von Hunde- und Katzendaten an dieser Stelle beenden.
Teil 18 ←
Recommended Posts