多个输入通道

• 参数图像可能有RGB三个通道
• 转换为灰度会丢失信息
  
• 每一个通道都有一个卷积核，结果是所有通道卷积结果的和
  
• 用公式表达如下：这里$c_i$就是输入的通道数，卷积核的个数应该和输入的通道数一样，不管我们的输入有多少个通道我们的输出都是一个通道
  

多个输出通道

• 无论有多少个输入通道，到目前为止我们只用到单输出通道
• 我们可以有多个三维卷积核，每个核生成一个输出通道。比如：在RGB图片中，我们对每一个输出的通道我们都有一个三维的卷积核，也就是三输出通道
• 公式表达如下，这里的$c_o$就是输出通道的个数
  

多输入和输出通道

• 每个通道可以识别特定的模式。也就是可以认为每一个输出通道可以识别一个特定的模式。
  
• 输入通道核识别并组合输入中的模式。上面通过多输出通道可以识别出不同的模式，然后我们将多个输出给下一个层，然后下一个层将这些模式组合起来。

1 * 1的卷积层

• 1 * 1的卷积层就是融合通道的。也就是说将不同输入通道的对应位置的数据融合到一起。
  

二维卷积层

总结

• 下面第一点，输入通道不是一个超参数，它是前一个的超参数
  

代码演示

# 实现多输入通道互相关运算
import torch
from torch import nn
from d2l import torch as d2l

# 这里的输入是我们的输入x和卷积核K
def corr2d(X, K):
    """算二维互相关运算"""
    h, w = K.shape  # 这里就是拿出卷积核的行和列
    Y = torch.zeros(X.shape[0] -h + 1, X.shape[1] - w + 1)  # 根据上面理论我们可以得到我们输出的矩阵的大小，也就是输入矩阵的行减去卷积核的行+1，列同理
    # 下面的两个for循环的作用是给，输出矩阵的每个元素赋值，这里就是拿卷积核和对应的区的元素做乘法运算
    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):
    return sum(corr2d(x, k) for x, k in zip(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]]])

corr2d_multi_in(X, K)

tensor([[ 56.,  72.],
        [104., 120.]])

# 计算多个通道的输出的互相关函数
def corr2d_multi_in_out(X, K):
    # 这里stack的作用是在0这个维度上将我们得到的输出一个一个堆起来
    return torch.stack([corr2d_multi_in(X, k) for k in K], 0)  # 这里的输入X是一个3D的张量，这里是对每一个输出通道的K拿出一个k，这里k是一个3D的Tensor

# 这里就是相当于增加一个维度，然后每一个K或者K+1或者K+2都是该维度的一个元素
K = torch.stack((K, K + 1, K + 2), 0)
K.shape

torch.Size([3, 2, 2, 2])

corr2d_multi_in_out(X, K)

tensor([[[ 56.,  72.],
         [104., 120.]],

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

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

# 1 * 1卷积
def corr2d_muti_in_out_1x1(X, K):
    c_i, h, w = X.shape  # 这里我们拿到了输出的channel数，和每个channel的高和宽
    c_o = K.shape[0]  # 这里我们拿到了输出通道的数量
    X = X.reshape((c_i, h * w))  # 将输入转换为一个二维矩阵，他的行数是输入通道的channel数，列数是每个channel的高乘宽
    K = K.reshape((c_o, c_i))  # 这里我们将卷积核K转换为一个二维矩阵，他的行数是输出通道的个数，列数是输入通道的channel数
    Y = torch.matmul(K, X)  # 将刚刚得到的卷积核和输入做矩阵乘法运算得到输出，这里得到的是一个行数位c_i，列数位h*w的矩阵
    return Y.reshape((c_o, h, w))  # 将刚刚得到的矩阵还原

X = torch.normal(0, 1, (3, 3, 3))  # 输入的X是一个3*3*3的张量
K = torch.normal(0, 1, (2, 3, 1, 1))  # 这里是一个输入通道是3，输出通道到是2，kernel是1*1
Y1 = corr2d_muti_in_out_1x1(X, K)
Y2 = corr2d_multi_in_out(X, K)
assert float(torch.abs(Y1 -Y2).sum()) < 1e-6

# 使用PyTorch来实现上述操作
conv2d = nn.Conv2d(1, 1, kernel_size=3, padding=1, stride=2)  # 参数1：用来指定输入通道，参数2：用来指定输出通道