练习9-LeNet(沐神代码简要解析)

代码解析(这里是可以直接执行的代码,并没有函数详解)

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())
在沐神的代码里获得的就是准确数。故正确