Name	Size	Mode	Actions
activation.cpython-36.pyc	47635	0644	editdlrm
adaptive.cpython-36.pyc	9725	0644	editdlrm
batchnorm.cpython-36.pyc	31039	0644	editdlrm
channelshuffle.cpython-36.pyc	1901	0644	editdlrm
container.cpython-36.pyc	27970	0644	editdlrm
conv.cpython-36.pyc	57789	0644	editdlrm
distance.cpython-36.pyc	3684	0644	editdlrm
dropout.cpython-36.pyc	10310	0644	editdlrm
flatten.cpython-36.pyc	5813	0644	editdlrm
fold.cpython-36.pyc	12807	0644	editdlrm
instancenorm.cpython-36.pyc	18808	0644	editdlrm
lazy.cpython-36.pyc	11690	0644	editdlrm
linear.cpython-36.pyc	10188	0644	editdlrm
loss.cpython-36.pyc	91465	0644	editdlrm
module.cpython-36.pyc	66530	0644	editdlrm
normalization.cpython-36.pyc	11360	0644	editdlrm
padding.cpython-36.pyc	22217	0644	editdlrm
pixelshuffle.cpython-36.pyc	4398	0644	editdlrm
pooling.cpython-36.pyc	53203	0644	editdlrm
rnn.cpython-36.pyc	44653	0644	editdlrm
sparse.cpython-36.pyc	20956	0644	editdlrm
transformer.cpython-36.pyc	20737	0644	editdlrm
upsampling.cpython-36.pyc	10780	0644	editdlrm
utils.cpython-36.pyc	2528	0644	editdlrm
_functions.cpython-36.pyc	5441	0644	editdlrm
__init__.cpython-36.pyc	5236	0644	editdlrm

3 �Eg�K�@s0
dd
lm
Z

ddlmZmZmZ
ddlmZ
ddl m Z
ddlmZm Z mZ
ddlmZmZ
Gd d �d e
�ZGdd�de�ZGd d�de�ZGdd�de�ZGdd�de
�ZGdd�de�ZGdd�de�ZGdd�de�ZGdd�de
�ZGdd�de�ZGdd�de�ZGdd �d e�ZGd!d"�d"e�Zd#S)$�
)
�Module)�_pair� _quadruple�_ntuple�)
� functional�)
�Tensor)� _size_2_t� _size_4_t� _size_6_t)�Sequence�TuplecsXeZ
dZUd
dgZeeeedd��f
dd�Z e e d�dd �Zed �
dd�Z �ZS) �_ConstantPadNd�padding�valueN)r�returncstt
|�j�
|
|_dS)
N)�superr�__init__r)�selfr)
� __class__��D/usr/local/lib64/python3.6/site-packages/torch/nn/modules/padding.pyrs

z_ConstantPadNd.__init__)�inputrcCstj
|
|jd
|j�S)NZconstant)�
F�padrr)rrrrr�forwards
z_ConstantPadNd.forward)
rc

Csd
j|j
|j�S)Nzpadding={}, value={})�formatrr)
rrrr� extra_reprs
z_ConstantPadNd.extra_repr)�__name__� __module__�__qualname__� __constants__�floatrr �intrrr r�strr� __classcell__rr)
rrr s


rcs6eZ
dZUd
Zeeefeed��f
dd�Z �Z S)� ConstantPad1da�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:: >>> m = nn.ConstantPad1d(2, 3.5) >>> 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]]]) >>> m = nn.ConstantPad1d(2, 3.5) >>> 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]]]) )rrcstt
|�j|�

t|
�
|_dS)
N)rr'rrr)rrr)
rrrrJs

zConstantPad1d.__init__)rr r!�__doc__rr$rr r#rr&rr)
rrr's *
r'csDeZ
dZUd
ZddgZeeeeefee dd��f
dd�Z �ZS)� ConstantPad2daWPads 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:: >>> m = nn.ConstantPad2d(2, 3.5) >>> 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]]]) rrN)rrrcstt
|�j|�

t|
�
|_dS)
N)rr)rrr)rrr)
rrrr|s

zConstantPad2d.__init__)rr r!r(r"rr$rrr#rr&rr)
rrr)Os )

r)cs@eZ
dZUd
Zeeeeeeefeedd��f
dd�Z �Z S)� ConstantPad3da�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:: >>> m = nn.ConstantPad3d(3, 3.5) >>> 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) N)rrrcs"tt
|�j|�

td
�
|
�
|_dS)N�)rr*rrr)rrr)
rrrr�s

zConstantPad3d.__init__)rr r!r(rr$rrr#rr&rr)
rrr*�s 
r*c@s:eZ
dZUd
g
Zeeeed�dd�Ze d�
dd�Z dS) �_ReflectionPadNdr)rrcCstj
|
|jd
�S)NZreflect)rrr)rrrrrr�s
z_ReflectionPadNd.forward)
rc

Csd
j|j
�
S)Nz{})rr)
rrrrr�s
z_ReflectionPadNd.extra_reprN)rr r!r"r r$rr rr%rrrrrr,�s

r,cs6eZ
dZUd
Zeeefedd��f
dd�Z�Z S)�ReflectionPad1da�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:: >>> m = nn.ReflectionPad1d(2) >>> 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 = nn.ReflectionPad1d((3, 1)) >>> m(input) tensor([[[3., 2., 1., 0., 1., 2., 3., 2.], [7., 6., 5., 4., 5., 6., 7., 6.]]]) N)rrcstt
|�j�
t|
�
|_dS)
N)rr-rrr)rr)
rrrr�s

zReflectionPad1d.__init__) rr r!r(rr$rr rr&rr)
rrr-�s 
r-cs:eZ
dZUd
Zeeeeefedd��f
dd�Z�Z S)�ReflectionPad2da�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:: >>> m = nn.ReflectionPad2d(2) >>> 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.]]]]) N)rrcstt
|�j�
t|
�
|_dS)
N)rr.rrr)rr)
rrrr
s

zReflectionPad2d.__init__) rr r!r(rr$rrrr&rr)
rrr.�s +
r.cs>eZ
dZUd
Zeeeeeeefedd��f
dd�Z�Z S)�ReflectionPad3da�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:: >>> m = nn.ReflectionPad3d(1) >>> 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.]]]]]) N)rrcs tt
|�j�
td
�
|
�
|_dS)Nr+)rr/rrr)rr)
rrrr>
s

zReflectionPad3d.__init__) rr r!r(rr$rrrr&rr)
rrr/
s ,
r/c@s:eZ
dZUd
g
Zeeeed�dd�Ze d�
dd�Z dS) �_ReplicationPadNdr)rrcCstj
|
|jd
�S)NZ replicate)rrr)rrrrrrG
s
z_ReplicationPadNd.forward)
rc

Csd
j|j
�
S)Nz{})rr)
rrrrrJ
s
z_ReplicationPadNd.extra_reprN)rr r!r"r r$rr rr%rrrrrr0C
s

r0cs6eZ
dZUd
Zeeefedd��f
dd�Z�Z S)�ReplicationPad1da�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:: >>> m = nn.ReplicationPad1d(2) >>> 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 = nn.ReplicationPad1d((3, 1)) >>> m(input) tensor([[[0., 0., 0., 0., 1., 2., 3., 3.], [4., 4., 4., 4., 5., 6., 7., 7.]]]) N)rrcstt
|�j�
t|
�
|_dS)
N)rr1rrr)rr)
rrrrq
s

zReplicationPad1d.__init__) rr r!r(rr$rr rr&rr)
rrr1N
s 
r1cs:eZ
dZUd
Zeeeeefedd��f
dd�Z�Z S)�ReplicationPad2da�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:: >>> m = nn.ReplicationPad2d(2) >>> 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.]]]]) N)rrcstt
|�j�
t|
�
|_dS)
N)rr2rrr)rr)
rrrr�
s

zReplicationPad2d.__init__) rr r!r(rr$rrrr&rr)
rrr2v
s +
r2cs>eZ
dZUd
Zeeeeeeefedd��f
dd�Z�Z S)�ReplicationPad3da�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:: >>> m = nn.ReplicationPad3d(3) >>> 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) N)rrcs tt
|�j�
td
�
|
�
|_dS)Nr+)rr3rrr)rr)
rrrr�
s

zReplicationPad3d.__init__) rr r!r(rr$rrrr&rr)
rrr3�
s 
r3cs:eZ
dZUd
Zeeeeefedd��f
dd�Z�Z S)� ZeroPad2daPads 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]]]]) N)rrcstt
|�j|
d
�
dS)Ng)rr4r)rr)
rrrr�
s
zZeroPad2d.__init__) rr r!r(rr$rrrr&rr)
rrr4�
s +
r4N)�moduler�utilsrrr�rrZtorchr �common_typesr rr�typingr rrr'r)r*r,r-r.r/r0r1r2r3r4rrrr�
s$



22((34(3(