卷积层介绍及其输出张量形状的分析

深度学习卷积层解析

最新推荐文章于 2025-01-10 08:38:05 发布

XenonSec

最新推荐文章于 2025-01-10 08:38:05 发布

阅读量1.5k

点赞数

CC 4.0 BY-SA版权

分类专栏：机器学习

本文链接：https://blog.youkuaiyun.com/u013745174/article/details/99335097

机器学习专栏收录该内容

2 篇文章

订阅专栏

本文深入探讨深度学习中卷积层的参数及其计算过程，通过DQN模型实例讲解卷积层输出张量的形状变化，揭示Valid与Same卷积的区别，及卷积在减少数据尺寸、提取特征方面的作用。

卷积层在深度学习中常常用到。下面介绍一下卷积层中的参数，并使用一个DQN中的例子来推算卷积层输出张量的形状。

1. 卷积层参数及其意义

卷积层的意义在于提取给定的数据的特征，池化层的意义在于减少数据的大小，减少运算量。

1.1 卷积参数计算的过程分析

$[l]$ ：层数l
$f^{[l]}$ ：filter的大小
$p^{[l]}$ ：padding
$s^{[l]}$ ：步长stride
$nc[l]n^{[l]}_c$ ：filter的数量（也就是输出数据Channel的数量）
$nc[l−1]n^{[l-1]}_c$ ：输入数据Channel的数量
bias：每层的偏离值，是一个实数，即为逻辑回归中的b参数

输入张量形状： $nH[l−1]∗nW[l−1]∗n[l−1]n^{[l-1]}_H * n^{[l-1]}_W * n^{[l-1]}$
输出张量形状： $nH[l]∗nW[l]∗nc[l]n^{[l]}_H * n^{[l]}_W * n^{[l]}_c$

其中可以计算获得
$nH[l]=⌊nH[l−1]+2p[l]−f[l]s[l]+1⌋n^{[l]}_H = \lfloor \frac{n^{[l-1]}_H + 2p^{[l]} - f^{[l]}}{s^{[l]}} + 1 \rfloor$
$nW[l]=⌊nW[l−1]+2p[l]−f[l]s[l]+1⌋n^{[l]}_W = \lfloor \frac{n^{[l-1]}_W + 2p^{[l]} - f^{[l]}}{s^{[l]}} + 1 \rfloor$

1.2 Valid与Same卷积

padding的作用是防止边缘的数据计算次数过少，导致计算结果难以显示边缘的特征。

Valid卷积中无padding；
Same卷积的输入与输出大小一致，padding的数值可由 $\frac{f - 1}{2}$ 确定。其中f一般是奇数。

2. DQN数据处理模型

在Dueling DQN的forward函数中，先卷积运算了两次，并将获得的结果展开至一维，之后分别使用价值函数和优势函数计算Value和Advantage，再用Value和Advantage预测出Q值。

卷积过程: nn.Conv2d(conv1) -> ReLU -> nn.Conv2d(conv2) -> ReLU
Value计算过程: NoisyLinear(fc_h_v) -> ReLU -> NoisyLinear(fc_z_v) -> ReLU
Advantage计算过程: NoisyLinear(fc_h_a) -> ReLU -> NoisyLinear(fc_z_a) -> ReLU

class DQN(nn.Module):
    def __init__(self, args, action_space):
        super().__init__()
        self.atoms = args.atoms
        self.action_space = action_space

        # conv1，conv2与ReLU
        self.convs = nn.Sequential(nn.Conv2d(args.history_length, 32, 5, stride=2, padding=0), nn.ReLU(),
                                   nn.Conv2d(32, 32, 5, stride=2, padding=0), nn.ReLU())
        self.conv_output_size = 70688

        self.fc_h_v = NoisyLinear(self.conv_output_size, args.hidden_size, std_init=args.noisy_std)
        self.fc_h_a = NoisyLinear(self.conv_output_size, args.hidden_size, std_init=args.noisy_std)
        self.fc_z_v = NoisyLinear(args.hidden_size, self.atoms, std_init=args.noisy_std)
        self.fc_z_a = NoisyLinear(args.hidden_size, action_space * self.atoms, std_init=args.noisy_std)

def forward(self, x, log=False) -> torch.Tensor:
    x = self.convs(x)
    x = x.view(-1, self.conv_output_size)
    v = self.fc_z_v(F.relu(self.fc_h_v(x)))  # Value stream
    a = self.fc_z_a(F.relu(self.fc_h_a(x)))  # Advantage stream
    v, a = v.view(-1, 1, self.atoms), a.view(-1, self.action_space, self.atoms)
    q = v + a - a.mean(1, keepdim=True)  # Combine streams
    if log:  # Use log softmax for numerical stability
        q = F.log_softmax(q, dim=2)  # Log probabilities with action over second dimension
    else:
        q = F.softmax(q, dim=2)  # Probabilities with action over second dimension
    return q