TensorFlow - Réseaux de neurones récurrents

Les réseaux de neurones récurrents sont un type d'algorithme axé sur l'apprentissage en profondeur, qui suit une approche séquentielle. Dans les réseaux de neurones, nous supposons toujours que chaque entrée et sortie est indépendante de toutes les autres couches. Ces types de réseaux de neurones sont appelés récurrents car ils effectuent des calculs mathématiques de manière séquentielle.

Considérez les étapes suivantes pour former un réseau neuronal récurrent -

Step 1 - Saisissez un exemple spécifique à partir d'un ensemble de données.

Step 2 - Le réseau prendra un exemple et calculera certains calculs en utilisant des variables initialisées aléatoirement.

Step 3 - Un résultat prédit est ensuite calculé.

Step 4 - La comparaison du résultat réel généré avec la valeur attendue produira une erreur.

Step 5 - Pour tracer l'erreur, elle est propagée par le même chemin où les variables sont également ajustées.

Step 6 - Les étapes de 1 à 5 sont répétées jusqu'à ce que nous soyons sûrs que les variables déclarées pour obtenir la sortie sont définies correctement.

Step 7 - Une prédiction systématique est faite en appliquant ces variables pour obtenir une nouvelle entrée invisible.

L'approche schématique de la représentation des réseaux de neurones récurrents est décrite ci-dessous -

Implémentation récurrente de réseau neuronal avec TensorFlow

Dans cette section, nous allons apprendre à implémenter un réseau neuronal récurrent avec TensorFlow.

Step 1 - TensorFlow comprend diverses bibliothèques pour une implémentation spécifique du module de réseau neuronal récurrent.

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

Comme mentionné ci-dessus, les bibliothèques aident à définir les données d'entrée, qui constituent la partie principale de la mise en œuvre récurrente du réseau neuronal.

Step 2- Notre motivation principale est de classer les images à l'aide d'un réseau neuronal récurrent, où nous considérons chaque ligne d'image comme une séquence de pixels. La forme de l'image MNIST est spécifiquement définie comme 28 * 28 px. Nous allons maintenant gérer 28 séquences de 28 étapes pour chaque échantillon mentionné. Nous définirons les paramètres d'entrée pour obtenir le motif séquentiel.

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- Calculez les résultats en utilisant une fonction définie dans RNN pour obtenir les meilleurs résultats. Ici, chaque forme de données est comparée à la forme d'entrée actuelle et les résultats sont calculés pour maintenir le taux de précision.

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- Dans cette étape, nous allons lancer le graphe pour obtenir les résultats du calcul. Cela aide également à calculer la précision des résultats des tests.

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

Les captures d'écran ci-dessous montrent la sortie générée -