TensorFlow - Mạng thần kinh tái diễn

Mạng nơ-ron tuần hoàn là một loại thuật toán hướng đến học sâu, theo cách tiếp cận tuần tự. Trong mạng nơ-ron, chúng ta luôn giả định rằng mỗi đầu vào và đầu ra là độc lập với tất cả các lớp khác. Loại mạng nơ-ron này được gọi là mạng tái phát vì chúng thực hiện các phép tính toán học theo cách tuần tự.

Hãy xem xét các bước sau để đào tạo một mạng nơ-ron tuần hoàn:

Step 1 - Nhập một ví dụ cụ thể từ tập dữ liệu.

Step 2 - Mạng sẽ lấy một ví dụ và tính toán một số phép tính bằng cách sử dụng các biến được khởi tạo ngẫu nhiên.

Step 3 - Một kết quả dự đoán sau đó được tính toán.

Step 4 - Việc so sánh kết quả thực tế được tạo ra với giá trị mong đợi sẽ tạo ra lỗi.

Step 5 - Để theo dõi lỗi, nó được truyền thông qua cùng một đường dẫn nơi các biến cũng được điều chỉnh.

Step 6 - Các bước từ 1 đến 5 được lặp lại cho đến khi chúng ta tin chắc rằng các biến được khai báo để lấy đầu ra được định nghĩa đúng.

Step 7 - Một dự đoán có hệ thống được thực hiện bằng cách áp dụng các biến này để có được đầu vào mới chưa từng thấy.

Cách tiếp cận giản đồ của việc biểu diễn các mạng nơ-ron lặp lại được mô tả dưới đây:

Triển khai mạng thần kinh định kỳ với TensorFlow

Trong phần này, chúng ta sẽ học cách triển khai mạng nơ-ron tuần hoàn với TensorFlow.

Step 1 - TensorFlow bao gồm các thư viện khác nhau để triển khai cụ thể mô-đun mạng nơ-ron tuần hoàn.

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

Như đã đề cập ở trên, các thư viện giúp xác định dữ liệu đầu vào, dữ liệu này tạo thành phần chính của việc triển khai mạng nơ-ron tuần hoàn.

Step 2- Động cơ chính của chúng tôi là phân loại hình ảnh bằng cách sử dụng mạng nơ-ron tuần hoàn, nơi chúng tôi coi mỗi hàng hình ảnh là một chuỗi pixel. Hình dạng hình ảnh MNIST được xác định cụ thể là 28 * 28 px. Bây giờ chúng ta sẽ xử lý 28 chuỗi gồm 28 bước cho mỗi mẫu được đề cập. Chúng tôi sẽ xác định các tham số đầu vào để hoàn thành mẫu tuần tự.

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- Tính toán kết quả bằng một hàm xác định trong RNN để có kết quả tốt nhất. Tại đây, mỗi hình dạng dữ liệu được so sánh với hình dạng đầu vào hiện tại và kết quả được tính toán để duy trì tỷ lệ chính xác.

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- Ở bước này, chúng ta sẽ khởi chạy đồ thị để lấy kết quả tính toán. Điều này cũng giúp tính toán độ chính xác cho kết quả thử nghiệm.

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

Ảnh chụp màn hình bên dưới cho thấy kết quả được tạo -