Dự đoán
Trong bài này, RNN được mở cuộn (unroll) theo thời gian để xem trạng thái ẩn hₜ di chuyển từ trái sang phải, và hiểu vì sao gradient “phai nhạt” khi chuỗi dài.
Evaluating routing across providers.
AI Builder
Kiến trúc xử lý dữ liệu tuần tự bằng cách truyền trạng thái ẩn qua các bước thời gian
Trong bài này, RNN được mở cuộn (unroll) theo thời gian để xem trạng thái ẩn hₜ di chuyển từ trái sang phải, và hiểu vì sao gradient “phai nhạt” khi chuỗi dài.
Hãy tưởng tượng bạn đọc một truyện ngắn và cầm cuốn sổ nhỏ. Sau mỗi từ, bạn không chép lại cả câu mà chỉ cập nhật vài dòng ngắn ghi ý chính đến lúc này. Cuốn sổ đó chính là trạng thái ẩn hₜ của RNN. Cùng một bàn tay (cùng bộ trọng số) cập nhật cuốn sổ ở mọi bước; chỉ có nội dung cuốn sổ là thay đổi.
Khi mở cuộn mạng, một ô RNN lặp lại thành nhiều bản sao nối tiếp nhau, tất cả dùng chung W_xh, W_hh và b. Với câu “Tôi yêu mèo”, trạng thái ẩn truyền từ trái sang phải:
| Bước | Từ đầu vào | Trạng thái ẩn |
|---|---|---|
| t = 1 | Tôi | h₁: tóm tắt “Tôi” |
| t = 2 | yêu | h₂: tổ hợp “Tôi yêu”, không chỉ là embedding của “yêu” |
| t = 3 | mèo | h₃: tổ hợp của cả ba từ |
Trạng thái ẩn hₜ là một tóm tắt của mọi thứ RNN đã thấy từ đầu đến bước t. Nó là một vector cố định chiều, không phải danh sách các token.
Một RNN đã huấn luyện không nhớ câu “Tôi yêu mèo” như máy ghi âm. Nó có một cuốn sổ nhỏ cố định chiều (hₜ) và một cây bút cố định (W_xh, W_hh, b). Cây bút viết lại cuốn sổ sau mỗi từ; chính cuốn sổ là “ký ức”, không phải danh sách từng từ.
Đó là lý do RNN xử lý được chuỗi bất kỳ độ dài: 10 từ hay 10.000 từ đều dùng chung một bộ trọng số, chỉ có cuốn sổ chạy theo thời gian.
Mạng nơ-ron hồi quy (RNN) là họ kiến trúc xử lý chuỗi bằng cách duy trì vector trạng thái ẩn hₜ và cập nhật tuần tự qua các bước thời gian. Tại mỗi bước, đầu vào xₜ và trạng thái cũ hₜ₋₁ đi vào cùng một ô, có chung bộ trọng số ở mọi bước (weight sharing theo thời gian).
Công thức hồi quy cốt lõi của RNN thuần (Elman RNN):
Trong đó xₜ là đầu vào (thường là embedding của token t), hₜ là trạng thái ẩn, còn yₜ là đầu ra (có thể bỏ qua nếu chỉ cần hₜ cuối). Ba ma trận W_xh, W_hh, W_hy cùng bias được chia sẻ ở mọi bước.
Hiện thực RNN bằng PyTorch có thể rất ngắn gọn. Dưới đây là phiên bản từ gốc để thấy đúng công thức:
import torch
import torch.nn as nn
class SimpleRNNCell(nn.Module):
"""
Một ô RNN thuần tuân đúng công thức Elman:
h_t = tanh(W_xh * x_t + W_hh * h_{t-1} + b_h)
Dùng nn.Parameter để PyTorch tự tính gradient qua BPTT.
"""
def __init__(self, input_dim: int, hidden_dim: int):
super().__init__()
# Khởi tạo theo Xavier để tránh vanishing/exploding gradient
# ngay từ bước đầu. nn.Linear chỉ là tiện nghi cho W·x + b.
self.W_xh = nn.Linear(input_dim, hidden_dim, bias=True)
self.W_hh = nn.Linear(hidden_dim, hidden_dim, bias=False)
def forward(self, x_t: torch.Tensor, h_prev: torch.Tensor) -> torch.Tensor:
# x_t: (batch, input_dim); h_prev: (batch, hidden_dim)
return torch.tanh(self.W_xh(x_t) + self.W_hh(h_prev))
class SimpleRNN(nn.Module):
"""
Quấn nhiều bước thời gian lại: nhận chuỗi (batch, T, input_dim),
trả về toàn bộ hidden states (batch, T, hidden_dim) và h_T.
"""
def __init__(self, input_dim: int, hidden_dim: int):
super().__init__()
self.hidden_dim = hidden_dim
self.cell = SimpleRNNCell(input_dim, hidden_dim)
def forward(self, x: torch.Tensor, h0: torch.Tensor | None = None):
batch, T, _ = x.shape
if h0 is None:
h0 = x.new_zeros(batch, self.hidden_dim)
h = h0
hs = []
# Vòng lặp tuần tự theo thời gian — đây chính là lý do RNN
# KHÔNG song song hóa được giữa các bước (t và t+1).
for t in range(T):
h = self.cell(x[:, t, :], h)
hs.append(h)
# hs: danh sách T tensor kích thước (batch, hidden_dim)
return torch.stack(hs, dim=1), h
# Thực tế: dùng nn.RNN của PyTorch sẽ nhanh hơn (CuDNN tối ưu).
# Ví dụ sử dụng:
if __name__ == "__main__":
rnn = SimpleRNN(input_dim=50, hidden_dim=128)
# Batch 4, chuỗi 20 bước, mỗi bước embedding 50 chiều
dummy = torch.randn(4, 20, 50)
out, h_final = rnn(dummy)
print(out.shape, h_final.shape) # (4, 20, 128) (4, 128)Huấn luyện RNN cần backpropagation through time (BPTT). PyTorch làm tự động, nhưng bạn cần thêm gradient clipping để tránh exploding gradient:
import torch
import torch.nn as nn
# Giả sử bạn có sẵn mô hình và data loader
model = nn.RNN(input_size=50, hidden_size=128, batch_first=True)
head = nn.Linear(128, vocab_size) # vocab_size tùy bài toán
opt = torch.optim.Adam(list(model.parameters()) + list(head.parameters()), lr=1e-3)
loss_fn = nn.CrossEntropyLoss()
for epoch in range(num_epochs):
for batch_x, batch_y in train_loader:
# batch_x: (B, T, 50); batch_y: (B, T) — chỉ số token đích
out, _ = model(batch_x) # (B, T, 128)
logits = head(out) # (B, T, V)
loss = loss_fn(logits.reshape(-1, vocab_size), batch_y.reshape(-1))
opt.zero_grad()
loss.backward()
# QUAN TRỌNG: cắt gradient để tránh exploding gradient
# Với RNN thuần, norm gradient rất dễ nổ > 10^3 khi chuỗi dài.
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=5.0)
opt.step()Gọi L = Σₜ Lₜ là loss tổng cộng. Đạo hàm của L theo W_hh là tổng của nhiều đường:
Mỗi Jacobi ∂hⱼ/∂hⱼ₋₁ = diag(tanh′(zⱼ)) · W_hh. Khi T lớn, chuẩn của tích này bị chặn bởi (σ_max(W_hh))^(T−k). Nếu σ_max(W_hh) nhỏ hơn 1, tích co về 0 theo cấp số nhân (vanishing); nếu lớn hơn 1, bùng nổ. Đây là kết quả của Pascanu, Mikolov và Bengio (2013), nền tảng lý thuyết cho mọi biến thể RNN hiện đại.
Bidirectional RNN chạy hai RNN một chiều ngược nhau rồi nối trạng thái — hữu ích khi có toàn bộ chuỗi, không streaming. Stacked RNN xếp nhiều tầng: đầu ra tầng dưới là đầu vào cho tầng trên, giúp học biểu diễn phân cấp.
| Kiến trúc | Cổng | Bộ nhớ | Tham số | Mạnh | Yếu |
|---|---|---|---|---|---|
| RNN (vanilla) | Không có cổng | Một trạng thái ẩn h | W_xh, W_hh, b (ít nhất) | Đơn giản, dễ huấn luyện trên chuỗi ngắn | Gradient biến mất hoặc bùng nổ, khó nhớ xa |
| LSTM | 3 cổng: forget, input, output | Cell state c và hidden state h | 4 bộ (W_f, W_i, W_o, W_c) — nhiều hơn khoảng 4 lần | Nhớ được ngữ cảnh dài 100–300 bước | Chậm hơn RNN, nhiều tham số hơn |
| GRU | 2 cổng: reset, update | Chỉ có hidden state h (gộp cell và hidden) | 3 bộ — gọn hơn LSTM khoảng 25% | Cân bằng giữa LSTM và RNN, ít tham số | Hơi kém LSTM với chuỗi siêu dài |
Sai lầm thường gặp khi huấn luyện RNN:
Hiểu RNN là nền tảng để đọc LSTM (thêm cell state và 3 cổng), GRU (rút gọn còn 2 cổng), và hiểu vì sao Transformer vượt qua cả ba. Nên xem lại backpropagation để nắm BPTT.
Tăng chiều hₜ làm số phép nhân ma trận tăng theo O(d²). Đây là lý do RNN chiều lớn rất đắt.
| RNN thuần | LSTM (ước lượng) | |
|---|---|---|
| Tham số | d_h · (d_x + d_h + 1) | Khoảng 4 lần RNN thuần (4 cổng) |
| Bộ nhớ khi forward | O(T · d_h) | O(T · d_h), gấp 2 vì có cₜ và hₜ |
| Rủi ro | Vanishing hoặc exploding cao | Gradient ổn định hơn nhiều nhờ cell state |