Question

我正在尝试使用PyTorch为480 x 480像素大小的灰度图像构建自动编码器。我不知道要使用哪种类型的架构。最终，我希望能够使code_size足够小，以便可以尝试对图像的编码版本进行聚类。

如果我要集群，将要达到什么样的良好code_size？

什么是可以在减小尺寸的同时保留空间信息的好的架构？

我的重建物经常模糊不清，上面有棋盘格。

我不知道我的数据集中有多少个簇。

以下是到目前为止我最好的架构。我使用具有默认参数的Adam优化器，并且使用了二进制交叉熵损失。

class treNetFC(nn.Module):
    def __init__(self, code_size):
        super().__init__()
        self.code_size = code_size

        # Encoder Specs
        self.conv1 = nn.Conv2d(1, 32, kernel_size=5, stride=3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1)
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, stride=2, padding=1)
        self.conv4 = nn.Conv2d(128, 256, kernel_size=3, stride=2, padding=1)
        self.fc1 = nn.Linear(256*5*5, code_size)



        # Up/Down Samping
        self.pool = nn.MaxPool2d(2, 2)
        self.unpool = nn.Upsample(scale_factor=2, mode='nearest')

        # Decoder Specs
        self.fc2 = nn.Linear(code_size, 256*5*5)
        self.deconv1 = nn.ConvTranspose2d(
            256, 128, kernel_size=3, stride=2, padding=1, output_padding=1)
        self.deconv2 = nn.ConvTranspose2d(
            128, 64, kernel_size=3, stride=2, padding=1, output_padding=1)
        self.deconv3 = nn.ConvTranspose2d(
            64, 32, kernel_size=3, stride=2, padding=1, output_padding=1)
        self.deconv4 = nn.ConvTranspose2d(
            32, 1, kernel_size=5, stride=3, padding=1, output_padding=0)


    def forward(self, images):
        code = self.encode(images)
        out = self.decode(code)
        return out, code

    def encode(self, images):
        code = F.selu(self.conv1(images))
        code = self.pool(code)
        code = F.selu(self.conv2(code))
        code = self.pool(code)
        code = F.selu(self.conv3(code))
        code = F.selu(self.conv4(code))
        code = code.view(-1, 256*5*5)
        code = F.selu(self.fc1(code))
        return code

    def decode(self, code):
        out = F.selu(self.fc2(code))
        out = out.view(-1, 256, 5, 5)
        out = F.selu(self.deconv1(out))
        out = F.selu(self.deconv2(out))
        out = self.unpool(out)
        out = F.selu(self.deconv3(out))
        out = self.unpool(out)
        out = torch.sigmoid(self.deconv4(out))

        return out

我可以用100的代码大小产生不错的结果，但是只要我尝试减少它，或者使用更多的卷积层或池化层来进一步减小尺寸，我的重构就会变得模糊起来，并且它们看起来不像输入。 / p>

如何为480 x 480像素的灰度图像构建堆叠式自动编码器？

0 个答案: