卷积神经网络：卷积层

卷积层是卷积神经网络中提取图像特征的关键部分。通过局部连接和可学习的卷积核，卷积层能够有效捕捉图像中的重要特征，增强了模型的表达能力和泛化能力。卷积神经网络因其在各种计算机视觉任务中的高效性和准确性，已成为研究和应用的主流方法。IK5x53x3。

Wei_sx

1959人浏览 · 2025-01-08 17:37:45

Wei_sx · 2025-01-08 17:37:45 发布

卷积层是卷积神经网络（CNN）的核心组件，主要用于处理图像数据。以下是对卷积层功能和操作的详细解释，并通过实例进行说明。

1. 卷积的基本概念

卷积操作是卷积神经网络的基础，其主要构成包括：

卷积核（滤波器）：
卷积层使用多个小的可学习参数矩阵（卷积核）在输入图像上滑动以进行特征提取。比如，常见的卷积核大小有 3x3 和 5x5。

局部连接：
卷积层通过连接输入的局部区域进行特征提取，而非连接所有的输入。这使得网络可以专注于图像的局部特征。

运算：
卷积操作将卷积核在输入图像的每个局部区域上滑动并进行运算，生成特征图（feature map）：

$(I * K)(i, j) = \sum_m \sum_n I(m, n) \cdot K(i - m, j - n)$

其中 $I$ 为输入图像， $K$ 为卷积核。

示例：
假设我们有一个 $5x5$ 的输入图像和一个 $3x3$ 的卷积核：

卷积运算的部分结果如下：

1: (1*1 + 2*0 + 3*1 + 0*0 + 1*1 + 2*0 + 1*1 + 0*0 + 1*1) = 1 + 3 + 0 + 1 + 0 + 1 = 5

2. 特征图

特征图是卷积层输出的结果。每个卷积核生成一个特征图，表示网络在输入图像中检测到的特征。

在 CNN 中，多个卷积核被应用于同一输入，以产生多个特征图。例如，一个卷积层可以产生三到八个特征图，这些特征图各自捕捉了不同的特征（如边缘、纹理等）。

3. 特征提取过程

初始阶段：
卷积层首先接收原始图像，其 RGB 值作为输入，初期特征图可能识别基础特征，例如边缘和角落。

深层特征：
随着层的增加，特征图中的信息逐渐变得复杂，最终提取到更高级的特征，如物体的形状和结构。

4. 卷积操作的参数

步幅（Stride）：
卷积核在输入图像上滑动的步幅。通常的步幅为 1，即每次移动一个像素。若步幅设置为 2，则特征图的尺寸会减小一半。

填充（Padding）：
为防止特征图过小，可以在输入图像的边缘添加额外的像素（填充）。常见的填充类型包含：

无填充（valid padding）：不添加填充，特征图尺寸减小。
零填充（same padding）：通过在边缘添加零使输出特征图与输入图像相同尺寸。

5. 激活函数

在卷积层的逻辑输出后，通常会应用非线性的激活函数（如 ReLU），增加模型的表达能力。ReLU 的数学表达式为：

$f(x) = \max(0, x)$

其效果是将负值变为零，从而提高网络的非线性特征。

6. 卷积计算示例

6.1 单通道卷积计算

假设我们有一个单通道（黑白图像）输入图像和一个卷积核。输入图像为 $4 \times 4$ ，卷积核为 $3 \times 3$ 。

6.1.1 输入图像和卷积核

6.1.2 卷积运算

计算卷积时，首先将卷积核放在输入图像的左上角。对输入图像的每个局部区域进行乘法操作，然后求和，得出特征图的每个元素。

特征图大小计算：

        输入图像大小： $H = 4$ , $W = 4$
        卷积核大小： $K_h = 3$ , $K_w = 3$
        步幅 (Stride)：设为 1
        填充 (Padding)：不填充（valid padding）0

特征图的大小可以通过以下公式计算：

$Feature map height = \frac{H - K_h+2*Padding}{\text{Stride}} + 1 = \frac{4 - 3+2*0}{1} + 1 = 2$

$Feature map width= \frac{W - K_w+2*Padding}{\text{Stride}} + 1 = \frac{4 - 3+2*0}{1} + 1 = 2$

因此，特征图的大小为 $2 \times 2$

特征图计算如下：

位置(0,0)：

(1*1 + 2*0 + 3*1) + (0*0 + 1*1 + 2*0) + (1*1 + 0*0 + 1*1) = 1 + 0 + 3 + 0 + 1 + 0 + 1 + 0 + 1 = 7

位置(0,1)：
(2*1 + 3*0 + 0*1) + (1*0 + 2*1 + 3*0) + (0*1 + 1*0 + 0*1) = 2 + 0 + 0 + 0 + 2 + 0 + 0 + 0 + 0 = 4

位置(1,0)：
(0*1 + 1*0 + 2*1) + (1*0 + 0*1 + 1*0) + (4*1 + 1*0 + 0*1) = 0 + 0 + 2 + 0 + 0 + 0 + 4 + 0 + 0 = 6

位置(1,1)：
(1*1 + 2*0 + 3*1) + (0*0 + 1*1 + 2*0) + (1*1 + 0*0 + 1*1) = 1 + 0 + 3 + 0 + 1 + 0 + 1 + 0 + 1 = 7

6.1.3 特征图结果

特征图：

7 4  
6 7

6.2 多通道卷积计算

对于多通道输入（如彩色图像），假设我们有一个彩色图像（3个通道，RGB），每个通道大小为 $4 \times 4$ 。

6.2.1 输入图像

6.2.2 卷积核

假设我们使用一个 $3 \times 3$ 的卷积核，且对每个通道应用相同的卷积核：

6.2.3 卷积运算

对于每个通道计算卷积，然后将生成的特征图简单叠加，特征图的大小同样为 $2 \times 2$ 。

红色通道特征图计算：
(1 * 1 + 2 * 0 + 3 * 1) + (0 * 0 + 1 * 1 + 2 * 0) + (1 * 1 + 0 * 0 + 1 * 1) = 1 + 0 + 3 + 0 + 1 + 0 + 1 + 0 + 1 = 7

类似步骤进行其他通道计算：

绿色通道特征图计算：
(0 * 1 + 1 * 0 + 2 * 1) + (1 * 0 + 2 * 1 + 3 * 0) + (0 * 1 + 1 * 0 + 2 * 1) = 0 + 0 + 2 + 0 + 2 + 0 + 0 + 0 + 2 = 6

蓝色通道特征图计算：
(3 * 1 + 0 * 0 + 1 * 1) + (2 * 0 + 1 * 1 + 0 * 0) + (3 * 1 + 2 * 0 + 1 * 1) = 3 + 0 + 1 + 0 + 1 + 0 + 3 + 0 + 1 = 9

经过上述计算，得到的特征图合并为：

特征图 R：  
7 4  
6 7  

特征图 G：  
6 6  
6 6  

特征图 B：  
9 6  
8 6

6.2.4 最终特征图

为了获得最终的特征图，我们可以选择一种合并方式，比如取每个位置的最大值，或将所有特征图求平均，或是简单地对它们进行叠加。在这种情况下，特征图的排列可能如下（此处采用简单求和）：

特征图 R：  
7 4  
6 7  

特征图 G：  
6 6  
6 6  

特征图 B：  
9 6  
8 6

6.3 小结

单通道卷积提取了图像中简单的特征。
多通道卷积通过对每个通道进行卷积，然后合并多通道的特征图

7. 应用示例

下面是使用 Python 实现卷积层的代码示例，包括卷积操作、激活函数和如何在卷积神经网络中使用这些层。我们将实现一个简单的卷积操作，以展示卷积核如何在输入图像上滑动并生成特征图。

7.1 卷积操作的实现

import numpy as np  

def conv2d(input_image, kernel, stride=1, padding=0):  
    # 获取输入图像和卷积核的尺寸  
    i_h, i_w = input_image.shape  
    k_h, k_w = kernel.shape  

    # 计算输出特征图的尺寸  
    output_h = (i_h - k_h + 2 * padding) // stride + 1  
    output_w = (i_w - k_w + 2 * padding) // stride + 1  

    # 添加填充  
    input_padded = np.pad(input_image, ((padding, padding), (padding, padding)), mode='constant')  

    # 初始化输出特征图  
    output_feature_map = np.zeros((output_h, output_w))  

    # 执行卷积操作  
    for y in range(0, output_h):  
        for x in range(0, output_w):  
            region = input_padded[y * stride:y * stride + k_h, x * stride:x * stride + k_w]  
            output_feature_map[y, x] = np.sum(region * kernel)  

    return output_feature_map  

# 示例输入图像和卷积核  
input_image = np.array([[1, 2, 3, 0],  
                        [0, 1, 2, 3],  
                        [1, 0, 1, 0],  
                        [4, 1, 0, 1]])  

kernel = np.array([[1, 0, 1],  
                   [0, 1, 0],  
                   [1, 0, 1]])  

# 执行卷积操作  
conv_output = conv2d(input_image, kernel, stride=1, padding=0)  
print("卷积结果：")  
print(conv_output)

7.2 激活函数实现

我们通常会在卷积层输出之后应用非线性激活函数，比如 ReLU。以下是 ReLU 函数的简单实现：

def relu(x):  
    return np.maximum(0, x)  

# 对卷积输出应用 ReLU 激活函数  
activated_output = relu(conv_output)  
print("ReLU激活后的输出：")  
print(activated_output)

7.3 整体卷积层实现

在实际应用中，我们可以把卷积操作和激活函数结合，并添加到一个简单的模型中。以下是一个示例，展示如何组合这些功能：

class ConvLayer:  
    def __init__(self, num_filters, kernel_size, stride=1, padding=0):  
        self.num_filters = num_filters  
        self.kernel_size = kernel_size  
        self.stride = stride  
        self.padding = padding  
        # 初始化卷积核，使用随机值  
        self.kernels = np.random.randn(num_filters, kernel_size, kernel_size)  

    def forward(self, input_image):  
        batch_size, in_channels, height, width = input_image.shape  
        out_channels, kernel_height, kernel_width = self.kernels.shape  
        # 计算输出特征图的尺寸  
        output_height = (height - kernel_height + 2 * self.padding) // self.stride + 1  
        output_width = (width - kernel_width + 2 * self.padding) // self.stride + 1  
        
        # 将输入图像添加填充  
        input_padded = np.pad(input_image, ((0, 0), (0, 0), (self.padding, self.padding), (self.padding, self.padding)), mode='constant')  
        
        # 初始化
        output_feature_map = np.zeros((batch_size, out_channels, output_height, output_width))  

        # 对每个卷积核进行卷积操作  
        for f in range(out_channels):  
            for b in range(batch_size):  
                for y in range(output_height):  
                    for x in range(output_width):  
                        region = input_padded[b, :, y * self.stride:y * self.stride + kernel_height, x * self.stride:x * self.stride + kernel_width]  
                        output_feature_map[b, f, y, x] = np.sum(region * self.kernels[f])  

        return relu(output_feature_map)  
    
import numpy as np  

# 原始输入图像  
input_image = np.array([[1, 2, 3, 0],  
                        [0, 1, 2, 3],  
                        [1, 0, 1, 0],  
                        [4, 1, 0, 1]])  

# 重塑图像，确保其形状为 (1, 1, 4, 4)  
input_image_batch = input_image[np.newaxis, np.newaxis, :, :]  # 添加批次与通道维度  

# 使用 ConvLayer 类进行卷积操作  
conv_layer = ConvLayer(num_filters=1, kernel_size=3, stride=1, padding=0)  
conv_output_batch = conv_layer.forward(input_image_batch)  
print("卷积层输出：")  
print(conv_output_batch)

7.4 使用 Keras 构建卷积神经网络

以下是使用 Keras 构建卷积神经网络的示例代码：

from tensorflow.keras.models import Sequential  
from tensorflow.keras.layers import Conv2D, Flatten, Dense  

# 创建 sequential 模型  
model = Sequential()  

# 添加卷积层：32个3x3的卷积核，使用ReLU激活函数，输入尺寸为 (64, 64, 3)  
model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(64, 64, 3)))  

# 添加第二卷积层：64个3x3的卷积核  
model.add(Conv2D(64, (3, 3), activation='relu'))  

# 扁平化层，将特征图转换为一维  
model.add(Flatten())  

# 添加全连接层，假设输出为10个类别  
model.add(Dense(10, activation='softmax'))  

# 编译模型  
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])  

# 输出模型概况  
model.summary()

8. 总结

卷积层是卷积神经网络中提取图像特征的关键部分。通过局部连接和可学习的卷积核，卷积层能够有效捕捉图像中的重要特征，增强了模型的表达能力和泛化能力。卷积神经网络因其在各种计算机视觉任务中的高效性和准确性，已成为研究和应用的主流方法。

技术共进，成长同行——讯飞AI开发者社区

更多推荐

论文笔记：AlphaEdit: Null-Space Constrained Knowledge Editing for Language Models（AlphaEdit）

论文发表于人工智能顶会ICLR（基于定位和修改的模型编辑方法（针对和等）会破坏LLM中最初保存的知识，特别是在顺序编辑场景。为此，本文提出AlphaEdit：1、在将保留知识应用于参数之前，将扰动投影到保留知识的零空间上。2、从理论上证明，这种预测确保了在查询保留的知识时，编辑后的LLM的输出保持不变，从而减轻中断问题。3、对各种LLM（包括LLaMA3、GPT2XL和GPT-J）的广泛实验表明，