Unfold

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) — размер скользящих блоков
• dilation (int или tuple, необязательно) — параметр, который управляет шагом элементов в окрестности. По умолчанию: 1
• padding (int или tuple, необязательно) — неявное нулевое заполнение, которое нужно добавить по обеим сторонам входа. По умолчанию: 0
• stride (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)