Convolution và pooling

Một bộ dò đi qua nhiều vị trí

Ảnh xám là bảng số $H\times W$. Mỗi ô của bảng gọi là một điểm ảnh (pixel), mang một số từ 0 (đen) tới 255 (trắng). Ảnh xám có một kênh; ảnh màu có ba bảng như vậy, gọi là ba kênh RGB.

Các điểm cạnh nhau có quan hệ: cạnh của viên phấn thường kéo dài qua nhiều ô lân cận. Vì vậy ta đọc một cửa sổ nhỏ trước khi đọc cả ảnh.

Kernel (bộ lọc) là bảng trọng số $K$. Tại mỗi vị trí, nhân từng ô trong cửa sổ với ô tương ứng của $K$, rồi cộng. Với một kênh, stride 1, chưa có padding và bias:

$i,j$ chỉ vị trí trên bảng kết quả; $u,v$ chỉ vị trí bên trong kernel. Tổng ở đây là tích vô hướng của hai bảng khi trải thành vector. Nếu đã học linear regression, ta đang dùng một mô hình tuyến tính nhỏ trên từng cửa sổ, và mọi cửa sổ dùng chung trọng số.

Trong toán học, convolution lật kernel $180^\circ$ trước khi nhân; phép nhân thẳng không lật gọi là cross-correlation. Conv2d của PyTorch làm cross-correlation, nhưng ngành học sâu vẫn gọi nó là convolution.

Khi kernel được học, khác biệt này không quan trọng: mạng sẽ học luôn bản đã lật. Nó chỉ quan trọng khi đề cho sẵn kernel và hỏi kết quả; khi đó tính theo cách không lật như PyTorch.

Dùng chung trọng số còn quyết định số tham số. Nếu mỗi vị trí đầu ra có kernel riêng, một ảnh xám cho đầu ra $28\times28$ cần 784 bộ trọng số; dùng chung thì chỉ một bộ, và bộ ấy học từ mọi vị trí cùng lúc. So với nối thẳng mọi pixel vào lớp kết nối đầy đủ, khác biệt rất lớn: ảnh $224 \times 224 \times 3$ vào 1000 neuron đã cần khoảng 150 triệu trọng số.

Lấy ảnh và kernel sau. Chưa cần ảnh thật: bảng số nhỏ giúp nhìn mọi phép nhân.

import numpy as np

image = np.array([[1, 2, 0],
                  [0, 1, 3],
                  [2, 1, 0]], dtype=float)
kernel = np.array([[1, 0],
                   [0, 2]], dtype=float)

def correlate_valid(image, kernel):
    height, width = image.shape
    kh, kw = kernel.shape
    result = np.zeros((height - kh + 1, width - kw + 1))
    for row in range(result.shape[0]):
        for col in range(result.shape[1]):
            window = image[row:row + kh, col:col + kw]
            result[row, col] = np.sum(window * kernel)
    return result

feature_map = correlate_valid(image, kernel)
print(feature_map)

Kết quả[[3. 8.]
 [2. 1.]]

Ô trên trái là $1\cdot1+2\cdot0+0\cdot0+1\cdot2=3$. Ô trên phải là $2\cdot1+0\cdot0+1\cdot0+3\cdot2=8$. Hai ô hàng dưới lần lượt là 2 và 1. Bảng đầu ra nhỏ hơn vì kernel phải nằm trọn trong ảnh.

Kernel này được đặt tay cho dễ tính, nhưng đã cho thấy cách một bộ dò hoạt động: nó chỉ có trọng số dương trên đường chéo chính, nên cửa sổ có số lớn trên đường chéo ấy, $\begin{bmatrix}2&0\\1&3\end{bmatrix}$, cho giá trị lớn nhất là 8. Trong CNN, giá trị kernel không đặt tay mà được học từ dữ liệu. Vài kernel cổ điển vẫn đáng nhớ:

• Sobel $\begin{bmatrix}-1&0&1\\-2&0&2\\-1&0&1\end{bmatrix}$ phản ứng mạnh ở cạnh dọc, nơi độ sáng đổi đột ngột theo chiều ngang. Tìm những chỗ như vậy gọi là phát hiện cạnh.
• Làm mờ $3 \times 3$: 9 ô đều bằng $1/9$, tổng bằng 1 để giữ nguyên độ sáng trung bình.

Không phải bộ lọc cổ điển nào cũng là tổng có trọng số. Trên ảnh nhị phân, nền là 0 và vật là 1, phép giãn và phép co thay nhân–cộng bằng max và min trên cửa sổ $3 \times 3$. Giãn đặt ô ra bằng 1 nếu cửa sổ có ít nhất một ô 1, nên nét dày lên và lấp được khe nhỏ. Co chỉ đặt ô ra bằng 1 khi cả cửa sổ đều là 1, nên nét mỏng đi và chấm nhiễu nhỏ biến mất. Co rồi giãn (opening) xóa chấm nhiễu mà vật lớn gần như giữ nguyên; giãn rồi co (closing) lấp khe. Phép giãn (morphological dilation) này khác dilation của convolution ở mục sau.

def morph(img, op):
    padded = np.pad(img, 1)
    out = np.zeros_like(img)
    for i in range(img.shape[0]):
        for j in range(img.shape[1]):
            out[i, j] = op(padded[i:i + 3, j:j + 3])
    return out

mask = np.zeros((7, 7), dtype=int)
mask[1, 1] = 1                  # một chấm nhiễu
mask[3:6, 3:6] = 1              # một vật 3 × 3
dilated, eroded = morph(mask, np.max), morph(mask, np.min)
opened = morph(eroded, np.max)
print("Số ô bằng 1: gốc", mask.sum(), " giãn", dilated.sum(),
      " co", eroded.sum(), " co rồi giãn", opened.sum())
print("Chấm nhiễu sau co rồi giãn:", opened[1, 1])

Kết quảSố ô bằng 1: gốc 10  giãn 33  co 1  co rồi giãn 9
Chấm nhiễu sau co rồi giãn: 0

Giãn biến chấm nhiễu thành 9 ô và vật $3 \times 3$ thành $5 \times 5$; hai vùng chạm nhau ở một ô nên tổng là $9 + 25 - 1 = 33$. Co xóa chấm nhiễu và chỉ để lại ô giữa của vật. Giãn lại từ đó cho đúng vật $3 \times 3$ ban đầu, còn chấm nhiễu không quay lại.

Padding, stride và dilation thay đổi điều gì?

Padding thêm vành ô quanh ảnh, thường bằng 0. Nó cho kernel đọc cả vùng sát biên và có thể giữ kích thước. Giá trị 0 ở biên là một giả định về bên ngoài ảnh; với ảnh nhỏ, giả định này có ảnh hưởng đáng kể.

Stride là số ô dịch mỗi bước. Stride 2 đọc thưa hơn, giảm chi phí nhưng có thể bỏ sót nét mảnh.

Dilation tạo khoảng trống giữa các ô kernel: kernel 3 ô với dilation 2 bao phủ 5 vị trí, dù vẫn chỉ có 3 trọng số theo chiều đó. Kích thước bao phủ hiệu dụng là $d(k-1)+1$.

Ta đếm số vị trí hợp lệ theo một chiều. Chiều dài sau padding là $H+2p$; cửa sổ đầu chiếm $d(k-1)+1$ ô, phần còn lại cho phép dịch từng $s$ ô:

Chiều rộng tính tương tự. Công thức giả định mỗi đầu thêm đúng $p$ ô. Với stride 1, muốn giữ kích thước thì cần $2p=d(k-1)$; padding="same" của PyTorch tự chọn padding như vậy, và khi $d(k-1)$ lẻ (kernel chẵn) phần dư được thêm ở cuối.

Ví dụ $H=7$, $k=3$, $p=1$, $s=2$, $d=1$ cho $\lfloor6/2\rfloor+1=4$. Các vị trí bắt đầu là 0, 2, 4, 6 trên ảnh đã thêm vành, không phải $7/2$ làm tròn tùy ý.

Vài trường hợp hay gặp: ảnh $32 \times 32$, kernel 5, không padding ra $28 \times 28$; giữ $64 \times 64$ với kernel 3 cần $p = 1$; kernel 3 với dilation 2 trên 32 ô ra 28.

def output_size(size, kernel_size, padding=0, stride=1, dilation=1):
    covered = dilation * (kernel_size - 1) + 1
    return (size + 2 * padding - covered) // stride + 1

print(output_size(7, 3, padding=1, stride=2))
print(output_size(7, 3, dilation=2))

Kết quả4
3

Dòng thứ hai có dilation 2, nên kernel phủ 5 ô, còn 3 vị trí hợp lệ trên chiều dài 7. Tăng dilation không tăng số tham số của kernel nhưng đổi những điểm ảnh được đọc.

Xếp chồng nhiều lớp cùng dilation 2 thì có những pixel không bao giờ được đọc, để lại lưới lỗ; đổi dilation giữa các lớp hoặc ghép nhiều dilation song song, như ASPP trong DeepLab, vừa lấp lỗ vừa nhìn ngữ cảnh ở nhiều cỡ. Tăng stride từ 1 lên 2 giữ nguyên số tham số nhưng đầu ra còn khoảng một phần tư số ô.

Từ một bảng sang nhiều kênh

Một ảnh RGB có ba giá trị tại mỗi tọa độ. Một kernel cho một kênh đầu ra phải đọc cả ba kênh đầu vào, cộng kết quả rồi cộng một bias. Muốn tám kiểu bộ dò thì dùng tám kernel độc lập.

$N$ là số ảnh, không phải số kênh. Với groups=1, số tham số có bias bằng $C_{\mathrm{out}}(C_{\mathrm{in}}k_hk_w+1)$. Một lớp RGB → 8 kênh, kernel $3\times3$ có $8(3\cdot9+1)=224$ tham số, dù ảnh lớn hay nhỏ. Chi phí tính vẫn tăng theo số vị trí đầu ra; ít tham số không có nghĩa là chạy miễn phí.

Tương tự, nn.Conv2d(3, 16, 3) có $16(27 + 1) = 448$ tham số, nn.Conv2d(3, 64, 3) có $64 \cdot 28 = 1792$, và nn.Conv2d(3, 16, kernel_size=5).weight có shape (16, 3, 5, 5).

Kernel $1 \times 1$ không nhìn hàng xóm mà chỉ trộn kênh tại từng vị trí: khối $28 \times 28 \times 256$ qua 64 bộ lọc $1 \times 1$ thành $28 \times 28 \times 64$. Tích chập theo chiều sâu (depthwise, groups bằng số kênh) làm ngược lại: mỗi kênh một kernel riêng, trộn không gian trong từng kênh mà không trộn giữa các kênh; ghép depthwise với $1 \times 1$ là khối quen thuộc của MobileNet, ConvNeXt.

Đối chiếu bảng tính tay với thư viện trước, rồi xem shape của một lớp nhiều kênh:

import torch
from torch import nn

torch.set_num_threads(1)
x = torch.tensor(image, dtype=torch.float32)[None, None]
layer = nn.Conv2d(1, 1, kernel_size=2, bias=False)
with torch.no_grad():
    layer.weight.copy_(torch.tensor(kernel, dtype=torch.float32)[None, None])
    y = layer(x)
print(tuple(y.shape))
print(np.allclose(y[0, 0].numpy(), feature_map))

rgb_layer = nn.Conv2d(3, 8, 3, padding=1)
print(sum(parameter.numel() for parameter in rgb_layer.parameters()))
print(tuple(rgb_layer(torch.zeros(2, 3, 7, 7)).shape))

Kết quả(1, 1, 2, 2)
True
224
(2, 8, 7, 7)

True xác nhận ta và thư viện dùng cùng quy ước. Shape cuối giữ $7\times7$ vì kernel 3, padding 1, stride 1. Hai ảnh cùng chạy qua tám bộ lọc, nên đầu ra có hai ảnh, tám kênh.

Pooling giữ điều gì, mất điều gì?

Sau khi biết một vùng có nét, đôi khi ta không cần vị trí chính xác từng ô. Pooling gộp mỗi cửa sổ thành một số, và không có trọng số cần học:

• Max pooling lấy giá trị lớn nhất trong cửa sổ; average pooling lấy trung bình. Trên feature map $\begin{bmatrix}3&8\\2&1\end{bmatrix}$, max pooling $2\times2$ ra 8, average pooling ra $14/4=3.5$.
• Global pooling: cửa sổ phủ cả feature map, mỗi kênh chỉ còn một số. Global max trả lời “mẫu có xuất hiện ở đâu đó không”; global average đo mẫu phủ nhiều hay ít.

MaxPool2d(2) trên $7 \times 7$ ra $3 \times 3$ vì hàng, cột lẻ cuối bị bỏ; ceil_mode=True giữ cửa sổ thiếu nên ra $4 \times 4$. Thay pooling bằng tích chập stride 2 cũng thu nhỏ map, nhưng cách gộp được học thay vì cố định.

print(nn.MaxPool2d(2)(y).flatten().tolist())
print(nn.AvgPool2d(2)(y).flatten().tolist())
left = torch.tensor([[[[0., 4., 0., 0.]]]])
right = torch.tensor([[[[0., 0., 4., 0.]]]])
pool = nn.MaxPool2d((1, 2))
print(pool(left).flatten().tolist())
print(pool(right).flatten().tolist())

window = y.detach().clone().requires_grad_(True)
nn.MaxPool2d(2)(window).sum().backward()
print(window.grad[0, 0].tolist())

Kết quả[8.0]
[3.5]
[4.0, 0.0]
[0.0, 4.0]
[[0.0, 1.0], [0.0, 0.0]]

Dòng ba và bốn cho thấy dịch một ô có thể đưa đỉnh sang cửa sổ khác. Pooling có thể giảm nhạy với dịch nhỏ bên trong cùng cửa sổ, nhưng không tạo bất biến dịch tuyệt đối. Với segmentation, làm mất vị trí như vậy còn phải được bù bằng decoder hoặc nhánh giữ chi tiết.

Dòng cuối là gradient khi lan truyền ngược qua max pooling. Chỉ ô đạt max (ô chứa 8) nhận gradient 1, ba ô kia nhận 0: trong bước học này, chỉ ô thắng truyền tín hiệu về các lớp trước. Average pooling thì chia đều, mỗi ô nhận $1/4$. Khi các cửa sổ chồng nhau, một ô có thể thuộc nhiều cửa sổ và gradient của các cửa sổ ấy được cộng lại.

Receptive field: một ô đã nhìn xa đến đâu?

Vùng tiếp nhận (receptive field) là vùng đầu vào có thể ảnh hưởng đến một ô ở lớp đang xét. Hai kernel $3\times3$ stride 1 cho vùng $5\times5$, vì ba ô cạnh nhau ở lớp thứ nhất có các vùng nhìn chồng lấn. Đây là vùng có thể ảnh hưởng theo cấu trúc; trọng số hoặc ReLU có thể làm ảnh hưởng thực tế nhỏ hơn.

Để tính chuỗi lớp, giữ hai số: $r$ là chiều dài vùng nhìn và $j$ là khoảng cách trên ảnh gốc giữa hai ô đầu ra kề nhau. Bắt đầu $r=1$, $j=1$. Với lớp kernel $k$, dilation $d$, stride $s$, cập nhật:

Một conv 3, pool 2 stride 2, rồi conv 3 cho $r:1\to3\to4\to8$, $j:1\to1\to2\to2$. Conv cuối đọc ba ô cách nhau hai ô trên ảnh gốc, nên thêm 4 vào vùng nhìn. Công thức đo độ rộng; muốn biết vị trí chính xác ở biên còn phải theo dõi padding. Ba lớp $3 \times 3$ stride 1 cho $7 \times 7$; nếu lớp đầu có stride 2 thì $j$ thành 2 và ba lớp cho $11 \times 11$. Kernel $1 \times 1$ không làm vùng nhìn rộng thêm.

Xếp chồng kernel nhỏ là cách thường dùng để mở vùng nhìn. Hai lớp $3\times3$ nhìn $5\times5$ như một lớp $5\times5$, nhưng mỗi cặp kênh vào–ra chỉ cần $2\cdot9=18$ trọng số thay vì 25, và có thêm một activation ở giữa. Vì thế các họ mạng như VGG, ResNet chủ yếu dùng kernel $3\times3$.

Vùng nhìn lớn dần cũng giải thích vì sao feature map khác nhau theo độ sâu. Lớp đầu chỉ nhìn vài pixel nên phản ứng với cạnh, nét, chỗ đổi màu; feature map của nó còn giống ảnh gốc đã qua bộ lọc. Sau vài lần stride hoặc pooling, mỗi ô nhìn một vùng rộng, map nhỏ và thô đi, phản ứng với tổ hợp lớn hơn như góc, vân, bộ phận của vật. Cấu trúc cho phép thứ bậc ấy xuất hiện; chính huấn luyện mới tạo ra nó.

Giả định và ứng dụng

Convolution giả định các mẫu cục bộ hữu ích và cùng mẫu có thể xuất hiện ở nhiều vị trí. Điều này hợp với cạnh, góc, vân; chưa đủ để tự hiểu quan hệ “quyển sách bên trái cửa sổ”. Ta cần nhiều lớp để ghép chi tiết thành cấu trúc, hoặc cơ chế khác để trao đổi thông tin xa như attention ở bài 5.4.

Với stride 1, dịch ảnh đi một ô thì feature map dịch theo đúng một ô, các giá trị giữ nguyên trừ vùng sát biên. Tính chất này gọi là đồng biến với phép dịch (translation equivariance).

Bất biến, tức đầu ra không đổi khi ảnh dịch, chỉ xuất hiện khi về sau có phép gộp vị trí như global pooling; pooling cục bộ chỉ giảm nhạy với dịch nhỏ và vỡ khi đỉnh qua ranh giới cửa sổ, như cặp [4.0, 0.0] và [0.0, 4.0] ở trên. CNN cũng không tự bất biến với xoay, đổi tỉ lệ hay đổi ánh sáng.

Giả định “mẫu có thể ở bất kỳ đâu” yếu đi khi ảnh đã được căn chỉnh, ví dụ ảnh thẻ mà mắt luôn ở cùng một chỗ. Ngược lại, khi đề cần tọa độ tuyệt đối như vị trí một nguồn hay một keypoint, global pooling xóa đúng thông tin cần tìm; head phải đọc feature map còn chiều không gian, hoặc input được thêm hai kênh chứa tọa độ $x, y$ của từng ô.

Quay lại nét phấn: bộ dò cục bộ giúp tái sử dụng tri thức khi nét dịch chỗ. Ta vẫn phải kiểm ảnh của nhiều học sinh, nhiều camera, nhiều độ sáng. Nếu dữ liệu train chỉ có nét ở giữa ảnh, bộ lọc dùng chung chưa bảo đảm classifier cuối không học thói quen “nét luôn ở giữa”.

Chia sẻ trọng số là một giả định: bớt tham số nên giảm variance, đổi lại thêm bias khi giả định sai. Lớp kết nối đầy đủ cùng số đơn vị vào, ra biểu diễn được mọi thứ tích chập làm được, chỉ cần nhiều dữ liệu hơn hẳn để học; khi ảnh đã căn chỉnh sẵn, vật luôn cùng cỡ và cùng chỗ, lợi thế của tích chập nhỏ đi.