[PYTHON] Beurteilung, ob es sich um mein Kind handelt oder nicht, nach dem Bild des Shiba-Hundes durch tiefes Lernen (2) Datenerhöhung, Transferlernen, Feinabstimmung

Schritt 3 Modellbau / Lernen / Ergebnisse

(1) Lernergebnisse ohne Datenerweiterung

――Die Ergebnisse des Trainings sind in der folgenden Grafik dargestellt. Es gibt Anzeichen für Überlernen sowohl bei der Genauigkeit als auch beim Verlust, und es gibt keine merkliche Verbesserung.

(2) Anwendung zum Testen von Daten (keine Datenerweiterung)

Die auf die Testdaten angewendeten Verifizierungsergebnisse sind wie folgt. Das Erhöhen der Anzahl von Probendaten hat zu einer verbesserten Genauigkeit geführt, und die Genauigkeit hat etwa 80% erreicht. test loss: 1.7524430536416669 test acc: 0.8166666567325592

(3) Lernergebnisse mit Datenerweiterung

Dann habe ich mit Datenerweiterung trainiert. Die Ergebnisse des Trainings sind in der folgenden Grafik dargestellt.

(4) Anwendung zum Testen von Daten (mit Datenerweiterung)

Als nächstes lauten die Überprüfungsergebnisse der Testdaten, wenn die Bildgeneratoreinstellung so eingestellt ist, dass die Bilddaten aufgefüllt werden, wie folgt (die Auffüllbedingungen sind dieselben wie die Einstellungen des vorherigen Versuchs, nur die Ergebnisanzeige). Dieser hat eine höhere Genauigkeit. test loss: 1.382319548305386 test acc: 0.8666666634877522

Schritt 4 Transferlernen mit ImageNet-Modell (VGG16)

Dieses Mal werden wir Transferlernen durchführen. Importieren Sie das trainierte Modell (VGG16) von ImageNet, das ein typisches Modell ist, aus der Keras-Bibliothek und verwenden Sie es. Aus dem VGG16-Modell wird nur die trainierte Faltungsbasis verwendet, um eine vielseitige lokale Feature-Map zu extrahieren. Durch Verbinden des Klassifikators "(für Shiba-Hund) mein Kind - anderes Kind" mit der Ausgabe wird die Klassifizierungsgenauigkeit verbessert.

(1) Über VGG16

--VGG16 ist ein mehrschichtiges neuronales Netzwerk, das aus 13 Faltungsschichten und 3 vollständig verbundenen Schichten für insgesamt 16 Schichten besteht. Das veröffentlichte Modell wird mit einem großen Bildsatz namens ImageNet trainiert.

• Es ist im Modul keras.applications.vgg16 als Keras-Bibliothek implementiert.

(2) Laden Sie das Modell

―― Im Folgenden wird davon ausgegangen, dass in Google Drive ein Datenspeicherordner und ein Arbeitsordner erstellt wurden und Bilddaten für die Analyse gespeichert wurden. (Implementiert in derselben Analyseumgebung wie zuvor) --Laden Sie das VGG16-Modell in die Variable conv_base.

#Laden von VGG16
from keras.applications import VGG16

conv_base = VGG16(weights='imagenet', #Geben Sie die Art des Gewichts an(Geben Sie hier das von Imagenet gelernte Gewicht an)
                  include_top=False, #Gibt an, ob der vollständig gekoppelte Klassifikator auf der Ausgangsseite des NW enthalten sein soll(Da wir hier unseren eigenen vollständig verbundenen Klassifikator verwenden, werden wir ihn nicht einschließen.)
                  input_shape=(320, 320, 3)) #Der ImageNet-Standard ist die Form des Bildtensors, der dem NW zugeführt wird.(224, 224 3)　(Diesmal 320pxl*Geben Sie ein 320pxl-RGB-Bild an)
conv_base.summary()

Die folgende Modellstruktur wird für den relevanten Teil des geladenen VGG16 angezeigt.

Model: "vgg16"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
input_2 (InputLayer)         (None, 320, 320, 3)       0         
_________________________________________________________________
block1_conv1 (Conv2D)        (None, 320, 320, 64)      1792      
_________________________________________________________________
block1_conv2 (Conv2D)        (None, 320, 320, 64)      36928     
_________________________________________________________________
block1_pool (MaxPooling2D)   (None, 160, 160, 64)      0         
_________________________________________________________________
block2_conv1 (Conv2D)        (None, 160, 160, 128)     73856     
_________________________________________________________________
block2_conv2 (Conv2D)        (None, 160, 160, 128)     147584    
_________________________________________________________________
block2_pool (MaxPooling2D)   (None, 80, 80, 128)       0         
_________________________________________________________________
block3_conv1 (Conv2D)        (None, 80, 80, 256)       295168    
_________________________________________________________________
block3_conv2 (Conv2D)        (None, 80, 80, 256)       590080    
_________________________________________________________________
block3_conv3 (Conv2D)        (None, 80, 80, 256)       590080    
_________________________________________________________________
block3_pool (MaxPooling2D)   (None, 40, 40, 256)       0         
_________________________________________________________________
block4_conv1 (Conv2D)        (None, 40, 40, 512)       1180160   
_________________________________________________________________
block4_conv2 (Conv2D)        (None, 40, 40, 512)       2359808   
_________________________________________________________________
block4_conv3 (Conv2D)        (None, 40, 40, 512)       2359808   
_________________________________________________________________
block4_pool (MaxPooling2D)   (None, 20, 20, 512)       0         
_________________________________________________________________
block5_conv1 (Conv2D)        (None, 20, 20, 512)       2359808   
_________________________________________________________________
block5_conv2 (Conv2D)        (None, 20, 20, 512)       2359808   
_________________________________________________________________
block5_conv3 (Conv2D)        (None, 20, 20, 512)       2359808   
_________________________________________________________________
block5_pool (MaxPooling2D)   (None, 10, 10, 512)       0         
=================================================================
Total params: 14,714,688
Trainable params: 14,714,688
Non-trainable params: 0
_________________________________________________________________

(3) Modellbau

Erstellen Sie ein Modell, indem Sie die vollständig verbundene Ebene für diese binäre Klassifizierung mit conv_base verbinden.

from keras import models
from keras import layers

model = models.Sequential()
model.add(conv_base)
model.add(layers.Flatten())
model.add(layers.Dense(256, activation='relu'))
model.add(layers.Dense(1, activation='sigmoid'))

model.summary()

Die folgende Modellstruktur wird angezeigt.

Model: "sequential_1"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
vgg16 (Model)                (None, 10, 10, 512)       14714688  
_________________________________________________________________
flatten_1 (Flatten)          (None, 51200)             0         
_________________________________________________________________
dense_1 (Dense)              (None, 256)               13107456  
_________________________________________________________________
dense_2 (Dense)              (None, 1)                 257       
=================================================================
Total params: 27,822,401
Trainable params: 27,822,401
Non-trainable params: 0
_________________________________________________________________

(4) Überprüfen Sie die Anzahl der trainierbaren Gewichte

# conv_Anzahl der Gewichte, die vor dem Einfrieren der Basis trainiert werden können
print('conv_Anzahl der Gewichte, die vor dem Einfrieren der Basis trainiert werden können:' ,len(model.trainable_weights))

Bei der Ausführung wird das Ergebnis "30" angezeigt.

(5) Setzen Sie nur das Gewicht von conv_base auf nicht trainierbar und überprüfen Sie das Einstellungsergebnis.

# conv_Stellen Sie nur das Grundgewicht so ein, dass es nicht trainierbar ist
conv_base.trainable = False

#Überprüfen der Anzahl der trainierbaren Gewichte
print('conv_Basis Anzahl der Gewichte, die im gefrorenen Zustand trainiert werden können:' ,len(model.trainable_weights))

Bei der Ausführung wird die Anzahl der trainierbaren Gewichte auf "4" geändert und angezeigt. Trainieren Sie das Modell in diesem Setup-Zustand.

(5) Bildtensorisierung und Lernen

Verwenden Sie den folgenden Code.

from keras.preprocessing.image import ImageDataGenerator
from keras import optimizers

#Einstellungen des Zugdatengenerators Aufgeblasen: Ja
train_datagen = ImageDataGenerator(
    rescale=1./255,
    rotation_range=40,
    width_shift_range=0.2,
    height_shift_range=0.2,
    shear_range=0.2,
    zoom_range=0.2,
    horizontal_flip=True,
    fill_mode='nearest')

#Generatoreinstellungen für Validierungsdaten und Testdaten Aufgeblasen: Keine\(Der Generator von Validierungsdaten und Testdaten ist üblich)
test_datagen = ImageDataGenerator(rescale=1./255)

#Tensolisierung von Zugdaten
train_generator = train_datagen.flow_from_directory(
        # target directory
        train_dir,
        # size 320x320
        target_size=(320, 320),
        batch_size=20,
        #Binär als Verlustfunktion_Erfordert eine binäre Bezeichnung für die Verwendung von Crossentropy
        class_mode='binary')

#Tensolisierung von Validierungsdaten
validation_generator = test_datagen.flow_from_directory(
        validation_dir,
        target_size=(320, 320),
        batch_size=32,
        class_mode='binary')

#Modell kompilieren
model.compile(loss='binary_crossentropy',
              optimizer=optimizers.RMSprop(lr=2e-5),
              metrics=['acc'])

#Lernen
history = model.fit_generator(
      train_generator,
      steps_per_epoch=100,
      epochs=30,
      validation_data=validation_generator,
      validation_steps=50,
      verbose=2)

Speichern Sie das Modell nach der Ausführung.

model.save('mydog_or_otherdogs_02a.h5')

(6) Ausführungsergebnis

• Die Grafik der Trainingsergebnisse ist wie folgt. ――Die Form des Diagramms hat sich geändert. Die Genauigkeit beginnt bei etwa 0,88 und verbessert sich von 0,93 auf etwa 0,96. Der Verlust beginnt bei 0,3 und lag im Bereich von 0,1 bis 0,2. Es gibt einige Anzeichen für eine Verbesserung gegenüber dem Überlernzustand.

--Überprüfen Sie als nächstes das Klassifizierungsergebnis dieses Modells mit Testdaten. (Code siehe vorherigen Artikel) test loss: 0.274524162985399 test acc: 0.9333333373069763

• Durch das Transferlernen hat sich die Klassifizierungsleistung verbessert. Die Genauigkeit lag erstmals über 90%. ――In dieser Studie wurde nur das trainierte Modul von VGG16 für die Faltungsbasis verwendet, aber die Fähigkeit, die vielseitige lokale Feature-Map zu extrahieren, die durch Training mit ImageNet erhalten wurde, trägt erheblich zur Klassifizierungsleistung bei. Sie können sehen, dass es sein wird.

Schritt 5 Feinabstimmung mit dem ImageNet-Modell (VGG16)

(1) Überblick über die Feinabstimmung

Durch die Feinabstimmung werden mehrere ausgangsseitige Schichten der gefrorenen Faltungsbasis, die für die Merkmalsextraktion verwendet wird, aufgetaut und sowohl der neu hinzugefügte Teil des Modells (in diesem Fall der vollständig gekoppelte Klassifikator) als auch die aufgetaute Schicht trainiert. Es ist ein Mechanismus zu tun.

(2) Feinabstimmung des Implementierungsverfahrens

1. Fügen Sie am Ende des trainierten Basisnetzwerks ein benutzerdefiniertes Netzwerk hinzu

2. Frieren Sie das Basisnetzwerk ein
3. Lernen Sie den hinzugefügten Teil
4. Entpacken Sie einige Schichten des Basisnetzwerks
5. Trainieren Sie gleichzeitig die aufgetaute Schicht und das hinzugefügte Teil

• In Bezug auf die Beschreibung von (1) und (2) wird der relevante Teil aus "Deep Learning von Python und Keras" von Francois Chollet zitiert, übersetzt von Quipe Co., Ltd., übersetzt von Yusuke Negago und veröffentlicht von My Navi Publishing Co., Ltd.

(3) Einstellung der trainierbaren Gewichte

• Der folgende Code legt die Gewichte fest, die bei der Feinabstimmung trainiert werden können. --Stellen Sie nur drei Ebenen, block5_conv1, block5_conv2 und block5_conv3, so ein, dass sie trainiert werden können.

conv_base.trainable = True

set_trainable = False
for layer in conv_base.layers:
  if layer.name == 'block5_conv1':
    set_trainable = True
  if set_trainable:
    layer.trainable = True
  else:
    layer.trainable = False

(4) Durchführung der Feinabstimmung

Lernen wir mit dem folgenden Code.

#Wählen Sie RMSprop als Optimierer und verwenden Sie eine relativ niedrige Lernrate
#Wenn der Aktualisierungswert groß ist, werden die Ausdrücke der drei Feinabstimmungsebenen beschädigt.

model.compile(loss='binary_crossentropy',
              optimizer=optimizers.RMSprop(lr=1e-5),
              metrics=['acc'])

history = model.fit_generator(
      train_generator,
      steps_per_epoch=100,
      epochs=100,
      validation_data=validation_generator,
      validation_steps=50)

Speichern Sie das Modell nach dem Training.

model.save('mydog_or_otherdogs_02b.h5')

(5) Ergebnisdiagramm

Das resultierende Diagramm ist unten dargestellt. Der folgende Code glättet das Diagramm.

#Plotglättung
def smooth_curve(points, factor=0.8):
    smoothed_points = []
    for point in points:
        if smoothed_points:
            previous = smoothed_points[-1]
            smoothed_points.append(previous * factor + point * (1 - factor))
        else:
            smoothed_points.append(point)
    return smoothed_points


plt.plot(epochs, smooth_curve(acc), 'bo', label='Smoothed training acc')
plt.plot(epochs, smooth_curve(val_acc), 'b', label='Smoothed validation acc')
plt.title('Training and validation accuracy')
plt.legend()

plt.figure()

plt.plot(epochs, smooth_curve(loss), 'bo', label='Smoothed training loss')
plt.plot(epochs, smooth_curve(val_loss), 'b', label='Smoothed validation loss')
plt.title('Training and validation loss')
plt.legend()

plt.show()

Die Grafik ist wie folgt. Betrachtet man den Validierungsstatus, so scheint sich die Leistung mit zunehmender Anzahl von Epochen nicht zu verbessern, aber der Änderungsbereich des Diagramms wird in einem engeren Bereich als zuvor angezeigt, sodass die Genauigkeit verbessert wird. Sie können erwarten, dort zu sein.

(6) Wenden Sie das trainierte Modell auf die Testdaten an, um die Klassifizierungsgenauigkeit zu überprüfen.

Die auf die Testdaten angewendeten Verifizierungsergebnisse sind wie folgt.

test loss: 0.5482699687112941 test acc: 0.9499999916553498

Durch die Feinabstimmung konnten wir die Klassifizierungsleistung weiter verbessern. Ich möchte verschiedene Ansätze implementieren, die ich noch nicht versucht habe, um die Genauigkeit weiter zu verbessern. Bei dieser Überprüfung werden wir bisher eine Pause einlegen.