代码解析(这里是可以直接执行的代码,并没有函数详解)
import torch
from torch import nn
from d2l import torch as d2l
#这是一个样本进行如下操作
net=nn.Sequential(
nn.Conv2d(1,6,kernel_size=5,padding=2),nn.Sigmoid(),
nn.AvgPool2d(kernel_size=2,stride=2),
nn.Conv2d(6,16,kernel_size=5,),nn.Sigmoid(),
#这个张量的形状表示它是一个包含1个样本、每个样本有16个通道、每个通道的特征图大小为5x5的张量。
nn.AvgPool2d(kernel_size=2,stride=2),
#nn.Flatten() 会将其拉伸成一个一维向量,其大小是输入张量中所有元素的数量,即 1 * 16 * 5 * 5 = 400。
nn.Flatten(),
nn.Linear(16*5*5,120),nn.Sigmoid(),
nn.Linear(120,84),nn.Sigmoid(),
nn.Linear(84,10)
)
#可以尝试出所有模型层输出的代码
X = torch.rand(size=(1, 1, 28, 28), dtype=torch.float32)
for layer in net:
X = layer(X)
print(layer.__class__.__name__,'output shape: \t',X.shape)
#载入训练集
batch_size=256
train_iter,test_iter=d2l.load_data_fashion_mnist(batch_size=batch_size)
lr, num_epochs = 0.9, 10
d2l.train_ch6(net, train_iter, test_iter, num_epochs, lr, d2l.try_gpu())
函数详解
1.评估模型准确率的函数
## 对网络进行评估
1.将网络设置为评估模式:简单理解禁止dropout之类会对参数或者输入进行影响的层,保证网络使用的是训练时的参数与完整的输入,达到评估目的
2.获取设备:如果在调用函数时没有显式地指定设备,那么这段代码会自动检测模型参数已经存在的设备,并将其作为默认设备进行后续的计算
3.创建两个累计槽:第一个累积槽通常用来存储正确预测的数量(但这里是准确率),第二个累积槽用来存储样本的总数或总预测次数(累计槽存储什么是自己设计的)
4.开始评估
4.1 关闭梯度计算:防止评估时占用大量计算
4.2 在迭代器中循环
4.2.1 将张量放到设备上:因为张量可能是列表形式,故判断并处理
4.2.2 将标签放到设备上
4.2.3 通过张量预测获得预测值,通过预测值与真实值获得准确率,将该次循环的准确率*真实值的总数量(正确预测数)和真实值的总数量,放入到累计槽中(这是细节),实质上这里的d2l.accuracy获得的是正确预测数。
5.将总正确预测数/真实值的总数量,获得平均准确率
关于累计槽的补充
举个例子,如果你在一个批次中有5个预测正确,总共10个样本,你可以这样更新Accumulator实例:
metric.add(5, 10) # Adds 5 to the first slot (correct predictions) and 10 to the second slot (total predictions)
在所有批次处理完成后,你可以通过访问这些槽的值来计算整体的准确率或其他统计信息。比如计算准确率:
accuracy = metric[0] / metric[1
#这是评估模型平均准确率的函数
def evaluate_accuracy_gpu(net, data_iter, device=None): #@save
"""使用GPU计算模型在数据集上的精度"""
if isinstance(net, nn.Module):
#1
net.eval() # 设置为评估模式
#2
if not device:
device = next(iter(net.parameters())).device
# 正确预测的数量,总预测的数量
#3
metric = d2l.Accumulator(2)
#4
## 4.1
with torch.no_grad():
## 4.2
for X, y in data_iter:
### 4.2.1
if isinstance(X, list):
# BERT微调所需的(之后将介绍)
X = [x.to(device) for x in X]
else:
X = X.to(device)
### 4.2.2
y = y.to(device)
### 4.2.3 注意:d2l原有库可能表示:acc = d2l.accuracy(net(X), y) metric.add(acc * y.numel(), y.numel())
metric.add(d2l.accuracy(net(X), y), y.numel())
#5
return metric[0] / metric[1]
2.GPU上的训练函数
## 训练函数
1.初始参数
2.将网络放到device上
3.设定梯度下降算法
4.设定损失函数
5.画图:X轴:名字epoch,范围[1,num_epochs] 三根线条:trainloss trainacc testacc
6.初始化计时类:负责对训练过程的时间进行计时 计时方式(timer.start timer.stop)
7.按批次开始
7.1 设置三个累计槽用来保存训练损失之和,训练准确率之和,样本数
7.2 将网络设置为训练模式
7.3 本批次训练开始
7.4 将值变换放到累加器:
l * X.shape[0] 这个表达式计算的是整个批次的总损失
d2l.accuracy(y_hat, y) 计算当前批次中的准确率
X.shape[0] 当前批次中的样本数量
7.5 在转换获得trainloss trainacc testacc
7.6 然后绘图
#@save
def train_ch6(net, train_iter, test_iter, num_epochs, lr, device):
"""用GPU训练模型(在第六章定义)"""
#1
def init_weights(m):
if type(m) == nn.Linear or type(m) == nn.Conv2d:
nn.init.xavier_uniform_(m.weight)
net.apply(init_weights)
print('training on', device)
#2
net.to(device)
#3
optimizer = torch.optim.SGD(net.parameters(), lr=lr)
#4
loss = nn.CrossEntropyLoss()
#5
animator = d2l.Animator(xlabel='epoch', xlim=[1, num_epochs],
legend=['train loss', 'train acc', 'test acc'])
#6
timer, num_batches = d2l.Timer(), len(train_iter)
#7
for epoch in range(num_epochs):
# 训练损失之和,训练准确率之和,样本数
#7.1
metric = d2l.Accumulator(3)
#7.2
net.train()
#7.3
for i, (X, y) in enumerate(train_iter):
timer.start()
optimizer.zero_grad()
X, y = X.to(device), y.to(device)
y_hat = net(X)
l = loss(y_hat, y)
l.backward()
optimizer.step()
with torch.no_grad():
#7.4
metric.add(l * X.shape[0], d2l.accuracy(y_hat, y), X.shape[0])
timer.stop()
#7.5
train_l = metric[0] / metric[2]
train_acc = metric[1] / metric[2]
#7.6
if (i + 1) % (num_batches // 5) == 0 or i == num_batches - 1:
animator.add(epoch + (i + 1) / num_batches,
(train_l, train_acc, None))
test_acc = evaluate_accuracy_gpu(net, test_iter)
animator.add(epoch + 1, (None, None, test_acc))
print(f'loss {train_l:.3f}, train acc {train_acc:.3f}, '
f'test acc {test_acc:.3f}')
print(f'{metric[2] * num_epochs / timer.sum():.1f} examples/sec '
f'on {str(device)}')
这里唯一我不确定的问题是:沐神的这段正确吗?
metric.add(d2l.accuracy(net(X), y), y.numel())
在沐神的代码里获得的就是准确数。故正确