Zuvor habe ich versucht, den MNIST-Code zu lesen, um die Verarbeitung von TensorFlow zu verstehen, aber es ist immerhin ein Bild, also möchte ich CNN. Also habe ich einen Faltungsprozess hinzugefügt. Die Referenz lautet natürlich "Deep MNIST for Experts", aber hier / 25.02.15 3000) wurde ebenfalls als Referenz verwendet.

Faltvorgang

Wenden Sie einen n × n-Filter an. Für diejenigen, die Bildverarbeitung betreiben, ist es sehr vertraut, da es Kanten extrahiert und unscharf gemacht hat.

Die verwendete Funktion ist "tensorflow.nn.conv2d ()", und es müssen hauptsächlich vier Argumente festgelegt werden. Das erste sind Eingabedaten. Der zweite ist der Filter (vertikale Größe, horizontale Größe, Anzahl der Eingangskanäle, Anzahl der Ausgangskanäle). Der dritte ist ein bewegender Schritt. Die vierte ist die Polstereinstellung.

Normalerweise ist es so eingestellt.

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

Da es sich bei den MNIST-Daten um ein 28 x 28-Bild handelt, das auf eine Dimension gestreckt ist, wird es zunächst auf 28 x 28 wiederhergestellt. Als nächstes setze ich einen 5x5 Filter. Da der Eingang ein Schwarzweißbild ist, hat er 1 Kanal und der Ausgang 32 Kanäle.

Zusätzlich wird während des Faltungsprozesses ReLU als Aktivierungsfunktion verwendet, sodass die letzte Zeile tatsächlich ist

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)

Es wird so sein. ("W_conv1" und "b_conv1" sind Gewichtungsparameter, die durch Fehlerrückübertragung angepasst wurden.)

Pooling-Prozess

Der Pooling-Prozess wird normalerweise mit dem Faltungsprozess gepaart. Dies ist ein Bild, das die Bildgröße reduziert. (Finden Sie den repräsentativen Wert von n × n) Es gibt verschiedene Methoden wie Durchschnittswert und Medienwert, aber in Deep Learning wird häufig der Maximalwert "Max Poolong" verwendet.

TensorFlow verwendet "tensorflow.nn.max_pool ()". Es sind vier Hauptargumente zu setzen. Das erste sind Eingabedaten. Der zweite ist ein Filter. Der dritte ist ein bewegender Schritt. Die vierte ist die Polstereinstellung. Es ist ähnlich wie beim Falten, nicht wahr?

Der eigentliche Code sieht so aus.

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

Die Eingabe ist das Ergebnis des Faltungsprozesses. Die Größe des Filters beträgt 2x2, und der Schritt wird auch vertikal und horizontal um 2 Pixel verschoben. Dadurch wird die Größe des fertigen Bildes auf die Hälfte der Originalgröße reduziert. (Die Anzahl der Kanäle ändert sich nicht)

Für die vollständige Join-Verarbeitung

Da der Faltungsprozess und der Pooling-Prozess als zweidimensionales Bild verarbeitet werden, werden sie bei vollständiger Kombination in ein eindimensionales Bild konvertiert. Beachten Sie zu diesem Zeitpunkt, dass die Größe des Arrays nur eingestellt werden kann, wenn die Bildgröße und die Anzahl der Kanäle richtig bekannt sind. Die Funktion verwendet "tensorflow.reshape ()" auf dieselbe Weise wie beim Wechsel von 1D zu 2D.

Bonus

Es gibt einige Teile, die ich noch nicht erklärt habe, aber ich werde den Quellcode veröffentlichen, der funktioniert (sollte).

Bitte beachten Sie, dass Sie ab dem 21. März 2017 nicht mehr auf die Site zugreifen können, auf der sich der MNIST-Datensatz befindet.

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

#Ursprüngliche Funktionen
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')

#Hauptfunktion
def main():
    #Holen Sie sich den Datensatz
    #(Geben Sie nun den zuvor heruntergeladenen Zip-Ordner an.)
    mnist = input_data.read_data_sets("MNIST_data", one_hot=True)

    #Vorbereitung der Eingabe- / Ausgabedaten
    x = tf.placeholder(tf.float32, [None, 784])
    y_ = tf.placeholder(tf.float32, [None, 10])
    x_image = tf.reshape(x, [-1, 28, 28, 1])

    #Faltvorgang(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)

    #Pooling-Prozess(1)
    h_pool1 = max_pool_2x2(h_conv1)

    #Faltvorgang(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)

    #Pooling-Prozess(2)
    h_pool2 = max_pool_2x2(h_conv2)

    #Vollständige Join-Verarbeitung
    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)

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

    #Identifizierung (warum es keinen Softmax gibt, ist ein Rätsel)
    W_fc2 = weight_variable([1024, 10])
    b_fc2 = bias_variable([10])
    y_conv = tf.matmul(h_fc1_drop, W_fc2) + b_fc2

    #Bewertungsprozess (aus irgendeinem Grund gibt es hier Softmax)
    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))

    #Erstellen Sie eine Sitzung
    sess = tf.InteractiveSession()
    tf.global_variables_initializer().run()

    #Ausbildung
    for i in range(20000):
        #Die Chargengröße beträgt 50
        batch = mnist.train.next_batch(50)
        #Fortschrittsanzeige alle 100 Male
        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})

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

#Starten Sie die Verarbeitung
if __name__ == "__main__":
    main()

Danach muss ich den Dropout- und Evaluierungsprozess schreiben. .. .. (Bewertungsprozess, ich bin nicht sicher ^^;)

[PYTHON] Faltung zu MNIST hinzufügen

Faltvorgang

Pooling-Prozess

Für die vollständige Join-Verarbeitung

Bonus