• 常见的几种填充方式：ZeroPad2d/ReflectionPad2d...（Pytorch）

    填充方式

    一、ZeroPad2d：全零填充

    在搭建神经网络时，通常为了保证卷积操作前后的特征大小保持不变，会使用全零填充的方式进行卷积层padding参数的设置。此处，ZeroPad2d作为独立的网络层来调用，二者填充原理一致。

    1）调用方式

    • 通过在输入特征的左、右、上、下四个边界添加足够的零来完成填充；
    • padding参数的设置决定边界处填充零的数量，可设置为整数或者4元组；
    • padding为整数表示输入的左、右、上、下填充相同数量的零， padding为4元组表示输入的左、右、上、下按元组的元素顺序填充指定数量的零；
    • 输入形状为：(N,C,H_in,W_in)或(C,H_in,W_in)；
    • 输出形状为：(N,C,H_out,W_out)或(C,H_out,W_out)；其中H_out=H_in+pad_top+pad_bottom；W_out=W_in+pad_left+pad_right；
    torch.nn.ZeroPad2d(padding)

    • 1

    2）实例

    注意：无论padding为整数还是元组，实际填充是严格按照左、右、上、下顺序执行；
    （1）padding为整数：此时在输入的所有边界均填充相同大小的零。

    inp=torch.tensor([[[[8., 3., 6., 2., 7.],
          [0., 8., 4., 9., 3.]],

         [[3., 9., 6., 2., 7.],
          [7., 8., 4., 6., 2.]],

         [[1., 9., 0., 1., 4.],
          [7., 8., 1., 0., 3.]]]])
# print(inp.shape)  # torch.Size([1, 3, 2, 5])
# print("inp:",inp)
pad=1
out=nn.ZeroPad2d(padding=pad)(inp)
print("padding={},out:".format(pad),out)
print(out.shape)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    结果分析：

    padding=1,out: tensor([[[[0., 0., 0., 0., 0., 0., 0.],
          [0., 8., 3., 6., 2., 7., 0.],
          [0., 0., 8., 4., 9., 3., 0.],
          [0., 0., 0., 0., 0., 0., 0.]],

         [[0., 0., 0., 0., 0., 0., 0.],
          [0., 3., 9., 6., 2., 7., 0.],
          [0., 7., 8., 4., 6., 2., 0.],
          [0., 0., 0., 0., 0., 0., 0.]],

         [[0., 0., 0., 0., 0., 0., 0.],
          [0., 1., 9., 0., 1., 4., 0.],
          [0., 7., 8., 1., 0., 3., 0.],
          [0., 0., 0., 0., 0., 0., 0.]]]])
torch.Size([1, 3, 4, 7])

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    操作在H，W边界上进行，按照左、右、上、下顺序（①->②->③->④）依次填充提前设置的padding大小的零。比如此处设置padding为1，则表示需在输入特征的左右边界分别填充1列零，上下边界分别填充一行零。可看到在输入中H_in=2,W_in=5，而输出中为H_out=2+1+1=4,W_out=5+1+1=7。
    在这里插入图片描述

    （2）padding为4元组：padding=(pad_left,pad_right,pad_top,pad_bottom)，此时在输入的边界填充padding指定大小的零。

    inp=torch.tensor([[[[8., 3., 6., 2., 7.],
          [0., 8., 4., 9., 3.]],

         [[3., 9., 6., 2., 7.],
          [7., 8., 4., 6., 2.]],

         [[1., 9., 0., 1., 4.],
          [7., 8., 1., 0., 3.]]]])
# print(inp.shape)  # torch.Size([1, 3, 2, 5])
# print("inp:",inp)
pad=(2,2,1,1)
out=nn.ZeroPad2d(padding=pad)(inp)
print("padding={},out:".format(pad),out)
print(out.shape)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    结果分析：

    padding=(2, 2, 1, 1),out: tensor([[[[0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 8., 3., 6., 2., 7., 0., 0.],
          [0., 0., 0., 8., 4., 9., 3., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.]],

         [[0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 3., 9., 6., 2., 7., 0., 0.],
          [0., 0., 7., 8., 4., 6., 2., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.]],

         [[0., 0., 0., 0., 0., 0., 0., 0., 0.],
          [0., 0., 1., 9., 0., 1., 4., 0., 0.],
          [0., 0., 7., 8., 1., 0., 3., 0., 0.],
          [0., 0., 0., 0., 0., 0., 0., 0., 0.]]]])
torch.Size([1, 3, 4, 9])

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    操作在H，W边界上进行，按照左、右、上、下顺序（①->②->③->④）依次填充提前设置的padding大小的零。比如此处设置padding为(2, 2, 1, 1)，则表示需在输入特征的左右边界分别填充两列零，上下边界分别填充一行零。可看到在输入中H_in=2,W_in=5，而输出中为H_out=2+1+1=4,W_out=5+2+2=9。
    在这里插入图片描述

    二、ReflectionPad1d/ReflectionPad2d：反射填充

    详见：https://blog.csdn.net/qq_43665602/article/details/126593617

    三、ConstantPad1d/ConstantPad2d：常量填充

    1.ConstantPad1d

    可按照全零填充的方法去理解，只不过此时用来填充的数字变成自定义常量，而不是0。

    1）调用方式

    1. 使用常量值填充输入向量的边界（左、右边界）；
    2. padding可设为整数或者2元组；
    3. value为设定用来填充的常量；
    4. 输入形状：(N,C,W_in)或(C,W_in)；
    5. 输出形状：(N,C,W_out)或(C,W_out)；其中W_out=W_in+pad_left+pad_right；
    torch.nn.ConstantPad1d(padding, value)

    • 1

    2）实例

    （1）padding为整数

    inp=torch.randint(10,size=(2,5))
print(inp.shape) 
print("inp:",inp)
pad=1
value=10
out=nn.ConstantPad1d(padding=pad,value=value)(inp)
print("padding={},out:".format(pad),out)
print(out.shape)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    结果分析：
    可看到此时，该函数分别在输入向量左右两边填充了1列10。

    torch.Size([2, 5])
inp: tensor([[5, 5, 6, 6, 1],
        [8, 3, 2, 3, 1]])
padding=1,out: tensor([[10,  5,  5,  6,  6,  1, 10],
        [10,  8,  3,  2,  3,  1, 10]])
torch.Size([2, 7])

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    （2）padding为2元组:padding=(pad_left,pad_right)

    inp=torch.tensor([[5, 5, 6, 6, 1],
        [8, 3, 2, 3, 1]])
# print(inp.shape)
# print("inp:",inp)
pad=(1,2)
value=10
out=nn.ConstantPad1d(padding=pad,value=value)(inp)
print("padding={},out:".format(pad),out)
print(out.shape)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9

    结果分析：
    可看到此时，该函数分别在输入向量左右两边填充了1、2列10.

    padding=(1, 2),out: tensor([[10,  5,  5,  6,  6,  1, 10, 10],
        [10,  8,  3,  2,  3,  1, 10, 10]])
torch.Size([2, 8])

    • 1
    • 2
    • 3

    2.ConstantPad2d

    使用常量填充向量边界的方法与全零填充相比，区别在于：二维全零填充是使用0填充，而二维常量填充是使用自定义的value值进行填充。当value=0时，常量填充与全零填充等价。

    1）调用方式

    1. 使用常量值填充输入向量的边界（左、右、上、下边界）；
    2. padding可设为整数或者4元组；
    3. value为设定用来填充的常量；
    4. 输入形状：(N,C,H_in,W_in)或(C,H_in,W_in)；
    5. 输出形状：(N,C,H_out,W_out)或(C,H_out,W_out)；其中H_out=H_in+pad_top+pad_bottom；W_out=W_in+pad_left+pad_right；
    torch.nn.ConstantPad2d(padding, value)

    • 1

    2）实例

    （1）padding为整数

    inp=torch.tensor([[[[8., 3., 6., 2., 7.],
          [0., 8., 4., 9., 3.]],

         [[3., 9., 6., 2., 7.],
          [7., 8., 4., 6., 2.]],

         [[1., 9., 0., 1., 4.],
          [7., 8., 1., 0., 3.]]]])
# print(inp.shape)  # torch.Size([1, 3, 2, 5])
# print("inp:",inp)
pad=1
value=10
out=nn.ConstantPad2d(padding=pad,value=value)(inp)
print("padding={},out:".format(pad),out)
print(out.shape)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    结果分析：
    当padding为整数时，输入按照左右上下的顺序，依次对向量使用自定义value值进行padding大小的填充。

    padding=1,out: tensor([[[[10., 10., 10., 10., 10., 10., 10.],
          [10.,  8.,  3.,  6.,  2.,  7., 10.],
          [10.,  0.,  8.,  4.,  9.,  3., 10.],
          [10., 10., 10., 10., 10., 10., 10.]],

         [[10., 10., 10., 10., 10., 10., 10.],
          [10.,  3.,  9.,  6.,  2.,  7., 10.],
          [10.,  7.,  8.,  4.,  6.,  2., 10.],
          [10., 10., 10., 10., 10., 10., 10.]],

         [[10., 10., 10., 10., 10., 10., 10.],
          [10.,  1.,  9.,  0.,  1.,  4., 10.],
          [10.,  7.,  8.,  1.,  0.,  3., 10.],
          [10., 10., 10., 10., 10., 10., 10.]]]])
torch.Size([1, 3, 4, 7])

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    （2）padding为4元组：padding=(pad_left,pad_right,pad_top,pad_bottom)

    inp=torch.tensor([[[[8., 3., 6., 2., 7.],
          [0., 8., 4., 9., 3.]],

         [[3., 9., 6., 2., 7.],
          [7., 8., 4., 6., 2.]],

         [[1., 9., 0., 1., 4.],
          [7., 8., 1., 0., 3.]]]])
# print(inp.shape)  # torch.Size([1, 3, 2, 5])
# print("inp:",inp)
pad=(1,2,3,4)
value=10
out=nn.ConstantPad2d(padding=pad,value=value)(inp)
print("padding={},out:".format(pad),out)
print(out.shape)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    结果分析：
    当padding为4元组时，输入按照左右上下的顺序，依次对向量使用自定义value值进行填充。

    padding=(1, 2, 3, 4),out: tensor([[[[10., 10., 10., 10., 10., 10., 10., 10.],
          [10., 10., 10., 10., 10., 10., 10., 10.],
          [10., 10., 10., 10., 10., 10., 10., 10.],
          [10.,  8.,  3.,  6.,  2.,  7., 10., 10.],
          [10.,  0.,  8.,  4.,  9.,  3., 10., 10.],
          [10., 10., 10., 10., 10., 10., 10., 10.],
          [10., 10., 10., 10., 10., 10., 10., 10.],
          [10., 10., 10., 10., 10., 10., 10., 10.],
          [10., 10., 10., 10., 10., 10., 10., 10.]],

         [[10., 10., 10., 10., 10., 10., 10., 10.],
          [10., 10., 10., 10., 10., 10., 10., 10.],
          [10., 10., 10., 10., 10., 10., 10., 10.],
          [10.,  3.,  9.,  6.,  2.,  7., 10., 10.],
          [10.,  7.,  8.,  4.,  6.,  2., 10., 10.],
          [10., 10., 10., 10., 10., 10., 10., 10.],
          [10., 10., 10., 10., 10., 10., 10., 10.],
          [10., 10., 10., 10., 10., 10., 10., 10.],
          [10., 10., 10., 10., 10., 10., 10., 10.]],

         [[10., 10., 10., 10., 10., 10., 10., 10.],
          [10., 10., 10., 10., 10., 10., 10., 10.],
          [10., 10., 10., 10., 10., 10., 10., 10.],
          [10.,  1.,  9.,  0.,  1.,  4., 10., 10.],
          [10.,  7.,  8.,  1.,  0.,  3., 10., 10.],
          [10., 10., 10., 10., 10., 10., 10., 10.],
          [10., 10., 10., 10., 10., 10., 10., 10.],
          [10., 10., 10., 10., 10., 10., 10., 10.],
          [10., 10., 10., 10., 10., 10., 10., 10.]]]])
torch.Size([1, 3, 9, 8])

    • 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

    四、ReplicationPad1d/ReplicationPad2d：复制填充

    复制填充的方式，根据设定的padding，分别对输入向量的边界进行复制，并填充在对应的边界。

    1.ReplicationPad1d

    1）调用方式

    1. 使用padding大小的边界复制品，填充输入向量的边界（左、右边界）；
    2. padding可为整数或者2元组；
    3. 输入形状：(N,C,W_in)；
    4. 输出形状：(N,C,W_out)；其中W_out=W_in+pad_left+pad_right；
    torch.nn.ReplicationPad1d(padding)

    • 1

    2）实例

    （1）padding为整数

    inp=torch.tensor([[[2., 8., 4., 6.],
         [0., 1., 8., 6.],
         [7., 5., 5., 6.]],

        [[3., 2., 0., 6.],
         [0., 3., 3., 0.],
         [5., 1., 3., 4.]]])  # torch.Size([2, 3, 4])
print(inp.shape)
print("inp:",inp)
pad=3
out=nn.ReplicationPad1d(padding=pad)(inp)
print("padding={},out:".format(pad),out)
print(out.shape)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    结果分析：padding为整数意味着在输入向量的所有边界填充该数量大小的元素。此处padding=3，表示在输入向量的左、右边界均填充3个对应边界的复制品。

    padding=3,out: tensor([[[2., 2., 2., 2., 8., 4., 6., 6., 6., 6.],
         [0., 0., 0., 0., 1., 8., 6., 6., 6., 6.],
         [7., 7., 7., 7., 5., 5., 6., 6., 6., 6.]],

        [[3., 3., 3., 3., 2., 0., 6., 6., 6., 6.],
         [0., 0., 0., 0., 3., 3., 0., 0., 0., 0.],
         [5., 5., 5., 5., 1., 3., 4., 4., 4., 4.]]])
torch.Size([2, 3, 10])

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    （2）padding为2元组：padding=(pad_left,pad_right)

    inp=torch.tensor([[[2., 8., 4., 6.],
         [0., 1., 8., 6.],
         [7., 5., 5., 6.]],

        [[3., 2., 0., 6.],
         [0., 3., 3., 0.],
         [5., 1., 3., 4.]]])  # torch.Size([2, 3, 4])
print(inp.shape)
print("inp:",inp)
pad=(1,2)
out=nn.ReplicationPad1d(padding=pad)(inp)
print("padding={},out:".format(pad),out)
print(out.shape)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13

    结果分析：图中可以看到，红框表示原始输入向量，蓝框表示填充元素，绿框分别表示输入向量的左、右边界。最后进行填充时，左面填充pad_left=1个左边界复制品，而右面填充pad_right=2个右边界复制品。

    padding=(1, 2),out: tensor([[[2., 2., 8., 4., 6., 6., 6.],
         [0., 0., 1., 8., 6., 6., 6.],
         [7., 7., 5., 5., 6., 6., 6.]],

        [[3., 3., 2., 0., 6., 6., 6.],
         [0., 0., 3., 3., 0., 0., 0.],
         [5., 5., 1., 3., 4., 4., 4.]]])
torch.Size([2, 3, 7])

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8

    在这里插入图片描述

    2.ReplicationPad2d

    1）调用方式

    1. 使用padding指定大小的边界复制品，填充输入向量的边界（左、右、上、下边界）；
    2. padding可设为整数或者4元组；
    3. 输入形状：(N,C,H_in,W_in)；
    4. 输出形状：(N,C,H_out,W_out)；其中H_out=H_in+pad_top+pad_bottom；W_out=W_in+pad_left+pad_right；
    torch.nn.ReplicationPad2d(padding)

    • 1

    2）实例

    （1）padding为整数

    inp=torch.tensor([[[[8., 3., 6., 2., 7.],
          [0., 8., 4., 9., 3.]],

         [[3., 9., 6., 2., 7.],
          [7., 8., 4., 6., 2.]],

         [[1., 9., 0., 1., 4.],
          [7., 8., 1., 0., 3.]]]])
# print(inp.shape)  # torch.Size([1, 3, 2, 5])
# print("inp:",inp)
pad=1
out=nn.ReplicationPad2d(padding=pad)(inp)
print("padding={},out:".format(pad),out)
print(out.shape)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    结果分析：与ReflectionPad1d的填充方式区别在于，此时需要填充的边界变成左、右、上、下四个。

    padding=1,out: tensor([[[[8., 8., 3., 6., 2., 7., 7.],
          [8., 8., 3., 6., 2., 7., 7.],
          [0., 0., 8., 4., 9., 3., 3.],
          [0., 0., 8., 4., 9., 3., 3.]],

         [[3., 3., 9., 6., 2., 7., 7.],
          [3., 3., 9., 6., 2., 7., 7.],
          [7., 7., 8., 4., 6., 2., 2.],
          [7., 7., 8., 4., 6., 2., 2.]],

         [[1., 1., 9., 0., 1., 4., 4.],
          [1., 1., 9., 0., 1., 4., 4.],
          [7., 7., 8., 1., 0., 3., 3.],
          [7., 7., 8., 1., 0., 3., 3.]]]])
torch.Size([1, 3, 4, 7])

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15

    （2）padding为4元组：padding=(pad_left,pad_right,pad_top,pad_bottom)

    inp=torch.tensor([[[[8., 3., 6., 2., 7.],
          [0., 8., 4., 9., 3.]],

         [[3., 9., 6., 2., 7.],
          [7., 8., 4., 6., 2.]],

         [[1., 9., 0., 1., 4.],
          [7., 8., 1., 0., 3.]]]])
# print(inp.shape)  # torch.Size([1, 3, 2, 5])
# print("inp:",inp)
pad=(1,2,3,4)
out=nn.ReplicationPad2d(padding=pad)(inp)
print("padding={},out:".format(pad),out)
print(out.shape)

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14

    结果：可看到原始输入的左、右、上、下四个边界依次填充pad_left=1,pad_right=2,pad_top=3,pad_bottom=4大小的边界复制品。

    padding=(1, 2, 3, 4),out: tensor([[[[8., 8., 3., 6., 2., 7., 7., 7.],
          [8., 8., 3., 6., 2., 7., 7., 7.],
          [8., 8., 3., 6., 2., 7., 7., 7.],
          [8., 8., 3., 6., 2., 7., 7., 7.],
          [0., 0., 8., 4., 9., 3., 3., 3.],
          [0., 0., 8., 4., 9., 3., 3., 3.],
          [0., 0., 8., 4., 9., 3., 3., 3.],
          [0., 0., 8., 4., 9., 3., 3., 3.],
          [0., 0., 8., 4., 9., 3., 3., 3.]],

         [[3., 3., 9., 6., 2., 7., 7., 7.],
          [3., 3., 9., 6., 2., 7., 7., 7.],
          [3., 3., 9., 6., 2., 7., 7., 7.],
          [3., 3., 9., 6., 2., 7., 7., 7.],
          [7., 7., 8., 4., 6., 2., 2., 2.],
          [7., 7., 8., 4., 6., 2., 2., 2.],
          [7., 7., 8., 4., 6., 2., 2., 2.],
          [7., 7., 8., 4., 6., 2., 2., 2.],
          [7., 7., 8., 4., 6., 2., 2., 2.]],

         [[1., 1., 9., 0., 1., 4., 4., 4.],
          [1., 1., 9., 0., 1., 4., 4., 4.],
          [1., 1., 9., 0., 1., 4., 4., 4.],
          [1., 1., 9., 0., 1., 4., 4., 4.],
          [7., 7., 8., 1., 0., 3., 3., 3.],
          [7., 7., 8., 1., 0., 3., 3., 3.],
          [7., 7., 8., 1., 0., 3., 3., 3.],
          [7., 7., 8., 1., 0., 3., 3., 3.],
          [7., 7., 8., 1., 0., 3., 3., 3.]]]])
torch.Size([1, 3, 9, 8])

    • 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

    五、注意事项

    1. padding可设置整数或元组两种，本质上padding设置为整数与padding设置为所有元素都为该整数的元组等价；
    2. 对于一维填充方式（指函数名后缀是1d），设定padding为整数或2元组时，表示在向量左、右边界处进行填充，并且严格按照左、右顺序进行填充；对于二维填充方式（指函数名后缀是2d），设定padding为整数或4元组时，表示在向量左、右、上、下边界处进行填充，并且严格按照左、右、上、下的顺序进行填充；
    3. 虽然官网对于一维填充和二维填充方式的输入或输出形状均给出两种方式，但对于一维复制填充：内部实现仅支持输入形状为（N,C,W_in），而二维复制填充：内部实现仅支持输入形状为（N,C,H_in,W_in）。
  • 相关阅读:
    【python实战】朋友因股票亏了，很惨常愤恨不平，当天我就分析出原因：怎么做到的？(听说关注我的人会暴富)
    （附源码）Springboot工程技术研究中心小程序 毕业设计 201738
    Android 12 init(2) rc脚本解析和事件执行流程
    {版本发布公告}HMS Core 6.6.0来啦
    LabVIEW使用VI Snippets存储和共享重用代码段
    ＜网络安全＞《30 网络信息安全基础（1）常用术语整理》
    丁腈橡胶油封有哪些优点？
    rhcsa-文件内容显示
    “次世代”究竟是什么？次世代角色建模又该怎么学？
    Vue(1)
  • 原文地址：https://blog.csdn.net/qq_43665602/article/details/126607104