Caffe2 - Python API
A deep learning, cross platform ML framework
padding.py
1 from .module import Module
2 from .utils import _pair, _quadruple, _ntuple
3 from .. import functional as F
4 from ..._jit_internal import weak_module, weak_script_method
5 
6 
7 # TODO: grad_output size asserts in THNN
8 
9 
10 @weak_module
11 class _ConstantPadNd(Module):
12  __constants__ = ['padding', 'value']
13 
14  def __init__(self, value):
15  super(_ConstantPadNd, self).__init__()
16  self.value = value
17 
18  @weak_script_method
19  def forward(self, input):
20  return F.pad(input, self.padding, 'constant', self.value)
21 
22  def extra_repr(self):
23  return 'padding={}, value={}'.format(self.padding, self.value)
24 
25 
26 @weak_module
27 class ConstantPad1d(_ConstantPadNd):
28  r"""Pads the input tensor boundaries with a constant value.
29 
30  For `N`-dimensional padding, use :func:`torch.nn.functional.pad()`.
31 
32  Args:
33  padding (int, tuple): the size of the padding. If is `int`, uses the same
34  padding in both boundaries. If a 2-`tuple`, uses
35  (:math:`\text{padding\_left}`, :math:`\text{padding\_right}`)
36 
37  Shape:
38  - Input: :math:`(N, C, W_{in})`
39  - Output: :math:`(N, C, W_{out})` where
40 
41  :math:`W_{out} = W_{in} + \text{padding\_left} + \text{padding\_right}`
42 
43  Examples::
44 
45  >>> m = nn.ConstantPad1d(2, 3.5)
46  >>> input = torch.randn(1, 2, 4)
47  >>> input
48  tensor([[[-1.0491, -0.7152, -0.0749, 0.8530],
49  [-1.3287, 1.8966, 0.1466, -0.2771]]])
50  >>> m(input)
51  tensor([[[ 3.5000, 3.5000, -1.0491, -0.7152, -0.0749, 0.8530, 3.5000,
52  3.5000],
53  [ 3.5000, 3.5000, -1.3287, 1.8966, 0.1466, -0.2771, 3.5000,
54  3.5000]]])
55  >>> m = nn.ConstantPad1d(2, 3.5)
56  >>> input = torch.randn(1, 2, 3)
57  >>> input
58  tensor([[[ 1.6616, 1.4523, -1.1255],
59  [-3.6372, 0.1182, -1.8652]]])
60  >>> m(input)
61  tensor([[[ 3.5000, 3.5000, 1.6616, 1.4523, -1.1255, 3.5000, 3.5000],
62  [ 3.5000, 3.5000, -3.6372, 0.1182, -1.8652, 3.5000, 3.5000]]])
63  >>> # using different paddings for different sides
64  >>> m = nn.ConstantPad1d((3, 1), 3.5)
65  >>> m(input)
66  tensor([[[ 3.5000, 3.5000, 3.5000, 1.6616, 1.4523, -1.1255, 3.5000],
67  [ 3.5000, 3.5000, 3.5000, -3.6372, 0.1182, -1.8652, 3.5000]]])
68 
69  """
70 
71  def __init__(self, padding, value):
72  super(ConstantPad1d, self).__init__(value)
73  self.padding = _pair(padding)
74 
75 
76 @weak_module
77 class ConstantPad2d(_ConstantPadNd):
78  r"""Pads the input tensor boundaries with a constant value.
79 
80  For `N`-dimensional padding, use :func:`torch.nn.functional.pad()`.
81 
82  Args:
83  padding (int, tuple): the size of the padding. If is `int`, uses the same
84  padding in all boundaries. If a 4-`tuple`, uses (:math:`\text{padding\_left}`,
85  :math:`\text{padding\_right}`, :math:`\text{padding\_top}`, :math:`\text{padding\_bottom}`)
86 
87  Shape:
88  - Input: :math:`(N, C, H_{in}, W_{in})`
89  - Output: :math:`(N, C, H_{out}, W_{out})` where
90 
91  :math:`H_{out} = H_{in} + \text{padding\_top} + \text{padding\_bottom}`
92 
93  :math:`W_{out} = W_{in} + \text{padding\_left} + \text{padding\_right}`
94 
95  Examples::
96 
97  >>> m = nn.ConstantPad2d(2, 3.5)
98  >>> input = torch.randn(1, 2, 2)
99  >>> input
100  tensor([[[ 1.6585, 0.4320],
101  [-0.8701, -0.4649]]])
102  >>> m(input)
103  tensor([[[ 3.5000, 3.5000, 3.5000, 3.5000, 3.5000, 3.5000],
104  [ 3.5000, 3.5000, 3.5000, 3.5000, 3.5000, 3.5000],
105  [ 3.5000, 3.5000, 1.6585, 0.4320, 3.5000, 3.5000],
106  [ 3.5000, 3.5000, -0.8701, -0.4649, 3.5000, 3.5000],
107  [ 3.5000, 3.5000, 3.5000, 3.5000, 3.5000, 3.5000],
108  [ 3.5000, 3.5000, 3.5000, 3.5000, 3.5000, 3.5000]]])
109  >>> # using different paddings for different sides
110  >>> m = nn.ConstantPad2d((3, 0, 2, 1), 3.5)
111  >>> m(input)
112  tensor([[[ 3.5000, 3.5000, 3.5000, 3.5000, 3.5000],
113  [ 3.5000, 3.5000, 3.5000, 3.5000, 3.5000],
114  [ 3.5000, 3.5000, 3.5000, 1.6585, 0.4320],
115  [ 3.5000, 3.5000, 3.5000, -0.8701, -0.4649],
116  [ 3.5000, 3.5000, 3.5000, 3.5000, 3.5000]]])
117 
118  """
119  __constants__ = ['padding', 'value']
120 
121  def __init__(self, padding, value):
122  super(ConstantPad2d, self).__init__(value)
123  self.padding = _quadruple(padding)
124 
125 
126 @weak_module
127 class ConstantPad3d(_ConstantPadNd):
128  r"""Pads the input tensor boundaries with a constant value.
129 
130  For `N`-dimensional padding, use :func:`torch.nn.functional.pad()`.
131 
132  Args:
133  padding (int, tuple): the size of the padding. If is `int`, uses the same
134  padding in all boundaries. If a 6-`tuple`, uses
135  (:math:`\text{padding\_left}`, :math:`\text{padding\_right}`,
136  :math:`\text{padding\_top}`, :math:`\text{padding\_bottom}`,
137  :math:`\text{padding\_front}`, :math:`\text{padding\_back}`)
138 
139  Shape:
140  - Input: :math:`(N, C, D_{in}, H_{in}, W_{in})`
141  - Output: :math:`(N, C, D_{out}, H_{out}, W_{out})` where
142 
143  :math:`D_{out} = D_{in} + \text{padding\_front} + \text{padding\_back}`
144 
145  :math:`H_{out} = H_{in} + \text{padding\_top} + \text{padding\_bottom}`
146 
147  :math:`W_{out} = W_{in} + \text{padding\_left} + \text{padding\_right}`
148 
149  Examples::
150 
151  >>> m = nn.ConstantPad3d(3, 3.5)
152  >>> input = torch.randn(16, 3, 10, 20, 30)
153  >>> output = m(input)
154  >>> # using different paddings for different sides
155  >>> m = nn.ConstantPad3d((3, 3, 6, 6, 0, 1), 3.5)
156  >>> output = m(input)
157 
158  """
159 
160  def __init__(self, padding, value):
161  super(ConstantPad3d, self).__init__(value)
162  self.padding = _ntuple(6)(padding)
163 
164 
165 @weak_module
166 class _ReflectionPadNd(Module):
167  __constants__ = ['padding']
168 
169  @weak_script_method
170  def forward(self, input):
171  return F.pad(input, self.padding, 'reflect')
172 
173  def extra_repr(self):
174  return '{}'.format(self.padding)
175 
176 
177 @weak_module
178 class ReflectionPad1d(_ReflectionPadNd):
179  r"""Pads the input tensor using the reflection of the input boundary.
180 
181  For `N`-dimensional padding, use :func:`torch.nn.functional.pad()`.
182 
183  Args:
184  padding (int, tuple): the size of the padding. If is `int`, uses the same
185  padding in all boundaries. If a 2-`tuple`, uses
186  (:math:`\text{padding\_left}`, :math:`\text{padding\_right}`)
187 
188  Shape:
189  - Input: :math:`(N, C, W_{in})`
190  - Output: :math:`(N, C, W_{out})` where
191 
192  :math:`W_{out} = W_{in} + \text{padding\_left} + \text{padding\_right}`
193 
194  Examples::
195 
196  >>> m = nn.ReflectionPad1d(2)
197  >>> input = torch.arange(8, dtype=torch.float).reshape(1, 2, 4)
198  >>> input
199  tensor([[[0., 1., 2., 3.],
200  [4., 5., 6., 7.]]])
201  >>> m(input)
202  tensor([[[2., 1., 0., 1., 2., 3., 2., 1.],
203  [6., 5., 4., 5., 6., 7., 6., 5.]]])
204  >>> # using different paddings for different sides
205  >>> m = nn.ReflectionPad1d((3, 1))
206  >>> m(input)
207  tensor([[[3., 2., 1., 0., 1., 2., 3., 2.],
208  [7., 6., 5., 4., 5., 6., 7., 6.]]])
209 
210  """
211 
212  def __init__(self, padding):
213  super(ReflectionPad1d, self).__init__()
214  self.padding = _pair(padding)
215 
216 
217 @weak_module
218 class ReflectionPad2d(_ReflectionPadNd):
219  r"""Pads the input tensor using the reflection of the input boundary.
220 
221  For `N`-dimensional padding, use :func:`torch.nn.functional.pad()`.
222 
223  Args:
224  padding (int, tuple): the size of the padding. If is `int`, uses the same
225  padding in all boundaries. If a 4-`tuple`, uses (:math:`\text{padding\_left}`,
226  :math:`\text{padding\_right}`, :math:`\text{padding\_top}`, :math:`\text{padding\_bottom}`)
227 
228  Shape:
229  - Input: :math:`(N, C, H_{in}, W_{in})`
230  - Output: :math:`(N, C, H_{out}, W_{out})` where
231 
232  :math:`H_{out} = H_{in} + \text{padding\_top} + \text{padding\_bottom}`
233 
234  :math:`W_{out} = W_{in} + \text{padding\_left} + \text{padding\_right}`
235 
236  Examples::
237 
238  >>> m = nn.ReflectionPad2d(2)
239  >>> input = torch.arange(9, dtype=torch.float).reshape(1, 1, 3, 3)
240  >>> input
241  tensor([[[[0., 1., 2.],
242  [3., 4., 5.],
243  [6., 7., 8.]]]])
244  >>> m(input)
245  tensor([[[[8., 7., 6., 7., 8., 7., 6.],
246  [5., 4., 3., 4., 5., 4., 3.],
247  [2., 1., 0., 1., 2., 1., 0.],
248  [5., 4., 3., 4., 5., 4., 3.],
249  [8., 7., 6., 7., 8., 7., 6.],
250  [5., 4., 3., 4., 5., 4., 3.],
251  [2., 1., 0., 1., 2., 1., 0.]]]])
252  >>> # using different paddings for different sides
253  >>> m = nn.ReflectionPad2d((1, 1, 2, 0))
254  >>> m(input)
255  tensor([[[[7., 6., 7., 8., 7.],
256  [4., 3., 4., 5., 4.],
257  [1., 0., 1., 2., 1.],
258  [4., 3., 4., 5., 4.],
259  [7., 6., 7., 8., 7.]]]])
260 
261  """
262 
263  def __init__(self, padding):
264  super(ReflectionPad2d, self).__init__()
265  self.padding = _quadruple(padding)
266 
267 
268 @weak_module
269 class _ReplicationPadNd(Module):
270  __constants__ = ['padding']
271 
272  @weak_script_method
273  def forward(self, input):
274  return F.pad(input, self.padding, 'replicate')
275 
276  def extra_repr(self):
277  return '{}'.format(self.padding)
278 
279 
280 @weak_module
281 class ReplicationPad1d(_ReplicationPadNd):
282  r"""Pads the input tensor using replication of the input boundary.
283 
284  For `N`-dimensional padding, use :func:`torch.nn.functional.pad()`.
285 
286  Args:
287  padding (int, tuple): the size of the padding. If is `int`, uses the same
288  padding in all boundaries. If a 2-`tuple`, uses
289  (:math:`\text{padding\_left}`, :math:`\text{padding\_right}`)
290 
291  Shape:
292  - Input: :math:`(N, C, W_{in})`
293  - Output: :math:`(N, C, W_{out})` where
294 
295  :math:`W_{out} = W_{in} + \text{padding\_left} + \text{padding\_right}`
296 
297  Examples::
298 
299  >>> m = nn.ReplicationPad1d(2)
300  >>> input = torch.arange(8, dtype=torch.float).reshape(1, 2, 4)
301  >>> input
302  tensor([[[0., 1., 2., 3.],
303  [4., 5., 6., 7.]]])
304  >>> m(input)
305  tensor([[[0., 0., 0., 1., 2., 3., 3., 3.],
306  [4., 4., 4., 5., 6., 7., 7., 7.]]])
307  >>> # using different paddings for different sides
308  >>> m = nn.ReplicationPad1d((3, 1))
309  >>> m(input)
310  tensor([[[0., 0., 0., 0., 1., 2., 3., 3.],
311  [4., 4., 4., 4., 5., 6., 7., 7.]]])
312 
313  """
314 
315  def __init__(self, padding):
316  super(ReplicationPad1d, self).__init__()
317  self.padding = _pair(padding)
318 
319 
320 @weak_module
321 class ReplicationPad2d(_ReplicationPadNd):
322  r"""Pads the input tensor using replication of the input boundary.
323 
324  For `N`-dimensional padding, use :func:`torch.nn.functional.pad()`.
325 
326  Args:
327  padding (int, tuple): the size of the padding. If is `int`, uses the same
328  padding in all boundaries. If a 4-`tuple`, uses (:math:`\text{padding\_left}`,
329  :math:`\text{padding\_right}`, :math:`\text{padding\_top}`, :math:`\text{padding\_bottom}`)
330 
331  Shape:
332  - Input: :math:`(N, C, H_{in}, W_{in})`
333  - Output: :math:`(N, C, H_{out}, W_{out})` where
334 
335  :math:`H_{out} = H_{in} + \text{padding\_top} + \text{padding\_bottom}`
336 
337  :math:`W_{out} = W_{in} + \text{padding\_left} + \text{padding\_right}`
338 
339  Examples::
340 
341  >>> m = nn.ReplicationPad2d(2)
342  >>> input = torch.arange(9, dtype=torch.float).reshape(1, 1, 3, 3)
343  >>> input
344  tensor([[[[0., 1., 2.],
345  [3., 4., 5.],
346  [6., 7., 8.]]]])
347  >>> m(input)
348  tensor([[[[0., 0., 0., 1., 2., 2., 2.],
349  [0., 0., 0., 1., 2., 2., 2.],
350  [0., 0., 0., 1., 2., 2., 2.],
351  [3., 3., 3., 4., 5., 5., 5.],
352  [6., 6., 6., 7., 8., 8., 8.],
353  [6., 6., 6., 7., 8., 8., 8.],
354  [6., 6., 6., 7., 8., 8., 8.]]]])
355  >>> # using different paddings for different sides
356  >>> m = nn.ReplicationPad2d((1, 1, 2, 0))
357  >>> m(input)
358  tensor([[[[0., 0., 1., 2., 2.],
359  [0., 0., 1., 2., 2.],
360  [0., 0., 1., 2., 2.],
361  [3., 3., 4., 5., 5.],
362  [6., 6., 7., 8., 8.]]]])
363 
364  """
365 
366  def __init__(self, padding):
367  super(ReplicationPad2d, self).__init__()
368  self.padding = _quadruple(padding)
369 
370 
371 @weak_module
372 class ReplicationPad3d(_ReplicationPadNd):
373  r"""Pads the input tensor using replication of the input boundary.
374 
375  For `N`-dimensional padding, use :func:`torch.nn.functional.pad()`.
376 
377  Args:
378  padding (int, tuple): the size of the padding. If is `int`, uses the same
379  padding in all boundaries. If a 6-`tuple`, uses
380  (:math:`\text{padding\_left}`, :math:`\text{padding\_right}`,
381  :math:`\text{padding\_top}`, :math:`\text{padding\_bottom}`,
382  :math:`\text{padding\_front}`, :math:`\text{padding\_back}`)
383 
384  Shape:
385  - Input: :math:`(N, C, D_{in}, H_{in}, W_{in})`
386  - Output: :math:`(N, C, D_{out}, H_{out}, W_{out})` where
387 
388  :math:`D_{out} = D_{in} + \text{padding\_front} + \text{padding\_back}`
389 
390  :math:`H_{out} = H_{in} + \text{padding\_top} + \text{padding\_bottom}`
391 
392  :math:`W_{out} = W_{in} + \text{padding\_left} + \text{padding\_right}`
393 
394  Examples::
395 
396  >>> m = nn.ReplicationPad3d(3)
397  >>> input = torch.randn(16, 3, 8, 320, 480)
398  >>> output = m(input)
399  >>> # using different paddings for different sides
400  >>> m = nn.ReplicationPad3d((3, 3, 6, 6, 1, 1))
401  >>> output = m(input)
402 
403  """
404 
405  def __init__(self, padding):
406  super(ReplicationPad3d, self).__init__()
407  self.padding = _ntuple(6)(padding)
408 
409 
410 @weak_module
411 class ZeroPad2d(ConstantPad2d):
412  r"""Pads the input tensor boundaries with zero.
413 
414  For `N`-dimensional padding, use :func:`torch.nn.functional.pad()`.
415 
416  Args:
417  padding (int, tuple): the size of the padding. If is `int`, uses the same
418  padding in all boundaries. If a 4-`tuple`, uses (:math:`\text{padding\_left}`,
419  :math:`\text{padding\_right}`, :math:`\text{padding\_top}`, :math:`\text{padding\_bottom}`)
420 
421  Shape:
422  - Input: :math:`(N, C, H_{in}, W_{in})`
423  - Output: :math:`(N, C, H_{out}, W_{out})` where
424 
425  :math:`H_{out} = H_{in} + \text{padding\_top} + \text{padding\_bottom}`
426 
427  :math:`W_{out} = W_{in} + \text{padding\_left} + \text{padding\_right}`
428 
429  Examples::
430 
431  >>> m = nn.ZeroPad2d(2)
432  >>> input = torch.randn(1, 1, 3, 3)
433  >>> input
434  tensor([[[[-0.1678, -0.4418, 1.9466],
435  [ 0.9604, -0.4219, -0.5241],
436  [-0.9162, -0.5436, -0.6446]]]])
437  >>> m(input)
438  tensor([[[[ 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000],
439  [ 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000],
440  [ 0.0000, 0.0000, -0.1678, -0.4418, 1.9466, 0.0000, 0.0000],
441  [ 0.0000, 0.0000, 0.9604, -0.4219, -0.5241, 0.0000, 0.0000],
442  [ 0.0000, 0.0000, -0.9162, -0.5436, -0.6446, 0.0000, 0.0000],
443  [ 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000],
444  [ 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000]]]])
445  >>> # using different paddings for different sides
446  >>> m = nn.ZeroPad2d((1, 1, 2, 0))
447  >>> m(input)
448  tensor([[[[ 0.0000, 0.0000, 0.0000, 0.0000, 0.0000],
449  [ 0.0000, 0.0000, 0.0000, 0.0000, 0.0000],
450  [ 0.0000, -0.1678, -0.4418, 1.9466, 0.0000],
451  [ 0.0000, 0.9604, -0.4219, -0.5241, 0.0000],
452  [ 0.0000, -0.9162, -0.5436, -0.6446, 0.0000]]]])
453 
454  """
455 
456  def __init__(self, padding):
457  super(ZeroPad2d, self).__init__(padding, 0.)
torch.nn.modules.padding._ReflectionPadNd
Definition: padding.py:166
torch.nn.modules.padding._ConstantPadNd.value
value
Definition: padding.py:16
torch.nn.modules.padding._ReplicationPadNd
Definition: padding.py:269
torch.nn.modules.padding._ConstantPadNd
Definition: padding.py:11
Generated on Thu Mar 21 2019 13:06:37 for Caffe2 - Python API by   doxygen 1.8.11