标签: generative-adversarial-network

我目前正在考虑在 keras 中实施 Self-Attention GAN。我想实现的方式如下：

def Attention(X, channels):
    def hw_flatten(x):
        return np.reshape(x, (x.shape[0], -1, x.shape[-1]))

    f = Conv2D(channels//8, kernel_size=1, strides=1, padding='same')(X)  # [bs, h, w, c']
    g = Conv2D(channels//8, kernel_size=1, strides=1, padding='same')(X)  # [bs, h, w, c']
    h = Conv2D(channels, kernel_size=1, strides=1, padding='same')(X)  # [bs, h, w, c]

    # N = h * w
    flatten_g = hw_flatten(g)
    flatten_f = hw_flatten(f)
    s = np.matmul(flatten_g, flatten_f.reshape((flatten_f.shape[0], flatten_f.shape[-1], -1)))  # [bs, N, N]

    beta = softmax(s, axis=-1)  # attention map

    flatten_h = hw_flatten(h) …

我必须用生成器和鉴别器训练 GAN 网络。我的发电机网络如下。

def Generator(image_shape=(512,512,3):
  inputs = Input(image_shape)
  # 5 convolution Layers
  # 5 Deconvolution Layers along with concatenation
  # output shape is (512,512,3) 
  model=Model(inputs=inputs,outputs=outputs, name='Generator')
  return model, output

我的鉴别器网络如下。鉴别器网络的第一步是我必须将鉴别器的输入与生成器的输出连接起来。

def Discriminator(Generator_output, image_shape=(512,512,3)):
  inputs=Input(image_shape)
  concatenated_input=concatenate([Generator_output, inputs], axis=-1)
  # Now start applying Convolution Layers on concatenated_input
  # Deconvolution Layers
  return Model(inputs=inputs,outputs=outputs, name='Discriminator')

启动架构

G, Generator_output=Generator(image_shape=(512,512,3))
G.summary

D=Discriminator(Generator_output, image_shape=(512,512,3))
D.summary()

我的问题是当我传递concatenated_input到convolution图层时，它会出现以下错误。

Graph disconnected: cannot obtain value for tensor Tensor("input_1:0", shape=(?, 512, 512, 3), dtype=float32) at layer …

我正在为我的神经网络设计一个自定义层，但我的代码出现错误。

我想做一个注意力层，如论文中所述：SAGAN。和原来的tf代码

class AttentionLayer(Layer):
def __init__(self, **kwargs):
    super(AttentionLayer, self).__init__(**kwargs)

def build(self, input_shape):
    input_dim = input_shape[-1]
    filters_f_g = input_dim // 8
    filters_h = input_dim
    kernel_shape_f_g = (1, 1) + (input_dim, filters_f_g)
    kernel_shape_h = (1, 1) + (input_dim, filters_h)
    # Create a trainable weight variable for this layer:
    self.gamma = self.add_weight(name='gamma', shape=[1], initializer='zeros', trainable=True)
    self.kernel_f = self.add_weight(shape=kernel_shape_f_g,
                                    initializer='glorot_uniform',
                                    name='kernel')
    self.kernel_g = self.add_weight(shape=kernel_shape_f_g,
                                    initializer='glorot_uniform',
                                    name='kernel')
    self.kernel_h = self.add_weight(shape=kernel_shape_h,
                                    initializer='glorot_uniform',
                                    name='kernel')
    self.bias_f = self.add_weight(shape=(filters_f_g,),
                                  initializer='zeros',
                                  name='bias')
    self.bias_g = self.add_weight(shape=(filters_f_g,),
                                  initializer='zeros',
                                  name='bias') …

我已经深入研究了甘斯，并在 pytorch 中实现了它，现在我正在研究甘斯背后的核心统计数据，当时我在看那个网站Mathematics behing Gans 它说

“Loss(G) = - Loss(D)，请注意，我们将生成器成本定义为鉴别器成本的负数。这是因为我们没有明确的方法来评估生成器的成本。”

但是在实现 gan 时，我们将生成器的损失定义为：

生成器生成的图像的鉴别器输出与原始论文和以下代码中的真实标签之间的二进制熵交叉熵损失（由我实现和测试）

    # train generator
    z_ = to.randn(minibatch,100 ).view(-1, 100, 1, 1)
    z_ = Variable(z_.cuda())
    gen_images = generator(z_)

    D_fake_decisions = discriminator(gen_images).squeeze()
    G_loss = criterion(D_fake_decisions,real_labels)

    discriminator.zero_grad()
    generator.zero_grad()
    G_loss.backward()
    opt_Gen.step()

请解释一下两者之间的区别，正确的是

代码链接：https : //github.com/mabdullahrafique/Gan_with_Pytorch/blob/master/DCGan_mnist.ipynb

谢谢

我现在做的就是GAN。事实上，我们现在还不知道 CNN 和 RNN 正在用 GAN 做什么，而且由于计算环境是个人的，所以我们正在开发一个付费版本的“Google Colab”。据我了解，Google Colab 可以使用开发环境长达 24 小时（不完全是 24 小时）。

结果，机器学习需要一些时间，中间就被切断了，到目前为止，我被迫使用可以在 24 小时内训练的数据集和 epoke 来学习，突然我想，“难道我们就不能积累训练吗？”

所以我的问题是，例如，如果我最多训练 100 次，但只训练了 50 次就被切断，我不能从 50 次开始进行下一次训练吗？如果我们能做到这一点，那么是不是可以进行长时间的训练，因为 Google Colab 可以在 24 小时限制的情况下每 24 小时继续训练一次？我也这么想。

这可能吗？

我无法判断这个错误是由于技术错误还是超参数造成的，但我的 DC-GAN 的鉴别器损失一开始很低，然后逐渐攀升，在 8 左右减慢，而我的发电机损失则大幅下降。我在大约 60,000 epoch 时结束了它。有趣的是，鉴别器的准确率似乎在 20-50% 左右浮动。有人有任何建议来解决这个问题吗？任何帮助表示赞赏。

重要信息

• 数据格式：472 320x224 彩色 PNG 文件。
• 优化器：Adam(0.0002, 0.5)
• 损失：二元交叉熵

50,000+ epochs 后生成的图像：（应该是白色背景上的运动鞋）

鉴别器模型：

    def build_discriminator(self):

        img_shape = (self.img_size[0], self.img_size[1], self.channels)

        model = Sequential()

        model.add(Conv2D(32, kernel_size=self.kernel_size, strides=2, input_shape=img_shape, padding="same"))  # 192x256 -> 96x128
        model.add(LeakyReLU(alpha=0.2))
        model.add(Dropout(0.25))

        model.add(Conv2D(64, kernel_size=self.kernel_size, strides=2, padding="same"))  # 96x128 -> 48x64
        model.add(ZeroPadding2D(padding=((0, 1), (0, 1))))
        model.add(LeakyReLU(alpha=0.2))
        model.add(Dropout(0.25))
        model.add(BatchNormalization(momentum=0.8))

        model.add(Conv2D(128, kernel_size=self.kernel_size, strides=2, padding="same"))  # 48x64 -> 24x32
        model.add(LeakyReLU(alpha=0.2))
        model.add(Dropout(0.25))
        model.add(BatchNormalization(momentum=0.8))

        model.add(Conv2D(256, kernel_size=self.kernel_size, strides=1, padding="same"))  # 24x32 -> 12x16
        model.add(LeakyReLU(alpha=0.2)) …

我正在尝试使用tensorflow和keras实现WGAN-GP模型（用于来自kaggle的信用卡欺诈数据）。

我主要遵循keras 网站中提供的示例代码以及互联网上的其他几个示例代码（但将它们从图像更改为我的数据），并且非常简单。

但是当我想更新批评家时，批评家权重的损失梯度nan在几批之后就变成了全部。这导致批评者的权重变成nan，然后生成器的权重变成nan，...所以一切都变成nan！

我使用tf.debugging.enable_check_numerics后发现问题的出现是因为-Inf经过一些迭代后a出现在梯度中。

这与损失中的梯度惩罚项直接相关，因为当我删除它时，问题就消失了。

请注意，它gp本身不是nan，但是当我获得损失批评家权重的梯度（c_grads在下面的代码中）时，它包含-Inf并以某种方式变成全部nan。

我检查了数学和网络架构是否存在可能的错误（例如梯度消失的概率等），并且我花了好几个小时检查代码是否存在可能的错误。但我被困住了。

如果有人能找到问题的根源，我将非常感激

注意： 请记住，评论家的输出和损失函数与原始论文略有不同（因为我试图使其成为有条件的），但这与问题无关，因为正如我之前所说，整个问题消失了当我刚刚删除梯度惩罚项时

这是我的批评者：

critic = keras.Sequential([
        keras.layers.Input(shape=(x_dim,), name='c-input'),
        keras.layers.Dense(64, kernel_initializer=keras.initializers.he_normal(), name='c-hidden-1'),
        keras.layers.LeakyReLU(alpha=0.25, name='c-activation-1'),
        keras.layers.Dense(32, kernel_initializer=keras.initializers.he_normal(), name='c-hidden-2'),
        keras.layers.LeakyReLU(alpha=0.25, name='c-activation-2'),
        keras.layers.Dense(2, activation='tanh', name='c-output')
    ], name='critic')

这是我的梯度惩罚函数：

def gradient_penalty(self, batch_size, x_real, x_fake):
    # get the random linear interpolation of real and fake data (x hat)
    alpha = tf.random.uniform([batch_size, 1], …

对抗网络，例如 GAN，被称为“隐式”网络。这是什么意思？而且，它们与“显式”生成网络有何不同？什么是“显式”生成网络？

我使用 gensim 库保存了我的文本向量，该库由一些负数组成。会影响训练吗？如果不是，那么为什么我在某些训练步骤之后首先获得判别器的 nan 损失值，然后再获得判别器和生成器的 nan 损失值？