python - 为什么不这样训练 GAN？

Question

我是生成网络的新手，我决定先自己尝试一下，然后再查看代码。这些是我用来训练我的 GAN 的步骤。

[库: tensorflow ]

1) 在数据集上训练鉴别器。 (我使用了 2 个特征的数据集，标签为“mediatating”或“not meditating”，数据集:https://drive.google.com/open?id=0B5DaSp-aTU-KSmZtVmFoc0hRa3c)

2) 鉴别器训练完成后，将其保存。

3) 为另一个前馈网络(或任何其他取决于您的数据集)制作另一个文件。这个前馈网络就是生成器。

4) 构建生成器后，恢复鉴别器并为生成器定义损失函数，使其学会欺骗鉴别器。 (这在 tensorflow 中不起作用，因为 sess.run() 不返回 tf 张量并且 G 和 D 之间的路径中断，但应该从头开始工作)

d_output = sess.run(graph.get_tensor_by_name('ol:0'), feed_dict={graph.get_tensor_by_name('features_placeholder:0'): g_output})
print(d_output)

optimize_for = tf.constant([[0.0]*10]) #not meditating

g_loss = -tf.reduce_mean((d_output - optimize_for)**2)

train = tf.train.GradientDescentOptimizer(learning_rate).minimize(g_loss)

我们为什么不这样训练生成器呢？这看起来简单多了。的确，我无法在 tensorflow 上运行它，但如果我从头开始，这应该是可能的。

完整代码:

鉴别器:

import pandas as pd
import tensorflow as tf
from sklearn.utils import shuffle

data = pd.read_csv("E:/workspace_py/datasets/simdata/linear_data_train.csv")

learning_rate = 0.001
batch_size = 1
n_epochs = 1000
n_examples = 999 # This is highly unsatisfying >:3
n_iteration = int(n_examples/batch_size)


features = tf.placeholder('float', [None, 2], name='features_placeholder')
labels = tf.placeholder('float', [None, 1], name = 'labels_placeholder')

weights = {
            'ol': tf.Variable(tf.random_normal([2, 1]), name = 'w_ol')
}

biases = {
            'ol': tf.Variable(tf.random_normal([1]), name = 'b_ol')
}

ol = tf.nn.sigmoid(tf.add(tf.matmul(features, weights['ol']), biases['ol']), name = 'ol')

loss = tf.reduce_mean((labels - ol)**2, name = 'loss')

train = tf.train.GradientDescentOptimizer(learning_rate).minimize(loss)

sess = tf.Session()
sess.run(tf.global_variables_initializer())

for epoch in range(n_epochs):
    ptr = 0
    data = shuffle(data)
    data_f = data.drop("lbl", axis = 1)
    data_l = data.drop(["f1", "f2"], axis = 1)

    for iteration in range(n_iteration):
        epoch_x = data_f[ptr: ptr + batch_size]
        epoch_y = data_l[ptr: ptr + batch_size]
        ptr = ptr + batch_size

        _, lss = sess.run([train, loss], feed_dict={features: epoch_x, labels:epoch_y})
    print("Loss @ epoch ", epoch, " = ", lss)

print("\nTesting...\n")

data = pd.read_csv("E:/workspace_py/datasets/simdata/linear_data_eval.csv")
test_data_l = data.drop(["f1", "f2"], axis = 1)
test_data_f = data.drop("lbl", axis = 1)
print(sess.run(ol, feed_dict={features: test_data_f}))
print(test_data_l)

print("Saving model...")
saver = tf.train.Saver()
saver.save(sess, save_path="E:/workspace_py/saved_models/meditation_disciminative_model.ckpt")
sess.close()

生成器:

import tensorflow as tf

# hyper parameters

learning_rate = 0.1
# batch_size = 1
n_epochs = 100

from numpy import random
noise = random.rand(10, 2)
print(noise)

# Model

input_placeholder = tf.placeholder('float', [None, 2])

weights = {
            'hl1': tf.Variable(tf.random_normal([2, 3]), name = 'w_hl1'),
            'ol': tf.Variable(tf.random_normal([3, 2]), name = 'w_ol')
}

biases = {
            'hl1': tf.Variable(tf.zeros([3]), name = 'b_hl1'),
            'ol': tf.Variable(tf.zeros([2]), name = 'b_ol')
}

hl1 = tf.add(tf.matmul(input_placeholder, weights['hl1']), biases['hl1'])
ol = tf.add(tf.matmul(hl1, weights['ol']), biases['ol'])

sess = tf.Session()
sess.run(tf.global_variables_initializer())

g_output = sess.run(ol, feed_dict={input_placeholder: noise})

# restoring discriminator

saver = tf.train.import_meta_graph("E:/workspace_py/saved_models/meditation_disciminative_model.ckpt.meta")
saver.restore(sess, tf.train.latest_checkpoint('E:/workspace_py/saved_models/'))

graph = tf.get_default_graph()

d_output = sess.run(graph.get_tensor_by_name('ol:0'), feed_dict={graph.get_tensor_by_name('features_placeholder:0'): g_output})
print(d_output)

optimize_for = tf.constant([[0.0]*10])

g_loss = -tf.reduce_mean((d_output - optimize_for)**2)

train = tf.train.GradientDescentOptimizer(learning_rate).minimize(g_loss)

Answer 1

鉴别器的目的不是对您的原始数据进行分类，也不是真正鉴别原始数据的任何内容。它的唯一目的是将生成器的输出与原始输出区分开来。

想一个艺术伪造者的例子。你的数据集都是原画。你的生成器网络 G 是一个艺术品伪造者，而你的鉴别器 D 是一个侦探，其唯一的生活目的就是找到 G 制造的伪造品。

D光看原画是学不到多少的。对他来说真正重要的是弄清楚是什么让 G 的伪造品与众不同。如果他的所有作品都被 D 发现并标记为伪造品，G 就无法通过销售伪造品赚钱，因此他必须学会如何阻止 D。

这创造了一个环境，在这个环境中，G 不断尝试使他的作品看起来更“像”原创艺术品，而 D 不断地越来越善于发现 G 的伪造风格的细微差别。 D 越好，G 就需要越优秀才能谋生。他们每个人都在自己的任务中做得更好，直到他们(理论上)达到由网络的复杂性和他们试图伪造的数据定义的某种纳什均衡。

这就是为什么 D 需要与 G 来回训练的原因，因为它需要知道并适应 G 的特殊细微差别(随着 G 的学习和适应而变化)，而不仅仅是找到一些“不”的平均定义伪造”。通过让 D 专门猎杀 G，你可以迫使 G 成为一个更好的伪造者，从而最终得到一个更好的生成器网络。如果你只训练 D 一次，那么 G 可以学习一些简单、明显、不重要的方法来打败 D，而实际上永远不会产生很好的伪造。