1、简介

首先回顾一下普通卷积， 下图是以stride=1， padding=0， kernel_size=3为例， 假设输入特征图大小为4×4(假设输入输出都是单通道), 通过卷积后的特征图大小为2×2， 一般使用卷积的情况中， 要是特征图变小（stride>1)， 要么保持不变(stride=1)， 当然也可以通过四周padding让特征图变大但是没有意义。

conv1

2、转置卷积

转置卷积主要起到上采样的作用， 但转置卷积不是卷积的逆运算(一般卷积操作是不可逆的), 它只能恢复到原来的大小， 数值与原来的不一样。转置卷积的运算步骤可以归纳为以下几点：

在输入特征图元素间填充s-1行， 列0(其中s是转置卷积的步距)

在输入特征图四周填充p-1行， 列0（其中k表示转置卷积的kernel_size大小， p为转置卷积的padding， 注意这里的padding和卷积操作有些不同)

将卷积核参数上下、左右翻转

做正常卷积运算(填充0， 步距1)

下面假设输入的特征图为2×2（假设输入输出为单通道)， 通过转置卷积后的的得到4×4大小的特征图。 这里使用的转置卷积核大小k=3， stride=1， padding=0的情况(忽略偏置bias)

首先在元素间填充s-1=0行，列0

然后再特征图四周填充k-p-1=2行， 列0

接着对卷积核参数进行上下， 左右翻转

最后做正常卷积(填充0， 步距1) transpose_conv.jpg

transpose_conv

下面展示了不同转置卷积中不同s和p的情况 transpose_conv_s2_p0_k3.gif transpose_conv_s1_p0_k3.gif transpose_conv_s2_p1_k3.gif

s=1, p=0, k=3
间隙填充s-1=0,四周填充k-p-1=2
s=2, p=0, k=3
间隙填充s-1=1,四周填充k-p-1=2
s=2, p=1, k=3
间隙填充s-1=1,四周填充k-p-1=1

转置卷积操作后特征图的大小可以通过如下公式进行计算：

其中stride[0]表示高度方向的stride， padding[0]表示高度方向的padding， kernel_size[0]表示高度方向的kernel_size, 同理[1]表示宽度方向上的。 通过上面的公式可以看出， padding越大，输出特征矩阵的高宽越小。 你可以理解为正向传播过程中进行了padding然后得到了特征图， 现在使用转置卷积还原到原来的高宽后要把原来的padding减掉。

3、pytorch中转置卷积参数

pytorch官方关于转置卷积的ConvTranspose2d的文档。

Applied a 2D transposed convolution operator over an input image composed of several input planes. This module can be seen as the gradient of Conv2d with respect to its input. It is also known as a fractionally-strided convolution or a deconvolution (althought it is not an actual deconvolution operation). image-20231107093032555.png

image-20231107093032555

官方的介绍中还有如下几个参数：

output_padding: 在计算得到的输出特征图的高、宽各方向各填充几行或列0(注意：这里只是在上下以及左右的一侧one side填充，并不是两侧头填充)

groups: 当使用到组卷积时才会用到的参数， 默认为1即为普通卷积

bias： 是否使用偏置， 默认为True使用

dilation： 当使用空洞卷积（膨胀卷积）时才会使用到的参数， 默认为1即为普通卷积。

输出特征图高、宽计算

4、pytorch转置卷积实验

下面使用pytorch模拟s=1, p=0, k=3的转置卷积操作

conv_s1k0p3

在代码中transpose_conv_official函数是通过官方的转置卷积进行计算， transpose_conv_self是按照上面的介绍对输入特征图进行填充并通过卷积得到的结果。 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
# !/usr/bin/env python
# -*-coding:utf-8 -*-
"""
# @File       : convTranspose_demo.py
# @Time       ：
# @Author     ：
# @version    ：python 3.9
# @Software   : PyCharm
# @Description：
"""
# ================【功能：】====================
import torch
import torch.nn as nn


def transposed_conv_official():
    feature_map = torch.as_tensor([[1, 0],
                                   [2, 1]], dtype=torch.float32).reshape([1, 1, 2, 2])
    print(feature_map)
    trans_conv = nn.ConvTranspose2d(in_channels=1, out_channels=1,
                                    kernel_size=3, stride=1, bias=False)
    trans_conv.load_state_dict({"weight":
                                    torch.as_tensor([[1, 0, 1],
                                                     [0, 1, 1],
                                                     [1, 0, 0]],
                                                    dtype=torch.float32)
                               .reshape([1, 1, 3, 3])})
    print(trans_conv.weight)
    output = trans_conv(feature_map)
    print("output, \n", output)


def transposed_conv_self():
    feature_map = torch.as_tensor([[0, 0, 0, 0, 0, 0],
                                   [0, 0, 0, 0, 0, 0],
                                   [0, 0, 1, 0, 0, 0],
                                   [0, 0, 2, 1, 0, 0],
                                   [0, 0, 0, 0, 0, 0],
                                   [0, 0, 0, 0, 0, 0],
                                   ], dtype=torch.float32).reshape([1, 1, 6, 6])
    print(feature_map)
    conv = nn.Conv2d(in_channels=1, out_channels=1,
                     kernel_size=3, stride=1, bias=False)
    conv.load_state_dict({"weight": torch.as_tensor([[0, 0, 1],
                                                     [1, 1, 0],
                                                     [1, 0, 1]], dtype=torch.float32).reshape([1, 1, 3, 3])})

    print(conv.weight)
    output = conv(feature_map)
    print("output \n", output)


def main():
    transposed_conv_official()
    print('--------')
    transposed_conv_self()


if __name__ == '__main__':
    main()

终端输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
feature_map 
 tensor([[[[1., 0.],
          [2., 1.]]]])
trans_conv.weight 
 Parameter containing:
tensor([[[[1., 0., 1.],
          [0., 1., 1.],
          [1., 0., 0.]]]], requires_grad=True)
output, 
 tensor([[[[1., 0., 1., 0.],
          [2., 2., 3., 1.],
          [1., 2., 3., 1.],
          [2., 1., 0., 0.]]]], grad_fn=<ConvolutionBackward0>)
--------
self feature_map 
 tensor([[[[0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0.],
          [0., 0., 1., 0., 0., 0.],
          [0., 0., 2., 1., 0., 0.],
          [0., 0., 0., 0., 0., 0.],
          [0., 0., 0., 0., 0., 0.]]]])
conv.weight 
 Parameter containing:
tensor([[[[0., 0., 1.],
          [1., 1., 0.],
          [1., 0., 1.]]]], requires_grad=True)
output 
 tensor([[[[1., 0., 1., 0.],
          [2., 2., 3., 1.],
          [1., 2., 3., 1.],
          [2., 1., 0., 0.]]]], grad_fn=<ConvolutionBackward0>)