เข้าใจการทำงานพื้นฐานของ Neurons ใน Neural Networks

Neural networks (nnet) คือหนึ่งใน algorithms ที่ทรงพลังที่สุดในงาน machine learning ทุกวันนี้เรารู้จักมันในชื่อ Deep Learning ซึ่งก็คือ networks ที่พัฒนาต่อยอด มี layers หลายชั้น และถูกนำมาใช้กันอย่างจริงจังตั้งแต่ช่วงประมาณปี 2012 เป็นต้นมา

บทความนี้เราจะมาทำความรู้จักกับ neural networks แบบเจาะลึก อธิบายละเอียด พร้อมภาพประกอบสุดน่ารัก วาดเองทุกรูป เย้ 555+ อยากเขียนเรื่องนี้มานานแล้ว 😆

Table of Contents

Intro to Linear Regression

แอดดด! ไหนบอกว่าจะสอน neurons ทำไมมาโผล่ที่ linear regression ได้ 555+

จริงๆ linear regression เรียกว่าเป็นพื้นฐานของหลายๆ machine learning algorithms ที่เราเรียนกันเลย และเป็น foundation ของ neural networks เช่นกัน

เราใช้ linear regression ในการทำนาย numeric values เช่น เงินเดือน ราคาสินค้า ยอดขาย เป็นต้น ซึ่งสามารถเขียนเป็นสมการเส้นตรงในฟอร์ม y = mx + c

โดย c = constant (y intercept) และ m = slope (หรือความชันของเส้น)

ในรูปตัวอย่าง แอดขอเขียนเป็น y = w0 + w1*x (เราเขียน wo = c, w1 = m) ในงาน ML เรียก w ว่าค่า weights แต่ถ้าอยู่ในวิชาสถิติจะเรียกว่า regression coefficients

# find w0, w1 that best fit the data
y = f(x)
y = w0 + w1*x 

Note – learning algorithm ของ linear regression ที่หลายคนน่าจะคุ้นหูเรียกว่า Least Squares ใช้ในการทำ data fitting หาค่า w0, w1 เพื่อให้ได้ the best fitted line

แล้ว linear regression มันเกี่ยวข้องกับ nnet ยังไง? หาคำตอบได้ในพาร์ทต่อไป

Intro to Neural Networks

ในหนึ่งวัน สมองมนุษย์ใช้พลังงานประมาณ 20% แค่เรานั่งอยู่เฉยๆ just to think ก็ถูกเบิร์นไปแล้ว 320 calories อ้างอิงจาก Does Thinking Burn Calories (Time, 2018)

นักวิทยาศาสตร์ประเมินว่าในสมองเรามี neurons เฉลี่ยประมาณ 86 billion cells (พันล้านเซลล์) โดย neurons คือเซลล์การทำงานพื้นฐานในสมอง องค์ประกอบหลักของ neurons ดูได้ที่รูปด้านล่าง

• Cell body เป็นเหมือน node/ unit ของ neuron ตัวนั้นๆ
• Dendrites ใช้รับข้อมูลจาก neurons ตัวอื่นๆ
• Axon ใช้ส่งข้อมูล

Neurons รับส่งข้อมูลหากันด้วย electrical & chemical signals และด้วยความที่สมองเรามี neurons จำนวนมหาศาลที่เชื่อมต่อหากัน เราเลยเรียกมันตรงๆเลยว่า Neural Networks แปลว่า โครงข่ายนิวรอน (แปลตรงๆ 555+)

ยิ่งเราเรียนรู้เรื่องใดเรื่องหนึ่งมากขึ้นเท่าไหร่ neural network ของความรู้เรื่องนั้นก็จะยิ่งแข็งแรงมากขึ้นเท่านั้น => stronger network

แล้ว neural network algorithm ในงาน machine learning คืออะไรนะ?

ในบทความนี้เราใช้ ANN architecture แบบเรียบง่ายที่สุดเลย เรียกว่า Feed-Forward Neural Networks with a Single Hidden Layer (Wikipedia) เพราะ input วิ่งจากซ้ายไปขวา ไม่มี cycles หรือ loop ใน networks

Architecture นี้มีทั้งหมด 3 layers และ nodes ใน hidden/ output layers คือ neurons

• Input layer ข้อมูลที่จะส่งเข้ามาใน network ในตัวอย่างนี้มี 3 neurons ทำหน้าที่ส่งข้อมูล (3 neurons = 3 features ใน dataset ที่เราใช้เทรนโมเดล)
• Hidden layer ในตัวอย่างนี้มี 3 neurons (ตัวเลขนี้ arbitrary สามารถปรับได้)
• Output layer ในตัวอย่างนี้มีแค่ 1 neuron ทำหน้าที่ทำนายผล

หน้าที่อย่างแรกของ neuron คือการหาผลรวมของ input ทั้งหมดที่วิ่งเข้ามาหามัน ในรูปแบบของ weighted sum ถ้าดูดีๆจะเห็นว่านี่มันสมการ linear regression เลย 555+

เส้นที่เชื่อม neuron ทั้งหมดเข้าด้วยกัน (เราเรียกว่า edges หรือ links) จะมีค่า weights ติดอยู่ด้วย เช่น w₁ w₂ w₃ โดยทั่วไปเราจะเพิ่ม w₀ (ชื่อเล่นของ bias) เข้าไปที่สมการด้วย

# weighted sum
output = wo + w1*x1 + w2*x2 + w3*x3

Technical note – หน้าที่ของ bias หรือ w₀ คือการช่วยปรับค่า และเพิ่มความแม่นยำให้กับโมเดลโดยรวมของเรา สามารถ drop ทิ้งก็ได้ ถ้ามันไม่ช่วยให้การทำนายผลเราดีขึ้น 😛

การคำนวณ weighted sum คือหน้าที่แรกของ neurons ใน hidden layer แต่ก่อนที่ [output₁, output₂, output₃] จะถูกส่งไปที่ layer ต่อไป => neurons ยังมี operation ที่สองที่ต้องทำก่อน คือการเรียกใช้งาน activation functions

# hidden layer: neuron1, neuron2, neuron3
output1 = w0 + w1*x1 + w2*x2 + w3*x3
output2 = w0 + w1*x1 + w2*x2 + w3*x3
output3 = w0 + w1*x1 + w2*x2 + w3*x3

แล้ว activation functions คืออะไร? ต้องอ่านต่อ 555+

Activation Functions

Neurons ใช้ activation functions เพื่อบีบตัว output ให้อยู่ในช่วงที่ต้องการ เช่น [0, 1], [-1, +1] เป็นต้น การใช้ weighted sum ร่วมกับ activation functions ช่วยให้ neuron สามารถเรียนรู้ความสัมพันธ์แบบ non-linear ได้ดียิ่งขึ้น

ถ้าเราไม่มี activation functions โมเดลของเราจะเรียนรู้ได้แค่ linear relationship เท่านั้น

# how a single neuron works
output = activation_fn(wo + w1*x1 + w2*x2 + w3*x3)

มาลองดูตัวอย่าง code ง่ายๆใน R อันนี้แอดเขียน input, weights และใช้ ReLU activation เอาจริงๆ ReLu ใช้ simple rule ง่ายๆ เขียน if-else ได้แบบนี้

=IF(x > 0, x, 0)

# R code example
# inputs x, weights w
x <- c(1, 2, 3)
w <- c(0.5, -0.4, 0.25); w0 <- 0.1

# neurons workout the sum
weighted_sum <- w0 + sum(x*w)

# ReLU activation
output <- max(0, weighted_sum)

อ่านมาถึงตรงนี้แอดขอสรุปสั้นๆ (Quick Recap)

• ANN ที่เราสอนวันนี้เป็นแบบ feed forward architecture
• Neuron ทำ simple operations สองอย่างคือ
  1. Weighted sum
  2. Activation function

การทำงานของ an artificial neuron ได้รับแรงบันดาลใจมาจาก a biological neuron ที่รับข้อมูลผ่าน dendrites และส่งข้อมูลออกทาง axon

Note – ตอนนี้นักวิทยาศาสตร์ยังพยายามทำความเข้าใจการทำงานของสมองมนุษย์อยู่เลย ทุกคนยกให้สมองเป็น the most complex systems in the known universe

นี่คือเหตุผลที่เราเรียก neurons ในงาน machine learning ว่า “Artificial” (ของจำลองที่ยังห่างไกลจาก real human brain ของจริงมาก)

Output Layer

Output layer คือ layer สุดท้าย มีทำหน้าที่ทำนายผลค่า y และคำนวณค่า error

ดูจากรูปจะเห็นว่า output neuron ก็ทำงานเหมือนเดิมเลยคือหาค่า weighted sum แล้วส่งเข้า activation function ตัวอย่างนี้สมมติ networks ของเราพยายามจะทำนายราคาบ้าน (regression) เราก็ใช้ linear activation ปกติได้เลย (x = x)

Linear function คือ input มาแบบไหน output ก็ออกไปตรงๆแบบนั้น แล้วจะมีทำไม 555+ อีกชื่อหนึ่งของ linear activation คือ “No activation”

พอโมเดลได้ค่า prediction ออกมาแล้ว ก็จะเอาค่านี้ไปเทียบกับ actual value

วิธีการคำนวณ error สามารถทำได้หลายวิธี สำหรับปัญหา regression ตัวพื้นฐานที่เรานิยมใช้กันคือ Mean Squared Error หรือเรียกสั้นๆว่า MSE

# error function
MSE = mean((actual - prediction)^2)

ตัวอย่างเช่น actual = [9, 9, 8] และ prediction = [10, 8 , 5]

# R code example
actual <- c(9, 9, 8)
prediction <- c(10, 8, 5)
MSE <- mean((actual - prediction)^2)

MSE = ( (-1)^2 + 1^2 + 3^2 ) / 3 = 3.67

ในงานวิจัย neural networks เราเรียกว่า MSE ว่า Loss Function ยิ่งต่ำเข้าใกล้ศูนย์ ยิ่งดี

Backpropagation

คำถาม => แล้ว nnet มันเรียนรู้ค่า weights ใน network ได้ยังไง?

Learning algorithm ที่เรานิยมใช้กันใน networks ชื่อว่า Backpropagation ซึ่งการทำงานของ algorithm ถ้าให้อธิบายแบบง่ายที่สุดคือ การส่ง signals จาก output layer กลับไปปรับค่า weights ทั้งหมดใน layers ก่อนหน้า

Signals ในที่นี่คือค่า error (MSE) นั่นเอง ถ้า output node ทำนายผลผิด มันจะถามว่าค่า weights [w0, w1, w2, w3] ที่วิ่งเข้ามาที่ output node ควรจะปรับเพิ่มขึ้นหรือลดลงยังไงดี เพื่อทำให้ MSE ลดลงต่ำที่สุด i.e. ปรับ weights ให้โมเดลทำนายผลได้แม่นยำขึ้น

Backpropagation จะปรับค่าจูน weights ไปเรื่อยๆจนกว่า output layer จะมี error ต่ำที่สุดเท่าที่จะเป็นไปได้ เราสามารถกำหนดจำนวน batch size และ epoch (รอบในการเทรนโมเดล) ได้ อันนี้อยู่นอกเหนือเนื้อหาในบทความนี้ เดี๋ยวจะยาวเกินไป 555+ ลองอ่านเรื่อง batch size และ epoch ได้ที่เว็บไซต์ Machine Learning Mastery

ตอนนี้ทุกคนเข้าใจการทำงานของ nnet เบื้องต้นแล้ว สุดยอดครับทุกคน

• Input layer
• Hidden layer และการทำงานของ neuron แต่ละตัว
• Output layer

หัวข้อถัดไปเรามาลองเขียน code เพื่อสร้างโมเดลแรกกันดีกว่าครับ 😁 โดยตัวอย่างทั้งหมดแอดเขียนด้วยภาษา R

Let’s Build NNET

Optional – สำหรับเพื่อนๆที่อยากลองทำตาม สามารถเปิด RStudio Cloud สร้าง new project ได้เลยนะครับ

เราจะลองเทรนโมเดล feed forward network ง่ายๆกับ iris dataset ทำนายคอลัมน์ Species โดยใช้ features: Sepal.Length, Sepal.Width, Petal.Lenth, Petal.Width

ตัวอย่างนี้เป็นปัญหาแบบ multiclass classification – 3 Species และใช้ softmax activation function ใน output layer

ติดตั้ง packages เพื่อใช้ในการ train model

• dplyr สำหรับทำ data manipulation ตอนเรา random, split data
• nnet สำหรับเทรน feed forward nnet
• NeuralNetTools ไว้ทำ visualization ตัว networks ที่เราสร้างขึ้นมา

# install packages
install.packages(c("dplyr", "nnet", "NeuralNetTools"))

ขั้นตอนการ train-test model จะแบ่งเป็น 3 ขั้นตอน (อันนี้แบบ simple)

1. Train test split แบ่งข้อมูลเป็นสองส่วนสำหรับ train: test
2. Train model
3. Test and evaluate model performance

Code ด้านล่างเราเรียกใช้ packages ที่เราเพิ่งติดตั้งเสร็จ และ split data เป็น train 80%, test 20% ตามลำดับ

# import library
library(dplyr)
library(nnet)
library(NeuralNetTools)

# train test split
set.seed(42)
n <- nrow(iris)
shuffle_iris <- iris %>% sample_n(n, replace = FALSE)

iris_train <- shuffle_iris[1:120,  ]
iris_test <- shuffle_iris[121:150, ]

Train model ด้วยฟังก์ชัน nnet กำหนดจำนวน neurons ใน hidden layer = 3 พอเทรนโมเดลเสร็จใช้ฟังก์ชัน plotnet() เพื่อ visualize networks

# model training
set.seed(42)
nn_model <- nnet(Species ~ ., 
                 data = iris_train,
                 size = 3)

# plot networks
plotnet(nn_model)

เราสามารถเรียกดูค่า weights (w) ของโมเดลด้วยฟังก์ชัน summary(nn_model)

a 4-3-3 network with 27 weights
options were - softmax modelling 
  b->h1  i1->h1  i2->h1  i3->h1  i4->h1 
-152.29   -3.04  -20.04   23.31   66.39 
  b->h2  i1->h2  i2->h2  i3->h2  i4->h2 
   7.24   19.75   59.04  -70.79  -38.63 
  b->h3  i1->h3  i2->h3  i3->h3  i4->h3 
 118.10    8.73   12.52  -23.52  -54.08 
  b->o1  h1->o1  h2->o1  h3->o1 
  21.47 -188.32  174.62   -1.16 
  b->o2  h1->o2  h2->o2  h3->o2 
  92.45  -82.32  -73.99  109.73 
  b->o3  h1->o3  h2->o3  h3->o3 
-113.85  270.90 -101.17 -109.79 

ขั้นตอนสุดท้ายคือเอา nn_model ของเราไปทำนาย test_iris เพื่อคำนวณ model accuracy

# model evaluation
p <- predict(nn_model, newdata = iris_test, type = "class")
mean(p == iris_test$Species)

Test accuracy อยู่ที่ 96.67% จะเต็มอยู่แล้ว 555+ (เพราะโจทย์วันนี้ไม่ได้ซับซ้อนเท่าไหร่)

Note – จำนวน hidden layers, neurons, activation functions, weight initialization และปัจจัยอื่นๆอีกหลายอย่างมีผลโดยตรงกับ performance ของโมเดล ตอนทำงานจริงต้องใช้การทดลอง (experiments) เพื่อหา final/ optimal model ที่ดีที่สุดของโจทย์นั้นๆ

[อัพเดท] อันนี้แอดลอง snapshot ตัวโปรแกรม RStudio มาให้ดู ตอนเทรนโมเดลลองเปลี่ยน size หรือ seed จะเห็นว่าผลลัพธ์เปลี่ยนไปพอสมควรเลย

What is Deep Learning

ตัวอย่าง network ที่เราเพิ่งสร้างเมื่อกี้ (one hidden layer) เรียกว่า “Shallow networks”

แต่ถ้าเราเพิ่มจำนวน hidden layers เพิ่มจำนวน neurons หลายๆชั้น โมเดลเราจะกลายร่างเป็น “Deep networks” หรืออีกชื่อที่หลายคนน่าจะเคยได้ยินคือ Deep Learning 😋

Deep Learning มี architectures หลากหลายรูปแบบ ความซับซ้อนแตกต่างกันไป มีงานวิจัยอัพเดทใหม่ทุกเดือน smartphones ที่ทุกคนใช้อยู่ก็ต้องมี deep learning models รันอยู่ไม่น้อยกว่า 10 models แน่นอน (ทั้ง androids, iOS)

Learn More?

ทำไมมันง่ายอย่างนี้! ยั๊งงง 555+ สำหรับเพื่อนๆที่อยากศึกษาต่อ แอดแนะนำของ อ. Andrew Ng – DeepLearning.AI สมัครเรียนฟรีได้บน Coursera หรือจะอัพเกรดเพื่อรับ certificates ไว้สมัครงานก็ได้ (เดือนละ 49 USD)

อาจารย์ Andrew กำลังจะเปิดตัวคอร์ส Machine Learning Specialization ใหม่ในเดือน มิ.ย. 2022 นี้ด้วย ใครอยากอัพสกิล ML ห้ามพลาดเลย

ถ้าอ่านบทความนี้แล้วชอบ ช่วยแชร์ต่อให้เพื่อนๆได้อ่านด้วยนะครับ 😊

ติดตามอัพเดทบทความใหม่ๆได้ที่ FB DataRockie และ Twitter (เพิ่งเล่นเป็นกับเค้า 555+)