深度学习-----------------多个输入和输出通道

鼠扑  金牌会员 | 2024-8-13 07:06:52 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题

主题 873|帖子 873|积分 2619

多个输入通道

彩色图像大概有RGB三个通道
转换为灰度会丢失信息。






每个通道都有一个卷积核,结果是所有通道卷积结果的和

输入有2个通道(通道0、通道1),对每一个通道都有一个卷积核。




                                                   c                               i                                            c_i                     ci​是通道,输入是三维的。核也是三维。



多个输出通道

无论有多少输入通道,到现在为止我们只用到单输出通道。
我们可以有多个三维卷积核,每个核生成一个输出通道

                                                   c                               o                                            c_o                     co​其实就是                                                   c                                           o                                  u                                  t                                  p                                  u                                  t                                                       c_{output}                     coutput​,                                                         c                                  i                                                 c_i                        ci​个通道,每个通道                                                         c                                  o                                                 c_o                        co​种卷积核,共有                                                         c                                  i                                                 c_i                        ci​*                                                         c                                  o                                                 c_o                        co​种卷积核。
                                                   c                               i                                            c_i                     ci​:输入通道的(卷积核)层数
                                                    c                               o                                            c_o                     co​:输出通道(卷积核)层数

为了提出不同的特性,两者无相关性。



多个输入和输出通道

每个输出通道可以辨认特定模式

输入通道核辨认并组合输入中的模式。



1×1卷积层

                                                         k                                  h                                                 k_h                        kh​=                                                         k                                  w                                                 k_w                        kw​=1是一个受欢迎的选择。它不辨认空间模式,只是融合通道

通道0和通道1的卷积核

把output对应输入里面的像素,每个不同的通道做加权和。


相称于输入形状为                                                   n                               h                                            n_ h                     nh​                                                   n                               w                                            n_ w                     nw​×                                                   c                               i                                            c_ i                     ci​(把输入拉成一个                                                   n                               h                                            n_ h                     nh​                                                   n                               w                                            n_ w                     nw​向量,列数是                                                   c                               i                                            c_ i                     ci​,整体是一个矩阵),权重为                                                   c                               i                                            c_ i                     ci​×                                                   c                               o                                            c_ o                     co​的全连接层。



二维卷积层


一共有                                                   c                               o                                            c_ o                     co​×                                                   c                               i                                            c_ i                     ci​个卷积核,每个卷积核都有一个毛病。
计算复杂度:
    这么理解:最后输出                                                         m                                  h                                                 m_ h                        mh​×                                                         m                                  w                                                 m_ w                        mw​个点有                                                         c                                  o                                                 c_ o                        co​个通道,这意味着总共有                                                         c                                  o                                                 c_ o                        co​×                                                         m                                  h                                                 m_ h                        mh​×                                                         m                                  w                                                 m_ w                        mw​个输出点,对于每个输出点,它都涉及到与卷积核的乘法操作。卷积核的大小为                                                         k                                  h                                                 k_h                        kh​×                                                         k                                  w                                                 k_w                        kw​,且输入特性图有                                                         c                                  i                                                 c_ i                        ci​个通道,那么对于输出特性图上的每一个点,都需要进行                                                   c                               i                                            c_ i                     ci​×                                                   k                               h                                            k_h                     kh​×                                                   k                               w                                            k_w                     kw​次乘法操作。(因为每个输出点都是输入特性图上对应地区的                                                   c                               i                                            c_i                     ci​个通道与卷积核的乘积之和)。



总结

    ①输入通道数是卷积层的超参数。
    ②每个输入通道都有独立的二维卷积核,所有通道结果相加得到一个输出通道结果。
    ③每个输出通道有独立的三维卷积核。




多输入多输出通道代码实现

多输入单输出通道代码实现

实现一下多输入通道互相关运算
  1. import torch
  2. from d2l import torch as d2l
  3. def corr2d_multi_in(X, K):
  4.     # for使得对最外面通道进行遍历,先遍历“X”和“K”的第0个维度(通道维度)
  5.     # 使用sum 函数来遍历 X 和 K 的通道,并对每个通道对应用 d2l.corr2d 函数进行二维卷积操作,然后将所有通道的结果相加。
  6.     return sum(d2l.corr2d(x, k) for x, k in zip(X, K))
复制代码
验证互相关运算的输出
  1. X = torch.tensor([[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]],
  2.                   [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]])
  3. K = torch.tensor([[[0.0, 1.0], [2.0, 3.0]], [[1.0, 2.0], [3.0, 4.0]]])
  4. print(corr2d_multi_in(X, K))
复制代码
输出:




多输出通道代码实现

计算多个通道的输出的互相关函数
  1. def corr2d_multi_in_out(X, K)
  2. :
  3.     # 迭代“K”的第0个维度(输出通道),每次都对输入“X”执行互相关运算。
  4.     # 最后将所有结果都叠加在一起
  5.     # torch.stack([...], 0) 将上一步生成的列表中的张量沿着一个新的维度(这里是第0维,即批量大小维度)堆叠起来
  6.     return torch.stack([corr2d_multi_in(X, k) for k in K], 0)
复制代码
通过将核张量K与K+1(K中每个元素加1)和K+2连接起来,构造了一个具有3个输出通道的卷积核。
  1. # 要堆叠的张量K、K+1、K+2
  2. # K原来是3D,然后通过stack堆叠成为4D
  3. K = torch.stack((K, K + 1, K + 2), 0)
  4. print(K.shape)
复制代码
输出:输出是3,输入是2,高和宽分别是2(3个卷积核,每个卷积核有两个通道,每个通道是2×2的矩阵)




①为什么原先K形状是torch.Size([2, 2, 2]),厥后变成了torch.Size([3, 2, 2, 2])?
三个堆起来就是最外层3.



②输入为什么是2?
因为X的通道是2
  1. X = torch.tensor([[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]],
  2.                   [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]])
复制代码
显示:




③原先的K、K+1、K+2(左),厥后堆叠的(右)




该部门代码

  1. import torchX = torch.tensor([[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]],
  2.                   [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]])
  3. print(X.shape)K = torch.tensor([[[0.0, 1.0], [2.0, 3.0]], [[1.0, 2.0], [3.0, 4.0]]])print(K.shape) # torch.Size([2, 2, 2]) 两块2行2列print(K)print(K+1)print(K+2)K = torch.stack((K, K + 1, K + 2), 0)print(K)print(K.shape)
复制代码



输入张量X卷积核张量K实行互相关运算。现在的输出包含3个通道,第一个通道的结果与先前输入张量X和多输入单输出通道的结果一致。
  1. corr2d_multi_in_out(X, K)
复制代码
多输入多输出通道总代码

  1. import torch
  2. from d2l import torch as d2l
  3. def corr2d_multi_in(X, K):
  4.     # for使得对最外面通道进行遍历,先遍历“X”和“K”的第0个维度(通道维度)
  5.     # 使用sum 函数来遍历 X 和 K 的通道,并对每个通道对应用 d2l.corr2d 函数进行二维卷积操作,然后将所有通道的结果相加。
  6.     return sum(d2l.corr2d(x, k) for x, k in zip(X, K))
  7. def corr2d_multi_in_out(X, K)
  8. :    # 迭代“K”的第0个维度(输出通道),每次都对输入“X”实行互相关运算。    # 最后将所有结果都叠加在一起    # torch.stack([...], 0) 将上一步生成的列表中的张量沿着一个新的维度(这里是第0维,即批量大小维度)堆叠起来    return torch.stack([corr2d_multi_in(X,k) for k in K],0) # 大k中每个小k是一个3D的Tensor。0表示stack堆叠函数里面在0这个维度堆叠。X = torch.tensor([[[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]],
  9.                   [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]]])
  10. K = torch.tensor([[[0.0, 1.0], [2.0, 3.0]], [[1.0, 2.0], [3.0, 4.0]]])K = torch.stack((K, K + 1, K + 2), 0)print(corr2d_multi_in_out(X, K)
  11. )
复制代码
输出:




多个输入和输出通道用途

    ①每个输出通道可以辨认特定模式
    ②输入通道核辨认并组合输入中的模式




1×1卷积

                                                         k                                  h                                                 k_h                        kh​=                                                         k                                  w                                                 k_w                        kw​=1。它不辨认空间模式,只是融合通道。相称于输入形状为                                                   n                               h                                            n_h                     nh​                                                   n                               w                                            n_w                     nw​×                                                   c                               i                                            c_i                     ci​,权重为                                                   c                               o                                            c_o                     co​×                                                   c                               i                                            c_i                     ci​的全连接层。

下面,我们利用全连接层实现 1×1 卷积。 请注意,我们需要对输入输出的数据形状进行调整
  1. def corr2d_multi_in_out_1x1(X, K):
  2.         # 获取输入X的形状,其中c_i是输入通道数,h是高度,w是宽度  
  3.     c_i, h, w = X.shape
  4.     # 获取卷积核K的形状,其中c_o是输出通道数
  5.     c_o = K.shape[0]
  6.     # 将二维的图像数据(高度和宽度)平铺成一维  
  7.     X = X.reshape((c_i, h * w))
  8.     # # 将卷积核K的形状保持不变,因为对于1x1卷积,卷积核的形状已经是(c_o, c_i)
  9.     K = K.reshape((c_o, c_i))
  10.     # 全连接层中的矩阵乘法
  11.     Y = torch.matmul(K, X)
  12.     # 将矩阵乘法的结果Y的形状从(c_o, h*w)重塑为(c_o, h, w)  
  13.     # 即将一维的输出数据恢复成二维的图像数据(高度和宽度),同时保持输出通道数c_o  
  14.     return Y.reshape((c_o, h, w))
复制代码
当实行 1×1 卷积运算时,上述函数相称于先前实现的互相关函数corr2d_multi_in_out。让我们用一些样本数据来验证这一点。

  1. # (3, 3, 3)第一个3是3个通道数,反面两个3是高和宽X = torch.normal(0, 1, (3, 3, 3))# (2, 3, 1, 1)第一个参数2是输出,第二个参数是输入通道3,反面两个参数是高和宽,kernel数是1×1K = torch.normal(0, 1, (2, 3, 1, 1))Y1 = corr2d_multi_in_out_1x1(X, K)Y2 = corr2d_multi_in_out(X, K)
  2. assert float(torch.abs(Y1 - Y2).sum()) < 1e-6# 意味着1×1的卷积层相称于输入形状为c_i × n_hn_w,权重为c_o × c_i的全连接层
复制代码



该部门总代码

  1. import torch
  2. from d2l import torch as d2l
  3. def corr2d_multi_in(X, K):
  4.     # for使得对最外面通道进行遍历,先遍历“X”和“K”的第0个维度(通道维度)
  5.     # 使用sum 函数来遍历 X 和 K 的通道,并对每个通道对应用 d2l.corr2d 函数进行二维卷积操作,然后将所有通道的结果相加。
  6.     return sum(d2l.corr2d(x, k) for x, k in zip(X, K))
  7. def corr2d_multi_in_out(X, K)
  8. :    # 迭代“K”的第0个维度(输出通道),每次都对输入“X”实行互相关运算。    # 最后将所有结果都叠加在一起    # torch.stack([...], 0) 将上一步生成的列表中的张量沿着一个新的维度(这里是第0维,即批量大小维度)堆叠起来    return torch.stack([corr2d_multi_in(X, k) for k in K], 0)  # 大k中每个小k是一个3D的Tensor。0表示stack堆叠函数里面在0这个维度堆叠。def corr2d_multi_in_out_1x1(X, K):    # 获取输入X的形状,其中c_i是输入通道数,h是高度,w是宽度    c_i, h, w = X.shape    # 获取卷积核K的形状,其中c_o是输出通道数    c_o = K.shape[0]    # 将二维的图像数据(高度和宽度)平铺成一维    X = X.reshape((c_i, h * w))    # # 将卷积核K的形状保持不变,因为对于1x1卷积,卷积核的形状已经是(c_o, c_i)    K = K.reshape((c_o, c_i))    # 全连接层中的矩阵乘法    Y = torch.matmul(K, X)    # 将矩阵乘法的结果Y的形状从(c_o, h*w)重塑为(c_o, h, w)    # 即将一维的输出数据规复成二维的图像数据(高度和宽度),同时保持输出通道数c_o    return Y.reshape((c_o, h, w))# (3, 3, 3)第一个3是3个通道数,反面两个3是高和宽X = torch.normal(0, 1, (3, 3, 3))# (2, 3, 1, 1)第一个参数2是输出,第二个参数是输入通道3,反面两个参数是高和宽,kernel数是1×1K = torch.normal(0, 1, (2, 3, 1, 1))Y1 = corr2d_multi_in_out_1x1(X, K)Y2 = corr2d_multi_in_out(X, K)
  9. print(Y1.shape)print(Y2.shape)print(Y1)print(Y2)assert float(torch.abs(Y1 - Y2).sum()) < 1e-6# 意味着1×1的卷积层相称于输入形状为c_i × n_hn_w,权重为c_o × c_i的全连接层print(float(torch.abs(Y1-Y2).sum()))
复制代码
输出:




问题

①网络越深,Padding 0越多,这里是否会影响性能?
    0不会影响性能。

②⭐每个通道的卷积核都不一样吗?不同通道的卷积核大小必须一样吗?
    每个通道的卷积核是不一样的,因为有多少个输出通道就有多少种卷积核。
    不同通道的卷积核是一样的,(这是因为计算上的利益,假如不一样的话得写成两个卷积操作。)即:不同通道的同一个输出通道的卷积核是一样的。

③计算卷积时,bias的有无,对结果影响大吗?bias的作用怎么解释?
    偏移是有一些用的。但没那么大的影响。
④核的参数是学出来的,不是选出来的。
⑤假如是一个RGB图像,加上深度图,相称于输入是四个通道,做卷积是和RGB三通道同样做法吗?
    不是,这地方先容的二维卷积(只有高宽两个channel),假如加上深度这个维度,就用3D卷积。3D卷积同样有一个输入输出通道。输入就会变成:输入通道×深度×宽×高(4D),核会变成5D的张量,输出同样也是4D.


免责声明:如果侵犯了您的权益,请联系站长,我们会及时删除侵权内容,谢谢合作!更多信息从访问主页:qidao123.com:ToB企服之家,中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

您需要 登录 才可以下载或查看,没有账号?立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览

快速回复

您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

鼠扑

金牌会员
这个人很懒什么都没写!

标签云

快速回复 返回顶部 返回列表