高频词在训练中可能不是那么有用。我们可以对他们进行下采样，以便在训练中加快速度。

为了提高计算效率，我们以小批量方式加载样本。我们可以定义其他变量来区分填充标记和非填充标记，以及正例和负例。

我们可以使用嵌入层和二元交叉熵损失来训练带负采样的跳元模型。

词嵌入的应用包括基于词向量的余弦相似度为给定词找到语义相似的词。

1.用于预训练词嵌入的数据集

1.1读取数据集

1.2下采样

1.3中心词和上下文词的提取

1.4负采样

1.5小批量加载训练实例

1.6整合代码

2.预训练word2vec

2.1跳元模型

2.1.1嵌入层

2.1.2定义前向传播

2.2训练

2.2.1 二元交叉熵损失

2.2.2初始化模型参数

2.2.3定义训练阶段代码

2.3应用词嵌入

1.用于预训练词嵌入的数据集

现在我们通过已经了解了word2vec模型的技术细节和大致的训练方法，让我们来看看它们的实现。具体地说，我们将以跳元模型和负采样为例。本节从用于预训练词嵌入模型的数据集开始：数据的原始格式将被转换为可以在训练期间迭代的小批量。

pip install mxnet==1.7.0.post1

pip install d2l==0.15.0

import math
import os
import random
from mxnet import gluon, np
from d2l import mxnet as d2l

1.1读取数据集

我们在这里使用的数据集是Penn Tree Bank（PTB）。该语料库取自“华尔街日报”的文章，分为训练集、验证集和测试集。在原始格式中，文本文件的每一行表示由空格分隔的一句话。在这里，我们将每个单词视为一个词元。

#@save
d2l.DATA_HUB['ptb'] = (d2l.DATA_URL + 'ptb.zip','319d85e578af0cdc590547f26231e4e31cdf1e42')#@save
def read_ptb():"""将PTB数据集加载到文本行的列表中"""data_dir = d2l.download_extract('ptb')# Readthetrainingset.with open(os.path.join(data_dir, 'ptb.train.txt')) as f:raw_text = f.read()return [line.split() for line in raw_text.split('\n')]sentences = read_ptb()
f'# sentences数: {len(sentences)}'

在读取训练集之后，我们为语料库构建了一个词表，其中出现次数少于10次的任何单词都将由“<unk>”词元替换。请注意，原始数据集还包含表示稀有（未知）单词的“<unk>”词元。

vocab = d2l.Vocab(sentences, min_freq=10)
f'vocab size: {len(vocab)}'

'vocab size: 6719'

1.2下采样

文本数据通常有“the”“a”和“in”等高频词：它们在非常大的语料库中甚至可能出现数十亿次。然而，这些词经常在上下文窗口中与许多不同的词共同出现，提供的有用信息很少。例如，考虑上下文窗口中的词“chip”：直观地说，它与低频单词“intel”的共现比与高频单词“a”的共现在训练中更有用。此外，大量（高频）单词的训练速度很慢。因此，当训练词嵌入模型时，可以对高频单词进行下采样 (Mikolov et al., 2013)。具体地说，数据集中的每个词wi将有概率地被丢弃

#@save
def subsample(sentences, vocab):"""下采样高频词"""# 排除未知词元'<unk>'sentences = [[token for token in line if vocab[token] != vocab.unk]for line in sentences]counter = d2l.count_corpus(sentences)num_tokens = sum(counter.values())# 如果在下采样期间保留词元，则返回Truedef keep(token):return(random.uniform(0, 1) <math.sqrt(1e-4 / counter[token] * num_tokens))return ([[token for token in line if keep(token)] for line in sentences],counter)subsampled, counter = subsample(sentences, vocab)

下面的代码片段绘制了下采样前后每句话的词元数量的直方图。正如预期的那样，下采样通过删除高频词来显著缩短句子，这将使训练加速。

#@save
def show_list_len_pair_hist(legend, xlabel, ylabel, xlist, ylist):"""绘制列表长度对的直方图"""d2l.set_figsize()_, _, patches = d2l.plt.hist([[len(l) for l in xlist], [len(l) for l in ylist]])d2l.plt.xlabel(xlabel)d2l.plt.ylabel(ylabel)for patch in patches[1].patches:patch.set_hatch('/')d2l.plt.legend(legend)

show_list_len_pair_hist(['origin', 'subsampled'], '# tokens per sentence','count', sentences, subsampled);

对于单个词元，高频词“the”的采样率不到1/20。

def compare_counts(token):return (f'"{token}"的数量：'f'之前={sum([l.count(token) for l in sentences])}, 'f'之后={sum([l.count(token) for l in subsampled])}')compare_counts('the')

'"the"的数量：之前=50770, 之后=1990'

相比之下，低频词“join”则被完全保留。

compare_counts('join')

'"join"的数量：之前=45, 之后=45'

在下采样之后，我们将词元映射到它们在语料库中的索引。

corpus = [vocab[line] for line in subsampled]
corpus[:3]

[[], [71, 2132, 275, 406], [140, 5464, 3080, 1595]]

1.3中心词和上下文词的提取

下面的get_centers_and_contexts函数从corpus中提取所有中心词及其上下文词。它随机采样1到max_window_size之间的整数作为上下文窗口。对于任一中心词，与其距离不超过采样上下文窗口大小的词为其上下文词。

#@save
def get_centers_and_contexts(corpus, max_window_size):"""返回跳元模型中的中心词和上下文词"""centers, contexts = [], []for line in corpus:# 要形成“中心词-上下文词”对，每个句子至少需要有2个词if len(line) < 2:continuecenters += linefor i in range(len(line)):  # 上下文窗口中间iwindow_size = random.randint(1, max_window_size)indices = list(range(max(0, i - window_size),min(len(line), i + 1 + window_size)))# 从上下文词中排除中心词indices.remove(i)contexts.append([line[idx] for idx in indices])return centers, contexts

接下来，我们创建一个人工数据集，分别包含7个和3个单词的两个句子。设置最大上下文窗口大小为2，并打印所有中心词及其上下文词。

tiny_dataset = [list(range(7)), list(range(7, 10))]
print('数据集', tiny_dataset)
for center, context in zip(*get_centers_and_contexts(tiny_dataset, 2)):print('中心词', center, '的上下文词是', context)

数据集 [[0, 1, 2, 3, 4, 5, 6], [7, 8, 9]]
中心词 0 的上下文词是 [1]
中心词 1 的上下文词是 [0, 2]
中心词 2 的上下文词是 [1, 3]
中心词 3 的上下文词是 [2, 4]
中心词 4 的上下文词是 [2, 3, 5, 6]
中心词 5 的上下文词是 [4, 6]
中心词 6 的上下文词是 [4, 5]
中心词 7 的上下文词是 [8, 9]
中心词 8 的上下文词是 [7, 9]
中心词 9 的上下文词是 [7, 8]

在PTB数据集上进行训练时，我们将最大上下文窗口大小设置为5。下面提取数据集中的所有中心词及其上下文词。

all_centers, all_contexts = get_centers_and_contexts(corpus, 5)
f'# “中心词-上下文词对”的数量: {sum([len(contexts) for contexts in all_contexts])}'

'# “中心词-上下文词对”的数量: 1499183'

1.4负采样

我们使用负采样进行近似训练。为了根据预定义的分布对噪声词进行采样，我们定义以下RandomGenerator类，其中（可能未规范化的）采样分布通过变量sampling_weights传递。

#@save
class RandomGenerator:"""根据n个采样权重在{1,...,n}中随机抽取"""def __init__(self, sampling_weights):# Excludeself.population = list(range(1, len(sampling_weights) + 1))self.sampling_weights = sampling_weightsself.candidates = []self.i = 0def draw(self):if self.i == len(self.candidates):# 缓存k个随机采样结果self.candidates = random.choices(self.population, self.sampling_weights, k=10000)self.i = 0self.i += 1return self.candidates[self.i - 1]

例如，我们可以在索引1、2和3中绘制10个随机变量X，采样概率为P(X=1)=2/9,P(X=2)=3/9和P(X=3)=4/9，如下所示。

#@save
generator = RandomGenerator([2, 3, 4])
[generator.draw() for _ in range(10)]

[2, 2, 1, 1, 3, 2, 3, 1, 1, 3]

对于一对中心词和上下文词，我们随机抽取了K个（实验中为5个）噪声词。根据word2vec论文中的建议，将噪声词w的采样概率P(w)设置为其在字典中的相对频率，其幂为0.75 (Mikolov et al., 2013)。

#@save
def get_negatives(all_contexts, vocab, counter, K):"""返回负采样中的噪声词"""# 索引为1、2、...（索引0是词表中排除的未知标记）sampling_weights = [counter[vocab.to_tokens(i)]**0.75for i in range(1, len(vocab))]all_negatives, generator = [], RandomGenerator(sampling_weights)for contexts in all_contexts:negatives = []while len(negatives) < len(contexts) * K:neg = generator.draw()# 噪声词不能是上下文词if neg not in contexts:negatives.append(neg)all_negatives.append(negatives)return all_negativesall_negatives = get_negatives(all_contexts, vocab, counter, 5)

1.5小批量加载训练实例

在提取所有中心词及其上下文词和采样噪声词后，将它们转换成小批量的样本，在训练过程中可以迭代加载。

为了区分正反例，我们在contexts_negatives中通过一个labels变量将上下文词与噪声词分开。类似于masks，在labels中的元素和contexts_negatives中的元素之间也存在一一对应关系，其中labels中的1（否则为0）对应于contexts_negatives中的上下文词的正例。

上述思想在下面的batchify函数中实现。其输入data是长度等于批量大小的列表，其中每个元素是由中心词center、其上下文词context和其噪声词negative组成的样本。此函数返回一个可以在训练期间加载用于计算的小批量，例如包括掩码变量masks。

#@save
def batchify(data):"""返回带有负采样的跳元模型的小批量样本"""max_len = max(len(c) + len(n) for _, c, n in data)centers, contexts_negatives, masks, labels = [], [], [], []for center, context, negative in data:cur_len = len(context) + len(negative)centers += [center]contexts_negatives += \[context + negative + [0] * (max_len - cur_len)]masks += [[1] * cur_len + [0] * (max_len - cur_len)]labels += [[1] * len(context) + [0] * (max_len - len(context))]return (np.array(centers).reshape((-1, 1)), np.array(contexts_negatives), np.array(masks), np.array(labels))

让我们使用一个小批量的两个样本来测试此函数。

x_1 = (1, [2, 2], [3, 3, 3, 3])
x_2 = (1, [2, 2, 2], [3, 3])
batch = batchify((x_1, x_2))names = ['centers', 'contexts_negatives', 'masks', 'labels']
for name, data in zip(names, batch):print(name, '=', data)

centers = [[1.][1.]]
contexts_negatives = [[2. 2. 3. 3. 3. 3.][2. 2. 2. 3. 3. 0.]]
masks = [[1. 1. 1. 1. 1. 1.][1. 1. 1. 1. 1. 0.]]
labels = [[1. 1. 0. 0. 0. 0.][1. 1. 1. 0. 0. 0.]]

1.6整合代码

最后，我们定义了读取PTB数据集并返回数据迭代器和词表的load_data_ptb函数。

#@save
def load_data_ptb(batch_size, max_window_size, num_noise_words):"""下载PTB数据集，然后将其加载到内存中"""sentences = read_ptb()vocab = d2l.Vocab(sentences, min_freq=10)subsampled, counter = subsample(sentences, vocab)corpus = [vocab[line] for line in subsampled]all_centers, all_contexts = get_centers_and_contexts(corpus, max_window_size)all_negatives = get_negatives(all_contexts, vocab, counter, num_noise_words)dataset = gluon.data.ArrayDataset(all_centers, all_contexts, all_negatives)data_iter = gluon.data.DataLoader(dataset, batch_size, shuffle=True,batchify_fn=batchify,num_workers=d2l.get_dataloader_workers())return data_iter, vocab

让我们打印数据迭代器的第一个小批量。

data_iter, vocab = load_data_ptb(512, 5, 5)
for batch in data_iter:for name, data in zip(names, batch):print(name, 'shape:', data.shape)break

centers shape: (512, 1)
contexts_negatives shape: (512, 60)
masks shape: (512, 60)
labels shape: (512, 60)

2.预训练word2vec

我们继续实现预训练——词嵌入（word2vec）、近似训练_流萤数点的博客-CSDN博客中定义的跳元语法模型。然后，我们将在PTB数据集上使用负采样预训练word2vec。首先，让我们通过调用d2l.load_data_ptb函数来获得该数据集的数据迭代器和词表，该函数在第1.6节中进行了描述。

import math
from mxnet import autograd, gluon, np, npx
from mxnet.gluon import nn
from d2l import mxnet as d2lnpx.set_np()batch_size, max_window_size, num_noise_words = 512, 5, 5
data_iter, vocab = d2l.load_data_ptb(batch_size, max_window_size,num_noise_words)

2.1跳元模型

我们通过嵌入层和批量矩阵乘法实现了跳元模型。首先，让我们回顾一下嵌入层是如何工作的。

2.1.1嵌入层

嵌入层将词元的索引映射到其特征向量。该层的权重是一个矩阵，其行数等于字典大小（input_dim），列数等于每个标记的向量维数（output_dim）。在词嵌入模型训练之后，这个权重就是我们所需要的。

embed = nn.Embedding(input_dim=20, output_dim=4)
embed.initialize()
embed.weight

Parameter embedding0_weight (shape=(20, 4), dtype=float32)

嵌入层的输入是词元（词）的索引。对于任何词元索引i，其向量表示可以从嵌入层中的权重矩阵的第i行获得。由于向量维度（output_dim）被设置为4，因此当小批量词元索引的形状为（2，3）时，嵌入层返回具有形状（2，3，4）的向量。

x = np.array([[1, 2, 3], [4, 5, 6]])
embed(x)

array([[[ 0.01438687,  0.05011239,  0.00628365,  0.04861524],[-0.01068833,  0.01729892,  0.02042518, -0.01618656],[-0.00873779, -0.02834515,  0.05484822, -0.06206018]],[[ 0.06491279, -0.03182812, -0.01631819, -0.00312688],[ 0.0408415 ,  0.04370362,  0.00404529, -0.0028032 ],[ 0.00952624, -0.01501013,  0.05958354,  0.04705103]]])

2.1.2定义前向传播

在前向传播中，跳元语法模型的输入包括形状为（批量大小，1）的中心词索引center和形状为（批量大小，max_len）的上下文与噪声词索引contexts_and_negatives，其中max_len在 1.5节中定义。这两个变量首先通过嵌入层从词元索引转换成向量，然后它们的批量矩阵相乘（在注意力汇聚：Nadaraya-Watson 核回归_流萤数点的博客-CSDN博客中描述）返回形状为（批量大小，1，max_len）的输出。输出中的每个元素是中心词向量和上下文或噪声词向量的点积。

def skip_gram(center, contexts_and_negatives, embed_v, embed_u):v = embed_v(center)u = embed_u(contexts_and_negatives)pred = npx.batch_dot(v, u.swapaxes(1, 2))return pred

让我们为一些样例输入打印此skip_gram函数的输出形状。

skip_gram(np.ones((2, 1)), np.ones((2, 4)), embed, embed).shape

(2, 1, 4)

2.2训练

在训练带负采样的跳元模型之前，我们先定义它的损失函数。

2.2.1 二元交叉熵损失

根据预训练——词嵌入（word2vec）、近似训练_流萤数点的博客-CSDN博客中负采样损失函数的定义，我们将使用二元交叉熵损失。

loss = gluon.loss.SigmoidBCELoss()

回想一下我们在1.5节中对掩码变量和标签变量的描述。下面计算给定变量的二进制交叉熵损失。

pred = np.array([[1.1, -2.2, 3.3, -4.4]] * 2)
label = np.array([[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0]])
mask = np.array([[1, 1, 1, 1], [1, 1, 0, 0]])
loss(pred, label, mask) * mask.shape[1] / mask.sum(axis=1)

array([0.93521017, 1.8462094 ])

下面显示了如何使用二元交叉熵损失中的Sigmoid激活函数（以较低效率的方式）计算上述结果。我们可以将这两个输出视为两个规范化的损失，在非掩码预测上进行平均。

def sigmd(x):return -math.log(1 / (1 + math.exp(-x)))print(f'{(sigmd(1.1) + sigmd(2.2) + sigmd(-3.3) + sigmd(4.4)) / 4:.4f}')
print(f'{(sigmd(-1.1) + sigmd(-2.2)) / 2:.4f}')

0.9352
1.8462

2.2.2初始化模型参数

我们定义了两个嵌入层，将词表中的所有单词分别作为中心词和上下文词使用。字向量维度embed_size被设置为100。

embed_size = 100
net = nn.Sequential()
net.add(nn.Embedding(input_dim=len(vocab), output_dim=embed_size),nn.Embedding(input_dim=len(vocab), output_dim=embed_size))

2.2.3定义训练阶段代码

训练阶段代码实现定义如下。由于填充的存在，损失函数的计算与以前的训练函数略有不同。

def train(net, data_iter, lr, num_epochs, device=d2l.try_gpu()):net.initialize(ctx=device, force_reinit=True)trainer = gluon.Trainer(net.collect_params(), 'adam',{'learning_rate': lr})animator = d2l.Animator(xlabel='epoch', ylabel='loss',xlim=[1, num_epochs])# 规范化的损失之和，规范化的损失数metric = d2l.Accumulator(2)for epoch in range(num_epochs):timer, num_batches = d2l.Timer(), len(data_iter)for i, batch in enumerate(data_iter):center, context_negative, mask, label = [data.as_in_ctx(device) for data in batch]with autograd.record():pred = skip_gram(center, context_negative, net[0], net[1])l = (loss(pred.reshape(label.shape), label, mask) *mask.shape[1] / mask.sum(axis=1))l.backward()trainer.step(batch_size)metric.add(l.sum(), l.size)if (i + 1) % (num_batches // 5) == 0 or i == num_batches - 1:animator.add(epoch + (i + 1) / num_batches,(metric[0] / metric[1],))print(f'loss {metric[0] / metric[1]:.3f}, 'f'{metric[1] / timer.stop():.1f} tokens/sec on {str(device)}')

现在，我们可以使用负采样来训练跳元模型。

lr, num_epochs = 0.002, 5
train(net, data_iter, lr, num_epochs)

2.3应用词嵌入

在训练word2vec模型之后，我们可以使用训练好模型中词向量的余弦相似度来从词表中找到与输入单词语义最相似的单词。

def get_similar_tokens(query_token, k, embed):W = embed.weight.data()x = W[vocab[query_token]]# 计算余弦相似性。增加1e-9以获得数值稳定性cos = np.dot(W, x) / np.sqrt(np.sum(W * W, axis=1) * np.sum(x * x) + \1e-9)topk = npx.topk(cos, k=k+1, ret_typ='indices').asnumpy().astype('int32')for i in topk[1:]:  # 删除输入词print(f'cosine sim={float(cos[i]):.3f}: {vocab.to_tokens(i)}')get_similar_tokens('chip', 3, net[0])

cosine sim=0.688: intel
cosine sim=0.673: chips
cosine sim=0.666: microprocessor

预训练word2vec，代码相关推荐

那些牛了逼的embedding预训练 ----- word2vec 篇
此篇献给一直视自己为垃圾的喵主,喵呜?(It's a sad story). 前言阿正在某一天丢给我了几个预训练模型,有现在比较热门的,也有已经老得不行的然而还没有深入的,对就是那个word2vec ...
word2vec预训练词向量+通俗理解word2vec+CountVectorizer+TfidfVectorizer+tf-idf公式及sklearn中TfidfVectorizer
文章目录文分类实(一) word2vec预训练词向量 2 数据集 3 数据预处理 4 预训练word2vec模型 canci 通俗理解word2vec 独热编码 word2vec (Continuo ...
【Whole Word Mask】中文 bert wwm 预训练代码，预训练你自己的模型
基于 transformers 来进行 bert 的 wwm (全词掩码)预训练,让你的模型可以领域适配提示:文章偏向于NLP进阶,大佬请绕路-- 文章目录基于 transformers 来进行 ...
预训练word2vec--Word2Vec实现(二)
文章目录预训练word2vec 跳元模型嵌入层定义前向传播训练二元交叉熵损失初始化模型参数定义训练阶段代码应用词嵌入小结预训练word2vec 现在,我们将在PTB数据集上使用负采 ...
自然语言处理：预训练
14.8 来自trans的双向编码器表示(Bert) Bidirectional Encoder Representation from Transformers 14.8.1 从上下文无关到上下 ...
《预训练周刊》第24期：Infinite-former：无限记忆变换器、2500万悟道科研基金开始申请
No.24 智源社区预训练组预训练研究观点资源活动关于周刊超大规模预训练模型是当前人工智能领域研究的热点,为了帮助研究与工程人员了解这一领域的进展和资讯,智源社区整理了第24期&l ...
《预训练周刊》第24期：Infinite-former：无限记忆变换器、2500万悟道科研基金开始申请...
No.24 智源社区预训练组预训练研究观点资源活动关于周刊超大规模预训练模型是当前人工智能领域研究的热点,为了帮助研究与工程人员了解这一领域的进展和资讯,智源社区整理了第24期&l ...
代码表征预训练语言模型学习指南：原理、分析和代码
©作者 | 孙秋实学校 | 华东师范大学研究方向 | 自然语言处理自从 2020 年 CodeBERT 开了代码表征预训练模型(本文称之为 CodePTM)这个新坑后,在短短两年的时间内出现了若 ...
在Keras的Embedding层中使用预训练的word2vec词向量
文章目录 1 准备工作 1.1 什么是词向量? 1.2 获取词向量 2 转化词向量为keras所需格式 2.1 获取所有词语word和词向量 2.2 构造"词语-词向量"字典 2. ...

预训练word2vec，代码

1.用于预训练词嵌入的数据集

1.1读取数据集

1.2下采样

1.3中心词和上下文词的提取

1.4负采样

1.5小批量加载训练实例

1.6整合代码

2.预训练word2vec

2.1跳元模型

2.1.1嵌入层

2.1.2定义前向传播

2.2训练

2.2.1 二元交叉熵损失

2.2.2初始化模型参数

2.2.3定义训练阶段代码

2.3应用词嵌入

预训练word2vec，代码相关推荐

最新文章

热门文章