Lecture8 (deep_learning_part3_2.pdf, 37 หน้า) · 2603520 Deep Learning

CNN Architectures, Transfer Learning และ Vision Transformers

Lesson 7 ให้ชิ้นส่วนของ CNN (convolution, pooling, การนับ parameter). บทนี้ใช้ชิ้นส่วนเหล่านั้นตอบสามคำถาม:

1. สถาปัตยกรรมที่มีชื่อแต่ละตัวแก้ปัญหาอะไร (LeNet → AlexNet → VGG → Inception → ResNet → รุ่นใหม่; หน้า 2–20)
2. จะนำโมเดลที่เทรนแล้วมาใช้กับงานของเราอย่างไร (transfer learning สามแบบ และโค้ด Keras; หน้า 21–29)
3. ถ้าไม่ใช้ convolution เลยจะได้อะไร (ViT และ Swin Transformer; หน้า 30–37)

1. ILSVRC และแผนที่วิวัฒนาการของ CNN

หน้า 2 คือสารบัญของครึ่งแรกของบท. แต่ละสถาปัตยกรรมมีหนึ่งคำตอบต่อคำถาม "What Problem Did Each Architecture Solve?":

ImageNet เป็น benchmark สำหรับประเมินอัลกอริทึมจำแนกภาพ (การแข่งขันจัดช่วงปี 2010–2017). ในปี 2012 ILSVRC ให้ภาพความละเอียดสูง 1.2 ล้านภาพ (224×224×3) แบ่งเป็น 1,000 class ซึ่งบาง class ต่างกันน้อยมาก (เช่น สุนัข 120 สายพันธุ์). ตัวเลขสำคัญของสไลด์: top-5 error rate ลดจากมากกว่า 26% เหลือน้อยกว่า 2.3% ภายในหกปี.

2. LeNet-5 (1998): convolution ใช้ได้จริง

LeNet-5 เป็น CNN architecture ที่ widely known ที่สุด และใช้กับ MNIST (LeCun, 1998). ประกอบด้วย 5 weight layers: 3 CONV และ 2 FC โดยมี pooling หลัง CONV ชั้นที่หนึ่งและสอง. ตารางในสไลด์ระบุว่าใช้ average pooling และ activation tanh (ไม่ใช่ max pooling และ ReLU แบบปัจจุบัน).

Main insight discovered: แทนที่จะใช้แต่ละ pixel เป็น input แยกกันของ network ขนาดใหญ่ convolutions ที่มี learnable parameters สามารถ extract spatial features ที่กระจายอยู่ทั่วทั้งภาพ. LeNet-5 ได้ accuracy สูงกว่า 99% แต่ MNIST เป็น dataset ที่ very simple เพราะเป็นภาพ grayscale และมีเพียง 10 class.

3. AlexNet (2012): ลึกขึ้น ใหญ่ขึ้น

AlexNet (Krizhevsky et al.) คือ LeNet-5 รุ่นที่ deeper (hidden layer มากขึ้น) และ larger (filter ต่อ layer มากขึ้น). ชนะ ILSVRC 2012 ด้วย top-5 test error rate 15.3% ขณะที่อันดับสองได้ 26.2%. เป็น real “deep” network ตัวแรกที่เปิดทาง for CV community ให้พิจารณา CNN อย่างจริงจัง. เทรนบนภาพ 1.2 ล้านภาพ 1,000 class ใช้ 60 million parameters และ 650,000 neurons.

AlexNet ใช้เทคนิคใหม่หลายอย่างเพื่อให้ deeper (8 weight layers: 5 CONV + 3 FC) กว่า LeNet:

• ReLU ซึ่งช่วยบรรเทา vanishing-gradient เมื่อเทียบกับ sigmoid/tanh (Lesson 5)
• สามเทคนิคเพื่อ overcome overfitting: (1) drop-out (2) data augmentation (3) l2 regularizations
• local response normalization เพื่อเร่ง convergence และเทรนบน GPU สองตัว (NVIDIA GTX 580 ที่มี memory เพียง 3GB) เพื่อลดเวลาเทรน
• เป็นตัวแรกที่ซ้อน convolutional layer ต่อกันโดยตรง (C5, C6, C7) แทนการวาง pooling หลังทุก convolutional layer

ข้อเสีย: AlexNet มี many hyperparameters to tune (kernel 11, 5, 3; stride 4, 1; padding valid/same ต่างกันทุกชั้น) ทำให้เข้าใจและจัดการยาก. ข้อเสียนี้คือโจทย์ที่ VGG แก้ใน §4.

model = Sequential()
# C1 Convolutional Layer
model.add(Conv2D(filters=96,kernel_size=11,strides=4,activation='relu',input_shape=(224,224,3),padding='valid'))
# S2 Pooling Layer
model.add(MaxPooling2D(pool_size=3,strides=2))
model.add(Lambda(tf.nn.local_response_normalization))
# C3 Convolutional Layer
model.add(Conv2D(filters=256,kernel_size=5,strides=1,activation='relu',padding='same',kernel_regularizer=l2(0.0005)))
# S4 Pooling Layer
model.add(MaxPooling2D(pool_size=3,strides=2))
model.add(Lambda(tf.nn.local_response_normalization))
# C5 Convolutional Layer
model.add(Conv2D(filters=384,kernel_size=3,strides=1,activation='relu',padding='same',kernel_regularizer=l2(0.0005)))
model.add(Lambda(tf.nn.local_response_normalization))
# C6 Convolutional Layer
model.add(Conv2D(filters=384,kernel_size=3,strides=1,activation='relu',padding='same',kernel_regularizer=l2(0.0005)))
model.add(Lambda(tf.nn.local_response_normalization))
# C7 Convolutional Layer
model.add(Conv2D(filters=256,kernel_size=3,strides=1,activation='relu',padding='same',kernel_regularizer=l2(0.0005)))
model.add(Lambda(tf.nn.local_response_normalization))
model.add(MaxPooling2D(pool_size=3,strides=2))

model.add(Flatten())
# FC8 Fully Connected Layer
model.add(Dense(units=4096,activation='relu'))
model.add(Dropout(0.5))
# FC9 Fully Connected Layer
model.add(Dense(units=4096,activation='relu'))
model.add(Dropout(0.5))
# FC10 Output layer with softmax activation
model.add(Dense(units=1000,activation='softmax'))

4. VGGNet (2014): บล็อก 3×3 ซ้ำกันทั้ง network

VGG (Visual Geometry Group, Oxford University) ได้ top-5 error rate 7.3% เป็น runner up ปี 2014. จุดเด่นคือ uniform architecture และ reduced filter size (เทียบกับ AlexNet) เพื่อให้เรียนเร็วขึ้นและทนต่อ overfitting มากขึ้น. รูป VGG16 แสดงรูปแบบที่สม่ำเสมอ: ทุกครั้งที่ pooling ลดด้านลงครึ่ง จำนวน channel เพิ่มสองเท่า: 224×224×64 → 112×112×128 → 56×56×256 → 28×28×512 → 14×14×512 → 7×7×512 แล้วต่อด้วย FC 4096, 4096, 1000.

VGG แก้ปัญหาการตั้ง hyperparameter ของ convolutional และ pooling layer ด้วย one uniform configuration ที่ใช้ทั้ง network:

• convolutional layer ทุกชั้น: filter 3×3, stride = 1, padding = 'same'
• pooling layer ทุกชั้น: pool size 2×2, stride = 2

การกำหนดค่าแบบเดียวนี้ทำให้สถาปัตยกรรม easy to understand and implement. VGG ปรับปรุง AlexNet โดยแทน filter ขนาดใหญ่ (11 และ 5 ในสองชั้นแรก) ด้วย multiple 3 × 3 filters ต่อกัน. เหตุผลในสไลด์: ที่ receptive field เท่ากัน multiple stacked smaller kernels ดีกว่า kernel ใหญ่ตัวเดียว เพราะมี nonlinear layer หลายชั้นจึงเพิ่มความลึก ทำให้ learn more complex features at a lower cost จากการที่มี parameter น้อยกว่า.

5. Inception และ GoogLeNet (2014): หลายขนาด filter พร้อมกัน + 1×1 bottleneck

Inception แก้โจทย์เดียวกับ VGGNet. เผยแพร่ในบทความ "Going Deeper with Convolutions" ของนักวิจัย Google (2014). รุ่นหนึ่งคือ GoogLeNet ซึ่งชนะ ILSVRC 2014 ด้วย top-5 error rate 6.67% (ใกล้ระดับมนุษย์). เอกลักษณ์คือการสร้าง deeper neural network ที่

• extract features จาก input at varying scales ด้วย convolutional filter หลายขนาด
• ปรับปรุง utilization of the computing resources ภายใน network (ลด parameter เหลือราว 13 ล้าน น้อยกว่า VGG16 ราว 12 เท่า)

การทำงานของ inception module ตามรูป:

1. input ถูก copy ส่งเข้า 4 เส้นทางขนาน: (ก) conv 1×1 (ข) conv 1×1 → conv 3×3 (ค) conv 1×1 → conv 5×5 (ง) max pool 3×3 → conv 1×1
2. ทุก layer ใช้ stride 1 และ padding "same" จึงได้ output กว้าง×สูงเท่ากันทุกเส้นทาง
3. conv 1×1 (เรียกว่า bottleneck layer) เรียน pattern ข้าม depth ของ input และลด depth ลง จึงลดการคำนวณ
4. convolutional layer ทุกตัวใช้ ReLU
5. ผลของ 4 เส้นทางถูก concatenate ตาม depth เป็นบล็อก Filter Concatenation

ทุกค่าของ output ต้องคูณ f×f ครั้งต่อ channel ของ input

GoogLeNet มี 22 layers: (1) ชุด CONV และ POOL ก่อน inception module เหมือน AlexNet และ LeNet (2) inception module 9 ตัว (ตัวละ 2 layers) มี max pooling คั่นทุกสองสามบล็อกเพื่อลดมิติ (3) ส่วน classifier คือ fully connected และ softmax. GoogLeNet deeper (wider) กว่า CNN ก่อนหน้ามาก แต่ใช้ parameter น้อยกว่า AlexNet 10 เท่า (6 ล้าน จาก 60 ล้าน). Inception มีรุ่นอื่นอีก เช่น Inception-v3 และ Inception-v4.

• แทนการเลือกขนาด filter ของ CONV layer และตำแหน่งของ pooling ให้ apply all of them พร้อมกันในบล็อกเดียว เรียกว่า "Inception Module"
• แทนการซ้อน layer ทีละชั้นแบบ classical ให้สร้าง inception module ที่มี convolutional layer หลายขนาด kernel แล้วสร้างสถาปัตยกรรมด้วยการ stacking the inception modules on top of each other
• 1x1 CONV layer รักษา spatial dimensions (H & W) ของ input แต่เปลี่ยนจำนวน channel (depth). วาง 1×1 ไว้ก่อน kernel ใหญ่ (3×3, 5×5) เพื่อ reduce their depth ซึ่งจะ reduce the number of operations

6. ResNet (2015): skip connection ทำให้ network ลึกมากเทรนได้

ResNet (He et al., Microsoft Research) ใช้แนวทางเดียวกับ Inception คือสร้างบล็อกแล้วนำมาซ้อน. ชนะ ILSVRC 2015 ด้วย top-5 error rate 4.49%. ใช้ skip (or shortcut) connections ระหว่างทุกสอง CONV layer. การเชื่อมนี้สร้าง residual blocks ซึ่งทำให้สร้าง network ลึกได้โดยแก้ vanishing gradient problem. จึงเทรน network ที่มี 50, 101 และ 152 weight layers ได้โดยยังมี complexity ต่ำกว่า. Skip connection ยังทำให้ residual block เรียน identity mapping ได้ง่ายเมื่อการแปลงเพิ่มเติมไม่มีประโยชน์.

รูปซ้ายของสไลด์เทียบสองบล็อก. ให้ \(h(x)\) คือฟังก์ชันที่ต้องการให้บล็อกเรียน.

• บล็อกธรรมดา: Layer 1 → Layer 2 ต้องเรียน \(h(x)\) โดยตรง
• Residual block: input \(x\) ถูกส่งข้ามสอง layer ไปบวกกับ output. สอง layer จึงเรียนเพียงส่วนต่าง

บล็อกเรียนเฉพาะ "ส่วนที่ต้องเพิ่มจาก input" (residual) ไม่ต้องสร้าง output ทั้งหมดใหม่

รุ่นที่ชนะใช้ CNN ลึก 152 layers (รุ่นอื่นมี 18, 34, 50, 101). ตัวอย่างในสไลด์คือ Resnet-34:

• ต้นและท้ายเหมือน GoogLeNet (แต่ไม่มี dropout layer) ตรงกลางคือ residual unit ซ้อนกันลึกมาก
• residual unit แต่ละตัวมี convolutional layer สองชั้น (ไม่มี pooling) พร้อม Batch Normalization (BN) และ ReLU ใช้ kernel 3×3 และรักษา spatial dimensions (stride 1, "same" padding)
• มี no pooling layers ใน residual block. ใน ResNet-50, ResNet-101 และ ResNet-152 ผู้ออกแบบลดมิติด้วย bottleneck 1x1 convolutional layers แบบเดียวกับ Inception

• ResNet สร้าง deeper networks กว่าสถาปัตยกรรมอื่น
• นำเสนอ "skip connections" ที่เรียกว่า residual module. ข้อมูลไหลจาก layer ต้นไป layer หลังได้ และเกิด shortcut path ให้ gradient to flow
• ใช้ batch normalization อย่างหนักกับ hidden layers
• Breakthrough: เทรน network ลึกหลายร้อยชั้นได้ ซึ่งเดิมทำยากเพราะ vanishing gradients

จำนวน layer เพิ่มทุกรุ่น (5 → 8 → 16 → 22 → 152) และ error ลดทุกรุ่น (15.3 → 7.3 → 6.67 → 4.49). หมายเหตุในสไลด์: Inception-v4 ของ Google รวมแนวคิดของ GoogLeNet และ ResNet ได้ top-five error ใกล้ 3%.

FLOP (Floating Point Operations) คือจำนวนการคำนวณของ forward pass หนึ่งครั้ง. อ่านตารางเป็นการแลกเปลี่ยน: Inception ได้ accuracy สูงกว่า VGGNet 1 จุด (93.30 เทียบกับ 92.30) ด้วย parameter น้อยกว่า \(138 / 6.4 \approx 21.6\) เท่า และ FLOP น้อยกว่า \(19.6 / 2 \approx 9.8\) เท่า. ResNet-152 ลึกกว่า VGG16 เกือบ 10 เท่า (152 เทียบกับ 16 layers) แต่มี parameter น้อยกว่าครึ่ง (60.3M เทียบกับ 138M). ความสัมพันธ์ accuracy กับ error: \(100 - 95.51 = 4.49\%\) ตรงกับ top-5 error ของ ResNet-152.

7. Modern CNNs และหลักออกแบบสถาปัตยกรรม

Modern CNN design is no longer simply "make the network deeper." สถาปัตยกรรมรุ่นใหม่ต้องสมดุล accuracy, parameters, computation, memory, and inference speed. ห้ารุ่นและแนวคิดหลัก:

Xception (eXtreme Inception; Chollet, 2016) ทำได้ดีกว่า Inception-v3 อย่างชัดเจนในงานขนาดใหญ่ (350 ล้านภาพ, 17,000 class). เหมือน Inception-v4 ตรงที่รวมแนวคิดของ GoogLeNet และ ResNet แต่แทน inception module ด้วย depthwise separable convolutional layer.

Convolution ปกติจับ spatial pattern (เช่น รูปวงรี) และ cross-channel pattern (เช่น ปาก + จมูก + ตา = หน้า) พร้อมกัน. Separable convolution ตั้งสมมติฐานว่า spatial patterns and cross- channel patterns can be modeled separately จึงแบ่งเป็นสองส่วน:

1. Depthwise (spatial-only filters): ใช้ spatial filter 1 ตัวต่อ 1 input feature map (1 per input channel)
2. Pointwise: convolutional layer ปกติที่ใช้ filter 1×1 ซึ่งมองหาเฉพาะ cross-channel pattern

Separable convolutional layer ใช้ fewer parameters (reduce overfitting) ใช้ memory น้อยกว่า และคำนวณน้อยกว่า convolution ปกติ และโดยทั่วไปทำงานได้ดีกว่าด้วย.

ตัวอย่าง DenseNet เป็นตัวเลข: ถ้าทุก layer ใน block ให้ output 32 channel และ input ของ block มี 64 channel, layer 4 จะรับ \(64 + 32 + 32 + 32 = 160\) channel. การนำ feature เดิมกลับมาใช้ (feature reuse) ทำให้แต่ละ layer ต้องผลิต feature ใหม่เพียงเล็กน้อย.

เมื่อต้องสร้าง CNN มีสองทางเลือก.

1. Build model from scratch (หลักจากหนังสือ Deep Learning with Python):

• จัดโมเดลเป็น repeated blocks of layers ซึ่งมักประกอบด้วย convolution หลายชั้น
• จำนวน filter ควรเพิ่มเมื่อขนาด spatial feature map ลด
• Deep and narrow ดีกว่า broad and shallow
• ใส่ residual connection รอบบล็อกช่วยให้เทรน network ลึกขึ้นได้
• ใส่ batch normalization หลัง convolution layer อาจช่วย
• แทน Conv2D ด้วย SeparableConv2D ซึ่ง parameter-efficient กว่า อาจช่วย

2. Use transfer learning โดยเฉพาะเมื่อ dataset เล็ก.

หมายเหตุ: ใช้ hyperparameter tuning (Lesson 6) หาค่าที่เหมาะได้ แต่ใช้เวลามาก. วิธีที่ใช้ทั่วไปคือสร้างต่อยอดจากสถาปัตยกรรม CNN ที่มีอยู่.

8. Transfer Learning: แนวคิด สามแนวทาง และ Guidelines

แทนการเทรนโมเดลขนาดใหญ่มากจากศูนย์ เราสามารถ reuse a pretrained layers with its optimized weights ของ existing model ที่เทรนบน dataset ขนาดใหญ่มาแล้ว เพื่อเทรน our model. Transfer learning คือการถ่ายโอนความรู้จาก pretrained model มายังโมเดลของเรา. ได้ผลดีมากกับ small image datasets, speed up training considerably และ generalize the learning and avoid overfitting.

ตัวอย่างในสไลด์: Model A จำแนกภาพเป็นหลายประเภท (สัตว์, พืช, ยานพาหนะ และวัตถุอื่น). Model B ต้องจำแนกเฉพาะชนิดของยานพาหนะ (แท็กซี่, ตุ๊กตุ๊ก, รถตู้, สามล้อ). Model A เรียน feature ระดับล่าง (ขอบ, สี, ล้อ, กระจก) มาแล้ว Model B จึงนำ layer เหล่านั้นมาใช้ได้โดยไม่ต้องเรียนใหม่.

• The input pictures ของงานใหม่ ควรมี the same size กับที่ใช้ใน original task (resize ให้ตรงกับที่โมเดลเดิมคาดหวัง). แต่ตั้งขนาดเล็กลงได้ถ้าต้องการลด computation
• hidden layers ของโมเดลเดิม: layer ต้นของโมเดลสกัด feature map ที่ local และ generic มาก (visual edges, colors, textures) จึงน่าจะ reuse lower layers กับงานของเราได้
• The output layer ของโมเดลเดิม ควรถูกแทนที่ (usually be replaced) เพราะมักไม่มีประโยชน์กับงานใหม่ และอาจมีจำนวน output ไม่ตรง

รูปในสไลด์: DNN เดิมของ task A มี Hidden 1–5. DNN ใหม่ของ task B ที่คล้ายกันนำ Hidden 1–4 มาใช้ โดย Hidden 1–2 เป็น fixed weights (frozen) และ Hidden 3–4 เป็น trainable weights. Hidden 5 และ Output เดิมถูกทิ้ง แล้วใส่ Output ใหม่.

Choose the appropriate levels of tuning based on two important factors. ได้แก่ (1) domain similarity of the source and target domain และ (2) amount of data ที่มี (small หรือ large). Dataset เล็กมักทำให้ overfit จึง fine tune น้อยลงและพึ่ง source dataset มากขึ้น.

หลักเบื้องหลังตาราง: ยิ่ง domain ต่างจาก source มาก feature ระดับสูงของโมเดลเดิมยิ่งใช้ไม่ได้ จึงต้องปลด freeze ย้อนไปถึง layer ต้นขึ้น (freeze น้อยลง). ยิ่งข้อมูลมาก ยิ่งเทรน layer จำนวนมากได้โดยไม่ overfit.

Use smaller learning rate when fine tuning. weight ของ pretrained model ถือว่าดีอยู่แล้ว จึงไม่ต้องการบิดมันเร็วเกินและมากเกิน.

Some strategies to help convergence (if any problem):

1. output layer ใหม่ถูกกำหนดค่าเริ่มต้นแบบสุ่ม จึงผิดพลาดมากในช่วง epoch แรกๆ ทำให้เกิด large error gradients ที่อาจทำลาย weight ที่นำมาใช้ซ้ำ
2. วิธีหนึ่งคือ freeze layer ที่นำมาใช้ซ้ำในช่วง epoch แรก เพื่อ giving the new layer some time to learn reasonable weights.
3. เทรนสองสาม epoch then unfreeze the reused layers (ซึ่งต้อง compile โมเดลใหม่) แล้วเทรนต่อเพื่อ fine-tune layer เหล่านั้น
4. หลัง unfreeze ควร reduce the learning rate อีกครั้งเพื่อไม่ให้ weight ที่นำมาใช้ซ้ำเสียหาย

9. ตัวอย่าง Dog-Cat: สามแนวทางด้วย VGG16 ใน Keras

โจทย์: จำแนกภาพสุนัขหรือแมวด้วย pretrained model คือ VGG. Dataset มี 4,000 ภาพ (สุนัขและแมวอย่างละ 2,000). ขั้นแรกตามสไลด์คือ create directory in the structure format that Keras's ImageDataGenerator can read the images from folders containing images: โฟลเดอร์ cats_and_dogs_small มี train, validation, test และแต่ละโฟลเดอร์มีโฟลเดอร์ย่อย cats, dogs. ชื่อโฟลเดอร์ย่อยถูกใช้เป็น label.

train_dataset = image_dataset_from_directory(
    train_dir,
    image_size = (224,224),
    batch_size = 64
)
val_dataset = image_dataset_from_directory(
    validation_dir,
    image_size = (224,224),
    batch_size = 64
)
test_dataset = image_dataset_from_directory(
    test_dir,
    image_size = (224,224),
    batch_size = 64
)

for data_batch, labels_batch in train_dataset.take(1):
    print("data batch shape", data_batch.shape)
    print("label batch shape", labels_batch.shape)
    print("labels_batch", labels_batch)

ผลลัพธ์ที่พิมพ์ในสไลด์: data batch shape (64, 224, 224, 3), label batch shape (64,) และ labels_batch เป็น tensor ของ 0/1 จำนวน 64 ค่า (dtype=int32). Train set มี 2,000 ภาพ จึงมี \(\lceil 2000/64 \rceil = 32\) batch ต่อ epoch (31 batch เต็ม และ batch สุดท้าย \(2000 - 31 \times 64 = 16\) ภาพ).

Approach #1: Pretrained model as a classifier. โหลด VGG16 ทั้งตัวรวม classifier 1,000 class แล้วทำนายทันที ไม่มีการเทรน.

# load the VGG16 model and its pretrained weights
model = VGG16(weights="imagenet", include_top=True,input_shape=(224,224,3))
model.summary()

# load an image from a file
image = load_img('S__5988354.jpg',target_size=(224,224))
# convert the image pixels to a numpy array
image = img_to_array(image)
plt.imshow(image/255)

# reshape data for the model
image = image.reshape((1,image.shape[0],image.shape[1],image.shape[2]))
# print(image.shape) #(1, 224, 224, 3)
# BGR and zero-centered
image = preprocess_input(image)
image

# predict the probabilites across all output classes
pred = model.predict(image)
# decode_predictions() - display the top K predictions,
# including theclass name and the estimated probability of each predicted class
# let 's convert the probabilities to class labels
label = decode_predictions(pred)

Approach #2: Pretrained model as feature detector. โหลดเฉพาะ conv base (include_top=False) แล้วต่อ classifier ใหม่. สไลด์แสดงสองวิธี.

วิธี A — Without Data Augmentation: ส่งภาพทั้งหมดผ่าน conv base ครั้งเดียวแล้วเก็บ feature เป็น array จากนั้นเทรน classifier เล็กๆ บน feature เหล่านั้น.

# instantiate the VGG16 model.
conv_base = VGG16(weights='imagenet',include_top=False,input_shape=(224,224,3))

# extracting features as NumPy arrays by calling the predict() method of the VGG model on our training, validation, and testing datasets.
def get_features_and_labels(dataset):
  all_features = []
  all_labels = []
  for images, labels in dataset:
    # the VGG16 model expects inputs that are preprocessed with the function preprocess_input, which scales pixel values to an appropriate range.
    preprocessed_image = preprocess_input(images)
    features = conv_base.predict(preprocessed_image)
    all_features.append(features)
    all_labels.append(labels)
  # predict() only expects images, not labels, but our current dataset yields batches that contain both images and their labels.
  return np.concatenate(all_features),np.concatenate(all_labels)

train_features, train_labels = get_features_and_labels(train_dataset)
val_features, val_labels = get_features_and_labels(val_dataset)
test_features, test_labels = get_features_and_labels(test_dataset)
train_features.shape # (2000, 7, 7, 512)

def build_model_feature_extractor1():
  model = Sequential()
  model.add(Flatten(input_shape=(last_layer.output_shape[1:])))
  model.add(Dense(256, activation='relu'))
  model.add(Dropout(0.5))
  model.add(Dense(1, activation='sigmoid'))
  return model

วิธี B — With Data Augmentation: วิธี A ใช้ augmentation ไม่ได้ เพราะ feature ถูกคำนวณครั้งเดียวจากภาพเดิม. วิธี B จึงวาง conv base ไว้ในโมเดล เพื่อให้ภาพที่ถูก augment ใหม่ทุก epoch ไหลผ่าน conv base ทุกครั้ง และต้อง freeze conv base ด้วย conv_base.trainable = False.

conv_base.trainable = False

def build_model_feature_extractor2():
  model = Sequential()
  model.add(Input(shape=(224,224,3)))
  model.add(data_augmentation)
  model.add(Lambda(lambda x: preprocess_input(x)))
  model.add(conv_base) #models behave just like layers
  model.add(Flatten())
  model.add(Dense(256, activation='relu'))
  model.add(Dropout(0.5))
  model.add(Dense(1, activation='sigmoid'))
  return model

Approach #3: Fine Tuning. freeze conv base ถึง block4 และปล่อย block5 (convolution สามชั้นสุดท้าย) ให้เทรนร่วมกับ classifier ใหม่.

#instantiate the VGG16 model.
conv_base = VGG16(weights='imagenet',include_top=False,input_shape=(224,224,3))
conv_base.summary()

set_trainable = False
for layer in conv_base.layers:
  if layer.name == 'block5_conv1':
    set_trainable = True
  if set_trainable:
    layer.trainable = True
  else:
    layer.trainable = False
  print("layer name",layer.name, layer.trainable)

def build_model_fine_tuning2():
  inputs = Input(shape=(224,224,3))
  x = data_augmentation(inputs)
  x = preprocess_input(x)
  x = conv_base(x)
  x = Flatten()(x)
  x = Dense(256, activation='relu')(x)
  x = Dropout(0.5)(x)
  outputs = Dense(1, activation='sigmoid')(x)
  model = Model(inputs,outputs)
  return model

10. Beyond CNNs: Vision Transformer และ Swin Transformer

โมเดล vision รุ่นใหม่แทนภาพเป็น patch แล้วประมวลผลด้วยสถาปัตยกรรมแบบ Transformer เช่น ViT และ Swin Transformer:

• replace convolution with attention → ViT
• recover hierarchy/locality in ViT → Swin Transformer

สไลด์หมายเหตุว่ารายละเอียดของ attention และ transformer จะเรียนในคาบถัดไป. ในบทนี้ให้เข้าใจ self-attention ว่าเป็นกลไกที่ทุก token คำนวณความสัมพันธ์กับ token อื่นแล้วรวมข้อมูลตามน้ำหนักความสัมพันธ์นั้น.

ViT (Dosovitskiy et al., 2020) ใช้ Transformer architecture to image recognition. ขั้นตอนตามสไลด์:

1. แทนการใช้ convolutional filter ViT แบ่งภาพเป็น fixed-size patches และถือแต่ละ patch เป็น token เหมือน token ใน NLP
2. แต่ละ patch ถูก flatten แล้วแปลงเชิงเส้นเป็น vector ขนาดคงที่ เรียกว่า patch embedding
3. บวก position embeddings เข้ากับ patch embedding เพื่อให้โมเดลรู้ว่า patch อยู่ตรงไหนของภาพ
4. ลำดับของ patch embedding ถูกประมวลผลด้วย Transformer ซึ่งเรียน relationships among these patches (self-attention) ทำให้ข้อมูลจาก different parts of the image ถูก combined for prediction

• Patch-based representation: ภาพถูกแทนด้วยลำดับของ image patch
• No convolution is required ในสถาปัตยกรรม ViT ดั้งเดิม
• จำลองความสัมพันธ์ระหว่าง different image regions ด้วย self-attention
• มี less built-in image-specific inductive bias กว่า CNN (CNN ถูกออกแบบให้เชื่อว่า pixel ใกล้กันสัมพันธ์กัน; ViT ต้องเรียนสิ่งนี้จากข้อมูล)
• ได้ประโยชน์มากจาก large-scale pretraining และ pretrained ViT นำไป transfer/fine-tune กับงาน downstream ได้

ViT ทำ global self-attention ระหว่างทุก patch. สไลด์ระบุปัญหาสองข้อ:

1. Global self-attention computational expensive เมื่อจำนวน patch เพิ่ม. ภาพความละเอียดสูงมี patch มาก การให้ทุก patch โต้ตอบกันทั้งหมดจึงแพงขึ้นตามความละเอียด
2. ViT ดั้งเดิมคง single-scale representation ต่างจาก hierarchical feature map ของ CNN. Multi-scale feature มีประโยชน์กับ object detection and segmentation ที่วัตถุมีหลายขนาด (ความละเอียดสูงเก็บรายละเอียดเชิงพื้นที่; ความละเอียดต่ำเก็บ representation ระดับสูง)

คำถามที่ Swin ตอบ: คง vision แบบ Transformer ไว้โดยทำให้ more hierarchical and efficient ได้หรือไม่. Swin รวม Transformer-based feature learning กับ locality และ hierarchical representations.

แทนที่จะให้ทุก patch attend ไปยัง every other patch, Swin (from Shifted Window) แบ่ง feature map เป็น windows เล็กๆ. คำนวณ self-attention ภายใน local windows and shifts those windows between layers พร้อมสร้าง hierarchical feature maps:

• แบ่ง image representation เป็น local windows
• คำนวณ within each window ไม่ใช่ global ข้ามทุก patch
• Window ถูก shifted between successive layers ทำให้ข้อมูลไหลข้าม window ที่อยู่ติดกันได้

รูปในสไลด์: Layer l แบ่งเป็น 4 window ปกติ. Layer l+1 เลื่อนขอบ window ไปครึ่งหนึ่ง patch ที่เคยอยู่คนละ window จึงมาอยู่ window เดียวกัน. หมายเหตุ: Swin reintroduces locality คือการประมวลผลช่วงต้นเกิดระหว่าง patch ใกล้กัน คล้าย local processing ของ CNN แต่ยังเป็น self-attention.

เมื่อ network ลึกขึ้น: fewer spatial locations / higher-level features. สิ่งนี้สร้าง hierarchical, multi-scale feature maps คล้ายลำดับชั้น feature ของ CNN. Swin ออกแบบเป็น general-purpose backbone สำหรับ classification, object detection และ segmentation.

อ่านตารางตามคอลัมน์: Swin ใช้ basic unit เดียวกับ ViT (patch tokens) แต่ในหกแถวที่เหลือมีคุณสมบัติตรงกับ CNN (local, progressive, hierarchical, multi-scale, มี downsampling, scale ได้). Swin จึงเป็น Transformer ที่นำข้อดีเชิงโครงสร้างของ CNN กลับมา.

สรุปทั้งบทตามสไลด์:

• CNNs: ปรับปรุงสถาปัตยกรรม convolution ทีละขั้น. Classical Architecture: LeNet → AlexNet → VGG → Inception → ResNet. Modern Architecture: Xception / MobileNet / DenseNet / EfficientNet / ConvNeXt
• Transformers: ViT ถามว่า convolution จำเป็นหรือไม่; Swin ปรับ vision แบบ Transformer ไปสู่ locality, hierarchy และ multi-scale tasks

กราฟในสไลด์แสดง ImageNet-1K accuracy: กลุ่มที่เทรนบน ImageNet-1K อยู่ช่วง 78–84% (ResNet ต่ำสุด, Swin และ ConvNeXt สูงสุด); กลุ่มที่ pretrain บน ImageNet-22K (ViT, Swin, ConvNeXt) ขึ้นไปถึง 85–88%. ทั้งสองข้อสอดคล้องกับที่สไลด์กล่าว: Transformer ได้ประโยชน์จาก large-scale pretraining และ ConvNeXt ซึ่งเป็น CNN ล้วนยังแข่งขันได้.

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

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