卷积神经网络（Convolutional Neural Network，CNN）
受生物学上感受野机制的启发而提出。
一般是由卷积层、汇聚层和全连接层交叉堆叠而成的前馈神经网络
有三个结构上的特性：局部连接、权重共享、汇聚。
具有一定程度上的平移、缩放和旋转不变性。
和前馈神经网络相比，卷积神经网络的参数更少。
主要应用在图像和视频分析的任务上，其准确率一般也远远超出了其他的神经网络模型。
近年来卷积神经网络也广泛地应用到自然语言处理、推荐系统等领域。
5.1 卷积
考虑到使用全连接前馈网络来处理图像时，会出现如下问题：
1.模型参数过多，容易发生过拟合。 在全连接前馈网络中，隐藏层的每个神经元都要跟该层所有输入的神经元相连接。随着隐藏层神经元数量的增多，参数的规模也会急剧增加，导致整个神经网络的训练效率非常低，也很容易发生过拟合。
2.难以提取图像中的局部不变性特征。 自然图像中的物体都具有局部不变性特征，比如尺度缩放、平移、旋转等操作不影响其语义信息。而全连接前馈网络很难提取这些局部不变性特征。
卷积神经网络有三个结构上的特性：局部连接、权重共享和汇聚。这些特性使得卷积神经网络具有一定程度上的平移、缩放和旋转不变性。和前馈神经网络相比，卷积神经网络的参数也更少。因此，通常会使用卷积神经网络来处理图像信息。
卷积是分析数学中的一种重要运算，常用于信号处理或图像处理任务。本节以二维卷积为例来进行实践。
5.1.1 二维卷积运算
在机器学习和图像处理领域，卷积的主要功能是在一个图像（或特征图）上滑动一个卷积核，通过卷积操作得到一组新的特征。在计算卷积的过程中，需要进行卷积核的翻转，而这也会带来一些不必要的操作和开销。因此，在具体实现上，一般会以数学中的互相关（Cross-Correlatio）运算来代替卷积。
在神经网络中，卷积运算的主要作用是抽取特征，卷积核是否进行翻转并不会影响其特征抽取的能力。特别是当卷积核是可学习的参数时，卷积和互相关在能力上是等价的。因此，很多时候，为方便起见，会直接用互相关来代替卷积。
5.1.2 二维卷积算子
在本书后面的实现中，算子都继承torch.nn.Module，并使用支持反向传播的飞桨API进行实现，这样我们就可以不用手工写backword()的代码实现。
【使用pytorch实现自定义二维卷积算子】
import torch#导入包
class Conv2D(torch.nn.Module):#继承torch.nn.Module下的二维卷积算子
def __init__(self, kernel_size, weight_attr=torch.tensor([[0., 1.],[2., 3.]])):#类初始化，初始化权重属性为默认值
super(Conv2D, self).__init__()#继承torch.nn.Module中的Conv2D卷积算子
self.weight = torch.nn.Parameter(weight_attr)
#torch.nn.Parameter将一个不可训练的类型为Tensor的参数转化为可训练的类型为parameter的参数，并将这个参数绑定到module里面，成为module中可训练的参数。
self.weight.reshape([kernel_size,kernel_size])#将卷积核大小改为kernel_size*kernel_size
def forward(self, X):#定义前向传播
"""
输入：
- X：输入矩阵，shape=[B, M, N]，B为样本数量
输出：
- output：输出矩阵
"""
u, v = self.weight.shape#得到输入形状大小
output = torch.zeros([X.shape[0], X.shape[1] - u + 1, X.shape[2] - v + 1])#初始化输出矩阵
for i in range(output.shape[1]):
for j in range(output.shape[2]):
output[:, i, j] = torch.sum(X[:, i:i+u, j:j+v]*self.weight, axis=[1,2])#进行卷积
return output
# 随机构造一个二维输入矩阵
torch.manual_seed(100)#定义随机种子
inputs = torch.tensor([[[1.,2.,3.],[4.,5.,6.],[7.,8.,9.]]])#初始化输入
kernel = torch.tensor([[0.,1.],[2.,3.]])#初始化kernel即weight_attr
conv2d = Conv2D(kernel_size=2)#传入kernel_size参数
outputs = conv2d(inputs)#测试二维卷积算子
print("input:\n {}, \nuse kernel:\n {}\noutput:\n {}".format(inputs,kernel, outputs))#输出结果。
实验结果：
input:
tensor([[[1., 2., 3.],
[4., 5., 6.],
[7., 8., 9.]]]),
use kernel:
tensor([[0., 1.],
[2., 3.]])
output:
tensor([[[25., 31.],
[43., 49.]]], grad_fn=<CopySlices>)
5.1.3 二维卷积的参数量和计算量
参数量
由于二维卷积的运算方式为在一个图像（或特征图）上滑动一个卷积核，通过卷积操作得到一组新的特征。所以参数量仅仅与卷积核的尺寸有关，对于一个输入矩阵X∈RM×N和一个滤波器W∈RU×V，卷积核的参数量为U×V。
假设有一幅大小为32×32的图像，如果使用全连接前馈网络进行处理，即便第一个隐藏层神经元个数为1，此时该层的参数量也高达1025个。
随着隐藏层神经元数量的变多以及层数的加深，
使用全连接前馈网络处理图像数据时，参数量会急剧增加。
如果使用卷积进行图像处理，相较于全连接前馈网络，参数量少了非常多。
计算量
在卷积神经网络中运算时，通常会统计网络总的乘加运算次数作为计算量（FLOPs，floating point of operations），来衡量整个网络的运算速度。对于单个二维卷积，计算量的统计方式为：
其中M′×N′表示输出特征图的尺寸，即输出特征图上每个点都要与卷积核W∈RU×V进行U×V次乘加运算。对于一幅大小为32×32的图像，使用3×3的卷积核进行运算可以得到以下的输出特征图尺寸：
此时，计算量为：
5.1.4 感受野
输出特征图上每个点的数值，是由输入图片上大小为U×V的区域的元素与卷积核每个元素相乘再相加得到的，所以输入图像上U×V区域内每个元素数值的改变，都会影响输出点的像素值。我们将这个区域叫做输出特征图上对应点的感受野。感受野内每个元素数值的变动，都会影响输出点的数值变化。比如3×3卷积对应的感受野大小就是3×3，如图 所示。
而当通过两层3×3的卷积之后，感受野的大小将会增加到5×5，如图所示。
因此，当增加卷积网络深度的同时，感受野将会增大，输出特征图中的一个像素点将会包含更多的图像语义信息。
5.1.5 卷积的变种
在卷积的标准定义基础上，还可以引入卷积核的滑动步长和零填充来增加卷积的多样性，从而更灵活地进行特征抽取。
5.1.5.1 步长（Stride）
在卷积运算的过程中，有时会希望跳过一些位置来降低计算的开销，也可以把这一过程看作是对标准卷积运算输出的下采样。
在计算卷积时，可以在所有维度上每间隔S个元素计算一次，S称为卷积运算的步长（Stride），也就是卷积核在滑动时的间隔。
在二维卷积运算中，当步长S=2时，计算过程如图所示。
5.1.5.2 零填充（Zero Padding）
在卷积运算中，还可以对输入用零进行填充使得其尺寸变大。根据卷积的定义，如果不进行填充，当卷积核尺寸大于1时，输出特征会缩减。对输入进行零填充则可以对卷积核的宽度和输出的大小进行独立的控制。
在二维卷积运算中，零填充（Zero Padding）是指在输入矩阵周围对称地补上P个0。
一般常用的卷积有以下三类：
1.窄卷积：步长S=1，两端不补零P=0，卷积后输出尺寸为：
2.宽卷积：步长S=1，两端补零P=U−1=V−1，卷积后输出尺寸为：
3.等宽卷积：步长S=1，两端补零P=(U−1)2=(V−1)2，卷积后输出尺寸为：
通常情况下，在层数较深的卷积神经网络，比如：VGG、ResNet中，会使用等宽卷积保证输出特征图的大小不会随着层数的变深而快速缩减。例如：当卷积核的大小为3×3时，会将步长设置为S=1，两端补零P=1，此时，卷积后的输出尺寸就可以保持不变。在本章后续的案例中，会使用ResNet进行实验。
5.1.6 带步长和零填充的二维卷积算子
引入步长和零填充后，二维卷积算子代码实现如下：
class Conv2D(nn.Module):
def __init__(self, kernel_size, stride=1, padding=0, weight_attr=False):
super(Conv2D, self).__init__()
if type(weight_attr) == bool:
weight_attr = torch.ones(size=(kernel_size, kernel_size))
self.weight = torch.nn.Parameter(weight_attr)
# 步长
self.stride = stride
# 零填充
self.padding = padding
def forward(self, X):
# 零填充
new_X = torch.zeros([X.shape[0], X.shape[1] + 2 * self.padding, X.shape[2] + 2 * self.padding])
new_X[:, self.padding:X.shape[1] + self.padding, self.padding:X.shape[2] + self.padding] = X
u, v = self.weight.shape
output_w = (new_X.shape[1] - u) // self.stride + 1
output_h = (new_X.shape[2] - v) // self.stride + 1
output = torch.zeros([X.shape[0], output_w, output_h])
for i in range(0, output.shape[1]):
for j in range(0, output.shape[2]):
output[:, i, j] = torch.sum(
new_X[:, self.stride * i:self.stride * i + u, self.stride * j:self.stride * j + v] * self.weight,
dim=[1, 2])
return output
inputs = torch.randn(size=[2, 8, 8])
conv2d_padding = Conv2D(kernel_size=3, padding=1, weight_attr=torch.zeros((3, 3)))
outputs = conv2d_padding(inputs)
print(
"When kernel_size=3, padding=1 stride=1, input's shape: {}, output's shape: {}".format(inputs.shape, outputs.shape))
conv2d_stride = Conv2D(kernel_size=3, stride=2, padding=1)
outputs = conv2d_stride(inputs)
print(
"When kernel_size=3, padding=1 stride=2, input's shape: {}, output's shape: {}".format(inputs.shape, outputs.shape))
实验结果：
When kernel_size=3, padding=1 stride=1, input's shape: torch.Size([2, 8, 8]), output's shape: torch.Size([2, 8, 8])
When kernel_size=3, padding=1 stride=2, input's shape: torch.Size([2, 8, 8]), output's shape: torch.Size([2, 4, 4])
从输出结果看出，使用3×3大小卷积，padding为1，当stride=1时，模型的输出特征图与输入特征图保持一致；当stride=2时，模型的输出特征图的宽和高都缩小一倍。
5.1.7 使用卷积运算完成图像边缘检测任务
【使用pytorch实现图像边缘检测】
在图像处理任务中，常用拉普拉斯算子对物体边缘进行提取，拉普拉斯算子为一个大小为3×3的卷积核，中心元素值是8，其余元素值是−1。
下面我们利用上面定义的Conv2D算子，构造一个简单的拉普拉斯算子，并对一张输入的灰度图片进行边缘检测，提取出目标的外形轮廓。
import matplotlib.pyplot as plt
from PIL import Image
# 读取图片
img = Image.open(r'C:\Users\86181\Desktop\1.png').convert('L')
img = np.array(img, dtype='float32')
im = torch.from_numpy(img.reshape((img.shape[0], img.shape[1])))
# 创建卷积算子，卷积核大小为3x3，并使用上面的设置好的数值作为卷积核权重的初始化参数
conv = Conv2D(kernel_size=3, stride=1, padding=0)
# 将读入的图片转化为float32类型的numpy.ndarray
inputs = np.array(im).astype('float32')
print("bf as_tensor, inputs:", inputs)
# 将图片转为Tensor
inputs = torch.as_tensor(inputs)
print("bf unsqueeze, inputs:", inputs)
inputs = torch.unsqueeze(inputs, axis=0)
print("af unsqueeze, inputs:", inputs)
outputs = conv(inputs)
print(outputs)
# outputs = outputs.data.squeeze().numpy()
# # 可视化结果
plt.subplot(121).set_title('input image', fontsize=15)
plt.imshow(img.astype('uint8'), cmap='gray')
plt.subplot(122).set_title('output feature map', fontsize=15)
plt.imshow(outputs.squeeze().detach().numpy(), cmap='gray')
plt.savefig('conv-vis.pdf')
plt.show()
实验结果：
bf as_tensor, inputs: [[255. 255. 255. ... 255. 255. 255.]
[ 0. 0. 0. ... 0. 0. 0.]
[ 0. 0. 0. ... 0. 0. 0.]
...
[ 0. 0. 0. ... 0. 0. 0.]
[ 0. 0. 0. ... 0. 0. 0.]
[ 0. 0. 0. ... 0. 0. 0.]]
bf unsqueeze, inputs: tensor([[255., 255., 255., ..., 255., 255., 255.],
[ 0., 0., 0., ..., 0., 0., 0.],
[ 0., 0., 0., ..., 0., 0., 0.],
...,
[ 0., 0., 0., ..., 0., 0., 0.],
[ 0., 0., 0., ..., 0., 0., 0.],
[ 0., 0., 0., ..., 0., 0., 0.]])
af unsqueeze, inputs: tensor([[[255., 255., 255., ..., 255., 255., 255.],
[ 0., 0., 0., ..., 0., 0., 0.],
[ 0., 0., 0., ..., 0., 0., 0.],
...,
[ 0., 0., 0., ..., 0., 0., 0.],
[ 0., 0., 0., ..., 0., 0., 0.],
[ 0., 0., 0., ..., 0., 0., 0.]]])
tensor([[[-765., -765., -765., ..., -765., -765., -765.],
[ 0., 0., 0., ..., 0., 0., 0.],
[ 0., 0., 0., ..., 0., 0., 0.],
...,
[ 0., 0., 0., ..., 0., 0., 0.],
[ 0., 0., 0., ..., 0., 0., 0.],
[ 0., 0., 0., ..., 0., 0., 0.]]],
grad_fn=<CopySlices>)
从输出结果看，使用拉普拉斯算子，目标的边缘可以成功被检测出来。
选做题
实现一些传统边缘检测算子，如：Roberts、Prewitt、Sobel、Scharr、Kirsch、Robinson、Laplacian
import cv2
import numpy as np
# 加载图像
image = cv2.imread(r'C:\Users\86181\Desktop\1.png', 0)
image = cv2.resize(image, (800, 800))
# 自定义卷积核
# Roberts边缘算子
kernel_Roberts_x = np.array([
[1, 0],
[0, -1]
])
kernel_Roberts_y = np.array([
[0, -1],
[1, 0]
])
# Sobel边缘算子
kernel_Sobel_x = np.array([
[-1, 0, 1],
[-2, 0, 2],
[-1, 0, 1]])
kernel_Sobel_y = np.array([
[1, 2, 1],
[0, 0, 0],
[-1, -2, -1]])
# Prewitt边缘算子
kernel_Prewitt_x = np.array([
[-1, 0, 1],
[-1, 0, 1],
[-1, 0, 1]])
kernel_Prewitt_y = np.array([
[1, 1, 1],
[0, 0, 0],
[-1, -1, -1]])
# Kirsch 边缘检测算子
def kirsch(image):
m, n = image.shape
list = []
kirsch = np.zeros((m, n))
for i in range(2, m - 1):
for j in range(2, n - 1):
d1 = np.square(5 * image[i - 1, j - 1] + 5 * image[i - 1, j] + 5 * image[i - 1, j + 1] -
3 * image[i, j - 1] - 3 * image[i, j + 1] - 3 * image[i + 1, j - 1] -
3 * image[i + 1, j] - 3 * image[i + 1, j + 1])
d2 = np.square((-3) * image[i - 1, j - 1] + 5 * image[i - 1, j] + 5 * image[i - 1, j + 1] -
3 * image[i, j - 1] + 5 * image[i, j + 1] - 3 * image[i + 1, j - 1] -
3 * image[i + 1, j] - 3 * image[i + 1, j + 1])
d3 = np.square((-3) * image[i - 1, j - 1] - 3 * image[i - 1, j] + 5 * image[i - 1, j + 1] -
3 * image[i, j - 1] + 5 * image[i, j + 1] - 3 * image[i + 1, j - 1] -
3 * image[i + 1, j] + 5 * image[i + 1, j + 1])
d4 = np.square((-3) * image[i - 1, j - 1] - 3 * image[i - 1, j] - 3 * image[i - 1, j + 1] -
3 * image[i, j - 1] + 5 * image[i, j + 1] - 3 * image[i + 1, j - 1] +
5 * image[i + 1, j] + 5 * image[i + 1, j + 1])
d5 = np.square((-3) * image[i - 1, j - 1] - 3 * image[i - 1, j] - 3 * image[i - 1, j + 1] - 3
* image[i, j - 1] - 3 * image[i, j + 1] + 5 * image[i + 1, j - 1] +
5 * image[i + 1, j] + 5 * image[i + 1, j + 1])
d6 = np.square((-3) * image[i - 1, j - 1] - 3 * image[i - 1, j] - 3 * image[i - 1, j + 1] +
5 * image[i, j - 1] - 3 * image[i, j + 1] + 5 * image[i + 1, j - 1] +
5 * image[i + 1, j] - 3 * image[i + 1, j + 1])
d7 = np.square(5 * image[i - 1, j - 1] - 3 * image[i - 1, j] - 3 * image[i - 1, j + 1] +
5 * image[i, j - 1] - 3 * image[i, j + 1] + 5 * image[i + 1, j - 1] -
3 * image[i + 1, j] - 3 * image[i + 1, j + 1])
d8 = np.square(5 * image[i - 1, j - 1] + 5 * image[i - 1, j] - 3 * image[i - 1, j + 1] +
5 * image[i, j - 1] - 3 * image[i, j + 1] - 3 * image[i + 1, j - 1] -
3 * image[i + 1, j] - 3 * image[i + 1, j + 1])
# 第一种方法：取各个方向的最大值，效果并不好，采用另一种方法
list = [d1, d2, d3, d4, d5, d6, d7, d8]
kirsch[i, j] = int(np.sqrt(max(list)))
for i in range(m):
for j in range(n):
if kirsch[i, j] > 127:
kirsch[i, j] = 255
else:
kirsch[i, j] = 0
return kirsch
# 拉普拉斯卷积核
kernel_Laplacian_1 = np.array([
[0, 1, 0],
[1, -4, 1],
[0, 1, 0]])
kernel_Laplacian_2 = np.array([
[1, 1, 1],
[1, -8, 1],
[1, 1, 1]])
# 下面两个卷积核不具有旋转不变性
kernel_Laplacian_3 = np.array([
[2, -1, 2],
[-1, -4, -1],
[2, 1, 2]])
kernel_Laplacian_4 = np.array([
[-1, 2, -1],
[2, -4, 2],
[-1, 2, -1]])
# 5*5 LoG卷积模板
kernel_LoG = np.array([
[0, 0, -1, 0, 0],
[0, -1, -2, -1, 0],
[-1, -2, 16, -2, -1],
[0, -1, -2, -1, 0],
[0, 0, -1, 0, 0]])
# 卷积
output_1 = cv2.filter2D(image, -1, kernel_Prewitt_x)
output_2 = cv2.filter2D(image, -1, kernel_Sobel_x)
output_3 = cv2.filter2D(image, -1, kernel_Prewitt_x)
output_4 = cv2.filter2D(image, -1, kernel_Laplacian_1)
output_5 = kirsch(image)
# 显示锐化效果
image = cv2.resize(image, (800, 600))
output_1 = cv2.resize(output_1, (800, 600))
output_2 = cv2.resize(output_2, (800, 600))
output_3 = cv2.resize(output_3, (800, 600))
output_4 = cv2.resize(output_4, (800, 600))
output_5 = cv2.resize(output_5, (800, 600))
cv2.imshow('Original Image', image)
cv2.imshow('Prewitt Image', output_1)
cv2.imshow('Sobel Image', output_2)
cv2.imshow('Prewitt Image', output_3)
cv2.imshow('Laplacian Image', output_4)
cv2.imshow('kirsch Image', output_5)
# 停顿
if cv2.waitKey(0) & 0xFF == 27:
cv2.destroyAllWindows()
实验结果：
观察可知，kirsch边缘检测算子对本幅图检测出轮廓太复杂，Laplacian边缘检测算子对本幅图检测出轮廓太简单，Prewitt和Sobel边缘检测算子对本幅图检测结果较好。
实现的简易的 Canny 边缘检测算法
import cv2
# 加载图像
image = cv2.imread(r'C:\Users\86181\Desktop\1.png',0)
image = cv2.resize(image,(800,800))
def Canny(image,k,t1,t2):
img = cv2.GaussianBlur(image, (k, k), 0)
canny = cv2.Canny(img, t1, t2)
return canny
image = cv2.resize(image, (800, 600))
cv2.imshow('Original Image', image)
output =cv2.resize(Canny(image,3,50,150),(800,600))
cv2.imshow('Canny Image', output)
# 停顿
if cv2.waitKey(0) & 0xFF == 27:
cv2.destroyAllWindows()
实验结果：
可见，Canny算子是上述中效果最好的算子。
**实验总结：**这次开始学习卷积，了解到了边缘检测的基本步骤，学到了边缘检测的一些算子，Canny边缘检测方法等，通过paddle转torch,完成实例化，同时也了解了一些传统边缘检测算子。
124
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
