[PYTHON] Créer un outil de reconnaissance de visage à l'aide de TensorFlow

introduction

Bonjour, c'est Hironsan.

La reconnaissance faciale est une technologie qui détecte une personne dans une image et l'identifie. La reconnaissance faciale peut être intégrée aux systèmes de caméras de surveillance pour améliorer la sécurité, ou intégrée aux robots pour reconnaître les visages de la famille.

Cette fois, je vais créer un réseau de neurones convolutifs à l'aide de TensorFlow et créer un dispositif de reconnaissance de visage à l'aide d'un ensemble de données existant.

Public cible

• Connaître le réseau de neurones convolutifs (CNN)
• Je ne sais pas comment écrire dans TensorFlow

Vous pouvez voir la théorie de CNN en regardant ce qui suit.

• Qu'est-ce que le réseau neuronal convolutif

Préparation

Installez TensorFlow

Veuillez vous référer au site officiel pour l'installation de TensorFlow.

• Installer TensorFlow

Télécharger les données

Tout d'abord, préparez l'ensemble de données. Cette fois, nous utiliserons l'ensemble de données d'image de visage suivant.

• Olivetti Faces

Cet ensemble de données contient 10 images pour chacune de 40 personnes. Chaque taille d'image est de 64x64 et est une image en échelle de gris.

Chargement des images

Après avoir préparé l'ensemble de données, chargez l'image. PyFaceRecognizer/example/input_data.py

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

Ici, l'ensemble de données contient des données d'entraînement, des données de validation et des données de test. En outre, la taille de l'image est réduite à 32x32 lorsqu'elle est lue.

Construire un réseau neuronal convolutif

La reconnaissance faciale est effectuée à l'aide du réseau neuronal convolutif (CNN). L'image globale est la suivante.

Les convolution, pool et fc de chaque couche représentent respectivement la couche de convolution, la couche de pooling et la couche entièrement connectée. ReL dans la colonne de fonction représente une fonction linéaire normalisée. Le tableau ci-dessous montre les paramètres.

Si vous l'écrivez dans le code, ce sera comme suit. C'est presque pareil. PyFaceRecognizer/example/run.py

def inference(input_placeholder, keep_prob):
    W_conv1 = weight_variable([5, 5, 1, 32])  #Les deux premiers sont des tailles de patch. Le reste est le nombre de canaux d'entrée et de sortie
    b_conv1 = bias_variable([32])

    x_image = tf.reshape(input_placeholder, [-1, 32, 32, 1])  #Les deuxième et troisième dimensions sont la largeur et la hauteur de l'image, et la dernière dimension est le nombre de canaux de couleur.

    h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)  #Pliant
    h_pool1 = max_pool_2x2(h_conv1)  #mise en commun maximale

    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)  #Sortie donc

    return y_conv

Formation et évaluation de modèles

J'ai écrit le code du modèle par inférence. Ensuite, nous écrirons le code pour entraîner le modèle. C'est la perte et la formation. En perte, l'entropie croisée est calculée et en entraînement, l'optimiseur Adam est utilisé pour mettre à jour les paramètres. Le code est comme suit.

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

La reconnaissance faciale est effectuée en utilisant l'inférence, la perte et l'entraînement définis ci-dessus. Génère un journal toutes les 100 itérations du processus de formation. J'ai mis keep_peob à 1.0 pour qu'il ne disparaisse pas lors des tests.

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}))

Courir

Le résultat de l'exécution ressemble à celui ci-dessous. Vous pouvez voir comment l'entropie croisée diminue.

9.8893
1.68918
0.602403
0.261183
0.0490791
0.0525591
0.0133087
0.0121071
0.00673524
0.00580989

Code source

Vous pouvez télécharger et exécuter le code source à partir des référentiels suivants.

• PyFaceRecognizer

en conclusion

J'ai essayé la reconnaissance faciale sur un ensemble de données de visage existant à l'aide d'un réseau neuronal convolutif. Ensuite, j'aimerais essayer la détection de visage et la reconnaissance de visage à l'aide d'images acquises en temps réel depuis la caméra.

Matériel de référence

• Tutoriel TensorFlow
• [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 & mots-clés =% E6% B7 % B1% E5% B1% A4% E5% AD% A6% E7% BF% 92)