OSSForks/pytorch
1
0
Fork 0
mirror of https://github.com/zebrajr/pytorch.git synced 2025-12-07 00:21:07 +01:00
Code Issues Actions 38 Packages Projects Releases Wiki Activity
59bda9a8c4
pytorch/torch/nn/modules/padding.py
Tongzhou Wang 59bda9a8c4
Fix reflection padding boundary checks (#6438) 
* Fix Reflection padding boundary checks

* Improve padding docs

* fix lint
2018-04-10 10:37:01 -04:00

481 lines
14 KiB
Python
Raw Blame History

from .module import Module
from .utils import _pair, _quadruple, _ntuple
from .. import functional as F
# TODO: grad_output size asserts in THNN
class _ConstantPadNd(Module):
def __init__(self, value):
super(_ConstantPadNd, self).__init__()
self.value = value
def forward(self, input):
return F.pad(input, self.padding, 'constant', self.value)
def extra_repr(self):
return 'padding={}, value={}'.format(self.padding, self.value)
class ConstantPad1d(_ConstantPadNd):
r"""Pads the input tensor boundaries with a constant value.
For `N`d-padding, use :func:`torch.nn.functional.pad()`.
Args:
padding (int, tuple): the size of the padding. If is `int`, uses the same
padding in both boundaries. If a 2-`tuple`, uses (`paddingLeft`, `paddingRight`)
Shape:
- Input: :math:`(N, C, W_{in})`
- Output: :math:`(N, C, W_{out})` where
:math:`W_{out} = W_{in} + \textit{paddingLeft} + \textit{paddingRight}`
Examples::
>>> m = nn.ConstantPad1d(2, 3.5)
>>> input = torch.randn(1, 2, 4)
>>> input
(0 ,.,.) =
0.1875 0.5046 -1.0074 2.0005
-0.3540 -1.8645 1.1530 0.0632
[torch.FloatTensor of size (1,2,4)]
>>> m(input)
(0 ,.,.) =
3.5000 3.5000 0.1875 0.5046 -1.0074 2.0005 3.5000 3.5000
3.5000 3.5000 -0.3540 -1.8645 1.1530 0.0632 3.5000 3.5000
[torch.FloatTensor of size (1,2,8)]
>>> # using different paddings
>>> m = nn.ConstantPad1d((3, 1), 3.5)
>>> m(input)
(0 ,.,.) =
3.5000 3.5000 3.5000 0.1875 0.5046 -1.0074 2.0005 3.5000
3.5000 3.5000 3.5000 -0.3540 -1.8645 1.1530 0.0632 3.5000
[torch.FloatTensor of size (1,2,8)]
"""
def __init__(self, padding, value):
super(ConstantPad1d, self).__init__(value)
self.padding = _pair(padding)
class ConstantPad2d(_ConstantPadNd):
r"""Pads the input tensor boundaries with a constant value.
For `N`d-padding, use :func:`torch.nn.functional.pad()`.
Args:
padding (int, tuple): the size of the padding. If is `int`, uses the same
padding in all boundaries. If a 4-`tuple`, uses (`paddingLeft`, `paddingRight`,
`paddingTop`, `paddingBottom`)
Shape:
- Input: :math:`(N, C, H_{in}, W_{in})`
- Output: :math:`(N, C, H_{out}, W_{out})` where
:math:`H_{out} = H_{in} + \textit{paddingTop} + \textit{paddingBottom}`
:math:`W_{out} = W_{in} + \textit{paddingLeft} + \textit{paddingRight}`
Examples::
>>> m = nn.ConstantPad2d(2, 3.5)
>>> input = torch.randn(1, 2, 2)
>>> input
(0 ,.,.) =
-0.2295 -0.9774
-0.3335 -1.4178
[torch.FloatTensor of size (1,2,2)]
>>> m(input)
(0 ,.,.) =
3.5000 3.5000 3.5000 3.5000 3.5000 3.5000
3.5000 3.5000 3.5000 3.5000 3.5000 3.5000
3.5000 3.5000 -0.2295 -0.9774 3.5000 3.5000
3.5000 3.5000 -0.3335 -1.4178 3.5000 3.5000
3.5000 3.5000 3.5000 3.5000 3.5000 3.5000
3.5000 3.5000 3.5000 3.5000 3.5000 3.5000
[torch.FloatTensor of size (1,6,6)]
>>> # using different paddings
>>> m = nn.ConstantPad2d((3, 0, 2, 1), 3.5)
>>> m(input)
(0 ,.,.) =
3.5000 3.5000 3.5000 3.5000 3.5000
3.5000 3.5000 3.5000 3.5000 3.5000
3.5000 3.5000 3.5000 -0.2295 -0.9774
3.5000 3.5000 3.5000 -0.3335 -1.4178
3.5000 3.5000 3.5000 3.5000 3.5000
[torch.FloatTensor of size (1,5,5)]
"""
def __init__(self, padding, value):
super(ConstantPad2d, self).__init__(value)
self.padding = _quadruple(padding)
class ConstantPad3d(_ConstantPadNd):
r"""Pads the input tensor boundaries with a constant value.
For `N`d-padding, use :func:`torch.nn.functional.pad()`.
Args:
padding (int, tuple): the size of the padding. If is `int`, uses the same
padding in all boundaries. If a 6-`tuple`, uses
(`paddingLeft`, `paddingRight`, `paddingTop`, `paddingBottom`, `paddingFront`, `paddingBack`)
Shape:
- Input: :math:`(N, C, D_{in}, H_{in}, W_{in})`
- Output: :math:`(N, C, D_{out}, H_{out}, W_{out})` where
:math:`D_{out} = D_{in} + \textit{paddingFront} + \textit{paddingBack}`
:math:`H_{out} = H_{in} + \textit{paddingTop} + \textit{paddingBottom}`
:math:`W_{out} = W_{in} + \textit{paddingLeft} + \textit{paddingRight}`
Examples::
>>> m = nn.ConstantPad3d(3, 3.5)
>>> input = torch.randn(16, 3, 10, 20, 30)
>>> output = m(input)
>>> # using different paddings
>>> m = nn.ConstantPad3d((3, 3, 6, 6, 0, 1), 3.5)
>>> output = m(input)
"""
def __init__(self, padding, value):
super(ConstantPad3d, self).__init__(value)
self.padding = _ntuple(6)(padding)
class _ReflectionPadNd(Module):
def forward(self, input):
return F.pad(input, self.padding, 'reflect')
def extra_repr(self):
return '{}'.format(self.padding)
class ReflectionPad1d(_ReflectionPadNd):
r"""Pads the input tensor using the reflection of the input boundary.
For `N`d-padding, use :func:`torch.nn.functional.pad()`.
Args:
padding (int, tuple): the size of the padding. If is `int`, uses the same
padding in all boundaries. If a 2-`tuple`, uses (`paddingLeft`, `paddingRight`)
Shape:
- Input: :math:`(N, C, W_{in})`
- Output: :math:`(N, C, W_{out})` where
:math:`W_{out} = W_{in} + \textit{paddingLeft} + \textit{paddingRight}`
Examples::
>>> m = nn.ReflectionPad1d(2)
>>> input = torch.arange(8).reshape(1, 2, 4)
>>> input
(0 ,.,.) =
0 1 2 3
4 5 6 7
[torch.FloatTensor of size (1,2,4)]
>>> m(input)
(0 ,.,.) =
2 1 0 1 2 3 2 1
6 5 4 5 6 7 6 5
[torch.FloatTensor of size (1,2,8)]
>>> # using different paddings
>>> m = nn.ReflectionPad1d((3, 1))
>>> m(input)
(0 ,.,.) =
3 2 1 0 1 2 3 2
7 6 5 4 5 6 7 6
[torch.FloatTensor of size (1,2,8)]
"""
def __init__(self, padding):
super(ReflectionPad1d, self).__init__()
self.padding = _pair(padding)
class ReflectionPad2d(_ReflectionPadNd):
r"""Pads the input tensor using the reflection of the input boundary.
For `N`d-padding, use :func:`torch.nn.functional.pad()`.
Args:
padding (int, tuple): the size of the padding. If is `int`, uses the same
padding in all boundaries. If a 4-`tuple`, uses (`paddingLeft`, `paddingRight`,
`paddingTop`, `paddingBottom`)
Shape:
- Input: :math:`(N, C, H_{in}, W_{in})`
- Output: :math:`(N, C, H_{out}, W_{out})` where
:math:`H_{out} = H_{in} + \textit{paddingTop} + \textit{paddingBottom}`
:math:`W_{out} = W_{in} + \textit{paddingLeft} + \textit{paddingRight}`
Examples::
>>> m = nn.ReflectionPad2d(2)
>>> input = torch.arange(9).reshape(1, 1, 3, 3)
>>> input
(0 ,0 ,.,.) =
0 1 2
3 4 5
6 7 8
[torch.FloatTensor of size (1,1,3,3)]
>>> m(input)
(0 ,0 ,.,.) =
8 7 6 7 8 7 6
5 4 3 4 5 4 3
2 1 0 1 2 1 0
5 4 3 4 5 4 3
8 7 6 7 8 7 6
5 4 3 4 5 4 3
2 1 0 1 2 1 0
[torch.FloatTensor of size (1,1,7,7)]
>>> # using different paddings
>>> m = nn.ReflectionPad2d((1, 1, 2, 0))
>>> m(input)
(0 ,0 ,.,.) =
7 6 7 8 7
4 3 4 5 4
1 0 1 2 1
4 3 4 5 4
7 6 7 8 7
[torch.FloatTensor of size (1,1,5,5)]
"""
def __init__(self, padding):
super(ReflectionPad2d, self).__init__()
self.padding = _quadruple(padding)
class _ReplicationPadNd(Module):
def forward(self, input):
return F.pad(input, self.padding, 'replicate')
def extra_repr(self):
return '{}'.format(self.padding)
class ReplicationPad1d(_ReplicationPadNd):
r"""Pads the input tensor using replication of the input boundary.
For `N`d-padding, use :func:`torch.nn.functional.pad()`.
Args:
padding (int, tuple): the size of the padding. If is `int`, uses the same
padding in all boundaries. If a 2-`tuple`, uses (`paddingLeft`, `paddingRight`)
Shape:
- Input: :math:`(N, C, W_{in})`
- Output: :math:`(N, C, W_{out})` where
:math:`W_{out} = W_{in} + \textit{paddingLeft} + \textit{paddingRight}`
Examples::
>>> m = nn.ReplicationPad1d(2)
>>> input = torch.arange(8).reshape(1, 2, 4)
>>> input
(0 ,.,.) =
0 1 2 3
4 5 6 7
[torch.FloatTensor of size (1,2,4)]
>>> m(input)
(0 ,.,.) =
0 0 0 1 2 3 3 3
4 4 4 5 6 7 7 7
[torch.FloatTensor of size (1,2,8)]
>>> # using different paddings
>>> m = nn.ReplicationPad1d((3, 1))
>>> m(input)
(0 ,.,.) =
0 0 0 0 1 2 3 3
4 4 4 4 5 6 7 7
[torch.FloatTensor of size (1,2,8)]
"""
def __init__(self, padding):
super(ReplicationPad1d, self).__init__()
self.padding = _pair(padding)
class ReplicationPad2d(_ReplicationPadNd):
r"""Pads the input tensor using replication of the input boundary.
For `N`d-padding, use :func:`torch.nn.functional.pad()`.
Args:
padding (int, tuple): the size of the padding. If is `int`, uses the same
padding in all boundaries. If a 4-`tuple`, uses (`paddingLeft`, `paddingRight`,
`paddingTop`, `paddingBottom`)
Shape:
- Input: :math:`(N, C, H_{in}, W_{in})`
- Output: :math:`(N, C, H_{out}, W_{out})` where
:math:`H_{out} = H_{in} + \textit{paddingTop} + \textit{paddingBottom}`
:math:`W_{out} = W_{in} + \textit{paddingLeft} + \textit{paddingRight}`
Examples::
>>> m = nn.ReplicationPad2d(2)
>>> input = torch.arange(9).reshape(1, 1, 3, 3)
>>> input
(0 ,0 ,.,.) =
0 1 2
3 4 5
6 7 8
[torch.FloatTensor of size (1,1,3,3)]
>>> m(input)
(0 ,0 ,.,.) =
0 0 0 1 2 2 2
0 0 0 1 2 2 2
0 0 0 1 2 2 2
3 3 3 4 5 5 5
6 6 6 7 8 8 8
6 6 6 7 8 8 8
6 6 6 7 8 8 8
[torch.FloatTensor of size (1,1,7,7)]
>>> # using different paddings
>>> m = nn.ReplicationPad2d((1, 1, 2, 0))
>>> m(input)
(0 ,0 ,.,.) =
0 0 1 2 2
0 0 1 2 2
0 0 1 2 2
3 3 4 5 5
6 6 7 8 8
[torch.FloatTensor of size (1,1,5,5)]
"""
def __init__(self, padding):
super(ReplicationPad2d, self).__init__()
self.padding = _quadruple(padding)
class ReplicationPad3d(_ReplicationPadNd):
r"""Pads the input tensor using replication of the input boundary.
For `N`d-padding, use :func:`torch.nn.functional.pad()`.
Args:
padding (int, tuple): the size of the padding. If is `int`, uses the same
padding in all boundaries. If a 6-`tuple`, uses (`paddingLeft`, `paddingRight`,
`paddingTop`, `paddingBottom`, `paddingFront`, `paddingBack`)
Shape:
- Input: :math:`(N, C, D_{in}, H_{in}, W_{in})`
- Output: :math:`(N, C, D_{out}, H_{out}, W_{out})` where
:math:`D_{out} = D_{in} + \textit{paddingFront} + \textit{paddingBack}`
:math:`H_{out} = H_{in} + \textit{paddingTop} + \textit{paddingBottom}`
:math:`W_{out} = W_{in} + \textit{paddingLeft} + \textit{paddingRight}`
Examples::
>>> m = nn.ReplicationPad3d(3)
>>> input = torch.randn(16, 3, 8, 320, 480)
>>> output = m(input)
>>> # using different paddings
>>> m = nn.ReplicationPad3d((3, 3, 6, 6, 1, 1))
>>> output = m(input)
"""
def __init__(self, padding):
super(ReplicationPad3d, self).__init__()
self.padding = _ntuple(6)(padding)
class ZeroPad2d(ConstantPad2d):
r"""Pads the input tensor boundaries with zero.
For `N`d-padding, use :func:`torch.nn.functional.pad()`.
Args:
padding (int, tuple): the size of the padding. If is `int`, uses the same
padding in all boundaries. If a 4-`tuple`, uses (`paddingLeft`, `paddingRight`,
`paddingTop`, `paddingBottom`)
Shape:
- Input: :math:`(N, C, H_{in}, W_{in})`
- Output: :math:`(N, C, H_{out}, W_{out})` where
:math:`H_{out} = H_{in} + \textit{paddingTop} + \textit{paddingBottom}`
:math:`W_{out} = W_{in} + \textit{paddingLeft} + \textit{paddingRight}`
Examples::
>>> m = nn.ZeroPad2d(2)
>>> input = torch.randn(1, 1, 3, 3)
>>> input
(0 ,0 ,.,.) =
1.4418 -1.9812 -0.3815
-0.3828 -0.6833 -0.2376
0.1433 0.0211 0.4311
[torch.FloatTensor of size (1,1,3,3)]
>>> m(input)
(0 ,0 ,.,.) =
0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000
0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000
0.0000 0.0000 1.4418 -1.9812 -0.3815 0.0000 0.0000
0.0000 0.0000 -0.3828 -0.6833 -0.2376 0.0000 0.0000
0.0000 0.0000 0.1433 0.0211 0.4311 0.0000 0.0000
0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000
0.0000 0.0000 0.0000 0.0000 0.0000 0.0000 0.0000
[torch.FloatTensor of size (1,1,7,7)]
>>> # using different paddings
>>> m = nn.ZeroPad2d((1, 1, 2, 0))
>>> m(input)
(0 ,0 ,.,.) =
0.0000 0.0000 0.0000 0.0000 0.0000
0.0000 0.0000 0.0000 0.0000 0.0000
0.0000 1.4418 -1.9812 -0.3815 0.0000
0.0000 -0.3828 -0.6833 -0.2376 0.0000
0.0000 0.1433 0.0211 0.4311 0.0000
[torch.FloatTensor of size (1,1,5,5)]
"""
def __init__(self, padding):
super(ZeroPad2d, self).__init__(padding, 0)
Reference in New Issue View Git Blame Copy Permalink