One-Hot trong Word Embedding: Từ chỉ mục đến vector từ

Chuyển đổi từ vựng thành vector nhị phân thông qua kỹ thuật One-Hot Encoding

Khi học biểu diễn nhúng từ (word embedding), one-hot thường xuất hiện ở bước đầu tiên nhưng cũng là phần dễ gây nhầm lẫn nhất. One-hot không phải là vector ngữ nghĩa cuối cùng của từ; nó chỉ giúp mô hình xác định chính xác từ nào đang được xử lý.

Bài viết sử dụng một ví dụ nhỏ với các từ cat, dog, eats, fish, meat để phân tích toàn bộ quá trình: từ điển → one-hot → ma trận nhúng → vector ngữ cảnh → dự đoán → sai số → lan truyền ngược → cập nhật embedding.

Tóm tắt nội dung

One-hot chỉ xác định danh tính của từ, không biểu diễn ý nghĩa của từ.

Phép nhân giữa ma trận embedding và one-hot thực chất là chọn đúng vector tương ứng với từ.

Vector chỉ mang thông tin hữu ích sau khi được cập nhật qua quá trình huấn luyện và lan truyền ngược.

One-hot không tạo embedding; nó chọn vector tương ứng trong ma trận đang được học.

1. One-hot thực sự biểu diễn điều gì?

Giả sử tập từ vựng có V từ. Mỗi từ được gán một chỉ số duy nhất từ 0 đến V−1. Biểu diễn one-hot là một vector có V phần tử, trong đó chỉ có đúng một phần tử bằng 1 tại vị trí của từ và các phần tử còn lại bằng 0.

Với từ điển:

cat  = [1, 0, 0, 0, 0]
dog  = [0, 1, 0, 0, 0]
eats = [0, 0, 1, 0, 0]
fish = [0, 0, 0, 1, 0]
meat = [0, 0, 0, 0, 1]

Các vector này giúp phân biệt từ một cách tuyệt đối nhưng không chứa quan hệ ngữ nghĩa. Theo biểu diễn one-hot, cat không gần dog hơn so với cat và eats. Mọi cặp từ khác nhau đều trực giao với nhau.

Cần phân biệt: one-hot là biểu diễn danh tính của từ, còn word embedding là biểu diễn số thực có thể học. Nói “one-hot biến thành embedding” chỉ là cách nói rút gọn; chính xác hơn, one-hot được dùng để truy xuất vector từ một ma trận tham số.

2. Vì sao nhân one-hot với ma trận lại lấy được vector từ?

Giả sử ta muốn mỗi từ được biểu diễn bằng vector hai chiều. Khi đó có thể xây dựng ma trận W kích thước 2 × 5:

W =
[0.1  0.2  0.8  0.5  0.6]
[0.3  0.4  0.9  0.1  0.2]

Theo quy ước này, mỗi cột của W tương ứng với một từ. Cột thứ nhất dành cho cat, cột thứ hai dành cho dog và cứ tiếp tục như vậy.

v_i = W x_i = W[:, i]

Nếu x_i là one-hot của cat:

x_cat = [1, 0, 0, 0, 0]^T
W x_cat = [0.1, 0.3]^T

Nguyên nhân rất đơn giản: cột đầu tiên được nhân với 1, còn mọi cột khác được nhân với 0. Vì vậy phép nhân với one-hot thực chất là một phép chọn cột.

Python · One-hot và embedding

import numpy as np

vocab = ["cat", "dog", "eats", "fish", "meat"]

word2idx = {
word: i for i, word in enumerate(vocab)
}

V = len(vocab)

W = np.array([
[0.1, 0.2, 0.8, 0.5, 0.6],
[0.3, 0.4, 0.9, 0.1, 0.2]
])

def get_one_hot(word_idx, vocab_size):
x = np.zeros((vocab_size, 1))
x[word_idx] = 1.0 return x

x_cat = get_one_hot(word2idx["cat"], V)

# Phép nhân này chọn cột tương ứng với cat
v_cat = W @ x_cat

print(x_cat.T) print(v_cat.T)

Kết quả:

[[1. 0. 0. 0. 0.]]
[[0.1 0.3]]

Trong hệ thống thực tế, việc tạo một vector one-hot lớn như vậy thường không cần thiết. Nếu từ điển có 100.000 từ thì one-hot sẽ có 100.000 phần tử nhưng chỉ chứa một giá trị 1. Các thư viện học sâu vì vậy thường nhận trực tiếp chỉ số từ và thực hiện phép tra cứu embedding.

3. One-hot tham gia mô hình CBOW như thế nào?

Trong CBOW (Continuous Bag of Words), mô hình sử dụng các từ xung quanh để dự đoán từ ở giữa. Xét câu:

cat → eats ← fish

Ta dùng cat và fish làm ngữ cảnh, còn eats là từ cần dự đoán.

Từ W:

v_cat = [0.1, 0.3]^T
v_fish = [0.5, 0.1]^T

CBOW thường kết hợp các vector ngữ cảnh bằng trung bình:

h = (v_cat + v_fish) / 2 = [0.3, 0.2]^T

Vector h đại diện cho ngữ cảnh hiện tại. Sau đó một ma trận đầu ra W′ biến h thành điểm số cho từng từ trong từ điển:

z = W′h

Hàm softmax chuyển các điểm số này thành phân phối xác suất:

P(w_i | context) = exp(z_i) / Σ exp(z_j)

Nếu mô hình dự đoán đúng, xác suất của eats phải lớn hơn các từ còn lại. Tuy nhiên ở giai đoạn đầu, các ma trận mới chỉ chứa trọng số khởi tạo nên dự đoán thường chưa tốt.

4. Word embedding thực sự được học ở đâu?

Đây là bước quan trọng nhất. Vector embedding không trở nên có nghĩa vì ta dùng one-hot. Nó trở nên hữu ích vì các trọng số trong W được điều chỉnh để giảm lỗi dự đoán.

Với từ mục tiêu eats, nhãn one-hot là:

y = [0, 0, 1, 0, 0]^T

Khi dùng softmax kết hợp với mất mát entropy chéo (cross-entropy loss), gradient tại đầu ra có dạng:

e = ŷ − y

Trong đó ŷ là phân phối xác suất dự đoán. Sai số được truyền ngược qua W′ về vector ngữ cảnh h:

∂L/∂h = W′^T(ŷ − y)

Vì h được tạo từ vector cat và fish, gradient tiếp tục truyền về đúng các vector này trong W. Sau mỗi bước học:

W ← W − η ∂L/∂W

η là tốc độ học. Việc lặp đi lặp lại quá trình này trên nhiều câu và nhiều ngữ cảnh làm cho các vector được sắp xếp lại trong không gian embedding.

Kết luận quan trọng: one-hot chỉ xác định vector nào cần đọc hoặc cập nhật. Thông tin ngữ nghĩa hình thành từ tín hiệu lỗi của nhiệm vụ huấn luyện.

Python · Một bước huấn luyện CBOW

import numpy as np

context_idxs = [
word2idx["cat"],
word2idx["fish"]
]

target_idx = word2idx["eats"]

d = W.shape[0]
h = np.zeros((d, 1))

# Lấy embedding của các từ ngữ cảnh for idx in context_idxs:
h += W[:, idx:idx + 1]

h /= len(context_idxs)

# Lan truyền tiến
z = W_prime @ h

# Softmax ổn định số học
z = z - np.max(z)
exp_z = np.exp(z)
y_pred = exp_z / np.sum(exp_z)

# Tạo nhãn one-hot
y_true = np.zeros((V, 1))
y_true[target_idx] = 1.0

# Gradient đầu ra
error = y_pred - y_true

grad_W_prime = error @ h.T
grad_h = W_prime.T @ error

learning_rate = 0.05

# Cập nhật ma trận đầu ra
W_prime -= learning_rate * grad_W_prime

# Cập nhật embedding của các từ ngữ cảnh for idx in context_idxs:
W[:, idx:idx + 1] -= (
learning_rate
* grad_h
/ len(context_idxs)
)

Trong đoạn mã trên, chỉ các cột tương ứng với cat và fish được cập nhật ở bước hiện tại. Đây chính là ý nghĩa tính toán của one-hot: nó giúp xác định phần nào trong ma trận embedding liên quan tới mẫu huấn luyện.

5. Tại sao các từ có ngữ cảnh giống nhau lại có embedding gần nhau?

Giả sử dữ liệu chứa nhiều cấu trúc tương tự:

• cat eats fish
• dog eats meat

Trong nhiều bước học, cat và dog thường tham gia vào những nhiệm vụ dự đoán tương tự. Gradient tác động lên hai vector này theo những hướng gần nhau. Kết quả là chúng có thể dần nằm gần nhau trong không gian embedding.

Một cách thường dùng để đo mức độ gần về hướng là độ tương đồng cosin (cosine similarity):

cos(a,b) = (a · b) / (||a|| ||b||)

Giá trị gần 1 cho biết hai vector có hướng gần nhau; gần 0 cho biết chúng gần vuông góc; giá trị âm biểu thị hướng đối lập. Tuy nhiên không nên đồng nhất độ tương đồng cosin cao với “hai từ chắc chắn cùng nghĩa”. Embedding phản ánh cấu trúc mà nhiệm vụ huấn luyện và dữ liệu tạo ra.

Cần thận trọng với ví dụ dữ liệu nhỏ: nếu chỉ huấn luyện trên vài câu, cat và dog có thể có cosine gần 1 chỉ vì chúng giữ vai trò gần như giống nhau trong những mẫu đó. Điều này chưa chứng minh mô hình đã học được ngữ nghĩa ngôn ngữ tổng quát.

6. One-hot và word embedding khác nhau ở đâu?

Thuộc tính	One-hot	Word embedding
Số chiều	Bằng kích thước từ điển	Thường nhỏ hơn nhiều
Giá trị	Chỉ gồm 0 và 1	Các số thực được học
Mật độ	Vector thưa	Vector dày đặc
Ngữ nghĩa	Không thể hiện trực tiếp	Có thể phản ánh quan hệ từ dữ liệu
Có được huấn luyện?	Không	Có
Vai trò chính	Xác định từ hoặc lớp	Biểu diễn đặc trưng của từ

Có thể hình dung one-hot giống như số hiệu của một ngăn kéo. Nó chỉ cho mô hình biết cần mở ngăn nào. Embedding chính là nội dung nằm trong ngăn kéo đó, và nội dung này được thay đổi trong quá trình học.

7. Trong thực tế có cần tạo one-hot hay không?

Về mặt toán học, one-hot rất hữu ích vì nó giúp giải thích rõ phép ánh xạ từ một từ rời rạc sang vector liên tục. Nhưng khi lập trình mô hình thực tế, người ta thường không tạo one-hot đầu vào.

Ví dụ, nếu cat có chỉ số 0, hai biểu thức sau về bản chất cho cùng một kết quả:

W @ one_hot_cat
W[:, 0]

Biểu thức thứ hai nhanh và tiết kiệm bộ nhớ hơn. Đó là nguyên lý của các lớp embedding trong PyTorch, TensorFlow và nhiều thư viện học sâu khác: đầu vào là chỉ số nguyên, còn hệ thống tự truy xuất vector tương ứng.

Tương tự, ở đầu ra cũng không phải lúc nào cần tạo nhãn one-hot đầy đủ. Các hàm mất mát phân loại hiện đại thường có thể nhận trực tiếp chỉ số của lớp đúng. Với từ điển rất lớn, các kỹ thuật như lấy mẫu âm (negative sampling) còn tránh phải tính xác suất trên toàn bộ tập từ.

Luồng xử lý cần ghi nhớ

Từ → Chỉ số → One-hot → Chọn vector trong W → Dự đoán → Tính lỗi → Gradient → Cập nhật embedding

Điều quan trọng nhất là không nhầm lẫn giữa mã hóa danh tính và biểu diễn ngữ nghĩa. One-hot chỉ trả lời câu hỏi “đây là từ nào?”, trong khi embedding cố gắng học câu trả lời cho câu hỏi “từ này có quan hệ như thế nào với các từ khác trong nhiệm vụ hiện tại?”.

Kết luận: one-hot không phải word embedding và cũng không tự mang thông tin ngữ nghĩa. Nó là cơ chế định vị giúp mô hình truy xuất đúng vector trong ma trận embedding. Qua nhiều bước dự đoán, tính sai số và lan truyền ngược, các vector này được cập nhật dần và trở thành biểu diễn từ hữu ích cho những mô hình như CBOW, Skip-gram và các mạng nơ-ron xử lý ngôn ngữ.