{'fraction_non_alphanumeric': 0.03441124300723154, 'fraction_numerical': 0.013753581661891117, 'mean_word_length': 4.605935444393452, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 13, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
SeqGAN: Sequence Generative Adversarial Nets with Policy Gradient

As a new way of training generative models, Generative Adversarial Nets (GAN) that uses a discriminative model to guide the training of the generative model has enjoyed considerable success in generating real-valued data. However, it has limitations when the goal is for generating sequences of discrete tokens. A major reason lies in that the discrete outputs from the generative model make it difficult to pass the gradient update from the discriminative model to the generative model. Also, the discriminative model can only assess a complete sequence, while for a partially generated sequence, it is non-trivial to balance its current score and the future one once the entire sequence has been generated. In this paper, we propose a sequence generation framework, called SeqGAN, to solve the problems. Modeling the data generator as a stochastic policy in reinforcement learning (RL), SeqGAN bypasses the generator differentiation problem by directly performing gradient policy update. The RL reward signal comes from the GAN discriminator judged on a complete sequence, and is passed back to the intermediate state-action steps using Monte Carlo search. Extensive experiments on synthetic data and real-world tasks demonstrate significant improvements over strong baselines.


Introduction
Generating sequential synthetic data that mimics the real one is an important problem in unsupervised learning. Recently, recurrent neural networks (RNNs) with long shortterm memory (LSTM) cells (Hochreiter and Schmidhuber 1997) have shown excellent performance ranging from natural language generation to handwriting generation (Wen et al. 2015;Graves 2013). The most common approach to training an RNN is to maximize the log predictive likelihood of each true token in the training sequence given the previous observed tokens (Salakhutdinov 2009). However, as argued in , the maximum likelihood approaches suffer from so-called exposure bias in the inference stage: the model generates a sequence iteratively and predicts next token conditioned on its previously predicted ones that may be never observed in the training data. Such a discrepancy between training and inference can incur accumulatively along with the sequence and will become prominent as the length of sequence increases. To address this problem,  proposed a training strategy called scheduled sampling (SS), where the generative model is partially fed with its own synthetic data as prefix (observed tokens) rather than the true data when deciding the next token in the training stage. Nevertheless, (Huszár 2015) showed that SS is an inconsistent training strategy and fails to address the problem fundamentally. Another possible solution of the training/inference discrepancy problem is to build the loss function on the entire generated sequence instead of each transition. For instance, in the application of machine translation, a task specific sequence score/loss, bilingual evaluation understudy (BLEU) (Papineni et al. 2002), can be adopted to guide the sequence generation. However, in many other practical applications, such as poem generation (Zhang and Lapata 2014) and chatbot (Hingston 2009), a task specific loss may not be directly available to score a generated sequence accurately.
General adversarial net (GAN) proposed by (Goodfellow and others 2014) is a promising framework for alleviating the above problem. Specifically, in GAN a discriminative net D learns to distinguish whether a given data instance is real or not, and a generative net G learns to confuse D by generating high quality data. This approach has been successful and been mostly applied in computer vision tasks of generating samples of natural images (Denton et al. 2015).
Unfortunately, applying GAN to generating sequences has two problems. Firstly, GAN is designed for generating real-valued, continuous data but has difficulties in directly generating sequences of discrete tokens, such as texts (Huszár 2015). The reason is that in GANs, the generator starts with random sampling first and then a determistic transform, govermented by the model parameters. As such, the gradient of the loss from D w.r.t. the outputs by G is used to guide the generative model G (paramters) to slightly change the generated value to make it more realistic. If the generated data is based on discrete tokens, the "slight change" guidance from the discriminative net makes little sense because there is probably no corresponding token for such slight change in the limited dictionary space (Goodfellow 2016). Secondly, GAN can only give the score/loss for an entire sequence when it has been generated; for a partially generated sequence, it is non-trivial to balance how good as it is now and the future score as the entire sequence.
In this paper, to address the above two issues, we follow (Bachman and Precup 2015;Bahdanau et al. 2016) and consider the sequence generation procedure as a sequential decision making process. The generative model is treated as an agent of reinforcement learning (RL); the state is the generated tokens so far and the action is the next token to be generated. Unlike the work in (Bahdanau et al. 2016) that requires a task-specific sequence score, such as BLEU in machine translation, to give the reward, we employ a discriminator to evaluate the sequence and feedback the evaluation to guide the learning of the generative model. To solve the problem that the gradient cannot pass back to the generative model when the output is discrete, we regard the generative model as a stochastic parametrized policy. In our policy gradient, we employ Monte Carlo (MC) search to approximate the state-action value. We directly train the policy (generative model) via policy gradient (Sutton et al. 1999), which naturally avoids the differentiation difficulty for discrete data in a conventional GAN.
Extensive experiments based on synthetic and real data are conducted to investigate the efficacy and properties of the proposed SeqGAN. In our synthetic data environment, SeqGAN significantly outperforms the maximum likelihood methods, scheduled sampling and PG-BLEU. In three realworld tasks, i.e. poem generation, speech language generation and music generation, SeqGAN significantly outperforms the compared baselines in various metrics including human expert judgement.

Related Work
Deep generative models have recently drawn significant attention, and the ability of learning over large (unlabeled) data endows them with more potential and vitality (Salakhutdinov 2009;. (Hinton, Osindero, and Teh 2006) first proposed to use the contrastive divergence algorithm to efficiently training deep belief nets (DBN).  proposed denoising autoencoder (DAE) that learns the data distribution in a supervised learning fashion. Both DBN and DAE learn a low dimensional representation (encoding) for each data instance and generate it from a decoding network. Recently, variational autoencoder (VAE) that combines deep learning with statistical inference intended to represent a data instance in a latent hidden space (Kingma and Welling 2014), while still utilizing (deep) neural networks for non-linear mapping. The inference is done via variational methods. All these generative models are trained by maximizing (the lower bound of) training data likelihood, which, as mentioned by (Goodfellow and others 2014), suffers from the difficulty of approximating intractable probabilistic computations. (Goodfellow and others 2014) proposed an alternative training methodology to generative models, i.e. GANs, where the training procedure is a minimax game between a generative model and a discriminative model. This framework bypasses the difficulty of maximum likelihood learning and has gained striking successes in natural image generation (Denton et al. 2015). However, little progress has been made in applying GANs to sequence discrete data generation problems, e.g. natural language generation (Huszár 2015). This is due to the generator network in GAN is designed to be able to adjust the output continuously, which does not work on discrete data generation (Goodfellow 2016).
On the other hand, a lot of efforts have been made to generate structured sequences. Recurrent neural networks can be trained to produce sequences of tokens in many applications such as machine translation (Sutskever, Vinyals, and Le 2014;Bahdanau, Cho, and Bengio 2014). The most popular way of training RNNs is to maximize the likelihood of each token in the training data whereas  pointed out that the discrepancy between training and generating makes the maximum likelihood estimation suboptimal and proposed scheduled sampling strategy (SS). Later (Huszár 2015) theorized that the objective function underneath SS is improper and explained the reason why GANs tend to generate natural-looking samples in theory. Consequently, the GANs have great potential but are not practically feasible to discrete probabilistic models currently.
As pointed out by (Bachman and Precup 2015), the sequence data generation can be formulated as a sequential decision making process, which can be potentially be solved by reinforcement learning techniques. Modeling the sequence generator as a policy of picking the next token, policy gradient methods (Sutton et al. 1999) can be adopted to optimize the generator once there is an (implicit) reward function to guide the policy. For most practical sequence generation tasks, e.g. machine translation (Sutskever, Vinyals, and Le 2014), the reward signal is meaningful only for the entire sequence, for instance in the game of Go (Silver et al. 2016), the reward signal is only set at the end of the game. In those cases, state-action evaluation methods such as Monte Carlo (tree) search have been adopted (Browne et al. 2012). By contract, our proposed SeqGAN extends GANs with the RL-based generator to solve the sequence generation problem, where a reward signal is provided by the discriminator at the end of each episode via Monte Carlo approach, and the generator picks the action and learns the policy using estimated overall rewards.

Sequence Generative Adversarial Nets
The sequence generation problem is denoted as follows. Given a dataset of real-world structured sequences, train a θ-parameterized generative model G θ to produce a sequence Y 1:T = (y 1 , . . . , y t , . . . , y T ), y t ∈ Y, where Y is the vocabulary of candidate tokens. We interpret this problem based on reinforcement learning. In timestep t, the state s is the current produced tokens (y 1 , . . . , y t−1 ) and the action a is the next token y t to select. Thus the policy model G θ (y t |Y 1:t−1 ) is stochastic, whereas the state transition is deterministic after an action has been chosen, i.e. δ a s,s = 1 for the next state s = Y 1:t if the current state s = Y 1:t−1 and the action a = y t ; for other next states s , δ a s,s = 0. Additionally, we also train a φ-parameterized discriminative model D φ (Goodfellow and others 2014) to provide a guidance for improving generator G θ . D φ (Y 1:T ) is a probability indicating how likely a sequence Y 1:T is from real sequence data or not. As illustrated in Figure 1, the dis- criminative model D φ is trained by providing positive examples from the real sequence data and negative examples from the synthetic sequences generated from the generative model G θ . At the same time, the generative model G θ is updated by employing a policy gradient and MC search on the basis of the expected end reward received from the discriminative model D φ . The reward is estimated by the likelihood that it would fool the discriminative model D φ . The specific formulation is given in the next subsection.

SeqGAN via Policy Gradient
Following (Sutton et al. 1999), when there is no intermediate reward, the objective of the generator model (policy) G θ (y t |Y 1:t−1 ) is to generate a sequence from the start state s 0 to maximize its expected end reward: where R T is the reward for a complete sequence. Note that the reward is from the discriminator D φ , which we will discuss later. Q G θ D φ (s, a) is the action-value function of a sequence, i.e. the expected accumulative reward starting from state s, taking action a, and then following policy G θ . The rational of the objective function for a sequence is that starting from a given initial state, the goal of the generator is to generate a sequence which would make the discriminator consider it is real.
The next question is how to estimate the action-value function. In this paper, we use the REINFORCE algorithm (Williams 1992) and consider the estimated probability of being real by the discriminator D φ (Y n 1:T ) as the reward. Formally, we have: However, the discriminator only provides a reward value for a finished sequence. Since we actually care about the longterm reward, at every timestep, we should not only consider the fitness of previous tokens (prefix) but also the resulted future outcome. This is similar to playing the games such as Go or Chess where players sometimes would give up the immediate interests for the long-term victory (Silver et al. 2016). Thus, to evaluate the action-value for an intermediate state, we apply Monte Carlo search with a roll-out policy G β to sample the unknown last T − t tokens. We represent an N -time Monte Carlo search as where Y n 1:t = (y 1 , . . . , y t ) and Y n t+1:T is sampled based on the roll-out policy G β and the current state. In our experiment, G β is set the same as the generator, but one can use a simplified version if the speed is the priority (Silver et al. 2016). To reduce the variance and get more accurate assessment of the action value, we run the roll-out policy starting from current state till the end of the sequence for N times to get a batch of output samples. Thus, we have: where, we see that when no intermediate reward, the function is iteratively defined as the next-state value starting from state s = Y 1:t and rolling out to the end. A benefit of using the discriminator D φ as a reward function is that it can be dynamically updated to further improve the generative model iteratively. Once we have a set of more realistic generated sequences, we shall re-train the discriminator model as follows: (5) Each time when a new discriminator model has been obtained, we are ready to update the generator. The proposed policy based method relies upon optimizing a parametrized policy to directly maximize the long-term reward. Following (Sutton et al. 1999), the gradient of the objective function J(θ) w.r.t. the generator's parameters θ can be derived as The above form is due to the deterministic state transition and zero intermediate rewards. The detailed derivation is provided in the appendix. Using likelihood ratios (Glynn 1990;Sutton et al. 1999), we build an unbiased estimation for Eq. (6) (on one episode): where Y 1:t−1 is the observed intermediate state sampled from G θ . Since the expectation E[·] can be approximated by sampling methods, we then update the generator's parameters as: where α h ∈ R + denotes the corresponding learning rate at h-th step. Also the advanced gradient algorithms such as Adam and RMSprop can be adopted here.
In summary, Algorithm 1 shows full details of the proposed SeqGAN. At the beginning of the training, we use the maximum likelihood estimation (MLE) to pre-train G θ on Algorithm 1 Sequence Generative Adversarial Nets Require: generator policy G θ ; roll-out policy G β ; discriminator D φ ; a sequence dataset S = {X1:T } 1: Initialize G θ , D φ with random weights θ, φ. 2: Pre-train G θ using MLE on S 3: β ← θ 4: Generate negative samples using G θ for training D φ 5: Pre-train D φ via minimizing the cross entropy 6: repeat 7: for g-steps do 8: Generate a sequence Y1:T = (y1, . . . , yT ) ∼ G θ 9: for t in 1 : T do 10: Compute Q(a = yt; s = Y1:t−1) by Eq. (4)  training set S. We found the supervised signal from the pretrained discriminator is informative to help adjust the generator efficiently.
After the pre-training, the generator and discriminator are trained alternatively. As the generator gets progressed via training on g-steps updates, the discriminator needs to be retrained periodically to keeps a good pace with the generator. When training the discriminator, positive examples are from the given dataset S, whereas negative examples are generated from our generator. In order to keep the balance, the number of negative examples we generate for each d-step is the same as the positive examples. And to reduce the variability of the estimation, we use different sets of negative samples combined with positive ones, which is similar to bootstrapping (Quinlan 1996).

The Generative Model for Sequences
We use recurrent neural networks (RNNs) (Hochreiter and Schmidhuber 1997) as the generative model. An RNN maps the input embedding representations x 1 , . . . , x T of the sequence x 1 , . . . , x T into a sequence of hidden states h 1 , . . . , h T by using the update function g recursively.
Moreover, a softmax output layer z maps the hidden states into the output token distribution where the parameters are a bias vector c and a weight matrix V . To deal with the common vanishing and exploding gradient problem (Goodfellow, Bengio, and Courville 2016) of the backpropagation through time, we leverage the Long Short-Term Memory (LSTM) cells (Hochreiter and Schmidhuber 1997) to implement the update function g in Eq. (9). It is worth noticing that most of the RNN variants, such as the gated recurrent unit (GRU) ) and soft attention mechanism (Bahdanau, Cho, and Bengio 2014), can be used as a generator in SeqGAN.

The Discriminative Model for Sequences
Deep discriminative models such as deep neural network (DNN) (Veselỳ et al. 2013), convolutional neural network (CNN) (Kim 2014) and recurrent convolutional neural network (RCNN) (Lai et al. 2015) have shown a high performance in complicated sequence classification tasks. In this paper, we choose the CNN as our discriminator as CNN has recently been shown of great effectiveness in text (token sequence) classification (Zhang and LeCun 2015). Most discriminative models can only perform classification well for an entire sequence rather than the unfinished one. In this paper, we also focus on the situation where the discriminator predicts the probability that a finished sequence is real. 1 We first represent an input sequence x 1 , . . . , x T as: where x t ∈ R k is the k-dimensional token embedding and ⊕ is the concatenation operator to build the matrix E 1:T ∈ R T ×k . Then a kernel w ∈ R l×k applies a convolutional operation to a window size of l words to produce a new feature map: where ⊗ operator is the summation of elementwise production, b is a bias term and ρ is a non-linear function. We can use various numbers of kernels with different window sizes to extract different features. Finally we apply a max-over-time pooling operation over the feature maps c = max {c 1 , . . . , c T −l+1 }.
To enhance the performance, we also add the highway architecture (Srivastava, Greff, and Schmidhuber 2015) based on the pooled feature maps. Finally, a fully connected layer with sigmoid activation is used to output the probability that the input sequence is real. The optimization target is to minimize the cross entropy between the ground truth label and the predicted probability as formulated in Eq. (5).
Detailed implementations of the generative and discriminative models are provided in the appendix.

Synthetic Data Experiments
To test the efficacy and add our understanding of SeqGAN, we conduct a simulated test with synthetic data 2 . To simulate the real-world structured sequences, we consider a language model to capture the dependency of the tokens. We use a randomly initialized LSTM as the true model, aka, the oracle, to generate the real data distribution p(x t |x 1 , . . . , x t−1 ) for the following experiments.

Evaluation Metric
The benefit of having such oracle is that firstly, it provides the training dataset and secondly evaluates the exact performance of the generative models, which will not be possible with real data. We know that MLE is trying to minimize the cross-entropy between the true data distribution p and our approximation q, i.e. −E x∼p log q(x). However, the most accurate way of evaluating generative models is that we draw some samples from it and let human observers review them based on their prior knowledge. We assume that the human observer has learned an accurate model of the natural distribution p human (x). Then in order to increase the chance of passing Turing Test, we actually need to minimize the exact opposite average negative log-likelihood −E x∼q log p human (x) (Huszár 2015), with the role of p and q exchanged. In our synthetic data experiments, we can consider the oracle to be the human observer for real-world problems, thus a perfect evaluation metric should be where G θ and G oracle denote our generative model and the oracle respectively. At the test stage, we use G θ to generate 100,000 sequence samples and calculate NLL oracle for each sample by G oracle and their average score. Also significance tests are performed to compare the statistical properties of the generation performance between the baselines and SeqGAN.

Training Setting
To set up the synthetic data experiments, we first initialize the parameters of an LSTM network following the normal distribution N (0, 1) as the oracle describing the real data distribution G oracle (x t |x 1 , . . . , x t−1 ). Then we use it to generate 10,000 sequences of length 20 as the training set S for the generative models.
In SeqGAN algorithm, the training set for the discriminator is comprised by the generated examples with the label 0 and the instances from S with the label 1. For different tasks, one should design specific structure for the convolutional layer and in our synthetic data experiments, the kernel size is from 1 to T and the number of each kernel size is between 100 to 200 3 . Dropout (Srivastava et al. 2014) and L2 regularization are used to avoid over-fitting.
Four generative models are compared with SeqGAN. The first model is a random token generation. The second one is the MLE trained LSTM G θ . The third one is scheduled sampling . The fourth one is the Policy Gradient with BLEU (PG-BLEU). In the scheduled sampling, the training process gradually changes from a fully guided scheme feeding the true previous tokens into LSTM, towards a less guided scheme which mostly feeds the LSTM with its generated tokens. A curriculum rate ω is used to control the probability of replacing the true tokens with the generated ones. To get a good and stable performance, we decrease ω by 0.002 for every training epoch. In the PG-BLEU algorithm, we use BLEU, a metric measuring the similarity between a generated sequence and references (training data), to score the finished samples from Monte Carlo search.

Results
The NLL oracle performance of generating sequences from the compared policies is provided in Table 1. Since the evaluation metric is fundamentally instructive, we can see the impact of SeqGAN, which outperforms other baselines significantly. A significance T-test on the NLL oracle score distribution of the generated sequences from the compared models is also performed, which demonstrates the significant improvement of SeqGAN over all compared models. The learning curves shown in Figure 4 illustrate the superiority of SeqGAN explicitly. After about 150 training epochs, both the maximum likelihood estimation and the schedule sampling methods converge to a relatively high NLL oracle score, whereas SeqGAN can improve the limit of the generator with the same structure as the baselines significantly. This indicates the prospect of applying adversarial training strategies to discrete sequence generative models to breakthrough the limitations of MLE. Additionally, SeqGAN outperforms PG-BLEU, which means the discriminative signal in GAN is more general and effective than a predefined score (e.g. BLEU) to guide the generative policy to capture the underlying distribution of the sequence data.

Discussion
In our synthetic data experiments, we find that the stability of SeqGAN depends on the training strategy. More specifically, the g-steps, d-steps and k parameters in Algorithm 1 have a large effect on the convergence and performance of SeqGAN. Figure 3 shows the effect of these parameters. In Figure 3(a), the g-steps is much larger than the d-steps and epoch number k, which means we train the generator for many times until we update the discriminator. This strategy leads to a fast convergence but as the generator improves quickly, the discriminator cannot get fully trained and thus will provide a misleading signal gradually. In Figure 3(b), with more discriminator training epochs, the unstable training process is alleviated. In Figure 3(c), we train the generator for only one epoch and then before the discriminator gets  are emphasized, which will lead to a more comprehensive guidance for training generator. This is in line with the theorem in (Goodfellow and others 2014). When analyzing the convergence of generative adversarial nets, an important assumption is that the discriminator is allowed to reach its optimum given G. Only if the discriminator is capable of differentiating real data from unnatural data consistently, the supervised signal from it can be meaningful and the whole adversarial training process can be stable and effective.

Real-world Scenarios
To complement the previous experiments, we also test Se-qGAN on several real-world tasks, i.e. poem composition, speech language generation and music generation.

Text Generation
For text generation scenarios, we apply the proposed Seq-GAN to generate Chinese poems and Barack Obama political speeches. In the poem composition task, we use a corpus 4 of 16,394 Chinese quatrains, each containing four lines   of twenty characters in total. To focus on a fully automatic solution and stay general, we did not use any prior knowledge of special structure rules in Chinese poems such as specific phonological rules. In the Obama political speech generation task, we use a corpus 5 , which is a collection of 11,092 paragraphs from Obama's political speeches. We use BLEU score as an evaluation metric to measure the similarity degree between the generated texts and the human-created texts. BLEU is originally designed to automatically judge the machine translation quality (Papineni et al. 2002). The key point is to compare the similarity between the results created by machine and the references provided by human. Specifically, for poem evaluation, we set n-gram to be 2 (BLEU-2) since most words (dependency) in classical Chinese poems consist of one or two characters (Yi, Li, and Sun 2016) and for the similar reason, we use BLEU-3 and BLEU-4 to evaluate Obama speech generation performance. In our work, we use the whole test set as the references instead of trying to find some references for the following line given the previous line (He, Zhou, and Jiang 2012). The reason is in generation tasks we only provide some positive examples and then let the model catch the patterns of them and generate new ones. In addition to BLEU, we also choose poem generation as a case for human judgement since a poem is a creative text construction and human evaluation is ideal. Specifically, we mix the 20 real poems and 20 each generated from SeqGAN and MLE. Then 70 experts on Chinese poems are invited to judge whether each of the 60 poem is created by human or machines. Once regarded to be real, it gets +1 score, otherwise 0. Finally, the average score for each algorithm is calculated.
The experiment results are shown in Tables 2 and 3, from which we can see the significant advantage of SeqGAN over the MLE in text generation. Particularly, for poem composition, SeqGAN performs comparably to real human data.

Music Generation
For music composition, we use Nottingham 6 dataset as our training data, which is a collection of 695 music of folk tunes in midi file format. We study the solo track of each music. In our work, we use 88 numbers to represent 88 pitches, which correspond to the 88 keys on the piano. With the pitch sampling for every 0.4s 7 , we transform the midi files into sequences of numbers from 1 to 88 with the length 32.
To model the fitness of the discrete piano key patterns, BLEU is used as the evaluation metric. To model the fitness of the continuous pitch data patterns, the mean squared error (MSE) (Manaris et al. 2007) is used for evaluation.
From Table 4, we see that SeqGAN outperforms the MLE significantly in both metrics in the music generation task.

Conclusion
In this paper, we proposed a sequence generation method, SeqGAN, to effectively train generative adversarial nets for structured sequences generation via policy gradient. To our best knowledge, this is the first work extending GANs to generate sequences of discrete tokens. In our synthetic data experiments, we used an oracle evaluation mechanism to explicitly illustrate the superiority of SeqGAN over strong baselines. For three real-world scenarios, i.e., poems, speech language and music generation, SeqGAN showed excellent performance on generating the creative sequences. We also performed a set of experiments to investigate the robustness and stability of training SeqGAN. For future work, we plan to build Monte Carlo tree search and value network (Silver et al. 2016) to improve action decision making for large scale data and in the case of longer-term planning.

Proof for Eq. (6)
For readability, we provide the detailed derivation of Eq. (6) here by following (Sutton et al. 1999).
As mentioned in SEQUENCE GENERATIVE ADVERSARIAL NETS section, the state transition is deterministic after an action has been chosen, i.e. δ a s,s = 1 for the next state s = Y 1:t if the current state s = Y 1:t−1 and the action a = y t ; for other next states s , δ a s,s = 0. In addition, the intermediate reward R a s is 0. We re-write the action value and state value as follows: For the start state s 0 , the value is calculated as which is the objective function J(θ) to maximize in Eq.
(1) of the paper. Then we can obtain the gradient of the objective function, defined in Eq. (1), w.r.t. the generator's parameters θ: which is the result in Eq. (6) of the paper.

Model Implementations
In this section, we present a full version of the discussed generative model and discriminative model in our paper submission.
The Generative Model for Sequences We use recurrent neural networks (RNNs) (Hochreiter and Schmidhuber 1997) as the generative model. An RNN maps the input embedding representations x 1 , . . . , x T of the sequence x 1 , . . . , x T into a sequence of hidden states h 1 , . . . , h T by using the update function g recursively.
Moreover, a softmax output layer z maps the hidden states into the output token distribution where the parameters are a bias vector c and a weight matrix V . The vanishing and exploding gradient problem in backpropagation through time (BPTT) issues a challenge of learning longterm dependencies to recurrent neural network (Goodfellow, Bengio, and Courville 2016). To address such problems, gated RNNs have been designed based on the basic idea of creating paths through time that have derivatives that neither vanish nor explode. Among various gated RNNs, we choose the Long Short-Term Memory (LSTM) (Hochreiter and Schmidhuber 1997) to be our generative networks with the update equations: where [h, x] is the vector concatenation and is the elementwise product.
For simplicity, we use the standard LSTM as the generator, while it is worth noticing that most of the RNN variants, such as the gated recurrent unit (GRU) ) and soft attention mechanism (Bahdanau, Cho, and Bengio 2014), can be used as a generator in SeqGAN.
The standard way of training an RNN G θ is the maximum likelihood estimation (MLE), which involves minimizing the negative log-likelihood − T t=1 log G θ (y t = x t | {x 1 , . . . , x t−1 }) for a generated sequence (y 1 , . . . , y T ) given input (x 1 , . . . , x T ). However, when applying MLE to generative models, there is a discrepancy between training and generating Huszár 2015), which motivates our work.
The Discriminative Model for Sequences Deep discriminative models such as deep neural network (DNN) (Veselỳ et al. 2013), convolutional neural network (CNN) (Kim 2014) and recurrent convolutional neural network (RCNN) (Lai et al. 2015) have shown a high performance in complicated sequence classification tasks. In this paper, we choose the CNN as our discriminator as CNN has recently been shown of great effectiveness in text (token sequence) classification (Zhang and LeCun 2015).
As far as we know, except for some specific tasks, most discriminative models can only perform classification well for a whole sequence rather than the unfinished one. In case of some specific tasks, one may design a classifier to provide intermediate reward signal to enhance the performance of our framework. But to make it more general, we focus on the situation where discriminator can only provide final reward, i.e., the probability that a finished sequence was real.
We first represent an input sequence x 1 , . . . , x T as: where x t ∈ R k is the k-dimensional token embedding and ⊕ is the vertical concatenation operator to build the matrix E 1:T ∈ R T ×k . Then a kernel w ∈ R l×k applies a convolutional operation to a window size of l words to produce a new feature map: where ⊗ operator is the summation of elementwise production, b is a bias term and ρ is a non-linear function. We can use various numbers of kernels with different window sizes to extract different features. Specifically, a kernel w with window size l applied to the concatenated embeddings of input sequence will produce a feature map Finally we apply a max-over-time pooling operation over the feature mapc = max {c} and pass all pooled features from different kernels to a fully connected softmax layer to get the probability that a given sequence is real.
We perform an empirical experiment to choose the kernel window sizes and numbers as shown in Table 5. For different tasks, one should design specific structures for the discriminator.

32
(1, 100),(2, 200), (3,200),(4, 200),(5, 200) (6, 100), (7,100),(8, 100),(9, 100),(10, 100) (16, 160),(24, 160), (32,160) where W T , b T and W H are highway layer weights, H denotes an affine transform followed by a non-linear activation function such as a rectified linear unit (ReLU) and τ is the "transform gate" with the same dimensionality as H(c, W H ) andc. Finally, we apply a sigmoid transformation to get the probability that a given sequence is real: where W o and b o is the output layer weight and bias. When optimizing discriminative models, supervised training is applied to minimize the cross entropy, which is widely used as the objective function for classification and prediction tasks: where y is the ground truth label of the input sequence andŷ is the predicted probability from the discriminative models. In the DISCUSSION subsection of SYNTHETIC DATA EXPERIMENTS section of our paper, we discussed the ablation study of three hyperparameters of SeqGAN, i.e., g-steps, d-steps and k epoch number. Here we provide another ablation study which is instructive for the better training of SeqGAN.

More Ablation Study
As described in our paper, we start the adversarial training process after the convergence of MLE supervised pre-training. Here we further conduct experiments to investigate the performance of SeqGAN when the supervised pre-training is insufficient.
As shown in Figure 4, if we pre-train the generative model with conventional MLE methods for only 20 epochs, which is far from convergence, then the adversarial training process improves the generator quite slowly and unstably. The reason is that in SeqGAN, the discriminative model provides reward guidance when training the generator and if the generator acts almost randomly, the discriminator will identify the generated sequence to be unreal with high confidence and almost every action the generator takes receives a low (unified) reward, which does not guide the generator towards a good improvement direction, resulting in an ineffective training procedure. This indicates that in order to apply adversarial training strategies to sequence generative models, a sufficient pre-training is necessary.