Lecture7 (deep_learning_part3_1.pdf, 30 หน้า) · 2603520 Deep Learning

Convolutional Neural Networks: Convolution, Padding, Stride, Pooling และการนับ Parameter

Lesson 1–6 ใช้ network แบบ dense (fully connected) ทั้งหมด: ทุก node ต่อกับทุก node ของ layer ก่อนหน้า. บทนี้เปลี่ยนชนิดของ layer สำหรับข้อมูลภาพ. ส่วนที่ต้องคำนวณมือได้มีสามเรื่อง:

1. ค่าใน feature map จากการเลื่อน filter ทับภาพ (หน้า 7–9)
2. ขนาด output ของ convolution/pooling จากสูตร \(\lfloor (n+2p-f)/s \rfloor + 1\) (หน้า 12–20)
3. จำนวน parameter ของแต่ละ layer ในตารางหน้า 21

1. Computer Vision และเหตุผลที่ Dense Network ไม่เหมาะกับภาพ

Computer vision คือสาขาที่ทำให้เครื่องมีความสามารถ understand visual input เช่นภาพและวิดีโอ ในแบบที่มนุษย์เข้าใจ. ระบบของมนุษย์มีตา (sensing device) ส่งสัญญาณให้สมอง (interpreting device). ระบบของคอมพิวเตอร์มีกล้องเป็น sensing device และโมเดลเป็น interpreting device ซึ่งให้ output เดียวกัน เช่น "bowl, oranges, bananas, lemons, peaches".

Applications of Computer Vision ที่สไลด์ระบุมี 4 กลุ่ม:

• Image Classification, Image captioning
• Object Detection, Semantic Segmentation (Lesson 9)
• Autonomous systems (e.g., cars, robots)
• Create new things such as art works

Deep learning has been applied in various fields of computer vision. ตัวอย่างในสไลด์คือการจำแนกว่าภาพเป็น Motorcycle หรือไม่ (binary classification, output เดียวผ่าน sigmoid). วิธีแรกที่ทำได้ด้วยความรู้เดิมคือ Image Classification using Densely Connected Neural Networks: flatten ภาพเป็น vector แล้วป้อนเข้า dense layer.

คอมพิวเตอร์เห็นภาพ grayscale เป็นตารางตัวเลข 1 ชั้น. ภาพสีเป็นตาราง 3 ชั้น: pixel ที่มีค่า (R, G, B) = (11, 102, 35) คือสี forest green. จำนวน input feature จึงเท่ากับ สูง × กว้าง × จำนวน channel.

สไลด์ให้เหตุผลสองข้อที่ dense network ใช้กับภาพไม่ดี.

ข้อ 1: Computational Complexity & Not Scale. จำนวน weight ของ dense layer แรก = (จำนวน input) × (จำนวน node) และจำนวน input โตตามพื้นที่ภาพ.

ข้อ 2: Loss Spatial Information of Images. การ flatten ทำลายข้อมูลว่า pixel ไหนอยู่ติดกัน. ตารางแรกในสไลด์เป็นภาพ 4×4 ที่มีสี่เหลี่ยมอยู่มุมซ้ายบน (pixel ค่า 1 ที่ตำแหน่ง (1,1), (1,2), (2,1), (2,2)). เมื่อ flatten ทีละแถวได้

ค่า 1 สองตัวของแถวบน (ตำแหน่ง 1–2) กับสองตัวของแถวล่าง (ตำแหน่ง 5–6) ซึ่งติดกันในภาพ ถูกแยกห่างกัน 4 ตำแหน่งใน vector. Dense network เรียน weight แยกต่อตำแหน่ง จึงเรียนได้แค่ว่า "ตำแหน่ง 1, 2, 5, 6 เป็น 1". ถ้าสี่เหลี่ยมเดียวกันย้ายไปมุมขวาล่าง ค่า 1 จะไปอยู่ตำแหน่ง 11, 12, 15, 16 ซึ่งใช้ weight คนละชุดที่ไม่เคยถูกเทรน. สไลด์สรุปว่า network จะ no idea ว่ารูปเหล่านี้คือสี่เหลี่ยม เพราะไม่ได้เรียนรูปทรงสี่เหลี่ยมเป็น feature.

2. CNN: ที่มาและโครงสร้างระดับบน

CNN (อีกชื่อคือ ConvNets) เกิดในทศวรรษ 1980 จากการศึกษา visual cortex ของสมอง. ข้อค้นพบของ Hubel & Wiesel (1968) ที่สไลด์อ้างมีสองข้อ และทั้งสองข้อกลายเป็นหลักออกแบบ CNN:

1. neuron จำนวนมากใน visual cortex มี receptive field ขนาดเล็กเฉพาะที่ คือตอบสนองต่อสิ่งเร้าในบริเวณจำกัดของลานสายตาเท่านั้น ⇒ ใน CNN neuron หนึ่งตัวต่อกับ pixel กลุ่มเล็ก ไม่ต่อทั้งภาพ
2. neuron ระดับสูงทำงานจาก output ของ neuron ระดับล่างที่อยู่ใกล้กัน ⇒ ใน CNN layer ลึกรวม feature ง่าย (เส้น, ขอบ) เป็น feature ซับซ้อน (รูปทรง, วัตถุ)

CNNs Architecture ประกอบด้วยสี่ส่วนเรียงกัน:

หมายเหตุในสไลด์: neuron ใน convolutional layer ต่อเฉพาะกับ pixel ใน receptive fields. ของตัวเอง ต่างจาก dense layer ที่ต่อกับ input ทุกตัว. รูปล่างของสไลด์แสดงลำดับชั้นของ feature: layer ต้นเรียน low-level feature (ขอบ, เส้น), layer กลางเรียนชิ้นส่วน (ตา, จมูก), layer ลึกเรียน high-level feature (ใบหน้าทั้งหน้า).

3. Convolution Operation และ Filter

Convolution layer ใช้ convolution kernels (อีกชื่อคือ filters) สกัด feature จากภาพ. ตัวอย่างในสไลด์คือ edge detection. วิธีคำนวณ: filter เลื่อนไปบนภาพทีละตำแหน่ง ที่แต่ละตำแหน่งคูณค่าที่ซ้อนกันทีละคู่ (element-wise multiplication) แล้วบวกทั้งหมด ได้ตัวเลข 1 ตัว. ตัวเลขทั้งหมดเรียงกันเป็น feature map (หรือ activation map).

ภาพหน้า 8 ถูกทำให้ง่าย: ครึ่งซ้ายสว่าง (80) ครึ่งขวาดำ (0) จึงมีขอบแนวตั้งหนึ่งเส้นตรงกลาง. ใช้กฎ "คอลัมน์ซ้าย − คอลัมน์ขวา" ของ filter เดิม:

• หน้าต่างคอลัมน์ 1–3 (80 ทั้งหมด): \(3(80) - 3(80) = 0\)
• หน้าต่างคอลัมน์ 2–4 (ซ้าย 80, ขวา 0): \(3(80) - 3(0) = 240\)
• หน้าต่างคอลัมน์ 3–5 (ซ้าย 80, ขวา 0): \(240\)
• หน้าต่างคอลัมน์ 4–6 (0 ทั้งหมด): \(0 - 0 = 0\)

Feature map จึงเป็น \([0, 240, 240, 0]\) ทุกแถว. บริเวณสีเรียบให้ 0 ไม่ว่าจะสว่างหรือมืด. ค่าสูงเกิดเฉพาะตำแหน่งที่หน้าต่างคร่อมขอบ. filter นี้จึงเป็นตัวตรวจ vertical edge และ feature map "amplifying the edges".

หมุน filter 90° ให้แถวบนเป็น 1, แถวกลางเป็น 0, แถวล่างเป็น −1 จะได้ output = (ผลรวมแถวบน) − (ผลรวมแถวล่าง) ซึ่งตรวจ horizontal edge. ภาพหน้า 9 มีมุมซ้ายบนและขวาล่างสว่าง (80).

สไลด์ปิดหน้า 9 ว่า filter แบบอื่นใช้ตรวจ feature ชนิดอื่นได้ (blur, sharpen, ขอบแนวทแยง).

ค่า 1, 0, −1 ที่ใช้มาเป็นค่าที่คนตั้งเองเพื่ออธิบาย. ใน CNN จริง:

• Filter Element: each element in a filter คือ weight หนึ่งตัว. ค่าเหล่านี้ randomly initialized and trainable คือเริ่มจากค่าสุ่มแล้วเรียนด้วย backpropagation เหมือน \(\theta\) ของ dense layer (Lesson 3). network จึงเลือกเองว่าควรตรวจ feature ชนิดใด
• Filter Size: filter เล็กจับรายละเอียดละเอียดของภาพ (fine details), filter ใหญ่จับรายละเอียดกว้าง (broader details)

ตัวอย่างในสไลด์ใช้ filter 7×7 สองตัวกับภาพอาคาร. (1) Vertical filter: เป็น 0 ทั้งหมดยกเว้นคอลัมน์กลางเป็น 1 ⇒ Feature Map 1 เส้นแนวตั้งชัดขึ้น ส่วนอื่นเบลอ. (2) Horizontal filter: เป็น 0 ทั้งหมดยกเว้นแถวกลางเป็น 1 ⇒ Feature Map 2 เส้นแนวนอนชัดขึ้น. input เดียวกัน filter ต่างกันให้ feature map ต่างกัน.

4. Padding และ Stride

Two downside of basic convolutional:

1. Image shrink down ทุกครั้งที่ทำ convolution. ภาพ 5×5 กับ filter 3×3 ในสไลด์ให้ output \(5-3+1 = 3\) คือ 3×3. network ลึกจะทำให้ภาพเล็กลงจนไม่เหลือให้สกัด feature: ภาพ 32×32 ผ่าน filter 3×3 แต่ละครั้งด้านลดลง 2 จึงเหลือ 2×2 หลัง 15 layer
2. Throw away a lot of information from edge. pixel มุมถูกหน้าต่างคลุมเพียง 1 ครั้ง ส่วน pixel กลางภาพ 5×5 ถูกคลุม 9 ครั้ง ข้อมูลที่ขอบจึงมีน้ำหนักใน output น้อยกว่ามาก

Padding คือการเติม additional border รอบภาพ (ส่วนใหญ่เติม zeros) เพื่อรักษาขนาดเชิงพื้นที่ ให้ความกว้างและสูงของ output เท่ากับ input. Keras มีสองค่า:

• "SAME": ใช้ zero padding เท่าที่จำเป็นเพื่อให้ output มีขนาดเท่า input
• "VALID": ไม่ใช้ padding (no padding) และเป็นค่า default ของ Keras

เติมขอบข้างละ p ทำให้ด้านยาวขึ้น 2p ก่อนเข้าสูตรเดิม n − f + 1

Stride คือ step size ของ filter ขณะเลื่อนไปบนภาพ. stride 1 เลื่อนทีละ 1 ช่อง; stride 2 ข้ามทีละ 2 ช่องทั้งแนวนอนและแนวตั้ง. ผลของ stride ที่ใหญ่ขึ้นตามสไลด์:

• อาจ skip valuable regions in the image ทำให้ lesser overlap และ smaller output volume
• increase speed, lesser computation and memory ที่ต้องใช้กับ output
• ความละเอียดที่ลดลงมีผลเชิง regularization ช่วยลด overfitting

ถ้าหารไม่ลงตัวให้ปัดลง: ตำแหน่งที่หน้าต่างล้นออกนอกภาพ (รวม padding แล้ว) ไม่ถูกคำนวณ

5. Convolution บน Volume, หลาย Filter และ Convolution Layer เต็มรูป

ภาพสีมี 3 channel. filter ที่ใช้กับ input หลาย channel ต้องมี the same number of channels กับ input (หนึ่งชั้นต่อหนึ่ง channel) โดยแต่ละชั้นมี weight ต่างกันได้. filter จึงมีขนาด \(f \times f \times n_C\). การคำนวณหนึ่งตำแหน่งคือคูณและบวกทุกช่องของทุก channel รวมกันเป็นตัวเลขเดียว.

• ภาพ 6×6×3 กับ filter 3×3×3: หนึ่งตำแหน่งมีการคูณ \(3 \times 3 \times 3 = 27\) ครั้ง แล้วบวกเป็น 1 ค่า
• Feature map ที่ได้จาก filter หนึ่งตัวมี 1 channel ขนาด \(4 \times 4\) ไม่ใช่ 4×4×3

Convolutional layer ใช้ multiple trainable filters พร้อมกันได้ จึง detecting multiple features anywhere ใน input. filter แต่ละตัวให้ feature map 1 แผ่น. เมื่อนำมาซ้อนกันจะได้ output

กว้างและสูงมาจากสูตรเดิม ส่วน channel ของ output เท่ากับจำนวน filter ไม่เกี่ยวกับ channel ของ input

Convolution layer มีส่วนประกอบเดียวกับ dense layer ของ Lesson 2 ทุกตัว:

6. Pooling Layer และ Translation Invariance

Pooling layer ทำหน้าที่ reduce the size of images or feature maps:

• Downsize ภาพหรือ feature map ที่ convolutional layer ผลิต โดยไม่กระทบจำนวน channel (not affect channels)
• ลด spatial dimensions จึงลด computation และ number of parameters ใน subsequent layers ซึ่งจำกัดความเสี่ยง overfitting

Common types of polling strategy มีสองแบบ:

• Max Pooling (ใช้บ่อยที่สุด): เก็บค่าสูงสุดในหน้าต่าง = feature ที่เด่นที่สุด (most important features) ไม่ว่าอยู่ตรงไหนในหน้าต่าง. มีเฉพาะ hyperparameter (filter size, stride) และ no parameters to learn
• Average Pooling: เฉลี่ยค่าในหน้าต่าง

ภาพที่เลื่อนไปไม่กี่ pixel ควรให้ feature ใกล้เคียงเดิม เรียกว่า invariance to small translations. ตัวอย่างในสไลด์: ภาพ A, B, C ผ่าน max pooling ที่ใช้ kernel 2×2 stride 2. B คือ A เลื่อนขวา 1 pixel, C คือ A เลื่อนขวา 2 pixel.

• Output ของ A และ B เหมือนกันทุกช่อง. การเลื่อน 1 pixel ยังอยู่ในหน้าต่าง 2×2 เดิม ค่าสูงสุดของหน้าต่างจึงไม่เปลี่ยน. นี่คือความหมายของ translation invariance
• Output ของ C ต่างออกไป: เลื่อนขวา 1 ช่อง. การเลื่อน 2 pixel ข้ามไปอยู่หน้าต่างถัดไป. สไลด์ระบุว่ายังมี invariance 75%

ข้อสรุปของสไลด์: ใส่ max pooling ทุกสองสาม layer ทำให้ได้ translation invariance ระดับหนึ่งในสเกลที่ใหญ่ขึ้น. invariance นี้มีประโยชน์กับงานที่คำตอบไม่ควรขึ้นกับตำแหน่งละเอียด เช่น classification.

7. ประกอบเป็น CNN และตาราง Parameters Summary

หน้า 17 ต่อ convolution สองชั้นเข้ากับ dense layer โดยยังไม่มี pooling. ภาพ 32×32×3 ผ่านชั้นแรก (f = 3, 10 filter, p = 0, s = 1) ได้ \(32 - 3 + 1 = 30\) คือ 30×30×10. ชั้นที่สอง (f = 5, 20 filter, p = 0, s = 2) ได้ \(\lfloor (30-5)/2 \rfloor + 1 = \lfloor 12.5 \rfloor + 1 = 13\) คือ 13×13×20. เมื่อ flatten จะได้ vector ยาว \(13 \times 13 \times 20 = 3{,}380\).

หน้า 20 เพิ่ม max pooling (f = 2, s = 2) หลัง convolution แต่ละชั้น. สไลด์นับ convolution + pooling คู่หนึ่งเป็น 1 layer (Layer 1, Layer 2) เพราะ pooling ไม่มี parameter. dense layer จึงเริ่มที่ Layer 3.

หมายเหตุใต้ตาราง: เมื่อ CNN ลึกขึ้น height and width จะ decrease ส่วน number of channels จะ increase. ในตารางนี้ด้านกว้างเดินเป็น 32 → 30 → 15 → 6 → 3 และ channel เดินเป็น 3 → 10 → 20.

8. ทำไมต้อง ConvNets

CNNs can learn spatial features of images. network มองภาพเป็นกลุ่ม pixel ที่ถ้าอยู่ใกล้กันจะสัมพันธ์กันมาก โดยไม่ขึ้นกับตำแหน่งในภาพ. ตารางสามรูปเดิมจากหน้า 4 กลับมาอีกครั้ง: filter ตัวเดียวที่ตรวจมุมของสี่เหลี่ยมถูกเลื่อนไปทั่วภาพ จึงพบสี่เหลี่ยมได้ทั้งมุมซ้ายบน กลางภาพ และมุมขวาล่าง. ปัญหาข้อ 2 ของ dense network (§1) จึงหมดไป.

CNN ประกอบด้วย locally connected layers ซึ่งใช้ fewer parameters เมื่อเทียบกับ fully connected layer จึงคำนวณน้อยกว่าและ overfit ยากกว่า. มีสองกลไกที่ทำให้ parameter น้อย:

• Local connectivity (sparse connection): ค่า 5 ที่มุมซ้ายบนของ feature map ขึ้นกับ input เพียง 9 ช่องในกรอบ 3×3 เท่านั้น pixel อื่นอีก 27 ช่องไม่มีผลต่อค่านี้
• Weight sharing: neuron ทุกตัวใน feature map เดียวกันใช้ parameter ชุดเดียวกัน. feature map 4×4 มี 16 ค่า แต่ทั้ง 16 ค่าคำนวณจาก weight 9 ตัวและ bias 1 ตัวชุดเดียว: \(3 \times 3 + 1 = 10\) parameter ต่อ filter

9. Design Patterns และ Hyperparameter ของ CNN

Convnet แบบ classical มีสองส่วน:

1. ส่วน feature extraction: ซ้อน convolutional layer สองสามชั้น (แต่ละชั้นตามด้วย ReLU) แล้ว pooling layer แล้ว convolutional layer อีกชุด แล้ว pooling อีก. นิยมจัดกลุ่ม convolutional layer 1–3 ชั้นต่อ pooling 1 ชั้น
2. ส่วน classification: fully-connected layer จำนวนไม่มาก (+ReLU) และ layer สุดท้ายให้ผลทำนาย

ระหว่างเดินผ่าน network image gets smaller and smaller แต่ deeper and deeper (มี feature map มากขึ้น). จำนวน filter โตตามความลึก และมักเพิ่มเป็นสองเท่า (เช่น 32 → 64 → 128).

ตัวอย่างในรูปของสไลด์ตรวจด้วยสูตรได้ทั้งหมด: input 28×28 ผ่าน convolution kernel 5×5 ได้ \(28-5+1 = 24\); max pooling 2×2 ได้ 12; convolution 5×5 ได้ \(12-5+1 = 8\); max pooling 2×2 ได้ 4; จากนั้น flatten เข้า fully connected และ softmax 10 class.

รูป ResNet-34 ในสไลด์เริ่มด้วย convolution 7×7 (64 filter, stride 2) และ max pool 3×3 (stride 2) หนึ่งครั้ง จากนั้นเป็น convolution 3×3 ต่อกันยาว. จุดที่จำนวน filter เพิ่มจาก 64 เป็น 128 ใช้ convolution stride 2 ย่อขนาดแทน pooling. ท้าย network คือ global average pool → fully connected 1000 units → softmax. หมายเหตุของสไลด์: CNN รุ่นใหม่ (เช่น ResNets) use pooling minimally or not at all. รายละเอียด residual unit อยู่ใน Lesson 8.

นอกจาก hyperparameter ทั่วไปของ neural network (Lesson 6) CNN มีของตัวเอง:

10. เขียน CNN ด้วย Keras

โค้ดหน้า 27 คือ network ของหน้า 20–21 ทุกชั้น. model.summary() ให้ตัวเลขชุดเดียวกับที่คำนวณมือใน §7.

model = models.Sequential()
model.add(Conv2D(filters=10,kernel_size=3,activation='relu',input_shape=(32,32,3)))
model.add(MaxPooling2D(pool_size=2,strides=2))
model.add(Conv2D(filters=20,kernel_size=5,strides=2, activation='relu'))
model.add(MaxPooling2D(pool_size=2,strides=2))
model.add(Flatten())
model.add(Dense(100, activation='relu'))
model.add(Dense(100, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
model.summary()

แบบฝึกหัดหน้า 28 กำหนดสถาปัตยกรรม 3 CONV + 3 POOL + 1 FC สำหรับ MNIST (ภาพ 28×28×1, 10 class). ทุก CONV ใช้ f = 3, padding = same, ReLU และจำนวน filter เพิ่มสองเท่า 32 → 64 → 128. (สไลด์พิมพ์ POOL ตัวที่สามว่า "POOL2" ซึ่งหมายถึง POOL3.) โค้ดที่ตรงกับ spec:

model = models.Sequential()
model.add(Conv2D(32, kernel_size=3, activation='relu', padding='SAME', input_shape=(28, 28, 1)))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(64, kernel_size=3, activation='relu', padding='SAME'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Conv2D(128, kernel_size=3, activation='relu', padding='SAME'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Flatten())
model.add(Dense(10, activation='softmax'))
model.summary()

11. Data Augmentation

Data augmentation สร้าง training data เพิ่มจากตัวอย่างที่มีอยู่ด้วยการ augmenting the examples via a number of random transformations (หมุน, เลื่อน, ซูม, กลับด้าน). แนวคิดนี้ปรากฏครั้งแรกใน Lesson 4 ในฐานะวิธีลด overfitting. สไลด์ระบุสามข้อ:

1. มัน not permanently create and store a new dataset. การแปลงเกิด on the fly ขณะประมวลผลแต่ละ training batch. ภาพเดิมจึงถูกแปลงต่างกันทุก epoch และขนาด dataset บนดิสก์ไม่เปลี่ยน
2. ภาพที่โมเดลเห็นยัง still heavily intercorrelated with original images เพราะมาจากภาพต้นฉบับชุดเดิม. data augmentation อย่างเดียวจึง cannot completely get rid of overfitting
3. ไม่ได้เพิ่ม accuracy ของ CNN เสมอไป แต่เพิ่มบ่อย โดยเฉพาะกับ dataset ขนาดเล็ก

Keras ทำ data augmentation ด้วย preprocessing layers ซึ่งวางเป็น layer แรกของโมเดล. ภาพสุนัขสี่ภาพในสไลด์คือภาพต้นฉบับภาพเดียวที่ผ่าน pipeline สี่ครั้ง ได้การหมุน เลื่อน และซูมต่างกันทุกครั้ง.

# Create a data augmentation pipeline
data_augmentation = keras.Sequential([
    # Randomly rotate images by up to ±10% of 360° (±36°)
    keras.layers.RandomRotation(0.1),
    # Randomly shift images vertically and horizontally by up to ±20%
    keras.layers.RandomTranslation(0.2, 0.2),
    # Randomly zoom images by up to ±20%
    keras.layers.RandomZoom(0.2),
    # Randomly flip images horizontally
    keras.layers.RandomFlip("horizontal")
])

model = keras.Sequential([
    keras.Input(shape=(32, 32, 3)),
    data_augmentation,
    keras.layers.Conv2D(32, 3, padding="same", activation="relu"),
    ...
])

ภาคผนวก: Slide ทั้งหมดใน deep_learning_part3_1.pdf (30 หน้า) — เช็คว่าอ่านครบ

สงสัยตรงไหน ถามได้เลยในแชท — ผมเป็นผู้สอนของคุณ ถามซ้ำได้ ถามลึกได้ ไม่ต้องเกรงใจ.