采取例如，这个来自数据集的讽刺标题：

christian bale given neutered male statuette named oscar

假设我们词汇表中的所有单词都以 0 值开头，我们可以将这句话中每个单词的值加 1，最终得到：

{ "christian" : 1, "bale" : 1, "given" : 1, "neutered": 1, "male" : 1, 
  "statuette": 1, "named" : 1, "oscar": 1}

然后，在下一步中，考虑一个普通的标题，而不是讽刺的标题，如下所示：

gareth bale scores wonder goal against germany

因为这是不同的情绪，我们可以从每个单词的当前值中减去 1，所以我们的值集将如下所示：

{ "christian" : 1, "bale" : 0, "given" : 1, "neutered": 1, "male" : 1,
  "statuette": 1, "named" : 1, "oscar": 1, "gareth" : -1, "scores": -1,
  "wonder" : -1, "goal" : -1, "against" : -1, "germany" : -1}

请注意，讽刺的“bale”（来自“christian bale”）已被非讽刺的“bale”（来自“gareth bale”）抵消，因此它的分数最终为 0。重复此过程数千次，你将结束从你的语料库中根据它们的使用情况评分的大量单词列表。

现在想象一下我们要建立这句话的情感：

neutered male named against germany, wins statuette!

使用我们现有的值集，我们可以查看每个单词的分数并将它们相加。我们会得到 2 分，表明（因为它是一个正数）这是一个讽刺的句子。

更深入一点：向量

希望前面的例子帮助你理解了通过与同一“方向”上的其他词的关联，为一个词建立某种形式的相对意义的心智模型。在我们的例子中，虽然计算机不理解单个词的含义，但它可以将已知讽刺标题中的标记词朝一个方向移动（通过加 1），并将来自已知正常标题的标记词朝另一个方向移动（通过减去 1 ). 这使我们对单词的含义有了基本的理解，但确实失去了一些细微差别。

如果我们增加方向的维度以尝试捕获更多信息会怎样？例如，假设我们要看简·奥斯丁小说《傲慢与偏见》中的人物，考虑性别和贵族的维度。我们可以将前者绘制在 x 轴上，将后者绘制在 y 轴上，向量的长度表示每个角色的财富（图 6-1）。

通过检查图形，您可以得出有关每个字符的大量信息。其中三个是男性。达西先生非常富有，但他的贵族身份并不明确（他被称为“先生”，这与不太富有但显然更高贵的威廉·卢卡斯爵士不同）。另一位“先生”，班纳特先生，显然不是贵族，在经济上举步维艰。他的女儿伊丽莎白·班纳特 (Elizabeth Bennet) 与他相似，但为女性。凯瑟琳夫人，我们例子中的另一个女性角色，高贵且非常富有。达西先生和伊丽莎白之间的罗曼史引起了紧张——从矢量的高尚的一面到不那么高贵的一面的偏见。

正如这个例子所示，通过考虑多个维度，我们可以开始看到单词（这里是字符名称）的真正含义。同样，我们不是在谈论具体的定义，而是基于轴的相对含义以及一个词的向量与其他向量之间的关系。

这使我们想到了嵌入的概念，它只是在训练神经网络时学习的单词的向量表示。接下来我们将探讨这一点。

使用嵌入构建讽刺检测器

在第 5 章你加载并在称为讽刺检测新闻头条数据集（简称 Sarcasm）的 JSON 数据集上进行了一些预处理。当你完成时，你已经有了训练和测试数据和标签的列表。这些可以转换为 Numpy 格式，供 TensorFlow 用于训练，代码如下：

import numpy as np
training_padded = np.array(training_padded)
training_labels = np.array(training_labels)
testing_padded = np.array(testing_padded)
testing_labels = np.array(testing_labels)

tokenizer = Tokenizer(num_words=vocab_size, oov_token=oov_tok)

tf.keras.layers.Embedding(vocab_size, embedding_dim),

随着时间的推移，当网络通过将训练数据与其标签匹配来学习时，将通过反向传播学习维度。

下一步重要的是将嵌入层的输出馈送到致密层。执行此操作的最简单方法（类似于使用卷积神经网络时的方法）是使用池化。在这种情况下，嵌入的维度被平均以产生固定长度的输出向量。

例如，考虑这个模型架构：

model = tf.keras.Sequential([
    tf.keras.layers.Embedding(10000, 16),
    tf.keras.layers.GlobalAveragePooling1D(),
    tf.keras.layers.Dense(24, activation='relu'),
    tf.keras.layers.Dense(1, activation='sigmoid')
])
model.compile(loss='binary_crossentropy',
              optimizer='adam',metrics=['accuracy'])

这里定义了一个嵌入层，并为其指定了词汇大小 ( 10000) 和嵌入维数16。让我们看一下网络中可训练参数的数量，使用model.summary：

Model: "sequential_2"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
embedding_2 (Embedding)      (None, None, 16)          160000    
_________________________________________________________________
global_average_pooling1d_2 ( (None, 16)                0         
_________________________________________________________________
dense_4 (Dense)              (None, 24)                408       
_________________________________________________________________
dense_5 (Dense)              (None, 1)                 25        
=================================================================
Total params: 160,433
Trainable params: 160,433
Non-trainable params: 0
_________________________________________________________________

由于嵌入有 10,000 个单词的词汇表，每个单词都是 16 维的向量，因此可训练参数的总数为 160,000。

平均池化层有 0 个可训练参数，因为它只是对之前嵌入层中的参数进行平均，以获得单个 16 值向量。

然后将其送入 24 个神经元的致密层。请记住，密集神经元使用权重和偏差进行有效计算，因此需要学习 (24 × 16) + 16 = 408 个参数。

然后将该层的输出传递到最后的单神经元层，其中将有 (1 × 24) + 1 = 25 个参数需要学习。

如果我们训练这个模型，在 30 个时期后我们将获得 99+% 的相当不错的准确率——但我们的验证准确率将只有大约 81%（图 6-2）。

图 6-2。训练准确性与验证准确性

 考虑到验证数据可能包含许多训练数据中不存在的词，这似乎是一条合理的曲线。但是，如果您检查30 个时期内训练与验证的损失曲线，你会发现一个问题。尽管您希望看到训练准确度高于验证准确度，但一个明确的指标过度拟合是，虽然验证准确率随着时间的推移略有下降（在图 6-2中），但它的损失却在急剧增加，如图 6-3所示。

过拟合当网络对训练数据过度专业化时，就会发生这种情况，其中一部分是它已经非常擅长匹配训练集中“嘈杂”数据中的模式，而这些模式在其他任何地方都不存在。因为验证集中不存在这种特殊的噪声，所以网络匹配得越好，验证集的损失就越严重。这会导致您在图 6-3中看到的不断增加的损失。在本节中，我们将探讨几种泛化模型和减少过度拟合的方法。

调整学习率

也许可能导致过度拟合的最大因素是优化器的学习率是否过高。这意味着网络学习太快了。对于这个例子，编译模型的代码如下：

model.compile(loss='binary_crossentropy',
              optimizer='adam', metrics=['accuracy'])

优化器简单地声明为adam，它使用默认参数调用 Adam 优化器。但是，此优化器支持多个参数，包括学习率。您可以将代码更改为：

adam = tf.keras.optimizers.Adam(learning_rate=0.0001, 
                                 beta_1=0.9, beta_2=0.999, amsgrad=False)

model.compile(loss='binary_crossentropy',
              optimizer=adam, metrics=['accuracy'])

其中学习率的默认值（通常为 0.001）已减少 90% 至 0.0001。和beta_1值beta_2保持默认值， 也是如此amsgrad。beta_1并且beta_2必须介于 0 和 1 之间，通常两者都接近 1。Amsgrad 是 Adam 优化器的替代实现，在Sashank Reddi、Satyen Kale 和 Sanjiv Kumar 的论文“On the Convergence of Adam and Beyond”中介绍。

这个低得多的学习率对网络有深远的影响。图 6-4显示了网络超过 100 个时期的准确率。在前 10 个时期左右可以看到较低的学习率，在网络“爆发”并开始快速学习之前，网络似乎没有在学习。

图 6-4。较低学习率的准确性

探索损失（如图 6-5所示）我们可以看到，即使在前几个时期的准确性没有上升，损失也在下降，所以你可以相信网络最终会开始学习，如果你一个时代一个时代地看着它。

图 6-5。学习率较低的损失

 虽然损失确实开始显示与您在图 6-3中看到的相同的过度拟合曲线，但请注意，它发生的时间要晚得多，而且发生率要低得多。到第 30 轮时，损失约为 0.45，而图 6-3中学习率较高时，损失是该数量的两倍多。虽然网络需要更长的时间才能达到良好的准确率，但它的损失更少，因此您可以对结果更有信心。使用这些超参数，验证集的损失在大约第 60 个时期开始增加，此时训练集的准确度为 90%，验证集的准确度约为 81%，表明我们拥有一个非常有效的网络。

当然，调整优化器然后宣布胜利很容易，但是您可以使用许多其他方法来改进您的模型，您将在接下来的几节中看到这些方法。对于这些，我恢复使用默认的 Adam 优化器，因此调整学习率的效果不会隐藏这些其他技术提供的好处。

wc=tokenizer.word_counts
print(wc)

OrderedDict([('former', 75), ('versace', 1), ('store', 35), ('clerk', 8), 
     ('sues', 12), ('secret', 68), ('black', 203), ('code', 16),...

from collections import OrderedDict
newlist = (OrderedDict(sorted(wc.items(), key=lambda t: t[1], reverse=True)))
print(newlist)

OrderedDict([('new', 1143), ('trump', 966), ('man', 940), ('not', 555), ('just',
430), ('will', 427), ('one', 406), ('year', 386),

xs=[]
ys=[]
curr_x = 1
for item in newlist:
  xs.append(curr_x)
  curr_x=curr_x+1
  ys.append(newlist[item])

plt.plot(xs,ys)
plt.show()

plt.plot(xs,ys)
plt.axis([300,10000,0,100])
plt.show()

探索模型架构

后经过前面部分的优化，模型架构现在看起来像这样：

model = tf.keras.Sequential([
    tf.keras.layers.Embedding(2000, 7),
    tf.keras.layers.GlobalAveragePooling1D(),
    tf.keras.layers.Dense(24, activation='relu'),
    tf.keras.layers.Dense(1, activation='sigmoid')
])
model.compile(loss='binary_crossentropy',
              optimizer='adam',metrics=['accuracy'])

突然想到的一件事是维度——该GlobalAveragePooling1D层现在只发射七个维度，但它们被馈送到一个由 24 个神经元组成的密集层中，这太过分了。让我们探索一下当它减少到只有八个神经元并训练一百个时期时会发生什么。

你可以在图 6-12中看到训练与验证的准确性。与使用 24 个神经元的图 6-7相比，整体结果非常相似，但波动已被平滑（在线条中可见锯齿较少）。训练速度也稍快一些。

图 6-12。降低密集架构精度结果

同样，图 6-13中的损失曲线显示了类似的结果，但锯齿状减少了。

图 6-13。减少密集架构损失结果

 

model = tf.keras.Sequential([
    tf.keras.layers.Embedding(vocab_size, embedding_dim),
    tf.keras.layers.GlobalAveragePooling1D(),
    tf.keras.layers.Dense(8, activation='relu'),
    tf.keras.layers.Dropout(.25),
    tf.keras.layers.Dense(1, activation='sigmoid')
])

model = tf.keras.Sequential([
    tf.keras.layers.Embedding(vocab_size, embedding_dim),
    tf.keras.layers.GlobalAveragePooling1D(),
    tf.keras.layers.Dense(8, activation='relu', 
             kernel_regularizer = tf.keras.regularizers.l2(0.01)),
    tf.keras.layers.Dense(1, activation='sigmoid')
])

xs=[]
ys=[]
current_item=1
for item in sentences:
    xs.append(current_item)
    current_item=current_item+1
    ys.append(len(item))
newys = sorted(ys)

import matplotlib.pyplot as plt
plt.plot(xs,newys)
plt.show()

使用模型对句子进行分类

现在您已经创建了模型，对其进行了训练并对其进行了优化以消除导致过度拟合的许多问题，下一步是运行模型并检查其结果。为此，创建一个新句子数组。例如：

sentences = ["granny starting to fear spiders in the garden might be real", 
             "game of thrones season finale showing this sunday night", 
             "TensorFlow book will be a best seller"]

sequences = tokenizer.texts_to_sequences(sentences)
print(sequences)

[[1, 816, 1, 691, 1, 1, 1, 1, 300, 1, 90], 
 [111, 1, 1044, 173, 1, 1, 1, 1463, 181], 
 [1, 234, 7, 1, 1, 46, 1]]

padded = pad_sequences(sequences, maxlen=max_length, 
                       padding=padding_type, truncating=trunc_type)
print(padded)

[   1  816    1  691    1    1    1    1  300    1   90    0    0    0
    0    0    0    0    0    0    0    0    0    0    0    0    0    0
    0    0    0    0    0    0    0    0    0    0    0    0    0    0
    0    0    0    0    0    0    0    0    0    0    0    0    0    0
    0    0    0    0    0    0    0    0    0    0    0    0    0    0
    0    0    0    0    0    0    0    0    0    0    0    0    0    0
    0    0    0    0    0    0    0    0    0    0    0    0    0    0
    0    0]

print(model.predict(padded))

[[0.7194135 ]
 [0.02041999]
 [0.13156283]]