Shortcuts

from .module import Module
from .utils import _pair, _quadruple, _ntuple
from .. import functional as F

from torch import Tensor
from ..common_types import _size_2_t, _size_4_t, _size_6_t
from typing import Sequence, Tuple

# TODO: grad_output size asserts in THNN

value: float

def __init__(self, value: float) -> None:
self.value = value

def forward(self, input: Tensor) -> Tensor:

def extra_repr(self) -> str:

r"""Pads the input tensor boundaries with a constant value.

For N-dimensional 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
(:math:\text{padding\_left}, :math:\text{padding\_right})

Shape:
- Input: :math:(C, W_{in}) or :math:(N, C, W_{in}).
- Output: :math:(C, W_{out}) or :math:(N, C, W_{out}), where

:math:W_{out} = W_{in} + \text{padding\_left} + \text{padding\_right}

Examples::

>>> input = torch.randn(1, 2, 4)
>>> input
tensor([[[-1.0491, -0.7152, -0.0749,  0.8530],
[-1.3287,  1.8966,  0.1466, -0.2771]]])
>>> m(input)
tensor([[[ 3.5000,  3.5000, -1.0491, -0.7152, -0.0749,  0.8530,  3.5000,
3.5000],
[ 3.5000,  3.5000, -1.3287,  1.8966,  0.1466, -0.2771,  3.5000,
3.5000]]])
>>> input = torch.randn(1, 2, 3)
>>> input
tensor([[[ 1.6616,  1.4523, -1.1255],
[-3.6372,  0.1182, -1.8652]]])
>>> m(input)
tensor([[[ 3.5000,  3.5000,  1.6616,  1.4523, -1.1255,  3.5000,  3.5000],
[ 3.5000,  3.5000, -3.6372,  0.1182, -1.8652,  3.5000,  3.5000]]])
>>> # using different paddings for different sides
>>> m = nn.ConstantPad1d((3, 1), 3.5)
>>> m(input)
tensor([[[ 3.5000,  3.5000,  3.5000,  1.6616,  1.4523, -1.1255,  3.5000],
[ 3.5000,  3.5000,  3.5000, -3.6372,  0.1182, -1.8652,  3.5000]]])

"""

def __init__(self, padding: _size_2_t, value: float):

r"""Pads the input tensor boundaries with a constant value.

For N-dimensional 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 (:math:\text{padding\_left},
:math:\text{padding\_right}, :math:\text{padding\_top}, :math:\text{padding\_bottom})

Shape:
- Input: :math:(N, C, H_{in}, W_{in}) or :math:(C, H_{in}, W_{in}).
- Output: :math:(N, C, H_{out}, W_{out}) or :math:(C, H_{out}, W_{out}), where

:math:H_{out} = H_{in} + \text{padding\_top} + \text{padding\_bottom}

:math:W_{out} = W_{in} + \text{padding\_left} + \text{padding\_right}

Examples::

>>> input = torch.randn(1, 2, 2)
>>> input
tensor([[[ 1.6585,  0.4320],
[-0.8701, -0.4649]]])
>>> m(input)
tensor([[[ 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,  1.6585,  0.4320,  3.5000,  3.5000],
[ 3.5000,  3.5000, -0.8701, -0.4649,  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]]])
>>> # using different paddings for different sides
>>> m = nn.ConstantPad2d((3, 0, 2, 1), 3.5)
>>> m(input)
tensor([[[ 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,  1.6585,  0.4320],
[ 3.5000,  3.5000,  3.5000, -0.8701, -0.4649],
[ 3.5000,  3.5000,  3.5000,  3.5000,  3.5000]]])

"""

def __init__(self, padding: _size_4_t, value: float) -> None:

r"""Pads the input tensor boundaries with a constant value.

For N-dimensional 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
(:math:\text{padding\_left}, :math:\text{padding\_right},
:math:\text{padding\_top}, :math:\text{padding\_bottom},
:math:\text{padding\_front}, :math:\text{padding\_back})

Shape:
- Input: :math:(N, C, D_{in}, H_{in}, W_{in}) or :math:(C, D_{in}, H_{in}, W_{in}).
- Output: :math:(N, C, D_{out}, H_{out}, W_{out}) or
:math:(C, D_{out}, H_{out}, W_{out}), where

:math:D_{out} = D_{in} + \text{padding\_front} + \text{padding\_back}

:math:H_{out} = H_{in} + \text{padding\_top} + \text{padding\_bottom}

:math:W_{out} = W_{in} + \text{padding\_left} + \text{padding\_right}

Examples::

>>> input = torch.randn(16, 3, 10, 20, 30)
>>> output = m(input)
>>> # using different paddings for different sides
>>> m = nn.ConstantPad3d((3, 3, 6, 6, 0, 1), 3.5)
>>> output = m(input)

"""
padding: Tuple[int, int, int, int, int, int]

def __init__(self, padding: _size_6_t, value: float) -> None:

def forward(self, input: Tensor) -> Tensor:

def extra_repr(self) -> str:

r"""Pads the input tensor using the reflection of the input boundary.

For N-dimensional 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
(:math:\text{padding\_left}, :math:\text{padding\_right})

Shape:
- Input: :math:(C, W_{in}) or :math:(N, C, W_{in}).
- Output: :math:(C, W_{out}) or :math:(N, C, W_{out}), where

:math:W_{out} = W_{in} + \text{padding\_left} + \text{padding\_right}

Examples::

>>> input = torch.arange(8, dtype=torch.float).reshape(1, 2, 4)
>>> input
tensor([[[0., 1., 2., 3.],
[4., 5., 6., 7.]]])
>>> m(input)
tensor([[[2., 1., 0., 1., 2., 3., 2., 1.],
[6., 5., 4., 5., 6., 7., 6., 5.]]])
>>> # using different paddings for different sides
>>> m(input)
tensor([[[3., 2., 1., 0., 1., 2., 3., 2.],
[7., 6., 5., 4., 5., 6., 7., 6.]]])

"""

def __init__(self, padding: _size_2_t) -> None:

r"""Pads the input tensor using the reflection of the input boundary.

For N-dimensional 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 (:math:\text{padding\_left},
:math:\text{padding\_right}, :math:\text{padding\_top}, :math:\text{padding\_bottom})

Shape:
- Input: :math:(N, C, H_{in}, W_{in}) or :math:(C, H_{in}, W_{in}).
- Output: :math:(N, C, H_{out}, W_{out}) or :math:(C, H_{out}, W_{out}) where

:math:H_{out} = H_{in} + \text{padding\_top} + \text{padding\_bottom}

:math:W_{out} = W_{in} + \text{padding\_left} + \text{padding\_right}

Examples::

>>> input = torch.arange(9, dtype=torch.float).reshape(1, 1, 3, 3)
>>> input
tensor([[[[0., 1., 2.],
[3., 4., 5.],
[6., 7., 8.]]]])
>>> m(input)
tensor([[[[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.]]]])
>>> # using different paddings for different sides
>>> m = nn.ReflectionPad2d((1, 1, 2, 0))
>>> m(input)
tensor([[[[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.]]]])

"""

def __init__(self, padding: _size_4_t) -> None:

r"""Pads the input tensor using the reflection of the input boundary.

For N-dimensional 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
(:math:\text{padding\_left}, :math:\text{padding\_right},
:math:\text{padding\_top}, :math:\text{padding\_bottom},
:math:\text{padding\_front}, :math:\text{padding\_back})

Shape:
- Input: :math:(N, C, D_{in}, H_{in}, W_{in}) or :math:(C, D_{in}, H_{in}, W_{in}).
- Output: :math:(N, C, D_{out}, H_{out}, W_{out}) or :math:(C, D_{out}, H_{out}, W_{out}),
where

:math:D_{out} = D_{in} + \text{padding\_front} + \text{padding\_back}

:math:H_{out} = H_{in} + \text{padding\_top} + \text{padding\_bottom}

:math:W_{out} = W_{in} + \text{padding\_left} + \text{padding\_right}

Examples::

>>> input = torch.arange(8, dtype=torch.float).reshape(1, 1, 2, 2, 2)
>>> m(input)
tensor([[[[[7., 6., 7., 6.],
[5., 4., 5., 4.],
[7., 6., 7., 6.],
[5., 4., 5., 4.]],
[[3., 2., 3., 2.],
[1., 0., 1., 0.],
[3., 2., 3., 2.],
[1., 0., 1., 0.]],
[[7., 6., 7., 6.],
[5., 4., 5., 4.],
[7., 6., 7., 6.],
[5., 4., 5., 4.]],
[[3., 2., 3., 2.],
[1., 0., 1., 0.],
[3., 2., 3., 2.],
[1., 0., 1., 0.]]]]])
"""
padding: Tuple[int, int, int, int, int, int]

def __init__(self, padding: _size_6_t) -> None:

def forward(self, input: Tensor) -> Tensor:

def extra_repr(self) -> str:

r"""Pads the input tensor using replication of the input boundary.

For N-dimensional 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
(:math:\text{padding\_left}, :math:\text{padding\_right})

Shape:
- Input: :math:(C, W_{in}) or :math:(N, C, W_{in}).
- Output: :math:(C, W_{out}) or :math:(N, C, W_{out}), where

:math:W_{out} = W_{in} + \text{padding\_left} + \text{padding\_right}

Examples::

>>> input = torch.arange(8, dtype=torch.float).reshape(1, 2, 4)
>>> input
tensor([[[0., 1., 2., 3.],
[4., 5., 6., 7.]]])
>>> m(input)
tensor([[[0., 0., 0., 1., 2., 3., 3., 3.],
[4., 4., 4., 5., 6., 7., 7., 7.]]])
>>> # using different paddings for different sides
>>> m(input)
tensor([[[0., 0., 0., 0., 1., 2., 3., 3.],
[4., 4., 4., 4., 5., 6., 7., 7.]]])

"""

def __init__(self, padding: _size_2_t) -> None:

r"""Pads the input tensor using replication of the input boundary.

For N-dimensional 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 (:math:\text{padding\_left},
:math:\text{padding\_right}, :math:\text{padding\_top}, :math:\text{padding\_bottom})

Shape:
- Input: :math:(N, C, H_{in}, W_{in}) or :math:(C, H_{in}, W_{in}).
- Output: :math:(N, C, H_{out}, W_{out}) or :math:(C, H_{out}, W_{out}), where

:math:H_{out} = H_{in} + \text{padding\_top} + \text{padding\_bottom}

:math:W_{out} = W_{in} + \text{padding\_left} + \text{padding\_right}

Examples::

>>> input = torch.arange(9, dtype=torch.float).reshape(1, 1, 3, 3)
>>> input
tensor([[[[0., 1., 2.],
[3., 4., 5.],
[6., 7., 8.]]]])
>>> m(input)
tensor([[[[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.]]]])
>>> # using different paddings for different sides
>>> m = nn.ReplicationPad2d((1, 1, 2, 0))
>>> m(input)
tensor([[[[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.]]]])

"""

def __init__(self, padding: _size_4_t) -> None:

r"""Pads the input tensor using replication of the input boundary.

For N-dimensional 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
(:math:\text{padding\_left}, :math:\text{padding\_right},
:math:\text{padding\_top}, :math:\text{padding\_bottom},
:math:\text{padding\_front}, :math:\text{padding\_back})

Shape:
- Input: :math:(N, C, D_{in}, H_{in}, W_{in}) or :math:(C, D_{in}, H_{in}, W_{in}).
- Output: :math:(N, C, D_{out}, H_{out}, W_{out}) or :math:(C, D_{out}, H_{out}, W_{out}),
where

:math:D_{out} = D_{in} + \text{padding\_front} + \text{padding\_back}

:math:H_{out} = H_{in} + \text{padding\_top} + \text{padding\_bottom}

:math:W_{out} = W_{in} + \text{padding\_left} + \text{padding\_right}

Examples::

>>> input = torch.randn(16, 3, 8, 320, 480)
>>> output = m(input)
>>> # using different paddings for different sides
>>> m = nn.ReplicationPad3d((3, 3, 6, 6, 1, 1))
>>> output = m(input)

"""
padding: Tuple[int, int, int, int, int, int]

def __init__(self, padding: _size_6_t) -> None:

[docs]class ZeroPad2d(ConstantPad2d): r"""Pads the input tensor boundaries with zero. For N-dimensional 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 (:math:\text{padding\_left}, :math:\text{padding\_right}, :math:\text{padding\_top}, :math:\text{padding\_bottom}) Shape: - Input: :math:(N, C, H_{in}, W_{in}) or :math:(C, H_{in}, W_{in}). - Output: :math:(N, C, H_{out}, W_{out}) or :math:(C, H_{out}, W_{out}), where :math:H_{out} = H_{in} + \text{padding\_top} + \text{padding\_bottom} :math:W_{out} = W_{in} + \text{padding\_left} + \text{padding\_right} Examples:: >>> m = nn.ZeroPad2d(2) >>> input = torch.randn(1, 1, 3, 3) >>> input tensor([[[[-0.1678, -0.4418, 1.9466], [ 0.9604, -0.4219, -0.5241], [-0.9162, -0.5436, -0.6446]]]]) >>> m(input) tensor([[[[ 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, -0.1678, -0.4418, 1.9466, 0.0000, 0.0000], [ 0.0000, 0.0000, 0.9604, -0.4219, -0.5241, 0.0000, 0.0000], [ 0.0000, 0.0000, -0.9162, -0.5436, -0.6446, 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]]]]) >>> # using different paddings for different sides >>> m = nn.ZeroPad2d((1, 1, 2, 0)) >>> m(input) tensor([[[[ 0.0000, 0.0000, 0.0000, 0.0000, 0.0000], [ 0.0000, 0.0000, 0.0000, 0.0000, 0.0000], [ 0.0000, -0.1678, -0.4418, 1.9466, 0.0000], [ 0.0000, 0.9604, -0.4219, -0.5241, 0.0000], [ 0.0000, -0.9162, -0.5436, -0.6446, 0.0000]]]]) """ padding: Tuple[int, int, int, int] def __init__(self, padding: _size_4_t) -> None: super(ZeroPad2d, self).__init__(padding, 0.) def extra_repr(self) -> str: return '{}'.format(self.padding)

Docs

Access comprehensive developer documentation for PyTorch

View Docs

Tutorials

Get in-depth tutorials for beginners and advanced developers

View Tutorials