Caffe中实现卷积的计算

女爷i 2022-06-06 02:43 194阅读 0赞

转载自：[https://buptldy.github.io/2016/10/01/2016-10-01-im2col/][https_buptldy.github.io_2016_10_01_2016-10-01-im2col]

# [![61814949.jpg][]][61814949.jpg] #

## CNN中的卷积操作 ##

卷积层是CNNs网络中可以说是最重要的层了，卷积层的主要作用是对输入图像求卷积运算。如下图所示，输入图片的维数为\[c0,h0,w0\] \[c0,h0,w0\] ；卷积核的维数为\[c1,c0,hk,wk\] \[c1,c0,hk,wk\]，其中c0 c0在图中没有表示出来，一个卷积核可以看成由c1 c1个维数为\[c0,hk,wk\] \[c0,hk,wk\]的三维滤波器组成；除了这些参数通常在计算卷积运算的时候还有一些超参数比如：stride（步长）：S S,padding（填充）：P P。

根据上面所说的参数就可以求出输出特征的维数为\[c1,h1,w1\] \[c1,h1,w1\],其中h1=(h0−hk\+2P)/S\+1 h1=(h0−hk+2P)/S+1,w1=(w0−wk\+2P)/S\+1 w1=(w0−wk+2P)/S+1。

[![28468053.jpg][]][28468053.jpg]

卷积的计算过程其实很简单，但不是很容易说清楚，下面通过代码来说明。

基本环境设置:

卷积层计算的代码如下，想象一副图像尺寸为MxM，卷积核mxm。在计算时，卷积核与图像中每个mxm大小的图像块做element-wise相乘，然后得到的结果相加得到一个值，然后再移动一个stride，做同样的运算，直到整副输入图像遍历完，上述过程得到的值就组成了输出特征，具体运算过程还是看代码。

下面来检测下上面的卷积计算代码，我们人为的设置两个卷积核（分别为求灰度特征，和边缘特征），然后对两幅输入图像求卷积，观察输出的结果：

<table style="border-collapse:collapse; border-spacing:0px; margin:0px; width:auto; border:none; font-size:14px; table-layout:fixed"> 
 <tbody> 
 <tr style="background-color:rgb(249,249,249)"> 
 <td style="padding:0px; vertical-align:middle; border:none"> <pre style="overflow:auto; font-family:consolas,Menlo,&quot;PingFang SC&quot;,&quot;Microsoft YaHei&quot;,monospace; font-size:13px; margin-top:0px; margin-bottom:0px; padding:10px; color:rgb(134,145,148); background:rgb(239,242,243); line-height:1.6; border:none; text-align:right">1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
</pre> </td> 
 <td style="padding:0px; vertical-align:middle; border:none"> <pre style="overflow:auto; font-family:consolas,Menlo,&quot;PingFang SC&quot;,&quot;Microsoft YaHei&quot;,monospace; font-size:13px; margin-top:0px; margin-bottom:0px; padding:10px; color:rgb(77,77,76); background:rgb(247,247,247); line-height:1.6; border:none; width:613.6px">from scipy.misc import imread, imresize
kitten, puppy = imread('kitten.jpg'), imread('puppy.jpg')

d = kitten.shape[1] - kitten.shape[0]
kitten_cropped = kitten[:, d/2:-d/2, :]

img_size = 200 # Make this smaller if it runs too slow
x = np.zeros((2, 3, img_size, img_size))
x[0, :, :, :] = imresize(puppy, (img_size, img_size)).transpose((2, 0, 1))
x[1, :, :, :] = imresize(kitten_cropped, (img_size, img_size)).transpose((2, 0, 1))

# Set up a convolutional weights holding 2 filters, each 3x3
w = np.zeros((2, 3, 3, 3))

# The first filter converts the image to grayscale.
# Set up the red, green, and blue channels of the filter.
w[0, 0, :, :] = [[0, 0, 0], [0, 0.3, 0], [0, 0, 0]]
w[0, 1, :, :] = [[0, 0, 0], [0, 0.6, 0], [0, 0, 0]]
w[0, 2, :, :] = [[0, 0, 0], [0, 0.1, 0], [0, 0, 0]]

# Second filter detects horizontal edges in the blue channel.
w[1, 2, :, :] = [[1, 2, 1], [0, 0, 0], [-1, -2, -1]]

# Vector of biases. We don't need any bias for the grayscale
# filter, but for the edge detection filter we want to add 128
# to each output so that nothing is negative.
b = np.array([0, 128])

# Compute the result of convolving each input in x with each filter in w,
# offsetting by b, and storing the results in out.
out, _ = conv_forward_naive(x, w, b, {
 'stride': 1, 'pad': 1})

def imshow_noax(img, normalize=True):
 """ Tiny helper to show images as uint8 and remove axis labels """
 if normalize:
 img_max, img_min = np.max(img), np.min(img)
 img = 255.0 * (img - img_min) / (img_max - img_min)
 plt.imshow(img.astype('uint8'))
 plt.gca().axis('off')

# Show the original images and the results of the conv operation
plt.subplot(2, 3, 1)
imshow_noax(puppy, normalize=False)
plt.title('Original image')
plt.subplot(2, 3, 2)
imshow_noax(out[0, 0])
plt.title('Grayscale')
plt.subplot(2, 3, 3)
imshow_noax(out[0, 1])
plt.title('Edges')
plt.subplot(2, 3, 4)
imshow_noax(kitten_cropped, normalize=False)
plt.subplot(2, 3, 5)
imshow_noax(out[1, 0])
plt.subplot(2, 3, 6)
imshow_noax(out[1, 1])
plt.show()
</pre> </td> 
 </tr> 
 </tbody> 
</table>

图像经过卷积后，输入结果如下所示：

:  
[![81198578.jpg][]][81198578.jpg]

## im2col ##

运行上面代码的时候，我们发现对这两张图片计算卷积还是比较慢的，而在CNN中是存在大量的卷积运算的，所以我们需要一个更加快速的计算卷积的方法。如下图所示为Caffe中计算卷积的示意图，通过上面普通卷积运算的实现我们可以发现，卷积操作实际上是在对输入特征的一定范围内和卷积核滤波器做点乘，如下图我们可以利用这一特性把卷积操作转换成两个大矩阵相乘。

把输入图像要经行卷积操作的这一区域展成列向量的操作通常称为`im2col`，具体过程如下图所示。

[![72204285.jpg][]][72204285.jpg]

下图为一个具体的例子，看懂下面这个图应该就会清楚上面的做法。

[![690672.jpg][]][690672.jpg]

下面的`im2col_cython`是使用Cython代码来实现`im2col`功能，有关Cython在Python中的具体使用可参考：[Python速度优化-Cython中numpy以及多线程的使用][Python_-Cython_numpy]。

调用上面的`im2col_cython`函数来实现卷积操作：

测试使用`im2col`方法的卷积操作，从输出的图片可以看出和原始卷积方法一样。

[![81198578.jpg][]][81198578.jpg]

下面来测试一下使用两种方法的时间，使用原始的卷积操作每次循环需要2.19s，而使用`im2col`方法则只需要28.3ms，时间大概缩短了77倍，当然这其中也包括了使用Cython所降低的时间，但总体上来说还是大大加快了卷积的计算速度。

虽然使用`im2col`方法加快了计算速度，但也会使用更多的内存，因为把输入图像转换为col的时候，会有很多重复的元素。

## 参考 ##

[Convolutional Neural Networks (CNNs / ConvNets)][Convolutional Neural Networks _CNNs _ ConvNets]

[深入理解Caffe源码（卷积实现详细分析][Caffe]

[https_buptldy.github.io_2016_10_01_2016-10-01-im2col]: https://buptldy.github.io/2016/10/01/2016-10-01-im2col/
[61814949.jpg]: http://7xritj.com1.z0.glb.clouddn.com/16-10-1/61814949.jpg
[28468053.jpg]: http://7xritj.com1.z0.glb.clouddn.com/16-10-1/28468053.jpg
[81198578.jpg]: http://7xritj.com1.z0.glb.clouddn.com/16-10-1/81198578.jpg
[72204285.jpg]: http://7xritj.com1.z0.glb.clouddn.com/16-10-1/72204285.jpg
[690672.jpg]: http://7xritj.com1.z0.glb.clouddn.com/16-10-1/690672.jpg
[Python_-Cython_numpy]: http://buptldy.github.io/2016/06/15/2016-06-15-Python%E9%80%9F%E5%BA%A6%E4%BC%98%E5%8C%96-Cython%E4%B8%ADnumpy%E4%BB%A5%E5%8F%8A%E5%A4%9A%E7%BA%BF%E7%A8%8B%E7%9A%84%E4%BD%BF%E7%94%A8/
[Convolutional Neural Networks _CNNs _ ConvNets]: http://cs231n.github.io/convolutional-networks/
[Caffe]: http://www.colinyan.com/%E6%B7%B1%E5%85%A5%E7%90%86%E8%A7%A3caffe%E6%BA%90%E7%A0%81%EF%BC%88%E5%8D%B7%E7%A7%AF%E5%AE%9E%E7%8E%B0%E8%AF%A6%E7%BB%86%E5%88%86%E6%9E%90%EF%BC%89/