Spaces:
Sleeping
Sleeping
| from .module import Module | |
| from .. import functional as F | |
| from torch import Tensor | |
| from typing import Optional | |
| from ..common_types import _size_2_t, _ratio_2_t, _size_any_t, _ratio_any_t | |
| __all__ = ['Upsample', 'UpsamplingNearest2d', 'UpsamplingBilinear2d'] | |
| class Upsample(Module): | |
| r"""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'``, ``'bicubic'``, or ``'trilinear'``. | |
| Default: ``False`` | |
| recompute_scale_factor (bool, optional): recompute the scale_factor for use in the | |
| interpolation calculation. If `recompute_scale_factor` is ``True``, then | |
| `scale_factor` must be passed in and `scale_factor` is used to compute the | |
| output `size`. The computed output `size` will be used to infer new scales for | |
| the interpolation. Note that when `scale_factor` is floating-point, it may differ | |
| from the recomputed `scale_factor` due to rounding and precision issues. | |
| If `recompute_scale_factor` is ``False``, then `size` or `scale_factor` will | |
| be used directly for interpolation. | |
| 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.]]]]) | |
| >>> # xdoctest: +IGNORE_WANT("other tests seem to modify printing styles") | |
| >>> 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.]]]]) | |
| >>> # xdoctest: +IGNORE_WANT("seems to fail when other tests are run in the same session") | |
| >>> 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]]]]) | |
| """ | |
| __constants__ = ['size', 'scale_factor', 'mode', 'align_corners', 'name', 'recompute_scale_factor'] | |
| name: str | |
| size: Optional[_size_any_t] | |
| scale_factor: Optional[_ratio_any_t] | |
| mode: str | |
| align_corners: Optional[bool] | |
| recompute_scale_factor: Optional[bool] | |
| def __init__(self, size: Optional[_size_any_t] = None, scale_factor: Optional[_ratio_any_t] = None, | |
| mode: str = 'nearest', align_corners: Optional[bool] = None, | |
| recompute_scale_factor: Optional[bool] = None) -> None: | |
| super().__init__() | |
| self.name = type(self).__name__ | |
| self.size = size | |
| if isinstance(scale_factor, tuple): | |
| self.scale_factor = tuple(float(factor) for factor in scale_factor) | |
| else: | |
| self.scale_factor = float(scale_factor) if scale_factor else None | |
| self.mode = mode | |
| self.align_corners = align_corners | |
| self.recompute_scale_factor = recompute_scale_factor | |
| def forward(self, input: Tensor) -> Tensor: | |
| return F.interpolate(input, self.size, self.scale_factor, self.mode, self.align_corners, | |
| recompute_scale_factor=self.recompute_scale_factor) | |
| def __setstate__(self, state): | |
| if 'recompute_scale_factor' not in state: | |
| state['recompute_scale_factor'] = True | |
| super().__setstate__(state) | |
| def extra_repr(self) -> str: | |
| if self.scale_factor is not None: | |
| info = 'scale_factor=' + repr(self.scale_factor) | |
| else: | |
| info = 'size=' + repr(self.size) | |
| info += ', mode=' + repr(self.mode) | |
| return info | |
| class UpsamplingNearest2d(Upsample): | |
| r"""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.]]]]) | |
| """ | |
| def __init__(self, size: Optional[_size_2_t] = None, scale_factor: Optional[_ratio_2_t] = None) -> None: | |
| super().__init__(size, scale_factor, mode='nearest') | |
| class UpsamplingBilinear2d(Upsample): | |
| r"""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.]]]]) | |
| >>> # xdoctest: +IGNORE_WANT("do other tests modify the global state?") | |
| >>> 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]]]]) | |
| """ | |
| def __init__(self, size: Optional[_size_2_t] = None, scale_factor: Optional[_ratio_2_t] = None) -> None: | |
| super().__init__(size, scale_factor, mode='bilinear', align_corners=True) | |