[PYTHON] [Zur Aufnahme] Keras-Bildsystem Teil 2: Lassen Sie CNN anhand Ihres eigenen Datensatzes beurteilen

Vielen Dank.

Im vorherigen Artikel ging es darum, Bilder mit Keras zu lesen und einen Datensatz zu erstellen.

https://qiita.com/ku_a_i/items/7f71933f6b71cf30a3a8

Dieses Mal werde ich versuchen, diesen Datensatz zu verwenden, um tatsächlich ein Urteil von CNN zu fällen. Es wird angenommen, dass die Ordnerstruktur wie folgt ist.

python

'''
picture -╷- train -╷- Apple(Kategorie 1) -╷- **.png #Zum Lernen
         ╎         ╎            　  ╎  (Viele Bilder ... weggelassen)
         ╎         ╎            　  ╵- **.png
         ╎         ╵- Mango(Kategorie 2) - (Abkürzung)
         ╎         
         ╵-  val  -╷- Apple(Kategorie 1) - (Abkürzung) #Zur Überprüfung des Lernens
                   ╵- Mango(Kategorie 2) - (Abkürzung)
'''

0. Letzte Überprüfung. Erstellen eines Datensatzes

python

from keras.preprocessing.image import ImageDataGenerator

#Aufbau
classes = ['Apple', 'Mango']#Wenn Sie lernen möchten, Äpfel und Mangos zu klassifizieren
train_data_dir = './picture/train'#Geben Sie den übergeordneten Ordner für die Klassifizierung an(Apple,Mango oberer Ordner)
val_data_dir = './picture/val'
img_height = 100
img_width = 100
batch_size = 16

#Trainingsdaten erstellen
#Teilen Sie durch 255, um zu skalieren
train_datagen = ImageDataGenerator(rescale = 1.0 / 255) #Sie können auch die Polsterung einstellen, diesmal wird sie jedoch weggelassen

#Stellen Sie den Lerngenerator ein.
#Grob gesagt ist Generator jedes Mal(Hier für jede Losgröße)Ein Bild erzeugen
train_generator = train_datagen.flow_from_directory(
    train_data_dir,
    target_size = (img_height, img_width), #Keine Abmessungen erforderlich
    color_mode = 'rgb', #Wenn grau'grayscale'Eingeben
    classes = classes, 
    class_mode = 'binary', #Da gibt es zwei, binär. Wenn es 3 oder mehr gibt'categorical'
    batch_size = batch_size,
    shuffle = True)


#Erstellen Sie Validierungsdaten
val_datagen = ImageDataGenerator(rescale = 1.0 / 255)

#Stellen Sie den Validierungsgenerator ein.
val_generator = val_datagen.flow_from_directory(
    val_data_dir,
    target_size = (img_height, img_width),
    color_mode = 'rgb',
    classes = classes, 
    class_mode = 'binary',
    batch_size = batch_size,
    shuffle = True)

Nachdem wir einen Datensatz haben, erstellen wir einen CNN, um diese Daten einzufügen.

1. Erstellen eines CNN

Es gibt verschiedene Arten von CNNs. Einfach gesagt ① Erstellen Sie eine Ebene, indem Sie selbst von 0 entwerfen (2) Verwenden Sie ein Modell, das jemand auf der Welt bereits für das Lernen eingestellt hat.

Diese beiden sind grob klassifiziert. Da es in Qiita bereits viele Artikel gibt, die sowohl für ① als auch für ② leicht zu verstehen sind, werde ich es diesmal mit ② versuchen. Ich möchte Ihnen sagen, dass das CNN-Lernen mit dem Keras-Generator das erste ist.

python

#Laden Sie VGG16

from keras.applications.vgg16 import VGG16
from keras.optimizers import Adam
from keras.layers import Input, Dense, Flatten, Dropout
from keras.models import Sequential
from keras.models import Model

input_tensor = Input(shape=(img_width, img_height, 3))

#Der Straßenteil der VGG. FC-Schicht ist nicht erforderlich, also einschließen_top=Auf False setzen
vgg16 = VGG16(include_top=False, weights='imagenet', input_tensor=input_tensor)

#Entwerfen Sie die FC-Ebene, die Sie nicht mehr benötigen
model = Sequential()
model.add(Flatten(input_shape=vgg16.output_shape[1:]))
model.add(Dense(256, activation='relu'))
model.add(Dense(1, activation='sigmoid'))

#Erstellen Sie ein Modell, indem Sie VGG16 und Ihre eigene FC-Ebene kombinieren
vgg16_model = Model(input=vgg16.input, output=model(vgg16.output))

#Friere die Ebene kurz vor der letzten Conv-Ebene ein(Einfrieren: Vom Lernen weglassen)
for layer in vgg16_model.layers[:15]:
    layer.trainble=False
    
#kompilieren
vgg16_model.compile(loss='binary_crossentropy',
                 optimizer=Adam(lr=1e-4),
                 metrics=['accuracy'])

Dies vervollständigt das Design des für das Training verwendeten CNN. Alles was Sie tun müssen, ist zu lernen. Schauen wir uns vorher das Gesamtbild von CNN an

python

vgg16_model.summary()

Es ist ziemlich luxuriös, aber mach dir keine Sorgen. ..

Übrigens ist der Teil, den ich gemacht habe, ein sequentieller Teil, aber es gibt keine Details. Lassen Sie es uns unten überprüfen

python

model.summary()

Jetzt sind alle Schichten klar.

2. Lernen wir mit CNN

Jetzt, wo ich ein vollständiges Bild habe, ist es Zeit zu lernen.

python

#Geben Sie die Gesamtzahl der Bilder ein *.Praktisch, weil Sie die Gesamtzahl der Blätter mit n sehen können
steps_per_epoch = train_generator.n
validation_steps = val_generator.n
#Einstellen der Anzahl der Epochen. Da später das frühe Stoppen beschrieben wird, können Sie es größer einstellen.
nb_epoch = 1000

#Rückrufeinstellungen
from keras.callbacks import EarlyStopping,ModelCheckpoint
es = EarlyStopping(monitor='val_loss', patience=10, verbose=1)#Nur die Anzahl der Geduld val_Automatischer Stopp, wenn der Verlust nicht aktualisiert wird
cp = ModelCheckpoint(filepath = './model.hdf5', save_best_only=True)#save_best_Modell speichern, wenn Verlust nur mit aktualisiert wird

#Das CNN-Lernen begann. passen_Generator verwenden.
history = vgg16_model.fit_generator(
    train_generator,
    steps_per_epoch = steps_per_epoch // batch_size,
    epochs = nb_epoch,
    verbose=1,
    validation_data=val_generator,
    validation_steps = validation_steps // batch_size,
    callbacks=[es, cp])

Lassen Sie uns nach dem Lernen den Lernstatus zeichnen und anzeigen

python

acc = histry.history['acc']
val_acc = histry.history['val_acc']
loss = histry.history['loss']
val_loss = histry.history['val_loss']

epochs = range(1, len(acc) + 1)

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

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

plt.show()

3. Lassen Sie uns anhand des trainierten Modells beurteilen

Und beurteilen wir ein anderes Bild mit dem fertigen Lernmodell Da ich beim letzten Mal gelernt habe, wie man ein Bild lädt, laden wir es mit load_img und beurteilen ein Bild.

• Beurteilungsbilder werden der Einfachheit halber in dieselbe Hierarchie wie das Programm gestellt. (B.jpg)
• Wenn Sie mehrere Daten testen, können Sie den Generator verwenden oder auf dieselbe Weise auflisten.

python

import numpy as np
from keras.preprocessing.image import load_img,img_to_array

img_shape = (100, 100, 3) 
img = load_img('B.jpg', grayscale=False, target_size=img_shape)

#Konvertieren Sie in den Numpy-Array-Typ, um ihn in ein neuronales Netzwerk aufzunehmen
x_test = img_to_array(img) / 255

#Mit Umformung in CNN setzen(n, w, h, c)Ich werde es in eine Form machen
#Da eine kleine Anzahl von 0 bis 1 ausgegeben wird, ist np.Ich werde die Ausgabe in eine Klassenbezeichnung mit rund ändern(0or1)
print(np.round(vgg16_model.predict(x_test.reshape(1,100,100,3))))

Dann sehen Sie 0 oder 1 als Ergebnis. Da Sie jede Klassifizierung mit print überprüfen können (train_generator.class_indices) Wenn das Lernen erfolgreich ist, sollte diesmal 0 Apple und 1 Mango sein.

Nun, diesmal werde ich es so machen. Wie war das? Ich denke nicht, dass es so schwierig war. Das nächste Mal denke ich darüber nach, die Bildwiederherstellung mit einem Auto-Encoder oder 3 oder mehr Klassifizierungsversionen durchzuführen.

Da wir die Veröffentlichung priorisiert haben, werden wir später darauf zurückblicken und alle seltsamen oder unzureichenden Erklärungen ergänzen / korrigieren. ..