[PYTHON] Ich habe versucht, das Lachproblem mit Keras zu erkennen.

Bestimmen Sie das Lachproblem durch Bilderkennung

Ich war frei in Corona, also habe ich es schnell geschafft. Der größte Teil des Codes wird wiederverwendet, wenn das Bild von Keyakizaka46 erkannt wird. Wenn Sie Ihre Lieblingssachen mit tiefem Lernen erkennen möchten, kommen Sie bitte! Damit Sie dies auch zum ersten Mal tun können, werden auch die Teile aufgelistet, die wahrscheinlich auslösen werden! !! [Ich denke, das ist alles, was Sie mit Python-Einstellungen tun müssen! ]] (https://prog-8.com/docs/python-env)

Verzeichnis

/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

Im Fall von Mac ist dies beispielsweise wie folgt.

Inhaltsverzeichnis

1, laden Sie das zu trainierende Bild herunter 2, Gesichtserkennung des heruntergeladenen Bildes 3, Aufblasen des zu trainierenden Bildes 4, Lernen (Deep Learninng Produktion) 5, Unterscheiden Sie Bilder unter Verwendung des gelernten Modells

1, laden Sie das zu trainierende Bild herunter

Erstellen und speichern Sie zunächst die folgende Datei mit dem Namen get_image.py. Klicken Sie hier, um Bilder automatisch von Google-Suchbildern herunterzuladen

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)

Wenn Sie diese Python-Datei wie folgt im Terminal ausführen, wird das Image heruntergeladen. Wenn Sie beispielsweise Tanaka über das Lachproblem herunterladen möchten,

$ python */get_image.py */data/TANAKA LOL Problem Tanaka

Der Download wird gestartet, wenn Sie ausführen.

Als Bild

$python */get_image.py Verzeichnis des Speicherorts, den Sie speichern möchten Name, den Sie suchen möchten

Apropos

Ich denke, dass dieses Mal viele Sternchen im Code erscheinen werden, wie * / get_image.py, aber dieses Mal wage ich es, es mit Sternchen zu verbergen. Bitte beachten Sie den folgenden Link, wenn Sie das Verzeichnis der Dateien auf Ihrem eigenen Computer überprüfen. Für Windows Für Mac

2. Gesichtserkennung des heruntergeladenen Bildes

Ich denke, der Inhalt der zuvor erstellten Datei ist wie folgt. Wenn es ein anderes Foto als Mr. Ota gibt, habe ich es gelöscht, und wenn es andere Leute als Mr. Ota gibt, habe ich nur Mr. Ota das Gesicht ausgeschnitten.

Diesmal habe ich zunächst den folgenden Code verwendet.

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)+".Ich habe das JPG gespeichert.")
       
        else:
            print("no face")
            continue
        print(image.shape)

Wenn Sie diesen Code ausführen

Da eine Kaskadendatei mit dem Namen haarcascade_frontalface_alt.xml zur Gesichtserkennung verwendet wird, Hier herunterladen!

3. Teilen Sie das Bild in Trainingsdaten und Testdaten.

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_Shuffle-Liste, 20% davon Test_in Bildverzeichnis legen
    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. Trainingsdaten aufblasen

Wie erwartet ist die Anzahl der Bilder gering, sodass die Bilder aufgeblasen werden.

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)

Bei der Ausführung wird das Bild wie unten gezeigt aufgeblasen.

5, Beginn des Lernens

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

#Konvertieren Sie das richtige Etikettenformat
y_train = np_utils.to_categorical(y_train, 2)
#Konvertieren Sie das richtige Etikettenformat
y_test = np_utils.to_categorical(y_test, 2)

#Erstellen Sie 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'))

#kompilieren
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)
#Konvertieren Sie das richtige Etikettenformat
y_test = np_utils.to_categorical(y_test, 4)

model.add(Dense(4))

Wenn Sie diesen Teil ändern, wird es funktionieren! !!

6. Unterscheiden Sie Bilder anhand des erlernten Modells

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)

Diesmal habe ich versucht zu unterscheiden, wie ich unterscheiden konnte, als ich Herrn Hirate von Keyakizaka in eine andere Datei legte.

Ich erkannte, dass es Mr. Ota mit einer 99,9% igen Chance war, lol

Apropos, Wenn Sie nach dem echten Mr. Tanaka urteilen Es wird es richtig bestimmen! !! !!

Dieses Mal habe ich versucht, den Fluss der Bilderkennung mithilfe von Deep Learning zusammenzufassen. Ich konnte es nicht so weit wie möglich weglassen, damit auch Anfänger es tun können. (Ich hatte eine harte Zeit, aber lol) Ich denke, du kannst es mit deinen Lieblingsschauspielern und -figuren machen, also komm bitte zu uns! !!

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