1. 转置卷积
转置卷积通俗讲解
先记住一句话：普通卷积把图片变小；转置卷积（也叫反卷积）把图片变大，它不是普通卷积求逆，只是把输出尺寸还原回去。
1. 普通卷积可以等价变成矩阵乘法
- \(Y=X \star W\)：X是输入图片，W是卷积核，普通卷积做完，图片高宽会缩小：\((h,w)\rightarrow(h',w')\)。
- 我们可以把图片X拉成一长条向量\(X'\)，输出图片Y也拉成长条向量\(Y'\)。
- 然后构造一个大矩阵V，卷积操作完全等价做矩阵乘法：\(Y'=V X'\)。
简单说：卷积不用滑动窗口，直接乘大矩阵 V，也能得到一模一样的结果。 假设：输入向量\(X'\)长度是n，输出向量\(Y'\)长度是m，那矩阵V的形状就是 \(\boldsymbol{m \times n}\)。 输入 n 个元素，输出 m 个元素，\(m<n\)，所以输出图片尺寸变小。
2. 什么是转置 \(V^T\)
矩阵V是\(m\times n\)，它的转置\(V^T\)就是把行和列互换，变成 \(\boldsymbol{n\times m}\)。
- 原来矩阵 V：n 个输入 → m 个输出（n 大 m 小，图片缩小）
- 转置后的矩阵\(V^T\)：m 个输入 → n 个输出（m 小 n 大，图片放大！）
于是就有：转置卷积等价 \(Y'=V^T X'\)
3. 尺寸关系（最核心）
- 普通卷积：输入图片尺寸\((h,w)\) → 输出\((h',w')\)，图片变小
- 同样的卷积核、同样 padding、步长这些超参数，换成转置卷积：输入\((h',w')\) → 输出变回\((h,w)\)，图片被放大回去。
⚠️重要误区：
❗转置卷积不能复原原始像素数值 ！只是把图片高宽尺寸还原，不是数学上把图片完完全全变回去。 不是普通卷积的逆运算，只是借用矩阵 V 的转置，实现放大图片。
举个生活化小例子
想象普通卷积：一张大照片，经过卷积，压缩成一张小缩略图。 这个压缩过程，可以写成矩阵 V 乘法。
转置卷积就是拿这个 V 做转置，拿小缩略图作为输入，输出一张大尺寸图片。
注意：输出的大图不是原来那张原图，只是尺寸和原图一样大，像素是网络重新算出来的，常用于 GAN、Unet 分割网络里，把小特征图放大。
对应图里的 n、m
- V：\(m \times n\)，普通卷积：输入向量长度 n，输出 m，\(m<n\)，图变小
- \(V^T\)：\(n \times m\)，转置卷积：输入向量长度 m，输出 n，(n>m)，图变大
一句话总结
普通卷积 = 矩阵 V，图片缩小； 转置卷积 = 矩阵 V 的转置V^T，用一样的超参数，把特征图尺寸再放大回去。
2. 转置卷积
python
import torch
from torch import nn
from d2l import torch as d2l
python
# 实现基本的转置卷积运算
# 定义转置卷积运算
def trans_conv(X, K):
# 获取卷积核的宽度和高度
h, w = K.shape # 卷积核的宽、高
# 创建一个新的张量Y，其尺寸为输入X的尺寸加上卷积核K的尺寸减去1。在常规卷积中，输出尺寸通常是输入尺寸减去卷积核尺寸加1
Y = torch.zeros((X.shape[0] + h -1, X.shape[1] + w - 1)) # 正常的卷积后尺寸为(X.shape[0] - h + 1, X.shape[1] - w + 1)
# 遍历输入张量X的每一行
for i in range(X.shape[0]):
# 遍历输入张量X的每一列
for j in range(X.shape[1]):
# 对于输入X的每一个元素，我们将其与卷积核K进行元素级别的乘法，然后将结果加到输出张量Y的相应位置上
Y[i:i + h, j:j + w] += X[i, j] * K # 按元素乘法，加回到自己矩阵
# 返回转置卷积的结果
return Y
python
# 验证上述实现输出
# 定义输入张量X，这是一个2x2的矩阵
X = torch.tensor([[0.0,1.0],[2.0,3.0]])
# 定义卷积核K，也是一个2x2的矩阵
K = torch.tensor([[0.0,1.0],[2.0,3.0]])
# 调用上面定义的trans_conv函数，对输入张量X和卷积核K进行转置卷积操作，并打印结果
trans_conv(X,K)tensor([[ 0., 0., 1.],
[ 0., 4., 6.],
[ 4., 12., 9.]])
python
# 使用高级API获得相同的结果
# 将输入张量X和卷积核K进行形状变换，原来是2x2的二维张量，现在变成了1x1x2x2的四维张量
# 第一个1表示批量大小，第二个1表示通道数，2x2是卷积核的高和宽
X, K = X.reshape(1,1,2,2), K.reshape(1,1,2,2)
# 创建一个转置卷积层对象tconv，其中输入通道数为1，输出通道数为1，卷积核的大小为2，没有偏置项
tconv = nn.ConvTranspose2d(1,1,kernel_size=2,bias=False) # 输入通道数为1，输出通道数为1
# 将创建的转置卷积层对象tconv的权重设置为我们的卷积核K
tconv.weight.data = K
# 使用创建的转置卷积层tconv对输入张量X进行转置卷积操作，并返回结果
tconv(X)tensor([[[[ 0., 0., 1.],
[ 0., 4., 6.],
[ 4., 12., 9.]]]], grad_fn=<SlowConvTranspose2DBackward0>)
python
# 填充、步幅和多通道
# 填充在输出上，padding=1，之前输出3x3，现在上下左右都填充了1，那就剩下中心那个元素了
# 填充为1，就是把输出最外面的一圈当作填充
# 创建一个转置卷积层对象tconv，其中输入通道数为1，输出通道数为1，卷积核的大小为2，没有偏置项，同时设置填充大小为1
# 填充(padding)操作在输出上执行，原本输出为3x3，由于填充了大小为1的边框，结果就只剩下中心的元素
# 所以填充大小为1就相当于将输出矩阵最外面的一圈当作填充并剔除
tconv = nn.ConvTranspose2d(1,1,kernel_size=2,padding=1,bias=False)
# 将创建的转置卷积层对象tconv的权重设置为我们的卷积核K
tconv.weight.data = K
# 使用创建的转置卷积层tconv对输入张量X进行转置卷积操作，并返回结果
tconv(X)tensor([[[[4.]]]], grad_fn=<SlowConvTranspose2DBackward0>)
python
# 创建一个转置卷积层对象tconv，其中输入通道数为1，输出通道数为1，卷积核的大小为2，步幅(stride)为2，没有偏置项
# 步幅为2表示在进行卷积时，每次移动2个单位，相较于步幅为1，这样会使得输出尺寸增大
tconv = nn.ConvTranspose2d(1,1,kernel_size=2,stride=2,bias=False)
# 将创建的转置卷积层对象tconv的权重设置为我们的卷积核K
tconv.weight.data = K
# 使用创建的转置卷积层tconv对输入张量X进行转置卷积操作，并返回结果
tconv(X)tensor([[[[0., 0., 0., 1.],
[0., 0., 2., 3.],
[0., 2., 0., 3.],
[4., 6., 6., 9.]]]], grad_fn=<SlowConvTranspose2DBackward0>)
python
# 多通道
# 创建一个四维张量X，批量大小为1，通道数为10，高和宽都为16
X = torch.rand(size=(1,10,16,16))
# 创建一个二维卷积层对象conv，其中输入通道数为10，输出通道数为20，卷积核大小为5，填充为2，步幅为3
# 这会将输入的10个通道的图像转换为20个通道的特征图
conv = nn.Conv2d(10,20,kernel_size=5,padding=2,stride=3)
# 创建一个转置卷积层对象tconv，其中输入通道数为20，输出通道数为10，卷积核大小为5，填充为2，步幅为3
# 这会将输入的20个通道的特征图转换回10个通道的图像
tconv = nn.ConvTranspose2d(20,10,kernel_size=5,padding=2,stride=3)
# 首先对输入张量X进行卷积操作，然后再对卷积的结果进行转置卷积操作
# 然后检查这个结果的形状是否和原始输入张量X的形状相同
# 如果相同，说明转置卷积操作成功地还原了原始输入的形状
tconv(conv(X)).shape == X.shapeTrue
python
# 与矩阵变换的联系
# 创建一个一维张量，其中包含从0.0到8.0的连续数字
# 然后将这个一维张量重塑为3x3的二维张量
X = torch.arange(9.0).reshape(3,3)
# 创建一个2x2的卷积核K，其中包含四个元素：1.0，2.0，3.0，4.0
K = torch.tensor([[1.0,2.0],[3.0,4.0]])
# 使用自定义的二维卷积函数corr2d对输入张量X和卷积核K进行卷积操作
# corr2d函数需要在引入d2l（深度学习库）之后才能使用
Y = d2l.corr2d(X,K) # 卷积
# 打印卷积操作的结果
Ytensor([[27., 37.],
[57., 67.]])
python
# 定义一个函数kernel2matrix，用于将给定的卷积核K转换为一个稀疏矩阵W
def kernel2matrix(K):
# 创建长度为5的零向量k和4x9的零矩阵W
k, W = torch.zeros(5), torch.zeros((4,9))
# 打印初始状态的k
print(k)
# 打印初始状态的W
print(W)
# 打印输入的卷积核K
print(K)
# 将卷积核K的元素填充到向量k中的适当位置，形成一个稀疏向量
k[:2], k[3:5] = K[0, :], K[1,:]
# 打印填充后的向量k
print(k)
# 将稀疏向量k填充到矩阵W中的适当位置，形成一个稀疏矩阵
W[0,:5], W[1,1:6], W[2,3:8], W[3,4:] = k, k, k, k
# 返回转换后的稀疏矩阵W
return Wtensor([0., 0., 0., 0., 0.])
python
# 每一行向量表示在一个位置的卷积操作，0填充表示卷积核未覆盖到的区域。
# 输入大小为 3 * 3 的图片，拉长一维向量后变成 1 * 9 的向量
# 输入大小为 3 * 3 的图片，卷积核为 2 * 2，则输出图片为 2 * 2，拉长后变为 4 * 1 的向量
# kernel2matrix函数将卷积核改为稀疏矩阵C后矩阵情况
# 使用kernel2matrix函数将卷积核K转换为一个稀疏矩阵W
# 这个矩阵的每一行表示在一个特定位置进行的卷积操作，其中的0表示卷积核没有覆盖的区域
# 如果输入是一个3x3的图像，并被拉平为一个1x9的向量
# 而卷积核是2x2的，那么输出图像的大小为2x2，拉平后变为一个4x1的向量
# kernel2matrix函数实际上就是在构建这种转换关系
W = kernel2matrix(K)
Wtensor([[0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0.],
[0., 0., 0., 0., 0., 0., 0., 0., 0.]])
tensor([[1., 2.],
[3., 4.]])
tensor([1., 2., 0., 3., 4.])tensor([[1., 2., 0., 3., 4., 0., 0., 0., 0.],
[0., 1., 2., 0., 3., 4., 0., 0., 0.],
[0., 0., 0., 1., 2., 0., 3., 4., 0.],
[0., 0., 0., 0., 1., 2., 0., 3., 4.]])
python
# 打印输入张量X的内容
print(X)
# 使用reshape函数将输入张量X拉平为一个一维向量，并打印结果
# 这是为了将X与稀疏矩阵W进行矩阵乘法操作
print(X.reshape(-1))
# 判断卷积操作的结果Y是否等于稀疏矩阵W与拉平的输入张量X的矩阵乘法的结果，并将结果重塑为2x2的形状
# 这是一种检查卷积操作是否等价于某种矩阵变换的方式
Y == torch.matmul(W, X.reshape(-1)).reshape(2,2)tensor([[0., 1., 2.],
[3., 4., 5.],
[6., 7., 8.]])
tensor([0., 1., 2., 3., 4., 5., 6., 7., 8.])tensor([[True, True],
[True, True]])
python
# 使用自定义的转置卷积函数trans_conv对卷积操作的结果Y和卷积核K进行转置卷积操作
Z = trans_conv(Y, K)
# 判断转置卷积操作的结果Z是否等于稀疏矩阵W的转置与拉平的卷积结果Y的矩阵乘法的结果，并将结果重塑为3x3的形状
# 这是一种检查转置卷积操作是否等价于某种特定的矩阵变换的方式
# 注意这里得到的结果并不是原图像，尽管它们的尺寸是一样的
Z == torch.matmul(W.T, Y.reshape(-1)).reshape(3,3) # 由卷积后的图像乘以转置卷积后，得到的并不是原图像，而是尺寸一样 tensor([[True, True, True],
[True, True, True],
[True, True, True]])1. 转置卷积是一种卷积
