PyTorch中的转置卷积详解——全网最细_transpose conv

前言

转置卷积，学名transpose convolution，在tf和torch里都叫这个。
有时在论文里可以看到别人叫它deconvolution（反卷积），但这个名词不合适。
因为转置卷积并非direct convolution的逆运算(reverse)，并不能还原出原张量，所以叫它逆卷积是错的。
只是从形状上看，其结果的形状等同于原张量的形状。

写这篇文章是因为网上介绍转置卷积的博客，
都讲不清楚，我看了半天还是云里雾里。
只能自己手动来一篇了。

一、 基本运算——错位扫描

定义 本文中，我们将平时用到的普通卷积，称为direct convolution。

transpose conv 与 direct conv最大的区别在于：

转置卷积支持错位扫描。

显然，错位扫描的性质使得扫描次数变多了。因此transpose conv的输出结果，shape会比输入大。
这就是转置卷积能在shape上还原input的基本原理。（当然数值上并不能还原）

二、形状公式

这篇介绍卷积的论文写得，十！分！详！尽！
但是跟天书一样难懂。

A guide to convolution arithmetic for deep learning
Vincent Dumoulin, Francesco Visin
https://arxiv.org/abs/1603.07285

我尝试另外写一份自己的版本。

定义2.1 我们将kernel_size相同的，能还原输入shape的转置卷积，称为与direct conv相对应的 transpose conv。

例如我们输入一个(7x7)，直接卷积得到(3x3)。
那么理论上存在很多个transpose conv能从(3x3)还原为(7x7)，这不利于我们研究。
所以我们规定只有kernel_size相同的那个transpose conv是对应的， corresponding transpose conv。

定理2.1 每一个direct conv对应的transpose conv，又存在一个shape变换上等价的，对应的direct conv。

显然，想实现(3x3)还原为(7x7)这件事，我们也能用带padding的direct conv做到，不是吗？
其他情况也是一样的，仅仅还原形状的话，transpose conv总是可以用某个direct conv代替，我们也称呼kernel_size相同的，仅仅padding不同的那个为corresponding direct conv。

现在我们有了3个不同的概念，original direct conv, corresponding transpose conv, corresponding direct conv.

先约定几个符号表示，以下简称

对direct conv

input_size = i (注意，我们隐性地假设了2D输入的形状是正方形所以只需要一个字母i，而不必用2个字母wh)
output_size = o
kernel_size = k
padding = p
stride = s

对transpose conv

input_size=i’
output_size = o’
kernel_size = k’，由于我们只研究the corresponding one，所以此处k’=k
padding=p’
stride=s’

我们希望转置卷积的输出，能恢复原来的输入形状，即希望 o’=i ,

定理2.2 direct conv的形状公式
$$o=[i+2\ast p-(k-1)]/s$$
这条公式学过卷积的人都不会陌生。

定理2.3 transpose conv的形状公式
$$o^{\prime }=[i^{\prime }+2\ast p^{\prime }+(k^{\prime }-1)]/s^{\prime }$$

初学者大多数会晕在这一步，因为转置卷积悄悄地偷换了2个概念 ，s’与p’。
往下看就明白为什么说偷换了。
我先给出结论，

在现行的对应转置卷积中，s’总是等于1，p’<=0。

证明

对定理2.2进行变形，得到
$$\begin{gathered} i=o\ast s+(k-1)-2\ast p \\ =o\ast s+(k-1)+2\ast (-p) \end{gathered}$$
对照定理2.3 $$o^{\prime }=[i^{\prime }+(k-1)+2\ast p^{\prime }]/s^{\prime }$$

如果我们希望达成$o^{\prime }=i$，corresponding transpose conv就应该满足：
$i^{\prime }=o\ast s$
$p^{\prime }=-p$
$s^{\prime }=1$

虽然上述3个条件不是唯一解，但却是实践应用中最简单的一组解，所以被作为默认解。你去看torch和tf的源码，都是这么设置的。

上式表明，欲使转置卷积的输出$o^{\prime }$完美还原直接卷积的输入形状$i$，
需要先对$o$做$stride$处理，
然后进行步长为1的错位扫描得到（k-1）的形状增益，
最后减去$padding$。

“进行步长为1的错位扫描能得到（k-1）的形状增益”是一个不言自证的结论。

三、进阶运算，stride处理，步长1的错位扫描，与padding消融

本节对第二节中最后推导出的3个步骤进行分解说明。

3.1 stride处理

我称之为内部zero-padding，简称内部padding。
简单的说，就是把转置卷积的输入o先放大stride倍，
填充的部分使用zero。（而不是一般图片用的插值填充）

这里肯定有人会奇怪，
按第二节给出的公式，$i^{\prime }=o\ast s=3\ast 2=6$才对，怎么会是5。

事实上，我们在实践中真正使用的处理公式是
$i^{\prime }=(o-1)\ast s+1$

我将在第五节补充讨论这个问题。

3.2 步长1的错位扫描

这个在第一节已经介绍过了。

3.3 padding消融

上节说过$p^{\prime }=-p$，这意味着我们在转置卷积中，做的不是加边，而是消边。
以p=1为例，那么p’=-1，我们需要在四周消去1条边。
最终o’=7+2*(-1)=5

四、代码验证3步骤的正确性

注意！torch中的weight会被reverse。

本节通用头文件

import torch
import torch.nn.functional as F
1
2

4.1 一个基本的1d转置卷积

算2d很累的，看看1d弄明白就行了。
代码参考

inputs = torch.Tensor([[1,2,3],[4,5,6]]).unsqueeze(0) #(1,2,3)
weights = torch.Tensor([1.1,2.2,3.3]).view(1,1,-1).repeat(2,1,1) #(2,5,k=3)
print(inputs.shape)
print(weights.shape)
o =F.conv_transpose1d(inputs, weights,padding=0,stride=1)
print(o.shape)
print(o)
1
2
3
4
5
6
7

打印结果

torch.Size([1, 2, 3])
torch.Size([2, 1, 3])
torch.Size([1, 1, 5])
tensor([[[ 5.5000, 18.7000, 41.8000, 42.9000, 29.7000]]])
1
2
3
4

对上述运算进行基本说明。
inputs形状为[batch_size,C_in,L_in]=[1,2,3]
weights的形状为[C_in,C_out,kernel_size] = [2,1,3]
输出的形状为[batch_size,C_out,L_out] = [1,1,5]
本例中，我们设置

batch_size=1,
C_in=2,
L_in=3,即直接卷积的输出o=3
C_out=1,
k=3
p=0
s=1

其中C_out本质上是输出特征图的数量，我们令为1，所以结果只需要输出一张特征图。

对结果进行分析不难发现

o = tensor([[[ 5.5000, 18.7000, 41.8000, 42.9000, 29.7000]]])
5.5 = (1+4)*1.1
18.7= (2+5)*1.1+(1+4)*2.2
41.8= (3+6)*1.1+(2+5)*2.2+(1+4)*3.3
42.9= (3+6)*2.2+(2+5)*3.3
29.7= (3+6)*3.3

对应扫描方式为

这就是很奇怪的一点了，
weights我们定义是$[1.1,2.2,3.3]$，
进去运算时，它里面就reverse了变成$[3.3,2.2,1.1]$

当然平时我们用的转置卷积，大多数是随机初始化参数自己去学习的，这个reverse也不影响。
但若是固定weights，自己手动控制转置卷积时，这个reverse就非常值得注意了。
在使用torch时务必当心。

4.2 stride处理的正确性验证

inputs = torch.Tensor([[1,2,3],[4,5,6]]).unsqueeze(0) #(1,2,3)
weights = torch.Tensor([1.1,2.2,3.3]).view(1,1,-1).repeat(2,1,1) #(2,5,k=3)
print(inputs.shape)
print(weights.shape)
o =F.conv_transpose1d(inputs, weights,padding=0,stride=2)
print(o.shape)
print(o)
1
2
3
4
5
6
7

输出

torch.Size([1, 2, 3])
torch.Size([2, 1, 3])
torch.Size([1, 1, 7])
tensor([[[ 5.5000, 11.0000, 24.2000, 15.4000, 33.0000, 19.8000, 29.7000]]])
1
2
3
4

本例我们设置p=0，s=2.
如同我们在3.2中猜想的那样，输入的o=3，先被stride=2处理变成i’=5，然后进行k=3、步长为1的错位扫描，最后输出的形状o’=7。

数值上也显然可以验证是正确的。
"由于篇幅限制，这里写不下。”
请读者自行验证。

、

4.3 padding消融的正确性验证

在4.2的代码基础上，把padding改成1即可。

oinputs = torch.Tensor([[1,2,3],[4,5,6]]).unsqueeze(0) #(1,2,3)
weights = torch.Tensor([1.1,2.2,3.3]).view(1,1,-1).repeat(2,1,1) 
print(inputs.shape)
print(weights.shape)
o =F.conv_transpose1d(inputs, weights,padding=1,stride=2)
print(o.shape)
print(o)
1
2
3
4
5
6
7

输出

torch.Size([1, 2, 3])
torch.Size([2, 1, 3])
torch.Size([1, 1, 5])
tensor([[[11.0000, 24.2000, 15.4000, 33.0000, 19.8000]]])
1
2
3
4

注意到，
4.2中的输出是$[5.5,11,24.2,15.4,33,19.8,29.7]$，共7个。
4.3中的输出是$[11,24.2,15.4,33,19.8]$，共5个。
我们设p=1之后，输出结果在4.2的基础上，两头各消去1个值，得到o’=5。

至此，我们完美验证了第三节的所有猜想。

草（一种植物）
我突然发现，这个卷积核的英文名叫transpose conv filter。
这东西的断句可能不是(transpose conv) filter，即 filter of transpose conv，
而是transpose (conv filter)，即conv filter in transpose form?
难道因为这样，所以weights进去必须被transpose???
所以1.1，2.2，3.3逆转了。
玄学。。。

五、对stride处理的补充

我们回来讨论第三节中遗留的问题，
为什么o=3,s=2,k=3,p=1时，i’=5，而不是6。

再次回顾转置卷积的背景意义，我们希望在shape上还原直接卷积的input。
不妨思考，i=多少时，经过k=3,p=1,s=2的直接卷积，能得到o=3？

在第四节的代码已经能看到，我们最终还原出来的o’=5。

显然可以验证，如果i=5,k=3,p=1,s=2，我们是能得到o=3的。

关键在于直接卷积有一个隐性操作，
若 $[i+2\ast p-(k-1)]\%s!=0$
直接卷积，会额外做padding操作。

本例中，i=5,k=3,p=1,s=2，计算得到 $i+2\ast p-(k-1)=5+2\ast 1-(3-1)=5$，不能被$s=2$整除。
于是5又额外pad一次，得到6，然后$o=6/2=3$。

同理，如果i=6,k=3,p=1,s=2，也能得到o=3。

也就是说，在满足我们给定的背景意义“希望转置卷积还原直接卷积的输入shape”的基础上， {o=3,k=3,p=1,s=2}这组条件，有2个解，i=5 or i=6。

但计算机中，我们不可能让transpose_conv_layer输出2个解，我们只能求一个确定解，这样才有计算可行性。
因此这种“内部pad”的stride处理方式，本质上是一种人为规定。
虽然给定条件可能对应多个解，但我们总是取最小的那个解。

而且，这种stride处理方式，看起来很优美不是吗。

六、corresponding direct conv

我们回顾第二节中获得的公式
$$\begin{gathered} i=o\ast s+(k-1)-2\ast p \\ =o\ast s+(k-1)+2\ast (-p) \end{gathered}$$
继续变形得到
$$\begin{gathered} i=o\ast s+2\ast (k-1)-(k-1)+2\ast (-p) \\ =o\ast s+2\ast (k-1-p)-(k-1) \end{gathered}$$

对照定理2.2的式子
$$o^{\prime \prime }=[i^{\prime \prime }+2\ast p^{\prime \prime }-(k^{\prime \prime }-1)]/s^{\prime \prime }$$

不难得出，corresponding direct conv若想让输出完美还原输入，
需要令
$i^{\prime \prime }=o\ast s$
$k^{\prime \prime }=k$
$s^{\prime \prime }=1$
$p^{\prime \prime }=k-1-p$
才能得到$o^{\prime \prime }==i$
当然，我们也会遇到第四节中讨论的多解问题。
因此同样的，我们也对$i^{\prime \prime }=o\ast s$进行微调，
改为采用$i^{\prime \prime }=(o-1)\ast s+1$，这样总是能得到多个解中的最小值。

这一节有什么意义呢？
我也不知道。
但是第二节中那篇论文的作者很热衷于讨论这个东西。（摊手）

他有一个字面意思上有趣的结论。
我们先约定s=1。
如果p=0，就能得到
$p^{\prime \prime }=k-1$，那个作者称这个$p^{\prime \prime }$为fully-padding。
于是我们可以这样说。

non-padding的direct conv，对应的corresponding direct conv是fully-padding的。

相反地，如果想让$p^{\prime \prime }=0$，就需要$p=k-1$
于是可以说

fully-padding的direct conv，对应的corresponding direct conv是non-padding的。

大概就是这么个用处吧。