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

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

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

Recommended Posts

Créons un modèle de reconnaissance d'image avec vos propres données et jouons!
Mettez vos propres données d'image dans Deep Learning et jouez avec
[Jouons avec Python] Traitement d'image en monochrome et points
Prenez une image avec Pepper et affichez-la sur votre tablette
Fractal pour faire et jouer avec Python
Essayez de créer votre propre AWS-SDK avec bash
Créez rapidement votre propre module avec setuptools (python)
Reconnaissance d'image avec le modèle Caffe Chainer Yo!
Entraînez Stanford NER Tagger avec vos propres données
[Apprentissage automatique] Créez un modèle d'apprentissage automatique en effectuant un apprentissage par transfert avec votre propre ensemble de données
J'ai essayé de créer une API de reconnaissance d'image simple avec Fast API et Tensorflow
Créez votre propre lecteur de musique avec Bottle0.13 + jPlayer2.5!
Créons une application capable de rechercher des images similaires avec Python et Flask Part1
Créons une application capable de rechercher des images similaires avec Python et Flask Part2
Créez un modèle de classification d'images de manière explosive avec Azure Custom Vision et implémentez-le avec Flask
Appelons votre propre bibliothèque C ++ avec Python (Préférences)
[Jouons avec Python] Créer un livre de comptes de ménage
[# 2] Créez Minecraft avec Python. ~ Dessin du modèle et implémentation du lecteur ~
Essayez de créer un jeu simple avec Python 3 et iPhone
Créons une application Mac avec Tkinter et py2app
Personnalisez Jupyter Notebook: modifiez l'arrière-plan et les icônes
Reconnaissance d'image avec keras
Jusqu'à ce que vous annotiez votre propre jeu de données et détectiez un objet avec EfficientDet ~ Détection de visage de personnage ~
[Pour l'enregistrement] Système d'image Keras Partie 2: Laissez CNN juger en utilisant votre propre ensemble de données
Reconnaissance d'image en temps réel sur les appareils mobiles à l'aide du modèle d'apprentissage TensorFlow
Apprentissage par renforcement 23 Créez et utilisez votre propre module avec Colaboratory
[Jouons avec Python] Viser la génération automatique de phrases ~ Lisez .txt et faites-en une unité de phrase ~
Jouons avec la 4e dimension 4e
Jouons avec les données Amedas - Partie 1
Faisons Othello avec wxPython
Faisons un plugin Errbot
Jouons avec les données Amedas - Partie 4
Jouons avec les données Amedas - Partie 3
Jouons avec les données Amedas - Partie 2
Reconnaissance d'image avec Keras + OpenCV
Défi la classification des images par TensorFlow2 + Keras 4 ~ Prédisons avec un modèle entraîné ~
Créez votre propre VPC avec un seul sous-réseau public uniquement avec boto
Comment créer votre propre site de domaine avec heroku (plan gratuit)
ZOOM en remplaçant votre visage par une icône Twitter avec la reconnaissance faciale openCV
Faisons une chemise IoT avec Lambda, Kinesis, Raspberry Pi [Partie 1]
J'ai essayé de créer une fonction de similitude d'image avec Python + OpenCV
À propos de l'itinéraire le plus court pour créer un modèle de reconnaissance d'image par apprentissage automatique et mettre en œuvre une application Android