Python 为什么不这样训练GANs呢？

我对生成网络还不熟悉，我决定先自己尝试一下，然后再看代码。这些是我用来训练我的脚的步骤

[lib:tensorflow]

1） 在数据集上训练鉴别器。（我使用了一个包含两个特性的数据集，标签为“中介”或“不冥想”，数据集：）

2） 一旦识别器被训练，保存它

3） 为另一个前馈网络（或任何其他，取决于您的数据集）创建另一个文件。这个前馈网络就是发电机

4） 一旦生成器构建完成，恢复鉴别器，并为生成器定义损失函数，使其学会愚弄鉴别器。（这在tensorflow中不起作用，因为sess.run（）不返回tf张量以及G和D之间的路径中断，但从头开始执行时应该起作用）

我们为什么不这样训练发电机呢？这似乎简单得多。这是真的，我无法在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)

---

鉴别器的目的不是对原始数据进行分类，也不是真正对原始数据进行鉴别。其唯一目的是区分发电机的输出和原始输出

想象一个艺术品伪造者的例子。您的数据集是所有原始绘画。你的生成器网络G是一个艺术品伪造者，而你的鉴别器D是一个侦探，他一生的唯一目的就是找到G的伪造品

D光看原画学不了多少东西。对他来说，真正重要的是弄清楚是什么让G的赝品与众不同。如果G的所有作品都被发现并被D标记为伪造品，他就不能靠卖假货赚钱，所以他必须学会如何挫败D

这就创造了一个环境，在这个环境中，G一直在努力使他的作品看起来更“像”原作，而D则一直在更好地发现G伪造风格的细微差别。D越好，G就需要越好才能谋生。他们每个人都能更好地完成任务，直到（理论上）达到某种纳什均衡，这种均衡是由网络的复杂性和他们试图伪造的数据定义的

---

这就是为什么D需要和G一起反复训练的原因，因为它需要知道并适应G的特殊细微差别（随着G的学习和适应而变化），而不仅仅是找到“非伪造”的一般定义。通过使D亨特G具体化，你迫使G成为一个更好的伪造者，从而得到一个更好的生成器网络。如果你只训练D一次，那么G就可以学习一些简单、明显、不重要的方法来击败D，而且永远不会真正产生非常好的伪造品。

我明白了。看来我对甘斯的理解还很模糊。非常感谢。

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)