[PYTHON] J'ai essayé la reconnaissance faciale du problème du rire en utilisant Keras.

Déterminez le problème du rire par reconnaissance d'image

J'étais libre à Corona, donc je l'ai fait rapidement. La plupart du code est réutilisé lorsque l'image de Keyakizaka46 est reconnue. Si vous souhaitez reconnaître vos images préférées grâce à l'apprentissage en profondeur, venez! Pour que vous puissiez le faire même pour la première fois, les pièces susceptibles de trébucher sont également répertoriées! !! [Je pense que c'est tout ce que vous avez à faire avec les préférences python! ] (https://prog-8.com/docs/python-env)

annuaire

/bakusyomondai
　/data
　　/TANAKA
　　/ota
　/face
　　/ota
　　/TANAKA
　/train
　　/ota
　　/TANAKA
　/test
　　/ota
　　/TANAKA
　
　get_image.py
　detect_face/py
　devide_test_train.py
　inflation.py
　learn2.py
　Bakunin.py

Par exemple, dans le cas de mac, c'est comme suit.

table des matières

1, téléchargez l'image à former 2, détection de visage de l'image téléchargée 3, gonfler l'image à former 4, apprentissage (production Deep Learninng) 5, images discriminantes en utilisant le modèle appris

1, téléchargez l'image à former

Tout d'abord, créez et enregistrez le fichier suivant appelé get_image.py. Cliquez ici pour savoir comment télécharger automatiquement des images de recherche Google

get_image.py

from icrawler.builtin import BingImageCrawler
import sys
import os

argv = sys.argv

if not os.path.isdir(argv[1]):
    os.makedirs(argv[1])


crawler = BingImageCrawler(storage = {"root_dir" : argv[1]})
crawler.crawl(keyword = argv[2], max_num = 1000)

Si vous exécutez ce fichier python dans le terminal comme suit, l'image sera téléchargée. Par exemple, si vous souhaitez télécharger Tanaka du problème du rire,

$ python */get_image.py */data/TANAKA LOL problème Tanaka

Le téléchargement démarrera lorsque vous exécuterez.

Comme image

$python */get_image.py Répertoire de l'emplacement que vous souhaitez enregistrer Nom que vous souhaitez rechercher

Au fait

Je pense que beaucoup d'astérisques apparaîtront dans le code cette fois comme * / get_image.py, mais cette fois j'ose le cacher avec des astérisques. Veuillez vous référer au lien ci-dessous lors de la vérification du répertoire des fichiers sur votre propre ordinateur. Pour Windows Pour Mac

2. Détection de visage de l'image téléchargée

Je pense que le contenu du fichier créé précédemment est le suivant. S'il y a une photo autre que M. Ota, je l'ai supprimée, et s'il y a des personnes autres que M. Ota, je ne découpe le visage que de M. Ota.

Tout d'abord, cette fois, j'ai utilisé le code suivant.

detect_face.py

import glob
import os
import cv2

names = ['ota','TANAKA']
out_dir = "*/bakusyomondai/face/"
os.makedirs(out_dir, exist_ok=True)
for i in range(len(names)):
   
    in_dir = "*/bakusyomondai/data/"+names[i]+"/*.jpg "
    in_jpg = glob.glob(in_dir)
    os.makedirs(out_dir + names[i], exist_ok=True)
    # print(in_jpg)
    print(len(in_jpg))
    for num in range(len(in_jpg)):
        image=cv2.imread(str(in_jpg[num]))
        if image is None:
            print("Not open:",num)
            continue

        image_gs = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        cascade = cv2.CascadeClassifier("*/haarcascade_frontalface_alt.xml")

       
        face_list=cascade.detectMultiScale(image_gs, scaleFactor=1.1, minNeighbors=2,minSize=(64,64))
       
        if len(face_list) > 0:
            for rect in face_list:
                x,y,width,height=rect
                image = image[rect[1]:rect[1]+rect[3],rect[0]:rect[0]+rect[2]]
                if image.shape[0]<64:
                    continue
                image = cv2.resize(image,(64,64))
                
                fileName=os.path.join(out_dir+"/"+names[i],str(num)+".jpg ")
                cv2.imwrite(str(fileName),image)
                print(str(num)+".J'ai enregistré le jpg.")
       
        else:
            print("no face")
            continue
        print(image.shape)

Lorsque vous exécutez ce code

Puisqu'un fichier en cascade appelé haarcascade_frontalface_alt.xml est utilisé pour la détection de visage, Téléchargez ici!

3. Divisez l'image en données d'entraînement et données de test.

devide_test_train.py

import shutil
import random
import glob
import os
names = ['ota','TANAKA']
os.makedirs("*/bakusyomondai/test", exist_ok=True)

for name in names:
    in_dir = "*/bakusyomondai/face/"+name+"/*"
    in_jpg=glob.glob(in_dir)
    img_file_name_list=os.listdir("*/bakusyomondai/face/"+name+"/")
    #img_file_name_Liste aléatoire, dont 20% test_mettre dans le répertoire d'images
    random.shuffle(in_jpg)
    os.makedirs('*/bakusyomondai/test/' + name, exist_ok=True)
    for t in range(len(in_jpg)//5):
        shutil.move(str(in_jpg[t]), "*/bakusyomondai/test/"+name)

4. Gonflage des données d'entraînement

Comme prévu, le nombre d'images est petit, donc les images sont gonflées.

inflation.py

import os
import cv2
import glob
from scipy import ndimage

names = ['ota','TANAKA']
os.makedirs("*/bakusyomondai/train", exist_ok=True)
for name in names:
    in_dir = "*/bakusyomondai/face/"+name+"/*"
    out_dir = "*/bakusyomondai/train/"+name
    os.makedirs(out_dir, exist_ok=True)
    in_jpg=glob.glob(in_dir)
    img_file_name_list=os.listdir("*/bakusyomondai/face/"+name+"/")
    for i in range(len(in_jpg)):
        #print(str(in_jpg[i]))
        img = cv2.imread(str(in_jpg[i]))
        
        for ang in [-10,0,10]:
            img_rot = ndimage.rotate(img,ang)
            img_rot = cv2.resize(img_rot,(64,64))
            fileName=os.path.join(out_dir,str(i)+"_"+str(ang)+".jpg ")
            cv2.imwrite(str(fileName),img_rot)
           
            img_thr = cv2.threshold(img_rot, 100, 255, cv2.THRESH_TOZERO)[1]
            fileName=os.path.join(out_dir,str(i)+"_"+str(ang)+"thr.jpg ")
            cv2.imwrite(str(fileName),img_thr)
            
            img_filter = cv2.GaussianBlur(img_rot, (5, 5), 0)
            fileName=os.path.join(out_dir,str(i)+"_"+str(ang)+"filter.jpg ")
            cv2.imwrite(str(fileName),img_filter)

Une fois exécutée, l'image sera gonflée comme indiqué ci-dessous.

5, début de l'apprentissage

learn2.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
import numpy as np
from sklearn.model_selection import train_test_split
from PIL import Image
import glob

folder = ['ota','TANAKA']
image_size = 50

X_train = []
y_train = []
for index, name in enumerate(folder):
    dir = "*/bakusyomondai/train/" + name
    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_train.append(data)
        y_train.append(index)

X_train = np.array(X_train)
y_train = np.array(y_train)

folder = ['ota','TANAKA']
image_size = 50

X_test = []
y_test = []
for index, name in enumerate(folder):
    dir = "*/bakusyomondai/test/" + name
    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_test.append(data)
        y_test.append(index)

X_test = np.array(X_test)
y_test = np.array(y_test)

X_train = X_train.astype('float32')
X_train = X_train / 255.0

X_test = X_test.astype('float32')
X_test = X_test / 255.0

#Convertir le format d'étiquette correct
y_train = np_utils.to_categorical(y_train, 2)
#Convertir le format d'étiquette correct
y_test = np_utils.to_categorical(y_test, 2)

#Construire CNN
model = Sequential()

model.add(Conv2D(32, (3, 3), padding='same',input_shape=X_train.shape[1:]))
model.add(Activation('relu'))
model.add(Conv2D(32, (3, 3)))
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(Activation('relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

model.add(Flatten())
model.add(Dense(512))
model.add(Activation('relu'))
model.add(Dropout(0.5))
model.add(Dense(2))
model.add(Activation('softmax'))

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

history = model.fit(X_train, y_train, epochs=100)
print(model.evaluate(X_test, y_test))
model.save("*/bakusyomonadai/bakusyo_model.h5")

y_train = np_utils.to_categorical(y_train, 4)
#Convertir le format d'étiquette correct
y_test = np_utils.to_categorical(y_test, 4)

model.add(Dense(4))

Si vous changez cette partie, cela fonctionnera! !!

6. Discriminer les images en utilisant le modèle appris

kakunin.py

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

jpg_name = '*/hirate/000002.jpg'
my_model='*/bakusyomondai/bakusyo_model.h5'

model=load_model(my_model)

img_path = (jpg_name)
img = img_to_array(load_img(img_path, target_size=(50,50)))
img_nad = img_to_array(img)/255
img_nad = img_nad[None, ...]

label=['ota','TANAKA']
pred = model.predict(img_nad, batch_size=1, verbose=0)
score = np.max(pred)
pred_label = label[np.argmax(pred[0])]
print('name:',pred_label)
print('score:',score)

Cette fois, j'ai essayé de voir comment distinguer quand je mettais M. Hirate de Keyakizaka dans un dossier différent.

J'ai reconnu que c'était M. Ota avec 99,9% de chance lol

Au fait, Si vous jugez par le vrai M. Tanaka Il le déterminera correctement! !! !!

Cette fois, j'ai essayé de résumer le flux de reconnaissance d'image en utilisant le deep learning. Je ne pourrais pas l'omettre autant que possible pour que même les débutants puissent le faire. (J'ai eu du mal, mais lol) Je pense que vous pouvez le faire avec vos acteurs et personnages préférés, alors venez nous rejoindre! !!

Devis https://qiita.com/nirs_kd56/items/bc78bf2c3164a6da1ded