Multi-Layer Perceptron (MLP) là mạng nơ-ron truyền thẳng gồm nhiều tầng, trong đó các tầng chính thường là những lớp kết nối đầy đủ (fully connected). MLP là một trong những kiến trúc cơ bản nhất để hiểu cách mạng nơ-ron biến đổi dữ liệu, tạo tính phi tuyến, tính gradient và học tham số.
MLP có thể được sử dụng cho phân loại, hồi quy, dữ liệu dạng bảng, xấp xỉ hàm hoặc làm classification head và feed-forward block trong những mô hình lớn hơn. Dù CNN phù hợp hơn với cấu trúc không gian của ảnh và Transformer phù hợp với nhiều bài toán chuỗi, MLP vẫn xuất hiện ở hầu hết hệ thống Deep Learning hiện đại dưới một hình thức nào đó.
- MLP gồm input, hidden layers và output, với dữ liệu truyền theo một chiều từ đầu vào đến đầu ra.
- Mỗi hidden layer thường thực hiện phép biến đổi affine + activation phi tuyến.
- Forward Pass tạo dự đoán; Backpropagation tính gradient; optimizer cập nhật tham số.
- MLP là baseline tốt cho nhiều dữ liệu dạng vector nhưng không tự có inductive bias về không gian hoặc thứ tự.
MLP thực sự là gì?
MLP thuộc nhóm feed-forward neural network. Trong một lần suy luận thông thường, thông tin đi từ input qua các hidden layer rồi tới output mà không có vòng phản hồi từ output quay về chính các tầng trước.
Một mạng điển hình có ba nhóm thành phần:
- Input: vector đặc trưng của dữ liệu.
- Hidden layers: học representation trung gian.
- Output layer: sinh logits hoặc giá trị dự đoán cuối cùng.
Nếu một mẫu có d đặc trưng, có thể biểu diễn:
MLP học một ánh xạ từ vector này đến đầu ra mong muốn bằng cách hợp thành nhiều hàm đơn giản hơn.
Perceptron và MLP
Perceptron cơ bản là một mô hình tuyến tính cho phân loại. MLP mở rộng cấu trúc này bằng hidden layer và các activation phi tuyến, cho phép mạng tạo decision boundary phức tạp hơn.
Nếu loại bỏ toàn bộ activation phi tuyến, nhiều Linear layer liên tiếp vẫn có thể rút gọn thành một phép biến đổi affine duy nhất. Vì vậy chiều sâu chỉ thực sự hữu ích khi các tầng được kết hợp với phép biến đổi phi tuyến hoặc những cấu trúc khác không thể rút gọn tuyến tính.
Forward Pass và số tham số của MLP
Với quy ước vector cột, tầng thứ l trước tiên tính:
Sau đó activation φ được áp dụng:
Với tầng đầu tiên, a(0) chính là input x. Activation có thể là ReLU, GELU, SiLU hoặc hàm khác tùy kiến trúc.
Ví dụ một mạng:
có bốn input feature, hai hidden layer lần lượt gồm tám và bốn neuron, sau đó tạo hai output.
Kích thước ma trận trọng số
Nếu một tầng nhận nin đầu vào và có nout neuron:
Bias có nout phần tử. Tổng số tham số là:
Trong PyTorch, nn.Linear(in_features, out_features) lưu weight với shape (out_features, in_features). Với batch được biểu diễn bằng các vector hàng, phép toán tương đương:
Hai cách viết không mâu thuẫn; chúng chỉ khác quy ước biểu diễn vector theo hàng hay theo cột.
Backpropagation: MLP học bằng cách nào?
Forward Pass chỉ tạo dự đoán. Để mạng học, ta cần một hàm mất mát L so sánh dự đoán với mục tiêu:
Backpropagation sử dụng quy tắc dây chuyền để tính gradient của loss theo từng tham số. Với weight của tầng l:
Gradient Descent cơ bản sau đó cập nhật weight:
Trong thực tế, optimizer có thể là SGD, Adam hoặc AdamW. Backpropagation chịu trách nhiệm tính gradient; optimizer quyết định cách sử dụng gradient đó để thay đổi tham số.
Forward Pass tạo prediction.
Loss đo sai số.
Backpropagation tính gradient.
Optimizer cập nhật tham số.
Chu trình được lặp lại trên dữ liệu huấn luyện.
Thiết kế MLP đúng cách
Không có công thức chung cho số hidden layer hoặc số neuron tối ưu. Capacity cần phù hợp với số feature, số mẫu, độ phức tạp của quan hệ cần học và mức regularization.
Width và depth
Width là số neuron của một tầng, còn depth mô tả chiều sâu của chuỗi phép biến đổi. Mạng quá nhỏ có thể underfit; mạng quá lớn có thể tăng chi phí và overfit.
Với dữ liệu tabular có vài chục feature, một baseline đơn giản có thể bắt đầu từ:
Sau đó nên tăng hoặc giảm capacity dựa trên training loss và validation performance thay vì chọn mạng rất lớn ngay từ đầu.
Activation
ReLU là baseline đơn giản cho nhiều MLP. GELU hoặc SiLU cũng có thể được sử dụng. Điểm quan trọng nhất là hidden layer phải có tính phi tuyến nếu muốn nhiều Linear layer biểu diễn nhiều hơn một phép affine duy nhất.
Chuẩn hóa feature
Với tabular data, các feature có scale rất khác nhau có thể làm quá trình tối ưu khó hơn. Standardization thường là một baseline hợp lý:
Mean và standard deviation phải được ước lượng từ tập train rồi áp dụng cho validation và test, tránh rò rỉ dữ liệu.
Dropout và regularization
Dropout có thể giúp hạn chế overfitting bằng cách ngẫu nhiên bỏ một phần activation trong lúc huấn luyện. Weight decay cũng thường được sử dụng để kiểm soát độ lớn tham số.
Không nên thêm nhiều regularization ngay từ đầu nếu chưa biết mô hình có overfit hay không. Validation curve sẽ cho thông tin đáng tin cậy hơn.
Universal Approximation Theorem
Các kết quả về xấp xỉ phổ quát cho thấy feed-forward neural network với ít nhất một hidden layer, activation thích hợp và đủ số hidden unit có thể xấp xỉ một lớp rất rộng các hàm với độ chính xác tùy ý trên miền thích hợp.
Xây dựng MLP hoàn chỉnh bằng PyTorch
Ví dụ sau sử dụng dữ liệu make_moons. Hai lớp tạo thành decision boundary phi tuyến nên phù hợp để kiểm tra khả năng của một MLP nhỏ.
import torch
import torch.nn as nn
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
torch.manual_seed(42)
# 1. Tạo dữ liệu
X, y = make_moons(
n_samples=1000,
noise=0.2,
random_state=42
)
X_train, X_test, y_train, y_test = train_test_split(
X,
y,
test_size=0.2,
random_state=42,
stratify=y
)
# 2. Chuẩn hóa chỉ dựa trên tập train
scaler = StandardScaler()
X_train = scaler.fit_transform(X_train)
X_test = scaler.transform(X_test)
# 3. Chuyển sang Tensor
X_train = torch.tensor(
X_train,
dtype=torch.float32
)
X_test = torch.tensor(
X_test,
dtype=torch.float32
)
y_train = torch.tensor(
y_train,
dtype=torch.float32
).view(-1, 1)
y_test = torch.tensor(
y_test,
dtype=torch.float32
).view(-1, 1)
# 4. Định nghĩa MLP
class MLP(nn.Module):
def __init__(self):
super().__init__()
self.net = nn.Sequential(
nn.Linear(2, 32),
nn.ReLU(),
nn.Linear(32, 16),
nn.ReLU(),
# Một raw logit cho binary classification
nn.Linear(16, 1)
)
def forward(self, x):
return self.net(x)
model = MLP()
criterion = nn.BCEWithLogitsLoss()
optimizer = torch.optim.Adam(
model.parameters(),
lr=1e-3
)
# 5. Huấn luyện full-batch
num_epochs = 500
for epoch in range(num_epochs):
model.train()
optimizer.zero_grad()
logits = model(X_train)
loss = criterion(
logits,
y_train
)
loss.backward()
optimizer.step()
# 6. Đánh giá
model.eval()
with torch.no_grad():
logits = model(X_test)
probs = torch.sigmoid(logits)
predictions = (
probs >= 0.5
).float()
accuracy = (
predictions == y_test
).float().mean()
print(
"Test accuracy:",
round(accuracy.item(), 4)
)Output layer không có Sigmoid vì BCEWithLogitsLoss nhận trực tiếp logits và kết hợp phép Sigmoid với Binary Cross-Entropy theo cách ổn định số học. Sigmoid chỉ được áp dụng khi cần biến logits thành xác suất.
Multi-class classification
import torch.nn as nn
num_features = 20
num_classes = 5
model = nn.Sequential(
nn.Linear(num_features, 128),
nn.ReLU(),
nn.Linear(128, 64),
nn.ReLU(),
# C raw logits
nn.Linear(64, num_classes)
)
criterion = nn.CrossEntropyLoss()Không thêm Softmax trước CrossEntropyLoss. Loss nhận trực tiếp unnormalized logits. Softmax chỉ cần khi muốn chuyển logits thành xác suất.
Regression
import torch.nn as nn
model = nn.Sequential(
nn.Linear(10, 64),
nn.ReLU(),
nn.Linear(64, 32),
nn.ReLU(),
# Linear output: phù hợp với target không bị giới hạn
nn.Linear(32, 1)
)
criterion = nn.MSELoss()Khi nào nên dùng MLP và khi nào không?
MLP phù hợp tự nhiên với dữ liệu đã có dạng vector kích thước cố định. Nó cũng thường được dùng sau một encoder để ánh xạ embedding sang nhãn hoặc giá trị cần dự đoán.
| Dữ liệu / nhiệm vụ | MLP | Lựa chọn khác đáng cân nhắc |
|---|---|---|
| Tabular | Baseline tốt | Gradient boosting, mô hình tabular chuyên biệt |
| Embedding vector | Rất phù hợp | Linear head nếu bài toán đơn giản |
| Ảnh thô | Có thể dùng nhưng không tận dụng tốt cấu trúc không gian | CNN, Vision Transformer |
| Văn bản / chuỗi thô | Không mô hình hóa thứ tự một cách tự nhiên | Transformer, RNN tùy bài toán |
| Function approximation | Phù hợp | KAN, RBF network hoặc mô hình chuyên biệt |
Tại sao flatten ảnh trực tiếp không lý tưởng?
Ảnh RGB 224 × 224 có:
Nếu flatten ảnh rồi nối trực tiếp với một layer 1024 neuron, chỉ riêng weight matrix đã có hơn 150 triệu phần tử. Quan trọng hơn, mạng không được cung cấp inductive bias rằng những pixel gần nhau có quan hệ không gian đặc biệt.
CNN giải quyết vấn đề bằng local receptive field và weight sharing. Vision Transformer chia ảnh thành patch và mô hình hóa quan hệ giữa các token ảnh.
MLP vẫn nằm bên trong Transformer
Transformer không loại bỏ MLP. Mỗi Transformer block thường chứa một feed-forward network sau hoặc xen kẽ với attention:
Attention trao đổi thông tin giữa token, còn FFN biến đổi representation của từng token. Vì vậy hiểu MLP là bước nền tảng để hiểu Transformer.
Chuẩn hóa feature khi phù hợp.
Bắt đầu với 1–3 hidden layer.
Dùng ReLU hoặc SiLU làm activation cơ bản.
Chọn output và loss đúng với loại bài toán.
Theo dõi validation metric thay vì chỉ training loss.
Chỉ tăng width hoặc depth khi mô hình còn underfit.
Kết luận
Multi-Layer Perceptron là một trong những mô hình nền tảng nhất của Deep Learning. Mỗi tầng học một phép biến đổi của representation, activation tạo tính phi tuyến, Forward Pass tạo dự đoán và Backpropagation cung cấp gradient để optimizer cập nhật tham số.
MLP đặc biệt hữu ích với dữ liệu dạng vector, tabular, embedding và các prediction head. Đồng thời, các khối MLP vẫn xuất hiện bên trong Transformer và nhiều kiến trúc hiện đại, khiến việc hiểu rõ MLP trở thành nền tảng cần thiết trước khi nghiên cứu những mạng phức tạp hơn.
Nguồn tham khảo và nguồn hình ảnh công khai
- Goodfellow, Bengio & Courville – Deep Learning, Chapter 6: Deep Feedforward Networks. Tham khảo về feed-forward network, hidden layer, activation và Universal Approximation.
- PyTorch Documentation – torch.nn.Linear. Tham khảo phép biến đổi affine, shape của weight và input/output của fully connected layer.
- PyTorch Documentation – BCEWithLogitsLoss và CrossEntropyLoss. Tham khảo cách sử dụng raw logits cho binary và multi-class classification.
- Wikimedia Commons – MultiLayerPerceptron.svg. Tác giả: Sky99. Giấy phép CC BY-SA 3.0. Dùng làm nguồn đối chiếu cấu trúc mạng MLP cổ điển.
- Wikimedia Commons – MLP-training-loop.svg. Tác giả: Alexis0Olson. Giấy phép CC BY 4.0. Dùng làm nguồn đối chiếu quy trình Forward Pass, Loss, Backward Pass và cập nhật tham số.
- Wikimedia Commons – Neural network.svg. Tác giả: Dake và Mysid. Giấy phép CC BY 1.0. Hình minh họa công khai về cấu trúc mạng nơ-ron feed-forward.
Nội dung gốc thuộc tác giả. Vui lòng không đăng lại toàn văn khi chưa được phép, trừ trường hợp pháp luật hoặc giấy phép áp dụng cho phép. Nội dung của bên thứ ba tuân theo quyền và giấy phép tương ứng.
Nguồn gốc: Multi-Layer Perceptron - MLP là gì? Kiến trúc nền tảng của mạng nơ-ron sâu