一用于处理这些情况的工具是词汇外(OOV) 标记。这可以帮助您的神经网络理解包含以前看不见的文本的数据的上下文。例如，给定前面的小示例语料库，假设你想处理这样的句子：

test_data = [
    'Today is a snowy day',
    'Will it be rainy tomorrow?'
]

请记住，您并不是将此输入添加到现有文本的语料库（您可以将其视为训练数据），而是考虑预训练网络如何查看此文本。如果你用你已经使用过的词和你现有的分词器来分词，就像这样：

test_sequences = tokenizer.texts_to_sequences(test_data)
print(word_index)
print(test_sequences)

您的结果将如下所示：

{'today': 1, 'is': 2, 'a': 3, 'sunny': 4, 'day': 5, 'rainy': 6, 'it': 7}
[[1, 2, 3, 5], [7, 6]]

所以新的句子，将标记换回单词，将是“今天是一天”和“下雨了”。

如您所见，您几乎失去了所有上下文和意义。词汇表外的标记在这里可能会有所帮助，您可以在标记器中指定它。您可以通过添加一个名为 的参数来执行此操作oov_token，如此处所示——您可以为其分配您喜欢的任何字符串，但要确保它不会出现在您的语料库中的其他地方：

tokenizer = Tokenizer(num_words = 100, oov_token="<OOV>")
tokenizer.fit_on_texts(sentences)
word_index = tokenizer.word_index

sequences = tokenizer.texts_to_sequences(sentences)

test_sequences = tokenizer.texts_to_sequences(test_data)
print(word_index)
print(test_sequences)

您会看到输出有所改进：

{'<OOV>': 1, 'today': 2, 'is': 3, 'a': 4, 'sunny': 5, 'day': 6, 'rainy': 7, 
 'it': 8}

[[2, 3, 4, 1, 6], [1, 8, 1, 7, 1]]

您的标记列表有一个新项目“<OOV>”，并且您的测试句子保持其长度。反向编码它们现在将给出“今天是 <OOV> 日”和“<OOV> it <OOV> rainy <OOV>”。

前者更接近本意。后者，因为它的大部分词不在语料库中，仍然缺乏很多上下文，但它是朝着正确方向迈出的一步。

了解填充

什么时候训练神经网络，您通常需要所有数据都具有相同的形状。回想一下前面的章节，当使用图像进行训练时，您将图像重新格式化为相同的宽度和高度。对于文本，你会面临同样的问题——一旦你标记了你的单词并将你的句子转换成序列，它们的长度都可能不同。要使它们具有相同的大小和形状，您可以使用padding。

为了探索填充，让我们在语料库中添加另一个更长的句子：

sentences = [
    'Today is a sunny day',
    'Today is a rainy day',
    'Is it sunny today?',
    'I really enjoyed walking in the snow today'
]

当你排序时，你会看到你的数字列表有不同的长度：

[
  [2, 3, 4, 5, 6], 
  [2, 3, 4, 7, 6], 
  [3, 8, 5, 2], 
  [9, 10, 11, 12, 13, 14, 15, 2]
]

（当你打印序列时，它们都在一行上，但为了清楚起见，我在这里将它们分成不同的行。）

如果你想让这些长度相同，你可以使用 pad_sequences应用程序接口。首先，您需要导入它：

from tensorflow.keras.preprocessing.sequence import pad_sequences

API 的使用非常简单。要将您的（未填充的）序列转换为填充集，您只需pad_sequences这样调用：

padded = pad_sequences(sequences)

print(padded)

您将获得一组格式良好的序列。它们也将在不同的行上，如下所示：

[[ 0  0  0  2  3  4  5  6]
 [ 0  0  0  2  3  4  7  6]
 [ 0  0  0  0  3  8  5  2]
 [ 9 10 11 12 13 14 15  2]]

序列被填充0，这不是我们单词列表中的标记。如果你想知道为什么令牌列表从 1 开始，而通常程序员从 0 开始计数，现在你知道了！

您现在拥有可用于训练的规则形状的东西。但在开始之前，让我们稍微研究一下这个 API，因为它为您提供了许多选项，您可以使用这些选项来改进数据。

首先，您可能已经注意到，对于较短的句子，为了使它们与最长的句子形状相同，在开头添加了必要数量的零。这称为prepadding，这是默认行为。您可以使用padding参数更改它。例如，如果你希望你的序列在最后用零填充，你可以使用：

padded = pad_sequences(sequences, padding='post')

输出将是：

[[ 2  3  4  5  6  0  0  0]
 [ 2  3  4  7  6  0  0  0]
 [ 3  8  5  2  0  0  0  0]
 [ 9 10 11 12 13 14 15  2]]

你可以看到现在单词在填充序列的开头，字符0在结尾。

您可能已经观察到的下一个默认行为是，所有句子的长度都与最长的句子相同。这是一个明智的默认设置，因为这意味着您不会丢失任何数据。权衡是你得到了很多填充。但是如果你不想要这个怎么办，也许是因为你有一个疯狂的长句子，这意味着你在填充序列中有太多的填充？要解决这个问题，您可以使用maxlen参数，在调用 时指定所需的最大长度，pad_sequences如下所示：

padded = pad_sequences(sequences, padding='post', maxlen=6)

输出将是：

[[ 2  3  4  5  6  0]
 [ 2  3  4  7  6  0]
 [ 3  8  5  2  0  0]
 [11 12 13 14 15  2]]

现在你填充的序列都是相同的长度，并且没有太多的填充。但是，您从最长的句子中丢失了一些单词，并且它们从一开始就被截断了。如果您不想丢失开头的单词，而是希望它们从句子的末尾截断怎么办？您可以使用参数覆盖默认行为truncating，如下所示：

padded = pad_sequences(sequences, padding='post', maxlen=6, truncating='post')

结果将显示最长的句子现在在末尾而不是开头被截断：

[[ 2  3  4  5  6  0]
 [ 2  3  4  7  6  0]
 [ 3  8  5  2  0  0]
 [ 9 10 11 12 13 14]]

TFDS还包含一些使用子词的预处理 IMDb 数据集。在这里，您不必按单词分解句子；他们已经为你分成了子词。使用子词是将语料库拆分为单个字母（相对较少的低语义标记）和单个单词（许多具有高语义含义的标记）之间的中间方法，这种方法通常可以非常有效地用于训练语言分类器。这些数据集还包括用于拆分和编码语料库的编码器和解码器。

要访问它们，您可以调用tfds.load并传递它imdb_reviews/subwords8k或imdb_reviews/subwords32k像这样：

(train_data, test_data), info = tfds.load(
    'imdb_reviews/subwords8k', 
    split = (tfds.Split.TRAIN, tfds.Split.TEST),
    as_supervised=True,
    with_info=True
)

info您可以像这样访问对象上的编码器。这将帮助您了解vocab_size：

encoder = info.features['text'].encoder
print ('Vocabulary size: {}'.format(encoder.vocab_size))

这将输出8185，因为此实例中的词汇表由 8,185 个标记组成。如果要查看子词列表，可以使用以下encoder.subwords属性获取它：

print(encoder.subwords)

['the_', ', ', '. ', 'a_', 'and_', 'of_', 'to_', 's_', 'is_', 'br', 'in_', 'I_', 
 'that_',...]

您在这里可能会注意到的一些事情是停用词、标点符号和语法都在语料库中，HTML 标记也是如此，例如<br>. 空格由下划线表示，因此第一个标记是单词“the”。

如果你想编码一个字符串，你可以像这样使用编码器：

sample_string = 'Today is a sunny day'

encoded_string = encoder.encode(sample_string)
print ('Encoded string is {}'.format(encoded_string))

其输出将是一个令牌列表：

Encoded string is [6427, 4869, 9, 4, 2365, 1361, 606]

所以，你的五个词被编码成七个标记。要查看标记，您可以使用subwords编码器上的属性，它返回一个数组。它是从零开始的，因此虽然“Today”中的“Tod”被编码为6427，但它是数组中的第 6,426 项：

print(encoder.subwords[6426])
Tod

如果要解码，可以使用decodeencoder的方法：

encoded_string = encoder.encode(sample_string)

original_string = encoder.decode(encoded_string)
test_string = encoder.decode([6427, 4869, 9, 4, 2365, 1361, 606])

后几行将有相同的结果encoded_string，因为尽管它的名字是一个标记列表，就像在下一行硬编码的标记一样。

现在文本语料库已被读入句子列表，您需要将其拆分为训练和测试子集以训练模型。例如，如果你想使用 28,000 个句子进行训练，其余的保留用于测试，你可以使用这样的代码：

training_size = 28000

training_sentences = sentences[0:training_size]
testing_sentences = sentences[training_size:]
training_labels = labels[0:training_size]
testing_labels = labels[training_size:]

现在您有了一个训练集，您需要从中创建单词索引。下面是使用分词器创建最多包含 20,000 个单词的词汇表的代码。我们将一个句子的最大长度设置为 10 个单词，通过截断末尾来截断较长的句子，在末尾填充较短的句子，并使用“<OOV>”：

vocab_size = 20000
max_length = 10
trunc_type='post'
padding_type='post'
oov_tok = "<OOV>"

tokenizer = Tokenizer(num_words=vocab_size, oov_token=oov_tok)
tokenizer.fit_on_texts(training_sentences)

word_index = tokenizer.word_index

training_sequences = tokenizer.texts_to_sequences(training_sentences)

training_padded = pad_sequences(training_sequences, maxlen=max_length, 
                                padding=padding_type, 
                                truncating=trunc_type)

training_sequences您可以通过查看和来检查结果training_padded。例如，这里我们打印训练序列中的第一项，您可以看到它是如何被填充到最大长度 10 的：

print(training_sequences[0])
print(training_padded[0])

[18, 3257, 47, 4770, 613, 508, 951, 423]
[  18 3257   47 4770  613  508  951  423    0    0]

您还可以通过打印来检查单词索引：

{'<OOV>': 1, 'just': 2, 'not': 3, 'now': 4, 'day': 5, 'get': 6, 'no': 7, 
 'good': 8, 'like': 9, 'go': 10, 'dont': 11, ...}

这里有很多词你可能想考虑去掉作为停用词，比如“喜欢”和“不要”。检查单词索引总是有用的。

Python 的json库使读取 JSON 文件变得简单。鉴于 JSON 使用名称/值对，您可以根据名称对内容进行索引。因此，例如，对于 Sarcasm 数据集，您可以创建 JSON 文件的文件句柄，使用库打开它json，进行迭代，逐行读取每个字段，并使用字段名称获取数据项.

import json
with open("/tmp/sarcasm.json", 'r') as f:
    datastore = json.load(f)
    for item in datastore:
        sentence = item['headline'].lower()
        label= item['is_sarcastic']
        link = item['article_link']

with open("/tmp/sarcasm.json", 'r') as f:
    datastore = json.load(f)

sentences = [] 
labels = []
urls = []
for item in datastore:
    sentence = item['headline'].lower()
    sentence = sentence.replace(",", " , ")
    sentence = sentence.replace(".", " . ")
    sentence = sentence.replace("-", " - ")
    sentence = sentence.replace("/", " / ")
    soup = BeautifulSoup(sentence)
    sentence = soup.get_text()
    words = sentence.split()
    filtered_sentence = ""
    for word in words:
        word = word.translate(table)
        if word not in stopwords:
            filtered_sentence = filtered_sentence + word + " "
    sentences.append(filtered_sentence)
    labels.append(item['is_sarcastic'])
    urls.append(item['article_link'])

和以前一样，这些可以分为训练集和测试集。如果要使用数据集中 26,000 项中的 23,000 项进行训练，可以执行以下操作：

training_size = 23000

training_sentences = sentences[0:training_size]
testing_sentences = sentences[training_size:]
training_labels = labels[0:training_size]
testing_labels = labels[training_size:]

要标记数据并为训练做好准备，您可以采用与之前相同的方法。在这里，我们再次指定 20,000 个单词的词汇量，最大序列长度为 10，并在末尾进行截断和填充，以及“<OOV>”的 OOV 标记：

vocab_size = 20000
max_length = 10
trunc_type='post'
padding_type='post'
oov_tok = "<OOV>"

tokenizer = Tokenizer(num_words=vocab_size, oov_token=oov_tok)
tokenizer.fit_on_texts(training_sentences)

word_index = tokenizer.word_index

training_sequences = tokenizer.texts_to_sequences(training_sentences)
padded = pad_sequences(training_sequences, padding='post')
print(word_index)

输出将是整个索引，按词频顺序排列：

{'<OOV>': 1, 'new': 2, 'trump': 3, 'man': 4, 'not': 5, 'just': 6, 'will': 7,  
 'one': 8, 'year': 9, 'report': 10, 'area': 11, 'donald': 12, ... }

希望看起来相似的代码将帮助您了解在为神经网络准备文本以进行分类或生成时可以遵循的模式。在下一章中，您将看到如何使用嵌入为文本构建分类器，而在第 7 章中，您将更进一步，探索递归神经网络。然后，在第 8 章中，您将看到如何进一步增强序列数据以创建可以生成新文本的神经网络！