卷积详解和并行卷积

ps:在 TensorFlow Keras 中,构建 Sequential 模型的正确方式是将层作为列表传递,而不是作为一系列单独的参数。
model=models.Sequential([layers,layers])
而不是model=models.Sequential(layers,layers)

文章目录

  • 卷积操作及其计算过程的详细解释
    • 卷积的基本操作
      • 1. 卷积核(Convolution Kernel)
        • 卷积核如何提取特征
      • 2. 卷积过程
        • 卷积的数学表示
        • 简单例子
        • 输出尺寸的计算
      • 3.卷积矩阵在深度训练中的改变过程
        • 卷积核的调整过程
          • 1. 初始化
          • 2. 前向传播
          • 3. 反向传播和卷积核的更新
          • 4. 迭代过程
        • 卷积核的角色
  • 并行卷积结构和深度可分离卷积的详细数学解释
    • 并行卷积结构:Inception 模块
      • 概念
      • 数学表示
      • 简单例子
        • 输出尺寸的计算
        • 为什么不同的卷积大小产生相同的尺寸输出
      • 代码

卷积操作及其计算过程的详细解释

卷积是深度学习中用于图像和信号处理的一种基本数学操作。它通过应用卷积核(或过滤器)到输入数据上,来提取重要特征。

卷积的基本操作

1. 卷积核(Convolution Kernel)

  • 卷积核是一个小的矩阵(通常是2D),用于通过滤过输入数据来提取特定特征。
卷积核如何提取特征
  • 边缘检测:例如,卷积核 K = [ − 1 0 1 − 1 0 1 − 1 0 1 ] K = \begin{bmatrix}-1 & 0 & 1 \\ -1 & 0 & 1 \\ -1 & 0 & 1\end{bmatrix} K= 111000111 被用于边缘检测。这个特定的卷积核可以突出水平方向的边缘。它通过计算左侧像素与右侧像素的差异来工作,这种差异在边缘处最大。

  • 纹理和模式识别:不同的卷积核可以识别不同的纹理和模式。例如,对于识别特定方向的纹理,卷积核会有特定的方向性。

在实际应用中,通常不是手动设计这些卷积核,而是通过训练过程让神经网络自行学习最优的卷积核,以适应特定的任务和数据。

2. 卷积过程

  • 将卷积核放在输入数据的左上角。
  • 将卷积核的每个元素与其覆盖的输入数据元素相乘,然后将结果求和,得到输出特征图的一个元素。
  • 将卷积核向右滑动一个步长(Stride),重复上述过程,直到覆盖整个输入数据。
卷积的数学表示

卷积操作可以表示为:

S ( i , j ) = ( I ∗ K ) ( i , j ) = ∑ m ∑ n I ( m , n ) K ( i − m , j − n ) S(i, j) = (I \ast K)(i, j) = \sum_m \sum_n I(m, n) K(i-m, j-n) S(i,j)=(IK)(i,j)=mnI(m,n)K(im,jn)

其中, I I I 是输入图像, K K K 是卷积核, S S S 是输出特征图, i i i j j j 表示特征图上的位置。

  • 以一个 3 × 3 3 \times 3 3×3 的卷积核为例,应用于一个二维输入数据(如图像):

    S ( i , j ) = ∑ m = 0 2 ∑ n = 0 2 I ( i + m , j + n ) K ( m , n ) S(i, j) = \sum_{m=0}^{2} \sum_{n=0}^{2} I(i+m, j+n) K(m, n) S(i,j)=m=02n=02I(i+m,j+n)K(m,n)

    其中 I I I 是输入数据, K K K 是卷积核, S S S 是输出特征图, i i i j j j 是特征图上的位置。

简单例子

假设输入数据是一个 4 × 4 4 \times 4 4×4 的矩阵,卷积核是一个 3 × 3 3 \times 3 3×3 的矩阵,如下所示:
输入数据 I:
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16

卷积核 K:
-1 0 1
-1 0 1
-1 0 1

  • 将卷积核放在输入数据的左上角,计算卷积(不考虑步长和填充):

S(0, 0) = (1*-1 + 20 + 31) + (5*-1 + 60 + 71) + (9*-1 + 100 + 111)
= -1 + 0 + 3 - 5 + 0 + 7 - 9 + 0 + 11
= 7

  • 将卷积核向右滑动一个步长,并重复计算。
输出尺寸的计算

输出尺寸取决于输入尺寸、卷积核尺寸、步长和填充:

Output Size = Input Size − Filter Size + 2 × Padding Stride + 1 \text{Output Size} = \frac{\text{Input Size} - \text{Filter Size} + 2 \times \text{Padding}}{\text{Stride}} + 1 Output Size=StrideInput SizeFilter Size+2×Padding+1

在不使用填充且步长为1的情况下,上述例子中的输出尺寸将是 2 × 2 2 \times 2 2×2

3.卷积矩阵在深度训练中的改变过程

在深度学习中,卷积矩阵(或称为卷积核、过滤器)是通过训练过程逐渐调整以优化特征提取的。这个调整过程是通过反向传播算法和梯度下降方法实现的。

卷积核的调整过程
1. 初始化
  • 初始化:开始训练时,卷积核的权重通常被初始化为随机小数值。
2. 前向传播
  • 提取特征:在训练过程中,卷积核在前向传播阶段通过卷积操作提取输入数据的特征。
    前向传播是数据通过神经网络的过程,其中的每一步如下:
    1. 数据输入:原始数据输入网络。
    2. 卷积操作:数据通过卷积层,卷积核应用于数据。
    3. 激活函数:卷积的结果通过激活函数,如ReLU。
    4. 池化:可选步骤,应用池化(如最大池化)降低维度。
    5. 输出生成:通过全连接层生成最终输出。
3. 反向传播和卷积核的更新

卷积核的更新发生在反向传播过程中,该过程如下:

  1. 损失计算:计算预测输出和实际输出之间的差异(损失)。
  • 损失函数衡量模型预测与实际标签之间的差距。常用的损失函数包括均方误差(MSE)和交叉熵损失。

  • 假设有实际值 y y y 和预测值 y ^ \hat{y} y^,MSE 计算公式为:

    MSE = 1 n ∑ i = 1 n ( y i − y ^ i ) 2 \text{MSE} = \frac{1}{n} \sum_{i=1}^{n} (y_i - \hat{y}_i)^2 MSE=n1i=1n(yiy^i)2

    其中 n n n 是样本数量。

  1. 梯度计算:通过反向传播算法计算损失函数相对于卷积核权重的梯度。
  • 对于每个权重 W W W,损失函数的梯度计算为:

    ∂ Loss ∂ W = ∂ Loss ∂ y ^ × ∂ y ^ ∂ W \frac{\partial \text{Loss}}{\partial W} = \frac{\partial \text{Loss}}{\partial \hat{y}} \times \frac{\partial \hat{y}}{\partial W} WLoss=y^Loss×Wy^

  1. 权重更新:根据梯度和学习率更新卷积核的权重。更新公式为:

W new = W old − η × ∂ Loss ∂ W W_{\text{new}} = W_{\text{old}} - \eta \times \frac{\partial \text{Loss}}{\partial W} Wnew=Woldη×WLoss

其中 W W W 是卷积核权重, η \eta η 是学习率, ∂ Loss ∂ W \frac{\partial \text{Loss}}{\partial W} WLoss 是损失函数相对于 W W W 的梯度。

示例:单层神经网络

  • 假设有一个单层网络,输出 y ^ = W x + b \hat{y} = Wx + b y^=Wx+b,损失函数是 MSE。

  • 损失对 W W W 的梯度为:

    ∂ Loss ∂ W = 2 n ∑ ( y − y ^ ) × ( − x ) \frac{\partial \text{Loss}}{\partial W} = \frac{2}{n} \sum (y - \hat{y}) \times (-x) WLoss=n2(yy^)×(x)

  • 在反向传播中,这个梯度用于更新 W W W

4. 迭代过程
  • 重复迭代:这个过程在多个训练周期(epoch)中重复进行,直到模型性能达到预定的标准或者停止改进。
卷积核的角色
  • 在训练过程中,卷积核逐渐学习到如何有效地提取输入数据的关键特征,这些特征对于完成特定的深度学习任务(如图像分类、物体检测等)至关重要。

并行卷积结构和深度可分离卷积的详细数学解释

并行卷积结构:Inception 模块

概念

  • Inception 模块是一种在同一网络层上并行应用多种不同尺寸卷积核的结构。
  • 它允许网络在单一层级上捕获多尺度特征。

数学表示

假设输入特征图为 X X X,Inception 模块中的不同分支可以表示如下:

  1. 1 × 1 1 \times 1 1×1 卷积分支
    Y 1 = Conv 1 × 1 ( X ) Y_1 = \text{Conv}_{1 \times 1}(X) Y1=Conv1×1(X)
    这里, Conv 1 × 1 \text{Conv}_{1 \times 1} Conv1×1 表示 1 × 1 1 \times 1 1×1 卷积,用于捕获局部特征。

  2. 3 × 3 3 \times 3 3×3 卷积分支
    Y 2 = Conv 3 × 3 ( X ) Y_2 = \text{Conv}_{3 \times 3}(X) Y2=Conv3×3(X)
    3 × 3 3 \times 3 3×3 卷积能捕获更广泛的空间特征。

  3. 5 × 5 5 \times 5 5×5 卷积分支
    Y 3 = Conv 5 × 5 ( X ) Y_3 = \text{Conv}_{5 \times 5}(X) Y3=Conv5×5(X)
    5 × 5 5 \times 5 5×5 卷积提供了更大范围的感受野。

这些分支的输出被沿深度方向合并,生成综合特征映射 Y Y Y
Y = [ Y 1 , Y 2 , Y 3 ] Y = [Y_1, Y_2, Y_3] Y=[Y1,Y2,Y3]

简单例子

考虑一个 224 × 224 × 3 224 \times 224 \times 3 224×224×3 的图像作为输入 X X X。Inception 模块中的 1 × 1 1 \times 1 1×1 卷积可能产生 224 × 224 × 64 224 \times 224 \times 64 224×224×64 的输出 Y 1 Y_1 Y1 3 × 3 3 \times 3 3×3 卷积产生相同尺寸的输出 Y 2 Y_2 Y2,而 5 × 5 5 \times 5 5×5 卷积也产生相同尺寸的输出 Y 3 Y_3 Y3。合并这些输出,我们得到一个 224 × 224 × 192 224 \times 224 \times 192 224×224×192 的特征映射 Y Y Y

输出尺寸的计算

输出特征图的尺寸取决于几个因素:

  • 输入尺寸:输入图像的尺寸。
  • 卷积核尺寸:卷积核的大小。
  • 步长(Stride):卷积核在输入上滑动的步长。
  • 填充(Padding):在输入周围添加的零的层数。

输出尺寸的计算公式为:

Output Size = Input Size − Filter Size + 2 × Padding Stride + 1 \text{Output Size} = \frac{\text{Input Size} - \text{Filter Size} + 2 \times \text{Padding}}{\text{Stride}} + 1 Output Size=StrideInput SizeFilter Size+2×Padding+1

为什么不同的卷积大小产生相同的尺寸输出

在前面的例子中, 1 × 1 1 \times 1 1×1 3 × 3 3 \times 3 3×3 5 × 5 5 \times 5 5×5 的卷积产生了相同尺寸的输出,这是因为:

  1. 步长和填充的调整:通过调整步长和填充,可以使不同大小的卷积核产生相同尺寸的输出。通常,较大的卷积核会使用更多的填充来保持输出尺寸不变。

  2. 保持特征图空间分辨率:这种做法使得并行的卷积分支可以在深度方向上直接合并,因为它们具有相同的空间维度。

所以假设输入尺寸为 224 × 224 224 \times 224 224×224,卷积核尺寸分别为 1 × 1 1 \times 1 1×1 3 × 3 3 \times 3 3×3 5 × 5 5 \times 5 5×5,步长为 1,并且对于 3 × 3 3 \times 3 3×3 5 × 5 5 \times 5 5×5 卷积使用适当的填充(分别为 1 和 2)来保持输出尺寸不变。根据上述公式,所有这些卷积操作将产生 224 × 224 224 \times 224 224×224 的输出特征图。

代码

import tensorflow as tf
from tensorflow.keras.layers import Input, Conv2D, Concatenate
from tensorflow.keras.models import Model

# 定义一个函数来创建并行卷积层
def parallel_convolution(input_tensor):
    # 1x1 卷积
    conv_1x1 = Conv2D(filters=64, kernel_size=(1, 1), padding='same', activation='relu')(input_tensor)

    # 3x3 卷积
    conv_3x3 = Conv2D(filters=64, kernel_size=(3, 3), padding='same', activation='relu')(input_tensor)

    # 5x5 卷积
    conv_5x5 = Conv2D(filters=64, kernel_size=(5, 5), padding='same', activation='relu')(input_tensor)

    # 合并不同尺寸卷积的结果
    output = Concatenate()([conv_1x1, conv_3x3, conv_5x5])

    return output

# 输入层
input_layer = Input(shape=(224, 224, 3))

# 应用并行卷积层
output_layer = parallel_convolution(input_layer)

# 创建模型
model = Model(inputs=input_layer, outputs=output_layer)

# 查看模型概况
model.summary()

你可能感兴趣的:(算法,机器学习)