如何解决Pytorch展开并折叠:如何再次将该图像张量放回原处?
我正在尝试使用展开来过滤大小为256x256的单通道2D图像,以创建重叠为8的16x16块。如下所示:
# I = [256,256] image
kernel_size = 16
stride = bx/2
patches = I.unfold(1,kernel_size,int(stride)).unfold(0,int(stride)) # size = [31,31,16,16]
我已经开始尝试将图像折叠起来,但是还没有到那儿。我尝试使用视图来使图像“符合”预期,但我看不出它将如何保留原始图像。也许我想得太过分了。
# patches.shape = [31,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,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:],stride=stride)
norm_map = F.fold(F.unfold(torch.ones(I.shape).type(dtype),stride=stride),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,0).cpu()/255)
整个过程也适用于单通道图像。要注意的一件事是,如果跨步不能将图像的空间尺寸整除,由于某些像素无法到达,您将获得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,stride).unfold(3,stride)
#shape [1,31,16,16]
在此之后,我对张量堆栈进行了一些转换和过滤。在执行此操作之前,我应用余弦窗口并进行归一化:
# 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,16)
window_patches = win.unsqueeze(0).unsqueeze(0).unsqueeze(0).unsqueeze(0).repeat(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,kernel_size*kernel_size)
patches = patches.permute(0,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()
这使我可以创建一个重叠的滑动窗口,并将图像无缝地缝在一起。取消过滤可以得到相同的图像。
版权声明:本文内容由互联网用户自发贡献,该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容, 请发送邮件至 dio@foxmail.com 举报,一经查实,本站将立刻删除。