ONE is preparing: 01 / INITIALIZING MODEL ROUTER. Evaluating routing across providers.
Current state
01 / INITIALIZING MODEL ROUTER.

Evaluating routing across providers.

Start learning
← Kiến trúc

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ả

lesson90 minKiến trúcAI Engineer

Dự đoán

Câu: “Tôi sinh ở Huế, học ở Sài Gòn, làm việc ở Hà Nội, nên tôi thích ăn bún bò ___”. Từ cuối liên quan đến từ nào cách xa 15 từ? RNN thường nhớ được chuỗi dài bao nhiêu?

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ẩyQuyết định xoá bớt gì khỏi vở
CandidateNhápĐề xuất nội dung mới để ghi
Cổng nhập (input)Duyệt viếtQuyết định ghi bao nhiêu của nháp vào vở
Cổng xuất (output)Đọc lạiQuyế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 / 3
  1. 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 NGradient RNN ≈ 0,25^NGradient 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

LSTM có hidden size = 256 và input size = 128. RNN cùng kích thước có khoảng (256 + 128) × 256 ≈ 98K tham số. LSTM có bao nhiêu tham số (bỏ qua bias)?
Bạn huấn luyện LSTM sinh văn bản. Loss giảm nhưng output chỉ là từ ngữ ngẫu nhiên, không có logic dài hạn. Điều nào khả năng cao nhất?

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:

ft=σ(Wf⋅[ht−1,xt]+bf)(Forget Gate)f_t = \sigma(W_f \cdot [h_{t-1}, x_t] + b_f) \quad \text{(Forget Gate)}
it=σ(Wi⋅[ht−1,xt]+bi)(Input Gate)i_t = \sigma(W_i \cdot [h_{t-1}, x_t] + b_i) \quad \text{(Input Gate)}
C~t=tanh⁡(WC⋅[ht−1,xt]+bC)(Candidate)\tilde{C}_t = \tanh(W_C \cdot [h_{t-1}, x_t] + b_C) \quad \text{(Candidate)}
Ct=ft⊙Ct−1+it⊙C~t(Cell State Update)C_t = f_t \odot C_{t-1} + i_t \odot \tilde{C}_t \quad \text{(Cell State Update)}
ot=σ(Wo⋅[ht−1,xt]+bo)(Output Gate)o_t = \sigma(W_o \cdot [h_{t-1}, x_t] + b_o) \quad \text{(Output Gate)}
ht=ot⊙tanh⁡(Ct)(Hidden State)h_t = o_t \odot \tanh(C_t) \quad \text{(Hidden State)}

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 đó:

∂Ct∂Ct−1=ft+(đoˊng goˊp nhỏ khaˊc qua ht−1)\frac{\partial C_t}{\partial C_{t-1}} = f_t + \text{(đóng góp nhỏ khác qua } h_{t-1}\text{)}

Khi nhân T bước lại với nhau:

∂CT∂C0≈∏t=1Tft\frac{\partial C_T}{\partial C_0} \approx \prod_{t=1}^{T} f_t

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íRNNLSTMGRUTransformer
Tham số1×4×3×Khoảng 12× (điển hình)
Nhớ xaKhoảng 20 bướcKhoảng 200 bướcKhoảng 200 bướcKhông giới hạn về lý thuyết; thực tế giới hạn bởi context window
Song songKhôngKhôngKhôngCó
StreamingTốtTốtTốtKhó
Độ phức tạp mỗi tokenO(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.
Vì sao khởi tạo bias của cổng quên bằng 1 là hữu ích?

Continue the module

Lesson 3 of 12