Ajouter une convolution à MNIST

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. 20161226145014.png

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. relu.png ("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) filter.png 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. 20150126055504.png

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

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 ^^;)

Recommended Posts

Ajouter une convolution à MNIST
Ajouter / supprimer un noyau à JupyterLab
Ajouter un dictionnaire à MeCab
Ajouter un numéro de page au PDF
Ajouter un dictionnaire utilisateur à MeCab
Pour ajouter un module C à MicroPython ...
Ajouter des champs à des entités avec ArcPy
Ajouter le ratio cumulatif à l'histogramme matplotlib
Python 2.7 Ajout de la documentation japonaise à Dash.app
Comment ajouter sudo lors de l'exécution du débogage
Ajouter des paramètres aux commandes personnalisées de Django
Comment ajouter un volume AWS EBS
Ajouter le niveau de journal TRACE à Python ...?
Ajouter des utilisateurs connectables SSH à EC2
Solution de contournement si vous ne pouvez pas ajouter à LD_LIBRARY_PATH
Ajoutez une carte GPIO à votre ordinateur. (1)
Ajoutez votre propre vue de contenu à mitmproxy
(Pour moi) Flask_5 (Ajouter au fichier txt)
Comment ajouter un package avec PyCharm
Introduction au Deep Learning ~ Pliage et mise en commun ~
[MNIST] Convertir les données en PNG pour les keras
Dans Jupyter, ajoutez IPerl au noyau.
Ajouter des images à des photos iOS avec Pythonista
Ajouter le ratio cumulatif au graphique à barres de matplotlib
[Python] Ajouter le nombre total de lignes à Pandas DataFrame
Ajouter du bruit gaussien aux images avec python2.7
Comment ajouter un module python à l'environnement anaconda
Comment ajouter des options au serveur de runtime manage.py de Django
Ce que j'ajoute toujours à mon ~ / .bashrc
Ajouter un environnement virtuel Python à VSCode
[Python] Ajouter un commentaire au fichier d'entrée standard