Chương D · encoder ảnh chuẩn — vì sao không trải phẳng mọi pixel vào MLP

Khung 6 câu hỏi

🖼️ Hình nhanh: Conv nhìn cục bộ + chia sẻ lọc; sâu hơn → “cửa sổ” lớn hơn (receptive field).
```
Ảnh conv 3×3 conv+pool head
┌────┐ cạnh/texture bộ phận class/bbox/π
│····│ ──► [████] ─────► [────────] ─────► (actor/critic)
│·██·│ RF nhỏ RF lớn
└────┘

MLP phẳng: mỗi pixel ↔ mọi trọng số → ★ nổ tham số, mất tính cục bộ
CNN: cùng bộ lọc trượt khắp ảnh → ít tham số, đẳng biến tịnh tiến ≈
```

🇻🇳 Chuyện thật (sân A): Weight sharing = cùng một kính lúp trượt trên ảnh luống chè — cạnh lá / khoảng trống được nhận cùng một bộ lọc dù nằm góc nào của khung hình.
MLP trải phẳng thì mỗi vị trí pixel có “kính” riêng: nổ tham số, mất tính cục bộ, khó học khi data drone vốn ít.
Chốt: CNN là inductive bias đúng cho ảnh phủ / detect trước khi gắn head policy. ../00C.

Hình minh họa (seminar-ready)

Hình gốc hoặc minh họa cho ebook — không cắt từ slide Princeton. Dùng Present: bật Slide · F toàn màn.

0. Mục tiêu học

1. Giải thích vì sao convolution phù hợp ảnh hơn MLP trải phẳng.
2. Hiểu receptive field tăng theo độ sâu / stride / dilation.
3. Biết pattern triển khai UAV: CNN encoder + policy head; freeze encoder khi ít sample.
4. Đồng bộ ràng buộc tần số: mạng 5 Hz ≠ policy 20 Hz — hai bài toán khác nhau.
5. Nêu khi nào không cần CNN (obs đã là vector ngắn đủ thông tin).

1. Trực giác

Nhận mặt người: trước hết thấy cạnh mắt/mũi, sau mới ghép thành “đó là An”.
CNN bắt chước sự xếp tầng đó: lọc cục bộ → khái niệm lớn dần theo độ sâu.

Nhận diện ổ gà trên đường: bạn dùng cùng một “mẫu nhìn” ở mọi chỗ trên ảnh — đó là weight sharing. Không cần học lại từ đầu cho góc trên-trái và dưới-phải.

Với ảnh đồi chè từ UAV: lớp nông bắt ranh hàng / texture lá; lớp sâu bắt “khối hàng chưa phủ” hay “vật cản”. Nếu bạn flatten 84×84×3 vào MLP, mạng phải tự học lại rằng pixel cạnh nhau liên quan — vừa tốn mẫu vừa dễ overfit (Lec 21).

2. Cốt lõi + sơ đồ

2. Cốt lõi + sơ đồ

2.1. Convolution vs MLP

\[ (I * k)(x,y) = \sum_{i,j} I(x+i,y+j)\,k(i,j) \]

2. Cốt lõi + sơ đồ

2.2. Stack và receptive field

ảnh H×W×3
 │
 ▼
[conv + ReLU] × N     ← cạnh, gradient cục bộ   (RF nhỏ)
 │
 ▼
 pool / stride         ← RF tăng, độ phân giải giảm
 │
 ▼
[conv + ReLU] × M     ← bộ phận / texture hàng chè  (RF lớn)
 │
 ▼
 head: class | bbox | depth | π_θ (± V_φ)

Thực dụng: YOLO / Faster R-CNN (detection), U-Net / DeepLab (segmentation). Trên Crazyflie-class: mạng thường chạy trên laptop/companion (≥ ~30 Hz ở Lab 4), không phải MCU bay.

2. Cốt lõi + sơ đồ

2.3. Đếm tham số (trực giác số)

Ảnh 64×64, ẩn 128:
  MLP 1 lớp:  64*64 * 128 ≈ 524k trọng số (chỉ một lớp!)
  Conv 3×3, 32 kênh: 3*3*3*32 ≈ 864 trọng số / lớp (RGB→32)
★ CNN thắng vì chia sẻ — không vì “thần kỳ deep learning”.

3. Demo — MLP vs conv: tham số và dịch ảnh

"""
Demo Lec22: (1) đếm tham số MLP vs conv;
(2) hiện tượng: lọc cạnh 3×3 cho đáp ứng dịch khi ảnh dịch — tinh thần equivariance.
"""
import numpy as np

H = W = 64
mlp_in = H * W
mlp_hidden = 128
mlp_params = mlp_in * mlp_hidden + mlp_hidden  # +bias
conv_params = 3 * 3 * 1 * 32 + 32             # 1 kênh → 32, +bias
print("Tham số MLP một lớp ~", mlp_params)
print("Tham số conv 3×3×32 ~", conv_params)
print("Tỉ lệ MLP/conv      ~", round(mlp_params / conv_params, 1))

# Ảnh có một cạnh dọc; dịch sang phải
img = np.zeros((7, 7))
img[:, 2] = 1.0
img_shift = np.zeros_like(img)
img_shift[:, 3] = 1.0

# Lọc gradient ngang Sobel-ish
k = np.array([[-1, 0, 1],
              [-2, 0, 2],
              [-1, 0, 1]], dtype=float)

def conv2d_valid(x, k):
    kh, kw = k.shape
    out = np.zeros((x.shape[0] - kh + 1, x.shape[1] - kw + 1))
    for i in range(out.shape[0]):
        for j in range(out.shape[1]):
            out[i, j] = np.sum(x[i:i+kh, j:j+kw] * k)
    return out

r0 = conv2d_valid(img, k)
r1 = conv2d_valid(img_shift, k)
# So khớp: đáp ứng gốc dịch 1 cột có gần đáp ứng ảnh dịch không?
r0_shifted = np.zeros_like(r1)
r0_shifted[:, 1:] = r0[:, :-1]
err = np.mean(np.abs(r1 - r0_shifted))
print("||resp(shift(img)) - shift(resp(img))|| ~", round(float(err), 6))
print("→ Conv: dịch ảnh ≈ dịch feature (trong vùng hợp lệ). MLP phẳng không có sẵn.")

🧪 Kỳ vọng demo:
- MLP một lớp có ~ hàng trăm nghìn tham số; conv 3×3×32 chỉ ~ hàng trăm–nghìn.
- Sai số equivariance gần 0 trên ví dụ cạnh dịch — minh họa vì sao CNN “hiểu” tịnh tiến.
- Kết luận: ảnh cần inductive bias cục bộ trước khi đổ sample RL.

4. Gắn RL–UAV

• Mẫu chuẩn: CNN encoder + policy head (actor) ± value head (critic).
• Đóng băng encoder pretrained (ImageNet/COCO/drone data) rồi RL chỉ train head: thường ít mẫu hơn train end-to-end từ đầu (nối Lec 19 trường phái A).
• Nhớ ràng buộc tần số: policy 20 Hz + mạng 5 Hz là hai bài toán khác nhau — cần async, frame-skip, hoặc mạng nhẹ.
• Augmentation: xoay ảnh tùy ý có thể phá horizon / hướng trọng lực cần cho điều khiển.
• Coverage: U-Net-style seg “chè chưa phủ” → feature cho reward đa mục tiêu; RF phải đủ lớn để thấy cả hàng, không chỉ lá.
• Đô thị: detect tòa nhà / no-fly proxy từ ảnh — vẫn CNN, nhưng latency phải khớp vòng control.

5. Ưu / nhược

6. Lỗi thường gặp

1. Dùng backbone quá lớn cho vòng điều khiển chặt.
2. Augmentation làm hỏng tín hiệu hình học cần cho điều khiển (xoay tùy ý khi horizon quan trọng).
3. Flatten ảnh vào MLP “cho đơn giản” rồi kết luận RL không học được vision.
4. Receptive field quá nhỏ so với vật cần nhận (ống xa chỉ vài pixel sau nhiều pool).
5. Đồng bộ sai: policy đọc feature cũ 200 ms mà không model trễ (nối Lec 19–20).
6. Quên chuẩn hóa kích thước / FOV khi đổi camera → GSD và RF “ảo” (Lec 17).

7. Checklist

1. Vì sao conv thường hơn MLP trên ảnh? (tham số + cục bộ)
2. Receptive field nghĩa là gì? Cách tăng RF?
3. Trên UAV nhỏ, mạng nên chạy ở đâu và vì sao?
4. Freeze encoder giúp sample efficiency thế nào?
5. Aug nào nguy hiểm cho UAV có horizon?
6. Task coverage của bạn cần RF lớn đến mức nào (lá / hàng / cả thửa)?

⚡ Nhớ một câu: Ảnh cần lọc cục bộ chia sẻ trọng số — CNN mua inductive bias bằng ít tham số; RF phải đủ lớn cho task.

🔗 Sang bài sau mang theo: Đủ dynamics–plan–estimate–vision → Lec 23 đặt RL đúng tầng trong stack và chốt pipeline nghiên cứu.

Trước: Lec21 — Overfitting · Sau: Lec23 — RL trong Robotics