Развертывание

class torch.nn.Unfold(kernel_size, dilation=1, padding=0, stride=1) [source]

Извлекает скользящие локальные блоки из тензора входных данных в пакете.

Рассмотрим тензор в пакете input формы $(N, C, *)$, где $N$ — размерность пакета, $C$ — размерность канала, а $*$ представляют произвольные пространственные размерности. Эта операция сплющивает каждый скользящий блок размера kernel_size в пространственных измерениях input в столбец (т.е., последнюю размерность) 3-мерного output тензора формы $(N, C \times \prod(\text{kernel\_size}), L)$, где $C \times \prod(\text{kernel\_size})$ — общее количество значений в каждом блоке (блок содержит $\prod(\text{kernel\_size})$ пространственных расположений, каждое из которых содержит вектор с $C$ каналами), а $L$ — общее количество таких блоков:

$$L = \prod_d \left\lfloor\frac{\text{spatial\_size}[d] + 2 \times \text{padding}[d]$$

где $\text{spatial\_size}$ формируется пространственными размерностями input ($*$ выше), а $d$ — по всем пространственным размерностям.

Поэтому индексирование output в последней размерности (размерности столбца) дает все значения в определенном блоке.

Аргументы padding, stride и dilation определяют, как извлекаются скользящие блоки.

• stride управляет шагом для скользящих блоков.
• padding управляет количеством неявного нулевого заполнения по обеим сторонам для padding количества точек для каждой размерности перед преобразованием в форму.
• dilation управляет пространством между точками ядра; также известен как алгоритм à trous. Его сложнее описать, но эта ссылка содержит хорошую визуализацию того, что делает dilation.

Параметры:

• kernel_size (int или tuple) – размер скользящих блоков
• stride (int или tuple, необязательно) – шаг скользящих блоков в пространственных измерениях входных данных. По умолчанию: 1
• padding (int или tuple, необязательно) – неявное нулевое заполнение, которое нужно добавить по обе стороны входных данных. По умолчанию: 0
• dilation (int или tuple, необязательно) – параметр, который управляет шагом элементов в окрестности. По умолчанию: 1

• Если kernel_size, dilation, padding или stride является целым числом или кортежем длины 1, их значения будут дублироваться по всем пространственным размерностям.
• В случае двух пространственных измерений ввода эта операция иногда называется im2col.

Примечание

Fold вычисляет каждое комбинированное значение в результирующем большом тензоре, суммируя все значения из всех содержащих блоков. Unfold извлекает значения в локальных блоках, копируя их из большого тензора. Таким образом, если блоки перекрываются, они не являются взаимно обратными.

В общем, операции свёртки и развертывания связаны следующим образом. Рассмотрим экземпляры Fold и Unfold, созданные с теми же параметрами:

>>> fold_params = dict(kernel_size=..., dilation=..., padding=..., stride=...)
>>> fold = nn.Fold(output_size=..., **fold_params)
>>> unfold = nn.Unfold(**fold_params)

Тогда для любого (поддерживаемого) input тензора выполняется следующее равенство:

fold(unfold(input)) == divisor * input

где divisor — тензор, зависящий только от формы и типа данных input:

>>> input_ones = torch.ones(input.shape, dtype=input.dtype)
>>> divisor = fold(unfold(input_ones))

Когда тензор divisor не содержит нулевых элементов, тогда операции fold и unfold являются взаимно обратными (с точностью до постоянного делителя).

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

В настоящее время поддерживаются только 4-мерные тензоры входных данных (тензоры, похожие на пакет изображений).

Форма:

• Вход: $(N, C, *)$
• Выход: $(N, C \times \prod(\text{kernel\_size}), L)$ как описано выше

Примеры:

>>> unfold = nn.Unfold(kernel_size=(2, 3))
>>> input = torch.randn(2, 5, 3, 4)
>>> output = unfold(input)
>>> # each patch contains 30 values (2x3=6 vectors, each of 5 channels)
>>> # 4 blocks (2x3 kernels) in total in the 3x4 input
>>> output.size()
torch.Size([2, 30, 4])

>>> # Convolution is equivalent with Unfold + Matrix Multiplication + Fold (or view to output shape)
>>> inp = torch.randn(1, 3, 10, 12)
>>> w = torch.randn(2, 3, 4, 5)
>>> inp_unf = torch.nn.functional.unfold(inp, (4, 5))
>>> out_unf = inp_unf.transpose(1, 2).matmul(w.view(w.size(0), -1).t()).transpose(1, 2)
>>> out = torch.nn.functional.fold(out_unf, (7, 8), (1, 1))
>>> # or equivalently (and avoiding a copy),
>>> # out = out_unf.view(1, 2, 7, 8)
>>> (torch.nn.functional.conv2d(inp, w) - out).abs().max()
tensor(1.9073e-06)