diff --git "a/parse/train/r1YqWz-R-/r1YqWz-R-_middle.json" "b/parse/train/r1YqWz-R-/r1YqWz-R-_middle.json" new file mode 100644--- /dev/null +++ "b/parse/train/r1YqWz-R-/r1YqWz-R-_middle.json" @@ -0,0 +1,31804 @@ +{ + "pdf_info": [ + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 78, + 504, + 135 + ], + "lines": [ + { + "bbox": [ + 105, + 78, + 505, + 98 + ], + "spans": [ + { + "bbox": [ + 105, + 78, + 505, + 98 + ], + "score": 1.0, + "content": "IMPROVING CONDITIONAL SEQUENCE GENERATIVE", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 99, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 99, + 505, + 117 + ], + "score": 1.0, + "content": "ADVERSARIAL NETWORKS BY STEPWISE EVALUA-", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 120, + 146, + 137 + ], + "spans": [ + { + "bbox": [ + 106, + 120, + 146, + 137 + ], + "score": 1.0, + "content": "TION", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 112, + 155, + 244, + 177 + ], + "lines": [ + { + "bbox": [ + 113, + 156, + 201, + 167 + ], + "spans": [ + { + "bbox": [ + 113, + 156, + 201, + 167 + ], + "score": 1.0, + "content": "Anonymous authors", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 112, + 166, + 245, + 178 + ], + "spans": [ + { + "bbox": [ + 112, + 166, + 245, + 178 + ], + "score": 1.0, + "content": "Paper under double-blind review", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + }, + { + "type": "title", + "bbox": [ + 278, + 207, + 333, + 218 + ], + "lines": [ + { + "bbox": [ + 276, + 206, + 335, + 219 + ], + "spans": [ + { + "bbox": [ + 276, + 206, + 335, + 219 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 143, + 230, + 468, + 362 + ], + "lines": [ + { + "bbox": [ + 142, + 230, + 470, + 243 + ], + "spans": [ + { + "bbox": [ + 142, + 230, + 470, + 243 + ], + "score": 1.0, + "content": "Conditional sequence generation is a widely researched topic. One of the most", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 241, + 470, + 255 + ], + "spans": [ + { + "bbox": [ + 141, + 241, + 470, + 255 + ], + "score": 1.0, + "content": "important tasks is dialogue generation, which is composed of input-output pairs", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 252, + 470, + 266 + ], + "spans": [ + { + "bbox": [ + 141, + 252, + 470, + 266 + ], + "score": 1.0, + "content": "with the one-to-many property. Given the recent success of generative adversarial", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 263, + 469, + 276 + ], + "spans": [ + { + "bbox": [ + 141, + 263, + 469, + 276 + ], + "score": 1.0, + "content": "networks (GANs), GANs have been used for sequence generation. However, there", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 141, + 274, + 470, + 288 + ], + "spans": [ + { + "bbox": [ + 141, + 274, + 470, + 288 + ], + "score": 1.0, + "content": "is still limited work of its application on conditional sequence generation. We in-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 285, + 470, + 298 + ], + "spans": [ + { + "bbox": [ + 141, + 285, + 470, + 298 + ], + "score": 1.0, + "content": "vestigate the influence of GAN on conditional sequence generation with three ar-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 296, + 470, + 309 + ], + "spans": [ + { + "bbox": [ + 141, + 296, + 470, + 309 + ], + "score": 1.0, + "content": "tificial grammars and dialogue generation. Moreover, we propose stepwise GAN", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 307, + 470, + 320 + ], + "spans": [ + { + "bbox": [ + 141, + 307, + 470, + 320 + ], + "score": 1.0, + "content": "(StepGAN) for conditional sequence generation, which predicts the reward at each", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 318, + 470, + 331 + ], + "spans": [ + { + "bbox": [ + 141, + 318, + 470, + 331 + ], + "score": 1.0, + "content": "time-step. StepGAN can be seen as the general version of SeqGAN. It estimates", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 329, + 470, + 342 + ], + "spans": [ + { + "bbox": [ + 141, + 329, + 470, + 342 + ], + "score": 1.0, + "content": "the expected returns predicted by Monte-Carlo Search in SeqGAN, but it has a", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 340, + 469, + 353 + ], + "spans": [ + { + "bbox": [ + 141, + 340, + 469, + 353 + ], + "score": 1.0, + "content": "lower computational cost than Monte-Carlo Search. Experimental results show", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 351, + 469, + 364 + ], + "spans": [ + { + "bbox": [ + 141, + 351, + 469, + 364 + ], + "score": 1.0, + "content": "that stepwise GAN can outperform other state-of-the-art algorithms in most tasks.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 11.5 + }, + { + "type": "title", + "bbox": [ + 108, + 382, + 206, + 394 + ], + "lines": [ + { + "bbox": [ + 105, + 381, + 208, + 398 + ], + "spans": [ + { + "bbox": [ + 105, + 381, + 208, + 398 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 107, + 406, + 505, + 506 + ], + "lines": [ + { + "bbox": [ + 106, + 407, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 106, + 407, + 505, + 420 + ], + "score": 1.0, + "content": "Conditional sequence generation is the task of generating the correspondent response given an in-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 104, + 417, + 506, + 431 + ], + "spans": [ + { + "bbox": [ + 104, + 417, + 506, + 431 + ], + "score": 1.0, + "content": "put sequence. One of the most important applications is dialogue generation. Dialogue generation", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 428, + 506, + 443 + ], + "spans": [ + { + "bbox": [ + 105, + 428, + 506, + 443 + ], + "score": 1.0, + "content": "is one-to-many; that is, there can be many acceptable responses for a specific input. In previous", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 439, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 439, + 505, + 453 + ], + "score": 1.0, + "content": "work, the sequence-to-sequence based dialogue generation model is trained using maximum likeli-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 450, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 505, + 464 + ], + "score": 1.0, + "content": "hood estimation, and achieves promising results in terms of both meaning and coherence (Vinyals", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 461, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 461, + 505, + 475 + ], + "score": 1.0, + "content": "& Le, 2015). Despite this success, the generated responses given the inputs are still sometimes", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 473, + 505, + 485 + ], + "spans": [ + { + "bbox": [ + 106, + 473, + 505, + 485 + ], + "score": 1.0, + "content": "broken and are often general (for example, I don’t know). Reinforcement learning was therefore", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 483, + 505, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 505, + 497 + ], + "score": 1.0, + "content": "proposed to preserve sequence-level quality as opposed to predicting each word given the sequence", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 494, + 418, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 418, + 507 + ], + "score": 1.0, + "content": "history (Ranzato et al., 2015; Kandasamy et al., 2017; Bahdanau et al., 2016).", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 107, + 511, + 505, + 621 + ], + "lines": [ + { + "bbox": [ + 105, + 510, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 505, + 524 + ], + "score": 1.0, + "content": "More recently, generative adversarial networks have been applied to sequence generation, especially", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 522, + 505, + 534 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 505, + 534 + ], + "score": 1.0, + "content": "for natural language. The discrete nature of random variables for natural language precludes the use", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 533, + 505, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 505, + 546 + ], + "score": 1.0, + "content": "of back-propagation. To solve this problem, several approaches have been proposed, such as policy", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 544, + 506, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 544, + 506, + 558 + ], + "score": 1.0, + "content": "gradient (Yu et al., 2017; Li et al., 2017), Gumbel-Softmax (Kusner & Hernandez-Lobato, 2016), ´", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 554, + 506, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 506, + 568 + ], + "score": 1.0, + "content": "MaliGAN (Che et al., 2017), and directly connected WGAN-GP (Gulrajani et al., 2017; Rajeswar", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 566, + 506, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 506, + 578 + ], + "score": 1.0, + "content": "et al., 2017; Press et al., 2017). In most previous work, multiple assistant methods are used to", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 577, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 505, + 590 + ], + "score": 1.0, + "content": "stabilize training and often introduce improvements, for example, Monte-Carlo search (Yu et al.,", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 588, + 506, + 600 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 506, + 600 + ], + "score": 1.0, + "content": "2017; Li et al., 2017; Che et al., 2017) and curriculum learning (Rajeswar et al., 2017; Press et al.,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 598, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 505, + 612 + ], + "score": 1.0, + "content": "2017). Furthermore, modifications of the GAN objective function have been proposed to improve", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 610, + 358, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 358, + 622 + ], + "score": 1.0, + "content": "quality in text generation (Zhang et al., 2017; Lin et al., 2017).", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 107, + 627, + 505, + 693 + ], + "lines": [ + { + "bbox": [ + 106, + 626, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 106, + 626, + 505, + 639 + ], + "score": 1.0, + "content": "SeqGAN has been successfully applied on dialogue generation (Li et al., 2017). Due to the high", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 638, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 638, + 505, + 650 + ], + "score": 1.0, + "content": "variance of SeqGAN with 1-sample estimate REINFORCE algorithm, researchers use Marte-Carlo", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 649, + 505, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 505, + 662 + ], + "score": 1.0, + "content": "search for variation reduction. This method costs extremely high computational resources, therefore", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 659, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 505, + 672 + ], + "score": 1.0, + "content": "Reward for Every Generation Step (REGS) is proposed to replace Monte-Carlo search (Li et al.,", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 671, + 505, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 505, + 683 + ], + "score": 1.0, + "content": "2017). Nonetheless, REGS results in a less accurate discriminator because it takes non-terminal", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 682, + 226, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 682, + 226, + 694 + ], + "score": 1.0, + "content": "sequences into consideration.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 40.5 + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 697, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 697, + 505, + 712 + ], + "score": 1.0, + "content": "To address the weaknesses of Monte-Carlo Search and REGS, we propose stepwise GAN (Step-", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "GAN). In this approach, the discriminator evaluates the generated sequences at every generation", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 720, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 506, + 733 + ], + "score": 1.0, + "content": "step, and gives a score for every step. A final score for the whole sequence is the summation of the", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 45 + } + ], + "page_idx": 0, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 303, + 751, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 308, + 761 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 308, + 761 + ], + "score": 1.0, + "content": "1", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 78, + 504, + 135 + ], + "lines": [ + { + "bbox": [ + 105, + 78, + 505, + 98 + ], + "spans": [ + { + "bbox": [ + 105, + 78, + 505, + 98 + ], + "score": 1.0, + "content": "IMPROVING CONDITIONAL SEQUENCE GENERATIVE", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 99, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 99, + 505, + 117 + ], + "score": 1.0, + "content": "ADVERSARIAL NETWORKS BY STEPWISE EVALUA-", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 120, + 146, + 137 + ], + "spans": [ + { + "bbox": [ + 106, + 120, + 146, + 137 + ], + "score": 1.0, + "content": "TION", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 112, + 155, + 244, + 177 + ], + "lines": [ + { + "bbox": [ + 113, + 156, + 201, + 167 + ], + "spans": [ + { + "bbox": [ + 113, + 156, + 201, + 167 + ], + "score": 1.0, + "content": "Anonymous authors", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 112, + 166, + 245, + 178 + ], + "spans": [ + { + "bbox": [ + 112, + 166, + 245, + 178 + ], + "score": 1.0, + "content": "Paper under double-blind review", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5, + "bbox_fs": [ + 112, + 156, + 245, + 178 + ] + }, + { + "type": "title", + "bbox": [ + 278, + 207, + 333, + 218 + ], + "lines": [ + { + "bbox": [ + 276, + 206, + 335, + 219 + ], + "spans": [ + { + "bbox": [ + 276, + 206, + 335, + 219 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 143, + 230, + 468, + 362 + ], + "lines": [ + { + "bbox": [ + 142, + 230, + 470, + 243 + ], + "spans": [ + { + "bbox": [ + 142, + 230, + 470, + 243 + ], + "score": 1.0, + "content": "Conditional sequence generation is a widely researched topic. One of the most", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 241, + 470, + 255 + ], + "spans": [ + { + "bbox": [ + 141, + 241, + 470, + 255 + ], + "score": 1.0, + "content": "important tasks is dialogue generation, which is composed of input-output pairs", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 252, + 470, + 266 + ], + "spans": [ + { + "bbox": [ + 141, + 252, + 470, + 266 + ], + "score": 1.0, + "content": "with the one-to-many property. Given the recent success of generative adversarial", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 263, + 469, + 276 + ], + "spans": [ + { + "bbox": [ + 141, + 263, + 469, + 276 + ], + "score": 1.0, + "content": "networks (GANs), GANs have been used for sequence generation. However, there", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 141, + 274, + 470, + 288 + ], + "spans": [ + { + "bbox": [ + 141, + 274, + 470, + 288 + ], + "score": 1.0, + "content": "is still limited work of its application on conditional sequence generation. We in-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 285, + 470, + 298 + ], + "spans": [ + { + "bbox": [ + 141, + 285, + 470, + 298 + ], + "score": 1.0, + "content": "vestigate the influence of GAN on conditional sequence generation with three ar-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 296, + 470, + 309 + ], + "spans": [ + { + "bbox": [ + 141, + 296, + 470, + 309 + ], + "score": 1.0, + "content": "tificial grammars and dialogue generation. Moreover, we propose stepwise GAN", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 307, + 470, + 320 + ], + "spans": [ + { + "bbox": [ + 141, + 307, + 470, + 320 + ], + "score": 1.0, + "content": "(StepGAN) for conditional sequence generation, which predicts the reward at each", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 318, + 470, + 331 + ], + "spans": [ + { + "bbox": [ + 141, + 318, + 470, + 331 + ], + "score": 1.0, + "content": "time-step. StepGAN can be seen as the general version of SeqGAN. It estimates", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 329, + 470, + 342 + ], + "spans": [ + { + "bbox": [ + 141, + 329, + 470, + 342 + ], + "score": 1.0, + "content": "the expected returns predicted by Monte-Carlo Search in SeqGAN, but it has a", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 340, + 469, + 353 + ], + "spans": [ + { + "bbox": [ + 141, + 340, + 469, + 353 + ], + "score": 1.0, + "content": "lower computational cost than Monte-Carlo Search. Experimental results show", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 351, + 469, + 364 + ], + "spans": [ + { + "bbox": [ + 141, + 351, + 469, + 364 + ], + "score": 1.0, + "content": "that stepwise GAN can outperform other state-of-the-art algorithms in most tasks.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 11.5, + "bbox_fs": [ + 141, + 230, + 470, + 364 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 382, + 206, + 394 + ], + "lines": [ + { + "bbox": [ + 105, + 381, + 208, + 398 + ], + "spans": [ + { + "bbox": [ + 105, + 381, + 208, + 398 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 107, + 406, + 505, + 506 + ], + "lines": [ + { + "bbox": [ + 106, + 407, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 106, + 407, + 505, + 420 + ], + "score": 1.0, + "content": "Conditional sequence generation is the task of generating the correspondent response given an in-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 104, + 417, + 506, + 431 + ], + "spans": [ + { + "bbox": [ + 104, + 417, + 506, + 431 + ], + "score": 1.0, + "content": "put sequence. One of the most important applications is dialogue generation. Dialogue generation", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 428, + 506, + 443 + ], + "spans": [ + { + "bbox": [ + 105, + 428, + 506, + 443 + ], + "score": 1.0, + "content": "is one-to-many; that is, there can be many acceptable responses for a specific input. In previous", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 439, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 439, + 505, + 453 + ], + "score": 1.0, + "content": "work, the sequence-to-sequence based dialogue generation model is trained using maximum likeli-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 450, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 505, + 464 + ], + "score": 1.0, + "content": "hood estimation, and achieves promising results in terms of both meaning and coherence (Vinyals", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 461, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 461, + 505, + 475 + ], + "score": 1.0, + "content": "& Le, 2015). Despite this success, the generated responses given the inputs are still sometimes", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 473, + 505, + 485 + ], + "spans": [ + { + "bbox": [ + 106, + 473, + 505, + 485 + ], + "score": 1.0, + "content": "broken and are often general (for example, I don’t know). Reinforcement learning was therefore", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 483, + 505, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 505, + 497 + ], + "score": 1.0, + "content": "proposed to preserve sequence-level quality as opposed to predicting each word given the sequence", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 494, + 418, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 418, + 507 + ], + "score": 1.0, + "content": "history (Ranzato et al., 2015; Kandasamy et al., 2017; Bahdanau et al., 2016).", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 23, + "bbox_fs": [ + 104, + 407, + 506, + 507 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 511, + 505, + 621 + ], + "lines": [ + { + "bbox": [ + 105, + 510, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 505, + 524 + ], + "score": 1.0, + "content": "More recently, generative adversarial networks have been applied to sequence generation, especially", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 522, + 505, + 534 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 505, + 534 + ], + "score": 1.0, + "content": "for natural language. The discrete nature of random variables for natural language precludes the use", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 533, + 505, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 505, + 546 + ], + "score": 1.0, + "content": "of back-propagation. To solve this problem, several approaches have been proposed, such as policy", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 544, + 506, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 544, + 506, + 558 + ], + "score": 1.0, + "content": "gradient (Yu et al., 2017; Li et al., 2017), Gumbel-Softmax (Kusner & Hernandez-Lobato, 2016), ´", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 554, + 506, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 506, + 568 + ], + "score": 1.0, + "content": "MaliGAN (Che et al., 2017), and directly connected WGAN-GP (Gulrajani et al., 2017; Rajeswar", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 566, + 506, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 506, + 578 + ], + "score": 1.0, + "content": "et al., 2017; Press et al., 2017). In most previous work, multiple assistant methods are used to", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 577, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 505, + 590 + ], + "score": 1.0, + "content": "stabilize training and often introduce improvements, for example, Monte-Carlo search (Yu et al.,", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 588, + 506, + 600 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 506, + 600 + ], + "score": 1.0, + "content": "2017; Li et al., 2017; Che et al., 2017) and curriculum learning (Rajeswar et al., 2017; Press et al.,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 598, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 505, + 612 + ], + "score": 1.0, + "content": "2017). Furthermore, modifications of the GAN objective function have been proposed to improve", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 610, + 358, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 358, + 622 + ], + "score": 1.0, + "content": "quality in text generation (Zhang et al., 2017; Lin et al., 2017).", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 32.5, + "bbox_fs": [ + 105, + 510, + 506, + 622 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 627, + 505, + 693 + ], + "lines": [ + { + "bbox": [ + 106, + 626, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 106, + 626, + 505, + 639 + ], + "score": 1.0, + "content": "SeqGAN has been successfully applied on dialogue generation (Li et al., 2017). Due to the high", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 638, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 638, + 505, + 650 + ], + "score": 1.0, + "content": "variance of SeqGAN with 1-sample estimate REINFORCE algorithm, researchers use Marte-Carlo", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 649, + 505, + 662 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 505, + 662 + ], + "score": 1.0, + "content": "search for variation reduction. This method costs extremely high computational resources, therefore", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 659, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 505, + 672 + ], + "score": 1.0, + "content": "Reward for Every Generation Step (REGS) is proposed to replace Monte-Carlo search (Li et al.,", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 671, + 505, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 505, + 683 + ], + "score": 1.0, + "content": "2017). Nonetheless, REGS results in a less accurate discriminator because it takes non-terminal", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 682, + 226, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 682, + 226, + 694 + ], + "score": 1.0, + "content": "sequences into consideration.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 40.5, + "bbox_fs": [ + 105, + 626, + 505, + 694 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 697, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 697, + 505, + 712 + ], + "score": 1.0, + "content": "To address the weaknesses of Monte-Carlo Search and REGS, we propose stepwise GAN (Step-", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "GAN). In this approach, the discriminator evaluates the generated sequences at every generation", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 720, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 506, + 733 + ], + "score": 1.0, + "content": "step, and gives a score for every step. A final score for the whole sequence is the summation of the", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 82, + 506, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 506, + 95 + ], + "score": 1.0, + "content": "scores for every time step. This training scheme makes StepGAN a general version of SeqGAN,", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 95, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 95, + 505, + 106 + ], + "score": 1.0, + "content": "and can simulate the process of Monte-Carlo search with low extra computational cost. In the pro-", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 105, + 506, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 506, + 117 + ], + "score": 1.0, + "content": "posed approach, both generator and discriminator include weighted factors that change the relative", + "type": "text", + "cross_page": true + } + ], + "index": 2 + }, + { + "bbox": [ + 104, + 113, + 506, + 130 + ], + "spans": [ + { + "bbox": [ + 104, + 113, + 506, + 130 + ], + "score": 1.0, + "content": "importance of each time step. We find step-time-decreasing weight factors can facilitate the training.", + "type": "text", + "cross_page": true + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 125, + 506, + 140 + ], + "spans": [ + { + "bbox": [ + 105, + 125, + 506, + 140 + ], + "score": 1.0, + "content": "This is because the set of hyper-parameters simulate curriculum learning by focusing on generating", + "type": "text", + "cross_page": true + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 137, + 506, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 506, + 150 + ], + "score": 1.0, + "content": "the head of a sequence. After the first subsequence is fit, further improvement are found in later", + "type": "text", + "cross_page": true + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 149, + 166, + 162 + ], + "spans": [ + { + "bbox": [ + 105, + 149, + 166, + 162 + ], + "score": 1.0, + "content": "subsequences.", + "type": "text", + "cross_page": true + } + ], + "index": 6 + } + ], + "index": 45, + "bbox_fs": [ + 105, + 697, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 504, + 159 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 506, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 506, + 95 + ], + "score": 1.0, + "content": "scores for every time step. This training scheme makes StepGAN a general version of SeqGAN,", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 95, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 95, + 505, + 106 + ], + "score": 1.0, + "content": "and can simulate the process of Monte-Carlo search with low extra computational cost. In the pro-", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 105, + 506, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 506, + 117 + ], + "score": 1.0, + "content": "posed approach, both generator and discriminator include weighted factors that change the relative", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 104, + 113, + 506, + 130 + ], + "spans": [ + { + "bbox": [ + 104, + 113, + 506, + 130 + ], + "score": 1.0, + "content": "importance of each time step. We find step-time-decreasing weight factors can facilitate the training.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 125, + 506, + 140 + ], + "spans": [ + { + "bbox": [ + 105, + 125, + 506, + 140 + ], + "score": 1.0, + "content": "This is because the set of hyper-parameters simulate curriculum learning by focusing on generating", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 137, + 506, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 506, + 150 + ], + "score": 1.0, + "content": "the head of a sequence. After the first subsequence is fit, further improvement are found in later", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 149, + 166, + 162 + ], + "spans": [ + { + "bbox": [ + 105, + 149, + 166, + 162 + ], + "score": 1.0, + "content": "subsequences.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 107, + 165, + 505, + 253 + ], + "lines": [ + { + "bbox": [ + 105, + 164, + 505, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 164, + 505, + 178 + ], + "score": 1.0, + "content": "We construct artificial grammars to assist our realization of GANs in conditional sequence gen-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 176, + 505, + 188 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 505, + 188 + ], + "score": 1.0, + "content": "eration. In these tasks, we calculate the accuracy and the coverage of the generated conditioned", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 188, + 505, + 199 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 505, + 199 + ], + "score": 1.0, + "content": "sequence to evaluate the quality of the model. The coverage is the percentage of the conditioned", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 198, + 505, + 212 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 505, + 212 + ], + "score": 1.0, + "content": "sequences sampled from the model distribution over all the probable responses. While accuracy", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 209, + 505, + 222 + ], + "spans": [ + { + "bbox": [ + 105, + 209, + 505, + 222 + ], + "score": 1.0, + "content": "reflects coherence and meaningfulness, coverage measures the diversity of the responses. We fur-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 219, + 506, + 233 + ], + "spans": [ + { + "bbox": [ + 105, + 219, + 506, + 233 + ], + "score": 1.0, + "content": "ther compare the proposed approach with several conditional sequence generation approaches on", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 231, + 506, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 231, + 506, + 244 + ], + "score": 1.0, + "content": "dialogue generation, and evaluate the results by humans. The proposed models are comparable with", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 243, + 294, + 254 + ], + "spans": [ + { + "bbox": [ + 105, + 243, + 294, + 254 + ], + "score": 1.0, + "content": "or even outperform state-of-the-art algorithms.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 10.5 + }, + { + "type": "title", + "bbox": [ + 108, + 271, + 211, + 284 + ], + "lines": [ + { + "bbox": [ + 105, + 270, + 213, + 286 + ], + "spans": [ + { + "bbox": [ + 105, + 270, + 213, + 286 + ], + "score": 1.0, + "content": "2 RELATED WORK", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 107, + 297, + 505, + 385 + ], + "lines": [ + { + "bbox": [ + 105, + 297, + 506, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 297, + 506, + 310 + ], + "score": 1.0, + "content": "Conditional sequence generation using the seq2seq model (Sutskever et al., 2014; Vinyals & Le,", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 307, + 505, + 321 + ], + "spans": [ + { + "bbox": [ + 105, + 307, + 505, + 321 + ], + "score": 1.0, + "content": "2015) has been widely studied, and also for dialogue generation. The model can be learned by", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 319, + 505, + 332 + ], + "spans": [ + { + "bbox": [ + 105, + 319, + 505, + 332 + ], + "score": 1.0, + "content": "maximum-likelihood estimation (MLE), which minimizes the word-level cross-entropy between the", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 330, + 505, + 343 + ], + "spans": [ + { + "bbox": [ + 105, + 330, + 505, + 343 + ], + "score": 1.0, + "content": "true data distribution and the generated approximation. Although this method yields reasonable re-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 341, + 505, + 354 + ], + "spans": [ + { + "bbox": [ + 105, + 341, + 505, + 354 + ], + "score": 1.0, + "content": "sponses, it suffers from exposure bias and does not take into account sequence-level structure (Ran-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 351, + 505, + 365 + ], + "spans": [ + { + "bbox": [ + 105, + 351, + 505, + 365 + ], + "score": 1.0, + "content": "zato et al., 2015). Exposure bias is introduced because of inconsistent conditions between the train-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 363, + 505, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 505, + 376 + ], + "score": 1.0, + "content": "ing and testing stages: while the ground-truth words are fed to the seq2seq model in the training", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 375, + 314, + 387 + ], + "spans": [ + { + "bbox": [ + 105, + 375, + 314, + 387 + ], + "score": 1.0, + "content": "stage, generated words are used in the testing stage.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 19.5 + }, + { + "type": "text", + "bbox": [ + 107, + 390, + 505, + 544 + ], + "lines": [ + { + "bbox": [ + 106, + 390, + 505, + 403 + ], + "spans": [ + { + "bbox": [ + 106, + 390, + 505, + 403 + ], + "score": 1.0, + "content": "To solve these problems with MLE, besides beam search and scheduled sampling (Bengio et al.,", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 400, + 505, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 400, + 505, + 416 + ], + "score": 1.0, + "content": "2015), (Ranzato et al., 2015) propose the REINFORCE and MIXER algorithms for sequence gen-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 412, + 504, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 504, + 425 + ], + "score": 1.0, + "content": "eration. By providing a task-specific score for the generated sequence, the REINFORCE algo-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 423, + 506, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 506, + 436 + ], + "score": 1.0, + "content": "rithm (Williams, 1992) guides the seq2seq model to reach higher scores. Because the score is", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 434, + 506, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 434, + 506, + 447 + ], + "score": 1.0, + "content": "evaluated based on the whole generated sequence, both MLE problems are solved. However, as", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 446, + 506, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 446, + 506, + 459 + ], + "score": 1.0, + "content": "the REINFORCE algorithm cannot easily train the model from scratch, the MIXER algorithm is", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 456, + 506, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 506, + 470 + ], + "score": 1.0, + "content": "proposed to integrate MLE and REINFORCE. In this process, they first train the whole sequence", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 468, + 505, + 480 + ], + "spans": [ + { + "bbox": [ + 106, + 468, + 505, + 480 + ], + "score": 1.0, + "content": "using MLE, after which they accumulate the number of last words trained by REINFORCE. For fur-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 478, + 505, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 478, + 505, + 492 + ], + "score": 1.0, + "content": "ther improvements, (Bahdanau et al., 2016) adopt another reinforcement learning (Sutton & Barto,", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 489, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 106, + 489, + 505, + 502 + ], + "score": 1.0, + "content": "1998) based approach – the actor-critic architecture. They train a critic to predict the expected value", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 500, + 505, + 513 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 505, + 513 + ], + "score": 1.0, + "content": "of each time step to guide the actor. These algorithms outperform the original MLE algorithm on", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 511, + 504, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 504, + 523 + ], + "score": 1.0, + "content": "the task-specific score (BLEU) for text generation. Nonetheless, there is no evidence that these task-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 523, + 505, + 535 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 505, + 535 + ], + "score": 1.0, + "content": "specific scores are correlated with human prior knowledge. In particular, the relationship between", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 533, + 497, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 497, + 546 + ], + "score": 1.0, + "content": "the scores and human evaluation has been proven weak for dialogue generation (Liu et al., 2016).", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 30.5 + }, + { + "type": "text", + "bbox": [ + 107, + 550, + 505, + 704 + ], + "lines": [ + { + "bbox": [ + 105, + 549, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 549, + 505, + 563 + ], + "score": 1.0, + "content": "Recently, the significant success of generative adversarial networks (GAN) for image processing has", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 561, + 505, + 573 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 505, + 573 + ], + "score": 1.0, + "content": "led researchers to use GANs for natural language. However, this has seen limited success because", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 571, + 504, + 584 + ], + "spans": [ + { + "bbox": [ + 105, + 571, + 504, + 584 + ], + "score": 1.0, + "content": "of the difficulty of backpropagation through discrete random variables. To address this problem, (Yu", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 583, + 505, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 583, + 505, + 596 + ], + "score": 1.0, + "content": "et al., 2017) use policy gradients on text generation. The reward is provided by a discriminator with", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 593, + 505, + 607 + ], + "spans": [ + { + "bbox": [ + 105, + 593, + 505, + 607 + ], + "score": 1.0, + "content": "Monte-Carlo search. In addition, (Li et al., 2017) adopt the same idea for dialogue generation. They", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 605, + 506, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 506, + 618 + ], + "score": 1.0, + "content": "also propose Reward for Every Generation Step (REGS), which is more time-efficient but is weaker", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 615, + 505, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 505, + 630 + ], + "score": 1.0, + "content": "than Monte-Carlo search. Another way to use GAN for natural-language tasks is by using Gumbel-", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 626, + 505, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 505, + 640 + ], + "score": 1.0, + "content": "Softmax (Kusner & Hernandez-Lobato, 2016), which can simulate the discrete argmax outputs, ´", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 638, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 505, + 650 + ], + "score": 1.0, + "content": "and be directly backpropagated from the discriminator. Also, MaliGAN (Che et al., 2017) directly", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 649, + 504, + 660 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 504, + 660 + ], + "score": 1.0, + "content": "derives the gradient estimator for discrete data. More recently, the improved Wasserstein GAN", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "(WGAN-GP) (Gulrajani et al., 2017) has shown success for text generation by directly feeding the", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 670, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 670, + 505, + 684 + ], + "score": 1.0, + "content": "softmax layer to the discriminator, even without pre-training. This breakthrough then inspired (Press", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 681, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 505, + 694 + ], + "score": 1.0, + "content": "et al., 2017) and (Rajeswar et al., 2017) to further investigate WGAN-GP for better performance on", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 693, + 170, + 705 + ], + "spans": [ + { + "bbox": [ + 105, + 693, + 170, + 705 + ], + "score": 1.0, + "content": "text generation.", + "type": "text" + } + ], + "index": 51 + } + ], + "index": 44.5 + }, + { + "type": "text", + "bbox": [ + 107, + 709, + 503, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 708, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 708, + 505, + 722 + ], + "score": 1.0, + "content": "We focus on the influence of different objective function in GANs on conditional sequence genera-", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 106, + 721, + 505, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 505, + 732 + ], + "score": 1.0, + "content": "tion throughout this paper. We compare the state-of-the-art algorithms without additional assistance", + "type": "text" + } + ], + "index": 53 + } + ], + "index": 52.5 + } + ], + "page_idx": 1, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 763 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 763 + ], + "score": 1.0, + "content": "2", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 504, + 159 + ], + "lines": [], + "index": 3, + "bbox_fs": [ + 104, + 82, + 506, + 162 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 165, + 505, + 253 + ], + "lines": [ + { + "bbox": [ + 105, + 164, + 505, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 164, + 505, + 178 + ], + "score": 1.0, + "content": "We construct artificial grammars to assist our realization of GANs in conditional sequence gen-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 176, + 505, + 188 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 505, + 188 + ], + "score": 1.0, + "content": "eration. In these tasks, we calculate the accuracy and the coverage of the generated conditioned", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 188, + 505, + 199 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 505, + 199 + ], + "score": 1.0, + "content": "sequence to evaluate the quality of the model. The coverage is the percentage of the conditioned", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 198, + 505, + 212 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 505, + 212 + ], + "score": 1.0, + "content": "sequences sampled from the model distribution over all the probable responses. While accuracy", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 209, + 505, + 222 + ], + "spans": [ + { + "bbox": [ + 105, + 209, + 505, + 222 + ], + "score": 1.0, + "content": "reflects coherence and meaningfulness, coverage measures the diversity of the responses. We fur-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 219, + 506, + 233 + ], + "spans": [ + { + "bbox": [ + 105, + 219, + 506, + 233 + ], + "score": 1.0, + "content": "ther compare the proposed approach with several conditional sequence generation approaches on", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 231, + 506, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 231, + 506, + 244 + ], + "score": 1.0, + "content": "dialogue generation, and evaluate the results by humans. The proposed models are comparable with", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 243, + 294, + 254 + ], + "spans": [ + { + "bbox": [ + 105, + 243, + 294, + 254 + ], + "score": 1.0, + "content": "or even outperform state-of-the-art algorithms.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 10.5, + "bbox_fs": [ + 105, + 164, + 506, + 254 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 271, + 211, + 284 + ], + "lines": [ + { + "bbox": [ + 105, + 270, + 213, + 286 + ], + "spans": [ + { + "bbox": [ + 105, + 270, + 213, + 286 + ], + "score": 1.0, + "content": "2 RELATED WORK", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 107, + 297, + 505, + 385 + ], + "lines": [ + { + "bbox": [ + 105, + 297, + 506, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 297, + 506, + 310 + ], + "score": 1.0, + "content": "Conditional sequence generation using the seq2seq model (Sutskever et al., 2014; Vinyals & Le,", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 307, + 505, + 321 + ], + "spans": [ + { + "bbox": [ + 105, + 307, + 505, + 321 + ], + "score": 1.0, + "content": "2015) has been widely studied, and also for dialogue generation. The model can be learned by", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 319, + 505, + 332 + ], + "spans": [ + { + "bbox": [ + 105, + 319, + 505, + 332 + ], + "score": 1.0, + "content": "maximum-likelihood estimation (MLE), which minimizes the word-level cross-entropy between the", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 330, + 505, + 343 + ], + "spans": [ + { + "bbox": [ + 105, + 330, + 505, + 343 + ], + "score": 1.0, + "content": "true data distribution and the generated approximation. Although this method yields reasonable re-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 341, + 505, + 354 + ], + "spans": [ + { + "bbox": [ + 105, + 341, + 505, + 354 + ], + "score": 1.0, + "content": "sponses, it suffers from exposure bias and does not take into account sequence-level structure (Ran-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 351, + 505, + 365 + ], + "spans": [ + { + "bbox": [ + 105, + 351, + 505, + 365 + ], + "score": 1.0, + "content": "zato et al., 2015). Exposure bias is introduced because of inconsistent conditions between the train-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 363, + 505, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 505, + 376 + ], + "score": 1.0, + "content": "ing and testing stages: while the ground-truth words are fed to the seq2seq model in the training", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 375, + 314, + 387 + ], + "spans": [ + { + "bbox": [ + 105, + 375, + 314, + 387 + ], + "score": 1.0, + "content": "stage, generated words are used in the testing stage.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 19.5, + "bbox_fs": [ + 105, + 297, + 506, + 387 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 390, + 505, + 544 + ], + "lines": [ + { + "bbox": [ + 106, + 390, + 505, + 403 + ], + "spans": [ + { + "bbox": [ + 106, + 390, + 505, + 403 + ], + "score": 1.0, + "content": "To solve these problems with MLE, besides beam search and scheduled sampling (Bengio et al.,", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 400, + 505, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 400, + 505, + 416 + ], + "score": 1.0, + "content": "2015), (Ranzato et al., 2015) propose the REINFORCE and MIXER algorithms for sequence gen-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 412, + 504, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 504, + 425 + ], + "score": 1.0, + "content": "eration. By providing a task-specific score for the generated sequence, the REINFORCE algo-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 423, + 506, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 506, + 436 + ], + "score": 1.0, + "content": "rithm (Williams, 1992) guides the seq2seq model to reach higher scores. Because the score is", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 434, + 506, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 434, + 506, + 447 + ], + "score": 1.0, + "content": "evaluated based on the whole generated sequence, both MLE problems are solved. However, as", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 446, + 506, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 446, + 506, + 459 + ], + "score": 1.0, + "content": "the REINFORCE algorithm cannot easily train the model from scratch, the MIXER algorithm is", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 456, + 506, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 506, + 470 + ], + "score": 1.0, + "content": "proposed to integrate MLE and REINFORCE. In this process, they first train the whole sequence", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 468, + 505, + 480 + ], + "spans": [ + { + "bbox": [ + 106, + 468, + 505, + 480 + ], + "score": 1.0, + "content": "using MLE, after which they accumulate the number of last words trained by REINFORCE. For fur-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 478, + 505, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 478, + 505, + 492 + ], + "score": 1.0, + "content": "ther improvements, (Bahdanau et al., 2016) adopt another reinforcement learning (Sutton & Barto,", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 489, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 106, + 489, + 505, + 502 + ], + "score": 1.0, + "content": "1998) based approach – the actor-critic architecture. They train a critic to predict the expected value", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 500, + 505, + 513 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 505, + 513 + ], + "score": 1.0, + "content": "of each time step to guide the actor. These algorithms outperform the original MLE algorithm on", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 511, + 504, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 504, + 523 + ], + "score": 1.0, + "content": "the task-specific score (BLEU) for text generation. Nonetheless, there is no evidence that these task-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 523, + 505, + 535 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 505, + 535 + ], + "score": 1.0, + "content": "specific scores are correlated with human prior knowledge. In particular, the relationship between", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 533, + 497, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 497, + 546 + ], + "score": 1.0, + "content": "the scores and human evaluation has been proven weak for dialogue generation (Liu et al., 2016).", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 30.5, + "bbox_fs": [ + 105, + 390, + 506, + 546 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 550, + 505, + 704 + ], + "lines": [ + { + "bbox": [ + 105, + 549, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 549, + 505, + 563 + ], + "score": 1.0, + "content": "Recently, the significant success of generative adversarial networks (GAN) for image processing has", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 561, + 505, + 573 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 505, + 573 + ], + "score": 1.0, + "content": "led researchers to use GANs for natural language. However, this has seen limited success because", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 571, + 504, + 584 + ], + "spans": [ + { + "bbox": [ + 105, + 571, + 504, + 584 + ], + "score": 1.0, + "content": "of the difficulty of backpropagation through discrete random variables. To address this problem, (Yu", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 583, + 505, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 583, + 505, + 596 + ], + "score": 1.0, + "content": "et al., 2017) use policy gradients on text generation. The reward is provided by a discriminator with", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 593, + 505, + 607 + ], + "spans": [ + { + "bbox": [ + 105, + 593, + 505, + 607 + ], + "score": 1.0, + "content": "Monte-Carlo search. In addition, (Li et al., 2017) adopt the same idea for dialogue generation. They", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 605, + 506, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 506, + 618 + ], + "score": 1.0, + "content": "also propose Reward for Every Generation Step (REGS), which is more time-efficient but is weaker", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 615, + 505, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 505, + 630 + ], + "score": 1.0, + "content": "than Monte-Carlo search. Another way to use GAN for natural-language tasks is by using Gumbel-", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 626, + 505, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 505, + 640 + ], + "score": 1.0, + "content": "Softmax (Kusner & Hernandez-Lobato, 2016), which can simulate the discrete argmax outputs, ´", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 638, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 505, + 650 + ], + "score": 1.0, + "content": "and be directly backpropagated from the discriminator. Also, MaliGAN (Che et al., 2017) directly", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 649, + 504, + 660 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 504, + 660 + ], + "score": 1.0, + "content": "derives the gradient estimator for discrete data. More recently, the improved Wasserstein GAN", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "(WGAN-GP) (Gulrajani et al., 2017) has shown success for text generation by directly feeding the", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 670, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 670, + 505, + 684 + ], + "score": 1.0, + "content": "softmax layer to the discriminator, even without pre-training. This breakthrough then inspired (Press", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 681, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 505, + 694 + ], + "score": 1.0, + "content": "et al., 2017) and (Rajeswar et al., 2017) to further investigate WGAN-GP for better performance on", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 693, + 170, + 705 + ], + "spans": [ + { + "bbox": [ + 105, + 693, + 170, + 705 + ], + "score": 1.0, + "content": "text generation.", + "type": "text" + } + ], + "index": 51 + } + ], + "index": 44.5, + "bbox_fs": [ + 105, + 549, + 506, + 705 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 709, + 503, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 708, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 708, + 505, + 722 + ], + "score": 1.0, + "content": "We focus on the influence of different objective function in GANs on conditional sequence genera-", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 106, + 721, + 505, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 505, + 732 + ], + "score": 1.0, + "content": "tion throughout this paper. We compare the state-of-the-art algorithms without additional assistance", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "such as teacher forcing, curriculum learning, etc. By this setting, we only consider the improvement", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 461, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 461, + 106 + ], + "score": 1.0, + "content": "attributed by the intrinsic of different algorithms rather than other additional assistances.", + "type": "text", + "cross_page": true + } + ], + "index": 1 + } + ], + "index": 52.5, + "bbox_fs": [ + 106, + 708, + 505, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 505, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "such as teacher forcing, curriculum learning, etc. By this setting, we only consider the improvement", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 461, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 461, + 106 + ], + "score": 1.0, + "content": "attributed by the intrinsic of different algorithms rather than other additional assistances.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "title", + "bbox": [ + 107, + 122, + 331, + 135 + ], + "lines": [ + { + "bbox": [ + 104, + 120, + 332, + 137 + ], + "spans": [ + { + "bbox": [ + 104, + 120, + 332, + 137 + ], + "score": 1.0, + "content": "3 CONDITIONAL SEQUENCE GENERATION", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 106, + 147, + 505, + 192 + ], + "lines": [ + { + "bbox": [ + 105, + 148, + 505, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 148, + 377, + 161 + ], + "score": 1.0, + "content": "In conditional sequence generation, we generate an output sequence", + "type": "text" + }, + { + "bbox": [ + 378, + 149, + 406, + 158 + ], + "score": 0.91, + "content": "x \\in X", + "type": "inline_equation" + }, + { + "bbox": [ + 406, + 148, + 505, + 161 + ], + "score": 1.0, + "content": "given an input condition", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 158, + 506, + 172 + ], + "spans": [ + { + "bbox": [ + 106, + 159, + 135, + 171 + ], + "score": 0.89, + "content": "y \\in Y", + "type": "inline_equation" + }, + { + "bbox": [ + 136, + 158, + 418, + 172 + ], + "score": 1.0, + "content": ". When the output sequence is generated from a model, it is denoted", + "type": "text" + }, + { + "bbox": [ + 418, + 159, + 432, + 169 + ], + "score": 0.88, + "content": "x ^ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 432, + 158, + 506, + 172 + ], + "score": 1.0, + "content": "; when the output", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 169, + 505, + 182 + ], + "spans": [ + { + "bbox": [ + 105, + 170, + 373, + 182 + ], + "score": 1.0, + "content": "sequence is from real data (training examples), it is instead denoted", + "type": "text" + }, + { + "bbox": [ + 374, + 169, + 387, + 180 + ], + "score": 0.88, + "content": "x ^ { R }", + "type": "inline_equation" + }, + { + "bbox": [ + 387, + 170, + 505, + 182 + ], + "score": 1.0, + "content": ". In dialogue generation, both", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 107, + 181, + 330, + 192 + ], + "spans": [ + { + "bbox": [ + 107, + 183, + 113, + 191 + ], + "score": 0.75, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 114, + 181, + 131, + 192 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 132, + 183, + 138, + 192 + ], + "score": 0.81, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 138, + 181, + 330, + 192 + ], + "score": 1.0, + "content": "are sequences of words. They can be written as", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + }, + { + "type": "interline_equation", + "bbox": [ + 261, + 198, + 350, + 232 + ], + "lines": [ + { + "bbox": [ + 261, + 198, + 350, + 232 + ], + "spans": [ + { + "bbox": [ + 261, + 198, + 350, + 232 + ], + "score": 0.92, + "content": "\\begin{array} { r } { x = \\{ x _ { t } \\} _ { t = 1 } ^ { T } , x _ { t } \\in V } \\\\ { y = \\{ y _ { t } \\} _ { t = 1 } ^ { T } , y _ { t } \\in V . } \\end{array}", + "type": "interline_equation", + "image_path": "b6ddd1fa52ab57c49ed335a1686a3d35ecebc610e4d81a4ee471bf736566d6ea.jpg" + } + ] + } + ], + "index": 7.5, + "virtual_lines": [ + { + "bbox": [ + 261, + 198, + 350, + 215.0 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 261, + 215.0, + 350, + 232.0 + ], + "spans": [], + "index": 8 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 236, + 505, + 292 + ], + "lines": [ + { + "bbox": [ + 106, + 236, + 506, + 250 + ], + "spans": [ + { + "bbox": [ + 106, + 236, + 135, + 250 + ], + "score": 1.0, + "content": "Words", + "type": "text" + }, + { + "bbox": [ + 135, + 239, + 145, + 248 + ], + "score": 0.84, + "content": "x _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 146, + 236, + 164, + 250 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 164, + 239, + 174, + 248 + ], + "score": 0.83, + "content": "y _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 174, + 236, + 302, + 250 + ], + "score": 1.0, + "content": "represent the word at time step", + "type": "text" + }, + { + "bbox": [ + 302, + 238, + 307, + 246 + ], + "score": 0.76, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 308, + 236, + 367, + 250 + ], + "score": 1.0, + "content": "in the interval", + "type": "text" + }, + { + "bbox": [ + 367, + 237, + 376, + 246 + ], + "score": 0.83, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 376, + 236, + 479, + 250 + ], + "score": 1.0, + "content": "of the specific sequences", + "type": "text" + }, + { + "bbox": [ + 480, + 239, + 487, + 246 + ], + "score": 0.76, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 236, + 506, + 250 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 246, + 504, + 261 + ], + "spans": [ + { + "bbox": [ + 106, + 250, + 113, + 259 + ], + "score": 0.73, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 113, + 246, + 135, + 261 + ], + "score": 1.0, + "content": ". Set", + "type": "text" + }, + { + "bbox": [ + 135, + 248, + 145, + 258 + ], + "score": 0.8, + "content": "V", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 246, + 490, + 261 + ], + "score": 1.0, + "content": "is the vocabulary set from which the words are selected. In this paper, we generate", + "type": "text" + }, + { + "bbox": [ + 490, + 247, + 504, + 257 + ], + "score": 0.88, + "content": "x ^ { G }", + "type": "inline_equation" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 258, + 505, + 271 + ], + "spans": [ + { + "bbox": [ + 105, + 258, + 131, + 271 + ], + "score": 1.0, + "content": "given", + "type": "text" + }, + { + "bbox": [ + 131, + 261, + 138, + 270 + ], + "score": 0.77, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 138, + 258, + 309, + 271 + ], + "score": 1.0, + "content": "using the seq2seq model as the generator", + "type": "text" + }, + { + "bbox": [ + 309, + 259, + 318, + 268 + ], + "score": 0.82, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 319, + 258, + 505, + 271 + ], + "score": 1.0, + "content": "(Sutskever et al., 2014; Vinyals & Le, 2015).", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 268, + 505, + 282 + ], + "spans": [ + { + "bbox": [ + 105, + 268, + 505, + 282 + ], + "score": 1.0, + "content": "From Sections 3.1 to 3.3, we introduce maximum likelihood estimation, REINFORCE algorithm,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 281, + 459, + 293 + ], + "spans": [ + { + "bbox": [ + 106, + 281, + 459, + 293 + ], + "score": 1.0, + "content": "and GAN for sequence generation. In Section 4, we introduce the proposed approaches.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 11 + }, + { + "type": "title", + "bbox": [ + 108, + 306, + 292, + 317 + ], + "lines": [ + { + "bbox": [ + 105, + 306, + 293, + 319 + ], + "spans": [ + { + "bbox": [ + 105, + 306, + 293, + 319 + ], + "score": 1.0, + "content": "3.1 MAXIMUM LIKELIHOOD ESTIMATION", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 107, + 327, + 505, + 361 + ], + "lines": [ + { + "bbox": [ + 105, + 326, + 505, + 340 + ], + "spans": [ + { + "bbox": [ + 105, + 326, + 505, + 340 + ], + "score": 1.0, + "content": "The basic idea of maximum likelihood estimation (MLE) for conditional sequence generation is to", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 338, + 505, + 351 + ], + "spans": [ + { + "bbox": [ + 105, + 338, + 226, + 351 + ], + "score": 1.0, + "content": "find the parameters for model", + "type": "text" + }, + { + "bbox": [ + 227, + 339, + 236, + 349 + ], + "score": 0.81, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 236, + 338, + 505, + 351 + ], + "score": 1.0, + "content": "that maximize the likelihood of generating the training data. When", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 350, + 379, + 362 + ], + "spans": [ + { + "bbox": [ + 106, + 350, + 267, + 362 + ], + "score": 1.0, + "content": "using MLE to train the generator model", + "type": "text" + }, + { + "bbox": [ + 268, + 350, + 276, + 360 + ], + "score": 0.82, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 276, + 350, + 379, + 362 + ], + "score": 1.0, + "content": ", the objective function is", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16 + }, + { + "type": "interline_equation", + "bbox": [ + 176, + 367, + 434, + 401 + ], + "lines": [ + { + "bbox": [ + 176, + 367, + 434, + 401 + ], + "spans": [ + { + "bbox": [ + 176, + 367, + 434, + 401 + ], + "score": 0.94, + "content": "G ^ { * } = \\arg \\operatorname* { m a x } _ { G } E _ { ( x ^ { R } , y ) \\sim P ^ { R } ( X , Y ) } [ \\sum _ { t = 1 } ^ { T } \\log ( P ^ { G } ( x _ { t } ^ { R } | y , x _ { 1 \\dots t - 1 } ^ { R } ) ) ] ,", + "type": "interline_equation", + "image_path": "98c2280934f1732ac9d5dfa19dc1eea051281da98e949e1e97ec6574931f9c05.jpg" + } + ] + } + ], + "index": 19, + "virtual_lines": [ + { + "bbox": [ + 176, + 367, + 434, + 378.3333333333333 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 176, + 378.3333333333333, + 434, + 389.66666666666663 + ], + "spans": [], + "index": 19 + }, + { + "bbox": [ + 176, + 389.66666666666663, + 434, + 400.99999999999994 + ], + "spans": [], + "index": 20 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 408, + 505, + 466 + ], + "lines": [ + { + "bbox": [ + 102, + 406, + 509, + 438 + ], + "spans": [ + { + "bbox": [ + 102, + 406, + 118, + 438 + ], + "score": 1.0, + "content": "whof", + "type": "text" + }, + { + "bbox": [ + 131, + 406, + 133, + 438 + ], + "score": 1.0, + "content": ".", + "type": "text" + }, + { + "bbox": [ + 134, + 408, + 178, + 421 + ], + "score": 0.93, + "content": "P ^ { R } ( X , Y )", + "type": "inline_equation" + }, + { + "bbox": [ + 178, + 406, + 298, + 438 + ], + "score": 1.0, + "content": "is the joint distribution of the ning stage, in Eq. (2), the pre", + "type": "text" + }, + { + "bbox": [ + 299, + 409, + 322, + 421 + ], + "score": 0.91, + "content": "( x , y )", + "type": "inline_equation" + }, + { + "bbox": [ + 323, + 406, + 408, + 438 + ], + "score": 1.0, + "content": "pairs in the training n is learned based on", + "type": "text" + }, + { + "bbox": [ + 444, + 410, + 452, + 419 + ], + "score": 0.82, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 470, + 406, + 509, + 438 + ], + "score": 1.0, + "content": "e length, but the", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 118, + 419, + 470, + 433 + ], + "spans": [ + { + "bbox": [ + 118, + 419, + 131, + 430 + ], + "score": 0.86, + "content": "x ^ { R }", + "type": "inline_equation" + }, + { + "bbox": [ + 408, + 420, + 470, + 433 + ], + "score": 0.91, + "content": "< y , x _ { 1 \\ldots t - 1 } ^ { R } >", + "type": "inline_equation" + } + ], + "index": 22 + }, + { + "bbox": [ + 104, + 431, + 507, + 449 + ], + "spans": [ + { + "bbox": [ + 104, + 431, + 236, + 449 + ], + "score": 1.0, + "content": "condition in the testing stage is", + "type": "text" + }, + { + "bbox": [ + 236, + 432, + 298, + 446 + ], + "score": 0.92, + "content": "< y , x _ { 1 \\ldots t - 1 } ^ { G } >", + "type": "inline_equation" + }, + { + "bbox": [ + 298, + 431, + 507, + 449 + ], + "score": 1.0, + "content": ". This is known as exposure bias, which can result", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 443, + 506, + 456 + ], + "spans": [ + { + "bbox": [ + 105, + 443, + 506, + 456 + ], + "score": 1.0, + "content": "in accumulating error when testing. This is also due to the likelihood is estimated at the word", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 455, + 376, + 467 + ], + "spans": [ + { + "bbox": [ + 106, + 455, + 376, + 467 + ], + "score": 1.0, + "content": "level (Ranzato et al., 2015) only as opposed to the whole sequence.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23 + }, + { + "type": "title", + "bbox": [ + 107, + 480, + 192, + 492 + ], + "lines": [ + { + "bbox": [ + 105, + 480, + 193, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 480, + 193, + 494 + ], + "score": 1.0, + "content": "3.2 REINFORCE", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 106, + 501, + 505, + 592 + ], + "lines": [ + { + "bbox": [ + 106, + 502, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 106, + 502, + 505, + 514 + ], + "score": 1.0, + "content": "Conditional sequence generation can be formulated as reinforcement learning. Similar to (Ranzato", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 513, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 513, + 434, + 525 + ], + "score": 1.0, + "content": "et al., 2015), we describe it as a Markov decision process (MDP), where state", + "type": "text" + }, + { + "bbox": [ + 434, + 515, + 441, + 523 + ], + "score": 0.67, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 441, + 513, + 505, + 525 + ], + "score": 1.0, + "content": "consists of the", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 104, + 523, + 506, + 539 + ], + "spans": [ + { + "bbox": [ + 104, + 523, + 323, + 539 + ], + "score": 1.0, + "content": "condition and previous word sequence – in our case,", + "type": "text" + }, + { + "bbox": [ + 323, + 524, + 411, + 536 + ], + "score": 0.86, + "content": "s = < y , x _ { 1 . . . t - 1 } ^ { G } > -", + "type": "inline_equation" + }, + { + "bbox": [ + 412, + 523, + 472, + 539 + ], + "score": 1.0, + "content": "and an action", + "type": "text" + }, + { + "bbox": [ + 473, + 526, + 479, + 534 + ], + "score": 0.74, + "content": "a", + "type": "inline_equation" + }, + { + "bbox": [ + 479, + 523, + 506, + 539 + ], + "score": 1.0, + "content": "is the", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 536, + 505, + 550 + ], + "spans": [ + { + "bbox": [ + 104, + 536, + 357, + 550 + ], + "score": 1.0, + "content": "generated word conditioned on the current state – in our case,", + "type": "text" + }, + { + "bbox": [ + 357, + 536, + 390, + 548 + ], + "score": 0.9, + "content": "a = x _ { t } ^ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 390, + 536, + 505, + 550 + ], + "score": 1.0, + "content": "is a word in the vocabulary.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 547, + 505, + 560 + ], + "spans": [ + { + "bbox": [ + 105, + 547, + 505, + 560 + ], + "score": 1.0, + "content": "Each action is generated according to the policy, which is determined by the parameters of generator", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 559, + 505, + 571 + ], + "spans": [ + { + "bbox": [ + 105, + 559, + 135, + 571 + ], + "score": 1.0, + "content": "model", + "type": "text" + }, + { + "bbox": [ + 135, + 559, + 144, + 568 + ], + "score": 0.8, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 559, + 399, + 571 + ], + "score": 1.0, + "content": ". In typical reinforcement learning, the agent obtains a reward", + "type": "text" + }, + { + "bbox": [ + 400, + 560, + 409, + 569 + ], + "score": 0.84, + "content": "r _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 410, + 559, + 482, + 571 + ], + "score": 1.0, + "content": "at each time step", + "type": "text" + }, + { + "bbox": [ + 483, + 560, + 488, + 568 + ], + "score": 0.63, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 488, + 559, + 505, + 571 + ], + "score": 1.0, + "content": ". In", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 104, + 569, + 506, + 583 + ], + "spans": [ + { + "bbox": [ + 104, + 569, + 192, + 583 + ], + "score": 1.0, + "content": "sequence generation,", + "type": "text" + }, + { + "bbox": [ + 192, + 571, + 201, + 581 + ], + "score": 0.83, + "content": "r _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 202, + 569, + 273, + 583 + ], + "score": 1.0, + "content": "is zero except for", + "type": "text" + }, + { + "bbox": [ + 273, + 571, + 285, + 581 + ], + "score": 0.83, + "content": "r _ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 569, + 506, + 583 + ], + "score": 1.0, + "content": ", which evaluates the goodness of the whole generating", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 579, + 397, + 593 + ], + "spans": [ + { + "bbox": [ + 106, + 579, + 131, + 593 + ], + "score": 0.92, + "content": "x _ { 1 \\ldots T } ^ { G ^ { \\star } }", + "type": "inline_equation" + }, + { + "bbox": [ + 131, + 580, + 156, + 593 + ], + "score": 1.0, + "content": "given", + "type": "text" + }, + { + "bbox": [ + 156, + 582, + 163, + 592 + ], + "score": 0.74, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 163, + 580, + 225, + 593 + ], + "score": 1.0, + "content": ". The generator", + "type": "text" + }, + { + "bbox": [ + 226, + 581, + 234, + 590 + ], + "score": 0.85, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 580, + 397, + 593 + ], + "score": 1.0, + "content": "learns to maximize the expected reward", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 30.5 + }, + { + "type": "interline_equation", + "bbox": [ + 217, + 599, + 393, + 617 + ], + "lines": [ + { + "bbox": [ + 217, + 599, + 393, + 617 + ], + "spans": [ + { + "bbox": [ + 217, + 599, + 393, + 617 + ], + "score": 0.92, + "content": "G ^ { * } = \\arg \\operatorname* { m a x } _ { G } E _ { y \\sim P ^ { R } \\left( Y \\right) , x ^ { G } \\sim P ^ { G } \\left( X \\mid y \\right) } [ r _ { T } ] ,", + "type": "interline_equation", + "image_path": "9bc018fca1267a9ce7d0a66d3f4bfb64b19f00472f9734b80ba978d114ae3c6d.jpg" + } + ] + } + ], + "index": 35, + "virtual_lines": [ + { + "bbox": [ + 217, + 599, + 393, + 617 + ], + "spans": [], + "index": 35 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 623, + 505, + 682 + ], + "lines": [ + { + "bbox": [ + 105, + 622, + 506, + 638 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 134, + 638 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 135, + 624, + 165, + 637 + ], + "score": 0.92, + "content": "P ^ { R } ( Y )", + "type": "inline_equation" + }, + { + "bbox": [ + 166, + 622, + 343, + 638 + ], + "score": 1.0, + "content": "is the probability distribution of condition", + "type": "text" + }, + { + "bbox": [ + 344, + 627, + 351, + 636 + ], + "score": 0.8, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 622, + 437, + 638 + ], + "score": 1.0, + "content": "in the training data,", + "type": "text" + }, + { + "bbox": [ + 438, + 624, + 478, + 637 + ], + "score": 0.93, + "content": "P ^ { G } ( X | y )", + "type": "inline_equation" + }, + { + "bbox": [ + 478, + 622, + 506, + 638 + ], + "score": 1.0, + "content": "is the", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 635, + 506, + 649 + ], + "spans": [ + { + "bbox": [ + 105, + 635, + 267, + 649 + ], + "score": 1.0, + "content": "probability of generating the sequence", + "type": "text" + }, + { + "bbox": [ + 267, + 635, + 280, + 646 + ], + "score": 0.88, + "content": "x ^ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 281, + 635, + 365, + 649 + ], + "score": 1.0, + "content": "given the generator", + "type": "text" + }, + { + "bbox": [ + 365, + 636, + 374, + 646 + ], + "score": 0.82, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 375, + 635, + 435, + 649 + ], + "score": 1.0, + "content": "and condition", + "type": "text" + }, + { + "bbox": [ + 442, + 635, + 506, + 649 + ], + "score": 1.0, + "content": ". Note that the", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 101, + 641, + 509, + 663 + ], + "spans": [ + { + "bbox": [ + 101, + 641, + 446, + 663 + ], + "score": 1.0, + "content": "main difference between Equations (2) and (3) is that the condition sequence here is", + "type": "text" + }, + { + "bbox": [ + 446, + 646, + 478, + 659 + ], + "score": 0.93, + "content": "x _ { 1 \\ldots t - 1 } ^ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 478, + 641, + 509, + 663 + ], + "score": 1.0, + "content": "rather", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 103, + 656, + 507, + 675 + ], + "spans": [ + { + "bbox": [ + 103, + 656, + 126, + 675 + ], + "score": 1.0, + "content": "than", + "type": "text" + }, + { + "bbox": [ + 126, + 658, + 158, + 672 + ], + "score": 0.91, + "content": "x _ { 1 \\ldots t - 1 } ^ { R }", + "type": "inline_equation" + }, + { + "bbox": [ + 158, + 656, + 226, + 675 + ], + "score": 1.0, + "content": ". Moreover, each", + "type": "text" + }, + { + "bbox": [ + 226, + 659, + 239, + 671 + ], + "score": 0.9, + "content": "x _ { t } ^ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 239, + 656, + 507, + 675 + ], + "score": 1.0, + "content": "here is sampled using softmax rather than argmax over vocabulary", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 671, + 338, + 682 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 120, + 682 + ], + "score": 1.0, + "content": "set", + "type": "text" + }, + { + "bbox": [ + 120, + 671, + 129, + 680 + ], + "score": 0.76, + "content": "V", + "type": "inline_equation" + }, + { + "bbox": [ + 129, + 671, + 263, + 682 + ], + "score": 1.0, + "content": ". The parameters of the generator", + "type": "text" + }, + { + "bbox": [ + 264, + 672, + 276, + 681 + ], + "score": 0.89, + "content": "\\theta _ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 276, + 671, + 338, + 682 + ], + "score": 1.0, + "content": "are updated as", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 38 + }, + { + "type": "interline_equation", + "bbox": [ + 203, + 688, + 407, + 704 + ], + "lines": [ + { + "bbox": [ + 203, + 688, + 407, + 704 + ], + "spans": [ + { + "bbox": [ + 203, + 688, + 407, + 704 + ], + "score": 0.9, + "content": "\\theta _ { G } \\theta _ { G } + \\eta ( r _ { T } - b _ { t } ) \\nabla \\log ( p _ { G } ( x _ { t } ^ { G } | y , x _ { 1 \\dots t - 1 } ^ { G } ) ) ,", + "type": "interline_equation", + "image_path": "44b11792fb97c89a15701dfe1adad9ea95db34a7f69ddbe24062143b3c74c1dd.jpg" + } + ] + } + ], + "index": 41, + "virtual_lines": [ + { + "bbox": [ + 203, + 688, + 407, + 704 + ], + "spans": [], + "index": 41 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 133, + 722 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 710, + 143, + 721 + ], + "score": 0.87, + "content": "b _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "is the baseline to reduce training variance (Sutton & Barto, 1998; Ranzato et al., 2015),", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 720, + 210, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 123, + 733 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 123, + 722, + 130, + 732 + ], + "score": 0.81, + "content": "\\eta", + "type": "inline_equation" + }, + { + "bbox": [ + 131, + 720, + 210, + 733 + ], + "score": 1.0, + "content": "is the learning rate.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42.5 + } + ], + "page_idx": 2, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 26, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "score": 1.0, + "content": "3", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 505, + 105 + ], + "lines": [], + "index": 0.5, + "bbox_fs": [ + 105, + 82, + 505, + 106 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 107, + 122, + 331, + 135 + ], + "lines": [ + { + "bbox": [ + 104, + 120, + 332, + 137 + ], + "spans": [ + { + "bbox": [ + 104, + 120, + 332, + 137 + ], + "score": 1.0, + "content": "3 CONDITIONAL SEQUENCE GENERATION", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 106, + 147, + 505, + 192 + ], + "lines": [ + { + "bbox": [ + 105, + 148, + 505, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 148, + 377, + 161 + ], + "score": 1.0, + "content": "In conditional sequence generation, we generate an output sequence", + "type": "text" + }, + { + "bbox": [ + 378, + 149, + 406, + 158 + ], + "score": 0.91, + "content": "x \\in X", + "type": "inline_equation" + }, + { + "bbox": [ + 406, + 148, + 505, + 161 + ], + "score": 1.0, + "content": "given an input condition", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 158, + 506, + 172 + ], + "spans": [ + { + "bbox": [ + 106, + 159, + 135, + 171 + ], + "score": 0.89, + "content": "y \\in Y", + "type": "inline_equation" + }, + { + "bbox": [ + 136, + 158, + 418, + 172 + ], + "score": 1.0, + "content": ". When the output sequence is generated from a model, it is denoted", + "type": "text" + }, + { + "bbox": [ + 418, + 159, + 432, + 169 + ], + "score": 0.88, + "content": "x ^ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 432, + 158, + 506, + 172 + ], + "score": 1.0, + "content": "; when the output", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 169, + 505, + 182 + ], + "spans": [ + { + "bbox": [ + 105, + 170, + 373, + 182 + ], + "score": 1.0, + "content": "sequence is from real data (training examples), it is instead denoted", + "type": "text" + }, + { + "bbox": [ + 374, + 169, + 387, + 180 + ], + "score": 0.88, + "content": "x ^ { R }", + "type": "inline_equation" + }, + { + "bbox": [ + 387, + 170, + 505, + 182 + ], + "score": 1.0, + "content": ". In dialogue generation, both", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 107, + 181, + 330, + 192 + ], + "spans": [ + { + "bbox": [ + 107, + 183, + 113, + 191 + ], + "score": 0.75, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 114, + 181, + 131, + 192 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 132, + 183, + 138, + 192 + ], + "score": 0.81, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 138, + 181, + 330, + 192 + ], + "score": 1.0, + "content": "are sequences of words. They can be written as", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5, + "bbox_fs": [ + 105, + 148, + 506, + 192 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 261, + 198, + 350, + 232 + ], + "lines": [ + { + "bbox": [ + 261, + 198, + 350, + 232 + ], + "spans": [ + { + "bbox": [ + 261, + 198, + 350, + 232 + ], + "score": 0.92, + "content": "\\begin{array} { r } { x = \\{ x _ { t } \\} _ { t = 1 } ^ { T } , x _ { t } \\in V } \\\\ { y = \\{ y _ { t } \\} _ { t = 1 } ^ { T } , y _ { t } \\in V . } \\end{array}", + "type": "interline_equation", + "image_path": "b6ddd1fa52ab57c49ed335a1686a3d35ecebc610e4d81a4ee471bf736566d6ea.jpg" + } + ] + } + ], + "index": 7.5, + "virtual_lines": [ + { + "bbox": [ + 261, + 198, + 350, + 215.0 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 261, + 215.0, + 350, + 232.0 + ], + "spans": [], + "index": 8 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 236, + 505, + 292 + ], + "lines": [ + { + "bbox": [ + 106, + 236, + 506, + 250 + ], + "spans": [ + { + "bbox": [ + 106, + 236, + 135, + 250 + ], + "score": 1.0, + "content": "Words", + "type": "text" + }, + { + "bbox": [ + 135, + 239, + 145, + 248 + ], + "score": 0.84, + "content": "x _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 146, + 236, + 164, + 250 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 164, + 239, + 174, + 248 + ], + "score": 0.83, + "content": "y _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 174, + 236, + 302, + 250 + ], + "score": 1.0, + "content": "represent the word at time step", + "type": "text" + }, + { + "bbox": [ + 302, + 238, + 307, + 246 + ], + "score": 0.76, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 308, + 236, + 367, + 250 + ], + "score": 1.0, + "content": "in the interval", + "type": "text" + }, + { + "bbox": [ + 367, + 237, + 376, + 246 + ], + "score": 0.83, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 376, + 236, + 479, + 250 + ], + "score": 1.0, + "content": "of the specific sequences", + "type": "text" + }, + { + "bbox": [ + 480, + 239, + 487, + 246 + ], + "score": 0.76, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 236, + 506, + 250 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 246, + 504, + 261 + ], + "spans": [ + { + "bbox": [ + 106, + 250, + 113, + 259 + ], + "score": 0.73, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 113, + 246, + 135, + 261 + ], + "score": 1.0, + "content": ". Set", + "type": "text" + }, + { + "bbox": [ + 135, + 248, + 145, + 258 + ], + "score": 0.8, + "content": "V", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 246, + 490, + 261 + ], + "score": 1.0, + "content": "is the vocabulary set from which the words are selected. In this paper, we generate", + "type": "text" + }, + { + "bbox": [ + 490, + 247, + 504, + 257 + ], + "score": 0.88, + "content": "x ^ { G }", + "type": "inline_equation" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 258, + 505, + 271 + ], + "spans": [ + { + "bbox": [ + 105, + 258, + 131, + 271 + ], + "score": 1.0, + "content": "given", + "type": "text" + }, + { + "bbox": [ + 131, + 261, + 138, + 270 + ], + "score": 0.77, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 138, + 258, + 309, + 271 + ], + "score": 1.0, + "content": "using the seq2seq model as the generator", + "type": "text" + }, + { + "bbox": [ + 309, + 259, + 318, + 268 + ], + "score": 0.82, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 319, + 258, + 505, + 271 + ], + "score": 1.0, + "content": "(Sutskever et al., 2014; Vinyals & Le, 2015).", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 268, + 505, + 282 + ], + "spans": [ + { + "bbox": [ + 105, + 268, + 505, + 282 + ], + "score": 1.0, + "content": "From Sections 3.1 to 3.3, we introduce maximum likelihood estimation, REINFORCE algorithm,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 281, + 459, + 293 + ], + "spans": [ + { + "bbox": [ + 106, + 281, + 459, + 293 + ], + "score": 1.0, + "content": "and GAN for sequence generation. In Section 4, we introduce the proposed approaches.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 11, + "bbox_fs": [ + 105, + 236, + 506, + 293 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 306, + 292, + 317 + ], + "lines": [ + { + "bbox": [ + 105, + 306, + 293, + 319 + ], + "spans": [ + { + "bbox": [ + 105, + 306, + 293, + 319 + ], + "score": 1.0, + "content": "3.1 MAXIMUM LIKELIHOOD ESTIMATION", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 107, + 327, + 505, + 361 + ], + "lines": [ + { + "bbox": [ + 105, + 326, + 505, + 340 + ], + "spans": [ + { + "bbox": [ + 105, + 326, + 505, + 340 + ], + "score": 1.0, + "content": "The basic idea of maximum likelihood estimation (MLE) for conditional sequence generation is to", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 338, + 505, + 351 + ], + "spans": [ + { + "bbox": [ + 105, + 338, + 226, + 351 + ], + "score": 1.0, + "content": "find the parameters for model", + "type": "text" + }, + { + "bbox": [ + 227, + 339, + 236, + 349 + ], + "score": 0.81, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 236, + 338, + 505, + 351 + ], + "score": 1.0, + "content": "that maximize the likelihood of generating the training data. When", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 350, + 379, + 362 + ], + "spans": [ + { + "bbox": [ + 106, + 350, + 267, + 362 + ], + "score": 1.0, + "content": "using MLE to train the generator model", + "type": "text" + }, + { + "bbox": [ + 268, + 350, + 276, + 360 + ], + "score": 0.82, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 276, + 350, + 379, + 362 + ], + "score": 1.0, + "content": ", the objective function is", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 16, + "bbox_fs": [ + 105, + 326, + 505, + 362 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 176, + 367, + 434, + 401 + ], + "lines": [ + { + "bbox": [ + 176, + 367, + 434, + 401 + ], + "spans": [ + { + "bbox": [ + 176, + 367, + 434, + 401 + ], + "score": 0.94, + "content": "G ^ { * } = \\arg \\operatorname* { m a x } _ { G } E _ { ( x ^ { R } , y ) \\sim P ^ { R } ( X , Y ) } [ \\sum _ { t = 1 } ^ { T } \\log ( P ^ { G } ( x _ { t } ^ { R } | y , x _ { 1 \\dots t - 1 } ^ { R } ) ) ] ,", + "type": "interline_equation", + "image_path": "98c2280934f1732ac9d5dfa19dc1eea051281da98e949e1e97ec6574931f9c05.jpg" + } + ] + } + ], + "index": 19, + "virtual_lines": [ + { + "bbox": [ + 176, + 367, + 434, + 378.3333333333333 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 176, + 378.3333333333333, + 434, + 389.66666666666663 + ], + "spans": [], + "index": 19 + }, + { + "bbox": [ + 176, + 389.66666666666663, + 434, + 400.99999999999994 + ], + "spans": [], + "index": 20 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 408, + 505, + 466 + ], + "lines": [ + { + "bbox": [ + 102, + 406, + 509, + 438 + ], + "spans": [ + { + "bbox": [ + 102, + 406, + 118, + 438 + ], + "score": 1.0, + "content": "whof", + "type": "text" + }, + { + "bbox": [ + 131, + 406, + 133, + 438 + ], + "score": 1.0, + "content": ".", + "type": "text" + }, + { + "bbox": [ + 134, + 408, + 178, + 421 + ], + "score": 0.93, + "content": "P ^ { R } ( X , Y )", + "type": "inline_equation" + }, + { + "bbox": [ + 178, + 406, + 298, + 438 + ], + "score": 1.0, + "content": "is the joint distribution of the ning stage, in Eq. (2), the pre", + "type": "text" + }, + { + "bbox": [ + 299, + 409, + 322, + 421 + ], + "score": 0.91, + "content": "( x , y )", + "type": "inline_equation" + }, + { + "bbox": [ + 323, + 406, + 408, + 438 + ], + "score": 1.0, + "content": "pairs in the training n is learned based on", + "type": "text" + }, + { + "bbox": [ + 444, + 410, + 452, + 419 + ], + "score": 0.82, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 470, + 406, + 509, + 438 + ], + "score": 1.0, + "content": "e length, but the", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 118, + 419, + 470, + 433 + ], + "spans": [ + { + "bbox": [ + 118, + 419, + 131, + 430 + ], + "score": 0.86, + "content": "x ^ { R }", + "type": "inline_equation" + }, + { + "bbox": [ + 408, + 420, + 470, + 433 + ], + "score": 0.91, + "content": "< y , x _ { 1 \\ldots t - 1 } ^ { R } >", + "type": "inline_equation" + } + ], + "index": 22 + }, + { + "bbox": [ + 104, + 431, + 507, + 449 + ], + "spans": [ + { + "bbox": [ + 104, + 431, + 236, + 449 + ], + "score": 1.0, + "content": "condition in the testing stage is", + "type": "text" + }, + { + "bbox": [ + 236, + 432, + 298, + 446 + ], + "score": 0.92, + "content": "< y , x _ { 1 \\ldots t - 1 } ^ { G } >", + "type": "inline_equation" + }, + { + "bbox": [ + 298, + 431, + 507, + 449 + ], + "score": 1.0, + "content": ". This is known as exposure bias, which can result", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 443, + 506, + 456 + ], + "spans": [ + { + "bbox": [ + 105, + 443, + 506, + 456 + ], + "score": 1.0, + "content": "in accumulating error when testing. This is also due to the likelihood is estimated at the word", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 455, + 376, + 467 + ], + "spans": [ + { + "bbox": [ + 106, + 455, + 376, + 467 + ], + "score": 1.0, + "content": "level (Ranzato et al., 2015) only as opposed to the whole sequence.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23, + "bbox_fs": [ + 102, + 406, + 509, + 467 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 480, + 192, + 492 + ], + "lines": [ + { + "bbox": [ + 105, + 480, + 193, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 480, + 193, + 494 + ], + "score": 1.0, + "content": "3.2 REINFORCE", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 106, + 501, + 505, + 592 + ], + "lines": [ + { + "bbox": [ + 106, + 502, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 106, + 502, + 505, + 514 + ], + "score": 1.0, + "content": "Conditional sequence generation can be formulated as reinforcement learning. Similar to (Ranzato", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 513, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 513, + 434, + 525 + ], + "score": 1.0, + "content": "et al., 2015), we describe it as a Markov decision process (MDP), where state", + "type": "text" + }, + { + "bbox": [ + 434, + 515, + 441, + 523 + ], + "score": 0.67, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 441, + 513, + 505, + 525 + ], + "score": 1.0, + "content": "consists of the", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 104, + 523, + 506, + 539 + ], + "spans": [ + { + "bbox": [ + 104, + 523, + 323, + 539 + ], + "score": 1.0, + "content": "condition and previous word sequence – in our case,", + "type": "text" + }, + { + "bbox": [ + 323, + 524, + 411, + 536 + ], + "score": 0.86, + "content": "s = < y , x _ { 1 . . . t - 1 } ^ { G } > -", + "type": "inline_equation" + }, + { + "bbox": [ + 412, + 523, + 472, + 539 + ], + "score": 1.0, + "content": "and an action", + "type": "text" + }, + { + "bbox": [ + 473, + 526, + 479, + 534 + ], + "score": 0.74, + "content": "a", + "type": "inline_equation" + }, + { + "bbox": [ + 479, + 523, + 506, + 539 + ], + "score": 1.0, + "content": "is the", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 536, + 505, + 550 + ], + "spans": [ + { + "bbox": [ + 104, + 536, + 357, + 550 + ], + "score": 1.0, + "content": "generated word conditioned on the current state – in our case,", + "type": "text" + }, + { + "bbox": [ + 357, + 536, + 390, + 548 + ], + "score": 0.9, + "content": "a = x _ { t } ^ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 390, + 536, + 505, + 550 + ], + "score": 1.0, + "content": "is a word in the vocabulary.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 547, + 505, + 560 + ], + "spans": [ + { + "bbox": [ + 105, + 547, + 505, + 560 + ], + "score": 1.0, + "content": "Each action is generated according to the policy, which is determined by the parameters of generator", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 559, + 505, + 571 + ], + "spans": [ + { + "bbox": [ + 105, + 559, + 135, + 571 + ], + "score": 1.0, + "content": "model", + "type": "text" + }, + { + "bbox": [ + 135, + 559, + 144, + 568 + ], + "score": 0.8, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 559, + 399, + 571 + ], + "score": 1.0, + "content": ". In typical reinforcement learning, the agent obtains a reward", + "type": "text" + }, + { + "bbox": [ + 400, + 560, + 409, + 569 + ], + "score": 0.84, + "content": "r _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 410, + 559, + 482, + 571 + ], + "score": 1.0, + "content": "at each time step", + "type": "text" + }, + { + "bbox": [ + 483, + 560, + 488, + 568 + ], + "score": 0.63, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 488, + 559, + 505, + 571 + ], + "score": 1.0, + "content": ". In", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 104, + 569, + 506, + 583 + ], + "spans": [ + { + "bbox": [ + 104, + 569, + 192, + 583 + ], + "score": 1.0, + "content": "sequence generation,", + "type": "text" + }, + { + "bbox": [ + 192, + 571, + 201, + 581 + ], + "score": 0.83, + "content": "r _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 202, + 569, + 273, + 583 + ], + "score": 1.0, + "content": "is zero except for", + "type": "text" + }, + { + "bbox": [ + 273, + 571, + 285, + 581 + ], + "score": 0.83, + "content": "r _ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 569, + 506, + 583 + ], + "score": 1.0, + "content": ", which evaluates the goodness of the whole generating", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 579, + 397, + 593 + ], + "spans": [ + { + "bbox": [ + 106, + 579, + 131, + 593 + ], + "score": 0.92, + "content": "x _ { 1 \\ldots T } ^ { G ^ { \\star } }", + "type": "inline_equation" + }, + { + "bbox": [ + 131, + 580, + 156, + 593 + ], + "score": 1.0, + "content": "given", + "type": "text" + }, + { + "bbox": [ + 156, + 582, + 163, + 592 + ], + "score": 0.74, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 163, + 580, + 225, + 593 + ], + "score": 1.0, + "content": ". The generator", + "type": "text" + }, + { + "bbox": [ + 226, + 581, + 234, + 590 + ], + "score": 0.85, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 580, + 397, + 593 + ], + "score": 1.0, + "content": "learns to maximize the expected reward", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 30.5, + "bbox_fs": [ + 104, + 502, + 506, + 593 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 217, + 599, + 393, + 617 + ], + "lines": [ + { + "bbox": [ + 217, + 599, + 393, + 617 + ], + "spans": [ + { + "bbox": [ + 217, + 599, + 393, + 617 + ], + "score": 0.92, + "content": "G ^ { * } = \\arg \\operatorname* { m a x } _ { G } E _ { y \\sim P ^ { R } \\left( Y \\right) , x ^ { G } \\sim P ^ { G } \\left( X \\mid y \\right) } [ r _ { T } ] ,", + "type": "interline_equation", + "image_path": "9bc018fca1267a9ce7d0a66d3f4bfb64b19f00472f9734b80ba978d114ae3c6d.jpg" + } + ] + } + ], + "index": 35, + "virtual_lines": [ + { + "bbox": [ + 217, + 599, + 393, + 617 + ], + "spans": [], + "index": 35 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 623, + 505, + 682 + ], + "lines": [ + { + "bbox": [ + 105, + 622, + 506, + 638 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 134, + 638 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 135, + 624, + 165, + 637 + ], + "score": 0.92, + "content": "P ^ { R } ( Y )", + "type": "inline_equation" + }, + { + "bbox": [ + 166, + 622, + 343, + 638 + ], + "score": 1.0, + "content": "is the probability distribution of condition", + "type": "text" + }, + { + "bbox": [ + 344, + 627, + 351, + 636 + ], + "score": 0.8, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 622, + 437, + 638 + ], + "score": 1.0, + "content": "in the training data,", + "type": "text" + }, + { + "bbox": [ + 438, + 624, + 478, + 637 + ], + "score": 0.93, + "content": "P ^ { G } ( X | y )", + "type": "inline_equation" + }, + { + "bbox": [ + 478, + 622, + 506, + 638 + ], + "score": 1.0, + "content": "is the", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 635, + 506, + 649 + ], + "spans": [ + { + "bbox": [ + 105, + 635, + 267, + 649 + ], + "score": 1.0, + "content": "probability of generating the sequence", + "type": "text" + }, + { + "bbox": [ + 267, + 635, + 280, + 646 + ], + "score": 0.88, + "content": "x ^ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 281, + 635, + 365, + 649 + ], + "score": 1.0, + "content": "given the generator", + "type": "text" + }, + { + "bbox": [ + 365, + 636, + 374, + 646 + ], + "score": 0.82, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 375, + 635, + 435, + 649 + ], + "score": 1.0, + "content": "and condition", + "type": "text" + }, + { + "bbox": [ + 442, + 635, + 506, + 649 + ], + "score": 1.0, + "content": ". Note that the", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 101, + 641, + 509, + 663 + ], + "spans": [ + { + "bbox": [ + 101, + 641, + 446, + 663 + ], + "score": 1.0, + "content": "main difference between Equations (2) and (3) is that the condition sequence here is", + "type": "text" + }, + { + "bbox": [ + 446, + 646, + 478, + 659 + ], + "score": 0.93, + "content": "x _ { 1 \\ldots t - 1 } ^ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 478, + 641, + 509, + 663 + ], + "score": 1.0, + "content": "rather", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 103, + 656, + 507, + 675 + ], + "spans": [ + { + "bbox": [ + 103, + 656, + 126, + 675 + ], + "score": 1.0, + "content": "than", + "type": "text" + }, + { + "bbox": [ + 126, + 658, + 158, + 672 + ], + "score": 0.91, + "content": "x _ { 1 \\ldots t - 1 } ^ { R }", + "type": "inline_equation" + }, + { + "bbox": [ + 158, + 656, + 226, + 675 + ], + "score": 1.0, + "content": ". Moreover, each", + "type": "text" + }, + { + "bbox": [ + 226, + 659, + 239, + 671 + ], + "score": 0.9, + "content": "x _ { t } ^ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 239, + 656, + 507, + 675 + ], + "score": 1.0, + "content": "here is sampled using softmax rather than argmax over vocabulary", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 671, + 338, + 682 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 120, + 682 + ], + "score": 1.0, + "content": "set", + "type": "text" + }, + { + "bbox": [ + 120, + 671, + 129, + 680 + ], + "score": 0.76, + "content": "V", + "type": "inline_equation" + }, + { + "bbox": [ + 129, + 671, + 263, + 682 + ], + "score": 1.0, + "content": ". The parameters of the generator", + "type": "text" + }, + { + "bbox": [ + 264, + 672, + 276, + 681 + ], + "score": 0.89, + "content": "\\theta _ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 276, + 671, + 338, + 682 + ], + "score": 1.0, + "content": "are updated as", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 38, + "bbox_fs": [ + 101, + 622, + 509, + 682 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 203, + 688, + 407, + 704 + ], + "lines": [ + { + "bbox": [ + 203, + 688, + 407, + 704 + ], + "spans": [ + { + "bbox": [ + 203, + 688, + 407, + 704 + ], + "score": 0.9, + "content": "\\theta _ { G } \\theta _ { G } + \\eta ( r _ { T } - b _ { t } ) \\nabla \\log ( p _ { G } ( x _ { t } ^ { G } | y , x _ { 1 \\dots t - 1 } ^ { G } ) ) ,", + "type": "interline_equation", + "image_path": "44b11792fb97c89a15701dfe1adad9ea95db34a7f69ddbe24062143b3c74c1dd.jpg" + } + ] + } + ], + "index": 41, + "virtual_lines": [ + { + "bbox": [ + 203, + 688, + 407, + 704 + ], + "spans": [], + "index": 41 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 133, + 722 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 710, + 143, + 721 + ], + "score": 0.87, + "content": "b _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "is the baseline to reduce training variance (Sutton & Barto, 1998; Ranzato et al., 2015),", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 720, + 210, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 123, + 733 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 123, + 722, + 130, + 732 + ], + "score": 0.81, + "content": "\\eta", + "type": "inline_equation" + }, + { + "bbox": [ + 131, + 720, + 210, + 733 + ], + "score": 1.0, + "content": "is the learning rate.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42.5, + "bbox_fs": [ + 105, + 709, + 505, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 82, + 300, + 93 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 302, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 302, + 95 + ], + "score": 1.0, + "content": "3.3 GENERATIVE ADVERSARIAL NETWORK", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 102, + 505, + 169 + ], + "lines": [ + { + "bbox": [ + 105, + 102, + 505, + 115 + ], + "spans": [ + { + "bbox": [ + 105, + 102, + 505, + 115 + ], + "score": 1.0, + "content": "A generative adversarial network (GAN) is composed of a generator and a discriminator (Goodfel-", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 114, + 505, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 114, + 505, + 127 + ], + "score": 1.0, + "content": "low et al., 2014). The discriminator differentiates between real data and data from the generator,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 125, + 506, + 138 + ], + "spans": [ + { + "bbox": [ + 106, + 125, + 506, + 138 + ], + "score": 1.0, + "content": "and the generator attempts to generate plausible data that will deceive the discriminator. Here we", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 135, + 506, + 149 + ], + "spans": [ + { + "bbox": [ + 105, + 135, + 407, + 149 + ], + "score": 1.0, + "content": "use GAN for conditional sequence generation by considering our model", + "type": "text" + }, + { + "bbox": [ + 408, + 136, + 417, + 146 + ], + "score": 0.79, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 417, + 135, + 506, + 149 + ], + "score": 1.0, + "content": "as the generator and", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 147, + 506, + 160 + ], + "spans": [ + { + "bbox": [ + 106, + 147, + 221, + 160 + ], + "score": 1.0, + "content": "constructing a discriminator", + "type": "text" + }, + { + "bbox": [ + 221, + 147, + 231, + 157 + ], + "score": 0.8, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 231, + 147, + 390, + 160 + ], + "score": 1.0, + "content": "sequentially fed with input-output pairs", + "type": "text" + }, + { + "bbox": [ + 391, + 149, + 398, + 159 + ], + "score": 0.81, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 398, + 147, + 415, + 160 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 415, + 149, + 423, + 157 + ], + "score": 0.74, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 423, + 147, + 506, + 160 + ], + "score": 1.0, + "content": "(Mirza & Osindero,", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 158, + 195, + 169 + ], + "spans": [ + { + "bbox": [ + 106, + 158, + 195, + 169 + ], + "score": 1.0, + "content": "2014; Li et al., 2017).", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 3.5 + }, + { + "type": "title", + "bbox": [ + 107, + 181, + 181, + 193 + ], + "lines": [ + { + "bbox": [ + 105, + 180, + 182, + 195 + ], + "spans": [ + { + "bbox": [ + 105, + 180, + 182, + 195 + ], + "score": 1.0, + "content": "3.3.1 SEQGAN", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 107, + 200, + 506, + 267 + ], + "lines": [ + { + "bbox": [ + 106, + 200, + 505, + 213 + ], + "spans": [ + { + "bbox": [ + 106, + 200, + 194, + 213 + ], + "score": 1.0, + "content": "Since the vocabulary", + "type": "text" + }, + { + "bbox": [ + 194, + 201, + 203, + 210 + ], + "score": 0.74, + "content": "V", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 200, + 505, + 213 + ], + "score": 1.0, + "content": "in the generated sequence is a discrete variable, we cannot backpropagate", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 212, + 505, + 225 + ], + "spans": [ + { + "bbox": [ + 106, + 212, + 249, + 225 + ], + "score": 1.0, + "content": "through the generator. In SeqGAN (", + "type": "text" + }, + { + "bbox": [ + 249, + 212, + 262, + 222 + ], + "score": 0.28, + "content": "\\mathrm { Y u }", + "type": "inline_equation" + }, + { + "bbox": [ + 262, + 212, + 505, + 225 + ], + "score": 1.0, + "content": "et al., 2017; Li et al., 2017), the generation task is formulated", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 222, + 505, + 235 + ], + "spans": [ + { + "bbox": [ + 105, + 222, + 505, + 235 + ], + "score": 1.0, + "content": "as a reinforcement learning scenario, similar to that described in Section 3.2, and the reward function", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 234, + 505, + 245 + ], + "spans": [ + { + "bbox": [ + 106, + 234, + 393, + 245 + ], + "score": 1.0, + "content": "is replaced with the discriminator in regular GAN. The discriminator", + "type": "text" + }, + { + "bbox": [ + 394, + 234, + 403, + 243 + ], + "score": 0.8, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 404, + 234, + 505, + 245 + ], + "score": 1.0, + "content": "is then updated through", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 244, + 506, + 257 + ], + "spans": [ + { + "bbox": [ + 105, + 244, + 261, + 257 + ], + "score": 1.0, + "content": "backpropagation, while the generator", + "type": "text" + }, + { + "bbox": [ + 261, + 245, + 270, + 254 + ], + "score": 0.84, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 244, + 506, + 257 + ], + "score": 1.0, + "content": "is updated using policy gradient with a reward evaluated", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 255, + 371, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 255, + 126, + 267 + ], + "score": 1.0, + "content": "over", + "type": "text" + }, + { + "bbox": [ + 127, + 257, + 133, + 265 + ], + "score": 0.77, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 134, + 255, + 158, + 267 + ], + "score": 1.0, + "content": "given", + "type": "text" + }, + { + "bbox": [ + 159, + 257, + 165, + 267 + ], + "score": 0.8, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 166, + 255, + 179, + 267 + ], + "score": 1.0, + "content": "by", + "type": "text" + }, + { + "bbox": [ + 180, + 256, + 189, + 265 + ], + "score": 0.81, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 255, + 317, + 267 + ], + "score": 1.0, + "content": ". The optimization functions for", + "type": "text" + }, + { + "bbox": [ + 318, + 256, + 327, + 265 + ], + "score": 0.83, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 328, + 255, + 345, + 267 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 346, + 256, + 355, + 265 + ], + "score": 0.84, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 355, + 255, + 371, + 267 + ], + "score": 1.0, + "content": "are", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 10.5 + }, + { + "type": "interline_equation", + "bbox": [ + 111, + 271, + 513, + 313 + ], + "lines": [ + { + "bbox": [ + 111, + 271, + 513, + 313 + ], + "spans": [ + { + "bbox": [ + 111, + 271, + 513, + 313 + ], + "score": 0.9, + "content": "\\begin{array} { r l } { } & { \\mathcal { D } ^ { * } = \\underset { D } { \\arg \\operatorname* { m a x } } E _ { y \\sim P ^ { R } \\left( Y \\right) , x ^ { R } \\sim \\mathit { P } ^ { R } \\left( X \\mid y \\right) } [ \\log ( D ( x ^ { R } | y ) ) ] + E _ { y \\sim \\mathit { P } ^ { R } \\left( Y \\right) , x ^ { G } \\sim \\mathit { P } ^ { G } \\left( X \\mid y \\right) } [ \\log ( 1 - \\mathit { D } ( x ^ { G } | y ) ) ] } \\\\ { } & { \\mathcal { X } ^ { * } = \\underset { G } { \\arg \\operatorname* { m a x } } E _ { y \\sim \\mathit { P } ^ { R } \\left( Y \\right) , x ^ { G } \\sim \\mathit { P } ^ { G } \\left( X \\mid y \\right) } [ \\mathit { D } ( x ^ { G } | y ) ] . } \\end{array}", + "type": "interline_equation", + "image_path": "ce9e0c11c994a7a44c8e7b2af6bfa8145624990a44cec4006ecf0560ec87f505.jpg" + } + ] + } + ], + "index": 15, + "virtual_lines": [ + { + "bbox": [ + 111, + 271, + 513, + 285.0 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 111, + 285.0, + 513, + 299.0 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 111, + 299.0, + 513, + 313.0 + ], + "spans": [], + "index": 16 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 327, + 505, + 362 + ], + "lines": [ + { + "bbox": [ + 105, + 327, + 505, + 341 + ], + "spans": [ + { + "bbox": [ + 105, + 327, + 198, + 341 + ], + "score": 1.0, + "content": "In the basic SeqGAN,", + "type": "text" + }, + { + "bbox": [ + 199, + 329, + 207, + 338 + ], + "score": 0.82, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 208, + 327, + 505, + 341 + ], + "score": 1.0, + "content": "in Equation (5) is optimized using the REINFORCE algorithm. The for-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 339, + 505, + 351 + ], + "spans": [ + { + "bbox": [ + 106, + 339, + 206, + 351 + ], + "score": 1.0, + "content": "mulation for optimizing", + "type": "text" + }, + { + "bbox": [ + 206, + 339, + 215, + 349 + ], + "score": 0.83, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 216, + 339, + 445, + 351 + ], + "score": 1.0, + "content": "in Equation (5) is the same as Equation (3), except that", + "type": "text" + }, + { + "bbox": [ + 445, + 341, + 457, + 350 + ], + "score": 0.86, + "content": "r _ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 457, + 339, + 505, + 351 + ], + "score": 1.0, + "content": "is replaced", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 348, + 169, + 363 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 127, + 363 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 127, + 349, + 164, + 362 + ], + "score": 0.92, + "content": "D ( x ^ { G } | y )", + "type": "inline_equation" + }, + { + "bbox": [ + 165, + 348, + 169, + 363 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 106, + 366, + 505, + 498 + ], + "lines": [ + { + "bbox": [ + 105, + 366, + 505, + 380 + ], + "spans": [ + { + "bbox": [ + 105, + 366, + 505, + 380 + ], + "score": 1.0, + "content": "Due to the sparse reward that only given at the terminal state, this basic setting will cause high", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 376, + 506, + 391 + ], + "spans": [ + { + "bbox": [ + 105, + 376, + 506, + 391 + ], + "score": 1.0, + "content": "training variance. For example, when questioning ”What ’s your name ?”, ”I ’m sorry.” is a wrong", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 388, + 506, + 402 + ], + "spans": [ + { + "bbox": [ + 105, + 388, + 437, + 402 + ], + "score": 1.0, + "content": "answer, while ”I ’m John.” is a correct answer. Although they share the same prefix", + "type": "text" + }, + { + "bbox": [ + 437, + 389, + 464, + 399 + ], + "score": 0.68, + "content": "\\because \\mathrm { m } ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 464, + 388, + 506, + 402 + ], + "score": 1.0, + "content": ", the basic", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 399, + 505, + 412 + ], + "spans": [ + { + "bbox": [ + 106, + 399, + 505, + 412 + ], + "score": 1.0, + "content": "SeqGAN will give the prefix different reward in different sentences. The solution in (Yu et al., 2017;", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 409, + 504, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 409, + 350, + 425 + ], + "score": 1.0, + "content": "Che et al., 2017) is Monte Carlo search. For each prefix", + "type": "text" + }, + { + "bbox": [ + 351, + 412, + 372, + 422 + ], + "score": 0.79, + "content": "x _ { 1 \\ldots t }", + "type": "inline_equation" + }, + { + "bbox": [ + 372, + 409, + 377, + 425 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 378, + 411, + 388, + 421 + ], + "score": 0.67, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 388, + 409, + 470, + 425 + ], + "score": 1.0, + "content": "possible sequences", + "type": "text" + }, + { + "bbox": [ + 470, + 413, + 504, + 423 + ], + "score": 0.89, + "content": "x _ { t + 1 \\ldots T }", + "type": "inline_equation" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 422, + 505, + 434 + ], + "spans": [ + { + "bbox": [ + 106, + 422, + 315, + 434 + ], + "score": 1.0, + "content": "are samples according to the current policy, and the", + "type": "text" + }, + { + "bbox": [ + 316, + 422, + 326, + 432 + ], + "score": 0.76, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 326, + 422, + 505, + 434 + ], + "score": 1.0, + "content": "final rewards are averaged as the reward for", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 433, + 505, + 445 + ], + "spans": [ + { + "bbox": [ + 106, + 433, + 505, + 445 + ], + "score": 1.0, + "content": "current time step. In practice, we have to complete every prefixes for each training data in a batch,", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 442, + 505, + 456 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 201, + 456 + ], + "score": 1.0, + "content": "and evaluate all of the", + "type": "text" + }, + { + "bbox": [ + 201, + 444, + 228, + 454 + ], + "score": 0.44, + "content": "m T N", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 442, + 298, + 456 + ], + "score": 1.0, + "content": "episodes, where", + "type": "text" + }, + { + "bbox": [ + 298, + 445, + 308, + 454 + ], + "score": 0.74, + "content": "m", + "type": "inline_equation" + }, + { + "bbox": [ + 309, + 442, + 505, + 456 + ], + "score": 1.0, + "content": "is the batch size. This method costs extremely", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 454, + 505, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 454, + 505, + 468 + ], + "score": 1.0, + "content": "high computational resource. For time efficiency, (Li et al., 2017) proposes Reward for Every", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 466, + 505, + 478 + ], + "spans": [ + { + "bbox": [ + 106, + 466, + 505, + 478 + ], + "score": 1.0, + "content": "Generation Step (REGS) to replace Monte Carlo search. Because they train the discriminator in", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 477, + 506, + 489 + ], + "spans": [ + { + "bbox": [ + 106, + 477, + 506, + 489 + ], + "score": 1.0, + "content": "REGS with prefixes without considering whether the episode is terminated, REGS causes a less", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 488, + 199, + 499 + ], + "spans": [ + { + "bbox": [ + 106, + 488, + 199, + 499 + ], + "score": 1.0, + "content": "accurate discriminator.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 25.5 + }, + { + "type": "title", + "bbox": [ + 109, + 510, + 404, + 522 + ], + "lines": [ + { + "bbox": [ + 105, + 509, + 405, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 509, + 405, + 525 + ], + "score": 1.0, + "content": "3.3.2 WASSERSTEIN GAN WITH GRADIENT PENALTY (WGAN-GP)", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 108, + 529, + 504, + 585 + ], + "lines": [ + { + "bbox": [ + 105, + 529, + 505, + 543 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 505, + 543 + ], + "score": 1.0, + "content": "In recent work, WGAP-GP has been successfully used for sequence generation (Gulrajani et al.,", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 540, + 505, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 505, + 554 + ], + "score": 1.0, + "content": "2017; Rajeswar et al., 2017; Press et al., 2017). Instead of using more complicate methods such as", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 552, + 505, + 565 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 505, + 565 + ], + "score": 1.0, + "content": "policy gradient, they directly feed the softmax layer into the discriminator. The generator can there-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 563, + 505, + 576 + ], + "spans": [ + { + "bbox": [ + 105, + 563, + 505, + 576 + ], + "score": 1.0, + "content": "fore be updated through backpropagation. We then formulate the conditional version of WGAN-GP", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 575, + 118, + 586 + ], + "spans": [ + { + "bbox": [ + 105, + 575, + 118, + 586 + ], + "score": 1.0, + "content": "as", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35 + }, + { + "type": "interline_equation", + "bbox": [ + 133, + 587, + 478, + 629 + ], + "lines": [ + { + "bbox": [ + 133, + 587, + 478, + 629 + ], + "spans": [ + { + "bbox": [ + 133, + 587, + 478, + 629 + ], + "score": 0.91, + "content": "\\begin{array} { r l } & { D ^ { * } = \\underset { D } { \\arg \\operatorname* { m a x } } E _ { y \\sim P ^ { R } ( y ) , x ^ { R } \\sim P ^ { R } ( X | y ) } [ D ( x ^ { R } | y ) ] - E _ { y \\sim P ^ { R } ( y ) , x ^ { G } \\sim P ^ { G } ( X | y ) } [ D ( x ^ { G } | y ) ] } \\\\ & { G ^ { * } = \\underset { G } { \\arg \\operatorname* { m a x } } E _ { y \\sim P ^ { R } ( Y ) , x ^ { G } \\sim P ^ { G } ( X | y ) } [ D ( x ^ { G } | y ) ] . } \\end{array}", + "type": "interline_equation", + "image_path": "5d4154666cc02187cd0707df45bdac71f7dc204ae8657411673abc48b460b45d.jpg" + } + ] + } + ], + "index": 39, + "virtual_lines": [ + { + "bbox": [ + 133, + 587, + 478, + 601.0 + ], + "spans": [], + "index": 38 + }, + { + "bbox": [ + 133, + 601.0, + 478, + 615.0 + ], + "spans": [], + "index": 39 + }, + { + "bbox": [ + 133, + 615.0, + 478, + 629.0 + ], + "spans": [], + "index": 40 + } + ] + }, + { + "type": "title", + "bbox": [ + 107, + 640, + 331, + 654 + ], + "lines": [ + { + "bbox": [ + 105, + 640, + 331, + 655 + ], + "spans": [ + { + "bbox": [ + 105, + 640, + 331, + 655 + ], + "score": 1.0, + "content": "4 PROPOSED APPROACH: STEPWISE GAN", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 106, + 665, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 664, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 506, + 678 + ], + "score": 1.0, + "content": "The basic idea of stepwise GAN (see Fig. 1), or StepGAN, is to construct a sequence-to-sequence", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 676, + 506, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 204, + 689 + ], + "score": 1.0, + "content": "model as discriminator", + "type": "text" + }, + { + "bbox": [ + 205, + 677, + 214, + 687 + ], + "score": 0.81, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 214, + 676, + 313, + 689 + ], + "score": 1.0, + "content": ". At each time step of", + "type": "text" + }, + { + "bbox": [ + 313, + 678, + 322, + 687 + ], + "score": 0.81, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 323, + 676, + 506, + 689 + ], + "score": 1.0, + "content": "’s decoder, the hidden vector is passed to a", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 271, + 700 + ], + "score": 1.0, + "content": "fully-connected layer. The discriminator", + "type": "text" + }, + { + "bbox": [ + 272, + 689, + 281, + 698 + ], + "score": 0.82, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 281, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "then outputs the evaluation score for each subsequence", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 107, + 698, + 506, + 713 + ], + "spans": [ + { + "bbox": [ + 107, + 699, + 145, + 710 + ], + "score": 0.83, + "content": "\\langle y , x _ { 1 \\ldots t } \\rangle", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 698, + 197, + 713 + ], + "score": 1.0, + "content": ", denoted as", + "type": "text" + }, + { + "bbox": [ + 197, + 699, + 242, + 711 + ], + "score": 0.91, + "content": "D ( x _ { 1 . . . t } | y )", + "type": "inline_equation" + }, + { + "bbox": [ + 242, + 698, + 329, + 713 + ], + "score": 1.0, + "content": ". With discriminator", + "type": "text" + }, + { + "bbox": [ + 329, + 700, + 338, + 709 + ], + "score": 0.83, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 338, + 698, + 506, + 713 + ], + "score": 1.0, + "content": ", we seek to minimize the summation of", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 107, + 707, + 506, + 725 + ], + "spans": [ + { + "bbox": [ + 107, + 710, + 152, + 722 + ], + "score": 0.87, + "content": "D ( x _ { 1 \\ldots t } ^ { G } | y )", + "type": "inline_equation" + }, + { + "bbox": [ + 152, + 707, + 381, + 725 + ], + "score": 1.0, + "content": "over the time steps when input the generated sequences", + "type": "text" + }, + { + "bbox": [ + 381, + 709, + 395, + 720 + ], + "score": 0.89, + "content": "x ^ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 395, + 707, + 468, + 725 + ], + "score": 1.0, + "content": ". Simultaneously,", + "type": "text" + }, + { + "bbox": [ + 468, + 710, + 478, + 720 + ], + "score": 0.8, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 478, + 707, + 506, + 725 + ], + "score": 1.0, + "content": "maxi-", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 104, + 718, + 507, + 735 + ], + "spans": [ + { + "bbox": [ + 104, + 718, + 204, + 735 + ], + "score": 1.0, + "content": "mizes the summation of", + "type": "text" + }, + { + "bbox": [ + 205, + 720, + 250, + 733 + ], + "score": 0.93, + "content": "D ( x _ { 1 \\ldots t } ^ { \\mathrm { { R } } } | y )", + "type": "inline_equation" + }, + { + "bbox": [ + 250, + 718, + 358, + 735 + ], + "score": 1.0, + "content": "when the input is real data", + "type": "text" + }, + { + "bbox": [ + 359, + 720, + 372, + 730 + ], + "score": 0.89, + "content": "x ^ { R }", + "type": "inline_equation" + }, + { + "bbox": [ + 372, + 718, + 458, + 735 + ], + "score": 1.0, + "content": ". The optimization of", + "type": "text" + }, + { + "bbox": [ + 458, + 721, + 468, + 730 + ], + "score": 0.83, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 468, + 718, + 486, + 735 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 486, + 721, + 495, + 730 + ], + "score": 0.83, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 495, + 718, + 507, + 735 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 44.5 + } + ], + "page_idx": 3, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 310, + 762 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 12, + "width": 8 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 82, + 300, + 93 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 302, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 302, + 95 + ], + "score": 1.0, + "content": "3.3 GENERATIVE ADVERSARIAL NETWORK", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 102, + 505, + 169 + ], + "lines": [ + { + "bbox": [ + 105, + 102, + 505, + 115 + ], + "spans": [ + { + "bbox": [ + 105, + 102, + 505, + 115 + ], + "score": 1.0, + "content": "A generative adversarial network (GAN) is composed of a generator and a discriminator (Goodfel-", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 114, + 505, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 114, + 505, + 127 + ], + "score": 1.0, + "content": "low et al., 2014). The discriminator differentiates between real data and data from the generator,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 125, + 506, + 138 + ], + "spans": [ + { + "bbox": [ + 106, + 125, + 506, + 138 + ], + "score": 1.0, + "content": "and the generator attempts to generate plausible data that will deceive the discriminator. Here we", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 135, + 506, + 149 + ], + "spans": [ + { + "bbox": [ + 105, + 135, + 407, + 149 + ], + "score": 1.0, + "content": "use GAN for conditional sequence generation by considering our model", + "type": "text" + }, + { + "bbox": [ + 408, + 136, + 417, + 146 + ], + "score": 0.79, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 417, + 135, + 506, + 149 + ], + "score": 1.0, + "content": "as the generator and", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 147, + 506, + 160 + ], + "spans": [ + { + "bbox": [ + 106, + 147, + 221, + 160 + ], + "score": 1.0, + "content": "constructing a discriminator", + "type": "text" + }, + { + "bbox": [ + 221, + 147, + 231, + 157 + ], + "score": 0.8, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 231, + 147, + 390, + 160 + ], + "score": 1.0, + "content": "sequentially fed with input-output pairs", + "type": "text" + }, + { + "bbox": [ + 391, + 149, + 398, + 159 + ], + "score": 0.81, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 398, + 147, + 415, + 160 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 415, + 149, + 423, + 157 + ], + "score": 0.74, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 423, + 147, + 506, + 160 + ], + "score": 1.0, + "content": "(Mirza & Osindero,", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 158, + 195, + 169 + ], + "spans": [ + { + "bbox": [ + 106, + 158, + 195, + 169 + ], + "score": 1.0, + "content": "2014; Li et al., 2017).", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 3.5, + "bbox_fs": [ + 105, + 102, + 506, + 169 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 181, + 181, + 193 + ], + "lines": [ + { + "bbox": [ + 105, + 180, + 182, + 195 + ], + "spans": [ + { + "bbox": [ + 105, + 180, + 182, + 195 + ], + "score": 1.0, + "content": "3.3.1 SEQGAN", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 107, + 200, + 506, + 267 + ], + "lines": [ + { + "bbox": [ + 106, + 200, + 505, + 213 + ], + "spans": [ + { + "bbox": [ + 106, + 200, + 194, + 213 + ], + "score": 1.0, + "content": "Since the vocabulary", + "type": "text" + }, + { + "bbox": [ + 194, + 201, + 203, + 210 + ], + "score": 0.74, + "content": "V", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 200, + 505, + 213 + ], + "score": 1.0, + "content": "in the generated sequence is a discrete variable, we cannot backpropagate", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 212, + 505, + 225 + ], + "spans": [ + { + "bbox": [ + 106, + 212, + 249, + 225 + ], + "score": 1.0, + "content": "through the generator. In SeqGAN (", + "type": "text" + }, + { + "bbox": [ + 249, + 212, + 262, + 222 + ], + "score": 0.28, + "content": "\\mathrm { Y u }", + "type": "inline_equation" + }, + { + "bbox": [ + 262, + 212, + 505, + 225 + ], + "score": 1.0, + "content": "et al., 2017; Li et al., 2017), the generation task is formulated", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 222, + 505, + 235 + ], + "spans": [ + { + "bbox": [ + 105, + 222, + 505, + 235 + ], + "score": 1.0, + "content": "as a reinforcement learning scenario, similar to that described in Section 3.2, and the reward function", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 234, + 505, + 245 + ], + "spans": [ + { + "bbox": [ + 106, + 234, + 393, + 245 + ], + "score": 1.0, + "content": "is replaced with the discriminator in regular GAN. The discriminator", + "type": "text" + }, + { + "bbox": [ + 394, + 234, + 403, + 243 + ], + "score": 0.8, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 404, + 234, + 505, + 245 + ], + "score": 1.0, + "content": "is then updated through", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 244, + 506, + 257 + ], + "spans": [ + { + "bbox": [ + 105, + 244, + 261, + 257 + ], + "score": 1.0, + "content": "backpropagation, while the generator", + "type": "text" + }, + { + "bbox": [ + 261, + 245, + 270, + 254 + ], + "score": 0.84, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 244, + 506, + 257 + ], + "score": 1.0, + "content": "is updated using policy gradient with a reward evaluated", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 255, + 371, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 255, + 126, + 267 + ], + "score": 1.0, + "content": "over", + "type": "text" + }, + { + "bbox": [ + 127, + 257, + 133, + 265 + ], + "score": 0.77, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 134, + 255, + 158, + 267 + ], + "score": 1.0, + "content": "given", + "type": "text" + }, + { + "bbox": [ + 159, + 257, + 165, + 267 + ], + "score": 0.8, + "content": "y", + "type": "inline_equation" + }, + { + "bbox": [ + 166, + 255, + 179, + 267 + ], + "score": 1.0, + "content": "by", + "type": "text" + }, + { + "bbox": [ + 180, + 256, + 189, + 265 + ], + "score": 0.81, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 255, + 317, + 267 + ], + "score": 1.0, + "content": ". The optimization functions for", + "type": "text" + }, + { + "bbox": [ + 318, + 256, + 327, + 265 + ], + "score": 0.83, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 328, + 255, + 345, + 267 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 346, + 256, + 355, + 265 + ], + "score": 0.84, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 355, + 255, + 371, + 267 + ], + "score": 1.0, + "content": "are", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 10.5, + "bbox_fs": [ + 105, + 200, + 506, + 267 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 111, + 271, + 513, + 313 + ], + "lines": [ + { + "bbox": [ + 111, + 271, + 513, + 313 + ], + "spans": [ + { + "bbox": [ + 111, + 271, + 513, + 313 + ], + "score": 0.9, + "content": "\\begin{array} { r l } { } & { \\mathcal { D } ^ { * } = \\underset { D } { \\arg \\operatorname* { m a x } } E _ { y \\sim P ^ { R } \\left( Y \\right) , x ^ { R } \\sim \\mathit { P } ^ { R } \\left( X \\mid y \\right) } [ \\log ( D ( x ^ { R } | y ) ) ] + E _ { y \\sim \\mathit { P } ^ { R } \\left( Y \\right) , x ^ { G } \\sim \\mathit { P } ^ { G } \\left( X \\mid y \\right) } [ \\log ( 1 - \\mathit { D } ( x ^ { G } | y ) ) ] } \\\\ { } & { \\mathcal { X } ^ { * } = \\underset { G } { \\arg \\operatorname* { m a x } } E _ { y \\sim \\mathit { P } ^ { R } \\left( Y \\right) , x ^ { G } \\sim \\mathit { P } ^ { G } \\left( X \\mid y \\right) } [ \\mathit { D } ( x ^ { G } | y ) ] . } \\end{array}", + "type": "interline_equation", + "image_path": "ce9e0c11c994a7a44c8e7b2af6bfa8145624990a44cec4006ecf0560ec87f505.jpg" + } + ] + } + ], + "index": 15, + "virtual_lines": [ + { + "bbox": [ + 111, + 271, + 513, + 285.0 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 111, + 285.0, + 513, + 299.0 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 111, + 299.0, + 513, + 313.0 + ], + "spans": [], + "index": 16 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 327, + 505, + 362 + ], + "lines": [ + { + "bbox": [ + 105, + 327, + 505, + 341 + ], + "spans": [ + { + "bbox": [ + 105, + 327, + 198, + 341 + ], + "score": 1.0, + "content": "In the basic SeqGAN,", + "type": "text" + }, + { + "bbox": [ + 199, + 329, + 207, + 338 + ], + "score": 0.82, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 208, + 327, + 505, + 341 + ], + "score": 1.0, + "content": "in Equation (5) is optimized using the REINFORCE algorithm. The for-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 339, + 505, + 351 + ], + "spans": [ + { + "bbox": [ + 106, + 339, + 206, + 351 + ], + "score": 1.0, + "content": "mulation for optimizing", + "type": "text" + }, + { + "bbox": [ + 206, + 339, + 215, + 349 + ], + "score": 0.83, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 216, + 339, + 445, + 351 + ], + "score": 1.0, + "content": "in Equation (5) is the same as Equation (3), except that", + "type": "text" + }, + { + "bbox": [ + 445, + 341, + 457, + 350 + ], + "score": 0.86, + "content": "r _ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 457, + 339, + 505, + 351 + ], + "score": 1.0, + "content": "is replaced", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 348, + 169, + 363 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 127, + 363 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 127, + 349, + 164, + 362 + ], + "score": 0.92, + "content": "D ( x ^ { G } | y )", + "type": "inline_equation" + }, + { + "bbox": [ + 165, + 348, + 169, + 363 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18, + "bbox_fs": [ + 105, + 327, + 505, + 363 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 366, + 505, + 498 + ], + "lines": [ + { + "bbox": [ + 105, + 366, + 505, + 380 + ], + "spans": [ + { + "bbox": [ + 105, + 366, + 505, + 380 + ], + "score": 1.0, + "content": "Due to the sparse reward that only given at the terminal state, this basic setting will cause high", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 376, + 506, + 391 + ], + "spans": [ + { + "bbox": [ + 105, + 376, + 506, + 391 + ], + "score": 1.0, + "content": "training variance. For example, when questioning ”What ’s your name ?”, ”I ’m sorry.” is a wrong", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 388, + 506, + 402 + ], + "spans": [ + { + "bbox": [ + 105, + 388, + 437, + 402 + ], + "score": 1.0, + "content": "answer, while ”I ’m John.” is a correct answer. Although they share the same prefix", + "type": "text" + }, + { + "bbox": [ + 437, + 389, + 464, + 399 + ], + "score": 0.68, + "content": "\\because \\mathrm { m } ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 464, + 388, + 506, + 402 + ], + "score": 1.0, + "content": ", the basic", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 399, + 505, + 412 + ], + "spans": [ + { + "bbox": [ + 106, + 399, + 505, + 412 + ], + "score": 1.0, + "content": "SeqGAN will give the prefix different reward in different sentences. The solution in (Yu et al., 2017;", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 409, + 504, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 409, + 350, + 425 + ], + "score": 1.0, + "content": "Che et al., 2017) is Monte Carlo search. For each prefix", + "type": "text" + }, + { + "bbox": [ + 351, + 412, + 372, + 422 + ], + "score": 0.79, + "content": "x _ { 1 \\ldots t }", + "type": "inline_equation" + }, + { + "bbox": [ + 372, + 409, + 377, + 425 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 378, + 411, + 388, + 421 + ], + "score": 0.67, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 388, + 409, + 470, + 425 + ], + "score": 1.0, + "content": "possible sequences", + "type": "text" + }, + { + "bbox": [ + 470, + 413, + 504, + 423 + ], + "score": 0.89, + "content": "x _ { t + 1 \\ldots T }", + "type": "inline_equation" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 422, + 505, + 434 + ], + "spans": [ + { + "bbox": [ + 106, + 422, + 315, + 434 + ], + "score": 1.0, + "content": "are samples according to the current policy, and the", + "type": "text" + }, + { + "bbox": [ + 316, + 422, + 326, + 432 + ], + "score": 0.76, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 326, + 422, + 505, + 434 + ], + "score": 1.0, + "content": "final rewards are averaged as the reward for", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 433, + 505, + 445 + ], + "spans": [ + { + "bbox": [ + 106, + 433, + 505, + 445 + ], + "score": 1.0, + "content": "current time step. In practice, we have to complete every prefixes for each training data in a batch,", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 442, + 505, + 456 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 201, + 456 + ], + "score": 1.0, + "content": "and evaluate all of the", + "type": "text" + }, + { + "bbox": [ + 201, + 444, + 228, + 454 + ], + "score": 0.44, + "content": "m T N", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 442, + 298, + 456 + ], + "score": 1.0, + "content": "episodes, where", + "type": "text" + }, + { + "bbox": [ + 298, + 445, + 308, + 454 + ], + "score": 0.74, + "content": "m", + "type": "inline_equation" + }, + { + "bbox": [ + 309, + 442, + 505, + 456 + ], + "score": 1.0, + "content": "is the batch size. This method costs extremely", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 454, + 505, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 454, + 505, + 468 + ], + "score": 1.0, + "content": "high computational resource. For time efficiency, (Li et al., 2017) proposes Reward for Every", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 466, + 505, + 478 + ], + "spans": [ + { + "bbox": [ + 106, + 466, + 505, + 478 + ], + "score": 1.0, + "content": "Generation Step (REGS) to replace Monte Carlo search. Because they train the discriminator in", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 477, + 506, + 489 + ], + "spans": [ + { + "bbox": [ + 106, + 477, + 506, + 489 + ], + "score": 1.0, + "content": "REGS with prefixes without considering whether the episode is terminated, REGS causes a less", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 488, + 199, + 499 + ], + "spans": [ + { + "bbox": [ + 106, + 488, + 199, + 499 + ], + "score": 1.0, + "content": "accurate discriminator.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 25.5, + "bbox_fs": [ + 105, + 366, + 506, + 499 + ] + }, + { + "type": "title", + "bbox": [ + 109, + 510, + 404, + 522 + ], + "lines": [ + { + "bbox": [ + 105, + 509, + 405, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 509, + 405, + 525 + ], + "score": 1.0, + "content": "3.3.2 WASSERSTEIN GAN WITH GRADIENT PENALTY (WGAN-GP)", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 108, + 529, + 504, + 585 + ], + "lines": [ + { + "bbox": [ + 105, + 529, + 505, + 543 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 505, + 543 + ], + "score": 1.0, + "content": "In recent work, WGAP-GP has been successfully used for sequence generation (Gulrajani et al.,", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 540, + 505, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 505, + 554 + ], + "score": 1.0, + "content": "2017; Rajeswar et al., 2017; Press et al., 2017). Instead of using more complicate methods such as", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 552, + 505, + 565 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 505, + 565 + ], + "score": 1.0, + "content": "policy gradient, they directly feed the softmax layer into the discriminator. The generator can there-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 563, + 505, + 576 + ], + "spans": [ + { + "bbox": [ + 105, + 563, + 505, + 576 + ], + "score": 1.0, + "content": "fore be updated through backpropagation. We then formulate the conditional version of WGAN-GP", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 575, + 118, + 586 + ], + "spans": [ + { + "bbox": [ + 105, + 575, + 118, + 586 + ], + "score": 1.0, + "content": "as", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35, + "bbox_fs": [ + 105, + 529, + 505, + 586 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 133, + 587, + 478, + 629 + ], + "lines": [ + { + "bbox": [ + 133, + 587, + 478, + 629 + ], + "spans": [ + { + "bbox": [ + 133, + 587, + 478, + 629 + ], + "score": 0.91, + "content": "\\begin{array} { r l } & { D ^ { * } = \\underset { D } { \\arg \\operatorname* { m a x } } E _ { y \\sim P ^ { R } ( y ) , x ^ { R } \\sim P ^ { R } ( X | y ) } [ D ( x ^ { R } | y ) ] - E _ { y \\sim P ^ { R } ( y ) , x ^ { G } \\sim P ^ { G } ( X | y ) } [ D ( x ^ { G } | y ) ] } \\\\ & { G ^ { * } = \\underset { G } { \\arg \\operatorname* { m a x } } E _ { y \\sim P ^ { R } ( Y ) , x ^ { G } \\sim P ^ { G } ( X | y ) } [ D ( x ^ { G } | y ) ] . } \\end{array}", + "type": "interline_equation", + "image_path": "5d4154666cc02187cd0707df45bdac71f7dc204ae8657411673abc48b460b45d.jpg" + } + ] + } + ], + "index": 39, + "virtual_lines": [ + { + "bbox": [ + 133, + 587, + 478, + 601.0 + ], + "spans": [], + "index": 38 + }, + { + "bbox": [ + 133, + 601.0, + 478, + 615.0 + ], + "spans": [], + "index": 39 + }, + { + "bbox": [ + 133, + 615.0, + 478, + 629.0 + ], + "spans": [], + "index": 40 + } + ] + }, + { + "type": "title", + "bbox": [ + 107, + 640, + 331, + 654 + ], + "lines": [ + { + "bbox": [ + 105, + 640, + 331, + 655 + ], + "spans": [ + { + "bbox": [ + 105, + 640, + 331, + 655 + ], + "score": 1.0, + "content": "4 PROPOSED APPROACH: STEPWISE GAN", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 106, + 665, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 664, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 506, + 678 + ], + "score": 1.0, + "content": "The basic idea of stepwise GAN (see Fig. 1), or StepGAN, is to construct a sequence-to-sequence", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 676, + 506, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 204, + 689 + ], + "score": 1.0, + "content": "model as discriminator", + "type": "text" + }, + { + "bbox": [ + 205, + 677, + 214, + 687 + ], + "score": 0.81, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 214, + 676, + 313, + 689 + ], + "score": 1.0, + "content": ". At each time step of", + "type": "text" + }, + { + "bbox": [ + 313, + 678, + 322, + 687 + ], + "score": 0.81, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 323, + 676, + 506, + 689 + ], + "score": 1.0, + "content": "’s decoder, the hidden vector is passed to a", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 271, + 700 + ], + "score": 1.0, + "content": "fully-connected layer. The discriminator", + "type": "text" + }, + { + "bbox": [ + 272, + 689, + 281, + 698 + ], + "score": 0.82, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 281, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "then outputs the evaluation score for each subsequence", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 107, + 698, + 506, + 713 + ], + "spans": [ + { + "bbox": [ + 107, + 699, + 145, + 710 + ], + "score": 0.83, + "content": "\\langle y , x _ { 1 \\ldots t } \\rangle", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 698, + 197, + 713 + ], + "score": 1.0, + "content": ", denoted as", + "type": "text" + }, + { + "bbox": [ + 197, + 699, + 242, + 711 + ], + "score": 0.91, + "content": "D ( x _ { 1 . . . t } | y )", + "type": "inline_equation" + }, + { + "bbox": [ + 242, + 698, + 329, + 713 + ], + "score": 1.0, + "content": ". With discriminator", + "type": "text" + }, + { + "bbox": [ + 329, + 700, + 338, + 709 + ], + "score": 0.83, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 338, + 698, + 506, + 713 + ], + "score": 1.0, + "content": ", we seek to minimize the summation of", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 107, + 707, + 506, + 725 + ], + "spans": [ + { + "bbox": [ + 107, + 710, + 152, + 722 + ], + "score": 0.87, + "content": "D ( x _ { 1 \\ldots t } ^ { G } | y )", + "type": "inline_equation" + }, + { + "bbox": [ + 152, + 707, + 381, + 725 + ], + "score": 1.0, + "content": "over the time steps when input the generated sequences", + "type": "text" + }, + { + "bbox": [ + 381, + 709, + 395, + 720 + ], + "score": 0.89, + "content": "x ^ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 395, + 707, + 468, + 725 + ], + "score": 1.0, + "content": ". Simultaneously,", + "type": "text" + }, + { + "bbox": [ + 468, + 710, + 478, + 720 + ], + "score": 0.8, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 478, + 707, + 506, + 725 + ], + "score": 1.0, + "content": "maxi-", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 104, + 718, + 507, + 735 + ], + "spans": [ + { + "bbox": [ + 104, + 718, + 204, + 735 + ], + "score": 1.0, + "content": "mizes the summation of", + "type": "text" + }, + { + "bbox": [ + 205, + 720, + 250, + 733 + ], + "score": 0.93, + "content": "D ( x _ { 1 \\ldots t } ^ { \\mathrm { { R } } } | y )", + "type": "inline_equation" + }, + { + "bbox": [ + 250, + 718, + 358, + 735 + ], + "score": 1.0, + "content": "when the input is real data", + "type": "text" + }, + { + "bbox": [ + 359, + 720, + 372, + 730 + ], + "score": 0.89, + "content": "x ^ { R }", + "type": "inline_equation" + }, + { + "bbox": [ + 372, + 718, + 458, + 735 + ], + "score": 1.0, + "content": ". The optimization of", + "type": "text" + }, + { + "bbox": [ + 458, + 721, + 468, + 730 + ], + "score": 0.83, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 468, + 718, + 486, + 735 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 486, + 721, + 495, + 730 + ], + "score": 0.83, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 495, + 718, + 507, + 735 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 44.5, + "bbox_fs": [ + 104, + 664, + 507, + 735 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 110, + 84, + 489, + 367 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 110, + 84, + 489, + 367 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 110, + 84, + 489, + 367 + ], + "spans": [ + { + "bbox": [ + 110, + 84, + 489, + 367 + ], + "score": 0.971, + "type": "image", + "image_path": "15cf72773c0dc3be0e77149c6fc0495b5b4749ccc9002f79e1d792498ede3668.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 110, + 84, + 489, + 178.33333333333331 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 110, + 178.33333333333331, + 489, + 272.66666666666663 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 110, + 272.66666666666663, + 489, + 366.99999999999994 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 227, + 379, + 384, + 391 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 226, + 378, + 384, + 393 + ], + "spans": [ + { + "bbox": [ + 226, + 378, + 384, + 393 + ], + "score": 1.0, + "content": "Figure 1: Illustration of stepwise GAN", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "text", + "bbox": [ + 106, + 414, + 126, + 424 + ], + "lines": [ + { + "bbox": [ + 105, + 413, + 126, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 413, + 126, + 425 + ], + "score": 1.0, + "content": "thus", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "interline_equation", + "bbox": [ + 185, + 429, + 426, + 520 + ], + "lines": [ + { + "bbox": [ + 185, + 429, + 426, + 520 + ], + "spans": [ + { + "bbox": [ + 185, + 429, + 426, + 520 + ], + "score": 0.94, + "content": "\\begin{array} { l } { { \\displaystyle D ^ { \\prime } ( x | y ) = \\sum _ { t = 1 } ^ { T } \\alpha _ { t } ^ { D } D \\big ( x _ { 1 \\dots t } | y \\big ) } } \\\\ { { \\displaystyle D ^ { * } = \\arg \\operatorname* { m a x } _ { D } E _ { y \\sim P ^ { R } ( y ) , x ^ { R } \\sim P ^ { R } ( X | y ) } [ \\log ( D ^ { \\prime } ( x ^ { R } | y ) ) ] } } \\\\ { { \\displaystyle \\qquad + E _ { y \\sim P ^ { R } ( y ) , x ^ { G } \\sim P ^ { G } ( X | y ) } [ \\log \\big ( 1 - D ^ { \\prime } ( x ^ { G } | y ) \\big ) ] , } } \\\\ { { \\displaystyle G ^ { * } = \\arg \\operatorname* { m a x } _ { G } E _ { y \\sim P ^ { R } ( Y ) , x ^ { G } \\sim P ^ { G } ( X | y ) } [ D ( x ^ { G } | y ) ] , } } \\end{array}", + "type": "interline_equation", + "image_path": "29aa556b62f5c357fead9cd74064eed16e37e2eea11267141d15e2ead1ca778b.jpg" + } + ] + } + ], + "index": 7.5, + "virtual_lines": [ + { + "bbox": [ + 185, + 429, + 426, + 444.1666666666667 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 185, + 444.1666666666667, + 426, + 459.33333333333337 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 185, + 459.33333333333337, + 426, + 474.50000000000006 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 185, + 474.50000000000006, + 426, + 489.66666666666674 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 185, + 489.66666666666674, + 426, + 504.8333333333334 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 185, + 504.8333333333334, + 426, + 520.0000000000001 + ], + "spans": [], + "index": 10 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 526, + 506, + 574 + ], + "lines": [ + { + "bbox": [ + 100, + 520, + 511, + 552 + ], + "spans": [ + { + "bbox": [ + 100, + 520, + 133, + 552 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 528, + 148, + 541 + ], + "score": 0.91, + "content": "\\alpha _ { t } ^ { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 149, + 520, + 253, + 552 + ], + "score": 1.0, + "content": "is a weighted factor with", + "type": "text" + }, + { + "bbox": [ + 253, + 527, + 313, + 541 + ], + "score": 0.92, + "content": "\\textstyle \\sum _ { t = 1 } ^ { T } \\alpha _ { t } ^ { D } = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 313, + 520, + 395, + 552 + ], + "score": 1.0, + "content": ". In practice, we set", + "type": "text" + }, + { + "bbox": [ + 395, + 528, + 432, + 542 + ], + "score": 0.93, + "content": "\\begin{array} { r } { \\alpha _ { t } ^ { D } = \\frac { 1 } { T } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 432, + 520, + 511, + 552 + ], + "score": 1.0, + "content": ", but it is possible", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 550, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 550, + 379, + 563 + ], + "score": 1.0, + "content": "assign scores for each prefix. Although we only use one way to train", + "type": "text" + }, + { + "bbox": [ + 379, + 552, + 388, + 561 + ], + "score": 0.82, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 389, + 550, + 505, + 563 + ], + "score": 1.0, + "content": ", we think there are two ways", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 561, + 493, + 573 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 168, + 573 + ], + "score": 1.0, + "content": "to interpret the", + "type": "text" + }, + { + "bbox": [ + 168, + 563, + 177, + 571 + ], + "score": 0.84, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 178, + 561, + 480, + 573 + ], + "score": 1.0, + "content": "’s scores, and different view points lead to different update formulations for", + "type": "text" + }, + { + "bbox": [ + 480, + 564, + 488, + 571 + ], + "score": 0.87, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 489, + 561, + 493, + 573 + ], + "score": 1.0, + "content": ":", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 133, + 582, + 504, + 606 + ], + "lines": [ + { + "bbox": [ + 133, + 582, + 504, + 596 + ], + "spans": [ + { + "bbox": [ + 133, + 582, + 142, + 596 + ], + "score": 1.0, + "content": "•", + "type": "text" + }, + { + "bbox": [ + 142, + 583, + 188, + 595 + ], + "score": 0.92, + "content": "D ( x _ { 1 . . . t } | y )", + "type": "inline_equation" + }, + { + "bbox": [ + 188, + 582, + 371, + 596 + ], + "score": 1.0, + "content": "evaluates the extra benefit of adding the word", + "type": "text" + }, + { + "bbox": [ + 371, + 585, + 381, + 594 + ], + "score": 0.84, + "content": "x _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 382, + 582, + 504, + 596 + ], + "score": 1.0, + "content": "into the sequence. The formu-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 594, + 280, + 606 + ], + "spans": [ + { + "bbox": [ + 141, + 594, + 182, + 606 + ], + "score": 1.0, + "content": "lation for", + "type": "text" + }, + { + "bbox": [ + 182, + 596, + 191, + 604 + ], + "score": 0.84, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 191, + 594, + 280, + 606 + ], + "score": 1.0, + "content": "’s parameter update is", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14.5 + }, + { + "type": "interline_equation", + "bbox": [ + 198, + 612, + 449, + 646 + ], + "lines": [ + { + "bbox": [ + 198, + 612, + 449, + 646 + ], + "spans": [ + { + "bbox": [ + 198, + 612, + 449, + 646 + ], + "score": 0.94, + "content": "\\theta _ { G } \\theta _ { G } + \\eta \\alpha _ { t } ^ { G } ( \\sum _ { t ^ { \\prime } = t } ^ { T } D ( x _ { 1 \\dots t ^ { \\prime } } | y ) ) \\nabla \\log ( p _ { G } ( x _ { t } ^ { G } | y , x _ { 1 \\dots t - 1 } ^ { G } ) ) .", + "type": "interline_equation", + "image_path": "5726e8a8a466f9279639e08091d448724a752320368f1f5bfbd3bb16c39a92ea.jpg" + } + ] + } + ], + "index": 17, + "virtual_lines": [ + { + "bbox": [ + 198, + 612, + 449, + 623.3333333333334 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 198, + 623.3333333333334, + 449, + 634.6666666666667 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 198, + 634.6666666666667, + 449, + 646.0000000000001 + ], + "spans": [], + "index": 18 + } + ] + }, + { + "type": "text", + "bbox": [ + 140, + 653, + 465, + 668 + ], + "lines": [ + { + "bbox": [ + 142, + 648, + 468, + 672 + ], + "spans": [ + { + "bbox": [ + 142, + 656, + 151, + 665 + ], + "score": 0.8, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 151, + 648, + 275, + 672 + ], + "score": 1.0, + "content": "has to increase the summation", + "type": "text" + }, + { + "bbox": [ + 276, + 653, + 351, + 668 + ], + "score": 0.93, + "content": "\\scriptstyle \\sum _ { t ^ { \\prime } = t } ^ { T } D ( x _ { 1 \\dots t ^ { \\prime } } | y )", + "type": "inline_equation" + }, + { + "bbox": [ + 352, + 648, + 468, + 672 + ], + "score": 1.0, + "content": ". We call this stepGAN-Seq.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 133, + 670, + 507, + 694 + ], + "lines": [ + { + "bbox": [ + 132, + 669, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 132, + 669, + 142, + 684 + ], + "score": 1.0, + "content": "•", + "type": "text" + }, + { + "bbox": [ + 142, + 671, + 188, + 683 + ], + "score": 0.91, + "content": "D ( x _ { 1 . . . t } | y )", + "type": "inline_equation" + }, + { + "bbox": [ + 188, + 669, + 460, + 684 + ], + "score": 1.0, + "content": "evaluates the average goodness of all the sequences beginning with", + "type": "text" + }, + { + "bbox": [ + 461, + 672, + 482, + 682 + ], + "score": 0.86, + "content": "x _ { 1 \\ldots t }", + "type": "inline_equation" + }, + { + "bbox": [ + 482, + 669, + 505, + 684 + ], + "score": 1.0, + "content": ". The", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 142, + 681, + 258, + 694 + ], + "spans": [ + { + "bbox": [ + 142, + 681, + 235, + 694 + ], + "score": 1.0, + "content": "update formulation for", + "type": "text" + }, + { + "bbox": [ + 236, + 683, + 247, + 693 + ], + "score": 0.89, + "content": "\\theta _ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 681, + 258, + 694 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20.5 + }, + { + "type": "interline_equation", + "bbox": [ + 212, + 699, + 435, + 714 + ], + "lines": [ + { + "bbox": [ + 212, + 699, + 435, + 714 + ], + "spans": [ + { + "bbox": [ + 212, + 699, + 435, + 714 + ], + "score": 0.88, + "content": "\\theta _ { G } \\gets \\theta _ { G } + \\eta \\alpha _ { t } ^ { G } D ( x _ { 1 \\dots t } | y ) \\nabla \\log ( p _ { G } ( x _ { t } ^ { G } | y , x _ { 1 \\dots t - 1 } ^ { G } ) ) .", + "type": "interline_equation", + "image_path": "015ceee31cdf7858cebe3f34d6057ef0b76e5c713ef2f6f947c9fa63931d5c66.jpg" + } + ] + } + ], + "index": 22, + "virtual_lines": [ + { + "bbox": [ + 212, + 699, + 435, + 714 + ], + "spans": [], + "index": 22 + } + ] + }, + { + "type": "text", + "bbox": [ + 144, + 720, + 486, + 733 + ], + "lines": [ + { + "bbox": [ + 141, + 718, + 488, + 735 + ], + "spans": [ + { + "bbox": [ + 141, + 718, + 160, + 735 + ], + "score": 1.0, + "content": "The", + "type": "text" + }, + { + "bbox": [ + 160, + 721, + 169, + 730 + ], + "score": 0.82, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 170, + 718, + 294, + 735 + ], + "score": 1.0, + "content": "only needs to learn to increase", + "type": "text" + }, + { + "bbox": [ + 294, + 721, + 339, + 733 + ], + "score": 0.93, + "content": "D ( x _ { 1 \\ldots t } | y )", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 718, + 488, + 735 + ], + "score": 1.0, + "content": ". We call this stepGAN in following.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 23 + } + ], + "page_idx": 4, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "score": 1.0, + "content": "5", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 110, + 84, + 489, + 367 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 110, + 84, + 489, + 367 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 110, + 84, + 489, + 367 + ], + "spans": [ + { + "bbox": [ + 110, + 84, + 489, + 367 + ], + "score": 0.971, + "type": "image", + "image_path": "15cf72773c0dc3be0e77149c6fc0495b5b4749ccc9002f79e1d792498ede3668.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 110, + 84, + 489, + 178.33333333333331 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 110, + 178.33333333333331, + 489, + 272.66666666666663 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 110, + 272.66666666666663, + 489, + 366.99999999999994 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 227, + 379, + 384, + 391 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 226, + 378, + 384, + 393 + ], + "spans": [ + { + "bbox": [ + 226, + 378, + 384, + 393 + ], + "score": 1.0, + "content": "Figure 1: Illustration of stepwise GAN", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "text", + "bbox": [ + 106, + 414, + 126, + 424 + ], + "lines": [ + { + "bbox": [ + 105, + 413, + 126, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 413, + 126, + 425 + ], + "score": 1.0, + "content": "thus", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4, + "bbox_fs": [ + 105, + 413, + 126, + 425 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 185, + 429, + 426, + 520 + ], + "lines": [ + { + "bbox": [ + 185, + 429, + 426, + 520 + ], + "spans": [ + { + "bbox": [ + 185, + 429, + 426, + 520 + ], + "score": 0.94, + "content": "\\begin{array} { l } { { \\displaystyle D ^ { \\prime } ( x | y ) = \\sum _ { t = 1 } ^ { T } \\alpha _ { t } ^ { D } D \\big ( x _ { 1 \\dots t } | y \\big ) } } \\\\ { { \\displaystyle D ^ { * } = \\arg \\operatorname* { m a x } _ { D } E _ { y \\sim P ^ { R } ( y ) , x ^ { R } \\sim P ^ { R } ( X | y ) } [ \\log ( D ^ { \\prime } ( x ^ { R } | y ) ) ] } } \\\\ { { \\displaystyle \\qquad + E _ { y \\sim P ^ { R } ( y ) , x ^ { G } \\sim P ^ { G } ( X | y ) } [ \\log \\big ( 1 - D ^ { \\prime } ( x ^ { G } | y ) \\big ) ] , } } \\\\ { { \\displaystyle G ^ { * } = \\arg \\operatorname* { m a x } _ { G } E _ { y \\sim P ^ { R } ( Y ) , x ^ { G } \\sim P ^ { G } ( X | y ) } [ D ( x ^ { G } | y ) ] , } } \\end{array}", + "type": "interline_equation", + "image_path": "29aa556b62f5c357fead9cd74064eed16e37e2eea11267141d15e2ead1ca778b.jpg" + } + ] + } + ], + "index": 7.5, + "virtual_lines": [ + { + "bbox": [ + 185, + 429, + 426, + 444.1666666666667 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 185, + 444.1666666666667, + 426, + 459.33333333333337 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 185, + 459.33333333333337, + 426, + 474.50000000000006 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 185, + 474.50000000000006, + 426, + 489.66666666666674 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 185, + 489.66666666666674, + 426, + 504.8333333333334 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 185, + 504.8333333333334, + 426, + 520.0000000000001 + ], + "spans": [], + "index": 10 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 526, + 506, + 574 + ], + "lines": [ + { + "bbox": [ + 100, + 520, + 511, + 552 + ], + "spans": [ + { + "bbox": [ + 100, + 520, + 133, + 552 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 528, + 148, + 541 + ], + "score": 0.91, + "content": "\\alpha _ { t } ^ { D }", + "type": "inline_equation" + }, + { + "bbox": [ + 149, + 520, + 253, + 552 + ], + "score": 1.0, + "content": "is a weighted factor with", + "type": "text" + }, + { + "bbox": [ + 253, + 527, + 313, + 541 + ], + "score": 0.92, + "content": "\\textstyle \\sum _ { t = 1 } ^ { T } \\alpha _ { t } ^ { D } = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 313, + 520, + 395, + 552 + ], + "score": 1.0, + "content": ". In practice, we set", + "type": "text" + }, + { + "bbox": [ + 395, + 528, + 432, + 542 + ], + "score": 0.93, + "content": "\\begin{array} { r } { \\alpha _ { t } ^ { D } = \\frac { 1 } { T } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 432, + 520, + 511, + 552 + ], + "score": 1.0, + "content": ", but it is possible", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 550, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 550, + 379, + 563 + ], + "score": 1.0, + "content": "assign scores for each prefix. Although we only use one way to train", + "type": "text" + }, + { + "bbox": [ + 379, + 552, + 388, + 561 + ], + "score": 0.82, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 389, + 550, + 505, + 563 + ], + "score": 1.0, + "content": ", we think there are two ways", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 561, + 493, + 573 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 168, + 573 + ], + "score": 1.0, + "content": "to interpret the", + "type": "text" + }, + { + "bbox": [ + 168, + 563, + 177, + 571 + ], + "score": 0.84, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 178, + 561, + 480, + 573 + ], + "score": 1.0, + "content": "’s scores, and different view points lead to different update formulations for", + "type": "text" + }, + { + "bbox": [ + 480, + 564, + 488, + 571 + ], + "score": 0.87, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 489, + 561, + 493, + 573 + ], + "score": 1.0, + "content": ":", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12, + "bbox_fs": [ + 100, + 520, + 511, + 573 + ] + }, + { + "type": "text", + "bbox": [ + 133, + 582, + 504, + 606 + ], + "lines": [ + { + "bbox": [ + 133, + 582, + 504, + 596 + ], + "spans": [ + { + "bbox": [ + 133, + 582, + 142, + 596 + ], + "score": 1.0, + "content": "•", + "type": "text" + }, + { + "bbox": [ + 142, + 583, + 188, + 595 + ], + "score": 0.92, + "content": "D ( x _ { 1 . . . t } | y )", + "type": "inline_equation" + }, + { + "bbox": [ + 188, + 582, + 371, + 596 + ], + "score": 1.0, + "content": "evaluates the extra benefit of adding the word", + "type": "text" + }, + { + "bbox": [ + 371, + 585, + 381, + 594 + ], + "score": 0.84, + "content": "x _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 382, + 582, + 504, + 596 + ], + "score": 1.0, + "content": "into the sequence. The formu-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 594, + 280, + 606 + ], + "spans": [ + { + "bbox": [ + 141, + 594, + 182, + 606 + ], + "score": 1.0, + "content": "lation for", + "type": "text" + }, + { + "bbox": [ + 182, + 596, + 191, + 604 + ], + "score": 0.84, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 191, + 594, + 280, + 606 + ], + "score": 1.0, + "content": "’s parameter update is", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 14.5, + "bbox_fs": [ + 133, + 582, + 504, + 606 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 198, + 612, + 449, + 646 + ], + "lines": [ + { + "bbox": [ + 198, + 612, + 449, + 646 + ], + "spans": [ + { + "bbox": [ + 198, + 612, + 449, + 646 + ], + "score": 0.94, + "content": "\\theta _ { G } \\theta _ { G } + \\eta \\alpha _ { t } ^ { G } ( \\sum _ { t ^ { \\prime } = t } ^ { T } D ( x _ { 1 \\dots t ^ { \\prime } } | y ) ) \\nabla \\log ( p _ { G } ( x _ { t } ^ { G } | y , x _ { 1 \\dots t - 1 } ^ { G } ) ) .", + "type": "interline_equation", + "image_path": "5726e8a8a466f9279639e08091d448724a752320368f1f5bfbd3bb16c39a92ea.jpg" + } + ] + } + ], + "index": 17, + "virtual_lines": [ + { + "bbox": [ + 198, + 612, + 449, + 623.3333333333334 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 198, + 623.3333333333334, + 449, + 634.6666666666667 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 198, + 634.6666666666667, + 449, + 646.0000000000001 + ], + "spans": [], + "index": 18 + } + ] + }, + { + "type": "text", + "bbox": [ + 140, + 653, + 465, + 668 + ], + "lines": [ + { + "bbox": [ + 142, + 648, + 468, + 672 + ], + "spans": [ + { + "bbox": [ + 142, + 656, + 151, + 665 + ], + "score": 0.8, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 151, + 648, + 275, + 672 + ], + "score": 1.0, + "content": "has to increase the summation", + "type": "text" + }, + { + "bbox": [ + 276, + 653, + 351, + 668 + ], + "score": 0.93, + "content": "\\scriptstyle \\sum _ { t ^ { \\prime } = t } ^ { T } D ( x _ { 1 \\dots t ^ { \\prime } } | y )", + "type": "inline_equation" + }, + { + "bbox": [ + 352, + 648, + 468, + 672 + ], + "score": 1.0, + "content": ". We call this stepGAN-Seq.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19, + "bbox_fs": [ + 142, + 648, + 468, + 672 + ] + }, + { + "type": "text", + "bbox": [ + 133, + 670, + 507, + 694 + ], + "lines": [ + { + "bbox": [ + 132, + 669, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 132, + 669, + 142, + 684 + ], + "score": 1.0, + "content": "•", + "type": "text" + }, + { + "bbox": [ + 142, + 671, + 188, + 683 + ], + "score": 0.91, + "content": "D ( x _ { 1 . . . t } | y )", + "type": "inline_equation" + }, + { + "bbox": [ + 188, + 669, + 460, + 684 + ], + "score": 1.0, + "content": "evaluates the average goodness of all the sequences beginning with", + "type": "text" + }, + { + "bbox": [ + 461, + 672, + 482, + 682 + ], + "score": 0.86, + "content": "x _ { 1 \\ldots t }", + "type": "inline_equation" + }, + { + "bbox": [ + 482, + 669, + 505, + 684 + ], + "score": 1.0, + "content": ". The", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 142, + 681, + 258, + 694 + ], + "spans": [ + { + "bbox": [ + 142, + 681, + 235, + 694 + ], + "score": 1.0, + "content": "update formulation for", + "type": "text" + }, + { + "bbox": [ + 236, + 683, + 247, + 693 + ], + "score": 0.89, + "content": "\\theta _ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 681, + 258, + 694 + ], + "score": 1.0, + "content": "is", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20.5, + "bbox_fs": [ + 132, + 669, + 505, + 694 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 212, + 699, + 435, + 714 + ], + "lines": [ + { + "bbox": [ + 212, + 699, + 435, + 714 + ], + "spans": [ + { + "bbox": [ + 212, + 699, + 435, + 714 + ], + "score": 0.88, + "content": "\\theta _ { G } \\gets \\theta _ { G } + \\eta \\alpha _ { t } ^ { G } D ( x _ { 1 \\dots t } | y ) \\nabla \\log ( p _ { G } ( x _ { t } ^ { G } | y , x _ { 1 \\dots t - 1 } ^ { G } ) ) .", + "type": "interline_equation", + "image_path": "015ceee31cdf7858cebe3f34d6057ef0b76e5c713ef2f6f947c9fa63931d5c66.jpg" + } + ] + } + ], + "index": 22, + "virtual_lines": [ + { + "bbox": [ + 212, + 699, + 435, + 714 + ], + "spans": [], + "index": 22 + } + ] + }, + { + "type": "text", + "bbox": [ + 144, + 720, + 486, + 733 + ], + "lines": [ + { + "bbox": [ + 141, + 718, + 488, + 735 + ], + "spans": [ + { + "bbox": [ + 141, + 718, + 160, + 735 + ], + "score": 1.0, + "content": "The", + "type": "text" + }, + { + "bbox": [ + 160, + 721, + 169, + 730 + ], + "score": 0.82, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 170, + 718, + 294, + 735 + ], + "score": 1.0, + "content": "only needs to learn to increase", + "type": "text" + }, + { + "bbox": [ + 294, + 721, + 339, + 733 + ], + "score": 0.93, + "content": "D ( x _ { 1 \\ldots t } | y )", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 718, + 488, + 735 + ], + "score": 1.0, + "content": ". We call this stepGAN in following.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 23, + "bbox_fs": [ + 141, + 718, + 488, + 735 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 82, + 503, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 80, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 80, + 159, + 96 + ], + "score": 1.0, + "content": "Using factor", + "type": "text" + }, + { + "bbox": [ + 159, + 82, + 173, + 95 + ], + "score": 0.91, + "content": "\\alpha _ { t } ^ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 174, + 80, + 505, + 96 + ], + "score": 1.0, + "content": ", we diversify training by arbitrarily weighting the importance of each time step1.", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 92, + 506, + 107 + ], + "spans": [ + { + "bbox": [ + 105, + 92, + 303, + 107 + ], + "score": 1.0, + "content": "We explore the influence of different values of", + "type": "text" + }, + { + "bbox": [ + 303, + 92, + 317, + 105 + ], + "score": 0.9, + "content": "\\alpha _ { t } ^ { \\check { G } }", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 92, + 506, + 107 + ], + "score": 1.0, + "content": "and compare the two update formulations in", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 104, + 213, + 116 + ], + "spans": [ + { + "bbox": [ + 106, + 104, + 213, + 116 + ], + "score": 1.0, + "content": "section 5 and appendix B.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 107, + 120, + 505, + 156 + ], + "lines": [ + { + "bbox": [ + 105, + 120, + 505, + 134 + ], + "spans": [ + { + "bbox": [ + 105, + 120, + 360, + 134 + ], + "score": 1.0, + "content": "StepGAN-Seq is a generalized version of SeqGAN. If we set", + "type": "text" + }, + { + "bbox": [ + 361, + 120, + 396, + 134 + ], + "score": 0.9, + "content": "\\alpha _ { T } ^ { D } = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 120, + 401, + 134 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 401, + 120, + 438, + 133 + ], + "score": 0.9, + "content": "\\alpha _ { t } ^ { D } = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 438, + 120, + 454, + 134 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 455, + 122, + 483, + 132 + ], + "score": 0.89, + "content": "t < T", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 120, + 505, + 134 + ], + "score": 1.0, + "content": ", and", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 107, + 129, + 507, + 149 + ], + "spans": [ + { + "bbox": [ + 107, + 133, + 141, + 145 + ], + "score": 0.92, + "content": "\\alpha _ { t } ^ { G } = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 129, + 169, + 149 + ], + "score": 1.0, + "content": "for all", + "type": "text" + }, + { + "bbox": [ + 170, + 135, + 174, + 144 + ], + "score": 0.7, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 175, + 129, + 507, + 149 + ], + "score": 1.0, + "content": ", then stepGAN-Seq is equivalent to SeqGAN without Monte Carlo search. Also,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 143, + 451, + 158 + ], + "spans": [ + { + "bbox": [ + 105, + 143, + 288, + 158 + ], + "score": 1.0, + "content": "REGS (Li et al., 2017) can be induced by set", + "type": "text" + }, + { + "bbox": [ + 288, + 144, + 321, + 156 + ], + "score": 0.92, + "content": "\\alpha _ { t } ^ { D } = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 321, + 143, + 451, + 158 + ], + "score": 1.0, + "content": "at a randomly chosen time step.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 107, + 161, + 505, + 227 + ], + "lines": [ + { + "bbox": [ + 106, + 162, + 505, + 173 + ], + "spans": [ + { + "bbox": [ + 106, + 162, + 505, + 173 + ], + "score": 1.0, + "content": "StepGAN is similar to the actor-critic architecture in (Bahdanau et al., 2016). Instead of the assigned", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 173, + 505, + 184 + ], + "spans": [ + { + "bbox": [ + 106, + 173, + 392, + 184 + ], + "score": 1.0, + "content": "task-specific score, we learn the score by adversarial learning. Because", + "type": "text" + }, + { + "bbox": [ + 393, + 173, + 403, + 183 + ], + "score": 0.77, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 403, + 173, + 505, + 184 + ], + "score": 1.0, + "content": "’s scores are the expected", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 104, + 181, + 505, + 197 + ], + "spans": [ + { + "bbox": [ + 104, + 181, + 505, + 197 + ], + "score": 1.0, + "content": "return in this setting, we would like StepGAN to approximate the expected return obtained by Seq-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 193, + 505, + 207 + ], + "spans": [ + { + "bbox": [ + 105, + 193, + 505, + 207 + ], + "score": 1.0, + "content": "GAN or MaliGAN with Monte Carlo search. This approach only need to add a set of weight factors,", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 205, + 505, + 218 + ], + "spans": [ + { + "bbox": [ + 105, + 205, + 505, + 218 + ], + "score": 1.0, + "content": "and therefore much time efficient than Monte Carlo search. For more details of the algorithm, please", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 217, + 256, + 228 + ], + "spans": [ + { + "bbox": [ + 106, + 217, + 256, + 228 + ], + "score": 1.0, + "content": "refer to appendix A for pseudo-code.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 8.5 + }, + { + "type": "title", + "bbox": [ + 108, + 246, + 200, + 259 + ], + "lines": [ + { + "bbox": [ + 105, + 245, + 201, + 261 + ], + "spans": [ + { + "bbox": [ + 105, + 245, + 201, + 261 + ], + "score": 1.0, + "content": "5 EXPERIMENTS", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 107, + 273, + 505, + 317 + ], + "lines": [ + { + "bbox": [ + 105, + 273, + 505, + 286 + ], + "spans": [ + { + "bbox": [ + 105, + 273, + 505, + 286 + ], + "score": 1.0, + "content": "We use a recurrent neural network for both the discriminator and generator due to its strong sequen-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 285, + 505, + 297 + ], + "spans": [ + { + "bbox": [ + 106, + 285, + 505, + 297 + ], + "score": 1.0, + "content": "tial correlation (Press et al., 2017; Rajeswar et al., 2017). Specifically, we use gated recurrent units", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 295, + 505, + 308 + ], + "spans": [ + { + "bbox": [ + 105, + 295, + 505, + 308 + ], + "score": 1.0, + "content": "(GRUs) (Chung et al., 2014) in our experiments. We view the noise feature in GAN as the random", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 306, + 333, + 318 + ], + "spans": [ + { + "bbox": [ + 105, + 306, + 333, + 318 + ], + "score": 1.0, + "content": "process of sampling from the softmax layer distribution.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 14.5 + }, + { + "type": "title", + "bbox": [ + 108, + 334, + 236, + 345 + ], + "lines": [ + { + "bbox": [ + 106, + 334, + 236, + 346 + ], + "spans": [ + { + "bbox": [ + 106, + 334, + 236, + 346 + ], + "score": 1.0, + "content": "5.1 ARTIFICIAL GRAMMARS", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 356, + 505, + 498 + ], + "lines": [ + { + "bbox": [ + 106, + 355, + 505, + 368 + ], + "spans": [ + { + "bbox": [ + 106, + 355, + 505, + 368 + ], + "score": 1.0, + "content": "To better evaluate GANs for conditional sequence generation, we define three artificial grammars:", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 366, + 505, + 380 + ], + "spans": [ + { + "bbox": [ + 105, + 366, + 505, + 380 + ], + "score": 1.0, + "content": "sequence, counting, and addition. The three grammars are described in Table 1. For the sequence", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 377, + 505, + 391 + ], + "spans": [ + { + "bbox": [ + 105, + 377, + 474, + 391 + ], + "score": 1.0, + "content": "grammar, the aim is to generate a continued consecutive number sequence behind the input", + "type": "text" + }, + { + "bbox": [ + 475, + 378, + 484, + 388 + ], + "score": 0.72, + "content": "Y", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 377, + 505, + 391 + ], + "score": 1.0, + "content": ". For", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 388, + 504, + 401 + ], + "spans": [ + { + "bbox": [ + 105, + 388, + 186, + 401 + ], + "score": 1.0, + "content": "example, for input", + "type": "text" + }, + { + "bbox": [ + 187, + 389, + 219, + 400 + ], + "score": 0.93, + "content": "\\langle 1 , 2 , 3 \\rangle", + "type": "inline_equation" + }, + { + "bbox": [ + 219, + 388, + 504, + 401 + ], + "score": 1.0, + "content": ", the answer would be a consecutive number sequence of any length", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 399, + 505, + 412 + ], + "spans": [ + { + "bbox": [ + 105, + 399, + 204, + 412 + ], + "score": 1.0, + "content": "starting with 4, such as", + "type": "text" + }, + { + "bbox": [ + 204, + 400, + 254, + 412 + ], + "score": 0.89, + "content": "\\langle 4 , 5 , 6 , 7 , 8 \\rangle", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 399, + 505, + 412 + ], + "score": 1.0, + "content": ". The counting grammar is more complicated. The generated", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 410, + 505, + 423 + ], + "spans": [ + { + "bbox": [ + 105, + 410, + 505, + 423 + ], + "score": 1.0, + "content": "sequence should contain exactly 3 words, where the median is a randomly selected word from the", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 421, + 505, + 434 + ], + "spans": [ + { + "bbox": [ + 105, + 421, + 505, + 434 + ], + "score": 1.0, + "content": "input sequence. The first generated word should be the number of words on the left-hand side of the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 433, + 504, + 444 + ], + "spans": [ + { + "bbox": [ + 106, + 433, + 504, + 444 + ], + "score": 1.0, + "content": "selected median, while the last generated word should be the number of words on the right-hand side.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 442, + 505, + 458 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 231, + 458 + ], + "score": 1.0, + "content": "For example, when the input is", + "type": "text" + }, + { + "bbox": [ + 232, + 443, + 311, + 455 + ], + "score": 0.9, + "content": "\\langle 5 , 9 , 2 , 8 , 3 , 2 , 9 , 1 \\rangle", + "type": "inline_equation" + }, + { + "bbox": [ + 311, + 442, + 469, + 458 + ], + "score": 1.0, + "content": ", one permissible generated sequence is", + "type": "text" + }, + { + "bbox": [ + 469, + 443, + 501, + 456 + ], + "score": 0.93, + "content": "\\langle 0 , 5 , 7 \\rangle", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 442, + 505, + 458 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 453, + 505, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 505, + 468 + ], + "score": 1.0, + "content": "Last, for the addition grammar we generate the addition of two numbers randomly segmented from", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 465, + 505, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 465, + 255, + 477 + ], + "score": 1.0, + "content": "the input sequence. That is, for input", + "type": "text" + }, + { + "bbox": [ + 255, + 465, + 296, + 477 + ], + "score": 0.91, + "content": "\\langle 8 , 1 , 3 , 4 \\rangle", + "type": "inline_equation" + }, + { + "bbox": [ + 296, + 465, + 505, + 477 + ], + "score": 1.0, + "content": ", then one permissible output is the addition of 8 and", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 475, + 506, + 489 + ], + "spans": [ + { + "bbox": [ + 105, + 475, + 152, + 489 + ], + "score": 1.0, + "content": "134 – thus", + "type": "text" + }, + { + "bbox": [ + 152, + 476, + 184, + 488 + ], + "score": 0.92, + "content": "\\langle 1 , 4 , 2 \\rangle", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 475, + 506, + 489 + ], + "score": 1.0, + "content": ". Note that both the input and output numbers for this grammar are represented", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 487, + 260, + 500 + ], + "spans": [ + { + "bbox": [ + 105, + 487, + 260, + 500 + ], + "score": 1.0, + "content": "in terms of their corresponding digits.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 106, + 504, + 505, + 614 + ], + "lines": [ + { + "bbox": [ + 106, + 504, + 505, + 516 + ], + "spans": [ + { + "bbox": [ + 106, + 504, + 505, + 516 + ], + "score": 1.0, + "content": "The purpose of these design is to imitate major properties in dialogue generation, such as variable-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 515, + 505, + 528 + ], + "spans": [ + { + "bbox": [ + 105, + 515, + 505, + 528 + ], + "score": 1.0, + "content": "length, repeated prefixes, the same sequence space, one-to-many, and many-to-one. The variable-", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 526, + 505, + 539 + ], + "spans": [ + { + "bbox": [ + 105, + 526, + 505, + 539 + ], + "score": 1.0, + "content": "length property means there is no fixed length for the input and output sequences. The repeated", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 538, + 505, + 549 + ], + "spans": [ + { + "bbox": [ + 106, + 538, + 505, + 549 + ], + "score": 1.0, + "content": "prefixes property means the beginning subsequences are usually shared by many data, for instance", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 547, + 506, + 561 + ], + "spans": [ + { + "bbox": [ + 105, + 547, + 506, + 561 + ], + "score": 1.0, + "content": "What and I am in natural language. The same sequence space here means that the input and output", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 559, + 506, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 559, + 506, + 572 + ], + "score": 1.0, + "content": "have the same structure and as such are sampled from the same space. Finally, one-to-many and", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 570, + 505, + 582 + ], + "spans": [ + { + "bbox": [ + 105, + 570, + 505, + 582 + ], + "score": 1.0, + "content": "many-to-one are quite common in dialogue generation. For example, when asking How are you?,", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 581, + 505, + 593 + ], + "spans": [ + { + "bbox": [ + 105, + 581, + 505, + 593 + ], + "score": 1.0, + "content": "responses vary from I’m fine to Great! How are you?. Also, the same response can be paired with", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 592, + 506, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 592, + 506, + 605 + ], + "score": 1.0, + "content": "multiple questions, such as for My name is Paul in response to What’s your name? and Who are", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 103, + 603, + 132, + 615 + ], + "spans": [ + { + "bbox": [ + 103, + 603, + 132, + 615 + ], + "score": 1.0, + "content": "you?.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 35.5 + }, + { + "type": "text", + "bbox": [ + 107, + 619, + 504, + 708 + ], + "lines": [ + { + "bbox": [ + 106, + 620, + 506, + 632 + ], + "spans": [ + { + "bbox": [ + 106, + 620, + 506, + 632 + ], + "score": 1.0, + "content": "We then randomly generate 100,000 samples as training data, 10,000 as development data, and", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 631, + 506, + 643 + ], + "spans": [ + { + "bbox": [ + 106, + 631, + 506, + 643 + ], + "score": 1.0, + "content": "10,000 samples as testing data. The architectures are set to one layer with 128 hidden units. We", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 641, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 641, + 505, + 654 + ], + "score": 1.0, + "content": "evaluate our results using the three measures in Table 2. The first is the accuracy of samples gen-", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 653, + 505, + 665 + ], + "spans": [ + { + "bbox": [ + 105, + 653, + 505, + 665 + ], + "score": 1.0, + "content": "erated from the argmax policy (Acc), the second is that generated from the softmax probability", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 663, + 506, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 506, + 677 + ], + "score": 1.0, + "content": "(AccS), and the last is the coverage of softmax samples over all the permissible answers of the spe-", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 674, + 505, + 687 + ], + "spans": [ + { + "bbox": [ + 105, + 674, + 505, + 687 + ], + "score": 1.0, + "content": "cific grammar (Cov). We report them to ensure whether the one-to-many property is being learned.", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 685, + 505, + 698 + ], + "spans": [ + { + "bbox": [ + 105, + 685, + 505, + 698 + ], + "score": 1.0, + "content": "AccS and Cov are important because they can indicate if the model can learn the underlying dis-", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 697, + 505, + 709 + ], + "spans": [ + { + "bbox": [ + 105, + 697, + 505, + 709 + ], + "score": 1.0, + "content": "tribution of answers. When mode collapse happens, which means the model only know a specific", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 44.5 + } + ], + "page_idx": 5, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 120, + 721, + 249, + 732 + ], + "lines": [ + { + "bbox": [ + 123, + 718, + 246, + 735 + ], + "spans": [ + { + "bbox": [ + 123, + 720, + 136, + 732 + ], + "score": 0.74, + "content": "\\alpha _ { t } ^ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 136, + 718, + 232, + 735 + ], + "score": 1.0, + "content": "needs not be equivalent to", + "type": "text" + }, + { + "bbox": [ + 233, + 722, + 246, + 732 + ], + "score": 0.91, + "content": "\\alpha _ { t } ^ { D }", + "type": "inline_equation" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "score": 1.0, + "content": "6", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 82, + 503, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 80, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 80, + 159, + 96 + ], + "score": 1.0, + "content": "Using factor", + "type": "text" + }, + { + "bbox": [ + 159, + 82, + 173, + 95 + ], + "score": 0.91, + "content": "\\alpha _ { t } ^ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 174, + 80, + 505, + 96 + ], + "score": 1.0, + "content": ", we diversify training by arbitrarily weighting the importance of each time step1.", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 92, + 506, + 107 + ], + "spans": [ + { + "bbox": [ + 105, + 92, + 303, + 107 + ], + "score": 1.0, + "content": "We explore the influence of different values of", + "type": "text" + }, + { + "bbox": [ + 303, + 92, + 317, + 105 + ], + "score": 0.9, + "content": "\\alpha _ { t } ^ { \\check { G } }", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 92, + 506, + 107 + ], + "score": 1.0, + "content": "and compare the two update formulations in", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 104, + 213, + 116 + ], + "spans": [ + { + "bbox": [ + 106, + 104, + 213, + 116 + ], + "score": 1.0, + "content": "section 5 and appendix B.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1, + "bbox_fs": [ + 105, + 80, + 506, + 116 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 120, + 505, + 156 + ], + "lines": [ + { + "bbox": [ + 105, + 120, + 505, + 134 + ], + "spans": [ + { + "bbox": [ + 105, + 120, + 360, + 134 + ], + "score": 1.0, + "content": "StepGAN-Seq is a generalized version of SeqGAN. If we set", + "type": "text" + }, + { + "bbox": [ + 361, + 120, + 396, + 134 + ], + "score": 0.9, + "content": "\\alpha _ { T } ^ { D } = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 120, + 401, + 134 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 401, + 120, + 438, + 133 + ], + "score": 0.9, + "content": "\\alpha _ { t } ^ { D } = 0", + "type": "inline_equation" + }, + { + "bbox": [ + 438, + 120, + 454, + 134 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 455, + 122, + 483, + 132 + ], + "score": 0.89, + "content": "t < T", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 120, + 505, + 134 + ], + "score": 1.0, + "content": ", and", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 107, + 129, + 507, + 149 + ], + "spans": [ + { + "bbox": [ + 107, + 133, + 141, + 145 + ], + "score": 0.92, + "content": "\\alpha _ { t } ^ { G } = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 129, + 169, + 149 + ], + "score": 1.0, + "content": "for all", + "type": "text" + }, + { + "bbox": [ + 170, + 135, + 174, + 144 + ], + "score": 0.7, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 175, + 129, + 507, + 149 + ], + "score": 1.0, + "content": ", then stepGAN-Seq is equivalent to SeqGAN without Monte Carlo search. Also,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 143, + 451, + 158 + ], + "spans": [ + { + "bbox": [ + 105, + 143, + 288, + 158 + ], + "score": 1.0, + "content": "REGS (Li et al., 2017) can be induced by set", + "type": "text" + }, + { + "bbox": [ + 288, + 144, + 321, + 156 + ], + "score": 0.92, + "content": "\\alpha _ { t } ^ { D } = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 321, + 143, + 451, + 158 + ], + "score": 1.0, + "content": "at a randomly chosen time step.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4, + "bbox_fs": [ + 105, + 120, + 507, + 158 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 161, + 505, + 227 + ], + "lines": [ + { + "bbox": [ + 106, + 162, + 505, + 173 + ], + "spans": [ + { + "bbox": [ + 106, + 162, + 505, + 173 + ], + "score": 1.0, + "content": "StepGAN is similar to the actor-critic architecture in (Bahdanau et al., 2016). Instead of the assigned", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 173, + 505, + 184 + ], + "spans": [ + { + "bbox": [ + 106, + 173, + 392, + 184 + ], + "score": 1.0, + "content": "task-specific score, we learn the score by adversarial learning. Because", + "type": "text" + }, + { + "bbox": [ + 393, + 173, + 403, + 183 + ], + "score": 0.77, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 403, + 173, + 505, + 184 + ], + "score": 1.0, + "content": "’s scores are the expected", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 104, + 181, + 505, + 197 + ], + "spans": [ + { + "bbox": [ + 104, + 181, + 505, + 197 + ], + "score": 1.0, + "content": "return in this setting, we would like StepGAN to approximate the expected return obtained by Seq-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 193, + 505, + 207 + ], + "spans": [ + { + "bbox": [ + 105, + 193, + 505, + 207 + ], + "score": 1.0, + "content": "GAN or MaliGAN with Monte Carlo search. This approach only need to add a set of weight factors,", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 205, + 505, + 218 + ], + "spans": [ + { + "bbox": [ + 105, + 205, + 505, + 218 + ], + "score": 1.0, + "content": "and therefore much time efficient than Monte Carlo search. For more details of the algorithm, please", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 217, + 256, + 228 + ], + "spans": [ + { + "bbox": [ + 106, + 217, + 256, + 228 + ], + "score": 1.0, + "content": "refer to appendix A for pseudo-code.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 8.5, + "bbox_fs": [ + 104, + 162, + 505, + 228 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 246, + 200, + 259 + ], + "lines": [ + { + "bbox": [ + 105, + 245, + 201, + 261 + ], + "spans": [ + { + "bbox": [ + 105, + 245, + 201, + 261 + ], + "score": 1.0, + "content": "5 EXPERIMENTS", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 107, + 273, + 505, + 317 + ], + "lines": [ + { + "bbox": [ + 105, + 273, + 505, + 286 + ], + "spans": [ + { + "bbox": [ + 105, + 273, + 505, + 286 + ], + "score": 1.0, + "content": "We use a recurrent neural network for both the discriminator and generator due to its strong sequen-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 285, + 505, + 297 + ], + "spans": [ + { + "bbox": [ + 106, + 285, + 505, + 297 + ], + "score": 1.0, + "content": "tial correlation (Press et al., 2017; Rajeswar et al., 2017). Specifically, we use gated recurrent units", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 295, + 505, + 308 + ], + "spans": [ + { + "bbox": [ + 105, + 295, + 505, + 308 + ], + "score": 1.0, + "content": "(GRUs) (Chung et al., 2014) in our experiments. We view the noise feature in GAN as the random", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 306, + 333, + 318 + ], + "spans": [ + { + "bbox": [ + 105, + 306, + 333, + 318 + ], + "score": 1.0, + "content": "process of sampling from the softmax layer distribution.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 14.5, + "bbox_fs": [ + 105, + 273, + 505, + 318 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 334, + 236, + 345 + ], + "lines": [ + { + "bbox": [ + 106, + 334, + 236, + 346 + ], + "spans": [ + { + "bbox": [ + 106, + 334, + 236, + 346 + ], + "score": 1.0, + "content": "5.1 ARTIFICIAL GRAMMARS", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 356, + 505, + 498 + ], + "lines": [ + { + "bbox": [ + 106, + 355, + 505, + 368 + ], + "spans": [ + { + "bbox": [ + 106, + 355, + 505, + 368 + ], + "score": 1.0, + "content": "To better evaluate GANs for conditional sequence generation, we define three artificial grammars:", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 366, + 505, + 380 + ], + "spans": [ + { + "bbox": [ + 105, + 366, + 505, + 380 + ], + "score": 1.0, + "content": "sequence, counting, and addition. The three grammars are described in Table 1. For the sequence", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 377, + 505, + 391 + ], + "spans": [ + { + "bbox": [ + 105, + 377, + 474, + 391 + ], + "score": 1.0, + "content": "grammar, the aim is to generate a continued consecutive number sequence behind the input", + "type": "text" + }, + { + "bbox": [ + 475, + 378, + 484, + 388 + ], + "score": 0.72, + "content": "Y", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 377, + 505, + 391 + ], + "score": 1.0, + "content": ". For", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 388, + 504, + 401 + ], + "spans": [ + { + "bbox": [ + 105, + 388, + 186, + 401 + ], + "score": 1.0, + "content": "example, for input", + "type": "text" + }, + { + "bbox": [ + 187, + 389, + 219, + 400 + ], + "score": 0.93, + "content": "\\langle 1 , 2 , 3 \\rangle", + "type": "inline_equation" + }, + { + "bbox": [ + 219, + 388, + 504, + 401 + ], + "score": 1.0, + "content": ", the answer would be a consecutive number sequence of any length", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 399, + 505, + 412 + ], + "spans": [ + { + "bbox": [ + 105, + 399, + 204, + 412 + ], + "score": 1.0, + "content": "starting with 4, such as", + "type": "text" + }, + { + "bbox": [ + 204, + 400, + 254, + 412 + ], + "score": 0.89, + "content": "\\langle 4 , 5 , 6 , 7 , 8 \\rangle", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 399, + 505, + 412 + ], + "score": 1.0, + "content": ". The counting grammar is more complicated. The generated", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 410, + 505, + 423 + ], + "spans": [ + { + "bbox": [ + 105, + 410, + 505, + 423 + ], + "score": 1.0, + "content": "sequence should contain exactly 3 words, where the median is a randomly selected word from the", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 421, + 505, + 434 + ], + "spans": [ + { + "bbox": [ + 105, + 421, + 505, + 434 + ], + "score": 1.0, + "content": "input sequence. The first generated word should be the number of words on the left-hand side of the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 433, + 504, + 444 + ], + "spans": [ + { + "bbox": [ + 106, + 433, + 504, + 444 + ], + "score": 1.0, + "content": "selected median, while the last generated word should be the number of words on the right-hand side.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 442, + 505, + 458 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 231, + 458 + ], + "score": 1.0, + "content": "For example, when the input is", + "type": "text" + }, + { + "bbox": [ + 232, + 443, + 311, + 455 + ], + "score": 0.9, + "content": "\\langle 5 , 9 , 2 , 8 , 3 , 2 , 9 , 1 \\rangle", + "type": "inline_equation" + }, + { + "bbox": [ + 311, + 442, + 469, + 458 + ], + "score": 1.0, + "content": ", one permissible generated sequence is", + "type": "text" + }, + { + "bbox": [ + 469, + 443, + 501, + 456 + ], + "score": 0.93, + "content": "\\langle 0 , 5 , 7 \\rangle", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 442, + 505, + 458 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 453, + 505, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 505, + 468 + ], + "score": 1.0, + "content": "Last, for the addition grammar we generate the addition of two numbers randomly segmented from", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 465, + 505, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 465, + 255, + 477 + ], + "score": 1.0, + "content": "the input sequence. That is, for input", + "type": "text" + }, + { + "bbox": [ + 255, + 465, + 296, + 477 + ], + "score": 0.91, + "content": "\\langle 8 , 1 , 3 , 4 \\rangle", + "type": "inline_equation" + }, + { + "bbox": [ + 296, + 465, + 505, + 477 + ], + "score": 1.0, + "content": ", then one permissible output is the addition of 8 and", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 475, + 506, + 489 + ], + "spans": [ + { + "bbox": [ + 105, + 475, + 152, + 489 + ], + "score": 1.0, + "content": "134 – thus", + "type": "text" + }, + { + "bbox": [ + 152, + 476, + 184, + 488 + ], + "score": 0.92, + "content": "\\langle 1 , 4 , 2 \\rangle", + "type": "inline_equation" + }, + { + "bbox": [ + 185, + 475, + 506, + 489 + ], + "score": 1.0, + "content": ". Note that both the input and output numbers for this grammar are represented", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 487, + 260, + 500 + ], + "spans": [ + { + "bbox": [ + 105, + 487, + 260, + 500 + ], + "score": 1.0, + "content": "in terms of their corresponding digits.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 24, + "bbox_fs": [ + 105, + 355, + 506, + 500 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 504, + 505, + 614 + ], + "lines": [ + { + "bbox": [ + 106, + 504, + 505, + 516 + ], + "spans": [ + { + "bbox": [ + 106, + 504, + 505, + 516 + ], + "score": 1.0, + "content": "The purpose of these design is to imitate major properties in dialogue generation, such as variable-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 515, + 505, + 528 + ], + "spans": [ + { + "bbox": [ + 105, + 515, + 505, + 528 + ], + "score": 1.0, + "content": "length, repeated prefixes, the same sequence space, one-to-many, and many-to-one. The variable-", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 526, + 505, + 539 + ], + "spans": [ + { + "bbox": [ + 105, + 526, + 505, + 539 + ], + "score": 1.0, + "content": "length property means there is no fixed length for the input and output sequences. The repeated", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 538, + 505, + 549 + ], + "spans": [ + { + "bbox": [ + 106, + 538, + 505, + 549 + ], + "score": 1.0, + "content": "prefixes property means the beginning subsequences are usually shared by many data, for instance", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 547, + 506, + 561 + ], + "spans": [ + { + "bbox": [ + 105, + 547, + 506, + 561 + ], + "score": 1.0, + "content": "What and I am in natural language. The same sequence space here means that the input and output", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 559, + 506, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 559, + 506, + 572 + ], + "score": 1.0, + "content": "have the same structure and as such are sampled from the same space. Finally, one-to-many and", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 570, + 505, + 582 + ], + "spans": [ + { + "bbox": [ + 105, + 570, + 505, + 582 + ], + "score": 1.0, + "content": "many-to-one are quite common in dialogue generation. For example, when asking How are you?,", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 581, + 505, + 593 + ], + "spans": [ + { + "bbox": [ + 105, + 581, + 505, + 593 + ], + "score": 1.0, + "content": "responses vary from I’m fine to Great! How are you?. Also, the same response can be paired with", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 592, + 506, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 592, + 506, + 605 + ], + "score": 1.0, + "content": "multiple questions, such as for My name is Paul in response to What’s your name? and Who are", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 103, + 603, + 132, + 615 + ], + "spans": [ + { + "bbox": [ + 103, + 603, + 132, + 615 + ], + "score": 1.0, + "content": "you?.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 35.5, + "bbox_fs": [ + 103, + 504, + 506, + 615 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 619, + 504, + 708 + ], + "lines": [ + { + "bbox": [ + 106, + 620, + 506, + 632 + ], + "spans": [ + { + "bbox": [ + 106, + 620, + 506, + 632 + ], + "score": 1.0, + "content": "We then randomly generate 100,000 samples as training data, 10,000 as development data, and", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 631, + 506, + 643 + ], + "spans": [ + { + "bbox": [ + 106, + 631, + 506, + 643 + ], + "score": 1.0, + "content": "10,000 samples as testing data. The architectures are set to one layer with 128 hidden units. We", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 641, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 641, + 505, + 654 + ], + "score": 1.0, + "content": "evaluate our results using the three measures in Table 2. The first is the accuracy of samples gen-", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 653, + 505, + 665 + ], + "spans": [ + { + "bbox": [ + 105, + 653, + 505, + 665 + ], + "score": 1.0, + "content": "erated from the argmax policy (Acc), the second is that generated from the softmax probability", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 663, + 506, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 506, + 677 + ], + "score": 1.0, + "content": "(AccS), and the last is the coverage of softmax samples over all the permissible answers of the spe-", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 674, + 505, + 687 + ], + "spans": [ + { + "bbox": [ + 105, + 674, + 505, + 687 + ], + "score": 1.0, + "content": "cific grammar (Cov). We report them to ensure whether the one-to-many property is being learned.", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 685, + 505, + 698 + ], + "spans": [ + { + "bbox": [ + 105, + 685, + 505, + 698 + ], + "score": 1.0, + "content": "AccS and Cov are important because they can indicate if the model can learn the underlying dis-", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 697, + 505, + 709 + ], + "spans": [ + { + "bbox": [ + 105, + 697, + 505, + 709 + ], + "score": 1.0, + "content": "tribution of answers. When mode collapse happens, which means the model only know a specific", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 388, + 505, + 401 + ], + "spans": [ + { + "bbox": [ + 105, + 388, + 505, + 401 + ], + "score": 1.0, + "content": "type of answers, it will obtain high AccS and low Cov scores. To ensure a fair comparison, all the", + "type": "text", + "cross_page": true + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 399, + 453, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 399, + 453, + 411 + ], + "score": 1.0, + "content": "algorithms are based on the same pre-trained model: the MLE model listed in Table 2.", + "type": "text", + "cross_page": true + } + ], + "index": 12 + } + ], + "index": 44.5, + "bbox_fs": [ + 105, + 620, + 506, + 709 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 125, + 104, + 486, + 164 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 217, + 80, + 394, + 92 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 216, + 79, + 394, + 93 + ], + "spans": [ + { + "bbox": [ + 216, + 79, + 394, + 93 + ], + "score": 1.0, + "content": "Table 1: Grammar definitions and examples", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table_body", + "bbox": [ + 125, + 104, + 486, + 164 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 125, + 104, + 486, + 164 + ], + "spans": [ + { + "bbox": [ + 125, + 104, + 486, + 164 + ], + "score": 0.971, + "html": "
GrammarDefinitionExamples
SequenceContinue the sequence for a random length123: 4, 45,...
CountingRandomly choose a digit, and then calculate the left-and right-hand lengths123: 012,121, 230
AdditionRandomly partition,and then add the two numbers123: 15,24
", + "type": "table", + "image_path": "a488ea6f1ce399dde9cc4f1dcd75f80c6c31db2893dcf3a32c7012970d14d62a.jpg" + } + ] + } + ], + "index": 2, + "virtual_lines": [ + { + "bbox": [ + 125, + 104, + 486, + 124.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 125, + 124.0, + 486, + 144.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 125, + 144.0, + 486, + 164.0 + ], + "spans": [], + "index": 3 + } + ] + } + ], + "index": 1.0 + }, + { + "type": "table", + "bbox": [ + 111, + 237, + 501, + 363 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 179, + 506, + 224 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 180, + 505, + 191 + ], + "spans": [ + { + "bbox": [ + 106, + 180, + 463, + 191 + ], + "score": 1.0, + "content": "Table 2: Results of artificial grammars with different algorithms. Evaluation label Acc", + "type": "text" + }, + { + "bbox": [ + 463, + 180, + 479, + 191 + ], + "score": 0.75, + "content": "( \\% )", + "type": "inline_equation" + }, + { + "bbox": [ + 479, + 180, + 505, + 191 + ], + "score": 1.0, + "content": "is the", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 191, + 505, + 203 + ], + "spans": [ + { + "bbox": [ + 106, + 191, + 254, + 203 + ], + "score": 1.0, + "content": "accuracy of argmax samples, AccS", + "type": "text" + }, + { + "bbox": [ + 254, + 191, + 270, + 202 + ], + "score": 0.76, + "content": "( \\% )", + "type": "inline_equation" + }, + { + "bbox": [ + 271, + 191, + 462, + 203 + ], + "score": 1.0, + "content": "is the accuracy of softmax samples, and Cov", + "type": "text" + }, + { + "bbox": [ + 462, + 191, + 478, + 202 + ], + "score": 0.73, + "content": "( \\% )", + "type": "inline_equation" + }, + { + "bbox": [ + 478, + 191, + 505, + 203 + ], + "score": 1.0, + "content": "is the", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 202, + 505, + 214 + ], + "spans": [ + { + "bbox": [ + 106, + 202, + 505, + 214 + ], + "score": 1.0, + "content": "coverage of softmax samples over permissible answers. The dash (-) here indicates that the algorithm", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 213, + 351, + 225 + ], + "spans": [ + { + "bbox": [ + 106, + 213, + 351, + 225 + ], + "score": 1.0, + "content": "introduced no improvements based on the pre-trained model.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5.5 + }, + { + "type": "table_body", + "bbox": [ + 111, + 237, + 501, + 363 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 111, + 237, + 501, + 363 + ], + "spans": [ + { + "bbox": [ + 111, + 237, + 501, + 363 + ], + "score": 0.983, + "html": "
SequenceCountingAddition
AccAccSCovAccAccSCovAccAccSCov
MLE97.4381.3253.7773.4868.8970.6344.5732.2831.79
REINFORCE99.8197.304.5499.9799.3616.9979.9875.6018.32
WGAN-GP111111111
basic-MaliGAN97.3481.6654.1974.1270.3570.1544.2732.0531.92
basic-SeqGAN97.2080.2857.6174.5970.5670.3944.8732.3031.90
MC-SeqGAN97.2080.9855.4972.9668.1070.5444.7232.2831.83
REGS97.4281.3653.8275.9970.9369.4044.6432.3232.01
StepGAN-Seq97.1174.8567.4975.4770.6469.8245.5532.4932.01
StepGAN97.1975.9266.0881.9872.2469.0244.9432.1931.67
", + "type": "table", + "image_path": "2ccf2814fe842e1e86b9ca31c6920623cd4405e3eef1d617612e5cbc1121d7e4.jpg" + } + ] + } + ], + "index": 9, + "virtual_lines": [ + { + "bbox": [ + 111, + 237, + 501, + 279.0 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 111, + 279.0, + 501, + 321.0 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 111, + 321.0, + 501, + 363.0 + ], + "spans": [], + "index": 10 + } + ] + } + ], + "index": 7.25 + }, + { + "type": "text", + "bbox": [ + 107, + 388, + 503, + 410 + ], + "lines": [ + { + "bbox": [ + 105, + 388, + 505, + 401 + ], + "spans": [ + { + "bbox": [ + 105, + 388, + 505, + 401 + ], + "score": 1.0, + "content": "type of answers, it will obtain high AccS and low Cov scores. To ensure a fair comparison, all the", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 399, + 453, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 399, + 453, + 411 + ], + "score": 1.0, + "content": "algorithms are based on the same pre-trained model: the MLE model listed in Table 2.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5 + }, + { + "type": "text", + "bbox": [ + 106, + 419, + 505, + 507 + ], + "lines": [ + { + "bbox": [ + 106, + 418, + 506, + 433 + ], + "spans": [ + { + "bbox": [ + 106, + 418, + 506, + 433 + ], + "score": 1.0, + "content": "We discuss the results of MLE, REINFORCE, and state-of-the-art GAN algorithms on Sequence,", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 430, + 506, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 448, + 442 + ], + "score": 1.0, + "content": "Counting, and Addition in Table 2. REINFORCE has higher Acc and AccS than", + "type": "text" + }, + { + "bbox": [ + 449, + 430, + 475, + 441 + ], + "score": 0.35, + "content": "{ \\mathrm { M L E } } ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 475, + 430, + 506, + 442 + ], + "score": 1.0, + "content": ", but it", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 441, + 505, + 454 + ], + "spans": [ + { + "bbox": [ + 105, + 441, + 505, + 454 + ], + "score": 1.0, + "content": "results in strong mode-collapse (very low Cov). We have a very strong MLE baseline for Sequence.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 452, + 506, + 465 + ], + "spans": [ + { + "bbox": [ + 105, + 452, + 506, + 465 + ], + "score": 1.0, + "content": "Therefore we cannot pretrain discriminator well based on this baseline MLE model. Every GAN", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 464, + 505, + 476 + ], + "spans": [ + { + "bbox": [ + 106, + 464, + 505, + 476 + ], + "score": 1.0, + "content": "algorithms cannot outperform MLE by this setting. StepGAN improves Acc on both Counting and", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 474, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 474, + 505, + 487 + ], + "score": 1.0, + "content": "Addition without heavily trade-off with Cov. That is, training model using StepGAN enhances and", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 485, + 505, + 498 + ], + "spans": [ + { + "bbox": [ + 105, + 485, + 505, + 498 + ], + "score": 1.0, + "content": "maintains the knowledge of underlying distribution rather than resulting in strong mode-collapse as", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 497, + 167, + 507 + ], + "spans": [ + { + "bbox": [ + 106, + 497, + 167, + 507 + ], + "score": 1.0, + "content": "REINFORCE.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 16.5 + }, + { + "type": "text", + "bbox": [ + 107, + 513, + 505, + 568 + ], + "lines": [ + { + "bbox": [ + 106, + 513, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 106, + 513, + 505, + 525 + ], + "score": 1.0, + "content": "To investigate the trade-off between AccS and Cov, we plot the accuracy-coverage curve in Fig. 2.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 523, + 505, + 537 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 505, + 537 + ], + "score": 1.0, + "content": "The trade-off between accuracy and coverage is controlled by sharpening the softmax layer. Besides", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 534, + 505, + 549 + ], + "spans": [ + { + "bbox": [ + 105, + 534, + 505, + 549 + ], + "score": 1.0, + "content": "Fig. 2a, of which the GANs do not obtain good results, StepGAN improves the accuracy-coverage", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 546, + 505, + 559 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 505, + 559 + ], + "score": 1.0, + "content": "curves in Fig. 2b and Fig. 2c. This is consistent with our realization of Table 2 that StepGAN fits", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 557, + 280, + 571 + ], + "spans": [ + { + "bbox": [ + 105, + 557, + 280, + 571 + ], + "score": 1.0, + "content": "model to the underlying distribution better.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23 + }, + { + "type": "title", + "bbox": [ + 108, + 583, + 237, + 594 + ], + "lines": [ + { + "bbox": [ + 105, + 582, + 239, + 595 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 239, + 595 + ], + "score": 1.0, + "content": "5.2 DIALOGUE GENERATION", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 107, + 604, + 505, + 681 + ], + "lines": [ + { + "bbox": [ + 106, + 604, + 506, + 616 + ], + "spans": [ + { + "bbox": [ + 106, + 604, + 506, + 616 + ], + "score": 1.0, + "content": "We split OpenSubtitles (Tiedemann, 2009) into training set, development set, and testing set with a", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 614, + 506, + 628 + ], + "spans": [ + { + "bbox": [ + 105, + 614, + 506, + 628 + ], + "score": 1.0, + "content": "vocabulary of the top 4,000 most frequently occurring words. Both the generator and discriminator", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 624, + 506, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 300, + 640 + ], + "score": 1.0, + "content": "are 1-layer GRUs with a hidden dimension set to", + "type": "text" + }, + { + "bbox": [ + 301, + 625, + 321, + 636 + ], + "score": 0.84, + "content": "5 1 2 ^ { 3 }", + "type": "inline_equation" + }, + { + "bbox": [ + 321, + 624, + 506, + 640 + ], + "score": 1.0, + "content": ". To compare the improvements introduced by", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 637, + 505, + 649 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 505, + 649 + ], + "score": 1.0, + "content": "all the algorithms, we first pre-trained the generator using MLE, after which we further trained the", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 647, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 647, + 505, + 661 + ], + "score": 1.0, + "content": "model for 1-epoch by different GANs. SeqGAN, MaliGAN, REGS, and StepGAN were compared.", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 658, + 505, + 671 + ], + "spans": [ + { + "bbox": [ + 106, + 658, + 505, + 671 + ], + "score": 1.0, + "content": "We do not compare Monte Carlo search with other approaches because its time complexity is much", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 669, + 506, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 669, + 506, + 683 + ], + "score": 1.0, + "content": "larger. All discriminators of SeqGAN, MaliGAN, REGS, and StepGAN were pre-trained on real", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 30 + } + ], + "page_idx": 6, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 690, + 505, + 731 + ], + "lines": [ + { + "bbox": [ + 118, + 688, + 506, + 703 + ], + "spans": [ + { + "bbox": [ + 118, + 688, + 506, + 703 + ], + "score": 1.0, + "content": "2Since the given reward of REINFORCE is the true accuracy, the Acc and AccS of REINFORCE here are", + "type": "text" + } + ] + }, + { + "bbox": [ + 106, + 700, + 204, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 700, + 204, + 712 + ], + "score": 1.0, + "content": "taken as the upper bounds.", + "type": "text" + } + ] + }, + { + "bbox": [ + 117, + 708, + 506, + 725 + ], + "spans": [ + { + "bbox": [ + 117, + 708, + 506, + 725 + ], + "score": 1.0, + "content": "3We trained another value network with the same seq2seq architecture to estimate the baseline. This is", + "type": "text" + } + ] + }, + { + "bbox": [ + 106, + 720, + 203, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 203, + 733 + ], + "score": 1.0, + "content": "similar to (Li et al., 2017).", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "score": 1.0, + "content": "7", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 125, + 104, + 486, + 164 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 217, + 80, + 394, + 92 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 216, + 79, + 394, + 93 + ], + "spans": [ + { + "bbox": [ + 216, + 79, + 394, + 93 + ], + "score": 1.0, + "content": "Table 1: Grammar definitions and examples", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table_body", + "bbox": [ + 125, + 104, + 486, + 164 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 125, + 104, + 486, + 164 + ], + "spans": [ + { + "bbox": [ + 125, + 104, + 486, + 164 + ], + "score": 0.971, + "html": "
GrammarDefinitionExamples
SequenceContinue the sequence for a random length123: 4, 45,...
CountingRandomly choose a digit, and then calculate the left-and right-hand lengths123: 012,121, 230
AdditionRandomly partition,and then add the two numbers123: 15,24
", + "type": "table", + "image_path": "a488ea6f1ce399dde9cc4f1dcd75f80c6c31db2893dcf3a32c7012970d14d62a.jpg" + } + ] + } + ], + "index": 2, + "virtual_lines": [ + { + "bbox": [ + 125, + 104, + 486, + 124.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 125, + 124.0, + 486, + 144.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 125, + 144.0, + 486, + 164.0 + ], + "spans": [], + "index": 3 + } + ] + } + ], + "index": 1.0 + }, + { + "type": "table", + "bbox": [ + 111, + 237, + 501, + 363 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 179, + 506, + 224 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 180, + 505, + 191 + ], + "spans": [ + { + "bbox": [ + 106, + 180, + 463, + 191 + ], + "score": 1.0, + "content": "Table 2: Results of artificial grammars with different algorithms. Evaluation label Acc", + "type": "text" + }, + { + "bbox": [ + 463, + 180, + 479, + 191 + ], + "score": 0.75, + "content": "( \\% )", + "type": "inline_equation" + }, + { + "bbox": [ + 479, + 180, + 505, + 191 + ], + "score": 1.0, + "content": "is the", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 191, + 505, + 203 + ], + "spans": [ + { + "bbox": [ + 106, + 191, + 254, + 203 + ], + "score": 1.0, + "content": "accuracy of argmax samples, AccS", + "type": "text" + }, + { + "bbox": [ + 254, + 191, + 270, + 202 + ], + "score": 0.76, + "content": "( \\% )", + "type": "inline_equation" + }, + { + "bbox": [ + 271, + 191, + 462, + 203 + ], + "score": 1.0, + "content": "is the accuracy of softmax samples, and Cov", + "type": "text" + }, + { + "bbox": [ + 462, + 191, + 478, + 202 + ], + "score": 0.73, + "content": "( \\% )", + "type": "inline_equation" + }, + { + "bbox": [ + 478, + 191, + 505, + 203 + ], + "score": 1.0, + "content": "is the", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 202, + 505, + 214 + ], + "spans": [ + { + "bbox": [ + 106, + 202, + 505, + 214 + ], + "score": 1.0, + "content": "coverage of softmax samples over permissible answers. The dash (-) here indicates that the algorithm", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 213, + 351, + 225 + ], + "spans": [ + { + "bbox": [ + 106, + 213, + 351, + 225 + ], + "score": 1.0, + "content": "introduced no improvements based on the pre-trained model.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5.5 + }, + { + "type": "table_body", + "bbox": [ + 111, + 237, + 501, + 363 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 111, + 237, + 501, + 363 + ], + "spans": [ + { + "bbox": [ + 111, + 237, + 501, + 363 + ], + "score": 0.983, + "html": "
SequenceCountingAddition
AccAccSCovAccAccSCovAccAccSCov
MLE97.4381.3253.7773.4868.8970.6344.5732.2831.79
REINFORCE99.8197.304.5499.9799.3616.9979.9875.6018.32
WGAN-GP111111111
basic-MaliGAN97.3481.6654.1974.1270.3570.1544.2732.0531.92
basic-SeqGAN97.2080.2857.6174.5970.5670.3944.8732.3031.90
MC-SeqGAN97.2080.9855.4972.9668.1070.5444.7232.2831.83
REGS97.4281.3653.8275.9970.9369.4044.6432.3232.01
StepGAN-Seq97.1174.8567.4975.4770.6469.8245.5532.4932.01
StepGAN97.1975.9266.0881.9872.2469.0244.9432.1931.67
", + "type": "table", + "image_path": "2ccf2814fe842e1e86b9ca31c6920623cd4405e3eef1d617612e5cbc1121d7e4.jpg" + } + ] + } + ], + "index": 9, + "virtual_lines": [ + { + "bbox": [ + 111, + 237, + 501, + 279.0 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 111, + 279.0, + 501, + 321.0 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 111, + 321.0, + 501, + 363.0 + ], + "spans": [], + "index": 10 + } + ] + } + ], + "index": 7.25 + }, + { + "type": "text", + "bbox": [ + 107, + 388, + 503, + 410 + ], + "lines": [], + "index": 11.5, + "bbox_fs": [ + 105, + 388, + 505, + 411 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 106, + 419, + 505, + 507 + ], + "lines": [ + { + "bbox": [ + 106, + 418, + 506, + 433 + ], + "spans": [ + { + "bbox": [ + 106, + 418, + 506, + 433 + ], + "score": 1.0, + "content": "We discuss the results of MLE, REINFORCE, and state-of-the-art GAN algorithms on Sequence,", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 430, + 506, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 448, + 442 + ], + "score": 1.0, + "content": "Counting, and Addition in Table 2. REINFORCE has higher Acc and AccS than", + "type": "text" + }, + { + "bbox": [ + 449, + 430, + 475, + 441 + ], + "score": 0.35, + "content": "{ \\mathrm { M L E } } ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 475, + 430, + 506, + 442 + ], + "score": 1.0, + "content": ", but it", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 441, + 505, + 454 + ], + "spans": [ + { + "bbox": [ + 105, + 441, + 505, + 454 + ], + "score": 1.0, + "content": "results in strong mode-collapse (very low Cov). We have a very strong MLE baseline for Sequence.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 452, + 506, + 465 + ], + "spans": [ + { + "bbox": [ + 105, + 452, + 506, + 465 + ], + "score": 1.0, + "content": "Therefore we cannot pretrain discriminator well based on this baseline MLE model. Every GAN", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 464, + 505, + 476 + ], + "spans": [ + { + "bbox": [ + 106, + 464, + 505, + 476 + ], + "score": 1.0, + "content": "algorithms cannot outperform MLE by this setting. StepGAN improves Acc on both Counting and", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 474, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 474, + 505, + 487 + ], + "score": 1.0, + "content": "Addition without heavily trade-off with Cov. That is, training model using StepGAN enhances and", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 485, + 505, + 498 + ], + "spans": [ + { + "bbox": [ + 105, + 485, + 505, + 498 + ], + "score": 1.0, + "content": "maintains the knowledge of underlying distribution rather than resulting in strong mode-collapse as", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 497, + 167, + 507 + ], + "spans": [ + { + "bbox": [ + 106, + 497, + 167, + 507 + ], + "score": 1.0, + "content": "REINFORCE.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 16.5, + "bbox_fs": [ + 105, + 418, + 506, + 507 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 513, + 505, + 568 + ], + "lines": [ + { + "bbox": [ + 106, + 513, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 106, + 513, + 505, + 525 + ], + "score": 1.0, + "content": "To investigate the trade-off between AccS and Cov, we plot the accuracy-coverage curve in Fig. 2.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 523, + 505, + 537 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 505, + 537 + ], + "score": 1.0, + "content": "The trade-off between accuracy and coverage is controlled by sharpening the softmax layer. Besides", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 534, + 505, + 549 + ], + "spans": [ + { + "bbox": [ + 105, + 534, + 505, + 549 + ], + "score": 1.0, + "content": "Fig. 2a, of which the GANs do not obtain good results, StepGAN improves the accuracy-coverage", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 546, + 505, + 559 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 505, + 559 + ], + "score": 1.0, + "content": "curves in Fig. 2b and Fig. 2c. This is consistent with our realization of Table 2 that StepGAN fits", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 557, + 280, + 571 + ], + "spans": [ + { + "bbox": [ + 105, + 557, + 280, + 571 + ], + "score": 1.0, + "content": "model to the underlying distribution better.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23, + "bbox_fs": [ + 105, + 513, + 505, + 571 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 583, + 237, + 594 + ], + "lines": [ + { + "bbox": [ + 105, + 582, + 239, + 595 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 239, + 595 + ], + "score": 1.0, + "content": "5.2 DIALOGUE GENERATION", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 107, + 604, + 505, + 681 + ], + "lines": [ + { + "bbox": [ + 106, + 604, + 506, + 616 + ], + "spans": [ + { + "bbox": [ + 106, + 604, + 506, + 616 + ], + "score": 1.0, + "content": "We split OpenSubtitles (Tiedemann, 2009) into training set, development set, and testing set with a", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 614, + 506, + 628 + ], + "spans": [ + { + "bbox": [ + 105, + 614, + 506, + 628 + ], + "score": 1.0, + "content": "vocabulary of the top 4,000 most frequently occurring words. Both the generator and discriminator", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 624, + 506, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 300, + 640 + ], + "score": 1.0, + "content": "are 1-layer GRUs with a hidden dimension set to", + "type": "text" + }, + { + "bbox": [ + 301, + 625, + 321, + 636 + ], + "score": 0.84, + "content": "5 1 2 ^ { 3 }", + "type": "inline_equation" + }, + { + "bbox": [ + 321, + 624, + 506, + 640 + ], + "score": 1.0, + "content": ". To compare the improvements introduced by", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 637, + 505, + 649 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 505, + 649 + ], + "score": 1.0, + "content": "all the algorithms, we first pre-trained the generator using MLE, after which we further trained the", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 647, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 647, + 505, + 661 + ], + "score": 1.0, + "content": "model for 1-epoch by different GANs. SeqGAN, MaliGAN, REGS, and StepGAN were compared.", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 658, + 505, + 671 + ], + "spans": [ + { + "bbox": [ + 106, + 658, + 505, + 671 + ], + "score": 1.0, + "content": "We do not compare Monte Carlo search with other approaches because its time complexity is much", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 669, + 506, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 669, + 506, + 683 + ], + "score": 1.0, + "content": "larger. All discriminators of SeqGAN, MaliGAN, REGS, and StepGAN were pre-trained on real", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 30, + "bbox_fs": [ + 105, + 604, + 506, + 683 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 114, + 85, + 492, + 195 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 114, + 85, + 492, + 195 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 114, + 85, + 492, + 195 + ], + "spans": [ + { + "bbox": [ + 114, + 85, + 492, + 195 + ], + "score": 0.971, + "type": "image", + "image_path": "51918436916ce27a7936dcb270ad55e741a33a77f82a6d8e511af766a2b1dde4.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 114, + 85, + 492, + 121.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 114, + 121.66666666666666, + 492, + 158.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 114, + 158.33333333333331, + 492, + 194.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 206, + 204, + 404, + 216 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 206, + 203, + 405, + 218 + ], + "spans": [ + { + "bbox": [ + 206, + 203, + 405, + 218 + ], + "score": 1.0, + "content": "Figure 2: Sampled accuracy and coverage curves", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "text", + "bbox": [ + 104, + 230, + 504, + 253 + ], + "lines": [ + { + "bbox": [ + 106, + 230, + 505, + 243 + ], + "spans": [ + { + "bbox": [ + 106, + 230, + 408, + 243 + ], + "score": 1.0, + "content": "Table 3: Human evaluation and BLEU score for dialogue generation. CoHS", + "type": "text" + }, + { + "bbox": [ + 408, + 231, + 423, + 241 + ], + "score": 0.69, + "content": "( \\% )", + "type": "inline_equation" + }, + { + "bbox": [ + 423, + 230, + 505, + 243 + ], + "score": 1.0, + "content": "is coherence human", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 241, + 309, + 254 + ], + "spans": [ + { + "bbox": [ + 105, + 241, + 154, + 254 + ], + "score": 1.0, + "content": "score. SHS", + "type": "text" + }, + { + "bbox": [ + 154, + 242, + 170, + 253 + ], + "score": 0.65, + "content": "( \\% )", + "type": "inline_equation" + }, + { + "bbox": [ + 170, + 241, + 309, + 254 + ], + "score": 1.0, + "content": "is sentence structure human score.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5 + }, + { + "type": "table", + "bbox": [ + 110, + 266, + 501, + 348 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 110, + 266, + 501, + 348 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 110, + 266, + 501, + 348 + ], + "spans": [ + { + "bbox": [ + 110, + 266, + 501, + 348 + ], + "score": 0.975, + "html": "
CoHS (%)SHS (%)BLEU
ArgmaxBSMMIArgmaxBSMMIArgmaxBSMMI
MLE44.8954.2260.4415.111.337.560.2220.2810.272
SeqGAN41.3353.3363.5530.676.2210.220.2020.2670.251
MaliGAN35.5651.1145.3320.895.788.000.1800.2710.263
REGS36.4454.6753.7836.449.339.780.1800.2560.246
StepGAN47.5663.5661.3340.893.568.890.1710.2540.248
", + "type": "table", + "image_path": "eb38d3e441297806e4dbd66d23ba6617503091769c8b72ea736106bb5dbdf0bf.jpg" + } + ] + } + ], + "index": 7, + "virtual_lines": [ + { + "bbox": [ + 110, + 266, + 501, + 293.3333333333333 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 110, + 293.3333333333333, + 501, + 320.66666666666663 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 110, + 320.66666666666663, + 501, + 347.99999999999994 + ], + "spans": [], + "index": 8 + } + ] + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 107, + 376, + 505, + 420 + ], + "lines": [ + { + "bbox": [ + 106, + 376, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 106, + 376, + 505, + 388 + ], + "score": 1.0, + "content": "data and generated data from the pre-trained generator. Note that these models were all trained", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 387, + 506, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 387, + 506, + 399 + ], + "score": 1.0, + "content": "without MIXER, curriculum learning, or teacher forcing, etc. Both the generator and discriminator", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 397, + 505, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 397, + 505, + 410 + ], + "score": 1.0, + "content": "are optimized by SGD. We used grid search in the experiments with learning rate={1e-1,1e-2,1e-3},", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 408, + 343, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 321, + 421 + ], + "score": 1.0, + "content": "discriminator iteration step={1,5}, and used batchsize", + "type": "text" + }, + { + "bbox": [ + 322, + 409, + 338, + 419 + ], + "score": 0.79, + "content": "_ { = 6 4 }", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 408, + 343, + 421 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10.5 + }, + { + "type": "text", + "bbox": [ + 106, + 425, + 505, + 535 + ], + "lines": [ + { + "bbox": [ + 105, + 424, + 505, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 424, + 505, + 439 + ], + "score": 1.0, + "content": "For human evaluation, we randomly selected 25 inputs from the testing set, and decoded using", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 435, + 505, + 450 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 505, + 450 + ], + "score": 1.0, + "content": "argmax policy, beam search, and MMI (Li et al., 2015)4. We presented both an input and the", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 447, + 507, + 462 + ], + "spans": [ + { + "bbox": [ + 104, + 447, + 507, + 462 + ], + "score": 1.0, + "content": "generated outputs to 8 and 4 judges respectively, and we asked them to do Turing test (correct or", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 457, + 505, + 471 + ], + "spans": [ + { + "bbox": [ + 105, + 457, + 505, + 471 + ], + "score": 1.0, + "content": "not) of the coherence and sentence structure. Coherence is the rationality of the generated responses", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 104, + 469, + 506, + 483 + ], + "spans": [ + { + "bbox": [ + 104, + 469, + 506, + 483 + ], + "score": 1.0, + "content": "given inputs. Sentence structure is the correctness and complexity of grammar. The sentences", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 104, + 480, + 506, + 493 + ], + "spans": [ + { + "bbox": [ + 104, + 480, + 506, + 493 + ], + "score": 1.0, + "content": "provide specific information would be considered as having better sentence structure rather than the", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 104, + 491, + 506, + 505 + ], + "spans": [ + { + "bbox": [ + 104, + 491, + 506, + 505 + ], + "score": 1.0, + "content": "general ones (egs. I don’t know.) due to more complex grammar. In Table 3, the two measures are", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 503, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 106, + 503, + 505, + 514 + ], + "score": 1.0, + "content": "labeled as CoHS (Coherence Human Score) and SHS (Sentence structure Human Score). We also", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 512, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 512, + 505, + 525 + ], + "score": 1.0, + "content": "show the BLEU score of each algorithm. It was already found that BLEU score is inconsistent with", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 524, + 496, + 536 + ], + "spans": [ + { + "bbox": [ + 106, + 524, + 496, + 536 + ], + "score": 1.0, + "content": "human evaluation (Liu et al., 2016), we also observe the same phenomenon it in our experiments.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 17.5 + }, + { + "type": "text", + "bbox": [ + 106, + 541, + 505, + 694 + ], + "lines": [ + { + "bbox": [ + 105, + 539, + 506, + 555 + ], + "spans": [ + { + "bbox": [ + 105, + 539, + 506, + 555 + ], + "score": 1.0, + "content": "We show the CoHS and SHS of 15 different results (5 different algorithms and 3 different decoding", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 104, + 551, + 505, + 566 + ], + "spans": [ + { + "bbox": [ + 104, + 551, + 505, + 566 + ], + "score": 1.0, + "content": "methods) in Table 3. First, we can see decoding using beam search or MMI improve CoHS. Step-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 563, + 505, + 576 + ], + "spans": [ + { + "bbox": [ + 105, + 563, + 505, + 576 + ], + "score": 1.0, + "content": "GAN obtains the best performance in terms of CoHS when using argmax policy or beam search,", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 574, + 506, + 587 + ], + "spans": [ + { + "bbox": [ + 105, + 574, + 506, + 587 + ], + "score": 1.0, + "content": "but StepGAN cannot further increase the performance using MMI. When using MMI, the CoHS of", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 585, + 506, + 597 + ], + "spans": [ + { + "bbox": [ + 105, + 585, + 506, + 597 + ], + "score": 1.0, + "content": "MLE, SeqGAN and StepGAN are comparable. Second, argmax policy has higher SHS than beam", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 596, + 505, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 596, + 505, + 609 + ], + "score": 1.0, + "content": "search and MMI in all cases. In the meantime, GANs have higher SHS than MLE, and StepGAN", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 607, + 505, + 620 + ], + "spans": [ + { + "bbox": [ + 105, + 607, + 505, + 620 + ], + "score": 1.0, + "content": "has the highest score with argmax. The inconsistency of improvement between argmax policy, beam", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 618, + 505, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 618, + 505, + 630 + ], + "score": 1.0, + "content": "search and MMI is very likely because that the GANs are learned with the softmax policy and do not", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 628, + 505, + 641 + ], + "spans": [ + { + "bbox": [ + 106, + 628, + 505, + 641 + ], + "score": 1.0, + "content": "consider beam search and MMI during training. Additionally, we know beam search and MMI max-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 640, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 106, + 640, + 505, + 653 + ], + "score": 1.0, + "content": "imize the probability of response given an input without maintaining the probability of the response", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 650, + 505, + 664 + ], + "spans": [ + { + "bbox": [ + 105, + 650, + 505, + 664 + ], + "score": 1.0, + "content": "itself. This makes them prefer a coherence response rather than a good sentence structure. These", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 662, + 505, + 674 + ], + "spans": [ + { + "bbox": [ + 106, + 662, + 505, + 674 + ], + "score": 1.0, + "content": "statistics show that SeqGAN, MaliGAN, and REGS cannot consistently improve both coherence", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 672, + 505, + 685 + ], + "spans": [ + { + "bbox": [ + 105, + 672, + 505, + 685 + ], + "score": 1.0, + "content": "and sentence structure, whereas StepGAN outperforms MLE in terms both CoHS and SHS with all", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 684, + 188, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 684, + 188, + 695 + ], + "score": 1.0, + "content": "decoding methods.5", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 29.5 + } + ], + "page_idx": 7, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 118, + 710, + 335, + 732 + ], + "lines": [ + { + "bbox": [ + 118, + 708, + 262, + 723 + ], + "spans": [ + { + "bbox": [ + 118, + 708, + 262, + 723 + ], + "score": 1.0, + "content": "4We use MMI-p(x) in our experiments.", + "type": "text" + } + ] + }, + { + "bbox": [ + 118, + 719, + 335, + 734 + ], + "spans": [ + { + "bbox": [ + 118, + 719, + 335, + 734 + ], + "score": 1.0, + "content": "5To see the generated examples, please refer to appendix D.", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 12, + "width": 9 + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 114, + 85, + 492, + 195 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 114, + 85, + 492, + 195 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 114, + 85, + 492, + 195 + ], + "spans": [ + { + "bbox": [ + 114, + 85, + 492, + 195 + ], + "score": 0.971, + "type": "image", + "image_path": "51918436916ce27a7936dcb270ad55e741a33a77f82a6d8e511af766a2b1dde4.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 114, + 85, + 492, + 121.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 114, + 121.66666666666666, + 492, + 158.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 114, + 158.33333333333331, + 492, + 194.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 206, + 204, + 404, + 216 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 206, + 203, + 405, + 218 + ], + "spans": [ + { + "bbox": [ + 206, + 203, + 405, + 218 + ], + "score": 1.0, + "content": "Figure 2: Sampled accuracy and coverage curves", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "text", + "bbox": [ + 104, + 230, + 504, + 253 + ], + "lines": [ + { + "bbox": [ + 106, + 230, + 505, + 243 + ], + "spans": [ + { + "bbox": [ + 106, + 230, + 408, + 243 + ], + "score": 1.0, + "content": "Table 3: Human evaluation and BLEU score for dialogue generation. CoHS", + "type": "text" + }, + { + "bbox": [ + 408, + 231, + 423, + 241 + ], + "score": 0.69, + "content": "( \\% )", + "type": "inline_equation" + }, + { + "bbox": [ + 423, + 230, + 505, + 243 + ], + "score": 1.0, + "content": "is coherence human", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 241, + 309, + 254 + ], + "spans": [ + { + "bbox": [ + 105, + 241, + 154, + 254 + ], + "score": 1.0, + "content": "score. SHS", + "type": "text" + }, + { + "bbox": [ + 154, + 242, + 170, + 253 + ], + "score": 0.65, + "content": "( \\% )", + "type": "inline_equation" + }, + { + "bbox": [ + 170, + 241, + 309, + 254 + ], + "score": 1.0, + "content": "is sentence structure human score.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5, + "bbox_fs": [ + 105, + 230, + 505, + 254 + ] + }, + { + "type": "table", + "bbox": [ + 110, + 266, + 501, + 348 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 110, + 266, + 501, + 348 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 110, + 266, + 501, + 348 + ], + "spans": [ + { + "bbox": [ + 110, + 266, + 501, + 348 + ], + "score": 0.975, + "html": "
CoHS (%)SHS (%)BLEU
ArgmaxBSMMIArgmaxBSMMIArgmaxBSMMI
MLE44.8954.2260.4415.111.337.560.2220.2810.272
SeqGAN41.3353.3363.5530.676.2210.220.2020.2670.251
MaliGAN35.5651.1145.3320.895.788.000.1800.2710.263
REGS36.4454.6753.7836.449.339.780.1800.2560.246
StepGAN47.5663.5661.3340.893.568.890.1710.2540.248
", + "type": "table", + "image_path": "eb38d3e441297806e4dbd66d23ba6617503091769c8b72ea736106bb5dbdf0bf.jpg" + } + ] + } + ], + "index": 7, + "virtual_lines": [ + { + "bbox": [ + 110, + 266, + 501, + 293.3333333333333 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 110, + 293.3333333333333, + 501, + 320.66666666666663 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 110, + 320.66666666666663, + 501, + 347.99999999999994 + ], + "spans": [], + "index": 8 + } + ] + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 107, + 376, + 505, + 420 + ], + "lines": [ + { + "bbox": [ + 106, + 376, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 106, + 376, + 505, + 388 + ], + "score": 1.0, + "content": "data and generated data from the pre-trained generator. Note that these models were all trained", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 387, + 506, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 387, + 506, + 399 + ], + "score": 1.0, + "content": "without MIXER, curriculum learning, or teacher forcing, etc. Both the generator and discriminator", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 397, + 505, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 397, + 505, + 410 + ], + "score": 1.0, + "content": "are optimized by SGD. We used grid search in the experiments with learning rate={1e-1,1e-2,1e-3},", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 408, + 343, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 321, + 421 + ], + "score": 1.0, + "content": "discriminator iteration step={1,5}, and used batchsize", + "type": "text" + }, + { + "bbox": [ + 322, + 409, + 338, + 419 + ], + "score": 0.79, + "content": "_ { = 6 4 }", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 408, + 343, + 421 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10.5, + "bbox_fs": [ + 105, + 376, + 506, + 421 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 425, + 505, + 535 + ], + "lines": [ + { + "bbox": [ + 105, + 424, + 505, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 424, + 505, + 439 + ], + "score": 1.0, + "content": "For human evaluation, we randomly selected 25 inputs from the testing set, and decoded using", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 435, + 505, + 450 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 505, + 450 + ], + "score": 1.0, + "content": "argmax policy, beam search, and MMI (Li et al., 2015)4. We presented both an input and the", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 447, + 507, + 462 + ], + "spans": [ + { + "bbox": [ + 104, + 447, + 507, + 462 + ], + "score": 1.0, + "content": "generated outputs to 8 and 4 judges respectively, and we asked them to do Turing test (correct or", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 457, + 505, + 471 + ], + "spans": [ + { + "bbox": [ + 105, + 457, + 505, + 471 + ], + "score": 1.0, + "content": "not) of the coherence and sentence structure. Coherence is the rationality of the generated responses", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 104, + 469, + 506, + 483 + ], + "spans": [ + { + "bbox": [ + 104, + 469, + 506, + 483 + ], + "score": 1.0, + "content": "given inputs. Sentence structure is the correctness and complexity of grammar. The sentences", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 104, + 480, + 506, + 493 + ], + "spans": [ + { + "bbox": [ + 104, + 480, + 506, + 493 + ], + "score": 1.0, + "content": "provide specific information would be considered as having better sentence structure rather than the", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 104, + 491, + 506, + 505 + ], + "spans": [ + { + "bbox": [ + 104, + 491, + 506, + 505 + ], + "score": 1.0, + "content": "general ones (egs. I don’t know.) due to more complex grammar. In Table 3, the two measures are", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 503, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 106, + 503, + 505, + 514 + ], + "score": 1.0, + "content": "labeled as CoHS (Coherence Human Score) and SHS (Sentence structure Human Score). We also", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 512, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 512, + 505, + 525 + ], + "score": 1.0, + "content": "show the BLEU score of each algorithm. It was already found that BLEU score is inconsistent with", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 524, + 496, + 536 + ], + "spans": [ + { + "bbox": [ + 106, + 524, + 496, + 536 + ], + "score": 1.0, + "content": "human evaluation (Liu et al., 2016), we also observe the same phenomenon it in our experiments.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 17.5, + "bbox_fs": [ + 104, + 424, + 507, + 536 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 541, + 505, + 694 + ], + "lines": [ + { + "bbox": [ + 105, + 539, + 506, + 555 + ], + "spans": [ + { + "bbox": [ + 105, + 539, + 506, + 555 + ], + "score": 1.0, + "content": "We show the CoHS and SHS of 15 different results (5 different algorithms and 3 different decoding", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 104, + 551, + 505, + 566 + ], + "spans": [ + { + "bbox": [ + 104, + 551, + 505, + 566 + ], + "score": 1.0, + "content": "methods) in Table 3. First, we can see decoding using beam search or MMI improve CoHS. Step-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 563, + 505, + 576 + ], + "spans": [ + { + "bbox": [ + 105, + 563, + 505, + 576 + ], + "score": 1.0, + "content": "GAN obtains the best performance in terms of CoHS when using argmax policy or beam search,", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 574, + 506, + 587 + ], + "spans": [ + { + "bbox": [ + 105, + 574, + 506, + 587 + ], + "score": 1.0, + "content": "but StepGAN cannot further increase the performance using MMI. When using MMI, the CoHS of", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 585, + 506, + 597 + ], + "spans": [ + { + "bbox": [ + 105, + 585, + 506, + 597 + ], + "score": 1.0, + "content": "MLE, SeqGAN and StepGAN are comparable. Second, argmax policy has higher SHS than beam", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 596, + 505, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 596, + 505, + 609 + ], + "score": 1.0, + "content": "search and MMI in all cases. In the meantime, GANs have higher SHS than MLE, and StepGAN", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 607, + 505, + 620 + ], + "spans": [ + { + "bbox": [ + 105, + 607, + 505, + 620 + ], + "score": 1.0, + "content": "has the highest score with argmax. The inconsistency of improvement between argmax policy, beam", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 618, + 505, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 618, + 505, + 630 + ], + "score": 1.0, + "content": "search and MMI is very likely because that the GANs are learned with the softmax policy and do not", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 628, + 505, + 641 + ], + "spans": [ + { + "bbox": [ + 106, + 628, + 505, + 641 + ], + "score": 1.0, + "content": "consider beam search and MMI during training. Additionally, we know beam search and MMI max-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 640, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 106, + 640, + 505, + 653 + ], + "score": 1.0, + "content": "imize the probability of response given an input without maintaining the probability of the response", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 650, + 505, + 664 + ], + "spans": [ + { + "bbox": [ + 105, + 650, + 505, + 664 + ], + "score": 1.0, + "content": "itself. This makes them prefer a coherence response rather than a good sentence structure. These", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 662, + 505, + 674 + ], + "spans": [ + { + "bbox": [ + 106, + 662, + 505, + 674 + ], + "score": 1.0, + "content": "statistics show that SeqGAN, MaliGAN, and REGS cannot consistently improve both coherence", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 672, + 505, + 685 + ], + "spans": [ + { + "bbox": [ + 105, + 672, + 505, + 685 + ], + "score": 1.0, + "content": "and sentence structure, whereas StepGAN outperforms MLE in terms both CoHS and SHS with all", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 684, + 188, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 684, + 188, + 695 + ], + "score": 1.0, + "content": "decoding methods.5", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 29.5, + "bbox_fs": [ + 104, + 539, + 506, + 695 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 110, + 87, + 479, + 294 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 110, + 87, + 479, + 294 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 110, + 87, + 479, + 294 + ], + "spans": [ + { + "bbox": [ + 110, + 87, + 479, + 294 + ], + "score": 0.961, + "type": "image", + "image_path": "2f5e0ffc3242f4a5aab01b71dbbb5daaaca0aa7de2df387887037e42946a04f8.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 110, + 87, + 479, + 156.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 110, + 156.0, + 479, + 225.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 110, + 225.0, + 479, + 294.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 302, + 505, + 347 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 302, + 505, + 316 + ], + "spans": [ + { + "bbox": [ + 105, + 302, + 505, + 316 + ], + "score": 1.0, + "content": "Figure 3: The variation of discriminators’ scores using different GAN algorithms during training", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 313, + 504, + 326 + ], + "spans": [ + { + "bbox": [ + 105, + 313, + 415, + 326 + ], + "score": 1.0, + "content": "iterations. The printed color is normalized throughout the generation steps", + "type": "text" + }, + { + "bbox": [ + 416, + 316, + 421, + 324 + ], + "score": 0.33, + "content": "\\mathbf { \\bar { x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 422, + 313, + 504, + 326 + ], + "score": 1.0, + "content": "-axis) for each algo-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 325, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 506, + 338 + ], + "score": 1.0, + "content": "rithm. (a)(b) are given “how are you ?” as input, and (c)(d) are given “what ’s your name ?” as", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 104, + 335, + 133, + 349 + ], + "spans": [ + { + "bbox": [ + 104, + 335, + 133, + 349 + ], + "score": 1.0, + "content": "input.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + } + ], + "index": 2.75 + }, + { + "type": "text", + "bbox": [ + 107, + 375, + 505, + 464 + ], + "lines": [ + { + "bbox": [ + 106, + 375, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 106, + 375, + 505, + 388 + ], + "score": 1.0, + "content": "To understand what the discriminators learn, we measure the variance throughout the training itera-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 386, + 505, + 400 + ], + "spans": [ + { + "bbox": [ + 105, + 386, + 505, + 400 + ], + "score": 1.0, + "content": "tions at each generation step. In adversarial learning, discriminator’s scores oscillate during training", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 398, + 506, + 409 + ], + "spans": [ + { + "bbox": [ + 105, + 398, + 506, + 409 + ], + "score": 1.0, + "content": "according to the current performance of generator. We argue that discriminator’s score for the most", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 409, + 506, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 409, + 506, + 421 + ], + "score": 1.0, + "content": "crucial generation step is the most easy to oscillate. This is because the generation step is the most", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 419, + 504, + 431 + ], + "spans": [ + { + "bbox": [ + 105, + 419, + 504, + 431 + ], + "score": 1.0, + "content": "important one for discriminator to identify whether it’s real or fake. In Fig. (3), we show four exam-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 430, + 505, + 443 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 505, + 443 + ], + "score": 1.0, + "content": "ples. Fig. (3a) and Fig. (3b) are respectively true response and wrong response given input question", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 441, + 505, + 455 + ], + "spans": [ + { + "bbox": [ + 106, + 441, + 505, + 455 + ], + "score": 1.0, + "content": "”how are you ?”, and Fig. (3c) and Fig. (3d) are given input question ”what ’s your name ?. The", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 452, + 366, + 465 + ], + "spans": [ + { + "bbox": [ + 106, + 452, + 366, + 465 + ], + "score": 1.0, + "content": "darker color indicates the higher variance on the generation step.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 10.5 + }, + { + "type": "text", + "bbox": [ + 106, + 469, + 505, + 623 + ], + "lines": [ + { + "bbox": [ + 105, + 469, + 505, + 483 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 505, + 483 + ], + "score": 1.0, + "content": "In Fig. (3), the colors for SeqGAN is always the same. Because the disriminator of SeqGAN only", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 481, + 505, + 492 + ], + "spans": [ + { + "bbox": [ + 106, + 481, + 505, + 492 + ], + "score": 1.0, + "content": "evaluate the whole sequence, the generation steps means no difference to discriminator. Second,", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 490, + 506, + 505 + ], + "spans": [ + { + "bbox": [ + 105, + 490, + 506, + 505 + ], + "score": 1.0, + "content": "REGS and StepGAN both aim to approximate Monte-Carlo search on SeqGAN, but in practice,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 503, + 504, + 514 + ], + "spans": [ + { + "bbox": [ + 106, + 503, + 504, + 514 + ], + "score": 1.0, + "content": "we can clearly see that the variance of REGS is very different from Monte Carlo search. This is", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 514, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 106, + 514, + 505, + 525 + ], + "score": 1.0, + "content": "because REGS considers non-terminated episodes, which makes REGS has to spend extra effort on", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 524, + 505, + 536 + ], + "spans": [ + { + "bbox": [ + 106, + 524, + 403, + 536 + ], + "score": 1.0, + "content": "the generation maximum length to check whether there’s a terminal state", + "type": "text" + }, + { + "bbox": [ + 403, + 524, + 452, + 535 + ], + "score": 0.87, + "content": "( < E O S > )", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 524, + 505, + 536 + ], + "score": 1.0, + "content": ". The results", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 534, + 505, + 547 + ], + "spans": [ + { + "bbox": [ + 105, + 534, + 505, + 547 + ], + "score": 1.0, + "content": "of StepGAN and Monte Carlo search (MC-SeqGAN) are quite similar. Based on MC-SeqGAN", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 547, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 106, + 547, + 505, + 558 + ], + "score": 1.0, + "content": "and StepGAN, the important parts (with darker colors) in the sentences for discriminating the true", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 556, + 506, + 570 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 506, + 570 + ], + "score": 1.0, + "content": "ones from fake correspond to human knowledge. For example, ”fine , thank you ” are the most", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 568, + 505, + 581 + ], + "spans": [ + { + "bbox": [ + 106, + 568, + 505, + 581 + ], + "score": 1.0, + "content": "important region in Fig. (3a), ”sorry , i ’m sorry” are the most important region in Fig. (3b) when", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 578, + 506, + 592 + ], + "spans": [ + { + "bbox": [ + 105, + 578, + 506, + 592 + ], + "score": 1.0, + "content": "answering ”how are you ?”. When given ”what ’s your name ?”, MC-SeqGAN and StepGAN focus", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 590, + 505, + 603 + ], + "spans": [ + { + "bbox": [ + 106, + 590, + 505, + 603 + ], + "score": 1.0, + "content": "on ”’m john” in Fig. (3c) and ”sorry” in Fig. (3d). We believe the success of StepGAN comes from", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 601, + 505, + 614 + ], + "spans": [ + { + "bbox": [ + 106, + 601, + 505, + 614 + ], + "score": 1.0, + "content": "estimating the goodness of a sequence at every generation step as Monte Carlo search, but with little", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 613, + 183, + 624 + ], + "spans": [ + { + "bbox": [ + 106, + 613, + 183, + 624 + ], + "score": 1.0, + "content": "extra computation.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 21.5 + }, + { + "type": "title", + "bbox": [ + 107, + 647, + 195, + 659 + ], + "lines": [ + { + "bbox": [ + 105, + 645, + 197, + 663 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 197, + 663 + ], + "score": 1.0, + "content": "6 CONCLUSION", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 107, + 676, + 504, + 731 + ], + "lines": [ + { + "bbox": [ + 105, + 676, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 505, + 690 + ], + "score": 1.0, + "content": "In this paper we propose StepGAN to approximate Monte Carlo search with a much lower compu-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "tational cost.We show that the proposed StepGAN performs equally to or outperforms the state-of-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "score": 1.0, + "content": "the-art GAN algorithms on artificial grammars. On a representative real-world conditional sequence", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "score": 1.0, + "content": "generation task–dialogue generation, StepGAN also outperforms other approaches on both coher-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 721, + 221, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 221, + 733 + ], + "score": 1.0, + "content": "ence and sentence structure.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32 + } + ], + "page_idx": 8, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "score": 1.0, + "content": "9", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 110, + 87, + 479, + 294 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 110, + 87, + 479, + 294 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 110, + 87, + 479, + 294 + ], + "spans": [ + { + "bbox": [ + 110, + 87, + 479, + 294 + ], + "score": 0.961, + "type": "image", + "image_path": "2f5e0ffc3242f4a5aab01b71dbbb5daaaca0aa7de2df387887037e42946a04f8.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 110, + 87, + 479, + 156.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 110, + 156.0, + 479, + 225.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 110, + 225.0, + 479, + 294.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 302, + 505, + 347 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 302, + 505, + 316 + ], + "spans": [ + { + "bbox": [ + 105, + 302, + 505, + 316 + ], + "score": 1.0, + "content": "Figure 3: The variation of discriminators’ scores using different GAN algorithms during training", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 313, + 504, + 326 + ], + "spans": [ + { + "bbox": [ + 105, + 313, + 415, + 326 + ], + "score": 1.0, + "content": "iterations. The printed color is normalized throughout the generation steps", + "type": "text" + }, + { + "bbox": [ + 416, + 316, + 421, + 324 + ], + "score": 0.33, + "content": "\\mathbf { \\bar { x } }", + "type": "inline_equation" + }, + { + "bbox": [ + 422, + 313, + 504, + 326 + ], + "score": 1.0, + "content": "-axis) for each algo-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 325, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 506, + 338 + ], + "score": 1.0, + "content": "rithm. (a)(b) are given “how are you ?” as input, and (c)(d) are given “what ’s your name ?” as", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 104, + 335, + 133, + 349 + ], + "spans": [ + { + "bbox": [ + 104, + 335, + 133, + 349 + ], + "score": 1.0, + "content": "input.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + } + ], + "index": 2.75 + }, + { + "type": "text", + "bbox": [ + 107, + 375, + 505, + 464 + ], + "lines": [ + { + "bbox": [ + 106, + 375, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 106, + 375, + 505, + 388 + ], + "score": 1.0, + "content": "To understand what the discriminators learn, we measure the variance throughout the training itera-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 386, + 505, + 400 + ], + "spans": [ + { + "bbox": [ + 105, + 386, + 505, + 400 + ], + "score": 1.0, + "content": "tions at each generation step. In adversarial learning, discriminator’s scores oscillate during training", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 398, + 506, + 409 + ], + "spans": [ + { + "bbox": [ + 105, + 398, + 506, + 409 + ], + "score": 1.0, + "content": "according to the current performance of generator. We argue that discriminator’s score for the most", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 409, + 506, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 409, + 506, + 421 + ], + "score": 1.0, + "content": "crucial generation step is the most easy to oscillate. This is because the generation step is the most", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 419, + 504, + 431 + ], + "spans": [ + { + "bbox": [ + 105, + 419, + 504, + 431 + ], + "score": 1.0, + "content": "important one for discriminator to identify whether it’s real or fake. In Fig. (3), we show four exam-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 430, + 505, + 443 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 505, + 443 + ], + "score": 1.0, + "content": "ples. Fig. (3a) and Fig. (3b) are respectively true response and wrong response given input question", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 441, + 505, + 455 + ], + "spans": [ + { + "bbox": [ + 106, + 441, + 505, + 455 + ], + "score": 1.0, + "content": "”how are you ?”, and Fig. (3c) and Fig. (3d) are given input question ”what ’s your name ?. The", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 452, + 366, + 465 + ], + "spans": [ + { + "bbox": [ + 106, + 452, + 366, + 465 + ], + "score": 1.0, + "content": "darker color indicates the higher variance on the generation step.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 10.5, + "bbox_fs": [ + 105, + 375, + 506, + 465 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 469, + 505, + 623 + ], + "lines": [ + { + "bbox": [ + 105, + 469, + 505, + 483 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 505, + 483 + ], + "score": 1.0, + "content": "In Fig. (3), the colors for SeqGAN is always the same. Because the disriminator of SeqGAN only", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 481, + 505, + 492 + ], + "spans": [ + { + "bbox": [ + 106, + 481, + 505, + 492 + ], + "score": 1.0, + "content": "evaluate the whole sequence, the generation steps means no difference to discriminator. Second,", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 490, + 506, + 505 + ], + "spans": [ + { + "bbox": [ + 105, + 490, + 506, + 505 + ], + "score": 1.0, + "content": "REGS and StepGAN both aim to approximate Monte-Carlo search on SeqGAN, but in practice,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 503, + 504, + 514 + ], + "spans": [ + { + "bbox": [ + 106, + 503, + 504, + 514 + ], + "score": 1.0, + "content": "we can clearly see that the variance of REGS is very different from Monte Carlo search. This is", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 514, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 106, + 514, + 505, + 525 + ], + "score": 1.0, + "content": "because REGS considers non-terminated episodes, which makes REGS has to spend extra effort on", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 524, + 505, + 536 + ], + "spans": [ + { + "bbox": [ + 106, + 524, + 403, + 536 + ], + "score": 1.0, + "content": "the generation maximum length to check whether there’s a terminal state", + "type": "text" + }, + { + "bbox": [ + 403, + 524, + 452, + 535 + ], + "score": 0.87, + "content": "( < E O S > )", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 524, + 505, + 536 + ], + "score": 1.0, + "content": ". The results", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 534, + 505, + 547 + ], + "spans": [ + { + "bbox": [ + 105, + 534, + 505, + 547 + ], + "score": 1.0, + "content": "of StepGAN and Monte Carlo search (MC-SeqGAN) are quite similar. Based on MC-SeqGAN", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 547, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 106, + 547, + 505, + 558 + ], + "score": 1.0, + "content": "and StepGAN, the important parts (with darker colors) in the sentences for discriminating the true", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 556, + 506, + 570 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 506, + 570 + ], + "score": 1.0, + "content": "ones from fake correspond to human knowledge. For example, ”fine , thank you ” are the most", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 568, + 505, + 581 + ], + "spans": [ + { + "bbox": [ + 106, + 568, + 505, + 581 + ], + "score": 1.0, + "content": "important region in Fig. (3a), ”sorry , i ’m sorry” are the most important region in Fig. (3b) when", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 578, + 506, + 592 + ], + "spans": [ + { + "bbox": [ + 105, + 578, + 506, + 592 + ], + "score": 1.0, + "content": "answering ”how are you ?”. When given ”what ’s your name ?”, MC-SeqGAN and StepGAN focus", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 590, + 505, + 603 + ], + "spans": [ + { + "bbox": [ + 106, + 590, + 505, + 603 + ], + "score": 1.0, + "content": "on ”’m john” in Fig. (3c) and ”sorry” in Fig. (3d). We believe the success of StepGAN comes from", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 601, + 505, + 614 + ], + "spans": [ + { + "bbox": [ + 106, + 601, + 505, + 614 + ], + "score": 1.0, + "content": "estimating the goodness of a sequence at every generation step as Monte Carlo search, but with little", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 613, + 183, + 624 + ], + "spans": [ + { + "bbox": [ + 106, + 613, + 183, + 624 + ], + "score": 1.0, + "content": "extra computation.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 21.5, + "bbox_fs": [ + 105, + 469, + 506, + 624 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 647, + 195, + 659 + ], + "lines": [ + { + "bbox": [ + 105, + 645, + 197, + 663 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 197, + 663 + ], + "score": 1.0, + "content": "6 CONCLUSION", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 107, + 676, + 504, + 731 + ], + "lines": [ + { + "bbox": [ + 105, + 676, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 505, + 690 + ], + "score": 1.0, + "content": "In this paper we propose StepGAN to approximate Monte Carlo search with a much lower compu-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "tational cost.We show that the proposed StepGAN performs equally to or outperforms the state-of-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "score": 1.0, + "content": "the-art GAN algorithms on artificial grammars. On a representative real-world conditional sequence", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "score": 1.0, + "content": "generation task–dialogue generation, StepGAN also outperforms other approaches on both coher-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 721, + 221, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 221, + 733 + ], + "score": 1.0, + "content": "ence and sentence structure.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32, + "bbox_fs": [ + 105, + 676, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 137 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 506, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 506, + 95 + ], + "score": 1.0, + "content": "Our proposed artificial grammars not only accurately reflect model coverage and accuracy but also", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "boast clearly distinguishable styles. For example, the sequence style can be the length, the counting", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 105, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 505, + 117 + ], + "score": 1.0, + "content": "style can be the selected digit position, and the addition style can be the selected partition position.", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 114, + 506, + 129 + ], + "spans": [ + { + "bbox": [ + 105, + 114, + 506, + 129 + ], + "score": 1.0, + "content": "This property lends itself to investigating style transfering for sequences generation, which is one of", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 209, + 138 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 209, + 138 + ], + "score": 1.0, + "content": "our aims for future work.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 104, + 154, + 507, + 740 + ], + "lines": [ + { + "bbox": [ + 106, + 154, + 176, + 168 + ], + "spans": [ + { + "bbox": [ + 106, + 154, + 176, + 168 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 173, + 506, + 186 + ], + "spans": [ + { + "bbox": [ + 105, + 173, + 506, + 186 + ], + "score": 1.0, + "content": "Dzmitry Bahdanau, Philemon Brakel, Kelvin Xu, Anirudh Goyal, Ryan Lowe, Joelle Pineau, Aaron", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 116, + 185, + 506, + 199 + ], + "spans": [ + { + "bbox": [ + 116, + 185, + 506, + 199 + ], + "score": 1.0, + "content": "Courville, and Yoshua Bengio. An actor-critic algorithm for sequence prediction. arXiv preprint", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 116, + 196, + 219, + 208 + ], + "spans": [ + { + "bbox": [ + 116, + 196, + 219, + 208 + ], + "score": 1.0, + "content": "arXiv:1607.07086, 2016.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 215, + 506, + 229 + ], + "spans": [ + { + "bbox": [ + 105, + 215, + 506, + 229 + ], + "score": 1.0, + "content": "Samy Bengio, Oriol Vinyals, Navdeep Jaitly, and Noam Shazeer. Scheduled sampling for sequence", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 226, + 505, + 240 + ], + "spans": [ + { + "bbox": [ + 115, + 226, + 505, + 240 + ], + "score": 1.0, + "content": "prediction with recurrent neural networks. In Advances in Neural Information Processing Sys-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 116, + 237, + 230, + 250 + ], + "spans": [ + { + "bbox": [ + 116, + 237, + 230, + 250 + ], + "score": 1.0, + "content": "tems, pp. 1171–1179, 2015.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 257, + 506, + 271 + ], + "spans": [ + { + "bbox": [ + 106, + 257, + 506, + 271 + ], + "score": 1.0, + "content": "Tong Che, Yanran Li, Ruixiang Zhang, R Devon Hjelm, Wenjie Li, Yangqiu Song, and Yoshua", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 116, + 267, + 506, + 282 + ], + "spans": [ + { + "bbox": [ + 116, + 267, + 506, + 282 + ], + "score": 1.0, + "content": "Bengio. Maximum-likelihood augmented discrete generative adversarial networks. arXiv preprint", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 116, + 279, + 219, + 291 + ], + "spans": [ + { + "bbox": [ + 116, + 279, + 219, + 291 + ], + "score": 1.0, + "content": "arXiv:1702.07983, 2017.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 299, + 506, + 313 + ], + "spans": [ + { + "bbox": [ + 105, + 299, + 506, + 313 + ], + "score": 1.0, + "content": "Junyoung Chung, Caglar Gulcehre, KyungHyun Cho, and Yoshua Bengio. Empirical evaluation of", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 114, + 309, + 498, + 322 + ], + "spans": [ + { + "bbox": [ + 114, + 309, + 498, + 322 + ], + "score": 1.0, + "content": "gated recurrent neural networks on sequence modeling. arXiv preprint arXiv:1412.3555, 2014.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 330, + 505, + 342 + ], + "spans": [ + { + "bbox": [ + 105, + 330, + 505, + 342 + ], + "score": 1.0, + "content": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 116, + 340, + 505, + 353 + ], + "spans": [ + { + "bbox": [ + 116, + 340, + 505, + 353 + ], + "score": 1.0, + "content": "Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural infor-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 114, + 350, + 318, + 364 + ], + "spans": [ + { + "bbox": [ + 114, + 350, + 318, + 364 + ], + "score": 1.0, + "content": "mation processing systems, pp. 2672–2680, 2014.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 371, + 505, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 371, + 505, + 383 + ], + "score": 1.0, + "content": "Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron Courville. Im-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 114, + 382, + 426, + 395 + ], + "spans": [ + { + "bbox": [ + 114, + 382, + 426, + 395 + ], + "score": 1.0, + "content": "proved training of wasserstein gans. arXiv preprint arXiv:1704.00028, 2017.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 402, + 505, + 414 + ], + "spans": [ + { + "bbox": [ + 106, + 402, + 505, + 414 + ], + "score": 1.0, + "content": "Kirthevasan Kandasamy, Yoram Bachrach, Ryota Tomioka, Daniel Tarlow, and David Carter.", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 116, + 413, + 505, + 425 + ], + "spans": [ + { + "bbox": [ + 116, + 413, + 505, + 425 + ], + "score": 1.0, + "content": "Batch policy gradient methods for improving neural conversation models. arXiv preprint", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 116, + 424, + 219, + 436 + ], + "spans": [ + { + "bbox": [ + 116, + 424, + 219, + 436 + ], + "score": 1.0, + "content": "arXiv:1702.03334, 2017.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 442, + 506, + 456 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 506, + 456 + ], + "score": 1.0, + "content": "Matt J Kusner and Jose Miguel Hern ´ andez-Lobato. Gans for sequences of discrete elements with ´", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 116, + 455, + 412, + 467 + ], + "spans": [ + { + "bbox": [ + 116, + 455, + 412, + 467 + ], + "score": 1.0, + "content": "the gumbel-softmax distribution. arXiv preprint arXiv:1611.04051, 2016.", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 104, + 472, + 506, + 488 + ], + "spans": [ + { + "bbox": [ + 104, + 472, + 506, + 488 + ], + "score": 1.0, + "content": "Jiwei Li, Michel Galley, Chris Brockett, Jianfeng Gao, and Bill Dolan. A diversity-promoting", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 116, + 485, + 482, + 497 + ], + "spans": [ + { + "bbox": [ + 116, + 485, + 482, + 497 + ], + "score": 1.0, + "content": "objective function for neural conversation models. arXiv preprint arXiv:1510.03055, 2015.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 505, + 505, + 517 + ], + "spans": [ + { + "bbox": [ + 105, + 505, + 505, + 517 + ], + "score": 1.0, + "content": "Jiwei Li, Will Monroe, Tianlin Shi, Alan Ritter, and Dan Jurafsky. Adversarial learning for neural", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 116, + 515, + 363, + 528 + ], + "spans": [ + { + "bbox": [ + 116, + 515, + 363, + 528 + ], + "score": 1.0, + "content": "dialogue generation. arXiv preprint arXiv:1701.06547, 2017.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 534, + 506, + 549 + ], + "spans": [ + { + "bbox": [ + 105, + 534, + 506, + 549 + ], + "score": 1.0, + "content": "Kevin Lin, Dianqi Li, Xiaodong He, Zhengyou Zhang, and Ming-Ting Sun. Adversarial ranking for", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 114, + 545, + 366, + 559 + ], + "spans": [ + { + "bbox": [ + 114, + 545, + 366, + 559 + ], + "score": 1.0, + "content": "language generation. arXiv preprint arXiv:1705.11001, 2017.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 564, + 506, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 564, + 506, + 579 + ], + "score": 1.0, + "content": "Chia-Wei Liu, Ryan Lowe, Iulian V Serban, Michael Noseworthy, Laurent Charlin, and Joelle", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 116, + 577, + 505, + 589 + ], + "spans": [ + { + "bbox": [ + 116, + 577, + 505, + 589 + ], + "score": 1.0, + "content": "Pineau. How not to evaluate your dialogue system: An empirical study of unsupervised eval-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 116, + 588, + 474, + 600 + ], + "spans": [ + { + "bbox": [ + 116, + 588, + 474, + 600 + ], + "score": 1.0, + "content": "uation metrics for dialogue response generation. arXiv preprint arXiv:1603.08023, 2016.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 605, + 506, + 621 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 506, + 621 + ], + "score": 1.0, + "content": "Mehdi Mirza and Simon Osindero. Conditional generative adversarial nets. arXiv preprint", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 116, + 618, + 215, + 631 + ], + "spans": [ + { + "bbox": [ + 116, + 618, + 215, + 631 + ], + "score": 1.0, + "content": "arXiv:1411.1784, 2014.", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 636, + 506, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 636, + 506, + 651 + ], + "score": 1.0, + "content": "Ofir Press, Amir Bar, Ben Bogin, Jonathan Berant, and Lior Wolf. Language generation with re-", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 115, + 649, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 115, + 649, + 505, + 661 + ], + "score": 1.0, + "content": "current generative adversarial networks without pre-training. arXiv preprint arXiv:1706.01399,", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 116, + 658, + 144, + 673 + ], + "spans": [ + { + "bbox": [ + 116, + 658, + 144, + 673 + ], + "score": 1.0, + "content": "2017.", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 679, + 505, + 692 + ], + "spans": [ + { + "bbox": [ + 106, + 679, + 505, + 692 + ], + "score": 1.0, + "content": "Sai Rajeswar, Sandeep Subramanian, Francis Dutil, Christopher Pal, and Aaron Courville. Adver-", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 114, + 690, + 431, + 703 + ], + "spans": [ + { + "bbox": [ + 114, + 690, + 431, + 703 + ], + "score": 1.0, + "content": "sarial generation of natural language. arXiv preprint arXiv:1705.10929, 2017.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "score": 1.0, + "content": "Marc’Aurelio Ranzato, Sumit Chopra, Michael Auli, and Wojciech Zaremba. Sequence level train-", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 114, + 720, + 423, + 734 + ], + "spans": [ + { + "bbox": [ + 114, + 720, + 423, + 734 + ], + "score": 1.0, + "content": "ing with recurrent neural networks. arXiv preprint arXiv:1511.06732, 2015.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 24.5 + } + ], + "page_idx": 9, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "10", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 137 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 506, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 506, + 95 + ], + "score": 1.0, + "content": "Our proposed artificial grammars not only accurately reflect model coverage and accuracy but also", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "boast clearly distinguishable styles. For example, the sequence style can be the length, the counting", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 105, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 505, + 117 + ], + "score": 1.0, + "content": "style can be the selected digit position, and the addition style can be the selected partition position.", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 114, + 506, + 129 + ], + "spans": [ + { + "bbox": [ + 105, + 114, + 506, + 129 + ], + "score": 1.0, + "content": "This property lends itself to investigating style transfering for sequences generation, which is one of", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 209, + 138 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 209, + 138 + ], + "score": 1.0, + "content": "our aims for future work.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 2, + "bbox_fs": [ + 105, + 82, + 506, + 138 + ] + }, + { + "type": "list", + "bbox": [ + 104, + 154, + 507, + 740 + ], + "lines": [ + { + "bbox": [ + 106, + 154, + 176, + 168 + ], + "spans": [ + { + "bbox": [ + 106, + 154, + 176, + 168 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 5, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 173, + 506, + 186 + ], + "spans": [ + { + "bbox": [ + 105, + 173, + 506, + 186 + ], + "score": 1.0, + "content": "Dzmitry Bahdanau, Philemon Brakel, Kelvin Xu, Anirudh Goyal, Ryan Lowe, Joelle Pineau, Aaron", + "type": "text" + } + ], + "index": 6, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 185, + 506, + 199 + ], + "spans": [ + { + "bbox": [ + 116, + 185, + 506, + 199 + ], + "score": 1.0, + "content": "Courville, and Yoshua Bengio. An actor-critic algorithm for sequence prediction. arXiv preprint", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 116, + 196, + 219, + 208 + ], + "spans": [ + { + "bbox": [ + 116, + 196, + 219, + 208 + ], + "score": 1.0, + "content": "arXiv:1607.07086, 2016.", + "type": "text" + } + ], + "index": 8, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 215, + 506, + 229 + ], + "spans": [ + { + "bbox": [ + 105, + 215, + 506, + 229 + ], + "score": 1.0, + "content": "Samy Bengio, Oriol Vinyals, Navdeep Jaitly, and Noam Shazeer. Scheduled sampling for sequence", + "type": "text" + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 226, + 505, + 240 + ], + "spans": [ + { + "bbox": [ + 115, + 226, + 505, + 240 + ], + "score": 1.0, + "content": "prediction with recurrent neural networks. In Advances in Neural Information Processing Sys-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 116, + 237, + 230, + 250 + ], + "spans": [ + { + "bbox": [ + 116, + 237, + 230, + 250 + ], + "score": 1.0, + "content": "tems, pp. 1171–1179, 2015.", + "type": "text" + } + ], + "index": 11, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 257, + 506, + 271 + ], + "spans": [ + { + "bbox": [ + 106, + 257, + 506, + 271 + ], + "score": 1.0, + "content": "Tong Che, Yanran Li, Ruixiang Zhang, R Devon Hjelm, Wenjie Li, Yangqiu Song, and Yoshua", + "type": "text" + } + ], + "index": 12, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 267, + 506, + 282 + ], + "spans": [ + { + "bbox": [ + 116, + 267, + 506, + 282 + ], + "score": 1.0, + "content": "Bengio. Maximum-likelihood augmented discrete generative adversarial networks. arXiv preprint", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 116, + 279, + 219, + 291 + ], + "spans": [ + { + "bbox": [ + 116, + 279, + 219, + 291 + ], + "score": 1.0, + "content": "arXiv:1702.07983, 2017.", + "type": "text" + } + ], + "index": 14, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 299, + 506, + 313 + ], + "spans": [ + { + "bbox": [ + 105, + 299, + 506, + 313 + ], + "score": 1.0, + "content": "Junyoung Chung, Caglar Gulcehre, KyungHyun Cho, and Yoshua Bengio. Empirical evaluation of", + "type": "text" + } + ], + "index": 15, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 309, + 498, + 322 + ], + "spans": [ + { + "bbox": [ + 114, + 309, + 498, + 322 + ], + "score": 1.0, + "content": "gated recurrent neural networks on sequence modeling. arXiv preprint arXiv:1412.3555, 2014.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 330, + 505, + 342 + ], + "spans": [ + { + "bbox": [ + 105, + 330, + 505, + 342 + ], + "score": 1.0, + "content": "Ian Goodfellow, Jean Pouget-Abadie, Mehdi Mirza, Bing Xu, David Warde-Farley, Sherjil Ozair,", + "type": "text" + } + ], + "index": 17, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 340, + 505, + 353 + ], + "spans": [ + { + "bbox": [ + 116, + 340, + 505, + 353 + ], + "score": 1.0, + "content": "Aaron Courville, and Yoshua Bengio. Generative adversarial nets. In Advances in neural infor-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 114, + 350, + 318, + 364 + ], + "spans": [ + { + "bbox": [ + 114, + 350, + 318, + 364 + ], + "score": 1.0, + "content": "mation processing systems, pp. 2672–2680, 2014.", + "type": "text" + } + ], + "index": 19, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 371, + 505, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 371, + 505, + 383 + ], + "score": 1.0, + "content": "Ishaan Gulrajani, Faruk Ahmed, Martin Arjovsky, Vincent Dumoulin, and Aaron Courville. Im-", + "type": "text" + } + ], + "index": 20, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 382, + 426, + 395 + ], + "spans": [ + { + "bbox": [ + 114, + 382, + 426, + 395 + ], + "score": 1.0, + "content": "proved training of wasserstein gans. arXiv preprint arXiv:1704.00028, 2017.", + "type": "text" + } + ], + "index": 21, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 402, + 505, + 414 + ], + "spans": [ + { + "bbox": [ + 106, + 402, + 505, + 414 + ], + "score": 1.0, + "content": "Kirthevasan Kandasamy, Yoram Bachrach, Ryota Tomioka, Daniel Tarlow, and David Carter.", + "type": "text" + } + ], + "index": 22, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 413, + 505, + 425 + ], + "spans": [ + { + "bbox": [ + 116, + 413, + 505, + 425 + ], + "score": 1.0, + "content": "Batch policy gradient methods for improving neural conversation models. arXiv preprint", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 116, + 424, + 219, + 436 + ], + "spans": [ + { + "bbox": [ + 116, + 424, + 219, + 436 + ], + "score": 1.0, + "content": "arXiv:1702.03334, 2017.", + "type": "text" + } + ], + "index": 24, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 442, + 506, + 456 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 506, + 456 + ], + "score": 1.0, + "content": "Matt J Kusner and Jose Miguel Hern ´ andez-Lobato. Gans for sequences of discrete elements with ´", + "type": "text" + } + ], + "index": 25, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 455, + 412, + 467 + ], + "spans": [ + { + "bbox": [ + 116, + 455, + 412, + 467 + ], + "score": 1.0, + "content": "the gumbel-softmax distribution. arXiv preprint arXiv:1611.04051, 2016.", + "type": "text" + } + ], + "index": 26, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 472, + 506, + 488 + ], + "spans": [ + { + "bbox": [ + 104, + 472, + 506, + 488 + ], + "score": 1.0, + "content": "Jiwei Li, Michel Galley, Chris Brockett, Jianfeng Gao, and Bill Dolan. A diversity-promoting", + "type": "text" + } + ], + "index": 27, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 485, + 482, + 497 + ], + "spans": [ + { + "bbox": [ + 116, + 485, + 482, + 497 + ], + "score": 1.0, + "content": "objective function for neural conversation models. arXiv preprint arXiv:1510.03055, 2015.", + "type": "text" + } + ], + "index": 28, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 505, + 505, + 517 + ], + "spans": [ + { + "bbox": [ + 105, + 505, + 505, + 517 + ], + "score": 1.0, + "content": "Jiwei Li, Will Monroe, Tianlin Shi, Alan Ritter, and Dan Jurafsky. Adversarial learning for neural", + "type": "text" + } + ], + "index": 29, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 515, + 363, + 528 + ], + "spans": [ + { + "bbox": [ + 116, + 515, + 363, + 528 + ], + "score": 1.0, + "content": "dialogue generation. arXiv preprint arXiv:1701.06547, 2017.", + "type": "text" + } + ], + "index": 30, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 534, + 506, + 549 + ], + "spans": [ + { + "bbox": [ + 105, + 534, + 506, + 549 + ], + "score": 1.0, + "content": "Kevin Lin, Dianqi Li, Xiaodong He, Zhengyou Zhang, and Ming-Ting Sun. Adversarial ranking for", + "type": "text" + } + ], + "index": 31, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 545, + 366, + 559 + ], + "spans": [ + { + "bbox": [ + 114, + 545, + 366, + 559 + ], + "score": 1.0, + "content": "language generation. arXiv preprint arXiv:1705.11001, 2017.", + "type": "text" + } + ], + "index": 32, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 564, + 506, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 564, + 506, + 579 + ], + "score": 1.0, + "content": "Chia-Wei Liu, Ryan Lowe, Iulian V Serban, Michael Noseworthy, Laurent Charlin, and Joelle", + "type": "text" + } + ], + "index": 33, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 577, + 505, + 589 + ], + "spans": [ + { + "bbox": [ + 116, + 577, + 505, + 589 + ], + "score": 1.0, + "content": "Pineau. How not to evaluate your dialogue system: An empirical study of unsupervised eval-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 116, + 588, + 474, + 600 + ], + "spans": [ + { + "bbox": [ + 116, + 588, + 474, + 600 + ], + "score": 1.0, + "content": "uation metrics for dialogue response generation. arXiv preprint arXiv:1603.08023, 2016.", + "type": "text" + } + ], + "index": 35, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 605, + 506, + 621 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 506, + 621 + ], + "score": 1.0, + "content": "Mehdi Mirza and Simon Osindero. Conditional generative adversarial nets. arXiv preprint", + "type": "text" + } + ], + "index": 36, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 618, + 215, + 631 + ], + "spans": [ + { + "bbox": [ + 116, + 618, + 215, + 631 + ], + "score": 1.0, + "content": "arXiv:1411.1784, 2014.", + "type": "text" + } + ], + "index": 37, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 636, + 506, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 636, + 506, + 651 + ], + "score": 1.0, + "content": "Ofir Press, Amir Bar, Ben Bogin, Jonathan Berant, and Lior Wolf. Language generation with re-", + "type": "text" + } + ], + "index": 38, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 649, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 115, + 649, + 505, + 661 + ], + "score": 1.0, + "content": "current generative adversarial networks without pre-training. arXiv preprint arXiv:1706.01399,", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 116, + 658, + 144, + 673 + ], + "spans": [ + { + "bbox": [ + 116, + 658, + 144, + 673 + ], + "score": 1.0, + "content": "2017.", + "type": "text" + } + ], + "index": 40, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 679, + 505, + 692 + ], + "spans": [ + { + "bbox": [ + 106, + 679, + 505, + 692 + ], + "score": 1.0, + "content": "Sai Rajeswar, Sandeep Subramanian, Francis Dutil, Christopher Pal, and Aaron Courville. Adver-", + "type": "text" + } + ], + "index": 41, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 690, + 431, + 703 + ], + "spans": [ + { + "bbox": [ + 114, + 690, + 431, + 703 + ], + "score": 1.0, + "content": "sarial generation of natural language. arXiv preprint arXiv:1705.10929, 2017.", + "type": "text" + } + ], + "index": 42, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "score": 1.0, + "content": "Marc’Aurelio Ranzato, Sumit Chopra, Michael Auli, and Wojciech Zaremba. Sequence level train-", + "type": "text" + } + ], + "index": 43, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 720, + 423, + 734 + ], + "spans": [ + { + "bbox": [ + 114, + 720, + 423, + 734 + ], + "score": 1.0, + "content": "ing with recurrent neural networks. arXiv preprint arXiv:1511.06732, 2015.", + "type": "text" + } + ], + "index": 44, + "is_list_end_line": true + } + ], + "index": 24.5, + "bbox_fs": [ + 104, + 154, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 504, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 504, + 95 + ], + "score": 1.0, + "content": "Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks.", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 93, + 427, + 107 + ], + "spans": [ + { + "bbox": [ + 115, + 93, + 427, + 107 + ], + "score": 1.0, + "content": "In Advances in neural information processing systems, pp. 3104–3112, 2014.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 106, + 112, + 503, + 135 + ], + "lines": [ + { + "bbox": [ + 106, + 112, + 504, + 124 + ], + "spans": [ + { + "bbox": [ + 106, + 112, + 504, + 124 + ], + "score": 1.0, + "content": "Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction, volume 1. MIT", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 115, + 124, + 213, + 136 + ], + "spans": [ + { + "bbox": [ + 115, + 124, + 213, + 136 + ], + "score": 1.0, + "content": "press Cambridge, 1998.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 107, + 142, + 504, + 186 + ], + "lines": [ + { + "bbox": [ + 105, + 142, + 505, + 154 + ], + "spans": [ + { + "bbox": [ + 105, + 142, + 505, + 154 + ], + "score": 1.0, + "content": "Jorg Tiedemann. News from OPUS - A collection of multilingual parallel corpora with tools ¨", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 116, + 154, + 505, + 165 + ], + "spans": [ + { + "bbox": [ + 116, + 154, + 505, + 165 + ], + "score": 1.0, + "content": "and interfaces. In N. Nicolov, K. Bontcheva, G. Angelova, and R. Mitkov (eds.), Recent Ad-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 164, + 506, + 177 + ], + "spans": [ + { + "bbox": [ + 115, + 164, + 506, + 177 + ], + "score": 1.0, + "content": "vances in Natural Language Processing, volume V, pp. 237–248. John Benjamins, Amster-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 116, + 175, + 402, + 187 + ], + "spans": [ + { + "bbox": [ + 116, + 175, + 402, + 187 + ], + "score": 1.0, + "content": "dam/Philadelphia, Borovets, Bulgaria, 2009. ISBN 978 90 272 4825 1.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5.5 + }, + { + "type": "text", + "bbox": [ + 106, + 194, + 503, + 206 + ], + "lines": [ + { + "bbox": [ + 105, + 192, + 505, + 207 + ], + "spans": [ + { + "bbox": [ + 105, + 192, + 505, + 207 + ], + "score": 1.0, + "content": "Oriol Vinyals and Quoc Le. A neural conversational model. arXiv preprint arXiv:1506.05869, 2015.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 106, + 213, + 504, + 235 + ], + "lines": [ + { + "bbox": [ + 106, + 212, + 505, + 226 + ], + "spans": [ + { + "bbox": [ + 106, + 212, + 505, + 226 + ], + "score": 1.0, + "content": "Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 223, + 324, + 236 + ], + "spans": [ + { + "bbox": [ + 115, + 223, + 324, + 236 + ], + "score": 1.0, + "content": "learning. Machine learning, 8(3-4):229–256, 1992.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9.5 + }, + { + "type": "text", + "bbox": [ + 106, + 243, + 504, + 265 + ], + "lines": [ + { + "bbox": [ + 105, + 241, + 506, + 257 + ], + "spans": [ + { + "bbox": [ + 105, + 241, + 506, + 257 + ], + "score": 1.0, + "content": "Lantao Yu, Weinan Zhang, Jun Wang, and Yong Yu. Seqgan: Sequence generative adversarial nets", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 116, + 253, + 330, + 266 + ], + "spans": [ + { + "bbox": [ + 116, + 253, + 330, + 266 + ], + "score": 1.0, + "content": "with policy gradient. In AAAI, pp. 2852–2858, 2017.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5 + }, + { + "type": "text", + "bbox": [ + 105, + 272, + 504, + 295 + ], + "lines": [ + { + "bbox": [ + 106, + 272, + 505, + 285 + ], + "spans": [ + { + "bbox": [ + 106, + 272, + 505, + 285 + ], + "score": 1.0, + "content": "Yizhe Zhang, Zhe Gan, Kai Fan, Zhi Chen, Ricardo Henao, Dinghan Shen, and Lawrence Carin.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 116, + 283, + 477, + 296 + ], + "spans": [ + { + "bbox": [ + 116, + 283, + 477, + 296 + ], + "score": 1.0, + "content": "Adversarial feature matching for text generation. arXiv preprint arXiv:1706.03850, 2017.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5 + }, + { + "type": "text", + "bbox": [ + 105, + 302, + 503, + 325 + ], + "lines": [ + { + "bbox": [ + 105, + 302, + 505, + 316 + ], + "spans": [ + { + "bbox": [ + 105, + 302, + 505, + 316 + ], + "score": 1.0, + "content": "Junbo Zhao, Michael Mathieu, and Yann LeCun. Energy-based generative adversarial network.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 115, + 313, + 279, + 326 + ], + "spans": [ + { + "bbox": [ + 115, + 313, + 279, + 326 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:1609.03126, 2016.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5 + } + ], + "page_idx": 10, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 504, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 504, + 95 + ], + "score": 1.0, + "content": "Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks.", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 93, + 427, + 107 + ], + "spans": [ + { + "bbox": [ + 115, + 93, + 427, + 107 + ], + "score": 1.0, + "content": "In Advances in neural information processing systems, pp. 3104–3112, 2014.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5, + "bbox_fs": [ + 106, + 82, + 504, + 107 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 112, + 503, + 135 + ], + "lines": [ + { + "bbox": [ + 106, + 112, + 504, + 124 + ], + "spans": [ + { + "bbox": [ + 106, + 112, + 504, + 124 + ], + "score": 1.0, + "content": "Richard S Sutton and Andrew G Barto. Reinforcement learning: An introduction, volume 1. MIT", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 115, + 124, + 213, + 136 + ], + "spans": [ + { + "bbox": [ + 115, + 124, + 213, + 136 + ], + "score": 1.0, + "content": "press Cambridge, 1998.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2.5, + "bbox_fs": [ + 106, + 112, + 504, + 136 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 142, + 504, + 186 + ], + "lines": [ + { + "bbox": [ + 105, + 142, + 505, + 154 + ], + "spans": [ + { + "bbox": [ + 105, + 142, + 505, + 154 + ], + "score": 1.0, + "content": "Jorg Tiedemann. News from OPUS - A collection of multilingual parallel corpora with tools ¨", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 116, + 154, + 505, + 165 + ], + "spans": [ + { + "bbox": [ + 116, + 154, + 505, + 165 + ], + "score": 1.0, + "content": "and interfaces. In N. Nicolov, K. Bontcheva, G. Angelova, and R. Mitkov (eds.), Recent Ad-", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 164, + 506, + 177 + ], + "spans": [ + { + "bbox": [ + 115, + 164, + 506, + 177 + ], + "score": 1.0, + "content": "vances in Natural Language Processing, volume V, pp. 237–248. John Benjamins, Amster-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 116, + 175, + 402, + 187 + ], + "spans": [ + { + "bbox": [ + 116, + 175, + 402, + 187 + ], + "score": 1.0, + "content": "dam/Philadelphia, Borovets, Bulgaria, 2009. ISBN 978 90 272 4825 1.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5.5, + "bbox_fs": [ + 105, + 142, + 506, + 187 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 194, + 503, + 206 + ], + "lines": [ + { + "bbox": [ + 105, + 192, + 505, + 207 + ], + "spans": [ + { + "bbox": [ + 105, + 192, + 505, + 207 + ], + "score": 1.0, + "content": "Oriol Vinyals and Quoc Le. A neural conversational model. arXiv preprint arXiv:1506.05869, 2015.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8, + "bbox_fs": [ + 105, + 192, + 505, + 207 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 213, + 504, + 235 + ], + "lines": [ + { + "bbox": [ + 106, + 212, + 505, + 226 + ], + "spans": [ + { + "bbox": [ + 106, + 212, + 505, + 226 + ], + "score": 1.0, + "content": "Ronald J Williams. Simple statistical gradient-following algorithms for connectionist reinforcement", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 223, + 324, + 236 + ], + "spans": [ + { + "bbox": [ + 115, + 223, + 324, + 236 + ], + "score": 1.0, + "content": "learning. Machine learning, 8(3-4):229–256, 1992.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9.5, + "bbox_fs": [ + 106, + 212, + 505, + 236 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 243, + 504, + 265 + ], + "lines": [ + { + "bbox": [ + 105, + 241, + 506, + 257 + ], + "spans": [ + { + "bbox": [ + 105, + 241, + 506, + 257 + ], + "score": 1.0, + "content": "Lantao Yu, Weinan Zhang, Jun Wang, and Yong Yu. Seqgan: Sequence generative adversarial nets", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 116, + 253, + 330, + 266 + ], + "spans": [ + { + "bbox": [ + 116, + 253, + 330, + 266 + ], + "score": 1.0, + "content": "with policy gradient. In AAAI, pp. 2852–2858, 2017.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5, + "bbox_fs": [ + 105, + 241, + 506, + 266 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 272, + 504, + 295 + ], + "lines": [ + { + "bbox": [ + 106, + 272, + 505, + 285 + ], + "spans": [ + { + "bbox": [ + 106, + 272, + 505, + 285 + ], + "score": 1.0, + "content": "Yizhe Zhang, Zhe Gan, Kai Fan, Zhi Chen, Ricardo Henao, Dinghan Shen, and Lawrence Carin.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 116, + 283, + 477, + 296 + ], + "spans": [ + { + "bbox": [ + 116, + 283, + 477, + 296 + ], + "score": 1.0, + "content": "Adversarial feature matching for text generation. arXiv preprint arXiv:1706.03850, 2017.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 13.5, + "bbox_fs": [ + 106, + 272, + 505, + 296 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 302, + 503, + 325 + ], + "lines": [ + { + "bbox": [ + 105, + 302, + 505, + 316 + ], + "spans": [ + { + "bbox": [ + 105, + 302, + 505, + 316 + ], + "score": 1.0, + "content": "Junbo Zhao, Michael Mathieu, and Yann LeCun. Energy-based generative adversarial network.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 115, + 313, + 279, + 326 + ], + "spans": [ + { + "bbox": [ + 115, + 313, + 279, + 326 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:1609.03126, 2016.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15.5, + "bbox_fs": [ + 105, + 302, + 505, + 326 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 81, + 363, + 94 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 363, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 363, + 95 + ], + "score": 1.0, + "content": "A APPENDIX: PSEUDO CODE OF STEPWISE GAN", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table", + "bbox": [ + 155, + 147, + 455, + 330 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 226, + 109, + 385, + 121 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 225, + 109, + 385, + 122 + ], + "spans": [ + { + "bbox": [ + 225, + 109, + 385, + 122 + ], + "score": 1.0, + "content": "Table 4: Pseudo code of stepwise GAN", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "table_caption", + "bbox": [ + 157, + 135, + 360, + 147 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 157, + 133, + 360, + 151 + ], + "spans": [ + { + "bbox": [ + 157, + 133, + 360, + 151 + ], + "score": 1.0, + "content": "Algorithm 1 Stepwise GAN (StepGAN) Training", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 2 + }, + { + "type": "table_body", + "bbox": [ + 155, + 147, + 455, + 330 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 155, + 147, + 455, + 330 + ], + "spans": [ + { + "bbox": [ + 155, + 147, + 455, + 330 + ], + "score": 0.583, + "html": "
1for number of training iterations do
2for i=1, D-steps do Sample (y,xR) from real data
3
4Sample xG ~ PG(.ly)
5Update D using equation (7) T
6D'(xly)=∑-1PD(x.tly)
7D* = arg maxD Ey~pR(y),R~pR(xly)[log(D'(xR|y))] +Ey~PR(y),xG~PG(xly)[log(1-D'(xG|y)]
8end for
9for i=1, G-steps do
10Sample y from real data
11Sample xG ~ PG(.ly)
12Update G using equation (9)
130G ←0G + na£D(x1...tly)Vlog(𝑝G(x£ly,x...t-1))
14end for
15end for
", + "type": "table", + "image_path": "36032d27352dfeba3b79e53b3edfc36ca22c1080b9805cc24a877d1dcceb9a67.jpg" + } + ] + } + ], + "index": 4, + "virtual_lines": [ + { + "bbox": [ + 155, + 147, + 455, + 208.0 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 155, + 208.0, + 455, + 269.0 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 155, + 269.0, + 455, + 330.0 + ], + "spans": [], + "index": 5 + } + ] + } + ], + "index": 2 + }, + { + "type": "title", + "bbox": [ + 107, + 360, + 460, + 374 + ], + "lines": [ + { + "bbox": [ + 104, + 359, + 462, + 376 + ], + "spans": [ + { + "bbox": [ + 104, + 359, + 462, + 376 + ], + "score": 1.0, + "content": "B WEIGHTED FACTORS SEARCH OF STEPGAN AND STEPGAN-SEQ", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "table", + "bbox": [ + 146, + 426, + 465, + 553 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 104, + 390, + 504, + 414 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 390, + 505, + 403 + ], + "spans": [ + { + "bbox": [ + 106, + 390, + 505, + 403 + ], + "score": 1.0, + "content": "Table 5: StepGAN and StepGAN-Seq with different weight factors. The dash (-) here notes that the", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 402, + 349, + 415 + ], + "spans": [ + { + "bbox": [ + 106, + 402, + 349, + 415 + ], + "score": 1.0, + "content": "weight factors yield neither improvements nor deterioration.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5 + }, + { + "type": "table_body", + "bbox": [ + 146, + 426, + 465, + 553 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 146, + 426, + 465, + 553 + ], + "spans": [ + { + "bbox": [ + 146, + 426, + 465, + 553 + ], + "score": 0.983, + "html": "
StepGAN StepGAN-Seq
AccAccSCovAccAccS Cov
SequenceUniform97.1975.9266.0897.1174.85 67.49
Increase97.1775.3366.75 97.1873.3068.19
Decrease97.1674.7367.1497.09 74.3467.48
CountingUniform77.2371.4370.1874.9170.70 69.84
Increasing74.5069.6670.8674.54 70.7470.11
Decreasing81.9872.2469.0275.47 70.6469.82
AdditionUniform44.2632.3931.9144.7732.34 31.65
Increasing11 -=11
Decreasing44.9432.1931.6745.55 32.4932.01
", + "type": "table", + "image_path": "7f26433ca7bf61c7ac142ba13ecfb24904cbf6f3fbade2612157dda630eceb1e.jpg" + } + ] + } + ], + "index": 10, + "virtual_lines": [ + { + "bbox": [ + 146, + 426, + 465, + 468.3333333333333 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 146, + 468.3333333333333, + 465, + 510.66666666666663 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 146, + 510.66666666666663, + 465, + 553.0 + ], + "spans": [], + "index": 11 + } + ] + } + ], + "index": 8.75 + }, + { + "type": "text", + "bbox": [ + 106, + 568, + 506, + 646 + ], + "lines": [ + { + "bbox": [ + 105, + 566, + 506, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 265, + 583 + ], + "score": 1.0, + "content": "We compare different weighted factors", + "type": "text" + }, + { + "bbox": [ + 266, + 568, + 280, + 579 + ], + "score": 0.92, + "content": "\\alpha ^ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 280, + 566, + 439, + 583 + ], + "score": 1.0, + "content": "for StepGAN and StepGAN-Seq, with", + "type": "text" + }, + { + "bbox": [ + 439, + 568, + 476, + 581 + ], + "score": 0.93, + "content": "\\begin{array} { r } { \\alpha _ { t } ^ { D } = \\frac { 1 } { T } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 477, + 566, + 506, + 583 + ], + "score": 1.0, + "content": "for all", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 579, + 506, + 592 + ], + "spans": [ + { + "bbox": [ + 106, + 579, + 506, + 592 + ], + "score": 1.0, + "content": "the presented cases. As depicted in Table 5, the three grammars are trained using three sorts of", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 104, + 588, + 506, + 605 + ], + "spans": [ + { + "bbox": [ + 104, + 588, + 219, + 605 + ], + "score": 1.0, + "content": "weighted factors: uniform", + "type": "text" + }, + { + "bbox": [ + 219, + 590, + 258, + 603 + ], + "score": 0.89, + "content": "\\begin{array} { r } { \\dot { \\left( \\alpha _ { t } ^ { G } \\ = \\ 1 \\right) } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 258, + 588, + 312, + 605 + ], + "score": 1.0, + "content": "), increasing", + "type": "text" + }, + { + "bbox": [ + 312, + 590, + 349, + 603 + ], + "score": 0.89, + "content": "( \\alpha _ { t } ^ { G } \\ = t )", + "type": "inline_equation" + }, + { + "bbox": [ + 350, + 588, + 421, + 605 + ], + "score": 1.0, + "content": ", and decreasing", + "type": "text" + }, + { + "bbox": [ + 422, + 590, + 501, + 603 + ], + "score": 0.9, + "content": "( \\alpha _ { t } ^ { G } \\ = \\ T - \\ t + 1 )", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 588, + 506, + 605 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 601, + 506, + 614 + ], + "spans": [ + { + "bbox": [ + 105, + 601, + 506, + 614 + ], + "score": 1.0, + "content": "The results clearly show that the time-step-decreasing weight factors positively affect training. We", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 612, + 505, + 625 + ], + "spans": [ + { + "bbox": [ + 105, + 612, + 505, + 625 + ], + "score": 1.0, + "content": "believe this is because the training spirit of decreased weighted factor start from first correcting", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 624, + 505, + 635 + ], + "spans": [ + { + "bbox": [ + 106, + 624, + 505, + 635 + ], + "score": 1.0, + "content": "prefix. After correcting prefix, it becomes easier to correct the suffix. Please refer to section 5 if you", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 634, + 312, + 647 + ], + "spans": [ + { + "bbox": [ + 106, + 634, + 312, + 647 + ], + "score": 1.0, + "content": "are interested in the details of Acc, AccS, and Cov.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 15 + }, + { + "type": "title", + "bbox": [ + 107, + 662, + 377, + 676 + ], + "lines": [ + { + "bbox": [ + 105, + 659, + 379, + 679 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 379, + 679 + ], + "score": 1.0, + "content": "C ENERGY-BASED STEPWISE GAN (EBSTEPGAN)", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 688, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 505, + 700 + ], + "score": 1.0, + "content": "We propose energy-based stepwise GAN (EBStepGAN) that only change the form of objective", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "score": 1.0, + "content": "function of StepGAN. This is mainly inspired by energy-based GAN (Zhao et al., 2016). As depicted", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 215, + 722 + ], + "score": 1.0, + "content": "in Fig. 4, the discriminator", + "type": "text" + }, + { + "bbox": [ + 215, + 711, + 225, + 720 + ], + "score": 0.82, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 225, + 709, + 398, + 722 + ], + "score": 1.0, + "content": "here has the same architecture as generator", + "type": "text" + }, + { + "bbox": [ + 399, + 710, + 408, + 720 + ], + "score": 0.77, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 408, + 709, + 505, + 722 + ], + "score": 1.0, + "content": ", and its energy function", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 721, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 505, + 733 + ], + "score": 1.0, + "content": "is cross-entropy. Discriminator assigns low energy to real samples and high enery to generated", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 21.5 + } + ], + "page_idx": 11, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "12", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 81, + 363, + 94 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 363, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 363, + 95 + ], + "score": 1.0, + "content": "A APPENDIX: PSEUDO CODE OF STEPWISE GAN", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table", + "bbox": [ + 155, + 147, + 455, + 330 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 226, + 109, + 385, + 121 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 225, + 109, + 385, + 122 + ], + "spans": [ + { + "bbox": [ + 225, + 109, + 385, + 122 + ], + "score": 1.0, + "content": "Table 4: Pseudo code of stepwise GAN", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "table_caption", + "bbox": [ + 157, + 135, + 360, + 147 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 157, + 133, + 360, + 151 + ], + "spans": [ + { + "bbox": [ + 157, + 133, + 360, + 151 + ], + "score": 1.0, + "content": "Algorithm 1 Stepwise GAN (StepGAN) Training", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 2 + }, + { + "type": "table_body", + "bbox": [ + 155, + 147, + 455, + 330 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 155, + 147, + 455, + 330 + ], + "spans": [ + { + "bbox": [ + 155, + 147, + 455, + 330 + ], + "score": 0.583, + "html": "
1for number of training iterations do
2for i=1, D-steps do Sample (y,xR) from real data
3
4Sample xG ~ PG(.ly)
5Update D using equation (7) T
6D'(xly)=∑-1PD(x.tly)
7D* = arg maxD Ey~pR(y),R~pR(xly)[log(D'(xR|y))] +Ey~PR(y),xG~PG(xly)[log(1-D'(xG|y)]
8end for
9for i=1, G-steps do
10Sample y from real data
11Sample xG ~ PG(.ly)
12Update G using equation (9)
130G ←0G + na£D(x1...tly)Vlog(𝑝G(x£ly,x...t-1))
14end for
15end for
", + "type": "table", + "image_path": "36032d27352dfeba3b79e53b3edfc36ca22c1080b9805cc24a877d1dcceb9a67.jpg" + } + ] + } + ], + "index": 4, + "virtual_lines": [ + { + "bbox": [ + 155, + 147, + 455, + 208.0 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 155, + 208.0, + 455, + 269.0 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 155, + 269.0, + 455, + 330.0 + ], + "spans": [], + "index": 5 + } + ] + } + ], + "index": 2 + }, + { + "type": "title", + "bbox": [ + 107, + 360, + 460, + 374 + ], + "lines": [ + { + "bbox": [ + 104, + 359, + 462, + 376 + ], + "spans": [ + { + "bbox": [ + 104, + 359, + 462, + 376 + ], + "score": 1.0, + "content": "B WEIGHTED FACTORS SEARCH OF STEPGAN AND STEPGAN-SEQ", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "table", + "bbox": [ + 146, + 426, + 465, + 553 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 104, + 390, + 504, + 414 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 390, + 505, + 403 + ], + "spans": [ + { + "bbox": [ + 106, + 390, + 505, + 403 + ], + "score": 1.0, + "content": "Table 5: StepGAN and StepGAN-Seq with different weight factors. The dash (-) here notes that the", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 402, + 349, + 415 + ], + "spans": [ + { + "bbox": [ + 106, + 402, + 349, + 415 + ], + "score": 1.0, + "content": "weight factors yield neither improvements nor deterioration.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5 + }, + { + "type": "table_body", + "bbox": [ + 146, + 426, + 465, + 553 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 146, + 426, + 465, + 553 + ], + "spans": [ + { + "bbox": [ + 146, + 426, + 465, + 553 + ], + "score": 0.983, + "html": "
StepGAN StepGAN-Seq
AccAccSCovAccAccS Cov
SequenceUniform97.1975.9266.0897.1174.85 67.49
Increase97.1775.3366.75 97.1873.3068.19
Decrease97.1674.7367.1497.09 74.3467.48
CountingUniform77.2371.4370.1874.9170.70 69.84
Increasing74.5069.6670.8674.54 70.7470.11
Decreasing81.9872.2469.0275.47 70.6469.82
AdditionUniform44.2632.3931.9144.7732.34 31.65
Increasing11 -=11
Decreasing44.9432.1931.6745.55 32.4932.01
", + "type": "table", + "image_path": "7f26433ca7bf61c7ac142ba13ecfb24904cbf6f3fbade2612157dda630eceb1e.jpg" + } + ] + } + ], + "index": 10, + "virtual_lines": [ + { + "bbox": [ + 146, + 426, + 465, + 468.3333333333333 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 146, + 468.3333333333333, + 465, + 510.66666666666663 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 146, + 510.66666666666663, + 465, + 553.0 + ], + "spans": [], + "index": 11 + } + ] + } + ], + "index": 8.75 + }, + { + "type": "text", + "bbox": [ + 106, + 568, + 506, + 646 + ], + "lines": [ + { + "bbox": [ + 105, + 566, + 506, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 265, + 583 + ], + "score": 1.0, + "content": "We compare different weighted factors", + "type": "text" + }, + { + "bbox": [ + 266, + 568, + 280, + 579 + ], + "score": 0.92, + "content": "\\alpha ^ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 280, + 566, + 439, + 583 + ], + "score": 1.0, + "content": "for StepGAN and StepGAN-Seq, with", + "type": "text" + }, + { + "bbox": [ + 439, + 568, + 476, + 581 + ], + "score": 0.93, + "content": "\\begin{array} { r } { \\alpha _ { t } ^ { D } = \\frac { 1 } { T } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 477, + 566, + 506, + 583 + ], + "score": 1.0, + "content": "for all", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 579, + 506, + 592 + ], + "spans": [ + { + "bbox": [ + 106, + 579, + 506, + 592 + ], + "score": 1.0, + "content": "the presented cases. As depicted in Table 5, the three grammars are trained using three sorts of", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 104, + 588, + 506, + 605 + ], + "spans": [ + { + "bbox": [ + 104, + 588, + 219, + 605 + ], + "score": 1.0, + "content": "weighted factors: uniform", + "type": "text" + }, + { + "bbox": [ + 219, + 590, + 258, + 603 + ], + "score": 0.89, + "content": "\\begin{array} { r } { \\dot { \\left( \\alpha _ { t } ^ { G } \\ = \\ 1 \\right) } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 258, + 588, + 312, + 605 + ], + "score": 1.0, + "content": "), increasing", + "type": "text" + }, + { + "bbox": [ + 312, + 590, + 349, + 603 + ], + "score": 0.89, + "content": "( \\alpha _ { t } ^ { G } \\ = t )", + "type": "inline_equation" + }, + { + "bbox": [ + 350, + 588, + 421, + 605 + ], + "score": 1.0, + "content": ", and decreasing", + "type": "text" + }, + { + "bbox": [ + 422, + 590, + 501, + 603 + ], + "score": 0.9, + "content": "( \\alpha _ { t } ^ { G } \\ = \\ T - \\ t + 1 )", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 588, + 506, + 605 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 601, + 506, + 614 + ], + "spans": [ + { + "bbox": [ + 105, + 601, + 506, + 614 + ], + "score": 1.0, + "content": "The results clearly show that the time-step-decreasing weight factors positively affect training. We", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 612, + 505, + 625 + ], + "spans": [ + { + "bbox": [ + 105, + 612, + 505, + 625 + ], + "score": 1.0, + "content": "believe this is because the training spirit of decreased weighted factor start from first correcting", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 624, + 505, + 635 + ], + "spans": [ + { + "bbox": [ + 106, + 624, + 505, + 635 + ], + "score": 1.0, + "content": "prefix. After correcting prefix, it becomes easier to correct the suffix. Please refer to section 5 if you", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 634, + 312, + 647 + ], + "spans": [ + { + "bbox": [ + 106, + 634, + 312, + 647 + ], + "score": 1.0, + "content": "are interested in the details of Acc, AccS, and Cov.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 15, + "bbox_fs": [ + 104, + 566, + 506, + 647 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 662, + 377, + 676 + ], + "lines": [ + { + "bbox": [ + 105, + 659, + 379, + 679 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 379, + 679 + ], + "score": 1.0, + "content": "C ENERGY-BASED STEPWISE GAN (EBSTEPGAN)", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 688, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 505, + 700 + ], + "score": 1.0, + "content": "We propose energy-based stepwise GAN (EBStepGAN) that only change the form of objective", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "score": 1.0, + "content": "function of StepGAN. This is mainly inspired by energy-based GAN (Zhao et al., 2016). As depicted", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 215, + 722 + ], + "score": 1.0, + "content": "in Fig. 4, the discriminator", + "type": "text" + }, + { + "bbox": [ + 215, + 711, + 225, + 720 + ], + "score": 0.82, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 225, + 709, + 398, + 722 + ], + "score": 1.0, + "content": "here has the same architecture as generator", + "type": "text" + }, + { + "bbox": [ + 399, + 710, + 408, + 720 + ], + "score": 0.77, + "content": "G", + "type": "inline_equation" + }, + { + "bbox": [ + 408, + 709, + 505, + 722 + ], + "score": 1.0, + "content": ", and its energy function", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 721, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 505, + 733 + ], + "score": 1.0, + "content": "is cross-entropy. Discriminator assigns low energy to real samples and high enery to generated", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 332, + 506, + 345 + ], + "spans": [ + { + "bbox": [ + 105, + 332, + 506, + 345 + ], + "score": 1.0, + "content": "samples. The advantage of EBStepGAN is that we can initialize both generator and discriminator", + "type": "text", + "cross_page": true + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 343, + 455, + 356 + ], + "spans": [ + { + "bbox": [ + 105, + 343, + 455, + 356 + ], + "score": 1.0, + "content": "with the same pre-trained model using MLE. The optimization functions are written as", + "type": "text", + "cross_page": true + } + ], + "index": 18 + } + ], + "index": 21.5, + "bbox_fs": [ + 105, + 688, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 171, + 79, + 435, + 290 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 171, + 79, + 435, + 290 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 171, + 79, + 435, + 290 + ], + "spans": [ + { + "bbox": [ + 171, + 79, + 435, + 290 + ], + "score": 0.968, + "type": "image", + "image_path": "644661665ab6f5463846bfc5f87051f82283916167e2527b207cd6ca308a0415.jpg" + } + ] + } + ], + "index": 7.5, + "virtual_lines": [ + { + "bbox": [ + 171, + 79, + 435, + 92.1875 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 171, + 92.1875, + 435, + 105.375 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 171, + 105.375, + 435, + 118.5625 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 171, + 118.5625, + 435, + 131.75 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 171, + 131.75, + 435, + 144.9375 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 171, + 144.9375, + 435, + 158.125 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 171, + 158.125, + 435, + 171.3125 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 171, + 171.3125, + 435, + 184.5 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 171, + 184.5, + 435, + 197.6875 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 171, + 197.6875, + 435, + 210.875 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 171, + 210.875, + 435, + 224.0625 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 171, + 224.0625, + 435, + 237.25 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 171, + 237.25, + 435, + 250.4375 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 171, + 250.4375, + 435, + 263.625 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 171, + 263.625, + 435, + 276.8125 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 171, + 276.8125, + 435, + 290.0 + ], + "spans": [], + "index": 15 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 199, + 298, + 412, + 311 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 199, + 298, + 412, + 312 + ], + "spans": [ + { + "bbox": [ + 199, + 298, + 412, + 312 + ], + "score": 1.0, + "content": "Figure 4: Illustration of energy-based stepwise GAN", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + } + ], + "index": 11.75 + }, + { + "type": "text", + "bbox": [ + 107, + 331, + 504, + 355 + ], + "lines": [ + { + "bbox": [ + 105, + 332, + 506, + 345 + ], + "spans": [ + { + "bbox": [ + 105, + 332, + 506, + 345 + ], + "score": 1.0, + "content": "samples. The advantage of EBStepGAN is that we can initialize both generator and discriminator", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 343, + 455, + 356 + ], + "spans": [ + { + "bbox": [ + 105, + 343, + 455, + 356 + ], + "score": 1.0, + "content": "with the same pre-trained model using MLE. The optimization functions are written as", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5 + }, + { + "type": "interline_equation", + "bbox": [ + 143, + 360, + 466, + 430 + ], + "lines": [ + { + "bbox": [ + 143, + 360, + 466, + 430 + ], + "spans": [ + { + "bbox": [ + 143, + 360, + 466, + 430 + ], + "score": 0.92, + "content": "\\begin{array} { l } { { \\displaystyle D ^ { * } = \\arg \\operatorname* { m a x } _ { D } E _ { ( x ^ { R } , y ) \\sim P ^ { R } ( X , Y ) } [ \\sum _ { t = 1 } ^ { T } l o g ( P ^ { D } ( x _ { t } ^ { R } | y , x _ { 1 \\dots t - 1 } ^ { R } ) ) ] } } \\\\ { { \\displaystyle \\qquad + m a x i m u m ( 0 , \\beta - E _ { y \\sim P ^ { R } ( Y ) , x ^ { G } \\sim P ^ { G } ( X | y ) } [ \\sum _ { t = 1 } ^ { T } l o g ( P ^ { D } ( x _ { t } ^ { G } | y , x _ { 1 \\dots t - 1 } ^ { G } ) ) ] ) } } \\end{array}", + "type": "interline_equation", + "image_path": "b3598c995fbe2c319dde3ae92ed9e325d9b5bba7a13173e619a25b16fb614fc0.jpg" + } + ] + } + ], + "index": 20, + "virtual_lines": [ + { + "bbox": [ + 143, + 360, + 466, + 383.3333333333333 + ], + "spans": [], + "index": 19 + }, + { + "bbox": [ + 143, + 383.3333333333333, + 466, + 406.66666666666663 + ], + "spans": [], + "index": 20 + }, + { + "bbox": [ + 143, + 406.66666666666663, + 466, + 429.99999999999994 + ], + "spans": [], + "index": 21 + } + ] + }, + { + "type": "interline_equation", + "bbox": [ + 165, + 442, + 444, + 476 + ], + "lines": [ + { + "bbox": [ + 165, + 442, + 444, + 476 + ], + "spans": [ + { + "bbox": [ + 165, + 442, + 444, + 476 + ], + "score": 0.93, + "content": "G ^ { * } = \\arg \\operatorname* { m a x } _ { G } E _ { y \\sim P ^ { R } ( Y ) , x ^ { G } \\sim P ^ { G } ( X | y ) } [ \\sum _ { t = 1 } ^ { T } l o g ( P ^ { D } ( x _ { t } ^ { G } | y , x _ { 1 \\dots t - 1 } ^ { G } ) ) ] ,", + "type": "interline_equation", + "image_path": "f3ac7a85ca44672cf3e5e7d54a3470e8f5451e0024ee44cee726b00f61fe5f54.jpg" + } + ] + } + ], + "index": 23, + "virtual_lines": [ + { + "bbox": [ + 165, + 442, + 444, + 453.3333333333333 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 165, + 453.3333333333333, + 444, + 464.66666666666663 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 165, + 464.66666666666663, + 444, + 475.99999999999994 + ], + "spans": [], + "index": 24 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 480, + 505, + 549 + ], + "lines": [ + { + "bbox": [ + 102, + 475, + 505, + 500 + ], + "spans": [ + { + "bbox": [ + 102, + 475, + 133, + 500 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 481, + 212, + 495 + ], + "score": 0.91, + "content": "P ^ { D } ( x _ { t } ^ { G } | y , x _ { 1 \\dots t - 1 } ^ { G } )", + "type": "inline_equation" + }, + { + "bbox": [ + 212, + 475, + 403, + 500 + ], + "score": 1.0, + "content": "in Equation (11) is the probability of generating", + "type": "text" + }, + { + "bbox": [ + 403, + 481, + 417, + 494 + ], + "score": 0.9, + "content": "x _ { t } ^ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 417, + 475, + 441, + 500 + ], + "score": 1.0, + "content": "given", + "type": "text" + }, + { + "bbox": [ + 441, + 481, + 505, + 495 + ], + "score": 0.87, + "content": "< y , x _ { 1 \\ldots t - 1 } ^ { G } >", + "type": "inline_equation" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 493, + 505, + 506 + ], + "spans": [ + { + "bbox": [ + 106, + 493, + 219, + 506 + ], + "score": 1.0, + "content": "based on the current model", + "type": "text" + }, + { + "bbox": [ + 230, + 493, + 251, + 506 + ], + "score": 1.0, + "content": ", and", + "type": "text" + }, + { + "bbox": [ + 251, + 493, + 258, + 504 + ], + "score": 0.85, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 259, + 493, + 505, + 506 + ], + "score": 1.0, + "content": "in Equation (10) is the threshold for preventing the discrim-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 504, + 506, + 517 + ], + "spans": [ + { + "bbox": [ + 106, + 504, + 506, + 517 + ], + "score": 1.0, + "content": "inator from distinguishing generated samples from real samples too easily. When the energy of", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 515, + 505, + 527 + ], + "spans": [ + { + "bbox": [ + 105, + 515, + 505, + 527 + ], + "score": 1.0, + "content": "generated samples is too high, the threshold turns off the second term in (10). The results of EB-", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 525, + 505, + 539 + ], + "spans": [ + { + "bbox": [ + 105, + 525, + 505, + 539 + ], + "score": 1.0, + "content": "StepGAN is shown in Table 6. According to Table 6, EBStepGAN does not show better performance", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 537, + 279, + 550 + ], + "spans": [ + { + "bbox": [ + 106, + 537, + 279, + 550 + ], + "score": 1.0, + "content": "than StepGAN in our current experiments.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 27.5 + }, + { + "type": "table", + "bbox": [ + 117, + 584, + 495, + 621 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 114, + 558, + 494, + 571 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 115, + 558, + 495, + 571 + ], + "spans": [ + { + "bbox": [ + 115, + 558, + 495, + 571 + ], + "score": 1.0, + "content": "Table 6: Results of artificial grammars by EBStepGAN. Please check Table 2 for other results.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 31 + }, + { + "type": "table_body", + "bbox": [ + 117, + 584, + 495, + 621 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 117, + 584, + 495, + 621 + ], + "spans": [ + { + "bbox": [ + 117, + 584, + 495, + 621 + ], + "score": 0.972, + "html": "
SequenceCountingAddition
AccAccSCovAccAccSCovAccAccSCov
EBStepGAN97.3280.0957.1279.7871.5268.4445.7432.6832.11
", + "type": "table", + "image_path": "0e6de376861cc4f5891efd891a5a12414391cd676f1a6890fa180de05e54835c.jpg" + } + ] + } + ], + "index": 33, + "virtual_lines": [ + { + "bbox": [ + 117, + 584, + 495, + 596.3333333333334 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 117, + 596.3333333333334, + 495, + 608.6666666666667 + ], + "spans": [], + "index": 33 + }, + { + "bbox": [ + 117, + 608.6666666666667, + 495, + 621.0000000000001 + ], + "spans": [], + "index": 34 + } + ] + } + ], + "index": 32.0 + } + ], + "page_idx": 12, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "13", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 106, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 171, + 79, + 435, + 290 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 171, + 79, + 435, + 290 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 171, + 79, + 435, + 290 + ], + "spans": [ + { + "bbox": [ + 171, + 79, + 435, + 290 + ], + "score": 0.968, + "type": "image", + "image_path": "644661665ab6f5463846bfc5f87051f82283916167e2527b207cd6ca308a0415.jpg" + } + ] + } + ], + "index": 7.5, + "virtual_lines": [ + { + "bbox": [ + 171, + 79, + 435, + 92.1875 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 171, + 92.1875, + 435, + 105.375 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 171, + 105.375, + 435, + 118.5625 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 171, + 118.5625, + 435, + 131.75 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 171, + 131.75, + 435, + 144.9375 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 171, + 144.9375, + 435, + 158.125 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 171, + 158.125, + 435, + 171.3125 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 171, + 171.3125, + 435, + 184.5 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 171, + 184.5, + 435, + 197.6875 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 171, + 197.6875, + 435, + 210.875 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 171, + 210.875, + 435, + 224.0625 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 171, + 224.0625, + 435, + 237.25 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 171, + 237.25, + 435, + 250.4375 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 171, + 250.4375, + 435, + 263.625 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 171, + 263.625, + 435, + 276.8125 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 171, + 276.8125, + 435, + 290.0 + ], + "spans": [], + "index": 15 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 199, + 298, + 412, + 311 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 199, + 298, + 412, + 312 + ], + "spans": [ + { + "bbox": [ + 199, + 298, + 412, + 312 + ], + "score": 1.0, + "content": "Figure 4: Illustration of energy-based stepwise GAN", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + } + ], + "index": 11.75 + }, + { + "type": "text", + "bbox": [ + 107, + 331, + 504, + 355 + ], + "lines": [], + "index": 17.5, + "bbox_fs": [ + 105, + 332, + 506, + 356 + ], + "lines_deleted": true + }, + { + "type": "interline_equation", + "bbox": [ + 143, + 360, + 466, + 430 + ], + "lines": [ + { + "bbox": [ + 143, + 360, + 466, + 430 + ], + "spans": [ + { + "bbox": [ + 143, + 360, + 466, + 430 + ], + "score": 0.92, + "content": "\\begin{array} { l } { { \\displaystyle D ^ { * } = \\arg \\operatorname* { m a x } _ { D } E _ { ( x ^ { R } , y ) \\sim P ^ { R } ( X , Y ) } [ \\sum _ { t = 1 } ^ { T } l o g ( P ^ { D } ( x _ { t } ^ { R } | y , x _ { 1 \\dots t - 1 } ^ { R } ) ) ] } } \\\\ { { \\displaystyle \\qquad + m a x i m u m ( 0 , \\beta - E _ { y \\sim P ^ { R } ( Y ) , x ^ { G } \\sim P ^ { G } ( X | y ) } [ \\sum _ { t = 1 } ^ { T } l o g ( P ^ { D } ( x _ { t } ^ { G } | y , x _ { 1 \\dots t - 1 } ^ { G } ) ) ] ) } } \\end{array}", + "type": "interline_equation", + "image_path": "b3598c995fbe2c319dde3ae92ed9e325d9b5bba7a13173e619a25b16fb614fc0.jpg" + } + ] + } + ], + "index": 20, + "virtual_lines": [ + { + "bbox": [ + 143, + 360, + 466, + 383.3333333333333 + ], + "spans": [], + "index": 19 + }, + { + "bbox": [ + 143, + 383.3333333333333, + 466, + 406.66666666666663 + ], + "spans": [], + "index": 20 + }, + { + "bbox": [ + 143, + 406.66666666666663, + 466, + 429.99999999999994 + ], + "spans": [], + "index": 21 + } + ] + }, + { + "type": "interline_equation", + "bbox": [ + 165, + 442, + 444, + 476 + ], + "lines": [ + { + "bbox": [ + 165, + 442, + 444, + 476 + ], + "spans": [ + { + "bbox": [ + 165, + 442, + 444, + 476 + ], + "score": 0.93, + "content": "G ^ { * } = \\arg \\operatorname* { m a x } _ { G } E _ { y \\sim P ^ { R } ( Y ) , x ^ { G } \\sim P ^ { G } ( X | y ) } [ \\sum _ { t = 1 } ^ { T } l o g ( P ^ { D } ( x _ { t } ^ { G } | y , x _ { 1 \\dots t - 1 } ^ { G } ) ) ] ,", + "type": "interline_equation", + "image_path": "f3ac7a85ca44672cf3e5e7d54a3470e8f5451e0024ee44cee726b00f61fe5f54.jpg" + } + ] + } + ], + "index": 23, + "virtual_lines": [ + { + "bbox": [ + 165, + 442, + 444, + 453.3333333333333 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 165, + 453.3333333333333, + 444, + 464.66666666666663 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 165, + 464.66666666666663, + 444, + 475.99999999999994 + ], + "spans": [], + "index": 24 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 480, + 505, + 549 + ], + "lines": [ + { + "bbox": [ + 102, + 475, + 505, + 500 + ], + "spans": [ + { + "bbox": [ + 102, + 475, + 133, + 500 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 481, + 212, + 495 + ], + "score": 0.91, + "content": "P ^ { D } ( x _ { t } ^ { G } | y , x _ { 1 \\dots t - 1 } ^ { G } )", + "type": "inline_equation" + }, + { + "bbox": [ + 212, + 475, + 403, + 500 + ], + "score": 1.0, + "content": "in Equation (11) is the probability of generating", + "type": "text" + }, + { + "bbox": [ + 403, + 481, + 417, + 494 + ], + "score": 0.9, + "content": "x _ { t } ^ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 417, + 475, + 441, + 500 + ], + "score": 1.0, + "content": "given", + "type": "text" + }, + { + "bbox": [ + 441, + 481, + 505, + 495 + ], + "score": 0.87, + "content": "< y , x _ { 1 \\ldots t - 1 } ^ { G } >", + "type": "inline_equation" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 493, + 505, + 506 + ], + "spans": [ + { + "bbox": [ + 106, + 493, + 219, + 506 + ], + "score": 1.0, + "content": "based on the current model", + "type": "text" + }, + { + "bbox": [ + 230, + 493, + 251, + 506 + ], + "score": 1.0, + "content": ", and", + "type": "text" + }, + { + "bbox": [ + 251, + 493, + 258, + 504 + ], + "score": 0.85, + "content": "\\beta", + "type": "inline_equation" + }, + { + "bbox": [ + 259, + 493, + 505, + 506 + ], + "score": 1.0, + "content": "in Equation (10) is the threshold for preventing the discrim-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 504, + 506, + 517 + ], + "spans": [ + { + "bbox": [ + 106, + 504, + 506, + 517 + ], + "score": 1.0, + "content": "inator from distinguishing generated samples from real samples too easily. When the energy of", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 515, + 505, + 527 + ], + "spans": [ + { + "bbox": [ + 105, + 515, + 505, + 527 + ], + "score": 1.0, + "content": "generated samples is too high, the threshold turns off the second term in (10). The results of EB-", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 525, + 505, + 539 + ], + "spans": [ + { + "bbox": [ + 105, + 525, + 505, + 539 + ], + "score": 1.0, + "content": "StepGAN is shown in Table 6. According to Table 6, EBStepGAN does not show better performance", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 537, + 279, + 550 + ], + "spans": [ + { + "bbox": [ + 106, + 537, + 279, + 550 + ], + "score": 1.0, + "content": "than StepGAN in our current experiments.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 27.5, + "bbox_fs": [ + 102, + 475, + 506, + 550 + ] + }, + { + "type": "table", + "bbox": [ + 117, + 584, + 495, + 621 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 114, + 558, + 494, + 571 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 115, + 558, + 495, + 571 + ], + "spans": [ + { + "bbox": [ + 115, + 558, + 495, + 571 + ], + "score": 1.0, + "content": "Table 6: Results of artificial grammars by EBStepGAN. Please check Table 2 for other results.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 31 + }, + { + "type": "table_body", + "bbox": [ + 117, + 584, + 495, + 621 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 117, + 584, + 495, + 621 + ], + "spans": [ + { + "bbox": [ + 117, + 584, + 495, + 621 + ], + "score": 0.972, + "html": "
SequenceCountingAddition
AccAccSCovAccAccSCovAccAccSCov
EBStepGAN97.3280.0957.1279.7871.5268.4445.7432.6832.11
", + "type": "table", + "image_path": "0e6de376861cc4f5891efd891a5a12414391cd676f1a6890fa180de05e54835c.jpg" + } + ] + } + ], + "index": 33, + "virtual_lines": [ + { + "bbox": [ + 117, + 584, + 495, + 596.3333333333334 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 117, + 596.3333333333334, + 495, + 608.6666666666667 + ], + "spans": [], + "index": 33 + }, + { + "bbox": [ + 117, + 608.6666666666667, + 495, + 621.0000000000001 + ], + "spans": [], + "index": 34 + } + ] + } + ], + "index": 32.0 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 105, + 82, + 434, + 94 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 436, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 436, + 96 + ], + "score": 1.0, + "content": "D APPENDIX: EXAMPLES OF NEURAL DIALOGUE GENERATION", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table", + "bbox": [ + 135, + 134, + 476, + 691 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 156, + 109, + 454, + 121 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 156, + 108, + 455, + 123 + ], + "spans": [ + { + "bbox": [ + 156, + 108, + 455, + 123 + ], + "score": 1.0, + "content": "Table 7: Examples of neural dialogue generation trained on OpenSubtitles", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "table_body", + "bbox": [ + 135, + 134, + 476, + 691 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 135, + 134, + 476, + 691 + ], + "spans": [ + { + "bbox": [ + 135, + 134, + 476, + 691 + ], + "score": 0.978, + "html": "
Inputhello,i'm senator snatch
MLESeqGANMaliGANREGSStepGANi'm sorry .i'm sorry,i'm sorry.i'm a good man . i'm here to see you againsorry you 're late
Inputi got the money right here .
MLESeqGANMaliGANREGSStepGANi'm sorry .i'm here to help .ican.ican 't do it .i'll take you home .
Inputhope you enjoyed your pee ..because it ’'s your last on this trip .
MLESeqGANMaliGANREGSStepGANit 's not a problem . it 's not your fault .it doesn 't matter . it 's not a dream . it 's the only thing i can do .
Inputhe say ... if you want to be an actor,he has something to show you .
MLESeqGANMaliGANREGSStepGANyou 're not .you can 't do that .what 's he mean ?he 's a very good guy , you know .you 're not gonna be a liar .
Input thank you, thank you .
MLESeqGANMaliGANREGSStepGANi'm sorry.i'm sorry ,sir .thank you .i'll be right back .you 're welcome .
Inputi feel like a paris princess.
MLESeqGANMaliGANREGSStepGANiknow it .i know that you 're not there .i feel like ..i can 't see it . you 're not a child anymore .
Inputi'm tired of all your questions
MLESeqGANMaliGANREGSStepGANi'm gonna have to ask you to come . i'm gonna call you .i'ma friend. i 'm going to have to ask you to come in i'm going to be a friend of you .
Input it 's great .
MLE yeah.SeqGAN it 's great, huh ?MaliGAN it 's great .REGS i was just thinking about it .StepGAN you 're so sweet .
", + "type": "table", + "image_path": "7bac822b5ad2120cbefc663273e4b022347f0610e89dc4164a2289e27d2fde78.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 135, + 134, + 476, + 319.66666666666663 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 135, + 319.66666666666663, + 476, + 505.33333333333326 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 135, + 505.33333333333326, + 476, + 690.9999999999999 + ], + "spans": [], + "index": 4 + } + ] + } + ], + "index": 2.0 + } + ], + "page_idx": 13, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 26, + 309, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 763 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 763 + ], + "score": 1.0, + "content": "14", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 105, + 82, + 434, + 94 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 436, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 436, + 96 + ], + "score": 1.0, + "content": "D APPENDIX: EXAMPLES OF NEURAL DIALOGUE GENERATION", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table", + "bbox": [ + 135, + 134, + 476, + 691 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 156, + 109, + 454, + 121 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 156, + 108, + 455, + 123 + ], + "spans": [ + { + "bbox": [ + 156, + 108, + 455, + 123 + ], + "score": 1.0, + "content": "Table 7: Examples of neural dialogue generation trained on OpenSubtitles", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "table_body", + "bbox": [ + 135, + 134, + 476, + 691 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 135, + 134, + 476, + 691 + ], + "spans": [ + { + "bbox": [ + 135, + 134, + 476, + 691 + ], + "score": 0.978, + "html": "
Inputhello,i'm senator snatch
MLESeqGANMaliGANREGSStepGANi'm sorry .i'm sorry,i'm sorry.i'm a good man . i'm here to see you againsorry you 're late
Inputi got the money right here .
MLESeqGANMaliGANREGSStepGANi'm sorry .i'm here to help .ican.ican 't do it .i'll take you home .
Inputhope you enjoyed your pee ..because it ’'s your last on this trip .
MLESeqGANMaliGANREGSStepGANit 's not a problem . it 's not your fault .it doesn 't matter . it 's not a dream . it 's the only thing i can do .
Inputhe say ... if you want to be an actor,he has something to show you .
MLESeqGANMaliGANREGSStepGANyou 're not .you can 't do that .what 's he mean ?he 's a very good guy , you know .you 're not gonna be a liar .
Input thank you, thank you .
MLESeqGANMaliGANREGSStepGANi'm sorry.i'm sorry ,sir .thank you .i'll be right back .you 're welcome .
Inputi feel like a paris princess.
MLESeqGANMaliGANREGSStepGANiknow it .i know that you 're not there .i feel like ..i can 't see it . you 're not a child anymore .
Inputi'm tired of all your questions
MLESeqGANMaliGANREGSStepGANi'm gonna have to ask you to come . i'm gonna call you .i'ma friend. i 'm going to have to ask you to come in i'm going to be a friend of you .
Input it 's great .
MLE yeah.SeqGAN it 's great, huh ?MaliGAN it 's great .REGS i was just thinking about it .StepGAN you 're so sweet .
", + "type": "table", + "image_path": "7bac822b5ad2120cbefc663273e4b022347f0610e89dc4164a2289e27d2fde78.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 135, + 134, + 476, + 319.66666666666663 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 135, + 319.66666666666663, + 476, + 505.33333333333326 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 135, + 505.33333333333326, + 476, + 690.9999999999999 + ], + "spans": [], + "index": 4 + } + ] + } + ], + "index": 2.0 + } + ] + } + ], + "_backend": "pipeline", + "_version_name": "2.2.2" +} \ No newline at end of file