美食家大橙子 发表于 2025-4-2 15:05:49

torch.nn.Conv2d介绍——Pytorch中的二维卷积层

  torch.nn.Conv2d是torch.nn模块中的二维卷积层类,用于构建神经网络中的二维卷积层。
1、根本语法

torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros', device=None, dtype=None)
将 2D 卷积应用于由多个输入平面组成的输入信号。
在最简单的环境下,具有 input size                                    (                         N                         ,                                 C                                       i                               n                                          ,                         H                         ,                         W                         )                              (N,C_{in},H,W)                  (N,Cin​,H,W) 和 output                                    (                         N                         ,                                 C                                       o                               u                               t                                          ,                                 H                                       o                               u                               t                                          ,                                 W                                       o                               u                               t                                          )                              (N,C_{out},H_{out},W_{out})                  (N,Cout​,Hout​,Wout​)的层的输出值可以精确描述为:
                                       o                            u                            t                            (                                       N                               i                                    ,                                       C                                           o                                  u                                             t                                     j                                                             )                            =                            b                            i                            a                            s                            (                                       C                                           o                                  u                                             t                                     j                                                             )                            +                                       ∑                                           k                                  =                                  0                                                                   C                                                   i                                        n                                                         −                                  1                                                 w                            e                            i                            g                            h                            t                            (                                       C                                           o                                  u                                             t                                     j                                                             ,                            k                            )                            ∗                            i                            n                            p                            u                            t                            (                                       N                               i                                    ,                            k                            )                                  out(N_i,C_{out_{j}})=bias(C_{out_{j}})+\sum_{k=0}^{C_{in}-1}weight(C_{out_{j}},k)*input(N_{i},k)                     out(Ni​,Coutj​​)=bias(Coutj​​)+k=0∑Cin​−1​weight(Coutj​​,k)∗input(Ni​,k)
此中                                    ⋆                              ⋆                  ⋆ 是有效的 2D 互相关运算符,                                    N                              N                  N是批量大小,                                    C                              C                  C 表现通道数,                                    H                              H                  H是输入平面的高度(以像素为单位),                                    W                              W                  W是宽度(以像素为单位)。
该模块支持 TensorFloat32。


[*]stride 控制互相关的步幅,单个数字或元组。
[*]padding 控制应用于输入的填充量。它可以是一个字符串 {‘valid’, ‘same’} 或一个 int / 一个 int 元组,给出在两侧应用的隐式填充量。
[*]dilation 控制内核点之间的间距;也称为 à trous 算法。这更难描述,但这个链接很好地可视化了 dilation 它的作用。
[*]groups 控制输入和输出之间的毗连。 in_channels ,而且 out_channels 两者都必须能被 groups 整除。比方
在 groups=1 时,所有输入都与所有输出进行卷积。
在 groups=2 时,该作相称于并排有两个 conv 层,每个 conv 层看到一半的 input channels,产生一半的 output channels,然后两个 级联。
[*]在 groups= in_channels 处,每个输入通道都与自己的一组滤波器(大小                                                                o                                  u                                  t                                  _                                  c                                  h                                  a                                  n                                  n                                  e                                  l                                  s                                                      i                                  n                                  _                                  c                                  h                                  a                                  n                                  n                                  e                                  l                                  s                                                 ​                                  \frac{out\_channels}{in\_channels}​                     in_channelsout_channels​​)进行卷积。
参数 kernel_size , stride dilation , padding , 可以是:


[*]一个整数 – 在这种环境下,height 和 width 维度利用雷同的值
[*]两个整数的元组 – 在这种环境下,第一个 int 用于高度维度,第二个 int 用于宽度维度
2、Parameters 参数



[*]in_channels (int) – 输入图像中的通道数
[*]out_channels (int) – 卷积产生的通道数
[*]kernel_size (int or tuple) – 卷积内核的大小
[*]stride (int or tuple, optional) - 卷积的步幅。默认值:1
[*]padding (int, tuple or str, optional) – 添加到输入的所有四个边的填充。默认值:0
[*]dilation (int 或 tuple,可选) – 内核元素之间的间距。默认值:1
[*]groups (int, optional) – 从输入通道到输出通道的壅闭毗连数。默认值:1
[*]bias (bool, optional) – 如果 ,则 True 向输出添加可学习的偏差。默认值: True
[*]padding_mode (str,可选) – ‘zeros’ 、 ‘reflect’ ‘replicate’ 或 ‘circular’ .默认值: ‘zeros’
3、Shape: 形状



[*]输入:                                        (                            N                            ,                                       C                                           i                                  n                                                 ,                                       H                                           i                                  n                                                 ,                                       W                                           i                                  n                                                 )                                  (N,C_{in},H_{in},W_{in})                     (N,Cin​,Hin​,Win​) 或                                        (                                       C                                           i                                  n                                                 ,                                       H                                           i                                  n                                                 ,                                       W                                           i                                  n                                                 )                                  (C_{in},H_{in},W_{in})                     (Cin​,Hin​,Win​)
[*]输出:                                        (                            N                            ,                                       C                                           o                                  u                                  t                                                 ,                                       H                                           o                                  u                                  t                                                 ,                                       W                                           o                                  u                                  t                                                 )                                  (N,C_{out},H_{out},W_{out})                     (N,Cout​,Hout​,Wout​) 或                                        (                                       C                                           o                                  u                                  t                                                 ,                                       H                                           o                                  u                                  t                                                 ,                                       W                                           o                                  u                                  t                                                 )                                  (C_{out},H_{out},W_{out})                     (Cout​,Hout​,Wout​)
此中:
                                                          H                                             o                                     u                                     t                                                      =                               [                                                                      H                                                       i                                           n                                                                +                                     2                                     ×                                     p                                     a                                     d                                     d                                     i                                     n                                     g                                     [                                     0                                     ]                                     −                                     d                                     i                                     l                                     a                                     t                                     i                                     o                                     n                                     [                                     0                                     ]                                     ×                                     (                                     k                                     e                                     r                                     n                                     e                                                   l                                        s                                                i                                     z                                     e                                     [                                     0                                     ]                                     −                                     1                                     )                                     −                                     1                                                         s                                     t                                     r                                     i                                     d                                     e                                     [                                     0                                     ]                                                      +                               1                               ]                                    H_{out}=[\frac{H_{in}+2\times padding-dilation\times (kernel_size-1)-1}{stride}+1]                        Hout​=Hin​+2×padding−dilation×(kernels​ize−1)−1​+1]
                                                          W                                             o                                     u                                     t                                                      =                               [                                                                      W                                                       i                                           n                                                                +                                     2                                     ×                                     p                                     a                                     d                                     d                                     i                                     n                                     g                                     [                                     1                                     ]                                     −                                     d                                     i                                     l                                     a                                     t                                     i                                     o                                     n                                     [                                     1                                     ]                                     ×                                     (                                     k                                     e                                     r                                     n                                     e                                                   k                                        s                                                i                                     z                                     e                                     [                                     1                                     ]                                     −                                     1                                     )                                     −                                     1                                                         s                                     t                                     r                                     i                                     d                                     e                                     [                                     1                                     ]                                                      +                               1                               ]                                    W_{out}=[\frac{W_{in}+2 \times padding-dilation \times (kernek_size-1)-1}{stride}+1]                        Wout​=Win​+2×padding−dilation×(kerneks​ize−1)−1​+1]
4、Variables 变量:



[*]weight (Tensor) :形状为                                        (                            o                            u                            t                            _                            c                            h                            a                            n                            n                            e                            l                            s                            ,                                                   i                                  n                                  _                                  c                                  h                                  a                                  n                                  n                                  e                                  l                                  s                                                      g                                  r                                  o                                  u                                  p                                  s                                                 ,                            k                            e                            r                            n                            e                            l                            _                            s                            i                            z                            e                            [                            0                            ]                            ,                            k                            e                            r                            n                            e                            _                            s                            i                            z                            e                            [                            1                            ]                            )                                  (out\_channels,\frac{in\_channels}{groups} , kernel\_size,kerne\_size)                     (out_channels,groupsin_channels​,kernel_size,kerne_size)的模型的可学习权重。这些权重的值是从                                        u                            (                            (                            −                                       k                                    ,                                       k                                    )                                  u((-\sqrt{k},\sqrt{k})                     u((−k             ​,k             ​)中抽样的,                                        k                            =                                                   g                                  r                                  o                                  u                                  p                                  s                                                                   C                                                   i                                        n                                                         ∗                                                             ∏                                                       i                                           =                                           0                                                      1                                                         k                                  e                                  r                                  n                                  e                                  l                                  _                                  s                                  i                                  z                                  e                                  [                                  i                                  ]                                                       k=\frac{groups}{C_{in}* {\textstyle \prod_{i=0}^{1}}kernel\_size }                     k=Cin​∗∏i=01​kernel_sizegroups​
[*]bias (Tensor) :形状                                       (                            o                            u                            t                            _                            c                            h                            a                            n                            n                            e                            l                            s                            )                                  (out\_channels)                     (out_channels)的模型的可学习偏差。如果 bias 是True 则这些权重的值从                                        u                            (                            (                            −                                       k                                    ,                                       k                                    )                                  u((-\sqrt{k},\sqrt{k})                     u((−k             ​,k             ​)中抽样,                                        k                            =                                                   g                                  r                                  o                                  u                                  p                                  s                                                                   C                                                   i                                        n                                                         ∗                                                             ∏                                                       i                                           =                                           0                                                      1                                                         k                                  e                                  r                                  n                                  e                                  l                                  _                                  s                                  i                                  z                                  e                                  [                                  i                                  ]                                                       k=\frac{groups}{C_{in}* {\textstyle \prod_{i=0}^{1}}kernel\_size }                     k=Cin​∗∏i=01​kernel_sizegroups​
5、例子

# With square kernels and equal stride
m = nn.Conv2d(16, 33, 3, stride=2)
# non-square kernels and unequal stride and with padding
m = nn.Conv2d(16, 33, (3, 5), stride=(2, 1), padding=(4, 2))
# non-square kernels and unequal stride and with padding and dilation
m = nn.Conv2d(16, 33, (3, 5), stride=(2, 1), padding=(4, 2), dilation=(3, 1))
input = torch.randn(20, 16, 50, 100)
output = m(input)

免责声明:如果侵犯了您的权益,请联系站长,我们会及时删除侵权内容,谢谢合作!更多信息从访问主页:qidao123.com:ToB企服之家,中国第一个企服评测及商务社交产业平台。
页: [1]
查看完整版本: torch.nn.Conv2d介绍——Pytorch中的二维卷积层