AI Builder
Bộ nhớ dài-ngắn hạn
Vietnamese onlyThe learning content is available in Vietnamese only. The surrounding interface follows your language.Biến thể RNN với cơ chế cổng giúp nhớ thông tin dài hạn hiệu quả
Khám phá — bốn quyết định trong một ô LSTM
Hãy tưởng tượng bạn ghi chép trong lớp học với một cuốn vở (cell state, bộ nhớ dài hạn). Tại mỗi thời điểm bạn cần bốn quyết định:
| Cổng | Ẩn dụ | Vai trò |
|---|---|---|
| Cổng quên (forget) | Tẩy | Quyết định xoá bớt gì khỏi vở |
| Candidate | Nháp | Đề xuất nội dung mới để ghi |
| Cổng nhập (input) | Duyệt viết | Quyết định ghi bao nhiêu của nháp vào vở |
| Cổng xuất (output) | Đọc lại | Quyết định phần nào của vở được đưa ra làm đầu ra |
Bốn khối này tính song song trong một ô LSTM. Ba cổng dùng sigmoid để mở và đóng từ 0 đến 1. Candidate dùng tanh để đề xuất giá trị mới.
Cách đọc giá trị cổng
Khi cổng quên gần 1, cell state gần như giữ nguyên. Khi cổng nhập gần 0, candidate mới hầu như không được ghi. Hai cổng này cùng quyết định cell state thay đổi chậm hay nhanh.
Khoảnh khắc Aha
Cell state là đường cao tốc cho thông tin — chạy thẳng qua và chỉ thay đổi nhẹ bởi phép nhân và cộng. Gradient cũng chạy thẳng qua đường này, nên không bị vanishing.
RNN thường: gradient phải đi qua hàm tanh ở mỗi bước nên bị nhân nhỏ dần rồi biến mất. LSTM: gradient đi thẳng qua cell state (nhân với cổng quên gần 1) nên sống sót qua hàng trăm bước. Sau này, Transformer giải quyết vấn đề này triệt để hơn bằng self-attention song song.
Unroll qua một câu
Cell state qua câu “Tôi sinh ở Huế nên tôi thích ăn bún bò”:
Theo dõi “Huế” qua câu
1. Đọc “Huế”
Cổng quên giữ “Huế” lại (gần 1), xoá bớt chi tiết không cần thiết.
RNN thường đã quên “Huế” sau khoảng 5 đến 6 bước. LSTM giữ được nhờ cell state truyền thẳng.
LSTM và RNN: gradient sống sót qua N bước
Gradient của RNN nhân qua N lần với tanh′ ≈ 0,25; gradient của LSTM nhân qua N lần với cổng quên f ≈ 0,95. Chênh lệch này lớn đến mức nào, bảng dưới cho thấy:
| Số bước N | Gradient RNN ≈ 0,25^N | Gradient LSTM ≈ 0,95^N |
|---|---|---|
| 10 | ≈ 10⁻⁶ | ≈ 0,60 |
| 100 | ≈ 10⁻⁶⁰ (coi như 0) | ≈ 0,006 (nhỏ nhưng không biến mất) |
Thử thách
Giải thích chi tiết
LSTM (Long Short-Term Memory) do Hochreiter và Schmidhuber đề xuất năm 1997, giải quyết vanishing gradient bằng cơ chế ba cổng và một cell state riêng. Đây là bước tiến lớn đầu tiên giúp mạng neural xử lý được phụ thuộc dài hạn thực sự.
Các công thức cốt lõi:
Bộ phân loại văn bản dùng LSTM hai tầng, hai chiều:
lstm_pytorch.py
import torch
import torch.nn as nn
class LSTMClassifier(nn.Module):
"""Bộ phân loại văn bản dùng LSTM 2 tầng, 2 chiều."""
def __init__(self, vocab_size, embed_dim, hidden_dim, num_classes):
super().__init__()
self.embedding = nn.Embedding(vocab_size, embed_dim)
self.lstm = nn.LSTM(
input_size=embed_dim,
hidden_size=hidden_dim,
num_layers=2, # 2 lớp LSTM xếp chồng
batch_first=True,
bidirectional=True, # Đọc cả 2 chiều
dropout=0.3,
)
# Mẹo: khởi tạo bias forget = 1 để "mặc định nhớ"
for name, param in self.lstm.named_parameters():
if "bias" in name:
n = param.size(0)
start, end = n // 4, n // 2
param.data[start:end].fill_(1.0)
# Bidirectional → hidden_dim * 2
self.fc = nn.Linear(hidden_dim * 2, num_classes)
def forward(self, x):
emb = self.embedding(x) # (batch, seq_len, embed_dim)
output, (h_n, c_n) = self.lstm(emb) # output: full sequence
# h_n[-2], h_n[-1]: hidden cuối 2 chiều của LỚP CUỐI
h_cat = torch.cat([h_n[-2], h_n[-1]], dim=1)
return self.fc(h_cat)
# Tổng tham số ≈ 4× RNN cùng hidden size, nhưng nhớ xa hơn rất nhiều.Phiên bản viết tay để dạy học và debug. Không nhanh hơn nn.LSTM:
lstm_manual.py — triển khai thủ công
import torch
import torch.nn as nn
import torch.nn.functional as F
class LSTMCellManual(nn.Module):
"""LSTM cell viết tay — dạy học & debug. KHÔNG nhanh hơn nn.LSTM."""
def __init__(self, input_size, hidden_size):
super().__init__()
self.hidden_size = hidden_size
# Gộp 4 bộ trọng số thành 1 ma trận lớn (tối ưu bộ nhớ)
self.W = nn.Linear(input_size + hidden_size, 4 * hidden_size)
# Khởi tạo bias forget = 1 (Jozefowicz 2015)
with torch.no_grad():
self.W.bias[hidden_size:2 * hidden_size].fill_(1.0)
def forward(self, x, state):
"""
x: (batch, input_size)
state: (h_prev, c_prev), mỗi cái (batch, hidden_size)
"""
h_prev, c_prev = state
combined = torch.cat([x, h_prev], dim=1)
gates = self.W(combined) # (batch, 4*hidden)
i, f, g, o = gates.chunk(4, dim=1)
i = torch.sigmoid(i)
f = torch.sigmoid(f)
g = torch.tanh(g)
o = torch.sigmoid(o)
c = f * c_prev + i * g # cell state update
h = o * torch.tanh(c) # hidden state
return h, (h, c)
# Dùng: khởi tạo zeros, lặp qua sequence
cell = LSTMCellManual(input_size=64, hidden_size=128)
batch = 16
x_seq = torch.randn(10, batch, 64) # (seq_len, batch, input)
h = torch.zeros(batch, 128)
c = torch.zeros(batch, 128)
outputs = []
for t in range(x_seq.size(0)):
h, (h, c) = cell(x_seq[t], (h, c))
outputs.append(h)
outputs = torch.stack(outputs) # (seq_len, batch, hidden)Vì sao gradient qua cell state không biến mất?
Xét đạo hàm của cell state theo cell state trước đó:
Khi nhân T bước lại với nhau:
Nếu các f_t đều gần 1, tích này xấp xỉ 1 ngay cả khi T = 1000. Đây là điểm khác biệt quyết định so với RNN, nơi đạo hàm nhân với W^T · diag(tanh′), khoảng 0,25^T. Tuy vậy, nếu cổng quên dao động quanh 0,5, tích vẫn tiến về 0 — đó là lý do khởi tạo bias bằng 1 rất quan trọng. Xem thêm Understanding LSTM Networks của Christopher Olah (2015).
So sánh RNN, LSTM, GRU và Transformer
| Tiêu chí | RNN | LSTM | GRU | Transformer |
|---|---|---|---|---|
| Tham số | 1× | 4× | 3× | Khoảng 12× (điển hình) |
| Nhớ xa | Khoảng 20 bước | Khoảng 200 bước | Khoảng 200 bước | Không giới hạn về lý thuyết; thực tế giới hạn bởi context window |
| Song song | Không | Không | Không | Có |
| Streaming | Tốt | Tốt | Tốt | Khó |
| Độ phức tạp mỗi token | O(1) | O(1) | O(1) | O(N) |
Tóm tắt
- LSTM giải quyết vanishing gradient bằng cell state — đường cao tốc cho gradient đi qua phép nhân với cổng quên.
- Bốn khối tính toán song song: cổng quên (xoá gì), cổng nhập (ghi bao nhiêu), candidate (giá trị mới), cổng xuất (xuất gì).
- Cell state C là bộ nhớ dài hạn; hidden state h = tanh(C) nhân với cổng xuất là phiên bản đã lọc dùng cho đầu ra.
- Tham số gấp khoảng 4 lần RNN (4 bộ trọng số riêng), đổi lại nhớ xa hàng trăm bước. Khởi tạo bias cổng quên bằng 1 để mặc định nhớ.
- Biến thể: Bidirectional, Stacked, GRU (đơn giản hơn, khoảng 3 lần tham số), ConvLSTM cho video.
- Ngày nay Transformer thay thế LSTM trong NLP, nhưng LSTM vẫn dùng cho time series, streaming và thiết bị edge.