第二次作业：卷积神经网络 part 1

【第一部分】视频学习心得及问题总结

机器学习三要素

• 模型：对要学习问题映射的假设（问题建模，确定假设空间）

• 策略：从假设空间中学习/选择最优模型的准则（确定目标函数）

• 算法：根据目标函数求解最优模型的具体计算方法（求解模型参数）

概率/函数形式的统一

策略设计

• 训练误差→泛化误差

PAC给出了实际训练学习器的目标：

从合理数量的训练数据中通过合理计算量学习到可靠的知识。

• 无免费午餐定理

当考虑在所有问题上的平均性能时，任意两个模型都是相同的。

即，脱离具体问题，谈“什么学习算法更好”毫无意义。

• 奥卡姆剃刀原理

“如无必要，勿增实体”即“简单有效原理”。

如果多种模型能够同等程度地符合一个问题的观测结果，应该选择其中使用假设最少的，即最简单的模型。

卷积神经网络的基本应用

• 分类
• 检索
• 检测
• 分割

传统神经网络 & 卷积神经网络

• 全连接网络处理图像的问题
  • 参数太多：权重矩阵的参数太多，造成过拟合。
• 卷积神经网络的解决方式
  • 局部关联，参数共享。

CNN基本结构

卷积 Convolutional Layer

• 一维卷积

\(y_t=\sum_{k=1}^{m}{f_k\cdot x_{t-k+1}}\)

• 卷积

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

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

• 卷积的基本概念
  • input：输入
  • kernel/filter：卷积核/滤波器
  • weights：权重
  • receptive field：感受野
  • stride：步长
  • activation map/filter map：特征图
  • padding
  • channel/depth：深度
  • output：输出

池化 Pooling Layer

• Pooling
  • 保留了主要特征的同时减少参数和计算量，防止过拟合，提高模型的泛化能力。
  • 它一般处于卷积层与卷积层之间，全连接层与全连接层之间。
• Pooling的类型
  • Max Pooling：最大值池化
  • Average Pooling：平均池化

全连接 Fully Connected Layer

• 两层之间所有神经元都有权重链接
• 通常全连接层在卷积神经网络尾部
• 全连接层参数量通常最大

卷积神经网络的典型结构

AlexNet

• 模型结构

  • CONV1
  • MAX POOL1
  • NORM1
  • CONV2
  • MAX POOL2
  • NORM2
  • CONV3
  • CONV4
  • CONV5
  • MAX POOL3
  • FC6
  • FC7
  • FC8

• 优点

  • 大数据训练：百万级ImageNet图像数据
  • 非线性激活函数：ReLU
    • 解决了梯度消失的问题
    • 计算速度特别快，只需要判断输入是否大于0
    • 收敛速度远快于sigmoid
  • 防止过拟合
    • Dropout（随机失活）：训练时随机关闭部分神经元，测试时整合所有神经元
    • Data augmentation（数据增强）：平移、翻转、对称、改变RGB通道强度
  • 双GPU实现

ZFNet

网络结构与AlexNet相同，修改了卷积层1的感受野、步长，卷积层3、4、5的滤波器个数。

VGG

加深了层数，分为16层和19层。

GoogleNet

• 包含22个带参数的层（如果考虑pooling层就是27层），独立成块的层总共约有100个
• 参数量大概是AlexNet的1/12
• 没有FC层

ResNet

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

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

深度有152层。

【第二部分】代码练习

2.1 MNIST 数据集分类

1. 加载数据

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

PyTorch里包含了 MNIST， CIFAR10 等常用数据集，调用 torchvision.datasets即可把这些数据由远程下载到本地。

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

在机器学习和深度学习中，通常算法的结果是可以表示向量的数组（即包含两对或以上的方括号形式[[]]），如果直接利用这个数组进行画图可能显示界面为空。可以利用squeeze（）函数将表示向量的数组转换为秩为1的数组，这样利用matplotlib库函数画图时，就可以正常的显示结果了。

2. 创建网络

nn.Linear：

Applies a linear transformation to the incoming data:

\[y=xA^T+b \]

• in_features - 每个输入样本的大小
• out_features - 每个输出样本的大小
• bias - 如果设置为False，则图层不会学习附加偏差。默认值：True

Softmax：

• dim=0：对每一列的所有元素进行softmax运算，并使得每一列所有元素和为1。

• dim=1：对每一行的所有元素进行softmax运算，并使得每一行所有元素和为1。

LogSoftmax

对softmax的结果进行log，即Log(Softmax(x))

model类的forward函数

forward 函数的作用是，指定网络的运行过程。

view一般出现在model类的forward函数中，用于改变输入或输出的形状。

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):
        # 代码指定二维数据的列数为 input_size=784，行数 -1 表示我们不想算，电脑会自己计算对应的数字
        # 在 DataLoader 部分，我们可以看到 batch_size 是64，所以得到 x 的行数是64
        # 大家可以加一行代码：print(x.cpu().numpy().shape)
        # 训练过程中，就会看到 (64, 784) 的输出，和我们的预期是一致的
        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)

            # 把梯度置零，也就是把loss关于weight的导数变成0
            optimizer.zero_grad()
            # 前向传播求出预测的值
            output = model(data)
            # 求loss
            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))
      

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

class torch.optim.SGD(params, lr=, momentum=0, dampening=0, weight_decay=0, nesterov=False)

• params (iterable) – 待优化参数的iterable或者是定义了参数组的dict
• lr (float) – 学习率
• momentum (float, 可选) – 动量因子（默认：0）
• weight_decay (float, 可选) – 权重衰减（L2惩罚）（默认：0）
• dampening (float, 可选) – 动量的抑制因子（默认：0）
• nesterov (bool, 可选) – 使用Nesterov动量（默认：False）

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. 在卷积神经网络上训练

# 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. 打乱像素顺序再次在两个网络上训练与测试

考虑到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')

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

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

全连接网络的性能基本上没有发生变化，但是卷积神经网络的性能明显下降。

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

2.2 CIFAR10 数据集分类

2.2.1 CIFAR10简介

对于视觉数据，PyTorch 创建了一个叫做 totchvision的包，该包含有支持加载类似Imagenet，CIFAR10，MNIST 等公共数据集的数据加载模块 torchvision.datasets 和支持加载图像数据数据转换模块 torch.utils.data.DataLoader。

下面将使用CIFAR10数据集，它包含十个类别：‘airplane’, ‘automobile’, ‘bird’, ‘cat’, ‘deer’, ‘dog’, ‘frog’, ‘horse’, ‘ship’, ‘truck’。CIFAR-10 中的图像尺寸为3x32x32，也就是RGB的3层颜色通道，每层通道内的尺寸为32*32。

#### 2.2.2 下载图片

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

input[channel] = (input[channel] - mean[channel]) / std[channel]

这样就是：(（0,1）-0.5）/0.5=(-1,1)。

对于一般的图片也可以进行类似的处理，计算机更喜欢，并且容易收敛，如果是0-255，在某些操作对图片进行处理，数值也很容易溢出。

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

** numpy.transpose**

用于改变序列。

• 对于二维 ndarray，transpose在不指定参数是默认是矩阵转置

  • x.transpose((0,1)) # 按照原坐标轴改变序列，也就是保持不变
    

  • x.transpose((1,0)) # 交换 ‘0轴’ 和 ‘1轴’
    

• 对于三维ndarray：

  • A.transpose((0,1,2))  #保持A不变
    

  • A.transpose((1,0,2))  #将 0轴 和 1轴 交换
    

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

2.2.3 创建网络

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)

2.2.4 训练网络

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

2.2.5 选一组图片进行测试

从测试集中取出8张图片，输入模型，看看CNN把这些图片识别成什么：

# 得到一组图像
images, labels = iter(testloader).next()
# 展示图像
imshow(torchvision.utils.make_grid(images))
# 展示图像的标签
for j in range(8):
    print(classes[labels[j]])

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

# 展示预测的结果
for j in range(8):
    print(classes[predicted[j]])

有3个识别错误。

2.2.6 网络放到整个数据集上测试

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

最终得到64%的准确率。

2.3使用 VGG16 对 CIFAR10 分类

2.3.1 定义dataloader

此VGG网络的结构较为简单，预先对数据进行增强处理，并设置batch大小为128。

transform_train = transforms.Compose([
    # 数据增强
    # 随机裁剪
    transforms.RandomCrop(32, padding=4),
    # 按照0.5的概率对图片进行水平翻转
    transforms.RandomHorizontalFlip(),
    
    transforms.ToTensor(),
    # CIFAR10
    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')

2.3.2 VGG网络定义

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

NameError: name 'cfg' is not defined
参数cfg改为self.cfg

RuntimeError: mat1 dim 1 must match mat2 dim 0
nn.linear的参数设置与网络结构不匹配不能完成矩阵运算，改为(512, 10)

2.3.3 训练与测试

2.4 使用VGG模型迁移学习进行猫狗大战

2.4.1 数据处理

pytorch_torch.transforms常用参数

• mnist是灰度图，transforms.Normalize((0.1307 ), (0.3081 ))
• cifar10，transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))
• image net，transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225])

normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])

vgg_format = transforms.Compose([
  							# 进行了中心裁剪作为数据增强
                transforms.CenterCrop(224),
                transforms.ToTensor(),
                normalize,
            ])

data_dir = './dogscats'

dsets = {x: datasets.ImageFolder(os.path.join(data_dir, x), vgg_format)
         for x in ['train', 'valid']}

dset_sizes = {x: len(dsets[x]) for x in ['train', 'valid']}
dset_classes = dsets['train'].classes

一个输出图片的函数：

def imshow(inp, title=None):
#   Imshow for Tensor.
    inp = inp.numpy().transpose((1, 2, 0))
    mean = np.array([0.485, 0.456, 0.406])
    std = np.array([0.229, 0.224, 0.225])
    inp = np.clip(std * inp + mean, 0,1)
    plt.imshow(inp)
    if title is not None:
        plt.title(title)
    plt.pause(0.001)  # pause a bit so that plots are updated

2.4.2 创建 VGG Model

在这里，使用了预训练好的VGG模型，先对5张图片进行预测。

model_vgg = models.vgg16(pretrained=True)

with open('./imagenet_class_index.json') as f:
    class_dict = json.load(f)
dic_imagenet = [class_dict[str(i)][1] for i in range(len(class_dict))]

inputs_try , labels_try = inputs_try.to(device), labels_try.to(device)
model_vgg = model_vgg.to(device)

outputs_try = model_vgg(inputs_try)

print(outputs_try)
print(outputs_try.shape)

结果为5行 * 1000列的数据，每一列代表对每一种目标识别的结果。
且有负数，有正数，用softmax函数将VGG网络输出的结果转化为对每一类的预测概率。

m_softm = nn.Softmax(dim=1)
probs = m_softm(outputs_try)
vals_try,pred_try = torch.max(probs,dim=1)

print( 'prob sum: ', torch.sum(probs,1))
print( 'vals_try: ', vals_try)
print( 'pred_try: ', pred_try)

print([dic_imagenet[i] for i in pred_try.data])
imshow(torchvision.utils.make_grid(inputs_try.data.cpu()), 
       title=[dset_classes[x] for x in labels_try.data.cpu()])

2.4.3 冻结前面层的参数

我们的目标是使用预训练好的模型，因此，需要把最后的 nn.Linear 层由1000类，替换为2类。为了在训练中冻结前面层的参数，需要设置 required_grad=False。这样，反向传播训练梯度时，前面层的权重就不会自动更新了。训练中，只会更新最后一层的参数。

model_vgg_new = model_vgg;

for param in model_vgg_new.parameters():
    param.requires_grad = False
model_vgg_new.classifier._modules['6'] = nn.Linear(4096, 2)
model_vgg_new.classifier._modules['7'] = torch.nn.LogSoftmax(dim = 1)

model_vgg_new = model_vgg_new.to(device)

2.4.4 训练并测试全连接层

criterion = nn.NLLLoss()
# 学习率
lr = 0.001

# 随机梯度下降
optimizer_vgg = torch.optim.SGD(model_vgg_new.classifier[6].parameters(),lr = lr)

模型训练：

def train_model(model,dataloader,size,epochs=1,optimizer=None):
    model.train()
    
    for epoch in range(epochs):
        running_loss = 0.0
        running_corrects = 0
        count = 0
        for inputs,classes in dataloader:
            inputs = inputs.to(device)
            classes = classes.to(device)
            outputs = model(inputs)
            loss = criterion(outputs,classes)           
            optimizer = optimizer
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
            _,preds = torch.max(outputs.data,1)
            # statistics
            running_loss += loss.data.item()
            running_corrects += torch.sum(preds == classes.data)
            count += len(inputs)
            print('Training: No. ', count, ' process ... total: ', size)
        epoch_loss = running_loss / size
        epoch_acc = running_corrects.data.item() / size
        print('Loss: {:.4f} Acc: {:.4f}'.format(
                     epoch_loss, epoch_acc))
        
        
# 模型训练
train_model(model_vgg_new,loader_train,size=dset_sizes['train'], epochs=1, 
            optimizer=optimizer_vgg)  

测试：

def test_model(model,dataloader,size):
    model.eval()
    predictions = np.zeros(size)
    all_classes = np.zeros(size)
    all_proba = np.zeros((size,2))
    i = 0
    running_loss = 0.0
    running_corrects = 0
    for inputs,classes in dataloader:
        inputs = inputs.to(device)
        classes = classes.to(device)
        outputs = model(inputs)
        loss = criterion(outputs,classes)           
        _,preds = torch.max(outputs.data,1)
        # statistics
        running_loss += loss.data.item()
        running_corrects += torch.sum(preds == classes.data)
        predictions[i:i+len(classes)] = preds.to('cpu').numpy()
        all_classes[i:i+len(classes)] = classes.to('cpu').numpy()
        all_proba[i:i+len(classes),:] = outputs.data.to('cpu').numpy()
        i += len(classes)
        print('Testing: No. ', i, ' process ... total: ', size)        
    epoch_loss = running_loss / size
    epoch_acc = running_corrects.data.item() / size
    print('Loss: {:.4f} Acc: {:.4f}'.format(
                     epoch_loss, epoch_acc))
    return predictions, all_proba, all_classes
  
predictions, all_proba, all_classes = test_model(model_vgg_new,loader_valid,size=dset_sizes['valid'])