TensorFlow - Redes Neurais Recorrentes

Redes neurais recorrentes são um tipo de algoritmo orientado para aprendizagem profunda, que segue uma abordagem sequencial. Em redes neurais, sempre assumimos que cada entrada e saída é independente de todas as outras camadas. Esses tipos de redes neurais são chamados de recorrentes porque executam cálculos matemáticos de maneira sequencial.

Considere as seguintes etapas para treinar uma rede neural recorrente -

Step 1 - Insira um exemplo específico do conjunto de dados.

Step 2 - A rede pegará um exemplo e calculará alguns cálculos usando variáveis inicializadas aleatoriamente.

Step 3 - Um resultado previsto é então calculado.

Step 4 - A comparação do resultado real gerado com o valor esperado produzirá um erro.

Step 5 - Para rastrear o erro, ele é propagado pelo mesmo caminho onde as variáveis também são ajustadas.

Step 6 - As etapas de 1 a 5 são repetidas até que tenhamos certeza de que as variáveis declaradas para obter a saída estão definidas corretamente.

Step 7 - Uma previsão sistemática é feita aplicando essas variáveis para obter uma nova entrada invisível.

A abordagem esquemática de representação de redes neurais recorrentes é descrita abaixo -

Implementação de rede neural recorrente com TensorFlow

Nesta seção, aprenderemos como implementar uma rede neural recorrente com o TensorFlow.

Step 1 - TensorFlow inclui várias bibliotecas para implementação específica do módulo de rede neural recorrente.

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

Conforme mencionado acima, as bibliotecas ajudam a definir os dados de entrada, que constituem a parte principal da implementação da rede neural recorrente.

Step 2- Nosso motivo principal é classificar as imagens usando uma rede neural recorrente, onde consideramos cada linha de imagem como uma sequência de pixels. O formato da imagem MNIST é especificamente definido como 28 * 28 px. Agora lidaremos com 28 sequências de 28 etapas para cada amostra mencionada. Vamos definir os parâmetros de entrada para concluir o padrão sequencial.

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- Calcule os resultados usando uma função definida no RNN para obter os melhores resultados. Aqui, cada formato de dados é comparado com o formato de entrada atual e os resultados são calculados para manter a taxa de precisão.

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- Nesta etapa, lançaremos o gráfico para obter os resultados computacionais. Isso também ajuda no cálculo da precisão dos resultados do teste.

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

As imagens abaixo mostram a saída gerada -