【CNN】卷积神经网络多通道卷积与偏置过程- part2

多通道卷积的核心思想是：对每个通道分别进行卷积，然后把结果加起来。

以彩色图像为例，包含三个通道，分别表示RGB三原色的像素值，输入为（3,5,5），分别表示3个通道，每个通道的宽为5，高为5。假设卷积核只有1个，卷积核通道为3，每个通道的卷积核大小仍为3x3，padding=0，stride=1。

卷积过程如下，每一个通道的像素值与对应的卷积核通道的数值进行卷积，因此每一个通道会对应一个输出卷积结果，三个卷积结果对应位置累加求和，得到最终的卷积结果（这里卷积输出结果通道只有1个，因为卷积核只有1个。卷积多输出通道下面会继续讲到）。

可以这么理解：最终得到的卷积结果是原始图像各个通道上的综合信息结果。

上述过程中，每一个卷积核的通道数量，必须要求与输入通道数量一致，因为要对每一个通道的像素值要进行卷积运算，所以每一个卷积核的通道数量必须要与输入通道数量保持一致。

我们把上述图像通道如果放在一块，计算原理过程还是与上面一样，堆叠后的表示如下：

2.单卷积核多通道

我们来看下面的单卷积核多通道卷积的演变过程。

复制代码

import torch
import torch.nn as nn
import numpy as np

matrix_np = np.array([[[[0,1,1],
                       [0,0,1],
                       [0,0,0]],
                       [[0,0,1],
                        [1,0,1],
                        [0,0,0]],
                        [[1,0,1],
                         [1,1,1],
                         [1,0,0]]
                         ]])    

kernel = torch.tensor([
    [
        [1,0],
        [0,0]
    ]
    ,
    [
        [0,1],
        [0,0]
    ]
    ,
    [
        [0,0],
        [1,0]
    ]
], dtype=torch.float32)  

matrix_np = np.array(matrix_np).astype(np.float32)

conv_layer = nn.Conv2d(in_channels=3, out_channels=1, kernel_size=2, stride=1, padding=0,bias=False)

conv_layer.weight.data = kernel.view(1,3,2,2)

output_data = conv_layer(input_data)

print(output_data.shape)
print(torch.round(output_data))

3.多卷积核多通道

复制代码

import torch
import torch.nn as nn
import numpy as np

# 创建一个大小为 28*28 的单通道图像
# input_data = torch.randn(1, 3, 3, 3)  # 一个大小为28x28的单通道图像

# 创建一个 NumPy 数组

matrix_np = np.array([[[[0.0, 1.0, 1.0],
                        [0.0, 0.0, 1.0],
                        [0.0, 0.0, 0.0]]
                          ,
                       [[0.0, 0.0, 1.0],
                        [1.0, 0.0, 1.0],
                        [0.0, 0.0, 0.0]]
                          ,
                       [[1.0, 0.0, 1.0],
                        [1.0, 1.0, 1.0],
                        [1.0, 0.0, 0.0]]
                       ]])

kernel = torch.tensor([
    [
        [
            [1., 0.],
            [0., 0.]
        ]
        ,
        [
            [0., 1.],
            [0., 0.]
        ]
        ,
        [
            [0., 0.],
            [1., 0.]
        ]
    ],
    [
        [
            [1., 0.],
            [0., 0.]
        ]
        ,
        [
            [1., 0.],
            [0., 0.]
        ]
        ,
        [
            [1., 0.],
            [0., 0.]
        ]
    ]

], dtype=torch.float32)

matrix_np = np.array(matrix_np).astype(np.float32)
# 转换为 PyTorch 张量
input_data = torch.from_numpy(matrix_np)

print(input_data)

# 创建卷积层，输入通道数为 3
# 输出通道数1
# 步长默认是1
# 卷积核大小2*2
# 0个0填充
# 默认没有偏置项 bias=False
conv_layer = nn.Conv2d(in_channels=3, out_channels=2, stride=1, kernel_size=2, padding=0, bias=True)
# conv_layer = nn.Conv2d(in_channels=3, out_channels=2, stride=1, kernel_size=2, padding=0, bias=True)

# 手动设置卷积核权重（权重形状：[out_channels, in_channels, height, width]）
conv_layer.weight.data = kernel.view(2, 3, 2, 2)

# 手动设置卷积核偏置项（偏置项形状：[out_channels]）
# conv_layer.bias.data.fill_(-1.0)
# 对输入数据进行卷积操作
output_data = conv_layer(input_data)

# 输出结果
print(output_data.shape)
print(torch.round(output_data))