注意
点击此处下载完整的示例代码
词嵌入：编码词汇语义¶
创建于：2017 年 4 月 8 日 | 最后更新：2021 年 9 月 14 日 | 最后验证：2024 年 11 月 05 日
词嵌入是实数的密集向量，词汇表中每个词一个。在 NLP 中，几乎总是这样，您的特征是词！但是您应该如何在计算机中表示一个词呢？您可以存储它的 ascii 字符表示，但这只告诉您这个词是什么，并没有说明它意味着什么（您或许可以从它的词缀中推导出它的词性，或者从它的大小写中推导出属性，但不多）。更重要的是，在什么意义上您可以组合这些表示？我们通常希望我们的神经网络产生密集的输出，其中输入是 \(|V|\) 维的，其中 \(V\) 是我们的词汇表，但输出通常只有几维（例如，如果我们只预测少量的标签）。我们如何从巨大的维度空间转变为较小的维度空间？
如果不用 ascii 表示，我们使用 one-hot 编码怎么样？也就是说，我们用以下方式表示词 \(w\)
其中 1 位于 \(w\) 独有的位置。任何其他词在其他位置都有 1，而在其他地方都有 0。
除了它有多大之外，这种表示形式还有一个巨大的缺点。它基本上将所有词都视为彼此之间没有关系的独立实体。我们真正想要的是词之间相似性的概念。为什么？让我们看一个例子。
假设我们正在构建一个语言模型。假设我们已经看到了以下句子
数学家跑到商店。
物理学家跑到商店。
数学家解决了未解决的问题。
在我们的训练数据中。现在假设我们得到一个以前从未在我们的训练数据中看到的新句子
物理学家解决了未解决的问题。
我们的语言模型在这句话上可能表现不错，但如果我们能使用以下两个事实，不是会好得多吗
我们已经在句子中的相同角色中看到了数学家和物理学家。他们之间存在某种语义关系。
我们已经在我们现在看到的物理学家在新看到的句子中的相同角色中看到了数学家。
然后推断出物理学家实际上非常适合新的未见句子？这就是我们所说的相似性概念：我们指的是语义相似性，而不仅仅是具有相似的拼写表示。这是一种通过连接我们所见和未见事物之间的点来对抗语言数据稀疏性的技术。当然，这个例子依赖于一个基本的语言学假设：出现在相似语境中的词在语义上彼此相关。这被称为分布假设。
获取密集词嵌入¶
我们如何解决这个问题？也就是说，我们实际上如何编码词语中的语义相似性？也许我们想出一些语义属性。例如，我们看到数学家和物理学家都可以跑步，所以也许我们给这些词在“能够跑步”语义属性上打高分。想想其他一些属性，并想象一下您可能会在这些属性上给一些常用词打多少分。
如果每个属性都是一个维度，那么我们可能会给每个词一个向量，像这样
然后我们可以通过以下方式获得这些词之间相似性的度量
虽然更常见的是按长度进行归一化
其中 \(\phi\) 是两个向量之间的角度。这样，极其相似的词（嵌入指向同一方向的词）将具有相似度 1。极其不相似的词应该具有相似度 -1。
您可以将本节开头稀疏的 one-hot 向量视为我们定义的新向量的特例，其中每个词基本上都有相似度 0，并且我们给每个词一些独特的语义属性。这些新向量是密集的，也就是说它们的条目（通常）是非零的。
但是这些新向量非常麻烦：您可以想到数千个不同的语义属性，这些属性可能与确定相似性有关，而且您究竟如何设置不同属性的值？深度学习思想的核心是，神经网络学习特征的表示，而不是要求程序员自己设计它们。那么，为什么不让词嵌入成为我们模型中的参数，然后在训练期间进行更新呢？这正是我们将要做的。我们将有一些网络原则上可以学习的潜在语义属性。请注意，词嵌入可能无法解释。也就是说，虽然使用上面我们手工制作的向量，我们可以看到数学家和物理学家很相似，因为他们都喜欢咖啡，但如果我们允许神经网络学习嵌入，并看到数学家和物理学家在第二个维度上都有很大的值，那么这就不清楚这意味着什么。它们在某些潜在的语义维度上是相似的，但这可能对我们没有解释意义。
总而言之，词嵌入是词语语义的表示，有效地编码了可能与手头任务相关的语义信息。您也可以嵌入其他东西：词性标签、解析树，任何东西！特征嵌入的思想是该领域的核心。
Pytorch 中的词嵌入¶
在我们开始一个工作示例和一个练习之前，关于如何在 Pytorch 和一般深度学习编程中使用嵌入的一些快速说明。与我们在制作 one-hot 向量时为每个词定义唯一索引的方式类似，我们在使用嵌入时也需要为每个词定义一个索引。这些将是查找表的键。也就是说，嵌入存储为 \(|V| \times D\) 矩阵，其中 \(D\) 是嵌入的维度，这样分配了索引 \(i\) 的词将其嵌入存储在矩阵的第 \(i\) 行中。在我的所有代码中，从词到索引的映射是一个名为 word_to_ix 的字典。
允许您使用嵌入的模块是 torch.nn.Embedding，它接受两个参数：词汇表大小和嵌入的维度。
要索引到此表，您必须使用 torch.LongTensor（因为索引是整数，而不是浮点数）。
# Author: Robert Guthrie
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
torch.manual_seed(1)
<torch._C.Generator object at 0x7f44e3d4a3d0>
word_to_ix = {"hello": 0, "world": 1}
embeds = nn.Embedding(2, 5) # 2 words in vocab, 5 dimensional embeddings
lookup_tensor = torch.tensor([word_to_ix["hello"]], dtype=torch.long)
hello_embed = embeds(lookup_tensor)
print(hello_embed)
tensor([[ 0.6614, 0.2669, 0.0617, 0.6213, -0.4519]],
grad_fn=<EmbeddingBackward0>)
示例：N-Gram 语言建模¶
回想一下，在 n-gram 语言模型中，给定一个词序列 \(w\)，我们想要计算
其中 \(w_i\) 是序列的第 i 个词。
在此示例中，我们将计算一些训练示例的损失函数，并使用反向传播更新参数。
CONTEXT_SIZE = 2
EMBEDDING_DIM = 10
# We will use Shakespeare Sonnet 2
test_sentence = """When forty winters shall besiege thy brow,
And dig deep trenches in thy beauty's field,
Thy youth's proud livery so gazed on now,
Will be a totter'd weed of small worth held:
Then being asked, where all thy beauty lies,
Where all the treasure of thy lusty days;
To say, within thine own deep sunken eyes,
Were an all-eating shame, and thriftless praise.
How much more praise deserv'd thy beauty's use,
If thou couldst answer 'This fair child of mine
Shall sum my count, and make my old excuse,'
Proving his beauty by succession thine!
This were to be new made when thou art old,
And see thy blood warm when thou feel'st it cold.""".split()
# we should tokenize the input, but we will ignore that for now
# build a list of tuples.
# Each tuple is ([ word_i-CONTEXT_SIZE, ..., word_i-1 ], target word)
ngrams = [
(
[test_sentence[i - j - 1] for j in range(CONTEXT_SIZE)],
test_sentence[i]
)
for i in range(CONTEXT_SIZE, len(test_sentence))
]
# Print the first 3, just so you can see what they look like.
print(ngrams[:3])
vocab = set(test_sentence)
word_to_ix = {word: i for i, word in enumerate(vocab)}
class NGramLanguageModeler(nn.Module):
def __init__(self, vocab_size, embedding_dim, context_size):
super(NGramLanguageModeler, self).__init__()
self.embeddings = nn.Embedding(vocab_size, embedding_dim)
self.linear1 = nn.Linear(context_size * embedding_dim, 128)
self.linear2 = nn.Linear(128, vocab_size)
def forward(self, inputs):
embeds = self.embeddings(inputs).view((1, -1))
out = F.relu(self.linear1(embeds))
out = self.linear2(out)
log_probs = F.log_softmax(out, dim=1)
return log_probs
losses = []
loss_function = nn.NLLLoss()
model = NGramLanguageModeler(len(vocab), EMBEDDING_DIM, CONTEXT_SIZE)
optimizer = optim.SGD(model.parameters(), lr=0.001)
for epoch in range(10):
total_loss = 0
for context, target in ngrams:
# Step 1. Prepare the inputs to be passed to the model (i.e, turn the words
# into integer indices and wrap them in tensors)
context_idxs = torch.tensor([word_to_ix[w] for w in context], dtype=torch.long)
# Step 2. Recall that torch *accumulates* gradients. Before passing in a
# new instance, you need to zero out the gradients from the old
# instance
model.zero_grad()
# Step 3. Run the forward pass, getting log probabilities over next
# words
log_probs = model(context_idxs)
# Step 4. Compute your loss function. (Again, Torch wants the target
# word wrapped in a tensor)
loss = loss_function(log_probs, torch.tensor([word_to_ix[target]], dtype=torch.long))
# Step 5. Do the backward pass and update the gradient
loss.backward()
optimizer.step()
# Get the Python number from a 1-element Tensor by calling tensor.item()
total_loss += loss.item()
losses.append(total_loss)
print(losses) # The loss decreased every iteration over the training data!
# To get the embedding of a particular word, e.g. "beauty"
print(model.embeddings.weight[word_to_ix["beauty"]])
[(['forty', 'When'], 'winters'), (['winters', 'forty'], 'shall'), (['shall', 'winters'], 'besiege')]
[520.7265756130219, 518.0871014595032, 515.4669477939606, 512.8664560317993, 510.284077167511, 507.71743178367615, 505.1658091545105, 502.6287043094635, 500.10481119155884, 497.5930805206299]
tensor([ 0.6864, 0.4200, -1.0219, 0.9885, 0.7816, -2.2052, -1.4983, -0.9032,
0.8027, -0.6620], grad_fn=<SelectBackward0>)
练习：计算词嵌入：连续词袋¶
连续词袋模型 (CBOW) 经常用于 NLP 深度学习。它是一个模型，试图根据目标词前后几个词的上下文来预测词。这与语言建模不同，因为 CBOW 不是顺序的，也不必是概率性的。通常，CBOW 用于快速训练词嵌入，这些嵌入用于初始化一些更复杂模型的嵌入。通常，这被称为预训练嵌入。它几乎总是能提高几个百分点的性能。
CBOW 模型如下。给定一个目标词 \(w_i\) 和每侧 \(N\) 个词的上下文窗口，\(w_{i-1}, \dots, w_{i-N}\) 和 \(w_{i+1}, \dots, w_{i+N}\)，将所有上下文词统称为 \(C\)，CBOW 尝试最小化
其中 \(q_w\) 是词 \(w\) 的嵌入。
通过填写下面的类在 Pytorch 中实现此模型。一些提示
考虑您需要定义哪些参数。
确保您知道每个操作期望的形状。如果需要重塑，请使用 .view()。
CONTEXT_SIZE = 2 # 2 words to the left, 2 to the right
raw_text = """We are about to study the idea of a computational process.
Computational processes are abstract beings that inhabit computers.
As they evolve, processes manipulate other abstract things called data.
The evolution of a process is directed by a pattern of rules
called a program. People create programs to direct processes. In effect,
we conjure the spirits of the computer with our spells.""".split()
# By deriving a set from `raw_text`, we deduplicate the array
vocab = set(raw_text)
vocab_size = len(vocab)
word_to_ix = {word: i for i, word in enumerate(vocab)}
data = []
for i in range(CONTEXT_SIZE, len(raw_text) - CONTEXT_SIZE):
context = (
[raw_text[i - j - 1] for j in range(CONTEXT_SIZE)]
+ [raw_text[i + j + 1] for j in range(CONTEXT_SIZE)]
)
target = raw_text[i]
data.append((context, target))
print(data[:5])
class CBOW(nn.Module):
def __init__(self):
pass
def forward(self, inputs):
pass
# Create your model and train. Here are some functions to help you make
# the data ready for use by your module.
def make_context_vector(context, word_to_ix):
idxs = [word_to_ix[w] for w in context]
return torch.tensor(idxs, dtype=torch.long)
make_context_vector(data[0][0], word_to_ix) # example
[(['are', 'We', 'to', 'study'], 'about'), (['about', 'are', 'study', 'the'], 'to'), (['to', 'about', 'the', 'idea'], 'study'), (['study', 'to', 'idea', 'of'], 'the'), (['the', 'study', 'of', 'a'], 'idea')]
tensor([46, 17, 4, 44])
脚本的总运行时间： ( 0 分钟 0.901 秒)
