week4 7月31日

LeNet

导入第三方库

import torch
from torch import nn
from d2l import torch as d2l

定义LeNet网络

net = nn.Sequential(nn.Conv2d(1,6,kernel_size=5,padding=2),nn.Sigmoid(),
                    #填充5-1=4 4/2=2 上下左右都填充2
                    #卷积层+激活层 卷积1输入通道数——>6输出
                    nn.AvgPool2d(kernel_size=2,stride=2),
                    #池化层
                    nn.Conv2d(6,16,kernel_size=5),nn.Sigmoid(),
                    nn.AvgPool2d(kernel_size=2,stride=2),
                    #卷积 激活 池化
                    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)
#随机生成一个1输入1输出 28*28大小的矩阵
for layer in net:
#每一层都做如下处理
    x=layer(x)
    print(layer.__class__.__name__,'output shape:\t',x.shape)

输入图像维度为 1x1x28x28 经过第一层卷积 5x5后 输出为1x6x24x24 则说明使用了6个5x5的卷积核进行卷积操作

 图中的conv2d函数，设置的是1个输入通道数，6个输出通道（过滤器），以及做了填充，所以输出的是6*28*28。

第2个卷积，没有填充，所以经过该卷积之后，特征图会变小

定义模型评估函数

def evaluate_accuracy_gpu(net,data_iter,device=None):#@save
    if isinstance(net,nn.Module):
    #如果net是nn里的模型的话
        net.eval()
        #把模型设置成评估模型
        if not device:#如果没有填设备，就使用模型默认的设备（cuda或者cpu）
            device=next(iter(net.parameters())).device
    metric = d2l.Accumulator(2)
    with torch.no_grad():
        for x,y in data_iter:
            if isinstance(x,list):
                #如果x是列表的话，就把列表中的每个数据放进cuda或者cpu中
                x=[x.to(device) for x in x]
            else:
                #如果不是列表，直接放进cuda或者cpu
                x=x.to(device)
            y=y.to(device)
            metric.add(d2l.accuracy(net(x),y),y.numel())
            #把正确数和总数放入
    return metric[0]/metric[1]

定义训练函数

def train_ch6(net,train_iter,test_iter,num_epochs,lr,device):
    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)
    net.to(device)
    #把网络放到cuda或者cpu中运行
    optimizer = torch.optim.SGD(net.parameters(),lr=lr)
    #定义优化函数
    loss = nn.CrossEntropyLoss()
    #定义损失函数
    animator = d2l.Animator(xlabel='epoch',xlim=[1,num_epochs],legend=['train loss','train acc','test acc'])
    #定义可视化函数
    timer,num_batches=d2l.Timer(),len(train_iter)
    for epoch in range(num_epochs):
        metric=d2l.Accumulator(3)
        net.train()
        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():
                metric.add(l*x.shape[0],d2l.accuracy(y_hat,y),x.shape[0])
                #存放（错误的个数（损失度*总个数），正确的个数，总个数）
            timer.stop()
            #停止计时
            train_l=metric[0]/metric[2]
            train_acc=metric[1]/metric[2]
            if (i+1)%(num_batches//5)==0 or i==num_batches-1:
                #//是整数除法，大致意思就是每5组数据，就在可视化图上标一个点
                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)}')

AlexNet

丢弃法控制模型复杂度

relu，相比sigmoid函数，他让梯度更大，

sigmoid激活函数的输出一般接近0或者1，这些地方的梯度几乎为0。relu函数在正区间的梯度总为1。所以他让梯度更大。

在零点处支撑一阶导，支持更深的模型

maxpooling使输出更大，让梯度更大一点

 

VGG

 

首先3*3计算更快。其次，在同样的计算成本下， 模型更深、窗口更窄的效果比较好。所以不是5*5

块中的每一次卷积都是3*3 填充1（3-1=2 /2=1）所以每层卷积之后 特征图大小不变。

在块末，2*2池化，步幅为2，即，特征图直接小一半。所以后一块的输入是前一块的输出（前一块输入的一半）。如上上上图，224 112 56 28 14 7