Créez une IA qui identifie le visage de Zuckerberg grâce à l'apprentissage en profondeur ③ (Apprentissage des données)
Partie 1: Créer une IA qui identifie le visage de Zuckerberg grâce à l'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)
Continuant de, cet article est la partie 3. Ce que nous fabriquons, 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.
En continuant à partir de la dernière fois, j'écrirai le traitement avec TensorFlow. Le travail de la partie TensorFlow est ** "(1) Concevoir un modèle d'apprentissage pour TensorFlow (terminé!) → (2) Apprentissage et formation des données de visage → (3) Rendre possible de juger le visage de n'importe quelle image en utilisant les résultats d'apprentissage" * C'est un flux général de *.
Part 2 a terminé ** "(1) Design of TensorFlow learning model (neural network)" , donc cette fois, [Part 2] Partie 1]((http://qiita.com/AkiyoshiOkano/items/72f3e4ba9caf514460ee)) Basé sur la grande quantité de données sur le visage de Zuckerberg, Billgates et Earon Mask, en fait ** "Données d'image du visage" Apprenons "".
On a l'impression que l'apprentissage en profondeur avec TensorFlow est enfin terminé. (Les documents minimaux qui semblent nécessaires pour les prémisses de l'apprentissage en profondeur et de TensorFlow et les articles auxquels j'ai fait référence sont résumés dans Partie 2. J'espère que vous pourrez vous y référer.)
Laissons réellement l'IA apprendre les données! J'ai hâte d'y être!
③ Apprenez les données d'image de visage collectées
1. Ecrire le traitement de la partie formation des données de TensorFlow
Nous allons créer le traitement de la partie TensorFlow qui entraîne réellement les données d'entraînement. Comme je l'ai écrit dans l'article précédent, la structure des répertoires de ce projet ressemble à ceci.
Structure du répertoire
/tensoflow
main.py(J'écrirai le modèle d'apprentissage et le processus d'apprentissage ici)
eval.py(Un fichier qui renvoie les résultats de cas de n'importe quelle image)
/data(Données de visage collectées dans l'article précédent)
/train
/zuckerbuerg
/elonmusk
/billgates
data.txt
/test
/zuckerbuerg
/elonmusk
/billgates
data.txt
Après cela, les dossiers et fichiers créés lors de l'installation de tensorflow se trouvent dans le dossier tensorflow.
Nous ajouterons le traitement de la partie d'apprentissage au fichier `` main.py '' utilisé la dernière fois.
(Le code de la partie construction du ** modèle d'apprentissage créé la dernière fois ** est inclus dans ce fichier `` main.py '', mais il sera dupliqué et allongé, donc le code de la partie précédente est décrit ci-dessous. Je l'ai omis, mais lorsque vous l'exécutez, veuillez également insérer le code de la partie du modèle d'apprentissage précédent dans ce fichier. Il peut être bon de le séparer dans un autre fichier et de l'importer.)
main.py(Partie apprentissage des données)
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import cv2
import random
import numpy as np
import tensorflow as tf
import tensorflow.python.platform
#Nombre d'étiquettes d'identification(Cette fois trois)
NUM_CLASSES = 3
#Taille de l'image lors de l'apprentissage(px)
IMAGE_SIZE = 28
#Nombre de dimensions de l'image(28px*28px*3(Couleur))
IMAGE_PIXELS = IMAGE_SIZE*IMAGE_SIZE*3
#Flag est une fonction intégrée de TensorFlow qui peut enregistrer les valeurs par défaut et aider les explications de l'écran telles que les constantes.
flags = tf.app.flags
FLAGS = flags.FLAGS
#Données d'entraînement
flags.DEFINE_string('train', './data/train/data.txt', 'File name of train data')
#Données de vérification
flags.DEFINE_string('test', './data/test/data.txt', 'File name of train data')
#Dossier de stockage de données TensorBoard
flags.DEFINE_string('train_dir', './data', 'Directory to put the training data.')
#Nombre d'essais de formation à l'apprentissage
flags.DEFINE_integer('max_steps', 100, 'Number of steps to run trainer.')
#Combien d'images à utiliser dans une étude
flags.DEFINE_integer('batch_size', 20, 'Batch size Must divide evenly into the dataset sizes.')
#Si le taux d'apprentissage est trop petit, l'apprentissage ne se poursuivra pas, et s'il est trop grand, l'erreur ne convergera ni ne divergera. délicat
flags.DEFINE_float('learning_rate', 1e-4, 'Initial learning rate.')
#------------------------------------------------
##################################################
#Principal que j'ai écrit la dernière fois pendant cette période.Contient le code pour créer un modèle d'apprentissage pour py.#
#Il peut être bon de créer un fichier séparé uniquement ici, de l'importer et de le lire.#
##################################################
#------------------------------------------------
#Calculez le taux d '"erreur" entre le résultat de la prédiction et la bonne réponse
#logits est le résultat du calcul: float - [batch_size, NUM_CLASSES]
#étiquettes est l'étiquette de réponse correcte: int32 - [batch_size, NUM_CLASSES]
def loss(logits, labels):
#Calcul de l'entropie croisée
cross_entropy = -tf.reduce_sum(labels*tf.log(logits))
#Spécifier pour afficher dans TensorBoard
tf.scalar_summary("cross_entropy", cross_entropy)
#Valeur du taux d'erreur(cross_entropy)rends le
return cross_entropy
#Erreur(loss)Former un modèle d'apprentissage conçu à l'aide d'une rétropropagation d'erreur basée sur
#Je ne suis pas sûr de ce qui se passe dans les coulisses, mais les poids de chaque couche du modèle d'apprentissage(w)Etc
#Comprendre que les paramètres sont ajustés en optimisant en fonction de l'erreur(?)
# (L'explication du livre "L'intelligence artificielle dépasse-t-elle les humains?")
def training(loss, learning_rate):
#Comme cette fonction fait tout ça
train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss)
return train_step
#Calculer le taux de réponse correct du résultat de prédiction donné par le modèle d'apprentissage à l'inférence
def accuracy(logits, labels):
#Comparez si l'étiquette de prédiction et l'étiquette de réponse correcte sont égales. Renvoie Vrai s'ils sont identiques
#argmax est l'indice de la partie avec la plus grande valeur dans le tableau(=Le numéro de l'étiquette qui semble être la réponse la plus correcte)rends le
correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(labels, 1))
#booléen correct_Calculez le taux de réponse correct en changeant la prédiction en flottant
# false:0,true:Convertir en 1 et calculer
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
#Configurer pour afficher sur TensorBoard
tf.scalar_summary("accuracy", accuracy)
return accuracy
if __name__ == '__main__':
#Format Tensor pour que les images d'apprentissage puissent être lues par TensorFlow(queue)Conversion en
#Fichier ouvert
f = open(FLAGS.train, 'r')
#Tableau pour mettre des données
train_image = []
train_label = []
for line in f:
#Séparé par des espaces sauf pour les sauts de ligne
line = line.rstrip()
l = line.split()
#Lire les données et réduire à 28x28
img = cv2.imread(l[0])
img = cv2.resize(img, (IMAGE_SIZE, IMAGE_SIZE))
#Après avoir fait la queue, 0-Défini sur une valeur flottante de 1
train_image.append(img.flatten().astype(np.float32)/255.0)
#Étiquette 1-of-Préparez-vous avec la méthode k
tmp = np.zeros(NUM_CLASSES)
tmp[int(l[1])] = 1
train_label.append(tmp)
#Convertir au format numpy
train_image = np.asarray(train_image)
train_label = np.asarray(train_label)
f.close()
#De même, le format Tensor pour que les images de vérification puissent être lues par TensorFlow(queue)Conversion en
f = open(FLAGS.test, 'r')
test_image = []
test_label = []
for line in f:
line = line.rstrip()
l = line.split()
img = cv2.imread(l[0])
img = cv2.resize(img, (IMAGE_SIZE, IMAGE_SIZE))
test_image.append(img.flatten().astype(np.float32)/255.0)
tmp = np.zeros(NUM_CLASSES)
tmp[int(l[1])] = 1
test_label.append(tmp)
test_image = np.asarray(test_image)
test_label = np.asarray(test_label)
f.close()
#Spécifiez la portée à afficher dans le graphique TensorBoard
with tf.Graph().as_default():
#Tensor pour insérer des images(28*28*3(IMAGE_PIXELS)N'importe quel nombre d'images dimensionnelles(None)J'ai une minute)
images_placeholder = tf.placeholder("float", shape=(None, IMAGE_PIXELS))
#Tenseur pour mettre une étiquette(3(NUM_CLASSES)N'importe quel nombre d'étiquettes dimensionnelles(None)Entrez les minutes)
labels_placeholder = tf.placeholder("float", shape=(None, NUM_CLASSES))
#Tensor temporaire pour mettre le taux d'abandon
keep_prob = tf.placeholder("float")
# inference()Faire un modèle
logits = inference(images_placeholder, keep_prob)
# loss()Pour calculer la perte
loss_value = loss(logits, labels_placeholder)
# training()Pour former et ajuster les paramètres du modèle d'apprentissage
train_op = training(loss_value, FLAGS.learning_rate)
#Calcul de la précision
acc = accuracy(logits, labels_placeholder)
#Prêt à économiser
saver = tf.train.Saver()
#Créer une session(Les calculs TensorFlow doivent être effectués dans une session absolue)
sess = tf.Session()
#Initialisation variable(Initialiser après le démarrage de la session)
sess.run(tf.initialize_all_variables())
#Paramètres d'affichage du TensorBoard(Déclaratif du Tensor Board?)
summary_op = tf.merge_all_summaries()
# train_Spécifiez le chemin pour sortir le journal TensorBoard avec dir
summary_writer = tf.train.SummaryWriter(FLAGS.train_dir, sess.graph_def)
#En fait max_Exécuter l'entraînement autant de fois que l'étape
for step in range(FLAGS.max_steps):
for i in range(len(train_image)/FLAGS.batch_size):
# batch_Exécution de la formation pour les images de taille
batch = FLAGS.batch_size*i
# feed_Spécifiez les données à mettre dans l'espace réservé avec dict
sess.run(train_op, feed_dict={
images_placeholder: train_image[batch:batch+FLAGS.batch_size],
labels_placeholder: train_label[batch:batch+FLAGS.batch_size],
keep_prob: 0.5})
#Calculez la précision après chaque étape
train_accuracy = sess.run(acc, feed_dict={
images_placeholder: train_image,
labels_placeholder: train_label,
keep_prob: 1.0})
print "step %d, training accuracy %g"%(step, train_accuracy)
#Ajouter une valeur à afficher sur le TensorBoard après chaque étape
summary_str = sess.run(summary_op, feed_dict={
images_placeholder: train_image,
labels_placeholder: train_label,
keep_prob: 1.0})
summary_writer.add_summary(summary_str, step)
#Afficher la précision des données de test après l'entraînement
print "test accuracy %g"%sess.run(acc, feed_dict={
images_placeholder: test_image,
labels_placeholder: test_label,
keep_prob: 1.0})
#Former les données et enregistrer le modèle final
# "model.ckpt"Est le nom du fichier de sortie
save_path = saver.save(sess, "model.ckpt")
Ceci termine le traitement de la partie d'apprentissage de TensorFlow.
En passant, cette fois, il a presque la même composition que M. kivantium de Identifier la société de production de l'anime Yuruyuri avec TensorFlow. est. Au début, j'ai fait diverses choses moi-même, mais (je ne pouvais pas me sentir bien) j'ai finalement essayé de faire de même. m (_ _) m
La partie lecture de données n'est pas OpenCV, mais il semble que vous puissiez mieux l'écrire en utilisant les fonctions tf.TextLineReader '' et decode_jpeg '' intégrées à TensorFlow, mais je ne peux pas bien le faire et je ne peux pas le faire après tout ... orz
J'ai pensé: "C'est un peu la même chose d'écrire un article tel qu'il est ...", et au moins j'ai écrit un commentaire sur la partie explication du code plus en détail pour les super débutants comme moi. (S'il vous plaît laissez-moi savoir s'il y a quelque chose qui ne va pas avec l'explication m (_ _) m)
2. Apprenez réellement les données de visage
Maintenant que le modèle d'apprentissage a été conçu et que la partie d'apprentissage des données a été traitée, le fichier main.py est placé dans le répertoire avec les données d'image du visage, et TensorFlow est lancé avec source bin / activate ''. Ensuite, exécutez le fichier main.py avec python main.py '' et vous devriez réellement commencer à apprendre et générer le fichier `` model.ckpt '' du résultat d'apprentissage final. Effectuons réellement l'apprentissage des données!
① cd tensorflow '' (déplacer vers le répertoire tensorflow) ② source bin / activate(démarrer tensorflow) ③ python main.py(exécution d'apprentissage!) ④ Générer un fichier model.ckpt '' du résultat d'apprentissage final
C'est très facile à faire tant que vous écrivez le processus. Dans mon cas, il a fallu environ 30 minutes pour étudier à 200 STEP. Je pense qu'il faudra beaucoup de temps pour apprendre 100 millions de fois.
3. Regardez les résultats d'apprentissage
Vous pouvez voir la transition du taux de précision (précision) et de l'erreur (cross_entropy) lorsque vous exécutez l'apprentissage, car il est généré sous forme de graphique sur TensorBoard.
Je pense que le résultat d'apprentissage changera en fonction des données d'entraînement même avec le même modèle d'apprentissage, mais dans mon cas, c'était comme ça. Je pense que le taux de réponse correct pendant l'apprentissage sera également affiché sur la console. D'ailleurs, le nombre de formations et le nombre de lots ont été décidés de manière appropriée en se référant aux articles d'autres personnes et en fixant le nombre de formations à 100 à 200 et le nombre de lots à 10 à 20. Quel type de valeur est bon?
** graphique de précision (taux de réponse correct) **
J'ai changé le nombre de lots et le nombre d'apprentissages et l'ai exécuté 3 fois, mais la précision n'a pas changé du tout de 0,33 (1/3) à la fin dans les 1ère et 2ème fois, et la 3ème fois à nouveau dans les mêmes conditions que la 2ème fois. Après l'exécution de l'apprentissage, la précision a augmenté correctement en fonction du nombre de STEP. (Ce comportement dont le taux de réponse correcte a soudainement commencé à augmenter au troisième apprentissage cette fois, je n'ai pas faim, je veux que quelqu'un me dise ce qui s'est passé m (_ _) m)
(La sortie de la console au moment du troisième apprentissage. Le taux de réponse correct est passé à 1 à environ 40 STEP.)
Dans mon cas, le taux de réponse correct est devenu 1 en environ 40 étapes, et j'ai senti qu'il était étrangement plus rapide que les cas d'autres personnes, donc je l'ai optimisé uniquement pour les données d'entraînement et j'ai créé un modèle qui ne peut pas être utilisé. ** "Overlearning" **? J'en doutais, mais le taux de réponse correct dans les données de test pour la vérification ultérieure était d'environ 97%, alors y a-t-il un problème? J'ai décidé de continuer. (J'ai aussi pensé: "Est-ce que ça va si le taux de réponse correct est de 1? W". Je me demande si c'était bien de continuer comme ça ...)
** Graphique Cross_entropy (erreur) **
Le graphique de cross_entropy ressemble à ceci. (Au moment de la troisième exécution d'apprentissage)
Ce que j'ai pensé après avoir essayé jusqu'ici était ** "Idem pour la conception de modèles d'apprentissage (réseau neuronal), mais je pense que l'ajustement du nombre de formations et du nombre de lots est une partie où le sens et l'expérience sont nécessaires." C'était une impression. C'est moche!
C'est la fin de l'apprentissage. Il semble qu'il existe une fonction qui peut facilement gonfler les données en inversant les données d'entraînement ou en modifiant la tonalité de couleur avec la fonction intégrée de TensorFlow, donc je voulais l'utiliser, mais cette fois, c'est la troisième exécution d'apprentissage Même si je n'utilisais pas de rembourrage, cela ressemblait au résultat d'apprentissage que je recherchais pour le moment, alors j'ai abandonné cette fois. (Référence: Apprenez à gonfler des images à partir du code TensorFlow)
J'étais en train de tâtonner pour la première fois en apprenant TensorFlow, mais si vous avez quelque chose comme "Je devrais faire plus ici", merci de me le faire savoir. M (_ _) m
④ Rendre possible de juger le visage de n'importe quelle image
Enfin, les données du modèle entraîné seront utilisées pour déterminer le visage de n'importe quelle image. En utilisant TensorFlow et Flask, un framework d'application WEB de Python, nous allons l'implémenter afin qu'il puisse être exécuté sur l'interface WEB.
Cliquez ici pour la quatrième partie de la suite → Créer une IA qui identifie le visage de Zuckerberg par apprentissage profond ④ (construction WEB)
** "Créez une IA qui identifie le visage de Zuckerberg grâce à l'apprentissage en profondeur"
GitHub：https://github.com/AkiyoshiOkano/zuckerberg-detect-ai
Résultat du jugement bonus
Images de jugement bonus. Cette fois, si aucune des ** 3 personnes de Zuckerberg, Billgates et Ilone Mask ne dépasse 90%, la spécification ** sera affichée comme "Aucune des 3 personnes".
Savannah Takahashi qui est trafiquée comme Zuckerberg [^ 1]
Une IA qui identifie correctement Zuckerberg et Savannah Takahashi
M. Zuckerberg
[^ 1]: Source: http://matsukonews.com/1555