DL之CNN优化技术：卷积神经网络算法简介之特有的优化技术及其代码实现——im2col技术等技术

DL之CNN优化技术：卷积神经网络算法简介之特有的优化技术及其代码实现——im2col技术等技术

im2col技术

im2col简介

1、im2col 的示意图

2、将滤波器的应用区域从头开始依次横向展开为1列

3、卷积运算的滤波器处理的细节：将滤波器纵向展开为1 列，并计算和im2col展开的数据的矩阵乘积，最后转换（reshape）为输出数据的大小

4、对输入数据展开池化的应用区域（2×2 的池化的例子）
池化的应用区域按通道单独展开

im2col代码实现

1、im2col技术应用在卷积层、池化层内

#CNN中各层间传递的数据是4维数据

x = np.random.rand(10, 1, 28, 28) #随机生成数据，对应10个高为28、长为28、通道为1的数据
print(x.shape)
print(x[0].shape)   #访问第1个数据
print(x[0,0] )      #或者x[0][0],访问第1个数据的第1个通道的空间数据，即(1, 28, 28)

#将这个im2col函数作为黑盒(不关心内部实现)使用：是一个10行左右的简单函数，im2col这一便捷函数具有以下接口。

x1 = np.random.rand(1, 3, 7, 7)           # 批大小为1、通道为3的7*7的数据
col1 = im2col(x1, 5, 5, stride=1, pad=0)  # im2col会考虑滤波器大小、步幅、填充，将输入数据展开为2维数组。第2维的元素个数均为75。这是滤波器(通道为3、大小为5*5)的元素个数的总和。
print(col1.shape)                         # 批大小为1时，im2col的结果是(9, 75)

x2 = np.random.rand(10, 3, 7, 7)          # 10个数据
col2 = im2col(x2, 5, 5, stride=1, pad=0)
print(col2.shape)                         # 批大小为10，所以保存了10倍的数据，即(90, 75)。

def im2col(input_data, filter_h, filter_w, stride=1, pad=0):
    """
    Parameters
    ----------
    input_data : 由(数据量, 通道, 高, 长)的4维数组构成的输入数据
    filter_h : 滤波器的高
    filter_w : 滤波器的长
    stride : 步幅
    pad : 填充

    Returns
    -------
    col : 2维数组
    """
    N, C, H, W = input_data.shape
    out_h = (H + 2*pad - filter_h)//stride + 1
    out_w = (W + 2*pad - filter_w)//stride + 1

    img = np.pad(input_data, [(0,0), (0,0), (pad, pad), (pad, pad)], 'constant')
    col = np.zeros((N, C, filter_h, filter_w, out_h, out_w))

    for y in range(filter_h):
        y_max = y + stride*out_h
        for x in range(filter_w):
            x_max = x + stride*out_w
            col[:, :, y, x, :, :] = img[:, :, y:y_max:stride, x:x_max:stride]

    col = col.transpose(0, 4, 5, 1, 2, 3).reshape(N*out_h*out_w, -1)
    return col

#卷积层的实现：使用im2col来实现卷积层，通过使用im2col进行展开，基本上可以像实现全连接层的Affine层一样来实现
#(1)、但需要注意，在进行卷积层的反向传播时，必须进行im2col的逆处理，调用col2im函数
class Convolution:
    def __init__(self, W, b, stride=1, pad=0): #卷积层的初始化方法将滤波器(权重)、偏置、步幅、填充作为参数接收。
        self.W = W
        self.b = b
        self.stride = stride
        self.pad = pad

    #forward方法：卷积层的反向传播的实现，思路和Affine层类似。
    def forward(self, x):
        FN, C, FH, FW = self.W.shape  #滤波器是4维形状(FN, C, FH, FW)，即FilterNumber(滤波器数量)、Channel、FilterHeight、FilterWidth的缩写。
        N, C, H, W = x.shape
        out_h = int(1 + (H + 2*self.pad - FH) / self.stride)
        out_w = int(1 + (W + 2*self.pad - FW) / self.stride)
        col = im2col(x, FH, FW, self.stride, self.pad)     #用im2col展开输入数据
        col_W = self.W.reshape(FN, -1).T                   #滤波器的展开，用reshape将滤波器展开为2维数组，将各个滤波器的方块纵向展开为1列
                #比如，(10, 3, 5, 5)形状的数组的元素个数共有750个，指定reshape(10,-1)后，就会转换成(10, 75)形状的数组。
        out = np.dot(col, col_W) + self.b                  #计算展开后的矩阵的乘积。
        out = out.reshape(N, out_h, out_w, -1).transpose(0, 3, 1, 2)
              #transpose方法：将输出大小转换为合适的形状。基于NumPy的transpose会更改多维数组的轴的顺序，它通过指定索引(编号)，更改轴的顺序。
              #比如：(N,H,W,C)对应索引(0,1,2,3) → (N,C,H,W)对应索引(0,3,1,2)
        return out

#池化层的实现
#(1)、池化层的实现和卷积层相同，都使用im2col展开输入数据。不过，池化的情况下，在通道方向上是独立的，这一点和卷积层不同，池化的应用区域按通道单独展开。
class Pooling:
    def __init__(self, pool_h, pool_w, stride=1, pad=0):
        self.pool_h = pool_h
        self.pool_w = pool_w
        self.stride = stride
        self.pad = pad

    def forward(self, x):
        #池化层的forward方法：展开之后，只需对展开的矩阵求各行的最大值，并转换为合适的形状即可。通过将输入数据展开为容易进行池化的形状，后面的实现就会变得非常简单。
        #思路：展开输入数据 → 求各行的最大值 → 转换为合适的输出大小。池化层的backward方法可参考ReLU层的实现中使用的max的反向传播

        N, C, H, W = x.shape
        out_h = int(1 + (H - self.pool_h) / self.stride)
        out_w = int(1 + (W - self.pool_w) / self.stride)
        # 展开(1)
        col = im2col(x, self.pool_h, self.pool_w, self.stride, self.pad)
        col = col.reshape(-1, self.pool_h*self.pool_w)
        # 最大值(2)
        out = np.max(col, axis=1)  #np.max(x, axis=1)，就可以在输入x的第1 维的各个轴方向上求最大值。
        # 转换(3)
        out = out.reshape(N, out_h, out_w, C).transpose(0, 3, 1, 2)
        return out
赞 (0)

相关推荐