[PYTHON] [Pour l'enregistrement] Système d'image Keras Partie 1: Comment créer votre propre ensemble de données?

Ravi de vous rencontrer.

Depuis cette année, j'étudie pour écrire réellement python et j'utilise Keras comme framework pour Deep Learning en raison de sa facilité d'utilisation. Je pense étudier PyTorch à l'avenir, mais avant cela, je pensais pouvoir partager les connaissances du système d'image Keras (python) que j'avais du mal à retenir dans le projet sans avoir aucune expérience en programmation, j'ai donc fait mon premier post. C'était.

Quand j'ai cherché, il était difficile de parcourir divers sites en conséquence (je ne pouvais pas lire le sens écrit sur ce Qiita et d'autres sites de commentaires car je n'avais pas assez de connaissances de base). (MNIST est déjà bon .. C'est mon propre jeu de données ...) Je vais également le résumer pour l'enregistrement à moi-même, sur lequel je reviendrai plus tard.

Cette fois, la première fois, les bases de la capture d'images et de la création de votre propre jeu de données? Je vais résumer.

J'espère qu'un jour cela sera utile pour les débutants que personne ne connaît ... (J'ai l'intention de faire plus de commentaires japonais que d'autres articles similaires)

De plus, puisque c'est le premier post de Qiita, j'imagine l'apparence. .. .. J'étudierai progressivement, alors soyez patient.

Partie 1 (cet article) Capture d'image Comment créer votre propre ensemble de données

Partie 2 (prévu d'écrire la prochaine fois) Mettons l'ensemble de données créé dans NN

1. Méthode de chargement d'image spécifique à Keras Load_img

En python, il existe également une méthode pour importer des images à l'aide de l'oreiller (PIL) ou OpenCV, mais comme il s'agit d'un article Keras, je me concentrerai ici sur load_img. Ici, à titre d'exemple, comment importer votre image (A.png) lorsqu'elle est placée dans la même hiérarchie (répertoire) que les données du programme (.py)? Expliquer.

python

#La magie de la sortie d'images avec matplotlib et Jupyter Notebook utilisés pour afficher les images
import matplotlib.pyplot as plt
%matplotlib inline

#Keras, une bibliothèque capable de gérer facilement les images avec Keras.preprocessing.image
from keras.preprocessing.image import load_img

#Tel quel(En couleur)Lis(La taille d'image originale d'Irasutoya(646,839)Image couleur PNG 3D de)
#.Puisqu'il y a une image dans la même hiérarchie que py, A tel quel.Peut être lu par png
img1 = load_img('A.png')

#niveaux de gris(1 dimension)Lors de la lecture avec
img2 = load_img('A.png', grayscale=True)

#Lors du redimensionnement et de la lecture
img_shape = (256, 256, 3) #Essayez de redimensionner à une image couleur de 256 hauteur et largeur
img3 = load_img('A.png', grayscale=False, target_size=img_shape)

Ensuite, affichons chaque image en utilisant matplotlib

python

plt.imshow(img1) #img2 à la place de img1,Swap 3 et essayez

et ça? Vous pouvez voir qu'il s'affiche correctement. Par ailleurs, en général, le traitement suivant est nécessaire pour entrer une image dans NN (Neural Net).

python

#Redimensionner et charger
img_shape = (256, 256, 3) #256 images couleur en hauteur et en largeur
img = load_img('A.png', grayscale=False, target_size=img_shape)

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

#Diviser par 255 et normaliser
img_array /= 255
#img_array = img_array /255 est OK

Vous êtes maintenant prêt à entrer dans NN. Cependant, vous n'êtes pas obligé d'en saisir un seul ... Habituellement, vous en avez plus d'un à apprendre. .. .. Alors, comment capturer plusieurs images au lieu d'une seule image cette fois?

python

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

#annuaire(path)Nom
dir_name = 'picture'
#Extension d'image
file_type = 'png'

#glob.Obtenez les informations de chemin de toutes les images avec glob
#/*.png signifie toutes les extensions png
img_list_path = glob.glob('./' + dir_name + '/*.' + file_type ) 
#img_list_path = glob.glob('./picture./*.png' )Mais bien sûr, c'est possible

#Créez une liste vide pour stocker les images chargées
img_list = []
img_shape = (256, 256, 3)

#Extrayez les informations de chemin une par une avec l'instruction for et chargez-la_Lire avec img et stocker dans la liste
for img in img_list_path:
    temp_img = load_img(img, grayscale=False, target_size=img_shape)#Lecture d'image au format PIL
    temp_img_array = img_to_array(temp_img) / 255 #PIL ⇒ Arrangement+Normaliser en divisant par 255
    img_list.append(temp_img_array) #Ajouter à la liste préparée

#En tant qu'image de formation, organisez davantage la liste,(n, width, haight, ch)Convertir en forme de
x_train = np.array(img_list)

Vérifiez la forme de cette liste comme un essai et affichez la 0ème image comme un essai.

python

print(x_train.shape)

plt.imshow(x_train[0]) #0e dans la liste(1er)Essayez d'accéder et d'afficher les éléments de

Je ne le montre pas ici, mais je pense que vous pouvez voir correctement la forme de (n, 256, 256, 3) et la 0ème image. Ceci termine la préparation de l'image d'entrée.

À l'origine, il est nécessaire non seulement de lire l'image, mais aussi de donner l'étiquette de réponse correcte en même temps. Il existe plusieurs façons de procéder, mais si toutes les images de img_list_path ont la même balise de classification, vous pouvez les ajouter dans la même instruction for.

• Si les dossiers sont divisés par classification d'apprentissage, la même balise d'apprentissage doit être utilisée pour chaque img_list_path.

python

img_list = []
y = []
img_shape = (256, 256, 3)

for img in img_list_path:
    temp_img = load_img(img, grayscale=False, target_size=img_shape)
    temp_img_array = img_to_array(temp_img) / 255
    img_list.append(temp_img_array) 
    y.append('Irasutoya')#img_list_pathにある画像は全部Irasutoyaなので、分類タグを加える

#x_train et y_les trains sont jumelés dans l'ordre
x_train = np.array(img_list)
y_train = np.array(y)

2. ImageDataGenerator qui gère un grand nombre d'images qui ne peuvent pas tenir dans la mémoire

À propos, comme l'image d'apprentissage est stockée sous forme de liste dans ce qui précède, il existe un cas où un problème survient lorsque vous essayez de l'utiliser telle quelle pour l'apprentissage. Le problème est que si vous enregistrez un nombre ridiculement grand d'images sous forme de liste, la mémoire de votre PC deviendra pleine et vous ne pourrez pas apprendre en premier lieu.

Pour le premier essai ou une petite quantité, vous pouvez le faire avec la liste ci-dessus, mais en pratique, par exemple, apprenez la taille (256,256,3) de 10 000 feuilles. .. Quand ça sort en pratique normalement, le PC commence à gémir et ça devient un problème (rires)

Et c'est Imade Data Generator de Keras qui joue un rôle actif dans un tel cas. En guise de préparation préliminaire, il est nécessaire de diviser les dossiers selon la classification d'apprentissage.

• L'image a été empruntée à l'ensemble de données de Kaggle. Vous pouvez essayer la même chose si vous le téléchargez et l'utilisez https://github.com/Horea94/Fruit-Images-Dataset

La structure des dossiers est la suivante et le programme utilisé comme exemple est exécuté dans la même hiérarchie que le dossier d'images. le train est pour apprendre. val contiendra une image pour vérification.

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

Regardons maintenant la création d'un ensemble de données pour classer les images de pommes et de mangues.

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)
img_height = 100
img_width = 100
#Taille du lot(Le nombre de feuilles à apprendre par NN à la fois. 2 à la nième puissance est commune)
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)

Ceci termine la création de l'ensemble de données d'entraînement. Est-ce plus facile que celui de la liste ci-dessus? ?? Cela chargera l'image pour chaque lot, vous n'avez donc pas à percer votre mémoire. Cependant, si vous craignez de pouvoir lire l'image parce que c'est vraiment comme ça, sortons l'image du contenu du générateur une fois

python

#Définissez la taille du lot à retirer pour l'affichage sur 1.
batch_size_show = 1

#Préparez un générateur différent du précédent pour l'affichage
train_generator_show = 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_show,
    shuffle = True)

#Préparez une liste pour stocker les images et les étiquettes à afficher
imgs = []
labbels = []

#Pour 100, spécifiez le nombre de feuilles à afficher. Vous pouvez définir le nombre total d'images
for i in range(100):
    x,y = train_generator_show.next() #next()Extraire les éléments du générateur dans l'ordre avec
    
    imgs.append(x[0])
    labbels.append(y)

Ensuite, affichons réellement l'image et l'étiquette

#Confirmation de la classification de la classe de générateur
print(train_generator_show.class_indices)

#Paramètres d'affichage
fig = plt.figure(figsize=(12,12))
fig.subplots_adjust(hspace=0.5, wspace=0.5)
row = 10
col = 10

for i, img in enumerate(imgs):#Numéro d'index,Les éléments peuvent être obtenus avec enumerate
    plot_num = i+1
    plt.subplot(row, col, plot_num,xticks=[], yticks=[])
    plt.imshow(img)
    plt.title('%d' % labbels[i])
plt.show():

Avec cela, il semble que l'image et la balise de classification sont susceptibles d'être correctes et que les données d'entraînement peuvent être définies, donc Après cela, préparez l'ensemble de données de validation de la même manière et préparez-vous à l'apprentissage. (Abordez le dossier val de la même manière)

python

#réglage de la valeur
classes = ['Apple', 'Mango']
val_data_dir = './picture/val'
img_height = 100
img_width = 100
batch_size = 16

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

Cette fois, ça se termine ici. Je peux l'ajouter plus tard