Rate this post

Hidden Layer là một mạng nơ-ron nhân tạo là một lớp nằm giữa các lớp đầu vào và lớp đầu ra. Nơi các tế bào thần kinh nhân tạo tiếp nhận một tập hợp các đầu vào có trọng số và tạo ra đầu ra thông qua một chức năng kích hoạt. Nó là một phần của gần và thần kinh, trong đó các kỹ sư mô phỏng các loại hoạt động diễn ra trong não người.

Mạng nơ-ron ẩn được thiết lập trong một số kỹ thuật. Trong nhiều trường hợp, các đầu vào có trọng số được chỉ định ngẫu nhiên. Mặt khác, chúng được tinh chỉnh và hiệu chỉnh thông qua một quá trình được gọi là nhân giống ngược.

Các bài viết liên quan:

Tế bào thần kinh nhân tạo trong lớp ẩn của tế bào cảm thụ hoạt động như một tế bào thần kinh sinh học trong não – nó nhận các tín hiệu đầu vào xác suất và hoạt động trên chúng. Và nó chuyển đổi chúng thành một đầu ra tương ứng với sợi trục của nơ-ron sinh học.

Các lớp sau lớp đầu vào được gọi là ẩn vì chúng được phân giải trực tiếp đến đầu vào. Cấu trúc mạng đơn giản nhất là có một nơ-ron duy nhất trong lớp ẩn trực tiếp xuất ra giá trị.

Học sâu có thể đề cập đến việc có nhiều lớp ẩn trong mạng nơ-ron của chúng ta. Chúng rất sâu vì chúng sẽ chậm không thể tưởng tượng được để huấn luyện trong lịch sử, nhưng có thể mất vài giây hoặc vài phút để chuẩn bị bằng cách sử dụng các kỹ thuật và phần cứng hiện đại.

Một lớp ẩn duy nhất sẽ xây dựng một mạng đơn giản.

Mã cho các lớp ẩn của perceptron được hiển thị bên dưới:

#Importing the essential modules in the hidden layer  
import tensorflow as tf   
import numpy as np   
import mat  
plotlib.pyplot as plt   
import math, random   
  
  
  
np.random.seed(1000)   
function_to_learn = lambda x: np.cos(x) + 0.1*np.random.randn(*x.shape)   
layer_1_neurons = 10   
NUM_points = 1000   
  
#Train the parameters of hidden layer  
batch_size = 100   
NUM_EPOCHS = 1500   
  
all_x = np.float32(np.random.uniform(-2*math.pi, 2*math.pi, (1, NUM_points))).T   
   np.random.shuffle(all_x)   
  
train_size = int(900)   
#Train the first 700 points in the set x_training = all_x[:train_size]  
y_training = function_to_learn(x_training)  
  
#Training the last 300 points in the given set x_validation = all_x[train_size:]   
y_validation = function_to_learn(x_validation)   
  
plt.figure(1)   
plt.scatter(x_training, y_training, c = 'blue', label = 'train')   
plt.scatter(x_validation, y_validation, c = 'pink', label = 'validation')   
plt.legend()   
plt.show()  
  
X = tf.placeholder(tf.float32, [None, 1], name = "X")  
Y = tf.placeholder(tf.float32, [None, 1], name = "Y")  
  
#first layer   
#Number of neurons = 10   
w_h = tf.Variable(  
   tf.random_uniform([1, layer_1_neurons],\ minval = -1, maxval = 1, dtype = tf.float32))   
b_h = tf.Variable(tf.zeros([1, layer_1_neurons], dtype = tf.float32))   
h = tf.nn.sigmoid(tf.matmul(X, w_h) + b_h)  
  
#output layer   
#Number of neurons = 10   
w_o = tf.Variable(  
   tf.random_uniform([layer_1_neurons, 1],\ minval = -1, maxval = 1, dtype = tf.float32))   
b_o = tf.Variable(tf.zeros([1, 1], dtype = tf.float32))   
  
#building the model  
model = tf.matmul(h, w_o) + b_o   
  
#minimize the cost function (model - Y)   
train_op = tf.train.AdamOptimizer().minimize(tf.nn.l2_loss(model - Y))   
  
#Starting the Learning phase  
sess = tf.Session() sess.run(tf.initialize_all_variables())   
  
errors = []   
for i in range(NUM_EPOCHS):   
   for start, end in zip(range(0, len(x_training), batch_size),\   
      range(batch_size, len(x_training), batch_size)):   
      sess.run(train_op, feed_dict = {X: x_training[start:end],\ Y: y_training[start:end]})  
   cost = sess.run(tf.nn.l2_loss(model - y_validation),\ feed_dict = {X:x_validation})   
   errors.append(cost)   
     
   if i%100 == 0:   
      print("epoch %d, cost = %g" % (i, cost))   
        
plt.plot(errors,label='MLP Function Approximation') plt.xlabel('epochs')   
plt.ylabel('cost')   
plt.legend()   
plt.show()

Output

Sau đây là minh họa về xấp xỉ lớp chức năng-