第三章 神经网络基础--续
向量化
从文本数据集到向量化小批量的第二个阶段是迭代输入数据点的标记并将每个标记转换为整数形式。此迭代的结果应该是向量。因为这个向量将与来自其他数据点的向量组合，所以要求Vectorizer中的向量应该总是具有相同的长度。
为了实现这些目标，Vectorizer该类封装了评论Vocabulary，该评论将评论中的单词映射到整数。在例3-15中，Vectorizer使用Python的classmethod装饰器装饰方法from_dataframe，用于指示实例化的入口点Vectorizer。该方法from_dataframe以两个目标迭代Pandas数据帧的行。第一个目标是计算数据集中存在的所有令牌的频率。第二个目标是仅关键字参数相同的频率的令牌cutoff创建一个Vocabulary。这种方法是找到至少出现的所有单词cutof``f并将它们添加到Vocabulary。因为UNK令牌也被添加到了Vocabulary，未添加任何字将具有unk_index当所述Vocabulary的lookup_token方法被调用。
该方法vectorize封装了核心功能Vectorizer。它将表示输入的字符串作为参数，并返回的向量化表示。在此示例中，我们使用第1章中介绍的独热编码表示。这种表示创建了一个二进制向量 - 一个1s和0s 的向量- 其长度等于的大小Vocabulary。二进制向量具有1与评论中的单词对应的位置。请注意，此表示具有一些限制。首先它是稀疏的 - 评论中唯一单词的数量总是远远小于单词中的唯一单词数。第二是它丢弃了评论中出现的单词的顺序（“一袋单词”）。在随后的章节中，您将看到其他方法可以规避这些问题。
class ReviewDataset(Dataset):
def __init__(self, review_df, vectorizer):
"""
Args:
review_df (pandas.DataFrame): the dataset
vectorizer (ReviewVectorizer): vectorizer instantiated from dataset
"""
self.review_df = review_df
self._vectorizer = vectorizer
self.train_df = self.review_df[self.review_df.split=='train']
self.train_size = len(self.train_df)
self.val_df = self.review_df[self.review_df.split=='val']
self.validation_size = len(self.val_df)
self.test_df = self.review_df[self.review_df.split=='test']
self.test_size = len(self.test_df)
self._lookup_dict = {'train': (self.train_df, self.train_size),
'val': (self.val_df, self.validation_size),
'test': (self.test_df, self.test_size)}
self.set_split('train')
@classmethod
def load_dataset_and_make_vectorizer(cls, review_csv):
"""Load dataset and make a new vectorizer from scratch
Args:
review_csv (str): location of the dataset
Returns:
an instance of ReviewDataset
"""
review_df = pd.read_csv(review_csv)
train_review_df = review_df[review_df.split=='train']
return cls(review_df, ReviewVectorizer.from_dataframe(train_review_df))
@classmethod
def load_dataset_and_load_vectorizer(cls, review_csv, vectorizer_filepath):
"""Load dataset and the corresponding vectorizer.
Used in the case in the vectorizer has been cached for re-use
Args:
review_csv (str): location of the dataset
vectorizer_filepath (str): location of the saved vectorizer
Returns:
an instance of ReviewDataset
"""
review_df = pd.read_csv(review_csv)
vectorizer = cls.load_vectorizer_only(vectorizer_filepath)
return cls(review_df, vectorizer)
@staticmethod
def load_vectorizer_only(vectorizer_filepath):
"""a static method for loading the vectorizer from file
Args:
vectorizer_filepath (str): the location of the serialized vectorizer
Returns:
an instance of ReviewVectorizer
"""
with open(vectorizer_filepath) as fp:
return ReviewVectorizer.from_serializable(json.load(fp))
def save_vectorizer(self, vectorizer_filepath):
"""saves the vectorizer to disk using json
Args:
vectorizer_filepath (str): the location to save the vectorizer
"""
with open(vectorizer_filepath, "w") as fp:
json.dump(self._vectorizer.to_serializable(), fp)
def get_vectorizer(self):
""" returns the vectorizer """
return self._vectorizer
def set_split(self, split="train"):
"""selects the splits in the dataset using a column in the dataframe"""
self._target_split = split
self._target_df, self._target_size = self._lookup_dict[split]
def __len__(self):
return self._target_size
def __getitem__(self, index):
"""the primary entry point method for PyTorch datasets
Args:
index (int): the index to the data point
Returns:
a dict of the data point's features (x_data) and label (y_target)
"""
row = self._target_df.iloc[index]
review_vector = \
self._vectorizer.vectorize(row.review)
rating_index = \
self._vectorizer.rating_vocab.lookup_token(row.rating)
return {'x_data': review_vector,
'y_target': rating_index}
def get_num_batches(self, batch_size):
"""Given a batch size, return the number of batches in the dataset
Args:
batch_size (int)
Returns:
number of batches in the dataset
"""
return len(self) // batch_size
DATALOADER
文本到矢量化小批量的最后阶段是实际分组矢量化数据点。因为分组到计算机是训练神经网络的重要部分，PyTorch提供了一个称为DataLoader类，用于协调这个过程。DataLoader类是通过提供PyTorch实例化Dataset（例如，ReviewDataset在这个例子中所定义的），一个batch_size和其他关键字参数。生成的对象是一个Python迭代器，用于对提供的数据点进行分组和整理Dataset。在例3-16中，我们将函数包装DataLoader在一个generate_batches()函数中，该函数是一个生成器，可以方便地在CPU和GPU之间切换数据。
def generate_batches(dataset, batch_size, shuffle=True,
drop_last=True, device="cpu"):
"""
A generator function which wraps the PyTorch DataLoader. It will
ensure each tensor is on the write device location.
"""
dataloader = DataLoader(dataset=dataset, batch_size=batch_size,
shuffle=shuffle, drop_last=drop_last)
for data_dict in dataloader:
out_data_dict = {}
for name, tensor in data_dict.items():
out_data_dict[name] = data_dict[name].to(device)
yield out_data_dict
感知器分类器
我们在这里使用的模型是Perceptron我们在本章开头所示的重新实现。在ReviewClassifier从PyTorch的模块继承和创建单个Linear结合单输出层。因为这是二进制分类设置（负面或正面评论），所以这是一个合适的设置。sigmoid函数用作最终的非线性。
我们对forward方法进行参数化以允许可选地应用sigmoid函数。主要原因是，首先指出在二进制分类任务中，二元交叉熵损失（torch.nn.BCELoss）是最合适的损失函数。它在数学上适用于二元概率。然而，应用S形模型然后使用该损失函数存在数值稳定性问题。为了向用户提供更稳定的数字快捷方式，PyTorch提供了这些快捷方式BCEWithLogitsLoss。要使用此损失函数，输出不应该应用sigmoid函数。因此，默认情况下，我们不应用sigmoid。然而，在分类器的用户想要概率值的情况下，需要sigmoid，并将其留作选项。我们在例3-17的结果部分中看到了以这种方式使用它的示例。
import torch.nn as nn
import torch.nn.functional as F
class ReviewClassifier(nn.Module):
""" a simple perceptron based classifier """
def __init__(self, num_features):
"""
Args:
num_features (int): the size of the input feature vector
"""
super(ReviewClassifier, self).__init__()
self.fc1 = nn.Linear(in_features=num_features,
out_features=1)
def forward(self, x_in, apply_sigmoid=False):
"""The forward pass of the classifier
Args:
x_in (torch.Tensor): an input data tensor.
x_in.shape should be (batch, num_features)
apply_sigmoid (bool): a flag for the sigmoid activation
should be false if used with the Cross Entropy losses
Returns:
the resulting tensor. tensor.shape should be (batch,)
"""
y_out = self.fc1(x_in).squeeze()
if apply_sigmoid:
y_out = F.sigmoid(y_out)
return y_out
训练套路
在本节中，我们将描述训练的组成部分以及它们如何与数据集和模型结合在一起，以调整模型参数并提高其性能。从本质上讲，训练例程负责实例化模型，迭代数据集，在给定数据作为输入时计算模型的输出，计算损失（模型有多错），并更新与模型成比例的模型。表面看起来管理很多细节，但是需要改变的地方并不多，因此在您的深度学习开发过程中它将变得非常习惯。为了帮助管理更高级别的决策，我们使用一个args对象来集中保存所有决策点，您可以在例3-18中看到
from argparse import Namespace
args = Namespace(
# Data and Path information
frequency_cutoff=25,
model_state_file='model.pth',
review_csv='data/yelp/reviews_with_splits_lite.csv',
save_dir='model_storage/ch3/yelp/',
vectorizer_file='vectorizer.json',
# No Model hyper parameters
# Training hyper parameters
batch_size=128,
early_stopping_criteria=5,
learning_rate=0.001,
num_epochs=100,
seed=1337,
# ... runtime options omitted for space
)
在本节的其余部分，我们首先描述训练状态，我们用来跟踪培训过程信息的字典。当您跟踪有关训练例程的更多详细信息时，此词典将会增长，但我们下一个示例中提供的词典是您在模型培训期间将要跟踪的基本信息集。在描述训练状态之后，我们将概述为要执行的模型训练而实例化的对象集。这包括模型本身，数据集，优化程序和损失函数。在其他示例和补充材料中，我们包含其他组件，但为简单起见，我们不在文本中列出它们。最后，我们用训练循环本身结束本节，并演示标准的PyTorch优化模式。
为培训开始奠定基础
例3-19显示了我们为此示例实例化的训练组件。第一项是初始训练状态。该函数接受args对象作为参数，以便训练状态可以处理复杂的信息，但在本书的文本中，我们没有显示任何这些复杂性。我们向您推荐补充材料，以了解您可以在培训状态中使用哪些其他内容。此处显示的最小集包括纪元索引以及培训损失，培训准确性，验证损失和验证准确性的列表。它还包括两个测试损失和测试精度的字段。
接下来要实例化的两个项目是数据集和模型。在本例中，以及本书其余部分的示例中，我们设计了负责实例化矢量化器的数据集。在补充材料中，数据集实例化嵌套在if-statement中，该-statement允许加载先前实例化的矢量化器或新的实例化，该实例化也将矢量化器保存到磁盘。通过协调用户的愿望（通过args.cuda）和检查GPU设备是否确实可用的条件，模型被重要地移动到正确的设备。目标设备用于generate_batches核心训练循环中的函数调用，以便数据和模型位于相同的设备位置。
初始实例化中的最后两项是损失函数和优化程序。此示例中使用的损失函数是BCEWithLogitsLoss。有关使用此损失，请参阅“A Perceptron分类器”，其中描述了该模型。简而言之，二进制分类最合适的损失函数是二进制交叉熵（BCE）损失，并且将BCEWithLogitsLoss不应用sigmoid函数的模型与输出结果配对比在配对中更具数值稳定性。BCELoss使用将sigmoid函数应用于输出的模型。我们使用的优化器是Adam优化器。一般来说，Adam与其他优化器，截至本文撰写时，没有令人信服的证据说明Adam比其他的差。我们鼓励您通过尝试其他优化器并注意性能来自行验证。
import torch.optim as optim
def make_train_state(args):
return {'epoch_index': 0,
'train_loss': [],
'train_acc': [],
'val_loss': [],
'val_acc': [],
'test_loss': -1,
'test_acc': -1}
train_state = make_train_state(args)
if not torch.cuda.is_available():
args.cuda = False
args.device = torch.device("cuda" if args.cuda else "cpu")
# dataset and vectorizer
dataset = ReviewDataset.load_dataset_and_make_vectorizer(args.review_csv)
vectorizer = dataset.get_vectorizer()
# model
classifier = ReviewClassifier(num_features=len(vectorizer.review_vocab))
classifier = classifier.to(args.device)
# loss and optimizer
loss_func = nn.BCEWithLogitsLoss()
optimizer = optim.Adam(classifier.parameters(), lr=args.learning_rate)
训练循环
训练循环使用初始实例化中的对象来更新模型参数，以便随着时间的推移而改进。更具体地说，训练循环由两个循环组成：数据集中的小环上的内循环和外循环，其重复内循环多次。在内循环中，计算每个小批量的损失，优化程序用于更新模型参数。
要开始更全面地了解正在发生的事情，让我们从下面的代码片段的顶部开始。在第一行中，我们使用for-循环，其范围超过了epoch。epoch是您可以设置的超参数。它控制训练例程应该对数据集进行多少次传递。在实践中，您应该使用类似早期停止标准的东西在它到达结束之前终止此循环。在补充材料中，我们将展示如何做到这一点。
在for-循环的顶部，发生了几个例程定义和实例化。首先，设置训练状态的纪元索引。然后，设置数据集的分割（'train'，'val'``'test'）。最好在generate_batches()调用之前设置拆分。之后batch_generator被创建，两个浮点数被实例化跟踪损失和准确性。有关我们在这里使用的“运行平均公式”的更多详细信息，我们将向您推荐“ 移动平均 ”维基百科页面。最后，我们称之为分类器.train()指示模型处于“训练模式”并且模型参数是可变的方法。
训练循环的下一部分是迭代训练批次batch_generator并执行更新模型参数的基本操作。在每次批处理迭代中，首先使用该optimizer.zero_grad()方法重置优化程序的渐变。然后，从模型计算输出。接下来，损失函数用于计算模型输出和监督目标（真实类标签）之间的损失。在此之后，在loss.backward()损失对象（而不是损失函数对象）上调用该方法，导致梯度传播到每个参数。最后，优化器使用这些传播的渐变来执行参数更新optimizer.step()方法。这五个步骤是梯度下降的基本步骤。除此之外，还有一些额外的记账和跟踪操作。具体而言，计算损失和准确度值（存储为常规Python变量），然后用于更新运行损失和运行准确性变量。
在训练拆分批次的内循环之后，有几个簿记和实例化操作。具体而言，首先使用最终损失和准确度值更新训练状态。然后，创建新的批生产器，运行损失和运行精度。循环验证数据几乎与训练数据相同，因此重复使用相同的变量。有一个主要区别：.eval()调用分类器的方法，它对分类器的方法执行逆操作.train()。该.eval()方法使模型参数不可变并禁用Dropout。该eval模式还禁止计算梯度的损失和传播回参数。这很重要，因为我们不希望模型相对于验证数据调整其参数。相反，我们希望这些数据可以作为模型执行情况的衡量标准。如果训练数据的测量性能与验证数据的测量性能之间存在较大差异，则模型可能过度拟合训练数据，您应该对模型或训练程序进行调整（例如设置早期停止，我们在本例的补充笔记本中使用）。
在迭代验证数据并保存得到的验证损失和准确度值之后，外部for循环完成。我们在本书中实现的每个训练程序都遵循非常相似的设计模式。实际上，所有梯度下降算法都遵循类似的设计模式。在你已经习惯于从头开始编写这个循环之后，你将学会用它来实现渐变下降！例3-20给出了代码。
for epoch_index in range(args.num_epochs):
train_state['epoch_index'] = epoch_index
# Iterate over training dataset
# setup: batch generator, set loss and acc to 0, set train mode on
dataset.set_split('train')
batch_generator = generate_batches(dataset,
batch_size=args.batch_size,
device=args.device)
running_loss = 0.0
running_acc = 0.0
classifier.train()
for batch_index, batch_dict in enumerate(batch_generator):
# the training routine is 5 steps:
# step 1. zero the gradients
optimizer.zero_grad()
# step 2. compute the output
y_pred = classifier(x_in=batch_dict['x_data'].float())
# step 3. compute the loss
loss = loss_func(y_pred, batch_dict['y_target'].float())
loss_batch = loss.item()
running_loss += (loss_batch - running_loss) / (batch_index + 1)
# step 4. use loss to produce gradients
loss.backward()
# step 5. use optimizer to take gradient step
optimizer.step()
# -----------------------------------------
# compute the accuracy
acc_batch = compute_accuracy(y_pred, batch_dict['y_target'])
running_acc += (acc_batch - running_acc) / (batch_index + 1)
train_state['train_loss'].append(running_loss)
train_state['train_acc'].append(running_acc)
# Iterate over val dataset
# setup: batch generator, set loss and acc to 0; set eval mode on
dataset.set_split('val')
batch_generator = generate_batches(dataset,
batch_size=args.batch_size,
device=args.device)
running_loss = 0.
running_acc = 0.
classifier.eval()
for batch_index, batch_dict in enumerate(batch_generator):
# step 1. compute the output
y_pred = classifier(x_in=batch_dict['x_data'].float())
# step 2. compute the loss
loss = loss_func(y_pred, batch_dict['y_target'].float())
loss_batch = loss.item()
running_loss += (loss_batch - running_loss) / (batch_index + 1)
# step 3. compute the accuracy
acc_batch = compute_accuracy(y_pred, batch_dict['y_target'])
running_acc += (acc_batch - running_acc) / (batch_index + 1)
train_state['val_loss'].append(running_loss)
train_state['val_acc'].append(running_acc)
评估，推理和检查
在获得训练有素的模型之后，接下来的步骤是评估它对一些数据保留的影响，用它来推断新数据，或者检查模型权重以查看它的学习内容。在本节中，我们将向您展示所有三个步骤。
评估测试数据
为了评估保持测试集上的数据，代码与我们在前一个示例中看到的训练例程中的验证循环完全相同，只有一个小的区别：分割设置为'test'而不是'val'。数据集的两个分区之间的差异来自于测试集应该尽可能少地运行的事实。每次在测试集上运行训练模型时，做出新的模型决策（例如更改图层的大小），并在测试集上重新测量新的重新训练模型，就会使建模决策偏向于测试数据。换句话说，如果你经常重复这个过程，测试集将变得毫无意义，作为真正保持数据的准确度量。例3-21更仔细地研究了这一点。
dataset.set_split('test')
batch_generator = generate_batches(dataset,
batch_size=args.batch_size,
device=args.device)
running_loss = 0.
running_acc = 0.
classifier.eval()
for batch_index, batch_dict in enumerate(batch_generator):
# compute the output
y_pred = classifier(x_in=batch_dict['x_data'].float())
# compute the loss
loss = loss_func(y_pred, batch_dict['y_target'].float())
loss_batch = loss.item()
running_loss += (loss_batch - running_loss) / (batch_index + 1)
# compute the accuracy
acc_batch = compute_accuracy(y_pred, batch_dict['y_target'])
running_acc += (acc_batch - running_acc) / (batch_index + 1)
train_state['test_loss'] = running_loss
train_state['test_acc'] = running_acc
print("Test loss: {:.3f}".format(train_state['test_loss']))
print("Test Accuracy: {:.2f}".format(train_state['test_acc']))
Test loss: 0.297
Test Accuracy: 90.55
推断和分类新数据点
评估模型的另一种方法是对新数据进行推断，并对模型是否有效进行定性判断。我们可以在例3-22中看到这一点。
def predict_rating(review, classifier, vectorizer,
decision_threshold=0.5):
"""Predict the rating of a review
Args:
review (str): the text of the review
classifier (ReviewClassifier): the trained model
vectorizer (ReviewVectorizer): the corresponding vectorizer
decision_threshold (float): The numerical boundary which
separates the rating classes
"""
review = preprocess_text(review)
vectorized_review = torch.tensor(vectorizer.vectorize(review))
result = classifier(vectorized_review.view(1, -1))
probability_value = F.sigmoid(result).item()
index = 1
if probability_value < decision_threshold:
index = 0
return vectorizer.rating_vocab.lookup_index(index)
test_review = "this is a pretty awesome book"
prediction = predict_rating(test_review, classifier, vectorizer)
print("{} -> {}".format(test_review, prediction)
this is a pretty awesome book -> positive
检查模型重量
最后，了解模型在完成培训后是否表现良好的最后一种方法是检查权重并对其是否正确进行定性判断。如例3-23所示，使用Perceptron和折叠的单热编码，这是一种相当简单的方法，因为每个模型权重与我们词汇表中的单词完全对应。
# Sort weights
fc1_weights = classifier.fc1.weight.detach()[0]
_, indices = torch.sort(fc1_weights, dim=0, descending=True)
indices = indices.numpy().tolist()
# Top 20 words
print("Influential words in Positive Reviews:")
print("--------------------------------------")
for i in range(20):
print(vectorizer.review_vocab.lookup_index(indices[i]))
Influential words in Positive Reviews:
--------------------------------------
great
awesome
amazing
love
friendly
delicious
best
excellent
definitely
perfect
fantastic
wonderful
vegas
favorite
loved
yummy
fresh
reasonable
always
recommend
# Top 20 negative words
print("Influential words in Negative Reviews:")
print("--------------------------------------")
indices.reverse()
for i in range(20):
print(vectorizer.review_vocab.lookup_index(indices[i]))
Influential words in Negative Reviews:
--------------------------------------
worst
horrible
mediocre
terrible
not
rude
bland
disgusting
dirty
awful
poor
disappointing
ok
no
overpriced
sorry
nothing
meh
manager
gross
摘要
在本章中，您学习了监督神经网络训练的一些基本概念：
- 最简单的神经网络模型，Perceptrons
- 基本概念，如激活函数，损失函数及其不同类型
- 在玩具示例的上下文中，训练循环，批量大小和时期
- 什么概括意味着，以及使用培训/测试/验证拆分来衡量泛化性能的良好实践
- 提前停止和其他标准，以确定训练算法的终点或收敛
- 什么超参数和它们的一些例子，如批量大小，学习率等
- 如何使用PyTorch中实现的Perceptron模型对Yelp餐厅的英语评论进行分类，
- 及如何通过检查其权重来解释模型
