[PYTHON] Nach dem Bild des Shiba-Hundes zu urteilen, indem man tief lernt, ob es mein Kind ist (1)

Schritt 3 Kopieren Sie die angegebene Anzahl von Shiba-Hundefotos (jeweils 60) in die Ordner Zug, Test und Validierung.

(1) Legen Sie den Dateipfad zum Kopieren der Bilddatei fest und erstellen Sie einen neuen Ordner.

#Laden der erforderlichen Bibliotheken
import os, shutil

#Definieren Sie den gewünschten Dateipfad
# cd '/content/drive/'My Drive/'Colab Notebooks'Ändern Sie das aktuelle Verzeichnis in den Arbeitsordner in
%cd '/content/drive/'My Drive/Colab Notebooks/Self_Study/02_mydog_or_otherdogs

# original_Festlegen des Dateipfads des Datenordners
original_dataset_dir = 'original_data'
# original_data(Definitionsname'original_dataset_dir')Legen Sie die folgenden zwei Ordnerpfade fest.
original_mydog_dir = 'original_data/mydog'
original_otherdogs_dir = 'original_data/otherdogs'

# use_Festlegen des Dateipfads von Daten
base_dir = 'use_data'

# use_Datenordner(Definitionsname'base_dir')Legen Sie die folgenden drei Ordnerpfade fest. Erstellen Sie einen Ordner.
train_dir = os.path.join(base_dir, 'train')
os.mkdir(train_dir)
validation_dir = os.path.join(base_dir, 'validation')
os.mkdir(validation_dir)
test_dir = os.path.join(base_dir, 'test')
os.mkdir(test_dir)

#Im Zugordner'mydog'Mit Ordnern'otherdogs'Legen Sie den Ordnerpfad fest. Erstellen Sie einen Ordner.
train_mydog_dir = os.path.join(train_dir, 'mydog')
os.mkdir(train_mydog_dir)
train_otherdogs_dir = os.path.join(train_dir, 'otherdogs')
os.mkdir(train_otherdogs_dir)

#Im Validierungsordner'mydog'Mit Ordnern'otherdogs'Legen Sie den Ordnerpfad fest. Erstellen Sie einen Ordner.
validation_mydog_dir = os.path.join(validation_dir, 'mydog')
os.mkdir(validation_mydog_dir)
validation_otherdogs_dir = os.path.join(validation_dir, 'otherdogs')
os.mkdir(validation_otherdogs_dir)

#Im Testordner'mydog'Mit Ordnern'otherdogs'Legen Sie den Ordnerpfad fest. Erstellen Sie einen Ordner.
test_mydog_dir = os.path.join(test_dir, 'mydog')
os.mkdir(test_mydog_dir)
test_otherdogs_dir = os.path.join(test_dir, 'otherdogs')
os.mkdir(test_otherdogs_dir)

(2) Führen Sie eine Dateikopie durch und überprüfen Sie die Anzahl der kopierten Dateien.

#Zug für Zug_mydog_Kopieren Sie 30 Mydog-Dateien in das Verzeichnis
fnames = ['mydog{}.jpg'.format(i) for i in range(30)]
for fname in fnames:
    src = os.path.join(original_mydog_dir, fname)
    dst = os.path.join(train_mydog_dir, fname)
    shutil.copyfile(src, dst)

#Validierung zur Validierung_mydog_Kopieren Sie 20 Mydog-Dateien nach dir
fnames = ['mydog{}.jpg'.format(i) for i in range(30,50)]
for fname in fnames:
    src = os.path.join(original_mydog_dir, fname)
    dst = os.path.join(validation_mydog_dir, fname)
    shutil.copyfile(src, dst)

#Test für Test_mydog_Kopieren Sie 10 Mydog-Dateien nach dir
fnames = ['mydog{}.jpg'.format(i) for i in range(50,60)]
for fname in fnames:
    src = os.path.join(original_mydog_dir, fname)
    dst = os.path.join(test_mydog_dir, fname)
    shutil.copyfile(src, dst)

#Zug für Zug_otherdogs_Kopieren Sie 30 andere Hundedateien nach dir
fnames = ['otherdogs{}.jpg'.format(i) for i in range(30)]
for fname in fnames:
    src = os.path.join(original_otherdogs_dir, fname)
    dst = os.path.join(train_otherdogs_dir, fname)
    shutil.copyfile(src, dst)

#Validierung zur Validierung_otherdogs_Kopieren Sie 20 andere Hundedateien nach dir
fnames = ['otherdogs{}.jpg'.format(i) for i in range(30, 50)]
for fname in fnames:
    src = os.path.join(original_otherdogs_dir, fname)
    dst = os.path.join(validation_otherdogs_dir, fname)
    shutil.copyfile(src, dst)

#Test für Test_otherdogs_Kopieren Sie 10 andere Hundedateien nach dir
fnames = ['otherdogs{}.jpg'.format(i) for i in range(50, 60)]
for fname in fnames:
    src = os.path.join(original_otherdogs_dir, fname)
    dst = os.path.join(test_otherdogs_dir, fname)
    shutil.copyfile(src, dst)

#Überprüfen Sie die Anzahl der in jedem Ordner gespeicherten Dateien
print('total training mydog images:', len(os.listdir(train_mydog_dir)))
print('total training otherdogs images:', len(os.listdir(train_otherdogs_dir)))
print('total validation mydog images:', len(os.listdir(validation_mydog_dir)))
print('total validation otherdogs images:', len(os.listdir(validation_otherdogs_dir)))
print('total test mydog images:', len(os.listdir(test_mydog_dir)))
print('total test otherdogs images:', len(os.listdir(test_otherdogs_dir)))

Die Anzahl der Dateien wird wie folgt angezeigt.

Schritt 4 Modellbau

(1) Importieren Sie Keras und erstellen Sie ein Modell wie folgt.

Die Größe des Eingabebildes in der Originaldatei beträgt 320 * 320, diesmal wird die Größe der Eingabe jedoch als 150 * 150 gelesen.

from keras import layers
from keras import models

model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu',
                        input_shape=(150, 150, 3)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(128, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(128, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Flatten())
model.add(layers.Dense(512, activation='relu'))
model.add(layers.Dense(1, activation='sigmoid'))

model.summary()

Die Modellkonfiguration wird folgendermaßen angezeigt.

(2) Stellen Sie die Verlustfunktion (binäre Kreuzentropie), den Optimierer (RMS Prop) und den Überwachungsindex (Genauigkeit) ein und kompilieren Sie das Modell.

from keras import optimizers

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

(3) Konvertieren Sie die Bilddatei mithilfe der Keras-Bibliothek ImageDataGenerator in einen Tensor.

Diesmal wurde keine Datenerweiterung implementiert.

from keras.preprocessing.image import ImageDataGenerator

# rescaled by 1./255
train_datagen = ImageDataGenerator(rescale=1./255)
test_datagen = ImageDataGenerator(rescale=1./255)

train_generator = train_datagen.flow_from_directory(
        # target directory
        train_dir,
        # resized to 150x150
        target_size=(150, 150),
        batch_size=20,
        class_mode='binary')

validation_generator = test_datagen.flow_from_directory(
        validation_dir,
        target_size=(150, 150),
        batch_size=20,
        class_mode='binary')

Schritt 5 Lernen

(1) Trainieren Sie das Modell mit dem Batch-Generator.

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

Wenn das Lernen beginnt, sieht die Anzeige folgendermaßen aus und die Berechnung wird fortgesetzt. (Es wird eine Weile dauern)

(2) Speichern Sie das Modell nach dem Training.

model.save('mydog_or_otherdogs_01a.h5')

Schritt 6 Ergebnis

(1) Zeigen Sie das Lernergebnis in einer Grafik an

import matplotlib.pyplot as plt

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

epochs = range(len(acc))

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()

Ergebnisdiagramm

Vor allem Genauigkeit

--Die Übertragungsgenauigkeit hat von Anfang an 100% erreicht.

• Die Genauigkeit der Validierung liegt zwischen 70% und 85%, und die Genauigkeit verbessert sich nicht mehr. Sie können die Funktionen wie sehen. Leider betrachten wir nur die Merkmale, die nur für Zugdaten gelten, und es kann nicht gesagt werden, dass wir ein klares Merkmal unseres Hundes haben, das für andere als Zugdaten gültig ist.

Auf der anderen Seite über Verlust

• Der Trainingsverlust liegt von Anfang an nahe bei 0. ――Der Validierungsverlust nimmt nicht mit zunehmender Häufigkeit ab, sondern steigt nach oben.

Von oben trainieren wir die Zugdaten. Immerhin war die Anzahl der Daten ursprünglich gering, so dass das Ergebnis unvermeidlich ist.

(2) Antrag auf Prüfung von Daten

Wenden wir dieses Modell mit dem folgenden Code auf die Testdaten an, um die Klassifizierungsgenauigkeit zu überprüfen. ** Hinweis) ImageDataGenerator schlägt ohne Konvertierung fehl, wenn der Zielordner keine zwei oder mehr Unterordner enthält. ** (In diesem Fall benötigen Sie zwei Unterordner, mydog und otherdogs) </ font>

test_datagen = ImageDataGenerator(rescale=1./255)
test_generator = test_datagen.flow_from_directory(
    test_dir,
    target_size=(150,150),
    batch_size=50,
    class_mode='binary')

test_loss, test_acc = model.evaluate_generator(test_generator, steps=50)
print('test loss:', test_loss)
print('test acc:', test_acc)

#Aufgeblasene Zugdaten
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,)

#Validierungsdaten werden nicht aufgefüllt
test_datagen = ImageDataGenerator(rescale=1./255)

train_generator = train_datagen.flow_from_directory(
        # Target directory
        train_dir,
        # resized to 150x150
        target_size=(150, 150),
        batch_size=32,
        class_mode='binary')

validation_generator = test_datagen.flow_from_directory(
        validation_dir,
        target_size=(150, 150),
        batch_size=32,
        class_mode='binary')

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

model.save('mydog_or_otherdogs_01b.h5')