Pytorch: [機能リクエスト]畳み込み演算に「同じ」パディングを実装しますか？

これはやる価値があるようです。 あなたが提案しているインターフェースは何ですか？ nn.Conv2d(..., padding="same") ？

TensorFlowの同じ動作を探している場合、追加するピクセル数は入力サイズに依存するため、実装はそれほど単純ではないことに注意してください。 参考のためにhttps://github.com/caffe2/caffe2/blob/master/caffe2/proto/caffe2_legacy.protoを参照してください

問題と参照を示していただきありがとうございます。
@fmassaが述べた問題を解決するために、2つのインターフェースを提案します。
まず、 @ southithが述べたように、最初のインターフェースはnn.Conv*d(..., padding="same") 、 forward()呼び出しごとにパディングを計算します。
ただし、初期化フェーズで入力形状がわかっている場合は、非効率的な方法になります。 したがって、 nn.CalcPadConv*d(<almost same parameters as Conv*d>)ようなインターフェイスをお勧めします。 これを使用すると、ユーザーは初期化時に既知の幅と高さを使用してパディングを計算し、出力（パディングの形状）をnn.Conv2d(...)パディングパラメーターに渡すことができます。
2番目の提案が時期尚早の最適化である可能性があるかどうかはわかりません。
これらについてどう思いますか？ より良い名前のアイデアはありますか？

非効率の最大の原因は、 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() 。 あなたが言ったように、この方法は計算されたパディングが奇妙なときにうまくいくだけではありません。 したがって、 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の画像を持っているとします。 次に、初期化フェーズで3つのケースのパディングを計算し、対応するパディングを使用して画像を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と同じ結果は得られませ

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を使用することもできます。

「スライディングウィンドウ演算子」はすべて非対称パディングをサポートする必要があると思います。

「同じ」議論について...
@soumith入力サイズに応じてパディングを作成するのが悪い理由を説明してください。
それが問題である場合、とにかく、実用的な解決策は、「同じ」を使用するときにstride == 1を要求することである可能性があります。 stride == 1場合、パディングは入力サイズに依存せず、1回だけ計算できます。 ユーザーがstride > 1 padding='same'を使用しようとすると、コンストラクターはValueError必要があります。

私は知っています、それは最もクリーンな解決策ではありませんが、制約は私にとって十分に合理的に聞こえます：

1. ラベル「same」の元のセマンティクスは、ストライドされていない畳み込みのために導入され、次のようになりました。出力は入力と_同じ_サイズです。 もちろん、これはstride > 1テンソルフローには当てはまりません。そのため、「同じ」という単語を使用すると、少し誤解を招くIMOになります。
2. 「同じ」を使用したいケースの99％をカバーします。 誰かがstride > 1のテンソルフローの動作を本当に必要としている場合はほとんど想像できませんが、元のセマンティクスを「同じ」にすると、もちろん、ストライド畳み込みを使用しても意味がありません。出力が入力と同じサイズである必要がある場合。

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を意味するので、パディング= "same"が導入され、書き込まれると、カーネルのサイズとストライドが自動的に読み取られ（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 / estimatorAPIを使用した経歴を持っています。 すべてがsameパディングをサポートしています。 現在、元々TFでPyTorchを使用して作成した畳み込みニューラルネットワークを再実装しています。ゼロパディングの演算を自分で組み込む必要があったため、約半日かかりました。

「中心的な目標」が本当に使いやすさに焦点を当てている場合、（前述のように）すべてのフォワードパスでゼロパディングを計算する効率が低下したとしても、開発者の効率と保守性の観点から時間を節約できます（前述のとおり）。たとえば、ゼロパディングを計算するためにカスタムコードを記述する必要がないこと）は、トレードオフの価値があるかもしれません。 考え？

この機能を使用します

padding=SAMEオプションのAPIを提供できないのはなぜですか？ 誰かがパディングの追加費用を負担することをいとわない場合は、そうさせてください。 多くの研究者にとって、ラピッドプロトタイピングは必須です。

はい、誰かがこれを追加して承認してくれるなら、それは素晴らしいことです。

間違いなくこれを追加してください、コナーはそれを望んでいます。

pytorchは今それをサポートしていますか？ VGGの最初の操作と同じ操作を使用して、padding =（kernel_size-1）/ 2を設定できますか？
VGGネットワ​​ークは、最初のグループで出力サイズを変更しないようにすることができます。 次に、ストライドを使用して機能マップのサイズを変更できますが、問題ないように聞こえますか？

これは、deepfakesから同じconv2dのパディングを呼び出す1つの例です。

# 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)

私もこれにとても感謝していると言うために立ち寄るだけです。 現在、テンソルフローから単純なモデルを移植しており、計算には非常に長い時間がかかります...

このスレッドはちょうどなくなったようです。 ここでの親指の数を考えると、より高速なプロトタイピングのためにこの機能を追加することは本当に素晴らしいことです。

私はこれについての提案を書きます、そして私たちはそれを実行する誰かを見つけることができます。
私はこれをv1.1のマイルストーンに当てはめています。

ありがとう、あなたは素晴らしいです！ また、パディング引数が4タプルを受け入れるようにするために、別の機能要求を提出

@soumithpytorchに同じパディングモードがあると便利です。

@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出力形状の計算が間違っていると思いますh=w=28, stride=3, kernel_size=1ように、コードはテンソルフローとは異なる結果になるはずです。

事前に計算を行うバリアントは次のとおりです。

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同意します。この機能により、

@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に新しいパディングメソッドを追加するのは賢明な選択であり、メソッドをオーバーロードすることで、パディングスケジュールを簡単に延長できます。

@soumithがその提案を書いた場合、または誰かが何をする必要があるかを要約した場合、私はおそらくこれを取ることができます。 上記で多くの議論があり、私たちが何に落ち着いたのかわかりません。 入力データに応じてパディングを計算していますか？プールにもpadding="same"を実装する必要がありますか？

因果パディングも追加したいのですが。 また、これをconv1dに追加してください。
ある時点でコメントのフォローをやめましたが、この機能はkerasで非常にうまく機能していると思います。 正確に従う必要があります。

@Chilleeここに行きます：

範囲

次のレイヤーにパディングを追加する必要があります。

• コンバージョン* d
• MaxPool * d
• AvgPool * d

最初のPRでは、シンプルに保ち、Conv * dに固執しましょう。

複雑さと欠点

上で説明した複雑さは、 sameパディングオプションが記述された後、レイヤーが本質的に動的になることです。 つまり、モデルのエクスポート（ONNXエクスポートなど）に最適な静的に既知のレイヤーのパラメーターから、動的なレイヤーのパラメーターになります。 この場合、動的パラメーターはpaddingです。
これはかなり無害に見えますが、モバイルやエキゾチックハードウェアランタイムなどの限られたランタイムでは、静的な形状の分析と最適化を行う場合など、非静的性が非常に重要になります。

もう1つの実際的な欠点は、この動的に計算された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のint（つまり、高さ/幅の各次元）になるようにサポートしています。
same値を持つ文字列を受け取る、 padding追加のオーバーロードをサポートする必要があります。

sameパディングは、 outputサイズがinputサイズと同じになるように畳み込みに与える前に、 inputをパディングする必要があります。

実装の詳細

'same'がpaddingに与えられた場合、各次元で必要な左右のパディングの量を計算する必要があります。

必要なL（左）とR（右）のパディングが計算された後、考慮すべき2つのケースがあります。

• L == R：この場合、対称パディングです。 L等しいpadding値でF.conv2dを呼び出すだけです。
• 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 / Tensorflow2.0よりも簡単だと思いました...

@zwep始めるにはもう少し努力が必要です。 煩わしい可能性のあるトライアニングループを作成する必要があり、レイヤーをより明示的に作成する必要があります。 それを（一度）行うと、それを超えて実際の改善をさらに進めることができます。

私の親指のルールは、あなたが何百万回もやったことがあるなら、Kerasを使うことです/超標準。
研究開発が行われているときはいつでもpytorchを使用してください。

これがパディングされた1dコンバージョンの私のコードです

トーチをインポート
トーチからインポートnn
numpyをnpとしてインポートします
torch.functionalを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'がありませんか？

これは、任意のカーネルサイズ、ストライド、および拡張に対して同じパディングを機能させる1つの方法です（カーネルサイズも機能します）。

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も「同じパディング」機能が必要です。

ところで、上記のパフォーマンス/シリアル化の懸念に加えて、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をリンクしています。