Activation và loss

Activation là một phép biến đổi có mục đích

MLP cần phi tuyến giữa các lớp. ReLU giữ phần dương, đặt phần âm về 0. Tanh đưa số về khoảng $(-1,1)$; sigmoid đưa về $(0,1)$. Hãy nhìn đồ thị trước khi thuộc tên: ReLU có một cổng mở hoặc đóng, còn tanh và sigmoid dần nằm ngang ở hai đầu. Khi đầu ra gần như không đổi dù đầu vào đổi, gradient cũng nhỏ.

Các công thức là $\operatorname{ReLU}(z)=\max(0,z)$, $\sigma(z)=1/(1+e^{-z})$ và $\tanh z=(e^{z}-e^{-z})/(e^{z}+e^{-z})$. Đạo hàm của sigmoid và tanh đọc được ngay từ đầu ra: $\sigma'(z)=\sigma(z)(1-\sigma(z))$, lớn nhất $1/4$ tại 0; $\tanh'(z)=1-\tanh^2 z$, lớn nhất 1 tại 0. ReLU có đạo hàm 1 khi $z>0$ và 0 khi $z<0$.

Ví dụ một nơ-ron có đầu vào $(2, -1, 3)$, trọng số $(0.5, 2, -1)$, bias 1: $z = 1 - 2 - 3 + 1 = -3$, ReLU cho 0. Sigmoid đang ra $0.4$ thì đạo hàm là $0.4 \cdot 0.6 = 0.24$. Đạo hàm tanh là $1 - \tanh^2 z \le 1$, nên đi ngược qua tanh, gradient không bao giờ lớn thêm.

import numpy as np
import torch
from torch import nn
from torch.nn import functional as F

torch.set_num_threads(1)
torch.manual_seed(13)
z = torch.tensor([-10., 0., 10.], requires_grad=True)
torch.sigmoid(z).sum().backward()
print('sigmoid :', [round(v, 6) for v in torch.sigmoid(z).tolist()])
print("sigmoid':", [round(v, 6) for v in z.grad.tolist()])
z.grad = None                       # xóa gradient cũ trước lần backward thứ hai
torch.tanh(z).sum().backward()
print("tanh'   :", [round(v, 6) for v in z.grad.tolist()])
r = torch.tensor([-2., 0., 3.], requires_grad=True)
torch.relu(r).sum().backward()
print('relu    :', torch.relu(r).tolist(), "relu':", r.grad.tolist())

Kết quảsigmoid : [4.5e-05, 0.5, 0.999955]
sigmoid': [4.5e-05, 0.25, 4.5e-05]
tanh'   : [0.0, 1.0, 0.0]
relu    : [0.0, 0.0, 3.0] relu': [0.0, 0.0, 1.0]

Hàng sigmoid' cho $0.25$ ở giữa và $4.5\cdot10^{-5}$ ở hai đầu; tanh' bằng 1 ở giữa và tròn về 0 trong float32 tại $|z|=10$. Một neuron ẩn bão hòa (đầu ra nằm ở vùng phẳng) vì thế gần như ngừng học: mọi gradient đi qua nó bị nhân với một số gần 0.

Đây là độ nhạy của riêng activation, chưa có loss. Ở lớp đầu ra, sigmoid ghép với BCE cho đạo hàm theo logit rút gọn thành $\sigma(z)-y$ (kiểm ở mục nhị phân), nên bão hòa ở lớp cuối không gây cùng vấn đề.

ReLU không bão hòa ở phía dương và tính rất rẻ, vì thế là lựa chọn mặc định cho hidden layer.

Đổi lại, một neuron có pre-activation âm trên mọi mẫu, chẳng hạn sau một bước cập nhật quá lớn đẩy bias xuống rất âm, cho đầu ra 0 và gradient 0 cho chính trọng số của nó. Neuron ấy “chết” và không tự hồi lại. LeakyReLU, $\max(0.01z,z)$, giữ một độ dốc nhỏ phía âm để neuron vẫn nhận gradient. Khi nhiều neuron sigmoid đã bão hòa, giảm learning rate không giúp: gradient nhỏ vì đạo hàm của activation, không phải vì bước đi.

Qua nhiều lớp: thang đo và khởi tạo

Một hidden layer tính $z_j=\sum_{i=1}^{n}w_{ji}a_i$ với $n$ đầu vào (fan-in). Giả sử các trọng số độc lập, trung bình 0, phương sai $\sigma_w^2$, và độc lập với đầu vào. Khi đó các số hạng không tương quan với nhau và

Với ReLU và pre-activation đối xứng quanh 0, nửa âm bị đặt về 0 nên $\mathbb E[a^2]$ bằng một nửa phương sai pre-activation của lớp trước. Qua mỗi lớp, phương sai vì thế nhân với $n\sigma_w^2/2$. Hệ số này lặp lại ở mọi lớp nên tác dụng là lũy thừa: nhỏ hơn 1 thì tín hiệu co theo cấp số nhân, lớn hơn 1 thì nổ. Backward đi qua chính các ma trận ấy (chuyển vị) và các mặt nạ ReLU, nên gradient về các lớp đầu cũng co hoặc nổ theo cùng cách.

Đặt hệ số bằng 1 cho

gọi là khởi tạo He (Kaiming), lựa chọn chuẩn cho mạng ReLU. Phương sai chỉ quyết định thang đo; bản thân các trọng số vẫn phải rút ngẫu nhiên, vì các neuron khởi tạo giống hệt nhau nhận cùng gradient và giống nhau mãi (bài 3.2).

Với activation khác:

• Tanh gần như là $z$ quanh 0 nên cần $\sigma_w=\sqrt{1/n}$; khởi tạo Xavier (Glorot) lấy trung bình fan-in và fan-out theo cùng tinh thần.
• Sigmoid còn thêm một hệ số: mỗi lớp nhân gradient với $\sigma'\le1/4$, nên chồng nhiều lớp sigmoid làm gradient của các lớp đầu tắt dần ngay cả khi trọng số vừa phải.

Vài ví dụ tính fan-in (số đầu vào của mỗi neuron):

• Lớp tuyến tính 512 đầu vào, theo He: $\sigma_w = \sqrt{2/512} = 0.0625$.
• Lớp tích chập $3 \times 3$ với 128 kênh vào (bài 5.1): fan-in $9 \cdot 128 = 1152$, nên $\sigma_w = \sqrt{2/1152} \approx 0.042$.
• Xavier dạng chuẩn dùng $\operatorname{Var}(w) = 2/(n_\text{in} + n_\text{out})$: lớp 300 vào, 100 ra có $\sigma_w = \sqrt{2/400} \approx 0.071$.

Cũng phép tính phương sai ấy cho thấy tích vô hướng của hai vector $d$ chiều độc lập, mỗi thành phần trung bình 0 và phương sai 1, có độ lệch chuẩn $\sqrt d$; attention ở bài 3.9 chia cho $\sqrt{d_k}$ vì vậy.

Thí nghiệm dưới đây dùng 10 lớp ReLU rộng 256, không bias, 512 mẫu đầu vào chuẩn. Hai cấu hình dùng cùng các ma trận ngẫu nhiên, chỉ khác hệ số nhân: $\mathcal N(0,0.01^2)$ hoặc He. Loss là trung bình đầu ra cuối, đủ để đo gradient chảy về lớp 1.

def depth_probe(std, depth=10, width=256):
    torch.manual_seed(0)                   # cùng dữ liệu và cùng ma trận cho mọi std
    h = torch.randn(512, width)
    weights = [(torch.randn(width, width) * std).requires_grad_() for _ in range(depth)]
    scales = []
    for w in weights:
        pre = h @ w                        # pre-activation, shape (512, 256)
        scales.append(pre.std().item())
        h = torch.relu(pre)
    h.mean().backward()                    # loss đơn giản để đo gradient về lớp 1
    return scales, weights[0].grad.norm().item()

scales_small, grad_small = depth_probe(0.01)
scales_he, grad_he = depth_probe((2 / 256) ** 0.5)
print('std pre-activation ở lớp 1, 4, 7, 10 và ‖grad W1‖:')
for name, scales, grad in [('N(0,0.01²)', scales_small, grad_small), ('He', scales_he, grad_he)]:
    print(f'{name:10s}', [float(f'{v:.2g}') for v in scales[::3]], f'{grad:.2g}')

Kết quảstd pre-activation ở lớp 1, 4, 7, 10 và ‖grad W1‖:
N(0,0.01²) [0.16, 0.00021, 3.1e-07, 4.9e-10] 2.8e-10
He         [1.4, 1.3, 1.3, 1.4] 0.091

Lý thuyết dự đoán được các con số này. Với $\sigma_w=0.01$ và $n=256$, phương sai nhân $256\cdot10^{-4}/2=0.0128$ mỗi lớp, tức độ lệch chuẩn nhân khoảng $0.113$. Lớp 1 nhận đầu vào chuẩn nên có std $\sqrt{256}\cdot0.01=0.16$; sau chín lớp nữa còn $0.16\cdot0.113^{9}\approx5\cdot10^{-10}$, đúng như output. Gradient về lớp 1 nhỏ hơn bản He khoảng $3\cdot10^{8}$ lần, nên mọi bước cập nhật gần như bằng 0 và loss đứng yên. Đầu ra không bằng 0, cũng còn rất xa giới hạn của float32 (cỡ $10^{-38}$): tín hiệu chỉ bị co tới mức vô dụng.

Với He, std giữ quanh 1.4 ở mọi lớp.

Hai cấu hình khác nhau đúng hệ số $0.01/\sqrt{2/256}\approx0.113$ ở mỗi lớp. Vì ReLU thuần nhất dương, $\operatorname{ReLU}(cz)=c\operatorname{ReLU}(z)$ với mọi $c>0$, nên trong mạng không bias, nhân trọng số của một lớp với $c$ thì mọi lớp phía sau nhân đúng $c$. Trên trục log, đường của $\mathcal N(0,0.01^2)$ vì thế gần như một đường thẳng đi xuống, cùng độ dốc ở mọi lớp.

nn.Linear của PyTorch mặc định lấy trọng số đều trong $[-1/\sqrt n,1/\sqrt n]$, tức độ lệch chuẩn $1/\sqrt{3n}$, nhỏ hơn He. Với mạng ReLU sâu tự viết, gọi nn.init.kaiming_normal_(layer.weight, nonlinearity='relu') để giữ thang đo. BatchNorm (bài 3.6) và kết nối residual (bài 5.2) là hai cách khác giữ thang đo khi mạng rất sâu.

Hồi quy: đo mức sai bằng đơn vị

Đoán thời gian là hồi quy; đầu ra cuối thường để linear, không qua activation nào. Thêm sigmoid ở cuối là ép số phút vào $(0,1)$ mà không có lý do.

Với phần dư $r=\hat y-y$, MSE trung bình $r^2$, MAE trung bình $|r|$. MSE có đơn vị phút bình phương, MAE có đơn vị phút. MSE phạt một sai số 10 nặng gấp 25 lần sai số 2, còn MAE nặng gấp 5 lần: chọn loss là chọn mức phạt cho lỗi lớn.

Nếu model chỉ được đoán một hằng số, MSE chọn trung bình của target, còn MAE chọn trung vị; vài bài có thời gian bất thường vì thế kéo model MSE đi xa hơn nhiều.

prediction = torch.tensor([1., 5., 12.])
target = torch.tensor([2., 3., 2.])
assert prediction.shape == target.shape
print('residual:', (prediction - target).tolist())
print('MSE:', round(F.mse_loss(prediction, target).item(), 4))
print('MAE:', round(F.l1_loss(prediction, target).item(), 4))
print('per item:', F.mse_loss(prediction, target, reduction='none').tolist())

Kết quảresidual: [-1.0, 2.0, 10.0]
MSE: 35.0
MAE: 4.3333
per item: [1.0, 4.0, 100.0]

Phần dư $(-1,2,10)$ cho MSE $(1+4+100)/3=35$ và MAE $(1+2+10)/3=13/3$. Một mẫu cuối đóng phần lớn loss MSE. Kiểm reduction='none' giúp phát hiện một dòng dữ liệu bất thường thay vì chỉ nhìn con số trung bình.

Huber loss nối hai cách: gần 0 giống bình phương, xa giống trị tuyệt đối. Khi đề chấm MAE, train bằng L1 hoặc Huber thường khớp metric hơn MSE; chọn cụ thể bằng validation.

Nhị phân: đầu ra một logit

Đoán “cần đồ thị” dùng nhãn $y\in\{0,1\}$. Mạng cho một số thực $z$, gọi là logit. Sigmoid biến $z$ thành xác suất $p$. Logit 0 tương ứng xác suất 0.5; logit dương nghiêng về lớp 1, âm nghiêng về lớp 0. Logit không bắt buộc nằm trong khoảng 0-1.

Binary cross-entropy là $-[y\log p+(1-y)\log(1-p)]$. Nếu tự tính sigmoid rồi log với $z$ rất lớn, làm tròn có thể cho $p=1$ và $\log(1-p)$ gặp lỗi số. Dùng BCEWithLogitsLoss để ghép hai phép bằng dạng ổn định:

log1p tính $\log(1+t)$ ổn hơn khi $t$ rất nhỏ. Ta tự cài dạng này bằng NumPy rồi so thư viện:

logits_np = np.array([-2., 0., 2., -1000., 1000.])
labels_np = np.array([0., 1., 1., 0., 1.])
stable_bce = np.maximum(logits_np, 0) - logits_np * labels_np
stable_bce += np.log1p(np.exp(-np.abs(logits_np)))
logits = torch.tensor(logits_np, requires_grad=True)
labels = torch.tensor(labels_np)
individual = F.binary_cross_entropy_with_logits(logits, labels, reduction='none')
print(np.round(stable_bce, 6).tolist())
print('match:', np.allclose(stable_bce, individual.detach().numpy()))
individual.sum().backward()
print('gradient:', [round(v, 6) for v in logits.grad.tolist()])

Kết quả[0.126928, 0.693147, 0.126928, 0.0, 0.0]
match: True
gradient: [0.119203, -0.5, -0.119203, 0.0, 0.0]

Loss tại hai logit cực lớn nhưng đoán đúng vẫn hữu hạn. Gradient của tổng loss theo từng logit là $p-y$, nên tại $z=0,y=1$ nó là $-0.5$. Khi logit rất dương mà target là 0, gradient gần 1: mô hình sai rất tự tin vẫn nhận tín hiệu chỉnh rõ.

Từ đó có ba quy tắc cho lớp cuối của bài nhị phân:

• Lớp cuối là nn.Linear(d, 1), không có sigmoid; sigmoid chỉ gọi lúc suy luận, khi cần xác suất. Ngưỡng 0.5 cho xác suất tương đương ngưỡng 0 cho logit.
• Không đặt ReLU ngay trước đầu ra: logit không bao giờ âm nên $p \ge 0.5$, mô hình không thể đoán lớp 0.
• nn.Linear(d, 2) đi với CrossEntropyLoss, không đi với BCEWithLogitsLoss.

Nhiều lớp: mỗi hàng là một bộ logits

Chọn đúng một độ khó trong ba lớp là multi-class. Mạng trả (B, C) logits. Softmax theo chiều lớp tạo $p_c=e^{z_c}/\sum_j e^{z_j}$, tổng bằng 1. CrossEntropyLoss nhận logits và target là chỉ số lớp (B,) kiểu long; nó đã gộp sẵn log-softmax bên trong. (Loss này cũng nhận target là phân phối xác suất (B,C) kiểu float, dùng cho nhãn mềm; bài này dùng chỉ số lớp.)

Với logits $(\log2,0)$, softmax là $(2/3,1/3)$. Nếu nhãn đúng là 0, loss $-\log(2/3)=\log(3/2)$. Hai cách tính sau phải khớp:

scores = torch.tensor([[np.log(2.), 0.], [0., np.log(2.)]], dtype=torch.float64)
classes = torch.tensor([0, 1], dtype=torch.long)
probabilities = scores.softmax(dim=1)
hand_loss = -probabilities[torch.arange(2), classes].log().mean()
correct_loss = F.cross_entropy(scores, classes)
double_softmax_loss = F.cross_entropy(probabilities, classes)
print(probabilities.tolist())
print(round(hand_loss.item(), 6), round(correct_loss.item(), 6))
print('softmax twice:', round(double_softmax_loss.item(), 6))
print('prediction:', scores.argmax(dim=1).tolist())

Kết quả[[0.6666666666666666, 0.3333333333333333], [0.3333333333333333, 0.6666666666666666]]
0.405465 0.405465
softmax twice: 0.540306
prediction: [0, 1]

Hai loss đầu bằng nhau; dòng “softmax twice” khác vì thư viện coi hai xác suất 2/3 và 1/3 như logits mới. Code vẫn chạy, nhưng biến đổi đã nén chênh lệch trước khi loss thực hiện log-softmax. Để lấy lớp có xác suất lớn nhất, scores.argmax(dim=1) đủ: softmax giữ thứ tự, không cần tốn thêm phép tính. Bài 10 lớp thì lớp ra có 10 neuron, mỗi neuron một logit.

Một mốc kiểm nhanh: khi mọi logit bằng nhau, mỗi lớp có xác suất $1/C$ và CE bằng $\log C$. Model mới khởi tạo cho logits nhỏ nên loss ở batch đầu nằm gần mốc này: $\log3\approx1.10$ với ba mức khó, $\log10\approx2.30$ với mười lớp. Loss đầu tiên xa hẳn mốc thường báo logits khởi đầu quá lớn hoặc nhãn bị ghép sai.

Nhiều thuộc tính cùng lúc

Một bài có thể thuộc cả “đồ thị” lẫn “DP”: hai thuộc tính không loại trừ nhau. Khi đó mỗi thuộc tính là một nhãn nhị phân riêng, model cho (B,K) logits và BCEWithLogitsLoss với target float cùng shape. Softmax sẽ ép các thuộc tính tranh nhau tổng xác suất 1, trái với ý nghĩa “cả hai đều đúng”.

Khi suy luận, mỗi thuộc tính bật độc lập khi sigmoid của nó vượt ngưỡng; với ngưỡng 0.5, điều đó tương đương logit dương. Lấy argmax chỉ trả về một thuộc tính và làm mất đúng trường hợp “cả hai”.

Tóm lại bốn kiểu đầu ra của bài:

Tính tay với hai thuộc tính đều đúng và logits bằng 0: mỗi sigmoid là 1/2, mỗi BCE là $\log2$. Reduction mean trên hai phần tử vẫn là $\log2$, còn sum là $2\log2$. Mean chia cho số phần tử tham gia: với target (B,K), đó là $BK$, không phải $B$.

Hai reduction chỉ khác nhau một hằng số nhân, nên có cùng điểm tối ưu; nhân loss với một hằng số dương không đổi nghiệm mà chỉ đổi độ lớn gradient. Với SGD, đổi reduction vì thế tương đương nhân learning rate với hằng số ấy.