introduction

J'avais l'habitude de vouloir faire de la reconnaissance d'image avec mes propres données au lieu de MNIST, mais c'est plutôt bien! !! Il y a peu d'articles comme ça, et même si je peux le faire, le seul résultat est le taux de réponse correct, donc je n'ai pas pu faire l'expérience, donc j'aimerais le résumer. Si je peux me le permettre, j'aimerais écrire jusqu'à faire une application de reconnaissance d'image en l'installant dans une application web.

Je pense que certaines choses ne peuvent être atteintes, mais j'apprécierais que vous signaliez des erreurs.

Flux brutal, ce que vous pouvez faire

Nous utilisons CNN, qui est à la base des méthodes récentes de reconnaissance d'images. Créez un modèle qui peut apprendre et reconnaître l'image préparée par vous-même, générer les données entraînées et les lire avec un autre code afin de pouvoir jouer avec. Cette fois, je vais créer un programme pour faire la distinction entre un chat à trois poils et un chat blanc chez moi.

environnement

win10
python 3.7.3
numpy
Pillow 6.1.0
tensorflow==1.13.1
keras==2.1.2
sklearn

code

Tout le code peut également être trouvé sur github, alors téléchargez-le à partir de là.

Partie 1: Préparation et remplissage des données

Préparez d'abord les données. C'est très simple ici, il vous suffit d'enregistrer les images collectées dans des dossiers. (Séparez les fichiers en fonction de ce que vous voulez identifier ici. Le siro et le micro de l'image ci-dessous sont identiques.)

Créez également un dossier test_img pour enregistrer les images que vous souhaitez prédire. スクリーンショット (94).png

Ensuite, nous gonflerons les données et créerons un ensemble de données. Le gonflement des données signifie qu'il est très difficile de collecter suffisamment de données à la main (c'est gênant), donc une fois que vous avez collecté des images, vous pouvez faire pivoter ou inverser les images pour gonfler l'ensemble de données et apprendre. Ce sera un appareil à faire. Le code ci-dessous est aug.py dans l'image ci-dessus.

`aug.py`


from PIL import Image
import os, glob
import numpy as np
from keras.utils import np_utils
from sklearn import model_selection
from sklearn.model_selection import train_test_split

classes = ["mike","siro"]####Saisissez ici le libellé que vous souhaitez identifier
num_classes = len(classes)
image_size = 128


#répertoire de l'ensemble de données
#Le micro que j'ai fait plus tôt,Entrez le chemin juste avant le dossier siro
datadir='./'

#Chargement des images
X = []
Y = []


for index, classlabel in enumerate(classes):
    photos_dir = datadir+ classlabel
    files = glob.glob(photos_dir + "/*.jpg ")
    for i, file in enumerate(files):
        
        image = Image.open(file)
        image = image.convert("RGB")
        image = image.resize((image_size, image_size))
        #image.save("./test/{}{}.jpg ".format(classlabel,i))
        data = np.asarray(image)
        
        for angle in range(-20, 20, 5):##5
            #rotation
            img_r = image.rotate(angle)
            data = np.asarray(img_r)
            X.append(data)
            Y.append(index)

            #Inverser
            img_trans = image.transpose(Image.FLIP_LEFT_RIGHT)
            data = np.asarray(img_trans)
            X.append(data)
            Y.append(index)



X = np.array(X)
Y = np.array(Y)

#Jusqu'à 20% des données de test
(X_train, X_test, y_train, y_test) = train_test_split(X, Y,test_size=0.2)

#Normalisation
X_train = X_train.astype("float") / 255
X_test = X_test.astype("float") / 255

#Convertir le type de données de l'enseignant
y_train = np_utils.to_categorical(y_train,num_classes)
y_test = np_utils.to_categorical(y_test, num_classes)

#X_train, X_test, y_train, y_test = model_selection.train_test_split(X, Y)
xy = (X_train, X_test, y_train, y_test)
np.save("./dataset.npy", xy)

À la fin de son exécution, vous devriez avoir un fichier appelé dataset.npy dans le même répertoire. Il s'agit de l'ensemble de données utilisé cette fois.

Partie 2: Apprentissage

Lisez l'ensemble de données que vous avez créé précédemment et commencez enfin à apprendre. Le code ci-dessous correspond à CNN.py dans la première image.

`CNN.py`



import keras
from keras.utils import np_utils
from keras.models import Sequential
from keras.layers.convolutional import Conv2D, MaxPooling2D
from keras.layers.core import Dense, Dropout, Activation, Flatten
from keras.layers import BatchNormalization
from keras.optimizers import SGD
import numpy as np
from sklearn.model_selection import train_test_split
from PIL import Image
import glob

from PIL import Image
import matplotlib.pyplot as plt

import os
from keras.callbacks import TensorBoard,ModelCheckpoint



#Hyper paramètres
hp1 = {}
hp1['class_num'] = 2 #Nombre de cours (cette fois mike,Parce que c'est 2 classes de siro 2)
hp1['batch_size'] = 64 #Taille du lot#####32
hp1['epoch'] = 20 #Nombre d'époques



#Chargement de l'ensemble de données
##Chargez le jeu de données créé dans le chapitre précédent ici
X_train, X_test, y_train, y_test = np.load("./dataset.npy", allow_pickle=True)


#Taille d'entrée
input_shape=X_train.shape[1:]

#Construire CNN
def CNN(input_shape):
        model = Sequential()
 
        model.add(Conv2D(32, (3, 3), padding='same',input_shape=input_shape))
        model.add(Activation('relu'))
        model.add(Conv2D(32, (3, 3)))
        model.add(BatchNormalization())
        model.add(Activation('relu'))
        model.add(MaxPooling2D(pool_size=(2, 2)))
        model.add(Dropout(0.25))

        model.add(Conv2D(64, (3, 3), padding='same'))
        model.add(Activation('relu'))
        model.add(Conv2D(64, (3, 3)))
        model.add(BatchNormalization())
        model.add(Activation('relu'))
        model.add(MaxPooling2D(pool_size=(2, 2)))
        model.add(Dropout(0.25))

        model.add(Conv2D(128, (3, 3), padding='same'))
        model.add(Activation('relu'))
        model.add(Conv2D(128, (3, 3)))
        model.add(BatchNormalization())
        model.add(Activation('relu'))

        model.add(MaxPooling2D(pool_size=(2, 2)))
        model.add(Dropout(0.25))


        model.add(Flatten())
        model.add(Dense(512))
        model.add(BatchNormalization())
        model.add(Activation('relu'))
        model.add(Dropout(0.5))
        model.add(Dense(hp1['class_num']))
        model.add(Activation('softmax'))
    
        return model
 

#Sélectionnez un modèle
model=CNN(input_shape)



#compiler

model.compile(loss='categorical_crossentropy',optimizer='SGD',metrics=['accuracy'])


#Enregistrement des données
log_dir = os.path.join(os.path.dirname(__file__), "logdir")
model_file_name="model_file.hdf5"

#Entraînement
history = model.fit(
        X_train, y_train,
         epochs=hp1['epoch'],
         validation_split = 0.2,
         callbacks=[
                TensorBoard(log_dir=log_dir),
                ModelCheckpoint(os.path.join(log_dir,model_file_name),save_best_only=True)
                ]
        )

#Évaluation&Sortie des résultats d'évaluation


loss,accuracy = model.evaluate(X_test, y_test, batch_size=hp1['batch_size'])

Il faudra du temps pour apprendre ici. Je pense que c'est un avertissement foiré, mais ne vous inquiétez pas ... Lorsque l'exécution est terminée, un dossier appelé logdir sera créé, et il devrait y avoir un fichier appelé ** model_file.hdf5 **. C'est le modèle le plus important et le plus formé.

Partie 3: Prédire les résultats de la reconnaissance et jouer

Jouez enfin avec le modèle entraîné. Je pense que le dossier ressemble à ceci maintenant.

スクリーンショット (96).png Veuillez mettre l'image que vous souhaitez prédire dans ce test_img,

Lisez la sortie ** model_file.hdf5 ** plus tôt et faites une prédiction. Le code suivant sera prédict.py.

`predict.py`


from pathlib import Path
import numpy as np
from PIL import Image
from keras.models import load_model
import glob

#####  mike=0,siro=1  ######


###Chargement du modèle entraîné
model_path = "./logdir/model_file.hdf5"

##Emplacement des données que vous souhaitez prédire
images_folder = "./test_img"

classes = ["mike","siro"]

# load model
model = load_model(model_path)

#image_size=100
image_size=128
X = []


dir = images_folder
#Vérifiez le chemin
#print(dir)

files = glob.glob(dir + "/*.jpg ")
for i, file in enumerate(files):
    image = Image.open(file)
    image = image.convert("RGB")
    image = image.resize((image_size, image_size))
    data = np.asarray(image)
    X.append(data)
    
 
X = np.array(X)


#Normalisation(0-1)
X = X.astype('float32')
X = X / 255.0

#print(len(files))

##softmax
for w in range(len(files)):

    result = model.predict([X])[w]
    predicted = result.argmax()
    percentage = int(result[predicted] * 100)
    print(files[w].split('\\')[-1])
    print("{0}({1} %)".format(classes[predicted],percentage))

Cette fois, j'ai essayé de saisir une telle image. (mignonne) c5d7411c6bd88106ebab0730b8af4f907_4620693218538323992_200325_0003.jpg

Je pense que le résultat de l'exécution de predict.py ressemblera à ceci. スクリーンショット (98).png

Vous pouvez prédire qu'il s'agit d'un chat blanc en toute sécurité! !!

Résumé

Comment était-ce? ?? J'espère que vous pourrez jouer en toute sécurité. Avec le développement à partir d'ici, si vous souhaitez créer une application de reconnaissance d'image, vous pouvez créer une application qui renvoie des prédictions si vous avez les modèles formés model_file.hdf5 et predict.py sur le serveur.

Pour référence, l'application Web de reconnaissance d'image que moi-même et d'autres membres avons créée dans le passé à Hackason et présentée à l'exposition sur l'enseignement technique est ici

Les références

Apprendre en profondeur à partir de zéro
Apprentissage en profondeur intuitif

[PYTHON] Créons un modèle de reconnaissance d'image avec vos propres données et jouons!