À en juger par l'image du chien Shiba en apprenant en profondeur si c'est mon enfant (1)

Étape 3 Copiez le nombre spécifié de photos de chiens Shiba (60 chacune) dans les dossiers train, test et validation.

(1) Définissez le chemin du fichier pour copier le fichier image et créez un nouveau dossier à utiliser.

#Chargement des bibliothèques requises
import os, shutil

#Définissez le chemin de fichier requis
# cd '/content/drive/'My Drive/'Colab Notebooks'Remplacez le répertoire actuel par le dossier de travail dans
%cd '/content/drive/'My Drive/Colab Notebooks/Self_Study/02_mydog_or_otherdogs

# original_Définition du chemin d'accès au fichier du dossier de données
original_dataset_dir = 'original_data'
# original_data(Nom de la définition'original_dataset_dir')Définissez les deux chemins de dossier suivants dans.
original_mydog_dir = 'original_data/mydog'
original_otherdogs_dir = 'original_data/otherdogs'

# use_Définition du chemin de fichier des données
base_dir = 'use_data'

# use_dossier de données(Nom de la définition'base_dir')Définissez les trois chemins de dossier suivants dans. Créez un dossier.
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)

#Dans le dossier du train'mydog'Avec dossiers'otherdogs'Définissez le chemin du dossier. Créez un dossier.
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)

#Dans le dossier de validation'mydog'Avec dossiers'otherdogs'Définissez le chemin du dossier. Créez un dossier.
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)

#Dans le dossier de test'mydog'Avec dossiers'otherdogs'Définissez le chemin du dossier. Créez un dossier.
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) Effectuez une copie des fichiers et vérifiez le nombre de fichiers copiés.

#train pour le train_mydog_Copiez 30 fichiers mydog dans le répertoire
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)

#validation pour validation_mydog_Copiez 20 fichiers mydog dans le répertoire
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 pour test_mydog_Copiez 10 fichiers mydog dans le répertoire
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)

#train pour le train_otherdogs_Copiez 30 autres fichiers de chiens dans le répertoire
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)

#validation pour validation_otherdogs_Copiez 20 autres fichiers de chiens dans le répertoire
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 pour test_otherdogs_Copiez 10 autres fichiers de chiens dans le répertoire
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)

#Vérifiez le nombre de fichiers stockés dans chaque dossier
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)))

Le nombre de fichiers s'affiche comme suit.

Étape 4 Construction du modèle

(1) Importez des keras et construisez un modèle comme suit.

La taille de l'image d'entrée est de 320 * 320 dans le fichier d'origine, mais cette fois la taille de l'entrée est lue comme 150 * 150.

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

La configuration du modèle est affichée comme ceci.

(2) Définissez la fonction de perte (crossentropie binaire), l'optimiseur (RMS Prop) et l'indice de surveillance (précision) et compilez le modèle.

from keras import optimizers

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

(3) Convertissez le fichier image en un tenseur à l'aide de la bibliothèque keras ImageDataGenerator.

Aucune augmentation de données n'a été mise en œuvre cette fois.

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

Étape 5 Apprentissage

(1) Entraînez le modèle à l'aide du générateur de lots.

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

Lorsque l'apprentissage commence, l'affichage ressemblera à ceci et le calcul se poursuivra. (Cela prendra un moment)

(2) Enregistrez le modèle après l'entraînement.

model.save('mydog_or_otherdogs_01a.h5')

Résultat de l'étape 6

(1) Afficher le résultat d'apprentissage dans un graphique

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

Graphique de résultat

Tout d'abord, la précision

• La précision de la formation a atteint 100% immédiatement depuis le début.
• La précision de la validation est d'environ 70% à 85%, et la précision ne s'améliore plus. Vous pouvez voir les fonctionnalités telles que. Malheureusement, nous ne regardons que les caractéristiques qui ne sont valables que pour les données de train, et on ne peut pas dire que nous avons une caractéristique claire de notre chien qui est valable pour d'autres que les données de train.

D'autre part, à propos de la perte

• La perte d'entraînement est proche de 0 depuis le début.
• La perte de validation ne diminue pas à mesure que le nombre de fois augmente, mais augmente à la hausse.

De ce qui précède, nous surentraînons les données du train. Après tout, le nombre de données était à l'origine petit, il semble donc que le résultat soit inévitable.

(2) Application aux données de test

Appliquons ce modèle aux données de test avec le code suivant pour voir la précision de la classification. ** Note) ImageDataGenerator échouera sans conversion s'il n'y a pas deux sous-dossiers ou plus dans le dossier cible. ** (Dans ce cas, vous avez besoin de deux sous-dossiers, mydog et 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)

#Données de train gonflées
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,)

#les données de validation ne sont pas complétées
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')