Pytorch 展开和折叠：如何将这个图像张量重新组合在一起？
Pytorch Unfold and Fold: How do I put this image tensor back together again?
我正在尝试使用展开来过滤大小为 256x256 的单通道二维图像，以创建重叠为 8 的 16x16 块。如下所示：
# I = [256, 256] image
kernel_size = 16
stride = bx/2
patches = I.unfold(1, kernel_size,
int(stride)).unfold(0, kernel_size, int(stride)) # size = [31, 31, 16, 16]
我已经开始尝试通过折叠将图像重新组合在一起，但我还没有完成。我尝试使用视图让图像按照预期的方式“适应”，但我看不出这将如何保留原始图像。可能是我多虑了
# patches.shape = [31, 31, 16, 16]
patches = = filt_data_block.contiguous().view(-1, kernel_size*kernel_size) # [961, 256]
patches = patches.permute(1, 0) # size = [951, 256]
如有任何帮助，我们将不胜感激。非常感谢。
我相信在这种情况下使用 torch.nn.functional.fold 和 torch.nn.functional.unfold 会让您受益，因为这些函数是专门为图像构建的（或任何 4D 张量，形状为 B X C X H X W）。
让我们从展开图像开始：
import torch
import torch.nn.functional as F
import matplotlib.pyplot as plt
from sklearn.datasets import load_sample_image #Used to load a sample image
dtype = torch.cuda.FloatTensor if torch.cuda.is_available() else torch.FloatTensor
#Load a flower image from sklearn.datasets, crop it to shape 1 X 3 X 256 X 256:
I = torch.from_numpy(load_sample_image('flower.jpg')).permute(2,0,1).unsqueeze(0).type(dtype)[...,128:128+256,256:256+256]
kernel_size = 16
stride = kernel_size//2
I_unf = F.unfold(I, kernel_size, stride=stride)
这里我们使用F.unfold函数获得所有步幅为8的16x16图像块。这将产生一个形状为 torch.Size([1, 768, 961]) 的 3D 张量。即 - 961 个补丁，每个补丁有 768 = 16 X 16 X 3 像素。
现在，假设我们希望将其折叠回我：
I_f = F.fold(I_unf,I.shape[-2:],kernel_size,stride=stride)
norm_map = F.fold(F.unfold(torch.ones(I.shape).type(dtype),kernel_size,stride=stride),I.shape[-2:],kernel_size,stride=stride)
I_f /= norm_map
我们使用 F.fold 告诉它 I 的原始形状，我们用来展开的 kernel_size 和使用的 stride。折叠 I_unf 后，我们将获得重叠 的总和 。这意味着生成的图像将显得饱和。因此，我们需要计算一个归一化映射，该映射将归一化由于重叠导致的像素的多次求和。一种有效地做到这一点的方法是采用一个张量并使用 unfold 后跟 fold - 来模拟重叠的求和。这给了我们归一化图，我们通过它归一化 I_f 以恢复 I.
现在，我们希望绘制 I_f 和 I 以证明内容已保留：
#Plot I:
plt.imshow(I[0,...].permute(1,2,0).cpu()/255)
#Plot I_f:
plt.imshow(I_f[0,...].permute(1,2,0).cpu()/255)
整个过程也适用于 single-channel 图片。需要注意的一件事是，如果图像的空间维度不能被步幅整除，由于某些像素无法到达，您将得到带有零（在边缘）的 norm_map，但您也可以轻松处理这种情况。
比 Gil 提出的解决方案略逊一筹：
I took inspiration from this post on the Pytorch forums，将我的图像张量格式化为标准形状 B x C x H x W (1 x 1 x 256 x 256)。展开:
# CREATE THE UNFOLDED IMAGE SLICES
I = image # shape [256, 256]
kernel_size = bx #shape [16]
stride = int(bx/2) #shape [8]
I2 = I.unsqueeze(0).unsqueeze(0) #shape [1, 1, 256, 256]
patches2 = I2.unfold(2, kernel_size, stride).unfold(3, kernel_size, stride)
#shape [1, 1, 31, 31, 16, 16]
在此之后，我对我的张量堆栈进行了一些转换和过滤。在这样做之前，我应用余弦 window 并归一化：
# NORMALISE AND WINDOW
Pvv = torch.mean(torch.pow(win, 2))*torch.numel(win)*(noise_std**2)
Pvv = Pvv.double()
mean_patches = torch.mean(patches2, (4, 5), keepdim=True)
mean_patches = mean_patches.repeat(1, 1, 1, 1, 16, 16)
window_patches = win.unsqueeze(0).unsqueeze(0).unsqueeze(0).unsqueeze(0).repeat(1, 1, 31, 31, 1, 1)
zero_mean = patches2 - mean_patches
windowed_patches = zero_mean * window_patches
#SOME FILTERING ....
#ADD MEAN AND WINDOW BEFORE FOLDING BACK TOGETHER.
filt_data_block = (filt_data_block + mean_patches*window_patches) * window_patches
上面的代码对我有用，但是掩码会更简单。接下来，我准备将 [1, 1, 31, 31, 16, 16] 形式的张量转换回原始 [1, 1, 256, 256]:
# REASSEMBLE THE IMAGE USING FOLD
patches = filt_data_block.contiguous().view(1, 1, -1, kernel_size*kernel_size)
patches = patches.permute(0, 1, 3, 2)
patches = patches.contiguous().view(1, kernel_size*kernel_size, -1)
IR = F.fold(patches, output_size=(256, 256), kernel_size=kernel_size, stride=stride)
IR = IR.squeeze()
这使我能够创建重叠滑动 window 并将图像无缝拼接在一起。去掉过滤后得到一个相同的图像。
我正在尝试使用展开来过滤大小为 256x256 的单通道二维图像，以创建重叠为 8 的 16x16 块。如下所示：
# I = [256, 256] image
kernel_size = 16
stride = bx/2
patches = I.unfold(1, kernel_size,
int(stride)).unfold(0, kernel_size, int(stride)) # size = [31, 31, 16, 16]
我已经开始尝试通过折叠将图像重新组合在一起，但我还没有完成。我尝试使用视图让图像按照预期的方式“适应”，但我看不出这将如何保留原始图像。可能是我多虑了
# patches.shape = [31, 31, 16, 16]
patches = = filt_data_block.contiguous().view(-1, kernel_size*kernel_size) # [961, 256]
patches = patches.permute(1, 0) # size = [951, 256]
如有任何帮助，我们将不胜感激。非常感谢。
我相信在这种情况下使用 torch.nn.functional.fold 和 torch.nn.functional.unfold 会让您受益，因为这些函数是专门为图像构建的（或任何 4D 张量，形状为 B X C X H X W）。
让我们从展开图像开始：
import torch
import torch.nn.functional as F
import matplotlib.pyplot as plt
from sklearn.datasets import load_sample_image #Used to load a sample image
dtype = torch.cuda.FloatTensor if torch.cuda.is_available() else torch.FloatTensor
#Load a flower image from sklearn.datasets, crop it to shape 1 X 3 X 256 X 256:
I = torch.from_numpy(load_sample_image('flower.jpg')).permute(2,0,1).unsqueeze(0).type(dtype)[...,128:128+256,256:256+256]
kernel_size = 16
stride = kernel_size//2
I_unf = F.unfold(I, kernel_size, stride=stride)
这里我们使用F.unfold函数获得所有步幅为8的16x16图像块。这将产生一个形状为 torch.Size([1, 768, 961]) 的 3D 张量。即 - 961 个补丁，每个补丁有 768 = 16 X 16 X 3 像素。
现在，假设我们希望将其折叠回我：
I_f = F.fold(I_unf,I.shape[-2:],kernel_size,stride=stride)
norm_map = F.fold(F.unfold(torch.ones(I.shape).type(dtype),kernel_size,stride=stride),I.shape[-2:],kernel_size,stride=stride)
I_f /= norm_map
我们使用 F.fold 告诉它 I 的原始形状，我们用来展开的 kernel_size 和使用的 stride。折叠 I_unf 后，我们将获得重叠 的总和 。这意味着生成的图像将显得饱和。因此，我们需要计算一个归一化映射，该映射将归一化由于重叠导致的像素的多次求和。一种有效地做到这一点的方法是采用一个张量并使用 unfold 后跟 fold - 来模拟重叠的求和。这给了我们归一化图，我们通过它归一化 I_f 以恢复 I.
现在，我们希望绘制 I_f 和 I 以证明内容已保留：
#Plot I:
plt.imshow(I[0,...].permute(1,2,0).cpu()/255)
#Plot I_f:
plt.imshow(I_f[0,...].permute(1,2,0).cpu()/255)
整个过程也适用于 single-channel 图片。需要注意的一件事是，如果图像的空间维度不能被步幅整除，由于某些像素无法到达，您将得到带有零（在边缘）的 norm_map，但您也可以轻松处理这种情况。
比 Gil 提出的解决方案略逊一筹：
I took inspiration from this post on the Pytorch forums，将我的图像张量格式化为标准形状 B x C x H x W (1 x 1 x 256 x 256)。展开:
# CREATE THE UNFOLDED IMAGE SLICES
I = image # shape [256, 256]
kernel_size = bx #shape [16]
stride = int(bx/2) #shape [8]
I2 = I.unsqueeze(0).unsqueeze(0) #shape [1, 1, 256, 256]
patches2 = I2.unfold(2, kernel_size, stride).unfold(3, kernel_size, stride)
#shape [1, 1, 31, 31, 16, 16]
在此之后，我对我的张量堆栈进行了一些转换和过滤。在这样做之前，我应用余弦 window 并归一化：
# NORMALISE AND WINDOW
Pvv = torch.mean(torch.pow(win, 2))*torch.numel(win)*(noise_std**2)
Pvv = Pvv.double()
mean_patches = torch.mean(patches2, (4, 5), keepdim=True)
mean_patches = mean_patches.repeat(1, 1, 1, 1, 16, 16)
window_patches = win.unsqueeze(0).unsqueeze(0).unsqueeze(0).unsqueeze(0).repeat(1, 1, 31, 31, 1, 1)
zero_mean = patches2 - mean_patches
windowed_patches = zero_mean * window_patches
#SOME FILTERING ....
#ADD MEAN AND WINDOW BEFORE FOLDING BACK TOGETHER.
filt_data_block = (filt_data_block + mean_patches*window_patches) * window_patches
上面的代码对我有用，但是掩码会更简单。接下来，我准备将 [1, 1, 31, 31, 16, 16] 形式的张量转换回原始 [1, 1, 256, 256]:
# REASSEMBLE THE IMAGE USING FOLD
patches = filt_data_block.contiguous().view(1, 1, -1, kernel_size*kernel_size)
patches = patches.permute(0, 1, 3, 2)
patches = patches.contiguous().view(1, kernel_size*kernel_size, -1)
IR = F.fold(patches, output_size=(256, 256), kernel_size=kernel_size, stride=stride)
IR = IR.squeeze()
这使我能够创建重叠滑动 window 并将图像无缝拼接在一起。去掉过滤后得到一个相同的图像。