Pytorch: [기능 요청] 컨볼루션 작업에 "동일한" 패딩을 구현하시겠습니까?

이것은 할 가치가 있는 것 같습니다. 당신이 제안하는 인터페이스는 무엇입니까? nn.Conv2d(..., padding="same") 처럼?

TensorFlow의 동일한 동작을 찾고 있는 경우 추가할 픽셀 수가 입력 크기에 따라 달라지기 때문에 구현이 간단하지 않습니다. 참조는 https://github.com/caffe2/caffe2/blob/master/caffe2/proto/caffe2_legacy.proto 를 참조하십시오.

문제와 참조를 지적해 주셔서 감사합니다.
@fmassa 가 언급한 문제를 해결하기 위해 두 가지 인터페이스를 제안합니다.
먼저 @soutmith가 언급했듯이 첫 번째 인터페이스는 nn.Conv*d(..., padding="same") 와 같으며 forward() 호출마다 패딩을 계산합니다.
그러나 초기화 단계에서 입력 형태를 알면 비효율적인 방법이 됩니다. 따라서 nn.CalcPadConv*d(<almost same parameters as Conv*d>) 와 같은 인터페이스를 제안합니다. 이를 사용하여 사용자는 초기화 시 알려진 너비와 높이를 사용하여 패딩을 계산하고 nn.Conv2d(...) 의 패딩 매개변수에 출력(패딩 모양)을 전달할 수 있습니다.
두 번째 제안이 조기 최적화가 될 수 있는지 잘 모르겠습니다.
이것들에 대해 어떻게 생각하세요? 더 나은 이름에 대한 아이디어가 있습니까?

비효율의 가장 큰 원인은 padding=same 케이스를 필요로 하는 다른 모든 컨볼루션 전에 F.pad 레이어를 추가해야 한다는 사실에서 비롯될 것이라고 생각합니다 TensorFlow가 cudnn 케이스에서 이를 처리하는 방법을 참조하십시오. 따라서 nn.CalcPadConv*d 는 일반적으로 nn.Conv*d(..., padding="same") 만큼 비쌉니다.

이것은 컨볼루션의 각 면에 대해 다른 패딩을 지원하면 더 효율적일 수 있지만(Caffe2에서와 같이 왼쪽, 오른쪽, 위쪽, 아래쪽) cudnn은 여전히 ​​이를 지원하지 않으므로 이러한 경우에 추가 패딩이 필요합니다. .

우리는 추가하는 경우 또한, 나는 생각 padding="same" 에 nn.Conv*d , 우리는 아마에 대해 동일해야 nn.*Pool*d 오른쪽?

제 생각에는 사용자가 padding=same 의 동작이 TF와 동일할 것으로 예상할 수 있지만 성능 저하를 기대하지 않을 수도 있다는 점이 저를 약간 괴롭히는 것 같습니다.

어떻게 생각하나요?

왜 그것이 비효율적입니까? 모든 전진 단계에서 패딩을 계산할 수 없습니까? 비용이 작아야 하므로 최적화할 필요가 없습니다. 의미를 완전히 이해하지 못하는 것일 수도 있지만 F.pad 이 필요한 이유를 알 수 없습니다.

입력 크기에 따라 패딩을 만드는 것은 매우 나쁩니다. 다양한 직렬화 및 효율성 이유로 이것이 왜 나쁜 생각인지 설명하는 @Yangqing 과 함께

@fmassa , 내가 의도한 것은 __init__() 사용하여 nn.CalcPadConv*d() __init__() 에서 "일정한" 패딩 모양을 계산하는 것이었습니다. 말했듯이 이 방법은 계산된 패딩이 홀수일 때만 작동하지 않습니다. 따라서 F.pad 레이어를 추가하거나 홀수 패딩에 대한 F.conv*d 지원이 도움이 될 것입니다.

편집: 그런 다음 내가 제안한 것은 기능이어야 하며, 예를 들어 torch.nn.utils 또는 torch.utils에 배치해야 합니다.

결과적으로 내가 제안하는 것은 (의사 코드)와 같은 간단한 유틸리티 기능입니다.

def calc_pad_conv1d(width, padding='same', check_symmetric=True, ... <params that conv1d has>):
    shape = <calculate padding>

    assert not check_symmetric or <shape is symmetric>, \
        'Calculated padding shape is asymmetric, which is not supported by conv1d. ' \ 
        'If you just want to get the value, consider using check_symmetric=False.'

    return shape


width = 100  # for example
padding = calc_pad_conv1d(width, ...)
m = nn.Conv1d(..., padding=padding)

또한 이 기능은 사용자에게 유리하게 F.pad 와 함께 사용할 수 있습니다.

@qbx2 아마도 귀하의 제안을 완전히 이해하지 못할 수도 있지만 TensorFlow 동작을 복제하려는 경우 이것으로 충분하지 않다고 생각합니다.

다음은 TensorFlow SAME 패딩을 모방한 것으로 생각되는 스니펫입니다( nn.Conv2d 가 F.conv2d_same_padding 호출할 수 있도록 기능 인터페이스에 적어 둡니다).

def conv2d_same_padding(input, weight, bias=None, stride=1, dilation=1, groups=1):
  input_rows = input.size(2)
  filter_rows = weight.size(2)
  effective_filter_size_rows = (filter_rows - 1) * dilation[0] + 1
  out_rows = (input_rows + stride[0] - 1) // stride[0]
  padding_needed =
          max(0, (out_rows - 1) * stride[0] + effective_filter_size_rows -
                  input_rows)
  padding_rows = max(0, (out_rows - 1) * stride[0] +
                        (filter_rows - 1) * dilation[0] + 1 - input_rows)
  rows_odd = (padding_rows % 2 != 0)
  # same for padding_cols

  if rows_odd or cols_odd:
    input = F.pad(input, [0, int(cols_odd), 0, int(rows_odd)])

  return F.conv2d(input, weight, bias, stride,
                  padding=(padding_rows // 2, padding_cols // 2),
                  dilation=dilation, groups=groups)

여기 와 여기 의 TensorFlow 코드에서 대부분 복사하여 붙여넣었

보시다시피, 거기에는 많은 숨겨진 일들이 일어나고 있고, 그래서 padding='same' 추가할 가치가 없을 수도 있다고 생각합니다. 그리고 TensorFlow에서 SAME 동작을 복제하지 않는 것도 이상적이지 않다고 생각합니다.

생각?

@fmassa 네, 맞습니다. forward() 마다 패딩을 계산하는 것은 비효율적일 수 있습니다.

그러나 내 제안은 forward() 호출마다 패딩을 계산하지 않는 것입니다. 연구원(개발자)은 런타임 전에 이미지의 크기를 nn.Conv2d 예상할 수 있습니다. 그리고 그/그녀가 '동일한' 패딩을 원하면 'SAME'을 모방하기 위해 필요한 패딩을 계산하는 기능을 사용할 수 있습니다.

예를 들어 연구원이 200x200, 300x300, 400x400 크기의 이미지를 가지고 있는 경우를 생각해 보십시오. 그런 다음 초기화 단계에서 세 가지 경우에 대한 패딩을 계산하고 해당 패딩과 함께 이미지를 F.pad() 전달할 수 있습니다. 또는 forward() 호출 전에 nn.Conv2d 의 패딩 필드를 변경합니다. 다음을 참조하십시오.

>>> import torch
>>> import torch.nn as nn
>>> from torch.autograd import Variable
>>> m = nn.Conv2d(1,1,1)
>>> m(Variable(torch.randn(1,1,2,2))).shape
torch.Size([1, 1, 2, 2])
>>> m.padding = (1, 1)
>>> m(Variable(torch.randn(1,1,2,2))).shape
torch.Size([1, 1, 4, 4])

예, pytorch 코어에 "패딩 계산 유틸리티 기능"을 추가하고 싶습니다.

연구자가 각 입력 이미지 크기에 대한 종속 패딩을 원할 때 nn.Conv2d 이미지를 전달하기 전에 F.pad() 와 함수를 결합할 수 있습니다. 코드 작성자가 모든 forward() 호출에서 입력을 채울지 여부를 결정하도록 하고 싶습니다.

가까운 장래에 pytorch에서 유사한 API를 구현할 계획이 있습니까? tensorflow / keras 배경에서 온 사람들은 확실히 감사할 것입니다.

따라서 기본 패딩 계산 전략(TensorFlow와 동일한 결과를 제공하지 않지만 모양은 유사함)은

def _get_padding(padding_type, kernel_size):
    assert padding_type in ['SAME', 'VALID']
    if padding_type == 'SAME':
        return tuple((k - 1) // 2 for k in kernel_size))
    return tuple(0 for _ in kernel_size)

@im9uri 를 염두에 두고

내가 염두에 두었던 것과 비슷하지만 앞서 언급했듯이 보폭과 팽창으로 계산이 복잡해집니다.

또한 ConvTranspose2d와 같은 다른 컨볼루션 작업에서 이러한 API를 사용하는 것이 좋습니다.

"슬라이딩 창 연산자"는 모두 비대칭 패딩을 지원해야 한다고 생각합니다.

"같은" 주장에 대해...
@sumith 입력 크기에 따라 패딩을 만드는 것이 왜
어쨌든 그것이 문제라면 실용적인 해결책은 "동일"을 사용할 때 stride == 1 를 요구하는 것일 수 있습니다. stride == 1 의 경우 패딩은 입력 크기에 의존하지 않으며 한 번에 계산할 수 있습니다. 사용자가 padding='same' 와 함께 stride > 1 padding='same' 를 사용하려고 하면 생성자는 ValueError 발생시켜야 합니다.

나는 그것이 가장 깨끗한 해결책은 아니지만 제약 조건이 다음과 같이 나에게 충분히 합리적으로 들린다는 것을 압니다.

1. "same"이라는 레이블의 원래 의미는 strided convolution이 아닌 경우에 도입되었으며 출력은 입력의 _same_ 크기를 갖습니다. 물론 이것은 stride > 1 대한 tensorflow에서 사실이 아니며 "동일한"이라는 단어를 사용하여 IMO를 약간 오해하게 만듭니다.
2. "동일"을 사용하려는 경우의 99%를 다룹니다. 누군가가 stride > 1 대한 tensorflow의 동작을 정말로 필요로 하는 경우를 거의 상상할 수 없지만, 원래 의미를 "동일하게" 제공하면 음, 물론 strided convolution을 사용하는 것은 의미가 없습니다. 출력을 원하는 경우 입력의 크기가 동일합니다.

conv2d 문서는 출력 크기에 대한 명시적인 공식을 제공합니다. 예를 들어 Hout을 Hin과 동일시하면 패딩을 해결할 수 있습니다.

def _get_padding(size, kernel_size, stride, dilation):
    padding = ((size - 1) * (stride - 1) + dilation * (kernel_size - 1)) //2
    return padding

동일한 패딩은 패딩 = (kernel_size - stride)//2를 의미하기 때문에 패딩 = "동일"이 도입되어 작성될 때 커널 크기와 보폭(nn.Conv2d에서도 언급됨)을 자동으로 읽고 패딩을 적용합니다. 그에 따라 자동으로

다음은 참조용으로 same 패딩이 있는 매우 간단한 Conv2d 레이어입니다. 정사각형 커널과 stride=1, dilation=1, groups=1만 지원합니다.

class Conv2dSame(torch.nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size, bias=True, padding_layer=torch.nn.ReflectionPad2d):
        super().__init__()
        ka = kernel_size // 2
        kb = ka - 1 if kernel_size % 2 == 0 else ka
        self.net = torch.nn.Sequential(
            padding_layer((ka,kb,ka,kb)),
            torch.nn.Conv2d(in_channels, out_channels, kernel_size, bias=bias)
        )
    def forward(self, x):
        return self.net(x)

c = Conv2dSame(1,3,5)
print(c(torch.rand((16,1,10,10))).shape)

# torch.Size([16, 3, 10, 10])

이것이 여전히 PyTorch에 추가되는 것으로 평가되고 있다면 개발자를 위한 복잡성/비효율성 대 사용 용이성 간의 절충점에 대해:

1.0 블로그 게시물로 가는 길에 다음 과 같이 명시되어 있습니다.

PyTorch의 중심 목표는 연구 및 해킹 가능성을 위한 훌륭한 플랫폼을 제공하는 것입니다. 따라서 이러한 모든 [프로덕션 사용] 최적화를 추가하는 동안 우리는 사용성과 이를 절충하지 않도록 엄격한 설계 제약 조건으로 작업해 왔습니다.

일화적으로 저는 Keras와 원래 tf.layers / estimator API를 사용한 경험이 있습니다. 모두 same 패딩을 지원합니다. 저는 현재 PyTorch를 사용하여 TF에서 원래 작성했던 convnet을 다시 구현하고 있으며, 제로 패딩을 위해 산술을 직접 구축해야 했기 때문에 약 반나절의 시간이 소요되었습니다.

"중심 목표"가 실제로 사용성에 중점을 둔다면 모든 전진 패스(위에서 언급한 바와 같이)에서 제로 패딩을 계산하는 데 효율성이 떨어지더라도 개발자 효율성 및 유지 관리 측면에서 시간이 절약된다고 주장하는 것보다 예를 들어 제로 패딩을 계산하기 위해 사용자 정의 코드를 작성할 필요가 없음은 절충의 가치가 있을 수 있습니다. 생각?

이 기능을 사용하겠습니다

padding=SAME 의 선택적 API를 제공할 수 없는 이유는 무엇입니까? 누군가가 패딩에 대한 추가 비용을 기꺼이 지불할 의사가 있다면 그렇게 하도록 하십시오. 많은 연구자에게 빠른 프로토타이핑은 요구 사항입니다.

예, 누군가 이것을 추가하고 승인할 수 있다면 좋을 것입니다.

확실히 이것을 추가하십시오. 코너는 그것을 원합니다.

이제 pytorch가 지원합니까? VGG에서 처음과 같은 작업을 사용하여 패딩 = (kernel_size-1)/2를 설정할 수 있습니까?
VGG 네트워크는 첫 번째 그룹에서 출력 크기가 변경되지 않도록 할 수 있습니다. 그런 다음 stride를 사용하여 featuremap의 크기를 조정할 수 있습니다. 괜찮습니까?

다음은 deepfakes에서 동일한 conv2d 패딩을 호출하는 한 가지 예입니다.

# modify con2d function to use same padding
# code referd to <strong i="6">@famssa</strong> in 'https://github.com/pytorch/pytorch/issues/3867'
# and tensorflow source code

import torch.utils.data
from torch.nn import functional as F

import math
import torch
from torch.nn.parameter import Parameter
from torch.nn.functional import pad
from torch.nn.modules import Module
from torch.nn.modules.utils import _single, _pair, _triple


class _ConvNd(Module):

    def __init__(self, in_channels, out_channels, kernel_size, stride,
                 padding, dilation, transposed, output_padding, groups, bias):
        super(_ConvNd, self).__init__()
        if in_channels % groups != 0:
            raise ValueError('in_channels must be divisible by groups')
        if out_channels % groups != 0:
            raise ValueError('out_channels must be divisible by groups')
        self.in_channels = in_channels
        self.out_channels = out_channels
        self.kernel_size = kernel_size
        self.stride = stride
        self.padding = padding
        self.dilation = dilation
        self.transposed = transposed
        self.output_padding = output_padding
        self.groups = groups
        if transposed:
            self.weight = Parameter(torch.Tensor(
                in_channels, out_channels // groups, *kernel_size))
        else:
            self.weight = Parameter(torch.Tensor(
                out_channels, in_channels // groups, *kernel_size))
        if bias:
            self.bias = Parameter(torch.Tensor(out_channels))
        else:
            self.register_parameter('bias', None)
        self.reset_parameters()

    def reset_parameters(self):
        n = self.in_channels
        for k in self.kernel_size:
            n *= k
        stdv = 1. / math.sqrt(n)
        self.weight.data.uniform_(-stdv, stdv)
        if self.bias is not None:
            self.bias.data.uniform_(-stdv, stdv)

    def __repr__(self):
        s = ('{name}({in_channels}, {out_channels}, kernel_size={kernel_size}'
             ', stride={stride}')
        if self.padding != (0,) * len(self.padding):
            s += ', padding={padding}'
        if self.dilation != (1,) * len(self.dilation):
            s += ', dilation={dilation}'
        if self.output_padding != (0,) * len(self.output_padding):
            s += ', output_padding={output_padding}'
        if self.groups != 1:
            s += ', groups={groups}'
        if self.bias is None:
            s += ', bias=False'
        s += ')'
        return s.format(name=self.__class__.__name__, **self.__dict__)


class Conv2d(_ConvNd):

    def __init__(self, in_channels, out_channels, kernel_size, stride=1,
                 padding=0, dilation=1, groups=1, bias=True):
        kernel_size = _pair(kernel_size)
        stride = _pair(stride)
        padding = _pair(padding)
        dilation = _pair(dilation)
        super(Conv2d, self).__init__(
            in_channels, out_channels, kernel_size, stride, padding, dilation,
            False, _pair(0), groups, bias)

    def forward(self, input):
        return conv2d_same_padding(input, self.weight, self.bias, self.stride,
                        self.padding, self.dilation, self.groups)


# custom con2d, because pytorch don't have "padding='same'" option.
def conv2d_same_padding(input, weight, bias=None, stride=1, padding=1, dilation=1, groups=1):

    input_rows = input.size(2)
    filter_rows = weight.size(2)
    effective_filter_size_rows = (filter_rows - 1) * dilation[0] + 1
    out_rows = (input_rows + stride[0] - 1) // stride[0]
    padding_needed = max(0, (out_rows - 1) * stride[0] + effective_filter_size_rows -
                  input_rows)
    padding_rows = max(0, (out_rows - 1) * stride[0] +
                        (filter_rows - 1) * dilation[0] + 1 - input_rows)
    rows_odd = (padding_rows % 2 != 0)
    padding_cols = max(0, (out_rows - 1) * stride[0] +
                        (filter_rows - 1) * dilation[0] + 1 - input_rows)
    cols_odd = (padding_rows % 2 != 0)

    if rows_odd or cols_odd:
        input = pad(input, [0, int(cols_odd), 0, int(rows_odd)])

    return F.conv2d(input, weight, bias, stride,
                  padding=(padding_rows // 2, padding_cols // 2),
                  dilation=dilation, groups=groups)

이 점에 대해 매우 감사하게 생각합니다. 현재 tensorflow에서 간단한 모델을 이식하고 있으며 계산을 이해하는 데 매우 오랜 시간이 걸립니다...

이 스레드가 방금 죽은 것 같습니다. 여기에서 엄지 손가락의 수를 감안할 때 더 빠른 프로토타이핑을 위해 이 기능을 추가하면 정말 좋을 것입니다.

이에 대한 제안서를 작성하고 이를 구현할 사람을 찾을 수 있습니다.
나는 이것을 v1.1 이정표에 대해 놓고 있습니다.

감사합니다, 당신은 굉장합니다! 또한 패딩 인수가 4-튜플을 허용하도록 별도의 기능 요청 을 제출했습니다. 이것은 대칭 패딩뿐만 아니라 대칭 패딩도 허용하며 이는 중간에 도달하기 위한 좋은 저비용 경로이기도 합니다.

@soumith pytorch 에 패딩 모드가 동일하면 좋을 것입니다.

@soumith 컴파일 유형 인터페이스를 사용하는 것은 어떻습니까?

model=torch.compile(model,input_shape=(3,224,224))

TensorFlow가 수행하는 방식에 따라 팽창과 보폭을 지원하는 동일한 패딩으로 Conv2D를 만들었습니다. 이것은 실시간으로 계산합니다. 미리 계산하려면 패딩을 init()으로 이동하고 입력 크기 매개변수를 가지기만 하면 됩니다.

import torch as tr
import math

class Conv2dSame(tr.nn.Module):

    def __init__(self, in_channels, out_channels, kernel_size, stride=1, dilation=1):
        super(Conv2dSame, self).__init__()
        self.F = kernel_size
        self.S = stride
        self.D = dilation
        self.layer = tr.nn.Conv2d(in_channels, out_channels, kernel_size, stride, dilation=dilation)

    def forward(self, x_in):
        N, C, H, W = x_in.shape
        H2 = math.ceil(H / self.S)
        W2 = math.ceil(W / self.S)
        Pr = (H2 - 1) * self.S + (self.F - 1) * self.D + 1 - H
        Pc = (W2 - 1) * self.S + (self.F - 1) * self.D + 1 - W
        x_pad = tr.nn.ZeroPad2d((Pr//2, Pr - Pr//2, Pc//2, Pc - Pc//2))(x_in)
        x_out = self.layer(x_pad)
        return x_out

예 1:
입력 모양: (1, 3, 96, 96)
필터: 64
크기: 9x9

Conv2dSame(3, 64, 9)

패딩 모양: (1, 3, 104, 104)
출력 형태: (1, 64, 96, 96)

예 2:
이전과 동일하지만 stride=2

Conv2dSame(3, 64, 9, 2)

패딩 모양 = (1, 3, 103, 103)
출력 형태 = (1, 64, 48, 48)

@jpatts 출력 모양 계산이 잘못되었다고 생각합니다. ceil(input_dimension / stride)이어야 합니다. 파이썬의 정수 나누기는 바닥 나누기입니다. 코드는 h=w=28, stride=3, kernel_size=1 대해 tensorflow와 다른 결과를 가져야 합니다.

다음은 미리 계산을 수행하는 변형입니다.

def pad_same(in_dim, ks, stride, dilation=1):
    """
    Refernces:
          https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/framework/common_shape_fns.h
          https://github.com/tensorflow/tensorflow/blob/master/tensorflow/core/framework/common_shape_fns.cc#L21
    """
    assert stride > 0
    assert dilation >= 1
    effective_ks = (ks - 1) * dilation + 1
    out_dim = (in_dim + stride - 1) // stride
    p = max(0, (out_dim - 1) * stride + effective_ks - in_dim)

    padding_before = p // 2
    padding_after = p - padding_before
    return padding_before, padding_after

입력 차원이 알려져 있고 즉시 계산되지 않는 경우 다음과 같이 사용할 수 있습니다.

# Pass this to nn.Sequential
def conv2d_samepad(in_dim, in_ch, out_ch, ks, stride, dilation=1, bias=True):
    pad_before, pad_after = pad_same(in_dim, ks, stride, dilation)
    if pad_before == pad_after:
        return [nn.Conv2d(in_ch, out_ch, ks, stride, pad_after, dilation, bias=bias)]
    else:
        return [nn.ZeroPad2d((pad_before, pad_after, pad_before, pad_after)),
                nn.Conv2d(in_ch, out_ch, ks, stride, 0, dilation, bias=bias)]

그러나 이 경우 입력 차원에 대해 일부 부기 관리를 수행해야 하므로(이것이 핵심 문제임) 위의 내용을 사용하면 유용할 수 있습니다.

def conv_outdim(in_dim, padding, ks, stride, dilation):
    if isinstance(padding, int) or isinstance(padding, tuple):
        return conv_outdim_general(in_dim, padding, ks, stride, dilation)
    elif isinstance(padding, str):
        assert padding in ['same', 'valid']
        if padding == 'same':
            return conv_outdim_samepad(in_dim, stride)
        else:
            return conv_outdim_general(in_dim, 0, ks, stride, dilation)
    else:
        raise TypeError('Padding can be int/tuple or str=same/valid')


def conv_outdim_general(in_dim, padding, ks, stride, dilation=1):
    # See https://arxiv.org/pdf/1603.07285.pdf, eq (15)
    return ((in_dim + 2 * padding - ks - (ks - 1) * (dilation - 1)) // stride) + 1


def conv_outdim_samepad(in_dim, stride):
    return (in_dim + stride - 1) // stride

@mirceamironenco 지적해 주셔서 감사합니다. 나는 이것을 빠르고 더럽게 만들었고 결코 확인하지 않았습니다. 대신 천장을 사용하도록 업데이트됨

@harritaylor 동의합니다. 이 기능은 Keras/TF 모델을 PyTorch로 이식하는 작업을 확실히 단순화합니다. 때때로 나는 여전히 패딩 크기의 "수동" 계산을 사용하여 동일한 패딩 레이어를 만듭니다.

@kylemcdonald

다음은 참조용으로 same 패딩이 있는 매우 간단한 Conv2d 레이어입니다. 정사각형 커널과 stride=1, dilation=1, groups=1만 지원합니다.

class Conv2dSame(torch.nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size, bias=True, padding_layer=torch.nn.ReflectionPad2d):
        super().__init__()
        ka = kernel_size // 2
        kb = ka - 1 if kernel_size % 2 == 0 else ka
        self.net = torch.nn.Sequential(
            padding_layer((ka,kb,ka,kb)),
            torch.nn.Conv2d(in_channels, out_channels, kernel_size, bias=bias)
        )
    def forward(self, x):
        return self.net(x)

c = Conv2dSame(1,3,5)
print(c(torch.rand((16,1,10,10))).shape)

# torch.Size([16, 3, 10, 10])

kb = ka - 1 if kernel_size % 2 else ka 이어야 할까요?

이것은 Conv1d에도 적용됩니까?

ConvND 클래스에 새로운 패딩 방법을 추가하는 것은 우아한 선택일 수 있으며, 메서드를 오버로드하여 패딩 일정을 쉽게 연장할 수 있습니다.

@sumith 가 그 제안을 작성한 적이 있거나 누군가가 수행해야 할 작업을 요약하면 아마도 이것을 받아들일 수 있습니다. 위에서 많은 논의가 있었고 우리가 무엇을 결정했는지 잘 모르겠습니다. 입력 데이터에 따라 패딩을 계산하는지 여부, 풀에도 padding="same" 를 구현해야 합니까?

인과관계 패딩도 추가하고 싶습니다. 그리고 이것을 conv1d에도 추가해주세요.
나는 어느 시점에서 주석을 따르는 것을 중단했지만 이 기능은 keras에서 매우 잘 수행되었다고 생각합니다. 정확히 따라야 합니다.

@칠리 여기 있습니다.

범위

다음 레이어에 패딩을 추가해야 합니다.

• 전환*일
• 최대 풀*d
• 평균 풀*d

첫 번째 PR의 경우 단순하게 유지하고 Conv*d를 고수합시다.

복잡성과 단점

위에서 논의한 복잡성은 same 패딩 옵션이 작성된 후 레이어가 본질적으로 동적으로 변하는 것입니다. 즉, 모델 내보내기(예: ONNX 내보내기)에 좋은 정적으로 알려진 레이어의 매개변수에서 동적인 레이어의 매개변수로 이동합니다. 이 경우 동적 매개변수는 padding 입니다.
이것은 매우 무해해 보이지만, 예를 들어 정적 형태 분석 및 최적화를 수행하려는 모바일 또는 이국적인 하드웨어 런타임과 같은 제한된 런타임에서 비정적성은 매우 중요합니다.

다른 실용적인 단점은 동적으로 계산된 padding 가 더 이상 항상 대칭적이지 않다는 것입니다. 커널의 크기/보폭, 팽창 계수 및 입력 크기에 따라 패딩이 비대칭(즉, 다른 왼쪽 대 오른쪽의 패딩 양). 예를 들어 CuDNN 커널을 사용할 수 없다는 의미입니다.

설계

현재 Conv2d의 서명은 다음과 같습니다.

torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros')

여기서 우리는 padding 가 int 또는 tuple 의 정수가 되도록 지원합니다(즉, 높이 / 너비의 각 차원에 대해).
값이 same 문자열을 사용하는 padding 대한 추가 오버로드를 지원해야 합니다.

same 패딩은 output 크기가 input 크기와 동일하도록 컨볼루션에 제공하기 전에 input 를 패딩해야 합니다.

구현 세부 정보

'same' 가 padding 주어졌을 때, 우리는 각 차원에서 필요한 왼쪽과 오른쪽 패딩의 양을 계산해야 합니다.

필요한 L(왼쪽) 및 R(오른쪽) 패딩이 계산된 후 고려해야 할 두 가지 경우가 있습니다.

• L == R: 이 경우 대칭 패딩입니다. 하나는 단순히 호출 할 수 있습니다 F.conv2d A를 padding 가치가 동일 L
• L != R: 이 경우 패딩은 비대칭이며 성능과 메모리에 상당한 영향을 미칩니다. 우리는 다음을 수행합니다.
  
  
  
  • input_padded = F.pad(input, ...) 호출하고 input_padded 를 F.conv2d 로 보냅니다.
  
  
  • 우리는 이 경우에 대해 성능 영향에 대해 경고를 표시합니다(최소한 초기 릴리스의 경우, 경고가 필요한 경우 다시 방문할 수 있음).
  
  
  • 공식의 세부 사항과 이 경우를 입력한 위치는 기억나지 않지만, 기억한다면 크기가 같은 커널을 갖는 것만큼 간단할 수 있습니다. 이 경우 경고를 통해 사용자 측에서 쉽게 수정할 수 있습니다.
  
  

말할 필요도 없이 JIT 경로에서도 작동하려면 테스트를 거쳐야 합니다.

@Chilee 참고용, 다음은 https://github.com/mlperf/inference/blob/master/others/edge/object_detection/ssd_mobilenet/pytorch/utils.py#L40 에서 영감을 얻을 수 있는 잠재적 구현입니다.

테스트한 구성에 대한 TF 구현과 일치했지만 테스트가 완전하지는 않았습니다.

@soumith 몇 가지 간단한 질문:

1. functional.conv2d 통해 이것을 구현하지 말아야 할 이유가 있습니까? 당신이 쓴 디자인은 그렇지 않다는 것을 암시하는 것 같습니다. padding = "same"에 대해서는 레이어에 특정해야 하는 것처럼 보이는 것이 없습니다. (편집: Nvm, 내가 보고 있는 F.conv2d impl이 양자화된 것임을 깨닫지 못했습니다).
2. Tensorflow의 valid 패딩 모드는 단순히 padding=0 가 있는 것과 동일하다고 생각합니다. 맞습니까?

또한 사용자가 비대칭 패딩을 쉽게 해결할 수 있을 것 같지 않습니다. 발생해야 하는 패딩의 양을 결정하는 전체 규칙은 다음과 같습니다.
차원을 따라 (ceil(x/stride) -1)*stride + (filter-1)*dilation + 1 - x 입니다. 특히, 이것이 2의 배수가 아닌 경우 비대칭 패딩을 수행해야 합니다. 이것이 짝수 크기의 필터에서만 발생하기를 바라는 것에 대한 반례로 input = 10, stride=3, filter=3, dilation=1 취하십시오. 나는 이것이 일어날 수 있는 상황을 해결하기 위한 어떤 간단한 규칙도 보지 못한다.

또한 stride=1 , ceil(x/stride) = x 인 경우를 제외하고 패딩을 정적으로 결정할 수 없으며 패딩이 (filter-1)*dilation .

@Chillee (1)에 대해 이유가 없습니다. 성능 또는 기타 의미에 대해 생각하지 않았습니다.

(2) 네.

또한 stride=1인 경우를 제외하고는 패딩을 정적으로 결정할 수 없습니다. ceil(x/stride) = x이고 패딩은 (filter-1)*dilation과 같습니다.

예, 하지만 stride=1은 충분히 일반적이며 정적 패딩의 이점은 확실히 특별히 처리해야 할 만큼 좋습니다.

비대칭 패딩에 대해, 음.....

padding=SAME 의 선택적 API를 제공할 수 없는 이유는 무엇입니까? 누군가가 패딩에 대한 추가 비용을 기꺼이 지불할 의사가 있다면 그렇게 하도록 하십시오. 많은 연구자에게 빠른 프로토타이핑은 요구 사항입니다.

예,

padding=SAME 의 선택적 API를 제공할 수 없는 이유는 무엇입니까? 누군가가 패딩에 대한 추가 비용을 기꺼이 지불할 의사가 있다면 그렇게 하도록 하십시오. 많은 연구자에게 빠른 프로토타이핑은 요구 사항입니다.

동의하다! 나는 이 빌어먹을 "패딩"에 4시간 동안 갇혀 있었다.

이 문제에 대한 솔루션에 대한 업데이트가 있습니까?

와우 그리고 여기에서 저는 Pytorch가 Keras/Tensorflow 2.0보다 쉬울 것이라고 생각했습니다...

@zwep 시작하는 데 조금 더 많은 노력이 필요합니다. 성가실 수 있는 trianing 루프를 작성해야 하고 레이어를 더 명시적으로 작성해야 합니다. 일단 당신이 그것을 끝내면(한 번) 당신은 그 이상으로 실제 개선에 대해 훨씬 더 발전할 수 있습니다.

내가 경험한 규칙은 백만 번/최고 수준의 작업을 수행한 경우 Keras를 사용하는 것입니다.
연구 개발이 필요할 때마다 pytorch를 사용하십시오.

패딩 1d 전환에 대한 내 코드는 다음과 같습니다.

수입 토치
토치 수입 nn에서
numpy를 np로 가져오기
토치.기능을 F로 가져오기

class Conv1dSamePad(nn.Module):
    def __init__(self, in_channels, out_channels, filter_len, stride=1, **kwargs):
        super(Conv1dSamePad, self).__init__()
        self.filter_len = filter_len
        self.conv = nn.Conv1d(in_channels, out_channels, filter_len, padding=(self.filter_len // 2), stride=stride,
                              **kwargs)
        nn.init.xavier_uniform_(self.conv.weight)
        # nn.init.constant_(self.conv.bias, 1 / out_channels)

    def forward(self, x):
        if self.filter_len % 2 == 1:
            return self.conv(x)
        else:
            return self.conv(x)[:, :, :-1]


class Conv1dCausalPad(nn.Module):
    def __init__(self, in_channels, out_channels, filter_len, **kwargs):
        super(Conv1dCausalPad, self).__init__()
        self.filter_len = filter_len
        self.conv = nn.Conv1d(in_channels, out_channels, filter_len, **kwargs)
        nn.init.xavier_uniform_(self.conv.weight)

    def forward(self, x):
        padding = (self.filter_len - 1, 0)
        return self.conv(F.pad(x, padding))


class Conv1dPad(nn.Module):
    def __init__(self, in_channels, out_channels, filter_len, padding="same", groups=1):
        super(Conv1dPad, self).__init__()
        if padding not in ["same", "causal"]:
            raise Exception("invalid padding type %s" % padding)
        self.conv = Conv1dCausalPad(in_channels, out_channels, filter_len, groups=groups) \
            if padding == "causal" else Conv1dSamePad(in_channels, out_channels, filter_len, groups=groups)

    def forward(self, x):
        return self.conv(x)

@danFromTelAviv 코드 감사합니다. 그 pytorch 철학을 염두에 둘 것입니다!

2020년입니다. 아직 Pytorch에 padding='same' 가 없습니까?

이것은 모든 커널 크기, 보폭 및 팽창에 대해 동일한 패딩이 작동하도록 하는 한 가지 방법입니다(커널 크기도 작동함).

class Conv1dSame(nn.Module):
    def __init__(self, in_channels, out_channels, kernel_size, stride=1, dilation=1):
        super().__init__()
        self.cut_last_element = (kernel_size % 2 == 0 and stride == 1 and dilation % 2 == 1)
        self.padding = math.ceil((1 - stride + dilation * (kernel_size-1))/2)
        self.conv = nn.Conv1d(in_channels, out_channels, kernel_size, padding=self.padding, stride=stride, dilation=dilation)

    def forward(self, x):
        if self.cut_last_element:
            return self.conv(x)[:, :, :-1]
        else:
            return self.conv(x)

nn.Conv2d 에도 "동일한 패딩" 기능이 필요합니다.

BTW, 위에서 논의한 성능/직렬화 문제 외에도 TF의 크기 종속 "동일한" 패딩 모드가 좋은 기본값이 아닌 이유에 대한 정확성/정확성 이유가 있습니다. https://github.com/tensorflow/tensorflow/issues/18213 에서 논의했으며 실제로 많은 Google 자체 코드가 크기 독립적인 "동일한" 패딩 모드를 대신 사용한다는 것을 보여주었습니다.

이 문제에 대해 현재 진행 중인 작업이 없는 것 같지만 만약 있다면 크기 독립적인 솔루션이기를 바랍니다.

안녕하세요, @ppwwyyxx Yuxin, 답변 주셔서 감사합니다.
@McHughes288 의 구현이 좋다고 생각하며 그의 구현에 대한 귀하의 의견이 궁금합니다.

다음은 Conv1D SAME 패딩에 대한 내 솔루션입니다( dilation==1 & groups==1 인 경우에만 올바르게 작동하며 팽창 및 그룹을 고려할 때 더 복잡함).

import torch.nn.functional as F
from torch import nn

class Conv1dSamePadding(nn.Conv1d):
    """Represents the "Same" padding functionality from Tensorflow.
    NOTE: Only work correctly when dilation == 1, groups == 1 !!!
    """
    def forward(self, input):
        size, kernel, stride = input.size(-1), self.weight.size(
            2), self.stride[0]
        padding = kernel - stride - size % stride
        while padding < 0:
            padding += stride
        if padding != 0:
            # pad left by padding // 2, pad right by padding - padding // 2
            # in Tensorflow, one more padding value(default: 0) is on the right when needed
            input = F.pad(input, (padding // 2, padding - padding // 2))
        return F.conv1d(input=input,
                        weight=self.weight,
                        bias=self.bias,
                        stride=stride,
                        dilation=1,
                        groups=1)

@Chillee 이 기능을 계속 작업할 의향이 있습니까? 이 문제의 진행 상황을 더 잘 추적할 수 있도록 지금은 할당을 취소하겠습니다. 아직 작업 중인 경우 언제든지 다시 할당해 주세요.

@wizcheu 의 코드를 읽은 후 padding='same'으로 다른 버전의 conv1d를 만듭니다.

class Conv1dPaddingSame(nn.Module):
    '''pytorch version of padding=='same'
    ============== ATTENTION ================
    Only work when dilation == 1, groups == 1
    =========================================
    '''
    def __init__(self, in_channels, out_channels, kernel_size, stride):
        super(Conv1dPaddingSame, self).__init__()
        self.kernel_size = kernel_size
        self.stride = stride
        self.weight = nn.Parameter(torch.rand((out_channels, 
                                                 in_channels, kernel_size)))
        # nn.Conv1d default set bias=True，so create this param
        self.bias = nn.Parameter(torch.rand(out_channels))

    def forward(self, x):
        batch_size, num_channels, length = x.shape
        if length % self.stride == 0:
            out_length = length // self.stride
        else:
            out_length = length // self.stride + 1

        pad = math.ceil((out_length * self.stride + 
                         self.kernel_size - length - self.stride) / 2)
        out = F.conv1d(input=x, 
                       weight = self.weight,
                       stride = self.stride, 
                       bias = self.bias,
                       padding=pad)
        return out

이에 대한 업데이트가 있습니까?

어떤 업데이트??

@peterbell10 이 팔로우할 수 있는 PR 초안을 연결했습니다.