Rate this post

Perceptron là một đơn vị xử lý duy nhất của bất kỳ mạng nơron nào. Frank Rosenblatt đề xuất lần đầu tiên vào năm 1958 là một nơ-ron đơn giản được sử dụng để phân loại đầu vào của nó thành một hoặc hai loại. Perceptron là một bộ phân loại tuyến tính và được sử dụng trong học tập có giám sát. Nó giúp tổ chức dữ liệu đầu vào nhất định.

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

Perceptron là một đơn vị mạng nơ-ron thực hiện tính toán chính xác để phát hiện các tính năng trong dữ liệu đầu vào. Perceptron chủ yếu được sử dụng để phân loại dữ liệu thành hai phần. Do đó, nó còn được gọi là Bộ phân loại nhị phân tuyến tính.

Perceptron sử dụng hàm bước trả về +1 nếu tổng trọng số của đầu vào của nó là 0 và -1.

Hàm kích hoạt được sử dụng để ánh xạ đầu vào giữa giá trị cần thiết như (0, 1) hoặc (-1, 1).

Một mạng nơ-ron thông thường trông giống như sau:

Perceptron bao gồm 4 phần.

Input value hoặc One input layer: Lớp đầu vào của perceptron được tạo ra từ các nơ-ron đầu vào nhân tạo và đưa dữ liệu ban đầu vào hệ thống để xử lý thêm.

Weights và Bias:

Weights : Nó thể hiện kích thước hoặc độ bền của kết nối giữa các đơn vị. Nếu trọng số từ nút 1 đến nút 2 có số lượng lớn hơn, thì nơron 1 có ảnh hưởng đáng kể hơn đến nơron.

Bias: Nó giống như số chặn được thêm vào trong một phương trình tuyến tính. Nó là một tham số bổ sung có nhiệm vụ sửa đổi đầu ra cùng với tổng trọng số của đầu vào cho nơ-ron khác.

Net sum: Nó tính tổng tổng.

Activation Function: Một neuron có thể được kích hoạt hay không, được xác định bởi một chức năng kích hoạt. Hàm kích hoạt tính tổng có trọng số và thêm độ lệch với nó để đưa ra kết quả.

Một mạng nơ-ron tiêu chuẩn trông giống như sơ đồ dưới đây.

Làm thế nào nó hoạt động?

Perceptron hoạt động theo các bước đơn giản sau:

  1. Trong bước đầu tiên, tất cả các đầu vào x được nhân với trọng số của chúng là w.
  1. Trong bước này, hãy thêm tất cả các giá trị tăng lên và gọi chúng là Tổng có trọng số.
  1. Trong bước cuối cùng của chúng tôi, hãy áp dụng tổng có trọng số cho một Hàm kích hoạt chính xác.

Ví dụ:

Chức năng kích hoạt bước đơn vị

Có hai kiểu kiến ​​trúc. Các loại này tập trung vào chức năng của mạng nơ-ron nhân tạo như sau:

  • Single Layer Perceptron
  • Multi-Layer Perceptron

Single Layer Perceptron

Single Layer Perceptron là mô hình mạng nơ-ron đầu tiên, được đề xuất vào năm 1958 bởi Frank Rosenbluth. Nó là một trong những mô hình sớm nhất cho việc học tập. Mục tiêu của chúng tôi là tìm một hàm quyết định tuyến tính được đo bằng vectơ trọng số w và tham số thiên vị b.

Để hiểu lớp perceptron, cần phải hiểu các mạng nơ-ron nhân tạo (ANN).

Mạng nơ-ron nhân tạo (ANN) là một hệ thống xử lý thông tin, có cơ chế được lấy cảm hứng từ chức năng của các mạch thần kinh sinh học. Một mạng nơ-ron nhân tạo bao gồm một số đơn vị xử lý được kết nối với nhau.

Đây là đề xuất đầu tiên khi mô hình nơ-ron được xây dựng. Nội dung của bộ nhớ cục bộ của nơ-ron chứa một vectơ trọng lượng.

Perceptron vectơ đơn được tính bằng cách tính tổng của vectơ đầu vào nhân với phần tử tương ứng của vectơ, với mỗi lần tăng lượng thành phần tương ứng của vectơ theo trọng số. Giá trị được hiển thị trong đầu ra là đầu vào của một chức năng kích hoạt.

Chúng ta hãy tập trung vào việc triển khai Single Layer Perceptron cho vấn đề phân loại hình ảnh bằng cách sử dụng TensorFlow. Ví dụ tốt nhất về việc vẽ Single Layer Perceptron là thông qua biểu diễn của “hồi quy logistic”.

Bây giờ, Chúng ta phải thực hiện các bước cần thiết sau để đào tạo hồi quy logistic-

Các trọng số được khởi tạo với các giá trị ngẫu nhiên tại nơi bắt đầu của mỗi lần huấn luyện.

Đối với mỗi phần tử của tập huấn luyện, sai số được tính toán với sự khác biệt giữa đầu ra mong muốn và đầu ra thực tế. Sai số tính toán được dùng để điều chỉnh trọng lượng.

Quá trình được lặp lại cho đến khi lỗi thực hiện trên toàn bộ tập huấn luyện nhỏ hơn giới hạn quy định cho đến khi đạt đến số lần lặp tối đa.

Mã hoàn chỉnh của Perceptron lớp đơn

# Import the MINST dataset  
from tensorflow.examples.tutorials.mnist import input_data   
mnist = input_data.read_data_ ("/tmp/data/", one_hot=True)  
  
import tensorflow as tf   
import matplotlib.pyplot as plt   
# Parameters   
learning_rate = 0.01   
training_epochs = 25   
batch_size = 100   
display_step = 1   
  
# tf Graph Input   
x = tf.placeholder("float", [none, 784]) # MNIST data image of shape 28*28 = 784   
y = tf.placeholder("float", [none, 10]) # 0-9 digits recognition => 10 classes   
# Create model   
# Set model weights   
W = tf.Variable(tf.zeros([784, 10]))   
b = tf.Variable(tf.zeros([10]))   
# Constructing the model  
activation=tf.nn.softmaxx(tf.matmul (x, W)+b) # Softmax  
 of function   
# Minimizing error using cross entropy  
cross_entropy = y*tf.log(activation)   
cost = tf.reduce_mean\ (-tf.reduce_sum\ (cross_entropy, reduction_indice = 1))  
optimizer = tf.train.GradientDescentOptimizer(learning_rate).minimize(cost)  
#Plot settings   
avg_set = []   
epoch_set = []   
# Initializing the variables where init = tf.initialize_all_variables()  
# Launching the graph  
with tf.Session() as sess:  
   sess.run(init)  
     
# Training of the cycle in  the dataset  
   for epoch in range(training_epochs):  
      avg_cost = 0.  
      total_batch = int(mnist.train.num_example/batch_size)  
        
# Creating loops at all the batches in the code  
      for i in range(total_batch):  
batch_xs, batch_ys = mnist.train.next_batch(batch_size)  
         # Fitting the training by the batch data sess.run(optimizr,  feed_dict = {  
x: batch_xs, y: batch_ys})  
 # Compute all the average of loss avg_cost += sess.run(cost, \ feed_dict = {  
x: batch_xs, \ y: batch_ys}) //total batch  
      # Display the logs at each epoch steps   
      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 = 'Logistics Regression Training')     
   plt.ylabel('cost')   
   plt.xlabel('epoch')   
   plt.legend()   
   plt.show()   
      
# Test the model  
   correct_prediction = tf.equal (tf.argmax (activation, 1),tf.argmax(y,1))   
    
# Calculating the accuracy of dataset  
accuracy = tf.reduce_mean(tf.cast (correct_prediction, "float")) print   
("Model accuracy:", accuracy.eval({x:mnist.test.images, y: mnist.test.labels}))  

Đầu ra của Mã:

Hồi quy logistic được coi là phân tích dự báo. Hồi quy logistic chủ yếu được sử dụng để mô tả dữ liệu và sử dụng để giải thích mối quan hệ giữa biến nhị phân phụ thuộc và một hoặc nhiều biến danh nghĩa hoặc độc lập.

Leave a Reply

Call now
%d bloggers like this: