[PYTHON] Erstellen Sie mit TensorFlow eine Gesichtserkennung

Einführung

Hallo, das ist Hironsan.

Die Gesichtserkennung ist eine Technologie, die eine Person in einem Bild erkennt und identifiziert. Die Gesichtserkennung kann verwendet werden, indem sie in ein Überwachungskamerasystem integriert wird, um die Sicherheit zu verbessern, oder indem sie in einen Roboter integriert wird, um das Gesicht eines Familienmitglieds zu erkennen.

Dieses Mal werde ich mit TensorFlow ein neuronales Faltungsnetzwerk aufbauen und anhand eines vorhandenen Datensatzes einen Gesichtserkenner erstellen.

Zielgruppe

• Kennen Sie das Faltungs-Neuronale Netz (CNN)
• Ich kann nicht in TensorFlow schreiben

Sie können die Theorie von CNN sehen, indem Sie das Folgende betrachten.

• Was ist das Convolutional Neural Network

Vorbereitung

Installieren Sie TensorFlow

Informationen zur Installation von TensorFlow finden Sie auf der offiziellen Website.

• TensorFlow installieren

Daten herunterladen

Bereiten Sie zunächst den Datensatz vor. Dieses Mal verwenden wir den folgenden Gesichtsbilddatensatz.

• Olivetti Faces

Dieser Datensatz enthält 10 Bilder für jeweils 40 Personen. Jede Bildgröße beträgt 64 x 64 und ist ein Graustufenbild.

Bilder laden

Laden Sie das Bild, nachdem Sie den Datensatz vorbereitet haben. PyFaceRecognizer/example/input_data.py

import input_data
dataset = input_data.read_data_sets('data/olivettifaces.mat')

Hier enthält der Datensatz Trainingsdaten, Validierungsdaten und Testdaten. Außerdem wird die Bildgröße beim Lesen auf 32 x 32 reduziert.

Aufbau eines neuronalen Faltungsnetzwerks

Die Gesichtserkennung wird unter Verwendung des Faltungs-Neuronalen Netzwerks (CNN) durchgeführt. Das Gesamtbild ist wie folgt.

Conv, Pool und fc jeder Schicht repräsentieren die Faltungsschicht, die Pooling-Schicht bzw. die vollständig verbundene Schicht. ReL in der Funktionsspalte repräsentiert eine normalisierte lineare Funktion. Die folgende Tabelle zeigt die Parameter.

Wenn Sie es in Code schreiben, wird es wie folgt sein. Es ist fast das gleiche. PyFaceRecognizer/example/run.py

def inference(input_placeholder, keep_prob):
    W_conv1 = weight_variable([5, 5, 1, 32])  #Die ersten beiden sind Patchgrößen. Der Rest ist die Anzahl der Eingangs- und Ausgangskanäle
    b_conv1 = bias_variable([32])

    x_image = tf.reshape(input_placeholder, [-1, 32, 32, 1])  #Die zweite und dritte Dimension sind die Breite und Höhe des Bildes, und die letzte Dimension ist die Anzahl der Farbkanäle.

    h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)  #Falten
    h_pool1 = max_pool_2x2(h_conv1)  #max Pooling

    W_conv2 = weight_variable([5, 5, 32, 64])
    b_conv2 = bias_variable([64])

    h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
    h_pool2 = max_pool_2x2(h_conv2)

    W_fc1 = weight_variable([8 * 8 * 64, 1024])
    b_fc1 = bias_variable([1024])

    h_pool2_flat = tf.reshape(h_pool2, [-1, 8 * 8 * 64])
    h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

    h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

    W_fc2 = weight_variable([1024, 40])
    b_fc2 = bias_variable([40])

    y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)  #Ausgabe so

    return y_conv

Modellschulung und Bewertung

Ich habe den Modellcode in Inferenz geschrieben. Als nächstes schreiben wir den Code, um das Modell zu trainieren. Das ist Verlust und Training. Bei Verlust wird die Kreuzentropie berechnet und im Training wird der Adam-Optimierer verwendet, um die Parameter zu aktualisieren. Der Code lautet wie folgt.

def loss(output, supervisor_labels_placeholder):
    cross_entropy = tf.reduce_mean(-tf.reduce_sum(supervisor_labels_placeholder * tf.log(output), reduction_indices=[1]))
    return cross_entropy


def training(loss):
    train_step = tf.train.AdamOptimizer(1e-4).minimize(loss)
    return train_step

Die Gesichtserkennung wird unter Verwendung der oben definierten Inferenz, des Verlusts und des Trainings durchgeführt. Gibt alle 100 Iterationen des Trainingsprozesses ein Protokoll aus. Ich habe keep_peob auf 1.0 gesetzt, damit es beim Testen nicht ausfällt.

with tf.Session() as sess:
    output = inference(x, keep_prob)
    loss = loss(output, y_)
    training_op = training(loss)

    init = tf.initialize_all_variables()
    sess.run(init)

    for step in range(1000):
        batch = dataset.train.next_batch(40)
        sess.run(training_op, feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})
        if step % 100 == 0:
            print(sess.run(loss, feed_dict={x: batch[0], y_: batch[1], keep_prob: 1.0}))

    correct_prediction = tf.equal(tf.argmax(output, 1), tf.argmax(y_, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    print('test accuracy %g' % accuracy.eval(feed_dict={x: dataset.test.images, y_: dataset.test.labels, keep_prob: 1.0}))

Lauf

Das Ausführungsergebnis sieht wie folgt aus. Sie können sehen, wie die Kreuzentropie abnimmt.

9.8893
1.68918
0.602403
0.261183
0.0490791
0.0525591
0.0133087
0.0121071
0.00673524
0.00580989

Quellcode

Sie können den Quellcode aus dem folgenden Repository herunterladen und ausführen.

• PyFaceRecognizer

abschließend

Ich habe versucht, die Gesichtserkennung in einem vorhandenen Gesichtsdatensatz mithilfe eines Faltungs-Neuronalen Netzwerks zu erkennen. Als nächstes möchte ich die Gesichtserkennung und Gesichtserkennung anhand von Bildern versuchen, die in Echtzeit von der Kamera aufgenommen wurden.

Referenzmaterial

• TensorFlow Tutorial
• [Deep Learning (Machine Learning Professional Series)](https://www.amazon.co.jp/%E6%B7%B1%E5%B1%A4%E5%AD%A6%E7%BF%92-% E6% A9% 9F% E6% A2% B0% E5% AD% A6% E7% BF% 92% E3% 83% 97% E3% 83% AD% E3% 83% 95% E3% 82% A7% E3% 83% 83% E3% 82% B7% E3% 83% A7% E3% 83% 8A% E3% 83% AB% E3% 82% B7% E3% 83% AA% E3% 83% BC% E3% 82% BA-% E5% B2% A1% E8% B0% B7-% E8% B2% B4% E4% B9% 8B / dp / 4061529021 / ref = sr_1_1? Ie = UTF8 & qid = 1469600155 & sr = 8-1 & Schlüsselwörter =% E6% B7 % B1% E5% B1% A4% E5% AD% A6% E7% BF% 92)