[PYTHON] Ich untersuchte die Gesichtszüge von Yuki Kashiwagi, um TensorFlow zu verstehen [Teil 2]

Ich untersuchte Yuki Kashiwagis Gesichtszüge, um TensorFlow und CNN (Convolutional Neural Network) zu verstehen. Dieses Mal werde ich den gesamten Prozess erklären und zusammenfassen, wobei ich mich auf den Beurteilungsteil von TensorFlow im gesamten Prozess konzentriere. Bei der Beurteilung wird anhand des trainierten Modells beurteilt, ob das Einzelbild Yuki Kashiwagi ist. Die Prämisse dieses Artikels ist Teil 1 und Teil 2.

Bestimmungsprozess

Wie ich in Teil 1 geschrieben habe, wird die Bildbeurteilung mit der Gesichtserkennung unter Verwendung von OpenCV + Zuschneiden und der Bildbeurteilung unter Verwendung von TensorFlow fortgesetzt, wie in der folgenden Abbildung gezeigt. tun. Die im Prozess von "3. Lernen" gespeicherten gelernten Parameter werden bei der Beurteilung des Bildes verwendet.

Vollstreckung des Urteils

Bereit zu rennen

Die Ordnerstruktur sieht folgendermaßen aus und legt das in OpenCV verwendete Lernmodell für die Gesichtserkennung im Ordner "models" ab. Die Erfassungsquelle ist Github. Die Grundlagen von OpenCV finden Sie im Artikel "[Erklärung für Anfänger] openCV-Gesichtserkennungsmechanismus und -praxis (detectMultiScale)". Legen Sie dann die zu beurteilende Bilddatei in den Ordner "images". Es können mehrere Dateien platziert werden, aber nur die Bilddatei, deren Gesichtserkennung zuerst erfolgreich war, wird beurteilt, und die verbleibenden Bilddateien werden nicht beurteilt. Andere Bilder als der Ordner "images" können auch geladen werden, indem zur Laufzeit Parameter angegeben werden.

models
│  haarcascade_frontalface_default.xml
│  haarcascade_frontalface_alt.xml
│  haarcascade_frontalface_alt2.xml
│  haarcascade_frontalface_alt_tree.xml
│  haarcascade_profileface.xml
images
│ Bilddatei zu beurteilen

Ausführung lernen

python judge_image.py

Führen Sie den Befehl mit dem obigen Befehl aus. Wenn die Gesichtserkennung erfolgreich ist, wird das erkannte Gesichtsbild in einem Popup angezeigt. Alles ist in Ordnung, also drücken Sie die Taste, um das Urteil auszuführen.

Die folgenden Angaben dienen als Laufzeitparameter. Implementiert mit der Bibliothek argparse, die im Artikel ["Parameter mit openCV-Gesichtserkennung angeben, um die Erkennungsgenauigkeit schnell zu verbessern"] erläutert wird (http://qiita.com/FukuharaYohei/items/116932920c99a5b73b32). tun.

Python-Programm

Urteilsteil (Judge_image.py)

[Modellteil (model_deep.py)](http://qiita.com/FukuharaYohei/items/1192ca038b0052ef300f#%E3%83%A2%E3%83%87%E3%83%AB%E9%83%A8%E5 % 88% 86model_deeppy) wird aufgerufen, um das Bild zu beurteilen.

import cv2, argparse, os
import numpy as np
import tensorflow as tf
import model_deep  #Geschätzter Teil von TensorFlow

#Ort des trainierten Bildidentifikationsmodells
CKPT_PATH = '/tmp/tensorflow/kashiwagi/logs/'

#Grundlegende Modellparameter
FLAGS = None

#Identifikationsetikett und der Name, der jeder Etikettennummer entspricht
HUMAN_NAMES = { 0: u'Kashiwagi', 1: u'others',}

#Gesichtserkennung trainierter Modelltyp
CASCADE = ['default','alt','alt2','tree','profile']

#Erwerb von Merkmalen des Klassifikators
def get_cascade():
    #Sortierverzeichnis(Erhalten von)
    # https://github.com/opencv/opencv/blob/master/data/haarcascades/

    #Geschulte Modelldatei
    if   FLAGS.cascade == CASCADE[0]:#'default':
        cascade_path = './models/haarcascade_frontalface_default.xml'
    elif FLAGS.cascade == CASCADE[1]:#'alt':
        cascade_path = './models/haarcascade_frontalface_alt.xml'
    elif FLAGS.cascade == CASCADE[2]:#'alt2':
        cascade_path = './models/haarcascade_frontalface_alt2.xml'
    elif FLAGS.cascade == CASCADE[3]:#'tree':
        cascade_path = './models/haarcascade_frontalface_alt_tree.xml'
    elif FLAGS.cascade == CASCADE[4]:#'profile':
        cascade_path = './models/haarcascade_profileface.xml'

    #Ermitteln Sie die Merkmalsmenge des Kaskadenklassifikators
    return(cv2.CascadeClassifier(cascade_path))

#Gesichtsurteil
def run_judge(image):
    
    #Gibt die Wahrscheinlichkeit jedes Etiketts für das Eingabebild aus und gibt sie zurück
    logits = model_deep.inference(image, 1.0, FLAGS.image_size, FLAGS.pool_size)
    
    #Softmax-Berechnung
    loss   = tf.nn.softmax(logits)

    #Geben Sie den bisherigen Inhalt an TensorBoard aus
    summary = tf.summary.merge_all()

    #Geschulte Vorbereitung von Modellanrufen
    saver = tf.train.Saver()
    
    #Sitzung erstellen(TensorFlow-Berechnungen müssen in einer absoluten Sitzung durchgeführt werden)
    with tf.Session() as sess:
    
        #Vorbereitung zum Schreiben an TensorBoard
        summary_writer = tf.summary.FileWriter(FLAGS.log_dir, sess.graph)

        #Variable Initialisierung(Vor dem Laden des trainierten Modells ausführen)
        sess.run(tf.global_variables_initializer())
        
        #Ein geschultes Modell erhalten
        ckpt = tf.train.get_checkpoint_state(CKPT_PATH)

        #Lesen Sie, ob es ein geschultes Modell gibt
        if ckpt:
            saver.restore(sess, ckpt.model_checkpoint_path)

        #Führen Sie die Sitzung aus und erhalten Sie die TensorBoard-Zusammenfassung und den Fehler
        summary_str, loss_value = sess.run([summary, loss])

        #Zusammenfassung zu TensorBoard hinzufügen und schließen
        summary_writer.add_summary(summary_str)
        summary_writer.close()

        #Urteilsergebnis
        result = loss_value[0]
        
        humans = []
        #Erstellen Sie einen Hash für Name und Wahrscheinlichkeit
        for index, rate in enumerate(result):
            humans.append({
                'name': HUMAN_NAMES[index],
                'rate': rate * 100
            })
        #Sortieren Sie in absteigender Reihenfolge mit Wahrscheinlichkeit und geben Sie die wahrscheinlichste Antwort aus
        rank = sorted(humans, key=lambda x: x['rate'], reverse=True)        
        print('Probalibity %d %% :This image is %s' % (rank[0]['rate'], rank[0]['name']))

#Gesichtserkennung und Beurteilung mit OpenCV
def read_and_edit_images(file_name, faceCascade):

    #Lesen der Bilddatei
    img = cv2.imread(FLAGS.input_dir + file_name)

    #Da es Dateien gibt, die bei einer großen Anzahl von Bildern selten fehlschlagen, protokollieren Sie die Ausgabe und überspringen Sie sie(Ursache unbekannt)
    if img is None:
        print(file_name + ':Cannot read image file')
        return 0

    #Gesichtserkennung
    face = faceCascade.detectMultiScale(cv2.cvtColor(img, cv2.COLOR_BGR2GRAY), 
                                        scaleFactor=FLAGS.scale, minNeighbors=FLAGS.neighbors, minSize=(FLAGS.min, FLAGS.min))

    #Wenn es nicht erkannt werden kann, protokollieren Sie die Ausgabe und beenden Sie das Programm
    if len(face) <= 0:
        print(file_name + ':No Face')
    else:
        
        #Schneiden Sie den Gesichtsteil aus und ändern Sie die Größe des Bildes, indem Sie nur das erste erkannte Gesicht verwenden
        cut_image = cv2.resize(img[face[0,1]:face[0,1] + face[0,3], face[0,0]:face[0,0] + face[0,2]], (FLAGS.image_size, FLAGS.image_size))
        
        #Zeigen Sie das Bild des im Popup geschnittenen Gesichts an(Drücken Sie die Taste, um das Popup zu schließen und mit dem nächsten Vorgang fortzufahren)
        cv2.imshow('image', cut_image)
        cv2.waitKey(0)
        cv2.destroyAllWindows()

        image = []

        #In das TensorFlow-Format konvertieren(Float 0-Bereich von 1)
        image.append(cut_image.astype(np.float32)/255.0)
        
        #Als Array zurückgeben
        return np.asarray(image)

        
def cut_and_judge_images():
    
    #Erwerb von Merkmalen des Klassifikators
    faceCascade = get_cascade()

    #Speichern Sie Dateien in Ordnern in Variablen(Speichert auch Verzeichnisse)
    files =  os.listdir(FLAGS.input_dir)

    #Wenn aus den gesammelten Bilddaten ein Gesicht erkannt wird, schneiden Sie es aus und speichern Sie es.
    for file_name in files:

        #Für Dateien(Wenn nicht ein Verzeichnis)
        if os.path.isfile(FLAGS.input_dir + file_name):
            
            #Bild lesen und Gesicht beschneiden
            image = read_and_edit_images(file_name, faceCascade)
            
            if image is not None:
                #Bildbeurteilung durch Weitergabe an TensorFlow
                run_judge(image)
                
                #Wenn Sie auch nur einmal urteilen, endet es
                return 0.
            
            
#Bestehen, wenn direkt ausgeführt(Importiert und nicht zur Laufzeit übergeben)
if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument(
        '--cascade',
        type=str,
        default='alt',
        choices=CASCADE,
        help='cascade file.'
  )
    parser.add_argument(
        '--scale',
        type=float,
        default=1.3,
        help='scaleFactor value of detectMultiScale.'
  )
    parser.add_argument(
        '--neighbors',
        type=int,
        default=2,
        help='minNeighbors value of detectMultiScale.'
  )
    parser.add_argument(
        '--min',
        type=int,
        default=50,
        help='minSize value of detectMultiScale.'
  )
    parser.add_argument(
        '--input_dir',
        type=str,
        default='./images/',
        help='The path of input directory.'
  )
    parser.add_argument(
        '--image_size',
        type=int,
        default=81,
        help='Input image size'
    )
    parser.add_argument(
        '--pool_size',
        type=int,
        default=3,
        help='Pooling size'
    )
    parser.add_argument(
        '--log_dir',
        type=str,
        default='/tmp/tensorflow/kashiwagi_judges',
        help='Directory to put the log data.'
    )

    #Parametererfassung und -ausführung
    FLAGS, unparsed = parser.parse_known_args()
    
    #Wenn das TensorBoard-Speicherverzeichnis vorhanden ist, löschen Sie es und erstellen Sie es neu.
    if tf.gfile.Exists(FLAGS.log_dir):
        tf.gfile.DeleteRecursively(FLAGS.log_dir)
    tf.gfile.MakeDirs(FLAGS.log_dir)

    #Gesichtserkennung und Beurteilung
    cut_and_judge_images()

Gesamtverbesserung

Eines Tages möchte ich die folgenden Verbesserungen und Rache überwinden: lifter_tone1: Wann wird es sein?

Fehlende Trainingsdaten

Ich denke, dass die geringe Menge an Trainingsdaten ein wesentlicher Faktor für die Verringerung der Genauigkeit war. Ich verwende Bing wie im Artikel "Aufrufen der Bing Image Search API v5 von Python zum Sammeln von Bildern" beschrieben, aber Google und andere verwenden es. War es gut? Außer mir [Phänomen, dass Bilder mit Bing nicht sehr oft aufgenommen werden können](http://qiita.com/ysdyt/items/49e99416079546b65dfc#%E7%B5%90%E6%9E%9C%E3%81%A8%E6% 89% 80% E6% 84% 9F) geschah. Es gab auch eine Zunahme von Bildauffüllung.

CNN-Lernmodell

Dieses Mal habe ich dasselbe Lernmodell wie Deep MNIST for Experts verwendet, aber Image Recognition Sie sollten sich auf / tutorials / image_recognition beziehen.

Schließlich

Weit entfernt von TensorFlow könnten sogar Anfänger von Python und Deep Learning diese Qualität erreichen! TensorFlow ist großartig. Es hat eine Weile gedauert, aber es hat Spaß gemacht. "Ich habe mit TensorFlow einen Dir en grey face-Klassifikator erstellt" und ["Erstellen einer KI, die Zuckerbergs Gesicht mit tiefem Lernen identifiziert" ]](Http://qiita.com/AkiyoshiOkano/items/72f3e4ba9caf514460ee) war sehr hilfreich.