Back-propagation Algorithm Is???

Back-propagation Algorithm

เป็นกระบวนการสำคัญในการย้อนกลับ (Backward) เพื่อปรับ Parameters (Weight และ Bias) ของ Model ซึ่งง่ายที่สุดคือ perception (p) มี input output นำเป็น 1 layer การแทนข้อมูล (input) ภายในมี process อยู่ การเข้าไปของข้อมูล แบบไม่มีทิศทาง เช่น น้ำหนัก ส่วนสูง และข้อมูลที่กำหนดทิศทาง เช่น อาเรย์มีสมาชิก 10 ตัว หรือ ข้อมูลกว้าง ยาว แถวคอลัมบ์ มีแบบ 3 มิติ ส่วน CNN คือข้อมูลอาจไม่เป็นภาพอย่างเดียว อาจมีแบบ 3D

Forward Propagation

Input Node

มี Cell ประสาท จำนวน 2 Cell คือ Node สีฟ้าเรียกว่า Input Layer จะเป็นข้อมูลแบบ Scalar, Vector หรือ Matrix

Xi, i ∈ 1, 2

Output Layer

เป็น Layer สุดท้ายของ Neural Network เป็น Node สีส้ม และ Node สีนำ้ตาล โดยที่ Node สีส้ม จะมีการนำ Weight ที่เกิดจากการสุ่มในช่วงเริ่มต้นของการ Train คูณกับ Input Data แล้วนำผลลัพธ์จากการคูณมาบวกกับ Bias (B) ซึ่งเกิดจากการสุ่มในช่วงเริ่มต้นเช่นกัน

Z = W · X + B

การ Implement เราจะแทน Weight (W) ด้วย Matrix ขนาด mxn โดย m คือจำนวน Output Node (ในที่นี้มี 1 Node) และ n คือ จำนวน Input Node (ในที่นี้มี 2 Node)

W = [w1 w2]

และ B เป็น Matrix ขนาด mx1

B = [b]

สมมติว่าให้ X1=0.05,X2=0.1, W1=0.2,W2=0.5 และ B=0.3 เป็น Neural Network และ Z = [z] ดังนั้นเราจะคำนวณค่า Z ได้ดังนี้

Z = [w1x1 + w2x2] + [b]
 = [(0.2)(0.05) + (0.5)(0.1)] + [0.3]
 = [0.36]

Activate Function

ปรับค่าด้วย Activate Function เพื่อทำให้มันอยู่ในช่วง 0–1 ซึ่งเราเรียกฟังก์ชันสำหรับการปรับค่าอย่างนี้ว่า Sigmoid Function ดังนั้นผลลัพธ์สุดท้ายที่เป็นค่าที่ Model ทำนายออกมาได้ หรือ ŷ จะเท่ากับ Sigmoid(z)

y^ = Sigmoid(z) = Sigmoid(0.36) = 0.5890

Loss Function

ขั้นตอนสุดท้ายของการทำ Forward Propagation คือการประเมินว่าผลการ Predict คลาดเคลื่อนกับ Output y มากน้อยเพียงใด ด้วย Loss Function (L) = Loss(y, ŷ) โดยที่ L อาจจะเป็น MSE (Mean Squared Error) หรือ Cross-entropy ฯลฯ

สมมติว่า y เท่ากับ 0.7 และ L คือ MSE ดังนั้น L จะมีค่าเท่ากับ 0.0123

L = (y - y^)^2 
= (0.7 - 0.589)^2 
= 0.0123

Back-propagation

เราสามารถทำกระบวนการ Backward Propagation เพื่อปรับค่า w1 จากการหาอนุพันธ์ของ L เทียบกับ w1 หรือความชัน (Gradient) ของ Loss(y, ŷ) หรือ Error ที่ w1 ด้วยสมการด้านล่าง

Implement with NumPy

class NeuralNetwork:
 def __init__(self, x, y):
 self.input = x
 self.weights1 = np.random.rand(self.input.shape[1],4) 
 self.weights2 = np.random.rand(4,1) 
 self.y = y
 self.output = np.zeros(y.shape)

กำหนดค่า X และ y

import numpy as npX = np.array([[0,0,1],
              [0,1,1],
              [1,0,1],
              [1,1,1]])y = np.array([[0],[1],[1],[0]])
X.shape, y.shape

สร้าง nn1 แล้ว Print ค่าต่างๆ

nn1 = NeuralNetwork(X,y)nn1.input.shapeprint(nn1.input)nn1.weights1.shapeprint(nn1.weights1)nn1.weights2.shapeprint(nn1.weights2)nn1.y.shapeprint(nn1.y)nn1.output.shapeprint(nn1.output)

นิยาม Neural Network Class

import numpy as npdef sigmoid(x):
 return 1.0/(1+ np.exp(-x))def sigmoid_derivative(x):
 return x * (1.0 — x)class NeuralNetwork:
 def __init__(self, x, y, l):
 self.input = x
 self.weights1 = np.random.rand(self.input.shape[1],4) 
 self.weights2 = np.random.rand(4,1) 
 self.y = y
 self.output = np.zeros(self.y.shape)
 self.learning_rate = 1 
 def loss1(self):
 return sum((self.y — self.output)**2)
 def loss2(self):
 return sum((self.y — self.output)**2)
 def loss3(self):
 return sum((self.y — self.output)**2)
 def loss4(self):
 return sum((self.y — self.output)**2)
 def loss5(self):
 return sum((self.y — self.output)**2)
 def loss6(self):
 return sum((self.y — self.output)**2)
 def loss7(self):
 return sum((self.y — self.output)**2)
 def loss8(self):
 return sum((self.y — self.output)**2)
 def loss9(self):
 return sum((self.y — self.output)**2) 
def loss10(self):
 return sum((self.y — self.output)**2)def feedforward(self):
 self.layer1 = sigmoid(np.dot(self.input, self.weights1))
 self.output = sigmoid(np.dot(self.layer1, self.weights2))def backprop(self):
 #learning_rate = 1.0
 
 d_weights2 = np.dot(self.layer1.T, (2*(self.y — self.output) * sigmoid_derivative(self.output)))
 d_weights1 = np.dot(self.input.T, (np.dot(2*(self.y — self.output) * sigmoid_derivative(self.output), self.weights2.T) * sigmoid_derivative(self.layer1)))#self.weights1 += d_weights1
 #self.weights2 += d_weights2
 
 self.weights1 += learning_rate*d_weights1
 self.weights2 += learning_rate*d_weights2

ปรับ Learning Rate ตั้งแต่ 0.1–1.0 แต่ละค่า Train 1,000 Epoch

โดยมีขั้นตอนดังนี้

• 1)Train Model
• 2)Plot Loss
• 3)กราฟแสดงค่า loss

Train Model

learningrate = 0.1–1.0 ทั้งหมด 10จำนวน

Plot Loss

Plot Loss ตั้งแต่ค่า 0.1–1.0 แทนด้วย df1-df10 , h1-h10

จะได้กราฟดังนี้

วิเคราะห์ผลการทดลอง

จากแผนภาพโมเดลค่า plot loss จาก Learning_rate 10 ค่า คือ

ค่า learning_rate มีค่าที่มากขึ้นก็จะทำให้ค่า epochs ลดลงไปตามลำดับตามกราฟ ในทางกลับกันค่า learning_rate ยิ่งมีค่าที่น้อย(ลดลง)กลับทำให้ค่า epochs เพิ่มมากขึ้น