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

:label:sec_word2vec_data

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

```{.python .input} from d2l import mxnet as d2l import math from mxnet import gluon, np import os import random

  2. ```{.python .input}
  3. #@tab pytorch
  4. from d2l import torch as d2l
  5. import math
  6. import torch
  7. import os
  8. import random

正在读取数据集

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

```{.python .input}

@tab all

@save

d2l.DATA_HUB[‘ptb’] = (d2l.DATA_URL + ‘ptb.zip’, ‘319d85e578af0cdc590547f26231e4e31cdf1e42’)

@save

def read_ptb(): “””将PTB数据集加载到文本行的列表中””” data_dir = d2l.download_extract(‘ptb’)

  1. # Readthetrainingset.
  2. with open(os.path.join(data_dir, 'ptb.train.txt')) as f:
  3.     raw_text = f.read()
  4. return [line.split() for line in raw_text.split('\n')]

sentences = read_ptb() f’# sentences数: {len(sentences)}’

  2. 在读取训练集之后，我们为语料库构建了一个词表，其中出现次数少于10次的任何单词都将由“<unk>”词元替换。请注意，原始数据集还包含表示稀有（未知）单词的“<unk>”词元。
  4. ```{.python .input}
  5. #@tab all
  6. vocab = d2l.Vocab(sentences, min_freq=10)
  7. f'vocab size: {len(vocab)}'

下采样

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

P(w_i) = \max\left(1 - \sqrt{\frac{t}{f(w_i)}}, 0\right),

其中$f(w_i)$是$w_i$的词数与数据集中的总词数的比率，常量$t$是超参数（在实验中为$10^{-4}$）。我们可以看到，只有当相对比率$f(w_i) > t$时，（高频）词$w_i$才能被丢弃，且该词的相对比率越高，被丢弃的概率就越大。

```{.python .input}

@tab all

@save

def subsample(sentences, vocab): “””下采样高频词”””

  1. # 排除未知词元'<unk>'
  2. sentences = [[token for token in line if vocab[token] != vocab.unk]
  3.              for line in sentences]
  4. counter = d2l.count_corpus(sentences)
  5. num_tokens = sum(counter.values())
  7. # 如果在下采样期间保留词元，则返回True
  8. def keep(token):
  9.     return(random.uniform(0, 1) <
  10.            math.sqrt(1e-4 / counter[token] * num_tokens))
  12. return ([[token for token in line if keep(token)] for line in sentences],
  13.         counter)

subsampled, counter = subsample(sentences, vocab)

  2. 下面的代码片段绘制了下采样前后每句话的词元数量的直方图。正如预期的那样，下采样通过删除高频词来显著缩短句子，这将使训练加速。
  4. ```{.python .input}
  5. #@tab all
  6. d2l.show_list_len_pair_hist(
  7.     ['origin', 'subsampled'], '# tokens per sentence',
  8.     'count', sentences, subsampled);

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

```{.python .input}

@tab all

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’)

  2. 相比之下，低频词“join”则被完全保留。
  4. ```{.python .input}
  5. #@tab all
  6. compare_counts('join')

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

```{.python .input}

@tab all

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

  2. ## 中心词和上下文词的提取
  4. 下面的`get_centers_and_contexts`函数从`corpus`中提取所有中心词及其上下文词。它随机采样1到`max_window_size`之间的整数作为上下文窗口。对于任一中心词，与其距离不超过采样上下文窗口大小的词为其上下文词。
  6. ```{.python .input}
  7. #@tab all
  8. #@save
  9. def get_centers_and_contexts(corpus, max_window_size):
  10.     """返回跳元模型中的中心词和上下文词"""
  11.     centers, contexts = [], []
  12.     for line in corpus:
  13.         # 要形成“中心词-上下文词”对，每个句子至少需要有2个词
  14.         if len(line) < 2:
  15.             continue
  16.         centers += line
  17.         for i in range(len(line)):  # 上下文窗口中间i
  18.             window_size = random.randint(1, max_window_size)
  19.             indices = list(range(max(0, i - window_size),
  20.                                  min(len(line), i + 1 + window_size)))
  21.             # 从上下文词中排除中心词
  22.             indices.remove(i)
  23.             contexts.append([line[idx] for idx in indices])
  24.     return centers, contexts

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

```{.python .input}

@tab all

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)

  2. 在PTB数据集上进行训练时，我们将最大上下文窗口大小设置为5。下面提取数据集中的所有中心词及其上下文词。
  4. ```{.python .input}
  5. #@tab all
  6. all_centers, all_contexts = get_centers_and_contexts(corpus, 5)
  7. f'# “中心词-上下文词对”的数量: {sum([len(contexts) for contexts in all_contexts])}'

负采样

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

```{.python .input}

@tab all

@save

class RandomGenerator: “””根据n个采样权重在{1,…,n}中随机抽取””” def init(self, sampling_weights):

  1.     # Exclude
  2.     self.population = list(range(1, len(sampling_weights) + 1))
  3.     self.sampling_weights = sampling_weights
  4.     self.candidates = []
  5.     self.i = 0
  7. def draw(self):
  8.     if self.i == len(self.candidates):
  9.         # 缓存k个随机采样结果
  10.         self.candidates = random.choices(
  11.             self.population, self.sampling_weights, k=10000)
  12.         self.i = 0
  13.     self.i += 1
  14.     return self.candidates[self.i - 1]
  2. 例如，我们可以在索引1、2和3中绘制10个随机变量$X$，采样概率为$P(X=1)=2/9, P(X=2)=3/9$和$P(X=3)=4/9$，如下所示。
  4. ```{.python .input}
  5. #@tab all
  6. #@save
  7. generator = RandomGenerator([2, 3, 4])
  8. [generator.draw() for _ in range(10)]

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

```{.python .input}

@tab all

@save

def get_negatives(all_contexts, vocab, counter, K): “””返回负采样中的噪声词”””

  1. # 索引为1、2、...（索引0是词表中排除的未知标记）
  2. sampling_weights = [counter[vocab.to_tokens(i)]**0.75
  3.                     for i in range(1, len(vocab))]
  4. all_negatives, generator = [], RandomGenerator(sampling_weights)
  5. for contexts in all_contexts:
  6.     negatives = []
  7.     while len(negatives) < len(contexts) * K:
  8.         neg = generator.draw()
  9.         # 噪声词不能是上下文词
  10.         if neg not in contexts:
  11.             negatives.append(neg)
  12.     all_negatives.append(negatives)
  13. return all_negatives

all_negatives = get_negatives(all_contexts, vocab, counter, 5)

  2. ## 小批量加载训练实例
  3. :label:`subsec_word2vec-minibatch-loading`
  5. 在提取所有中心词及其上下文词和采样噪声词后，将它们转换成小批量的样本，在训练过程中可以迭代加载。
  7. 在小批量中，$i^\mathrm{th}$个样本包括中心词及其$n_i$个上下文词和$m_i$个噪声词。由于上下文窗口大小不同，$n_i+m_i$对于不同的$i$是不同的。因此，对于每个样本，我们在`contexts_negatives`个变量中将其上下文词和噪声词连结起来，并填充零，直到连结长度达到$\max_i n_i+m_i$(`max_len`)。为了在计算损失时排除填充，我们定义了掩码变量`masks`。在`masks`中的元素和`contexts_negatives`中的元素之间存在一一对应关系，其中`masks`中的0（否则为1）对应于`contexts_negatives`中的填充。
  9. 为了区分正反例，我们在`contexts_negatives`中通过一个`labels`变量将上下文词与噪声词分开。类似于`masks`，在`labels`中的元素和`contexts_negatives`中的元素之间也存在一一对应关系，其中`labels`中的1（否则为0）对应于`contexts_negatives`中的上下文词的正例。
  11. 上述思想在下面的`batchify`函数中实现。其输入`data`是长度等于批量大小的列表，其中每个元素是由中心词`center`、其上下文词`context`和其噪声词`negative`组成的样本。此函数返回一个可以在训练期间加载用于计算的小批量，例如包括掩码变量。
  13. ```{.python .input}
  14. #@tab all
  15. #@save
  16. def batchify(data):
  17.     """返回带有负采样的跳元模型的小批量样本"""
  18.     max_len = max(len(c) + len(n) for _, c, n in data)
  19.     centers, contexts_negatives, masks, labels = [], [], [], []
  20.     for center, context, negative in data:
  21.         cur_len = len(context) + len(negative)
  22.         centers += [center]
  23.         contexts_negatives += \
  24.             [context + negative + [0] * (max_len - cur_len)]
  25.         masks += [[1] * cur_len + [0] * (max_len - cur_len)]
  26.         labels += [[1] * len(context) + [0] * (max_len - len(context))]
  27.     return (d2l.reshape(d2l.tensor(centers), (-1, 1)), d2l.tensor(
  28.         contexts_negatives), d2l.tensor(masks), d2l.tensor(labels))

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

```{.python .input}

@tab all

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)

  2. ## 整合代码
  4. 最后，我们定义了读取PTB数据集并返回数据迭代器和词表的`load_data_ptb`函数。
  6. ```{.python .input}
  7. #@save
  8. def load_data_ptb(batch_size, max_window_size, num_noise_words):
  9.     """下载PTB数据集，然后将其加载到内存中"""
  10.     sentences = read_ptb()
  11.     vocab = d2l.Vocab(sentences, min_freq=10)
  12.     subsampled, counter = subsample(sentences, vocab)
  13.     corpus = [vocab[line] for line in subsampled]
  14.     all_centers, all_contexts = get_centers_and_contexts(
  15.         corpus, max_window_size)
  16.     all_negatives = get_negatives(
  17.         all_contexts, vocab, counter, num_noise_words)
  18.     dataset = gluon.data.ArrayDataset(
  19.         all_centers, all_contexts, all_negatives)
  20.     data_iter = gluon.data.DataLoader(
  21.         dataset, batch_size, shuffle=True,batchify_fn=batchify,
  22.         num_workers=d2l.get_dataloader_workers())
  23.     return data_iter, vocab

```{.python .input}

@tab pytorch

@save

def load_data_ptb(batch_size, max_window_size, num_noise_words): “””下载PTB数据集，然后将其加载到内存中””” num_workers = d2l.get_dataloader_workers() 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)

  1. class PTBDataset(torch.utils.data.Dataset):
  2.     def __init__(self, centers, contexts, negatives):
  3.         assert len(centers) == len(contexts) == len(negatives)
  4.         self.centers = centers
  5.         self.contexts = contexts
  6.         self.negatives = negatives
  8.     def __getitem__(self, index):
  9.         return (self.centers[index], self.contexts[index],
  10.                 self.negatives[index])
  12.     def __len__(self):
  13.         return len(self.centers)
  15. dataset = PTBDataset(all_centers, all_contexts, all_negatives)
  17. data_iter = torch.utils.data.DataLoader(
  18.     dataset, batch_size, shuffle=True, 
  19.     collate_fn=batchify, num_workers=num_workers)
  20. return data_iter, vocab
  2. 让我们打印数据迭代器的第一个小批量。
  4. ```{.python .input}
  5. #@tab all
  6. data_iter, vocab = load_data_ptb(512, 5, 5)
  7. for batch in data_iter:
  8.     for name, data in zip(names, batch):
  9.         print(name, 'shape:', data.shape)
  10.     break

小结

  • 高频词在训练中可能不是那么有用。我们可以对他们进行下采样，以便在训练中加快速度。
  • 为了提高计算效率，我们以小批量方式加载样本。我们可以定义其他变量来区分填充标记和非填充标记，以及正例和负例。

练习

  1. 如果不使用下采样，本节中代码的运行时间会发生什么变化？
  2. RandomGenerator类缓存k个随机采样结果。将k设置为其他值，看看它如何影响数据加载速度。
  3. 本节代码中的哪些其他超参数可能会影响数据加载速度？

:begin_tab:mxnet Discussions :end_tab:

:begin_tab:pytorch Discussions :end_tab: