动手学深度学习（Pytorch版）代码实践 -卷积神经网络-21多输入多输出通道

21多输入多输出通道

import torch
from d2l import torch as d2l

def corr2d(X, K):
    """计算二维互相关运算"""
    h, w = K.shape
    Y = torch.zeros((X.shape[0] - h + 1, X.shape[1] - w + 1))
    for i in range(Y.shape[0]):
        for j in range(Y.shape[1]):
            Y[i, j] = (X[i:i + h, j:j + w] * K).sum()
    return Y

# 多输入通道互相关运算
def corr2d_multi_in(X, K):
     #对于每对输入通道 x 和滤波器 k，调用 corr2d 函数，并将所有结果相加。
     return sum(corr2d(x, k) for x, k in zip(X, K))
    #zip(X, K) 会生成一个元组迭代器，其中每个元组包含 X 和 K 中的对应元素

# X 是一个具有两个输入通道的张量，K 是一个具有两个通道的滤波器。
X = torch.tensor([[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]],
               [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]])
K = torch.tensor([[[0.0, 1.0], [2.0, 3.0]], [[1.0, 2.0], [3.0, 4.0]]])

print(corr2d_multi_in(X, K))
"""
tensor([[ 56.,  72.],
        [104., 120.]])
"""

# 多输出通道
def corr2d_multi_in_out(X, K):
    #对于每个输出通道的滤波器 k，调用 corr2d_multi_in 函数，并将所有结果堆叠在一起形成新的张量。
    return torch.stack([corr2d_multi_in(X, k) for k in K], 0)

# 将 K 扩展为一个具有三个输出通道的新滤波器
# K,K中每个元素加1,K中每个元素加2
K = torch.stack((K, K + 1, K + 2), 0)
print(K.shape)
#torch.Size([3, 2, 2, 2])
#具有3个输出通道、每个输出通道有2个输入通道的2x2滤波器的卷积核集合。
"""
第0维：新维度插入到最前面，堆叠的张量沿着第0维度排列。torch.Size([3, 2, 2, 2])
第1维：新维度插入到第二个位置，堆叠的张量沿着第1维度排列。torch.Size([2, 3, 2, 2])
第2维：新维度插入到第三个位置，堆叠的张量沿着第2维度排列。torch.Size([2, 2, 3, 2])
"""

print(corr2d_multi_in_out(X, K))
"""
tensor([[[ 56.,  72.],
         [104., 120.]],

        [[ 76., 100.],
         [148., 172.]],

        [[ 96., 128.],
         [192., 224.]]])
"""

# 1 * 1 卷积核
#可以将卷积层看作在每个像素位置应用的全连接层
#以c_i个输入值转换为c_o个输出值
def corr2d_multi_in_out_1x1(X, K):
    c_i, h, w = X.shape #获取输入张量 X 的通道数、高度和宽度。
    c_o = K.shape[0] #获取卷积核 K 的输出通道数。
    X = X.reshape((c_i, h * w)) # 3 * 9
    K = K.reshape((c_o, c_i)) # 2 * 3

    Y = torch.matmul(K, X)
    return Y.reshape((c_o, h, w)) # 2 * 3 * 3

X = torch.normal(0, 1, (3, 3, 3))

#表示具有2个输出通道，每个通道对应3个输入通道 1x1的滤波器
K = torch.normal(0, 1, (2, 3, 1, 1))
Y1 = corr2d_multi_in_out_1x1(X, K)
Y2 = corr2d_multi_in_out(X, K)
assert float(torch.abs(Y1 - Y2).sum()) < 1e-6
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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77