【第2周】卷积神经网络

1. 代码练习

 MNIST 数据集分类：构建简单的CNN对 mnist 数据集进行分类。同时，还会在实验中学习池化与卷积操作的基本作用。

CIFAR10 数据集分类：使用 CNN 对 CIFAR10 数据集进行分类；使用 VGG16 对 CIFAR10 分类。

1.1 MNIST 数据集分类：

分别创建一个简单的全连接网络和卷积神经网络，并训练：

class FC2Layer(nn.Module):
    def __init__(self, input_size, n_hidden, output_size):
        # nn.Module子类的函数必须在构造函数中执行父类的构造函数
        # 下式等价于nn.Module.__init__(self)        
        super(FC2Layer, self).__init__()
        self.input_size = input_size
        # 这里直接用 Sequential 就定义了网络，注意要和下面 CNN 的代码区分开
        self.network = nn.Sequential(
            nn.Linear(input_size, n_hidden), 
            nn.ReLU(), 
            nn.Linear(n_hidden, n_hidden), 
            nn.ReLU(), 
            nn.Linear(n_hidden, output_size), 
            nn.LogSoftmax(dim=1)
        )
    def forward(self, x):
        # view一般出现在model类的forward函数中，用于改变输入或输出的形状
        # x.view(-1, self.input_size) 的意思是多维的数据展成二维
        # 代码指定二维数据的列数为 input_size=784，行数 -1 表示我们不想算，电脑会自己计算对应的数字
        # 在 DataLoader 部分，我们可以看到 batch_size 是64，所以得到 x 的行数是64
        # 大家可以加一行代码：print(x.cpu().numpy().shape)
        # 训练过程中，就会看到 (64, 784) 的输出，和我们的预期是一致的

        # forward 函数的作用是，指定网络的运行过程，这个全连接网络可能看不啥意义，
        # 下面的CNN网络可以看出 forward 的作用。
        x = x.view(-1, self.input_size)
        return self.network(x)
    


class CNN(nn.Module):
    def __init__(self, input_size, n_feature, output_size):
        # 执行父类的构造函数，所有的网络都要这么写
        super(CNN, self).__init__()
        # 下面是网络里典型结构的一些定义，一般就是卷积和全连接
        # 池化、ReLU一类的不用在这里定义
        self.n_feature = n_feature
        self.conv1 = nn.Conv2d(in_channels=1, out_channels=n_feature, kernel_size=5)
        self.conv2 = nn.Conv2d(n_feature, n_feature, kernel_size=5)
        self.fc1 = nn.Linear(n_feature*4*4, 50)
        self.fc2 = nn.Linear(50, 10)    
    
    # 下面的 forward 函数，定义了网络的结构，按照一定顺序，把上面构建的一些结构组织起来
    # 意思就是，conv1, conv2 等等的，可以多次重用
    def forward(self, x, verbose=False):
        x = self.conv1(x)
        x = F.relu(x)
        x = F.max_pool2d(x, kernel_size=2)
        x = self.conv2(x)
        x = F.relu(x)
        x = F.max_pool2d(x, kernel_size=2)
        x = x.view(-1, self.n_feature*4*4)
        x = self.fc1(x)
        x = F.relu(x)
        x = self.fc2(x)
        x = F.log_softmax(x, dim=1)
        return x

 打乱像素顺序再次在两个网络上训练与测试：

# 这里解释一下 torch.randperm 函数，给定参数n，返回一个从0到n-1的随机整数排列
perm = torch.randperm(784)
plt.figure(figsize=(8, 4))
for i in range(10):
    image, _ = train_loader.dataset.__getitem__(i)
    # permute pixels
    image_perm = image.view(-1, 28*28).clone()
    image_perm = image_perm[:, perm]
    image_perm = image_perm.view(-1, 1, 28, 28)
    plt.subplot(4, 5, i + 1)
    plt.imshow(image.squeeze().numpy(), 'gray')
    plt.axis('off')
    plt.subplot(4, 5, i + 11)
    plt.imshow(image_perm.squeeze().numpy(), 'gray')
    plt.axis('off')

# 对每个 batch 里的数据，打乱像素顺序的函数
def perm_pixel(data, perm):
    # 转化为二维矩阵
    data_new = data.view(-1, 28*28)
    # 打乱像素顺序
    data_new = data_new[:, perm]
    # 恢复为原来4维的 tensor
    data_new = data_new.view(-1, 1, 28, 28)
    return data_new

 

总结：分别在小型全连接网络和卷积神经网络上进行训练，可以发现：含有相同参数的 CNN 效果要明显优于简单的全连接网络，是因为 CNN 主要通过卷积和池化两个操作，更好的挖掘图像中的信息。打乱像素顺序后再在这两个网络上测试，卷积神经网络的性能显著下降。这是因为CNN中的卷积操作，通过filter选取相邻像素的5*5大小的receptive field，如果打乱像素顺序，receptive field的特征性下降，进而CNN的泛化能力将会下降。

1.2 CIFAR10 数据集分类：

使用CNN进行CIFAR10 数据集分类

class Net(nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = nn.Conv2d(3, 6, 5)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(6, 16, 5)
        self.fc1 = nn.Linear(16 * 5 * 5, 120)
        self.fc2 = nn.Linear(120, 84)
        self.fc3 = nn.Linear(84, 10)

    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = x.view(-1, 16 * 5 * 5)
        x = F.relu(self.fc1(x))
        x = F.relu(self.fc2(x))
        x = self.fc3(x)
        return x

# 网络放到GPU上
net = Net().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), lr=0.001)


for epoch in range(10):  # 重复多轮训练
    for i, (inputs, labels) in enumerate(trainloader):
        inputs = inputs.to(device)
        labels = labels.to(device)
        # 优化器梯度归零 防止与上个数据相关
        optimizer.zero_grad()
        # 正向传播 +　反向传播 + 优化 
        outputs = net(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        # 输出统计信息
        if i % 100 == 0:   
            print('Epoch: %d Minibatch: %5d loss: %.3f' %(epoch + 1, i + 1, loss.item()))

print('Finished Training')

Accuracy of the network on the 10000 test images: 64 %，可以看到准确率不高。

使用VGG16 对 CIFAR10 分类

class VGG(nn.Module):
    def __init__(self):
        super(VGG, self).__init__()
        self.cfg = [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M']
        #self.features = self._make_layers(self.cfg)
        #self.classifier = nn.Linear(2048, 10)
        self.features = self._make_layers(self.cfg)
        self.classifier = nn.Linear(512, 10)

    def forward(self, x):
        out = self.features(x)
        out = out.view(out.size(0), -1)
        out = self.classifier(out)
        return out

    def _make_layers(self, cfg):
        layers = []
        in_channels = 3
        for x in cfg:
            if x == 'M':
                layers += [nn.MaxPool2d(kernel_size=2, stride=2)]
            else:
                layers += [nn.Conv2d(in_channels, x, kernel_size=3, padding=1),
                           nn.BatchNorm2d(x),
                           nn.ReLU(inplace=True)]
                in_channels = x
        layers += [nn.AvgPool2d(kernel_size=1, stride=1)]
        return nn.Sequential(*layers)
     
# 网络放到GPU上

net = VGG().to(device)
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), lr=0.001)

 Accuracy of the network on the 10000 test images: 83.88 %，可以看到使用一个简化版的 VGG 网络，就可以显著提高性能。

使用VGG19 对 CIFAR10 分类

# 定义网络模型
class VGG19Net(nn.Module):
    def __init__(self):
        super(VGG19Net, self).__init__()
 
        net = []
 
         # 输入32*32，输出16*16
        net.append(make_vgg_block(3, 64, 2))
 
         # 输出8*8
        net.append(make_vgg_block(64, 128, 2))
 
         # 输出4*4
        net.append(make_vgg_block(128, 256, 4))
 
         # 输出2*2
        net.append(make_vgg_block(256, 512, 4))
 
         # 无池化层，输出保持2*2
        net.append(make_vgg_block(512, 512, 4, False))
 
        self.cnn = nn.Sequential(*net)
 
        self.fc = nn.Sequential(
             # 512个feature，每个feature 2*2
            nn.Linear(512*2*2, 256),
            nn.ReLU(),
 
            nn.Linear(256, 256),
            nn.ReLU(),
 
            nn.Linear(256, 10)
         )
 
    def forward(self, x):
        x = self.cnn(x)
 
         # x.size()[0]: batch size
        x = x.view(x.size()[0], -1)
        x = self.fc(x)
 
        return x

Accuracy of the network on the 10000 test images: 77.52 % 相较于VGG16有所下降。VGG19更深，但却没有更好的性能。？？？

VGG16层结构（13个卷积层和3个全连接层）

VGG19层结构（16个卷积层和3个全连接层）

使用ResNet 对 CIFAR10 分类

# ResNet
class ResNet(nn.Module):
    def __init__(self, block, layers, num_classes=10):
        super(ResNet, self).__init__()
        self.in_channels = 16
        self.conv = conv3x3(3, 16)
        self.bn = nn.BatchNorm2d(16)
        self.relu = nn.ReLU(inplace=True)
        self.layer1 = self.make_layer(block, 16, layers[0])
        self.layer2 = self.make_layer(block, 32, layers[1], 2)
        self.layer3 = self.make_layer(block, 64, layers[2], 2)
        self.avg_pool = nn.AvgPool2d(8)
        self.fc = nn.Linear(64, num_classes)

    def make_layer(self, block, out_channels, blocks, stride=1):
        downsample = None
        if (stride != 1) or (self.in_channels != out_channels):
            downsample = nn.Sequential(
                conv3x3(self.in_channels, out_channels, stride=stride),
                nn.BatchNorm2d(out_channels))
        layers = []
        layers.append(block(self.in_channels, out_channels, stride, downsample))
        self.in_channels = out_channels
        for i in range(1, blocks):
            layers.append(block(out_channels, out_channels))
        return nn.Sequential(*layers)

    def forward(self, x):
        out = self.conv(x)
        out = self.bn(out)
        out = self.relu(out)
        out = self.layer1(out)
        out = self.layer2(out)
        out = self.layer3(out)
        out = self.avg_pool(out)
        out = out.view(out.size(0), -1)
        out = self.fc(out)
        return out

Accuracy of the network on the 10000 test images: 80.28 %，性能还可以。

总结：测试了CNN,VGG16,VGG19,ResNet对CIFAR10 分类性能，可以发现不同网络模型的性能不同，越复杂不一定越准确。要提升准确率，不仅要选择恰当的模型，还要调整各个参数，设置不同的策略，来达到较好的效果。

2. 问题总结

1.dataloader   里面 shuffle 取不同值有什么区别？

Shuffle为true表示随机读取样本，false为按顺序读取样本。一般来说训练集的shuffle为true，测试集的shuffle为false，这样是为了提高模型的泛化能力，防止模型陷入局部最优。Shuffle可以防止过拟合，并且使得模型学到更加正确的特征。

2. transform 里，取了不同值，这个有什么区别？

torchvision.transforms: 里面包括常用的图像预处理方法，用于图片的转换等一系列预处理操作，例如数据归一化，缩放，裁剪，旋转，翻转，填充，添加噪声，灰度变换，线性变换，仿射变换，亮度，饱和度，对比变换等。当进行数据预处理时，可以将通过transform平移、翻转、对称图片，改变RGB通道强度，扩大样本量，达到数据增强的作用。

3.epoch 和 batch 的区别？

当一个完整的数据集经过神经网络一次，并返回一次，这个过程称为一个epoch。epoch定义了学习算法在整个训练数据集中的工作次数。epoch由一个或多个batch组成。epoch 数量一般很大，通常是数百或数千，允许学习算法运行到模型的误差被充分地最小化。

当数据集很大时，对于每个 epoch，很难将所有的数据集一次读入到内存中，这就需要将数据集分为几次读入，每次称为一个 batch。

4.1x1的卷积和 FC 有什么区别？主要起什么作用？

1x1的卷积主要是为了进行降维，增加特征多样性，表征能力更强，加入非线性，提升网络的表达能力。在 googLeNet、ResNet、DenseNet 中得到了非常广泛的应用。而全连接层每一个结点都与上一层的所有结点相连，进行一个全连接。实际就是进行卷积运算，卷积后的结果为全连接层的一个节点。从计算上来说，1x1的卷积和 FC 都是一个卷积计算的过程（y=WX+b），在理论上是可以相互替代的。

5.residual leanring 为什么能够提升准确率？

残差block：去掉相同的主体部分，从而突出微小的变化

​

解决了随着网络深度的增加带来的梯度消散问题，减轻了神经网络的退化。

6.代码练习二里，网络和1989年 Lecun 提出的 LeNet 有什么区别？

练习二使用最大值池化 ，LeNet中使用平均值池化。

分类识别常使用最大值池化，当需要综合特征图上的所有信息做相应决策时，通常会用平均值池化。

7.代码练习二里，卷积以后feature map 尺寸会变小，如何应用 Residual Learning??????

当维度不一致时（对应的是维度增加一倍），这就不能直接相加。有两种策略：（1）采用zero-padding增加维度，此时一般要先做一个downsamp，可以采用strde=2的pooling，这样不会增加参数；（2）采用新的映射（projection shortcut），一般采用1x1的卷积，这样会增加参数，也会增加计算量。

8.有什么方法可以进一步提升准确率？

DropOut随机失活：训练时随机关闭部分神经元，测试时整合全部神经元。

数据增强：图片平移、翻转、对称，改变RGB通道强度。

多卷积核：增加特征多样性，插入1*1卷积核进行降维，用小的卷积核代替大的卷积核。

3.视频随记

全连接网络处理图像的问题

参数太多：权重矩阵参数太多导致过拟合

卷积神经网络的解决方式

局部关联，参数共享？

kernel/filter:卷积核/滤波器

weights：权重

receptive field：感受野

activation map/feature map：特征图

y=WX+b  W：卷积核 b：stride

padding扩充

不加padding时输出的特征图大小：（N-F）stride+1

加padding时输出的特征图大小：（N+2padding-F）stride+1

depth/channel:深度，与filter个数相同

池化Pooling：缩放featuremap,保留主要特征，减少参数和计算量，防止过拟合提高泛化能力。一般位于卷积层和卷积层之间。

最大值池化（分类识别）和平均值池化

全连接层：两层之间的所有神经元都有权重链接，位于尾部。

​

AlexNet

DropOut随机失活：随机关闭部分神经元，测试时整合全部神经元

数据增强：平移 翻转 对称，改变RGB通道强度

卷积-ReLU-池化   

ZFNet

 网络结构和AlexNet结构相同，感受野相同，滤波器变多。

VGG

是一个更深网络  参数量更多

GoogleNet

很深，但参数量不大，没有FC层

多卷积核增加特征多样性，利用padding保持多卷积核串联输出大小一致，太复杂

插入1*1卷积核进行降维，用小的卷积核代替大的卷积核，降低参数量，增加非线性激活函数，表征能力更强

Stem部分（卷-池）- 多个Inception结构堆叠 - 输出（没有额外的全连接层，除了最后的类别分类）

利用辅助分类器解决模型深度过深导致的梯度消失问题

ResNet残差学习网络

深度152层 残差block：去掉相同的主体部分，从而突出微小的变化

可以用来训练非常深的网络