pytorch基础-优化模型参数（6）
现在我们有了模型和数据，是时候通过优化数据参数来训练、验证和测试我们的模型了。训练一个模型就是一个迭代的过程，在每次迭代(称为epoch)中，模型对输出进行猜测，计算猜测中的误差(损失)，收集误差对其参数的导数(前一节中自动微分一样)，并使用梯度下降优化这些参数。
1、先决条件代码
从前面关于数据集和数据装载器以及构建模型的章节中加载代码。
PyTorch基础-自定义数据集和数据加载器（2）_一只小小的土拨鼠的博客-CSDN博客
pytorch基础-构建简单的神经网络（4）_一只小小的土拨鼠的博客-CSDN博客
import torch
from torch import nn
from torch.utils.data import DataLoader
from torchvision import datasets
from torchvision.transforms import ToTensor, Lambda
training_data = datasets.FashionMNIST(
root="data",
train=True,
download=True,
transform=ToTensor()
)
test_data = datasets.FashionMNIST(
root="data",
train=False,
download=True,
transform=ToTensor()
)
train_dataloader = DataLoader(training_data, batch_size=64)
test_dataloader = DataLoader(test_data, batch_size=64)
class NeuralNetwork(nn.Module):
def __init__(self):
super(NeuralNetwork, self).__init__()
self.flatten = nn.Flatten()
self.linear_relu_stack = nn.Sequential(
nn.Linear(28*28, 512),
nn.ReLU(),
nn.Linear(512, 512),
nn.ReLU(),
nn.Linear(512, 10),
)
def forward(self, x):
x = self.flatten(x)
logits = self.linear_relu_stack(x)
return logits
model = NeuralNetwork()2、超参数的设置
超参数是可调整的参数，可控制模型优化过程。 不同的超参数值会影响模型训练和收敛速度 。
我们为训练定义了以下超参数：
- Number of Epochs（迭代次数）:迭代数据集的次数，指的是训练过程中数据被“轮”多少次。
- Batch Size（样本大小） - 参数更新前通过网络传播的一小批数据样本数 。将数据分成几块，就是分成几个batch，一个batch中的数据量大小即为batch size
- Learning Rate（学习率） - 在每个批次/时期更新模型参数的程度。 较小的值会产生较慢的学习速度，而较大的值可能会导致训练期间出现不可预测的行为。
- iterations（迭代）- 每一次迭代都是一次权重更新，1个iteration等于使用batch size个样本训练一次。即batch size个样本需要完成一次epoch的次数。
learning_rate = 1e-3#学习率
batch_size = 64#样本大小
epochs = 5#迭代次数Epochs和 Batch Size的关系是：
在one epoch中，numbers of iterations = 训练样本的数量 / batch_size
epochs= numbers of iterations / batch_size
下面是关于epochs，batch_size，iterations这三个参数的详细解释：
tensorflow学习笔记--深度学习中的epochs，batch_size，iterations详解_STHSF的博客-CSDN博客_tensorflow的epoch
3、优化循环
一旦我们设置了超参数，我们就可以使用优化循环来训练和优化我们的模型。 每个 优化循环的迭代称为 epoch 。
每个时期包括两个主要部分：
- 训练循环 - 迭代训练数据集并尝试收敛到最佳参数。
- 验证/测试循环 - 迭代测试数据集以检查模型性能是否正在改善。
优化是在每个训练步骤中调整模型参数以减少模型误差的过程。优化算法定义了这个过程是如何执行的(在本例中，使用随机梯度下降)。所有优化逻辑都封装在优化器对象 optimizer 中。这里，我们使用SGD优化器，此外，PyTorch中有许多不同的优化器，如ADAM和RMSProp，它们可以更好地适用于不同类型的模型和数据。
这里我们需要输入需要训练的模型参数，并传入学习速率超参数来初始化优化器。
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)其中相关的函数可参考：理解optimizer.zero_grad(), loss.backward(), optimizer.step()的作用及原理_潜行隐耀的博客-CSDN博客_loss.backward()函数
（1）optimizer.zero_grad()函数会遍历模型的所有参数，通过p.grad.detach_()方法截断反向传播的梯度流，再通过p.grad.zero_()函数将每个参数的梯度值设为0，即上一次的梯度记录被清空。因为训练的过程通常使用mini-batch方法，所以如果不将梯度清零的话，梯度会与上一个batch的数据相关，因此该函数要写在反向传播和梯度下降之前。
（2）loss.backward()函数在使用后，会一层层的反向传播计算每个w的梯度值，并保存到该w的.grad属性中。如果没有进行 backward() 的话，梯度值将会是None，因此loss.backward()要写在optimizer.step()之前。
（3）optimizer.step()函数的作用是执行一次优化步骤，通过梯度下降法来更新参数的值。因为梯度下降是基于梯度的，所以在执行optimizer.step()函数前应先执行loss.backward()函数来计算梯度。
（4）在训练循环中，优化分三个步骤进行：
- 调用optimizer.zero_grad()重置模型参数的梯度。如果不设置默认情况下继续累加加起来； 为了防止重复计算，我们在每次迭代时明确地将它们归零。
- 通过调用
loss.backward()反向传播预测损失. PyTorch将误差梯度w.r.t.存储在每个参数中。 - 一旦我们有了梯度，我们就调用
optimizer.step()通过反向传播中收集的梯度来调整参数。
总得来说，optimizer只负责通过梯度下降进行优化，而不负责产生梯度，梯度是tensor.backward()方法产生的。这三个函数的作用是先将梯度归零（optimizer.zero_grad()），然后反向传播计算得到每个参数的梯度值loss.backward()，最后通过梯度下降执行一步参数更新（optimizer.step()）。
4、损失函数
当呈现一些训练数据时，我们未经训练的网络可能不会给出正确的回答。 损失函数衡量得到的结果与目标值的不同程度， 这是函数正是用于我们希望在训练期间损失最小化的。 为了计算损失，我们做了一个使用给定数据样本的输入进行预测，并将其与真实数据标签值进行比较。
常见的损失函数包括用于回归任务的nn.MSELoss （均方误差），以及用于分类的nn.NLLLoss （负对数似然）。 nn.CrossEntropyLoss 结合 nn.LogSoftmax 和 nn.NLLLoss 两种。
我们将模型的输出 logits 传递给 nn.CrossEntropyLoss，它将对 logits 进行归一化并计算预测误差。
# Initialize the loss function
loss_fn = nn.CrossEntropyLoss()5、优化循环的模型实现
（1）定义 train_loop循环我们的优化代码，以及根据测试数据评估模型的性能的test_loop。
#定义train_loop循环优化代码
def train_loop(dataloader, model, loss_fn, optimizer):
size = len(dataloader.dataset)#获取训练数据集总数大小
for batch, (X, y) in enumerate(dataloader):#从数据加载器中获取批次个数，图像数据和对应标签
# Compute prediction and loss
pred = model(X)#将图像数据通过训练模型
loss = loss_fn(pred, y)#计算预测值和真实值的误差大小
# Backpropagation
optimizer.zero_grad()#梯度清零
loss.backward()#反向传播
optimizer.step()#梯度更新
if batch % 100 == 0:#因为批次大小为64，所以每获取100个批次，也就是6400张图片时输出此时的误差
loss, current = loss.item(), batch * len(X)#获取当前的误差，batch * len(X)获取当前训练后的图片数量
print(f"loss: {loss:>7f} [{current:>5d}/{size:>5d}]")
#定义test_loop评估模型的性能。
def test_loop(dataloader, model, loss_fn):
size = len(dataloader.dataset)#获取测试数据集总数大小
num_batches = len(dataloader)#获取测试样本数据集中的组数，10000/64=157
test_loss, correct = 0, 0#将之前的测试误差和准确率清零
with torch.no_grad():#禁用梯度计算
for X, y in dataloader:#从数据加载器中获取图像数据和对应标签
pred = model(X)
test_loss += loss_fn(pred, y).item()#计算预测值和真实值的误差大小，此时的测试误差是所有样本数据的误差
correct += (pred.argmax(1) == y).type(torch.float).sum().item()#累加所有测试数据中预测正确的样本个数
test_loss /= num_batches#为了和训练数据做对比，在此处除上分组个数，以获取64张图片的测试误差
correct /= size#除以样本总数得到准确率
print(f"Test Error: \n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \n")其中，除了loss.backward()之外的loss调用都用loss.item()，否则每次迭代，空间占用就会增加，直到cpu或者gup爆炸。这是因为输出的loss的数据类型是Variable。而PyTorch的动态图机制就是通过Variable来构建图。如果这里直接将loss加起来，系统会认为这里也是计算图的一部分，也就是说网络会一直延伸变大，那么消耗的显存也就越来越大。也可以用下面这个代替：
loss_sum += loss.data[0]其中，len(dataloader)，len(label)和训练数据集个数之间的关系，以50000张图像的训练集为例，将训练集平均分成12500份，每份有4张图片（batch_size=4）。dataloader 中的每个元素相当于一个元组，一个组中有4张图片，label就是一个分组中的一张图片的标签。故
len(train_loader)==12500，len(label)==4
（2）初始化损失函数和优化器，并将其传递给 train_loop和 test_loop。随意增加 epoch 的数量来跟踪模型的改进性能。
loss_fn = nn.CrossEntropyLoss()
optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
epochs = 10
for t in range(epochs):
print(f"Epoch {t+1}\n-------------------------------")
train_loop(train_dataloader, model, loss_fn, optimizer)#输入参数，进行训练
test_loop(test_dataloader, model, loss_fn)#输入参数，进行测试
print("Done!")输出结果：
Epoch 1
-------------------------------
loss: 2.305601 [ 0/60000]
loss: 2.286215 [ 6400/60000]
loss: 2.274424 [12800/60000]
loss: 2.274253 [19200/60000]
loss: 2.245863 [25600/60000]
loss: 2.231054 [32000/60000]
loss: 2.223348 [38400/60000]
loss: 2.198419 [44800/60000]
loss: 2.202927 [51200/60000]
loss: 2.169171 [57600/60000]
339.87992119789124
Test Error:
Accuracy: 51.1%, Avg loss: 2.164840
Epoch 2
-------------------------------
loss: 2.174834 [ 0/60000]
loss: 2.161046 [ 6400/60000]
loss: 2.112201 [12800/60000]
loss: 2.138574 [19200/60000]
loss: 2.080806 [25600/60000]
loss: 2.024089 [32000/60000]
loss: 2.047061 [38400/60000]
loss: 1.977028 [44800/60000]
loss: 1.985450 [51200/60000]
loss: 1.912798 [57600/60000]
300.8142771720886
Test Error:
Accuracy: 58.3%, Avg loss: 1.916015
Epoch 3
-------------------------------
loss: 1.937905 [ 0/60000]
loss: 1.912784 [ 6400/60000]
loss: 1.804693 [12800/60000]
loss: 1.862017 [19200/60000]
loss: 1.732895 [25600/60000]
loss: 1.676894 [32000/60000]
loss: 1.700100 [38400/60000]
loss: 1.601977 [44800/60000]
loss: 1.629191 [51200/60000]
loss: 1.515440 [57600/60000]
241.9468252658844
Test Error:
Accuracy: 61.2%, Avg loss: 1.541063
Epoch 4
-------------------------------
loss: 1.594300 [ 0/60000]
loss: 1.561490 [ 6400/60000]
loss: 1.414611 [12800/60000]
loss: 1.504789 [19200/60000]
loss: 1.360155 [25600/60000]
loss: 1.353550 [32000/60000]
loss: 1.362576 [38400/60000]
loss: 1.290387 [44800/60000]
loss: 1.330305 [51200/60000]
loss: 1.219627 [57600/60000]
197.04337859153748
Test Error:
Accuracy: 63.2%, Avg loss: 1.255053
Epoch 5
-------------------------------
loss: 1.323310 [ 0/60000]
loss: 1.304586 [ 6400/60000]
loss: 1.141847 [12800/60000]
loss: 1.263436 [19200/60000]
loss: 1.123239 [25600/60000]
loss: 1.148370 [32000/60000]
loss: 1.159325 [38400/60000]
loss: 1.102562 [44800/60000]
loss: 1.147795 [51200/60000]
loss: 1.055924 [57600/60000]
170.1446869969368
Test Error:
Accuracy: 64.5%, Avg loss: 1.083724
Epoch 6
-------------------------------
loss: 1.146926 [ 0/60000]
loss: 1.147159 [ 6400/60000]
loss: 0.969630 [12800/60000]
loss: 1.117157 [19200/60000]
loss: 0.982535 [25600/60000]
loss: 1.015209 [32000/60000]
loss: 1.038843 [38400/60000]
loss: 0.987779 [44800/60000]
loss: 1.033760 [51200/60000]
loss: 0.957390 [57600/60000]
153.3584640622139
Test Error:
Accuracy: 65.4%, Avg loss: 0.976806
Epoch 7
-------------------------------
loss: 1.028089 [ 0/60000]
loss: 1.048259 [ 6400/60000]
loss: 0.855831 [12800/60000]
loss: 1.021706 [19200/60000]
loss: 0.895170 [25600/60000]
loss: 0.923148 [32000/60000]
loss: 0.962257 [38400/60000]
loss: 0.915383 [44800/60000]
loss: 0.957287 [51200/60000]
loss: 0.892491 [57600/60000]
142.20303839445114
Test Error:
Accuracy: 66.8%, Avg loss: 0.905752
Epoch 8
-------------------------------
loss: 0.943041 [ 0/60000]
loss: 0.981573 [ 6400/60000]
loss: 0.776476 [12800/60000]
loss: 0.955335 [19200/60000]
loss: 0.837068 [25600/60000]
loss: 0.856965 [32000/60000]
loss: 0.909417 [38400/60000]
loss: 0.867956 [44800/60000]
loss: 0.903040 [51200/60000]
loss: 0.846447 [57600/60000]
134.30496662855148
Test Error:
Accuracy: 67.8%, Avg loss: 0.855446
Epoch 9
-------------------------------
loss: 0.878709 [ 0/60000]
loss: 0.932838 [ 6400/60000]
loss: 0.717953 [12800/60000]
loss: 0.906739 [19200/60000]
loss: 0.795587 [25600/60000]
loss: 0.807454 [32000/60000]
loss: 0.869830 [38400/60000]
loss: 0.835157 [44800/60000]
loss: 0.862577 [51200/60000]
loss: 0.811464 [57600/60000]
128.36600986123085
Test Error:
Accuracy: 68.9%, Avg loss: 0.817618
Epoch 10
-------------------------------
loss: 0.827683 [ 0/60000]
loss: 0.894314 [ 6400/60000]
loss: 0.672606 [12800/60000]
loss: 0.869779 [19200/60000]
loss: 0.763892 [25600/60000]
loss: 0.769287 [32000/60000]
loss: 0.837992 [38400/60000]
loss: 0.810939 [44800/60000]
loss: 0.830898 [51200/60000]
loss: 0.783476 [57600/60000]
123.64656186103821
Test Error:
Accuracy: 69.9%, Avg loss: 0.787558
Done!