第三次作业：卷积神经网络基础

视频学习

邱琦

讲述了卷积神经网络的应用：分类，检索，检测，分割，人脸识别，表情识别，图像生成，自动驾驶。卷积神经网络相对传统神经网络的优点：局部关联，参数共享。卷积神经网络存在卷积层，RELU激活层，池化层，全连接层。其中卷积是对两个实变函数的一种数学操作，将图片进行参数化。池化层保留了主要特征的同时减少参数和计算量，防止过拟合，提高模型泛化能力。全连接层两层之间所有神经元都有权重链接，通常在卷积神经网络尾部，参数量通常最大。卷积神经网络典型结构包括AlexNet，ZFNet，VGG，GoogleNet，ResNet。这次视频最后举的例子，能够帮助较好的理解，再加上自己的实验，能够对课程有更好的理解。

陈江栋

对于计算机视觉来说，每⼀个图像是由⼀个个像素点构成，每个像素点有三个通道，分别
代表RGB三种颜⾊(不计算透明度)，我们以⼿写识别的数据集MNIST举例，每个图像的是 ⼀个⻓宽均为28，channel（通道数）为1的单⾊图像，如果使⽤全连接的⽹络结构， 即，⽹络中的神经与相邻层上的每个神经元均连接，那就意味着我们的⽹络有
28×28=784个神经元（RGB3⾊的话还要乘3），hidden层如果使⽤了15个神经元，需要 的参数个数(w和b)就有：28×28×15×10+15+10=117625个，这个数量级到现在为⽌也是 ⼀个很恐怖的数量级，⼀次反向传播计算量都是巨⼤的，这还只是⼀个单⾊的28像素⼤ ⼩的图⽚，如果我们使⽤更⼤的像素，计算量可想⽽知。 上⾯说到传统的⽹络需要⼤量的参数，但是这些参数是否重复了呢，例如，我们识别⼀个
⼈，只要看到他的眼睛，⿐⼦，嘴，还有脸基本上就知道这个⼈是谁了，只是⽤这些局部 的特征就能做做判断了，并不需要所有的特征。 另外⼀点就是我们上⾯说的可以有效提 取了输⼊图像的平移不变特征，就好像我们看到了这是个眼睛，这个眼睛在左边还是在右 边他都是眼睛，这就是平移不变性。并且我们也⼀般认为两个靠近的物品他俩都有相似的 属性。这也是图像本⾝的特性，这⼀特性在把NLP中transformer模型迁移到CV领域⽽产 ⽣的swin-transformer这⼀篇论⽂中起到了很⼤的影响⼒。 我们通过卷积的计算操作来提 取图像局部的特征，每⼀层都会计算出⼀些局部特征，这些局部特征再汇总到下⼀层，这 样⼀层⼀层的传递下去，特征由初级变为⾼级，最后在通过这些局部的特征对图⽚进⾏处 理，这样⼤⼤提⾼了计算效率，也提⾼了准确度。

李智杰

通过视频，学习到了许多关于卷积神经网络的知识，学习到了卷积网络的基本结构，卷积、池化和一些经典的网络与结构，AlexNet、VGG16、VGG19，GoogleNet的Inception和ResNet，通过后面的代码练习也了解到了相比传统的神经网络，卷积网络具有巨大的优势。

宋子昂

卷积神经网络的应用非常广泛，包括分类、检索、检测、分割、人脸识别、图像生成等，这些应用在我们现在看来都非常普遍；由此可以看出卷积神经网络的重要性。而与传统神经网络相比，卷积神经网络主要突出在局部关联、参数共享，它不像传统的网络那样需要大量的参数。这样可以在训练的时候大大节省时间。CNN在图像处理问题上优势明显，它是一个可以自动提取特征，而且待训练参数相对不是很多的神经网络。卷积神经网络是一个由卷积层、激活层、池化层、全连接层聚合而成的网络结构。卷积运用了局部连接的思想，它对图片的处理方式是一块一块的，并不是所有像素值一起处理，因此可以极大的降低参数值的总量。通过视频的学习，我觉得发现卷积这一个点的人也是相当厉害了，通过矩阵相乘来实现了提取特征这一过程。但同时池化层的思想，我认为在网络中的使用有待商榷，我认为应该分情况来决定是否使用池化层，这可以说是一种丢失了细节来提升模型不变性的方法，是存在一定弊端的，以后的研究可以提高池化层的准确率，避免在训练时丢失掉重要的细节。而全连接层实际上就是一个分类器！在CNN有不少优势的同时，我们也需正视其局限性：没有考虑图像中特征的依赖关系，且对特征的全局位置不敏感等在以后的研究中，希望可以有这些问题的解决。

韦境

通过本次对神经网络的学习，我深刻了解到了这一学科的严谨性和思维发散性。最令我感触的时googlenet模型中，对1×1卷积的应用。当某个卷积层输入的特征数较多，对这个输入进行卷积运算将产生巨大的计算量；如果对输入先进行降维到1×1，减少特征数后再做卷积计算量就会显著减少。它更高效的利用计算资源，在相同的计算量下能提取到更多的特征。

陈晓政

卷积神经网络是一种深度学习模型或类似于人工神经网络的多层感知器，卷积神经网络依旧是层级网络，只是层的功能和形式做了变化，是传统神经网络的一个改进。卷积神经网络是仿照生物的视知觉来构建的，可以进行监督学习和非监督学习。
卷积神经网络主要由 5 层组成：数据输入层，卷积计算层，ReLU 激励层 ，池化层 ，全连接层 。
优点：共享卷积核，对高维数据处理无压力，无需手动选取特征，训练好权重，即得特征分类效果好。
缺点：需要调参，需要大样本量，训练最好要 GPU，物理含义不明确，也就是说，我们并不知道没个卷积层到底提取到的是什么特征，而且神经网络本身就是一种难以解释的“黑箱模型”。

代码练习

MNIST 数据集分类

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

1. 引入库文件

mport torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
from torchvision import datasets, transforms
import matplotlib.pyplot as plt
import numpy

# 一个函数，用来计算模型中有多少参数
def get_n_params(model):
    np=0
    for p in list(model.parameters()):
        np += p.nelement()
    return np

# 使用GPU训练，可以在菜单 "代码执行工具" -> "更改运行时类型" 里进行设置
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

2. 加载数据

PyTorch里包含了 MNIST， CIFAR10 等常用数据集，调用 torchvision.datasets 即可把这些数据由远程下载到本地，下面给出MNIST的使用方法：

torchvision.datasets.MNIST(root, train=True, transform=None, target_transform=None, download=False)

• root 为数据集下载到本地后的根目录，包括 training.pt 和 test.pt 文件
• train，如果设置为True，从training.pt创建数据集就是为训练集，否则从test.pt创建即测试集。
• download，如果设置为True, 从互联网下载数据并放到root文件夹下
• transform, 一种函数或变换，输入PIL图片，返回变换之后的数据。
• target_transform 一种函数或变换，输入目标，进行变换。

配合DataLoader进行使用
loader_data=DataLoader(test_set,batch_size=64,shuffle=True,drop_last=True)

• 首先传入一个dataset数据类型的数据
• batch_size：可以理解为一副牌，每个人手里拿几张牌
• shuffle：是否每次随机抓取，就是是否重新洗牌
• drop_last：总共的dataset的数量除以batch_size的余数是否保留
• num_workers：加载数据的时候使用几个子进程

input_size  = 28*28   # MNIST上的图像尺寸是 28x28
output_size = 10      # 类别为 0 到 9 的数字，因此为十类

train_loader = torch.utils.data.DataLoader(
    datasets.MNIST('./data', train=True, download=True,
        transform=transforms.Compose(
            [transforms.ToTensor(),
             transforms.Normalize((0.1307,), (0.3081,))])),
    batch_size=64, shuffle=True)

test_loader = torch.utils.data.DataLoader(
    datasets.MNIST('./data', train=False, transform=transforms.Compose([
             transforms.ToTensor(),
             transforms.Normalize((0.1307,), (0.3081,))])),
    batch_size=1000, shuffle=True)

2.1 查看数据

除了使用老师提供的plt，还可以使用tensorboard展示

#显示数据集中的部分图像
#除了老师使用的plt还可以使用SummaryWriter
from torch.utils.tensorboard import SummaryWriter
writer=SummaryWriter('logs')#日志文件的存放地址
step=0
for data in train_loader:
  img,target=data
  writer.add_images('train_loader',img,step)
  step=step+1
%load_ext tensorboard
%tensorboard --logdir logs
writer.close()

这里的图像呈现灰色，是因为前面做了标准化处理transforms.Normalize

3. 创建网络

定义网络时，需要继承nn.Module，并实现它的forward方法，把网络中具有可学习参数的层放在构造函数init中。
注：这两个方法必须重写！

只要在nn.Module的子类中定义了forward函数，backward函数就会自动被实现(利用autograd)。

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

3.2 定义训练和测试函数

# 训练函数
def train(model):
    model.train()
    # 主里从train_loader里，64个样本一个batch为单位提取样本进行训练
    for batch_idx, (data, target) in enumerate(train_loader):
        # 把数据送到GPU中
        data, target = data.to(device), target.to(device)

        optimizer.zero_grad()
        output = model(data)
        loss = F.nll_loss(output, target)
        loss.backward()
        optimizer.step()
        if batch_idx % 100 == 0:
            print('Train: [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                batch_idx * len(data), len(train_loader.dataset),
                100. * batch_idx / len(train_loader), loss.item()))


def test(model):
    model.eval()
    test_loss = 0
    correct = 0
    for data, target in test_loader:
        # 把数据送到GPU中
        data, target = data.to(device), target.to(device)
        # 把数据送入模型，得到预测结果
        output = model(data)
        # 计算本次batch的损失，并加到 test_loss 中
        test_loss += F.nll_loss(output, target, reduction='sum').item()
        # get the index of the max log-probability，最后一层输出10个数，
        # 值最大的那个即对应着分类结果，然后把分类结果保存在 pred 里
        pred = output.data.max(1, keepdim=True)[1]
        # 将 pred 与 target 相比，得到正确预测结果的数量，并加到 correct 中
        # 这里需要注意一下 view_as ，意思是把 target 变成维度和 pred 一样的意思                                                
        correct += pred.eq(target.data.view_as(pred)).cpu().sum().item()

    test_loss /= len(test_loader.dataset)
    accuracy = 100. * correct / len(test_loader.dataset)
    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
        test_loss, correct, len(test_loader.dataset),
        accuracy))

4.1 在小型全连接网络上训练（Fully-connected network）

n_hidden = 8 # number of hidden units

model_fnn = FC2Layer(input_size, n_hidden, output_size)
model_fnn.to(device)
optimizer = optim.SGD(model_fnn.parameters(), lr=0.01, momentum=0.5)
print('Number of parameters: {}'.format(get_n_params(model_fnn)))

train(model_fnn)
test(model_fnn)

运行结果

4.2 在卷积神经网络上训练

#@title 3.2 在卷积神经网络上训练
# Training settings 
n_features = 6 # number of feature maps

model_cnn = CNN(input_size, n_features, output_size)
model_cnn.to(device)
optimizer = optim.SGD(model_cnn.parameters(), lr=0.01, momentum=0.5)
print('Number of parameters: {}'.format(get_n_params(model_cnn)))

train(model_cnn)
test(model_cnn)

运行结果

通过上面的测试结果，可以发现，含有相同参数的 CNN 效果要明显优于 简单的全连接网络，是因为 CNN 能够更好的挖掘图像中的信息，主要通过两个手段：

• 卷积：Locality and stationarity in images
• 池化：Builds in some translation invariance

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

5.1 图像的形态

考虑到CNN在卷积与池化上的优良特性，如果我们把图像中的像素打乱顺序，这样 卷积 和 池化 就难以发挥作用了，为了验证这个想法，我们把图像中的像素打乱顺序再试试。

首先下面代码展示随机打乱像素顺序后，图像的形态：

#@title 4. 打乱像素顺序再次在两个网络上训练与测试
# 这里解释一下 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

# 训练函数
def train_perm(model, perm):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        # 像素打乱顺序
        data = perm_pixel(data, perm)

        optimizer.zero_grad()
        output = model(data)
        loss = F.nll_loss(output, target)
        loss.backward()
        optimizer.step()
        if batch_idx % 100 == 0:
            print('Train: [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format(
                batch_idx * len(data), len(train_loader.dataset),
                100. * batch_idx / len(train_loader), loss.item()))

# 测试函数
def test_perm(model, perm):
    model.eval()
    test_loss = 0
    correct = 0
    for data, target in test_loader:
        data, target = data.to(device), target.to(device)

        # 像素打乱顺序
        data = perm_pixel(data, perm)

        output = model(data)
        test_loss += F.nll_loss(output, target, reduction='sum').item()
        pred = output.data.max(1, keepdim=True)[1]                                            
        correct += pred.eq(target.data.view_as(pred)).cpu().sum().item()

    test_loss /= len(test_loader.dataset)
    accuracy = 100. * correct / len(test_loader.dataset)
    print('\nTest set: Average loss: {:.4f}, Accuracy: {}/{} ({:.0f}%)\n'.format(
        test_loss, correct, len(test_loader.dataset),
        accuracy))

重新定义训练与测试函数，我们写了两个函数 train_perm 和 test_perm，分别对应着加入像素打乱顺序的训练函数与测试函数。

与之前的训练与测试函数基本上完全相同，只是对 data 加入了打乱顺序操作。

5.2 在全连接网络上训练与测试：

#@title 4.1 在全连接网络上训练与测试：
perm = torch.randperm(784)
n_hidden = 8 # number of hidden units

model_fnn = FC2Layer(input_size, n_hidden, output_size)
model_fnn.to(device)
optimizer = optim.SGD(model_fnn.parameters(), lr=0.01, momentum=0.5)
print('Number of parameters: {}'.format(get_n_params(model_fnn)))

train_perm(model_fnn, perm)
test_perm(model_fnn, perm)

5.3 在卷积神经网络上训练与测试:

#@title 4.2 在卷积神经网络上训练与测试:
perm = torch.randperm(784)
n_features = 6 # number of feature maps

model_cnn = CNN(input_size, n_features, output_size)
model_cnn.to(device)
optimizer = optim.SGD(model_cnn.parameters(), lr=0.01, momentum=0.5)
print('Number of parameters: {}'.format(get_n_params(model_cnn)))

train_perm(model_cnn, perm)
test_perm(model_cnn, perm)

从打乱像素顺序的实验结果来看，全连接网络的性能基本上没有发生变化，但是 卷积神经网络的性能明显下降。

这是因为对于卷积神经网络，会利用像素的局部关系，但是打乱顺序以后，这些像素间的关系将无法得到利用。

关于实验中的一些问题

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

当shuffle取True时就是每次取为乱序
取False就不会重新随机排序

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

transform=transforms.Compose(
            [transforms.ToTensor(),
             transforms.Normalize((0.1307,), (0.3081,))])

首先理解transform是对数据进行一些预处理的操作
1. Compose为一个流水线操作，就是依次执行数组里的操作
2. ToTensor将数据转为tensor数据类型
3. Normalize进行归一化处理，这就是为什么查看图片会是灰色的

3. epoch 和 batch 的区别？
   • Epoch：所有训练样本在神经网络中都进行了一次正向传播和一次反向传播。也就是1个epoch等于使用训练集中的全部样本训练一次。
   • Batch：将整个训练样本分成若干个Batch。
4. 1x1的卷积和 FC 有什么区别？主要起什么作用？
   • 1x1的卷积是针对矩阵的卷积操作，1x1卷积不改变宽度和高度，只改变channel数，主要作用是升维、降维以及提升网络的非线性；
   • FC是针对神经元的操作。FC的作用主要是将局部特征进行整合，并得到分类标签。

CIFAR10 数据集分类

使用 CNN 对 CIFAR10 数据集进行分类:
运用totchvision包来进行视觉数据的处理，数据集选用CIFAR10，包含十个类别：‘airplane’, ‘automobile’, ‘bird’, ‘cat’, ‘deer’, ‘dog’, ‘frog’, ‘horse’, ‘ship’, ‘truck’。CIFAR-10 中的图像尺寸为3x32x32，也就是RGB的3层颜色通道，每层通道内的尺寸为32*32。

首先，加载并归一化 CIFAR10 使用 torchvision 。torchvision 数据集的输出是范围在[0,1]之间的 PILImage，我们将他们转换成归一化范围为[-1,1]之间的张量 Tensors。

导入相关包，下载相关数据集并使用GPU训练：

通过书写imshow函数来展示CIFAR10里面的一些图片：

定义网络、损失函数和优化器：

训练网络，该过程耗时2分钟：

从测试集中取出8张图片：

把图片输入建立好的模型，查看CNN模型的识别效果，可以发现识别准确度不高，出现了一些错误：

再来查看网络在整个数据集上的表现，我们发现准确率只能说是可以接受：

所以我们需要建立更好的网络模型，总结CNN的使用效果，我们可以得到一些缺点：

• 当网络层次太深时，采用BP传播修改参数会使靠近输入层的参数改动较慢；
• 采用梯度下降算法很容易使训练结果收敛于局部最小值而非全局最小值；
• 池化层会丢失大量有价值信息，忽略局部与整体之间关联性；
• 由于特征提取的封装，为网络性能的改进罩了一层黑盒

使用 VGG16 对 CIFAR10 分类

1. 重新定义 dataloader

2. VGG 网络定义

原代码中出现“cfg”无法识别问题，将参数layers（cfg）改为layers（self.cfg）后正常运行。

3. 网络训练

原代码出现RuntimeError: mat1 and mat2 shapes cannot be multiplied (128x512 and 2048x10)报错，因此对nn.Linear 参数进行修改，把2048改成了512。

4. 测试验证准确率

使用一个简化版的 VGG 网络，就能将准确率提升到 83.18%

改为训练15次后，准确率提升到87.64%。

问题回答

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

dataloader是一个加载数据到模型中训练的方法，其中的参数shuffle参数有True/False两种取值；官方文档的解释如下：

· 当shuffle=false时，每次的训练不打乱数据的顺序，然后以batch为单位取数据
· 当shuffle=true时，每次训练前打乱所有的数据次序，然后以batch为单位取数据

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

transform里可以通过不同参数实现一些常用的数据预处理操作。
transforms.normalize()使得数据服从01分布。
加速了收敛，其使用的公式为 x=(x-mean)/std

3、epoch 和 batch 的区别？

一个epoch中包含了多个batch，每一次对整个数据集的训练都是一次epoch，而batch则表示单个epoch中一次批处理数据所包含的数据单位。

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

1×1卷积核是对二维情况下的简化，使得其仅仅反映在深度上的变化，起到了降维的作用。
相对于FC，1×1卷积核需要的参数量会比FC层所使用的参数量少，计算速度更快。

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

因为它引入了残差网络结构的概念，残差网络借鉴了高速网络的跨层链接思想，对其进行改进，打破了传统的神经网络n-1层的输出只能给n层作为输入的惯例，使某一层的输出可以直接跨过几层作为后面某一层的输入，从而解决了深度增加后的“退化”问题，达到了提高准确率的目的。

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

代码练习二中使用的是最大池化和ReLU激活函数，而LeNet使用的是平均池化，激活函数是sigmoid；

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

通过线性变换将原图像缩小为和feature map大小相同的图像；当输入输出维度上升时有两种处理方式：第一种是仍使用恒等映射，多出来的通道使用零矩阵填充，这样做的好处是不会带来额外的参数；第二种是添加变换方程，通常来说会使用 1*1 卷积来完成升维。

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

调整网络结构；增加数据集的大小，使数据更加丰富；增加深度与节点数；使用不同的激活函数、交叉熵函数；增加训练轮数