[PYTHON] [Pour l'enregistrement] Système d'image Keras Partie 2: Laissez CNN juger en utilisant votre propre ensemble de données

Merci.

L'article précédent portait sur la lecture d'images avec Keras et la création d'un ensemble de données.

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

Cette fois, je vais essayer d'utiliser cet ensemble de données pour rendre un jugement par CNN. On suppose que la structure des dossiers est la suivante.

python

'''
picture -╷- train -╷- Apple(Catégorie 1) -╷- **.png #Pour apprendre
         ╎         ╎            　  ╎  (De nombreuses images ... omises)
         ╎         ╎            　  ╵- **.png
         ╎         ╵- Mango(Catégorie 2) - (Abréviation)
         ╎         
         ╵-  val  -╷- Apple(Catégorie 1) - (Abréviation) #Pour la vérification d'apprentissage
                   ╵- Mango(Catégorie 2) - (Abréviation)
'''

0. Dernier examen. Créer un jeu de données

python

from keras.preprocessing.image import ImageDataGenerator

#Réglage
classes = ['Apple', 'Mango']#Si vous voulez apprendre à classer les pommes et les mangues
train_data_dir = './picture/train'#Spécifiez le dossier parent pour la classification(Apple,Dossier supérieur Mango)
val_data_dir = './picture/val'
img_height = 100
img_width = 100
batch_size = 16

#Créer des données d'entraînement
#Diviser par 255 à l'échelle
train_datagen = ImageDataGenerator(rescale = 1.0 / 255) #Vous pouvez également définir le remplissage, mais cette fois, il sera omis

#Réglez le générateur d'apprentissage.
#En gros, le générateur est à chaque fois(Ici pour chaque taille de lot)Pour générer une image
train_generator = train_datagen.flow_from_directory(
    train_data_dir,
    target_size = (img_height, img_width), #Aucune dimension requise
    color_mode = 'rgb', #Si gris'grayscale'Entrer
    classes = classes, 
    class_mode = 'binary', #Puisqu'il y en a deux, binaire. S'il y en a 3 ou plus'categorical'
    batch_size = batch_size,
    shuffle = True)


#Créer des données de validation
val_datagen = ImageDataGenerator(rescale = 1.0 / 255)

#Définissez le générateur de validation.
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)

Maintenant que nous avons un ensemble de données, créons un CNN pour insérer ces données.

1. Création d'un CNN

Il existe plusieurs types de CNN. Tout simplement ① Créez un calque en concevant à partir de 0 par vous-même (2) Utilisez un modèle que quelqu'un dans le monde a déjà réglé pour apprendre.

Ces deux sont grossièrement classés. Il existe déjà de nombreux articles faciles à comprendre sur Qiita pour ① et ②, donc cette fois je vais l'essayer avec ②. Je voudrais vous dire que l'apprentissage CNN à l'aide du générateur Keras est le premier.

python

#Charger 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))

#La partie routière de VGG. La couche FC n'est pas requise, alors incluez_top=Définir sur False
vgg16 = VGG16(include_top=False, weights='imagenet', input_tensor=input_tensor)

#Concevez la couche FC dont vous n'avez plus besoin
model = Sequential()
model.add(Flatten(input_shape=vgg16.output_shape[1:]))
model.add(Dense(256, activation='relu'))
model.add(Dense(1, activation='sigmoid'))

#Créez un modèle en combinant VGG16 et votre propre couche FC
vgg16_model = Model(input=vgg16.input, output=model(vgg16.output))

#Figer le calque juste avant le dernier calque de conv.(Figer: ne pas apprendre)
for layer in vgg16_model.layers[:15]:
    layer.trainble=False
    
#compiler
vgg16_model.compile(loss='binary_crossentropy',
                 optimizer=Adam(lr=1e-4),
                 metrics=['accuracy'])

Ceci complète la conception du CNN utilisé pour la formation. Tout ce que vous avez à faire est d'apprendre. Avant cela, jetons un coup d'œil à la vue d'ensemble de CNN

python

vgg16_model.summary()

C'est assez luxueux, mais ne vous en faites pas. ..

Au fait, la partie que j'ai faite est une partie séquentielle, mais il n'y a pas de détails. Vérifions-le ci-dessous

python

model.summary()

Maintenant, toutes les couches sont claires.

2. Apprenons avec CNN

Maintenant que j'ai une image complète, il est temps de commencer à apprendre.

python

#Entrez le nombre total d'images *.Pratique car vous pouvez voir le nombre total de feuilles avec n
steps_per_epoch = train_generator.n
validation_steps = val_generator.n
#Réglage du nombre d'époque. Comme l'arrêt anticipé est décrit plus tard, vous pouvez le définir plus grand.
nb_epoch = 1000

#Paramètres de rappel
from keras.callbacks import EarlyStopping,ModelCheckpoint
es = EarlyStopping(monitor='val_loss', patience=10, verbose=1)#Seul le nombre de patience val_Arrêt automatique si la perte ne se met pas à jour
cp = ModelCheckpoint(filepath = './model.hdf5', save_best_only=True)#save_best_Enregistrer le modèle lors de la mise à jour de la perte avec uniquement

#L'apprentissage CNN a commencé. en forme_Utilisez un générateur.
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])

Après l'apprentissage, traçons et affichons l'état de l'apprentissage

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. Jugons en utilisant le modèle entraîné

Et jugeons une autre image avec le modèle d'apprentissage terminé Depuis que j'ai appris à charger une image la dernière fois, chargeons-la avec load_img et jugeons une image.

• Les images de jugement sont placées dans la même hiérarchie que le programme pour plus de simplicité. (B.jpg)
• Lors du test de plusieurs données, vous pouvez utiliser le générateur ou les lister de la même manière.

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)

#Convertir en type de tableau numpy pour l'inclusion dans le réseau neuronal
x_test = img_to_array(img) / 255

#Avec remodeler pour mettre CNN(n, w, h, c)Je vais en faire un moule
#Puisqu'un petit nombre de 0 à 1 est émis, np.Je changerai la sortie en une étiquette de classe avec round(0or1)
print(np.round(vgg16_model.predict(x_test.reshape(1,100,100,3))))

Ensuite, vous verrez 0 ou 1 comme résultat. Puisque vous pouvez vérifier chaque classification avec print (train_generator.class_indices) Si l'apprentissage réussit, 0 devrait être Apple cette fois et 1 devrait être Mango.

Eh bien, cette fois, je vais faire comme ça. Comment était-ce? Je ne pense pas que ce soit si difficile. La prochaine fois, je pense faire une restauration d'image avec un encodeur automatique ou 3 versions de classification ou plus.

De plus, étant donné que nous avons priorisé la publication, nous y reviendrons plus tard et compléterons / corrigerons les explications étranges ou insuffisantes. ..