TensorFlow - Wiederkehrende neuronale Netze
Wiederkehrende neuronale Netze sind eine Art Deep-Learning-orientierter Algorithmus, der einem sequentiellen Ansatz folgt. In neuronalen Netzen gehen wir immer davon aus, dass jeder Ein- und Ausgang unabhängig von allen anderen Schichten ist. Diese Art von neuronalen Netzen wird als wiederkehrend bezeichnet, da sie sequentielle mathematische Berechnungen durchführen.
Betrachten Sie die folgenden Schritte, um ein wiederkehrendes neuronales Netzwerk zu trainieren:
Step 1 - Geben Sie ein bestimmtes Beispiel aus dem Datensatz ein.
Step 2 - Das Netzwerk nimmt ein Beispiel und berechnet einige Berechnungen mit zufällig initialisierten Variablen.
Step 3 - Ein vorhergesagtes Ergebnis wird dann berechnet.
Step 4 - Der Vergleich des tatsächlich generierten Ergebnisses mit dem erwarteten Wert führt zu einem Fehler.
Step 5 - Um den Fehler zu verfolgen, wird er über denselben Pfad weitergegeben, in dem auch die Variablen angepasst werden.
Step 6 - Die Schritte von 1 bis 5 werden wiederholt, bis wir sicher sind, dass die Variablen, die zum Abrufen der Ausgabe deklariert wurden, richtig definiert sind.
Step 7 - Eine systematische Vorhersage wird durchgeführt, indem diese Variablen angewendet werden, um neue unsichtbare Eingaben zu erhalten.
Der schematische Ansatz zur Darstellung wiederkehrender neuronaler Netze wird nachstehend beschrieben -
Wiederkehrende Implementierung eines neuronalen Netzwerks mit TensorFlow
In diesem Abschnitt erfahren Sie, wie Sie ein wiederkehrendes neuronales Netzwerk mit TensorFlow implementieren.
Step 1 - TensorFlow enthält verschiedene Bibliotheken für die spezifische Implementierung des wiederkehrenden neuronalen Netzwerkmoduls.
#Import necessary modules
from __future__ import print_function
import tensorflow as tf
from tensorflow.contrib import rnn
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("/tmp/data/", one_hot = True)
Wie oben erwähnt, helfen die Bibliotheken bei der Definition der Eingabedaten, die den Hauptteil der wiederkehrenden Implementierung eines neuronalen Netzwerks bilden.
Step 2- Unser Hauptmotiv besteht darin, die Bilder mithilfe eines wiederkehrenden neuronalen Netzwerks zu klassifizieren, wobei wir jede Bildzeile als eine Folge von Pixeln betrachten. Die MNIST-Bildform ist speziell als 28 * 28 px definiert. Jetzt werden wir 28 Sequenzen von 28 Schritten für jede erwähnte Probe behandeln. Wir werden die Eingabeparameter definieren, um das sequentielle Muster fertigzustellen.
n_input = 28 # MNIST data input with img shape 28*28
n_steps = 28
n_hidden = 128
n_classes = 10
# tf Graph input
x = tf.placeholder("float", [None, n_steps, n_input])
y = tf.placeholder("float", [None, n_classes]
weights = {
'out': tf.Variable(tf.random_normal([n_hidden, n_classes]))
}
biases = {
'out': tf.Variable(tf.random_normal([n_classes]))
}
Step 3- Berechnen Sie die Ergebnisse mit einer in RNN definierten Funktion, um die besten Ergebnisse zu erzielen. Hier wird jede Datenform mit der aktuellen Eingabeform verglichen und die Ergebnisse werden berechnet, um die Genauigkeitsrate aufrechtzuerhalten.
def RNN(x, weights, biases):
x = tf.unstack(x, n_steps, 1)
# Define a lstm cell with tensorflow
lstm_cell = rnn.BasicLSTMCell(n_hidden, forget_bias=1.0)
# Get lstm cell output
outputs, states = rnn.static_rnn(lstm_cell, x, dtype = tf.float32)
# Linear activation, using rnn inner loop last output
return tf.matmul(outputs[-1], weights['out']) + biases['out']
pred = RNN(x, weights, biases)
# Define loss and optimizer
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits = pred, labels = y))
optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cost)
# Evaluate model
correct_pred = tf.equal(tf.argmax(pred,1), tf.argmax(y,1))
accuracy = tf.reduce_mean(tf.cast(correct_pred, tf.float32))
# Initializing the variables
init = tf.global_variables_initializer()
Step 4- In diesem Schritt starten wir das Diagramm, um die Berechnungsergebnisse zu erhalten. Dies hilft auch bei der Berechnung der Genauigkeit für Testergebnisse.
with tf.Session() as sess:
sess.run(init)
step = 1
# Keep training until reach max iterations
while step * batch_size < training_iters:
batch_x, batch_y = mnist.train.next_batch(batch_size)
batch_x = batch_x.reshape((batch_size, n_steps, n_input))
sess.run(optimizer, feed_dict={x: batch_x, y: batch_y})
if step % display_step == 0:
# Calculate batch accuracy
acc = sess.run(accuracy, feed_dict={x: batch_x, y: batch_y})
# Calculate batch loss
loss = sess.run(cost, feed_dict={x: batch_x, y: batch_y})
print("Iter " + str(step*batch_size) + ", Minibatch Loss= " + \
"{:.6f}".format(loss) + ", Training Accuracy= " + \
"{:.5f}".format(acc))
step += 1
print("Optimization Finished!")
test_len = 128
test_data = mnist.test.images[:test_len].reshape((-1, n_steps, n_input))
test_label = mnist.test.labels[:test_len]
print("Testing Accuracy:", \
sess.run(accuracy, feed_dict={x: test_data, y: test_label}))
Die folgenden Screenshots zeigen die generierte Ausgabe -