03-手动实现卷积

卷积基本概念和操作

        卷积是一种基本的信号处理操作，在深度学习中被广泛应用于图像处理，语音识别和自然语言处理等任务。卷积操作是通过滑动一个或多个卷积核（也称为滤波器）在输入数据上进行的。在二维卷积中，卷积核是一个小矩阵，通常是3x3或5x5大小，它用于从输入图像中提取不同特征（边缘、角落等）。卷积操作涉及两个重要的概念：输入和输出特征图。具体而言，卷积操作的实现包括以下步骤：

1. 定义卷积核：卷积核是一组权重矩阵（或过滤器），它们将在输入信号上滑动以产生输出。

2. 滑动卷积核：卷积核在输入特征图上滑动，对输入数据的每个位置进行元素乘法操作并求和，得到一个输出标量值。

3. 重复步骤2：重复步骤2，对于所有输入位置，在输出特征图上构建一个新的值。
    

   

4. 投影到输出特征图：将结果值填充到输出特征图的相应位置上，输出特征图形状由输出通道数、步幅和填充方式决定。

卷积操作可以提取图像、音频、文本等数据中的特征，进而用于分类、分割、检测等任务。

思路

具体细节：

对应python代码：

​
import numpy
import cv2
import numpy as np


class Conv(object):
    def __init__(self, input_data, kernel_weight, stride, padding):
        self.input_data = np.asarray(input_data, np.float32)
        self.kernel_weight = np.asarray(kernel_weight, np.float32)
        self.stride = stride
        self.padding = padding

    def my_conv(self):
        # 获取维度信息
        C, H, W = self.input_data.shape
        KC, HC, WC = self.kernel_weight.shape
        # 默认图像通道与卷积核通道数相同
        assert C == KC
        # 初始化卷积后的输出尺寸
        H_out = int(((H + 2 * self.padding - HC) / self.stride) + 1)
        W_out = int(((W + 2 * self.padding - WC) / self.stride) + 1)
        feature_result = np.zeros((H_out, W_out))

        # 若padding!= 0,对原数据进行填充
        if self.padding != 0:
            C, H, W = self.input_data.shape
            data = np.zeros((C, 2 * self.padding + H, 2 * self.padding + W))
            data[:, self.padding:self.padding + H, self.padding:self.padding + W] = self.input_data
            self.input_data = data

        # 开始卷，每次送入以通道的特征图
        for i in range(C):
            feature_map = self.input_data[i]
            kernel = self.kernel_weight[i]
            feature_result += self.compute_conv(feature_map, kernel, [H_out, W_out])
        return feature_result

    def compute_conv(self, feature, kernel, size):
        # 输出特征图的size
        H, W = size[0], size[1]
        # 卷积核尺寸
        KH, KW = kernel.shape
        result = np.zeros((H, W))

        # 开始卷积
        for i in range(H):
            for j in range(W):
                result[i, j] = np.sum(
                    feature[i * self.stride:i * self.stride + KH, j * self.stride:j * self.stride + KW] * kernel)
        return result


if __name__ == '__main__':
    input_data = [
        [
            [1, 0, 1, 2, 1],
            [0, 2, 1, 0, 1],
            [1, 1, 0, 2, 0],
            [2, 2, 1, 1, 0],
            [2, 0, 1, 2, 0],
        ],
        [
            [2, 0, 2, 1, 1],
            [0, 1, 0, 0, 2],
            [1, 0, 0, 2, 1],
            [1, 1, 2, 1, 0],
            [1, 0, 1, 1, 1],

        ],
    ]
    weight_data = [
        [
            [1, 0, 1],
            [-1, 1, 0],
            [0, -1, 0],
        ],
        [
            [-1, 0, 1],
            [0, 0, 1],
            [1, 1, 1],
        ]
    ]

    conv = Conv(input_data, weight_data, 1, 0)
    result = conv.my_conv()
    print(result)

​

上面是一个手动实现卷积的简单实现，对2×5×5的特征图，利用2×3×3的卷积核，步长为1，填充为0进行特征卷积，输出：

        在这个例子中我们只是简单的进行了卷积操作，输出1通道的特征图，而在卷积网络之中，我们会经常涉及到通道映射的操作，若想实现此操作，只需要初始化对应通道数的卷积核即可，如想将32×256×256的特征图映射到64×H×W，我们可以初始化64×32×H_×W_个卷积核进行卷积。