Rate this post

Multi-layer Perceptron xác định kiến trúc phức tạp nhất của mạng nơ-ron nhân tạo. Về cơ bản, nó được hình thành từ nhiều lớp của perceptron. TensorFlow là một khung công tác học tập sâu rất phổ biến được phát hành và sổ tay này sẽ hướng dẫn xây dựng mạng nơ-ron với thư viện này. Nếu chúng ta muốn hiểu perceptron nhiều lớp là gì, chúng ta phải phát triển perceptron nhiều lớp từ đầu bằng cách sử dụng Numpy.

Biểu diễn bằng hình ảnh của việc học perceptron nhiều lớp như được hiển thị bên dưới-

Mạng MLP được sử dụng cho định dạng học tập có giám sát. Một thuật toán học điển hình cho mạng MLP còn được gọi là thuật toán lan truyền ngược.

Multilayer perceptron (MLP) là một mạng nơ-ron nhân tạo chuyển tiếp các dữ liệu tạo ra từ một tập hợp các dữ liệu output từ một tập hợp các input.

Các bài viết liên quan:

MLP được đặc trưng với các lớp nút đầu vào có kết nối theo dạng đồ thị có hướng giữa các input node được kết nối dưới dạng đồ thị có hướng giữa input layer và output. MLP sử dụng backpropagation để trainning . MLP là một phương pháp Deep Learning.

Bây giờ, chúng tôi đang tập trung vào việc triển khai với MLP cho vấn đề phân loại hình ảnh.

# Import MINST data   
from tensorflow.examples.tutorials.mnist import input_data   
mnist = input_data.read_data_sets("/tmp/data/", one_hot = True)   
  
import tensorflow as tf   
import matplotlib.pyplot as plt   
  
# Parameters   
learning_rate = 0.001   
training_epochs = 20   
batch_size = 100   
display_step = 1   
  
# Network Parameters   
n_hidden_1 = 256   
  
# 1st layer num features  
n_hidden_2 = 256 # 2nd layer num features   
n_input = 784 # MNIST data input (img shape: 28*28) n_classes = 10   
# MNIST total classes (0-9 digits)   
  
# tf Graph input   
x = tf.placeholder("float", [None, n_input])   
y = tf.placeholder("float", [None, n_classes])   
  
# weights layer 1   
h = tf.Variable(tf.random_normal([n_input, n_hidden_1])) # bias layer 1   
bias_layer_1 = tf.Variable(tf.random_normal([n_hidden_1]))   
# layer 1 layer_1 = tf.nn.sigmoid(tf.add(tf.matmul(x, h), bias_layer_1))   
  
# weights layer 2   
w = tf.Variable(tf.random_normal([n_hidden_1, n_hidden_2]))   
  
# bias layer 2   
bias_layer_2 = tf.Variable(tf.random_normal([n_hidden_2]))   
  
# layer 2   
layer_2 = tf.nn.sigmoid(tf.add(tf.matmul(layer_1, w), bias_layer_2))   
  
# weights output layer   
output = tf.Variable(tf.random_normal([n_hidden_2, n_classes]))   
  
# biar output layer   
bias_output = tf.Variable(tf.random_normal([n_classes])) # output layer   
output_layer = tf.matmul(layer_2, output) + bias_output  
  
# cost function   
cost = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(  
   logits = output_layer, labels = y))   
  
#cost = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(output_layer, y))   
# optimizer   
optimizer = tf.train.AdamOptimizer(learning_rate = learning_rate).minimize(cost)   
  
# optimizer = tf.train.GradientDescentOptimizer(  
   learning_rate = learning_rate).minimize(cost)   
  
# Plot settings   
avg_set = []   
epoch_set = []   
  
# Initializing the variables   
init = tf.global_variables_initializer()   
  
# Launch the graph   
with tf.Session() as sess:   
   sess.run(init)   
     
   # Training cycle  
   for epoch in range(training_epochs):   
      avg_cost = 0.   
      total_batch = int(mnist.train.num_examples / batch_size)   
        
      # Loop over all batches   
      for i in range(total_batch):   
         batch_xs, batch_ys = mnist.train.next_batch(batch_size)   
         # Fit training using batch data sess.run(optimizer, feed_dict = {  
            x: batch_xs, y: batch_ys})   
         # Compute average loss   
         avg_cost += sess.run(cost, feed_dict = {x: batch_xs, y: batch_ys}) / total_batch  
      # Display logs per epoch step   
      if epoch % display_step == 0:   
         print   
         Epoch:", '%04d' % (epoch + 1), "cost=", "{:.9f}".format(avg_cost)  
      avg_set.append(avg_cost)   
      epoch_set.append(epoch + 1)  
   print   
   "Training phase finished"   
     
   plt.plot(epoch_set, avg_set, 'o', label = 'MLP Training phase')   
   plt.ylabel('cost')   
   plt.xlabel('epoch')   
   plt.legend()   
   plt.show()   
     
   # Test model   
   correct_prediction = tf.equal(tf.argmax(output_layer, 1), tf.argmax(y, 1))   
     
   # Calculate accuracy   
   accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))   
   print   
   "Model Accuracy:", accuracy.eval({x: mnist.test.images, y: mnist.test.labels})

Dòng mã trên tạo ra đầu ra sau-

Tạo một phần tương tác

Chúng tôi có hai tùy chọn cơ bản khi sử dụng TensorFlow để chạy mã của chúng tôi:

Xây dựng đồ thị và chạy các phiên [Thực hiện tất cả các thiết lập và sau đó thực hiện một phiên để thực hiện một phiên để đánh giá các tensors và chạy các hoạt động].

Tạo mã hóa của chúng tôi và chạy nhanh.

Đối với phần đầu tiên này, chúng tôi sẽ sử dụng

phiên tương tác phù hợp hơn với môi trường như máy tính xách tay Jupiter.

sess = tf.InteractiveSession ()

Tạo placeholders

Cách tốt nhất là tạo trình giữ chỗ trước các phép gán biến khi sử dụng TensorFlow. Ở đây, chúng tôi sẽ tạo trình giữ chỗ cho đầu vào (“Xs”) và đầu ra (“Ys”).

Trình giữ chỗ “X”: Đại diện cho đầu vào được phân bổ ‘không gian’ hoặc hình ảnh.

Mỗi đầu vào có 784 pixel được phân phối bởi ma trận 28 chiều rộng x 28 chiều cao.

Đối số ‘hình dạng’ xác định kích thước tensor theo các kích thước của nó.

Tensorflow

Multi-layer Perceptron trong TensorFlow

Tạo một phần tương tác

Tạo placeholders

Trả lời Hủy