第三次作业
【第一部分】视频学习心得及问题总结
1.卷积神经网络的应用
基本：分类、检索、检测、分割
具体：人脸识别、人脸表情识别、图像生成、图像风格转化、自动驾驶
2.传统神经网络vs卷积神经网络
回顾：深度学习三部曲
step1：搭建神经网络结构
step2：找到一个合适的损失函数
step3：找到一个合适的优化函数，更新参数
全连接网络处理图像的问题：参数太多导致过拟合
卷积神经网络的解决方式：局部关联，参数共享
3.卷积
卷积是对两个实变函数的一种数学操作
图像处理使用二维卷积
input：输入 kernel/filter：卷积核/滤波器 weights：权重 receptive field：感受野
feature map：特征图（计算得到） channel：深度 stride：步长 output：输出
大小不匹配时零填充（padding）
输出的特征图大小
（1）未加padding：(N-F)/stride+1
（2）有padding：(N+padding*2-F)/stride+1
4.池化
减少参数和计算量，一般处于卷积层与卷积层之间，全连接层与全连接层之间
filter（一块区域） 例如：2x2 3x3
（1）最大值池化（倾向于使用） （2）平均值池化
5.全连接
（1）两层之间所有神经元都有权重连接
（2）通常在卷积神经网络尾部
（3）参数量通常最大
6.卷积神经网络典型结构
ReLU函数优点
（1）解决了梯度消失的问题（在正区间）
（2）计算速度特别快，只需要判断输入是否大于0
（3）收敛速度远快于Sigmoid
DropOut（随机失活）：训练时随机关闭神经元，测试时整合所有神经元（防止过拟合）
数据增强：平移、翻转、对称；改变RGB通道强度
（1）AlexNet
第一次卷积：卷积-ReLU-池化
第二次卷积：卷积-ReLU-池化
第三次卷积：卷积-ReLU
第四次卷积：卷积-ReLU
第五次卷积：卷积-ReLU-池化
第六层：全连接-ReLU-DropOut
第七层：全连接-ReLU-DropOut
第八层：全连接-SoftMax
该结构主要参数存在于全连接层
（2）ZFNet
网络结构与AlexNet相同
（3）VGG
VGG是一个更深网络 8 layers（AlexNet）->16-19（VGG）
该结构主要参数存在于全连接层，参数量大概为AlexNet的2倍
（4）GoogleNet
22个带参数的层，参数量大概是AlexNet的1/12，没有FC
Naive Inception初衷：多卷积核增加特征多样性
Inception V2解决思路：插入1*1卷积核降维
Inception V3解决思路：用小的卷积核代替大的卷积核（降低参数量，增加非线性激活 函数）
Stem部分：卷积-池化-卷积-卷积-池化
多个Inception结构堆叠
输出：没有额外的全连接层
（5）ResNet
深度有152层 残差block
残差思想：去掉相同的主体部分，从而突出微小的变化
问题
（1）哪种卷积神经网络结构最好
（2）几种卷积神经网络结构的应用场景是什么
（3）为什么全连接层的参数多
【第二部分】代码练习
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. 加载数据 （MNIST）
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');
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))
3.在小型全连接网络上训练（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.在卷积神经网络上训练
需要注意的是，上在定义的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)
通过上面的测试结果，可以发现，含有相同参数的 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')
重新定义训练与测试函数，我们写了两个函数 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)
在卷积神经网络上训练与测试：
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)
从打乱像素顺序的实验结果来看，全连接网络的性能基本上没有发生变化，但是 卷积神经网络的性能明显下降。
这是因为对于卷积神经网络，会利用像素的局部关系，但是打乱顺序以后，这些像素间的关系将无法得到利用。
CIFAR10 数据集分类
对于视觉数据，PyTorch 创建了一个叫做 totchvision 的包，该包含有支持加载类似Imagenet，CIFAR10，MNIST 等公共数据集的数据加载模块 torchvision.datasets 和支持加载图像数据数据转换模块 torch.utils.data.DataLoader。
首先，加载并归一化 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 F import 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))
准确率还可以，通过改进网络结构，性能还可以进一步提升。
使用 VGG16 对 CIFAR10 分类
1. 定义 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')
2. VGG 网络定义
报错了，错误：（1）cfg应放在函数外部定义 （2）nn.Linear()的参数大小错误，导致图像大小不一致
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')
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))
不难看出，通过使用简化版的VGG网络，可以显著提高准确率。
浙公网安备 33010602011771号