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 �Egd'�@s|dd
lm
Z

ddlmZ
ddlmZ
ddlmZ
ddl m Z mZmZm Z
Gdd �d e
�ZGd d�de�ZGdd �d e�ZdS)�
)
�Module�)
� functional�)
�Tensor)
�Optional)� _size_2_t� _ratio_2_t�_size_any_t�_ratio_any_tcs�eZ
dZUd
ZdddddgZeee ee eee deeee eee dd ��f
d d� Zeed�d d�Zed�
dd�Z�ZS)�Upsamplea�Upsamples a given multi-channel 1D (temporal), 2D (spatial) or 3D (volumetric) data. The input data is assumed to be of the form `minibatch x channels x [optional depth] x [optional height] x width`. Hence, for spatial inputs, we expect a 4D Tensor and for volumetric inputs, we expect a 5D Tensor. The algorithms available for upsampling are nearest neighbor and linear, bilinear, bicubic and trilinear for 3D, 4D and 5D input Tensor, respectively. One can either give a :attr:`scale_factor` or the target output :attr:`size` to calculate the output size. (You cannot give both, as it is ambiguous) Args: size (int or Tuple[int] or Tuple[int, int] or Tuple[int, int, int], optional): output spatial sizes scale_factor (float or Tuple[float] or Tuple[float, float] or Tuple[float, float, float], optional): multiplier for spatial size. Has to match input size if it is a tuple. mode (str, optional): the upsampling algorithm: one of ``'nearest'``, ``'linear'``, ``'bilinear'``, ``'bicubic'`` and ``'trilinear'``. Default: ``'nearest'`` align_corners (bool, optional): if ``True``, the corner pixels of the input and output tensors are aligned, and thus preserving the values at those pixels. This only has effect when :attr:`mode` is ``'linear'``, ``'bilinear'``, or ``'trilinear'``. Default: ``False`` Shape: - Input: :math:`(N, C, W_{in})`, :math:`(N, C, H_{in}, W_{in})` or :math:`(N, C, D_{in}, H_{in}, W_{in})` - Output: :math:`(N, C, W_{out})`, :math:`(N, C, H_{out}, W_{out})` or :math:`(N, C, D_{out}, H_{out}, W_{out})`, where .. math:: D_{out} = \left\lfloor D_{in} \times \text{scale\_factor} \right\rfloor .. math:: H_{out} = \left\lfloor H_{in} \times \text{scale\_factor} \right\rfloor .. math:: W_{out} = \left\lfloor W_{in} \times \text{scale\_factor} \right\rfloor .. warning:: With ``align_corners = True``, the linearly interpolating modes (`linear`, `bilinear`, `bicubic`, and `trilinear`) don't proportionally align the output and input pixels, and thus the output values can depend on the input size. This was the default behavior for these modes up to version 0.3.1. Since then, the default behavior is ``align_corners = False``. See below for concrete examples on how this affects the outputs. .. note:: If you want downsampling/general resizing, you should use :func:`~nn.functional.interpolate`. Examples:: >>> input = torch.arange(1, 5, dtype=torch.float32).view(1, 1, 2, 2) >>> input tensor([[[[ 1., 2.], [ 3., 4.]]]]) >>> m = nn.Upsample(scale_factor=2, mode='nearest') >>> m(input) tensor([[[[ 1., 1., 2., 2.], [ 1., 1., 2., 2.], [ 3., 3., 4., 4.], [ 3., 3., 4., 4.]]]]) >>> m = nn.Upsample(scale_factor=2, mode='bilinear') # align_corners=False >>> m(input) tensor([[[[ 1.0000, 1.2500, 1.7500, 2.0000], [ 1.5000, 1.7500, 2.2500, 2.5000], [ 2.5000, 2.7500, 3.2500, 3.5000], [ 3.0000, 3.2500, 3.7500, 4.0000]]]]) >>> m = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True) >>> m(input) tensor([[[[ 1.0000, 1.3333, 1.6667, 2.0000], [ 1.6667, 2.0000, 2.3333, 2.6667], [ 2.3333, 2.6667, 3.0000, 3.3333], [ 3.0000, 3.3333, 3.6667, 4.0000]]]]) >>> # Try scaling the same data in a larger tensor >>> >>> input_3x3 = torch.zeros(3, 3).view(1, 1, 3, 3) >>> input_3x3[:, :, :2, :2].copy_(input) tensor([[[[ 1., 2.], [ 3., 4.]]]]) >>> input_3x3 tensor([[[[ 1., 2., 0.], [ 3., 4., 0.], [ 0., 0., 0.]]]]) >>> m = nn.Upsample(scale_factor=2, mode='bilinear') # align_corners=False >>> # Notice that values in top left corner are the same with the small input (except at boundary) >>> m(input_3x3) tensor([[[[ 1.0000, 1.2500, 1.7500, 1.5000, 0.5000, 0.0000], [ 1.5000, 1.7500, 2.2500, 1.8750, 0.6250, 0.0000], [ 2.5000, 2.7500, 3.2500, 2.6250, 0.8750, 0.0000], [ 2.2500, 2.4375, 2.8125, 2.2500, 0.7500, 0.0000], [ 0.7500, 0.8125, 0.9375, 0.7500, 0.2500, 0.0000], [ 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000]]]]) >>> m = nn.Upsample(scale_factor=2, mode='bilinear', align_corners=True) >>> # Notice that values in top left corner are now changed >>> m(input_3x3) tensor([[[[ 1.0000, 1.4000, 1.8000, 1.6000, 0.8000, 0.0000], [ 1.8000, 2.2000, 2.6000, 2.2400, 1.1200, 0.0000], [ 2.6000, 3.0000, 3.4000, 2.8800, 1.4400, 0.0000], [ 2.4000, 2.7200, 3.0400, 2.5600, 1.2800, 0.0000], [ 1.2000, 1.3600, 1.5200, 1.2800, 0.6400, 0.0000], [ 0.0000, 0.0000, 0.0000, 0.0000, 0.0000, 0.0000]]]]) �size�scale_factor�mode� align_corners�nameN�nearest)r rrr�returncsbtt
|�j�
t|�
j|_|
|_t|t�r@td
d�|D�
�
|_ n|rLt |�
nd|_ ||_||_dS)Nc
ss|]}
t|
�
V
qdS)
N)
�float)�.0Zfactor�r�G/usr/local/lib64/python3.6/site-packages/torch/nn/modules/upsampling.py� �sz$Upsample.__init__..) �superr�__init__�type�__name__rr � isinstance�tuplerrrr)�selfr rrr)
� __class__rrr�s





zUpsample.__init__)�inputrcCstj
|
|j|j|j|j�S)
N)�
FZinterpolater rrr)rr!rrr�forward�s
zUpsample.forward)
rc
Cs:|jdk rd
t
|j�
}
ndt
|j�
}
|
d|j7}
|
S)Nz scale_factor=zsize=z, mode=)r�strr r)r�inforrr� extra_repr�s



zUpsample.extra_repr)NNrN)r� __module__�__qualname__�__doc__Z __constants__r$rrr r rrr�boolrrrr#r&� __classcell__rr)
r rr s o






(rcs4eZ
dZd
Zdeeeedd��f
dd� Z�ZS)�UpsamplingNearest2da"Applies a 2D nearest neighbor upsampling to an input signal composed of several input channels. To specify the scale, it takes either the :attr:`size` or the :attr:`scale_factor` as it's constructor argument. When :attr:`size` is given, it is the output size of the image `(h, w)`. Args: size (int or Tuple[int, int], optional): output spatial sizes scale_factor (float or Tuple[float, float], optional): multiplier for spatial size. .. warning:: This class is deprecated in favor of :func:`~nn.functional.interpolate`. Shape: - Input: :math:`(N, C, H_{in}, W_{in})` - Output: :math:`(N, C, H_{out}, W_{out})` where .. math:: H_{out} = \left\lfloor H_{in} \times \text{scale\_factor} \right\rfloor .. math:: W_{out} = \left\lfloor W_{in} \times \text{scale\_factor} \right\rfloor Examples:: >>> input = torch.arange(1, 5, dtype=torch.float32).view(1, 1, 2, 2) >>> input tensor([[[[ 1., 2.], [ 3., 4.]]]]) >>> m = nn.UpsamplingNearest2d(scale_factor=2) >>> m(input) tensor([[[[ 1., 1., 2., 2.], [ 1., 1., 2., 2.], [ 3., 3., 4., 4.], [ 3., 3., 4., 4.]]]]) N)r rrcstt
|�j|
|d
d�
dS)Nr)
r)rr,r)rr r)
r rrr�s
zUpsamplingNearest2d.__init__)NN) rr'r(r)rrr rr+rr)
r rr,�s(
r,cs4eZ
dZd
Zdeeeedd��f
dd� Z�ZS)�UpsamplingBilinear2da�Applies a 2D bilinear upsampling to an input signal composed of several input channels. To specify the scale, it takes either the :attr:`size` or the :attr:`scale_factor` as it's constructor argument. When :attr:`size` is given, it is the output size of the image `(h, w)`. Args: size (int or Tuple[int, int], optional): output spatial sizes scale_factor (float or Tuple[float, float], optional): multiplier for spatial size. .. warning:: This class is deprecated in favor of :func:`~nn.functional.interpolate`. It is equivalent to ``nn.functional.interpolate(..., mode='bilinear', align_corners=True)``. Shape: - Input: :math:`(N, C, H_{in}, W_{in})` - Output: :math:`(N, C, H_{out}, W_{out})` where .. math:: H_{out} = \left\lfloor H_{in} \times \text{scale\_factor} \right\rfloor .. math:: W_{out} = \left\lfloor W_{in} \times \text{scale\_factor} \right\rfloor Examples:: >>> input = torch.arange(1, 5, dtype=torch.float32).view(1, 1, 2, 2) >>> input tensor([[[[ 1., 2.], [ 3., 4.]]]]) >>> m = nn.UpsamplingBilinear2d(scale_factor=2) >>> m(input) tensor([[[[ 1.0000, 1.3333, 1.6667, 2.0000], [ 1.6667, 2.0000, 2.3333, 2.6667], [ 2.3333, 2.6667, 3.0000, 3.3333], [ 3.0000, 3.3333, 3.6667, 4.0000]]]]) N)r rrcstt
|�j|
|d
dd�
dS)NZbilinearT)rr)rr-r)rr r)
r rrr�s
zUpsamplingBilinear2d.__init__)NN) rr'r(r)rrr rr+rr)
r rr-�s)
r-N)�moduler�rr"Ztorchr�typingr�common_typesrr r rrr,r-rrrr�
s


-