[PYTHON] Ich habe versucht, eine Gesichtsdiagnose-KI für professionelle Golferinnen zu erstellen ①

1. Zuallererst

Ich dachte darüber nach, ein Produkt mit dem tiefen Lernen herzustellen, das ich jetzt lerne. Ich wollte eine KI-App erstellen, die Bilder verwendet, also habe ich daran gearbeitet.

Als ich mich fragte, was ich mit dem Thema anfangen sollte, war mein Vater süchtig nach weiblichen Golferinnen, und so beschloss ich, eine professionelle Diagnose-App für Frauen zu erstellen. Ich entschied mich für eine diagnostische Bildgebungs-App für Hinako Shibuno, Sakura Kobetsu und Erika Hara.

• Ich wollte hier unbedingt ein Foto von meinem Gesicht machen, aber ich habe aufgegeben, weil es aus urheberrechtlichen Gründen nutzlos zu sein scheint.

2. Wie geht es weiter?

① Bildersammlung

② Holen Sie sich nur das Gesichtsteil

③ Löschen Sie unnötige Daten (z. B. ein anderes Gesicht, eine Sonnenbrille oder das Bild des Onkels aus irgendeinem Grund).

④ Teilen Sie in Testdaten und Validierungsdaten

⑤ Aufgeblasenes Bild

⑥ Modellbau (diesmal vgg16 Transferlernen)

⑦ Antrag zur Veröffentlichung erstellen

⑧ Bereitstellen

Es war ziemlich schwer ... Ich werde über das schreiben, was ich versucht habe.

3. Bildersammlung

Ich denke, es gibt viele Möglichkeiten, aber ich habe icrawler verwendet.

Was ist icrawler?

Ein Mini-Framework für Webcrawler. Es unterstützt Mediendaten wie Bilder und Videos und kann auf Text und andere Dateitypen angewendet werden. Scrapy ist schwer und mächtig, aber icrawler scheint leicht zu sein. Offizielle Referenz Bitte beachten Sie auch die Installationsmethode.

search.py

from icrawler.builtin import BingImageCrawler
import os
import shutil

#Bild zu erkennen
golfer_lists = {'Hinako Shibuno': 'shibuno', 'Kleine Feier Sakura': 'koiwai', 'Erika Hara': 'hara'}

#Ordner erstellen
os.makedirs('./origin_image', exist_ok=True)

#Der Schlüssel ist der Suchname und der Wert ist der Ordnername.
for key, value in golfer_lists.items():
    #Geben Sie das Speicherziel des erfassten Bildes an
    crawler = BingImageCrawler(storage={'root_dir': value})
    #Geben Sie Schlüsselwörter und die Anzahl der Akquisitionen an
    crawler.crawl(keyword=key, max_num=1000)
    #Ordner verschieben
    path = os.path.join('./', value)
    shutil.move(path, './origin_image/')

Jetzt können Sie jedes Bild erhalten. Ich habe es auf 1000 gesetzt, aber es waren tatsächlich ungefähr 700.

4. Erwerb des Gesichtsteils

Ich habe face_recognition verwendet, um den Gesichtsteil zu erhalten.

face_recognition.py

import cv2
from PIL import  Image
import os, glob
import numpy as np
import random
from PIL import ImageFile
import face_recognition

#Originalordner mit dem Originalbild
in_dir = './origin_image/*'
#Enthält nur das Bild des Gesichts
out_dir = './face'
#Ordner für jeden Spieler
in_file = glob.glob(in_dir)
#Holen Sie sich den Ordnernamen jedes Spielers
fileName_lists = os.listdir('./origin_image')
#Wo soll die Testdatei gespeichert werden?
test_image_path = './test_image/'

#Führen Sie die Verarbeitung für jeden Ordner durch
for golfer, fileName in zip(in_file, fileName_lists):
    #Holen Sie sich die Bilderliste jedes Spielers
    in_jpg = glob.glob(golfer + '/*')
    #Bildname jedes Spielers
    in_fileName=os.listdir(golfer)
    #Ordnerpfad für jeden Spieler
    folder_path = out_dir + '/' + fileName
    #Erstellen Sie für jeden Player einen Ausgabeordner
    os.makedirs(folder_path, exist_ok=True)

    #Verarbeiten Sie jedes Bild
    for i in range(len(in_jpg)):
        #Bild laden
        # image(Vertikal,Seite,3 Farben)
        image = face_recognition.load_image_file(str(in_jpg[i]))
        faces = face_recognition.face_locations(image)
        
        #Wenn das Bild existiert([(911, 2452, 1466, 1897)])Wird wie ausgegeben
        if len(faces) > 0:
            #Wählen Sie das größte aus den aufgenommenen Gesichtsbildern aus((top - bottom)*(right - left)Berechnung)
            face_max = [(abs(faces[i][0]-faces[i][2])) * (abs(faces[i][1]-faces[i][3])) for i in range(len(faces))]
            top, right, bottom, left = faces[face_max.index(max(face_max))]

            #Extrahieren Sie das Bild des Gesichtsteils
            faceImage = image[top:bottom, left:right]

            # Image.fromarray()Weitergabe von ndarray an PIL.Das Bild wird erhalten und gespeichert()Kann mit der Methode als Bilddatei gespeichert werden.
            final = Image.fromarray(faceImage)

            final = np.asarray(final.resize((64, 64)))
            final = Image.fromarray(final)

            file_path = folder_path + '/' + str(i) + '.jpg'
            final.save(file_path)
        else:
            print('No Face')

Es ist ein bisschen lang, aber es sieht so aus.

Überprüfen Sie das aktuelle Ordnersystem

Jetzt können Sie das Gesichtsteil bekommen. __ Danach arbeiten Sie daran, eins nach dem anderen zu überprüfen ... __ Es ist sehr schwierig, aber wichtig.

5. Trennen Sie Trainingsdaten und Validierungsdaten

Teilen Sie 80% in Trainingsdaten und 20% in Validierungsdaten auf.

split.py

#Separate Trainingsdaten und Validierungsdaten
import os, glob
import shutil

#Enthält nur das Bild des Gesichts
in_dir = './face/*'
#Ordner für jeden Spieler['./face/shibuno'　'./face/koiwai', './face/hara']
in_file = glob.glob(in_dir) 
#Holen Sie sich den Ordnernamen jedes Spielers['shibuno', 'koiwai', 'hara']
fileName_lists = os.listdir('./face')
#Wo soll die Testdatei gespeichert werden?
test_image_path = './valid/'

#Führen Sie die Verarbeitung für jeden Ordner durch
for golfer, fileName in zip(in_file, fileName_lists):
    #Holen Sie sich die Bilderliste jedes Spielers
    in_jpg = glob.glob(golfer + '/*')
    #Bildname jedes Spielers
    in_fileName=os.listdir(golfer)

    #Daten zur Validierung speichern
    test_path = test_image_path + fileName
    os.makedirs(test_path, exist_ok=True)

    #Wechseln Sie in den Validierungsordner
    for i in range(len(in_jpg)//5):
        shutil.move(str(in_jpg[i]), test_path+'/')

Es ist in Ordnung, wenn es so aussieht. Als nächstes wird das Bild der Trainingsdaten aufgeblasen.

6. Aufgeblasene Daten (aufgeblasen)

Das Sammeln und Auswählen von Bilddaten ist sehr zeitaufwändig und schwierig. (Es war wirklich schwer) Daher werden neue Daten durch Invertieren oder Verschieben der Bilddaten erstellt.

pic_add

import PIL
from keras.preprocessing.image import load_img, img_to_array, ImageDataGenerator, array_to_img
import numpy as np
import os, glob
import matplotlib.pyplot as plt
import cv2

#Originalordner mit dem Originalbild
in_dir = './face/*'
#Enthält nur das Bild des Gesichts
out_dir = './face'
#Ordnerpfad für jeden Spieler
in_files = glob.glob(in_dir)
#Jeder Ordnername
folder_names = os.listdir('./face')

#Pass und Ordnername jedes Spielers
for file, name in zip(in_files, folder_names):
    #Jedes Bild
    image_files = glob.glob(file + '/*')
    #Jeder Dateiname
    in_fileName = os.listdir(file)

    SAVE_DIR = './face/' + name
    #Wenn das Speicherzielverzeichnis nicht vorhanden ist, erstellen Sie es.
    if not os.path.exists(SAVE_DIR):
        os.makedirs(SAVE_DIR)

    #Blasen Sie jedes Bild einzeln auf
    for num in range(len(image_files)):
        datagen = ImageDataGenerator(
        rotation_range=40,       #Zufällig rotierender Drehbereich (Einheit: Grad)
        width_shift_range=0.2,   #Zufällig parallele Bewegung in horizontaler Richtung, Verhältnis zur Breite des Bildes
        height_shift_range=0.2,  #Zufällig parallele Bewegung in vertikaler Richtung, Verhältnis zur vertikalen Breite des Bildes
        shear_range=0.2,         #Scherungsgrad. Durch Erhöhen der Größe wirkt das Bild diagonal gequetschter oder gedehnter (Einheit: Grad).
        zoom_range=0.2,          #Die Rate, mit der das Bild zufällig komprimiert und vergrößert wird. Mindestens 1-Auf Zoombereich komprimiert, bis zu 1+zoom_Erweitert auf Reichweite.
        horizontal_flip=True,    #Wenn True angegeben ist, wird es zufällig zufällig horizontal gespiegelt.
        fill_mode='nearest')

        img_array = cv2.imread(image_files[num])  #Bild wird geladen
        img_array = img_array.reshape((1,) + img_array.shape)  #In 4D-Daten konvertieren (Fluss()Weitergeben an)

        # flow()Erstellen Sie einen Stapel zufällig konvertierter Bilder.
        #Speichern Sie das generierte Bild im angegebenen Verzeichnis.
        i = 0
        for batch in datagen.flow(img_array, batch_size=1,
                                save_to_dir=SAVE_DIR, save_prefix='add', save_format='jpg'):
            i += 1
            if i == 5:
                break  #Endlosschleife, wenn nicht gestoppt

Damit hat die Anzahl der Bilder von Trainingsdaten 1000 überschritten.

__ Es ist so lange her, dass ich das nächste Mal die Modellerstellung übernehmen werde. __ __

Der Code, wenn der Kaskadenklassifizierer als zusätzliche Edition verwendet wird, wird ebenfalls beschrieben.

* Kaskadenklassifikator

Zuerst habe ich versucht, den Gesichtsteil mit dem Kaskadenklassifikator abzurufen, aber ich konnte den Charakterteil und das Gesicht nicht abrufen, und die Datenmenge betrug ungefähr 1/6. Ich werde vorerst auch den Kaskadenklassifikator veröffentlichen Laden Sie "haarcascade_frontalface_default.xml" über den folgenden Link herunter.

(https://github.com/opencv/opencv/tree/master/data/haarcascades)

cascade.py

import cv2
from PIL import  Image
import os, glob
import numpy as np
import random
from PIL import ImageFile

#Originalordner mit dem Originalbild
in_dir = './origin_image/*'
#Enthält nur das Bild des Gesichts
out_dir = './face_image'
#Ordner für jeden Spieler
in_file = glob.glob(in_dir)
#Holen Sie sich den Ordnernamen jedes Spielers
fileName_lists = os.listdir('./origin_image')
#Wo soll die Testdatei gespeichert werden?
test_image_path = './face_image/test_image/'

cascade_path = './haarcascade_frontalface_alt.xml'
face_cascade = cv2.CascadeClassifier(cascade_path)

#Führen Sie die Verarbeitung für jeden Ordner durch
for golfer, fileName in zip(in_file, fileName_lists):
    #Holen Sie sich die Bilderliste jedes Spielers
    in_jpg = glob.glob(golfer + '/*')
    #Bildname jedes Spielers
    in_fileName=os.listdir(golfer)
    #Ordnerpfad für jeden Spieler
    folder_path = out_dir + '/' + fileName
    #Erstellen Sie für jeden Player einen Ausgabeordner
    os.makedirs(folder_path, exist_ok=True)

    #Verarbeiten Sie jedes Bild
    for i in range(len(in_jpg)):
        #Bild laden
        image=cv2.imread(str(in_jpg[i]))
        #Machen Sie es Graustufen
        image_gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
        faces = face_cascade.detectMultiScale(image_gray, scaleFactor=1.1, minNeighbors=2, minSize=(64, 64))

        if len(faces) > 0:
            for j, face in enumerate(faces,1):
                x, y ,w, h =face
                save_img_path = folder_path + '/' + str(i) +'_' + str(j) + '.jpg'
                cv2.imwrite(save_img_path , image[y:y+h, x:x+w])
        else:
            print ('image' + str(i) + ':NoFace')