标签: generative-adversarial-network

在我的理解中，epoch 是在整个数据集上任意频繁地重复运行，然后分部分处理，即所谓的批处理。每次train_on_batch计算损失后，权重都会更新，下一批将获得更好的结果。这些损失是我对神经网络质量和学习状态的指标。

在几个来源中，每个时期都会计算（并打印）损失。因此，我不确定我这样做是否正确。

目前我的 GAN 看起来像这样：

for epoch:
  for batch:

    fakes = generator.predict_on_batch(batch)

    dlc = discriminator.train_on_batch(batch, ..)
    dlf = discriminator.train_on_batch(fakes, ..)
    dis_loss_total = 0.5 *  np.add(dlc, dlf)

    g_loss = gan.train_on_batch(batch,..)

    # save losses to array to work with later

这些损失是针对每个批次的。我如何在一个时代获得它们？顺便说一句：我需要一个时代的损失，为了什么？

我刚刚开始讨论这些主题。据我所知，风格迁移从一个图像中获取内容，从另一个图像中获取风格，以第二个的风格生成或重新创建第一个，而GAN基于训练集生成全新的图像。

但是我看到很多地方两者可以互换使用，比如这里的这篇博客和其他使用 GAN 实现风格迁移的地方，比如这里的这篇论文

GAN 和样式迁移是两种不同的东西，还是 GAN 是实现样式迁移的方法，还是它们都是做同一件事的不同东西？两者之间的界限究竟在哪里？

我是 GAN 新手。我正在学习对 GAN 进行建模来生成图像，但是我并不真正了解给予生成器的随机噪声到底是什么。它是从 0 到 1 的随机数吗？它的大小应该是多少。另外，每次发电机运行时随机噪声都应该恒定吗？

任何帮助，将不胜感激。

我pytorch-1.5用来做一些gan测试。我的代码是非常简单的 gan 代码，只适合 sin(x) 函数：

import torch
import torch.nn as nn
import numpy as np
import matplotlib.pyplot as plt


# Hyper Parameters
BATCH_SIZE = 64
LR_G = 0.0001
LR_D = 0.0001 
N_IDEAS = 5  
ART_COMPONENTS = 15 
PAINT_POINTS = np.vstack([np.linspace(-1, 1, ART_COMPONENTS) for _ in range(BATCH_SIZE)])


def artist_works():  # painting from the famous artist (real target)
    r = 0.02 * np.random.randn(1, ART_COMPONENTS)
    paintings = np.sin(PAINT_POINTS * np.pi) + r
    paintings = torch.from_numpy(paintings).float()
    return paintings


G = …

我想更改保存的模型的输入和输出签名，我使用 tf.Module 对象来构建主模型的操作。

class Generator(tf.Module):
    def __init__(....):
        super(Generator, self).__init__(name=name)
        ...       
        with self.name_scope:
             ...
    @tf.Module.with_name_scope
    def __call__(self, input):
        ...

    @tf.function
    def serve_function(self, input):
        out = self.__call__(input)
        return out



call = model.Generator.serve_function.get_concrete_function(tf.TensorSpec([None, 256, 256, 3], tf.float32))
tf.saved_model.save(model.Generator, os.path.join(train_log_dir, 'frozen'))

然后我正在加载模型，但我有“default_serving”和“output_0”作为签名，我该如何更改？

我第一次生成音乐文件。音乐文件类型是“IPython.lib.display.Audio”。我想将它从 colab 导出到我的本地驱动器。我无法从谷歌找到任何解决方案。请帮忙。

我从Keras的 Paper Edge-Connect ( https://github.com/knazeri/edge-connect )实施了提议的 GAN 模型，并在 KITTI 数据集上进行了一些培训。现在我试图弄清楚我的模型内部发生了什么，因此我有几个问题。

1. 初始训练（100 Epochs，500 batches/epoch，10 Samples/Batch）

起初，我按照论文中的建议训练了模型（包括风格、感知、L1 和对抗性损失）

乍一看，该模型收敛到不错的结果：

这是屏蔽输入（右）的生成器（左）的输出

tensorboard 中的大部分图看起来也相当不错：（这些都是来自 GAN 模型的值，包含生成器的总损失（GENERATOR_Loss），基于生成的图像（L1，perc，style）的不同损失为以及对抗性损失（DISCRIMINATOR_loss）

当仔细观察鉴别器时，事情看起来就不一样了。生成图像的判别器的对抗性损失稳步增加。训练鉴别器时的损失（50/50 假/真例子）根本没有改变：

![] ( https://i.stack.imgur.com/o5jCA.png )

当查看鉴别器输出的激活直方图时，它总是输出大约 0.5 的值。

谈到我的问题/结论，我希望得到您的反馈：

• 所以我现在假设，我的模型从鉴别器学到了很多，但没有学到什么，对吧？结果都是基于对抗性损失以外的损失？
• 似乎鉴别器跟不上生成器生成更好的图像。我认为鉴别器激活应该以某种方式提前移动到 0（假标签）和 1（真实标签）附近的两个峰值并保持在那里？
• 我知道我的最终目标是鉴别器输出 0.5 的真实概率和假概率……但是当这种情况从一开始就发生并且在训练期间没有改变时，这意味着什么？
• 我是否过早停止训练？鉴别器能否赶上（因为发电机的输出不再有太大变化）并消除发电机的最后一个小故障？

2.于是我开始了第二次训练，这次只使用了生成器中的对抗性损失！（~16 个 Epoch，500 个批次/时期，10 个样本/批次）

这次鉴别器似乎能够在一段时间后区分真假。（prob_real 是分配给真实图像的平均概率，反之亦然）激活的直方图看起来也不错：

但是不知何故，在大约 4k 个样本之后，事情开始发生变化，并且在大约 7k 时它发散了……来自生成器的所有样本也如下所示：

来到我的问题/结论的第二部分：

• 我是否应该预训练鉴别器以使其领先？我想它需要以某种方式能够区分真假（输出真实的大概率，反之亦然），以便生成器可以从中学习有用的东西？出于同样的原因，我应该在训练生成器一步的同时多次训练鉴别器吗？
• 第二次训练发生了什么？鉴别器的学习率是否太高？（选项：ADAM，lr=1.0E-3）
• 互联网上关于训练 GAN 的许多提示旨在增加鉴别器工作的难度（标签噪声/标签翻转、实例噪声、标签平滑等）。在这里，我认为鉴别器更需要提升？（-> 我还在不改变生成器的情况下训练了 Disc 并且它很好地收敛了）

我正在尝试训练 GAN 以了解事件中多个特征的分布。训练的鉴别器和生成器的损失较低，但生成的事件具有不同形状的分布，但我不确定为什么。

我将 GAN 定义如下：

def create_generator():

    generator = Sequential()

    generator.add(Dense(50,input_dim=noise_dim))
    generator.add(LeakyReLU(0.2))    
    generator.add(Dense(25))
    generator.add(LeakyReLU(0.2))
    generator.add(Dense(5))
    generator.add(LeakyReLU(0.2))
    generator.add(Dense(len(variables), activation='tanh'))

    return generator


def create_descriminator():
    discriminator = Sequential()

    discriminator.add(Dense(4, input_dim=len(variables)))
    discriminator.add(LeakyReLU(0.2))
    discriminator.add(Dense(4))
    discriminator.add(LeakyReLU(0.2))
    discriminator.add(Dense(4))
    discriminator.add(LeakyReLU(0.2))
    discriminator.add(Dense(1, activation='sigmoid'))   
    discriminator.compile(loss='binary_crossentropy', optimizer=optimizer)
    return discriminator


discriminator = create_descriminator()
generator = create_generator()

def define_gan(generator, discriminator):
    # make weights in the discriminator not trainable
    discriminator.trainable = False
    model = Sequential()
    model.add(generator)
    model.add(discriminator)
    model.compile(loss = 'binary_crossentropy', optimizer=optimizer)
    return model

gan = define_gan(generator, discriminator)

我使用这个循环训练 GAN：

for epoch in range(epochs): …

我有以下目标，我一直试图通过 Huggingface 库来实现这个目标，但遇到了一些障碍。

问题：

我想在训练时以可微分的方式生成句子。我为什么要这样做？我想对这个输出应用一个判别器来生成具有某些属性的句子，这些属性是由判别器“强制执行”的。这些句子也将以输入句子为条件，因此我需要一个编码器解码器模型。

为了解决 argmax 的不可微性，我只需采用解码器的 softmax 输出并将其与我的嵌入矩阵相乘。然后，我将这个嵌入式输入输入到变压器鉴别器中，该鉴别器简单地将输入分类为原始/伪造。然后我通过编码器解码器进行反向传播。就像人们对普通 GAN 所做的那样。

到目前为止，我已经尝试使用EncoderDecoderModelHuggingface 中的。这个类有一个名为generate的方法，它以不可微分的方式（贪婪或束搜索）生成句子。因此，我深入研究了源代码并尝试构建自己的可微生成方法。但我没有让它发挥作用。

问题：

• 有没有一种相当简单的方法可以使用 Huggingface 库来做到这一点，因为我真的想使用预训练的模型以及它附带的所有其他内容？
• 有没有一种方法可以调用解码器的前向方法并仅生成一个新令牌，而不是再次生成整个序列？

感谢您的帮助，我真的很感激，我已经在这件事上安静地坚持了一段时间了。

我正在尝试使用示例代码实现此处描述的 Unrolled GAN 模型。但是，它是使用 TF1 实现的，我一直在尽最大努力对其进行更新，但我对 python 和 TF 相对较新（过去仅使用了约 6 个月）。

我似乎无法完成的行（目前，可能还有更多）是这样的：

gen_vars = tf.compat.v1.get_collection(tf.compat.v1.GraphKeys.TRAINABLE_VARIABLES, "generator")
disc_vars = tf.compat.v1.get_collection(tf.compat.v1.GraphKeys.TRAINABLE_VARIABLES, "discriminator")

这些都返回空列表，我看不到我错过了什么。即使没有指定范围，也会get_collection()返回[]. 早些时候，我们将生成器和鉴别器都定义为范围，如下所示：

def generator(z, output_dim=2, n_hidden=128, n_layer=2):
    with tf.compat.v1.variable_scope("generator"):
        h = slim.stack(z, slim.fully_connected, [n_hidden] * n_layer, activation_fn=tf.nn.tanh)
        x = slim.fully_connected(h, output_dim, activation_fn=None)
    return x

def discriminator(x, n_hidden=128, n_layer=2, reuse=False):
    with tf.compat.v1.variable_scope("discriminator", reuse=reuse):
        h = slim.stack(x, slim.fully_connected, [n_hidden] * n_layer, activation_fn=tf.nn.tanh)
        log_d = slim.fully_connected(h, 1, activation_fn=None)
    return log_d

范围的定义有问题吗？

这是我更新的完整代码，以防万一我在其他地方遗漏了一些东西：

%pylab inline …