办个网站需要投资多少,网页翻译在哪,江苏网站建设网络推广,免费vps试用一年PyTorch深度学习实战#xff08;6#xff09;——神经网络性能优化技术 0. 前言1. 数据准备1.1 数据集分析1.2 数据集加载 2. 使用 PyTorch 训练神经网络2.1 神经网络训练流程2.2 PyTorch 神经网络训练 3. 缩放数据集4. 修改优化器5. 构建深层神经网络小结系列链接 0. 前言
… PyTorch深度学习实战6——神经网络性能优化技术 0. 前言1. 数据准备1.1 数据集分析1.2 数据集加载 2. 使用 PyTorch 训练神经网络2.1 神经网络训练流程2.2 PyTorch 神经网络训练 3. 缩放数据集4. 修改优化器5. 构建深层神经网络小结系列链接 0. 前言
我们已经学习了神经网络的基础概念并了解了如何利用 PyTorch 库构建实用神经网络模型。同时我们还提到了有多种超参数可以影响神经网络的准确率。在本节中我们将使用 Fashion MNIST 数据集用于构建神经网络模型执行图像分类任务并对比使用不同参数训练模型的性能差异。
1. 数据准备
1.1 数据集分析
Fashion MNIST 数据集是一个用于图像分类任务的经典数据集它包含了 10 个类别的时尚服饰图像。每个样本都是一张 28x28 像素的灰度图像总共有 60000 个训练样本和 10000 个测试样本。由于其简单易用的特点Fashion MNIST 数据集已经成为学术界和研究人员常用的基准数据集之一可以用于验证图像分类算法的性能。
1.2 数据集加载
(1) 首先下载数据集并导入相关库torchvision 库包含多个机器学习数据集其中包括 Fashion MNIST 数据集
from torchvision import datasets
import torch
data_folder ./data/FMNIST # This can be any directory you want to download FMNIST to
fmnist datasets.FashionMNIST(data_folder, downloadTrue, trainTrue)在以上代码中指定了要存储下载数据集的文件夹 (data_folder)。接下来利用 datasets.FashionMNIST 获取 fmnist 数据并将其存储在 data_folder 中。此外通过参数 train True 指定仅下载训练图像。
(2) 接下来将 fmnist.data 中可用的图像存储为 tr_images并将对应的图像标签 (fmnist.targets) 存储为 tr_targets
tr_images fmnist.data
tr_targets fmnist.targets(3) 检查加载后的张量数据
unique_values tr_targets.unique()
print(ftr_images tr_targets:\n\tX - {tr_images.shape}\n\tY - {tr_targets.shape}\n\tY - Unique Values : {unique_values})
print(fTASK:\n\t{len(unique_values)} class Classification)
print(fUNIQUE CLASSES:\n\t{fmnist.classes}) 代码输出结果如下
tr_images tr_targets:X - torch.Size([60000, 28, 28])Y - torch.Size([60000])Y - Unique Values : tensor([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
TASK:10 class Classification
UNIQUE CLASSES:[T-shirt/top, Trouser, Pullover, Dress, Coat, Sandal, Shirt, Sneaker, Bag, Ankle boot]在以上结果中可以看出训练数据集有 60,000 张图像每张图像的大小为 28 x 28且包含 10 个可能的类别tr_targets 包含每个图像的类别标签(以数值表示)而 fmnist.classes 表示与 tr_targets 中的每个数值对应的类别名称。
(4) 绘制随机图像样本。
导入相关库用于绘制图像以及处理图像数组
import matplotlib.pyplot as plt
import numpy as np创建一个 10 x 10 的图像网格其中网格的每一行对应一个类别遍历所有类别 (label_class) 并获取与给定类别对应的行索引 (label_x_rows)
R, C len(tr_targets.unique()), 10
fig, ax plt.subplots(R, C, figsize(10,10))
for label_class, plot_row in enumerate(ax):label_x_rows np.where(tr_targets label_class)[0]在以上代码中获取 np.where 输出的第 0 个索引(因为其输出的长度为 1)它包含目标值 (tr_targets) 等于 label_class 的所有索引。
循环 10 次填充所有图像网格我们从先前获得的给定类的索引 (label_x_rows) 中选择一个随机值 (ix) 并绘制 for plot_cell in plot_row:plot_cell.grid(False); plot_cell.axis(off)ix np.random.choice(label_x_rows)x, y tr_images[ix], tr_targets[ix]plot_cell.imshow(x, cmapgray)在上图中每一行代表属于同一类的 10 个不同图像的样本。
2. 使用 PyTorch 训练神经网络
接下来将介绍如何使用 PyTorch 训练神经网络以便根据输入图像预测图像类别。此外我们还将了解各种超参数对模型预测准确率的影响。
2.1 神经网络训练流程
使用 PyTorch 训练神经网络通常需要执行以下步骤
导入相关库构建数据集一次获取一个数据点使用 DataLoader 封装数据集构建模型并定义损失函数和优化器定义两个函数分别用于在一批数据上进行训练和验证定义函数用于模型预测的准确率在每批数据训练过程中更新模型权重通过多个 epoch 的迭代训练模型
2.2 PyTorch 神经网络训练
(1) 导入相关库和 Fashion MNIST 数据集
from torch.utils.data import Dataset, DataLoader
import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as pltdevice cuda if torch.cuda.is_available() else cpu
from torchvision import datasets
data_folder ./data/FMNIST # This can be any directory you want to download FMNIST to
fmnist datasets.FashionMNIST(data_folder, downloadTrue, trainTrue)
tr_images fmnist.data
tr_targets fmnist.targets(2) 构建一个用于获取数据集的类它继承自 Dataset 类且需要定义以下三个函数 __init__、__getitem__ 和 __len__
class FMNISTDataset(Dataset):def __init__(self, x, y):x x.float()x x.view(-1, 28*28)self.x, self.y x, ydef __getitem__(self, ix):x, y self.x[ix], self.y[ix]return x.to(device), y.to(device)def __len__(self):return len(self.x)在 __init__ 方法中将输入转换为浮点数并将每个图像展平为 28*28 784 个数值(其中每个数值对应一个像素值)在 __len__ 方法中指定数据数量__getitem__ 方法用于返回第 ix 个索引对应的数据( ix 为 0 到 __len__ 之间的整数)。
(3) 创建函数从数据集( FMNISTDataset )中生成一个训练数据 DataLoader——trn_dl每批数据包含随机采样的 32 个数据点
def get_data():train FMNISTDataset(tr_images, tr_targets)trn_dl DataLoader(train, batch_size32, shuffleTrue)return trn_dl在以上代码中创建了 FMNISTDataset 类的对象 train并调用了 DataLoader使其随机获取 32 个数据点并返回训练 DataLoader。
(4) 定义模型以及损失函数和优化器
from torch.optim import SGD
def get_model():model nn.Sequential(nn.Linear(28*28, 1000),nn.ReLU(),nn.Linear(1000, 10)).to(device)loss_fn nn.CrossEntropyLoss()optimizer SGD(model.parameters(), lr1e-2)return model, loss_fn, optimizer模型使用了一个具有 1,000 个神经元的隐藏层输出层包含 10 个神经元对应于 10 个可能的类别。由于输出结果表示输入图像属于 10 个类别的概率因此调用 CrossEntropyLoss 损失函数。最后将学习率 lr 初始化为 0.01而不使用默认值 0.001。 在神经网络中并未使用 “softmax” 函数(因此模型输出范围不受限制而交叉熵损失通常期望输出为概率——每一图像的预测结果之和 1)这是因为 nn.CrossEntropyLoss 接受原始 logits (即不受约束的值)并在内部执行 softmax。
(5) 定义将在一批图像上训练模型的函数
def train_batch(x, y, model, optimizer, loss_fn):model.train()# call your model like any python function on your batch of inputsprediction model(x)# compute lossbatch_loss loss_fn(prediction, y)# based on the forward pass in model(x) compute all the gradients of model.parameters()batch_loss.backward()# apply new-weights f(old-weights, old-weight-gradients) where f is the optimizeroptimizer.step()# Flush gradients memory for next batch of calculationsoptimizer.zero_grad()return batch_loss.item()在前向传播中通过模型处理输入图像计算输入批数据损失然后通过反向传播计算梯度并更新权重最后刷新梯度的内存以免对下一次传递中计算梯度时产生影响。可以通过在 batch_loss 之上获取 batch_loss.item() 提取标量损失值。
(6) 编写函数计算模型在给定数据集上准确率
torch.no_grad()
def accuracy(x, y, model):model.eval()# get the prediction matrix for a tensor of x imagesprediction model(x)# compute if the location of maximum in each row coincides with ground truthmax_values, argmaxes prediction.max(-1)is_correct argmaxes yreturn is_correct.cpu().numpy().tolist()在以上代码中通过使用 torch.no_grad() 显式的声明无需进行梯度计算。调用 prediction.max(-1) 来识别每行对应的 argmax 索引此外通过 argmaxes y 将预测结果 argmaxes 与真实值( ground true )进行比较以便检查是否得到正确预测。最后将 is_correct 对象列表移动到 CPU 中并将其转换为 numpy 数组后返回。
(7) 训练神经网络。
首先初始化模型、损失、优化器和数据加载器
trn_dl get_data()
model, loss_fn, optimizer get_model()在每个 epoch 结束时记录准确率和损失值
losses, accuracies [], []定义模型训练的 epoch 数
for epoch in range(10):print(epoch)初始化列表用于记录一个 epoch 内每批数据对应的准确率和损失值 epoch_losses, epoch_accuracies [], []通过迭代 DataLoader 创建批训练数据 for ix, batch in enumerate(iter(trn_dl)):x, y batch使用 train_batch 函数利用批数据训练模型并将批训练结束时的损失值 batch_loss 存储在 epoch_losses 列表中 batch_loss train_batch(x, y, model, optimizer, loss_fn)epoch_losses.append(batch_loss)存储一个 epoch 内所有批训练的平均损失值 epoch_loss np.array(epoch_losses).mean()在所有批训练结束时计算预测的准确率 for ix, batch in enumerate(iter(trn_dl)):x, y batchis_correct accuracy(x, y, model)epoch_accuracies.extend(is_correct)epoch_accuracy np.mean(epoch_accuracies)将每个 epoch 结束时的损失和准确率值存储在列表中 losses.append(epoch_loss)accuracies.append(epoch_accuracy)(8) 绘制训练损失和准确率随时间的变化情况
epochs np.arange(10)1
plt.figure(figsize(20,5))
plt.subplot(121)
plt.title(Loss value over increasing epochs)
plt.plot(epochs, losses, labelTraining Loss)
plt.legend()
plt.subplot(122)
plt.title(Accuracy value over increasing epochs)
plt.plot(epochs, accuracies, labelTraining Accuracy)
plt.gca().set_yticklabels([{:.0f}%.format(x*100) for x in plt.gca().get_yticks()])
plt.legend()
plt.show()在训练 5 个 epoch 时模型的训练准确率为 15%并且随着 epoch 的增加损失值并没有显着降低。换句话说无论再训练多长时间该模型的准确率都不太可能显著增长。 我们已经对训练神经网络的完整流程有了完整了解接下来我们通过微调超参数来获得更好的模型性能。
3. 缩放数据集
缩放数据集是确保变量被限制在给定范围内的过程以确保数据不会分布在较大的区间。在本节中我们通过将每个输入值除以数据集中的最大可能值将自变量的值限制在 0 和 1 之间。通常缩放输入数据集能够提高神经网络的性能表现。
(1) 获取数据集包括训练图像及其标签
from torch.utils.data import Dataset, DataLoader
import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as pltdevice cuda if torch.cuda.is_available() else cpu
from torchvision import datasets
data_folder ./data/FMNIST
fmnist datasets.FashionMNIST(data_folder, downloadTrue, trainTrue)
tr_images fmnist.data
tr_targets fmnist.targets(2) 修改获取数据的 FMNISTDataset 类将输入图像除以 255 (最大像素强度值)
class FMNISTDataset(Dataset):def __init__(self, x, y):x x.float() / 255.x x.view(-1, 28*28)self.x, self.y x, ydef __getitem__(self, ix):x, y self.x[ix], self.y[ix]return x.to(device), y.to(device)def __len__(self):return len(self.x)与上一小节相比唯一需要修改的是将输入数据除以最大可能的像素值 (255)将它们除以 255 将得到介于 0 到 1 之间的值。
(3) 训练模型首先获取数据、定义模型和用于训练和验证数据的数据然后训练模型最后绘制训练期间损失和准确率的变化 def get_data():train FMNISTDataset(tr_images, tr_targets)trn_dl DataLoader(train, batch_size32, shuffleTrue)return trn_dltrn_dl get_data()
model, loss_fn, optimizer get_model()losses, accuracies [], []
for epoch in range(10):print(epoch)epoch_losses, epoch_accuracies [], []for ix, batch in enumerate(iter(trn_dl)):x, y batchbatch_loss train_batch(x, y, model, optimizer, loss_fn)epoch_losses.append(batch_loss)epoch_loss np.array(epoch_losses).mean()for ix, batch in enumerate(iter(trn_dl)):x, y batchis_correct accuracy(x, y, model)epoch_accuracies.extend(is_correct)epoch_accuracy np.mean(epoch_accuracies)losses.append(epoch_loss)accuracies.append(epoch_accuracy)epochs np.arange(10)1
import matplotlib.pyplot as plt
plt.figure(figsize(20,5))
plt.subplot(121)
plt.title(Loss value over increasing epochs)
plt.plot(epochs, losses, labelTraining Loss)
plt.legend()
plt.subplot(122)
plt.title(Accuracy value over increasing epochs)
plt.plot(epochs, accuracies, labelTraining Accuracy)
plt.gca().set_yticklabels([{:.0f}%.format(x*100) for x in plt.gca().get_yticks()])
plt.legend()
plt.show()如上图所示训练损失不断减少训练准确率不断提高可以将准确率提高到约 85%。
接下来我们将了解缩放数据集能使神经网络性能更好的原因。假设输入数据未缩放以计算 sigmoid 值为例
输入权重偏置sigmoid 值2550.0100.932550.101.002550.201.002550.401.002550.801.002551.601.002553.201.002556.401.00
在上表中即使权重值在 0.01 到 6.4 之间变化在经过函数 Sigmoid 后输出变化也不大。Sigmoid 函数的计算公式如下 o u t p u t 1 1 e − ( w ∗ x b ) output \frac1 {1e^{-(w*x b)}} output1e−(w∗xb)1 其中 w w w 是权重 x x x 是输入 b b b 是偏置值。Sigmoid 输出不变的原因是由于 w ∗ x w*x w∗x 的乘积很大(因为 x x x 较大)导致 Sigmoid 值始终落在 Sigmoid 曲线的饱和部分中( Sigmoid 曲线的右上角或左下角的值称为饱和部分)。 如果我们将不同的权重值乘以一个较小的输入数字如下所示
输入权重偏置sigmoid 值10.0100.5010.100.5210.200.5510.400.6010.800.6911.600.8313.200.9616.401.00
由于输入值较小因此上表中的 Sigmoid 输出的变化幅度较大。通过此示例我们了解了缩放输入对数据集的影响当权重(假设权重不具有较大范围)乘以输入值时产生的值范围空间并不会突变从而使输入数据能够对输出产生足够重要的影响。 当权重值也很大时输入值对输出的影响也将变得不太重要。因此我们一般将权重值初始化为更接近零的较小数值。同时为了获得最佳的权重值通常设置初始权重的范围变化不大比如权重初始化为介于 -1 和 1 之间的随机值。
4. 修改优化器
不同优化器同样可能会影响模型学习拟合输入和输出的速度在本节中将了解修改优化器对模型准确性的影响。为了便于比较随机梯度下降( Stochastic Gradient Descent, SGD )和 Adam 在更多 epoch 上的性能将 epoch 修改为 20。
(1) 修改优化器在 get_model() 函数中使用 SGD 优化器同时确保其他设定保持不变
from torch.optim import SGD, Adam
def get_model():model nn.Sequential(nn.Linear(28 * 28, 1000),nn.ReLU(),nn.Linear(1000, 10)).to(device)loss_fn nn.CrossEntropyLoss()optimizer SGD(model.parameters(), lr1e-2)return model, loss_fn, optimizer(2) 增加训练模型的 epoch 数
trn_dl, val_dl get_data()
model, loss_fn, optimizer get_model()train_losses, train_accuracies [], []
val_losses, val_accuracies [], []
for epoch in range(20):print(epoch)train_epoch_losses, train_epoch_accuracies [], []for ix, batch in enumerate(iter(trn_dl)):x, y batchbatch_loss train_batch(x, y, model, optimizer, loss_fn)train_epoch_losses.append(batch_loss) train_epoch_loss np.array(train_epoch_losses).mean()for ix, batch in enumerate(iter(trn_dl)):x, y batchis_correct accuracy(x, y, model)train_epoch_accuracies.extend(is_correct)train_epoch_accuracy np.mean(train_epoch_accuracies)for ix, batch in enumerate(iter(val_dl)):x, y batchval_is_correct accuracy(x, y, model)validation_loss val_loss(x, y, model, loss_fn)val_epoch_accuracy np.mean(val_is_correct)train_losses.append(train_epoch_loss)train_accuracies.append(train_epoch_accuracy)val_losses.append(validation_loss)val_accuracies.append(val_epoch_accuracy)epochs np.arange(20)1
import matplotlib.ticker as mtick
import matplotlib.ticker as mticker
plt.subplot(121)
plt.plot(epochs, train_losses, bo, labelTraining loss)
plt.plot(epochs, val_losses, r, labelValidation loss)
plt.gca().xaxis.set_major_locator(mticker.MultipleLocator(1))
plt.title(Training and validation loss with SGD optimizer)
plt.xlabel(Epochs)
plt.ylabel(Loss)
plt.legend()
plt.grid(off)
plt.subplot(122)
plt.plot(epochs, train_accuracies, bo, labelTraining accuracy)
plt.plot(epochs, val_accuracies, r, labelValidation accuracy)
plt.gca().xaxis.set_major_locator(mticker.MultipleLocator(1))
plt.title(Training and validation accuracy with SGD optimizer)
plt.xlabel(Epochs)
plt.ylabel(Accuracy)
plt.gca().set_yticklabels([{:.0f}%.format(x*100) for x in plt.gca().get_yticks()])
plt.legend()
plt.grid(off)
plt.show()进行这些更改后优化器为 SGD 时训练和验证数据集上的准确率和损失的变化如下所示 在优化器为 Adam 时训练和验证数据集上的准确率和损失值的变化如下 与其他优化器相比Adam 通常优化器可以更快地实现最佳准确率其他一些可用的优化器包括 Adagrad、Adadelta、AdamW、LBFGS 和 RMSprop。
5. 构建深层神经网络
到目前为止我们构建的神经网络架构只有一个隐藏层。在本节中我们将对比具有两个隐藏层和没有隐藏层的神经网络模型的性能。
(1) 构建包含两层隐藏层的神经网络模型
def get_model():model nn.Sequential(nn.Linear(28 * 28, 1000),nn.ReLU(),nn.Linear(1000, 512),nn.ReLU(),nn.Linear(512, 10)).to(device)loss_fn nn.CrossEntropyLoss()optimizer Adam(model.parameters(), lr1e-3)return model, loss_fn, optimizer(2) 类似地修改 get_model() 函数构建不含隐藏层的神经网络将输入直接连接到输出层
from torch.optim import SGD, Adam
def get_model():model nn.Sequential(nn.Linear(28 * 28, 10)).to(device)loss_fn nn.CrossEntropyLoss()optimizer Adam(model.parameters(), lr1e-3)return model, loss_fn, optimizer训练和验证数据集的准确率和损失变化如下所示 从以上结果可以看出
当没有隐藏层时模型无法学习与一个隐藏层相比当有两个隐藏层时模型的过拟合会更严重
深度神经网络意味着在输入层和输出层间存在多个隐藏层。多个隐藏层确保神经网络可以学习输入和输出之间的复杂非线性关系而简单的神经网络则无法完成这样的需求(由于隐藏层数量有限)。
小结
神经网络性能优化技术是指通过改进神经网络的结构、参数初始化、正则化和训练过程等方面来提高其性能和泛化能力的方法。本节首先训练了一个简单的全连接网络然后在此基础上介绍了简单有效的神经网络性能提升技巧在之后的学习中还将进一步介绍包括批归一化、动态学习率等常见技术。
系列链接
PyTorch深度学习实战1——神经网络与模型训练过程详解 PyTorch深度学习实战2——PyTorch基础 PyTorch深度学习实战3——使用PyTorch构建神经网络 PyTorch深度学习实战4——常用激活函数和损失函数详解 PyTorch深度学习实战5——计算机视觉基础
