- Bộ nhớ trạng thái tuần tự: Khác với mạng truyền thẳng MLP chỉ xử lý các mẫu độc lập, mạng nơ-ron hồi quy RNN duy trì một trạng thái ẩn \(h_t\) đóng vai trò như bộ nhớ tích lũy thông tin từ quá khứ truyền qua từng bước thời gian.
- Cơ chế kiểm soát dòng thông tin: LSTM giảm mạnh vấn đề triệt tiêu đạo hàm (Vanishing Gradient) bằng băng chuyền trạng thái ô \(C_t\) kết hợp cùng 3 cổng độc lập: Cổng quên (Forget gate), Cổng vào (Input gate) và Cổng xuất (Output gate).
- GRU tinh giản và hiệu năng cao: Gated Recurrent Unit gộp trạng thái ô và trạng thái ẩn thành một, chỉ sử dụng 2 cổng (Reset gate và Update gate), giúp giảm 25% khối lượng tham số tính toán trong khi vẫn duy trì độ chính xác tương đương.
1. Giới thiệu bài toán xử lý dữ liệu chuỗi tuần tự
Trong thế giới thực tế, một tỷ lệ khổng lồ thông tin tồn tại dưới dạng chuỗi có thứ tự phụ thuộc chặt chẽ vào thời gian (sequential data). Ví dụ kinh điển bao gồm:
- Ngôn ngữ tự nhiên (Natural Language): Mỗi câu văn là một chuỗi các từ ngữ ghép lại. Nghĩa của một từ phụ thuộc vào các từ đứng trước và sau nó. Chẳng hạn câu "Tôi sống ở Việt Nam nên tôi nói thành thạo tiếng..." đòi hỏi mô hình phải ghi nhớ ngữ cảnh "Việt Nam" cách đó nhiều từ để suy luận ra từ tiếp theo là "Việt".
- Chuỗi thời gian tài chính (Time Series): Giá cổ phiếu, tỷ giá tiền tệ, nhu cầu tiêu thụ điện năng qua từng giờ.
- Tín hiệu âm thanh và sóng não: Giọng nói con người là chuỗi dao động âm học liên tục trong miền thời gian.
Các mạng nơ-ron truyền thẳng (Multi-Layer Perceptron - MLP) hoặc mạng tích chập (Convolutional Neural Network - CNN) truyền thống gặp phải hai rào cản chí mạng khi đối mặt với dữ liệu chuỗi:
- Kích thước đầu vào cố định: MLP yêu cầu vector đầu vào có số chiều cố định \(d\). Trong khi đó, các câu văn hay đoạn hội thoại thực tế có độ dài hoàn toàn biến thiên (một câu có thể gồm 3 từ hoặc 50 từ).
- Không chia sẻ tham số theo thời gian: Nếu ép buộc câu văn vào một vector dài bằng cách chèn padding, MLP sẽ gán các ma trận trọng số độc lập cho từng vị trí từ. Mô hình không thể học được rằng từ "mèo" xuất hiện ở đầu câu hay cuối câu đều mang chung một ý nghĩa thực thể.
Để giải quyết căn cơ bài toán này, mạng nơ-ron hồi quy (Recurrent Neural Network - RNN) ra đời với nguyên lý lặp lại tham số và truyền trạng thái ẩn theo thời gian.
2. Kiến trúc Mạng Nơ-ron Hồi quy Truyền thống (Vanilla RNN)
Ý tưởng cốt lõi của RNN là trang bị cho nơ-ron một vòng lặp hồi quy (feedback loop). Tại mỗi bước thời gian \(t\), mạng nhận vào hai tín hiệu:
- Vector đầu vào của bước hiện tại: \(\mathbf{x}_t \in \mathbb{R}^d\).
- Vector trạng thái ẩn của bước thời gian trước đó: \(\mathbf{h}_{t-1} \in \mathbb{R}^h\).
Mạng tính toán trạng thái ẩn mới \(\mathbf{h}_t\) và đầu ra dự đoán \(\mathbf{y}_t\) thông qua hệ phương trình tuyến tính kết hợp hàm kích hoạt phi tuyến:
\[\mathbf{h}_t = \tanh(\mathbf{W}_{hh} \mathbf{h}_{t-1} + \mathbf{W}_{xh} \mathbf{x}_t + \mathbf{b}_h)\]
\[\mathbf{y}_t = \text{softmax}(\mathbf{W}_{hy} \mathbf{h}_t + \mathbf{b}_y)\]
Trong đó:
- \(\mathbf{W}_{xh}\) là ma trận trọng số kết nối đầu vào với lớp ẩn.
- \(\mathbf{W}_{hh}\) là ma trận trọng số hồi quy kết nối trạng thái ẩn trước với trạng thái ẩn hiện tại. Trọng số này được chia sẻ nguyên vẹn qua tất cả các bước thời gian \(t = 1, 2, \dots, T\).
- \(\mathbf{b}_h\) là vector độ lệch (bias).
- Hàm \(\tanh\) nén giá trị trạng thái ẩn vào khoảng \((-1, 1)\), giữ cho biên độ tín hiệu ổn định qua các bước lặp.
Thách thức triệt tiêu và bùng nổ đạo hàm (Vanishing & Exploding Gradients)
Dù thanh lịch về mặt lý thuyết, Vanilla RNN gần như bất lực khi xử lý các chuỗi có độ dài vượt quá 10 đến 20 bước thời gian. Khi huấn luyện mô hình bằng giải thuật lan truyền ngược qua thời gian (Backpropagation Through Time - BPTT), gradient của hàm mất mát \(\mathcal{L}_T\) tại bước cuối cùng theo ma trận trọng số hồi quy \(\mathbf{W}_{hh}\) tại bước \(k\) ban đầu được tính theo quy tắc đạo hàm chuỗi:
\[\frac{\partial \mathcal{L}_T}{\partial \mathbf{h}_k} = \frac{\partial \mathcal{L}_T}{\partial \mathbf{h}_T} \prod_{j=k+1}^T \frac{\partial \mathbf{h}_j}{\partial \mathbf{h}_{j-1}}\]
Đạo hàm Jacobian giữa hai trạng thái ẩn liên tiếp có dạng:
\[\frac{\partial \mathbf{h}_j}{\partial \mathbf{h}_{j-1}} = \text{diag}(1 - \mathbf{h}_j^2) \mathbf{W}_{hh}^T\]
Tích chuỗi \(\prod_{j=k+1}^T \mathbf{W}_{hh}^T\) biểu diễn phép nhân ma trận lặp lại \(T - k\) lần:
- Nếu các trị riêng lớn nhất của \(\mathbf{W}_{hh}\) nhỏ hơn \(1\) (hoặc do đạo hàm của hàm \(\tanh\) luôn nhỏ hơn hoặc bằng \(1\)), tích chuỗi này suy giảm theo cấp số mũ về \(0\). Hiện tượng này gọi là triệt tiêu đạo hàm (Vanishing Gradient). Hệ quả là mô hình mất hoàn toàn khả năng cập nhật trọng số để nắm bắt các phụ thuộc xa (long-term dependencies).
- Ngược lại, nếu các trị riêng lớn hơn \(1\), tích số sẽ tăng vọt theo cấp số mũ dẫn đến bùng nổ đạo hàm (Exploding Gradient), khiến trọng số bị dao động dữ dội hoặc tràn số (
NaN). Dù bùng nổ đạo hàm có thể giảm bớt bằng kỹ thuật cắt tỉa gradient (Gradient Clipping), triệt tiêu đạo hàm vẫn là bài toán nan giải đối với RNN truyền thống.
3. Kiến trúc Mạng LSTM (Long Short-Term Memory)
Được Sepp Hochreiter và Jürgen Schmidhuber phát minh vào năm 1997 (cổng quên được Felix Gers, Jürgen Schmidhuber và Fred Cummins bổ sung năm 2000), kiến trúc LSTM ra đời nhằm thiết lập một đường truyền thông tin liên tục không bị suy giảm qua thời gian.
Chìa khóa của LSTM là tách biệt bộ nhớ thành hai thành phần song song:
- Trạng thái ô (Cell State - \(\mathbf{C}_t\)): Đóng vai trò như một băng chuyền thông tin chạy dọc xuyên suốt toàn bộ chuỗi. Thông tin truyền qua \(\mathbf{C}_t\) chỉ chịu các phép toán cộng và nhân theo từng phần tử (element-wise), giúp gradient lan truyền ngược tự do mà không bị co cụm theo lũy thừa ma trận.
- Trạng thái ẩn (Hidden State - \(\mathbf{h}_t\)): Biểu diễn tín hiệu làm việc tức thời tại bước hiện tại.
Dòng chảy thông tin trong ô nhớ LSTM được điều phối chính xác thông qua 3 cổng logic sử dụng hàm kích hoạt Sigmoid \(\sigma(z) = \frac{1}{1 + e^{-z}} \in (0, 1)\), trong đó giá trị \(0\) đại diện cho việc đóng hoàn toàn (loại bỏ) và \(1\) đại diện cho mở hoàn toàn (giữ lại).
Chi tiết 4 bước tính toán trong ô nhớ LSTM
Giả sử tại bước \(t\), đầu vào là vector \(\mathbf{x}_t\), trạng thái ẩn trước là \(\mathbf{h}_{t-1}\), và trạng thái ô trước là \(\mathbf{C}_{t-1}\):
Bước 1: Cổng quên (Forget Gate)
Quyết định tỷ lệ thông tin nào trong trạng thái ô cũ \(\mathbf{C}_{t-1}\) sẽ bị lãng quên hoặc xóa bỏ:
\[\mathbf{f}_t = \sigma(\mathbf{W}_f [\mathbf{x}_t, \mathbf{h}_{t-1}] + \mathbf{b}_f)\]
Nếu \(f_{t, i} \approx 0\), thông tin thành phần thứ \(i\) trong bộ nhớ cũ sẽ bị xóa sạch; nếu \(f_{t, i} \approx 1\), thông tin được bảo lưu trọn vẹn.
Bước 2: Cổng vào (Input Gate) và Giá trị ứng viên (Candidate Cell)
Quyết định lượng thông tin mới nào sẽ được nạp bổ sung vào bộ nhớ dài hạn:
- Cổng vào tính toán tỷ lệ nạp: \[\mathbf{i}_t = \sigma(\mathbf{W}_i [\mathbf{x}_t, \mathbf{h}_{t-1}] + \mathbf{b}_i)\]
- Vector ứng viên đề xuất thông tin mới thông qua hàm \(\tanh\): \[\tilde{\mathbf{C}}_t = \tanh(\mathbf{W}_c [\mathbf{x}_t, \mathbf{h}_{t-1}] + \mathbf{b}_c)\]
Bước 3: Cập nhật Trạng thái ô (Update Cell State)
Kết hợp thông tin từ cổng quên và cổng vào để tính toán trạng thái ô mới:
\[\mathbf{C}_t = \mathbf{f}_t \odot \mathbf{C}_{t-1} + \mathbf{i}_t \odot \tilde{\mathbf{C}}_t\]
Trong đó ký hiệu \(\odot\) là phép nhân từng phần tử (Hadamard product). Đây chính là phép toán cứu rỗi đạo hàm: vì đạo hàm \(\frac{\partial \mathbf{C}_t}{\partial \mathbf{C}_{t-1}} = \mathbf{f}_t\), nếu cổng quên mở gần \(1\), gradient có thể trôi ngược về hàng trăm bước thời gian trước mà không hề bị tiêu biến.
Bước 4: Cổng xuất (Output Gate) và Trạng thái ẩn mới
Quyết định phần nào của trạng thái ô sẽ được xuất ra thành trạng thái ẩn \(\mathbf{h}_t\):
- Cổng xuất tính tỷ lệ phát tín hiệu: \[\mathbf{o}_t = \sigma(\mathbf{W}_o [\mathbf{x}_t, \mathbf{h}_{t-1}] + \mathbf{b}_o)\]
- Trạng thái ẩn mới là kết quả của trạng thái ô sau khi qua hàm \(\tanh\) nhân với cổng xuất: \[\mathbf{h}_t = \mathbf{o}_t \odot \tanh(\mathbf{C}_t)\]
4. Kiến trúc Mạng GRU (Gated Recurrent Unit)
Năm 2014, Kyunghyun Cho cùng các cộng sự đề xuất kiến trúc Gated Recurrent Unit (GRU). GRU là một biến thể tinh giản của LSTM với hai thay đổi lớn:
- Loại bỏ trạng thái ô riêng biệt: Hợp nhất trạng thái ô \(\mathbf{C}_t\) và trạng thái ẩn \(\mathbf{h}_t\) thành một vector trạng thái ẩn duy nhất \(\mathbf{h}_t\).
- Chỉ sử dụng 2 cổng: Cổng đặt lại (Reset Gate - \(\mathbf{r}_t\)) và Cổng cập nhật (Update Gate - \(\mathbf{z}_t\)).
Hệ phương trình tính toán của GRU:
\[\mathbf{r}_t = \sigma(\mathbf{W}_r [\mathbf{x}_t, \mathbf{h}_{t-1}] + \mathbf{b}_r)\]
\[\mathbf{z}_t = \sigma(\mathbf{W}_z [\mathbf{x}_t, \mathbf{h}_{t-1}] + \mathbf{b}_z)\]
\[\tilde{\mathbf{h}}_t = \tanh(\mathbf{W}_h [\mathbf{x}_t, \mathbf{r}_t \odot \mathbf{h}_{t-1}] + \mathbf{b}_h)\]
\[\mathbf{h}_t = (1 - \mathbf{z}_t) \odot \mathbf{h}_{t-1} + \mathbf{z}_t \odot \tilde{\mathbf{h}}_t\]
- Cổng đặt lại \(\mathbf{r}_t\) quyết định mức độ kết hợp giữa trạng thái quá khứ với đầu vào hiện tại để tạo ra ứng viên \(\tilde{\mathbf{h}}_t\). Nếu \(\mathbf{r}_t \approx 0\), mạng quên hoàn toàn quá khứ và hành xử như một tầng truyền thẳng đơn thuần.
- Cổng cập nhật \(\mathbf{z}_t\) đóng đồng thời vai trò của cả cổng quên và cổng vào trong LSTM. Hệ số \((1 - \mathbf{z}_t)\) quy định mức giữ lại của quá khứ, trong khi \(\mathbf{z}_t\) quy định mức nạp của ứng viên mới.
Nhờ cấu trúc gọn nhẹ, GRU có số lượng tham số ít hơn 25% so với LSTM (chỉ có 3 ma trận trọng số thay vì 4), giúp giảm tải bộ nhớ GPU và tăng tốc độ hội tụ khi huấn luyện trên các tập dữ liệu nhỏ và vừa.
5. Bảng so sánh toàn diện RNN, LSTM và GRU
| Tiêu chí so sánh | Vanilla RNN | LSTM | GRU |
|---|---|---|---|
| Số lượng cổng | 0 cổng | 3 cổng (Forget, Input, Output) | 2 cổng (Reset, Update) |
| Trạng thái lưu trữ | 1 trạng thái (\(\mathbf{h}_t\)) | 2 trạng thái (\(\mathbf{C}_t\) và \(\mathbf{h}_t\)) | 1 trạng thái (\(\mathbf{h}_t\)) |
| Số lượng tham số | \(1 \times (d \cdot h + h^2)\) | \(4 \times (d \cdot h + h^2)\) | \(3 \times (d \cdot h + h^2)\) |
| Khả năng nhớ dài hạn | Kém (khó học phụ thuộc xa) | Tốt (bài báo gốc vượt được độ trễ hơn 1.000 bước trên dữ liệu nhân tạo) | Tốt (thực nghiệm thường ngang LSTM) |
| Vấn đề Vanishing Grad | Rất nghiêm trọng | Giảm mạnh nhờ đường \(\mathbf{C}_t\) | Khắc phục hiệu quả bằng \(\mathbf{z}_t\) |
| Tốc độ huấn luyện | Rất nhanh | Chậm hơn do nhiều cổng | Nhanh hơn LSTM khoảng 20-30% |
| Kịch bản phù hợp | Dữ liệu chuỗi cực ngắn, demo | Ngữ liệu phức tạp, dịch máy lớn | Dữ liệu vừa phải, thiết bị biên |
Chủ đề này nằm trong Lecture 14 - Neural Networks của Khóa AI. Xem đề cương
6. Cài đặt thuật toán kiểm thử: Bước truyền xuôi LSTM Cell
Dưới đây là mã nguồn cài đặt bước tính toán truyền xuôi độc lập của một ô nhớ LSTM Cell (1 chiều) trong cả Python và C++17, tính toán chi tiết giá trị trạng thái ô mới \(c_t\) và trạng thái ẩn mới \(h_t\):
import math
def sigmoid(x):
return 1.0 / (1.0 + math.exp(-x))
def lstm_cell_forward(x_val, h_prev, c_prev, Wf, Wi, Wc, Wo, bf, bi, bc, bo):
zf = Wf[0] * x_val + Wf[1] * h_prev + bf
f_t = sigmoid(zf)
zi = Wi[0] * x_val + Wi[1] * h_prev + bi
i_t = sigmoid(zi)
zc = Wc[0] * x_val + Wc[1] * h_prev + bc
c_tilde = math.tanh(zc)
c_t = f_t * c_prev + i_t * c_tilde
zo = Wo[0] * x_val + Wo[1] * h_prev + bo
o_t = sigmoid(zo)
h_t = o_t * math.tanh(c_t)
return round(c_t, 4), round(h_t, 4)
#include <iostream>
#include <vector>
#include <cmath>
#include <iomanip>
double sigmoid(double x) {
return 1.0 / (1.0 + std::exp(-x));
}
std::pair<double, double> lstm_cell_forward(
double x_val, double h_prev, double c_prev,
const std::vector<double>& Wf, const std::vector<double>& Wi,
const std::vector<double>& Wc, const std::vector<double>& Wo,
double bf, double bi, double bc, double bo
) {
double zf = Wf[0] * x_val + Wf[1] * h_prev + bf;
double f_t = sigmoid(zf);
double zi = Wi[0] * x_val + Wi[1] * h_prev + bi;
double i_t = sigmoid(zi);
double zc = Wc[0] * x_val + Wc[1] * h_prev + bc;
double c_tilde = std::tanh(zc);
double c_t = f_t * c_prev + i_t * c_tilde;
double zo = Wo[0] * x_val + Wo[1] * h_prev + bo;
double o_t = sigmoid(zo);
double h_t = o_t * std::tanh(c_t);
c_t = std::round(c_t * 10000.0) / 10000.0;
h_t = std::round(h_t * 10000.0) / 10000.0;
return {c_t, h_t};
}
Phân tích giải thuật và độ phức tạp
- Độ phức tạp thời gian (Time Complexity): Với mỗi bước thời gian của một ô nhớ kích thước ẩn \(h\) và kích thước đầu vào \(d\), việc tính toán các phép nhân ma trận trọng số đòi hỏi \(\mathcal{O}(d \cdot h + h^2)\) phép tính số học. Đối với toàn bộ chuỗi có độ dài \(T\), tổng thời gian tính toán là \(\mathcal{O}(T \cdot (d \cdot h + h^2))\).
- Độ phức tạp không gian (Space Complexity): Trong quá trình suy luận (Inference), bộ nhớ chỉ cần lưu trữ vector trạng thái hiện tại \(\mathcal{O}(h)\). Trong quá trình huấn luyện (Training với BPTT), mạng cần lưu lại toàn bộ các giá trị trung gian \(f_t, i_t, o_t, C_t, h_t\) qua tất cả \(T\) bước để phục vụ tính đạo hàm chuỗi, tiêu tốn dung lượng bộ nhớ \(\mathcal{O}(T \cdot h)\).
7. Các bẫy kỹ thuật thường gặp và kinh nghiệm thực chiến
- Khởi tạo sai lệch cho cổng quên (Forget Gate Bias Initialization): Một mẹo thực chiến kinh điển (có từ bài báo của Gers et al. năm 2000, được Rafal Jozefowicz et al. (2015) nhấn mạnh lại) là khởi tạo bias của cổng quên \(b_f\) bằng \(1.0\) hoặc \(2.0\) thay vì khởi tạo bằng \(0\). Khi \(b_f = 1\), giá trị ban đầu của \(f_t = \sigma(1) \approx 0.73\), giúp cổng quên mặc định mở rộng ở giai đoạn đầu huấn luyện. Nhờ đó, gradient không bị chặn ngay từ các epoch đầu tiên, cải thiện tốc độ hội tụ rõ rệt.
- Áp dụng Dropout không đúng cách trong RNN: Không bao giờ được áp dụng kỹ thuật Dropout ngẫu nhiên thông thường lên các kết nối hồi quy theo thời gian (\(h_{t-1} \to h_t\)). Làm như vậy sẽ làm đứt gãy dòng thông tin lịch sử và khiến mô hình không thể tích lũy bộ nhớ. Thay vào đó, phải sử dụng Variational Dropout (áp dụng cùng một mặt nạ dropout cố định cho tất cả các bước thời gian) hoặc chỉ áp dụng Dropout lên các kết nối giữa các tầng xếp chồng theo chiều dọc (inter-layer connections).
- Giới hạn tuần tự phần cứng: Hạn chế lớn nhất của họ mô hình hồi quy (RNN/LSTM/GRU) là tính tuần tự không thể phá vỡ: bước \(t\) bắt buộc phải chờ kết quả từ bước \(t-1\). Điều này khiến chúng không thể tận dụng tối đa kiến trúc hàng ngàn nhân xử lý song song của GPU. Đây chính là lý do lịch sử thúc đẩy sự ra đời của kiến trúc Transformer dựa hoàn toàn trên cơ chế Attention.
8. Bài tập vận dụng và câu hỏi phỏng vấn
- Câu hỏi: Tại sao trong công thức cập nhật trạng thái ô của LSTM lại dùng hàm \(\tanh\) cho ứng viên \(\tilde{\mathbf{C}}_t\) mà không dùng hàm Sigmoid hay ReLU?
- Gợi ý trả lời: Hàm Sigmoid chỉ trả về giá trị dương \((0, 1)\), khiến cho trạng thái ô \(\mathbf{C}_t\) chỉ có thể tăng đơn điệu theo thời gian nếu cứ cộng dồn. Hàm \(\tanh\) đối xứng quanh gốc tọa độ \((-1, 1)\), cho phép mô hình linh hoạt tăng hoặc giảm giá trị bộ nhớ. Hàm ReLU không bị chặn trên, dễ khiến trạng thái ô bùng nổ giá trị qua hàng trăm bước tích lũy.
- Câu hỏi: Giả sử bạn đang xây dựng mô hình phát hiện bất thường trong giao dịch ngân hàng theo thời gian thực trên thiết bị vi điều khiển có bộ nhớ RAM cực kỳ hạn chế (dưới 512KB). Bạn sẽ ưu tiên chọn LSTM hay GRU? Giải thích lý do cụ thể.
- Gợi ý trả lời: Ưu tiên lựa chọn GRU vì GRU giảm được 25% kích thước ma trận trọng số, chỉ phải lưu 1 vector trạng thái ẩn \(h_t\) thay vì 2 vector như LSTM, tiết kiệm tài nguyên lưu trữ và tính toán đáng kể trên phần cứng nhúng.
9. Đào sâu toán học: Lan truyền ngược qua thời gian (BPTT) và Bán kính phổ
Để thấu hiểu nguồn gốc sâu xa của hiện tượng suy biến đạo hàm trong mạng hồi quy, ta cần xem xét phép đạo hàm Jacobian đầy đủ trong quá trình Lan truyền ngược qua thời gian (Backpropagation Through Time - BPTT).
Xét một chuỗi đầu vào \(T\) bước với hàm mất mát tổng thể \(\mathcal{L} = \sum_{t=1}^T \mathcal{L}_t\). Khi cập nhật ma trận trọng số hồi quy \(\mathbf{W}_{hh}\), đạo hàm riêng tại bước \(t\) được mở rộng theo quy tắc đạo hàm chuỗi đa biến:
\[\frac{\partial \mathcal{L}_t}{\partial \mathbf{W}_{hh}} = \sum_{k=1}^t \frac{\partial \mathcal{L}_t}{\partial \mathbf{h}_t} \frac{\partial \mathbf{h}_t}{\partial \mathbf{h}_k} \frac{\partial^+ \mathbf{h}_k}{\partial \mathbf{W}_{hh}}\]
Trong đó \(\frac{\partial^+ \mathbf{h}_k}{\partial \mathbf{W}_{hh}}\) là đạo hàm riêng trực tiếp xem \(\mathbf{h}_{k-1}\) như một hằng số. Trọng tâm của sự bất ổn định số học nằm ở tích chuỗi ma trận chuyển tiếp trạng thái:
\[\frac{\partial \mathbf{h}_t}{\partial \mathbf{h}_k} = \prod_{j=k+1}^t \frac{\partial \mathbf{h}_j}{\partial \mathbf{h}_{j-1}} = \prod_{j=k+1}^t \text{diag}(1 - \mathbf{h}_j^2) \mathbf{W}_{hh}^T\]
Ký hiệu \(\mathbf{D}_j = \text{diag}(1 - \mathbf{h}_j^2)\) là ma trận đường chéo chứa các đạo hàm của hàm kích hoạt \(\tanh\). Vì giá trị của \(\tanh(z) \in (-1, 1)\), mọi phần tử trên đường chéo của \(\mathbf{D}_j\) đều bị chặn nghiêm ngặt:
\[0 \le 1 - h_{j, m}^2 \le 1\]
Đặt bán kính phổ (spectral radius) của ma trận trọng số \(\mathbf{W}_{hh}\) là \(\rho(\mathbf{W}_{hh}) = \max_i |\lambda_i|\), tức giá trị riêng có độ lớn tuyệt đối lớn nhất. Gọi \(\gamma\) là cận trên của \(\|\mathbf{D}_j\|\) (với \(\tanh\) thì \(\gamma \le 1\)) và dùng chuẩn phổ \(\|\mathbf{W}_{hh}\|\) (giá trị suy biến lớn nhất, luôn lớn hơn hoặc bằng \(\rho(\mathbf{W}_{hh})\)). Vì chuẩn của một tích không vượt quá tích các chuẩn:
\[\left\|\frac{\partial \mathbf{h}_t}{\partial \mathbf{h}_k}\right\| \le \prod_{j=k+1}^t \|\mathbf{D}_j\| \cdot \|\mathbf{W}_{hh}^T\| \le \gamma^{t-k} \|\mathbf{W}_{hh}\|^{t-k}\]
- Trường hợp \(\gamma \|\mathbf{W}_{hh}\| \lt 1\): Chuẩn của gradient giảm dần theo hàm mũ khi khoảng cách thời gian \(t - k\) tăng lên. Ví dụ với \(\gamma \|\mathbf{W}_{hh}\| = 0.9\): khi \(t - k = 50\), hệ số suy giảm xấp xỉ \(0.9^{50} \approx 0.00515\), và với \(t - k = 100\), hệ số này chỉ còn \(0.000026\). Điều này đồng nghĩa với việc các sự kiện diễn ra ở quá khứ xa hoàn toàn không thể tác động tới việc cập nhật trọng số của mô hình ở hiện tại. Mạng bị "mất trí nhớ dài hạn".
- Trường hợp \(\|\mathbf{W}_{hh}\| \gt 1\) và trạng thái nơ-ron không bão hòa: Gradient có thể tăng trưởng bùng nổ theo cấp số nhân \(\mathcal{O}(\lambda^{t-k})\), dẫn đến tràn số số học. Để chế ngự hiện tượng bùng nổ đạo hàm này, giải pháp tiêu chuẩn bắt buộc phải áp dụng trong mọi thư viện Deep Learning là kỹ thuật Cắt tỉa gradient (Gradient Clipping theo chuẩn L2):
\[\mathbf{g} \leftarrow \begin{cases} \mathbf{g} & \text{nếu } \|\mathbf{g}\|_2 \le \theta \\ \frac{\theta}{\|\mathbf{g}\|_2} \mathbf{g} & \text{nếu } \|\mathbf{g}\|_2 \gt \theta \end{cases}\]
Trong đó ngưỡng \(\theta\) thường được thiết lập trong khoảng từ \(1.0\) đến \(5.0\). Thao tác này giúp vector gradient giữ nguyên phương hướng tối ưu ban đầu nhưng độ dài bước nhảy bị giới hạn an toàn.
10. Mạng Hồi quy Hai chiều (Bidirectional RNN / LSTM)
Trong nhiều bài toán xử lý ngôn ngữ tự nhiên như gắn nhãn từ loại (Part-Of-Speech Tagging), nhận dạng thực thể có tên (Named Entity Recognition - NER) hoặc phân loại cảm xúc văn bản, mô hình không chỉ cần nắm bắt thông tin từ quá khứ mà còn cần hiểu toàn bộ ngữ cảnh tương lai xuất hiện phía sau.
Ví dụ trong hai câu:
- "Tôi đi rút tiền ở ngân hàng nông nghiệp."
- "Hai chiếc thuyền neo đậu bên bờ ngân hàng cát."
Nếu chỉ đọc từ trái sang phải tuần tự đến từ "ngân hàng", mô hình chưa thể phân biệt chính xác nghĩa của từ nếu chưa đọc tiếp các từ phía sau ("nông nghiệp" hay "cát").
Kiến trúc Mạng nơ-ron Hồi quy Hai chiều (Bidirectional LSTM - BiLSTM) giải quyết bài toán này bằng cách triển khai hai chuỗi ô nhớ hoạt động độc lập:
- Chuỗi tiến (Forward LSTM): Quét văn bản từ đầu câu đến cuối câu (\(t = 1 \to T\)), thu được vector trạng thái ẩn tiến \(\overrightarrow{\mathbf{h}}_t\).
- Chuỗi lùi (Backward LSTM): Quét văn bản từ cuối câu ngược về đầu câu (\(t = T \to 1\)), thu được vector trạng thái ẩn lùi \(\overleftarrow{\mathbf{h}}_t\).
Tại mỗi bước thời gian \(t\), biểu diễn toàn diện của từ được tạo ra bằng cách ghép nối (concatenate) hai vector trạng thái:
\[\mathbf{h}_t = [\overrightarrow{\mathbf{h}}_t \,;\, \overleftarrow{\mathbf{h}}_t] \in \mathbb{R}^{2h}\]
BiLSTM từng là trụ cột không thể thay thế trong các hệ thống trích xuất thông tin y tế, phân tích tài liệu pháp lý và nhận diện giọng nói trước khi kiến trúc Transformer xuất hiện.
11. Kiến trúc Seq2Seq và Cơ chế Chú ý sơ khai (Bahdanau Attention)
Thành tựu đỉnh cao nhất của mạng nơ-ron hồi quy trong thập kỷ 2010 là mô hình Sequence-to-Sequence (Seq2Seq) ứng dụng cho Dịch máy Tự động (Neural Machine Translation - NMT) của Sutskever et al. (2014) và Cho et al. (2014).
Hệ thống bao gồm hai khối LSTM độc lập:
- Khối Mã hóa (Encoder): Đọc chuỗi câu nguồn (ví dụ tiếng Anh) từng từ một. Trạng thái ẩn cuối cùng \(\mathbf{h}_T\) của Encoder đóng vai trò như một vector ngữ cảnh cô đọng toàn bộ ý nghĩa của câu văn.
- Khối Giải mã (Decoder): Nhận vector ngữ cảnh này làm trạng thái khởi tạo \(\mathbf{s}_0\), sau đó tự hồi quy sinh từng từ của câu đích (ví dụ tiếng Việt).
Tuy nhiên, việc ép buộc toàn bộ ý nghĩa của một câu văn dài 40 từ vào một vector ngữ cảnh có kích thước cố định (ví dụ 512 chiều) tạo ra một điểm nghẽn thông tin nghẹt thở (information bottleneck).
Năm 2014, Dzmitry Bahdanau cùng Yoshua Bengio đề xuất bổ sung Cơ chế Chú ý (Attention Mechanism) cho Seq2Seq. Thay vì chỉ nhìn vào vector trạng thái cuối cùng, tại mỗi bước giải mã \(t\), Decoder được phép nhìn lại toàn bộ các trạng thái ẩn \(\mathbf{h}_i\) của Encoder và tính toán trọng số chú ý mềm \(\alpha_{ti}\):
\[e_{ti} = \mathbf{v}_a^T \tanh(\mathbf{W}_a \mathbf{s}_{t-1} + \mathbf{U}_a \mathbf{h}_i)\]
\[\alpha_{ti} = \frac{\exp(e_{ti})}{\sum_{k=1}^T \exp(e_{tk})}\]
\[\mathbf{c}_t = \sum_{i=1}^T \alpha_{ti} \mathbf{h}_i\]
Vector ngữ cảnh động \(\mathbf{c}_t\) tập trung đúng vào từ ngữ đang cần dịch. Đây chính là bước tiến bản lề lịch sử, trực tiếp châm ngòi cho sự ra đời của bài báo "Attention Is All You Need" loại bỏ hoàn toàn khung sườn RNN 3 năm sau đó.
Khóa AI – Introduction to Machine Learning: nền tảng Máy học từ thuật toán cơ bản đến Neural Networks và LLM, học bằng Python. Học thử buổi 1 miễn phí.


