[PYTHON] Création, apprentissage et raisonnement de modèles d'apprentissage

introduction

• Il y a quelques années, j'ai fait un tutoriel sur MNIST CNN de TensorFlow et je l'ai laissé tranquille. C'est une histoire commune. ――Cette fois, j'ai modifié le tutoriel pour créer un modèle d'apprentissage pour les images faciales.
• La classe et la taille de l'image «10» sont les mêmes que celles du «28x28». La précision est d'environ «80%». Eh bien, c'est une pièce, donc je suis satisfait.
• La source complète est ici.

modèle

• Pour le modèle lui-même, je me suis référé à ce qui suit. --Référence: TensorFlow mnist_deep.py --num_classes ʻimg_rows ʻimg_cols utilise la valeur du fichier de configuration. Ajout de la prise en charge de la modification du nombre de classes et de la taille de l'image.

def model():
    """Modèle de référence MNIST."""

    num_classes = len(CLASSES)
    img_rows, img_cols = IMG_ROWS, IMG_COLS

    x = tf.compat.v1.placeholder(tf.float32, [None, img_rows*img_cols])

    with tf.name_scope('reshape'):
        x_image = tf.reshape(x, [-1, img_rows, img_cols, 1])

    with tf.name_scope('conv1'):
        W_conv1 = weight_variable([5, 5, 1, 32])
        b_conv1 = bias_variable([32])
        h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)

    with tf.name_scope('pool1'):
        h_pool1 = max_pool_2x2(h_conv1)

    with tf.name_scope('conv2'):
        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)

    with tf.name_scope('pool2'):
        h_pool2 = max_pool_2x2(h_conv2)

    with tf.name_scope('fc1'):
        W_fc1 = weight_variable([int(h_pool2.shape[1]) * int(h_pool2.shape[2]) * 64, 1024])
        b_fc1 = bias_variable([1024])

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

    with tf.name_scope('dropout'):
        keep_prob = tf.compat.v1.placeholder(tf.float32)
        h_fc1_drop = tf.nn.dropout(h_fc1, rate=1-keep_prob)

    with tf.name_scope('fc2'):
        W_fc2 = weight_variable([1024, num_classes])
        b_fc2 = bias_variable([num_classes])

        y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2

    return x, y_conv, keep_pro

――Ce qui suit utilise également le didacticiel.

def conv2d(x, W):
    """conv2d returns a 2d convolution layer with full stride."""
    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')


def max_pool_2x2(x):
    """max_pool_2x2 downsamples a feature map by 2X."""
    return tf.nn.max_pool2d(x, ksize=[1, 2, 2, 1], strides=[1, 2, 2, 1], padding='SAME')


def weight_variable(shape):
    """weight_variable generates a weight variable of a given shape."""
    initial = tf.random.truncated_normal(shape, stddev=0.1)
    return tf.Variable(initial)


def bias_variable(shape):
    """bias_variable generates a bias variable of a given shape."""
    initial = tf.constant(0.1, shape=shape)
    return tf.Variable(initial)

Apprentissage

Modèle d'apprentissage

――Nous rendons possible la lecture du jeu de données précédemment créé.

• De plus, la taille et l'époque du lot peuvent être modifiées.

def train(datasets, batch_size=128, epochs=12):
    """Apprentissage."""

    x, y_conv, keep_prob = model()

    y_ = tf.compat.v1.placeholder(tf.float32, [None, 10])

    with tf.name_scope('loss'):
        cross_entropy = tf.nn.softmax_cross_entropy_with_logits_v2(labels=y_, logits=y_conv)
    cross_entropy = tf.reduce_mean(cross_entropy)

    with tf.name_scope('adam_optimizer'):
        train_step = tf.compat.v1.train.AdamOptimizer(1e-4).minimize(cross_entropy)

    with tf.name_scope('accuracy'):
        correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
        correct_prediction = tf.cast(correct_prediction, tf.float32)
    accuracy = tf.reduce_mean(correct_prediction)

• Presque la même chose que le tutoriel, mais ajout de la sauvegarde du modèle.
• L'emplacement de sauvegarde est spécifié à partir du fichier de configuration.

    saver = tf.compat.v1.train.Saver()
    os.makedirs(os.path.dirname(os.path.abspath(MODEL_FILE)), exist_ok=True)

――Nous l'avons modifié à partir du tutoriel afin que la précision puisse être affichée et que le modèle puisse être enregistré pour chaque époque.

    with tf.compat.v1.Session() as sess:
        sess.run(tf.compat.v1.global_variables_initializer())

        next_epoch = 1
        print('epoch, train accuracy, test accuracy')
        while datasets.train.epochs_completed < epochs:
            train_images, train_labels = datasets.train.next_batch(batch_size)
            sess.run(train_step, feed_dict={x: train_images, y_: train_labels, keep_prob: 0.5})

            if datasets.train.epochs_completed == next_epoch:

                train_accuracy = accuracy.eval(feed_dict={x: datasets.train.images, y_: datasets.train.labels, keep_prob: 1.0})
                test_accuracy = accuracy.eval(feed_dict={x: datasets.test.images, y_: datasets.test.labels, keep_prob: 1.0})
                print('{:d}, {:.4f}, {:.4f}'.format(datasets.train.epochs_completed, train_accuracy, test_accuracy))

                saver.save(sess, MODEL_FILE)

                next_epoch = datasets.train.epochs_completed + 1

Exécution de l'apprentissage

--La formation est effectuée en spécifiant l'option --train.

• La taille du lot est "128" et l'époque est "120".

$ python face_deep.py --train
epoch, train accuracy, test accuracy
1, 0.4580, 0.4090
2, 0.5593, 0.4880
réduction
119, 1.0000, 0.8110
120, 1.0000, 0.792

inférence

inférence

• L'image doit être «numpy».
• Vous pouvez changer le type de résultat avec dtype.

def predict(images, dtype=None):
    """Le résultat de l'inférence est numpy, int,Changer argmax avec dtype."""

    tf.compat.v1.reset_default_graph()

    x, y_conv, keep_prob = model()

    with tf.compat.v1.Session() as sess:
        sess.run(tf.compat.v1.global_variables_initializer())

        saver = tf.compat.v1.train.Saver()
        saver.restore(sess, MODEL_FILE)

        results = sess.run(tf.nn.softmax(y_conv), feed_dict={x: images, keep_prob: 1.0})
        results = np.array(results * 100, dtype=np.uint8)
        if dtype == 'int':
            results = [[int(y) for y in result] for result in results]
        if dtype == 'argmax':
            results = [np.argmax(y) for y in results]

    return results

Exécuter l'inférence

• L'inférence est effectuée sans option. ――C'est le niveau de contrôle de fonctionnement jusqu'au dernier. Je pense l'utiliser à partir d'une application Web séparément.
• Ce qui suit est le résultat de l'inférence des 10 premières séquences de l'image de test de l'ensemble de données. Les premières centaines sont étiquetées «0», elles semblent donc correspondre.

$ python face_deep.py
réduction
[[100   0   0   0   0   0   0   0   0   0]
 [ 99   0   0   0   0   0   0   0   0   0]
 [ 99   0   0   0   0   0   0   0   0   0]
 [  0  99   0   0   0   0   0   0   0   0]
 [ 99   0   0   0   0   0   0   0   0   0]
 [ 97   0   0   0   0   0   0   0   0   1]
 [ 99   0   0   0   0   0   0   0   0   0]
 [  0  99   0   0   0   0   0   0   0   0]
 [ 99   0   0   0   0   0   0   0   0   0]
 [ 36  63   0   0   0   0   0   0   0   0]]

en conclusion

--Modification du tutoriel MNIST CNN de TensorFlow pour apprendre et déduire les images faciales. «Puisqu'il s'agit d'un niveau d'étude, il suffisait de pouvoir effectuer l'apprentissage et le raisonnement. ―― La prochaine fois, j'essaierai d'effectuer des inférences à partir de l'application Web Flask.