Language model

Mỗi bước chọn từ một phân phối

Với chuỗi token $t_1,\ldots,t_L$, quy tắc nhân xác suất cho

Ta thêm BOS (bắt đầu) và EOS (kết thúc) để model biết khi nào bắt đầu hoặc dừng. BOS thường là điều kiện đầu vào, EOS là một token cần dự đoán. Nếu không có EOS hoặc giới hạn số token, vòng sinh có thể không dừng.

Token ở đây theo tokenizer đã chọn, có thể là âm tiết, subword hoặc byte; “next word” chỉ là cách nói gần gũi, tên nhiệm vụ chính xác là next-token prediction. Đoán token tiếp theo, nối vào, rồi đoán tiếp là cách mọi model kiểu GPT sinh văn bản; gợi ý từ tiếp theo trên bàn phím điện thoại là phiên bản nhỏ của cùng ý.

Bigram chỉ nhìn một token trước: $p(t_i\mid t_{i-1})$; trigram nhìn hai token trước. N-gram dùng cửa sổ cố định nên dễ đếm và kiểm, nhưng không theo dõi được ngữ cảnh dài.

Bảng của nó còn phình rất nhanh: với vocabulary $V$, n-gram có $|V|^{n-1}$ ngữ cảnh, mỗi ngữ cảnh một phân phối trên $|V|$ token. Với $|V|=10\,000$, trigram đã có $10^8$ ngữ cảnh, mỗi ngữ cảnh cần $10^4$ xác suất; một corpus vài triệu token chỉ gặp được một phần nhỏ trong số đó, nên phần lớn ô của bảng không bao giờ được đếm.

Causal transformer dùng self-attention trên tiền tố: tại vị trí $i$, nó không được đọc token tương lai dùng làm nhãn. BERT ở bài 6.3 nhìn hai chiều cho MLM; nó không phải causal language model chỉ cần gọi vòng sinh là thành GPT.

Học một bigram trên corpus tự soạn

Ta dùng năm câu train. Từ vựng đích gồm bảy token chữ, EOS và UNK; BOS không nằm trong danh sách token được sinh. Vocabulary chỉ được rút từ train. Với token lạ ở evaluation, ta chuyển sang UNK, không âm thầm thêm cột mới.

from collections import Counter, defaultdict
import numpy as np

train_sentences = ["em học toán", "em học tin", "em đọc sách", "bạn học toán", "bạn đọc sách"]
BOS, EOS, UNK = "<bos>", "<eos>", "<unk>"
target_vocab = sorted({token for text in train_sentences for token in text.split()} | {EOS, UNK})
bigram_counts = defaultdict(Counter)
for text in train_sentences:
    tokens = [BOS] + text.split() + [EOS]
    for previous, following in zip(tokens, tokens[1:]):
        bigram_counts[previous][following] += 1

print("vocabulary size:", len(target_vocab))
print("sau 'em':", dict(bigram_counts["em"]))

Kết quảvocabulary size: 9
sau 'em': {'học': 2, 'đọc': 1}

Sau “em”, “học” xuất hiện hai lần và “đọc” một lần. Ước lượng không làm trơn cho $p(\text{học}\mid\text{em})=2/3$. Tương tự, “con” xuất hiện 200 lần và “con mèo” 30 lần cho $p(\text{mèo}\mid\text{con}) = 0.15$. Nhưng một cặp chưa thấy có xác suất 0, và chỉ một thừa số 0 cũng khiến cả tích chuỗi bằng 0. Ta dùng add-$\alpha$ smoothing, ở đây $\alpha=1$:

Mỗi token trong vocabulary được cộng cùng một số đếm giả $\alpha$, rồi chia cho tổng mới nên phân phối vẫn cộng thành 1.

alpha = 1.0

def next_distribution(previous):
    counts = bigram_counts.get(previous, Counter())
    denominator = sum(counts.values()) + alpha * len(target_vocab)
    return np.array([(counts[token] + alpha) / denominator for token in target_vocab])

em_distribution = next_distribution("em")
print("p(học|em):", round(em_distribution[target_vocab.index("học")], 3))
print("tổng xác suất:", round(em_distribution.sum(), 6))

Kết quảp(học|em): 0.25
tổng xác suất: 1.0

Đối chiếu bằng tay: tử số là $2+1=3$, mẫu số $3+9=12$, nên xác suất giảm từ $2/3$ xuống 0.25. Add-$\alpha$ cho mỗi ngữ cảnh cùng một tổng số đếm giả $\alpha|V|$. Ngữ cảnh càng ít gặp và vocabulary càng lớn thì phần giả này càng lấn át số đếm thật, và phần lớn xác suất bị chia cho những token chưa từng đi sau ngữ cảnh đó.

Vì vậy với corpus thật, nếu dùng add-$\alpha$ thì thường chọn $\alpha<1$ (chẳng hạn 0.5, 0.05 hay 0.01); dù vậy add-$\alpha$ vẫn kém cho language model, nên thực tế người ta dùng interpolation với n-gram ngắn hơn hoặc Kneser-Ney (xem Đọc thêm). $\alpha$ là hyperparameter phải chọn trên validation, không nhìn test rồi chọn số làm test đẹp nhất.

Label dịch một vị trí, loss và perplexity

Trong huấn luyện next-token prediction, input và label lệch một vị trí. Với chuỗi [BOS, em, học, toán, EOS], input là [BOS, em, học, toán], label là [em, học, toán, EOS]. Token PAD trong label được bỏ khỏi loss. Khi dùng causal mask, các vị trí input được xử lý đồng thời trong train mà vẫn không đọc tương lai. Khi suy luận, ta chưa biết label thật nên phải dùng token vừa sinh làm input cho bước kế tiếp.

Average negative log-likelihood trên $N$ token đích hợp lệ là

Ta dùng log tự nhiên nên perplexity là exp(loss). Nếu dùng log cơ số 2 thì là $2^{\mathcal{H}}$. Perplexity có thể hiểu như số lựa chọn mà model đang phân vân: model cho xác suất đúng bằng $1/4$ ở mọi bước có PPL bằng 4. Nó không phải số token sai hay số từ trong câu.

Cross-entropy 3 bit mỗi token cho PPL $2^3 = 8$; model chia đều xác suất cho 50 000 token có PPL đúng 50 000. Ngay cả model hoàn hảo cũng không xuống dưới entropy của chính phân phối dữ liệu, nên PPL có một sàn lớn hơn 1.

def sentence_nll(text):
    words = [word if word in target_vocab else UNK for word in text.split()]
    tokens = [BOS] + words + [EOS]
    log_probabilities = []
    for previous, following in zip(tokens, tokens[1:]):
        probability = next_distribution(previous)[target_vocab.index(following)]
        log_probabilities.append(np.log(probability))
    return -np.mean(log_probabilities), len(log_probabilities)

for text in ["em học toán", "em sách học", "robot học toán"]:
    nll, count = sentence_nll(text)
    print(text, "N=", count, "NLL=", round(nll, 3), "PPL=", round(np.exp(nll), 3))
print("PPL xác suất 1/4:", round(np.exp(-np.log(0.25)), 3))

Kết quảem học toán N= 4 NLL= 1.331 PPL= 3.785
em sách học N= 4 NLL= 2.155 PPL= 8.629
robot học toán N= 4 NLL= 1.88 PPL= 6.557
PPL xác suất 1/4: 4.0

Số đếm $N$ có cả EOS. So “em học toán” với “em sách học”: model đếm thích trật tự nó đã thấy hơn. Query có “robot” bị chuyển UNK, nên kết quả cũng phụ thuộc quy tắc xử lý từ lạ. Các câu trên là probe do ta đặt; câu đầu còn có trong train. Muốn báo chất lượng language model, cần một corpus đánh giá độc lập, tách theo tài liệu hoặc thời gian.

Causal neural language model tính cùng đại lượng theo cách khác: nó nhận cả chuỗi input một lần, trả một hàng logits cho mỗi vị trí, rồi so hàng thứ $i$ với label thứ $i$ bằng cross-entropy. Bigram cũng viết được như vậy, vì hàng ở vị trí $i$ chỉ phụ thuộc token $i$. Ta dùng log-xác suất làm logits: các xác suất đã cộng thành 1 nên softmax trả lại đúng phân phối cũ.

import torch
import torch.nn.functional as F

def bigram_logits(tokens):
    # Hàng i chỉ đọc tokens[i]: một causal language model có ngữ cảnh dài 1.
    rows = [np.log(next_distribution(token)) for token in tokens]
    return torch.tensor(np.array(rows), dtype=torch.float32)

sequence = [BOS, "em", "học", "toán", EOS]
inputs, labels = sequence[:-1], sequence[1:]
logits = bigram_logits(inputs)
label_ids = torch.tensor([target_vocab.index(token) for token in labels])
print("input:", inputs)
print("label:", labels)
print("logits shape:", tuple(logits.shape))
print("cross-entropy:", round(F.cross_entropy(logits, label_ids).item(), 3))

# Thêm hai vị trí đệm; label -100 bị cross_entropy bỏ qua theo mặc định.
padded_logits = bigram_logits(inputs + [EOS, EOS])
padded_labels = torch.cat([label_ids, torch.tensor([-100, -100])])
print("thêm 2 vị trí đệm:", round(F.cross_entropy(padded_logits, padded_labels).item(), 3))

Kết quảinput: ['<bos>', 'em', 'học', 'toán']
label: ['em', 'học', 'toán', '<eos>']
logits shape: (4, 9)
cross-entropy: 1.331
thêm 2 vị trí đệm: 1.331

Cross-entropy 1.331 khớp NLL của “em học toán” ở trên: loss huấn luyện của language model chính là NLL trung bình trên các token đích. Hai vị trí đệm mang label -100 nên loss giữ nguyên, dù hàng logits ở đó chứa gì.

Với batch thật, input có shape (B, L), logits có shape (B, L, |V|), và label là chính chuỗi token dịch trái một vị trí, nên mỗi chuỗi $L$ token cho $L-1$ cặp (vị trí, token kế). Quên dịch label, tức dùng chính input_ids làm nhãn ở cùng vị trí, thì model chỉ học chép lại token đang đọc: loss xuống rất thấp mà không học được gì về token tiếp theo.

Không so PPL của hai tokenizer khác nhau như cùng một thước đo (bài 4.5): chuỗi bị chia khác làm $N$ và phân phối đích đổi. Phải nói rõ tokenizer, vocabulary, cách tính BOS/EOS, truncation và đơn vị trung bình.

Loss phải cộng theo tổng số token hợp lệ; trung bình loss của các batch dài ngắn bằng trọng số ngang nhau có thể làm lệch phép đo.

Từ logits đến token được chọn

Causal neural language model trả logits $z_v$ cho mọi token trong vocabulary. Với temperature $T>0$, xác suất dùng khi sampling là

$T$ nhỏ làm phân phối nhọn, $T$ lớn làm phẳng. Greedy luôn lấy token có logits lớn nhất; chia mọi logits cho cùng một $T>0$ không đổi thứ tự, nên temperature không ảnh hưởng tới greedy. Không tính công thức với $T=0$; “temperature 0” trong một số API là quy ước chuyển sang greedy, không phải phép chia toán học hợp lệ.

def softmax_temperature(logits, temperature):
    if temperature <= 0:
        raise ValueError("Temperature phải dương trong công thức sampling")
    scaled = logits / temperature
    weights = np.exp(scaled - scaled.max())
    return weights / weights.sum()

example_logits = np.array([2.0, 1.0, 0.0])
for temperature in [0.5, 1.0, 2.0]:
    probability = softmax_temperature(example_logits, temperature)
    print("T=", temperature, "p=", probability.round(3))

Kết quảT= 0.5 p= [0.867 0.117 0.016]
T= 1.0 p= [0.665 0.245 0.09 ]
T= 2.0 p= [0.506 0.307 0.186]

Token đầu vẫn có xác suất lớn nhất ở cả ba hàng; chỉ độ chênh thay đổi. Khi $T\to0^+$, phân phối dồn về argmax nên sampling tiến tới greedy; khi $T\to\infty$, nó tiến tới phân phối đều trên cả vocabulary. Sampling lấy ngẫu nhiên theo phân phối, không nhất thiết chọn token đầu. Cố định seed giúp tái tạo cùng thí nghiệm trong cùng môi trường, nhưng không biến sampling thành kiểm chứng kiến thức.

Hai cách lọc trước khi rút:

• Top-k giữ đúng $k$ token có điểm cao nhất rồi chuẩn hóa lại.
• Top-p sắp token theo xác suất giảm dần, giữ đoạn đầu ngắn nhất có tổng xác suất đạt ít nhất $p$, rồi chuẩn hóa lại. Số token giữ thay đổi theo độ nhọn; phải giữ cả token làm tổng vượt ngưỡng.

def top_p_distribution(probability, threshold):
    if not 0 < threshold <= 1:
        raise ValueError("top-p nằm trong (0, 1]")
    order = np.argsort(-probability, kind="stable")
    sorted_probability = probability[order]
    # Giữ token khi tổng trước nó còn dưới ngưỡng, gồm cả token vượt ngưỡng.
    keep = np.cumsum(sorted_probability) - sorted_probability < threshold
    result = np.zeros_like(probability)
    result[order[keep]] = sorted_probability[keep]
    return result / result.sum()

base_probability = softmax_temperature(example_logits, 1.0)
filtered = top_p_distribution(base_probability, 0.8)
print("base:", base_probability.round(3))
print("top-p=0.8:", filtered.round(3))
print("số token giữ:", np.count_nonzero(filtered))

Kết quảbase: [0.665 0.245 0.09 ]
top-p=0.8: [0.731 0.269 0.   ]
số token giữ: 2

Top-p 0.8 giữ hai token: token đầu (0.665) chưa đạt 0.8, còn hai token đầu (0.91) đã đạt. Top-k giữ một số token cố định dù phân phối nhọn hay phẳng; top-p tự co lại khi model chắc chắn và nới ra khi model phân vân. Các thư viện như Hugging Face áp temperature vào logits trước, rồi mới lọc top-k và top-p trên phân phối đã đổi.

Ví dụ “và” 0.5, “nhưng” 0.3, “nên” 0.1, “thì” 0.1 với top-p 0.75: token đầu chưa đủ, hai token đầu đạt 0.8, nên chỉ chọn giữa “và” và “nhưng”.

Cũng vì sampling mà hỏi chatbot cùng một câu hai lần có thể nhận hai câu trả lời khác nhau. Việc cần chính xác như dịch văn bản pháp lý hợp với greedy hay beam search; viết truyện cần đa dạng thì hợp với sampling có temperature vừa phải.

Sinh từng bước và vì sao greedy không tối ưu cả chuỗi

Ta cho bigram sinh đến EOS hoặc tối đa 6 token. Greedy dùng argmax, sampling dùng RNG seed 0. Khi hòa điểm, thứ tự target_vocab quyết định greedy, nên quy tắc đó phải được biết.

def generate_bigram(sample=False, seed=0, max_tokens=6):
    rng = np.random.default_rng(seed)
    previous = BOS
    generated = []
    for _ in range(max_tokens):
        probability = next_distribution(previous)
        if sample:
            index = rng.choice(len(target_vocab), p=probability)
        else:
            index = int(probability.argmax())
        token = target_vocab[index]
        if token == EOS:
            break
        generated.append(token)
        previous = token
    return " ".join(generated)

print("greedy:", generate_bigram())
print("sampling seed 0:", generate_bigram(sample=True))

Kết quảgreedy: em học toán
sampling seed 0: em em

Greedy đi đúng đường được đếm nhiều nhất: “em” (3 lần sau BOS), “học”, “toán”, rồi EOS. Sampling với seed 0 ra “em em”, một cặp chưa từng xuất hiện: smoothing cho nó xác suất $1/12$, đủ để thỉnh thoảng được rút. Giới hạn số token giữ cho vòng sinh dừng, nhưng không sửa chất lượng. Chọn seed cho ra một câu hay rồi báo như thể model luôn sinh như vậy là chọn mẫu đẹp, giống chọn seed tốt nhất trên test.

Câu trả lời bị cắt ngang giữa câu thường do chạm giới hạn số token sinh trước khi gặp EOS. Greedy còn hay rơi vào vòng lặp: khi cụm vừa sinh làm chính nó có xác suất cao nhất ở bước sau, argmax cứ chọn lại mãi; sampling hoặc phạt lặp (repetition penalty) phá vòng ấy.

Greedy tối ưu mỗi bước, không bảo đảm tối ưu cả chuỗi. Ví dụ bước đầu $p(A)=0.6$, $p(B)=0.4$. Tiếp theo $p(\mathrm{EOS}\mid A)=0.5$, còn $p(\mathrm{EOS}\mid B)=0.95$. Greedy chọn A, chuỗi A EOS có xác suất $0.6\cdot0.5=0.30$, còn B EOS có $0.4\cdot0.95=0.38$.

Beam search độ rộng $k$ giữ $k$ tiền tố có tổng log-xác suất cao nhất thay vì một. Mỗi bước, mỗi tiền tố được nối với mọi token, tạo $k|V|$ ứng viên, rồi chỉ $k$ ứng viên tốt nhất được giữ; tiền tố vừa gặp EOS được cất riêng thành câu hoàn chỉnh. Với $k=2$, ví dụ trên giữ cả A lẫn B ở bước đầu nên tìm ra B EOS; với $k=1$, beam search chính là greedy.

Beam hữu hạn vẫn chỉ tìm gần đúng: tiền tố bị loại ở một bước không bao giờ quay lại. Mỗi token nối thêm cộng một số hạng $\log p\le0$, nên tổng log không bao giờ tăng và beam thuần ưu ái câu ngắn; length penalty chia điểm theo độ dài và vì vậy đổi mục tiêu xếp hạng. Chuỗi xác suất cao nhất cũng không nhất thiết tốt nhất theo metric của nhiệm vụ.

Perplexity và văn bản bị máy sửa

Ta có thể dùng loss language model làm một đặc trưng để phát hiện văn bản do máy viết hoặc sửa: văn phong máy có thể khác corpus tham chiếu. Nhưng đây là một bài phân loại riêng, cần nhãn biết chắc nguồn gốc của từng văn bản; không có luật “PPL thấp là do AI”. Một học sinh viết câu thông dụng có thể có loss thấp; một model sinh thuật ngữ hiếm có thể có loss cao. Dịch, sửa chính tả, tác giả và chủ đề còn là các yếu tố gây nhiễu.

Muốn thử, ta cần cặp bản gốc/bản sửa với cách tạo được ghi lại, chia theo nguồn văn bản để hai bản của cùng một đoạn không sang hai tập. Chọn ngưỡng bằng validation; báo false positives và false negatives trên nhóm tác giả, chủ đề và cách sửa chưa thấy. Không dùng một score để kết luận gian lận của một người.