Hàm kích hoạt Activation Function trong Deep Learning

Hàm kích hoạt (activation function) quyết định cách một neuron biến đổi tín hiệu trước khi truyền sang tầng tiếp theo. Nếu một mạng chỉ gồm các phép biến đổi tuyến tính, việc xếp chồng nhiều layer vẫn có thể rút gọn thành một phép biến đổi tuyến tính duy nhất và mạng không thể mô hình hóa tốt những quan hệ phi tuyến phức tạp.

Không tồn tại một activation tốt nhất cho mọi kiến trúc và mọi bài toán. ReLU phù hợp với nhiều CNN và MLP, GELU phổ biến trong Transformer, Sigmoid thích hợp cho xác suất nhị phân hoặc multi-label, trong khi Softmax thường được sử dụng để chuyển logits thành phân phối xác suất trên nhiều lớp loại trừ lẫn nhau.

Tóm tắt nội dung

• Hidden layer: ReLU, Leaky ReLU, GELU và SiLU là những lựa chọn phổ biến.
• Binary classification: thường huấn luyện bằng raw logits và BCEWithLogitsLoss; Sigmoid dùng khi cần xác suất.
• Multi-class classification: thường dùng logits với CrossEntropyLoss; Softmax chủ yếu cần ở bước suy luận.
• Regression: thường dùng đầu ra tuyến tính, trừ khi miền giá trị cần bị giới hạn.

Vì sao mạng nơ-ron cần hàm kích hoạt?

Một tầng tuyến tính có thể được viết:

$$z=Wx+b$$

Nếu tầng tiếp theo cũng chỉ thực hiện một phép biến đổi tuyến tính:

$$y=W_2(W_{1}x+b_1)+b_2$$

thì toàn bộ biểu thức vẫn có thể được rút gọn thành một phép tuyến tính khác. Vì vậy việc tăng số layer mà không chèn phi tuyến không giúp mạng học được decision boundary phức tạp hơn.

Khi một activation f được đặt sau phép biến đổi tuyến tính:

$$h=f(Wx+b)$$

mạng bắt đầu có khả năng xây dựng những phép biến đổi phi tuyến liên tiếp. Activation vì vậy ảnh hưởng đồng thời tới khả năng biểu diễn và quá trình lan truyền gradient.

Các activation quan trọng cho hidden layer

ReLU

Rectified Linear Unit (ReLU) là một trong những activation phổ biến nhất trong Deep Learning:

$$\mathrm{ReLU}\left(x\right)=\max (0,x)$$

Khi x dương, ReLU giữ nguyên đầu vào. Khi x âm, đầu ra bằng 0. Trên vùng dương, đạo hàm bằng 1 nên gradient không bị nén như ở các hàm sigmoid khi activation lớn.

ReLU đơn giản, tính toán rẻ và là baseline tốt cho nhiều CNN hoặc MLP. Nhược điểm chính là dying ReLU: một neuron có thể rơi vào vùng âm lâu dài, tạo output bằng 0 và gradient theo x bằng 0.

Leaky ReLU

Leaky ReLU giữ lại một độ dốc nhỏ khi x âm:

$$f\left(x\right)=\{\begin{array}{ll}x& \text{nếu}x\ge 0\\ \alpha x& \text{nếu}x<0\end{array}$$

Với α là một số dương nhỏ, neuron vẫn nhận gradient khi activation âm. Leaky ReLU đáng cân nhắc khi ReLU tạo quá nhiều activation bằng 0 hoặc mô hình có dấu hiệu xuất hiện neuron chết.

GELU

Gaussian Error Linear Unit (GELU) là activation quen thuộc trong Transformer và Vision Transformer. Công thức chính xác có thể viết:

$$\mathrm{GELU}\left(x\right)=x\mathrm{\Phi }\left(x\right)$$

Trong đó Φ(x) là hàm phân phối tích lũy của phân phối chuẩn chuẩn hóa. Khác ReLU, GELU không cắt đột ngột toàn bộ phần âm mà tạo một chuyển tiếp trơn.

Nếu sử dụng pretrained Transformer, thông thường nên giữ activation mà kiến trúc gốc đã dùng thay vì thay đổi tùy ý, vì trọng số pretrained đã được học trong điều kiện đó.

SiLU / Swish

SiLU được định nghĩa bởi:

$$\mathrm{SiLU}\left(x\right)=x\sigma \left(x\right)$$

SiLU cũng là một hàm trơn và cho phép một phần giá trị âm đi qua. Nó xuất hiện trong nhiều kiến trúc hiện đại, đặc biệt ở một số backbone Computer Vision và mạng có yêu cầu tối ưu gradient tốt hơn ReLU cơ bản.

Sigmoid và Tanh trong hidden state

Sigmoid ánh xạ đầu vào về khoảng (0,1):

$$\sigma \left(x\right)=\frac{1}{1+e^{-x}}$$

Tanh ánh xạ đầu vào về khoảng (−1,1):

$$\tanh \left(x\right)=\frac{e^x-e^{-x}}{e^x+e^{-x}}$$

Cả hai có thể bị saturation khi |x| lớn, làm đạo hàm tiến gần 0. Vì vậy chúng ít được dùng làm activation mặc định cho hidden layer sâu hiện đại, nhưng vẫn rất quan trọng trong LSTM và GRU: Sigmoid thường đóng vai trò gate, còn Tanh tạo hoặc biến đổi trạng thái.

Baseline thực tế: ReLU cho CNN/MLP cổ điển; GELU cho nhiều Transformer; SiLU cho nhiều kiến trúc hiện đại; Leaky ReLU khi cần giữ gradient ở miền âm.

Activation ở output layer: Sigmoid, Softmax hay không dùng gì?

Activation ở output layer không nên được chọn giống hidden layer. Nó phải phản ánh ý nghĩa thống kê của target và phải tương thích với loss function.

Binary classification

Mô hình thường sinh một logit z. Xác suất lớp dương được tính bằng Sigmoid:

$$p=\sigma \left(z\right)$$

Trong PyTorch, nếu dùng BCEWithLogitsLoss, model nên trả trực tiếp z. Không thêm Sigmoid vào model khi tính loss vì BCEWithLogitsLoss đã kết hợp hai bước theo cách ổn định số học.

Multi-label classification

Nếu một mẫu có thể đồng thời thuộc nhiều lớp, mỗi lớp cần một xác suất riêng:

$$p_i=\sigma \left(z_i\right)$$

Ví dụ một ảnh có thể đồng thời chứa person, car và tree. Ba nhãn không loại trừ nhau, do đó Sigmoid độc lập cho từng lớp phù hợp hơn Softmax.

Multi-class classification

Khi mỗi mẫu chỉ thuộc một trong C lớp, Softmax chuyển vector logits thành phân phối xác suất:

$${\mathrm{softmax}\left(z\right)}_i=\frac{e^{z_i}}{\sum _{j=1}^C{e}^{z_j}}$$

Các xác suất sau Softmax dương và tổng bằng 1. Tuy nhiên, khi huấn luyện bằng CrossEntropyLoss trong PyTorch, model cũng nên trả raw logits thay vì tự áp dụng Softmax trước loss.

Regression

Nếu target có thể nhận mọi giá trị thực, output thường là một tầng tuyến tính:

$$\hat{y}=Wh+b$$

Nếu target bắt buộc thuộc [0,1], có thể dùng Sigmoid. Nếu thuộc [−1,1], Tanh là một lựa chọn tự nhiên. Với target bắt buộc dương nhưng không bị chặn trên, Softplus thường mềm hơn ReLU:

$$\mathrm{Softplus}\left(x\right)=\log (1+e^x)$$

Bài toán	Output	Activation	Loss thường dùng
Binary classification	1 logit	Sigmoid khi inference	BCEWithLogitsLoss
Multi-label	C logits độc lập	Sigmoid từng lớp	BCEWithLogitsLoss
Multi-class	C logits	Softmax khi inference	CrossEntropyLoss
Regression không giới hạn	Số thực	Linear	MSE, MAE, Huber...
Regression [0,1]	Giá trị bị chặn	Sigmoid	Theo bài toán
Regression dương	Giá trị > 0	Softplus có thể phù hợp	Theo bài toán

Chọn activation cho CNN, Transformer và segmentation

Hidden activation nên được xem trong ngữ cảnh của toàn bộ kiến trúc. Một activation hoạt động tốt trong CNN không nhất thiết là lựa chọn mặc định tốt nhất cho Transformer.

Kiến trúc / bài toán	Activation thường gặp	Ghi chú
CNN	ReLU, Leaky ReLU, SiLU	ReLU là baseline đơn giản; SiLU phổ biến trong nhiều backbone hiện đại
Transformer	GELU, SiLU và gated variants	Nên giữ activation của pretrained architecture khi fine-tune
LSTM / GRU	Sigmoid + Tanh	Sigmoid dùng cho gate, Tanh cho candidate/state
Binary segmentation	Sigmoid ở output khi inference	Một logit cho mỗi pixel
Multi-class segmentation	Softmax ở output khi inference	C logits cho mỗi pixel

Binary segmentation

Với một foreground class và background, model thường sinh một logit cho mỗi pixel:

$$p_{h,w}=\sigma \left(z_{h,w}\right)$$

Khi huấn luyện bằng BCEWithLogitsLoss, Sigmoid không cần nằm trong model. Khi inference, Sigmoid chuyển logits thành probability map rồi threshold để tạo mask.

Multi-class segmentation

Với C lớp loại trừ lẫn nhau, model sinh tensor logits có dạng B × C × H × W. Sau khi huấn luyện, nhãn dự đoán tại pixel có thể lấy bằng:

$${\hat{y}}_{h,w}=\underset{c}{\mathrm{argmax}}{z}_{c,h,w}$$

Nếu chỉ cần class ID, argmax trên logits và argmax trên Softmax probability cho cùng thứ tự lớp. Vì vậy không nhất thiết phải tính Softmax chỉ để lấy lớp dự đoán.

Gated activations trong Transformer

Các kiến trúc Transformer hiện đại còn sử dụng những biến thể gated như GLU, GEGLU hoặc SwiGLU. Trực giác tổng quát có thể viết:

$$y=f\left(x{W}_1\right)\odot \left(x{W}_2\right)$$

Ký hiệu ⊙ là phép nhân từng phần tử. Trong trường hợp này, activation không chỉ được thay đổi độc lập mà nằm trong một cơ chế gating hoàn chỉnh.

Code PyTorch: ghép activation đúng với loss

Binary classification

import torch
import torch.nn as nn


class BinaryClassifier(nn.Module):
    def __init__(self, input_dim):
        super().__init__()

        self.net = nn.Sequential(
            nn.Linear(input_dim, 64),
            nn.ReLU(),
            nn.Linear(64, 1)
        )

    def forward(self, x):
        # Raw logits: không đặt Sigmoid ở đây
        return self.net(x)


model = BinaryClassifier(input_dim=20)
criterion = nn.BCEWithLogitsLoss()

x = torch.randn(8, 20)
targets = torch.randint(
    0,
    2,
    (8, 1)
).float()

logits = model(x)
loss = criterion(logits, targets)

# Chuyển logits thành xác suất khi inference
probs = torch.sigmoid(logits)

Multi-class classification

import torch
import torch.nn as nn

num_classes = 5

model = nn.Sequential(
    nn.Linear(128, 256),
    nn.GELU(),
    nn.Linear(256, num_classes)
)

criterion = nn.CrossEntropyLoss()

x = torch.randn(16, 128)
labels = torch.randint(
    0,
    num_classes,
    (16,)
)

logits = model(x)

# CrossEntropyLoss nhận raw logits
loss = criterion(logits, labels)

# Softmax chỉ cần khi muốn xác suất
probs = torch.softmax(logits, dim=1)

# Nếu chỉ cần class ID, có thể argmax trực tiếp logits
predictions = logits.argmax(dim=1)

Multi-label classification

import torch
import torch.nn as nn

num_labels = 4

model = nn.Sequential(
    nn.Linear(64, 128),
    nn.SiLU(),
    nn.Linear(128, num_labels)
)

criterion = nn.BCEWithLogitsLoss()

x = torch.randn(10, 64)

# Mỗi mẫu có thể có nhiều nhãn cùng lúc
targets = torch.randint(
    0,
    2,
    (10, num_labels)
).float()

logits = model(x)
loss = criterion(logits, targets)

probs = torch.sigmoid(logits)
predictions = (probs >= 0.5).int()

Những lỗi thường gặp và cách chọn activation nhanh

Dùng Softmax cho multi-label classification

Softmax tạo cạnh tranh giữa các lớp vì tổng xác suất bằng 1. Nếu nhiều nhãn có thể đúng đồng thời, cần sử dụng Sigmoid độc lập cho từng lớp.

Thêm Sigmoid trước BCEWithLogitsLoss

BCEWithLogitsLoss đã tích hợp Sigmoid bên trong. Model cần trả logits trực tiếp. Sigmoid chỉ được áp dụng bên ngoài khi muốn đọc xác suất.

Thêm Softmax trước CrossEntropyLoss

CrossEntropyLoss nhận logits và thực hiện phép biến đổi tương ứng theo cách ổn định số học. Vì vậy không cần Softmax trước loss.

Dùng Sigmoid cho mọi hidden layer

Sigmoid có thể saturation khi giá trị tuyệt đối của đầu vào lớn. Với mạng sâu, ReLU, GELU hoặc SiLU thường là baseline tốt hơn cho hidden representation.

Ép output regression bằng activation không phù hợp

Nếu target có thể âm, ReLU ở output khiến model không thể tạo dự đoán âm. Nếu target không bị giới hạn, linear output thường là lựa chọn tự nhiên nhất.

1. Xác định target
Binary / multi-class / regression

→

2. Chọn loss
BCE / CE / MSE...

→

3. Output activation
Theo miền của target

→

4. Hidden activation
Theo kiến trúc

Quy tắc chọn nhanh:

CNN / MLP: bắt đầu với ReLU hoặc SiLU.

Transformer: giữ GELU, SiLU hoặc gated activation của kiến trúc gốc.

Binary output: raw logits + BCEWithLogitsLoss; Sigmoid khi cần probability.

Multi-label: C logits + BCEWithLogitsLoss; Sigmoid độc lập từng lớp.

Multi-class: C logits + CrossEntropyLoss; Softmax khi cần probability.

Regression không giới hạn: linear output.

Regression bị giới hạn: chọn activation theo đúng miền của target.

Nếu model huấn luyện không ổn định, không nên mặc định activation là nguyên nhân duy nhất. Learning rate, normalization, weight initialization, residual connection, batch size và gradient clipping đều có thể ảnh hưởng mạnh đến quá trình tối ưu.

Kết luận

Hàm kích hoạt tạo ra tính phi tuyến giúp mạng nơ-ron học các quan hệ phức tạp. ReLU đơn giản và hiệu quả cho nhiều CNN và MLP, GELU và SiLU phù hợp với nhiều kiến trúc hiện đại, trong khi Sigmoid, Tanh và Softmax có vai trò đặc biệt rõ trong gating hoặc output layer.

Cách chọn activation đúng không phải là tìm một hàm “mạnh nhất”, mà là đảm bảo sự nhất quán giữa kiến trúc, hidden activation, ý nghĩa của output và loss function. Đặc biệt trong PyTorch, cần phân biệt rõ raw logits với probability để tránh những lỗi phổ biến như Sigmoid trước BCEWithLogitsLoss hoặc Softmax trước CrossEntropyLoss.