MLP và backpropagation

Vì sao thêm một lớp?

Với đầu vào $x_1,x_2$ thuộc $\{0,1\}$, XOR có nhãn 1 tại $(0,1),(1,0)$ và nhãn 0 ở hai góc còn lại. Một đường thẳng không tách được hai cặp góc đối diện. Đây là giới hạn của kiến trúc: train lâu hơn cũng không chữa được.

Tạo hai đặc trưng $h_1=\operatorname{ReLU}(x_1+x_2)$ và $h_2=\operatorname{ReLU}(x_1+x_2-1)$, với $\operatorname{ReLU}(z)=\max(0,z)$. Khi tổng là 0, 1, 2, hai đặc trưng lần lượt là $(0,0),(1,0),(2,1)$. Công thức $\hat y=h_1-2h_2$ cho 0, 1, 0, đúng XOR. Đây là một mạng được đặt trọng số bằng tay, chưa phải mạng đã học.

import numpy as np
import torch

torch.set_num_threads(1)
torch.manual_seed(11)
np.set_printoptions(precision=4, suppress=True)
X_xor = np.array([[0., 0.], [0., 1.], [1., 0.], [1., 1.]])
hidden = np.maximum(X_xor @ np.ones((2, 2)) + [0., -1.], 0.)
print(hidden)
print(hidden @ np.array([1., -2.]))

Kết quả[[0. 0.]
 [1. 0.]
 [1. 0.]
 [2. 1.]]
[0. 1. 1. 0.]

Dòng cuối cần cho 0, 1, 1, 0. Hidden layer đã biến bốn góc thành những vị trí mà lớp sau kết hợp được: hai góc $(0,1),(1,0)$ cùng rơi vào điểm $(h_1,h_2)=(1,0)$, còn góc $(1,1)$ bị đẩy ra $(2,1)$.

Nếu bỏ activation, hai lớp gộp lại: $(XW_1+b_1)W_2+b_2=X(W_1W_2)+(b_1W_2+b_2)$, vẫn là một lớp linear. Thêm tham số mà không thêm phi tuyến không giải quyết được XOR.

Xếp nhiều lớp như vậy là được một mạng nơ-ron nhiều lớp (multilayer perceptron, MLP). Các lớp nằm giữa đầu vào và đầu ra gọi là lớp ẩn; nhiều lớp ẩn thì gọi là mạng sâu.

Một nơ-ron ngưỡng, ra 1 khi $w_1x_1 + w_2x_2 + b > 0$, tính được AND, OR hay NAND; ví dụ $w = (-1, -1)$, $b = 1.5$ cho NAND. Nhưng nó chỉ vẽ được một đường, nên XOR cần ít nhất hai nơ-ron ẩn. Cũng vậy, muốn biết một điểm có nằm trong tam giác không, dùng ba nơ-ron ẩn, mỗi cái kiểm một cạnh, rồi nơ-ron ra làm phép AND.

Đường thẳng trong mặt phẳng tách được mọi cách gán nhãn của 3 điểm không thẳng hàng, nhưng không với 4 điểm: bốn góc XOR là ví dụ, và bỏ đi một góc thì ba góc còn lại lại tách được.

Forward có bảng shape

Ta thống nhất mẫu nằm ở hàng. Một batch $X$ có shape (B, d), hidden width $h$, đầu ra $c$:

Trong NumPy ta dùng cách viết hàng như bảng này. torch.nn.Linear(d,h) lưu weight shape (h,d) và thực hiện $X\,\text{weight}^\top+b$. Hai quy ước cùng đúng; khi chuyển trọng số tự viết sang Linear, cần chuyển vị. Nếu copy thẳng ma trận vuông thì shape vẫn hợp lệ nhưng nội dung có thể sai.

Mỗi nơ-ron của lớp nối với mọi đầu vào của lớp trước, nên gọi là lớp kết nối đầy đủ (fully connected); nn.Linear(10, 3) là lớp 10 vào, 3 ra. Số trọng số giữa hai lớp bằng số vào nhân số ra, cộng thêm số ra nếu có bias: mạng $30 \to 4 \to 3 \to 1$ không bias có $120 + 12 + 3 = 135$ trọng số.

Forward phải lưu $X,Z_1,H$ cho backward, vì đạo hàm phụ thuộc chúng. Đó là nguồn chi phí activation memory: nhớ giá trị trung gian để khỏi tính lại. Backprop là thuật toán đi ngược các phép, còn autograd là cơ chế thư viện xây graph và gọi đạo hàm phù hợp.

Từ loss về lớp đầu

Để dễ kiểm, ta dùng hồi quy một đầu ra $c=1$ và $J=\frac1B\sum_i(P_i-Y_i)^2$. Bài 3.3 sẽ đổi sang loss phân loại. Đặt $G_2=\partial J/\partial P=2(P-Y)/B$, shape (B,1). Với lớp linear cuối:

Đạo hàm theo hidden là $G_2W_2^\top$. Khi có nhiều đầu ra, mỗi hidden neuron nối tới tất cả nên ảnh hưởng tới loss qua nhiều đường; chain rule cộng đóng góp của các đường ấy, và phép nhân ma trận làm sẵn phép cộng này.

Gradient theo $W_1$ cần $\partial J/\partial Z_1$. Đại lượng này phụ thuộc mọi lớp phía sau nên chỉ có khi backward đổ về; còn đạo hàm cục bộ của activation thì tính được ngay lúc forward.

Qua ReLU, phần có $Z_1<0$ không đổi đầu ra khi xê dịch nhỏ nên gradient bằng 0; phần $Z_1>0$ đi qua nguyên vẹn:

$\odot$ là nhân từng phần tử, không phải nhân ma trận. Vài hệ quả và quy ước:

• Tại đúng 0, ReLU không có đạo hàm; ta và PyTorch chọn gradient 0. Khi kiểm bằng sai phân, tránh đặt điểm đúng chỗ gãy ấy.
• Nếu loss lấy trung bình trên nhiều đầu ra $c$, hệ số sẽ là $2/(Bc)$; công thức ở đây dùng $c=1$.
• Gradient của trọng số nối đầu vào $j$ với nơ-ron $i$ bằng 0 khi $x_j = 0$ hoặc khi nơ-ron đó đóng ($z_i < 0$), bất kể gradient đổ về là bao nhiêu.
• Với nn.Linear, weight có shape (out, in) và $Y = XW^\top + b$, nên $\partial L/\partial W = G^\top X$ với $G = \partial L/\partial Y$.

Vì gradient của một nơ-ron đi qua chính trọng số của nó, nếu mọi trọng số của một lớp bằng nhau thì các nơ-ron trong lớp nhận cùng gradient và mãi giống nhau; khởi tạo ngẫu nhiên là để phá đối xứng ấy.

Hình dưới vẽ đường đi ấy cho mạng $2\to3\to1$ sẽ dựng bằng PyTorch ở mục dùng thư viện: gradient từ $J$ về $P$, nhân $W_2^\top$ để về $H$, qua cổng ReLU′ rồi mới tới lớp đầu.

Tính thử trên một mẫu $x=2$, $y=0$, mạng một hidden neuron: $w_1=0.5,b_1=0,w_2=2,b_2=0$. Forward có $z_1=1,h=1,p=2,J=4$. Bắt đầu từ đầu ra: $dJ/dp=4$, nên $dJ/dw_2=4h=4$ và $dJ/db_2=4$. Truyền về hidden cho $dJ/dh=4w_2=8$; ReLU đang mở vì $z_1>0$, nên $dJ/dw_1=8x=16$, $dJ/db_1=8$.

Các gradient dùng trọng số trước cập nhật. Nếu sửa $w_2$ rồi mới tính gradient lớp đầu, đang trộn hai mạng khác nhau trong cùng lượt backward. Tính đủ gradient trước, cập nhật tất cả sau. Khi một neuron âm ở mọi mẫu, gradient qua ReLU của nó bằng 0; vấn đề này sẽ nối sang activation ở bài tiếp.

Cài nhỏ bằng NumPy

Ta kiểm trên hai mẫu, hai hidden neuron và điểm không nằm ở chỗ gãy. Tách forward/backward thành hàm để cùng một code phục vụ tính gradient và thử loss sau cập nhật:

X = np.array([[1., 2.], [2., -1.]])
Y = np.array([[1.], [0.]])
params = [np.array([[.2, -.3], [.4, .1]]), np.array([.1, .2]),
          np.array([[.5], [-.4]]), np.array([.05])]

def forward(params):
    W1, b1, W2, b2 = params
    Z1 = X @ W1 + b1
    H = np.maximum(Z1, 0)
    P = H @ W2 + b2
    return P, (Z1, H)

def objective(params):
    P, _ = forward(params)
    assert P.shape == Y.shape
    return np.mean((P - Y) ** 2)

def backward(params):
    P, (Z1, H) = forward(params)
    G2 = 2 * (P - Y) / len(X)
    G1 = (G2 @ params[2].T) * (Z1 > 0)
    return [X.T @ G1, G1.sum(axis=0), H.T @ G2, G2.sum(axis=0)]

print(forward(params)[0].ravel())
print(round(objective(params), 6))
for g in backward(params):
    print(g)

Kết quả[0.56 0.1 ]
0.1018
[[-0.12   0.176]
 [-0.49   0.352]]
[-0.17   0.176]
[[-0.474]
 [-0.044]]
[-0.34]

Hai dự đoán là $0.56$ và $0.10$, nên loss tính tay $(0.44^2+0.10^2)/2=0.1018$. Kiểm từng ma trận gradient cùng shape với trọng số tương ứng. Chẳng hạn $dJ/dW_2$ hàng đầu bằng $1.1(-0.44)+0.1(0.10)=-0.474$; đây là tổng hai đường đóng góp qua hai mẫu. Ở batch này $Z_1=\begin{bmatrix}1.1&0.1\\0.1&-0.5\end{bmatrix}$: neuron ẩn thứ hai đóng ở mẫu thứ hai, và mask (Z1 > 0) chặn gradient qua đúng ô đó.

Đối chiếu độc lập rồi mới học

Sai phân trung tâm ước lượng đạo hàm theo một phần tử tham số $\theta_k$ bằng $\big(J(\theta_k+\varepsilon)-J(\theta_k-\varepsilon)\big)/(2\varepsilon)$, giữ nguyên các phần tử khác. Mỗi phần tử tốn hai lần tính loss. Cách này chậm nhưng không dùng chung công thức nào với backward, giống lời giải brute force dùng để kiểm thuật toán tối ưu trong CP.

Ta dùng float64 và $\varepsilon=10^{-5}$: sai số của sai phân trung tâm cỡ $\varepsilon^2$, sai số làm tròn của float64 còn nhỏ hơn, nên so với ngưỡng atol=1e-8 là đủ chặt. Với float32, sai số làm tròn bị khuếch đại khi chia cho $2\varepsilon$, nên khi kiểm hãy chuyển mạng tí hon sang float64. Mọi phần tử của $Z_1$ cách 0 ít nhất $0.1$, xa hơn nhiều so với bước xê dịch, nên phép thử không vượt qua chỗ gãy của ReLU.

def numerical_gradient(params, eps=1e-5):
    answer = []
    for p in params:
        g = np.zeros_like(p)
        for index in np.ndindex(p.shape):
            old = p[index]
            p[index] = old + eps
            plus = objective(params)
            p[index] = old - eps
            minus = objective(params)
            p[index] = old
            g[index] = (plus - minus) / (2 * eps)
        answer.append(g)
    return answer

manual = backward(params)
numeric = numerical_gradient(params)
print('numeric match:', all(np.allclose(a, b, atol=1e-8)
                            for a, b in zip(manual, numeric)))

tp = [torch.tensor(p, dtype=torch.float64, requires_grad=True) for p in params]
tx, ty = torch.tensor(X), torch.tensor(Y)
pred = torch.relu(tx @ tp[0] + tp[1]) @ tp[2] + tp[3]
((pred - ty) ** 2).mean().backward()
print('autograd match:', all(np.allclose(g, p.grad.numpy(), atol=1e-10)
                            for g, p in zip(manual, tp)))
updated = [p - .05 * g for p, g in zip(params, manual)]
print(round(objective(params), 6), round(objective(updated), 6))

Kết quảnumeric match: True
autograd match: True
0.1018 0.065513

Hai dòng True nói backward khớp với hai cách tính độc lập tại bộ tham số đã chọn. Dòng cuối cho thấy một bước gradient descent với learning rate $0.05$ đưa loss từ $0.1018$ xuống $0.065513$. Hai loại bằng chứng này không thay được nhau. Loss giảm sau một bước chỉ cần hướng cập nhật đi xuống, nên một backward sai ở vài phần tử vẫn có thể làm loss giảm. Ngược lại, gradient đúng không hứa hội tụ tới nghiệm toàn cục, vì loss của mạng neural thường không lồi.

Dùng thư viện ở đúng tầng

Khi đã hiểu cơ chế, bài thực tế viết torch.nn.Sequential(torch.nn.Linear(d,h), torch.nn.ReLU(), torch.nn.Linear(h,c)) để thư viện quản lý tham số và autograd lo phần backward. Trước khi train, nên hỏi lại mô hình hai điều: output có shape như dự tính không, và mạng có bao nhiêu tham số:

model = torch.nn.Sequential(torch.nn.Linear(2, 3), torch.nn.ReLU(),
                            torch.nn.Linear(3, 1))
print(tuple(model(torch.zeros(4, 2)).shape))
print(sum(p.numel() for p in model.parameters()))

Kết quả(4, 1)
13

Đầu ra (4,1) là bốn dự đoán. Số tham số là $2\cdot3+3+3\cdot1+1=13$, tính cả hai bias; layer ReLU không có tham số học. Hai lỗi hay gặp khi tự viết model:

• Lớp con phải được gán làm thuộc tính của nn.Module hoặc đặt trong nn.ModuleList. Để trong list Python thường thì model.parameters() không thấy, optimizer không học và .to(device) cũng bỏ sót.
• Dùng cùng một đối tượng lớp ở hai chỗ, như nn.Sequential(l, nn.ReLU(), l), là chia sẻ trọng số: parameters() chỉ đếm một lần và gradient cộng từ cả hai chỗ.

Đầu ra và loss phải đi cùng nhau: phân loại nhị phân dùng một logit với BCEWithLogitsLoss, nhiều lớp loại trừ nhau dùng $c$ logits với CrossEntropyLoss (bài 3.3).