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. Capture d'écran 2020-04-19 16.16.27.png

スクリーンショット 2020-04-19 16.14.44.png

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. スクリーンショット 2020-04-19 6.09.36.png 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

スクリーンショット 2020-04-19 16.16.27.png De cette manière, une image dans laquelle seule la face de l'image téléchargée précédemment est découpée est créée dans le fichier de visage.

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. スクリーンショット 2020-04-19 16.29.55.png

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")
スクリーンショット 2020-04-19 16.34.45.png Il l'a fait comme ça. Par exemple, si vous souhaitez étudier avec quatre personnes, "'Nobita', 'Shizuka', 'Suneo', 'Gian'"
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. スクリーンショット 2020-04-19 16.40.22.png

J'ai reconnu que c'était M. Ota avec 99,9% de chance lol スクリーンショット 2020-04-19 16.43.35.png

Au fait, Si vous jugez par le vrai M. Tanaka スクリーンショット 2020-04-19 16.46.01.png スクリーンショット 2020-04-19 16.47.40.png 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

Recommended Posts

J'ai essayé la reconnaissance faciale du problème du rire en utilisant Keras.
J'ai essayé la reconnaissance faciale avec Face ++
J'ai essayé la reconnaissance de caractères manuscrits des caractères runiques avec CNN en utilisant Keras
J'ai essayé d'utiliser le filtre d'image d'OpenCV
J'ai essayé d'utiliser l'API de Sakenowa Data Project
[Python] J'ai essayé de juger l'image du membre du groupe d'idols en utilisant Keras
J'ai essayé de refactoriser le modèle CNN de TensorFlow en utilisant TF-Slim
J'ai essayé d'utiliser GrabCut d'OpenCV
J'ai essayé de reconnaître le visage de la vidéo (OpenCV: version python)
[Python] J'ai essayé de collecter des données en utilisant l'API de wikipedia
J'ai essayé la reconnaissance faciale avec OpenCV
J'ai essayé d'utiliser l'API checkio
J'ai essayé d'obtenir l'index de la liste en utilisant la fonction énumérer
J'ai regardé les méta-informations de BigQuery et essayé de les utiliser
J'ai essayé le serveur asynchrone de Django 3.0
Reconnaissance faciale des personnages d'anime avec Keras
Python: j'ai essayé le problème du voyageur de commerce
J'ai essayé d'utiliser l'API BigQuery Storage
J'ai essayé d'obtenir les résultats de Hachinai en utilisant le traitement d'image
J'ai essayé d'estimer la similitude de l'intention de la question en utilisant Doc2Vec de gensim
J'ai essayé d'extraire et d'illustrer l'étape de l'histoire à l'aide de COTOHA
J'ai essayé l'histoire courante de l'utilisation du Deep Learning pour prédire la moyenne Nikkei
En utilisant COTOHA, j'ai essayé de suivre le cours émotionnel de la course aux meros.
J'ai essayé l'histoire courante de prédire la moyenne Nikkei à l'aide du Deep Learning (backtest)
J'ai essayé la reconnaissance manuscrite des caractères des runes avec scikit-learn
J'ai essayé la fonction de tableau croisé dynamique des pandas
J'ai essayé l'analyse par grappes de la carte météo
J'ai essayé la reconnaissance d'image de CIFAR-10 avec Keras-Learning-
vprof - J'ai essayé d'utiliser le profileur pour Python
J'ai essayé la reconnaissance d'image de CIFAR-10 avec la reconnaissance d'image Keras-
J'ai résolu le problème le plus profond d'Hiroshi Yuki.
J'ai essayé d'utiliser PyCaret à la vitesse la plus rapide
J'ai essayé d'utiliser l'API Google Cloud Vision
J'ai essayé de corriger la forme trapézoïdale de l'image
J'ai essayé d'utiliser le module Datetime de Python
J'ai essayé d'utiliser la bibliothèque de programmation fonctionnelle toolz
J'ai essayé de mettre en œuvre le problème du voyageur de commerce
J'ai essayé de vectoriser les paroles de Hinatazaka 46!
J'ai essayé de prédire la détérioration de la batterie lithium-ion en utilisant le SDK Qore
J'ai essayé de notifier la mise à jour de "Hameln" en utilisant "Beautiful Soup" et "IFTTT"
J'ai essayé d'automatiser le travail de masquage du visage de l'image de coordination pour l'usure
J'ai essayé d'utiliser paramétré
J'ai essayé d'utiliser argparse
J'ai essayé d'utiliser la mimesis
J'ai essayé d'utiliser anytree
J'ai essayé d'utiliser Summpy
J'ai essayé d'utiliser coturn
J'ai essayé d'utiliser Pipenv
J'ai essayé d'utiliser matplotlib
J'ai essayé d'utiliser "Anvil".
J'ai essayé d'utiliser Hubot
J'ai essayé d'utiliser ESPCN
J'ai essayé d'utiliser openpyxl
J'ai essayé d'utiliser Ipython
J'ai essayé d'utiliser PyCaret
J'ai essayé d'utiliser cron
J'ai essayé d'utiliser ngrok