为什么随着网络训练的更多，GAN 生成的图像会变得更暗？

Question

我创建了一个简单的 6 层 DCGAN，并在 CelebA 数据集（其中一部分包含 30K 图像）上对其进行了训练。
我注意到我的网络生成的图像看起来很暗，随着网络训练的更多，明亮的颜色会逐渐变成暗淡的颜色！

这里有一些例子：
这就是 CelebA 图像的样子（用于训练的真实图像）：

这些是生成的，数字表示 epoch 数（他们最终训练了 30 个 epoch）：

造成这种现象的原因是什么？
我尝试了所有关于GANs 的一般技巧，例如在-1 和1 之间重新缩放输入图像，或者在Discriminator 的第一层和@的最后一层不使用BatchNorm 987654335@ 或 在Discriminator 中使用LeakyReLU(0.2)，在Generator 中使用ReLU。但我不知道为什么图像会这么暗/暗！
这是由于训练图像较少造成的吗？
还是网络问题造成的？如果是这样，这些缺陷的根源是什么？
以下是这些网络的实施方式：

def conv_batch(in_dim, out_dim, kernel_size, stride, padding, batch_norm=True):
    layers = nn.ModuleList()
    conv = nn.Conv2d(in_dim, out_dim, kernel_size, stride, padding, bias=False)
    layers.append(conv)
 if batch_norm:
        layers.append(nn.BatchNorm2d(out_dim))
 return nn.Sequential(*layers)

class Discriminator(nn.Module):
    def __init__(self, conv_dim=32, act = nn.ReLU()):
        super().__init__()

        self.conv_dim = conv_dim 
        self.act = act
        self.conv1 = conv_batch(3, conv_dim, 4, 2, 1, False)
        self.conv2 = conv_batch(conv_dim, conv_dim*2, 4, 2, 1)
        self.conv3 = conv_batch(conv_dim*2, conv_dim*4, 4, 2, 1)
        self.conv4 = conv_batch(conv_dim*4, conv_dim*8, 4, 1, 1)
        self.conv5 = conv_batch(conv_dim*8, conv_dim*10, 4, 2, 1)
        self.conv6 = conv_batch(conv_dim*10, conv_dim*10, 3, 1, 1)

        self.drp = nn.Dropout(0.5)
        self.fc = nn.Linear(conv_dim*10*3*3, 1) 

    def forward(self, input):
        batch = input.size(0)
        output = self.act(self.conv1(input))
        output = self.act(self.conv2(output))
        output = self.act(self.conv3(output))
        output = self.act(self.conv4(output))
        output = self.act(self.conv5(output))
        output = self.act(self.conv6(output))

        output = output.view(batch, self.fc.in_features)
        output = self.fc(output)
        output = self.drp(output)

        return output

def deconv_convtranspose(in_dim, out_dim, kernel_size, stride, padding, batchnorm=True):
    layers = []
    deconv = nn.ConvTranspose2d(in_dim, out_dim, kernel_size = kernel_size, stride=stride, padding=padding)
    layers.append(deconv)
    if batchnorm:
        layers.append(nn.BatchNorm2d(out_dim))
    return nn.Sequential(*layers)

class Generator(nn.Module):
    def __init__(self, z_size=100, conv_dim=32): 
        super().__init__()
         self.conv_dim = conv_dim
         # make the 1d input into a 3d output of shape (conv_dim*4, 4, 4 )
         self.fc = nn.Linear(z_size, conv_dim*4*4*4)#4x4
         # conv and deconv layer work on 3d volumes, so we now only need to pass the number of fmaps and the
         # input volume size (its h,w which is 4x4!)
         self.drp = nn.Dropout(0.5)
        self.deconv1 = deconv_convtranspose(conv_dim*4, conv_dim*3, kernel_size =4, stride=2, padding=1)
        self.deconv2 = deconv_convtranspose(conv_dim*3, conv_dim*2, kernel_size =4, stride=2, padding=1)
        self.deconv3 = deconv_convtranspose(conv_dim*2, conv_dim, kernel_size =4, stride=2, padding=1)
        self.deconv4 = deconv_convtranspose(conv_dim, conv_dim, kernel_size =3, stride=2, padding=1)
        self.deconv5 = deconv_convtranspose(conv_dim, 3, kernel_size =4, stride=1, padding=1, batchnorm=False)


    def forward(self, input):
        output = self.fc(input)
        output = self.drp(output)
        output = output.view(-1, self.conv_dim*4, 4, 4)
        output = F.relu(self.deconv1(output))
        output = F.relu(self.deconv2(output))
        output = F.relu(self.deconv3(output))
        output = F.relu(self.deconv4(output))
        # we create the image using tanh!
        output = F.tanh(self.deconv5(output))

        return output

# testing nets 
dd = Discriminator()
zd = np.random.rand(2,3,64,64)
zd = torch.from_numpy(zd).float()
# print(dd)
print(dd(zd).shape)

gg = Generator()
z = np.random.uniform(-1,1,size=(2,100))
z = torch.from_numpy(z).float()
print(gg(z).shape)

Answer 1

我认为问题在于架构本身，我会首先考虑生成图像的整体质量，而不是它们的亮度或暗度。当你训练更多的时代时，这些世代显然会变得更好。我同意图像变得更暗，但即使在早期，生成的图像也比训练样本中的图像暗得多。 （至少与您发布的相比。）

现在回到您的架构，30k 个样本实际上足以获得令人信服的结果，正如最先进的人脸生成模型所取得的那样。几代人确实变得更好了，但距离“非常好”还有很长的路要走。

我认为生成器肯定不够强大，是有问题的部分。（你的生成器损失猛增的事实也可以暗示这一点。）在生成器中，你要做的就是只是上采样和上采样。您应该注意，转置卷积更像是一种启发式方法，它不提供太多的可学习性。这与问题的性质有关。当您进行卷积时，您拥有所有信息并且您正在尝试学习编码，但在解码器中，您正在尝试恢复以前丢失的信息:)。因此，在某种程度上，它更难学习，因为作为输入的信息有限且缺乏。

事实上，确定性双线性插值方法的性能与转置卷积相似甚至更好，并且这些方法完全基于缩放/扩展零可学习性。（https://arxiv.org/pdf/1707.05847.pdf )

为了观察转置卷积的限制，我建议您将所有Transposedconv2d 替换为UpSampling2D (https://www.tensorflow.org/api_docs/python/tf/keras/layers/UpSampling2D)，我声称结果不会有太大不同。 UpSampling2D 是我提到的确定性方法之一。

要改进您的生成器，您可以尝试在上采样层之间插入卷积层。这些层将细化特征/图像并纠正上采样期间发生的一些错误。除了更正之外，下一个上采样层将采用更多信息输入。我的意思是尝试在此链接 (https://arxiv.org/pdf/1505.04597.pdf) 中找到类似 UNet 的解码。当然，这将是探索的主要步骤。您可以尝试更多 GAN 架构，并且可能会表现得更好。