[PYTHON] Créez une IA qui identifie le visage de Zuckerberg grâce à l'apprentissage en profondeur ④ (construction WEB)
Partie 1: Créer une IA pour identifier le visage de Zuckerberg par apprentissage en profondeur ① (Préparation des données d'apprentissage) Partie 2: Créer une IA qui identifie le visage de Zuckerberg par apprentissage en profondeur ② (Construction de modèles d'IA) Partie 3: Créer une IA qui identifie le visage de Zuckerberg grâce à l'apprentissage en profondeur ③ (Apprentissage des données)
Cet article est la partie 4. Ce que nous faisons, c'est "une IA qui identifie le visage de Zuckerberg". Utilisez TensorFlow de la bibliothèque d'apprentissage en profondeur de Google. Des exemples de vidéos de ce que j'ai fait cette fois sont ici.
Jusqu'à présent, dans les parties 1 à 3, les données de visage collectées ont été apprises à l'aide de TensorFlow, donc cette fois, nous avons en fait extrait le visage d'une image arbitraire en utilisant le résultat d'apprentissage et le visage extrait. J'aimerais pouvoir déterminer à quel point un visage est proche d'un visage appris. Et enfin, nous utiliserons Flask, le framework d'application Web de Python, pour permettre d'effectuer une série d'identifications à partir d'une interface Web. Si vous le faites jusqu'à la fin, je pense que ce sera "Oh, c'est comme l'IA!" Je suis devenu w
Tout d'abord, considérons la structure du répertoire de travail (préparation)
Considérant la coopération WEB plus tard, la structure du répertoire ressemble à ce qui suit.
Structure du répertoire
/tensoflow
main.py
model.ckpt(Fichier dans lequel les résultats d'apprentissage sont enregistrés)
eval.py(Décrit le processus de retour du résultat de cas de n'importe quelle image)
web.py(Décrire le traitement lié au WEB à l'aide de Flask)
/opencv(J'ai cloné à partir du github officiel d'opencv)
/static(Placer l'image utilisée dans Flask)
/images
/default
/cut_dace
/face_detect
/data
/train
/zuckerbuerg
/elonmusk
/billgates
data.txt
/test
/zuckerbuerg
/elonmusk
/billgates
data.txt
Après cela, les fichiers créés lors de l'installation de tensorflow, etc.
Cette fois, je vais principalement éditer les fichiers ʻeval.py`` et `web.py. Pour enregistrer la partie de reconnaissance faciale de l'image d'entrée et l'image avec le visage découpé, créez un répertoire appelé / static / images '' en préparation de la construction WEB ultérieure, et enregistrez l'image d'entrée et l'image traitée dans ce répertoire. Je vais continuer. L'OpenCV utilisé dans Part 1 sera également utilisé pour la reconnaissance faciale et le recadrage, donc OpenCV J'ai également placé le dossier cloné depuis opencv / opencv).
④ Rendre possible de juger n'importe quelle image en utilisant le résultat d'apprentissage
Depuis que je vous ai fait apprendre les données de visage en utilisant TensorFlow dans la partie 3 de la dernière fois, un nouveau save_path = saver.save (sess, "model.ckpt") à la fin de main.pyJe pense que le fichier model.ckptspécifié dans une ligne de est terminé. Étant donné que les paramètres ajustés après l'entraînement des données sont enregistrés dans ce fichier, vous pouvez facilement utiliser le modèle AI réellement entraîné par TensorFlow en utilisant ce fichier `` model.ckpt ''. Je vais.
Commençons par écrire le traitement lié à TensorFlow afin que le visage puisse être jugé à partir de n'importe quelle image. (TensorFlow pour la reconnaissance faciale des membres Momokuro (Partie 2) J'ai fait référence à l'article. Merci m (_ _) m)
eval.py
#!/usr/bin/env python
#! -*- coding: utf-8 -*-
import sys
import numpy as np
import cv2
import tensorflow as tf
import os
import random
import main
#Chemin du classificateur de visage par défaut OpenCV
cascade_path = './opencv/data/haarcascades/haarcascade_frontalface_default.xml'
faceCascade = cv2.CascadeClassifier(cascade_path)
#Étiquette d'identification et le nom correspondant à chaque numéro d'étiquette
HUMAN_NAMES = {
0: u"Zuckerberg",
1: u"Masque Eron",
2: u"Bill Gates"
}
#Image spécifiée(img_path)Résultats d'apprentissage(ckpt_path)Jugement utilisant
def evaluation(img_path, ckpt_path):
#Réinitialisation du graphique(Apparemment, je ne suis pas sûr de ce que je fais ...)
tf.reset_default_graph()
#Ouvrir l'image
f = open(img_path, 'r')
#Chargement d'image
img = cv2.imread(img_path, cv2.IMREAD_COLOR)
#Convertir en image monochrome
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
face = faceCascade.detectMultiScale(gray, 1.1, 3)
if len(face) > 0:
for rect in face:
#Je voulais donner un nom approprié à l'image traitée car cela n'a pas d'importance. Peut-être la date et le nombre de secondes
random_str = str(random.random())
#Écrivons la partie du visage avec une ligne rouge
cv2.rectangle(img, tuple(rect[0:2]), tuple(rect[0:2]+rect[2:4]), (0, 0, 255), thickness=2)
#Où enregistrer l'image avec le visage entouré d'une ligne rouge
face_detect_img_path = './static/images/face_detect/' + random_str + '.jpg'
#Enregistrement de l'image avec le visage entouré d'une ligne rouge
cv2.imwrite(face_detect_img_path, img)
x = rect[0]
y = rect[1]
w = rect[2]
h = rect[3]
#Enregistrer l'image du visage détecté découpé
cv2.imwrite('./static/images/cut_face/' + random_str + '.jpg', img[y:y+h, x:x+w])
#Découpez l'image du visage à transmettre à TensorFlow
target_image_path = './static/images/cut_face/' + random_str + '.jpg'
else:
#Si aucun visage n'est trouvé, le processus se termine
print 'image:NoFace'
return
f.close()
f = open(target_image_path, 'r')
#Tableau pour mettre des données
image = []
#Chargement d'image
img = cv2.imread(target_image_path)
# 28px*Redimensionné à 28px
img = cv2.resize(img, (28, 28))
#Après avoir aligné les informations sur l'image, 0-Défini sur une valeur flottante de 1
image.append(img.flatten().astype(np.float32)/255.0)
#Convertir au format numpy afin qu'il puisse être traité par TensorFlow
image = np.asarray(image)
#Sort et renvoie la probabilité de chaque étiquette pour l'image d'entrée(main.Appel de py)
logits = main.inference(image, 1.0)
# We can just use 'c.eval()' without passing 'sess'
sess = tf.InteractiveSession()
# restore(Lecture des paramètres)Préparation de
saver = tf.train.Saver()
#Initialisation variable
sess.run(tf.initialize_all_variables())
if ckpt_path:
#Lecture des paramètres après l'apprentissage
saver.restore(sess, ckpt_path)
# sess.run(logits)Pareil que
softmax = logits.eval()
#résultat du jugement
result = softmax[0]
#Résultat du jugement%Et arrondir
rates = [round(n * 100.0, 1) for n in result]
humans = []
#Créer un hachage pour le numéro d'étiquette, le nom, le pourcentage
for index, rate in enumerate(rates):
name = HUMAN_NAMES[index]
humans.append({
'label': index,
'name': name,
'rate': rate
})
#Trier par pourcentage le plus élevé
rank = sorted(humans, key=lambda x: x['rate'], reverse=True)
#Renvoie le résultat du jugement et le chemin de l'image traitée
return [rank, face_detect_img_path, target_image_path]
#Pour tester à partir de la ligne de commande
if __name__ == '__main__':
evaluation('testimage.jpg', './model2.ckpt')
Le processus ci-dessus renverra un tableau ** [Pourcentage des résultats de jugement, image avec une partie du visage entourée d'une ligne rouge, image avec une partie du visage découpée] **. Il ne vous reste plus qu'à permettre d'effectuer une série d'opérations telles que (1) télécharger une image → (2) découper le visage et faire un jugement AI → (3) sortir le résultat du jugement sur l'interface WEB.
L'apprentissage profond utilisant TensorFlow se termine ici, voici donc la construction du WEB.
⑤ Permet de juger des images sur le WEB
Cette fois, nous utiliserons Flask, un framework d'application web pour python. Flask est un framework qui facilite la création d'applications Web en Python. Cette fois, j'omettrai comment utiliser Flask. (Référence: Essayez d'utiliser le framework d'application Web Flask)
C'est vraiment simple: "Télécharger l'image-> transmettre l'image à eval.py-> afficher le résultat".
web.py
# -*- coding: utf-8 -*-
import tensorflow as tf
import multiprocessing as mp
from flask import Flask, render_template, request, redirect, url_for
import numpy as np
from werkzeug import secure_filename
import os
import eval
#Instanciez votre nom en tant qu'application
app = Flask(__name__)
app.config['DEBUG'] = True
#Où enregistrer l'image publiée
UPLOAD_FOLDER = './static/images/default'
#routage./Lors de l'accès
@app.route('/')
def index():
return render_template('index.html')
#Action lors de la publication d'une image
@app.route('/post', methods=['GET','POST'])
def post():
if request.method == 'POST':
if not request.files['file'].filename == u'':
#Enregistrez le fichier téléchargé
f = request.files['file']
img_path = os.path.join(UPLOAD_FOLDER, secure_filename(f.filename))
f.save(img_path)
# eval.Transmettez l'image téléchargée à py
result = eval.evaluation(img_path, './model2.ckpt')
else:
result = []
return render_template('index.html', result=result)
else:
#Si vous souhaitez rediriger en raison d'une erreur, etc.
return redirect(url_for('index'))
if __name__ == '__main__':
app.debug = True
app.run(host='0.0.0.0')
Cliquez ici pour les fichiers View et CSS <** index.html > Vue principale https://github.com/AkiyoshiOkano/zuckerberg-detect-ai/blob/First_commit/templates/index.html < layout.html > Partie de mise en page commune https://github.com/AkiyoshiOkano/zuckerberg-detect-ai/blob/First_commit/templates/layout.html < style.css **> Fichier CSS https://github.com/AkiyoshiOkano/zuckerberg-detect-ai/blob/First_commit/static/style.css
La structure finale du répertoire ressemble à ceci.
Structure du répertoire
/tensoflow
main.py(modèle d'apprentissage tensorflow et partie formation)
model.ckpt(Fichier dans lequel les résultats d'apprentissage sont enregistrés)
eval.py(Décrit le processus de retour du résultat de cas de n'importe quelle image)
web.py(Décrire le traitement lié au WEB à l'aide de Flask)
/opencv(J'ai cloné à partir du github officiel d'opencv)
/static(Placer les images et le CSS utilisés dans Flask)
/images
/default(Image téléchargée)
/cut_dace(Image avec visage recadré)
/face_detect(Image du visage entouré d'une ligne rouge)
style.css
/templates(Voir une partie de Flask)
index.html
layout.html
/data
/train
/zuckerbuerg
/elonmusk
/billgates
data.txt
/test
/zuckerbuerg
/elonmusk
/billgates
data.txt
Après cela, les fichiers créés lors de l'installation de tensorflow, etc.
TensorFlow semble pouvoir fonctionner sur Heroku, je vais donc l'essayer quand j'aurai le temps.
C'est la fin de la procédure de création d'un détecteur Zuckerberg à l'aide de TensorFLow! Merci à tous ceux qui nous ont aidés. J'espère que mon article sera utile à quelqu'un m (_ _) m
Post-scriptum de développement
C'était mon premier apprentissage automatique (deplanning) cette fois, mais je pensais que les informations sur le net étaient excellentes parce que je ne pouvais les former dans une certaine mesure qu'avec les informations sur le WEB sans utiliser de livres, etc. et je pouvais tellement comprendre l'apprentissage en profondeur. pensée. Cependant, je pense que cette fois, j'ai évoqué "Je pense que c'est vraiment la première étape de l'apprentissage automatique (apprentissage en profondeur)." (Est-il possible de passer d'une «personne inexpérimentée» à un «débutant»?)
En ce qui concerne l'IA réellement formée **, il y a une forte probabilité que les images de femmes soient à 95% ou plus de M. Bill Gates ou de M. Earon Mask **, ce qui signifie que les données entraînées cette fois sont toutes des visages masculins. Donc, si le visage d'une femme est remis, il ne peut pas être bien jugé, mais pour le moment, j'ai deviné que ce serait le résultat car la probabilité de chaque étiquette doit être combinée à 100% et sortie. difficile.
Cependant, j'ai été assez surpris de la précision de l'apprentissage en profondeur car ** Zuckerberg, Ilone Mask et Bill Gates qui ont formé les données de visage peuvent être identifiés presque sans suppression **. C'est comme "Oh, je vais vraiment te frapper". (Est-il possible de supprimer uniquement le masque Ilone de temps en temps?)
Après cela, j'ai été impressionné par la commodité de TensorFlow, qui vous permet d'utiliser des fonctions intégrées pour le moment, même si vous ne comprenez pas vraiment les formules mathématiques compliquées et l'intégration différentielle qui se produisent derrière l'apprentissage en profondeur. Si j'étudie davantage, la gamme de choses que je peux faire s'élargira considérablement, je voudrais donc profiter de cette occasion pour faire de mon mieux pour rattraper les informations sur la machine. Je pense qu'il y avait de nombreux points que je n'ai pas pu atteindre lors de ma première expérience d'apprentissage en profondeur, mais je tiens à remercier tous ceux qui l'ont lu jusqu'au bout. (Je vous serais reconnaissant si vous pouviez souligner les points qui sont mal interprétés m (_ _) m)
J'ai même réalisé un road movie de développement sous le nom de ** GW Free Research ** en 2017, donc si vous avez le temps, jetez-y un œil (rires). Vous pouvez également voir les résultats des jugements jugés à partir des images de différentes personnes. Le film de développement vient de ici.
** "Créer une IA qui identifie le visage de Zuckerberg grâce à l'apprentissage en profondeur"
GitHub:https://github.com/AkiyoshiOkano/zuckerberg-detect-ai
Recommended Posts