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(...) के पैडिंग पैरामीटर में पास कर सकता है।
मुझे यकीन नहीं है कि दूसरा प्रस्ताव समयपूर्व अनुकूलन हो सकता है।
आप इन के बारे में कैसे सोचते हैं? क्या बेहतर नाम का कोई विचार है?

मुझे लगता है कि अक्षमता का सबसे बड़ा स्रोत इस तथ्य से आएगा कि हमें हर दूसरे कनवल्शन से पहले एक F.pad परत जोड़ने की आवश्यकता होगी जिसके लिए padding=same केस की आवश्यकता होती है (क्योंकि पैडिंग की मात्रा समान नहीं हो सकती है) बाईं और दाईं ओर), उदाहरण के लिए देखें कि cudnn मामले में TensorFlow को इसे कैसे संभालना है । तो इसका मतलब है कि 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 के समर्थन से मदद मिलनी चाहिए।

संपादित करें: फिर मैंने जो सुझाव दिया वह एक समारोह होना चाहिए और कहें, टॉर्च.एनएन.यूटिल्स या टॉर्च.यूटिल्स में रखा जाना चाहिए।

नतीजतन, मैं जो सुझाव देता हूं वह एक साधारण उपयोगिता फ़ंक्शन है, जैसे (छद्म कोड):

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 उम्मीद कर सकता है। और अगर वह 'समान' पैडिंग चाहता है, तो वह 'समान' की नकल करने के लिए आवश्यक पैडिंग की गणना करने के लिए फ़ंक्शन का उपयोग कर सकता है।

उदाहरण के लिए, मान लें कि किसी शोधकर्ता के पास 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])

हां, मैं सिर्फ पाइटोरच कोर में "पैडिंग कैलकुलेटिंग यूटिलिटी फंक्शन" जोड़ना चाहता हूं।

जब शोधकर्ता प्रत्येक इनपुट छवि आकार पर निर्भर पैडिंग चाहता है, तो वह छवि को nn.Conv2d पास करने से पहले फ़ंक्शन को F.pad() साथ जोड़ सकता है। मैं कोड लेखक को यह तय करने देना चाहता हूं कि प्रत्येक forward() कॉल पर इनपुट पैड करना है या नहीं।

क्या निकट भविष्य में पाइटोरच में इसी तरह के एपीआई को लागू करने की कोई योजना है? टेंसरफ़्लो / केरस पृष्ठभूमि से आने वाले लोग निश्चित रूप से इसकी सराहना करेंगे।

तो, एक बुनियादी पैडिंग गणना रणनीति (जो 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 जैसे अन्य कनवल्शन ऑपरेशंस में इस तरह के एपीआई का होना बहुत अच्छा होगा।

मुझे लगता है कि "स्लाइडिंग-विंडो ऑपरेटरों" को सभी असममित पैडिंग का समर्थन करना चाहिए।

"समान" तर्क के बारे में ...
@soumith क्या आप बता सकते हैं कि इनपुट आकार के आधार पर पैडिंग क्यों खराब है, कृपया?
यदि यह एक समस्या है, वैसे भी, "समान" का उपयोग करते समय stride == 1 आवश्यकता के लिए एक व्यावहारिक समाधान हो सकता है। stride == 1 , पैडिंग इनपुट आकार पर निर्भर नहीं करता है और इसकी गणना एक बार की जा सकती है। यदि उपयोगकर्ता padding='same' साथ stride > 1 का उपयोग करने का प्रयास करता है तो कंस्ट्रक्टर को ValueError उठाना चाहिए।

मुझे पता है, यह सबसे साफ समाधान नहीं है, लेकिन बाधा मुझे काफी उचित लगती है:

1. "समान" लेबल का मूल शब्दार्थ बिना स्ट्राइड कनवल्शन के लिए पेश किया गया था और था: आउटपुट में इनपुट का _same_ आकार है; बेशक, यह stride > 1 लिए टेंसरफ़्लो में सच नहीं है और यह "समान" शब्द का उपयोग थोड़ा भ्रामक आईएमओ बनाता है;
2. यह 99% मामलों को कवर करेगा जो कोई "समान" का उपयोग करना चाहता है; मैं मुश्किल से ऐसे मामले की कल्पना कर सकता हूं जब किसी को वास्तव में stride > 1 लिए टेंसरफ्लो के व्यवहार की आवश्यकता होती है, जबकि अगर हम इसके मूल अर्थ को "समान" देते हैं, तो निश्चित रूप से इसका कोई मतलब नहीं है एक कठोर दृढ़ संकल्प का उपयोग करने के लिए यदि आप चाहते हैं कि आउटपुट में इनपुट का आकार समान हो।

conv2d प्रलेखन आउटपुट आकार के लिए स्पष्ट सूत्र देता है। उदाहरण के लिए Hin के साथ Hout पैडिंग के लिए हल कर सकता है:

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

चूँकि समान पैडिंग का अर्थ है पैडिंग = (कर्नेल_साइज़ - स्ट्राइड)//2, क्या होगा यदि पैडिंग = "समान" को इस तरह पेश किया जाए कि जब लिखा जाए, तो यह स्वचालित रूप से कर्नेल आकार और स्ट्राइड को पढ़ता है (जैसा कि nn.Conv2d में भी उल्लेख किया गया है) और पैडिंग लागू करता है स्वचालित रूप से तदनुसार

संदर्भ के लिए same पैडिंग के साथ यहां एक बहुत ही सरल Conv2d परत है। यह केवल वर्गाकार गुठली और स्ट्राइड = 1, फैलाव = 1, समूह = 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 का केंद्रीय लक्ष्य अनुसंधान और हैक करने की क्षमता के लिए एक महान मंच प्रदान करना है। इसलिए, जब हम इन सभी [उत्पादन-उपयोग] अनुकूलनों को जोड़ते हैं, तो हम एक कठिन डिज़ाइन बाधा के साथ काम कर रहे हैं ताकि इन्हें उपयोगिता के विरुद्ध कभी भी व्यापार न किया जा सके।

अनजाने में, मैं केरस के साथ-साथ मूल tf.layers / अनुमानक एपीआई का उपयोग करने की पृष्ठभूमि से आया हूं। सभी के पास same पैडिंग का समर्थन है। मैं वर्तमान में एक कन्वनेट को फिर से कार्यान्वित कर रहा हूं जिसे मैंने मूल रूप से टीएफ में पायटॉर्च के साथ लिखा था, और तथ्य यह है कि मुझे शून्य-पैडिंग के लिए अंकगणित में निर्माण करना पड़ा है, मुझे लगभग आधे दिन का समय लगा है।

यदि "केंद्रीय लक्ष्य" वास्तव में उपयोगिता पर केंद्रित है, तो मैं तर्क दूंगा कि भले ही प्रत्येक फॉरवर्ड पास (जैसा कि ऊपर बताया गया है) पर शून्य-पैडिंग की गणना करने के लिए एक दक्षता हिट है, डेवलपर दक्षता और रखरखाव के मामले में बचाया गया समय ( उदाहरण के लिए शून्य पैडिंग की गणना करने के लिए कस्टम कोड लिखना नहीं है) ट्रेडऑफ़ के लायक हो सकता है। विचार?

मैं इस सुविधा का उपयोग करूंगा

यह मेरे लिए कोई मायने नहीं रखता है कि padding=SAME का वैकल्पिक एपीआई क्यों नहीं पेश किया जा सकता है? अगर कोई पैडिंग का अतिरिक्त खर्च उठाने को तैयार है तो उन्हें ऐसा करने दें। कई शोधकर्ताओं के लिए, त्वरित प्रोटोटाइप एक आवश्यकता है।

हां, अगर कोई कृपया इसे जोड़ और स्वीकृत कर सकता है, तो यह बहुत अच्छा होगा।

निश्चित रूप से इसे जोड़ें, कॉनर इसे चाहता है।

क्या pytorch अब इसका समर्थन करता है? क्या यह वीजीजी में पहले की तरह ही ऑपरेशन का उपयोग कर सकता है, पैडिंग = (कर्नेल_साइज -1)/2 सेट करें?
वीजीजी नेटवर्क पहले समूह में आउटपुट का आकार नहीं बदल सकता है। फिर आप फीचरमैप का आकार बदलने के लिए स्ट्राइड का उपयोग कर सकते हैं, क्या यह ठीक लगता है?

डीपफेक से समान 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)

बस यह कहने के लिए छोड़ रहा हूं कि मैं भी इसकी बहुत सराहना करता हूं। वर्तमान में टेंसरफ़्लो से एक साधारण मॉडल को पोर्ट कर रहा है और गणनाओं को समझने में मुझे बहुत लंबा समय लग रहा है ...

ऐसा लगता है कि यह धागा अभी मर गया। यहां पसंद की संख्या को देखते हुए, तेजी से प्रोटोटाइप के लिए इस सुविधा को जोड़ना वाकई बहुत अच्छा होगा।

मैं इसके लिए एक प्रस्ताव लिखूंगा और हम इसे लागू करने के लिए किसी को ढूंढ सकते हैं।
मैं इसे v1.1 मील के पत्थर के खिलाफ रख रहा हूं।

धन्यवाद, आप कमाल हैं! मैंने पैडिंग तर्क को 4-टुपल स्वीकार करने के लिए अलग फीचर अनुरोध भी दायर किया। यह असममित के साथ-साथ सममित पैडिंग की अनुमति देगा जो कि आधे रास्ते तक पहुंचने के लिए कम लागत वाला मार्ग भी है।

@soumith पाइटोरच में एक पैडिंग मोड SAME होना अच्छा होगा।

@soumith एक संकलन प्रकार इंटरफ़ेस का उपयोग करने के बारे में कैसे?

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

मैंने उसी पैडिंग के साथ एक Conv2D बनाया, जो इस पर आधारित है कि TensorFlow उनका कैसे करता है। यह वास्तविक समय में इसकी गणना करता है, हालांकि, यदि आप इसे पूर्व-गणना करना चाहते हैं तो बस पैडिंग को 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

Ex1:
इनपुट आकार: (1, 3, 96, 96)
फिल्टर: 64
आकार: 9x9

Conv2dSame(3, 64, 9)

गद्देदार आकार: (1, 3, 104, 104)
आउटपुट आकार: (1, 64, 96, 96)

Ex2:
पहले जैसा ही, लेकिन स्ट्राइड के साथ=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 सहमत हैं, यह सुविधा निश्चित रूप से केरस/टीएफ मॉडल को PyTorch में पोर्ट करना आसान बना देगी। हर बार एक समय में, मैं अभी भी अपनी समान-गद्देदार परतों के निर्माण के लिए पैडिंग आकार की "मैनुअल" गणना का उपयोग करता हूं।

@kylemcdonald

संदर्भ के लिए same पैडिंग के साथ यहां एक बहुत ही सरल Conv2d परत है। यह केवल वर्गाकार गुठली और स्ट्राइड = 1, फैलाव = 1, समूह = 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 होना चाहिए या नहीं?

क्या यह रूपांतरण1d पर भी लागू होगा?

हो सकता है कि कक्षा ConvND में नई पैडिंग विधि जोड़ना एक सुंदर विकल्प होगा, और विधि को ओवरलोड करके, पैडिंग शेड्यूल को आसानी से बढ़ाया जा सकता है।

मैं शायद इसे ले सकता हूं यदि @soumith ने कभी वह प्रस्ताव लिखा हो या यदि कोई संक्षेप में बताता है कि क्या करने की आवश्यकता है। ऊपर बहुत चर्चा हो चुकी है और मुझे नहीं पता कि हमने क्या तय किया है। क्या हम इनपुट डेटा पर निर्भर पैडिंग की गणना कर रहे हैं या नहीं, क्या हमें पूल के लिए भी padding="same" को लागू करने की आवश्यकता है, आदि?

मैं कारण पैडिंग भी जोड़ना चाहता हूं। और कृपया इसे भी conv1d में जोड़ें।
मैंने कुछ बिंदु पर टिप्पणियों का पालन करना बंद कर दिया लेकिन मुझे लगता है कि यह सुविधा केरस में बहुत अच्छी तरह से की जाती है। आपको इसका ठीक से पालन करना चाहिए।

@Chillee यहाँ तुम जाओ:

दायरा

हमें निम्नलिखित परतों में पैडिंग जोड़नी चाहिए:

• रूपा*डी
• मैक्सपूल*डी
• औसत पूल*डी

पहले पीआर के लिए, इसे सरल रखें और केवल रूपांतरण*d से चिपके रहें।

जटिलता और डाउनसाइड्स

same पैडिंग विकल्प लिखे जाने के बाद, ऊपर चर्चा की गई जटिलता प्रकृति में गतिशील होने वाली परत के आसपास है। यही है, यह परत के पैरामीटर से स्थिर रूप से ज्ञात होता है, जो मॉडल निर्यात (उदाहरण के लिए ओएनएनएक्स निर्यात) के लिए बहुत अच्छा है, परत के गतिशील होने के पैरामीटर के लिए। इस मामले में, डायनामिक पैरामीटर 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 ints (यानी ऊंचाई/चौड़ाई के प्रत्येक आयाम के लिए) होने का समर्थन करते हैं।
हम के लिए एक अतिरिक्त अधिभार का समर्थन करना चाहिए padding कि एक स्ट्रिंग ले जाएगा, साथ मूल्य same ।

same पैडिंग को input को कनवल्शन को देने से पहले इस तरह से पैड करना चाहिए कि output आकार input आकार के समान हो।

कार्यान्वयन विवरण

जब 'same' को padding , तो हमें प्रत्येक आयाम में आवश्यक बाएँ और दाएँ पैडिंग की मात्रा की गणना करनी होती है।

आवश्यक एल (बाएं) और आर (दाएं) पैडिंग की गणना के बाद विचार करने के लिए दो मामले हैं:

• एल == आर: इस मामले में यह सममित पैडिंग है। कोई भी F.conv2d को padding मान के साथ L बराबर कॉल कर सकता है
• एल! = आर: इस मामले में, पैडिंग असममित है, और इसके महत्वपूर्ण प्रदर्शन और स्मृति प्रभाव हैं। हम निम्नलिखित करते हैं:
  
  
  
  • हम input_padded = F.pad(input, ...) कॉल करते हैं और input_padded को F.conv2d भेजते हैं।
  
  
  • हम प्रदर्शन निहितार्थ के बारे में इस मामले के लिए एक चेतावनी फेंकते हैं (कम से कम प्रारंभिक रिलीज के लिए, और यदि चेतावनी की आवश्यकता है तो हम फिर से जा सकते हैं)।
  
  
  • मुझे फॉर्मूलेशन का विवरण याद नहीं है और हम इस मामले को कहां दर्ज करते हैं, लेकिन अगर मुझे याद है, तो यह एक समान आकार के कर्नेल के रूप में सरल हो सकता है। यदि ऐसा है, तो उपयोगकर्ता की ओर से चेतावनी को आसानी से ठीक किया जा सकता है।
  
  

कहने की जरूरत नहीं है कि जेआईटी पथ पर भी काम करने के लिए इसका परीक्षण करना होगा

@चिली संदर्भ के लिए, https://github.com/mlperf/inference/blob/master/others/edge/object_detection/ssd_mobilenet/pytorch/utils.py#L40 से प्रेरणा प्राप्त करने के लिए यहां एक संभावित कार्यान्वयन है।

यह परीक्षण किए गए कॉन्फ़िगरेशन के लिए TF कार्यान्वयन से मेल खाता है, लेकिन परीक्षण संपूर्ण नहीं था

@ सौमिथ कुछ त्वरित प्रश्न:

1. क्या कोई कारण है कि हमें इसे functional.conv2d माध्यम से लागू नहीं करना चाहिए? आपके द्वारा लिखा गया डिज़ाइन यह दर्शाता है कि ऐसा नहीं होना चाहिए। padding = "समान" के बारे में ऐसा कुछ भी नहीं है जो ऐसा लगता है कि यह परतों के लिए विशिष्ट होना चाहिए। (संपादित करें: एनवीएम, उस 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 बराबर पैडिंग हो।

@ चिली के बारे में (1), कोई कारण नहीं, मैंने प्रभावों के माध्यम से नहीं सोचा था - पूर्ण या अन्यथा।

(2) हाँ।

इसके अलावा, हम स्थिर रूप से पैडिंग निर्धारित करने में सक्षम नहीं होंगे, सिवाय उस स्थिति को छोड़कर जब स्ट्राइड = 1, तब छत (x / स्ट्राइड) = x, और हमारे पास पैडिंग (फ़िल्टर -1) * फैलाव के बराबर है

हां, लेकिन स्ट्राइड = 1 सामान्य-पर्याप्त है और स्टैटिक पैडिंग के लाभ इतने अच्छे हैं कि हमें इसे विशेष रूप से संभालना चाहिए।

असममित पैडिंग के बारे में, ओह वेल .....

यह मेरे लिए कोई मायने नहीं रखता है कि padding=SAME का वैकल्पिक एपीआई क्यों नहीं पेश किया जा सकता है? अगर कोई पैडिंग का अतिरिक्त खर्च उठाने को तैयार है तो उन्हें ऐसा करने दें। कई शोधकर्ताओं के लिए, त्वरित प्रोटोटाइप एक आवश्यकता है।

हां,

यह मेरे लिए कोई मायने नहीं रखता है कि padding=SAME का वैकल्पिक एपीआई क्यों नहीं पेश किया जा सकता है? अगर कोई पैडिंग का अतिरिक्त खर्च उठाने को तैयार है तो उन्हें ऐसा करने दें। कई शोधकर्ताओं के लिए, त्वरित प्रोटोटाइप एक आवश्यकता है।

इस बात से सहमत! मैं इस साला "पैडिंग" में 4 घंटे तक फंस गया।

क्या हमारे पास इस समस्या के समाधान के बारे में कोई अपडेट है?

वाह और यहाँ मैंने सोचा था कि पाइटोरच केरस/टेन्सरफ़्लो 2.0 की तुलना में आसान होगा ...

@zwep आरंभ करने में थोड़ा और प्रयास है। आपको अपना ट्राइनिंग लूप लिखना होगा जो कष्टप्रद हो सकता है और आपको परतों को अधिक स्पष्ट रूप से लिखना होगा। एक बार जब आप यह कर लेते हैं (एक बार) तो आप इससे आगे वास्तविक सुधार पर बहुत आगे बढ़ सकते हैं।

मेरे अंगूठे का नियम केरस का उपयोग करना है यदि यह ऐसा कुछ है जिसे आपने दस लाख बार/सुपर मानक किया है।
किसी भी समय अनुसंधान और विकास शामिल होने पर pytorch का उपयोग करें।

यहाँ गद्देदार 1d रूपांतरण के लिए मेरा कोड है

मशाल आयात करें
मशाल आयात nn . से
np . के रूप में numpy आयात करें
मशाल आयात करें। एफ के रूप में कार्यात्मक

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 वह आदमी, कोड के लिए धन्यवाद। उस पाइटोरेक दर्शन को ध्यान में रखेंगे!

यह 2020 है। अभी भी पाइटोरच में 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 भी "वही पैडिंग" सुविधा चाहता हूं।

बीटीडब्लू, ऊपर चर्चा की गई पूर्ण/क्रमबद्धता चिंताओं के अतिरिक्त, टीएफ में आकार-निर्भर "समान" पैडिंग मोड एक अच्छा डिफ़ॉल्ट क्यों नहीं है, इस पर शुद्धता/सटीकता कारण हैं। मैंने https://github.com/tensorflow/tensorflow/issues/18213 में चर्चा की है और दिखाया है कि वास्तव में कई Google का अपना कोड आकार-स्वतंत्र "समान" पैडिंग मोड का उपयोग करता है।

ऐसा लगता है कि इस मुद्दे के बारे में अभी कोई काम नहीं चल रहा है, लेकिन अगर ऐसा है, तो मुझे उम्मीद है कि यह एक आकार-स्वतंत्र समाधान है।

नमस्ते, @ppwwyyxx Yuxin, प्रतिक्रिया के लिए धन्यवाद।
मुझे लगता है कि @ McHughes288 से कार्यान्वयन अच्छा है, और मुझे उनके कार्यान्वयन के बारे में आपकी राय के बारे में आश्चर्य है।

यहाँ Conv1D समान पैडिंग के लिए मेरा समाधान है (केवल तभी सही ढंग से काम करता है जब 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)

@Chillie क्या आप इस सुविधा पर काम करना जारी रखना चाहते हैं? मैं अभी के लिए आपको अनअसाइन करने जा रहा हूं ताकि हम इस मुद्दे की प्रगति को बेहतर ढंग से ट्रैक कर सकें, कृपया बेझिझक फिर से असाइन करें यदि आप अभी भी इस पर काम कर रहे हैं।

@wizcheu के कोड को पढ़ने के बाद, मैं पैडिंग = 'समान' के साथ 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

क्या इस पर कोई अपडेट है?

कोई अपडेट्स??

@ पीटरबेल 10 ने एक मसौदा पीआर जोड़ा है जिसका आप अनुसरण कर सकते हैं।