Encoder-decoder

Nguồn là điều kiện, đích được viết từng bước

Encoder đọc toàn bộ nguồn $x$ thành bộ nhớ $H^x$. Decoder sinh chuỗi đích $y_1,\ldots,y_T$ theo

Encoder của bài dịch được nhìn cả câu nguồn vì câu đó đã có khi bắt đầu. Decoder chỉ được nhìn tiền tố đích đã có; để nó nhìn token đích tương lai khi train là lộ đáp án. Trong transformer encoder-decoder, decoder có causal self-attention trên đích và cross-attention sang các token nguồn. Query của cross-attention đến từ decoder; key và value đến từ encoder.

Nguồn có thể là token văn bản hoặc các vector patch do một image encoder tạo ra; decoder làm việc như nhau với cả hai.

Dịch máy, tóm tắt, viết caption cho ảnh đều là bài chuyển chuỗi (sequence-to-sequence). Dịch từng từ một không được: “red car” thành “đỏ xe” sai trật tự, nên model phải đọc cả câu nguồn; dữ liệu để học là kho song ngữ gồm các cặp câu nguồn-đích. Caption kinh điển ghép một image encoder (CNN) với một decoder sinh câu.

T5 đi xa hơn, đưa mọi nhiệm vụ về dạng văn bản vào, văn bản ra, kể cả phân loại cảm xúc: model sinh ra chữ “positive” hay “negative”.

Nếu nguồn có $L_x$ token, đích có $L_y$ token và hidden size $d$, hidden states của encoder và decoder có shape (B, Lx, d) và (B, Ly, d). Transformer encoder-decoder dùng attention ở ba chỗ, mỗi chỗ một mask riêng:

• Self-attention của encoder: query và key đều là nguồn; mask các vị trí PAD của nguồn.
• Self-attention của decoder: query và key đều là đích; causal mask, thêm mask PAD của đích khi batch có câu ngắn.
• Cross-attention: query từ đích, key và value từ nguồn; ma trận điểm của một head có shape (Ly, Lx), và PAD của nguồn lại phải bị mask.

Bài 3.9 đã tách padding mask khỏi causal mask. Điểm mới ở đây là mask PAD của nguồn phải đi theo memory sang cross-attention, còn cross-attention không cần causal mask: toàn bộ nguồn đã có từ đầu.

Teacher forcing: đáp án chỉ được đưa từ bước trước

Trong train, ta đã có chuỗi đích đúng. Teacher forcing đưa token đích đúng ở bước trước vào decoder thay vì token model vừa đoán. Với target B A EOS, decoder input là BOS B A; label là B A EOS. Không đưa B A EOS vào input cùng vị trí label rồi bắt model “đoán” lại. Dịch một vị trí kết hợp causal mask giữ bài toán đúng. Thư viện như Hugging Face tự làm bước dịch này khi nhận labels, nên chỉ đưa label kết thúc bằng EOS; label đã có sẵn token mở đầu sẽ bị dịch hai lần.

Teacher forcing giúp train hiệu quả vì mọi input đích đã biết, nên transformer có thể xử lý song song các vị trí. Lúc inference, không có token đúng để đưa vào; model phải ăn lại token nó vừa sinh. Một lỗi đầu có thể làm tiền tố sau khác train, rồi lỗi lan tiếp. Sự khác biệt phân phối này thường gọi là exposure bias. Vì thế validation cần chấm cả lúc model tự sinh (free-running), không chỉ loss với teacher forcing.

Một bài chuyển chuỗi nhỏ để nhìn tensor

Ta chọn nhiệm vụ đảo chuỗi hai ký hiệu lấy từ A, B, C. Nó không phải dịch máy hoặc tóm tắt; thứ tự đúng xác định được bằng phép đảo, nên ta kiểm độc lập được model. Có 9 cặp có thể có. Ta dùng 7 cặp train, giữ C B và C C để thử tổ hợp chưa thấy. Vocabulary gồm ba ký hiệu và ba token đặc biệt PAD, BOS, EOS.

Thí nghiệm dùng GRU encoder-decoder train từ đầu. Encoder là RNN như ở bài 3.8: hidden state cuối tóm tắt cả nguồn, đúng trạng thái mà 3.8 đọc tại lengths - 1 để phân loại câu. Ở đây trạng thái ấy không đi vào head phân loại mà trở thành trạng thái đầu của decoder. Model chưa có attention; phép tính cross-attention được làm riêng ở mục sau.

import itertools
import torch
from torch import nn

torch.manual_seed(65)
torch.set_num_threads(1)
PAD, BOS, EOS = 0, 1, 2
symbol_to_id = {"A": 3, "B": 4, "C": 5}
id_to_symbol = {value: key for key, value in symbol_to_id.items()}
pairs = list(itertools.product("ABC", repeat=2))
train_pairs = pairs[:7]
valid_pairs = pairs[7:]

def make_seq2seq_batch(pairs):
    sources = []
    decoder_inputs = []
    labels = []
    for pair in pairs:
        source = [symbol_to_id[symbol] for symbol in pair]
        target = list(reversed(source))
        sources.append(source)
        decoder_inputs.append([BOS] + target)
        labels.append(target + [EOS])
    return (torch.tensor(sources), torch.tensor(decoder_inputs), torch.tensor(labels))

source_ids, decoder_ids, target_ids = make_seq2seq_batch(train_pairs)
print("nguồn/input đích/label:", tuple(source_ids.shape), tuple(decoder_ids.shape), tuple(target_ids.shape))
print("cặp A B:", source_ids[1].tolist(), decoder_ids[1].tolist(), target_ids[1].tolist())

Kết quảnguồn/input đích/label: (7, 2) (7, 3) (7, 3)
cặp A B: [3, 4] [1, 4, 3] [4, 3, 2]

Ở cặp A B, nguồn [3,4], decoder input [1,4,3], target [4,3,2]. Vị trí đầu dự đoán B từ BOS và nguồn, vị trí thứ hai dự đoán A từ B và nguồn. Vị trí thứ ba học dừng bằng EOS. Với chuỗi thật dài ngắn khác nhau, cần thêm padding, loss mask, và trạng thái encoder phải lấy tại token thật cuối (hoặc qua pack_padded_sequence) như bài 3.8; dữ liệu cố định dài hai ký hiệu giúp tách lỗi shift khỏi lỗi padding.

Ta viết model thành các khối có trách nhiệm rõ: embedding, encoder, decoder và projection về vocabulary. Hidden state GRU có shape (layers, B, hidden_size), ở đây layers bằng 1. batch_first=True làm chuỗi input có batch ở trục đầu.

class SmallSeq2Seq(nn.Module):
    def __init__(self):
        super().__init__()
        self.embedding = nn.Embedding(6, 12, padding_idx=PAD)
        self.encoder = nn.GRU(12, 24, batch_first=True)
        self.decoder = nn.GRU(12, 24, batch_first=True)
        self.output_layer = nn.Linear(24, 6)

    def forward(self, source, decoder_input):
        _, source_state = self.encoder(self.embedding(source))
        decoded, _ = self.decoder(self.embedding(decoder_input), source_state)
        return self.output_layer(decoded)

model = SmallSeq2Seq()
logits = model(source_ids, decoder_ids)
print("logits:", tuple(logits.shape))

Kết quảlogits: (7, 3, 6)

Logits có shape (7, 3, 6): 7 mẫu, 3 bước đích, 6 token có thể chọn. Loss flatten hai chiều đầu thành một danh sách vị trí, nhưng giữ chiều lớp là 6. Target dùng số nguyên ID; không biến target thành one-hot để gọi loss này.

optimizer = torch.optim.Adam(model.parameters(), lr=0.02)
loss_function = nn.CrossEntropyLoss(ignore_index=PAD)
loss_history = []
model.train()
for step in range(220):
    optimizer.zero_grad()
    logits = model(source_ids, decoder_ids)
    loss = loss_function(logits.reshape(-1, 6), target_ids.reshape(-1))
    loss.backward()
    optimizer.step()
    loss_history.append(loss.item())

valid_source, valid_input, valid_target = make_seq2seq_batch(valid_pairs)
model.eval()
with torch.no_grad():
    valid_logits = model(valid_source, valid_input)
    valid_loss = loss_function(valid_logits.reshape(-1, 6), valid_target.reshape(-1))
print("train loss đầu/cuối:", round(loss_history[0], 4), round(loss_history[-1], 4))
print("validation teacher-forced loss:", round(valid_loss.item(), 4))

Kết quảtrain loss đầu/cuối: 1.8026 0.0003
validation teacher-forced loss: 1.2613

Train loss 0.0003 cho biết model khớp 7 cặp đã học dưới teacher forcing. Validation loss 1.2613 cao gấp hàng nghìn lần: hai tổ hợp chưa thấy là chỗ model còn yếu. Loss này vẫn đo với token đích đúng ở bước trước, nên chưa cho biết chuỗi tự sinh sẽ ra sao.

Free-running: tự ăn lại token vừa sinh

Vòng suy luận dưới đây encode nguồn một lần, bắt đầu bằng BOS, lấy argmax rồi đưa token đó vào bước tiếp. Nó dừng ở EOS hoặc tối đa 4 bước. PAD và BOS không được chọn làm output bằng cách đặt logits của chúng thành $-\infty$; trong nhiệm vụ thật, chỉ cấm token khi đề đã xác định chúng không hợp lệ.

def generate_reverse(pair, max_steps=4):
    source = torch.tensor([[symbol_to_id[symbol] for symbol in pair]])
    generated = []
    with torch.no_grad():
        _, state = model.encoder(model.embedding(source))
        current = torch.tensor([[BOS]])
        for _ in range(max_steps):
            decoded, state = model.decoder(model.embedding(current), state)
            next_logits = model.output_layer(decoded[:, -1]).clone()
            next_logits[:, [PAD, BOS]] = -torch.inf
            token = int(next_logits.argmax(dim=-1).item())
            if token == EOS:
                break
            generated.append(id_to_symbol[token])
            current = torch.tensor([[token]])
    return tuple(generated)

for split_name, split_pairs in [("train", train_pairs), ("validation", valid_pairs)]:
    correct = 0
    for pair in split_pairs:
        prediction = generate_reverse(pair)
        gold = tuple(reversed(pair))
        correct += prediction == gold
        if split_name == "validation":
            print("nguồn:", pair, "đích thật:", gold, "tự sinh:", prediction)
    print(split_name, "exact match:", f"{correct}/{len(split_pairs)}")

Kết quảtrain exact match: 7/7
nguồn: ('C', 'B') đích thật: ('B', 'C') tự sinh: ('B', 'C')
nguồn: ('C', 'C') đích thật: ('C', 'C') tự sinh: ('C', 'A')
validation exact match: 1/2

Train khớp 7/7, validation chỉ khớp 1/2: nguồn C C phải cho C C, nhưng model cho C A. Train loss 0.0003 chưa chứng minh model đã học quy tắc đảo.

Exact match đòi cả chuỗi trùng gold, nên đúng token đầu mà sai token sau, hoặc dư một token, đều tính sai. Đảo chuỗi có thuật toán chính xác làm oracle, nên mọi lỗi của model đều kiểm được; đó là lý do chọn nhiệm vụ nhỏ này.

Lỗi nằm ở token nào? Code dưới tách validation loss thành NLL từng vị trí, rồi xem phân phối của model ở bước thứ hai của C C khi được cho tiền tố đúng BOS C.

with torch.no_grad():
    token_nll = nn.functional.cross_entropy(
        valid_logits.reshape(-1, 6), valid_target.reshape(-1), reduction="none"
    ).reshape(2, 3)
    step2_probs = valid_logits[1, 1].softmax(dim=-1)  # cặp C C, vị trí 2, input BOS C
print("NLL từng vị trí:", [[round(x, 3) for x in row] for row in token_nll.tolist()])
print("C C, bước 2 sau BOS C:", {s: round(step2_probs[i].item(), 3) for s, i in symbol_to_id.items()})

Kết quảNLL từng vị trí: [[0.027, 0.729, 0.003], [0.002, 6.804, 0.003]]
C C, bước 2 sau BOS C: {'A': 0.994, 'B': 0.0, 'C': 0.001}

Trung bình sáu số NLL đúng bằng 1.2613; riêng vị trí thứ hai của C C là 6.804, gần 90% tổng. Ở C B, vị trí đó có NLL 0.729, tức xác suất token đúng chỉ khoảng 0.48: model phân vân, và free-running chọn đúng vì C nhỉnh hơn A. Với C C, dù được cho tiền tố đúng, model vẫn đặt 0.994 vào A. Token đầu đã đúng nên tiền tố tự sinh trùng tiền tố teacher forcing; lỗi ở đây không do lệch tiền tố mà do model chưa học được quy tắc cho tổ hợp này, và sai một cách tự tin.

Lỗi do lệch tiền tố vẫn có thật ở bài khác: train luôn được cho tiền tố đúng, còn lúc sinh model ăn lại token của chính nó, nên một lỗi nhỏ đầu câu đưa model vào những tiền tố chưa từng gặp và lỗi chồng lỗi (exposure bias).

Giải mã: beam search, độ dài và token lặp

Bài 6.4 đã giảng beam search: thay vì một tiền tố như greedy, giữ $k$ tiền tố có tổng log-prob lớn nhất; tiền tố gặp EOS được cất riêng. Ở seq2seq, thuật toán giữ nguyên, chỉ thêm điều kiện là nguồn: encoder chạy một lần, mỗi tiền tố mang theo trạng thái decoder của riêng nó. Code dưới chạy beam rộng 3 trên model GRU vừa train để xem beam làm được gì và không làm được gì.

def beam_search(pair, beam_size=3, max_steps=4):
    source = torch.tensor([[symbol_to_id[symbol] for symbol in pair]])
    finished = []
    with torch.no_grad():
        _, state = model.encoder(model.embedding(source))
        beams = [((), 0.0, state, BOS)]  # (đã sinh, tổng log-prob, trạng thái, token cuối)
        for _ in range(max_steps):
            candidates = []
            for tokens, score, state, last in beams:
                decoded, new_state = model.decoder(model.embedding(torch.tensor([[last]])), state)
                log_probs = torch.log_softmax(model.output_layer(decoded[:, -1]), dim=-1)[0]
                for token in [EOS, *symbol_to_id.values()]:
                    candidates.append((tokens, score + log_probs[token].item(), new_state, token))
            candidates.sort(key=lambda item: item[1], reverse=True)
            beams = []
            for tokens, score, state, token in candidates[:beam_size]:
                if token == EOS:
                    finished.append((" ".join(tokens), round(score, 3)))
                else:
                    beams.append((tokens + (id_to_symbol[token],), score, state, token))
            if not beams:
                break
    return sorted(finished, key=lambda item: item[1], reverse=True)

for pair in valid_pairs:
    print(" ".join(pair), "->", beam_search(pair)[:3])

Kết quảC B -> [('B C', -0.759), ('B A', -1.153), ('B B', -2.047)]
C C -> [('C A', -0.009), ('C', -5.279), ('A C', -6.142)]

Với C B, chuỗi đứng đầu là B C, log-prob $-0.759$ (xác suất khoảng 0.47), trùng greedy; B A theo sát ở $-1.153$. Với C C, beam trả về C A với $-0.009$, tức model tin chuỗi này tới 0.991. Beam search tìm chuỗi tốt nhất theo model; khi model sai một cách tự tin, mở rộng beam chỉ tìm ra đúng lỗi đó. Muốn sửa C C phải sửa model hoặc dữ liệu, không phải bộ giải mã.

Dòng C C còn có một ứng viên dừng sớm: chuỗi C, điểm $-5.279$, đứng thứ hai. Nó đứng trên A C vì token đầu A gần như không được chọn, chưa phải vì ngắn; nhưng tổng log-prob vẫn mang thiên lệch độ dài mà bài 6.4 đã nhắc. Mỗi token thêm vào cộng một số hạng $\log p\le 0$, nên chuỗi càng dài tổng càng thấp; beam rộng dễ chọn câu ngắn hơn câu đúng, và BLEU (mục cuối bài) sẽ phạt độ ngắn ấy.

Vì vậy tăng độ rộng beam từ 5 lên 100 thường làm câu dịch ngắn đi và BLEU giảm: beam rộng tìm ra đúng những chuỗi ngắn mà model chấm cao. Cách thường dùng là chuẩn hóa theo độ dài:

Với $\alpha=0$ là tổng thô, $\alpha=1$ là log-prob trung bình mỗi token. Trong Hugging Face, tham số này là length_penalty (mặc định 1.0), áp lên các chuỗi đã xong của beam search.

Model tóm tắt còn hay lặp một cụm: khi cụm đó đã có trong tiền tố, chính tiền tố lại làm cụm ấy có xác suất cao lần nữa. Hai cách chặn:

• no_repeat_ngram_size=n cấm mọi n-gram xuất hiện lần thứ hai trong output, bằng cách đặt logit của token sẽ tạo n-gram lặp thành $-\infty$, giống cách code free-running cấm PAD và BOS. Đặt no_repeat_ngram_size=3 là cấm mọi bộ ba token xuất hiện lần thứ hai.
• repetition_penalty mềm hơn: nó chỉ giảm logit của các token đã xuất hiện, chia logit dương và nhân logit âm cho hệ số; với 1.2, logit 2.4 thành 2.0 còn $-1.2$ thành $-1.44$.

Cả hai đổi phân phối của model để lấy output gọn hơn, nên chúng, cùng beam size và max_new_tokens, được chọn bằng metric trên validation như mọi hyperparameter khác.

Cross-attention: decoder đọc lại nguồn

GRU ở trên gửi sang decoder đúng một vector 24 số, dù nguồn dài bao nhiêu. Bài 3.8 đã đo gradient của RNN thường từ token cuối về token đầu một chuỗi 40 chỉ còn $1.9\cdot10^{-10}$; GRU và LSTM làm dịu hiện tượng đó, nhưng nút thắt một vector vẫn còn khi nguồn dài. Attention cho decoder đọc lại mọi vị trí nguồn ở từng bước sinh.

Để thấy phép toán, cho query đích $\mathbf{q}=(1,0)$, hai key nguồn $(1,0)$ và $(0,1)$, value tương ứng $(2,0)$ và $(0,2)$. Điểm sau chia $\sqrt{d_k}=\sqrt2$ là $(0.707,0)$; softmax xấp xỉ $(0.670,0.330)$. Vector đọc được là $(1.340,0.660)$, một tổ hợp có trọng số của hai values.

import numpy as np

query = np.array([[1.0, 0.0]])
keys = np.array([[1.0, 0.0], [0.0, 1.0]])
values = np.array([[2.0, 0.0], [0.0, 2.0]])
scores = query @ keys.T / np.sqrt(keys.shape[1])
weights = np.exp(scores - scores.max(axis=-1, keepdims=True))
weights /= weights.sum(axis=-1, keepdims=True)
context = weights @ values
print("attention:", weights.round(3))
print("context:", context.round(3))

Kết quảattention: [[0.67 0.33]]
context: [[1.34 0.66]]

Query gần key thứ nhất hơn nên value thứ nhất nhận trọng số 0.67. Một token đích khác có query khác, nên đọc cùng memory nguồn với một hàng trọng số khác. Trọng số attention cho biết decoder đọc từ đâu, nhưng chưa đủ giải thích vì sao model chọn một token: sau attention còn residual, FFN và projection.

Dịch, tóm tắt và caption cần cách đọc kết quả khác nhau

Dịch có nhiều câu đích cùng đúng, nên exact match quá khắt khe. BLEU so n-gram của bản dịch với bản tham chiếu:

1. Tính precision n-gram có clipping: một n-gram chỉ được tính khớp tối đa bằng số lần nó có trong tham chiếu.
2. Lấy trung bình nhân theo $n$.
3. Nhân brevity penalty $\mathrm{BP}=\min(1,\ e^{1-r/c})$, với $c$ là độ dài bản dịch và $r$ là độ dài tham chiếu, để phạt bản dịch quá ngắn.

BLEU chuẩn dùng tới 4-gram và cộng số đếm trên cả corpus; code dưới tính tới bigram trên một câu để đọc được từng thành phần.

from collections import Counter
import math

def ngram_counts(tokens, n):
    return Counter(tuple(tokens[i:i + n]) for i in range(len(tokens) - n + 1))

def bleu2(candidate, reference):
    precisions = []
    for n in (1, 2):
        counts, ref_counts = ngram_counts(candidate, n), ngram_counts(reference, n)
        clipped = sum(min(count, ref_counts[gram]) for gram, count in counts.items())
        precisions.append(clipped / sum(counts.values()))
    brevity = min(1.0, math.exp(1 - len(reference) / len(candidate)))
    return precisions, brevity, brevity * math.sqrt(precisions[0] * precisions[1])

reference = "câu lạc bộ họp vào thứ sáu".split()
for candidate in ["họp họp họp họp", "câu lạc bộ họp thứ sáu", "câu lạc bộ họp vào thứ bảy"]:
    (p1, p2), bp, score = bleu2(candidate.split(), reference)
    print(f"{candidate:27} p1={p1:.3f} p2={p2:.3f} BP={bp:.3f} BLEU-2={score:.3f}")

Kết quảhọp họp họp họp             p1=0.250 p2=0.000 BP=0.472 BLEU-2=0.000
câu lạc bộ họp thứ sáu      p1=1.000 p2=0.800 BP=0.846 BLEU-2=0.757
câu lạc bộ họp vào thứ bảy  p1=0.857 p2=0.833 BP=1.000 BLEU-2=0.845

Câu lặp họp bốn lần chỉ được tính khớp một lần ($p_1=0.25$) và không có bigram nào khớp, nên điểm bằng 0: clipping chặn mẹo lặp từ. Câu thứ hai đúng nội dung nhưng thiếu “vào”, ngắn hơn tham chiếu nên BP bằng 0.846, điểm 0.757. Câu thứ ba đổi thứ sáu thành thứ bảy, sai đúng thông tin quan trọng nhất, vẫn được 0.845, cao hơn câu đúng. Đếm n-gram trùng không kiểm được sự thật.

BLEU còn phụ thuộc tokenizer (ở đây tách theo âm tiết) và cách tổng hợp trên corpus; khi thi, dùng đúng metric và cách tính đề cho, không thay bằng một metric thuận lợi hơn rồi so với điểm chính thức.

Tóm tắt thường chấm bằng ROUGE. ROUGE-N trong định nghĩa gốc là recall n-gram: bao nhiêu n-gram của tham chiếu xuất hiện trong bản tóm tắt; ROUGE-L dựa trên subsequence chung dài nhất. Recall không phạt bản tóm tắt dài dòng, nên đề thường giới hạn độ dài hoặc báo F1. Tham chiếu “mèo ngủ trên ghế” và tóm tắt “mèo ngủ” có ROUGE-1 recall $2/4 = 0.5$, precision $2/2 = 1$.

Khác biệt cốt lõi: ROUGE thiên về recall, BLEU thiên về precision kèm phạt độ ngắn. Tóm tắt bằng cách chọn nguyên văn vài câu quan trọng từ bài gốc là tóm tắt trích xuất (extractive); viết lại bằng câu mới là tóm tắt tóm lược (abstractive).

Tóm tắt còn cần kiểm người, ngày, số lượng và quan hệ trong nguồn. Câu ngắn nghe hợp lý nhưng đổi “chưa tổ chức” thành “đã tổ chức” là lỗi lớn dù trùng nhiều token. Caption phải đúng đối tượng và hành động trong ảnh; model có thể sinh chi tiết phổ biến nhưng không có trong ảnh.

Một tập nhỏ có thể chấm bằng bảng lỗi: thiếu thông tin, thừa chi tiết, đảo quan hệ, sai phủ định và lặp câu. Khi một tài liệu có nhiều bản tham chiếu hoặc bị cắt thành nhiều đoạn, chia train và validation theo tài liệu để nguồn không rò sang validation. Với văn bản sáng tác như thơ, có rất nhiều đáp án tốt và không có tham chiếu duy nhất, nên metric tự động chỉ là gợi ý; vẫn cần người đọc.

Script text-to-text chạy một encoder-decoder pretrained, FLAN-T5 small, có sẵn trên máy cho một yêu cầu như tóm tắt. Theo hướng dẫn của chương, script kiểm tên model, revision và SHA-256 từng tệp trước khi nạp, và không tải gì từ Internet.

Prompt được tokenize với giới hạn 256 token; dài hơn thì script dừng, vì nó không tự chia đoạn. model.generate giải mã greedy (do_sample=False) với --max-new-tokens (mặc định 48), rồi in JSON gồm output, thời gian sinh, số token output và, trên CUDA, đỉnh bộ nhớ. Muốn thử beam search, length_penalty hay no_repeat_ngram_size, thêm chúng vào lời gọi generate và so trên cùng tập validation. Caption cần thêm image encoder và bộ xử lý ảnh; đường dẫn ảnh không đi qua tokenizer chữ.