一期4.CV基础
1 CNN 概述¶
卷积神经网络是深度学习在计算机视觉领域的突破性成果. 在计算机视觉领域, 往往我们输入的图像都很大，使用全连接网络的话，计算的代价较高. 另外图像也很难保留原有的特征，导致图像处理的准确率不高.
卷积神经网络（Convolutional Neural Network）是含有卷积层的神经网络. 卷积层的作用就是用来自动学习、提取图像的特征.
CNN网络主要有三部分构成：卷积层、池化层和全连接层构成，其中卷积层负责提取图像中的局部特征；池化层用来大幅降低参数量级(降维)；全连接层类似人工神经网络的部分，用来输出想要的结果。
2 图像基础知识¶
学习目标¶
- 知道像素、通道等概念
- 掌握使用matplotlib加载图片方法
我们在进行图像任务时，需要了解图像的基础知识。图像是由像素点组成的，每个像素点的值范围为: [0, 255], 像素值越大意味着较亮。比如一张 200x200 的图像, 则是由 40000 个像素点组成, 如果每个像素点都是 0 的话, 意味着这是一张全黑的图像.
我们看到的彩色图一般都是多通道的图像, 所谓多通道可以理解为图像由多个不同的图像层叠加而成, 例如我们看到的彩色图像一般都是由 RGB 三个通道组成的，还有一些图像具有 RGBA 四个通道，最后一个通道为透明通道，该值越小，则图像越透明。
1. 像素和通道的理解¶
接下来，我们使用 matplotlib 库来实际理解下上面讲解的图像知识。
示例代码：
import numpy as np
import matplotlib.pyplot as plt
# 1. 图像基本理解
def test01():
img = np.zeros([200, 200])
print(img)
plt.imshow(img, cmap='gray', vmin=0, vmax=255)
plt.show()
img = np.full([255, 255], 255)
print(img)
plt.imshow(img, cmap='gray', vmin=0, vmax=255)
plt.show()
# 2. 图像的通道
def test02():
img = plt.imread('data/彩色图片.png')
# 修改数据的维度
img = np.transpose(img, [2, 0, 1])
# 打印所有通道
for channel in img:
print(channel)
plt.imshow(channel)
plt.show()
# 修改透明度
img[3] = 0.05
img = np.transpose(img, [1, 2, 0])
plt.imshow(img)
plt.show()
if __name__ == '__main__':
test01()
test02()
程序输出结果:
2. 小节¶
在本小节我们了解了图像的像素、通道相关概念。图像是由像素点组成的，像素值的范围 [0, 255] 值越小表示亮度越小，值越大，表名亮度值越大。一个全0的图像就是一副全黑图像。 一个复杂的图像则是由多个通道组合在一起形成的。
3 卷积层¶
学习目标¶
- 掌握卷积计算过程
- 掌握特征图大小计算方法
- 掌握PyTorch卷积层API
在计算机视觉领域, 往往我们输入的图像都很大，使用全连接网络的话，计算的代价较高. 另外图像也很难保留原有的特征，导致图像处理的准确率不高.
卷积神经网络（Convolutional Neural Network）是含有卷积层的神经网络. 卷积层的作用就是用来自动学习、提取图像的特征.
CNN网络主要有三部分构成：卷积层、池化层和全连接层构成，其中卷积层负责提取图像中的局部特征；池化层用来大幅降低参数量级(降维)；全连接层类似人工神经网络的部分，用来输出想要的结果。
接下来，我们开始学习卷积核的计算过程, 即: 卷积核是如何提取特征的.
1. 卷积计算¶
- input 表示输入的图像
- filter 表示卷积核, 也叫做滤波器
- input 经过 filter 的得到输出为最右侧的图像，该图叫做特征图
那么, 它是如何进行计算的呢？卷积运算本质上就是在滤波器和输入数据的局部区域间做点积。
左上角的点计算方法：
按照上面的计算方法可以得到最终的特征图为:
2. Padding¶
通过上面的卷积计算过程，我们发现最终的特征图比原始图像小很多，如果想要保持经过卷积后的图像大小不变, 可以在原图周围添加 padding 来实现.
3. Stride¶
按照步长为1来移动卷积核，计算特征图如下所示：
如果我们把 Stride 增大为2，也是可以提取特征图的，如下图所示：
4. 多通道卷积计算¶
实际中的图像都是多个通道组成的，我们怎么计算卷积呢？
计算方法如下：
- 当输入有多个通道(Channel), 例如 RGB 三个通道, 此时要求卷积核需要拥有相同的通道数数.
- 每个卷积核通道与对应的输入图像的各个通道进行卷积.
- 将每个通道的卷积结果按位相加得到最终的特征图.
如下图所示:
5. 多卷积核卷积计算¶
上面的例子里我们只使用一个卷积核进行特征提取, 实际对图像进行特征提取时, 我们需要使用多个卷积核进行特征提取. 这个多个卷积核可以理解为从不同到的视角、不同的角度对图像特征进行提取.
那么, 当使用多个卷积核时, 应该怎么进行特征提取呢?
6. 特征图大小¶
输出特征图的大小与以下参数息息相关:
- size: 卷积核/过滤器大小，一般会选择为奇数，比如有 11, 33， 55
- Padding: 零填充的方式
- Stride: 步长
那计算方法如下图所示: - 输入图像大小: W x W
- 卷积核大小: F x F
- Stride: S
- Padding: P
- 输出图像大小: N x N
以下图为例: - 图像大小: 5 x 5
- 卷积核大小: 3 x 3
- Stride: 1
- Padding: 1
- (5 - 3 + 2) / 1 + 1 = 5, 即得到的特征图大小为: 5 x 5
7. PyTorch 卷积层 API¶
我们接下来对下面的图片进行特征提取:
test01 函数使用一个多通道卷积核进行特征提取, test02 函数使用 3 个多听到卷积核进行特征提取:
import torch
import torch.nn as nn
import matplotlib.pyplot as plt
# 显示图像
def show(img):
# 输入形状: (Height, Width, Channel)
plt.imshow(img)
plt.axis('off')
plt.show()
# 1. 单个多通道卷积核
def test01():
# 读取图像, 形状: (640, 640, 4)
img = plt.imread('data/彩色图片.png')
show(img)
# 构建卷积层
# 由于 out_channels 为 1, 相当于只有一个4通道卷积核
conv = nn.Conv2d(in_channels=4, out_channels=1, kernel_size=3, stride=1, padding=1)
# 输入形状: (BatchSize, Channel, Height, Width)
# mg形状: torch.Size([4, 640, 640])
img = torch.tensor(img).permute(2, 0, 1)
# img 形状: torch.Size([1, 4, 640, 640])
img = img.unsqueeze(0)
# 输入卷积层, new_img 形状: torch.Size([1, 1, 640, 640])
new_img = conv(img)
# new_img 形状: torch.Size([640, 640, 1])
new_img = new_img.squeeze(0).permute(1, 2, 0)
show(new_img.detach().numpy())
# 2. 多个多通道卷积核
def test02():
# 读取图像, 形状: (640, 640, 4)
img = plt.imread('data/彩色图片.png')
show(img)
# 构建卷积层
# 由于 out_channels 为 3, 相当于只有 3 个4通道卷积核
conv = nn.Conv2d(in_channels=4, out_channels=3, kernel_size=3, stride=1, padding=1)
# 输入形状: (BatchSize, Channel, Height, Width)
# img形状: torch.Size([3, 640, 640])
img = torch.tensor(img).permute(2, 0, 1)
# img 形状: torch.Size([1, 3, 640, 640])
img = img.unsqueeze(0)
# 输入卷积层, new_img 形状: torch.Size([1, 3, 640, 640])
new_img = conv(img)
# new_img 形状: torch.Size([640, 640, 3])
new_img = new_img.squeeze(0).permute(1, 2, 0)
# 打印三个特征图
show(new_img[:, :, 0].unsqueeze(2).detach().numpy())
show(new_img[:, :, 1].unsqueeze(2).detach().numpy())
show(new_img[:, :, 2].unsqueeze(2).detach().numpy())
if __name__ == '__main__':
test01()
test02()
程序输出结果:
8. 小节¶
本小节主要学习卷积层相关知识，卷积层主要用于提取图像特征，避免对复杂图像特征的手动提取，经过实践表明，基于卷积核实现的自动特征提取在很多场景下的效果要好于手动特征提取。
4 池化层¶
学习目标¶
- 掌握池化计算过程
- 掌握PyTorch池化层API
池化层 (Pooling) 降低维度, 缩减模型大小，提高计算速度. 即: 主要对卷积层学习到的特征图进行下采样（SubSampling）处理.
池化层主要有两种:
- 最大池化
- 平均池化
1. 池化层计算¶
最大池化:
- max(0, 1, 3, 4)
- max(1, 2, 4, 5)
- max(3, 4, 6, 7)
- max(4, 5, 7, 8)
平均池化: - mean(0, 1, 3, 4)
- mean(1, 2, 4, 5)
- mean(3, 4, 6, 7)
- mean(4, 5, 7, 8)
2. Stride¶
最大池化:
- max(0, 1, 4, 5)
- max(2, 3, 6, 7)
- max(8, 9, 12, 13)
- max(10, 11, 14, 15)
平均池化: - mean(0, 1, 4, 5)
- mean(2, 3, 6, 7)
- mean(8, 9, 12, 13)
- mean(10, 11, 14, 15)
3. Padding¶
最大池化:
- max(0, 0, 0, 0)
- max(0, 0, 0, 1)
- max(0, 0, 1, 2)
- max(0, 0, 2, 0)
- ... 以此类推
平均池化: - mean(0, 0, 0, 0)
- mean(0, 0, 0, 1)
- mean(0, 0, 1, 2)
- mean(0, 0, 2, 0)
- ... 以此类推
4. 多通道池化计算¶
在处理多通道输入数据时，池化层对每个输入通道分别池化，而不是像卷积层那样将各个通道的输入相加。这意味着池化层的输出和输入的通道数是相等。
5. PyTorch 池化 API 使用¶
import torch
import torch.nn as nn
# 1. API 基本使用
def test01():
inputs = torch.tensor([[0, 1, 2], [3, 4, 5], [6, 7, 8]]).float()
inputs = inputs.unsqueeze(0).unsqueeze(0)
# 1. 最大池化
# 输入形状: (N, C, H, W)
polling = nn.MaxPool2d(kernel_size=2, stride=1, padding=0)
output = polling(inputs)
print(output)
# 2. 平均池化
polling = nn.AvgPool2d(kernel_size=2, stride=1, padding=0)
output = polling(inputs)
print(output)
# 2. stride 步长
def test02():
inputs = torch.tensor([[0, 1, 2, 3], [4, 5, 6, 7], [8, 9, 10, 11], [12, 13, 14, 15]]).float()
inputs = inputs.unsqueeze(0).unsqueeze(0)
# 1. 最大池化
polling = nn.MaxPool2d(kernel_size=2, stride=2, padding=0)
output = polling(inputs)
print(output)
# 2. 平均池化
polling = nn.AvgPool2d(kernel_size=2, stride=2, padding=0)
output = polling(inputs)
print(output)
# 3. padding 填充
def test03():
inputs = torch.tensor([[0, 1, 2], [3, 4, 5], [6, 7, 8]]).float()
inputs = inputs.unsqueeze(0).unsqueeze(0)
# 1. 最大池化
polling = nn.MaxPool2d(kernel_size=2, stride=1, padding=1)
output = polling(inputs)
print(output)
# 2. 平均池化
polling = nn.AvgPool2d(kernel_size=2, stride=1, padding=1)
output = polling(inputs)
print(output)
# 4. 多通道池化
def test04():
inputs = torch.tensor([[[0, 1, 2], [3, 4, 5], [6, 7, 8]],
[[10, 20, 30], [40, 50, 60], [70, 80, 90]],
[[11, 22, 33], [44, 55, 66], [77, 88, 99]]]).float()
inputs = inputs.unsqueeze(0)
# 最大池化
polling = nn.MaxPool2d(kernel_size=2, stride=1, padding=0)
output = polling(inputs)
print(output)
if __name__ == '__main__':
test04()
5. 小节¶
本小节主要学习了池化层的相关知识，池化层主要用于减少数据的维度。其主要分为: 最大池化、平均池化，我们在进行图像分类任务时，可以使用最大池化。
5 案例-图像分类¶
学习目标¶
- 了解CIFAR10数据集
- 掌握分类网络搭建
- 掌握模型构建流程
在本小节，咱们使用前面的学习到的知识来构建一个卷积神经网络, 并训练该网络实现图像分类. 要完成这个案例，咱们需要学习的内容如下:
- 了解 CIFAR10 数据集
- 搭建卷积神经网络
- 编写训练函数
- 编写预测函数
1. CIFAR10 数据集¶
CIFAR-10数据集5万张训练图像、1万张测试图像、10个类别、每个类别有6k个图像，图像大小32×32×3。下图列举了10个类，每一类随机展示了10张图片：
PyTorch 中的 torchvision.datasets 计算机视觉模块封装了 CIFAR10 数据集, 使用方法如下:
from torchvision.datasets import CIFAR10
from torchvision.transforms import Compose
from torchvision.transforms import ToTensor
from torch.utils.data import DataLoader
# 1. 数据集基本信息
def test01():
# 加载数据集
train = CIFAR10(root='data', train=True, transform=Compose([ToTensor()]))
valid = CIFAR10(root='data', train=False, transform=Compose([ToTensor()]))
# 数据集数量
print('训练集数量:', len(train.targets))
print('测试集数量:', len(valid.targets))
# 数据集形状
print("数据集形状:", train[0][0].shape)
# 数据集类别
print("数据集类别:", train.class_to_idx)
# 2. 数据加载器
def test02():
train = CIFAR10(root='data', train=True, transform=Compose([ToTensor()]))
dataloader = DataLoader(train, batch_size=8, shuffle=True)
for x, y in dataloader:
print(x.shape)
print(y)
break
if __name__ == '__main__':
test01()
test02()
程序输出结果:
训练集数量: 50000
测试集数量: 10000
数据集形状: torch.Size([3, 32, 32])
数据集类别: {'airplane': 0, 'automobile': 1, 'bird': 2, 'cat': 3, 'deer': 4, 'dog': 5, 'frog': 6, 'horse': 7, 'ship': 8, 'truck': 9}
torch.Size([8, 3, 32, 32])
tensor([4, 7, 8, 4, 0, 6, 2, 9])
2. 搭建图像分类网络¶
我们要搭建的网络结构如下:
- 输入形状: 32x32
- 第一个卷积层输入 3 个 Channel, 输出 6 个 Channel, Kernel Size 为: 3x3
- 第一个池化层输入 30x30, 输出 15x15, Kernel Size 为: 2x2, Stride 为: 2
- 第二个卷积层输入 6 个 Channel, 输出 16 个 Channel, Kernel Size 为 3x3
- 第二个池化层输入 13x13, 输出 6x6, Kernel Size 为: 2x2, Stride 为: 2
- 第一个全连接层输入 576 维, 输出 120 维
- 第二个全连接层输入 120 维, 输出 84 维
- 最后的输出层输入 84 维, 输出 10 维
我们在每个卷积计算之后应用 relu 激活函数来给网络增加非线性因素。
网络代码实现如下:
class ImageClassification(nn.Module):
def __init__(self):
super(ImageClassification, self).__init__()
self.conv1 = nn.Conv2d(3, 6, stride=1, kernel_size=3)
self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
self.conv2 = nn.Conv2d(6, 16, stride=1, kernel_size=3)
self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
self.linear1 = nn.Linear(576, 120)
self.linear2 = nn.Linear(120, 84)
self.out = nn.Linear(84, 10)
def forward(self, x):
x = F.relu(self.conv1(x))
x = self.pool1(x)
x = F.relu(self.conv2(x))
x = self.pool2(x)
# 由于最后一个批次可能不够 32，所以需要根据批次数量来 flatten
x = x.reshape(x.size(0), -1)
x = F.relu(self.linear1(x))
x = F.relu(self.linear2(x))
return self.out(x)
3. 编写训练函数¶
我们的训练时，使用多分类交叉熵损失函数，Adam 优化器. 具体实现代码如下:
def train():
# 加载 CIFAR10 训练集, 并将其转换为张量
transgform = Compose([ToTensor()])
cifar10 = torchvision.datasets.CIFAR10(root='data', train=True, download=True, transform=transgform)
# 构建图像分类模型
model = ImageClassification()
# 构建损失函数
criterion = nn.CrossEntropyLoss()
# 构建优化方法
optimizer = optim.Adam(model.parameters(), lr=1e-3)
# 训练轮数
epoch = 100
for epoch_idx in range(epoch):
# 构建数据加载器
dataloader = DataLoader(cifar10, batch_size=BATCH_SIZE, shuffle=True)
# 样本数量
sam_num = 0
# 损失总和
total_loss = 0.0
# 开始时间
start = time.time()
correct = 0
for x, y in dataloader:
# 送入模型
output = model(x)
# 计算损失
loss = criterion(output, y)
# 梯度清零
optimizer.zero_grad()
# 反向传播
loss.backward()
# 参数更新
optimizer.step()
correct += (torch.argmax(output, dim=-1) == y).sum()
total_loss += (loss.item() * len(y))
sam_num += len(y)
print('epoch:%2s loss:%.5f acc:%.2f time:%.2fs' %
(epoch_idx + 1,
total_loss / sam_num,
correct / sam_num,
time.time() - start))
# 序列化模型
torch.save(model.state_dict(), 'model/image_classification.bin')
4. 编写预测函数¶
我们加载训练好的模型，对测试集中的 1 万条样本进行预测，查看模型在测试集上的准确率.
def test():
# 加载 CIFAR10 测试集, 并将其转换为张量
transgform = Compose([ToTensor()])
cifar10 = torchvision.datasets.CIFAR10(root='data', train=False, download=True, transform=transgform)
# 构建数据加载器
dataloader = DataLoader(cifar10, batch_size=BATCH_SIZE, shuffle=True)
# 加载模型
model = ImageClassification()
model.load_state_dict(torch.load('model/image_classification.bin'))
model.eval()
total_correct = 0
total_samples = 0
for x, y in dataloader:
output = model(x)
total_correct += (torch.argmax(output, dim=-1) == y).sum()
total_samples += len(y)
print('Acc: %.2f' % (total_correct / total_samples))
程序输出结果：
'Acc: 0.57
5. 小节¶
本小节主要学习如何使用卷积层、池化层来设计、构建一个卷积神经网络。从程序的运行结果来看，网络模型在测试集上的准确率并不高。我们可以从以下几个方面来调整网络:
- 增加卷积核输出通道数
- 增加全连接层的参数量
- 调整学习率
- 调整优化方法
- 修改激活函数
- 等等...
我把学习率由 1e-3 修改为 1e-4, 并网络参数量增加如下代码所示:
class ImageClassification(nn.Module):
def __init__(self):
super(ImageClassification, self).__init__()
self.conv1 = nn.Conv2d(3, 32, stride=1, kernel_size=3)
self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
self.conv2 = nn.Conv2d(32, 128, stride=1, kernel_size=3)
self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
self.linear1 = nn.Linear(128 * 6 * 6, 2048)
self.linear2 = nn.Linear(2048, 2048)
self.out = nn.Linear(2048, 10)
def forward(self, x):
x = F.relu(self.conv1(x))
x = self.pool1(x)
x = F.relu(self.conv2(x))
x = self.pool2(x)
# 由于最后一个批次可能不够 32，所以需要根据批次数量来 flatten
x = x.reshape(x.size(0), -1)
x = F.relu(self.linear1(x))
x = F.dropout(x, p=0.5)
x = F.relu(self.linear2(x))
x = F.dropout(x, p=0.5)
return self.out(x)
经过训练，模型在测试集的准确率由 0.57，提升到了 0.93，同学们也可以自己修改相应的网络结构、训练参数等来提升模型的性能。
浙公网安备 33010602011771号