class torch.nn.Fold(output_size: Union[T, Tuple[T, ...]], kernel_size: Union[T, Tuple[T, ...]], dilation: Union[T, Tuple[T, ...]] = 1, padding: Union[T, Tuple[T, ...]] = 0, stride: Union[T, Tuple[T, ...]] = 1)
[source]
Combines an array of sliding local blocks into a large containing tensor.
Consider a batched input
tensor containing sliding local blocks, e.g., patches of images, of shape $(N, C \times \prod(\text{kernel\_size}), L)$ , where $N$ is batch dimension, $C \times \prod(\text{kernel\_size})$ is the number of values within a block (a block has $\prod(\text{kernel\_size})$ spatial locations each containing a $C$ -channeled vector), and $L$ is the total number of blocks. (This is exactly the same specification as the output shape of Unfold
.) This operation combines these local blocks into the large output
tensor of shape $(N, C, \text{output\_size}[0], \text{output\_size}[1], \dots)$ by summing the overlapping values. Similar to Unfold
, the arguments must satisfy
where $d$ is over all spatial dimensions.
output_size
describes the spatial shape of the large containing tensor of the sliding local blocks. It is useful to resolve the ambiguity when multiple input shapes map to same number of sliding blocks, e.g., with stride > 0
.The padding
, stride
and dilation
arguments specify how the sliding blocks are retrieved.
stride
controls the stride for the sliding blocks.padding
controls the amount of implicit zero-paddings on both sides for padding
number of points for each dimension before reshaping.dilation
controls the spacing between the kernel points; also known as the à trous algorithm. It is harder to describe, but this link has a nice visualization of what dilation
does.output.sizes()[2:]
)output_size
, kernel_size
, dilation
, padding
or stride
is an int or a tuple of length 1 then their values will be replicated across all spatial dimensions.col2im
.Note
Fold
calculates each combined value in the resulting large tensor by summing all values from all containing blocks. Unfold
extracts the values in the local blocks by copying from the large tensor. So, if the blocks overlap, they are not inverses of each other.
In general, folding and unfolding operations are related as follows. Consider Fold
and Unfold
instances created with the same parameters:
>>> fold_params = dict(kernel_size=..., dilation=..., padding=..., stride=...) >>> fold = nn.Fold(output_size=..., **fold_params) >>> unfold = nn.Unfold(**fold_params)
Then for any (supported) input
tensor the following equality holds:
fold(unfold(input)) == divisor * input
where divisor
is a tensor that depends only on the shape and dtype of the input
:
>>> input_ones = torch.ones(input.shape, dtype=input.dtype) >>> divisor = fold(unfold(input_ones))
When the divisor
tensor contains no zero elements, then fold
and unfold
operations are inverses of each other (up to constant divisor).
Warning
Currently, only 4-D output tensors (batched image-like tensors) are supported.
Examples:
>>> fold = nn.Fold(output_size=(4, 5), kernel_size=(2, 2)) >>> input = torch.randn(1, 3 * 2 * 2, 12) >>> output = fold(input) >>> output.size() torch.Size([1, 3, 4, 5])
© 2019 Torch Contributors
Licensed under the 3-clause BSD License.
https://pytorch.org/docs/1.7.0/generated/torch.nn.Fold.html