ouc软件工程第三次作业-卷积神经网络

一．视频学习

1、绪论

1.1.卷积神经网络的应用

卷积神经网络主要应用于：分类、检索、分割、人脸识别、人脸表情识别、图像生成、图像风格转化、自动驾驶等。

1.2.传统神经网络VS卷积神经网络

（1）深度学习三部曲

搭建神经网络结构 --> 找到一个合适的损失函数（交叉熵损失，均方误差等）–> 找到一个合适的优化函数，更新参数（反向传播，随机梯度下降等）。

（2）损失函数

损失函数用于衡量预测结果和真实结果的吻合程度，能够帮助卷积神经网络调整参数/权重W，以达到更好的训练效果。

（3）二者比较

传统神经网络核卷积神经网络都采用了层级结构。

全连接网络处理图像的问题：权重矩阵的参数太多 --> 过拟合。

卷积神经网络的解决方式：局部关联，参数共享–>减少了参数规模。

2、基本组成结构

2.1卷积

（1）一维卷积

应用于信号处理中，用于计算信号的延迟累积。

（2）卷积是什么

①卷积是对两个实变函数的一种数学操作，

②在图像处理中，图像是以二维形式输入到神经网络的，因此我们需要二维卷积。

（3）卷积涉及到的基本概念：

①input（输入）：N x N

②kernel/filter（卷积核/滤波器）:F * F

③weights（权重）：kernel中每一个值。

④receptive field（感受野）：卷积核进行一次卷积时所对应的输入的区域。

⑤feature map（特征图）：经过一次卷积之后输出的结果。

⑥depth/channel（深度）：feature map的厚度。

⑦padding：在图像的四周补0的层数，使得卷积操作能兼顾图像边缘。

⑧stride（步长）：卷积核滑动一次的长度。

⑨output（输出）

（4）特征图大小计算

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

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

（5）卷积的可视化：

输出某一层的特征图，观察该层学习到了什么样的特征。

2. 2池化

• 保留主要特征的同时减少参数和计算量，防止过拟合，提高模型泛化能力。

• 一般处于卷积层和卷积层之间，全连接层和全连接层之间。

• 类型：最大值池化/平均池化

3. 3全连接

• 两层之间所有神经元都有权重连接。

• 通常全连接层在卷积神经网络尾部。

• 全连接层参数量通常都最大。

3、卷积神经网络典型结构

3.1AlexNet

AlexNet使得深度学习重回历史舞台，原因有：

①大数据集训练：百万级ImageNet图像数据

②非线性激活函数：ReLU

​ ReLU函数相较于Sigmoid函数有较多优点，在Sigmoid函数中，x小于-5或者大于5时，函数的导数为零，而在ReLU函数中，当x大于0时，导数恒为1，相较于Sigmoid函数，ReLU函数解决了梯度消失的问题（正区间），计算速度加快，只需要判断输入是否大于0，收敛速度远快于sigmoid。

③防过度拟合：

​ Dropout(随机失活)：训练时随机关闭部分神经元，训练时整合所有神经元

​ 数据增强：平移、反转、对称、改变RGB通道强度。

④其他：双GPU实现

分层解析：大体分为：五层卷积和三层全连接，掌握好如何求输出的特征图大小

节点数量越来越少，参数数量越来越多。

3.2VGG

相较于AlexNet,VGG的模型深度由8层增加到了16和19层。

VGG16实现：先将前面的11层训练，将网络参数固定住，然后再进行后面的训练。

ILSVRC top 5 错误率从11.7%到7.3%

VGG的参数量是AlexNet的两倍，参数大部分也在全连接层。

3.3GoogleNet

ImageNet top 5 error:11.7%到6.7%

​ 网络总体结构：网络包含22个带参数的层（带pooling是27层），独立成块的层总共有约100个；

​ 参数量大概是AlexNet的1/12；

​ 没有额外的全连接层（除了最后的类别输出层）

​ 多个inception结构堆叠；

​ 辅助分类器：解决由于模型深度过深导致的梯度消失问题。

inception的改进：

​ ①插入1*1卷积核进行降维

​ ②进一步对v2的参数数量进行降低（降低了参数量，增加了非线性激活函数使网络产生更多独立特，表征能力更强，训练更快。

3.4ResNet

​ 残差学习网络，错误率从6.7%到3.57%，深度有152层。

​ 除了输出之外没有其他全连接层。

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

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

二．代码练习

1、MNIST 数据集分类：构建简单的CNN对 mnist 数据集进行分类。

今天我们学习如何使用 PyTorch 进行CNN的训练与测试

我们还会展示池化与卷积操作的作用

深度卷积神经网络中，有如下特性：

很多层: compositionality

卷积: locality + stationarity of images

池化: Invariance of object class to translations

准备： Import所需的库

代码如下：

import 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")

1.1 加载数据 （MNIST）

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是一个比较重要的类，提供的常用操作有：batch_size(每个batch的大小), shuffle(是否进行随机打乱顺序的操作), 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)

运行截图

显示数据集中的部分图像;

代码如下：

plt.figure(figsize=(8, 5))
for i in range(20):
    plt.subplot(4, 5, i + 1)
    image, _ = train_loader.dataset.__getitem__(i)
    plt.imshow(image.squeeze().numpy(),'gray')
plt.axis('off');

运行结果：

1.2创建网络

定义网络时，需要继承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
 

定义训练和测试函数：

代码如下：

# 训练函数
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))

1.3在小型企业上进行训练

代码如下：

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)

运行结果如图：

从运行结果中，我们可以看出， 训练过程中，Loss逐渐减小， 整个训练过程中 Loss的平均值达到了 0.4954， 准确率是85 % ，准确率较高。

1.4在卷积神经网络上训练

需要注意的是，上在定义的CNN和全连接网络，拥有相同数量的模型参数

代码如下：

\# 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)

 

运行结果如下：

整个训练过程中 Loss的平均值达到了 0.1665， 准确率是95 % ，准确率更高。

在卷积神经网络上训练比在小型全连接网络上训练的准确率有明显的提升，平均Loss 有明显的下降。

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

卷积：Locality and stationarity in images

池化：Builds in some translation invariance

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

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

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

代码：
\# 这里解释一下 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')

运行结果：

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

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

# 对每个 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))

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

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)

运行结果：

整个训练过程中 Loss的平均值达到了 0.4271， 准确率是88%

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

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)

运行结果：

整个训练过程中 Loss的平均值达到了 0.5630， 准确率是82%

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

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

2、CIFAR10 数据集分类：使用 CNN 对 CIFAR10 数据集进行分类

首先，加载并归一化 CIFAR10 使用 torchvision 。

import torch
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np
import torch.nn as nn
import torch.nn.functional as Fimport torch.optim as optim

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

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

注意下面代码中：训练的 shuffle 是 True，测试的 shuffle 是 false# 训练时可以打乱顺序增加多样性，测试是没有必要

trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
                                        download=True, transform=transform)trainloader = torch.utils.data.DataLoader(trainset, batch_size=64,
                                          shuffle=True, num_workers=2)
testset = torchvision.datasets.CIFAR10(root='./data', train=False,
                                       download=True, transform=transform)testloader = torch.utils.data.DataLoader(testset, batch_size=8,
                                         shuffle=False, num_workers=2)
classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

展示CIFAR10中的一些图片：
def imshow(img):
    plt.figure(figsize=(8,8))
    img = img / 2 + 0.5     # 转换到 [0,1] 之间
    npimg = img.numpy()
    plt.imshow(np.transpose(npimg, (1, 2, 0)))
    plt.show()

得到一组图像

images, labels = iter(trainloader).next()

展示图像

imshow(torchvision.utils.make_grid(images))

展示第一行图像的标签

for j in range(8):
print(classes[labels[j]])


下面定义网络、损失函数和优化器：
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')

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

得到一组图像

images, labels = iter(testloader).next()

展示图像

imshow(torchvision.utils.make_grid(images))

展示图像的标签

for j in range(8):
    print(classes[labels[j]])

用CNN进行识别：

outputs = net(images.to(device))
_, predicted = torch.max(outputs, 1)

展示预测的结果

for j in range(8):
    print(classes[predicted[j]])

通过比较发现，有几个识别是错误的
下面展示网络在整个数据集中的表现：

correct = 0
total = 0
for data in testloader:
    images, labels = data
    images, labels = images.to(device), labels.to(device)
    outputs = net(images)
    _, predicted = torch.max(outputs.data, 1)
    total += labels.size(0)
correct += (predicted == labels).sum().item()

print('Accuracy of the network on the 10000 test images: %d %%' % (
100 * correct / total))

得到的结果如下，准确率为62%：

3、使用 VGG16 对 CIFAR10 分类

3.1定义 dataloader

需要注意的是，这里的 transform，dataloader 和之前定义的有所不同，大家自己体会

import torch
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim

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

transform_train = transforms.Compose([
    transforms.RandomCrop(32, padding=4),
    transforms.RandomHorizontalFlip(),
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))])

transform_test = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))])

trainset = torchvision.datasets.CIFAR10(root='./data', train=True,  download=True, transform=transform_train)
testset  = torchvision.datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test)

trainloader = torch.utils.data.DataLoader(trainset, batch_size=128, shuffle=True, num_workers=2)
testloader = torch.utils.data.DataLoader(testset, batch_size=128, shuffle=False, num_workers=2)

classes = ('plane', 'car', 'bird', 'cat',
           'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

3.2VGG 网络定义

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(cfg)
        self.classifier = nn.Linear(2048, 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)
        
        
        
        
初始化网络，根据实际需要，修改分类层。因为 tiny-imagenet 是对200类图像分类，这里把输出修改为200。

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

3.3网络训练

训练的代码和以前是完全一样的：

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')

3.4测试验证准确率

测试的代码和之前也是完全一样的。

correct = 0
total = 0

for data in testloader:
    images, labels = data
    images, labels = images.to(device), labels.to(device)
    outputs = net(images)
    _, predicted = torch.max(outputs.data, 1)
    total += labels.size(0)
    correct += (predicted == labels).sum().item()

print('Accuracy of the network on the 10000 test images: %.2f %%' % (
    100 * correct / total))

三．回答问题

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

答：shuffer=False表示不打乱数据的顺序，然后以batch（批）为单位从头到尾按顺序取用数据。

shuffer=Ture表示在每一次epoch中都打乱所有数据的顺序，然后以batch为单位从头到尾按顺序取用数据。这样的结果就是不同epoch中的数据都是乱序的。

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

答：tranfrom就是变换，改变，所有的变换都是围绕着x轴，y轴，中心点来进行变换的，有旋转、沿着x,y移动、缩放、扭曲等等，所用函数不同，操作不同，数值不同，操作的方向、角度、距离等不同。

3、epoch 和 batch 的区别？

答：Epoch（时期）：当一个完整的数据集通过了神经网络一次并且返回了一次，这个过程称为一次epoch。（也就是说，所有训练样本在神经网络中都进行了一次正向传播和一次反向传播 ），再通俗一点，一个Epoch就是将所有训练样本训练一次的过程。

Batch（批 / 一批样本）：将整个训练样本分成若干个Batch。

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

答：
​ ①1*1卷积可以减少或增加特征图的层数，而FC不可以。

​ ②卷积是作用在一个局部的区域，而全连接是对于整个输入而言。

1*1卷积的作用：降维、加入非线性、跨通道信息交互（channel的变换）

全连接层的作用是，可以将卷积得到的局部特征连接起来，综合考虑整个图像

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

答：在训练网络的过程中，深度越深，参数越复杂，网络也就越复杂，但分类任务具有过程未知性，并且深度的神经网络很难实现恒等映射，导致网络很难学习到更优的参数，引入残差学习后，网络能实现恒等映射了，训练过程中可以根据实际效果跳过其中的几个层，灵活性更大，因此可以提高准确率。

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

答：代码二中的网络使用了三个全连接层，而LeNet使用了两个全连接层；代码二中的网络使用的激活函数为Relu,而LeNet使用的激活函数为Sigmoid；代码二中的池化层为最大池化，而LeNet中使用的是平均池化。

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

答：可以使用padding进行零填充。

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

答：通过视频学习可认为 提升准确率可以有以下几种方法：
（1）改变激活函数；在AlexNet结构中，使用了非线性激活函数ReLU,这一函数可以解决梯度消失的问题，同时大大提升了计算的速度，而它的收敛速度也远快于sigmoid函数，这使得它的准确度有了一定的提升。
（2）改变感受野的大小、步长、滤波器的个数。ZENet结构就是很明显的例子。这样一来可以提取到更加详细的信息，是的准确率能有提升。
（3）层数的增加也会让准确率提高。VGG结构从8layers增加到16~19layers,而ResNet结构更是深度达到了152层，由此可以得出，层数越多，错误率越低，相应的准确性也就更高。