SeqGAN —— GAN + RL +NLP

2018-03-11

SeqGAN 是第一篇用 GAN 在 NLP 上做出一些成果的 model，Lantao Yu 的 CV 看的我也是羡慕不已，想着同龄人已经有如此出色的成绩，不由得感觉自己还是太菜了。

GAN for NLP

先前写过一篇文章，关于 Adversarial Training 在 NLP 的一些思考，Adversarial Training 算是 GAN 的源头，而 GAN 算是其在生成器领域的一大成就。但这个 GAN 在文本领域一直不怎么 work，先前我也做过用 GAN 中 Discriminator 作为 Classifier，希望对抗训练能够提升其分类准确度，然而并不成功。原因当时也总结了一下，记录在这里，一句话概括就是 Generator 太垃圾根本不能忽悠 Discriminator，反而 Discriminator 因为训练轮数少了（和 Generator 交替训练）被拖了后腿。那么问题又回到了 GAN 来生成文本的问题上了，图像和文本的核心区别在于图像的 Pixel 表示是连续的，而文本是由离散的 token 组成。因而，Goodfellow 也在 reddit 上说:

You can make slight changes to the synthetic data only if it is based on continuous numbers. If it is based on discrete numbers, there is no way to make a slight change.

If you output the word “penguin”, you can’t change that to “penguin + .001” on the next step, because there is no such word as “penguin + .001”. You have to go all the way from “penguin” to “ostrich”.

参数的微小改变不能对结果产生影响，或者说影响的方向也不对，这就导致 Discriminator 的梯度回传变得没有意义。再进一步的关于 GAN for NLP 的讨论，建议可以阅读胡杨的文章。前面说的这些都是为了凸显 SeqGAN 这一工作的重要性，毕竟，GAN 在 NLP 上这么难搞，还能搞出来，肯定了不得。确实，SeqGAN 是了 RL + GAN 用于文本生成的一大创举，接下来，一睹风采。

Seq GAN

Seq GAN 的模型很简洁：

SeqGAN model

沿用 GAN 的架构， Generator 来生成文本和 Discriminator 来判别文本是真实的还是生成的，那么是怎么解决更新 Generator 参数的这个问题的呢？用 Policy Gradient！如果我们把 Generator 看成是一个 Agent，他在每一 time step 上生成的 word token 作为 action，此前生成的所有 tokens 作为 state，我们就可以设计一个 reward function 来指导 Generator 生成更真实的句子。因为 Discriminator 输出是真实句子的概率 0-1，直接拿来作为 reward，于是就有了下面的式子:

$$ Q_{D_\phi}^{G_\theta}=(a = y_{T}, s= Y_{1:T-1} = D_{\phi}(Y_{1:T}))$$

但是对于生成了一半的句子怎么评估其真实性呢？用蒙特卡洛（蒙特卡洛就是随机采样）搜索在一个 Generator 的拷贝上（为了避免搜索过程引入对梯度的影响）补全句子，然后再交给 Discriminator 评估。于是，完成的 Q function 如下：

Q function

讲到这里，整个模型的架构已经讲完了，是不是很简单粗暴明了。接下来实作上还有一些小 tricks，文章的算法摘录如下：

SeqGAN Algorithm

Tricks

有些经验性的东西能 work 但是说不出个由头，也就成了所谓的玄学，文章用到的一些 tricks 如下：

CNN 做 Discriminator，LSTM 做 Generator：LSTM 做 Generator 没什么话说，Seq2Seq 里面也差不多是这么做的，为什么用 CNN 做 Discriminator 而不是 RNN，我觉得一个很重要的原因是 CNN 比 RNN，其他的就不清楚了。
还有就是 Reddit 上一个用户的 trick，也在 SeqGAN 中出现了：

a). Train a generator (G0) as normal using max-likelihood.

b). Train your discriminator to discriminate between inputs of this generator (G0) and real data.

c). Start with a fresh generator (G1) and use the GAN architecture to train it using the same discriminator.

先用 MLE 来训练 G，再用 G 生成的文本和真实文本预训练一下 D，再用全新的 G1 开始 Adversarial Training，可以理解为以后的拳击运动做热身运动吧。不过文章没有用一个全新的 G1，而是在 G 的基础上继续 G vs D 的过程。
$G_\beta$ 的参数并不是完全和 $G_\theta$ 保持完全一致，而是稍稍有些滞后更新，这是一个 weight decay 的操作，目的是用于 regularization，后面会详细的说。

Code

SeqGAN 的代码已经开源，但网上很少有结合代码对照论文讲解的。我向来是奉行 talk is cheap, show me the code 这一朴素的原则，因此，我来尝试着对论文的核心代码做一些小小的解释。

Generator

前面说了，Generator 是用一个 LSTM 做的，TensorFlow 本身有着 LSTM cell 的封装，但是不好用，为什么呢？因为 token 是要一步一步生成的，而 LSTM cell 是无法参与 iteration 这一过程的，因此需要手搓一个 LSTM cell 和循环生成 token 的代码：

# TensorArray for storing results
gen_o = tensor_array_ops.TensorArray(dtype=tf.float32, size=self.sequence_length,dynamic_size=False, infer_shape=True)
gen_x = tensor_array_ops.TensorArray(dtype=tf.int32, size=self.sequence_length, dynamic_size=False, infer_shape=True)

def _g_recurrence(i, x_t, h_tm1, gen_o, gen_x):
	h_t = self.g_recurrent_unit(x_t, h_tm1)  # hidden_memory_tuple
	o_t = self.g_output_unit(h_t)  # batch x vocab , xw + b logits not prob
	log_prob = tf.log(tf.nn.softmax(o_t))
	 # 根据 log_prob 采样下一个 word token
	next_token = tf.cast(tf.reshape(tf.multinomial(log_prob, 1), [self.batch_size]), tf.int32)
	# map next token to word embedding
	x_tp1 = tf.nn.embedding_lookup(self.g_embeddings, next_token)  # batch x emb_dim
	# save prob of the select token
	gen_o = gen_o.write(i, tf.reduce_sum(tf.multiply(tf.one_hot(next_token, self.num_emb, 1.0, 0.0),                                                   tf.nn.softmax(o_t)), 1))  # [batch_size] , prob
    gen_x = gen_x.write(i, next_token)  # indices, batch_size , save token generated
    return i + 1, x_tp1, h_t, gen_o, gen_x
	# while loop for generating tokens by time step
	_, _, _, self.gen_o, self.gen_x = control_flow_ops.while_loop(
            cond=lambda i, _1, _2, _3, _4: i < self.sequence_length,
            body=_g_recurrence,
            loop_vars=(tf.constant(0, dtype=tf.int32),
                       tf.nn.embedding_lookup(self.g_embeddings, self.start_token), self.h0, gen_o, gen_x))
	self.gen_x = self.gen_x.stack()  # seq_length x batch_size
	self.gen_x = tf.transpose(self.gen_x, perm=[1, 0])  # batch_size x seq_length

LSTM 的代码就不放了。这里用 TensorArray 来做结果的保存让我学到了，以前我都一直不知道用什么 TensorFlow 类型能不断的往里面写和读（Variable、Constant不能写，placeholder 要你传进去）。

至于预训练阶段，我们的生成是要基于真实的 token 的，所以代码有所区别:

# supervised loss
g_predictions = tensor_array_ops.TensorArray(dtype=tf.float32, size=self.sequence_length,dynamic_size=False, infer_shape=True)
ta_emb_x = tensor_array_ops.TensorArray(dtype=tf.float32, size=self.sequence_length)
# embedded x : seq * batch_size *  emb_size
ta_emb_x = ta_emb_x.unstack(self.processed_x) 

# using the same lstm cell to generate tokens
def _pretrain_recurrence(i, x_t, h_tm1, g_predictions):
	h_t = self.g_recurrent_unit(x_t, h_tm1)
	o_t = self.g_output_unit(h_t)
    # batch x vocab_size
	g_predictions = g_predictions.write(i, tf.nn.softmax(o_t))  
	 # using the real token to generate next token
	x_tp1 = ta_emb_x.read(i)
	return i + 1, x_tp1, h_t, g_predictions
# while loop for supervised task 
_, _, _, self.g_predictions = control_flow_ops.while_loop(
            cond=lambda i, _1, _2, _3: i < self.sequence_length,
            body=_pretrain_recurrence,
            loop_vars=(tf.constant(0, dtype=tf.int32),
                       tf.nn.embedding_lookup(self.g_embeddings, self.start_token),
                       self.h0,
                       g_predictions)
        )
self.g_predictions = tf.transpose(self.g_predictions.stack(),
                                          perm=[1, 0, 2])  # batch_size x seq_length x 
# pretrain loss，基于 MLE 的 loss ， log prob * one_hot label
self.pretrain_loss = -tf.reduce_sum(
            tf.one_hot(tf.to_int32(tf.reshape(self.x, [-1])), self.num_emb, 1.0, 0.0) *
            tf.log(tf.clip_by_value(tf.reshape(self.g_predictions, [-1, self.num_emb]), 1e-20, 1.0))
        ) / (self.sequence_length * self.batch_size)

# training update 
pretrain_opt = self.g_optimizer(self.learning_rate)
self.pretrain_grad, _ = tf.clip_by_global_norm(tf.gradients(self.pretrain_loss, self.g_params), self.grad_clip)
self.pretrain_updates = pretrain_opt.apply_gradients(zip(self.pretrain_grad, self.g_params))

手动 optimize varibales 虽然我也不是第一次见到了，一般我都很懒的 tf.train.AdamOptimizer().minimize(loss)，但我查了一下，说是梯度裁剪gradient clip 确实很多情况下比不裁剪要好，以后也就尽量这么干吧。

最后来看一眼 Generator 的 loss :

# generator loss
self.g_loss = -tf.reduce_sum(
	tf.reduce_sum(
        tf.one_hot(tf.to_int32(tf.reshape(self.x, [-1])), self.num_emb, 1.0, 0.0) *
		tf.log(tf.clip_by_value(tf.reshape(self.g_predictions, [-1, self.num_emb]), 1e-20, 1.0)),
		axis=1) * tf.reshape(self.rewards, [-1]))

就是我们上篇 blog 讲的，在 MLE loss 基础上，通过 reward 加权求和得到。

Discriminator

文章用 CNN 做 Discriminator，实际上就是一个分类器，输出 [0, 1] 则为真实文本，[1, 0] 即为生成本文。CNN 做 Classifier 在图像领域我是见的很多，做文本听说过但还真是第一次见：

# Create a convolution + maxpool layer for each filter size
for filter_size, filter_num in zip(filter_sizes, num_filters):
    # Create a convolution + maxpool layer for each filter size
    with tf.name_scope("cov2d-maxpool%s" % filter_size):
        filter_shape = [filter_size, embedding_size, 1, filter_num]
        W = tf.Variable(tf.truncated_normal(filter_shape, stddev=0.1), name="W")
        b = tf.Variable(tf.constant(0.1, shape=[filter_num]), name="b")
        conv = tf.nn.conv2d(
            self.embedded_chars_expanded,
            W,
            strides=[1, 1, 1, 1],
            padding="VALID",
            name="conv")
        # filter_num
        h = tf.nn.relu(tf.nn.bias_add(conv, b), name="relu")
        pooled = tf.nn.max_pool(
            h,
            ksize=[1, sequence_length - filter_size + 1, 1, 1],
            strides=[1, 1, 1, 1],
            padding='VALID',
            name="pool")  # 全部池化到 1x1
        # print(conv.name, ": ", conv.shape , "----", pooled.name, " : " ,pooled.shape)
        pooled_outputs.append(pooled)
total_filters_num = sum(num_filters)
# 拼接卷积结果
self.h_pool = tf.concat(pooled_outputs, 3)
# batch * total_num
self.h_pool_flat = tf.reshape(self.h_pool, [-1, total_filters_num]) 
with tf.name_scope("output"):
    W = tf.Variable(tf.truncated_normal([total_filters_num, num_classes], stddev=0.1), name="W")
    b = tf.Variable(tf.constant(0.1, shape=[num_classes]), name="b")
    l2_loss += tf.nn.l2_loss(W)
    l2_loss += tf.nn.l2_loss(b)
    self.scores = tf.nn.xw_plus_b(self.h_drop, W, b, name="scores")
    self.ypred_for_auc = tf.nn.softmax(self.scores)
    self.predictions = tf.argmax(self.scores, 1, name="predictions")
with tf.name_scope("loss"):
    losses = tf.nn.softmax_cross_entropy_with_logits(logits=self.scores, labels=self.input_y)
    self.loss = losses + l2_reg_lambda * l2_loss

把 word embedding 之后的 [batch_size, seq_len, embedding_size] 的向量扩充一个维度(对应 RGB channel)变成[batch_size, seq_len, embedding_size, 1] 我们就可以把文本看成一张图片了，然后使用不同 size 的 kernel，主要是 [1, filter_size, embedding_size, 1]，因为第一维是 batch_size 一般不做卷积操作，第二维是长度，我们会用不同长度的 filter_size 来 capture 不同长度下的特征，然后最后池化到 1x1，再把不同 kernel 卷积的结果拼起来，最后来一层全连接层输出到 num_class 搞定。

同样这里使用了手动 optimize：

self.params = [param for param in tf.trainable_variables() if 'discriminator' in param.name]
        d_optimizer = tf.train.AdamOptimizer(1e-4)
        # aggregation_method =2 似乎能够帮助减少内存占用
        grads_and_vars = d_optimizer.compute_gradients(self.loss, self.params, aggregation_method=2)
        self.train_op = d_optimizer.apply_gradients(grads_and_vars)

G_beta

$G_\beta$ 值得好好谈一谈，首先是要实现的功能：MC 产生完整的句子以及给出 reward。

先来看 MC 产生完整句子：

#  Unstack the values of a `Tensor` to the TensorArray
ta_emb_x = tensor_array_ops.TensorArray(dtype=tf.float32, size=self.sequence_length)
ta_emb_x = ta_emb_x.unstack(self.processed_x)  # seq * emb_size

ta_x = tensor_array_ops.TensorArray(dtype=tf.int32, size=self.sequence_length)
ta_x = ta_x.unstack(tf.transpose(self.x, perm=[1, 0]))  # seq * batch

# start state 
self.h0 = tf.zeros([self.batch_size, self.hidden_dim])
self.h0 = tf.stack([self.h0, self.h0])

# TensorArray for storing the generated tokens
gen_x = tensor_array_ops.TensorArray(dtype=tf.int32, size=self.sequence_length)


# while i < given num , using the provided tokens as input
def _g_recurrence_1(i, x_t, h_tm1, given_num, gen_x):
    h_t = self.g_recurrent_unit(x_t, h_tm1)
    x_tp1 = ta_emb_x.read(i)
    gen_x = gen_x.write(i, ta_x.read(i))
    return i + 1, x_tp1, h_t, given_num, gen_x
# i > given num, generate token using tokens generated before
def _g_recurrence_2(i, x_t, h_tm1, gen_x):
    h_t = self.g_recurrent_unit(x_t, h_tm1)
    o_t = self.g_output_unit(h_t)  # logits  : batch x vocab
    log_prob = tf.log(tf.nn.softmax(o_t))  # log prob
    next_token = tf.cast(tf.reshape(tf.multinomial(log_prob, 1), [self.batch_size]), tf.int32)
    x_tp1 = tf.nn.embedding_lookup(self.g_embeddings, next_token)
    gen_x = gen_x.write(i, next_token)
    return i + 1, x_tp1, h_t, gen_x

i, x_t, h_tm1, given_num, self.gen_x = control_flow_ops.while_loop(
    cond=lambda i, _1, _2, given_num, _4: i < given_num,
    body=_g_recurrence_1,
    loop_vars=(
        tf.constant(0, dtype=tf.int32),
        tf.nn.embedding_lookup(self.g_embeddings, self.start_token),
        self.h0, self.given_num, gen_x
    )
)
# generate the complete sentence
_, _, _, self.gen_x = control_flow_ops.while_loop(
    cond=lambda i, _1, _2, _3: i < self.sequence_length,
    body=_g_recurrence_2,
    loop_vars=(i, x_t, h_tm1, self.gen_x)
)

这里有两个循环，是针对两种情况，一个是已经生成的部分，直接用已经给出的 tokens 作为输入，但是考虑到后面继续生成未完成的部分我们还需要最后一个给定 tokens 所产生的 hidden_state，所以我们依旧进行 time step 的循环；到了没有 tokens 的时候，根据最后一个 hidden_state 继续生成完整的句子，就和 Generator 的代码类似了。

给出 reward，就是基于已经补充完整的句子，通过 Discriminator 计算他的真实性，用真实性概率作为 reward：

def get_reward(self, sess, input_x, rollout_num, discriminator):
    rewards = []
    for i in range(rollout_num):
        for given_num in range(1, self.sequence_length):
            feed = {self.x: input_x, self.given_num: given_num}
            samples = sess.run(self.gen_x, feed)
            feed = {discriminator.input_x: samples, discriminator.dropout_keep_prob: 1.0}
            ypred_for_auc = sess.run(discriminator.ypred_for_auc, feed)
            ypred = np.array([item[1] for item in ypred_for_auc])
            if i == 0:
                rewards.append(ypred)
            else:
                rewards[given_num - 1] += ypred

        # the last token reward
        feed = {discriminator.input_x: input_x, discriminator.dropout_keep_prob: 1.0}
        ypred_for_auc = sess.run(discriminator.ypred_for_auc, feed)
        ypred = np.array([item[1] for item in ypred_for_auc])
        if i == 0:
            rewards.append(ypred)
        else:
            rewards[self.sequence_length] += ypred
	# batch_size x seq_length
    rewards = np.transpose(np.array(rewards)) / (1.0 * rollout_num)  
    return rewards

因为我们的 Discriminator 的输出是类似 [0.1, 0.9] 这样的概率，所以句子为真实文本的概率即为 item[1] 的值，我们采样 rollout_num 次，对最后的 reward 取平均得到最终的 reward，这也就是前面 Q function 的实际实现。PS：原版的实现这里直接把 self.sequence_length 代成了 20，为此我还提了一个 PR，不知道 LantaoYu 会不会 merge， 2333.

然后是其参数更新的手段，由于篇幅，只展示最后输出单元的代码：

def update_output_unit(self):
    # weight decay
    self.Wo = self.update_rate * self.Wo + (1 - self.update_rate) * tf.identity(self.lstm.Wo)
    self.bo = self.update_rate * self.bo + (1 - self.update_rate) * tf.identity(self.lstm.bo)

    def unit(hidden_memory_tuple):
        hidden_state, c_prev = tf.unstack(hidden_memory_tuple)
        logits = tf.matmul(hidden_state, self.Wo) + self.bo
        return logits
    return unit

文章里说 $G_\beta$ 是和 $G_\theta$ 完全相同的，但这里参数的更新并不是直接拷贝，而是根据 update rate 来计算需要更新的部分，也可以理解，因为 SGD 训练的更新必然是 variance 的，而限制每次更新的幅度能够起到 regularizaiton 的作用。

Training Process

训练的过程就按照算法描述的部分，这边就摘录一些核心的片段：

# avoid occupy all the memory of the GPU
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
sess = tf.Session(config=config)
sess.run(tf.global_variables_initializer())

这是我以前一直不知道的用法，因为我没有 GPU（贫穷限制了我的想象力），因为 TensorFlow 默认会占完所有显存，所以如果和别人共用机子，写上这样的配置可以按需分配显存。

for total_batch in range(TOTAL_BATCH):
    # train generator once
    for it in range(1):
        samples = G.generate(sess)
        rewards = g_beta.get_reward(sess, samples, sample_time, D)
        feed = {G.x: samples, G.rewards: rewards}
        _ = sess.run(G.g_update, feed_dict=feed)
    g_beta.update_params()

    # train the discriminator
    for it in range(5):
        generate_samples(sess, G, BATCH_SIZE, generated_num, negative_file)
        dis_data_loader.load_train_data(positive_file, negative_file)

        for _ in range(3):
            dis_data_loader.reset_pointer()
            for batch in range(dis_data_loader.num_batch):
                x_batch, y_batch = dis_data_loader.next_batch()
                feed = {
                    D.input_x: x_batch,
                    D.input_y: y_batch,
                    D.dropout_keep_prob: dis_dropout_keep_prob
                }
                _ = sess.run(D.train_op, feed_dict=feed)

核心的 Adversarial Training 的代码就在上面了，在一次迭代中生成一些 fake data，根据 reward 来更新 G 的参数，同时滞后更新 $G_\beta$ 的参数，然后再训练 Discriminator。这里是 Discriminator 训练的次数多于 Generator，这也是 GAN 里面常用的手段了。

Summary

SeqGAN 的代码是用的合成数据做实验，输出只有 loss，无法直观的感受其生产的结果，但实际真实的文本生成还没有对应的开源代码。论文有提到说拿来测试过古诗生成，所以接下来我会尝试用 SeqGAN 做一下古诗生成的任务，看看效果到底怎么样。

这个代码看了我三天，收获到了很多原本不知道的 TensorFlow 的用法，所以说，代码还是多看多写。