第四周作业：卷积神经网络（Part2）

一、理论学习

1、AlexNet的主要改进：在全连接层后增加丢弃法Dropout、使用ReLU减缓梯度消失、使用MaxPooling

　　

　　上下两层是两个GPU的结果，输入为227*227*3的图片（由224*224*3调整得来），第一层卷积的卷积核数量为96，卷积核大小为11*11*3，步长是4，padding=0，卷积后得到的图像大小feature map size为55*55*96，由于采用双CPU处理，所以数据分为两组，分别是55*55*48

　　池化运算里步长为2，卷积核大小为3*3，计算过程是（55-3）/2+1=27，池化后的图像尺寸为27*27*96

　　第二层卷积输入是27*27*96的像素层，步长为1，卷积核大小为5*5*256，padding=2，feature map 为27*27*256

　　池化运算里步长为2，卷积核大小为3*3，计算过程是（27-3）/2+1=13，feature map 为13*13*256

　　第三层卷积输入是13*13*128的像素层，步长为1，卷积核大小为3*3*384，padding=1，feature map 为13*13*384

　　第四层卷积输入是13*13*192的像素层，卷积核大小为3*3*384，padding=1，feature map 为13*13*384

　　第五层卷积输入是13*13*192的像素层，步长为1，卷积核大小为3*3*256，padding=1，feature map 为13*13*256

　　池化运算里步长为2，卷积核大小为3*3，计算过程为（13-3）/2+1=6，feature map 为6*6*256

　　第六层第七层是全连接层，神经元个数为4096，第八层全连接层神经元个数为1000，对应于ImageNet的1000类。

net = nn.Sequential(
    nn.Conv2d(1, 96, kernel_size=11, stride=4, padding=1), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2),
    nn.Conv2d(96, 256, kernel_size=5, padding=2), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2),
    nn.Conv2d(256, 384, kernel_size=3, padding=1), nn.ReLU(),
    nn.Conv2d(384, 384, kernel_size=3, padding=1), nn.ReLU(),
    nn.Conv2d(384, 256, kernel_size=3, padding=1), nn.ReLU(),
    nn.MaxPool2d(kernel_size=3, stride=2), nn.Flatten(),
    nn.Linear(6400, 4096), nn.ReLU(), nn.Dropout(p=0.5),
    nn.Linear(4096, 4096), nn.ReLU(), nn.Dropout(p=0.5),
    nn.Linear(4096, 10))

　　除此之外，AlexNet还应用了“局部响应归一化层”，形象来说对于13×13×256，由于不需要太多高激活神经元，LRN要选取一个位置，从这个位置穿过整个通道得到256个数字并进行归一化。但是LRN的效果并不理想。

2、VGG：更大更深的AlexNet，使用可重复使用的卷积块构建网络。网络非常庞大，需要训练的特征数量也很大。随着网络的加深，图像的高度和宽度都在以一定的规律不断缩小，每次池化后刚好缩小一半，而通道数量在不断增加，而且刚好也是在每组卷积操作后增加一倍。也就是说，图像缩小的比例和通道数增加的比例是有规律的。

#vgg块
def vgg_block(num_convs, in_channels, out_channels):
    layers = []
    for _ in range(num_convs):
        layers.append(
            nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1))
        layers.append(nn.ReLU())
        in_channels = out_channels
    layers.append(nn.MaxPool2d(kernel_size=2, stride=2))
    return nn.Sequential(*layers)

#vgg网络
conv_arch = ((1, 64), (1, 128), (2, 256), (2, 512), (2, 512))

def vgg(conv_arch):
    conv_blks = []
    in_channels = 1
    for (num_convs, out_channels) in conv_arch:
        conv_blks.append(vgg_block(num_convs, in_channels, out_channels))
        in_channels = out_channels

    return nn.Sequential(*conv_blks, nn.Flatten(),
                         nn.Linear(out_channels * 7 * 7, 4096), nn.ReLU(),
                         nn.Dropout(0.5), nn.Linear(4096, 4096), nn.ReLU(),
                         nn.Dropout(0.5), nn.Linear(4096, 10))

3、NiN网络：由于全连接层参数多，会产生过拟合

　　无全连接层（NiN块里每个卷积后面两个全连接层）、交替使用NiN块和步长为2的最大池化层、最后使用全局平局池化得到输出。

def nin_block(in_channels, out_channels, kernel_size, strides, padding):
    return nn.Sequential(
        nn.Conv2d(in_channels, out_channels, kernel_size, strides, padding),
        nn.ReLU(), nn.Conv2d(out_channels, out_channels, kernel_size=1),
        nn.ReLU(), nn.Conv2d(out_channels, out_channels, kernel_size=1),
        nn.ReLU())
    
net = nn.Sequential(
    nin_block(1, 96, kernel_size=11, strides=4, padding=0),
    nn.MaxPool2d(3, stride=2),
    nin_block(96, 256, kernel_size=5, strides=1, padding=2),
    nn.MaxPool2d(3, stride=2),
    nin_block(256, 384, kernel_size=3, strides=1, padding=1),
    nn.MaxPool2d(3, stride=2), nn.Dropout(0.5),
    nin_block(384, 10, kernel_size=3, strides=1, padding=1),
    nn.AdaptiveAvgPool2d((1, 1)),
    nn.Flatten())

4、GoogLeNet

　　Inception块：4个路径从不同层面抽取信息，在输出通道维进行合并。输入被copy成4块，第一块进行1x1卷积，第二块先进行1x1卷积再进行3x3卷积（pad=1），第三块先进行1x1卷积再进行5x5卷积（pad=2），第四块先进行3x3的最大池化(pad=1)再进行1x1卷积。采用不同大小的卷积核意味着不同大小的感受野，最后拼接意味着不同尺度特征的融合。四块的总体特征是输出跟输入高宽不变，即等高等宽，但是通道数改变。GoogleNet使用了9个Inception块，最后通道数不断增大变为1024。

　　

class Inception(nn.Module):
    def __init__(self, in_channels, c1, c2, c3, c4, **kwargs):
        super(Inception, self).__init__(**kwargs)
        self.p1_1 = nn.Conv2d(in_channels, c1, kernel_size=1)
        self.p2_1 = nn.Conv2d(in_channels, c2[0], kernel_size=1)
        self.p2_2 = nn.Conv2d(c2[0], c2[1], kernel_size=3, padding=1)
        self.p3_1 = nn.Conv2d(in_channels, c3[0], kernel_size=1)
        self.p3_2 = nn.Conv2d(c3[0], c3[1], kernel_size=5, padding=2)
        self.p4_1 = nn.MaxPool2d(kernel_size=3, stride=1, padding=1)
        self.p4_2 = nn.Conv2d(in_channels, c4, kernel_size=1)

    def forward(self, x):
        p1 = F.relu(self.p1_1(x))
        p2 = F.relu(self.p2_2(F.relu(self.p2_1(x))))
        p3 = F.relu(self.p3_2(F.relu(self.p3_1(x))))
        p4 = F.relu(self.p4_2(self.p4_1(x)))
        return torch.cat((p1, p2, p3, p4), dim=1)

b1 = nn.Sequential(nn.Conv2d(1, 64, kernel_size=7, stride=2, padding=3),
                   nn.ReLU(), nn.MaxPool2d(kernel_size=3, stride=2,
                                           padding=1))

b2 = nn.Sequential(nn.Conv2d(64, 64, kernel_size=1), nn.ReLU(),
                   nn.Conv2d(64, 192, kernel_size=3, padding=1),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

b3 = nn.Sequential(Inception(192, 64, (96, 128), (16, 32), 32),
                   Inception(256, 128, (128, 192), (32, 96), 64),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

b4 = nn.Sequential(Inception(480, 192, (96, 208), (16, 48), 64),
                   Inception(512, 160, (112, 224), (24, 64), 64),
                   Inception(512, 128, (128, 256), (24, 64), 64),
                   Inception(512, 112, (144, 288), (32, 64), 64),
                   Inception(528, 256, (160, 320), (32, 128), 128),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

b5 = nn.Sequential(Inception(832, 256, (160, 320), (32, 128), 128),
                   Inception(832, 384, (192, 384), (48, 128), 128),
                   nn.AdaptiveAvgPool2d((1, 1)), nn.Flatten())

net = nn.Sequential(b1, b2, b3, b4, b5, nn.Linear(1024, 10))

5、批量归一化：底部数据梯度小，训练较慢，后面的层梯度较大，底层变化所有层要跟着变，导致收敛变慢。对全连接层，作用在特征维；对卷积层，作用在通道维。批量归一化可以放在输出激活函数前，也可以作用在输入上。通常使用nn.batchnorm函数完成批量归一化。

6、ResNet：串联一个残差块加入到右边得到f(x)=x+g(x)，使得很深的网络容易训练。随着网络深度增加，梯度逐渐消失，因此引入了残差单元，将前面一层的输出直接连到后面的第二层，进而抑制了退化问题。ResNet的层数很深，借鉴了Highway Network思想，使得原来的拟合输出F(x)变成输出和输入的差F(x)-x，其中F(X)是某一层原始的的期望映射输出，x是输入。

　　

class Residual(nn.Module):  
    def __init__(self, input_channels, num_channels, use_1x1conv=False,
                 strides=1):
        super().__init__()
        self.conv1 = nn.Conv2d(input_channels, num_channels, kernel_size=3,
                               padding=1, stride=strides)
        self.conv2 = nn.Conv2d(num_channels, num_channels, kernel_size=3,
                               padding=1)
        if use_1x1conv:
            self.conv3 = nn.Conv2d(input_channels, num_channels,
                                   kernel_size=1, stride=strides)
        else:
            self.conv3 = None
        self.bn1 = nn.BatchNorm2d(num_channels)
        self.bn2 = nn.BatchNorm2d(num_channels)
        self.relu = nn.ReLU(inplace=True)

    def forward(self, X):
        Y = F.relu(self.bn1(self.conv1(X)))
        Y = self.bn2(self.conv2(Y))
        if self.conv3:
            X = self.conv3(X)
        Y += X
        return F.relu(Y)

b1 = nn.Sequential(nn.Conv2d(3, 64, kernel_size=7, stride=2, padding=3),
                   nn.BatchNorm2d(64), nn.ReLU(),
                   nn.MaxPool2d(kernel_size=3, stride=2, padding=1))

def resnet_block(input_channels, num_channels, num_residuals,
                 first_block=False):
    blk = []
    for i in range(num_residuals):
        if i == 0 and not first_block:
            blk.append(
                Residual(input_channels, num_channels, use_1x1conv=True,
                         strides=2))
        else:
            blk.append(Residual(num_channels, num_channels))
    return blk

b2 = nn.Sequential(*resnet_block(64, 64, 2, first_block=True))
b3 = nn.Sequential(*resnet_block(64, 128, 2))
b4 = nn.Sequential(*resnet_block(128, 256, 2))
b5 = nn.Sequential(*resnet_block(256, 512, 2))

net = nn.Sequential(b1, b2, b3, b4, b5, nn.AdaptiveAvgPool2d((1, 1)),
                    nn.Flatten(), nn.Linear(512, 10))

二、使用ResNet完成猫狗大战

 1、首先是使用李老师的resnet网络跑的猫狗大战，可以发现网络很不稳定，loss时大时小，得到的分类结果不如Alexnet。

　　

 2、使用models自带的resnet50跑猫狗大战，准确率还是不高，我都惊了~

主要是晓晨大佬看出了net.eval()，应用了net.eval（）后准确率直线上升，非常nice。

net = models.resnet50(pretrained=True)
for param in net.parameters():
    param.requirse_grad = False
net.fc = nn.Linear(2048, 2, bias=True) # 二分类

print(net)

# 网络放到GPU上
net = net.to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.fc.parameters(), lr=0.001)
for epoch in range(1):  # 重复多轮训练
    net.train()
    for i, (inputs, labels) in enumerate(train_loader):
        inputs = inputs.to(device)
        labels = labels.to(device)
        # 优化器梯度归零
        optimizer.zero_grad()
        # 正向传播 +　反向传播 + 优化 
        outputs = net(inputs)
        loss = criterion(outputs, labels.long())
        loss.backward()
        optimizer.step() 
    print('Epoch: %d loss: %.6f' %(epoch + 1, loss.item()))
print('Finished Training')

 

 3、看到浩鹏对二分类的处理就很细致，2048直接到2估计会损失不少信息，再试着温柔的下降试试看~