ONE is preparing: 01 / INITIALIZING MODEL ROUTER. Evaluating routing across providers.
Current state
01 / INITIALIZING MODEL ROUTER.

Evaluating routing across providers.

Start learning
← NLP & Multimodal

AI Researcher

GloVe - Biểu diễn vector toàn cục

Vietnamese onlyThe learning content is available in Vietnamese only. The surrounding interface follows your language.

Phương pháp học biểu diễn từ dựa trên ma trận đồng xuất hiện toàn cục, kết hợp ưu điểm của phương pháp toàn cục và cục bộ.

lesson102 minNLP & MultimodalAI Researcher

Thử thách

Nếu đếm tất cả sách & bài báo tiếng Việt, cặp từ nào sẽ xuất hiện CÙNG NHAU nhiều nhất?

"Bún chả" là món ăn nổi tiếng — hai từ này gần như luôn đi cùng nhau trong văn bản ẩm thực! GloVe dựa trên chính ý tưởng này: đếm tần suất ĐI CÙNG NHAU của mọi cặp từ trên toàn bộ dữ liệu, rồi dùng thống kê đó để tạo word embeddings. "Bún chả" sẽ có similarity cực cao trong không gian vector.

Ma trận đồng xuất hiện

Đây là trái tim của GloVe: ma trận đồng xuất hiện X∈RV×VX \in \mathbb{R}^{V \times V} với 10 từ tiếng Việt. Mỗi ô XijX_{ij} là số lần từ i và j xuất hiện gần nhau (cửa sổ ±5). Di chuột qua ô để xem chi tiết, và kéo thanh trượt để xem quá trình phân tích ma trận X≈W⋅W~⊤X \approx W \cdot \tilde{W}^{\top}.

phởbúnchảngonHà Nộixe máyđường phốtuyệtthíchđông
phở
bún
chả
ngon
Hà Nội
xe máy
đường phố
tuyệt
thích
đông

Phân tích ma trận: X≈W⋅W~⊤X \approx W \cdot \tilde{W}^{\top}

Mục tiêu: tìm WW và W~\tilde{W} sao cho W⋅W~⊤W \cdot \tilde{W}^{\top} khớp với log⁡X\log X (có trọng số f).

Đồng xuất hiện cao

bún + chả = 22

→ log⁡22≈3.09\log 22 \approx 3.09 → vector rất gần

Đồng xuất hiện thấp

chả + xe máy = 0

→ log⁡0=−∞\log 0 = -\infty → bỏ qua (f=0)

Khoảnh khắc A-ha

GloVe = Global Vectors. Nó xây bảng thống kê "ai đi cùng ai" trên TOÀN BỘ dữ liệu (100 ô cho 10 từ, hàng trăm triệu ô cho từ vựng thật), rồi tìm vector sao cho wi⋅w~j≈log⁡Xij\mathbf{w}_i \cdot \tilde{\mathbf{w}}_j \approx \log X_{ij} .

Giống thám tử: Word2Vec theo dõi từng cuộc gặp riêng lẻ (mỗi cửa sổ là một "lần quan sát"), GloVe lập bảng tổng hợp "ai gặp ai bao nhiêu lần trong cả năm" rồi phân tích mối quan hệ một cách tổng thể — nhanh hơn, ổn định hơn, dễ song song hơn.

Thử thách nhanh

Trong ma trận 10×10, X(bún, chả) = 22 nhưng X(bún, xe máy) = 1. GloVe sẽ tạo embeddings thế nào?

GloVe muốn: w_bún · w_chả ≈ log(22) = 3.09 (lớn) và w_bún · w_xe_máy ≈ log(1) = 0 (nhỏ). Kết quả: bún gần chả trong không gian vector, xa xe máy. Đây chính là cách ngữ nghĩa được 'mã hoá' từ thống kê.

Analogy query

Một trong những test kinh điển cho word embeddings là analogy query: cho 3 từ A, B, C, tìm D sao cho "A với B như C với D". Biểu diễn vector: vD≈vA−vB+vC\mathbf{v}_D \approx \mathbf{v}_A - \mathbf{v}_B + \mathbf{v}_C . Hãy so sánh GloVe và Word2Vec trên 5 query tiếng Việt:

Hàm trọng số f(x)

Nếu chỉ optimize (wi⋅w~j−log⁡Xij)2(\mathbf{w}_i \cdot \tilde{\mathbf{w}}_j - \log X_{ij})^2 , hai vấn đề sẽ xảy ra: (1) cặp từ xuất hiện quá ít (nhiễu) có thể phá vỡ model, (2) cặp quá nhiều (như "của", "là") sẽ chi phối toàn bộ loss. Giải pháp: thêm trọng số f(Xij)f(X_{ij}).

f(x)={(x/xmax⁡)αneˆˊu x<xmax⁡1neˆˊu x≥xmax⁡f(x) = \begin{cases} (x/x_{\max})^{\alpha} & \text{nếu } x < x_{\max} \\ 1 & \text{nếu } x \geq x_{\max} \end{cases}

Vì sao chọn α = 0.75 và x_max = 100

Vì sao chọn α = 0.75 và x_max = 100?

Pennington et al. (2014) thử nghiệm trên corpus Wikipedia +Gigaword (6B tokens) và phát hiện:

  • α = 0.75 cho kết quả analogy tốt nhất (vượt α=1.0 khoảng 2-3%). Giá trị này giống exponent trong negative sampling của Word2Vec (không ngẫu nhiên!).
  • x_max = 100 đủ lớn để các cặp phổ biến không bị cắt đầu, nhưng đủ nhỏ để cặp như "the of" (xuất hiện hàng triệu lần) không phá vỡ training.
  • Model khá robust với các giá trị gần đó: α ∈ [0.65, 0.8], x_max ∈ [50, 200] đều cho kết quả tương đương.

Vì sao dùng log(X_ij)

Tại sao dùng log(X_ij) chứ không phải X_ij?

Mục tiêu của GloVe là mã hoá tỷ số xác suất đồng xuất hiện, không phải giá trị tuyệt đối:

PikPjk=Xik/XiXjk/Xj\frac{P_{ik}}{P_{jk}} = \frac{X_{ik}/X_i}{X_{jk}/X_j}

Pennington et al. chứng minh rằng nếu ta muốn F(wi−wj,w~k)=Pik/PjkF(\mathbf{w}_i - \mathbf{w}_j, \tilde{\mathbf{w}}_k) = P_{ik}/P_{jk} , và yêu cầu F là homomorphism, thì nghiệm duy nhất là F = exp. Lấy log hai vế → tích vô hướng bằng log của ratio → sau khi đơn giản hoá: wi⊤w~k=log⁡Xik−log⁡Xi\mathbf{w}_i^{\top} \tilde{\mathbf{w}}_k = \log X_{ik} - \log X_i . Phần log⁡Xi\log X_i được hấp thụ vào bias term. Kết quả cuối cùng: wi⊤w~j+bi+b~j=log⁡Xij\mathbf{w}_i^{\top} \tilde{\mathbf{w}}_j + b_i + \tilde{b}_j = \log X_{ij} . Đây là lý do tại sao log là lựa chọn tự nhiên — không phải ad hoc!

Thử thách nâng cao

Một corpus có X(của, là) = 2,000,000 (cực phổ biến) và X(phở, ngon) = 80. Hàm f với x_max = 100 xử lý ra sao?

Đây chính là lý do f bão hoà ở x_max: cặp 'của là' không còn chi phối gradient dù xuất hiện 2 triệu lần. Cặp 'phở ngon' (80 lần) vẫn được đánh trọng số đầy đủ (0.84). Nhờ vậy GloVe học được quan hệ ngữ nghĩa thay vì chỉ memorize stop words.

Lý thuyết

GloVe (Global Vectors for Word Representation, Pennington, Socher & Manning, Stanford 2014) kết hợp hai trường phái lớn: phân tích ma trận toàn cục (LSA, HAL) và học cửa sổ cục bộ (như Word2Vec). Cả hai đều cho ra word embeddings chất lượng cao, nhưng GloVe có điểm tựa toán học rõ ràng hơn: bắt đầu từ ratio của xác suất đồng xuất hiện và dẫn tới một objective có thể chứng minh được.

glove_gensim_demo.py

"""
Huấn luyện GloVe với Gensim trên corpus tiếng Việt.
Yêu cầu: pip install glove_python_binary gensim scikit-learn
"""
from glove import Corpus, Glove
from gensim.utils import simple_preprocess
import numpy as np

# ─── 1. Chuẩn bị corpus ───
# Mỗi câu là một list tokens
corpus_text = [
    "phở Hà Nội rất ngon và nổi tiếng",
    "bún chả là món đặc sản của Hà Nội",
    "xe máy chạy khắp đường phố Hà Nội",
    "tôi thích phở bò ngon tuyệt",
    # ... hàng triệu câu khác
]
sentences = [simple_preprocess(s) for s in corpus_text]

# ─── 2. Xây ma trận đồng xuất hiện ───
corpus = Corpus()
corpus.fit(sentences, window=10)   # cửa sổ ±10
print(f"Vocabulary size: {len(corpus.dictionary)}")
print(f"Non-zero entries: {corpus.matrix.nnz}")

# ─── 3. Huấn luyện GloVe ───
glove = Glove(
    no_components=100,      # vector 100 chiều
    learning_rate=0.05,
    alpha=0.75,             # exponent của f(x)
    max_count=100,          # x_max
)
glove.fit(
    corpus.matrix,
    epochs=30,
    no_threads=8,           # parallel
    verbose=True,
)
glove.add_dictionary(corpus.dictionary)

# ─── 4. Truy vấn ───
print(glove.most_similar("phở", number=5))
# → [('bún', 0.82), ('chả', 0.76), ('ngon', 0.71), ...]

# ─── 5. Analogy: vua - đàn_ông + phụ_nữ ≈ ? ───
def analogy(a, b, c, model, topn=3):
    va = model.word_vectors[model.dictionary[a]]
    vb = model.word_vectors[model.dictionary[b]]
    vc = model.word_vectors[model.dictionary[c]]
    target = va - vb + vc
    # cosine similarity với tất cả từ
    norms = np.linalg.norm(model.word_vectors, axis=1)
    sims = model.word_vectors @ target / (norms * np.linalg.norm(target) + 1e-8)
    # loại 3 từ đầu vào
    for w in (a, b, c):
        sims[model.dictionary[w]] = -1
    top = np.argsort(-sims)[:topn]
    inv_dict = {v: k for k, v in model.dictionary.items()}
    return [(inv_dict[i], sims[i]) for i in top]

print(analogy("vua", "đàn_ông", "phụ_nữ", glove))
# → [('hoàng_hậu', 0.78), ('nữ_hoàng', 0.71), ...]

# ─── 6. Lưu model ───
glove.save("vi_glove_100d.model")

load_pretrained_glove.py

"""
Sử dụng GloVe pre-trained (tải từ nlp.stanford.edu/projects/glove)
"""
import numpy as np

# ─── Tải glove.6B.100d.txt (822 MB, 400K từ tiếng Anh) ───
embeddings = {}
with open("glove.6B.100d.txt", "r", encoding="utf-8") as f:
    for line in f:
        values = line.split()
        word = values[0]
        vec = np.array(values[1:], dtype=np.float32)
        embeddings[word] = vec

print(f"Loaded {len(embeddings)} word vectors, dim={len(next(iter(embeddings.values())))}")

# ─── Cosine similarity ───
def cosine_sim(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b) + 1e-8)

# ─── So sánh các cặp nổi tiếng ───
print(cosine_sim(embeddings["king"], embeddings["queen"]))    # 0.75 — rất gần
print(cosine_sim(embeddings["king"], embeddings["man"]))      # 0.53 — gần
print(cosine_sim(embeddings["king"], embeddings["car"]))      # 0.15 — xa

# ─── Analogy kinh điển ───
target = embeddings["king"] - embeddings["man"] + embeddings["woman"]
# Tìm từ gần target nhất (trừ 3 từ đầu vào)
best = ("", -1)
for w, v in embeddings.items():
    if w in {"king", "man", "woman"}:
        continue
    s = cosine_sim(target, v)
    if s > best[1]:
        best = (w, s)
print(best)  # ('queen', 0.71)

# ─── Analogy địa danh ───
target = embeddings["paris"] - embeddings["france"] + embeddings["vietnam"]
# → "hanoi" (cosine ≈ 0.67)

Tóm tắt

  • GloVe xây ma trận đồng xuất hiện TOÀN CỤC X_ij — đếm số lần mọi cặp từ đi cùng nhau trên toàn corpus (không chỉ window cục bộ).
  • Mục tiêu cốt lõi: w_i · ~w_j + b_i + ~b_j ≈ log(X_ij) — tích vô hướng vector xấp xỉ log đồng xuất hiện, có trọng số f(X_ij).
  • Hàm f(x) = (x/x_max)^α (α=0.75, x_max=100) bão hoà ở 1 — giảm ảnh hưởng cặp hiếm (nhiễu) và cặp quá phổ biến ('của', 'là').
  • Kết hợp ưu điểm LSA (toàn cục) + Word2Vec (cục bộ) → embeddings ổn định, song song hoá dễ, kết quả analogy mạnh.
  • Pre-trained GloVe Stanford: glove.6B (400K từ, 50-300d), glove.42B (1.9M từ), glove.840B (2.2M từ) — tải miễn phí.
  • Hạn chế: mỗi từ chỉ có 1 vector cố định (không phân biệt nghĩa theo ngữ cảnh) → BERT/GPT giải quyết bằng contextual embeddings.

Continue the module

Lesson 3 of 13