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

Mạng nơ-ron hồi quy

Vietnamese onlyThe learning content is available in Vietnamese only. The surrounding interface follows your language.

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

lesson90 minKiến trúcAI Engineer

Dự đoán

Bạn đọc câu “Tôi yêu ___”. Từ tiếp theo dễ đoán là “mèo”, “phở”, “em”… Não bạn đã dùng gì để đ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.

Khám phá — mở cuộn RNN theo thời gian

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ướcTừ đầu vàoTrạng thái ẩn
t = 1Tôih₁: tóm tắt “Tôi”
t = 2yêuh₂: tổ hợp “Tôi yêu”, không chỉ là embedding của “yêu”
t = 3mèoh₃: 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.

Khoảnh khắc Aha

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.

Thử thách

RNN xử lý câu 6 từ cần 6 bước tuần tự. Transformer xử lý cùng câu đó cần tối đa bao nhiêu bước?
Bạn huấn luyện RNN thuần trên câu dài 100 từ, loss giảm rất chậm và gradient ở các tầng đầu gần bằng 0. Nguyên nhân phù hợp nhất là gì?

Giải thích chi tiết

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):

ht=tanh⁡(Wxh xt+Whh ht−1+bh)h_t = \tanh\big(W_{xh} \, x_t + W_{hh} \, h_{t-1} + b_h\big)
yt=Why ht+byy_t = W_{hy} \, h_t + b_y

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.

Ba thành phần cần nắm

  • Đầu vào xₜ: vector biểu diễn cho token hoặc điểm dữ liệu tại thời điểm t. Với văn bản thường là embedding 100–1024 chiều; với chuỗi số có thể chỉ vài chiều.
  • Trạng thái ẩn hₜ: cuốn sổ cố định chiều, chứa tóm tắt những gì đã thấy. Khi bắt đầu, h₀ thường là vector 0 (hoặc học được như một tham số).
  • Hàm tanh: nén tổ hợp tuyến tính về khoảng (−1, 1). Nếu bỏ tanh, RNN sụp thành phép biến đổi tuyến tính và mất khả năng học quan hệ phi tuyến theo thời gian.

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:

rnn_pytorch.py — RNN cell từ gố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:

train_rnn.py — vòng lặp huấn luyện với gradient clipping

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()

Chi tiết toán học: BPTT và điều kiện vanishing (nâng cao)

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:

∂L∂Whh=∑t=1T∑k=1t∂Lt∂ht(∏j=k+1t∂hj∂hj−1)∂hk∂Whh\frac{\partial L}{\partial W_{hh}} = \sum_{t=1}^{T} \sum_{k=1}^{t} \frac{\partial L_t}{\partial h_t} \left( \prod_{j=k+1}^{t} \frac{\partial h_j}{\partial h_{j-1}} \right) \frac{\partial h_k}{\partial W_{hh}}

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.

Các hình dạng chuỗi của RNN

  • Many-to-One (N đầu vào → 1 đầu ra): phân loại cảm xúc review phim.
  • One-to-Many (1 đầu vào → N đầu ra): sinh caption cho ảnh.
  • Many-to-Many đồng bộ (N → N): gắn nhãn từ loại (POS tagging).
  • Many-to-Many encoder-decoder (N → M): dịch máy (seq2seq).
  • Bidirectional RNN (đọc hai chiều, nối trạng thái): nhận dạng thực thể (NER).
  • Deep (stacked) RNN (xếp nhiều tầng): mô hình ngôn ngữ cũ trên PTB.

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.

So sánh RNN thuần, LSTM và GRU

Kiến trúcCổngBộ nhớTham sốMạnhYếu
RNN (vanilla)Không có cổngMột trạng thái ẩn hW_xh, W_hh, b (ít nhất)Đơn giản, dễ huấn luyện trên chuỗi ngắnGradient biến mất hoặc bùng nổ, khó nhớ xa
LSTM3 cổng: forget, input, outputCell state c và hidden state h4 bộ (W_f, W_i, W_o, W_c) — nhiều hơn khoảng 4 lầnNhớ được ngữ cảnh dài 100–300 bướcChậm hơn RNN, nhiều tham số hơn
GRU2 cổng: reset, updateChỉ 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:

  • Quên gradient clipping: loss đột ngột thành NaN sau vài epoch. Luôn đặt clip_grad_norm_ với max_norm = 5,0.
  • Khởi tạo W_hh kém: orthogonal hoặc identity-ish là lựa chọn tốt; Gaussian ngẫu nhiên thường có norm quá lớn, gây bùng nổ ngay từ đầu.
  • RNN thuần cho chuỗi trên 100 bước: gần như chắc chắn vanishing. Chuyển sang LSTM hoặc GRU.
  • Batch không đồng đều độ dài: phải pad và dùng pack_padded_sequence để RNN bỏ qua phần pad.
  • Quên reset hₜ giữa các câu độc lập: mô hình rò rỉ ngữ cảnh từ mẫu này sang mẫu khác.

Ứng dụng thực tế

  • Nhận dạng tiếng nói: Deep Speech (Baidu, 2014) dùng LSTM hai chiều; ngày nay Conformer đã thay thế, nhưng LSTM vẫn mạnh trên thiết bị biên.
  • Dự báo chuỗi thời gian: giá cổ phiếu, nhu cầu điện, tải mạng. RNN và LSTM phổ biến vì cần streaming.
  • Dịch máy: encoder-decoder LSTM từng là state-of-the-art (2014–2017) trước khi Transformer thay thế.
  • Gõ phím gợi ý trên điện thoại: RNN hoặc GRU nhỏ chạy on-device vì độ trễ và quyền riêng tư.
  • Phát hiện bất thường trong log hệ thống: RNN học pattern bình thường rồi đánh dấu bước có loss cao.

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.

Sandbox: chiều hidden state

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ầnLSTM (ướ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 forwardO(T · d_h)O(T · d_h), gấp 2 vì có cₜ và hₜ
Rủi roVanishing hoặc exploding caoGradient ổn định hơn nhiều nhờ cell state

Tóm tắt

  • RNN truyền trạng thái ẩn hₜ qua mỗi bước thời gian — hₜ là cuốn sổ tóm tắt mọi thứ đã thấy.
  • Công thức cốt lõi: hₜ = tanh(W_xh·xₜ + W_hh·hₜ₋₁ + b). Weight sharing theo thời gian, tương tự CNN chia sẻ kernel theo không gian.
  • Vanishing gradient là vấn đề kinh điển: gradient nhân qua T Jacobi co về 0. Triệu chứng: lớp đầu không học.
  • Gradient clipping (max_norm 1–5) là bắt buộc để tránh exploding gradient khi chuỗi dài.
  • LSTM và GRU khắc phục vanishing bằng cell state và cổng; Transformer giải quyết triệt để bằng attention nhưng mất lợi thế streaming.
  • RNN vẫn hữu ích cho streaming, thiết bị biên, và là nền tảng lý thuyết cho State Space Models (Mamba).

Continue the module

Lesson 2 of 12