Upsample

class torch.nn.modules.upsampling.Upsample(size=None, scale_factor=None, mode='nearest', align_corners=None, recompute_scale_factor=None) [исходный код]

Увеличивает размерность заданных одноканальных или многоканальных данных 1D (временных), 2D (пространственных) или 3D (объёмных).

Предполагается, что входные данные имеют формат minibatch x channels x [optional depth] x [optional height] x width. Поэтому для пространственных входных данных ожидается 4D-тензор, а для объёмных — 5D-тензор.

Доступны следующие алгоритмы увеличения размера: ближайший сосед, линейный, билинейный, бикубический и трилинейный — для входных тензоров размерности 3D, 4D и 5D соответственно.

Для вычисления размера выходных данных можно указать scale_factor или целевой выходной размер size. (Указать оба параметра нельзя, так как это приведёт к неоднозначности.)

Параметры:

• size (int или Tuple[int] или Tuple[int, int] или Tuple[int, int, int], необязательно) – размеры выходных пространственных измерений
• scale_factor (float или Tuple[float] или Tuple[float, float] или Tuple[float, float, float], необязательно) – коэффициент масштабирования пространственных измерений. Если это кортеж, его длина должна совпадать с размерностью входных данных.
• mode (str, необязательно) – алгоритм увеличения размера: один из 'nearest', 'linear', 'bilinear', 'bicubic' и 'trilinear'. По умолчанию: 'nearest'
• align_corners (bool, необязательно) – если True, угловые пиксели входного и выходного тензоров выравниваются, благодаря чему значения этих пикселей сохраняются. Этот параметр действует только если mode равно 'linear', 'bilinear', 'bicubic' или 'trilinear'. По умолчанию: False
• recompute_scale_factor (bool, необязательно) – повторно вычислять scale_factor для использования при интерполяции. Если recompute_scale_factor равно True, необходимо передать scale_factor, а scale_factor используется для вычисления выходного size. Вычисленное выходное size будет использовано для определения новых масштабов интерполяции. Обратите внимание: если scale_factor — число с плавающей точкой, оно может отличаться от повторно вычисленного scale_factor из-за округления и ограниченной точности. Если recompute_scale_factor равно False, для интерполяции напрямую используются size или scale_factor.

Форма:

• Вход: $(N, C, W_{in})$, $(N, C, H_{in}, W_{in})$ или $(N, C, D_{in}, H_{in}, W_{in})$
• Выход: $(N, C, W_{out})$, $(N, C, H_{out}, W_{out})$ или $(N, C, D_{out}, H_{out}, W_{out})$, где

$$D_{out} = \left\lfloor D_{in} \times \text{scale\_factor} \right\rfloor$$

$$H_{out} = \left\lfloor H_{in} \times \text{scale\_factor} \right\rfloor$$

$$W_{out} = \left\lfloor W_{in} \times \text{scale\_factor} \right\rfloor$$

Предупреждение

При использовании align_corners = True режимы линейной интерполяции (linear, bilinear, bicubic и trilinear) не обеспечивают пропорциональное выравнивание выходных и входных пикселей, поэтому значения на выходе могут зависеть от размера входных данных. Такое поведение было установлено по умолчанию для этих режимов до версии 0.3.1. Начиная с этой версии, по умолчанию используется align_corners = False. Ниже приведены конкретные примеры того, как это влияет на выходные данные.

Примечание

Для уменьшения размера или общего изменения размера следует использовать interpolate().

Примеры:

>>> 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]]]])

extra_repr() [исходный код]

Возвращает дополнительное представление модуля.

Тип возвращаемого значения:

str

forward(input) [исходный код]

Выполняет прямой проход.

Тип возвращаемого значения:

Tensor