Xử lý Ngôn ngữ Tự nhiên trước thời kỳ LLM

Bài viết đầu tiên này bàn về Xử lý Ngôn ngữ Tự nhiên (Natural Language Processing — NLP) cổ điển, trước kỷ nguyên của các LLM.

Tôi biết bạn đang nghĩ gì. Việc học lại NLP thế hệ cũ nghe có vẻ như đang lãng phí thời gian, bởi phần lớn những kỹ thuật này đều đã bị thay thế bởi các LLM hiện đại.

Tuy vậy, tôi tin rằng dành ra vài giờ cho chặng đường này là hoàn toàn xứng đáng. Trước hết, bạn sẽ nắm được những khái niệm cốt lõi vẫn còn nguyên giá trị cho đến tận ngày nay. Bạn cũng sẽ hiểu rõ hơn “phả hệ của các ý tưởng” — một nền tảng vô cùng quan trọng để rèn luyện gu thẩm mỹ nghiên cứu (research taste) của riêng mình. Đặc biệt, bạn sẽ thấy rõ vì sao và bằng cách nào kiến trúc Transformer lại ra đời rồi nhanh chóng thống lĩnh toàn bộ lĩnh vực. Cuối cùng, bài viết này điểm qua vài chục công trình khoa học kinh điển mà bất kỳ ai muốn theo đuổi chủ đề này một cách nghiêm túc cũng nên đọc qua ít nhất một lần trong đời.

Trong chương đầu tiên này, chúng ta sẽ lần theo hai câu hỏi lớn từng định hình sự phát triển của toàn bộ lĩnh vực NLP:

• Làm thế nào để xây dựng một mô hình học máy nhận đầu vào là một đoạn văn bản, khi mà văn bản đó không hề có độ dài cố định?
• Làm thế nào để chuyển giao (transfer) những gì mô hình đã học được từ tác vụ này sang tác vụ khác, dựa trên thực tế rằng ở mọi bài toán NLP, bản chất của ngôn ngữ về cơ bản vẫn là một?

Để khám phá hai câu hỏi trên, chúng ta sẽ thực hành chủ yếu với hai tác vụ và hai bộ dữ liệu:

• Đánh giá phim IMDB (IMDB movie reviews) cho bài toán phân loại cảm xúc (sentiment classification)
• WikiText-2 cho bài toán mô hình hóa ngôn ngữ (language modeling).

1. Các tác vụ điển hình của NLP

Ngày nay, khi đang sống trong thế giới của các LLM, chúng ta rất dễ mặc định rằng mô hình hóa ngôn ngữ tự hồi quy (autoregressive language modeling) là tất cả những gì thuộc về NLP. Thế nhưng trước năm 2019 — thời điểm giới nghiên cứu nhận ra GPT-2 có khả năng sinh văn bản mạch lạc và nhờ đó giải quyết được nhiều bài toán khác mà không cần huấn luyện chuyên biệt cho từng bài toán — mô hình hóa ngôn ngữ chỉ là một trong số rất nhiều tác vụ của NLP cổ điển.

Suốt nhiều thập kỷ, phân loại văn bản (text classification), gán nhãn chuỗi (tagging) và dịch máy (translation) mới là những thách thức quan trọng bậc nhất được giải quyết bằng các công cụ học máy.

Mỗi tác vụ trong số bốn tác vụ này đều có thể được biểu diễn một cách hình thức thành bài toán học các phân phối xác suất có điều kiện dựa trên một đoạn văn bản đầu vào, trong đó văn bản được xem như một chuỗi các từ. Minh họa dưới đây thể hiện trực quan góc nhìn này.

Hãy cùng điểm qua từng tác vụ này.

1.1 Phân loại văn bản (Classification)

Đây là tác vụ dễ phát biểu nhất trong NLP: bạn nhận vào một đoạn văn bản và phải phân loại nó vào một danh sách các danh mục (lớp) đã được định nghĩa trước. Đó có thể là phát hiện thư rác (spam detection), phân tích cảm xúc (sentiment analysis — “Bài đánh giá phim này khen hay chê?”), hoặc phân loại chủ đề (“Bài báo này viết về thể thao, chính trị hay công nghệ…?”).

Để làm được điều đó, bộ phân loại (classifier) cần học được xác suất có điều kiện:

biểu thị khả năng một chuỗi từ $x_1 \dots x_L$ thuộc về lớp $C$, trong đó độ dài $L$ không cố định trước (a priori) mà thay đổi tùy theo từng chuỗi văn bản.

Như đã thấy ở ví dụ mở đầu bài viết (“Chà, quả là một kiệt tác. […] Một bộ phim hoàn hảo nếu bạn thích ngủ gật.”), bài toán phân loại cảm xúc có thể rất tinh vi và đòi hỏi mô hình phải nhận diện được những sắc thái như sự mỉa mai, châm biếm (sarcasm).

1.2 Mô hình hóa ngôn ngữ (Language modeling)

Về mặt nguyên lý, mô hình hóa một ngôn ngữ đồng nghĩa với việc học phân phối xác suất $p(x_1 \dots x_L)$ của mọi chuỗi từ khả dĩ trong ngôn ngữ đó. Tuy nhiên trong thực tế, việc học xác suất của từ tiếp theo (next-word probability) thường thuận tiện hơn rất nhiều:

Từ xác suất dự đoán từ tiếp theo này, chúng ta có thể dễ dàng khôi phục lại xác suất của toàn bộ chuỗi bằng quy tắc dây chuyền (chain rule), chẳng hạn:

Dưới góc nhìn hiện đại, ứng dụng chính của phân phối xác suất này là sinh văn bản theo cơ chế tự hồi quy (autoregression): lấy mẫu một từ từ phân phối từ tiếp theo, nối từ đó vào cuối văn bản hiện tại, rồi lặp lại quá trình. Đây chính là nguyên lý vận hành đằng sau các chatbot và tác tử LLM ngày nay.

Thế nhưng việc nắm được phân phối xác suất của ngôn ngữ còn mang lại nhiều ứng dụng khác, ví dụ như chấm điểm xác suất cho các câu ứng viên trong một danh sách. Hãy hình dung một mô hình Nhận dạng Giọng nói Tự động (Automatic Speech Recognition — ASR) đưa ra hai bản gỡ băng ứng viên đều khớp khá hợp lý với mẫu âm thanh thu được: ta có thể bổ sung một bước hậu xử lý dùng mô hình ngôn ngữ để chấm điểm hai ứng viên này và chọn ra câu đúng. Chẳng hạn, với bất kỳ mô hình ngôn ngữ hợp lý nào, xác suất của câu “Thuyết tương đối rộng được xây dựng bởi Alfred Einstein” chắc chắn sẽ thấp hơn nhiều so với câu “Thuyết tương đối rộng được xây dựng bởi Albert Einstein”.

Mặc dù tôi trình bày tách biệt hai mục, nhưng có một nhận thức rất quan trọng cần ghi nhớ: dự đoán từ tiếp theo thực chất chính là một dạng bài toán phân loại! Thay vì gán xác suất cho một tập hữu hạn các lớp phân loại, bạn gán xác suất cho một tập hữu hạn các từ nằm trong bộ từ vựng đã định trước. Khác biệt thực tiễn lớn nhất nằm ở quy mô: các bài toán phân loại trong NLP thường chỉ có một vài lớp, trong khi kích thước bộ từ vựng trong mô hình hóa ngôn ngữ thường lên tới hàng chục nghìn từ.

1.3 Dịch máy (Translation)

Dịch từ ngôn ngữ này sang ngôn ngữ khác từ lâu đã là một trong những tác vụ quan trọng nhất của NLP, đồng thời cũng là một bài toán vô cùng hóc búa. Một cách hình thức, chúng ta muốn học xác suất của một câu dịch ứng viên $y_1 \dots y_K$ khi biết câu gốc $x_1 \dots x_L$. Tương tự như trên, trong thực tế, ta thường tìm cách ước lượng xác suất của từ tiếp theo trong chuỗi dịch, có điều kiện trên câu gốc và những từ đã được dịch ra trước đó:

Lưu ý rằng việc học phân phối xác suất này hoàn toàn không hề hiển nhiên, bởi hai câu ở hai ngôn ngữ vốn không có cùng độ dài, và phép dịch nhìn chung không phải là sự tương ứng một-đối-một giữa từng từ.

Hơn thế nữa, trật tự từ giữa các ngôn ngữ có thể khác biệt hoàn toàn. Hãy xem ví dụ thú vị dưới đây thể hiện cùng một câu trong 4 ngôn ngữ… bạn nhất định nên thử so sánh giữa tiếng Anh và tiếng Thổ Nhĩ Kỳ!

1.4 Gán nhãn chuỗi (Tagging)

Cuối cùng, một tác vụ tiêu biểu khác trong NLP là gán nhãn chuỗi (tagging). Mục tiêu của bài toán là gán một lớp (nhãn) cho từng từ (hoặc từng cụm từ). Đó có thể là phát hiện lỗi ngữ pháp, hoặc gán nhãn từ loại cho mỗi từ trong câu (danh từ, động từ,…), một tác vụ được gọi là gán nhãn từ loại (part-of-speech tagging — POS tagging).

Đó cũng có thể là bài toán Nhận diện Thực thể có Tên (Named Entity Recognition — NER), chẳng hạn như đánh dấu tất cả tên người (hoặc tất cả địa danh) xuất hiện trong văn bản.

Có thể xem bài toán gán nhãn chuỗi như “một bộ phân loại được áp dụng cho từng từ”, nhưng ở mỗi vị trí đều có xét đến ngữ cảnh xung quanh:

Trong khuôn khổ bài viết này, tôi sẽ không đi sâu vào bài toán gán nhãn chuỗi.

2. Đếm từ: các mô hình ngôn ngữ đơn giản nhất dựa trên n-gram

Vì các mô hình ngôn ngữ sẽ là mối quan tâm chính của chúng ta ở những phần sau của chuỗi bài giảng, rất đáng để bắt đầu bằng một ví dụ mang tính lịch sử, đại diện cho cách thức đơn giản nhất để sinh ngôn ngữ theo kiểu tự hồi quy: mô hình Markov (Markov model).

2.1 Mô hình Markov (Markov model)

Nếu bạn thực sự muốn có một mô hình ngôn ngữ đơn giản nhất (và cũng kém hiệu quả nhất), bạn chỉ việc bốc ngẫu nhiên các từ trong bộ từ vựng theo đúng tần suất xuất hiện tự nhiên của chúng trong ngôn ngữ. Đây được gọi là mô hình unigram (1-gram), trong đó:

với $C(x_i)$ là số lần xuất hiện (tần số đếm) của từ $x_i$ trong kho ngữ liệu huấn luyện, và $N = \sum C(x_i)$ là tổng quy mô của kho ngữ liệu. Đây là một mô hình vô cùng thô sơ! Ít nhất chúng ta có thể cải thiện nó bằng cách xét các cặp từ liên tiếp — tức bigram (2-gram), hay chính là mô hình chuỗi Markov.

Chuỗi Markov đơn giản (Simple Markov chain)

Trong mô hình chuỗi Markov bigram đơn giản nhất, xác suất xuất hiện của một từ trong chuỗi chỉ phụ thuộc vào duy nhất từ đứng ngay trước nó:

Giả định này tất nhiên là không đúng với ngôn ngữ tự nhiên của con người, nhưng đổi lại nó cho phép mô hình hóa cực kỳ đơn giản chỉ bằng một ma trận chuyển trạng thái (transition matrix).

Sử dụng tập huấn luyện, chúng ta chỉ cần đếm số lần xuất hiện của mỗi từ $C(v)$ và của mỗi cặp từ liên tiếp $C(v,w)$. Sau đó, ta dùng các số đếm này để tính xác suất $p(w \mid v) = C(v,w)/C(v)$ để từ $w$ xuất hiện ngay sau từ $v$. Các xác suất này xác định một ma trận chuyển trạng thái, có thể dùng trực tiếp để sinh văn bản tự hồi quy bằng mô hình Chuỗi Markov.

Hãy thử nghiệm ngay ý tưởng đó qua bài tập dưới đây.

from datasets import load_dataset

wikitext = load_dataset("Salesforce/wikitext", "wikitext-2-v1")
print(wikitext["train"][4]["text"][:70])   # 70 ký tự đầu của dòng 4

 The game began development in 2010 , carrying over a large portion of

text: 2051910 words
vocabulary: 33277 words
distinct pairs: 618405

The institute . " and long , Mortimer Wheeler secured by worry over the Song military officer notable example of willows along the Richmond Chamber of the opening sequence stars except those produced , In November 23 January 1908 Distinguished Service before dissipating as a more able to bring the

from datasets import load_dataset

wikitext = load_dataset("Salesforce/wikitext", "wikitext-2-v1")
print(wikitext["train"][4]["text"][:70])   # 70 ký tự đầu của dòng 4

 The game began development in 2010 , carrying over a large portion of

# (1) Tạo chuỗi huấn luyện bằng cách tách từ ở mỗi dòng theo dấu cách
train_sequence = []
for line in wikitext["train"]["text"]:
    train_sequence.extend(line.split())

print(f"text: {len(train_sequence)} words")
print(f"vocabulary: {len(set(train_sequence))} words")


# (2) Dùng từ điển lồng nhau để đếm các cặp từ (bigram)
bigram_counts = {}
for a, b in zip(train_sequence, train_sequence[1:]):
    if a not in bigram_counts:
        bigram_counts[a] = {}
    if b not in bigram_counts[a]:
        bigram_counts[a][b] = 0
    bigram_counts[a][b] += 1

print(f"distinct pairs: {sum(len(f) for f in bigram_counts.values())}")


# (3) Sinh chuỗi từ bằng random.choices với trọng số là số lần xuất hiện
first_word = "The"
length = 50

import random
random.seed(0)

sample_words = [first_word]
while len(sample_words) < length:
    followers = bigram_counts[sample_words[-1]]
    options, weights = list(followers), list(followers.values())
    next_word = random.choices(options, weights)[0]
    sample_words.append(next_word)

print("\n" + " ".join(sample_words))

text: 2051910 words
vocabulary: 33277 words
distinct pairs: 618405

The institute . " and long , Mortimer Wheeler secured by worry over the Song military officer notable example of willows along the Richmond Chamber of the opening sequence stars except those produced , In November 23 January 1908 Distinguished Service before dissipating as a more able to bring the

Mô hình n-gram (n-gram models)

Chúng ta cũng có thể mở rộng mô hình bằng cách sử dụng các n-gram, tức các cụm gồm $n$ từ liên tiếp. Khi đó, để dự đoán từ tiếp theo, ta lấy chuỗi $n-1$ từ đứng ngay trước nó làm đầu vào. Mô hình chuỗi Markov ở mục 2.1 ứng với $n = 2$, còn mô hình unigram ứng với $n = 1$ (không sử dụng bất kỳ ngữ cảnh nào).

Khi dùng n-gram, ma trận chuyển trạng thái sẽ có kích thước $V^{n-1} \times V$, con số này bùng nổ cực kỳ nhanh chóng (chẳng hạn với $n=3$ và $V=30{,}000$, ta có khoảng $3 \times 10^{13}$ phần tử). Trong thực tế, một lần nữa chúng ta chỉ lưu trữ những n-gram thực sự xuất hiện vào một từ điển đếm, chứ không lưu toàn bộ bảng.

Dưới đây bạn có thể khám phá các ví dụ thực tế trên tập WikiText-2 với nhiều giá trị $n$ khác nhau.

2.2 So sánh các phân phối xác suất

Trong bài toán mô hình hóa ngôn ngữ, mục tiêu của chúng ta là xấp xỉ phân phối xác suất “thực” của từ tiếp theo. Hãy ký hiệu phân phối thực này là $p(x_{L+1} \mid x_1 \dots x_L)$. Bất kỳ mô hình ngôn ngữ ứng viên nào cũng sẽ đưa ra một phân phối dự đoán $q(x_{L+1} \mid x_1 \dots x_L)$ (trong mô hình Markov n-gram, phân phối này chỉ phụ thuộc vào $x_{L-n+2} \dots x_L$).

Làm thế nào để đo lường mức độ thành công? Nói cách khác, làm sao ta định lượng được mức độ giống nhau giữa $q$ và $p$?

Phân kỳ KL (KL Divergence) và hàm mất mát entropy chéo (cross-entropy loss)

Để đánh giá xem một phân phối xác suất có phải là xấp xỉ tốt cho một phân phối khác hay không, công cụ tiêu chuẩn được lựa chọn là phân kỳ Kullback–Leibler (Kullback–Leibler divergence — KL divergence):

Ở đây tôi viết công thức với hai phân phối tổng quát $p$ và $q$, nhưng lưu ý rằng định nghĩa này hoàn toàn áp dụng được cho các xác suất có điều kiện, chẳng hạn trong trường hợp của chúng ta là $p(x_{L+1} \mid x_1 \dots x_L)$ và $q(x_{L+1} \mid x_1 \dots x_L)$.

Việc tìm phân phối $q$ xấp xỉ tốt nhất một phân phối $p$ cho trước đồng nghĩa với việc cực tiểu hóa phân kỳ KL. Tuy nhiên trong bài toán của chúng ta, vì phân phối thực $p$ chưa biết trước (a priori), việc tính chính xác đại lượng này thoạt nhìn có vẻ bất khả thi. Thế nhưng để cực tiểu hóa phân kỳ KL, trước hết ta có thể nhận xét rằng biểu thức logarit bên trong có thể tách thành hai phần:

Số hạng đầu tiên chính là (trừ) entropy của $p$ (đại lượng này hoàn toàn không phụ thuộc vào $q$), còn số hạng thứ hai được gọi là entropy chéo (cross-entropy).

Vì entropy chéo:

là thành phần duy nhất thực sự phụ thuộc vào $q$, nên bài toán quy về việc tìm phân phối $q$ sao cho đại lượng này đạt giá trị nhỏ nhất.

Việc tìm $q$ để cực tiểu hóa phân kỳ KL $D_{KL}(p \,\|\, q)$ hoàn toàn tương đương với việc cực tiểu hóa entropy chéo $H(p,q)$.

Bạn có thể trực tiếp trải nghiệm trực giác này trên một ví dụ rất đơn giản dưới đây bằng cách kéo thả các cột của phân phối màu cam.

Hợp lý cực đại (Likelihood)

Bây giờ hãy quay lại với hệ thống ký hiệu của bài toán và nhớ rằng chúng ta đang làm việc với các xác suất có điều kiện $p(x \mid c)$ và $q(x \mid c)$ để từ $x$ xuất hiện tiếp theo khi biết ngữ cảnh $c=(x_1,\dots,x_L)$.

Nếu phân phối $q$ phụ thuộc vào bộ tham số $\theta$, ta cần cực tiểu hóa entropy chéo:

biểu thức này có thể được hiểu như kỳ vọng toán học trên phân phối xác suất $x \sim p( . | c)$:

Một lần nữa, chúng ta không thể tính trực tiếp đại lượng này vì không biết phân phối thực $p$, nhưng kho ngữ liệu văn bản của chúng ta chính là một mẫu dữ liệu được rút ra từ $p$.

Tại mỗi vị trí $i$ trong văn bản, ngữ cảnh $x_{<i} = x_1 \dots x_{i-1}$ được nối tiếp bởi từ $x_i$ thực sự xuất hiện tại đó. Hầu hết các ngữ cảnh dài chỉ xuất hiện đúng một lần, nên ta không bao giờ quan sát được toàn bộ phân phối $p(\cdot \mid x_{<i})$, mà chỉ thấy duy nhất một từ được lấy mẫu từ phân phối ấy. Tuy nhiên, giá trị trung bình tính trên toàn bộ $N$ vị trí của văn bản sẽ cho ta một ước lượng của entropy chéo, lấy trung bình theo đúng tần suất xuất hiện tự nhiên của các ngữ cảnh trong ngôn ngữ:

Giá trị trung bình này mang một ý nghĩa rất trực quan. Tổng của các logarit chính là logarit của một tích, và theo quy tắc dây chuyền ở mục 1.2, tích $\prod_i q_\theta(x_i \mid x_{<i})$ chính là xác suất mà mô hình gán cho toàn bộ văn bản — hay còn gọi là độ hợp lý (likelihood) của văn bản. Do đó, $\hat{H}$ là trung bình log-hợp lý âm (negative log-likelihood — NLL) tính trên mỗi từ của văn bản, và việc cực tiểu hóa entropy chéo hoàn toàn tương đương với việc cực đại hóa độ hợp lý (maximizing likelihood) của kho ngữ liệu.

Để huấn luyện mô hình, chúng ta chọn bộ tham số $\theta$ (chẳng hạn như các trọng số của mạng nơ-ron) sao cho cực tiểu hóa $\hat{H}$ trên một văn bản huấn luyện. Bản thân mỗi số hạng trong tổng trên cũng là một entropy chéo: đó là entropy chéo giữa $q_\theta$ và phân phối dồn toàn bộ xác suất bằng 1 vào đúng từ thực tế quan sát được (phân phối one-hot), đóng vai trò đại diện cho phân phối $p$ chưa biết:

Đây chính là hàm mất mát entropy chéo (cross-entropy loss) được sử dụng để huấn luyện mọi mô hình ngôn ngữ, bao gồm cả các LLM hiện đại. Một số hạng đơn lẻ như vậy là một ước lượng nhiều nhiễu, nhưng khi lấy trung bình trên toàn bộ các từ của văn bản, đạo hàm (gradient) của nó chính là $\nabla_\theta H(p, q_\theta)$. Vì entropy của $p$ không phụ thuộc vào $\theta$, đại lượng này cũng chính bằng $\nabla_\theta D_{KL}(p \,\|\, q_\theta)$.

Cực đại hóa độ hợp lý (Likelihood) = Cực tiểu hóa hàm mất mát entropy chéo (Cross-entropy loss) = Cực tiểu hóa phân kỳ KL (KL divergence).

Đối với các mô hình n-gram, chúng ta thậm chí không cần dùng đến gradient: tỷ số đếm $C(v,w)/C(v)$ ở mục 2.1 chính là nghiệm giải tích $q$ giúp cực đại hóa độ hợp lý trên văn bản huấn luyện.

Độ hỗn loạn (Perplexity)

Tuy nhiên, giá trị entropy chéo thường khó đọc và khó diễn giải trực quan, nên trong thực tế người ta thường báo cáo hàm mũ của nó, gọi là độ hỗn loạn (perplexity) của mô hình trên văn bản:

Về mặt toán học, đây là nghịch đảo của trung bình nhân các xác suất mà mô hình gán cho từng từ trong văn bản. Một mô hình dự đoán phân phối đều (uniform) trên $V$ từ sẽ có perplexity bằng đúng $V$; vì vậy, độ hỗn loạn (perplexity) có thể được diễn giải trực quan là số lượng từ mà mô hình đang phải phân vân lựa chọn ở mỗi bước dự đoán.

Trong các bài tập thực hành, chúng ta sẽ đo perplexity trên tập xác thực, và chỉ tính perplexity trên tập kiểm tra để so sánh tổng thể các mô hình ở mục 6.

from datasets import load_dataset

wikitext = load_dataset("Salesforce/wikitext", "wikitext-2-v1")


# (1) Tạo chuỗi huấn luyện bằng cách tách từ ở mỗi dòng theo dấu cách
# [Sao chép từ lời giải bài 2.1, bước (1)]
train_sequence = []
for line in wikitext["train"]["text"]:
    train_sequence.extend(line.split())

print(f"text: {len(train_sequence)} words")
print(f"vocabulary: {len(set(train_sequence))} words")


# (2) Dùng từ điển lồng nhau để đếm các cặp từ (bigram)
# [Sao chép từ lời giải bài 2.1, bước (2)]
bigram_counts = {}
for a, b in zip(train_sequence, train_sequence[1:]):
    if a not in bigram_counts:
        bigram_counts[a] = {}
    if b not in bigram_counts[a]:
        bigram_counts[a][b] = 0
    bigram_counts[a][b] += 1

print(f"distinct pairs: {sum(len(f) for f in bigram_counts.values())}")


# -------------------------
#  Phần mới trong bài này
# -------------------------
# Chuỗi xác thực (validation) và kiểm tra (test), tạo tương tự
val_sequence = []
for line in wikitext["validation"]["text"]:
    val_sequence.extend(line.split())

test_sequence = []
for line in wikitext["test"]["text"]:
    test_sequence.extend(line.split())

print(f"validation: {len(val_sequence)} words")
print(f"test: {len(test_sequence)} words")

text: 2051910 words
vocabulary: 33277 words
distinct pairs: 618405
validation: 213886 words
test: 241211 words

unigram perplexity, validation set: 996.5

validation pairs never seen in training: 46338
out of 213885, or 21.7%
bigram perplexity, validation set: inf

unigram perplexity, test set: 941.7

from datasets import load_dataset

wikitext = load_dataset("Salesforce/wikitext", "wikitext-2-v1")


# (1) Tạo chuỗi huấn luyện bằng cách tách từ ở mỗi dòng theo dấu cách
# [Sao chép từ lời giải bài 2.1, bước (1)]
train_sequence = []
for line in wikitext["train"]["text"]:
    train_sequence.extend(line.split())

print(f"text: {len(train_sequence)} words")
print(f"vocabulary: {len(set(train_sequence))} words")


# (2) Dùng từ điển lồng nhau để đếm các cặp từ (bigram)
# [Sao chép từ lời giải bài 2.1, bước (2)]
bigram_counts = {}
for a, b in zip(train_sequence, train_sequence[1:]):
    if a not in bigram_counts:
        bigram_counts[a] = {}
    if b not in bigram_counts[a]:
        bigram_counts[a][b] = 0
    bigram_counts[a][b] += 1

print(f"distinct pairs: {sum(len(f) for f in bigram_counts.values())}")


# -------------------------
#  Phần mới trong bài này
# -------------------------
# Chuỗi xác thực (validation) và kiểm tra (test), tạo tương tự
val_sequence = []
for line in wikitext["validation"]["text"]:
    val_sequence.extend(line.split())

test_sequence = []
for line in wikitext["test"]["text"]:
    test_sequence.extend(line.split())

print(f"validation: {len(val_sequence)} words")
print(f"test: {len(test_sequence)} words")

text: 2051910 words
vocabulary: 33277 words
distinct pairs: 618405
validation: 213886 words
test: 241211 words

# (1) Đếm số lần xuất hiện của từng từ trong chuỗi huấn luyện
unigram_counts = {}
for word in train_sequence:
    if word not in unigram_counts:
        unigram_counts[word] = 0
    unigram_counts[word] += 1


# (2) Độ bối rối (perplexity) của mô hình unigram: hàm mũ của trừ
# trung bình log-xác suất trên các từ thuộc tập xác thực
import math

def perplexity(log_probs):
    return math.exp(-sum(log_probs) / len(log_probs))

n_train = len(train_sequence)
log_probs = []
for word in val_sequence:
    log_probs.append(math.log(unigram_counts[word] / n_train))

print(f"unigram perplexity, validation set: "
      f"{perplexity(log_probs):.1f}")


# (3) Độ bối rối của mô hình bigram. Một cặp từ chưa từng gặp khi
# huấn luyện sẽ có xác suất bằng 0, và log(0) bằng âm vô cùng.
follower_totals = {}
for a in bigram_counts:
    follower_totals[a] = sum(bigram_counts[a].values())

log_probs = []
unseen_pairs = 0
for a, b in zip(val_sequence, val_sequence[1:]):
    count = bigram_counts[a].get(b, 0)
    if count == 0:
        unseen_pairs += 1
        log_probs.append(-math.inf)
    else:
        log_probs.append(math.log(count / follower_totals[a]))

n_pairs = len(log_probs)
print(f"\nvalidation pairs never seen in training: {unseen_pairs}")
print(f"out of {n_pairs}, or {100 * unseen_pairs / n_pairs:.1f}%")
print(f"bigram perplexity, validation set: {perplexity(log_probs)}")


# (4) Độ bối rối của mô hình unigram trên tập kiểm tra (test)
log_probs = []
for word in test_sequence:
    log_probs.append(math.log(unigram_counts[word] / n_train))

test_perplexity = perplexity(log_probs)
print(f"\nunigram perplexity, test set: {test_perplexity:.1f}")

unigram perplexity, validation set: 996.5

validation pairs never seen in training: 46338
out of 213885, or 21.7%
bigram perplexity, validation set: inf

unigram perplexity, test set: 941.7

2.3 Lời nguyền số chiều (Curse of dimensionality)

Hiện tượng số đếm bằng 0 xảy ra cực kỳ nhanh khi làm việc với các từ trích từ kho ngữ liệu huấn luyện. Với bộ từ vựng 33.000 từ, có khoảng 1,1 tỷ cặp từ khả dĩ, nhưng một văn bản huấn luyện dài 2 triệu từ thì tối đa cũng chỉ chứa được 2 triệu cặp (trong bài tập 2.1 chúng ta chỉ thu được khoảng 618.000 cặp từ phân biệt, tức vỏn vẹn 0,06%). Các tổ hợp từ chưa từng thấy đã xuất hiện dày đặc trên văn bản kiểm tra ngay từ $n = 2$ hoặc $n = 3$. Đây chính là một biểu hiện điển hình của lời nguyền số chiều (curse of dimensionality): số lượng ngữ cảnh khả dĩ tăng theo hàm mũ $V^{n-1}$, trong khi kích thước văn bản huấn luyện lại giữ nguyên.

from datasets import load_dataset

wikitext = load_dataset("Salesforce/wikitext", "wikitext-2-v1")


# (1) Tạo chuỗi huấn luyện bằng cách tách từ ở mỗi dòng theo dấu cách
# [Sao chép từ lời giải bài 2.1, bước (1)]
train_sequence = []
for line in wikitext["train"]["text"]:
    train_sequence.extend(line.split())

print(f"text: {len(train_sequence)} words")
print(f"vocabulary: {len(set(train_sequence))} words")


# Chuỗi xác thực (validation) và kiểm tra (test), tạo tương tự
# [Sao chép từ mã khởi đầu bài 2.2]
val_sequence = []
for line in wikitext["validation"]["text"]:
    val_sequence.extend(line.split())

test_sequence = []
for line in wikitext["test"]["text"]:
    test_sequence.extend(line.split())

print(f"validation: {len(val_sequence)} words")
print(f"test: {len(test_sequence)} words")

text: 2051910 words
vocabulary: 33277 words
validation: 213886 words
test: 241211 words

n = 1: The island Several was a three with Coast and at 500 Stefani five game expressed 15 is oxidation Abd Beginning digital and continuing F closed down . that built weekly

n = 2: The institute . " and long , Mortimer Wheeler secured by worry over the Song military officer notable example of willows along the Richmond Chamber of the opening sequence stars

n = 3: The institute is part of the river also served as the negative critical reviews , but the studio floor were often built in 1858 on the south of Romani marked

n = 4: The institute is part of the first stone of the original route of Highway 36 was first assumed by the Department of Highways were accused of cowardice by fellow officers

n = 5: The institute is part of Florida Atlantic 's Department of Ocean Engineering which was founded in 1870 . By 20 April 1914 , when the residents passed Act to <unk>

n = 1: 0.0% never seen
n = 2: 21.7% never seen
n = 3: 60.8% never seen
n = 4: 85.8% never seen
n = 5: 95.2% never seen

from datasets import load_dataset

wikitext = load_dataset("Salesforce/wikitext", "wikitext-2-v1")


# (1) Tạo chuỗi huấn luyện bằng cách tách từ ở mỗi dòng theo dấu cách
# [Sao chép từ lời giải bài 2.1, bước (1)]
train_sequence = []
for line in wikitext["train"]["text"]:
    train_sequence.extend(line.split())

print(f"text: {len(train_sequence)} words")
print(f"vocabulary: {len(set(train_sequence))} words")


# Chuỗi xác thực (validation) và kiểm tra (test), tạo tương tự
# [Sao chép từ mã khởi đầu bài 2.2]
val_sequence = []
for line in wikitext["validation"]["text"]:
    val_sequence.extend(line.split())

test_sequence = []
for line in wikitext["test"]["text"]:
    test_sequence.extend(line.split())

print(f"validation: {len(val_sequence)} words")
print(f"test: {len(test_sequence)} words")

text: 2051910 words
vocabulary: 33277 words
validation: 213886 words
test: 241211 words

# (1) Với mỗi n, đếm các n-gram trong một từ điển lồng nhau:
# counts[n][context][word] là số lần `word` xuất hiện ngay sau
# `context` (tuple gồm n - 1 từ đứng trước nó).
# Với n = 1, ngữ cảnh là tuple rỗng ().
counts = {}
for n in range(1, 6):
    counts[n] = {}
    for i in range(n - 1, len(train_sequence)):
        context = tuple(train_sequence[i - n + 1:i])
        word = train_sequence[i]
        if context not in counts[n]:
            counts[n][context] = {}
        if word not in counts[n][context]:
            counts[n][context][word] = 0
        counts[n][context][word] += 1


# (2) Sinh 30 từ với mỗi giá trị n, bắt đầu bằng từ "The"
import random

first_word = "The"
length = 30

for n in range(1, 6):
    random.seed(0)
    sample_words = [first_word]
    while len(sample_words) < length:
        # Lấy n - 1 từ cuối, hoặc ít hơn ở những từ đầu tiên
        if n == 1:
            context = ()
        else:
            context = tuple(sample_words[-(n - 1):])
        followers = counts[len(context) + 1][context]
        options, weights = list(followers), list(followers.values())
        next_word = random.choices(options, weights)[0]
        sample_words.append(next_word)
    print(f"n = {n}: " + " ".join(sample_words) + "\n")


# (3) Với mỗi n, tính tỷ lệ n-gram trong chuỗi xác thực
# chưa từng xuất hiện khi huấn luyện
for n in range(1, 6):
    unseen = 0
    total = 0
    for i in range(n - 1, len(val_sequence)):
        context = tuple(val_sequence[i - n + 1:i])
        word = val_sequence[i]
        if context not in counts[n] or word not in counts[n][context]:
            unseen += 1
        total += 1
    print(f"n = {n}: {100 * unseen / total:.1f}% never seen")

n = 1: The island Several was a three with Coast and at 500 Stefani five game expressed 15 is oxidation Abd Beginning digital and continuing F closed down . that built weekly

n = 2: The institute . " and long , Mortimer Wheeler secured by worry over the Song military officer notable example of willows along the Richmond Chamber of the opening sequence stars

n = 3: The institute is part of the river also served as the negative critical reviews , but the studio floor were often built in 1858 on the south of Romani marked

n = 4: The institute is part of the first stone of the original route of Highway 36 was first assumed by the Department of Highways were accused of cowardice by fellow officers

n = 5: The institute is part of Florida Atlantic 's Department of Ocean Engineering which was founded in 1870 . By 20 April 1914 , when the residents passed Act to <unk>

n = 1: 0.0% never seen
n = 2: 21.7% never seen
n = 3: 60.8% never seen
n = 4: 85.8% never seen
n = 5: 95.2% never seen

Có một số phương pháp giúp tránh tình trạng perplexity tiến ra vô cùng do các xác suất bằng 0 gây ra bởi lời nguyền số chiều:

• Làm mượt (Smoothing): gán cho các chuỗi chưa từng xuất hiện một xác suất nhỏ khác 0. Cách đơn giản nhất là làm mượt cộng một (add-one smoothing / Laplace smoothing) — cộng thêm 1 vào mọi ô đếm — nhưng cách này hoạt động rất tệ với dữ liệu từ vựng: nó san sẻ quá nhiều tổng xác suất cho hàng tỷ cặp từ chưa từng xuất hiện.
• Nội suy (Interpolation) cho kết quả tốt hơn hẳn: phương pháp này pha trộn ước lượng xác suất của n-gram với ước lượng của $(n-1)$-gram theo một trọng số được tinh chỉnh trên tập xác thực. Công thức ước lượng được áp dụng đệ quy từng bước lùi dần về đến tận unigram; và vì xác suất unigram luôn khác 0 với mọi từ trong từ vựng, xác suất pha trộn cuối cùng sẽ không bao giờ bằng 0.
• Nhiều kỹ thuật tinh vi hơn đã được phát triển sau đó, tiêu biểu là phương pháp Kneser-Ney dưới đây — vốn giữ ngôi vị tối tân (state-of-the-art) suốt một thời gian dài.

Kỹ thuật làm mượt giải quyết bài toán các chuỗi từ mới được ghép từ những từ đã biết. Còn bản thân các từ mới chưa từng gặp (unseen words / out-of-vocabulary) lại là một vấn đề khác, vốn đã được WikiText-2 che giấu đi bằng cách thay thế toàn bộ các từ hiếm bằng token <unk>. Đây là lần đầu tiên chúng ta chạm trán với bài toán từ vựng: vấn đề này sẽ quay lại ở mục 3.2, và các bộ tách từ (tokenizers) — chủ đề của bài viết tiếp theo — sẽ giải quyết triệt để nó.

from datasets import load_dataset

wikitext = load_dataset("Salesforce/wikitext", "wikitext-2-v1")


# (1) Tạo chuỗi huấn luyện bằng cách tách từ ở mỗi dòng theo dấu cách
# [Sao chép từ lời giải bài 2.1, bước (1)]
train_sequence = []
for line in wikitext["train"]["text"]:
    train_sequence.extend(line.split())

print(f"text: {len(train_sequence)} words")
print(f"vocabulary: {len(set(train_sequence))} words")


# Chuỗi xác thực (validation) và kiểm tra (test), tạo tương tự
# [Sao chép từ mã khởi đầu bài 2.2]
val_sequence = []
for line in wikitext["validation"]["text"]:
    val_sequence.extend(line.split())

test_sequence = []
for line in wikitext["test"]["text"]:
    test_sequence.extend(line.split())

print(f"validation: {len(val_sequence)} words")
print(f"test: {len(test_sequence)} words")


# (1) Với mỗi n, đếm các n-gram trong một từ điển lồng nhau:
# counts[n][context][word] là số lần `word` xuất hiện ngay sau
# `context` (tuple gồm n - 1 từ đứng trước nó).
# Với n = 1, ngữ cảnh là tuple rỗng ().
# [Sao chép từ lời giải bài 2.3a, bước (1)]
counts = {}
for n in range(1, 6):
    counts[n] = {}
    for i in range(n - 1, len(train_sequence)):
        context = tuple(train_sequence[i - n + 1:i])
        word = train_sequence[i]
        if context not in counts[n]:
            counts[n][context] = {}
        if word not in counts[n][context]:
            counts[n][context][word] = 0
        counts[n][context][word] += 1

text: 2051910 words
vocabulary: 33277 words
validation: 213886 words
test: 241211 words

n = 1: add-one perplexity 999.1
n = 2: add-one perplexity 2207.8
n = 3: add-one perplexity 13327.0
n = 4: add-one perplexity 26020.8
n = 5: add-one perplexity 31024.1

n = 2: weight 0.68, interpolated perplexity 345.5
n = 3: weight 0.23, interpolated perplexity 303.7
n = 4: weight 0.11, interpolated perplexity 297.3
n = 5: weight 0.09, interpolated perplexity 296.2

test perplexity, n = 5: 277.7

from datasets import load_dataset

wikitext = load_dataset("Salesforce/wikitext", "wikitext-2-v1")


# (1) Tạo chuỗi huấn luyện bằng cách tách từ ở mỗi dòng theo dấu cách
# [Sao chép từ lời giải bài 2.1, bước (1)]
train_sequence = []
for line in wikitext["train"]["text"]:
    train_sequence.extend(line.split())

print(f"text: {len(train_sequence)} words")
print(f"vocabulary: {len(set(train_sequence))} words")


# Chuỗi xác thực (validation) và kiểm tra (test), tạo tương tự
# [Sao chép từ mã khởi đầu bài 2.2]
val_sequence = []
for line in wikitext["validation"]["text"]:
    val_sequence.extend(line.split())

test_sequence = []
for line in wikitext["test"]["text"]:
    test_sequence.extend(line.split())

print(f"validation: {len(val_sequence)} words")
print(f"test: {len(test_sequence)} words")


# (1) Với mỗi n, đếm các n-gram trong một từ điển lồng nhau:
# counts[n][context][word] là số lần `word` xuất hiện ngay sau
# `context` (tuple gồm n - 1 từ đứng trước nó).
# Với n = 1, ngữ cảnh là tuple rỗng ().
# [Sao chép từ lời giải bài 2.3a, bước (1)]
counts = {}
for n in range(1, 6):
    counts[n] = {}
    for i in range(n - 1, len(train_sequence)):
        context = tuple(train_sequence[i - n + 1:i])
        word = train_sequence[i]
        if context not in counts[n]:
            counts[n][context] = {}
        if word not in counts[n][context]:
            counts[n][context][word] = 0
        counts[n][context][word] += 1

text: 2051910 words
vocabulary: 33277 words
validation: 213886 words
test: 241211 words

# (1) Với mỗi từ trong chuỗi và mỗi n, tra cứu hai số đếm từ tập
# huấn luyện: số lần xuất hiện của n-gram kết thúc tại từ đó, và
# số lần xuất hiện của ngữ cảnh. Bắt đầu từ từ thứ 5 để mọi từ
# đều có đủ 4 từ đứng trước. Lưu kết quả vào mảng numpy.
import numpy as np

context_totals = {}
for n in range(1, 6):
    context_totals[n] = {}
    for context in counts[n]:
        context_totals[n][context] = sum(counts[n][context].values())

def lookup_counts(sequence):
    ngram_count = {}
    context_count = {}
    for n in range(1, 6):
        ngram_list = []
        context_list = []
        for i in range(4, len(sequence)):
            context = tuple(sequence[i - n + 1:i])
            followers = counts[n].get(context, {})
            ngram_list.append(followers.get(sequence[i], 0))
            context_list.append(context_totals[n].get(context, 0))
        ngram_count[n] = np.array(ngram_list)
        context_count[n] = np.array(context_list)
    return ngram_count, context_count

val_ngram, val_context = lookup_counts(val_sequence)

def perplexity(probs):
    return np.exp(-np.mean(np.log(probs)))


# (2) Làm mịn cộng một (add-one): cộng 1 vào số đếm của mọi
# n-gram khả dĩ, nên tổng số đếm của mỗi ngữ cảnh tăng thêm V
# (kích thước từ vựng)
V = len(set(train_sequence))
add_one = []
for n in range(1, 6):
    probs = (val_ngram[n] + 1) / (val_context[n] + V)
    add_one.append(perplexity(probs))
    print(f"n = {n}: add-one perplexity {add_one[-1]:.1f}")


# (3) Nội suy: q_n = w * p_n + (1 - w) * q_(n-1), trong đó p_n
# là xác suất tính từ số đếm n-gram. Khi ngữ cảnh chưa từng gặp
# trong tập huấn luyện, đặt q_n = q_(n-1).
def interpolate(ngram_count, context_count, weights):
    q = ngram_count[1] / context_count[1]   # n = 1
    for n in range(2, len(weights) + 2):
        w = weights[n - 2]   # weights[0] là trọng số của n = 2
        seen = context_count[n] > 0
        p = np.zeros(len(q))
        p[seen] = ngram_count[n][seen] / context_count[n][seen]
        q = np.where(seen, w * p + (1 - w) * q, q)
    return q

# Tinh chỉnh lần lượt trọng số của từng n bằng tìm kiếm lưới
weights = []
interpolation = [perplexity(interpolate(val_ngram, val_context, []))]
print()
for n in range(2, 6):
    best_w, best_perplexity = 0, np.inf
    for k in range(1, 100):
        w = k / 100
        q = interpolate(val_ngram, val_context, weights + [w])
        if perplexity(q) < best_perplexity:
            best_w, best_perplexity = w, perplexity(q)
    weights.append(best_w)
    interpolation.append(best_perplexity)
    print(f"n = {n}: weight {best_w}, "
          f"interpolated perplexity {best_perplexity:.1f}")


# (4) Độ bối rối trên tập kiểm tra của mô hình 5-gram nội suy
test_ngram, test_context = lookup_counts(test_sequence)
q = interpolate(test_ngram, test_context, weights)
test_perplexity = perplexity(q)
print(f"\ntest perplexity, n = 5: {test_perplexity:.1f}")

n = 1: add-one perplexity 999.1
n = 2: add-one perplexity 2207.8
n = 3: add-one perplexity 13327.0
n = 4: add-one perplexity 26020.8
n = 5: add-one perplexity 31024.1

n = 2: weight 0.68, interpolated perplexity 345.5
n = 3: weight 0.23, interpolated perplexity 303.7
n = 4: weight 0.11, interpolated perplexity 297.3
n = 5: weight 0.09, interpolated perplexity 296.2

test perplexity, n = 5: 277.7

import matplotlib.pyplot as plt

orders = [1, 2, 3, 4, 5]
plt.figure(figsize=(5, 3.5))
plt.plot(orders, add_one, "o-", label="add-one")
plt.plot(orders, interpolation, "o-", label="interpolation")
plt.yscale("log")
plt.xticks(orders)
plt.xlabel("n")
plt.ylabel("validation perplexity")
plt.legend()
plt.show()

Nếu bạn muốn đào sâu hơn, dưới đây là một số bài tập mở rộng.

3. Phân loại văn bản với Túi từ (Bag of Words)

Bây giờ, chúng ta hãy tạm gác lại bài toán mô hình hóa ngôn ngữ để chuyển sang tác vụ trọng tâm thứ hai của bài viết: phân loại các bài đánh giá phim thành tích cực (positive) hoặc tiêu cực (negative).

3.1 Khuôn mẫu chung: Bộ mã hóa (Encoder) → Biểu diễn kích thước cố định → Đầu phân loại (Head)

Trong một bài toán phân loại, chẳng hạn như phân tích cảm xúc của các bài đánh giá phim, văn bản đầu vào luôn có độ dài biến thiên. Và chúng ta không thể dùng lại mẹo đã áp dụng cho mô hình ngôn ngữ Markov — tức là chỉ giữ lại $n$ từ cuối cùng. Thật vậy, chẳng có lý do gì để giả định rằng thông tin quan trọng nhất của cả bài đánh giá lại luôn nằm ở $n$ từ cuối cùng, nhất là khi $n$ chỉ nhỏ hơn 3 hoặc 4!

Vì tất cả các phương pháp học máy cổ điển (hồi quy logistic, mạng nơ-ron truyền thẳng, các phương pháp dựa trên cây quyết định…) đều đòi hỏi đầu vào có kích thước cố định, chúng ta cần một cơ chế để chuyển đổi một đoạn văn bản có độ dài bất kỳ thành một biểu diễn có kích thước cố định (fixed-size representation) tóm lược nội dung của văn bản đó.

Nhìn chung, một mô hình phân loại trong NLP luôn có thể tách thành hai bước: bộ mã hóa (encoder) — làm nhiệm vụ tạo ra một biểu diễn có kích thước cố định cho văn bản (đôi khi được gọi là biểu diễn tiềm ẩn — latent representation), và đầu phân loại (classification head) — nhận biểu diễn này làm đầu vào để tính ra xác suất của từng lớp.

Khuôn mẫu này được minh họa trực quan ở hình dưới đây.

Lưu ý rằng các mô hình n-gram ở mục 2 thực chất cũng tuân theo khuôn mẫu này cho bài toán mô hình hóa ngôn ngữ: bộ mã hóa giữ lại $n - 1$ từ cuối cùng của văn bản (một biểu diễn có kích thước cố định), còn đầu dự đoán chính là bảng đếm tần số dùng để tra cứu xác suất của từ tiếp theo.

Vậy chúng ta có những lựa chọn nào để xây dựng một biểu diễn có kích thước cố định cho một bài đánh giá phim? Hãy bắt đầu với phương pháp đơn giản nhất.

3.2 Túi từ (Bag of words)

Hãy xét câu đánh giá phim sau đây:

Great acting, great lighting, and a flabbergasting soundtrack, but not even Zendaya could save this boring, boring plot. (Diễn xuất tuyệt vời, ánh sáng tuyệt vời và nhạc phim xuất sắc đến kinh ngạc, nhưng ngay cả Zendaya cũng không cứu nổi cốt truyện nhàm chán, vô cùng nhàm chán này.)

Chúng ta có thể đơn giản đếm số lần xuất hiện của từng từ trong câu.

Ta chưa thể dùng trực tiếp bảng này làm biểu diễn đầu vào cho mô hình được, bởi kích thước của bảng (cũng như các từ bên trong nó) sẽ thay đổi tùy theo từng bài đánh giá. Giải pháp là chọn trước một bộ từ vựng gồm $V$ từ, chẳng hạn như $V$ từ xuất hiện phổ biến nhất trong tập các bài đánh giá huấn luyện. Khi đó, mỗi bài đánh giá sẽ trở thành một vector có kích thước $V$, trong đó phần tử thứ $v$ chính là số lần xuất hiện $C_v$ của từ thứ $v$ (trong bộ từ vựng) ở bài đánh giá đang xét.

Hầu hết các phần tử của vector này đều bằng 0: một bài đánh giá IMDB trung vị chỉ dài khoảng 178 từ, trong khi bộ từ vựng chứa tới hàng nghìn từ. Đây là một vector thưa (sparse vector). Bạn cũng có thể hiểu vector này như tổng của các vector one-hot của từng từ xuất hiện trong bài đánh giá — tổng này luôn có cùng kích thước $V$ bất kể bài đánh giá dài hay ngắn. Vậy là chúng ta đã có được biểu diễn kích thước cố định, sẵn sàng đưa vào bất kỳ bộ phân loại cổ điển nào.

Cách biểu diễn này được gọi là túi từ (bag of words — BoW): cứ như thể chúng ta cắt rời bài đánh giá thành từng từ lẻ rồi trút tất cả vào chung một chiếc túi. Chúng ta biết chính xác mỗi từ xuất hiện bao nhiêu lần, nhưng đã đánh mất hoàn toàn trật tự xuất hiện của chúng (hãy ghi nhớ chi tiết này, chúng ta sẽ sớm quay lại với nó).

Tất nhiên, sẽ có những từ không nằm trong bộ từ vựng đã chọn, chẳng hạn như tên riêng “Zendaya” trong ví dụ của chúng ta. Những từ này đơn giản sẽ bị bỏ qua. Với $V = 10{,}000$, từ “flabbergasting” (kinh ngạc) nhiều khả năng cũng sẽ bị bỏ qua: nó chỉ xuất hiện trong đúng 2 trên tổng số 25.000 bài đánh giá huấn luyện của IMDB.

Về phần đầu phân loại (head), lựa chọn đơn giản nhất là hồi quy logistic (logistic regression). Mô hình này gán một trọng số $w_v$ cho mỗi từ trong bộ từ vựng, rồi tính xác suất bài đánh giá mang sắc thái tích cực theo công thức:

trong đó $b$ là độ chệch (bias), và hàm sigmoid $\sigma$ nén tổng điểm thành một giá trị xác suất nằm trong khoảng từ 0 đến 1. Nói cách khác, mỗi lần một từ xuất hiện sẽ đẩy tổng điểm tăng lên hoặc giảm xuống một lượng bằng đúng trọng số của từ đó, và mô hình sẽ kết luận là “tích cực” khi tổng điểm lớn hơn 0. Các trọng số này được học từ các bài đánh giá đã gán nhãn bằng cách cực tiểu hóa hàm mất mát entropy chéo ở mục 2.2 (với hai lớp thay vì toàn bộ từ vựng các từ tiếp theo).

Bạn có thể tương tác trực tiếp với mô hình này ở hình bên dưới: đây chính là mô hình bạn sẽ tự tay huấn luyện trong bài tập 3.2. Hãy thử chỉnh sửa nội dung bài đánh giá và quan sát vector đếm thay đổi. Để thấy rõ giới hạn của phương pháp này, hãy thử viết một câu chê bai thậm tệ nhưng vẫn bị mô hình phân loại nhầm thành tích cực, chẳng hạn bằng cách dùng giọng điệu mỉa mai.

Hãy cùng huấn luyện một mô hình như vậy trên bộ dữ liệu IMDB.

from datasets import load_dataset

imdb = load_dataset("stanfordnlp/imdb")

example = imdb["train"][0]
print(f"label {example['label']} (0 = negative, 1 = positive)")
print(example["text"][:70])

label 0 (0 = negative, 1 = positive)
I rented I AM CURIOUS-YELLOW from my video store because of all the co

train: 20000 reviews
validation: 5000 reviews
test: 25000 reviews

C = 0.01: validation accuracy 0.883
C = 0.03: validation accuracy 0.887
C = 0.1: validation accuracy 0.889
C = 0.3: validation accuracy 0.886
C = 1: validation accuracy 0.875
C = 3: validation accuracy 0.870
C = 10: validation accuracy 0.862

test accuracy, C = 0.1: 0.876

negative: worst waste disappointment awful poorly boring lacks fails avoid mess
positive: 7 8 perfect excellent refreshing wonderfully superb amazing favorite rare

from datasets import load_dataset

imdb = load_dataset("stanfordnlp/imdb")

example = imdb["train"][0]
print(f"label {example['label']} (0 = negative, 1 = positive)")
print(example["text"][:70])

label 0 (0 = negative, 1 = positive)
I rented I AM CURIOUS-YELLOW from my video store because of all the co

# (1) Tách 5.000 bài đánh giá huấn luyện làm tập xác thực, và
# thay thế các thẻ xuống dòng HTML bằng khoảng trắng

def clean(texts):
    return [text.replace("<br />", " ") for text in texts]

split = imdb["train"].train_test_split(test_size=5000, seed=0)
train_texts = clean(split["train"]["text"])
val_texts = clean(split["test"]["text"])
test_texts = clean(imdb["test"]["text"])
train_labels = split["train"]["label"]
val_labels = split["test"]["label"]
test_labels = imdb["test"]["label"]

print(f"train: {len(train_texts)} reviews")
print(f"validation: {len(val_texts)} reviews")
print(f"test: {len(test_texts)} reviews")


# (2) Đếm từ trong mỗi bài đánh giá trên 10.000 từ phổ biến nhất
# của tập huấn luyện. Biểu thức chính quy coi mọi chuỗi chữ cái
# hoặc chữ số là một từ, kể cả từ chỉ gồm một chữ cái như "a".
from sklearn.feature_extraction.text import CountVectorizer

vectorizer = CountVectorizer(max_features=10000,
                             token_pattern=r"\b\w+\b")
X_train = vectorizer.fit_transform(train_texts)
X_val = vectorizer.transform(val_texts)
X_test = vectorizer.transform(test_texts)


# (3) Huấn luyện hồi quy logistic với nhiều giá trị C (nghịch đảo
# cường độ điều chuẩn) và giữ lại mô hình tốt nhất trên tập xác thực
from sklearn.linear_model import LogisticRegression

print()
best_accuracy = 0
for C in [0.01, 0.03, 0.1, 0.3, 1, 3, 10]:
    model = LogisticRegression(C=C, max_iter=1000)
    model.fit(X_train, train_labels)
    accuracy = model.score(X_val, val_labels)
    print(f"C = {C}: validation accuracy {accuracy:.3f}")
    if accuracy > best_accuracy:
        best_accuracy, best_C, best_model = accuracy, C, model


# (4) Đo độ chính xác trên tập kiểm tra của mô hình tốt nhất
test_accuracy = best_model.score(X_test, test_labels)
print(f"\ntest accuracy, C = {best_C}: {test_accuracy:.3f}")


# (5) In ra các từ có trọng số lớn nhất nghiêng về tiêu cực và
# tích cực. np.argsort sắp xếp các trọng số theo thứ tự tăng dần
# và trả về chỉ số vị trí của chúng.
import numpy as np

words = vectorizer.get_feature_names_out()
weights = best_model.coef_[0]   # mỗi từ một trọng số
order = np.argsort(weights)
most_negative = [words[i] for i in order[:10]]
most_positive = [words[i] for i in order[-10:]]
most_positive.reverse()
print("\nnegative:", " ".join(most_negative))
print("positive:", " ".join(most_positive))

train: 20000 reviews
validation: 5000 reviews
test: 25000 reviews

C = 0.01: validation accuracy 0.883
C = 0.03: validation accuracy 0.887
C = 0.1: validation accuracy 0.889
C = 0.3: validation accuracy 0.886
C = 1: validation accuracy 0.875
C = 3: validation accuracy 0.870
C = 10: validation accuracy 0.862

test accuracy, C = 0.1: 0.876

negative: worst waste disappointment awful poorly boring lacks fails avoid mess
positive: 7 8 perfect excellent refreshing wonderfully superb amazing favorite rare

Việc để máy tự học trọng số của các từ từ dữ liệu hiệu quả hơn gấp bội so với việc con người tự chọn từ thủ công, và đây chính là một trong những bài học đầu tiên của bài toán phân loại cảm xúc bằng học máy.

3.3 Đánh trọng số TF-IDF (TF-IDF weighting)

Trong ví dụ vừa rồi, những từ như “a” hay “and” chắc chắn không mang lại nhiều thông tin phân loại, bởi chúng xuất hiện ở khắp mọi nơi: từ “the” có mặt trong 99% số bài đánh giá huấn luyện của IMDB, còn “a” và “and” xuất hiện trong 97% số bài. Ngược lại, từ “boring” chỉ xuất hiện trong 6% số bài đánh giá và chắc chắn mang thông tin rất có giá trị.

Một giải pháp để cải thiện biểu diễn túi từ là giảm trọng số của những từ xuất hiện ở hầu hết mọi tài liệu, đồng thời tăng trọng số cho những từ hiếm gặp hơn. Đó chính là vai trò của nghịch đảo tần suất tài liệu (inverse document frequency — IDF): nhân số lần xuất hiện của mỗi từ với $-\log$ của tỷ lệ các tài liệu có chứa từ đó:

trong đó $N$ là tổng số tài liệu và $N_v$ là số lượng tài liệu có chứa từ $v$. Khi đó, phần tử thứ $v$ trong vector biểu diễn của một tài liệu sẽ trở thành $C_v \times \text{idf}(v)$ — đó là nguồn gốc của cái tên TF-IDF, viết tắt của “term frequency times inverse document frequency” (tần suất từ nhân với nghịch đảo tần suất tài liệu). Nếu dùng logarit cơ số 2, từ “the” sẽ nhận trọng số IDF là 0,01 (gần như bằng 0), từ “boring” nhận trọng số là 4, còn từ “flabbergasting” (chỉ xuất hiện trong 2 trên 25.000 bài đánh giá) sẽ nhận trọng số lên tới 13,6.

Một biến thể đơn giản khác là chỉ giữ lại thông tin về sự hiện diện (presence) của mỗi từ: gán bằng 1 nếu từ đó có mặt trong bài đánh giá, và bằng 0 nếu không. Đây chính là cách biểu diễn cho kết quả tốt nhất trong nghiên cứu của Pang và cộng sự (xem ghi chú bên lề ở mục 3.2). Hãy cùng so sánh ba phương pháp đánh trọng số này trên tập dữ liệu IMDB.

from datasets import load_dataset

imdb = load_dataset("stanfordnlp/imdb")


# (1) Tách 5.000 bài đánh giá huấn luyện làm tập xác thực, và
# thay thế các thẻ xuống dòng HTML bằng khoảng trắng
# [Sao chép từ lời giải bài 3.2, bước (1)]

def clean(texts):
    return [text.replace("<br />", " ") for text in texts]

split = imdb["train"].train_test_split(test_size=5000, seed=0)
train_texts = clean(split["train"]["text"])
val_texts = clean(split["test"]["text"])
test_texts = clean(imdb["test"]["text"])
train_labels = split["train"]["label"]
val_labels = split["test"]["label"]
test_labels = imdb["test"]["label"]

print(f"train: {len(train_texts)} reviews")
print(f"validation: {len(val_texts)} reviews")
print(f"test: {len(test_texts)} reviews")

train: 20000 reviews
validation: 5000 reviews
test: 25000 reviews

counts: C = 0.1, test accuracy 0.876
presence: C = 0.03, test accuracy 0.882
TF-IDF: C = 3, test accuracy 0.884

from datasets import load_dataset

imdb = load_dataset("stanfordnlp/imdb")


# (1) Tách 5.000 bài đánh giá huấn luyện làm tập xác thực, và
# thay thế các thẻ xuống dòng HTML bằng khoảng trắng
# [Sao chép từ lời giải bài 3.2, bước (1)]

def clean(texts):
    return [text.replace("<br />", " ") for text in texts]

split = imdb["train"].train_test_split(test_size=5000, seed=0)
train_texts = clean(split["train"]["text"])
val_texts = clean(split["test"]["text"])
test_texts = clean(imdb["test"]["text"])
train_labels = split["train"]["label"]
val_labels = split["test"]["label"]
test_labels = imdb["test"]["label"]

print(f"train: {len(train_texts)} reviews")
print(f"validation: {len(val_texts)} reviews")
print(f"test: {len(test_texts)} reviews")

train: 20000 reviews
validation: 5000 reviews
test: 25000 reviews

# (1) Ba cách gán trọng số trên 10.000 từ phổ biến nhất
# của các bài đánh giá huấn luyện
from sklearn.feature_extraction.text import CountVectorizer
from sklearn.feature_extraction.text import TfidfVectorizer

V = 10000
pattern = r"\b\w+\b"   # mọi từ, kể cả từ chỉ gồm một chữ cái
vectorizers = {
    "counts": CountVectorizer(max_features=V, token_pattern=pattern),
    "presence": CountVectorizer(max_features=V, token_pattern=pattern,
                                binary=True),
    "TF-IDF": TfidfVectorizer(max_features=V, token_pattern=pattern),
}


# (2) Với mỗi cách gán trọng số, chọn C trên tập xác thực như ở
# bài 3.2, rồi đo độ chính xác trên tập kiểm tra của mô hình tốt nhất
from sklearn.linear_model import LogisticRegression

test_accuracies = {}
for name in vectorizers:
    vectorizer = vectorizers[name]
    X_train = vectorizer.fit_transform(train_texts)
    X_val = vectorizer.transform(val_texts)
    X_test = vectorizer.transform(test_texts)

    best_accuracy = 0
    for C in [0.01, 0.03, 0.1, 0.3, 1, 3, 10]:
        model = LogisticRegression(C=C, max_iter=1000)
        model.fit(X_train, train_labels)
        accuracy = model.score(X_val, val_labels)
        if accuracy > best_accuracy:
            best_accuracy, best_C, best_model = accuracy, C, model

    test_accuracies[name] = best_model.score(X_test, test_labels)
    print(f"{name}: C = {best_C}, "
          f"test accuracy {test_accuracies[name]:.3f}")

counts: C = 0.1, test accuracy 0.876
presence: C = 0.03, test accuracy 0.882
TF-IDF: C = 3, test accuracy 0.884

Những con số này rất điển hình đối với mô hình túi từ trên tập dữ liệu IMDB: bài báo gốc giới thiệu bộ dữ liệu này cũng báo cáo mức 87,8% khi sử dụng đặc trưng hiện diện của từ (Maas et al., 2011). Một mô hình cơ sở (baseline) rất mạnh dựa trên túi từ của Wang và Manning từng đạt tới 91,2% (Wang & Manning, 2012). Mô hình đó bổ sung thêm cả các cặp từ liên tiếp (bigram) vào bộ từ vựng — nhờ vậy cụm “not good” trở thành một mục từ độc lập — đồng thời kết hợp bộ phân loại Naive Bayes với SVM. Việc đưa thêm các cặp từ giúp khôi phục lại một phần nhỏ thông tin về trật tự từ, và trật tự từ chính là mảnh ghép quan trọng mà mô hình túi từ đang đánh mất.

3.4 Giới hạn của phương pháp

Hãy xét hai câu đánh giá ngắn sau đây:

A: Excellent movie, awesome soundtrack. (Phim xuất sắc, nhạc phim tuyệt đỉnh.)

B: Superb film, wonderful score. (Tác phẩm điện ảnh siêu phàm, phần âm nhạc tuyệt diệu.)

Cả hai câu về cơ bản đều diễn đạt cùng một ý khen ngợi, nhưng lại sử dụng những từ hoàn toàn khác nhau. Do đó, trong không gian túi từ, chúng nhận hai vector biểu diễn hoàn toàn trực giao (vuông góc) với nhau: không có bất kỳ vị trí nào cùng khác 0 ở cả hai vector.

Đối với mô hình túi từ, từ “superb” (siêu phàm) khác biệt với từ “excellent” (xuất sắc) chẳng kém gì sự khác biệt giữa nó với từ “boring” (nhàm chán). Biểu diễn túi từ không hề hỗ trợ gì cho đầu phân loại: đầu phân loại buộc phải tự học trọng số của từng từ một cách hoàn toàn tách biệt, chỉ dựa vào những bài đánh giá đã gán nhãn có chứa chính từ đó. Với một từ phổ biến như “excellent” (xuất hiện trong 1.780 bài đánh giá huấn luyện), cách này hoạt động ổn thỏa. Thế nhưng một từ hiếm hơn như “mesmerizing” (mê hoặc — chỉ có trong 62 bài đánh giá) sẽ phải học trọng số từ vỏn vẹn vài chục ví dụ ít ỏi, còn một từ nằm ngoài bộ từ vựng như “flabbergasting” thì thậm chí chẳng có lấy một trọng số nào.

Giới hạn thứ hai nằm ngay ở tên gọi của phương pháp: túi từ quên sạch trật tự của các từ. Hai câu đánh giá dưới đây chứa các từ giống hệt nhau, dẫn đến hai vector biểu diễn giống hệt nhau, và vì thế mô hình buộc phải gán cho chúng cùng một xác suất như nhau:

A: I expected it to be terrible, but it was great. (Tôi cứ tưởng phim sẽ dở tệ, nhưng hóa ra lại rất hay.)

B: I expected it to be great, but it was terrible. (Tôi cứ tưởng phim sẽ rất hay, nhưng hóa ra lại dở tệ.)

Điều tương tự cũng xảy ra với cấu trúc phủ định. Trong cụm “not bad at all” (không tệ chút nào), mô hình chỉ nhìn thấy các từ rời rạc “not”, “bad”, “at” và “all”, trong đó từ “bad” mang trọng số âm rất nặng. Còn sự mỉa mai (sarcasm) lại càng đánh lừa mô hình thê thảm hơn, bởi người viết cố tình dùng toàn những từ tích cực để diễn đạt một ý chê bai.

Để theo dõi xem các mô hình tiếp theo vượt qua những giới hạn này như thế nào xuyên suốt bài viết, tôi đã biên soạn một tập nhỏ gồm các bài đánh giá khó (hard reviews). Chúng đều là những câu ngắn gọn mà bất kỳ độc giả con người nào cũng nhận ra ngay sắc thái khen chê. Các câu này được nhóm theo từng loại thử thách: phủ định (negation), tương phản (contrast), mỉa mai (sarcasm), trật tự từ (word order), từ đồng nghĩa (synonyms) và từ hiếm (rare words). Chúng ta sẽ cho mọi mô hình phân loại IMDB trong bài viết chạy thử trên tập câu khó này, bắt đầu ngay với mô hình túi từ vừa xây dựng.

from datasets import load_dataset

imdb = load_dataset("stanfordnlp/imdb")


# (1) Tách 5.000 bài đánh giá huấn luyện làm tập xác thực, và
# thay thế các thẻ xuống dòng HTML bằng khoảng trắng
# [Sao chép từ lời giải bài 3.2, bước (1)]

def clean(texts):
    return [text.replace("<br />", " ") for text in texts]

split = imdb["train"].train_test_split(test_size=5000, seed=0)
train_texts = clean(split["train"]["text"])
val_texts = clean(split["test"]["text"])
test_texts = clean(imdb["test"]["text"])
train_labels = split["train"]["label"]
val_labels = split["test"]["label"]
test_labels = imdb["test"]["label"]

print(f"train: {len(train_texts)} reviews")
print(f"validation: {len(val_texts)} reviews")
print(f"test: {len(test_texts)} reviews")


# (2) Đếm từ trong mỗi bài đánh giá trên 10.000 từ phổ biến nhất
# của tập huấn luyện. Biểu thức chính quy coi mọi chuỗi chữ cái
# hoặc chữ số là một từ, kể cả từ chỉ gồm một chữ cái như "a".
# [Sao chép từ lời giải bài 3.2, bước (2)]
from sklearn.feature_extraction.text import CountVectorizer

vectorizer = CountVectorizer(max_features=10000,
                             token_pattern=r"\b\w+\b")
X_train = vectorizer.fit_transform(train_texts)
X_val = vectorizer.transform(val_texts)
X_test = vectorizer.transform(test_texts)


# -------------------------
#  Phần mới trong bài này
# -------------------------
# Mô hình hồi quy logistic của bài 3.2 với C = 0.1, giá trị đã
# được chọn trên tập xác thực
from sklearn.linear_model import LogisticRegression

model = LogisticRegression(C=0.1, max_iter=1000)
model.fit(X_train, train_labels)

# Các bài đánh giá khó: (bài đánh giá, nhãn), với 1 là tích cực
hard_reviews = [
    # Phủ định
    ("Not bad at all, actually.", 1),
    ("Nothing about this movie is good.", 0),
    ("I wouldn't call it a masterpiece, but I didn't regret "
     "a minute.", 1),
    # Tương phản
    ("Great acting, great lighting and a flabbergasting soundtrack, "
     "but not even Zendaya could save this boring, boring plot.", 0),
    ("The first hour is slow and the dialogue is clumsy, but the "
     "ending makes it all worth it.", 1),
    ("Everyone told me it would be the film of the year: great "
     "cast, amazing trailer, brilliant director. What a "
     "disappointment.", 0),
    # Mỉa mai / Châm biếm
    ("Wow, what a masterpiece. Two hours of pure brilliance, and I "
     "only checked my watch twenty times. The acting was so "
     "convincing that I truly believed the actors wanted to be "
     "somewhere else. A perfect film if you love naps.", 0),
    ("Brilliant. Another sequel nobody asked for, with the same "
     "jokes as the first one.", 0),
    # Cùng các từ nhưng khác thứ tự
    ("I expected it to be terrible, but it was great.", 1),
    ("I expected it to be great, but it was terrible.", 0),
    # Từ đồng nghĩa, không có từ chung
    ("Excellent movie, awesome soundtrack.", 1),
    ("Superb film, wonderful score.", 1),
    # Từ hiếm gặp
    ("A flabbergasting, mesmerizing tour de force.", 1),
]

print(f"{len(hard_reviews)} hard reviews")

train: 20000 reviews
validation: 5000 reviews
test: 25000 reviews
13 hard reviews

label     p(positive)  right  review
positive  0.335        NO     Not bad at all, actually.
negative  0.423        yes    Nothing about this movie is good.
positive  0.470        NO     I wouldn't call it a masterpiece, b…
negative  0.109        yes    Great acting, great lighting and a …
positive  0.513        yes    The first hour is slow and the dial…
negative  0.685        NO     Everyone told me it would be the fi…
negative  0.761        NO     Wow, what a masterpiece. Two hours …
negative  0.598        NO     Brilliant. Another sequel nobody as…
positive  0.495        NO     I expected it to be terrible, but i…
negative  0.495        yes    I expected it to be great, but it w…
positive  0.779        yes    Excellent movie, awesome soundtrack.
positive  0.810        yes    Superb film, wonderful score.
positive  0.521        yes    A flabbergasting, mesmerizing tour …

7 right out of 13

from datasets import load_dataset

imdb = load_dataset("stanfordnlp/imdb")


# (1) Tách 5.000 bài đánh giá huấn luyện làm tập xác thực, và
# thay thế các thẻ xuống dòng HTML bằng khoảng trắng
# [Sao chép từ lời giải bài 3.2, bước (1)]

def clean(texts):
    return [text.replace("<br />", " ") for text in texts]

split = imdb["train"].train_test_split(test_size=5000, seed=0)
train_texts = clean(split["train"]["text"])
val_texts = clean(split["test"]["text"])
test_texts = clean(imdb["test"]["text"])
train_labels = split["train"]["label"]
val_labels = split["test"]["label"]
test_labels = imdb["test"]["label"]

print(f"train: {len(train_texts)} reviews")
print(f"validation: {len(val_texts)} reviews")
print(f"test: {len(test_texts)} reviews")


# (2) Đếm từ trong mỗi bài đánh giá trên 10.000 từ phổ biến nhất
# của tập huấn luyện. Biểu thức chính quy coi mọi chuỗi chữ cái
# hoặc chữ số là một từ, kể cả từ chỉ gồm một chữ cái như "a".
# [Sao chép từ lời giải bài 3.2, bước (2)]
from sklearn.feature_extraction.text import CountVectorizer

vectorizer = CountVectorizer(max_features=10000,
                             token_pattern=r"\b\w+\b")
X_train = vectorizer.fit_transform(train_texts)
X_val = vectorizer.transform(val_texts)
X_test = vectorizer.transform(test_texts)


# -------------------------
#  Phần mới trong bài này
# -------------------------
# Mô hình hồi quy logistic của bài 3.2 với C = 0.1, giá trị đã
# được chọn trên tập xác thực
from sklearn.linear_model import LogisticRegression

model = LogisticRegression(C=0.1, max_iter=1000)
model.fit(X_train, train_labels)

# Các bài đánh giá khó: (bài đánh giá, nhãn), với 1 là tích cực
hard_reviews = [
    # Phủ định
    ("Not bad at all, actually.", 1),
    ("Nothing about this movie is good.", 0),
    ("I wouldn't call it a masterpiece, but I didn't regret "
     "a minute.", 1),
    # Tương phản
    ("Great acting, great lighting and a flabbergasting soundtrack, "
     "but not even Zendaya could save this boring, boring plot.", 0),
    ("The first hour is slow and the dialogue is clumsy, but the "
     "ending makes it all worth it.", 1),
    ("Everyone told me it would be the film of the year: great "
     "cast, amazing trailer, brilliant director. What a "
     "disappointment.", 0),
    # Mỉa mai / Châm biếm
    ("Wow, what a masterpiece. Two hours of pure brilliance, and I "
     "only checked my watch twenty times. The acting was so "
     "convincing that I truly believed the actors wanted to be "
     "somewhere else. A perfect film if you love naps.", 0),
    ("Brilliant. Another sequel nobody asked for, with the same "
     "jokes as the first one.", 0),
    # Cùng các từ nhưng khác thứ tự
    ("I expected it to be terrible, but it was great.", 1),
    ("I expected it to be great, but it was terrible.", 0),
    # Từ đồng nghĩa, không có từ chung
    ("Excellent movie, awesome soundtrack.", 1),
    ("Superb film, wonderful score.", 1),
    # Từ hiếm gặp
    ("A flabbergasting, mesmerizing tour de force.", 1),
]

print(f"{len(hard_reviews)} hard reviews")

train: 20000 reviews
validation: 5000 reviews
test: 25000 reviews
13 hard reviews

# (1) Đếm các từ của những bài đánh giá khó trên từ vựng của
# mô hình, và tính xác suất để chúng thuộc lớp tích cực
hard_texts = [review for review, label in hard_reviews]
X_hard = vectorizer.transform(hard_texts)
probabilities = model.predict_proba(X_hard)
p_positive = probabilities[:, 1]   # cột 0: tiêu cực, 1: tích cực


# (2) In bảng kết quả: mô hình đoán đúng khi gán xác suất lớn hơn
# 0.5 cho nhãn thực tế của bài đánh giá
names = ["negative", "positive"]
print("label     p(positive)  right  review")
right_count = 0
for (review, label), p in zip(hard_reviews, p_positive):
    right = (p > 0.5) == (label == 1)
    if right:
        right_count += 1
    mark = "yes" if right else "NO"
    short = review if len(review) <= 36 else review[:35] + "…"
    print(f"{names[label]:9} {p:.3f}        {mark:5}  {short}")
print(f"\n{right_count} right out of {len(hard_reviews)}")

label     p(positive)  right  review
positive  0.335        NO     Not bad at all, actually.
negative  0.423        yes    Nothing about this movie is good.
positive  0.470        NO     I wouldn't call it a masterpiece, b…
negative  0.109        yes    Great acting, great lighting and a …
positive  0.513        yes    The first hour is slow and the dial…
negative  0.685        NO     Everyone told me it would be the fi…
negative  0.761        NO     Wow, what a masterpiece. Two hours …
negative  0.598        NO     Brilliant. Another sequel nobody as…
positive  0.495        NO     I expected it to be terrible, but i…
negative  0.495        yes    I expected it to be great, but it w…
positive  0.779        yes    Excellent movie, awesome soundtrack.
positive  0.810        yes    Superb film, wonderful score.
positive  0.521        yes    A flabbergasting, mesmerizing tour …

7 right out of 13

Làm sao chúng ta có thể làm tốt hơn? Để giải quyết giới hạn đầu tiên, ta cần một cách biểu diễn sao cho những từ có nghĩa tương tự nhau sẽ nhận được các vector gần giống nhau — nhờ đó những gì mô hình học được từ chữ “excellent” cũng sẽ tự động giúp ích khi nó gặp chữ “superb”, và thậm chí giúp ích cho cả những từ hiếm khi xuất hiện. Đó chính là chủ đề của mục tiếp theo. Còn đối với bài toán trật tự từ, chúng ta sẽ phải đợi đến mục 7.

Nếu bạn muốn đào sâu hơn, dưới đây là một số bài tập mở rộng.

4. Biểu diễn nhúng từ đặc (Dense word embeddings)

Ở cuối mục 3, chúng ta đã thấy giới hạn đầu tiên của mô hình túi từ: mỗi từ chiếm một chiều không gian riêng biệt, nên đối với mô hình, từ “superb” (siêu phàm) khác biệt với từ “excellent” (xuất sắc) chẳng kém gì so với từ “boring” (nhàm chán). Hãy cùng khắc phục nhược điểm này.

4.1 Ma trận nhúng (The embedding matrix)

Ý tưởng cốt lõi ở đây là biểu diễn mỗi từ bằng một vector đặc (dense vector) gồm các số thực, nằm trong một không gian có số chiều $D$ nhỏ hơn rất nhiều so với kích thước $V$ của bộ từ vựng: chỉ vài trăm chiều (chẳng hạn $D = 300$) cho hàng chục nghìn từ. Vector này được gọi là biểu diễn nhúng (embedding) của từ đó.

Biểu diễn nhúng của toàn bộ các từ trong từ vựng được lưu trữ chung trong một ma trận nhúng (embedding matrix) $W$, với mỗi cột tương ứng với một từ:

Việc tra cứu vector nhúng của một từ về mặt toán học hoàn toàn tương đương với việc nhân ma trận $W$ với vector one-hot của từ đó: phép nhân ma trận này sẽ trích xuất ra đúng cột tương ứng với từ đang xét.

Lợi thế to lớn của các biểu diễn nhúng đặc so với các vector thưa của túi từ là chúng ta có thể so sánh trực tiếp chúng với nhau và đo lường mức độ tương đồng giữa hai từ bất kỳ. Thước đo tiêu chuẩn thường dùng là độ tương đồng cosine (cosine similarity) — tức cosine của góc hợp bởi hai vector, một đại lượng chỉ phụ thuộc vào hướng chứ không phụ thuộc vào độ dài của chúng:

Độ tương đồng cosine bằng $1$ khi hai vector cùng hướng, bằng $0$ khi chúng trực giao (vuông góc), và bằng $-1$ khi chúng ngược hướng nhau hoàn toàn. Lưu ý rằng các vector one-hot của hai từ khác nhau thì luôn luôn vuông góc: trong không gian túi từ, độ tương đồng giữa hai từ khác nhau bất kỳ luôn bằng 0.

Tạm thời hãy giả sử rằng chúng ta đã có sẵn một ma trận nhúng tốt (chúng ta sẽ sớm thấy cách tạo ra nó, và như bạn có thể đoán được, ta sẽ để máy tự học ma trận này). Khi đó, ta có quyền kỳ vọng rằng những từ có nghĩa gần nhau sẽ nhận được các vector gần nhau: độ tương đồng rất cao giữa “excellent” (xuất sắc) và “superb” (siêu phàm), nhưng lại rất thấp giữa “ball” (quả bóng) và “crocodile” (cá sấu). Đó chính là phẩm chất làm nên một biểu diễn nhúng tốt: độ tương đồng hình học giữa các vector phản ánh độ tương đồng ngữ nghĩa giữa các từ. Nhờ vậy, một mô hình đã học được điều gì đó về từ “excellent” thì nghiễm nhiên cũng hiểu được phần nào về từ “superb”.

Tuy nhiên, việc chỉ thay từng từ bằng vector nhúng vẫn chưa giải quyết được bài toán độ dài đầu vào biến thiên. Khi thay thế $L$ từ của một văn bản bằng $L$ vector có kích thước $D$, thứ ta thu được vẫn chưa phải là một biểu diễn có kích thước cố định! Do đó, chúng ta cần một phép tổng hợp (aggregation / pooling) để gộp $L$ vector này lại thành một vector duy nhất có kích thước không phụ thuộc vào $L$. Dưới đây là ba lựa chọn đơn giản:

• lấy trung bình cộng (average) của $L$ vector, thu được một vector kích thước $D$;
• lấy trung bình có trọng số (weighted average) để ưu tiên một số từ quan trọng hơn, cũng cho ra kích thước $D$;
• ghép nối (concatenation) các vector của $n - 1$ từ cuối cùng lại với nhau, thu được một vector có kích thước $(n - 1) \times D$, tương tự như cách mô hình n-gram ở mục 2 chỉ giữ lại $n - 1$ từ cuối.

Phép ghép nối giữ nguyên được trật tự của những từ cuối cùng, nhưng lại bỏ quên toàn bộ phần văn bản đứng trước đó. Đặc điểm này rất phù hợp với bài toán mô hình hóa ngôn ngữ — nơi từ tiếp theo phụ thuộc chủ yếu vào vài từ ngay trước nó — vì vậy chúng ta sẽ bắt đầu từ phương pháp này.

4.2 Ghép nối (Concatenation) → Mô hình ngôn ngữ nơ-ron của Bengio

Hãy quay lại với bài toán mô hình hóa ngôn ngữ một lát. Ở các mô hình n-gram trong mục 2, chúng ta đã giả định rằng xác suất của từ tiếp theo chỉ phụ thuộc vào $n - 1$ từ đứng ngay trước nó. Bây giờ, ta vẫn giữ nguyên giả định Markov này, nhưng thay thế bảng đếm tần số bằng một mạng nơ-ron nhận đầu vào là vector ghép nối của các biểu diễn nhúng của $n - 1$ từ đứng trước: một vector có kích thước cố định bằng $(n - 1) \times D$.

Đây chính là ý tưởng cốt lõi trong bài báo có tầm ảnh hưởng sâu rộng của Bengio và cộng sự năm 2003, công trình được xem là mô hình ngôn ngữ nơ-ron đầu tiên trong lịch sử. Kiến trúc của nó rất sáng sủa: tra cứu các vector nhúng $e_{L-n+2}, \dots, e_L$ của $n - 1$ từ cuối cùng trong ma trận $W$, ghép nối chúng lại thành một vector ngữ cảnh duy nhất $c$, rồi đưa $c$ đi qua một mạng truyền thẳng (feedforward network) có một tầng ẩn:

trong đó $A$ và $b$ là ma trận trọng số và vector độ chệch (bias) của tầng ẩn, còn $U$ và $d$ là trọng số và độ chệch của tầng đầu ra. Tầng đầu ra tính một điểm số (logit) $z_v$ cho mỗi từ $v$ trong bộ từ vựng, và hàm softmax, $\text{softmax}(z)_v = e^{z_v} / \sum_{w} e^{z_w}$, chuyển đổi $V$ điểm số này thành một phân phối xác suất hợp lệ (các giá trị đều dương và có tổng bằng 1), đóng vai trò tương tự như hàm sigmoid ở mục 3.2 nhưng mở rộng cho $V$ lớp thay vì hai lớp.

Ma trận nhúng $W$ cũng là một tham số của mô hình giống hệt như $A$, $b$, $U$ và $d$: các biểu diễn nhúng từ và các trọng số của mạng nơ-ron được học đồng thời cùng nhau (jointly learned) bằng cách cực tiểu hóa hàm mất mát entropy chéo ở mục 2.2 trên văn bản huấn luyện. Ở mỗi bước cập nhật, đạo hàm (gradient) của hàm mất mát được lan truyền ngược (backpropagation) xuyên qua mạng nơ-ron về tới tận các cột của ma trận $W$ ứng với các từ trong ngữ cảnh, qua đó dịch chuyển dần vị trí của các vector nhúng này trong không gian.

Ở đây tôi giả định rằng bạn đã biết cách huấn luyện một mạng nơ-ron cơ bản với thư viện PyTorch. Nếu chưa quen, khóa học của Andrej Karpathy là một điểm khởi đầu tuyệt vời — bài giảng thứ ba trong chuỗi đó xây dựng chính xác một mô hình kiểu này ở cấp độ ký tự.

optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
for epoch in range(n_epochs):
    order = torch.randperm(len(targets))  # xáo trộn thứ tự các mẫu huấn luyện
    for start in range(0, len(order), batch_size):
        batch = order[start:start + batch_size]
        scores = model(inputs[batch])
        loss = F.cross_entropy(scores, targets[batch])
        optimizer.zero_grad()
        loss.backward()   # tính đạo hàm ngược (gradients)
        optimizer.step()  # cập nhật các tham số mô hình

Tại sao kiến trúc này lại hoạt động hiệu quả hơn phương pháp đếm? Hãy nhớ lại lời nguyền số chiều ở mục 2.3: hầu hết các ngữ cảnh dài 3 hoặc 4 từ chưa từng xuất hiện trong văn bản huấn luyện, và đối với phương pháp đếm, gặp một ngữ cảnh mới đồng nghĩa với việc đi vào ngõ cụt. Ngược lại, mô hình nơ-ron không hề bị bó tay: nếu nó từng nhìn thấy cụm “the cat is walking”, và nếu từ “dog” có vector nhúng nằm gần vector nhúng của từ “cat”, thì mạng nơ-ron nghiễm nhiên đã biết cách xử lý cụm “the dog is walking”. Và quả thực, những từ tương tự nhau sẽ tự động hội tụ về các vector nhúng gần nhau, bởi chúng thường xuất hiện trong các ngữ cảnh giống nhau và đòi hỏi mô hình đưa ra các phân phối dự đoán tương tự nhau. Mô hình có khả năng khái quát hóa từ những ngữ cảnh đã từng gặp sang những ngữ cảnh hoàn toàn mới chưa từng thấy bao giờ.

Hãy huấn luyện mô hình này trên tập dữ liệu WikiText-2 và so sánh trực tiếp với các mô hình n-gram ở mục 2. Vì mạng nơ-ron này có số lượng tham số lớn hơn rất nhiều so với mô hình hồi quy logistic ở mục 3 và bắt đầu bị quá khớp (overfit) chỉ sau vài epoch, chúng ta sẽ theo dõi và chọn số epoch tối ưu dựa trên tập xác thực.

from datasets import load_dataset

wikitext = load_dataset("Salesforce/wikitext", "wikitext-2-v1")


# (1) Tạo chuỗi huấn luyện bằng cách tách từ ở mỗi dòng theo dấu cách
# [Sao chép từ lời giải bài 2.1, bước (1)]
train_sequence = []
for line in wikitext["train"]["text"]:
    train_sequence.extend(line.split())

print(f"text: {len(train_sequence)} words")
print(f"vocabulary: {len(set(train_sequence))} words")


# Chuỗi xác thực (validation) và kiểm tra (test), tạo tương tự
# [Sao chép từ mã khởi đầu bài 2.2]
val_sequence = []
for line in wikitext["validation"]["text"]:
    val_sequence.extend(line.split())

test_sequence = []
for line in wikitext["test"]["text"]:
    test_sequence.extend(line.split())

print(f"validation: {len(val_sequence)} words")
print(f"test: {len(test_sequence)} words")


# -------------------------
#  Phần mới trong bài này
# -------------------------
# Gán một chỉ số (index) cho mỗi từ trong từ vựng
vocabulary = sorted(set(train_sequence))
word_index = {word: i for i, word in enumerate(vocabulary)}

# Chuyển chuỗi từ thành các cặp chỉ số (ngữ cảnh, từ tiếp theo):
# hàng i của contexts chứa 3 từ đứng trước từ targets[i]
import torch

context_size = 3

def make_pairs(sequence):
    indices = [word_index[word] for word in sequence]
    contexts = [indices[i - context_size:i]
                for i in range(context_size, len(indices))]
    targets = indices[context_size:]
    return torch.tensor(contexts), torch.tensor(targets)

train_contexts, train_targets = make_pairs(train_sequence)
val_contexts, val_targets = make_pairs(val_sequence)
test_contexts, test_targets = make_pairs(test_sequence)

print(f"train: {len(train_targets)} pairs")
context = [vocabulary[i] for i in train_contexts[30].tolist()]
print(f"example: {context} -> {vocabulary[train_targets[30]]}")