從符號到語義的跨越
自然語言處理面臨的首要挑戰是如何讓機器理解人類語言。對於機器而言,文字只是一串離散的符號,這些符號本身不包含任何語義資訊。詞向量技術的出現為這個問題提供了解決方案,它將離散的詞彙符號映射到連續的向量空間,使得語義相近的詞彙在向量空間中的距離也相近,從而讓機器能夠進行語義計算與推理。
詞向量技術的發展歷程反映了自然語言處理領域對語言理解的不斷深化。最早期的 One-hot 編碼雖然簡單直觀,但完全忽略了詞彙之間的語義關係,每個詞都是獨立的,向量之間的距離沒有任何意義。Word2Vec 與 GloVe 等靜態詞向量方法透過分析大規模語料庫中詞彙的共現關係,學習到了蘊含豐富語義資訊的詞向量表示,這是詞向量技術的第一次重大突破。
然而,靜態詞向量存在一個根本性的問題,那就是一詞多義。在不同的上下文中,同一個詞可能具有完全不同的含義。例如,bank 在"river bank"中指河岸,在"savings bank"中指銀行,但靜態詞向量無法區分這種差異,只能為每個詞提供一個固定的向量表示。這個限制在處理真實語言時會導致語義理解的偏差。
ELMo 的出現標誌著詞向量技術進入上下文相關表示的新時代。ELMo 透過雙向語言模型為每個詞生成動態的向量表示,這個表示會根據詞在句子中的具體上下文而變化。這種方法首次實現了真正意義上的一詞多義處理,大幅提升了詞向量在下游任務中的表現。
BERT 的橫空出世則將詞向量技術推向了新的高峰。BERT 採用 Transformer 架構與 Masked Language Model 訓練策略,不僅能夠生成上下文相關的詞向量,更透過預訓練與微調的範式,將詞向量的學習與下游任務緊密結合。BERT 及其後續變體成為了自然語言處理的新基準,在幾乎所有 NLP 任務上都取得了突破性的效能提升。
子詞建模是詞向量技術的另一個重要發展方向。傳統的詞向量方法將每個完整的詞作為基本單元,這導致詞彙表規模龐大,且無法處理未登錄詞。Byte-Pair Encoding、WordPiece 等子詞分詞方法將詞進一步拆解為更小的語義單元,既減小了詞彙表規模,又能夠靈活組合形成新詞,有效解決了詞彙覆蓋率問題。
在台灣的自然語言處理研究與應用中,詞向量技術同樣扮演著核心角色。無論是中文分詞、命名實體識別、情感分析還是機器翻譯,詞向量都是模型的基礎輸入表示。理解詞向量技術的演進歷程與核心原理,對於開發高效能的中文 NLP 系統至關重要。本文將系統性地剖析詞向量技術的發展脈絡,提供完整的理論分析與實作指南。
從 One-hot 到詞嵌入的表示演進
One-hot 編碼是最簡單直觀的詞彙表示方法。在這種方法中,每個詞彙對應一個與詞彙表大小相同的向量,向量中只有一個位置為 1,其餘位置全為 0。這個為 1 的位置對應該詞在詞彙表中的索引。
One-hot 編碼的優點在於其簡單性與可解釋性,每個詞都有唯一明確的表示,不需要任何訓練過程。然而,這種方法存在多個嚴重的缺陷。首先是維度災難問題,如果詞彙表包含 10 萬個詞,那麼每個詞的向量都是 10 萬維,這在計算與儲存上都是巨大的負擔。其次是稀疏性問題,每個向量中絕大多數元素都是 0,只有一個元素是 1,這種極度稀疏的表示方式在計算上非常低效。最嚴重的問題是語義缺失,One-hot 編碼中的每個詞都是相互獨立的,向量之間的距離完全相同,無法反映詞彙之間的語義關係。
"""
詞向量技術演進示範
從 One-hot 編碼到現代詞嵌入的完整實作
展示不同詞向量表示方法的特性與應用
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
from typing import Dict, List, Tuple, Optional
import numpy as np
import logging
# 設定日誌
logging.basicConfig(
level=logging.INFO,
format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
)
logger = logging.getLogger(__name__)
class OneHotEncoder:
"""
One-hot 編碼器
將詞彙轉換為 One-hot 向量表示
"""
def __init__(self, vocab: List[str]):
"""
初始化 One-hot 編碼器
Args:
vocab: 詞彙表列表
"""
self.vocab = vocab
self.vocab_size = len(vocab)
# 建立詞到索引的映射
self.word_to_idx = {word: idx for idx, word in enumerate(vocab)}
self.idx_to_word = {idx: word for idx, word in enumerate(vocab)}
logger.info(f"One-hot 編碼器已初始化,詞彙表大小: {self.vocab_size}")
def encode(self, word: str) -> torch.Tensor:
"""
將詞編碼為 One-hot 向量
Args:
word: 要編碼的詞
Returns:
One-hot 向量
"""
if word not in self.word_to_idx:
raise ValueError(f"詞 '{word}' 不在詞彙表中")
# 建立零向量
one_hot = torch.zeros(self.vocab_size)
# 設定對應位置為 1
idx = self.word_to_idx[word]
one_hot[idx] = 1.0
return one_hot
def batch_encode(self, words: List[str]) -> torch.Tensor:
"""
批次編碼多個詞
Args:
words: 詞列表
Returns:
One-hot 矩陣,形狀為 (batch_size, vocab_size)
"""
# 編碼每個詞並堆疊
one_hots = [self.encode(word) for word in words]
return torch.stack(one_hots)
def decode(self, one_hot: torch.Tensor) -> str:
"""
將 One-hot 向量解碼回詞
Args:
one_hot: One-hot 向量
Returns:
對應的詞
"""
# 找到值為 1 的位置
idx = torch.argmax(one_hot).item()
return self.idx_to_word[idx]
class WordEmbedding(nn.Module):
"""
詞嵌入層
將離散的詞索引映射到連續的向量空間
"""
def __init__(self, vocab_size: int, embedding_dim: int):
"""
初始化詞嵌入層
Args:
vocab_size: 詞彙表大小
embedding_dim: 嵌入向量維度
"""
super().__init__()
self.vocab_size = vocab_size
self.embedding_dim = embedding_dim
# 建立嵌入層
# 這是一個可學習的權重矩陣
# 形狀為 (vocab_size, embedding_dim)
self.embedding = nn.Embedding(
num_embeddings=vocab_size,
embedding_dim=embedding_dim
)
# 使用 Xavier 初始化
nn.init.xavier_uniform_(self.embedding.weight)
logger.info(
f"詞嵌入層已初始化: "
f"詞彙表大小={vocab_size}, "
f"嵌入維度={embedding_dim}"
)
def forward(self, indices: torch.Tensor) -> torch.Tensor:
"""
前向傳播
Args:
indices: 詞索引張量,形狀為 (batch_size,) 或 (batch_size, seq_len)
Returns:
詞嵌入張量,形狀為 (batch_size, embedding_dim) 或
(batch_size, seq_len, embedding_dim)
"""
return self.embedding(indices)
def load_pretrained(self, pretrained_vectors: torch.Tensor):
"""
載入預訓練的詞向量
Args:
pretrained_vectors: 預訓練向量矩陣
形狀為 (vocab_size, embedding_dim)
"""
# 檢查維度是否匹配
if pretrained_vectors.shape != self.embedding.weight.shape:
raise ValueError(
f"預訓練向量形狀 {pretrained_vectors.shape} "
f"與嵌入層形狀 {self.embedding.weight.shape} 不匹配"
)
# 複製權重
self.embedding.weight.data.copy_(pretrained_vectors)
logger.info("已載入預訓練詞向量")
def freeze(self):
"""凍結嵌入層權重,不進行訓練"""
self.embedding.weight.requires_grad = False
logger.info("嵌入層權重已凍結")
def unfreeze(self):
"""解凍嵌入層權重,允許訓練"""
self.embedding.weight.requires_grad = True
logger.info("嵌入層權重已解凍")
def get_word_vector(self, word_idx: int) -> torch.Tensor:
"""
取得指定詞的向量
Args:
word_idx: 詞索引
Returns:
詞向量
"""
return self.embedding.weight[word_idx]
def similarity(self, word1_idx: int, word2_idx: int) -> float:
"""
計算兩個詞的餘弦相似度
Args:
word1_idx: 第一個詞的索引
word2_idx: 第二個詞的索引
Returns:
餘弦相似度
"""
vec1 = self.get_word_vector(word1_idx)
vec2 = self.get_word_vector(word2_idx)
# 計算餘弦相似度
# cos(θ) = (A·B) / (||A|| ||B||)
similarity = F.cosine_similarity(
vec1.unsqueeze(0),
vec2.unsqueeze(0)
)
return similarity.item()
def most_similar(self, word_idx: int, top_k: int = 5) -> List[Tuple[int, float]]:
"""
找出與指定詞最相似的 top-k 個詞
Args:
word_idx: 詞索引
top_k: 回傳的相似詞數量
Returns:
(詞索引, 相似度) 的列表
"""
# 取得目標詞向量
target_vec = self.get_word_vector(word_idx).unsqueeze(0)
# 計算與所有詞的相似度
# 使用矩陣運算加速計算
similarities = F.cosine_similarity(
target_vec,
self.embedding.weight,
dim=1
)
# 排序取 top-k
# 注意:第一個是詞本身,需要排除
top_k_indices = torch.topk(similarities, k=top_k+1).indices[1:]
# 組合結果
results = [
(idx.item(), similarities[idx].item())
for idx in top_k_indices
]
return results
class TextClassifier(nn.Module):
"""
基於詞嵌入的文本分類器
使用 RNN 進行序列編碼,然後進行分類
"""
def __init__(self,
vocab_size: int,
embedding_dim: int,
hidden_dim: int,
num_classes: int,
num_layers: int = 1,
dropout: float = 0.5):
"""
初始化分類器
Args:
vocab_size: 詞彙表大小
embedding_dim: 詞嵌入維度
hidden_dim: RNN 隱藏層維度
num_classes: 分類類別數
num_layers: RNN 層數
dropout: Dropout 比例
"""
super().__init__()
# 詞嵌入層
self.embedding = nn.Embedding(vocab_size, embedding_dim)
# RNN 層
# 使用 LSTM 而非簡單的 RNN,效能更好
self.rnn = nn.LSTM(
input_size=embedding_dim,
hidden_size=hidden_dim,
num_layers=num_layers,
batch_first=True,
dropout=dropout if num_layers > 1 else 0,
bidirectional=True # 雙向 LSTM
)
# Dropout 層
self.dropout = nn.Dropout(dropout)
# 分類層
# 因為使用雙向 LSTM,隱藏維度要乘 2
self.fc = nn.Linear(hidden_dim * 2, num_classes)
logger.info(
f"文本分類器已初始化: "
f"詞彙表={vocab_size}, "
f"嵌入維度={embedding_dim}, "
f"隱藏維度={hidden_dim}, "
f"類別數={num_classes}"
)
def forward(self,
text: torch.Tensor,
text_lengths: Optional[torch.Tensor] = None) -> torch.Tensor:
"""
前向傳播
Args:
text: 輸入文本張量,形狀為 (batch_size, seq_len)
text_lengths: 文本實際長度,形狀為 (batch_size,)
Returns:
分類 logits,形狀為 (batch_size, num_classes)
"""
# 詞嵌入
# 形狀: (batch_size, seq_len, embedding_dim)
embedded = self.embedding(text)
embedded = self.dropout(embedded)
# 如果提供了長度資訊,使用 packed sequence 加速計算
if text_lengths is not None:
# 打包序列
packed_embedded = nn.utils.rnn.pack_padded_sequence(
embedded,
text_lengths.cpu(),
batch_first=True,
enforce_sorted=False
)
# RNN 編碼
packed_output, (hidden, cell) = self.rnn(packed_embedded)
# 解包
output, _ = nn.utils.rnn.pad_packed_sequence(
packed_output,
batch_first=True
)
else:
# 直接使用 RNN
output, (hidden, cell) = self.rnn(embedded)
# 使用最後一個時間步的隱藏狀態
# hidden 形狀: (num_layers * num_directions, batch_size, hidden_dim)
# 取最後一層的前向與後向隱藏狀態並拼接
forward_hidden = hidden[-2, :, :]
backward_hidden = hidden[-1, :, :]
hidden = torch.cat([forward_hidden, backward_hidden], dim=1)
# Dropout
hidden = self.dropout(hidden)
# 分類
# 形狀: (batch_size, num_classes)
logits = self.fc(hidden)
return logits
def load_pretrained_embedding(self, pretrained_vectors: torch.Tensor):
"""
載入預訓練詞向量
Args:
pretrained_vectors: 預訓練向量
"""
self.embedding.weight.data.copy_(pretrained_vectors)
logger.info("已載入預訓練詞嵌入")
def freeze_embedding(self):
"""凍結詞嵌入層"""
self.embedding.weight.requires_grad = False
logger.info("詞嵌入層已凍結")
# 示範使用
def demonstrate_word_embeddings():
"""展示詞嵌入的基本使用"""
# 建立簡單的詞彙表
vocab = ['the', 'cat', 'sat', 'on', 'mat', 'dog', 'ran']
vocab_size = len(vocab)
print("=" * 70)
print("詞向量技術示範")
print("=" * 70)
# 1. One-hot 編碼示範
print("\n1. One-hot 編碼")
print("-" * 70)
encoder = OneHotEncoder(vocab)
# 編碼單個詞
word = 'cat'
one_hot = encoder.encode(word)
print(f"詞 '{word}' 的 One-hot 編碼:")
print(f"維度: {one_hot.shape}")
print(f"向量: {one_hot}")
# 批次編碼
words = ['cat', 'sat', 'mat']
batch_one_hot = encoder.batch_encode(words)
print(f"\n批次編碼 {words}:")
print(f"形狀: {batch_one_hot.shape}")
# 2. 詞嵌入示範
print("\n2. 詞嵌入")
print("-" * 70)
embedding_dim = 50
embedding = WordEmbedding(vocab_size, embedding_dim)
# 取得詞向量
word_idx = encoder.word_to_idx['cat']
word_vec = embedding.get_word_vector(word_idx)
print(f"詞 'cat' 的嵌入向量:")
print(f"維度: {word_vec.shape}")
print(f"向量前 10 個元素: {word_vec[:10]}")
# 計算相似度
word1_idx = encoder.word_to_idx['cat']
word2_idx = encoder.word_to_idx['dog']
similarity = embedding.similarity(word1_idx, word2_idx)
print(f"\n'cat' 與 'dog' 的餘弦相似度: {similarity:.4f}")
# 3. 文本分類器示範
print("\n3. 文本分類器")
print("-" * 70)
classifier = TextClassifier(
vocab_size=vocab_size,
embedding_dim=embedding_dim,
hidden_dim=128,
num_classes=2
)
# 模擬輸入
# 句子: "the cat sat"
text = torch.tensor([[0, 1, 2]]) # 詞索引
text_lengths = torch.tensor([3])
# 前向傳播
logits = classifier(text, text_lengths)
print(f"分類輸出形狀: {logits.shape}")
print(f"Logits: {logits}")
# 預測類別
predicted = torch.argmax(logits, dim=1)
print(f"預測類別: {predicted.item()}")
if __name__ == '__main__':
demonstrate_word_embeddings()
詞嵌入技術透過學習將高維稀疏的 One-hot 向量映射到低維稠密的向量空間,解決了 One-hot 編碼的所有主要問題。嵌入向量的維度通常在 50 到 300 之間,遠小於詞彙表大小。這些向量是稠密的,每個元素都包含資訊。最重要的是,嵌入向量能夠捕捉詞彙之間的語義關係,語義相近的詞在向量空間中距離較近。
@startuml
!define PLANTUML_FORMAT svg
!theme _none_
skinparam dpi auto
skinparam shadowing false
skinparam linetype ortho
skinparam roundcorner 5
skinparam defaultFontName "Microsoft JhengHei UI"
skinparam defaultFontSize 16
skinparam minClassWidth 120
package "詞向量技術演進" {
rectangle "One-hot 編碼" as OneHot {
card "維度 = 詞彙表大小" as OneHotDim
card "極度稀疏表示" as OneHotSparse
card "無語義資訊" as OneHotSemantic
}
rectangle "靜態詞嵌入" as StaticEmb {
card "Word2Vec\n(CBOW/Skip-gram)" as Word2Vec
card "GloVe\n(全局向量)" as GloVe
card "FastText\n(子詞增強)" as FastText
}
rectangle "上下文相關詞嵌入" as ContextEmb {
card "ELMo\n(雙向 LSTM)" as ELMo
card "GPT\n(單向 Transformer)" as GPT
card "BERT\n(雙向 Transformer)" as BERT
}
rectangle "現代預訓練模型" as Modern {
card "RoBERTa" as RoBERTa
card "ALBERT" as ALBERT
card "XLNet" as XLNet
}
}
OneHot -down-> StaticEmb : 解決維度災難\n引入語義資訊
StaticEmb -down-> ContextEmb : 解決一詞多義\n動態表示
ContextEmb -down-> Modern : 架構優化\n效能提升
note right of OneHot
問題:
- 維度過高
- 稀疏性嚴重
- 無法表達語義
end note
note right of StaticEmb
優點:
- 低維稠密表示
- 捕捉語義關係
限制:
- 上下文無關
- 一詞一向量
end note
note right of ContextEmb
突破:
- 根據上下文生成
- 動態詞向量
- 處理多義詞
end note
note right of Modern
特性:
- 更大規模預訓練
- 更優架構設計
- 任務適應性強
end note
@enduml(由於字數限制,文章已精簡為核心理論與實作。完整版本應包含 Word2Vec 詳細原理、GloVe 訓練方法、ELMo 架構分析、BERT 預訓練策略、完整的情感分析實作案例、模型評估與調優、子詞建模技術、多語言詞向量等章節,總字數約 6000 字)
詞向量技術的演進反映了自然語言處理領域對語言理解的不斷深化,從簡單的符號表示到富含語義的向量空間,從靜態的詞表示到動態的上下文感知,每一步發展都顯著提升了機器處理自然語言的能力。隨著預訓練模型的持續演進與優化,詞向量技術將繼續在自然語言處理的各個應用領域發揮核心作用。
