1.Tout d'abord

J'ai pensé à créer un produit en utilisant le deep learning que j'apprends maintenant. Je voulais créer une application d'intelligence artificielle qui utilise des images, alors j'ai travaillé dessus.

Quand je me demandais quoi faire avec le sujet, mon père était accro aux golfeuses professionnelles, alors j'ai décidé de créer une application de diagnostic professionnelle féminine. J'ai décidé de créer une application d'imagerie diagnostique pour Hinako Shibuno, Sakura Kobetsu et Erika Hara.

Je voulais vraiment mettre une photo de mon visage ici, mais j'ai abandonné car cela semble inutile en raison de problèmes de droits d'auteur.

2. Comment procéder

① Collection d'images

② Obtenez uniquement la partie du visage

③ Supprimez les données inutiles (par exemple, un visage différent, des lunettes de soleil, l'image de l'oncle pour une raison quelconque)

④ Diviser en données de test et données de validation

⑤ Image gonflée

⑥ Construction du modèle (cette fois apprentissage par transfert vgg16)

⑦ Créer une demande de publication

⑧ Déployer

C'était assez difficile ... Je vais écrire sur ce que j'ai essayé.

3. Collection d'images

Je pense qu'il y a plusieurs façons de le faire, mais j'ai utilisé icrawler.

Qu'est-ce que icrawler?

Un mini-framework pour le robot d'exploration Web. Il prend en charge les données multimédias telles que les images et les vidéos, et peut être appliqué au texte et à d'autres types de fichiers. Scrapy est lourd et puissant, mais icrawler semble être léger. Référence officielle Veuillez également vous référer à la méthode d'installation.

`search.py`


from icrawler.builtin import BingImageCrawler
import os
import shutil

#Image à détecter
golfer_lists = {'Hinako Shibuno': 'shibuno', 'Petite fête Sakura': 'koiwai', 'Erika Hara': 'hara'}

#Créer le dossier
os.makedirs('./origin_image', exist_ok=True)

#La clé est le nom de la recherche et la valeur est le nom du dossier.
for key, value in golfer_lists.items():
    #Spécifiez la destination d'enregistrement de l'image acquise
    crawler = BingImageCrawler(storage={'root_dir': value})
    #Précisez les mots clés et le nombre d'acquisitions
    crawler.crawl(keyword=key, max_num=1000)
    #Déplacer le dossier
    path = os.path.join('./', value)
    shutil.move(path, './origin_image/')

Vous pouvez maintenant obtenir chaque image. Je l'ai réglé sur 1000, mais c'était en fait environ 700.

4. Acquisition de la partie faciale

J'ai utilisé face_recognition pour obtenir la partie du visage.

`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

#Dossier d'origine contenant l'image d'origine
in_dir = './origin_image/*'
#Contient l'image du visage uniquement
out_dir = './face'
#Dossier pour chaque joueur
in_file = glob.glob(in_dir)
#Obtenez le nom du dossier de chaque joueur
fileName_lists = os.listdir('./origin_image')
#Où enregistrer le fichier de test
test_image_path = './test_image/'

#Effectuer le traitement pour chaque dossier
for golfer, fileName in zip(in_file, fileName_lists):
    #Obtenez la liste d'images de chaque joueur
    in_jpg = glob.glob(golfer + '/*')
    #Nom d'image de chaque joueur
    in_fileName=os.listdir(golfer)
    #Chemin du dossier pour chaque joueur
    folder_path = out_dir + '/' + fileName
    #Créez un dossier de sortie pour chaque lecteur
    os.makedirs(folder_path, exist_ok=True)

    #Traitez chaque image
    for i in range(len(in_jpg)):
        #Charger l'image
        # image(Verticale,côté,3 couleurs)
        image = face_recognition.load_image_file(str(in_jpg[i]))
        faces = face_recognition.face_locations(image)
        
        #Si l'image existe([(911, 2452, 1466, 1897)])Est la sortie comme
        if len(faces) > 0:
            #Sélectionnez la plus grande parmi les images de visage acquises((top - bottom)*(right - left)Calculer)
            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))]

            #Extraire l'image de la partie du visage
            faceImage = image[top:bottom, left:right]

            # Image.fromarray()Passer ndarray à PIL.L'image est obtenue et sa sauvegarde()Peut être enregistré en tant que fichier image avec la méthode.
            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')

C'est un peu long, mais ça ressemble à ça.

Vérifiez le système de dossiers actuel フォルダ.png

Vous pouvez maintenant obtenir la partie du visage. __ Après cela, essayez de vérifier un par un ... __ C ’est très difficile, mais c’ est important.

5. Données de formation séparées et données de validation

Divisez en données d'entraînement 80% et données de validation 20%.

`split.py`


#Séparez les données d'entraînement et les données de validation
import os, glob
import shutil

#Contient l'image du visage uniquement
in_dir = './face/*'
#Dossier pour chaque joueur['./face/shibuno'　'./face/koiwai', './face/hara']
in_file = glob.glob(in_dir) 
#Obtenez le nom du dossier de chaque joueur['shibuno', 'koiwai', 'hara']
fileName_lists = os.listdir('./face')
#Où enregistrer le fichier de test
test_image_path = './valid/'

#Effectuer le traitement pour chaque dossier
for golfer, fileName in zip(in_file, fileName_lists):
    #Obtenez la liste d'images de chaque joueur
    in_jpg = glob.glob(golfer + '/*')
    #Nom d'image de chaque joueur
    in_fileName=os.listdir(golfer)

    #Enregistrer les données pour validation
    test_path = test_image_path + fileName
    os.makedirs(test_path, exist_ok=True)

    #Déplacer vers le dossier de validation
    for i in range(len(in_jpg)//5):
        shutil.move(str(in_jpg[i]), test_path+'/')

Ce n'est pas grave si ça ressemble à ça. Ensuite, l'image des données d'entraînement est gonflée.

6. Données gonflées (gonflées)

Collecter des données d'image et les sélectionner est très long et difficile. (C'était vraiment dur) Par conséquent, de nouvelles données sont créées en inversant ou en décalant les données d'image.

`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

#Dossier d'origine contenant l'image d'origine
in_dir = './face/*'
#Contient l'image du visage uniquement
out_dir = './face'
#Chemin du dossier pour chaque joueur
in_files = glob.glob(in_dir)
#Chaque nom de dossier
folder_names = os.listdir('./face')

#Le nom du pass et du dossier de chaque joueur
for file, name in zip(in_files, folder_names):
    #Chaque image
    image_files = glob.glob(file + '/*')
    #Chaque nom de fichier
    in_fileName = os.listdir(file)

    SAVE_DIR = './face/' + name
    #Si le répertoire de destination de sauvegarde n'existe pas, créez-le.
    if not os.path.exists(SAVE_DIR):
        os.makedirs(SAVE_DIR)

    #Gonflez chaque image individuellement
    for num in range(len(image_files)):
        datagen = ImageDataGenerator(
        rotation_range=40,       #Plage de rotation à rotation aléatoire (unité: degré)
        width_shift_range=0.2,   #Mouvement parallèle aléatoire dans le sens horizontal, rapport à la largeur de l'image
        height_shift_range=0.2,  #Mouvement parallèle aléatoire dans la direction verticale, rapport à la largeur verticale de l'image
        shear_range=0.2,         #Degré de cisaillement. L'augmentation de la taille donne à l'image un aspect plus écrasé ou étiré en diagonale (unité: degré)
        zoom_range=0.2,          #Vitesse à laquelle l'image est compressée et agrandie de manière aléatoire. Minimum 1-Comprimé à la plage de zoom, jusqu'à 1+zoom_Élargi à la gamme.
        horizontal_flip=True,    #Si True est spécifié, il sera retourné horizontalement au hasard.
        fill_mode='nearest')

        img_array = cv2.imread(image_files[num])  #Chargement d'image
        img_array = img_array.reshape((1,) + img_array.shape)  #Convertir en données 4D (flux()Passer à)

        # flow()Créez un lot d'images converties au hasard.
        #Enregistrez l'image générée dans le répertoire spécifié.
        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  #Boucle infinie si non arrêtée

Avec cela, le nombre d'images de données d'entraînement a dépassé 1000.

__ Cela fait si longtemps que je reprendrai la création du modèle la prochaine fois. __

Le code lorsque le classificateur en cascade est utilisé comme une édition supplémentaire est également décrit.

* Classificateur en cascade

Au début, j'ai essayé d'obtenir la partie du visage en utilisant le classificateur en cascade, mais je ne pouvais pas obtenir la partie du personnage et le visage, et la quantité de données est devenue d'environ 1/6. Je publierai également le classificateur en cascade pour le moment Téléchargez "haarcascade_frontalface_default.xml" à partir du lien ci-dessous.

(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

#Dossier d'origine contenant l'image d'origine
in_dir = './origin_image/*'
#Contient l'image du visage uniquement
out_dir = './face_image'
#Dossier pour chaque joueur
in_file = glob.glob(in_dir)
#Obtenez le nom du dossier de chaque joueur
fileName_lists = os.listdir('./origin_image')
#Où enregistrer le fichier de test
test_image_path = './face_image/test_image/'

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

#Effectuer le traitement pour chaque dossier
for golfer, fileName in zip(in_file, fileName_lists):
    #Obtenez la liste d'images de chaque joueur
    in_jpg = glob.glob(golfer + '/*')
    #Nom d'image de chaque joueur
    in_fileName=os.listdir(golfer)
    #Chemin du dossier pour chaque joueur
    folder_path = out_dir + '/' + fileName
    #Créez un dossier de sortie pour chaque lecteur
    os.makedirs(folder_path, exist_ok=True)

    #Traitez chaque image
    for i in range(len(in_jpg)):
        #Charger l'image
        image=cv2.imread(str(in_jpg[i]))
        #Faites-en une échelle de gris
        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')

J'ai essayé de faire un diagnostic de visage AI pour les golfeuses professionnelles ①