Embedding và dữ liệu chuỗi

ID là địa chỉ, không phải độ lớn

Giả sử mã “đồ_thị” là 2 và “dp” là 3. Không có nghĩa dp lớn hơn đồ thị một đơn vị về kiến thức. Đưa ID thẳng vào lớp linear như một số thực sẽ tạo một quan hệ số không có cơ sở. Embedding dùng ID làm địa chỉ hàng trong bảng $E$ shape (V,d), với $V$ là số token trong vocabulary, $d$ là số thành phần vector.

One-hot $\mathbf u_k$ (số 1 ở vị trí $k$, còn lại 0) nhân bảng cũng chọn đúng hàng $k$: $\mathbf u_k^\top E=E_k$. Lookup trực tiếp cho cùng kết quả mà không phải tạo one-hot rộng $V$ cột.

Các hàng của embedding là tham số; gradient từ loss sửa các hàng đã được dùng. Khi khởi tạo ngẫu nhiên, vector chưa có nghĩa ngôn ngữ. Ý nghĩa đến từ mục tiêu học trên dữ liệu (mục backprop dưới đây) hoặc từ một bảng pretrained đã học sẵn.

Ta quy ước PAD=0, UNK=1, đồ_thị=2, dp=3, toán=4. UNK là token thật để biểu diễn token chưa biết; PAD là phần điền cho bảng. Hai vai trò cần hai ID khác nhau. Vocabulary và mapping phải lưu cùng checkpoint: fit vocabulary trên train, token mới gặp ở test ánh xạ về UNK (hoặc do tokenizer đã có xử lý).

Bảng có $V \cdot d$ tham số: nn.Embedding(30000, 768) có 23 040 000. Vocabulary lớn hơn thì chuỗi ngắn đi nhưng bảng embedding và lớp ra cũng to theo. Thêm token mới vào tokenizer thì bảng phải thêm hàng tương ứng, với Hugging Face là model.resize_token_embeddings(len(tokenizer)); quên bước này thì ID mới vượt khỏi bảng.

Padding tạo bảng, mask giữ ý nghĩa

Trong CP, thường lưu độ dài bên cạnh mảng chứa dư. Mask cũng là thông tin ấy nhưng biểu diễn theo từng ô. pad_sequence tạo độ dài bằng chuỗi dài nhất trong batch, không nhất thiết độ dài toàn dataset. Nếu giới hạn độ dài bằng truncation, ta đang bỏ thông tin thật và phải chọn giới hạn theo bài toán.

import torch
from torch import nn
from torch.nn.utils.rnn import pad_sequence

torch.set_num_threads(1)
torch.manual_seed(37)
PAD, UNK = 0, 1
sequences = [torch.tensor([2, 3]), torch.tensor([3]), torch.tensor([4, 2, 3])]
ids = pad_sequence(sequences, batch_first=True, padding_value=PAD)
valid_mask = ids.ne(PAD)
print(ids.tolist())
print(valid_mask.int().tolist())
print('lengths:', valid_mask.sum(dim=1).tolist())

Kết quả[[2, 3, 0], [3, 0, 0], [4, 2, 3]]
[[1, 1, 0], [1, 0, 0], [1, 1, 1]]
lengths: [2, 1, 3]

Đọc độ dài $2,1,3$; chiều bảng là (3,3) vì có ba mẫu và chuỗi dài nhất có ba token. Tokenizer chi tiết ở chương 6; bài này bắt đầu khi đã có token ID. Index embedding phải là số nguyên trong [0,V), không được chuẩn hóa ID bằng mean/std như feature liên tục.

Với tokenizer của Hugging Face, padding=True đệm tới chuỗi dài nhất của batch, còn truncation=True, max_length=8 cắt trước những chuỗi dài hơn 8: hai câu 5 và 11 token đều thành 8.

Một bảng embedding đặt tay để nhìn phép tính

Để mọi phép tính đọc được bằng mắt, ta đặt tay các vector hai chiều: đồ_thị $[2,0]$, dp $[0,4]$, toán $[2,2]$, UNK $[1,1]$, PAD $[0,0]$. Trong model thật, các hàng này là tham số học từ dữ liệu. padding_idx=0 làm hai việc: khởi tạo hàng PAD bằng 0 và chặn gradient đi vào hàng ấy. Nhưng nó không giữ hàng PAD bằng 0 mãi: copy_ dưới đây, hay nạp một checkpoint, ghi đè cả hàng 0 bằng đúng giá trị được nạp, nên sau khi nạp cần tự kiểm hàng PAD.

table = torch.tensor([[0., 0.], [1., 1.], [2., 0.], [0., 4.], [2., 2.]])
embedding = nn.Embedding(5, 2, padding_idx=PAD)
with torch.no_grad():
    embedding.weight.copy_(table)
vectors = embedding(ids)
print('shapes:', tuple(ids.shape), tuple(embedding.weight.shape), tuple(vectors.shape))
print(vectors[0].tolist())

Kết quảshapes: (3, 3) (5, 2) (3, 3, 2)
[[2.0, 0.0], [0.0, 4.0], [0.0, 0.0]]

ids (B,L) tra mỗi ô ra $d$ số nên vectors là (B,L,d), ở đây (3,3,2). Câu đầu gồm hai token và PAD; hàng cuối vector 0 vẫn là một ô trong tensor. Nếu gọi mean theo toàn chiều $L$, phép chia sẽ tính cả ô đó vào mẫu số. Đó là lỗi dù PAD vector đã bằng 0.

Masked mean giống đếm phần tử hợp lệ

Muốn một vector cho cả chuỗi, cách baseline là trung bình các token thật. Gọi $m_{i,t}$ bằng 1 ở token hợp lệ, 0 ở PAD, ta có

Tử số là tổng vector; mẫu số là số token thật. Mask (B,L) cần thêm chiều cuối thành (B,L,1) để nhân với vectors (B,L,d). Tổng theo dim=1 gộp độ dài, giữ batch và đặc trưng. Kết quả giống xử lý truy vấn tổng rồi chia số phần tử trong CP: mẫu số sai thì tổng đúng vẫn cho đáp án sai.

def masked_mean(vectors, valid_mask):
    assert vectors.shape[:2] == valid_mask.shape
    counts = valid_mask.sum(dim=1, keepdim=True)
    if torch.any(counts == 0):
        raise ValueError('Mỗi chuỗi cần ít nhất một token hợp lệ')
    weighted = vectors * valid_mask.unsqueeze(-1)
    return weighted.sum(dim=1) / counts

pooled = masked_mean(vectors, valid_mask)
print('masked:', [[round(v, 4) for v in row] for row in pooled.tolist()])
print('naive first:', [round(v, 4) for v in vectors.mean(dim=1)[0].tolist()])

Kết quảmasked: [[1.0, 2.0], [0.0, 4.0], [1.3333, 2.0]]
naive first: [0.6667, 1.3333]

Câu đầu đúng là $([2,0]+[0,4])/2=[1,2]$, còn mean ngây thơ chia 3 cho $[2/3,4/3]$. Câu chỉ dp vẫn phải ra $[0,4]$ bất kể nó được pad dài bao nhiêu. Câu thứ ba có $([2,2]+[2,0]+[0,4])/3=[4/3,2]$. Các số ấy giúp kiểm độc lập đoạn pooling.

counts = valid_mask.sum(dim=1)          # shape (2,)
return weighted.sum(dim=1) / counts     # (2,2) / (2,)

Kiểm bất biến khi thêm PAD

Một phép kiểm có ý nghĩa là thêm hai cột PAD và yêu cầu vector pooling không đổi. Đây giống kiểm tính bất biến của thuật toán khi thêm phần tử ngoài miền truy vấn. Ta còn kiểm đầu vào rỗng: không muốn chia 0, cũng không muốn âm thầm trả vector 0 rồi nhầm thành một câu hợp lệ.

extra_ids = torch.cat([ids, torch.zeros(len(ids), 2, dtype=torch.long)], dim=1)
extra_pooled = masked_mean(embedding(extra_ids), extra_ids.ne(PAD))
print('adding PAD changes nothing:', torch.allclose(pooled, extra_pooled))
try:
    empty_ids = torch.zeros(1, 3, dtype=torch.long)
    masked_mean(embedding(empty_ids), empty_ids.ne(PAD))
except ValueError:
    print('empty sequence rejected:', True)

Kết quảadding PAD changes nothing: True
empty sequence rejected: True

Hai dòng True kiểm hai điều khác nhau: padding không làm đổi kết quả; chuỗi rỗng được xử lý rõ ràng. Bài thật có thể quy định câu rỗng thành một token đặc biệt EMPTY hoặc UNK, nhưng quy tắc phải nằm trong dataset và áp dụng giống train/test. clamp_min(1) có thể tránh chia 0 nhưng không tự giải thích ý nghĩa câu rỗng.

Embedding cũng học bằng backprop

Để đọc gradient bằng mắt, đặt loss là tổng mọi thành phần của các vector lookup. Mỗi lần token xuất hiện, hàng embedding của nó nhận gradient $[1,1]$; cộng qua các vị trí ra đúng số lần dùng. Hàng PAD nhận 0 vì padding_idx.

embedding.zero_grad(set_to_none=True)
embedding(ids).sum().backward()
print('gradient rows:', embedding.weight.grad.tolist())
print('PAD has zero gradient:', embedding.weight.grad[PAD].eq(0).all().item())
classifier = nn.Linear(2, 2)
print('classifier logits shape:', tuple(classifier(pooled.detach()).shape))

Kết quảgradient rows: [[0.0, 0.0], [0.0, 0.0], [2.0, 2.0], [3.0, 3.0], [1.0, 1.0]]
PAD has zero gradient: True
classifier logits shape: (3, 2)

Token 2 xuất hiện hai lần, token 3 ba lần, token 4 một lần nên gradient các hàng tương ứng là $[2,2],[3,3],[1,1]$. Hàng UNK không xuất hiện nên nhận 0. Trong training thật, dùng classifier(masked_mean(embedding(ids),mask)), loss nhãn câu, backward và optimizer; không detach pooled nếu muốn embedding học cùng classifier. Dòng cuối ở đây detach vì chỉ kiểm shape và không tiếp tục training.

Nếu optimizer có weight decay áp trực tiếp vào toàn bảng, hàng PAD được nạp khác 0 có thể còn đổi theo decay dù lookup không tạo gradient; hãy kiểm chính sách weight và giữ PAD bằng 0 theo thiết kế. Không đánh đồng “gradient PAD bằng 0” với “mọi cơ chế đều không bao giờ thay PAD”.

Vậy ý nghĩa của vector đến từ đâu? Từ mục tiêu học. Word2vec (skip-gram) là ví dụ kinh điển: mỗi từ phải dự đoán các từ đứng quanh nó trong văn bản, không cần nhãn nào. “BFS” và “DFS” thường đứng cạnh “duyệt”, “đỉnh”, “đồ_thị”, nên gradient đẩy hai hàng embedding của chúng theo những hướng giống nhau và hai vector trở nên gần nhau, dù ID không liên quan gì. Gần nhau ở đây nghĩa là được dùng trong ngữ cảnh giống nhau, chưa chắc là cùng nghĩa.

Bảng học cùng classifier chỉ mang những nét giúp phân loại; bảng pretrained mang nét chung của một kho văn bản lớn và thường là điểm khởi đầu tốt khi dữ liệu train ít.

Skip-gram với cửa sổ 2 lấy mọi cặp (từ giữa, từ cách nó không quá 2 vị trí): câu 5 từ có $2 + 3 + 4 + 3 + 2 = 14$ cặp. Mỗi từ chỉ có một vector, nên “bank” bờ sông và “bank” ngân hàng dùng chung một vector; embedding theo ngữ cảnh ở chương 6 mới tách được hai nghĩa.

Word2vec còn một cách học thứ hai là CBOW (continuous bag of words): lấy trung bình vector các từ ngữ cảnh để đoán từ ở giữa. Mỗi vị trí trong văn bản chỉ cho CBOW một ví dụ, nên nó chạy nhanh hơn và hợp với từ hay gặp. Skip-gram tách mỗi vị trí thành nhiều cặp, nên một từ hiếm xuất hiện vài lần vẫn được cập nhật nhiều lần; với kho văn bản nhỏ có nhiều thuật ngữ hiếm, skip-gram thường cho vector tốt hơn.

Embedding tốt có những hướng gần như cố định: “vua” − “đàn ông” + “phụ nữ” gần “nữ hoàng”; với gensim là wv.most_similar(positive=['vua', 'phụ_nữ'], negative=['đàn_ông']). Nhưng gần nhau nghĩa là xuất hiện trong ngữ cảnh giống nhau, nên “nóng” và “lạnh” trái nghĩa vẫn khá gần.

Mean pooling mất thứ tự

Mean của “đồ_thị dp” và “dp đồ_thị” bằng nhau. Ta đổi vị trí và kiểm:

pair = torch.tensor([[2, 3], [3, 2]])
pair_vectors = masked_mean(embedding(pair), pair.ne(PAD))
print('same after swapping:', torch.allclose(pair_vectors[0], pair_vectors[1]))

Kết quảsame after swapping: True

Phép cộng giao hoán nên mean pooling mất thứ tự. Nó là baseline tốt khi nhãn phụ thuộc chủ yếu vào tập từ (chủ đề, từ khóa), nhưng không đủ khi “A thắng B” khác “B thắng A”.

Muốn phân biệt, token phải tương tác với vị trí trước khi pooling: RNN ở mục sau đọc lần lượt từng token; self-attention kèm thông tin vị trí ở bài 3.9 cho mọi token nhìn nhau. Chỉ cộng vector vị trí (positional encoding) rồi lấy mean ngay vẫn chưa đủ: tổng vector token và tổng vector vị trí đều không đổi khi hoán vị token trong cùng các slot. Self-attention không có tín hiệu vị trí rồi mean cuối cũng giữ tính bất biến hoán vị. Embedding riêng chỉ gán vector cho token, chưa cho token biết ngữ cảnh câu.

RNN đọc theo thứ tự, nhưng phải dừng đúng chỗ

Recurrent neural network (RNN) đọc chuỗi như một vòng lặp có trạng thái, giống duyệt mảng và cập nhật một biến tích lũy trong CP. Với vector token $\mathbf x_t$ và trạng thái ẩn (hidden state) $\mathbf h_{t-1}$:

$W_{xh}$ có shape (H,d), $W_{hh}$ shape (H,H), dùng chung cho mọi bước nên một RNN nhận chuỗi dài bao nhiêu cũng được. Trạng thái sau token cuối là một bản tóm tắt có thứ tự: đổi chỗ hai token là đổi thứ tự cập nhật, kết quả khác. Vì vậy RNN và LSTM không cần mã hóa vị trí như Transformer ở bài 3.9.

nn.RNN của PyTorch lưu hai bias bias_ih, bias_hh (tổng của chúng đóng vai $\mathbf b$), nên với $d=2$, $H=3$ có $3\cdot2+3\cdot3+3+3=21$ tham số.

Với batch đã pad, RNN vẫn chạy qua mọi cột. Ô PAD có vector 0 nhưng bước cập nhật vẫn là $\tanh(W_{hh}\mathbf h_{t-1}+\mathbf b)$, nên trạng thái tiếp tục đổi. Đọc cột cuối outputs[:, -1] là đọc trạng thái sau các PAD. Code dưới so cột cuối với trạng thái tại token thật cuối cùng (chỉ số lengths-1), và với pack_padded_sequence, cách PyTorch cho RNN bỏ hẳn các bước PAD.

from torch.nn.utils.rnn import pack_padded_sequence

torch.manual_seed(38)
rnn = nn.RNN(input_size=2, hidden_size=3, batch_first=True)
print('RNN parameters:', sum(p.numel() for p in rnn.parameters()))
with torch.no_grad():
    outputs, _ = rnn(vectors)                       # (B, L, H): trạng thái sau từng cột
    lengths = valid_mask.sum(dim=1)
    last_column = outputs[:, -1]                    # cột cuối, có thể nằm sau PAD
    last_valid = outputs[torch.arange(len(ids)), lengths - 1]
    packed = pack_padded_sequence(vectors, lengths, batch_first=True, enforce_sorted=False)
    _, h_packed = rnn(packed)                       # (1, B, H): dừng ở token thật cuối
    swapped = rnn(embedding(pair))[0][:, -1]
print('outputs shape:', tuple(outputs.shape))
print('last column is last token:', torch.isclose(last_column, last_valid).all(dim=1).tolist())
print('gather matches packed:', torch.allclose(last_valid, h_packed[0]))
print('RNN same after swapping:', torch.allclose(swapped[0], swapped[1]))

Kết quảRNN parameters: 21
outputs shape: (3, 3, 3)
last column is last token: [False, False, True]
gather matches packed: True
RNN same after swapping: False

Dòng [False, False, True] cho thấy chỉ câu thứ ba, câu không có PAD, có cột cuối đúng là token thật cuối. Hai câu kia nếu đọc cột cuối sẽ nhận trạng thái đã đi qua một hoặc hai PAD; model vẫn train được, nhưng biểu diễn phụ thuộc lượng PAD, đúng lỗi mà masked mean đã tránh. Lấy theo lengths-1 khớp với bản packed. Dòng cuối xác nhận RNN phân biệt “đồ_thị dp” với “dp đồ_thị”, điều mean pooling không làm được.

Chuỗi dài: gradient tắt dần và LSTM

RNN nhìn được cả chuỗi về lý thuyết, nhưng có học được quan hệ xa hay không là chuyện gradient. Trải theo $L$ bước, RNN là một mạng sâu $L$ lớp dùng chung $W_{hh}$, nên gặp đúng hiện tượng gradient tắt dần của bài 3.3, chỉ là theo chiều thời gian.

Đạo hàm của trạng thái cuối $\mathbf h_L$ theo token thứ $t$ đi qua $L-t$ bước, mỗi bước nhân một ma trận Jacobian gồm $W_{hh}$ và đạo hàm tanh (không quá 1). Với số vô hướng $h_t=w\,h_{t-1}+x_t$, ta có $\partial h_L/\partial x_t=w^{L-t}$: $|w|<1$ thì tắt theo cấp số nhân (vanishing gradient), $|w|>1$ thì bùng nổ (exploding gradient). Đo trên RNN của mục trước với một chuỗi ngẫu nhiên dài 40:

torch.manual_seed(0)
long_x = torch.randn(1, 40, 2, requires_grad=True)
_, h_end = rnn(long_x)
h_end.sum().backward()
grad_norm = long_x.grad[0].norm(dim=1)              # độ lớn gradient theo từng token
for t in [40, 30, 20, 10, 1]:
    print(f'token {t:2d}: {grad_norm[t - 1].item():.1e}')

Kết quảtoken 40: 4.5e-01
token 30: 1.3e-03
token 20: 8.4e-06
token 10: 1.9e-08
token  1: 1.9e-10

Token cuối nhận gradient cỡ $0.45$, token thứ 30 còn $1.3\cdot10^{-3}$, token đầu chỉ $1.9\cdot10^{-10}$: cứ mười bước, gradient giảm hai đến ba bậc. Nếu nhãn phụ thuộc vài token ở đầu một chuỗi dài, tín hiệu sửa trọng số theo các token ấy gần như bằng 0. Đây là lý do chính khiến RNN “quên” đầu chuỗi: trạng thái có thể đủ chỗ chứa điều cần nhớ, nhưng gradient quá nhỏ để dạy model giữ lại nó. Tăng hidden size không bỏ được phép nhân lặp.

Chiều ngược lại, gradient bùng nổ, được chặn bằng gradient clipping (bài 3.7 dùng nó cùng GradScaler). Clip theo chuẩn giữ hướng: gradient $(3, 4)$ có chuẩn 5, max_norm=1 cho $(0.6, 0.8)$; clip theo giá trị về $[-1, 1]$ cho $(1, 1)$, đổi cả hướng.

Với văn bản rất dài, như cả một cuốn sách, lan truyền ngược qua toàn bộ chuỗi vừa tốn bộ nhớ vừa chẳng mang lại gì ở các bước xa. Truncated BPTT cắt chuỗi thành từng đoạn $L$ token. Với mỗi đoạn: chạy RNN qua $L$ token, tính loss ở từng bước, lan truyền ngược trong đoạn, clip gradient, cập nhật tham số. Trạng thái cuối $\mathbf h_L$ được giữ làm trạng thái đầu cho đoạn sau nhưng phải detach(), để lần backward sau dừng ở ranh giới đoạn. Thông tin vẫn đi tiếp qua trạng thái, còn gradient chỉ đi ngược tối đa $L$ bước.

LSTM (long short-term memory) sửa ngay trên đường đi của gradient. Ngoài $\mathbf h_t$, LSTM giữ một cell state cập nhật bằng phép cộng có cổng:

với forget gate $\mathbf f_t$ và input gate $\mathbf i_t$ nằm trong $(0,1)$, do mạng tự học từ $\mathbf x_t$ và $\mathbf h_{t-1}$; $\tilde{\mathbf c}_t$ là nội dung mới đề xuất. Đường trực tiếp từ $\mathbf c_{t-1}$ tới $\mathbf c_t$ chỉ nhân với $\mathbf f_t$: khi cổng quên gần 1, gradient đi qua nhiều bước mà không bị nhân nhỏ dần, cùng ý với kết nối residual ở bài 3.9. GRU là biến thể gọn hơn cùng ý tưởng.

LSTM có bốn khối (ba cổng và nội dung mới), mỗi khối $H(d + H)$ trọng số và hai bias $H$: nn.LSTM(64, 128) có $4 \cdot 128 \cdot 192 + 8 \cdot 128 = 99\,328$ tham số. Trong PyTorch, nn.LSTM gọi giống hệt nn.RNN, kể cả với pack_padded_sequence; chỉ khác là trạng thái cuối trả về dạng cặp (h_n, c_n).

Cổng giúp nhớ xa hơn nhưng vẫn đi tuần tự từng bước; attention ở bài 3.9 nối thẳng mọi cặp vị trí.