Auparavant, j'ai essayé de lire le code MNIST pour comprendre le traitement de TensorFlow, mais après tout c'est une image, donc je veux CNN. Donc, j'ai ajouté un processus de convolution. Bien sûr, la référence est "Deep MNIST for Experts", mais ici / 25/02/15 3000) a également été utilisée comme référence.

Processus de pliage

Appliquez un filtre n × n. Les personnes qui font du traitement d'image le connaissent très bien car il a extrait et estompé les bords.

La fonction utilisée est "tensorflow.nn.conv2d ()", et il y a principalement quatre arguments à définir. Le premier concerne les données d'entrée. Le second est le filtre (taille verticale, taille horizontale, nombre de canaux d'entrée, nombre de canaux de sortie). Le troisième est un pas en mouvement. Le quatrième est le paramètre de remplissage.

Normalement, c'est réglé comme ça.

x = tensorflow.placeholder(tf.float32, [None, 784])
x_image = tensorflow.reshape(x, [-1, 28, 28, 1])
initial = tensorflow.truncated_normal([5, 5, 1, 32], stddev=0.1)
W_conv1 = tensorflow.Variable(initial)
h_conv1 = tensorflow.nn.conv2d(x_image,
                               W_conv1,
                               strides=[1, 1, 1, 1],
                               padding='SAME')

Étant donné que les données MNIST sont une image 28x28 étirée à une dimension, elles sont d'abord restaurées en 28x28. Ensuite, j'ai défini un filtre 5x5. Puisque l'entrée est une image en noir et blanc, elle a 1 canal et la sortie est 32 canaux.

De plus, pendant le processus de convolution, ReLU est utilisé comme fonction d'activation, donc la dernière ligne est en fait

initial = tensorflow.constant(0.1, [32])
b_conv1 = tensorflow.Variable(initial)
h_conv1 = tensorflow.nn.relu(tensorflow.nn.conv2d(x_image,
                                                  W_conv1,
                                                  strides=[1, 1, 1, 1],
                                                  padding='SAME')
                             + b_conv1)

Ce sera comme ça. ("W_conv1" et "b_conv1" sont des paramètres de poids ajustés par propagation de retour d'erreur)

Processus de mise en commun

Le processus de mise en commun est généralement associé au processus de convolution. C'est une image qui réduit la taille de l'image. (Trouvez la valeur représentative de n × n) Il existe différentes méthodes telles que la valeur moyenne et la valeur du média, mais dans Deep Learning, la valeur maximale appelée "Max Poolong" est souvent utilisée.

TensorFlow utilise "tensorflow.nn.max_pool ()". Il y a quatre arguments principaux à définir. Le premier concerne les données d'entrée. Le second est un filtre. Le troisième est un pas en mouvement. Le quatrième est le paramètre de remplissage. C'est similaire au processus de pliage, n'est-ce pas?

Le code réel ressemble à ceci.

h_pool1 = tensorflow.nn.max_pool(h_conv1,
                                 ksize=[1, 2, 2, 1],
                                 strides=[1, 2, 2, 1],
                                 padding='SAME')

L'entrée est le résultat du processus de convolution. La taille du filtre est de 2x2 et la foulée est également déplacée de 2 pixels verticalement et horizontalement. Cela réduira la taille de l'image finie à la moitié de la taille originale. (Le nombre de canaux ne change pas)

Pour le traitement des jointures complètes

De plus, puisque le processus de convolution et le processus de mise en commun sont traités comme une image bidimensionnelle, ils sont convertis en unidimensionnel lorsqu'ils sont entièrement combinés. À ce stade, veuillez noter que la taille du tableau ne peut être définie que si la taille de l'image et le nombre de canaux sont correctement connus. La fonction utilise "tensorflow.reshape ()" de la même manière que lors du passage de 1D à 2D.

prime

Il y a certaines parties que je n'ai pas encore expliquées, mais je posterai le code source qui fonctionne (devrait).

Veuillez noter qu'à compter du 21 mars 2017, vous ne pourrez plus accéder au site où se trouve le jeu de données MNIST.

from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf

#Fonctions originales
def weight_variable(shape):
    initial = tf.truncated_normal(shape, stddev=0.1)
    return tf.Variable(initial)

def bias_variable(shape):
    initial = tf.constant(0.1, shape=shape)
    return tf.Variable(initial)

def conv2d(x, W):
    return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')

def max_pool_2x2(x):
    return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],
                          strides=[1, 2, 2, 1], padding='SAME')

#Fonction principale
def main():
    #Obtenez l'ensemble de données
    #(Maintenant, spécifiez le dossier zip qui a été téléchargé à l'avance)
    mnist = input_data.read_data_sets("MNIST_data", one_hot=True)

    #Préparation des données d'entrée / sortie
    x = tf.placeholder(tf.float32, [None, 784])
    y_ = tf.placeholder(tf.float32, [None, 10])
    x_image = tf.reshape(x, [-1, 28, 28, 1])

    #Processus de pliage(1)
    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)

    #Processus de mise en commun(1)
    h_pool1 = max_pool_2x2(h_conv1)

    #Processus de pliage(2)
    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)

    #Processus de mise en commun(2)
    h_pool2 = max_pool_2x2(h_conv2)

    #Traitement de jointure complète
    W_fc1 = weight_variable([7 * 7 * 64, 1024])
    b_fc1 = bias_variable([1024])
    h_pool2_flat = tf.reshape(h_pool2, [-1, 7 * 7 * 64])
    h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)

    #Abandonner
    keep_prob = tf.placeholder(tf.float32)
    h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)

    #Identification (pourquoi il n'y a pas de softmax est un mystère)
    W_fc2 = weight_variable([1024, 10])
    b_fc2 = bias_variable([10])
    y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2

    #Processus d'évaluation (pour une raison quelconque, il y a softmax ici)
    cross_entropy = tf.reduce_mean(
        tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y_conv))
    train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)
    correct_prediction = tf.equal(tf.argmax(y_conv, 1), tf.argmax(y_, 1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

    #Créer une session
    sess = tf.InteractiveSession()
    tf.global_variables_initializer().run()

    #entraînement
    for i in range(20000):
        #La taille du lot est de 50
        batch = mnist.train.next_batch(50)
        #Affichage de la progression toutes les 100 fois
        if i%100 == 0:
            train_accuracy = accuracy.eval(feed_dict={
                x:batch[0], y_: batch[1], keep_prob: 1.0})
            print("step %d, training accuracy %g"%(i, train_accuracy))
        train_step.run(feed_dict={x: batch[0], y_: batch[1], keep_prob: 0.5})

    #Affichage des résultats
    print("test accuracy %g"%accuracy.eval(feed_dict={
        x: mnist.test.images, y_: mnist.test.labels, keep_prob: 1.0}))

#Commencer le traitement
if __name__ == "__main__":
    main()

Après cela, je dois rédiger le processus de décrochage et d'évaluation. .. .. (Processus d'évaluation, je ne suis pas sûr ^^;)

Ajouter une convolution à MNIST

Processus de pliage

Processus de mise en commun

Pour le traitement des jointures complètes

prime