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.

スクリーンショット 2017-05-09 22.13.58.png

zgif2.gif

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) ** スクリーンショット_2017-05-09_12_54_18.png

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)

スクリーンショット 2017-05-06 19.45.06.png (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) ** スクリーンショット 2017-05-09 14.34.11.png

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"

** 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) Partie 3: Créer une IA qui identifie le visage de Zuckerberg grâce à l'apprentissage en profondeur ③ (Apprentissage des données) Partie 4: Créer une IA qui identifie le visage de Zuckerberg grâce à l'apprentissage en profondeur ④ (Construction WEB)

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] スクリーンショット 2017-05-08 21.11.12.png


Une IA qui identifie correctement Zuckerberg et Savannah Takahashi スクリーンショット 2017-05-09 21.54.48.png


M. Zuckerberg スクリーンショット 2017-05-12 15.04.12.png

[^ 1]: Source: http://matsukonews.com/1555

Recommended Posts

Créez une IA qui identifie le visage de Zuckerberg grâce à l'apprentissage en profondeur ③ (Apprentissage des données)
Créez une IA qui identifie le visage de Zuckerberg grâce à l'apprentissage en profondeur ① (Préparation des données d'apprentissage)
Créez une IA qui identifie le visage de Zuckerberg grâce à l'apprentissage en profondeur ② (construction de modèles d'IA)
Créez une IA qui identifie le visage de Zuckerberg grâce à l'apprentissage en profondeur ④ (construction WEB)
[AI] Apprentissage métrique profond
J'ai essayé de prédire les courses de chevaux en faisant tout, de la collecte de données à l'apprentissage en profondeur
J'ai essayé de faire d'Othello AI que j'ai appris 7,2 millions de mains par apprentissage profond avec Chainer
Introduction au Deep Learning ~ Règles d'apprentissage ~
Apprentissage par renforcement profond 1 Introduction au renforcement de l'apprentissage
Introduction au Deep Learning ~ Rétropropagation ~
Introduction à l'apprentissage en profondeur ~ Approximation des fonctions ~
Apprentissage profond pour démarrer sans GPU
Introduction à l'apprentissage profond ~ Préparation au codage ~
Apprentissage profond appris par l'implémentation 1 (édition de retour)
Introduction au Deep Learning ~ Dropout Edition ~
Introduction au Deep Learning ~ Propagation vers l'avant ~
Introduction à l'apprentissage profond ~ Expérience CNN ~
Comment collecter des données d'apprentissage automatique
[AI] Apprentissage en profondeur pour le débruitage d'image
J'ai essayé de classer Oba Hanana et Otani Emiri par apprentissage profond
Traitement de la voix par apprentissage profond: identifions qui est l'acteur vocal à partir de la voix
Comment créer un ensemble de données d'image de visage utilisé dans l'apprentissage automatique (1: Acquérir des images de candidats à l'aide du service API Web)
Apprentissage amélioré pour apprendre de zéro à profond
Essayez de faire face à la somme partielle
Introduction au Deep Learning ~ Pliage et mise en commun ~
Comment étudier le test Deep Learning G
Produisez de belles vaches de mer par apprentissage profond
Détection d'objets par apprentissage profond pour comprendre en profondeur par Keras
Alignement d'image: du SIFT au deep learning
[Apprentissage en profondeur] Détection de visage Nogisaka ~ Pour les débutants ~
À propos du traitement d'expansion des données pour l'apprentissage en profondeur
Essayez de dessiner un "front de type carte météorologique" par apprentissage automatique basé sur des données météorologiques (5)
Essayez de dessiner un "front de type carte météo" par apprentissage automatique basé sur les données météorologiques (3)
Regroupez le nombre d'étapes par jour à partir des données de santé iPhone pour créer un fichier CSV
Essayez de dessiner un "front de type carte météo" par apprentissage automatique basé sur des données météorologiques (1)
Essayez de dessiner un "front de type carte météo" par apprentissage automatique basé sur des données météorologiques (4)
Essayez de dessiner un "front de type carte météo" par apprentissage automatique basé sur des données météorologiques (2)
[Apprentissage automatique] Créez un modèle d'apprentissage automatique en effectuant un apprentissage par transfert avec votre propre ensemble de données
Un débutant en apprentissage automatique a tenté de créer une IA de jugement Sheltie en un jour
J'ai essayé de classer Hanana Oba et Emiri Otani par apprentissage profond (partie 2)
Introduction au Deep Learning pour la première fois (Chainer) Reconnaissance de caractères japonais Chapitre 4 [Amélioration de la précision de la reconnaissance en développant les données]