构造G和D网络

一、建立生成模型

        with tf.variable_scope('Gen'):
            # 伪造数据的生成
            self.z = tf.placeholder(tf.float32, shape=(self.batch_size, 1))
            self.G = generator(self.z, self.mlp_hidden_size)

1、定义generator,用于生成数据，这里使用两层神经网络

def generator(input, h_dim):
    h0 = tf.nn.softplus(linear(input, h_dim, 'g0'))
    h1 = linear(h0, 1, 'g1')
    return h1

通过linear函数输入为12x1的shape，然后这个12x1的shape初始化一个w一个b，然后得到h1
生成网络非常简易只有2层，这次只生成了一维的点，不需要复杂网络

二、建立判别模型

对于D网络，有些许不同，因为他不光要接收真实的数据当做输入还要接收生成数据当做输入，用D1,D2来表示

with tf.variable_scope('Disc') as scope:
            # 对真实值做预测， D1为真实值的概率
            self.x = tf.placeholder(tf.float32, shape=(self.batch_size, 1))
            self.D1 = discriminator(self.x, self.mlp_hidden_size)
            # 变量重用
            scope.reuse_variables()
            # 对生成数据做预测， D2为预测到造假值的概率
            self.D2 = discriminator(self.G, self.mlp_hidden_size)

reuse意思是这两个网络是一样的只是把他们的变量重新使用了一下
不需要再重新定义

三、损失函数

        self.loss_d = tf.reduce_mean(-tf.log(self.D1) - tf.log(1 - self.D2))
        self.loss_g = tf.reduce_mean(-tf.log(self.D2))

1、对于self.loss_d：

左半边为真实的输入D1，希望log完的值越低越好，即希望self.D1是等于1的，那么log就趋近于0。
右半边为生成的输入D2，希望self.D2是等于0的，1-self.D2等于1，则log(1-self.D2)趋近于0。
如果离1越远，损失函数越大。

2、对于self.loss_g:

生成网络的损失函数，生成网络能够骗过判别网络，判别为真就行，希望self.D2生成数据判别为1

loss_d希望self.D2趋近于0，loss_g希望self.D2趋近于1

四、优化器

先把刚刚初始化参数拿到手
拿到手之后定义optimizer，学习率不断衰减的学习策略，通过这样的求解器不断的优化loss_d和loss_g
不断的优化这两个loss之后，就能得到两组参数模型，一组参数为生成网络生成参数，另一组为判别网络参数

self.d_pre_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='D_pre')
        self.d_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Disc')
        self.g_params = tf.get_collection(tf.GraphKeys.TRAINABLE_VARIABLES, scope='Gen')
        # 获得训练以后的参数
        self.opt_d = optimizer(self.loss_d, self.d_params, self.learning_rate)
        self.opt_g = optimizer(self.loss_g, self.g_params, self.learning_rate)

五、训练网络

def train(self):
        with tf.Session() as session:
            tf.global_variables_initializer().run()

            # pretraining discriminator
            num_pretrain_steps = 1000               #训练次数
            for step in range(num_pretrain_steps):  #先训练D_pre网络
                d = (np.random.random(self.batch_size) - 0.5) * 10.0
                # 生成随机值的标签
                labels = norm.pdf(d, loc=self.data.mu, scale=self.data.sigma)
                pretrain_loss, _ = session.run([self.pre_loss, self.pre_opt], {
                    self.pre_input: np.reshape(d, (self.batch_size, 1)),
                    self.pre_labels: np.reshape(labels, (self.batch_size, 1))
                })
            # 获得D_pre参数
            self.weightsD = session.run(self.d_pre_params)
            # copy weights from pre-training over to new D network
            # 将d_pre_params 参数拷贝给 d_params
            for i, v in enumerate(self.d_params):
                session.run(v.assign(self.weightsD[i]))#有了D_pre往D网络进行真正的初始化 

            # 进行两个对抗函数的参数训练
            for step in range(self.num_steps):
                # update discriminator
                x = self.data.sample(self.batch_size)#真实数据，有均值、标准差
                z = self.gen.sample(self.batch_size) #随机的高斯初始化
                loss_d, _ = session.run([self.loss_d, self.opt_d], {#先优化D
                    self.x: np.reshape(x, (self.batch_size, 1)),
                    self.z: np.reshape(z, (self.batch_size, 1))
                })

                # update generator
                z = self.gen.sample(self.batch_size)
                loss_g, _ = session.run([self.loss_g, self.opt_g], {
                    self.z: np.reshape(z, (self.batch_size, 1))
                })
                # 迭代一百次或者在最后一次进行画图
                if step % self.log_every == 0:
                    print('{}: {}\t{}'.format(step, loss_d, loss_g))                
                if step % 100 == 0 or step==0 or step == self.num_steps -1 :
                    self._plot_distributions(session)