Bài 34: Sequential Data — vì sao cần kiến trúc khác MLP / CNN

Sau bài học, bạn sẽ:

• Định nghĩa được sequential data và ba đặc thù (thứ tự, độ dài biến thiên, context phụ thuộc).
• Giải thích vì sao MLP (input fixed size) và CNN (receptive field hạn chế, không có memory) không phù hợp cho sequence dài.
• Liệt kê dòng kiến trúc lịch sử cho sequence: RNN (1986) → LSTM (1997) → GRU (2014) → Transformer (2017).
• Phân loại được ba task pattern: one-to-many, many-to-one, many-to-many.
• Biết cách biểu diễn text bằng one-hot, embedding học được, embedding pretrained (Word2Vec, GloVe).
• Biết cách xử lý batch sequence trong PyTorch: padding, pack_padded_sequence, bucketing.
• Hình dung lộ trình 7 bài của Module 5.

Bài này nối tiếp Bài 33 — Các kiến trúc CNN nổi bật và đặt nền cho Bài 35 — Vanilla RNN.

Sau bốn module đầu, bạn đã có:

• Module 1: perceptron, MLP, activation, loss, backpropagation.
• Module 2: PyTorch — tensor, autograd, nn.Module, optimizer, training loop, DataLoader.
• Module 3: regularization và optimization — dropout, batch norm, early stopping, LR schedule, augmentation.
• Module 4: CNN cho ảnh — conv, pooling, các kiến trúc kinh điển (LeNet → ResNet → EfficientNet).

Tất cả những gì đã học cho tới giờ giả định input là fixed-size vector (MLP, tabular) hoặc fixed-size tensor (CNN, ảnh được resize cố định). Khi sang dữ liệu chuỗi — một câu có thể 5 từ hoặc 100 từ, một chuỗi giá cổ phiếu có thể 30 ngày hoặc 365 ngày — giả định fixed-size không còn hợp lý.

Module 5 trả lời ba câu hỏi: sequential data khác ảnh / tabular ở điểm gì, kiến trúc nào phù hợp, và làm sao đưa data dạng chuỗi vào PyTorch training loop.

Sequential data là chuỗi các phần tử có thứ tự, viết là \( x_1, x_2, \dots, x_T \), với \( T \) là số time step. Mỗi \( x_t \) có thể là:

• Một số (giá cổ phiếu ngày \( t \), nhiệt độ giờ \( t \)).
• Một vector (embedding của từ thứ \( t \) trong câu, một frame audio).
• Một tensor (frame video — chính là ảnh).

Điểm chung là thứ tự: hoán đổi \( x_1 \) với \( x_5 \) tạo ra chuỗi khác hẳn về ngữ nghĩa, ngay cả khi tập phần tử giống nhau. Đây là điểm phân biệt với dữ liệu tabular (mỗi feature độc lập, đổi cột không đổi ý nghĩa hàng).

• Có thứ tự (ordered): "Tôi yêu mèo" khác "Mèo yêu tôi". Cùng ba từ, hai nghĩa khác nhau. Tương tự, chuỗi nhiệt độ [20, 22, 25, 28] (tăng dần) khác [28, 25, 22, 20] (giảm dần) dù tập giá trị giống hệt.
• Variable length: một câu có thể 5 từ, một câu khác 100 từ. Một đoạn audio có thể 2 giây, một đoạn khác 30 phút. Không có "số chiều" cố định để định nghĩa input shape như với ảnh \( 224 \times 224 \).
• Context phụ thuộc: nghĩa của \( x_t \) phụ thuộc context xung quanh. Trong "I went to the bank to deposit money", "bank" là ngân hàng. Trong "I sat by the river bank", "bank" là bờ sông. Cùng một token, nghĩa khác nhau vì context khác nhau.

Kiến trúc xử lý sequence cần tôn trọng cả ba đặc thù này.

• Text / NLP: dịch máy (machine translation), sentiment analysis, chatbot, autocomplete, code completion. Mỗi từ / subword là một time step.
• Time series: giá cổ phiếu, dữ liệu thời tiết, dữ liệu sensor IoT, nhịp tim ECG. Mỗi mốc thời gian là một time step.
• Audio waveform: speech recognition, music generation, voice command. Sampling rate điển hình 16 kHz hoặc 44.1 kHz — một giây có hàng chục nghìn time step nếu giữ raw signal, hoặc vài trăm step nếu chuyển sang spectrogram.
• Video: chuỗi frame theo thời gian. Mỗi frame là một ảnh. Action recognition, video captioning, tracking.
• DNA / RNA: chuỗi nucleotide (A, C, G, T). Bioinformatics, gene function prediction, protein folding (AlphaFold sử dụng kiến trúc dựa trên attention cho chuỗi amino acid).
• User behavior log: clickstream trên website, lịch sử mua hàng, session log. Recommendation system, fraud detection.

Module 5 tập trung vào text (B40 — Seq2Seq) và time series (B39 — forecasting). Audio và video có cùng nguyên lý nhưng cần thêm preprocessing chuyên biệt.

MLP có hai giới hạn cốt lõi khi xử lý sequence:

• Input fixed size: lớp nn.Linear(in_features=N, ...) bắt input phải đúng \( N \) phần tử. Với câu dài 5 từ và câu dài 100 từ, không có cách thẳng để đưa cả hai vào cùng một MLP. Phải pad / truncate về độ dài cố định — vừa lãng phí (pad nhiều), vừa mất thông tin (truncate phần cuối).
• Không có memory về past context: MLP tính \( y = f(x) \) thuần — output chỉ phụ thuộc input hiện tại, không có khái niệm "đã thấy gì trước đó". Khi sequence được flatten thành một vector dài, các time step bị xáo trộn vai trò và MLP không có cơ chế khôi phục thứ tự.

Có thể "ép" MLP làm với sequence cố định độ dài \( T \) bằng cách concat \( [x_1, \dots, x_T] \) thành một vector. Cách này hoạt động cho \( T \) nhỏ và cố định (vd 10 ngày cuối → dự đoán ngày kế), nhưng không scale lên text dài hoặc time series có độ dài biến thiên.

CNN handle variable length tốt hơn MLP (kernel trượt được trên input dài tuỳ ý) và có inductive bias locality phù hợp với một số sequence. 1D CNN từng được dùng cho NLP (Kim 2014, arXiv:1408.5882 — Convolutional Neural Networks for Sentence Classification) và vẫn được dùng cho time series ngắn.

Nhưng CNN có hai giới hạn cho sequence dài:

• Receptive field hạn chế: kernel \( k \) phần tử chỉ "nhìn" được \( k \) phần tử kế nhau. Để nhìn xa hơn phải chồng nhiều layer; receptive field tăng tuyến tính theo độ sâu. Với câu 1000 token cần phụ thuộc xa, mạng phải rất sâu hoặc dilated convolution — vẫn tốn kém.
• Không có memory rõ ràng: CNN tính output ở mỗi vị trí dựa trên local window, không duy trì trạng thái "tổng hợp" của toàn bộ chuỗi cho đến time step hiện tại. Bài toán đòi hỏi long-term dependency (vd câu đầu đoạn ảnh hưởng câu cuối đoạn) thì CNN không có cấu trúc tự nhiên cho việc này.

RNN ra đời để bù vào đúng hai chỗ này: variable length tự nhiên (xử lý từng time step) và có hidden state mang context tích luỹ.

Theo thứ tự lịch sử:

1. RNN (Rumelhart et al. 1986, Elman 1990): có hidden state truyền qua time step.
2. LSTM (Hochreiter & Schmidhuber 1997): thêm cơ chế gate để fix vanishing gradient của RNN.
3. GRU (Cho et al. 2014, arXiv:1406.1078): bản đơn giản hoá của LSTM.
4. Transformer (Vaswani et al. 2017, arXiv:1706.03762): bỏ recurrent, dùng attention. Là kiến trúc của các LLM hiện nay (GPT, Claude, Llama, Gemini).

Module 5 đi qua RNN → LSTM → GRU. Transformer được nhắc đến trong bài này, đã đề cập trong B33 (so sánh với ViT), và sẽ deep dive ở Series 4 (LLM & GenAI).

Ý tưởng cốt lõi: tại mỗi time step \( t \), mạng nhận input \( x_t \) và hidden state \( h_{t-1} \) (trạng thái từ step trước), sinh ra hidden state mới \( h_t \) và output \( y_t \) (nếu có):

\[ h_t = \tanh(W_{hh} h_{t-1} + W_{xh} x_t + b_h) \]

Cùng một bộ weight \( W_{hh}, W_{xh} \) được dùng cho mọi time step (weight sharing theo thời gian). Hidden state \( h_t \) tích luỹ thông tin từ \( x_1, \dots, x_t \) — đó là "memory" của mạng.

Đặc điểm:

• Variable length: xử lý từng time step nên độ dài chuỗi không cần cố định.
• Có memory: hidden state mang context cumulative.
• Train qua backpropagation through time (BPTT) — biến thể của backprop cho recurrent.

Vanilla RNN có vấn đề vanishing / exploding gradient với chuỗi dài. Chi tiết ở B35 (RNN cơ bản) và B36 (vanishing gradient).

Hochreiter & Schmidhuber (1997, "Long Short-Term Memory", Neural Computation 9(8)) đề xuất kiến trúc thay hidden state đơn của RNN bằng một cell có ba gate:

• Forget gate: quyết định bao nhiêu phần của cell state cũ giữ lại.
• Input gate: quyết định bao nhiêu thông tin mới ghi vào cell state.
• Output gate: quyết định bao nhiêu phần của cell state hiển thị ra hidden state.

Cell state đi qua các gate bằng phép nhân (multiplicative gating) — gradient có đường truyền "thẳng" theo cell state, ít bị nhân chuỗi tanh' như RNN. Kết quả: train được trên chuỗi dài hàng trăm time step, vẫn là một trong những kiến trúc phổ biến nhất cho time series.

Deep dive ở B37.

Cho et al. (2014, arXiv:1406.1078, "Learning Phrase Representations using RNN Encoder–Decoder for Statistical Machine Translation") đề xuất GRU — phiên bản đơn giản hơn của LSTM:

• Chỉ có hai gate (reset gate, update gate) thay vì ba.
• Không có cell state riêng — hidden state và memory hợp lại.
• Ít parameter hơn LSTM khoảng 25%.

Trên nhiều benchmark, GRU và LSTM tương đương về accuracy; GRU train nhanh hơn một chút và phù hợp với data ít. Deep dive ở B38.

Vaswani et al. (2017, arXiv:1706.03762, "Attention Is All You Need") đề xuất kiến trúc bỏ hoàn toàn recurrent, dùng self-attention — mỗi token nhìn trực tiếp đến tất cả token khác trong chuỗi (không phải qua hidden state tích luỹ).

Hai khác biệt lớn so với RNN/LSTM/GRU:

• Parallel: không có phụ thuộc tuần tự theo \( t \) — tất cả time step xử lý song song trên GPU. Train nhanh hơn nhiều cho cùng số param.
• Long-range dependency: mọi cặp token đều có path trực tiếp với nhau (\( O(1) \) thay vì \( O(T) \) như RNN). Phụ thuộc xa được học dễ hơn.

Modern LLM (GPT, Claude, Llama, Gemini) đều là kiến trúc decoder-only Transformer. Bài 33 đã đề cập trong context Vision Transformer; Series 4 (LLM & GenAI) sẽ deep dive từ encoder-decoder cơ bản đến scaling laws.

Trong phần lớn bài toán NLP với text trung bình–dài, data đủ lớn, GPU có sẵn — Transformer là default.

RNN / LSTM / GRU vẫn được dùng trong các trường hợp sau:

• Real-time / streaming: dữ liệu đến từng time step (audio streaming, sensor live). RNN xử lý từng step và update hidden state, không phải xử lý lại toàn chuỗi như attention chuẩn.
• Edge device / low-resource: param ít hơn Transformer cùng task; chạy được trên thiết bị nhúng, mobile.
• Time series ngắn (5–100 step): LSTM/GRU đủ tốt, đơn giản hơn Transformer, ít hyperparameter.
• Học foundation: hiểu RNN trước giúp tiếp cận attention dễ hơn. Hidden state cumulative là tiền đề khái niệm để hiểu vì sao attention "bỏ" cấu trúc tuần tự.

Module 5 đi RNN → LSTM → GRU để xây nền vững cho Series 4. Không có khẳng định "RNN đã chết" — kiến trúc nào phù hợp với bài toán nào thì dùng kiến trúc đó.

Quy ước dùng xuyên suốt Module 5:

• Chuỗi input: \( x_1, x_2, \dots, x_T \) với \( T \) là số time step.
• Mỗi \( x_t \) là vector kích thước \( d_{in} \) (vd embedding của một từ kích thước 300, một frame audio kích thước 80 cho mel-spectrogram).
• Hidden state: \( h_t \) kích thước \( d_h \) (hidden size).
• Output: \( y_t \) tại từng time step, hoặc \( y_T \) duy nhất ở cuối (cho classification).
• Batch dim: PyTorch dùng shape (batch, seq_len, feature) khi đặt batch_first=True. Mặc định của nn.RNN/nn.LSTM/nn.GRU là (seq_len, batch, feature) — chú ý khi đọc code.

Phân loại theo hình dạng input / output:

• One-to-many: 1 input → sequence output. Ví dụ image captioning (1 ảnh → 1 câu mô tả), music generation từ một seed.
• Many-to-one: sequence input → 1 output. Ví dụ sentiment classification (1 câu → 1 nhãn positive/negative), time series forecast 1 bước (\( x_1, \dots, x_T \) → \( y \) — giá trị tiếp theo).
• Many-to-many: sequence input → sequence output. Hai biến thể:
  • Aligned: cùng độ dài, mỗi step input có 1 step output. Vd named entity recognition, video frame labeling.
  • Unaligned (seq2seq): độ dài khác nhau. Vd machine translation ("I love cats" 3 token → "Tôi yêu mèo" 3 token, hoặc "tôi rất thích mèo" 4 token).

Mỗi pattern có kiến trúc tương ứng — chi tiết ở B40 (Seq2Seq intuition).

Mạng neural cần input là số. Text phải qua hai bước: tokenize (chia thành token, gán id integer) và embed (id → vector).

• One-hot: vocabulary \( V \) từ → mỗi từ là vector dài \( |V| \), một vị trí 1, còn lại 0. Vocabulary 50 000 từ → vector 50 000 chiều, gần như toàn 0. Tốn memory, không học được tương quan giữa từ.
• Embedding học được: bảng tra cứu (lookup table) shape \( (|V|, d_{emb}) \) — mỗi từ map sang vector dense kích thước \( d_{emb} \) (thường 100–1024). Bảng này là parameter của mạng, học cùng các weight khác qua backprop. Trong PyTorch: nn.Embedding(num_embeddings, embedding_dim).
• Embedding pretrained: Word2Vec (Mikolov et al. 2013, arXiv:1301.3781), GloVe (Pennington et al. 2014). Train trên corpus lớn, capture được tương quan ngữ nghĩa (vd king − man + woman ≈ queen). Dùng làm khởi tạo cho embedding layer, sau đó fine-tune hoặc freeze.
• Modern: BPE + embedding learned: GPT, Llama dùng Byte-Pair Encoding để tokenize ở cấp subword, kèm embedding học cùng model. Chi tiết ở Series 4 — Bài 3 (Tokenization).

• Raw numeric value: giá cổ phiếu, nhiệt độ, sensor reading — đã là số, đưa thẳng vào mạng.
• Normalize / standardize: bắt buộc khi các feature có scale rất khác nhau (giá cổ phiếu 1000 USD vs lãi suất 0.05). Thường dùng z-score: \( x' = (x - \mu) / \sigma \) tính trên train set, áp lên cả train và test.
• Lag features: thêm các giá trị quá khứ làm feature mở rộng — \( x_t, x_{t-1}, x_{t-7} \) cho time series có pattern theo tuần.
• Positional encoding (optional): khi dùng Transformer cho time series, phải tự thêm thông tin vị trí; không cần khi dùng RNN/LSTM (vị trí đã ngầm trong thứ tự xử lý).

Chi tiết time series ở B39.

Ba mức tokenize phổ biến:

• Word-level: tách theo từ. Vocabulary có thể 50 000–500 000 token. OOV (out-of-vocabulary) là vấn đề lớn — từ mới không có trong vocab phải map sang <UNK>.
• Char-level: tách theo ký tự. Vocabulary nhỏ (~100 cho tiếng Anh) nhưng sequence dài hơn nhiều (1 câu 5 từ ≈ 25 ký tự). Không có OOV.
• Subword (BPE, WordPiece, SentencePiece): chia từ thành các đơn vị nhỏ hơn. "tokenization" → ["token", "ization"]. Vocabulary 30 000–100 000, ít OOV, sequence length vừa phải. GPT (tiktoken), BERT (WordPiece), Llama (SentencePiece) đều dùng subword.

Module 5 sẽ dùng word-level đơn giản trong các bài lab. Subword sâu hơn ở Series 4.

Một batch trong PyTorch là tensor đều — tất cả sample phải cùng shape. Sequence variable length cần xử lý batch riêng:

• Padding: chọn độ dài tối đa trong batch \( T_{max} \), pad các sequence ngắn hơn bằng giá trị đặc biệt (thường là 0, hoặc id của <PAD>). Kết quả: batch tensor shape (batch, T_max, feature).
• PackedSequence: nn.utils.rnn.pack_padded_sequence tạo struct nén thông tin về độ dài thực của từng sample, để RNN không tính toán trên phần pad. Tiết kiệm compute và tránh "memory pad" làm bẩn hidden state.
• Bucketing: group các sample có độ dài gần nhau vào cùng batch — giảm pad waste. Phổ biến trong training NMT với corpus đa độ dài.

Code mẫu sẽ xuất hiện ở B35 trở đi.

1. Bài 34 (bài này) — Sequential data motivation: vì sao cần kiến trúc khác MLP / CNN.
2. Bài 35 — Vanilla RNN: công thức hidden state, BPTT, code PyTorch tay.
3. Bài 36 — Vanishing / Exploding Gradient: vì sao vanilla RNN khó train trên chuỗi dài.
4. Bài 37 — LSTM: cell state, ba gate, code nn.LSTM.
5. Bài 38 — GRU: reset / update gate, so sánh với LSTM.
6. Bài 39 — Time Series prediction: dự đoán một bước và nhiều bước trên dữ liệu thực.
7. Bài 40 — Seq2Seq intuition: encoder-decoder cho machine translation, bridge sang Transformer ở Series 4.

Kết thúc Module 5, bạn train được RNN/LSTM/GRU cho text classification và time series forecasting, và có nền để học Transformer ở Series 4.

Minh hoạ pipeline cơ bản: câu → list integer → tensor embedding. Chưa build RNN — đợi B35.

import torch
import torch.nn as nn

# Vocabulary đơn giản: word -> id
vocab = {"<PAD>": 0, "<UNK>": 1, "tôi": 2, "yêu": 3, "mèo": 4, "chó": 5}
vocab_size = len(vocab)
embedding_dim = 8

# Tokenize 1 câu
sentence = "tôi yêu mèo"
tokens = sentence.split()
ids = [vocab.get(t, vocab["<UNK>"]) for t in tokens]
print(f"tokens: {tokens}")
print(f"ids   : {ids}")

# Tensor input: shape (batch=1, seq_len=3)
x = torch.tensor([ids], dtype=torch.long)
print(f"x shape: {x.shape}")

# Embedding lookup
embed = nn.Embedding(num_embeddings=vocab_size, embedding_dim=embedding_dim)
out = embed(x)  # shape: (1, 3, 8)
print(f"out shape: {out.shape}")
print(f"params   : {sum(p.numel() for p in embed.parameters()):,}")

Output:

tokens: ['tôi', 'yêu', 'mèo']
ids   : [2, 3, 4]
x shape: torch.Size([1, 3])
out shape: torch.Size([1, 3, 8])
params   : 48

Mỗi token \( x_t \) (id integer) được map thành vector \( \mathbb{R}^8 \). Bảng embedding có \( |V| \times d_{emb} = 6 \times 8 = 48 \) param. Tensor out chính là input của RNN ở B35.

1. Xác định task pattern (one-to-many / many-to-one / many-to-many) cho 5 bài toán sau:
   • Sentiment analysis một review phim.
   • Machine translation Anh → Việt.
   • Image captioning từ một ảnh.
   • Time series forecast giá cổ phiếu (cho \( x_1, \dots, x_{30} \), dự đoán \( x_{31} \)).
   • Voice command — chuỗi audio frame → 1 trong 10 lệnh ("bật đèn", "tắt nhạc", ...).
2. Cho vocabulary {"<PAD>": 0, "<UNK>": 1, "the": 2, "cat": 3, "sat": 4, "on": 5, "mat": 6}. Tokenize hai câu sau thành list id, áp dụng padding để cùng độ dài 7:
   • "the cat sat on the mat"
   • "cat sat"
3. Tạo một nn.Embedding cho vocabulary 100 từ, embedding dim 16. Tính số parameter của embedding layer này. So sánh với one-hot + linear layer tương đương (one-hot 100 chiều → linear ra 16) — số param có khác không, và vì sao về bản chất chúng tương đương?
4. Một MLP nhận flatten của câu tối đa 50 từ với embedding dim 100. Tính số input feature và số param của lớp đầu tiên nếu MLP có 256 hidden unit. So sánh với một RNN có hidden size 256 (param = \( (100 + 256 + 1) \times 256 \)). Cái nào ít param hơn, và mỗi cái có ưu điểm gì?
5. Giải thích tại sao "I went to the bank to deposit money" và "I sat by the river bank" cần kiến trúc có context để xử lý đúng từ "bank". MLP one-hot có giải quyết được không, vì sao?
6. Tìm hiểu nhanh: hidden state \( h_t \) của RNN có phải tham số học được như weight không? Hay nó là giá trị tính ra trong forward pass? (Đáp án có ở B35 nhưng có thể đoán dựa trên công thức ở mục 9.)

• Sequential data có ba đặc thù: thứ tự, độ dài biến thiên, context phụ thuộc. MLP và CNN không tôn trọng đầy đủ ba đặc thù này.
• MLP yêu cầu input fixed size và không có memory về past context. CNN xử lý variable length tốt hơn nhưng receptive field tăng tuyến tính theo độ sâu, không phù hợp long-range dependency.
• Dòng kiến trúc cho sequence: RNN (1986/1990) → LSTM (1997) → GRU (2014) → Transformer (2017).
• RNN có hidden state \( h_t \) truyền qua time step — là "memory" của mạng. LSTM thêm gate để fix vanishing gradient; GRU đơn giản hoá LSTM; Transformer bỏ recurrent, dùng attention song song hoá được.
• Ba task pattern: one-to-many (image captioning), many-to-one (sentiment, forecast 1 bước), many-to-many (translation, NER, video labeling).
• Biểu diễn text: one-hot (sparse, inefficient), embedding học được (nn.Embedding), pretrained Word2Vec/GloVe, BPE + embedding cho LLM hiện đại.
• Biểu diễn time series: raw value + normalize + optional lag feature; positional encoding nếu dùng Transformer.
• DataLoader cho sequence cần padding, pack_padded_sequence, hoặc bucketing để xử lý variable length.
• Lộ trình Module 5: B34 motivation → B35 vanilla RNN → B36 vanishing gradient → B37 LSTM → B38 GRU → B39 time series → B40 seq2seq.