diff --git "a/parse/train/rk8wKk-R-/rk8wKk-R-_middle.json" "b/parse/train/rk8wKk-R-/rk8wKk-R-_middle.json" new file mode 100644--- /dev/null +++ "b/parse/train/rk8wKk-R-/rk8wKk-R-_middle.json" @@ -0,0 +1,41712 @@ +{ + "pdf_info": [ + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 78, + 496, + 97 + ], + "lines": [ + { + "bbox": [ + 105, + 78, + 498, + 99 + ], + "spans": [ + { + "bbox": [ + 105, + 78, + 498, + 99 + ], + "score": 1.0, + "content": "CONVOLUTIONAL SEQUENCE MODELING REVISITED", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 112, + 118, + 244, + 140 + ], + "lines": [ + { + "bbox": [ + 111, + 116, + 202, + 132 + ], + "spans": [ + { + "bbox": [ + 111, + 116, + 202, + 132 + ], + "score": 1.0, + "content": "Anonymous authors", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 111, + 128, + 245, + 140 + ], + "spans": [ + { + "bbox": [ + 111, + 128, + 245, + 140 + ], + "score": 1.0, + "content": "Paper under double-blind review", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1.5 + }, + { + "type": "title", + "bbox": [ + 278, + 168, + 333, + 181 + ], + "lines": [ + { + "bbox": [ + 276, + 168, + 335, + 182 + ], + "spans": [ + { + "bbox": [ + 276, + 168, + 335, + 182 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 143, + 196, + 468, + 361 + ], + "lines": [ + { + "bbox": [ + 142, + 197, + 469, + 209 + ], + "spans": [ + { + "bbox": [ + 142, + 197, + 469, + 209 + ], + "score": 1.0, + "content": "This paper revisits the problem of sequence modeling using convolutional archi-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 141, + 207, + 470, + 222 + ], + "spans": [ + { + "bbox": [ + 141, + 207, + 470, + 222 + ], + "score": 1.0, + "content": "tectures. Although both convolutional and recurrent architectures have a long", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 140, + 218, + 470, + 233 + ], + "spans": [ + { + "bbox": [ + 140, + 218, + 470, + 233 + ], + "score": 1.0, + "content": "history in sequence prediction, the current “default” mindset in much of the deep", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 230, + 469, + 244 + ], + "spans": [ + { + "bbox": [ + 141, + 230, + 469, + 244 + ], + "score": 1.0, + "content": "learning community is that generic sequence modeling is best handled using re-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 241, + 469, + 253 + ], + "spans": [ + { + "bbox": [ + 141, + 241, + 469, + 253 + ], + "score": 1.0, + "content": "current networks. The goal of this paper is to question this assumption. Specifi-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 252, + 470, + 264 + ], + "spans": [ + { + "bbox": [ + 141, + 252, + 470, + 264 + ], + "score": 1.0, + "content": "cally, we consider a simple generic temporal convolution network (TCN), which", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 141, + 263, + 469, + 275 + ], + "spans": [ + { + "bbox": [ + 141, + 263, + 469, + 275 + ], + "score": 1.0, + "content": "adopts features from modern ConvNet architectures such as a dilations and resid-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 274, + 470, + 286 + ], + "spans": [ + { + "bbox": [ + 141, + 274, + 470, + 286 + ], + "score": 1.0, + "content": "ual connections. We show that on a variety of sequence modeling tasks, includ-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 140, + 285, + 470, + 297 + ], + "spans": [ + { + "bbox": [ + 140, + 285, + 470, + 297 + ], + "score": 1.0, + "content": "ing many frequently used as benchmarks for evaluating recurrent networks, the", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 295, + 469, + 308 + ], + "spans": [ + { + "bbox": [ + 141, + 295, + 469, + 308 + ], + "score": 1.0, + "content": "TCN outperforms baseline RNN methods (LSTMs, GRUs, and vanilla RNNs)", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 306, + 469, + 320 + ], + "spans": [ + { + "bbox": [ + 141, + 306, + 469, + 320 + ], + "score": 1.0, + "content": "and sometimes even highly specialized approaches. We further show that the po-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 318, + 469, + 330 + ], + "spans": [ + { + "bbox": [ + 141, + 318, + 469, + 330 + ], + "score": 1.0, + "content": "tential “infinite memory” advantage that RNNs have over TCNs is largely absent", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 329, + 470, + 341 + ], + "spans": [ + { + "bbox": [ + 141, + 329, + 470, + 341 + ], + "score": 1.0, + "content": "in practice: TCNs indeed exhibit longer effective history sizes than their recurrent", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 340, + 469, + 351 + ], + "spans": [ + { + "bbox": [ + 141, + 340, + 469, + 351 + ], + "score": 1.0, + "content": "counterparts. As a whole, we argue that it may be time to (re)consider ConvNets", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 141, + 349, + 375, + 364 + ], + "spans": [ + { + "bbox": [ + 141, + 349, + 375, + 364 + ], + "score": 1.0, + "content": "as the default “go to” architecture for sequence modeling.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 11 + }, + { + "type": "title", + "bbox": [ + 108, + 390, + 205, + 403 + ], + "lines": [ + { + "bbox": [ + 105, + 389, + 208, + 406 + ], + "spans": [ + { + "bbox": [ + 105, + 389, + 208, + 406 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 107, + 419, + 505, + 539 + ], + "lines": [ + { + "bbox": [ + 105, + 418, + 505, + 431 + ], + "spans": [ + { + "bbox": [ + 105, + 418, + 505, + 431 + ], + "score": 1.0, + "content": "Since the re-emergence of neural networks to the forefront of machine learning, two types of net-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 430, + 505, + 441 + ], + "spans": [ + { + "bbox": [ + 106, + 430, + 505, + 441 + ], + "score": 1.0, + "content": "work architectures have played a pivotal role: the convolutional network, often used for vision and", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 440, + 505, + 454 + ], + "spans": [ + { + "bbox": [ + 105, + 440, + 505, + 454 + ], + "score": 1.0, + "content": "higher-dimensional input data; and the recurrent network, typically used for modeling sequential", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 450, + 505, + 465 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 505, + 465 + ], + "score": 1.0, + "content": "data. These two types of architectures have become so ingrained in modern deep learning that they", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 463, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 463, + 505, + 475 + ], + "score": 1.0, + "content": "can be viewed as constituting the “pillars” of deep learning approaches. This paper looks at the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 473, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 505, + 487 + ], + "score": 1.0, + "content": "problem of sequence modeling, predicting how a sequence will evolve over time. This is a key", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 484, + 506, + 498 + ], + "spans": [ + { + "bbox": [ + 105, + 484, + 506, + 498 + ], + "score": 1.0, + "content": "problem in domains spanning audio, language modeling, music processing, time series forecasting,", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 495, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 505, + 507 + ], + "score": 1.0, + "content": "and many others. Although exceptions certainly exist in some domains, the current “default” think-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 506, + 506, + 518 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 506, + 518 + ], + "score": 1.0, + "content": "ing in the deep learning community is that these sequential tasks are best handled by some type of", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 518, + 505, + 530 + ], + "spans": [ + { + "bbox": [ + 105, + 518, + 505, + 530 + ], + "score": 1.0, + "content": "recurrent network. Our aim is to revisit this default thinking, and specifically ask whether modern", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 527, + 420, + 542 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 420, + 542 + ], + "score": 1.0, + "content": "convolutional architectures are in fact just as powerful for sequence modeling.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 107, + 545, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 545, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 545, + 505, + 558 + ], + "score": 1.0, + "content": "Before making the main claims of our paper, some history of convolutional and recurrent models", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 556, + 506, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 506, + 569 + ], + "score": 1.0, + "content": "for sequence modeling is useful. In the early history of neural networks, convolutional models were", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 567, + 506, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 567, + 506, + 579 + ], + "score": 1.0, + "content": "specifically proposed as a means of handling sequence data, the idea being that one could slide a", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 578, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 106, + 578, + 505, + 590 + ], + "score": 1.0, + "content": "1-D convolutional filter over the data (and stack such layers together) to predict future elements of a", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 589, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 589, + 505, + 601 + ], + "score": 1.0, + "content": "sequence from past ones (Hinton, 1989; LeCun et al., 1995). Thus, the idea of using convolutional", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 600, + 505, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 600, + 505, + 613 + ], + "score": 1.0, + "content": "models for sequence modeling goes back to the beginning of convolutional architectures themselves.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 611, + 505, + 624 + ], + "spans": [ + { + "bbox": [ + 105, + 611, + 505, + 624 + ], + "score": 1.0, + "content": "However, these models were subsequently largely abandoned for many sequence modeling tasks in", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 622, + 505, + 635 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 505, + 635 + ], + "score": 1.0, + "content": "favor of recurrent networks (Elman, 1990). The reasoning for this appears straightforward: while", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 633, + 505, + 645 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 505, + 645 + ], + "score": 1.0, + "content": "convolutional architectures have a limited ability to look back in time (i.e., their receptive field is", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 643, + 505, + 657 + ], + "spans": [ + { + "bbox": [ + 105, + 643, + 505, + 657 + ], + "score": 1.0, + "content": "limited by the size and layers of the filters), recurrent networks have no such limitation. Because re-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 104, + 654, + 505, + 669 + ], + "spans": [ + { + "bbox": [ + 104, + 654, + 505, + 669 + ], + "score": 1.0, + "content": "current networks propagate forward a hidden state, they are theoretically capable of infinite memory,", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 664, + 505, + 679 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 505, + 679 + ], + "score": 1.0, + "content": "the ability to make predictions based upon data that occurred arbitrarily long ago in the sequence.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 677, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 690 + ], + "score": 1.0, + "content": "This possibility seems to be realized even moreso for the now-standard architectures of Long Short-", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 688, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 505, + 699 + ], + "score": 1.0, + "content": "Term Memory networks (LSTMs) (Hochreiter & Schmidhuber, 1997), or recent incarnations such", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "as the Gated Recurrent Unit (GRU) (Cho et al., 2014); these architectures aim to avoid the “vanish-", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 710, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 505, + 723 + ], + "score": 1.0, + "content": "ing gradient” challenge of traditional RNNs and appear to provide a means to actually realize this", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 720, + 174, + 734 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 174, + 734 + ], + "score": 1.0, + "content": "infinite memory.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 39 + } + ], + "page_idx": 0, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "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" + } + ] + } + ] + }, + { + "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" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 78, + 496, + 97 + ], + "lines": [ + { + "bbox": [ + 105, + 78, + 498, + 99 + ], + "spans": [ + { + "bbox": [ + 105, + 78, + 498, + 99 + ], + "score": 1.0, + "content": "CONVOLUTIONAL SEQUENCE MODELING REVISITED", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 112, + 118, + 244, + 140 + ], + "lines": [ + { + "bbox": [ + 111, + 116, + 202, + 132 + ], + "spans": [ + { + "bbox": [ + 111, + 116, + 202, + 132 + ], + "score": 1.0, + "content": "Anonymous authors", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 111, + 128, + 245, + 140 + ], + "spans": [ + { + "bbox": [ + 111, + 128, + 245, + 140 + ], + "score": 1.0, + "content": "Paper under double-blind review", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1.5, + "bbox_fs": [ + 111, + 116, + 245, + 140 + ] + }, + { + "type": "title", + "bbox": [ + 278, + 168, + 333, + 181 + ], + "lines": [ + { + "bbox": [ + 276, + 168, + 335, + 182 + ], + "spans": [ + { + "bbox": [ + 276, + 168, + 335, + 182 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 143, + 196, + 468, + 361 + ], + "lines": [ + { + "bbox": [ + 142, + 197, + 469, + 209 + ], + "spans": [ + { + "bbox": [ + 142, + 197, + 469, + 209 + ], + "score": 1.0, + "content": "This paper revisits the problem of sequence modeling using convolutional archi-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 141, + 207, + 470, + 222 + ], + "spans": [ + { + "bbox": [ + 141, + 207, + 470, + 222 + ], + "score": 1.0, + "content": "tectures. Although both convolutional and recurrent architectures have a long", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 140, + 218, + 470, + 233 + ], + "spans": [ + { + "bbox": [ + 140, + 218, + 470, + 233 + ], + "score": 1.0, + "content": "history in sequence prediction, the current “default” mindset in much of the deep", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 230, + 469, + 244 + ], + "spans": [ + { + "bbox": [ + 141, + 230, + 469, + 244 + ], + "score": 1.0, + "content": "learning community is that generic sequence modeling is best handled using re-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 241, + 469, + 253 + ], + "spans": [ + { + "bbox": [ + 141, + 241, + 469, + 253 + ], + "score": 1.0, + "content": "current networks. The goal of this paper is to question this assumption. Specifi-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 252, + 470, + 264 + ], + "spans": [ + { + "bbox": [ + 141, + 252, + 470, + 264 + ], + "score": 1.0, + "content": "cally, we consider a simple generic temporal convolution network (TCN), which", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 141, + 263, + 469, + 275 + ], + "spans": [ + { + "bbox": [ + 141, + 263, + 469, + 275 + ], + "score": 1.0, + "content": "adopts features from modern ConvNet architectures such as a dilations and resid-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 274, + 470, + 286 + ], + "spans": [ + { + "bbox": [ + 141, + 274, + 470, + 286 + ], + "score": 1.0, + "content": "ual connections. We show that on a variety of sequence modeling tasks, includ-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 140, + 285, + 470, + 297 + ], + "spans": [ + { + "bbox": [ + 140, + 285, + 470, + 297 + ], + "score": 1.0, + "content": "ing many frequently used as benchmarks for evaluating recurrent networks, the", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 295, + 469, + 308 + ], + "spans": [ + { + "bbox": [ + 141, + 295, + 469, + 308 + ], + "score": 1.0, + "content": "TCN outperforms baseline RNN methods (LSTMs, GRUs, and vanilla RNNs)", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 306, + 469, + 320 + ], + "spans": [ + { + "bbox": [ + 141, + 306, + 469, + 320 + ], + "score": 1.0, + "content": "and sometimes even highly specialized approaches. We further show that the po-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 318, + 469, + 330 + ], + "spans": [ + { + "bbox": [ + 141, + 318, + 469, + 330 + ], + "score": 1.0, + "content": "tential “infinite memory” advantage that RNNs have over TCNs is largely absent", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 329, + 470, + 341 + ], + "spans": [ + { + "bbox": [ + 141, + 329, + 470, + 341 + ], + "score": 1.0, + "content": "in practice: TCNs indeed exhibit longer effective history sizes than their recurrent", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 340, + 469, + 351 + ], + "spans": [ + { + "bbox": [ + 141, + 340, + 469, + 351 + ], + "score": 1.0, + "content": "counterparts. As a whole, we argue that it may be time to (re)consider ConvNets", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 141, + 349, + 375, + 364 + ], + "spans": [ + { + "bbox": [ + 141, + 349, + 375, + 364 + ], + "score": 1.0, + "content": "as the default “go to” architecture for sequence modeling.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 11, + "bbox_fs": [ + 140, + 197, + 470, + 364 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 390, + 205, + 403 + ], + "lines": [ + { + "bbox": [ + 105, + 389, + 208, + 406 + ], + "spans": [ + { + "bbox": [ + 105, + 389, + 208, + 406 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 107, + 419, + 505, + 539 + ], + "lines": [ + { + "bbox": [ + 105, + 418, + 505, + 431 + ], + "spans": [ + { + "bbox": [ + 105, + 418, + 505, + 431 + ], + "score": 1.0, + "content": "Since the re-emergence of neural networks to the forefront of machine learning, two types of net-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 430, + 505, + 441 + ], + "spans": [ + { + "bbox": [ + 106, + 430, + 505, + 441 + ], + "score": 1.0, + "content": "work architectures have played a pivotal role: the convolutional network, often used for vision and", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 440, + 505, + 454 + ], + "spans": [ + { + "bbox": [ + 105, + 440, + 505, + 454 + ], + "score": 1.0, + "content": "higher-dimensional input data; and the recurrent network, typically used for modeling sequential", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 450, + 505, + 465 + ], + "spans": [ + { + "bbox": [ + 105, + 450, + 505, + 465 + ], + "score": 1.0, + "content": "data. These two types of architectures have become so ingrained in modern deep learning that they", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 463, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 463, + 505, + 475 + ], + "score": 1.0, + "content": "can be viewed as constituting the “pillars” of deep learning approaches. This paper looks at the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 473, + 505, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 505, + 487 + ], + "score": 1.0, + "content": "problem of sequence modeling, predicting how a sequence will evolve over time. This is a key", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 484, + 506, + 498 + ], + "spans": [ + { + "bbox": [ + 105, + 484, + 506, + 498 + ], + "score": 1.0, + "content": "problem in domains spanning audio, language modeling, music processing, time series forecasting,", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 495, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 505, + 507 + ], + "score": 1.0, + "content": "and many others. Although exceptions certainly exist in some domains, the current “default” think-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 506, + 506, + 518 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 506, + 518 + ], + "score": 1.0, + "content": "ing in the deep learning community is that these sequential tasks are best handled by some type of", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 518, + 505, + 530 + ], + "spans": [ + { + "bbox": [ + 105, + 518, + 505, + 530 + ], + "score": 1.0, + "content": "recurrent network. Our aim is to revisit this default thinking, and specifically ask whether modern", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 527, + 420, + 542 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 420, + 542 + ], + "score": 1.0, + "content": "convolutional architectures are in fact just as powerful for sequence modeling.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 25, + "bbox_fs": [ + 105, + 418, + 506, + 542 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 545, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 545, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 105, + 545, + 505, + 558 + ], + "score": 1.0, + "content": "Before making the main claims of our paper, some history of convolutional and recurrent models", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 556, + 506, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 506, + 569 + ], + "score": 1.0, + "content": "for sequence modeling is useful. In the early history of neural networks, convolutional models were", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 567, + 506, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 567, + 506, + 579 + ], + "score": 1.0, + "content": "specifically proposed as a means of handling sequence data, the idea being that one could slide a", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 578, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 106, + 578, + 505, + 590 + ], + "score": 1.0, + "content": "1-D convolutional filter over the data (and stack such layers together) to predict future elements of a", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 589, + 505, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 589, + 505, + 601 + ], + "score": 1.0, + "content": "sequence from past ones (Hinton, 1989; LeCun et al., 1995). Thus, the idea of using convolutional", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 600, + 505, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 600, + 505, + 613 + ], + "score": 1.0, + "content": "models for sequence modeling goes back to the beginning of convolutional architectures themselves.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 611, + 505, + 624 + ], + "spans": [ + { + "bbox": [ + 105, + 611, + 505, + 624 + ], + "score": 1.0, + "content": "However, these models were subsequently largely abandoned for many sequence modeling tasks in", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 622, + 505, + 635 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 505, + 635 + ], + "score": 1.0, + "content": "favor of recurrent networks (Elman, 1990). The reasoning for this appears straightforward: while", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 633, + 505, + 645 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 505, + 645 + ], + "score": 1.0, + "content": "convolutional architectures have a limited ability to look back in time (i.e., their receptive field is", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 643, + 505, + 657 + ], + "spans": [ + { + "bbox": [ + 105, + 643, + 505, + 657 + ], + "score": 1.0, + "content": "limited by the size and layers of the filters), recurrent networks have no such limitation. Because re-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 104, + 654, + 505, + 669 + ], + "spans": [ + { + "bbox": [ + 104, + 654, + 505, + 669 + ], + "score": 1.0, + "content": "current networks propagate forward a hidden state, they are theoretically capable of infinite memory,", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 664, + 505, + 679 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 505, + 679 + ], + "score": 1.0, + "content": "the ability to make predictions based upon data that occurred arbitrarily long ago in the sequence.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 677, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 690 + ], + "score": 1.0, + "content": "This possibility seems to be realized even moreso for the now-standard architectures of Long Short-", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 688, + 505, + 699 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 505, + 699 + ], + "score": 1.0, + "content": "Term Memory networks (LSTMs) (Hochreiter & Schmidhuber, 1997), or recent incarnations such", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "as the Gated Recurrent Unit (GRU) (Cho et al., 2014); these architectures aim to avoid the “vanish-", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 710, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 505, + 723 + ], + "score": 1.0, + "content": "ing gradient” challenge of traditional RNNs and appear to provide a means to actually realize this", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 720, + 174, + 734 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 174, + 734 + ], + "score": 1.0, + "content": "infinite memory.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 39, + "bbox_fs": [ + 104, + 545, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 159 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "Given the substantial limitations of convolutional architectures at the time that RNNs/LSTMs were", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "initially proposed (when deep convolutional architectures were difficult to train, and strategies such", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 506, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 506, + 117 + ], + "score": 1.0, + "content": "as dilated convolutions had not reached widespread use), it is no surprise that CNNs fell out of", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 114, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 114, + 505, + 128 + ], + "score": 1.0, + "content": "favor to RNNs. While there have been a few notable examples in recent years of CNNs applied", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 505, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 505, + 139 + ], + "score": 1.0, + "content": "to sequence modeling (e.g., the WaveNet (Oord et al., 2016a) and PixelCNN (Oord et al., 2016b)", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 137, + 506, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 506, + 150 + ], + "score": 1.0, + "content": "architectures), the general “folk wisdom” of sequence modeling prevails, that the first avenue of", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 149, + 383, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 149, + 383, + 161 + ], + "score": 1.0, + "content": "attack for these problems should be some form of recurrent network.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 107, + 165, + 504, + 231 + ], + "lines": [ + { + "bbox": [ + 105, + 164, + 505, + 177 + ], + "spans": [ + { + "bbox": [ + 105, + 164, + 505, + 177 + ], + "score": 1.0, + "content": "The fundamental aim of this paper is to revisit this folk wisdom, and thereby make a counterclaim.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "score": 1.0, + "content": "We argue that with the tools of modern convolutional architectures at our disposal (namely the ability", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 186, + 506, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 186, + 506, + 201 + ], + "score": 1.0, + "content": "to train very deep networks via residual connections and other similar mechanisms, plus the ability", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 199, + 505, + 210 + ], + "spans": [ + { + "bbox": [ + 106, + 199, + 505, + 210 + ], + "score": 1.0, + "content": "to increase receptive field size via dilations), in fact convolutional architectures typically outperform", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 104, + 208, + 506, + 223 + ], + "spans": [ + { + "bbox": [ + 104, + 208, + 506, + 223 + ], + "score": 1.0, + "content": "recurrent architectures on sequence modeling tasks, especially (and perhaps somewhat surprisingly)", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 220, + 455, + 233 + ], + "spans": [ + { + "bbox": [ + 105, + 220, + 455, + 233 + ], + "score": 1.0, + "content": "on domains where a long effective history length is needed to make proper predictions.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 9.5 + }, + { + "type": "text", + "bbox": [ + 107, + 237, + 505, + 435 + ], + "lines": [ + { + "bbox": [ + 105, + 236, + 505, + 250 + ], + "spans": [ + { + "bbox": [ + 105, + 236, + 505, + 250 + ], + "score": 1.0, + "content": "This paper consists of two main contributions. First, we describe a generic, baseline temporal convo-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 247, + 505, + 261 + ], + "spans": [ + { + "bbox": [ + 105, + 247, + 505, + 261 + ], + "score": 1.0, + "content": "lutional network (TCN) architecture, combining best practices in the design of modern convolutional", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 259, + 505, + 272 + ], + "spans": [ + { + "bbox": [ + 105, + 259, + 505, + 272 + ], + "score": 1.0, + "content": "architectures, including residual layers and dilation. We emphasize that we are not claiming to in-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 270, + 505, + 282 + ], + "spans": [ + { + "bbox": [ + 105, + 270, + 505, + 282 + ], + "score": 1.0, + "content": "vent the practice of applying convolutional architectures to sequence prediction, and indeed the TCN", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 281, + 504, + 293 + ], + "spans": [ + { + "bbox": [ + 106, + 281, + 504, + 293 + ], + "score": 1.0, + "content": "architecture here mirrors closely architectures such as WaveNet (in fact TCN is notably simpler in", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 104, + 291, + 505, + 306 + ], + "spans": [ + { + "bbox": [ + 104, + 291, + 505, + 306 + ], + "score": 1.0, + "content": "some respects). We do, however, want to propose a generic modern form of convolutional sequence", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 303, + 505, + 316 + ], + "spans": [ + { + "bbox": [ + 105, + 303, + 505, + 316 + ], + "score": 1.0, + "content": "prediction for subsequent experimentation. Second, and more importantly, we extensively evaluate", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 313, + 505, + 327 + ], + "spans": [ + { + "bbox": [ + 105, + 313, + 505, + 327 + ], + "score": 1.0, + "content": "the TCN model versus alternative approaches on a wide variety of sequence modeling tasks, span-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 104, + 324, + 505, + 339 + ], + "spans": [ + { + "bbox": [ + 104, + 324, + 505, + 339 + ], + "score": 1.0, + "content": "ning many domains and datasets that have typically been the purview of recurrent models, including", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 335, + 506, + 349 + ], + "spans": [ + { + "bbox": [ + 105, + 335, + 506, + 349 + ], + "score": 1.0, + "content": "word- and character-level language modeling, polyphonic music prediction, and other baseline tasks", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 347, + 505, + 358 + ], + "spans": [ + { + "bbox": [ + 106, + 347, + 505, + 358 + ], + "score": 1.0, + "content": "commonly used to evaluate recurrent architectures. Although our baseline TCN can be outperformed", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 357, + 506, + 370 + ], + "spans": [ + { + "bbox": [ + 105, + 357, + 506, + 370 + ], + "score": 1.0, + "content": "by specialized (and typically highly-tuned) RNNs in some cases, for the majority of problems the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 369, + 506, + 381 + ], + "spans": [ + { + "bbox": [ + 106, + 369, + 506, + 381 + ], + "score": 1.0, + "content": "TCN performs best, with minimal tuning on the architecture or the optimization. This paper also", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 380, + 505, + 391 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 505, + 391 + ], + "score": 1.0, + "content": "analyzes empirically the myth of “infinite memory” in RNNs, and shows that in practice, TCNs", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 390, + 506, + 403 + ], + "spans": [ + { + "bbox": [ + 105, + 390, + 506, + 403 + ], + "score": 1.0, + "content": "of similar size and complexity may actually demonstrate longer effective history sizes. Our chief", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 401, + 506, + 414 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 506, + 414 + ], + "score": 1.0, + "content": "claim in this paper is thus an empirical one: rather than presuming that RNNs will be the default", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 412, + 506, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 506, + 425 + ], + "score": 1.0, + "content": "best method for sequence modeling tasks, it may be time to (re)consider ConvNets as the “go-to”", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 424, + 373, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 424, + 373, + 437 + ], + "score": 1.0, + "content": "approach when facing a new dataset or task in sequence modeling.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 21.5 + }, + { + "type": "title", + "bbox": [ + 108, + 455, + 211, + 468 + ], + "lines": [ + { + "bbox": [ + 104, + 454, + 213, + 471 + ], + "spans": [ + { + "bbox": [ + 104, + 454, + 213, + 471 + ], + "score": 1.0, + "content": "2 RELATED WORK", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 108, + 483, + 503, + 505 + ], + "lines": [ + { + "bbox": [ + 106, + 483, + 505, + 496 + ], + "spans": [ + { + "bbox": [ + 106, + 483, + 505, + 496 + ], + "score": 1.0, + "content": "In this section we highlight some of the key innovations in the history of recurrent and convolutional", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 494, + 258, + 507 + ], + "spans": [ + { + "bbox": [ + 106, + 494, + 258, + 507 + ], + "score": 1.0, + "content": "architectures for sequence prediction.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 107, + 511, + 505, + 577 + ], + "lines": [ + { + "bbox": [ + 106, + 512, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 106, + 512, + 505, + 523 + ], + "score": 1.0, + "content": "Recurrent networks broadly refer to networks that maintain a vector of hidden activations, which are", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 523, + 505, + 534 + ], + "spans": [ + { + "bbox": [ + 106, + 523, + 505, + 534 + ], + "score": 1.0, + "content": "kept over time by propagating them through the network. The intuitive appeal of this approach is that", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 532, + 505, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 532, + 505, + 546 + ], + "score": 1.0, + "content": "the hidden state can act as a sort of “memory” of everything that has been seen so far in a sequence,", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 545, + 505, + 557 + ], + "spans": [ + { + "bbox": [ + 106, + 545, + 505, + 557 + ], + "score": 1.0, + "content": "without the need for keeping an explicit history. Unfortunately, such memory comes at a cost, and", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 554, + 506, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 506, + 569 + ], + "score": 1.0, + "content": "it is well-known that the na¨ıve RNN architecture is difficult to train due to the exploding/vanishing", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 566, + 264, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 264, + 578 + ], + "score": 1.0, + "content": "gradient problem (Bengio et al., 1994).", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 36.5 + }, + { + "type": "text", + "bbox": [ + 107, + 583, + 505, + 704 + ], + "lines": [ + { + "bbox": [ + 105, + 581, + 505, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 581, + 505, + 596 + ], + "score": 1.0, + "content": "A number of solutions have been proposed to address this issue. More than twenty years", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 593, + 505, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 593, + 505, + 608 + ], + "score": 1.0, + "content": "ago, Hochreiter & Schmidhuber (1997) introduced the now-ubiquitous Long Short-Term Memory", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 605, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 505, + 617 + ], + "score": 1.0, + "content": "(LSTM) which uses a set of gates to explicitly maintain memory cells that are propagated forward", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 617, + 505, + 628 + ], + "spans": [ + { + "bbox": [ + 106, + 617, + 505, + 628 + ], + "score": 1.0, + "content": "in time. Other solutions or refinements include a simplified variant of LSTM, the Gated Recurrent", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 626, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 505, + 639 + ], + "score": 1.0, + "content": "Unit (GRU) (Cho et al., 2014), peephole connections (Gers et al., 2002), Clockwork RNN (Koutnik", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 637, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 505, + 650 + ], + "score": 1.0, + "content": "et al., 2014) and recent works such as MI-RNN (Wu et al., 2016) and the Dilated RNN (Chang et al.,", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 649, + 506, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 506, + 661 + ], + "score": 1.0, + "content": "2017). Alternatively, several regularization techniques have been proposed to better train LSTMs,", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 660, + 506, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 506, + 672 + ], + "score": 1.0, + "content": "such as those based upon the properties of the RNN dynamical system (Pascanu et al., 2013); more", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 671, + 505, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 505, + 683 + ], + "score": 1.0, + "content": "recently, strategies such as Zoneout (Krueger et al., 2017) and AWD-LSTM (Merity et al., 2017)", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 106, + 682, + 506, + 694 + ], + "spans": [ + { + "bbox": [ + 106, + 682, + 506, + 694 + ], + "score": 1.0, + "content": "were also introduced to regularize LSTM in various ways, and have achieved exceptional results in", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 106, + 692, + 233, + 706 + ], + "spans": [ + { + "bbox": [ + 106, + 692, + 233, + 706 + ], + "score": 1.0, + "content": "the field of language modeling.", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 45 + }, + { + "type": "text", + "bbox": [ + 108, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "While it is frequently criticized as a seemingly “ad-hoc” architecture, LSTMs have proven to be", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 106, + 721, + 505, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 505, + 732 + ], + "score": 1.0, + "content": "extremely robust and is very hard to improve upon by other recurrent architectures, at least for", + "type": "text" + } + ], + "index": 52 + } + ], + "index": 51.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, + 505, + 159 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "Given the substantial limitations of convolutional architectures at the time that RNNs/LSTMs were", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "initially proposed (when deep convolutional architectures were difficult to train, and strategies such", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 506, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 506, + 117 + ], + "score": 1.0, + "content": "as dilated convolutions had not reached widespread use), it is no surprise that CNNs fell out of", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 114, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 114, + 505, + 128 + ], + "score": 1.0, + "content": "favor to RNNs. While there have been a few notable examples in recent years of CNNs applied", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 505, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 505, + 139 + ], + "score": 1.0, + "content": "to sequence modeling (e.g., the WaveNet (Oord et al., 2016a) and PixelCNN (Oord et al., 2016b)", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 137, + 506, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 506, + 150 + ], + "score": 1.0, + "content": "architectures), the general “folk wisdom” of sequence modeling prevails, that the first avenue of", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 149, + 383, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 149, + 383, + 161 + ], + "score": 1.0, + "content": "attack for these problems should be some form of recurrent network.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 3, + "bbox_fs": [ + 105, + 82, + 506, + 161 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 165, + 504, + 231 + ], + "lines": [ + { + "bbox": [ + 105, + 164, + 505, + 177 + ], + "spans": [ + { + "bbox": [ + 105, + 164, + 505, + 177 + ], + "score": 1.0, + "content": "The fundamental aim of this paper is to revisit this folk wisdom, and thereby make a counterclaim.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "score": 1.0, + "content": "We argue that with the tools of modern convolutional architectures at our disposal (namely the ability", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 186, + 506, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 186, + 506, + 201 + ], + "score": 1.0, + "content": "to train very deep networks via residual connections and other similar mechanisms, plus the ability", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 199, + 505, + 210 + ], + "spans": [ + { + "bbox": [ + 106, + 199, + 505, + 210 + ], + "score": 1.0, + "content": "to increase receptive field size via dilations), in fact convolutional architectures typically outperform", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 104, + 208, + 506, + 223 + ], + "spans": [ + { + "bbox": [ + 104, + 208, + 506, + 223 + ], + "score": 1.0, + "content": "recurrent architectures on sequence modeling tasks, especially (and perhaps somewhat surprisingly)", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 220, + 455, + 233 + ], + "spans": [ + { + "bbox": [ + 105, + 220, + 455, + 233 + ], + "score": 1.0, + "content": "on domains where a long effective history length is needed to make proper predictions.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 9.5, + "bbox_fs": [ + 104, + 164, + 506, + 233 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 237, + 505, + 435 + ], + "lines": [ + { + "bbox": [ + 105, + 236, + 505, + 250 + ], + "spans": [ + { + "bbox": [ + 105, + 236, + 505, + 250 + ], + "score": 1.0, + "content": "This paper consists of two main contributions. First, we describe a generic, baseline temporal convo-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 247, + 505, + 261 + ], + "spans": [ + { + "bbox": [ + 105, + 247, + 505, + 261 + ], + "score": 1.0, + "content": "lutional network (TCN) architecture, combining best practices in the design of modern convolutional", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 259, + 505, + 272 + ], + "spans": [ + { + "bbox": [ + 105, + 259, + 505, + 272 + ], + "score": 1.0, + "content": "architectures, including residual layers and dilation. We emphasize that we are not claiming to in-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 270, + 505, + 282 + ], + "spans": [ + { + "bbox": [ + 105, + 270, + 505, + 282 + ], + "score": 1.0, + "content": "vent the practice of applying convolutional architectures to sequence prediction, and indeed the TCN", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 281, + 504, + 293 + ], + "spans": [ + { + "bbox": [ + 106, + 281, + 504, + 293 + ], + "score": 1.0, + "content": "architecture here mirrors closely architectures such as WaveNet (in fact TCN is notably simpler in", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 104, + 291, + 505, + 306 + ], + "spans": [ + { + "bbox": [ + 104, + 291, + 505, + 306 + ], + "score": 1.0, + "content": "some respects). We do, however, want to propose a generic modern form of convolutional sequence", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 303, + 505, + 316 + ], + "spans": [ + { + "bbox": [ + 105, + 303, + 505, + 316 + ], + "score": 1.0, + "content": "prediction for subsequent experimentation. Second, and more importantly, we extensively evaluate", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 313, + 505, + 327 + ], + "spans": [ + { + "bbox": [ + 105, + 313, + 505, + 327 + ], + "score": 1.0, + "content": "the TCN model versus alternative approaches on a wide variety of sequence modeling tasks, span-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 104, + 324, + 505, + 339 + ], + "spans": [ + { + "bbox": [ + 104, + 324, + 505, + 339 + ], + "score": 1.0, + "content": "ning many domains and datasets that have typically been the purview of recurrent models, including", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 335, + 506, + 349 + ], + "spans": [ + { + "bbox": [ + 105, + 335, + 506, + 349 + ], + "score": 1.0, + "content": "word- and character-level language modeling, polyphonic music prediction, and other baseline tasks", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 347, + 505, + 358 + ], + "spans": [ + { + "bbox": [ + 106, + 347, + 505, + 358 + ], + "score": 1.0, + "content": "commonly used to evaluate recurrent architectures. Although our baseline TCN can be outperformed", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 357, + 506, + 370 + ], + "spans": [ + { + "bbox": [ + 105, + 357, + 506, + 370 + ], + "score": 1.0, + "content": "by specialized (and typically highly-tuned) RNNs in some cases, for the majority of problems the", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 369, + 506, + 381 + ], + "spans": [ + { + "bbox": [ + 106, + 369, + 506, + 381 + ], + "score": 1.0, + "content": "TCN performs best, with minimal tuning on the architecture or the optimization. This paper also", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 380, + 505, + 391 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 505, + 391 + ], + "score": 1.0, + "content": "analyzes empirically the myth of “infinite memory” in RNNs, and shows that in practice, TCNs", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 390, + 506, + 403 + ], + "spans": [ + { + "bbox": [ + 105, + 390, + 506, + 403 + ], + "score": 1.0, + "content": "of similar size and complexity may actually demonstrate longer effective history sizes. Our chief", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 401, + 506, + 414 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 506, + 414 + ], + "score": 1.0, + "content": "claim in this paper is thus an empirical one: rather than presuming that RNNs will be the default", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 412, + 506, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 506, + 425 + ], + "score": 1.0, + "content": "best method for sequence modeling tasks, it may be time to (re)consider ConvNets as the “go-to”", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 424, + 373, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 424, + 373, + 437 + ], + "score": 1.0, + "content": "approach when facing a new dataset or task in sequence modeling.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 21.5, + "bbox_fs": [ + 104, + 236, + 506, + 437 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 455, + 211, + 468 + ], + "lines": [ + { + "bbox": [ + 104, + 454, + 213, + 471 + ], + "spans": [ + { + "bbox": [ + 104, + 454, + 213, + 471 + ], + "score": 1.0, + "content": "2 RELATED WORK", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 108, + 483, + 503, + 505 + ], + "lines": [ + { + "bbox": [ + 106, + 483, + 505, + 496 + ], + "spans": [ + { + "bbox": [ + 106, + 483, + 505, + 496 + ], + "score": 1.0, + "content": "In this section we highlight some of the key innovations in the history of recurrent and convolutional", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 494, + 258, + 507 + ], + "spans": [ + { + "bbox": [ + 106, + 494, + 258, + 507 + ], + "score": 1.0, + "content": "architectures for sequence prediction.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32.5, + "bbox_fs": [ + 106, + 483, + 505, + 507 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 511, + 505, + 577 + ], + "lines": [ + { + "bbox": [ + 106, + 512, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 106, + 512, + 505, + 523 + ], + "score": 1.0, + "content": "Recurrent networks broadly refer to networks that maintain a vector of hidden activations, which are", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 523, + 505, + 534 + ], + "spans": [ + { + "bbox": [ + 106, + 523, + 505, + 534 + ], + "score": 1.0, + "content": "kept over time by propagating them through the network. The intuitive appeal of this approach is that", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 532, + 505, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 532, + 505, + 546 + ], + "score": 1.0, + "content": "the hidden state can act as a sort of “memory” of everything that has been seen so far in a sequence,", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 545, + 505, + 557 + ], + "spans": [ + { + "bbox": [ + 106, + 545, + 505, + 557 + ], + "score": 1.0, + "content": "without the need for keeping an explicit history. Unfortunately, such memory comes at a cost, and", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 554, + 506, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 506, + 569 + ], + "score": 1.0, + "content": "it is well-known that the na¨ıve RNN architecture is difficult to train due to the exploding/vanishing", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 566, + 264, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 264, + 578 + ], + "score": 1.0, + "content": "gradient problem (Bengio et al., 1994).", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 36.5, + "bbox_fs": [ + 105, + 512, + 506, + 578 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 583, + 505, + 704 + ], + "lines": [ + { + "bbox": [ + 105, + 581, + 505, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 581, + 505, + 596 + ], + "score": 1.0, + "content": "A number of solutions have been proposed to address this issue. More than twenty years", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 593, + 505, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 593, + 505, + 608 + ], + "score": 1.0, + "content": "ago, Hochreiter & Schmidhuber (1997) introduced the now-ubiquitous Long Short-Term Memory", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 605, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 505, + 617 + ], + "score": 1.0, + "content": "(LSTM) which uses a set of gates to explicitly maintain memory cells that are propagated forward", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 617, + 505, + 628 + ], + "spans": [ + { + "bbox": [ + 106, + 617, + 505, + 628 + ], + "score": 1.0, + "content": "in time. Other solutions or refinements include a simplified variant of LSTM, the Gated Recurrent", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 626, + 505, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 505, + 639 + ], + "score": 1.0, + "content": "Unit (GRU) (Cho et al., 2014), peephole connections (Gers et al., 2002), Clockwork RNN (Koutnik", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 637, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 505, + 650 + ], + "score": 1.0, + "content": "et al., 2014) and recent works such as MI-RNN (Wu et al., 2016) and the Dilated RNN (Chang et al.,", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 649, + 506, + 661 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 506, + 661 + ], + "score": 1.0, + "content": "2017). Alternatively, several regularization techniques have been proposed to better train LSTMs,", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 660, + 506, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 506, + 672 + ], + "score": 1.0, + "content": "such as those based upon the properties of the RNN dynamical system (Pascanu et al., 2013); more", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 671, + 505, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 505, + 683 + ], + "score": 1.0, + "content": "recently, strategies such as Zoneout (Krueger et al., 2017) and AWD-LSTM (Merity et al., 2017)", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 106, + 682, + 506, + 694 + ], + "spans": [ + { + "bbox": [ + 106, + 682, + 506, + 694 + ], + "score": 1.0, + "content": "were also introduced to regularize LSTM in various ways, and have achieved exceptional results in", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 106, + 692, + 233, + 706 + ], + "spans": [ + { + "bbox": [ + 106, + 692, + 233, + 706 + ], + "score": 1.0, + "content": "the field of language modeling.", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 45, + "bbox_fs": [ + 105, + 581, + 506, + 706 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "While it is frequently criticized as a seemingly “ad-hoc” architecture, LSTMs have proven to be", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 106, + 721, + 505, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 505, + 732 + ], + "score": 1.0, + "content": "extremely robust and is very hard to improve upon by other recurrent architectures, at least for", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 105, + 83, + 506, + 94 + ], + "spans": [ + { + "bbox": [ + 105, + 83, + 506, + 94 + ], + "score": 1.0, + "content": "general problems. Jozefowicz et al. (2015) concluded that if there were “architectures much better", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 506, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 506, + 106 + ], + "score": 1.0, + "content": "than the LSTM”, then they were “not trivial to find”. However, while they evaluated a variety of", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 104, + 104, + 506, + 118 + ], + "spans": [ + { + "bbox": [ + 104, + 104, + 506, + 118 + ], + "score": 1.0, + "content": "recurrent architectures with different combinations of components via an evolutionary search, they", + "type": "text", + "cross_page": true + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 115, + 460, + 127 + ], + "spans": [ + { + "bbox": [ + 106, + 115, + 460, + 127 + ], + "score": 1.0, + "content": "did not consider architectures that were fundamentally different from the recurrent ones.", + "type": "text", + "cross_page": true + } + ], + "index": 3 + } + ], + "index": 51.5, + "bbox_fs": [ + 106, + 709, + 505, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 82, + 504, + 126 + ], + "lines": [ + { + "bbox": [ + 105, + 83, + 506, + 94 + ], + "spans": [ + { + "bbox": [ + 105, + 83, + 506, + 94 + ], + "score": 1.0, + "content": "general problems. Jozefowicz et al. (2015) concluded that if there were “architectures much better", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 94, + 506, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 94, + 506, + 106 + ], + "score": 1.0, + "content": "than the LSTM”, then they were “not trivial to find”. However, while they evaluated a variety of", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 104, + 104, + 506, + 118 + ], + "spans": [ + { + "bbox": [ + 104, + 104, + 506, + 118 + ], + "score": 1.0, + "content": "recurrent architectures with different combinations of components via an evolutionary search, they", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 115, + 460, + 127 + ], + "spans": [ + { + "bbox": [ + 106, + 115, + 460, + 127 + ], + "score": 1.0, + "content": "did not consider architectures that were fundamentally different from the recurrent ones.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 1.5 + }, + { + "type": "text", + "bbox": [ + 107, + 132, + 505, + 297 + ], + "lines": [ + { + "bbox": [ + 105, + 132, + 505, + 145 + ], + "spans": [ + { + "bbox": [ + 105, + 132, + 505, + 145 + ], + "score": 1.0, + "content": "The history of convolutional architectures for time series is comparatively shorter, as they soon fell", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 143, + 505, + 156 + ], + "spans": [ + { + "bbox": [ + 105, + 143, + 505, + 156 + ], + "score": 1.0, + "content": "out of favor compared to recurrent architectures for these tasks, though are also seeing a resurgence", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 154, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 154, + 505, + 167 + ], + "score": 1.0, + "content": "in recent years. Waibel et al. (1989) and Bottou et al. (1990) studied the usage of time-delay net-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 165, + 505, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 165, + 505, + 178 + ], + "score": 1.0, + "content": "works (TDNNs) for sequences, one of the earliest local-connection-based networks in this domain.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 174, + 505, + 190 + ], + "spans": [ + { + "bbox": [ + 105, + 174, + 505, + 190 + ], + "score": 1.0, + "content": "LeCun et al. (1995) then proposed and examined the usage of CNNs on time-series data, pointing", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 187, + 505, + 199 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 505, + 199 + ], + "score": 1.0, + "content": "out that the same kind of feature extraction used in images could work well on sequence model-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 198, + 505, + 210 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 505, + 210 + ], + "score": 1.0, + "content": "ing with convolutional filters. Recent years have seen a re-emergence of convolutional models for", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 209, + 505, + 222 + ], + "spans": [ + { + "bbox": [ + 105, + 209, + 505, + 222 + ], + "score": 1.0, + "content": "sequence data. Perhaps most notably, the WaveNet (Oord et al., 2016a) applied a stacked convolu-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 220, + 505, + 232 + ], + "spans": [ + { + "bbox": [ + 105, + 220, + 505, + 232 + ], + "score": 1.0, + "content": "tional architecture to model audio signals, using a combination of dilations (Yu & Koltun, 2015),", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 231, + 505, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 231, + 505, + 244 + ], + "score": 1.0, + "content": "skip connections, gating, and conditioning on context stacks; the WaveNet mode was additionally", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 242, + 505, + 254 + ], + "spans": [ + { + "bbox": [ + 105, + 242, + 505, + 254 + ], + "score": 1.0, + "content": "applied to a few other contexts, such as financial applications (Borovykh et al., 2017). Non-dilated", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 252, + 505, + 266 + ], + "spans": [ + { + "bbox": [ + 105, + 252, + 505, + 266 + ], + "score": 1.0, + "content": "gated convolutions have also been applied in the context of language modeling (Dauphin et al.,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 263, + 505, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 263, + 505, + 277 + ], + "score": 1.0, + "content": "2017). And finally, convolutional models have seen a recent adoption in sequence to sequence mod-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 275, + 505, + 288 + ], + "spans": [ + { + "bbox": [ + 105, + 275, + 505, + 288 + ], + "score": 1.0, + "content": "eling and machine translations applications, such as the ByteNet (Kalchbrenner et al., 2016) and", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 285, + 290, + 298 + ], + "spans": [ + { + "bbox": [ + 105, + 285, + 290, + 298 + ], + "score": 1.0, + "content": "ConvS2S architectures (Gehring et al., 2017).", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 107, + 303, + 504, + 357 + ], + "lines": [ + { + "bbox": [ + 106, + 303, + 505, + 315 + ], + "spans": [ + { + "bbox": [ + 106, + 303, + 505, + 315 + ], + "score": 1.0, + "content": "Despite these successes, the general consensus of the deep learning community seems to be that", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 312, + 505, + 326 + ], + "spans": [ + { + "bbox": [ + 105, + 312, + 505, + 326 + ], + "score": 1.0, + "content": "RNNs (here meaning all RNNs including LSTM and its variants) are better suited to sequence mod-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 324, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 324, + 506, + 338 + ], + "score": 1.0, + "content": "eling for two apparent reasons: 1) as discussed before, RNNs are theoretically capable of infinite", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 335, + 506, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 335, + 506, + 348 + ], + "score": 1.0, + "content": "memory; and 2) RNN models are inherently suitable for sequential inputs of varying length, whereas", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 345, + 439, + 359 + ], + "spans": [ + { + "bbox": [ + 105, + 345, + 439, + 359 + ], + "score": 1.0, + "content": "CNNs seem to be more appropriate in domains with fixed-size inputs (e.g., vision).", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 363, + 505, + 528 + ], + "lines": [ + { + "bbox": [ + 105, + 362, + 506, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 506, + 376 + ], + "score": 1.0, + "content": "With this as the context, this paper reconsiders convolutional sequence modeling in general, first", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 373, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 105, + 373, + 505, + 388 + ], + "score": 1.0, + "content": "introducing a simple general-purpose convolutional sequence modeling architecture that can be ap-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 385, + 505, + 397 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 505, + 397 + ], + "score": 1.0, + "content": "plied in all the same scenarios as an RNN (the architecture acts as a “drop-in” replacement for RNNs", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 397, + 505, + 408 + ], + "spans": [ + { + "bbox": [ + 106, + 397, + 505, + 408 + ], + "score": 1.0, + "content": "of any kind). We then extensively evaluate the performance of the architecture on tasks from dif-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 407, + 506, + 420 + ], + "spans": [ + { + "bbox": [ + 105, + 407, + 506, + 420 + ], + "score": 1.0, + "content": "ferent domains, focusing on domains and settings that have been used explicitly as applications and", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 418, + 506, + 431 + ], + "spans": [ + { + "bbox": [ + 105, + 418, + 506, + 431 + ], + "score": 1.0, + "content": "benchmarks for RNNs in the recent past. With regard to the specific architectures mentioned above", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 429, + 505, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 429, + 505, + 442 + ], + "score": 1.0, + "content": "(e.g. WaveNet, ByteNet, gated convolutional language models), the primary goal here is to describe", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 440, + 505, + 454 + ], + "spans": [ + { + "bbox": [ + 105, + 440, + 505, + 454 + ], + "score": 1.0, + "content": "a simple, application-independent architecture that avoids much of the extra specialized components", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 451, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 105, + 451, + 505, + 464 + ], + "score": 1.0, + "content": "of these architectures (gating, complex residuals, context stacks, or the encoder-decoder architec-", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 462, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 462, + 505, + 475 + ], + "score": 1.0, + "content": "tures of seq2seq models), and keeps only the “standard” convolutional components from most image", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 473, + 504, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 504, + 486 + ], + "score": 1.0, + "content": "architectures, with the restriction that the convolutions be causal. In several cases we specifically", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 104, + 483, + 505, + 498 + ], + "spans": [ + { + "bbox": [ + 104, + 483, + 505, + 498 + ], + "score": 1.0, + "content": "compare the architecture with and without additional components (e.g., gating elements), and high-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 495, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 505, + 507 + ], + "score": 1.0, + "content": "light that it does not seem to substantially improve performance of the architecture across domains.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 505, + 505, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 505, + 505, + 519 + ], + "score": 1.0, + "content": "Thus, the primary goal of this paper is to provide a baseline architecture for convolutional sequence", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 517, + 461, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 461, + 529 + ], + "score": 1.0, + "content": "prediction tasks, and to evaluate the performance of this model across multiple domains.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 31 + }, + { + "type": "title", + "bbox": [ + 107, + 546, + 336, + 559 + ], + "lines": [ + { + "bbox": [ + 104, + 544, + 339, + 562 + ], + "spans": [ + { + "bbox": [ + 104, + 544, + 339, + 562 + ], + "score": 1.0, + "content": "3 CONVOLUTIONAL SEQUENCE MODELING", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 39 + }, + { + "type": "text", + "bbox": [ + 107, + 573, + 505, + 672 + ], + "lines": [ + { + "bbox": [ + 106, + 573, + 504, + 585 + ], + "spans": [ + { + "bbox": [ + 106, + 573, + 504, + 585 + ], + "score": 1.0, + "content": "In this section, we propose a generic architecture for convolutional sequence prediction, and gen-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 584, + 505, + 596 + ], + "spans": [ + { + "bbox": [ + 106, + 584, + 505, + 596 + ], + "score": 1.0, + "content": "erally refer to it as Temporal Convolution Networks (TCNs). We emphasize that we adopt this", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 595, + 506, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 506, + 608 + ], + "score": 1.0, + "content": "term not as a label for a truly new architecture, but as a simple descriptive term for this and similar", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 605, + 505, + 619 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 505, + 619 + ], + "score": 1.0, + "content": "architectures. The distinguishing characteristics of the TCN are that: 1) the convolutions in the ar-", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 617, + 505, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 505, + 630 + ], + "score": 1.0, + "content": "chitecture are causal, meaning that there is no information “leakage” between future and past; 2) the", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 628, + 505, + 641 + ], + "spans": [ + { + "bbox": [ + 105, + 628, + 505, + 641 + ], + "score": 1.0, + "content": "architecture can take a sequence of any length and map it to an output sequence of the same length,", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 638, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 505, + 653 + ], + "score": 1.0, + "content": "just as with an RNN. Beyond this, we emphasize how to build very long effective history sizes (i.e.,", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 649, + 505, + 663 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 505, + 663 + ], + "score": 1.0, + "content": "the ability for the networks to look very far into the past to make a prediction) using a combination", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 661, + 433, + 673 + ], + "spans": [ + { + "bbox": [ + 106, + 661, + 433, + 673 + ], + "score": 1.0, + "content": "of very deep networks (augmented with residual layers) and dilated convolutions.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 44 + }, + { + "type": "title", + "bbox": [ + 108, + 687, + 275, + 699 + ], + "lines": [ + { + "bbox": [ + 105, + 686, + 277, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 686, + 277, + 701 + ], + "score": 1.0, + "content": "3.1 THE SEQUENCE MODELING TASK", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 49 + }, + { + "type": "text", + "bbox": [ + 107, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "Before defining the network structure, we highlight the nature of the sequence modeling task. We", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 720, + 505, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 292, + 734 + ], + "score": 1.0, + "content": "suppose that we are given a sequence of inputs", + "type": "text" + }, + { + "bbox": [ + 292, + 722, + 337, + 732 + ], + "score": 0.86, + "content": "x _ { 0 } , \\ldots , x _ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 338, + 720, + 505, + 734 + ], + "score": 1.0, + "content": ", and we wish to predict some correspond-", + "type": "text" + } + ], + "index": 51 + } + ], + "index": 50.5 + } + ], + "page_idx": 2, + "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, + 752, + 309, + 759 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 309, + 762 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 12, + "width": 8 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 82, + 504, + 126 + ], + "lines": [], + "index": 1.5, + "bbox_fs": [ + 104, + 83, + 506, + 127 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 132, + 505, + 297 + ], + "lines": [ + { + "bbox": [ + 105, + 132, + 505, + 145 + ], + "spans": [ + { + "bbox": [ + 105, + 132, + 505, + 145 + ], + "score": 1.0, + "content": "The history of convolutional architectures for time series is comparatively shorter, as they soon fell", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 143, + 505, + 156 + ], + "spans": [ + { + "bbox": [ + 105, + 143, + 505, + 156 + ], + "score": 1.0, + "content": "out of favor compared to recurrent architectures for these tasks, though are also seeing a resurgence", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 154, + 505, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 154, + 505, + 167 + ], + "score": 1.0, + "content": "in recent years. Waibel et al. (1989) and Bottou et al. (1990) studied the usage of time-delay net-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 165, + 505, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 165, + 505, + 178 + ], + "score": 1.0, + "content": "works (TDNNs) for sequences, one of the earliest local-connection-based networks in this domain.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 174, + 505, + 190 + ], + "spans": [ + { + "bbox": [ + 105, + 174, + 505, + 190 + ], + "score": 1.0, + "content": "LeCun et al. (1995) then proposed and examined the usage of CNNs on time-series data, pointing", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 187, + 505, + 199 + ], + "spans": [ + { + "bbox": [ + 105, + 187, + 505, + 199 + ], + "score": 1.0, + "content": "out that the same kind of feature extraction used in images could work well on sequence model-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 198, + 505, + 210 + ], + "spans": [ + { + "bbox": [ + 105, + 198, + 505, + 210 + ], + "score": 1.0, + "content": "ing with convolutional filters. Recent years have seen a re-emergence of convolutional models for", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 209, + 505, + 222 + ], + "spans": [ + { + "bbox": [ + 105, + 209, + 505, + 222 + ], + "score": 1.0, + "content": "sequence data. Perhaps most notably, the WaveNet (Oord et al., 2016a) applied a stacked convolu-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 220, + 505, + 232 + ], + "spans": [ + { + "bbox": [ + 105, + 220, + 505, + 232 + ], + "score": 1.0, + "content": "tional architecture to model audio signals, using a combination of dilations (Yu & Koltun, 2015),", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 231, + 505, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 231, + 505, + 244 + ], + "score": 1.0, + "content": "skip connections, gating, and conditioning on context stacks; the WaveNet mode was additionally", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 242, + 505, + 254 + ], + "spans": [ + { + "bbox": [ + 105, + 242, + 505, + 254 + ], + "score": 1.0, + "content": "applied to a few other contexts, such as financial applications (Borovykh et al., 2017). Non-dilated", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 252, + 505, + 266 + ], + "spans": [ + { + "bbox": [ + 105, + 252, + 505, + 266 + ], + "score": 1.0, + "content": "gated convolutions have also been applied in the context of language modeling (Dauphin et al.,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 263, + 505, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 263, + 505, + 277 + ], + "score": 1.0, + "content": "2017). And finally, convolutional models have seen a recent adoption in sequence to sequence mod-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 275, + 505, + 288 + ], + "spans": [ + { + "bbox": [ + 105, + 275, + 505, + 288 + ], + "score": 1.0, + "content": "eling and machine translations applications, such as the ByteNet (Kalchbrenner et al., 2016) and", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 285, + 290, + 298 + ], + "spans": [ + { + "bbox": [ + 105, + 285, + 290, + 298 + ], + "score": 1.0, + "content": "ConvS2S architectures (Gehring et al., 2017).", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 11, + "bbox_fs": [ + 105, + 132, + 505, + 298 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 303, + 504, + 357 + ], + "lines": [ + { + "bbox": [ + 106, + 303, + 505, + 315 + ], + "spans": [ + { + "bbox": [ + 106, + 303, + 505, + 315 + ], + "score": 1.0, + "content": "Despite these successes, the general consensus of the deep learning community seems to be that", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 312, + 505, + 326 + ], + "spans": [ + { + "bbox": [ + 105, + 312, + 505, + 326 + ], + "score": 1.0, + "content": "RNNs (here meaning all RNNs including LSTM and its variants) are better suited to sequence mod-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 324, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 324, + 506, + 338 + ], + "score": 1.0, + "content": "eling for two apparent reasons: 1) as discussed before, RNNs are theoretically capable of infinite", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 335, + 506, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 335, + 506, + 348 + ], + "score": 1.0, + "content": "memory; and 2) RNN models are inherently suitable for sequential inputs of varying length, whereas", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 345, + 439, + 359 + ], + "spans": [ + { + "bbox": [ + 105, + 345, + 439, + 359 + ], + "score": 1.0, + "content": "CNNs seem to be more appropriate in domains with fixed-size inputs (e.g., vision).", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 21, + "bbox_fs": [ + 105, + 303, + 506, + 359 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 363, + 505, + 528 + ], + "lines": [ + { + "bbox": [ + 105, + 362, + 506, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 506, + 376 + ], + "score": 1.0, + "content": "With this as the context, this paper reconsiders convolutional sequence modeling in general, first", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 373, + 505, + 388 + ], + "spans": [ + { + "bbox": [ + 105, + 373, + 505, + 388 + ], + "score": 1.0, + "content": "introducing a simple general-purpose convolutional sequence modeling architecture that can be ap-", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 385, + 505, + 397 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 505, + 397 + ], + "score": 1.0, + "content": "plied in all the same scenarios as an RNN (the architecture acts as a “drop-in” replacement for RNNs", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 397, + 505, + 408 + ], + "spans": [ + { + "bbox": [ + 106, + 397, + 505, + 408 + ], + "score": 1.0, + "content": "of any kind). We then extensively evaluate the performance of the architecture on tasks from dif-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 407, + 506, + 420 + ], + "spans": [ + { + "bbox": [ + 105, + 407, + 506, + 420 + ], + "score": 1.0, + "content": "ferent domains, focusing on domains and settings that have been used explicitly as applications and", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 418, + 506, + 431 + ], + "spans": [ + { + "bbox": [ + 105, + 418, + 506, + 431 + ], + "score": 1.0, + "content": "benchmarks for RNNs in the recent past. With regard to the specific architectures mentioned above", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 429, + 505, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 429, + 505, + 442 + ], + "score": 1.0, + "content": "(e.g. WaveNet, ByteNet, gated convolutional language models), the primary goal here is to describe", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 440, + 505, + 454 + ], + "spans": [ + { + "bbox": [ + 105, + 440, + 505, + 454 + ], + "score": 1.0, + "content": "a simple, application-independent architecture that avoids much of the extra specialized components", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 451, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 105, + 451, + 505, + 464 + ], + "score": 1.0, + "content": "of these architectures (gating, complex residuals, context stacks, or the encoder-decoder architec-", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 462, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 462, + 505, + 475 + ], + "score": 1.0, + "content": "tures of seq2seq models), and keeps only the “standard” convolutional components from most image", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 473, + 504, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 504, + 486 + ], + "score": 1.0, + "content": "architectures, with the restriction that the convolutions be causal. In several cases we specifically", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 104, + 483, + 505, + 498 + ], + "spans": [ + { + "bbox": [ + 104, + 483, + 505, + 498 + ], + "score": 1.0, + "content": "compare the architecture with and without additional components (e.g., gating elements), and high-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 495, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 505, + 507 + ], + "score": 1.0, + "content": "light that it does not seem to substantially improve performance of the architecture across domains.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 505, + 505, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 505, + 505, + 519 + ], + "score": 1.0, + "content": "Thus, the primary goal of this paper is to provide a baseline architecture for convolutional sequence", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 517, + 461, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 461, + 529 + ], + "score": 1.0, + "content": "prediction tasks, and to evaluate the performance of this model across multiple domains.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 31, + "bbox_fs": [ + 104, + 362, + 506, + 529 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 546, + 336, + 559 + ], + "lines": [ + { + "bbox": [ + 104, + 544, + 339, + 562 + ], + "spans": [ + { + "bbox": [ + 104, + 544, + 339, + 562 + ], + "score": 1.0, + "content": "3 CONVOLUTIONAL SEQUENCE MODELING", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 39 + }, + { + "type": "text", + "bbox": [ + 107, + 573, + 505, + 672 + ], + "lines": [ + { + "bbox": [ + 106, + 573, + 504, + 585 + ], + "spans": [ + { + "bbox": [ + 106, + 573, + 504, + 585 + ], + "score": 1.0, + "content": "In this section, we propose a generic architecture for convolutional sequence prediction, and gen-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 584, + 505, + 596 + ], + "spans": [ + { + "bbox": [ + 106, + 584, + 505, + 596 + ], + "score": 1.0, + "content": "erally refer to it as Temporal Convolution Networks (TCNs). We emphasize that we adopt this", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 595, + 506, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 506, + 608 + ], + "score": 1.0, + "content": "term not as a label for a truly new architecture, but as a simple descriptive term for this and similar", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 605, + 505, + 619 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 505, + 619 + ], + "score": 1.0, + "content": "architectures. The distinguishing characteristics of the TCN are that: 1) the convolutions in the ar-", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 617, + 505, + 630 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 505, + 630 + ], + "score": 1.0, + "content": "chitecture are causal, meaning that there is no information “leakage” between future and past; 2) the", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 628, + 505, + 641 + ], + "spans": [ + { + "bbox": [ + 105, + 628, + 505, + 641 + ], + "score": 1.0, + "content": "architecture can take a sequence of any length and map it to an output sequence of the same length,", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 638, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 105, + 638, + 505, + 653 + ], + "score": 1.0, + "content": "just as with an RNN. Beyond this, we emphasize how to build very long effective history sizes (i.e.,", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 649, + 505, + 663 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 505, + 663 + ], + "score": 1.0, + "content": "the ability for the networks to look very far into the past to make a prediction) using a combination", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 661, + 433, + 673 + ], + "spans": [ + { + "bbox": [ + 106, + 661, + 433, + 673 + ], + "score": 1.0, + "content": "of very deep networks (augmented with residual layers) and dilated convolutions.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 44, + "bbox_fs": [ + 105, + 573, + 506, + 673 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 687, + 275, + 699 + ], + "lines": [ + { + "bbox": [ + 105, + 686, + 277, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 686, + 277, + 701 + ], + "score": 1.0, + "content": "3.1 THE SEQUENCE MODELING TASK", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 49 + }, + { + "type": "text", + "bbox": [ + 107, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "Before defining the network structure, we highlight the nature of the sequence modeling task. We", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 720, + 505, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 292, + 734 + ], + "score": 1.0, + "content": "suppose that we are given a sequence of inputs", + "type": "text" + }, + { + "bbox": [ + 292, + 722, + 337, + 732 + ], + "score": 0.86, + "content": "x _ { 0 } , \\ldots , x _ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 338, + 720, + 505, + 734 + ], + "score": 1.0, + "content": ", and we wish to predict some correspond-", + "type": "text" + } + ], + "index": 51 + } + ], + "index": 50.5, + "bbox_fs": [ + 105, + 709, + 505, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 213, + 79, + 396, + 201 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 213, + 79, + 396, + 201 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 213, + 79, + 396, + 201 + ], + "spans": [ + { + "bbox": [ + 213, + 79, + 396, + 201 + ], + "score": 0.971, + "type": "image", + "image_path": "e4db16452e482b763cd61552fcde4b5c943fbde3fd808c44865ddb9b473e207d.jpg" + } + ] + } + ], + "index": 4, + "virtual_lines": [ + { + "bbox": [ + 213, + 79, + 396, + 92.55555555555556 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 213, + 92.55555555555556, + 396, + 106.11111111111111 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 213, + 106.11111111111111, + 396, + 119.66666666666667 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 213, + 119.66666666666667, + 396, + 133.22222222222223 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 213, + 133.22222222222223, + 396, + 146.77777777777777 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 213, + 146.77777777777777, + 396, + 160.33333333333331 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 213, + 160.33333333333331, + 396, + 173.88888888888886 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 213, + 173.88888888888886, + 396, + 187.4444444444444 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 213, + 187.4444444444444, + 396, + 200.99999999999994 + ], + "spans": [], + "index": 8 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 192, + 208, + 415, + 219 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 191, + 207, + 416, + 220 + ], + "spans": [ + { + "bbox": [ + 191, + 207, + 416, + 220 + ], + "score": 1.0, + "content": "Figure 1: A simple causal convolution with filter size 3.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 9 + } + ], + "index": 6.5 + }, + { + "type": "text", + "bbox": [ + 107, + 245, + 504, + 279 + ], + "lines": [ + { + "bbox": [ + 105, + 245, + 506, + 257 + ], + "spans": [ + { + "bbox": [ + 105, + 245, + 153, + 257 + ], + "score": 1.0, + "content": "ing outputs", + "type": "text" + }, + { + "bbox": [ + 154, + 247, + 197, + 256 + ], + "score": 0.92, + "content": "y _ { 0 } , \\ldots , y _ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 198, + 245, + 437, + 257 + ], + "score": 1.0, + "content": "at each time. The key constraint is that to predict the output", + "type": "text" + }, + { + "bbox": [ + 437, + 247, + 446, + 256 + ], + "score": 0.83, + "content": "y _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 446, + 245, + 506, + 257 + ], + "score": 1.0, + "content": "for some time", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 107, + 255, + 506, + 268 + ], + "spans": [ + { + "bbox": [ + 107, + 257, + 111, + 266 + ], + "score": 0.69, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 111, + 255, + 437, + 268 + ], + "score": 1.0, + "content": ", we are constrained to only use those inputs that have been previously observed:", + "type": "text" + }, + { + "bbox": [ + 438, + 257, + 480, + 267 + ], + "score": 0.91, + "content": "x _ { 0 } , \\ldots , x _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 481, + 255, + 506, + 268 + ], + "score": 1.0, + "content": ". For-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 104, + 263, + 507, + 282 + ], + "spans": [ + { + "bbox": [ + 104, + 263, + 315, + 282 + ], + "score": 1.0, + "content": "mally, a sequence modeling network is any function", + "type": "text" + }, + { + "bbox": [ + 315, + 266, + 394, + 278 + ], + "score": 0.92, + "content": "f : \\mathcal { X } ^ { T + \\bar { 1 } } \\mathcal { Y } ^ { T + \\bar { 1 } }", + "type": "inline_equation" + }, + { + "bbox": [ + 395, + 263, + 507, + 282 + ], + "score": 1.0, + "content": "that produces this mapping", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11 + }, + { + "type": "interline_equation", + "bbox": [ + 247, + 293, + 364, + 307 + ], + "lines": [ + { + "bbox": [ + 247, + 293, + 364, + 307 + ], + "spans": [ + { + "bbox": [ + 247, + 293, + 364, + 307 + ], + "score": 0.9, + "content": "\\hat { y } _ { 0 } , \\dots , \\hat { y } _ { T } = f ( x _ { 0 } , \\dots , x _ { T } )", + "type": "interline_equation", + "image_path": "3e15ca49e4386d69f8cfa21ce83287ba4a20ad4563252e97e510139c1ffba7ab.jpg" + } + ] + } + ], + "index": 13, + "virtual_lines": [ + { + "bbox": [ + 247, + 293, + 364, + 307 + ], + "spans": [], + "index": 13 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 315, + 504, + 359 + ], + "lines": [ + { + "bbox": [ + 105, + 314, + 506, + 328 + ], + "spans": [ + { + "bbox": [ + 105, + 314, + 257, + 328 + ], + "score": 1.0, + "content": "if it satisfies the causal constraint that", + "type": "text" + }, + { + "bbox": [ + 258, + 317, + 267, + 326 + ], + "score": 0.86, + "content": "y _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 268, + 314, + 336, + 328 + ], + "score": 1.0, + "content": "depends only on", + "type": "text" + }, + { + "bbox": [ + 336, + 317, + 379, + 326 + ], + "score": 0.9, + "content": "x _ { 0 } , \\ldots , x _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 314, + 506, + 328 + ], + "score": 1.0, + "content": ", and not on any “future” inputs", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 107, + 326, + 505, + 338 + ], + "spans": [ + { + "bbox": [ + 107, + 327, + 161, + 338 + ], + "score": 0.89, + "content": "x _ { t + 1 } , \\dots , x _ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 161, + 326, + 472, + 338 + ], + "score": 1.0, + "content": ". The goal of learning in the sequence modeling setting is to find the network", + "type": "text" + }, + { + "bbox": [ + 473, + 326, + 479, + 337 + ], + "score": 0.83, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 480, + 326, + 505, + 338 + ], + "score": 1.0, + "content": "mini-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 337, + 503, + 350 + ], + "spans": [ + { + "bbox": [ + 105, + 337, + 383, + 350 + ], + "score": 1.0, + "content": "mizing some expected loss between the actual outputs and predictions", + "type": "text" + }, + { + "bbox": [ + 383, + 337, + 503, + 349 + ], + "score": 0.89, + "content": "L ( y _ { 0 } , \\dots , y _ { T } , f ( x _ { 0 } , \\dots , x _ { T } ) )", + "type": "inline_equation" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 348, + 408, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 408, + 361 + ], + "score": 1.0, + "content": "where the sequences and outputs are drawn according to some distribution.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15.5 + }, + { + "type": "text", + "bbox": [ + 107, + 365, + 505, + 431 + ], + "lines": [ + { + "bbox": [ + 106, + 364, + 506, + 377 + ], + "spans": [ + { + "bbox": [ + 106, + 364, + 506, + 377 + ], + "score": 1.0, + "content": "This formalism encompasses many settings such as auto-regressive prediction (where we try to", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 376, + 505, + 389 + ], + "spans": [ + { + "bbox": [ + 105, + 376, + 505, + 389 + ], + "score": 1.0, + "content": "predict some signal given its past) by setting the target output to be simply the input shifted by one", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 387, + 504, + 399 + ], + "spans": [ + { + "bbox": [ + 106, + 387, + 504, + 399 + ], + "score": 1.0, + "content": "time step. It does not, however, directly capture domains such as machine translation, or sequence-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 397, + 505, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 397, + 505, + 410 + ], + "score": 1.0, + "content": "to-sequence prediction in general, since in these cases the entire input sequence (including “future”", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 408, + 506, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 506, + 421 + ], + "score": 1.0, + "content": "states) can be used to predict each output (though the techniques can naturally be extended to work", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 419, + 177, + 433 + ], + "spans": [ + { + "bbox": [ + 105, + 419, + 177, + 433 + ], + "score": 1.0, + "content": "in such settings).", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 20.5 + }, + { + "type": "title", + "bbox": [ + 108, + 448, + 303, + 460 + ], + "lines": [ + { + "bbox": [ + 105, + 448, + 305, + 461 + ], + "spans": [ + { + "bbox": [ + 105, + 448, + 305, + 461 + ], + "score": 1.0, + "content": "3.2 CAUSAL CONVOLUTIONS AND THE TCN", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 107, + 470, + 505, + 560 + ], + "lines": [ + { + "bbox": [ + 105, + 470, + 505, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 470, + 505, + 484 + ], + "score": 1.0, + "content": "As mentioned above, the TCN is based upon two principles: the fact that the network produces an", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 482, + 505, + 495 + ], + "spans": [ + { + "bbox": [ + 106, + 482, + 505, + 495 + ], + "score": 1.0, + "content": "output of the same length as the input, and the fact that there can be no leakage from the future", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 493, + 505, + 505 + ], + "spans": [ + { + "bbox": [ + 106, + 493, + 505, + 505 + ], + "score": 1.0, + "content": "into the past. To accomplish the first point, the TCN uses a 1D fully-convolutional network (FCN)", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 504, + 505, + 516 + ], + "spans": [ + { + "bbox": [ + 106, + 504, + 505, + 516 + ], + "score": 1.0, + "content": "architecture (Long et al., 2015), where each hidden layer is the same length as the input layer, and", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 515, + 505, + 528 + ], + "spans": [ + { + "bbox": [ + 106, + 515, + 505, + 528 + ], + "score": 1.0, + "content": "zero padding of length (kernel size − 1) is added to keep subsequent layers the same length as", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 526, + 505, + 539 + ], + "spans": [ + { + "bbox": [ + 105, + 526, + 505, + 539 + ], + "score": 1.0, + "content": "previous ones. To achieve the second point, the TCN uses causal convolutions, convolutions where", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 537, + 505, + 549 + ], + "spans": [ + { + "bbox": [ + 105, + 537, + 217, + 549 + ], + "score": 1.0, + "content": "a subsequent output at time", + "type": "text" + }, + { + "bbox": [ + 217, + 538, + 222, + 547 + ], + "score": 0.74, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 222, + 537, + 393, + 549 + ], + "score": 1.0, + "content": "is convolved only with elements from time", + "type": "text" + }, + { + "bbox": [ + 394, + 538, + 399, + 547 + ], + "score": 0.67, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 537, + 505, + 549 + ], + "score": 1.0, + "content": "and before in the previous", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 547, + 420, + 561 + ], + "spans": [ + { + "bbox": [ + 106, + 547, + 420, + 561 + ], + "score": 1.0, + "content": "layer.1 Graphically, the network is shown in Figure 1. Put in a simple manner:", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 28.5 + }, + { + "type": "interline_equation", + "bbox": [ + 224, + 569, + 385, + 581 + ], + "lines": [ + { + "bbox": [ + 224, + 569, + 385, + 581 + ], + "spans": [ + { + "bbox": [ + 224, + 569, + 385, + 581 + ], + "score": 0.75, + "content": "\\mathrm { T C N } = \\mathrm { 1 D F C N } + \\mathrm { c a u s a l ~ c o n v o l u t i o n s }", + "type": "interline_equation", + "image_path": "1d219a6b1d90dd2d8f2e79ec117e30d64ebd37a2e72228016bd60cb01f729fcb.jpg" + } + ] + } + ], + "index": 33, + "virtual_lines": [ + { + "bbox": [ + 224, + 569, + 385, + 581 + ], + "spans": [], + "index": 33 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 591, + 504, + 624 + ], + "lines": [ + { + "bbox": [ + 105, + 591, + 505, + 603 + ], + "spans": [ + { + "bbox": [ + 105, + 591, + 505, + 603 + ], + "score": 1.0, + "content": "It is worth emphasizing that this is essentially the same architecture as the time delay neural network", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 602, + 506, + 615 + ], + "spans": [ + { + "bbox": [ + 105, + 602, + 506, + 615 + ], + "score": 1.0, + "content": "proposed nearly 30 years ago by Waibel et al. (1989), with the sole tweak of zero padding to ensure", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 613, + 205, + 626 + ], + "spans": [ + { + "bbox": [ + 106, + 613, + 205, + 626 + ], + "score": 1.0, + "content": "equal sizes of all layers.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 107, + 630, + 505, + 685 + ], + "lines": [ + { + "bbox": [ + 105, + 630, + 505, + 643 + ], + "spans": [ + { + "bbox": [ + 105, + 630, + 505, + 643 + ], + "score": 1.0, + "content": "However, a major disadvantage of this “na¨ıve” approach is that in order to achieve a long effective", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 641, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 641, + 505, + 654 + ], + "score": 1.0, + "content": "history size, we need an extremely deep network or very large filters, neither of which were particu-", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 652, + 505, + 664 + ], + "spans": [ + { + "bbox": [ + 105, + 652, + 505, + 664 + ], + "score": 1.0, + "content": "larly feasible when the methods were first introduced. Thus, in the following sections, we describe", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 663, + 505, + 676 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 505, + 676 + ], + "score": 1.0, + "content": "how techniques from modern convolutional architectures can be integrated into the TCN to allow", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 104, + 673, + 347, + 689 + ], + "spans": [ + { + "bbox": [ + 104, + 673, + 347, + 689 + ], + "score": 1.0, + "content": "for both very deep networks and very long effective history.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 39 + } + ], + "page_idx": 3, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 701, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 118, + 699, + 506, + 714 + ], + "spans": [ + { + "bbox": [ + 118, + 699, + 506, + 714 + ], + "score": 1.0, + "content": "1Although many current deep learning libraries do not offer native support for these causal convolutions,", + "type": "text" + } + ] + }, + { + "bbox": [ + 105, + 711, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 711, + 505, + 722 + ], + "score": 1.0, + "content": "we note that they can be implemented (with some inefficiency) by simply using a standard convolution with", + "type": "text" + } + ] + }, + { + "bbox": [ + 106, + 721, + 360, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 360, + 733 + ], + "score": 1.0, + "content": "zero padding on both sides, and chopping off the end of the sequence.", + "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" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 759 + ], + "lines": [] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 213, + 79, + 396, + 201 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 213, + 79, + 396, + 201 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 213, + 79, + 396, + 201 + ], + "spans": [ + { + "bbox": [ + 213, + 79, + 396, + 201 + ], + "score": 0.971, + "type": "image", + "image_path": "e4db16452e482b763cd61552fcde4b5c943fbde3fd808c44865ddb9b473e207d.jpg" + } + ] + } + ], + "index": 4, + "virtual_lines": [ + { + "bbox": [ + 213, + 79, + 396, + 92.55555555555556 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 213, + 92.55555555555556, + 396, + 106.11111111111111 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 213, + 106.11111111111111, + 396, + 119.66666666666667 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 213, + 119.66666666666667, + 396, + 133.22222222222223 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 213, + 133.22222222222223, + 396, + 146.77777777777777 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 213, + 146.77777777777777, + 396, + 160.33333333333331 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 213, + 160.33333333333331, + 396, + 173.88888888888886 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 213, + 173.88888888888886, + 396, + 187.4444444444444 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 213, + 187.4444444444444, + 396, + 200.99999999999994 + ], + "spans": [], + "index": 8 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 192, + 208, + 415, + 219 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 191, + 207, + 416, + 220 + ], + "spans": [ + { + "bbox": [ + 191, + 207, + 416, + 220 + ], + "score": 1.0, + "content": "Figure 1: A simple causal convolution with filter size 3.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 9 + } + ], + "index": 6.5 + }, + { + "type": "text", + "bbox": [ + 107, + 245, + 504, + 279 + ], + "lines": [ + { + "bbox": [ + 105, + 245, + 506, + 257 + ], + "spans": [ + { + "bbox": [ + 105, + 245, + 153, + 257 + ], + "score": 1.0, + "content": "ing outputs", + "type": "text" + }, + { + "bbox": [ + 154, + 247, + 197, + 256 + ], + "score": 0.92, + "content": "y _ { 0 } , \\ldots , y _ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 198, + 245, + 437, + 257 + ], + "score": 1.0, + "content": "at each time. The key constraint is that to predict the output", + "type": "text" + }, + { + "bbox": [ + 437, + 247, + 446, + 256 + ], + "score": 0.83, + "content": "y _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 446, + 245, + 506, + 257 + ], + "score": 1.0, + "content": "for some time", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 107, + 255, + 506, + 268 + ], + "spans": [ + { + "bbox": [ + 107, + 257, + 111, + 266 + ], + "score": 0.69, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 111, + 255, + 437, + 268 + ], + "score": 1.0, + "content": ", we are constrained to only use those inputs that have been previously observed:", + "type": "text" + }, + { + "bbox": [ + 438, + 257, + 480, + 267 + ], + "score": 0.91, + "content": "x _ { 0 } , \\ldots , x _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 481, + 255, + 506, + 268 + ], + "score": 1.0, + "content": ". For-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 104, + 263, + 507, + 282 + ], + "spans": [ + { + "bbox": [ + 104, + 263, + 315, + 282 + ], + "score": 1.0, + "content": "mally, a sequence modeling network is any function", + "type": "text" + }, + { + "bbox": [ + 315, + 266, + 394, + 278 + ], + "score": 0.92, + "content": "f : \\mathcal { X } ^ { T + \\bar { 1 } } \\mathcal { Y } ^ { T + \\bar { 1 } }", + "type": "inline_equation" + }, + { + "bbox": [ + 395, + 263, + 507, + 282 + ], + "score": 1.0, + "content": "that produces this mapping", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11, + "bbox_fs": [ + 104, + 245, + 507, + 282 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 247, + 293, + 364, + 307 + ], + "lines": [ + { + "bbox": [ + 247, + 293, + 364, + 307 + ], + "spans": [ + { + "bbox": [ + 247, + 293, + 364, + 307 + ], + "score": 0.9, + "content": "\\hat { y } _ { 0 } , \\dots , \\hat { y } _ { T } = f ( x _ { 0 } , \\dots , x _ { T } )", + "type": "interline_equation", + "image_path": "3e15ca49e4386d69f8cfa21ce83287ba4a20ad4563252e97e510139c1ffba7ab.jpg" + } + ] + } + ], + "index": 13, + "virtual_lines": [ + { + "bbox": [ + 247, + 293, + 364, + 307 + ], + "spans": [], + "index": 13 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 315, + 504, + 359 + ], + "lines": [ + { + "bbox": [ + 105, + 314, + 506, + 328 + ], + "spans": [ + { + "bbox": [ + 105, + 314, + 257, + 328 + ], + "score": 1.0, + "content": "if it satisfies the causal constraint that", + "type": "text" + }, + { + "bbox": [ + 258, + 317, + 267, + 326 + ], + "score": 0.86, + "content": "y _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 268, + 314, + 336, + 328 + ], + "score": 1.0, + "content": "depends only on", + "type": "text" + }, + { + "bbox": [ + 336, + 317, + 379, + 326 + ], + "score": 0.9, + "content": "x _ { 0 } , \\ldots , x _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 314, + 506, + 328 + ], + "score": 1.0, + "content": ", and not on any “future” inputs", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 107, + 326, + 505, + 338 + ], + "spans": [ + { + "bbox": [ + 107, + 327, + 161, + 338 + ], + "score": 0.89, + "content": "x _ { t + 1 } , \\dots , x _ { T }", + "type": "inline_equation" + }, + { + "bbox": [ + 161, + 326, + 472, + 338 + ], + "score": 1.0, + "content": ". The goal of learning in the sequence modeling setting is to find the network", + "type": "text" + }, + { + "bbox": [ + 473, + 326, + 479, + 337 + ], + "score": 0.83, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 480, + 326, + 505, + 338 + ], + "score": 1.0, + "content": "mini-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 337, + 503, + 350 + ], + "spans": [ + { + "bbox": [ + 105, + 337, + 383, + 350 + ], + "score": 1.0, + "content": "mizing some expected loss between the actual outputs and predictions", + "type": "text" + }, + { + "bbox": [ + 383, + 337, + 503, + 349 + ], + "score": 0.89, + "content": "L ( y _ { 0 } , \\dots , y _ { T } , f ( x _ { 0 } , \\dots , x _ { T } ) )", + "type": "inline_equation" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 348, + 408, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 408, + 361 + ], + "score": 1.0, + "content": "where the sequences and outputs are drawn according to some distribution.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15.5, + "bbox_fs": [ + 105, + 314, + 506, + 361 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 365, + 505, + 431 + ], + "lines": [ + { + "bbox": [ + 106, + 364, + 506, + 377 + ], + "spans": [ + { + "bbox": [ + 106, + 364, + 506, + 377 + ], + "score": 1.0, + "content": "This formalism encompasses many settings such as auto-regressive prediction (where we try to", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 376, + 505, + 389 + ], + "spans": [ + { + "bbox": [ + 105, + 376, + 505, + 389 + ], + "score": 1.0, + "content": "predict some signal given its past) by setting the target output to be simply the input shifted by one", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 387, + 504, + 399 + ], + "spans": [ + { + "bbox": [ + 106, + 387, + 504, + 399 + ], + "score": 1.0, + "content": "time step. It does not, however, directly capture domains such as machine translation, or sequence-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 397, + 505, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 397, + 505, + 410 + ], + "score": 1.0, + "content": "to-sequence prediction in general, since in these cases the entire input sequence (including “future”", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 408, + 506, + 421 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 506, + 421 + ], + "score": 1.0, + "content": "states) can be used to predict each output (though the techniques can naturally be extended to work", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 419, + 177, + 433 + ], + "spans": [ + { + "bbox": [ + 105, + 419, + 177, + 433 + ], + "score": 1.0, + "content": "in such settings).", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 20.5, + "bbox_fs": [ + 105, + 364, + 506, + 433 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 448, + 303, + 460 + ], + "lines": [ + { + "bbox": [ + 105, + 448, + 305, + 461 + ], + "spans": [ + { + "bbox": [ + 105, + 448, + 305, + 461 + ], + "score": 1.0, + "content": "3.2 CAUSAL CONVOLUTIONS AND THE TCN", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 107, + 470, + 505, + 560 + ], + "lines": [ + { + "bbox": [ + 105, + 470, + 505, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 470, + 505, + 484 + ], + "score": 1.0, + "content": "As mentioned above, the TCN is based upon two principles: the fact that the network produces an", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 482, + 505, + 495 + ], + "spans": [ + { + "bbox": [ + 106, + 482, + 505, + 495 + ], + "score": 1.0, + "content": "output of the same length as the input, and the fact that there can be no leakage from the future", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 493, + 505, + 505 + ], + "spans": [ + { + "bbox": [ + 106, + 493, + 505, + 505 + ], + "score": 1.0, + "content": "into the past. To accomplish the first point, the TCN uses a 1D fully-convolutional network (FCN)", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 504, + 505, + 516 + ], + "spans": [ + { + "bbox": [ + 106, + 504, + 505, + 516 + ], + "score": 1.0, + "content": "architecture (Long et al., 2015), where each hidden layer is the same length as the input layer, and", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 515, + 505, + 528 + ], + "spans": [ + { + "bbox": [ + 106, + 515, + 505, + 528 + ], + "score": 1.0, + "content": "zero padding of length (kernel size − 1) is added to keep subsequent layers the same length as", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 526, + 505, + 539 + ], + "spans": [ + { + "bbox": [ + 105, + 526, + 505, + 539 + ], + "score": 1.0, + "content": "previous ones. To achieve the second point, the TCN uses causal convolutions, convolutions where", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 537, + 505, + 549 + ], + "spans": [ + { + "bbox": [ + 105, + 537, + 217, + 549 + ], + "score": 1.0, + "content": "a subsequent output at time", + "type": "text" + }, + { + "bbox": [ + 217, + 538, + 222, + 547 + ], + "score": 0.74, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 222, + 537, + 393, + 549 + ], + "score": 1.0, + "content": "is convolved only with elements from time", + "type": "text" + }, + { + "bbox": [ + 394, + 538, + 399, + 547 + ], + "score": 0.67, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 537, + 505, + 549 + ], + "score": 1.0, + "content": "and before in the previous", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 547, + 420, + 561 + ], + "spans": [ + { + "bbox": [ + 106, + 547, + 420, + 561 + ], + "score": 1.0, + "content": "layer.1 Graphically, the network is shown in Figure 1. Put in a simple manner:", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 28.5, + "bbox_fs": [ + 105, + 470, + 505, + 561 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 224, + 569, + 385, + 581 + ], + "lines": [ + { + "bbox": [ + 224, + 569, + 385, + 581 + ], + "spans": [ + { + "bbox": [ + 224, + 569, + 385, + 581 + ], + "score": 0.75, + "content": "\\mathrm { T C N } = \\mathrm { 1 D F C N } + \\mathrm { c a u s a l ~ c o n v o l u t i o n s }", + "type": "interline_equation", + "image_path": "1d219a6b1d90dd2d8f2e79ec117e30d64ebd37a2e72228016bd60cb01f729fcb.jpg" + } + ] + } + ], + "index": 33, + "virtual_lines": [ + { + "bbox": [ + 224, + 569, + 385, + 581 + ], + "spans": [], + "index": 33 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 591, + 504, + 624 + ], + "lines": [ + { + "bbox": [ + 105, + 591, + 505, + 603 + ], + "spans": [ + { + "bbox": [ + 105, + 591, + 505, + 603 + ], + "score": 1.0, + "content": "It is worth emphasizing that this is essentially the same architecture as the time delay neural network", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 602, + 506, + 615 + ], + "spans": [ + { + "bbox": [ + 105, + 602, + 506, + 615 + ], + "score": 1.0, + "content": "proposed nearly 30 years ago by Waibel et al. (1989), with the sole tweak of zero padding to ensure", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 613, + 205, + 626 + ], + "spans": [ + { + "bbox": [ + 106, + 613, + 205, + 626 + ], + "score": 1.0, + "content": "equal sizes of all layers.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35, + "bbox_fs": [ + 105, + 591, + 506, + 626 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 630, + 505, + 685 + ], + "lines": [ + { + "bbox": [ + 105, + 630, + 505, + 643 + ], + "spans": [ + { + "bbox": [ + 105, + 630, + 505, + 643 + ], + "score": 1.0, + "content": "However, a major disadvantage of this “na¨ıve” approach is that in order to achieve a long effective", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 641, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 641, + 505, + 654 + ], + "score": 1.0, + "content": "history size, we need an extremely deep network or very large filters, neither of which were particu-", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 652, + 505, + 664 + ], + "spans": [ + { + "bbox": [ + 105, + 652, + 505, + 664 + ], + "score": 1.0, + "content": "larly feasible when the methods were first introduced. Thus, in the following sections, we describe", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 663, + 505, + 676 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 505, + 676 + ], + "score": 1.0, + "content": "how techniques from modern convolutional architectures can be integrated into the TCN to allow", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 104, + 673, + 347, + 689 + ], + "spans": [ + { + "bbox": [ + 104, + 673, + 347, + 689 + ], + "score": 1.0, + "content": "for both very deep networks and very long effective history.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 39, + "bbox_fs": [ + 104, + 630, + 505, + 689 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 146, + 78, + 463, + 206 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 146, + 78, + 463, + 206 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 146, + 78, + 463, + 206 + ], + "spans": [ + { + "bbox": [ + 146, + 78, + 463, + 206 + ], + "score": 0.969, + "type": "image", + "image_path": "3d3384271f9fbd194ae3ecf347bb7e1e6b27e790b9063a1b747424be7bcaf5f9.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 146, + 78, + 463, + 120.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 146, + 120.66666666666666, + 463, + 163.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 146, + 163.33333333333331, + 463, + 205.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 105, + 213, + 505, + 236 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 213, + 505, + 226 + ], + "spans": [ + { + "bbox": [ + 106, + 213, + 349, + 226 + ], + "score": 1.0, + "content": "Figure 2: A dilated causal convolution with dilation factors", + "type": "text" + }, + { + "bbox": [ + 349, + 213, + 395, + 225 + ], + "score": 0.92, + "content": "d = 1 , 2 , 4", + "type": "inline_equation" + }, + { + "bbox": [ + 396, + 213, + 454, + 226 + ], + "score": 1.0, + "content": "and filter size", + "type": "text" + }, + { + "bbox": [ + 454, + 213, + 481, + 223 + ], + "score": 0.89, + "content": "k = 3", + "type": "inline_equation" + }, + { + "bbox": [ + 482, + 213, + 505, + 226 + ], + "score": 1.0, + "content": ". The", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 223, + 369, + 238 + ], + "spans": [ + { + "bbox": [ + 105, + 223, + 369, + 238 + ], + "score": 1.0, + "content": "receptive field is able to cover all values from the input sequence.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "index": 2.25 + }, + { + "type": "title", + "bbox": [ + 108, + 255, + 242, + 267 + ], + "lines": [ + { + "bbox": [ + 105, + 254, + 244, + 269 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 244, + 269 + ], + "score": 1.0, + "content": "3.3 DILATED CONVOLUTIONS", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 106, + 276, + 505, + 354 + ], + "lines": [ + { + "bbox": [ + 106, + 276, + 505, + 289 + ], + "spans": [ + { + "bbox": [ + 106, + 276, + 505, + 289 + ], + "score": 1.0, + "content": "Through convolutional filters, as previously addressed, a simple causal convolution is only able to", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 287, + 505, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 287, + 505, + 300 + ], + "score": 1.0, + "content": "look back at a history with size linear in the depth of the network. This makes it challenging to", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 298, + 506, + 312 + ], + "spans": [ + { + "bbox": [ + 105, + 298, + 506, + 312 + ], + "score": 1.0, + "content": "apply the aforementioned causal convolution on sequence tasks, especially those requiring longer", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 309, + 505, + 322 + ], + "spans": [ + { + "bbox": [ + 105, + 309, + 505, + 322 + ], + "score": 1.0, + "content": "history. Our solution here, used previously for example in audio synthesis by Oord et al. (2016a),", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 104, + 320, + 505, + 333 + ], + "spans": [ + { + "bbox": [ + 104, + 320, + 505, + 333 + ], + "score": 1.0, + "content": "is to employ dilated convolutions (Yu & Koltun, 2015) that enable an exponentially large receptive", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 330, + 506, + 344 + ], + "spans": [ + { + "bbox": [ + 105, + 330, + 299, + 344 + ], + "score": 1.0, + "content": "field. More formally, for a 1-D sequence input", + "type": "text" + }, + { + "bbox": [ + 300, + 332, + 334, + 342 + ], + "score": 0.91, + "content": "\\mathbf { x } \\in \\mathbb { R } ^ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 334, + 330, + 383, + 344 + ], + "score": 1.0, + "content": "and a filter", + "type": "text" + }, + { + "bbox": [ + 383, + 331, + 486, + 343 + ], + "score": 0.93, + "content": "f : \\bar { \\{ 0 , \\dots , k - 1 \\bar { \\} } } \\mathbb { R }", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 330, + 506, + 344 + ], + "score": 1.0, + "content": ", the", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 341, + 407, + 356 + ], + "spans": [ + { + "bbox": [ + 105, + 341, + 226, + 356 + ], + "score": 1.0, + "content": "dilated convolution operation", + "type": "text" + }, + { + "bbox": [ + 226, + 343, + 235, + 352 + ], + "score": 0.84, + "content": "F", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 341, + 282, + 356 + ], + "score": 1.0, + "content": "on element", + "type": "text" + }, + { + "bbox": [ + 283, + 345, + 288, + 352 + ], + "score": 0.75, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 341, + 407, + 356 + ], + "score": 1.0, + "content": "of the sequence is defined as", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 9 + }, + { + "type": "interline_equation", + "bbox": [ + 224, + 357, + 386, + 392 + ], + "lines": [ + { + "bbox": [ + 224, + 357, + 386, + 392 + ], + "spans": [ + { + "bbox": [ + 224, + 357, + 386, + 392 + ], + "score": 0.94, + "content": "F ( s ) = ( \\mathbf { x } * _ { d } f ) ( s ) = \\sum _ { i = 0 } ^ { k - 1 } f ( i ) \\cdot \\mathbf { x } _ { s + d \\cdot i }", + "type": "interline_equation", + "image_path": "c2f18d1bcf810be91cf4f6415c0e25ca6867b5ddba3cb28385e6dd7d5bc0ee2e.jpg" + } + ] + } + ], + "index": 13.5, + "virtual_lines": [ + { + "bbox": [ + 224, + 357, + 386, + 374.5 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 224, + 374.5, + 386, + 392.0 + ], + "spans": [], + "index": 14 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 394, + 505, + 439 + ], + "lines": [ + { + "bbox": [ + 106, + 395, + 505, + 407 + ], + "spans": [ + { + "bbox": [ + 106, + 395, + 133, + 407 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 396, + 140, + 405 + ], + "score": 0.81, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 140, + 395, + 239, + 407 + ], + "score": 1.0, + "content": "is the dilation factor and", + "type": "text" + }, + { + "bbox": [ + 239, + 396, + 245, + 405 + ], + "score": 0.83, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 246, + 395, + 505, + 407 + ], + "score": 1.0, + "content": "is the filter size. Dilation is thus equivalent to introducing a fixed", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 406, + 505, + 417 + ], + "spans": [ + { + "bbox": [ + 105, + 406, + 336, + 417 + ], + "score": 1.0, + "content": "step between every two adjacent filter taps. When taking", + "type": "text" + }, + { + "bbox": [ + 336, + 406, + 361, + 416 + ], + "score": 0.9, + "content": "d = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 362, + 406, + 505, + 417 + ], + "score": 1.0, + "content": ", for example, a dilated convolution", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 417, + 505, + 429 + ], + "spans": [ + { + "bbox": [ + 105, + 417, + 505, + 429 + ], + "score": 1.0, + "content": "is trivially a normal convolution operation. Using larger dilations enables an output at the top level", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 428, + 491, + 440 + ], + "spans": [ + { + "bbox": [ + 105, + 428, + 491, + 440 + ], + "score": 1.0, + "content": "to represent a wider range of inputs, thus effectively expanding the receptive field of a ConvNet.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 16.5 + }, + { + "type": "text", + "bbox": [ + 106, + 444, + 505, + 522 + ], + "lines": [ + { + "bbox": [ + 106, + 444, + 505, + 457 + ], + "spans": [ + { + "bbox": [ + 106, + 444, + 494, + 457 + ], + "score": 1.0, + "content": "This gives us two ways to increase the receptive field of the TCN: by choosing larger filter sizes", + "type": "text" + }, + { + "bbox": [ + 495, + 445, + 501, + 455 + ], + "score": 0.76, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 444, + 505, + 457 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 456, + 504, + 468 + ], + "spans": [ + { + "bbox": [ + 106, + 456, + 257, + 468 + ], + "score": 1.0, + "content": "and by increasing the dilation factor", + "type": "text" + }, + { + "bbox": [ + 257, + 456, + 263, + 466 + ], + "score": 0.78, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 264, + 456, + 464, + 468 + ], + "score": 1.0, + "content": ", where the effective history of one such layer is", + "type": "text" + }, + { + "bbox": [ + 464, + 456, + 501, + 468 + ], + "score": 0.92, + "content": "( k - 1 ) d", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 456, + 504, + 468 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 466, + 505, + 479 + ], + "spans": [ + { + "bbox": [ + 106, + 466, + 353, + 479 + ], + "score": 1.0, + "content": "As is common when using dilated convolutions, we increase", + "type": "text" + }, + { + "bbox": [ + 353, + 467, + 360, + 477 + ], + "score": 0.77, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 361, + 466, + 505, + 479 + ], + "score": 1.0, + "content": "exponentially with the depth of the", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 104, + 477, + 506, + 490 + ], + "spans": [ + { + "bbox": [ + 104, + 477, + 163, + 490 + ], + "score": 1.0, + "content": "network (i.e.,", + "type": "text" + }, + { + "bbox": [ + 164, + 477, + 209, + 489 + ], + "score": 0.93, + "content": "d = O ( 2 ^ { i } )", + "type": "inline_equation" + }, + { + "bbox": [ + 209, + 477, + 243, + 490 + ], + "score": 1.0, + "content": "at level", + "type": "text" + }, + { + "bbox": [ + 243, + 478, + 248, + 487 + ], + "score": 0.69, + "content": "i", + "type": "inline_equation" + }, + { + "bbox": [ + 249, + 477, + 506, + 490 + ], + "score": 1.0, + "content": "of the network). This ensures that there is some filter that hits", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 488, + 505, + 501 + ], + "spans": [ + { + "bbox": [ + 105, + 488, + 505, + 501 + ], + "score": 1.0, + "content": "each input within the effective history, while also allowing for an extremely large effective history", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 500, + 505, + 512 + ], + "spans": [ + { + "bbox": [ + 106, + 500, + 425, + 512 + ], + "score": 1.0, + "content": "using deep networks. We provide an illustration in Figure 2. Using filter size", + "type": "text" + }, + { + "bbox": [ + 425, + 500, + 453, + 510 + ], + "score": 0.92, + "content": "k = 3", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 500, + 505, + 512 + ], + "score": 1.0, + "content": "and dilation", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 510, + 457, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 132, + 524 + ], + "score": 1.0, + "content": "factor", + "type": "text" + }, + { + "bbox": [ + 133, + 511, + 176, + 522 + ], + "score": 0.91, + "content": "d = 1 , 2 , 4", + "type": "inline_equation" + }, + { + "bbox": [ + 176, + 510, + 457, + 524 + ], + "score": 1.0, + "content": ", the receptive field is able to cover all values from the input sequence.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22 + }, + { + "type": "title", + "bbox": [ + 107, + 534, + 242, + 546 + ], + "lines": [ + { + "bbox": [ + 105, + 533, + 243, + 548 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 243, + 548 + ], + "score": 1.0, + "content": "3.4 RESIDUAL CONNECTIONS", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 106, + 555, + 505, + 589 + ], + "lines": [ + { + "bbox": [ + 105, + 554, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 505, + 568 + ], + "score": 1.0, + "content": "Proposed by He et al. (2016), residual functions have proven to be especially useful in effectively", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 567, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 106, + 567, + 505, + 579 + ], + "score": 1.0, + "content": "training deep networks. In a residual network, each residual block contains a branch leading out to", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 578, + 438, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 578, + 214, + 590 + ], + "score": 1.0, + "content": "a series of transformations", + "type": "text" + }, + { + "bbox": [ + 215, + 578, + 224, + 587 + ], + "score": 0.84, + "content": "\\mathcal { F }", + "type": "inline_equation" + }, + { + "bbox": [ + 224, + 578, + 376, + 590 + ], + "score": 1.0, + "content": ", whose outputs are added to the input", + "type": "text" + }, + { + "bbox": [ + 376, + 579, + 384, + 587 + ], + "score": 0.68, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 384, + 578, + 438, + 590 + ], + "score": 1.0, + "content": "of the block:", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28 + }, + { + "type": "interline_equation", + "bbox": [ + 250, + 592, + 360, + 606 + ], + "lines": [ + { + "bbox": [ + 250, + 592, + 360, + 606 + ], + "spans": [ + { + "bbox": [ + 250, + 592, + 360, + 606 + ], + "score": 0.93, + "content": "o = \\mathrm { A c t i v a t i o n } ( \\mathbf { x } + \\mathcal { F } ( \\mathbf { x } ) )", + "type": "interline_equation", + "image_path": "a14b11eeb99c1c7768b94eec8e763486c2f41521fee1459687c6c0433c4fd694.jpg" + } + ] + } + ], + "index": 30, + "virtual_lines": [ + { + "bbox": [ + 250, + 592, + 360, + 606 + ], + "spans": [], + "index": 30 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 609, + 504, + 633 + ], + "lines": [ + { + "bbox": [ + 106, + 609, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 106, + 609, + 505, + 622 + ], + "score": 1.0, + "content": "This effectively allows for the layers to learn modifications to the identity mapping rather than the", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 622, + 453, + 633 + ], + "spans": [ + { + "bbox": [ + 106, + 622, + 453, + 633 + ], + "score": 1.0, + "content": "entire transformation, which has been repeatedly shown to benefit very deep networks.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 31.5 + }, + { + "type": "text", + "bbox": [ + 106, + 637, + 505, + 704 + ], + "lines": [ + { + "bbox": [ + 106, + 638, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 638, + 352, + 650 + ], + "score": 1.0, + "content": "As the TCN’s receptive field depends on the network depth", + "type": "text" + }, + { + "bbox": [ + 352, + 640, + 360, + 648 + ], + "score": 0.75, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 360, + 638, + 445, + 650 + ], + "score": 1.0, + "content": "as well as filter size", + "type": "text" + }, + { + "bbox": [ + 446, + 639, + 453, + 648 + ], + "score": 0.8, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 638, + 505, + 650 + ], + "score": 1.0, + "content": "and dilation", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 649, + 505, + 660 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 132, + 660 + ], + "score": 1.0, + "content": "factor", + "type": "text" + }, + { + "bbox": [ + 132, + 650, + 139, + 659 + ], + "score": 0.71, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 139, + 649, + 505, + 660 + ], + "score": 1.0, + "content": ", stabilization of deeper and larger TCNs becomes important. For example, in a case where", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 659, + 506, + 673 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 301, + 673 + ], + "score": 1.0, + "content": "the prediction could depend on a history of size", + "type": "text" + }, + { + "bbox": [ + 302, + 659, + 316, + 670 + ], + "score": 0.87, + "content": "2 ^ { 1 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 316, + 659, + 506, + 673 + ], + "score": 1.0, + "content": "and a high-dimensional input sequence, a net-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 670, + 505, + 683 + ], + "spans": [ + { + "bbox": [ + 106, + 670, + 505, + 683 + ], + "score": 1.0, + "content": "work of up to 12 layers could be needed. Each layer, more specifically, consists of multiple filters", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 681, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 505, + 694 + ], + "score": 1.0, + "content": "for feature extraction. In our design of the generic TCN model, we therefore employed a generic", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 693, + 304, + 705 + ], + "spans": [ + { + "bbox": [ + 106, + 693, + 304, + 705 + ], + "score": 1.0, + "content": "residual module in place of a convolutional layer.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 35.5 + }, + { + "type": "text", + "bbox": [ + 107, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 721 + ], + "score": 1.0, + "content": "The residual block for our baseline TCN is shown in figure 3a. Within a residual block, the TCN has", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "score": 1.0, + "content": "2 layers of dilated causal convolution and non-linearity, for which we used the rectified linear unit", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39.5 + } + ], + "page_idx": 4, + "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, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 763 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 763 + ], + "score": 1.0, + "content": "5", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 146, + 78, + 463, + 206 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 146, + 78, + 463, + 206 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 146, + 78, + 463, + 206 + ], + "spans": [ + { + "bbox": [ + 146, + 78, + 463, + 206 + ], + "score": 0.969, + "type": "image", + "image_path": "3d3384271f9fbd194ae3ecf347bb7e1e6b27e790b9063a1b747424be7bcaf5f9.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 146, + 78, + 463, + 120.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 146, + 120.66666666666666, + 463, + 163.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 146, + 163.33333333333331, + 463, + 205.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 105, + 213, + 505, + 236 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 213, + 505, + 226 + ], + "spans": [ + { + "bbox": [ + 106, + 213, + 349, + 226 + ], + "score": 1.0, + "content": "Figure 2: A dilated causal convolution with dilation factors", + "type": "text" + }, + { + "bbox": [ + 349, + 213, + 395, + 225 + ], + "score": 0.92, + "content": "d = 1 , 2 , 4", + "type": "inline_equation" + }, + { + "bbox": [ + 396, + 213, + 454, + 226 + ], + "score": 1.0, + "content": "and filter size", + "type": "text" + }, + { + "bbox": [ + 454, + 213, + 481, + 223 + ], + "score": 0.89, + "content": "k = 3", + "type": "inline_equation" + }, + { + "bbox": [ + 482, + 213, + 505, + 226 + ], + "score": 1.0, + "content": ". The", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 223, + 369, + 238 + ], + "spans": [ + { + "bbox": [ + 105, + 223, + 369, + 238 + ], + "score": 1.0, + "content": "receptive field is able to cover all values from the input sequence.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "index": 2.25 + }, + { + "type": "title", + "bbox": [ + 108, + 255, + 242, + 267 + ], + "lines": [ + { + "bbox": [ + 105, + 254, + 244, + 269 + ], + "spans": [ + { + "bbox": [ + 105, + 254, + 244, + 269 + ], + "score": 1.0, + "content": "3.3 DILATED CONVOLUTIONS", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 106, + 276, + 505, + 354 + ], + "lines": [ + { + "bbox": [ + 106, + 276, + 505, + 289 + ], + "spans": [ + { + "bbox": [ + 106, + 276, + 505, + 289 + ], + "score": 1.0, + "content": "Through convolutional filters, as previously addressed, a simple causal convolution is only able to", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 287, + 505, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 287, + 505, + 300 + ], + "score": 1.0, + "content": "look back at a history with size linear in the depth of the network. This makes it challenging to", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 298, + 506, + 312 + ], + "spans": [ + { + "bbox": [ + 105, + 298, + 506, + 312 + ], + "score": 1.0, + "content": "apply the aforementioned causal convolution on sequence tasks, especially those requiring longer", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 309, + 505, + 322 + ], + "spans": [ + { + "bbox": [ + 105, + 309, + 505, + 322 + ], + "score": 1.0, + "content": "history. Our solution here, used previously for example in audio synthesis by Oord et al. (2016a),", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 104, + 320, + 505, + 333 + ], + "spans": [ + { + "bbox": [ + 104, + 320, + 505, + 333 + ], + "score": 1.0, + "content": "is to employ dilated convolutions (Yu & Koltun, 2015) that enable an exponentially large receptive", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 330, + 506, + 344 + ], + "spans": [ + { + "bbox": [ + 105, + 330, + 299, + 344 + ], + "score": 1.0, + "content": "field. More formally, for a 1-D sequence input", + "type": "text" + }, + { + "bbox": [ + 300, + 332, + 334, + 342 + ], + "score": 0.91, + "content": "\\mathbf { x } \\in \\mathbb { R } ^ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 334, + 330, + 383, + 344 + ], + "score": 1.0, + "content": "and a filter", + "type": "text" + }, + { + "bbox": [ + 383, + 331, + 486, + 343 + ], + "score": 0.93, + "content": "f : \\bar { \\{ 0 , \\dots , k - 1 \\bar { \\} } } \\mathbb { R }", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 330, + 506, + 344 + ], + "score": 1.0, + "content": ", the", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 341, + 407, + 356 + ], + "spans": [ + { + "bbox": [ + 105, + 341, + 226, + 356 + ], + "score": 1.0, + "content": "dilated convolution operation", + "type": "text" + }, + { + "bbox": [ + 226, + 343, + 235, + 352 + ], + "score": 0.84, + "content": "F", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 341, + 282, + 356 + ], + "score": 1.0, + "content": "on element", + "type": "text" + }, + { + "bbox": [ + 283, + 345, + 288, + 352 + ], + "score": 0.75, + "content": "s", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 341, + 407, + 356 + ], + "score": 1.0, + "content": "of the sequence is defined as", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 9, + "bbox_fs": [ + 104, + 276, + 506, + 356 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 224, + 357, + 386, + 392 + ], + "lines": [ + { + "bbox": [ + 224, + 357, + 386, + 392 + ], + "spans": [ + { + "bbox": [ + 224, + 357, + 386, + 392 + ], + "score": 0.94, + "content": "F ( s ) = ( \\mathbf { x } * _ { d } f ) ( s ) = \\sum _ { i = 0 } ^ { k - 1 } f ( i ) \\cdot \\mathbf { x } _ { s + d \\cdot i }", + "type": "interline_equation", + "image_path": "c2f18d1bcf810be91cf4f6415c0e25ca6867b5ddba3cb28385e6dd7d5bc0ee2e.jpg" + } + ] + } + ], + "index": 13.5, + "virtual_lines": [ + { + "bbox": [ + 224, + 357, + 386, + 374.5 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 224, + 374.5, + 386, + 392.0 + ], + "spans": [], + "index": 14 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 394, + 505, + 439 + ], + "lines": [ + { + "bbox": [ + 106, + 395, + 505, + 407 + ], + "spans": [ + { + "bbox": [ + 106, + 395, + 133, + 407 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 133, + 396, + 140, + 405 + ], + "score": 0.81, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 140, + 395, + 239, + 407 + ], + "score": 1.0, + "content": "is the dilation factor and", + "type": "text" + }, + { + "bbox": [ + 239, + 396, + 245, + 405 + ], + "score": 0.83, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 246, + 395, + 505, + 407 + ], + "score": 1.0, + "content": "is the filter size. Dilation is thus equivalent to introducing a fixed", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 406, + 505, + 417 + ], + "spans": [ + { + "bbox": [ + 105, + 406, + 336, + 417 + ], + "score": 1.0, + "content": "step between every two adjacent filter taps. When taking", + "type": "text" + }, + { + "bbox": [ + 336, + 406, + 361, + 416 + ], + "score": 0.9, + "content": "d = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 362, + 406, + 505, + 417 + ], + "score": 1.0, + "content": ", for example, a dilated convolution", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 417, + 505, + 429 + ], + "spans": [ + { + "bbox": [ + 105, + 417, + 505, + 429 + ], + "score": 1.0, + "content": "is trivially a normal convolution operation. Using larger dilations enables an output at the top level", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 428, + 491, + 440 + ], + "spans": [ + { + "bbox": [ + 105, + 428, + 491, + 440 + ], + "score": 1.0, + "content": "to represent a wider range of inputs, thus effectively expanding the receptive field of a ConvNet.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 16.5, + "bbox_fs": [ + 105, + 395, + 505, + 440 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 444, + 505, + 522 + ], + "lines": [ + { + "bbox": [ + 106, + 444, + 505, + 457 + ], + "spans": [ + { + "bbox": [ + 106, + 444, + 494, + 457 + ], + "score": 1.0, + "content": "This gives us two ways to increase the receptive field of the TCN: by choosing larger filter sizes", + "type": "text" + }, + { + "bbox": [ + 495, + 445, + 501, + 455 + ], + "score": 0.76, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 501, + 444, + 505, + 457 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 456, + 504, + 468 + ], + "spans": [ + { + "bbox": [ + 106, + 456, + 257, + 468 + ], + "score": 1.0, + "content": "and by increasing the dilation factor", + "type": "text" + }, + { + "bbox": [ + 257, + 456, + 263, + 466 + ], + "score": 0.78, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 264, + 456, + 464, + 468 + ], + "score": 1.0, + "content": ", where the effective history of one such layer is", + "type": "text" + }, + { + "bbox": [ + 464, + 456, + 501, + 468 + ], + "score": 0.92, + "content": "( k - 1 ) d", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 456, + 504, + 468 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 466, + 505, + 479 + ], + "spans": [ + { + "bbox": [ + 106, + 466, + 353, + 479 + ], + "score": 1.0, + "content": "As is common when using dilated convolutions, we increase", + "type": "text" + }, + { + "bbox": [ + 353, + 467, + 360, + 477 + ], + "score": 0.77, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 361, + 466, + 505, + 479 + ], + "score": 1.0, + "content": "exponentially with the depth of the", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 104, + 477, + 506, + 490 + ], + "spans": [ + { + "bbox": [ + 104, + 477, + 163, + 490 + ], + "score": 1.0, + "content": "network (i.e.,", + "type": "text" + }, + { + "bbox": [ + 164, + 477, + 209, + 489 + ], + "score": 0.93, + "content": "d = O ( 2 ^ { i } )", + "type": "inline_equation" + }, + { + "bbox": [ + 209, + 477, + 243, + 490 + ], + "score": 1.0, + "content": "at level", + "type": "text" + }, + { + "bbox": [ + 243, + 478, + 248, + 487 + ], + "score": 0.69, + "content": "i", + "type": "inline_equation" + }, + { + "bbox": [ + 249, + 477, + 506, + 490 + ], + "score": 1.0, + "content": "of the network). This ensures that there is some filter that hits", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 488, + 505, + 501 + ], + "spans": [ + { + "bbox": [ + 105, + 488, + 505, + 501 + ], + "score": 1.0, + "content": "each input within the effective history, while also allowing for an extremely large effective history", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 500, + 505, + 512 + ], + "spans": [ + { + "bbox": [ + 106, + 500, + 425, + 512 + ], + "score": 1.0, + "content": "using deep networks. We provide an illustration in Figure 2. Using filter size", + "type": "text" + }, + { + "bbox": [ + 425, + 500, + 453, + 510 + ], + "score": 0.92, + "content": "k = 3", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 500, + 505, + 512 + ], + "score": 1.0, + "content": "and dilation", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 510, + 457, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 132, + 524 + ], + "score": 1.0, + "content": "factor", + "type": "text" + }, + { + "bbox": [ + 133, + 511, + 176, + 522 + ], + "score": 0.91, + "content": "d = 1 , 2 , 4", + "type": "inline_equation" + }, + { + "bbox": [ + 176, + 510, + 457, + 524 + ], + "score": 1.0, + "content": ", the receptive field is able to cover all values from the input sequence.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22, + "bbox_fs": [ + 104, + 444, + 506, + 524 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 534, + 242, + 546 + ], + "lines": [ + { + "bbox": [ + 105, + 533, + 243, + 548 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 243, + 548 + ], + "score": 1.0, + "content": "3.4 RESIDUAL CONNECTIONS", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 106, + 555, + 505, + 589 + ], + "lines": [ + { + "bbox": [ + 105, + 554, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 505, + 568 + ], + "score": 1.0, + "content": "Proposed by He et al. (2016), residual functions have proven to be especially useful in effectively", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 567, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 106, + 567, + 505, + 579 + ], + "score": 1.0, + "content": "training deep networks. In a residual network, each residual block contains a branch leading out to", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 578, + 438, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 578, + 214, + 590 + ], + "score": 1.0, + "content": "a series of transformations", + "type": "text" + }, + { + "bbox": [ + 215, + 578, + 224, + 587 + ], + "score": 0.84, + "content": "\\mathcal { F }", + "type": "inline_equation" + }, + { + "bbox": [ + 224, + 578, + 376, + 590 + ], + "score": 1.0, + "content": ", whose outputs are added to the input", + "type": "text" + }, + { + "bbox": [ + 376, + 579, + 384, + 587 + ], + "score": 0.68, + "content": "\\mathbf { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 384, + 578, + 438, + 590 + ], + "score": 1.0, + "content": "of the block:", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28, + "bbox_fs": [ + 105, + 554, + 505, + 590 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 250, + 592, + 360, + 606 + ], + "lines": [ + { + "bbox": [ + 250, + 592, + 360, + 606 + ], + "spans": [ + { + "bbox": [ + 250, + 592, + 360, + 606 + ], + "score": 0.93, + "content": "o = \\mathrm { A c t i v a t i o n } ( \\mathbf { x } + \\mathcal { F } ( \\mathbf { x } ) )", + "type": "interline_equation", + "image_path": "a14b11eeb99c1c7768b94eec8e763486c2f41521fee1459687c6c0433c4fd694.jpg" + } + ] + } + ], + "index": 30, + "virtual_lines": [ + { + "bbox": [ + 250, + 592, + 360, + 606 + ], + "spans": [], + "index": 30 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 609, + 504, + 633 + ], + "lines": [ + { + "bbox": [ + 106, + 609, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 106, + 609, + 505, + 622 + ], + "score": 1.0, + "content": "This effectively allows for the layers to learn modifications to the identity mapping rather than the", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 622, + 453, + 633 + ], + "spans": [ + { + "bbox": [ + 106, + 622, + 453, + 633 + ], + "score": 1.0, + "content": "entire transformation, which has been repeatedly shown to benefit very deep networks.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 31.5, + "bbox_fs": [ + 106, + 609, + 505, + 633 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 637, + 505, + 704 + ], + "lines": [ + { + "bbox": [ + 106, + 638, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 638, + 352, + 650 + ], + "score": 1.0, + "content": "As the TCN’s receptive field depends on the network depth", + "type": "text" + }, + { + "bbox": [ + 352, + 640, + 360, + 648 + ], + "score": 0.75, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 360, + 638, + 445, + 650 + ], + "score": 1.0, + "content": "as well as filter size", + "type": "text" + }, + { + "bbox": [ + 446, + 639, + 453, + 648 + ], + "score": 0.8, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 453, + 638, + 505, + 650 + ], + "score": 1.0, + "content": "and dilation", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 649, + 505, + 660 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 132, + 660 + ], + "score": 1.0, + "content": "factor", + "type": "text" + }, + { + "bbox": [ + 132, + 650, + 139, + 659 + ], + "score": 0.71, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 139, + 649, + 505, + 660 + ], + "score": 1.0, + "content": ", stabilization of deeper and larger TCNs becomes important. For example, in a case where", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 659, + 506, + 673 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 301, + 673 + ], + "score": 1.0, + "content": "the prediction could depend on a history of size", + "type": "text" + }, + { + "bbox": [ + 302, + 659, + 316, + 670 + ], + "score": 0.87, + "content": "2 ^ { 1 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 316, + 659, + 506, + 673 + ], + "score": 1.0, + "content": "and a high-dimensional input sequence, a net-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 670, + 505, + 683 + ], + "spans": [ + { + "bbox": [ + 106, + 670, + 505, + 683 + ], + "score": 1.0, + "content": "work of up to 12 layers could be needed. Each layer, more specifically, consists of multiple filters", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 681, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 505, + 694 + ], + "score": 1.0, + "content": "for feature extraction. In our design of the generic TCN model, we therefore employed a generic", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 693, + 304, + 705 + ], + "spans": [ + { + "bbox": [ + 106, + 693, + 304, + 705 + ], + "score": 1.0, + "content": "residual module in place of a convolutional layer.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 35.5, + "bbox_fs": [ + 105, + 638, + 506, + 705 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 721 + ], + "score": 1.0, + "content": "The residual block for our baseline TCN is shown in figure 3a. Within a residual block, the TCN has", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "score": 1.0, + "content": "2 layers of dilated causal convolution and non-linearity, for which we used the rectified linear unit", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39.5, + "bbox_fs": [ + 105, + 709, + 505, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 130, + 235, + 302, + 265 + ], + "lines": [ + { + "bbox": [ + 129, + 235, + 304, + 246 + ], + "spans": [ + { + "bbox": [ + 129, + 235, + 304, + 246 + ], + "score": 1.0, + "content": "(a) TCN residual block. An 1x1 convolution is", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 130, + 245, + 303, + 256 + ], + "spans": [ + { + "bbox": [ + 130, + 245, + 303, + 256 + ], + "score": 1.0, + "content": "added when residual input and output have dif-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 130, + 254, + 200, + 266 + ], + "spans": [ + { + "bbox": [ + 130, + 254, + 200, + 266 + ], + "score": 1.0, + "content": "ferent dimensions.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + }, + { + "type": "image", + "bbox": [ + 130, + 79, + 482, + 231 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 130, + 79, + 482, + 231 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 130, + 79, + 482, + 231 + ], + "spans": [ + { + "bbox": [ + 130, + 79, + 482, + 231 + ], + "score": 0.506, + "type": "image", + "image_path": "1813e828cfa0df05d2cac09fee75934b751463303c74b3ec805bc1f1e7e53827.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 130, + 79, + 482, + 129.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 130, + 129.66666666666666, + 482, + 180.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 130, + 180.33333333333331, + 482, + 230.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 200, + 275, + 408, + 287 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 199, + 274, + 409, + 288 + ], + "spans": [ + { + "bbox": [ + 199, + 274, + 409, + 288 + ], + "score": 1.0, + "content": "Figure 3: A visualization of the TCN residual block", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 9 + } + ], + "index": 5.0 + }, + { + "type": "text", + "bbox": [ + 308, + 235, + 480, + 266 + ], + "lines": [ + { + "bbox": [ + 307, + 235, + 481, + 245 + ], + "spans": [ + { + "bbox": [ + 307, + 235, + 481, + 245 + ], + "score": 1.0, + "content": "(b) An example of residual connection in TCN.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 307, + 245, + 481, + 256 + ], + "spans": [ + { + "bbox": [ + 307, + 245, + 481, + 256 + ], + "score": 1.0, + "content": "The blue lines are filters in the residual function,", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 307, + 254, + 461, + 267 + ], + "spans": [ + { + "bbox": [ + 307, + 254, + 461, + 267 + ], + "score": 1.0, + "content": "and the green lines are identity mappings.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 107, + 309, + 505, + 363 + ], + "lines": [ + { + "bbox": [ + 106, + 309, + 505, + 321 + ], + "spans": [ + { + "bbox": [ + 106, + 309, + 505, + 321 + ], + "score": 1.0, + "content": "(ReLU) (Nair & Hinton, 2010). For normalization, we applied Weight Normalization (Salimans &", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 320, + 504, + 331 + ], + "spans": [ + { + "bbox": [ + 106, + 320, + 504, + 331 + ], + "score": 1.0, + "content": "Kingma, 2016) to the filters in the dilated convolution (where we note that the filters are essentially", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 331, + 505, + 343 + ], + "spans": [ + { + "bbox": [ + 106, + 331, + 168, + 343 + ], + "score": 1.0, + "content": "vectors of size", + "type": "text" + }, + { + "bbox": [ + 169, + 331, + 195, + 342 + ], + "score": 0.88, + "content": "k \\times 1 \\AA", + "type": "inline_equation" + }, + { + "bbox": [ + 195, + 331, + 505, + 343 + ], + "score": 1.0, + "content": "). In addition, a 2-D dropout (Srivastava et al., 2014) layer was added after", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 341, + 505, + 354 + ], + "spans": [ + { + "bbox": [ + 105, + 341, + 505, + 354 + ], + "score": 1.0, + "content": "each dilated convolution for regularization: at each training step, a whole channel (in the width", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 353, + 209, + 365 + ], + "spans": [ + { + "bbox": [ + 106, + 353, + 209, + 365 + ], + "score": 1.0, + "content": "dimension) is zeroed out.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 107, + 370, + 505, + 414 + ], + "lines": [ + { + "bbox": [ + 106, + 370, + 505, + 381 + ], + "spans": [ + { + "bbox": [ + 106, + 370, + 505, + 381 + ], + "score": 1.0, + "content": "However, whereas in standard ResNet the input is passed in and added directly to the output of the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 380, + 506, + 393 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 506, + 393 + ], + "score": 1.0, + "content": "residual function, in TCN (and ConvNet in general) the input and output could have different widths.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 391, + 505, + 404 + ], + "spans": [ + { + "bbox": [ + 105, + 391, + 505, + 404 + ], + "score": 1.0, + "content": "Therefore in our TCN, when the input-output widths disagree, we use an additional 1x1 convolution", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 402, + 482, + 415 + ], + "spans": [ + { + "bbox": [ + 105, + 402, + 253, + 415 + ], + "score": 1.0, + "content": "to ensure that element-wise addition", + "type": "text" + }, + { + "bbox": [ + 253, + 404, + 263, + 413 + ], + "score": 0.83, + "content": "\\oplus", + "type": "inline_equation" + }, + { + "bbox": [ + 263, + 402, + 482, + 415 + ], + "score": 1.0, + "content": "receives tensors of the same shape (see Figure 3a, 3b).", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 16.5 + }, + { + "type": "text", + "bbox": [ + 107, + 419, + 505, + 475 + ], + "lines": [ + { + "bbox": [ + 105, + 419, + 505, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 419, + 505, + 432 + ], + "score": 1.0, + "content": "Note that many further optimizations (e.g., gating, skip connections, context stacking as in audio", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 430, + 505, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 505, + 442 + ], + "score": 1.0, + "content": "generation using WaveNet) are possible in a TCN than what we described here. However, in this", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 442, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 505, + 453 + ], + "score": 1.0, + "content": "paper, we aim to present a generic, general-purpose TCN, to which additional twists can be added", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 452, + 505, + 465 + ], + "spans": [ + { + "bbox": [ + 105, + 452, + 505, + 465 + ], + "score": 1.0, + "content": "as needed. As we are going to show in Section 4, this general-purpose architecture is already able", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 463, + 430, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 463, + 430, + 477 + ], + "score": 1.0, + "content": "to outperform recurrent units like LSTM on a number of tasks by a good margin.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 21 + }, + { + "type": "title", + "bbox": [ + 110, + 488, + 325, + 500 + ], + "lines": [ + { + "bbox": [ + 107, + 488, + 327, + 502 + ], + "spans": [ + { + "bbox": [ + 107, + 488, + 327, + 502 + ], + "score": 1.0, + "content": "3.5 ADVANTAGES OF TCN SEQUENCE MODELING", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 108, + 509, + 488, + 521 + ], + "lines": [ + { + "bbox": [ + 106, + 509, + 490, + 523 + ], + "spans": [ + { + "bbox": [ + 106, + 509, + 490, + 523 + ], + "score": 1.0, + "content": "There are several key advantages to a TCN model with the ingredients that we described above.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 132, + 531, + 504, + 586 + ], + "lines": [ + { + "bbox": [ + 131, + 531, + 505, + 544 + ], + "spans": [ + { + "bbox": [ + 131, + 531, + 505, + 544 + ], + "score": 1.0, + "content": "• Parallelism. Unlike in RNNs where the predictions for later timesteps must wait for their", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 141, + 543, + 505, + 554 + ], + "spans": [ + { + "bbox": [ + 141, + 543, + 505, + 554 + ], + "score": 1.0, + "content": "predecessors to complete, in a convolutional architecture these computations can be done", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 142, + 554, + 505, + 565 + ], + "spans": [ + { + "bbox": [ + 142, + 554, + 505, + 565 + ], + "score": 1.0, + "content": "in parallel since the same filter is used in each layer. Therefore, in training and evaluation,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 142, + 564, + 505, + 577 + ], + "spans": [ + { + "bbox": [ + 142, + 564, + 505, + 577 + ], + "score": 1.0, + "content": "a (possibly long) input sequence can be processed as a whole in TCN, instead of serially as", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 142, + 576, + 468, + 587 + ], + "spans": [ + { + "bbox": [ + 142, + 576, + 468, + 587 + ], + "score": 1.0, + "content": "in RNN, which depends on the length of the sequence and could be less efficient.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 133, + 590, + 503, + 645 + ], + "lines": [ + { + "bbox": [ + 132, + 590, + 505, + 603 + ], + "spans": [ + { + "bbox": [ + 132, + 590, + 505, + 603 + ], + "score": 1.0, + "content": "• Flexible receptive field size. With a TCN, we can change its receptive field size in mul-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 141, + 601, + 505, + 615 + ], + "spans": [ + { + "bbox": [ + 141, + 601, + 505, + 615 + ], + "score": 1.0, + "content": "tiple ways. For instance, stacking more dilated (causal) convolutional layers, using larger", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 141, + 611, + 506, + 626 + ], + "spans": [ + { + "bbox": [ + 141, + 611, + 506, + 626 + ], + "score": 1.0, + "content": "dilation factors, or increasing the filter size are all viable options (with possibly different", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 141, + 623, + 506, + 637 + ], + "spans": [ + { + "bbox": [ + 141, + 623, + 506, + 637 + ], + "score": 1.0, + "content": "interpretations). TCN is thus easy to tune and adapt to different domains, since we now can", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 141, + 633, + 336, + 648 + ], + "spans": [ + { + "bbox": [ + 141, + 633, + 336, + 648 + ], + "score": 1.0, + "content": "directly control the size of the model’s memory.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 33 + }, + { + "type": "text", + "bbox": [ + 133, + 650, + 505, + 694 + ], + "lines": [ + { + "bbox": [ + 132, + 650, + 506, + 663 + ], + "spans": [ + { + "bbox": [ + 132, + 650, + 506, + 663 + ], + "score": 1.0, + "content": "• Stable gradients. Unlike recurrent architectures, TCN has a backpropagation path that is", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 142, + 661, + 505, + 673 + ], + "spans": [ + { + "bbox": [ + 142, + 661, + 505, + 673 + ], + "score": 1.0, + "content": "different from the temporal direction of the sequence. This enables it to avoid the problem", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 142, + 672, + 506, + 685 + ], + "spans": [ + { + "bbox": [ + 142, + 672, + 506, + 685 + ], + "score": 1.0, + "content": "of exploding/vanishing gradients, which is a major issue for RNNs (and which led to the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 141, + 683, + 329, + 696 + ], + "spans": [ + { + "bbox": [ + 141, + 683, + 329, + 696 + ], + "score": 1.0, + "content": "development of LSTM, GRU, HF-RNN, etc.).", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 37.5 + }, + { + "type": "text", + "bbox": [ + 133, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 132, + 698, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 132, + 698, + 505, + 712 + ], + "score": 1.0, + "content": "• Low memory requirement for training. In a task where the input sequence is long,", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 141, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 141, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "a structure such as LSTM can easily use up a lot of memory to store the partial results", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 141, + 720, + 505, + 734 + ], + "spans": [ + { + "bbox": [ + 141, + 720, + 505, + 734 + ], + "score": 1.0, + "content": "for backpropagation (e.g., the results for each gate of the cell). However, in TCN, the", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41 + } + ], + "page_idx": 5, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 309, + 39 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 309, + 39 + ], + "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": [ + 130, + 235, + 302, + 265 + ], + "lines": [ + { + "bbox": [ + 129, + 235, + 304, + 246 + ], + "spans": [ + { + "bbox": [ + 129, + 235, + 304, + 246 + ], + "score": 1.0, + "content": "(a) TCN residual block. An 1x1 convolution is", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 130, + 245, + 303, + 256 + ], + "spans": [ + { + "bbox": [ + 130, + 245, + 303, + 256 + ], + "score": 1.0, + "content": "added when residual input and output have dif-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 130, + 254, + 200, + 266 + ], + "spans": [ + { + "bbox": [ + 130, + 254, + 200, + 266 + ], + "score": 1.0, + "content": "ferent dimensions.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4, + "bbox_fs": [ + 129, + 235, + 304, + 266 + ] + }, + { + "type": "image", + "bbox": [ + 130, + 79, + 482, + 231 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 130, + 79, + 482, + 231 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 130, + 79, + 482, + 231 + ], + "spans": [ + { + "bbox": [ + 130, + 79, + 482, + 231 + ], + "score": 0.506, + "type": "image", + "image_path": "1813e828cfa0df05d2cac09fee75934b751463303c74b3ec805bc1f1e7e53827.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 130, + 79, + 482, + 129.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 130, + 129.66666666666666, + 482, + 180.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 130, + 180.33333333333331, + 482, + 230.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 200, + 275, + 408, + 287 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 199, + 274, + 409, + 288 + ], + "spans": [ + { + "bbox": [ + 199, + 274, + 409, + 288 + ], + "score": 1.0, + "content": "Figure 3: A visualization of the TCN residual block", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 9 + } + ], + "index": 5.0 + }, + { + "type": "text", + "bbox": [ + 308, + 235, + 480, + 266 + ], + "lines": [ + { + "bbox": [ + 307, + 235, + 481, + 245 + ], + "spans": [ + { + "bbox": [ + 307, + 235, + 481, + 245 + ], + "score": 1.0, + "content": "(b) An example of residual connection in TCN.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 307, + 245, + 481, + 256 + ], + "spans": [ + { + "bbox": [ + 307, + 245, + 481, + 256 + ], + "score": 1.0, + "content": "The blue lines are filters in the residual function,", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 307, + 254, + 461, + 267 + ], + "spans": [ + { + "bbox": [ + 307, + 254, + 461, + 267 + ], + "score": 1.0, + "content": "and the green lines are identity mappings.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7, + "bbox_fs": [ + 307, + 235, + 481, + 267 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 309, + 505, + 363 + ], + "lines": [ + { + "bbox": [ + 106, + 309, + 505, + 321 + ], + "spans": [ + { + "bbox": [ + 106, + 309, + 505, + 321 + ], + "score": 1.0, + "content": "(ReLU) (Nair & Hinton, 2010). For normalization, we applied Weight Normalization (Salimans &", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 320, + 504, + 331 + ], + "spans": [ + { + "bbox": [ + 106, + 320, + 504, + 331 + ], + "score": 1.0, + "content": "Kingma, 2016) to the filters in the dilated convolution (where we note that the filters are essentially", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 331, + 505, + 343 + ], + "spans": [ + { + "bbox": [ + 106, + 331, + 168, + 343 + ], + "score": 1.0, + "content": "vectors of size", + "type": "text" + }, + { + "bbox": [ + 169, + 331, + 195, + 342 + ], + "score": 0.88, + "content": "k \\times 1 \\AA", + "type": "inline_equation" + }, + { + "bbox": [ + 195, + 331, + 505, + 343 + ], + "score": 1.0, + "content": "). In addition, a 2-D dropout (Srivastava et al., 2014) layer was added after", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 341, + 505, + 354 + ], + "spans": [ + { + "bbox": [ + 105, + 341, + 505, + 354 + ], + "score": 1.0, + "content": "each dilated convolution for regularization: at each training step, a whole channel (in the width", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 353, + 209, + 365 + ], + "spans": [ + { + "bbox": [ + 106, + 353, + 209, + 365 + ], + "score": 1.0, + "content": "dimension) is zeroed out.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 12, + "bbox_fs": [ + 105, + 309, + 505, + 365 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 370, + 505, + 414 + ], + "lines": [ + { + "bbox": [ + 106, + 370, + 505, + 381 + ], + "spans": [ + { + "bbox": [ + 106, + 370, + 505, + 381 + ], + "score": 1.0, + "content": "However, whereas in standard ResNet the input is passed in and added directly to the output of the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 380, + 506, + 393 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 506, + 393 + ], + "score": 1.0, + "content": "residual function, in TCN (and ConvNet in general) the input and output could have different widths.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 391, + 505, + 404 + ], + "spans": [ + { + "bbox": [ + 105, + 391, + 505, + 404 + ], + "score": 1.0, + "content": "Therefore in our TCN, when the input-output widths disagree, we use an additional 1x1 convolution", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 402, + 482, + 415 + ], + "spans": [ + { + "bbox": [ + 105, + 402, + 253, + 415 + ], + "score": 1.0, + "content": "to ensure that element-wise addition", + "type": "text" + }, + { + "bbox": [ + 253, + 404, + 263, + 413 + ], + "score": 0.83, + "content": "\\oplus", + "type": "inline_equation" + }, + { + "bbox": [ + 263, + 402, + 482, + 415 + ], + "score": 1.0, + "content": "receives tensors of the same shape (see Figure 3a, 3b).", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 16.5, + "bbox_fs": [ + 105, + 370, + 506, + 415 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 419, + 505, + 475 + ], + "lines": [ + { + "bbox": [ + 105, + 419, + 505, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 419, + 505, + 432 + ], + "score": 1.0, + "content": "Note that many further optimizations (e.g., gating, skip connections, context stacking as in audio", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 430, + 505, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 505, + 442 + ], + "score": 1.0, + "content": "generation using WaveNet) are possible in a TCN than what we described here. However, in this", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 442, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 505, + 453 + ], + "score": 1.0, + "content": "paper, we aim to present a generic, general-purpose TCN, to which additional twists can be added", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 452, + 505, + 465 + ], + "spans": [ + { + "bbox": [ + 105, + 452, + 505, + 465 + ], + "score": 1.0, + "content": "as needed. As we are going to show in Section 4, this general-purpose architecture is already able", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 463, + 430, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 463, + 430, + 477 + ], + "score": 1.0, + "content": "to outperform recurrent units like LSTM on a number of tasks by a good margin.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 21, + "bbox_fs": [ + 105, + 419, + 505, + 477 + ] + }, + { + "type": "title", + "bbox": [ + 110, + 488, + 325, + 500 + ], + "lines": [ + { + "bbox": [ + 107, + 488, + 327, + 502 + ], + "spans": [ + { + "bbox": [ + 107, + 488, + 327, + 502 + ], + "score": 1.0, + "content": "3.5 ADVANTAGES OF TCN SEQUENCE MODELING", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 108, + 509, + 488, + 521 + ], + "lines": [ + { + "bbox": [ + 106, + 509, + 490, + 523 + ], + "spans": [ + { + "bbox": [ + 106, + 509, + 490, + 523 + ], + "score": 1.0, + "content": "There are several key advantages to a TCN model with the ingredients that we described above.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25, + "bbox_fs": [ + 106, + 509, + 490, + 523 + ] + }, + { + "type": "text", + "bbox": [ + 132, + 531, + 504, + 586 + ], + "lines": [ + { + "bbox": [ + 131, + 531, + 505, + 544 + ], + "spans": [ + { + "bbox": [ + 131, + 531, + 505, + 544 + ], + "score": 1.0, + "content": "• Parallelism. Unlike in RNNs where the predictions for later timesteps must wait for their", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 141, + 543, + 505, + 554 + ], + "spans": [ + { + "bbox": [ + 141, + 543, + 505, + 554 + ], + "score": 1.0, + "content": "predecessors to complete, in a convolutional architecture these computations can be done", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 142, + 554, + 505, + 565 + ], + "spans": [ + { + "bbox": [ + 142, + 554, + 505, + 565 + ], + "score": 1.0, + "content": "in parallel since the same filter is used in each layer. Therefore, in training and evaluation,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 142, + 564, + 505, + 577 + ], + "spans": [ + { + "bbox": [ + 142, + 564, + 505, + 577 + ], + "score": 1.0, + "content": "a (possibly long) input sequence can be processed as a whole in TCN, instead of serially as", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 142, + 576, + 468, + 587 + ], + "spans": [ + { + "bbox": [ + 142, + 576, + 468, + 587 + ], + "score": 1.0, + "content": "in RNN, which depends on the length of the sequence and could be less efficient.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 28, + "bbox_fs": [ + 131, + 531, + 505, + 587 + ] + }, + { + "type": "text", + "bbox": [ + 133, + 590, + 503, + 645 + ], + "lines": [ + { + "bbox": [ + 132, + 590, + 505, + 603 + ], + "spans": [ + { + "bbox": [ + 132, + 590, + 505, + 603 + ], + "score": 1.0, + "content": "• Flexible receptive field size. With a TCN, we can change its receptive field size in mul-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 141, + 601, + 505, + 615 + ], + "spans": [ + { + "bbox": [ + 141, + 601, + 505, + 615 + ], + "score": 1.0, + "content": "tiple ways. For instance, stacking more dilated (causal) convolutional layers, using larger", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 141, + 611, + 506, + 626 + ], + "spans": [ + { + "bbox": [ + 141, + 611, + 506, + 626 + ], + "score": 1.0, + "content": "dilation factors, or increasing the filter size are all viable options (with possibly different", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 141, + 623, + 506, + 637 + ], + "spans": [ + { + "bbox": [ + 141, + 623, + 506, + 637 + ], + "score": 1.0, + "content": "interpretations). TCN is thus easy to tune and adapt to different domains, since we now can", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 141, + 633, + 336, + 648 + ], + "spans": [ + { + "bbox": [ + 141, + 633, + 336, + 648 + ], + "score": 1.0, + "content": "directly control the size of the model’s memory.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 33, + "bbox_fs": [ + 132, + 590, + 506, + 648 + ] + }, + { + "type": "text", + "bbox": [ + 133, + 650, + 505, + 694 + ], + "lines": [ + { + "bbox": [ + 132, + 650, + 506, + 663 + ], + "spans": [ + { + "bbox": [ + 132, + 650, + 506, + 663 + ], + "score": 1.0, + "content": "• Stable gradients. Unlike recurrent architectures, TCN has a backpropagation path that is", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 142, + 661, + 505, + 673 + ], + "spans": [ + { + "bbox": [ + 142, + 661, + 505, + 673 + ], + "score": 1.0, + "content": "different from the temporal direction of the sequence. This enables it to avoid the problem", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 142, + 672, + 506, + 685 + ], + "spans": [ + { + "bbox": [ + 142, + 672, + 506, + 685 + ], + "score": 1.0, + "content": "of exploding/vanishing gradients, which is a major issue for RNNs (and which led to the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 141, + 683, + 329, + 696 + ], + "spans": [ + { + "bbox": [ + 141, + 683, + 329, + 696 + ], + "score": 1.0, + "content": "development of LSTM, GRU, HF-RNN, etc.).", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 37.5, + "bbox_fs": [ + 132, + 650, + 506, + 696 + ] + }, + { + "type": "text", + "bbox": [ + 133, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 132, + 698, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 132, + 698, + 505, + 712 + ], + "score": 1.0, + "content": "• Low memory requirement for training. In a task where the input sequence is long,", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 141, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 141, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "a structure such as LSTM can easily use up a lot of memory to store the partial results", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 141, + 720, + 505, + 734 + ], + "spans": [ + { + "bbox": [ + 141, + 720, + 505, + 734 + ], + "score": 1.0, + "content": "for backpropagation (e.g., the results for each gate of the cell). However, in TCN, the", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 141, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 141, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "backpropagation path only depends on the network depth and the filters are shared in each", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 141, + 93, + 505, + 107 + ], + "spans": [ + { + "bbox": [ + 141, + 93, + 505, + 107 + ], + "score": 1.0, + "content": "layer, which means that in practice, as model size or sequence length gets large, TCN is", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 141, + 103, + 297, + 117 + ], + "spans": [ + { + "bbox": [ + 141, + 103, + 297, + 117 + ], + "score": 1.0, + "content": "likely to use less memory than RNNs.", + "type": "text", + "cross_page": true + } + ], + "index": 2 + } + ], + "index": 41, + "bbox_fs": [ + 132, + 698, + 505, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 142, + 82, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 141, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 141, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "backpropagation path only depends on the network depth and the filters are shared in each", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 141, + 93, + 505, + 107 + ], + "spans": [ + { + "bbox": [ + 141, + 93, + 505, + 107 + ], + "score": 1.0, + "content": "layer, which means that in practice, as model size or sequence length gets large, TCN is", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 141, + 103, + 297, + 117 + ], + "spans": [ + { + "bbox": [ + 141, + 103, + 297, + 117 + ], + "score": 1.0, + "content": "likely to use less memory than RNNs.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "title", + "bbox": [ + 107, + 131, + 342, + 142 + ], + "lines": [ + { + "bbox": [ + 105, + 130, + 343, + 145 + ], + "spans": [ + { + "bbox": [ + 105, + 130, + 343, + 145 + ], + "score": 1.0, + "content": "3.6 DISADVANTAGES OF TCN SEQUENCE MODELING", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 108, + 152, + 389, + 164 + ], + "lines": [ + { + "bbox": [ + 106, + 152, + 391, + 165 + ], + "spans": [ + { + "bbox": [ + 106, + 152, + 391, + 165 + ], + "score": 1.0, + "content": "We also summarize two disadvantages of using TCN instead of RNNs.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 132, + 176, + 505, + 314 + ], + "lines": [ + { + "bbox": [ + 132, + 176, + 505, + 188 + ], + "spans": [ + { + "bbox": [ + 132, + 176, + 505, + 188 + ], + "score": 1.0, + "content": "• Data storage in evaluation. In evaluation/testing, RNNs only need to maintain a hidden", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 141, + 187, + 506, + 199 + ], + "spans": [ + { + "bbox": [ + 141, + 187, + 277, + 199 + ], + "score": 1.0, + "content": "state and take in a current input", + "type": "text" + }, + { + "bbox": [ + 277, + 189, + 288, + 198 + ], + "score": 0.84, + "content": "x _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 288, + 187, + 506, + 199 + ], + "score": 1.0, + "content": "in order to generate a prediction. In other words, a", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 198, + 506, + 211 + ], + "spans": [ + { + "bbox": [ + 141, + 198, + 462, + 211 + ], + "score": 1.0, + "content": "“summary” of the entire history is provided by the fixed-length set of vectors", + "type": "text" + }, + { + "bbox": [ + 463, + 198, + 473, + 209 + ], + "score": 0.88, + "content": "h _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 473, + 198, + 506, + 211 + ], + "score": 1.0, + "content": ", which", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 209, + 506, + 222 + ], + "spans": [ + { + "bbox": [ + 141, + 209, + 506, + 222 + ], + "score": 1.0, + "content": "means that the actual observed sequence can be discarded (and indeed, the hidden state can", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 142, + 221, + 505, + 232 + ], + "spans": [ + { + "bbox": [ + 142, + 221, + 505, + 232 + ], + "score": 1.0, + "content": "be used as a kind of encoder for all the observed history). In contrast, the TCN still needs", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 141, + 231, + 505, + 243 + ], + "spans": [ + { + "bbox": [ + 141, + 231, + 505, + 243 + ], + "score": 1.0, + "content": "to take in a sequence with non-trivial length (precisely the effective history length) in order", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 242, + 412, + 255 + ], + "spans": [ + { + "bbox": [ + 141, + 242, + 412, + 255 + ], + "score": 1.0, + "content": "to predict, thus possibly requiring more memory during evaluation.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 133, + 258, + 505, + 270 + ], + "spans": [ + { + "bbox": [ + 133, + 258, + 505, + 270 + ], + "score": 1.0, + "content": "• Potential parameter change for a transfer of domain. Different domains can have dif-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 268, + 506, + 282 + ], + "spans": [ + { + "bbox": [ + 141, + 268, + 506, + 282 + ], + "score": 1.0, + "content": "ferent requirements on the amount of history the model needs to memorize. Therefore,", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 281, + 504, + 293 + ], + "spans": [ + { + "bbox": [ + 141, + 281, + 497, + 293 + ], + "score": 1.0, + "content": "when transferring a model from a domain where only little memory is needed (i.e., small", + "type": "text" + }, + { + "bbox": [ + 497, + 281, + 504, + 290 + ], + "score": 0.78, + "content": "k", + "type": "inline_equation" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 291, + 506, + 304 + ], + "spans": [ + { + "bbox": [ + 141, + 291, + 159, + 304 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 159, + 292, + 166, + 302 + ], + "score": 0.62, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 166, + 291, + 444, + 304 + ], + "score": 1.0, + "content": ") to a domain where much larger memory is required (i.e., much larger", + "type": "text" + }, + { + "bbox": [ + 445, + 292, + 452, + 301 + ], + "score": 0.8, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 291, + 469, + 304 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 469, + 292, + 477, + 302 + ], + "score": 0.73, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 477, + 291, + 506, + 304 + ], + "score": 1.0, + "content": "), TCN", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 303, + 421, + 315 + ], + "spans": [ + { + "bbox": [ + 141, + 303, + 421, + 315 + ], + "score": 1.0, + "content": "may perform poorly for not having a sufficiently large receptive field.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 10.5 + }, + { + "type": "text", + "bbox": [ + 108, + 325, + 504, + 359 + ], + "lines": [ + { + "bbox": [ + 106, + 325, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 106, + 325, + 506, + 338 + ], + "score": 1.0, + "content": "We want to emphasize, though, that we believe the notable lack of “infinite memory” for a TCN is", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 337, + 504, + 349 + ], + "spans": [ + { + "bbox": [ + 106, + 337, + 504, + 349 + ], + "score": 1.0, + "content": "decidedly not a practical disadvantage, since, as we show in Section 4, the TCN method actually", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 347, + 439, + 360 + ], + "spans": [ + { + "bbox": [ + 106, + 347, + 439, + 360 + ], + "score": 1.0, + "content": "outperforms RNNs in terms of the ability to deal with long temporal dependencies.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18 + }, + { + "type": "title", + "bbox": [ + 108, + 377, + 200, + 389 + ], + "lines": [ + { + "bbox": [ + 105, + 376, + 201, + 391 + ], + "spans": [ + { + "bbox": [ + 105, + 376, + 201, + 391 + ], + "score": 1.0, + "content": "4 EXPERIMENTS", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 107, + 403, + 505, + 480 + ], + "lines": [ + { + "bbox": [ + 105, + 403, + 505, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 403, + 505, + 416 + ], + "score": 1.0, + "content": "In this section, we conduct a series of experiments using the baseline TCN (described in section 3)", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 414, + 505, + 427 + ], + "spans": [ + { + "bbox": [ + 105, + 414, + 505, + 427 + ], + "score": 1.0, + "content": "and generic RNNs (namely LSTMs, GRUs, and vanilla RNNs). These experiments cover tasks and", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 424, + 505, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 424, + 505, + 439 + ], + "score": 1.0, + "content": "datasets from various domains, aiming to test different aspects of a model’s ability to learn sequence", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 435, + 505, + 449 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 505, + 449 + ], + "score": 1.0, + "content": "modeling. In several cases, specialized RNN models, or methods with particular forms of regulariza-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 447, + 505, + 460 + ], + "spans": [ + { + "bbox": [ + 105, + 447, + 505, + 460 + ], + "score": 1.0, + "content": "tion can indeed vastly outperform both generic RNNs and the TCN on particular problems, which", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 457, + 506, + 471 + ], + "spans": [ + { + "bbox": [ + 105, + 457, + 506, + 471 + ], + "score": 1.0, + "content": "we highlight when applicable. But as a general-purpose architecture, we believe the experiments", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 469, + 503, + 482 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 503, + 482 + ], + "score": 1.0, + "content": "make a compelling case for the TCN as the “first attempt” approach for many sequential problems.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 107, + 486, + 505, + 617 + ], + "lines": [ + { + "bbox": [ + 106, + 486, + 505, + 498 + ], + "spans": [ + { + "bbox": [ + 106, + 486, + 505, + 498 + ], + "score": 1.0, + "content": "All experiments reported in this section used the same TCN architecture, just varying the depth of the", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 496, + 505, + 510 + ], + "spans": [ + { + "bbox": [ + 105, + 496, + 402, + 510 + ], + "score": 1.0, + "content": "network and occasionally the kernel size. We use an exponential dilation", + "type": "text" + }, + { + "bbox": [ + 402, + 497, + 433, + 507 + ], + "score": 0.91, + "content": "d = 2 ^ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 433, + 496, + 471, + 510 + ], + "score": 1.0, + "content": "for layer", + "type": "text" + }, + { + "bbox": [ + 471, + 499, + 478, + 507 + ], + "score": 0.73, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 479, + 496, + 505, + 510 + ], + "score": 1.0, + "content": "in the", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 508, + 505, + 520 + ], + "spans": [ + { + "bbox": [ + 105, + 508, + 505, + 520 + ], + "score": 1.0, + "content": "network, and the Adam optimizer (Kingma & Ba, 2015) with learning rate 0.002 for TCN (unless", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 518, + 506, + 532 + ], + "spans": [ + { + "bbox": [ + 105, + 518, + 506, + 532 + ], + "score": 1.0, + "content": "otherwise noted). We also empirically find that gradient clipping helped training convergence of", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 529, + 505, + 542 + ], + "spans": [ + { + "bbox": [ + 106, + 529, + 505, + 542 + ], + "score": 1.0, + "content": "TCN, and we pick the maximum norm to clip from [0.3, 1]. When training recurrent models, we", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 541, + 506, + 553 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 506, + 553 + ], + "score": 1.0, + "content": "use a simple grid search to find a good set of hyperparameters (in particular, optimizer, recurrent", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 550, + 505, + 566 + ], + "spans": [ + { + "bbox": [ + 105, + 550, + 127, + 566 + ], + "score": 1.0, + "content": "drop", + "type": "text" + }, + { + "bbox": [ + 127, + 552, + 186, + 563 + ], + "score": 0.88, + "content": "p \\in [ 0 . 0 5 , 0 . 5 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 186, + 550, + 505, + 566 + ], + "score": 1.0, + "content": ", the learning rate, gradient clipping, and initial forget-gate bias), while keeping", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 561, + 506, + 576 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 506, + 576 + ], + "score": 1.0, + "content": "the network around the same size as TCN. No other optimizations, such as gating mechanism (see", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 574, + 506, + 586 + ], + "spans": [ + { + "bbox": [ + 106, + 574, + 506, + 586 + ], + "score": 1.0, + "content": "Appendix D), or highway network, were added to TCN or the RNNs. The hyperparameters we use", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 585, + 505, + 597 + ], + "spans": [ + { + "bbox": [ + 105, + 585, + 505, + 597 + ], + "score": 1.0, + "content": "for TCN on different tasks are reported in Table 2 in Appendix B. In addition, we conduct a series", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 596, + 506, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 596, + 506, + 608 + ], + "score": 1.0, + "content": "controlled experiments to investigate the effects of filter size and residual function on the TCN’s", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 607, + 335, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 607, + 335, + 618 + ], + "score": 1.0, + "content": "performance. These results can be found in Appendix C.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 33.5 + }, + { + "type": "title", + "bbox": [ + 108, + 633, + 269, + 645 + ], + "lines": [ + { + "bbox": [ + 106, + 633, + 271, + 646 + ], + "spans": [ + { + "bbox": [ + 106, + 633, + 271, + 646 + ], + "score": 1.0, + "content": "4.1 TASKS AND RESULTS SUMMARY", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 40 + }, + { + "type": "text", + "bbox": [ + 107, + 654, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 654, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 654, + 505, + 668 + ], + "score": 1.0, + "content": "In this section we highlight the general performance of generic TCNs vs generic LSTMs for a variety", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "score": 1.0, + "content": "of domains from the sequential modeling literature. A complete description of each task, as well", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "as references to some prior works that evaluated them, is given in Appendix A. In brief, the tasks", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 104, + 685, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 104, + 685, + 506, + 702 + ], + "score": 1.0, + "content": "we consider are: the adding problem, sequential MNIST, permuted MNIST (P-MNIST), the copy", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "score": 1.0, + "content": "memory task, the Nottingham and JSB Chorales polyphonic music tasks, Penn Treebank (PTB),", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "Wikitext-103 and LAMBADA word-level language modeling, as well as PTB and text8 character-", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 720, + 209, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 209, + 734 + ], + "score": 1.0, + "content": "level language modeling.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 44 + } + ], + "page_idx": 6, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "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": [ + 303, + 751, + 308, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 12, + "width": 7 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 142, + 82, + 504, + 116 + ], + "lines": [], + "index": 1, + "bbox_fs": [ + 141, + 82, + 505, + 117 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 107, + 131, + 342, + 142 + ], + "lines": [ + { + "bbox": [ + 105, + 130, + 343, + 145 + ], + "spans": [ + { + "bbox": [ + 105, + 130, + 343, + 145 + ], + "score": 1.0, + "content": "3.6 DISADVANTAGES OF TCN SEQUENCE MODELING", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 108, + 152, + 389, + 164 + ], + "lines": [ + { + "bbox": [ + 106, + 152, + 391, + 165 + ], + "spans": [ + { + "bbox": [ + 106, + 152, + 391, + 165 + ], + "score": 1.0, + "content": "We also summarize two disadvantages of using TCN instead of RNNs.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4, + "bbox_fs": [ + 106, + 152, + 391, + 165 + ] + }, + { + "type": "text", + "bbox": [ + 132, + 176, + 505, + 314 + ], + "lines": [ + { + "bbox": [ + 132, + 176, + 505, + 188 + ], + "spans": [ + { + "bbox": [ + 132, + 176, + 505, + 188 + ], + "score": 1.0, + "content": "• Data storage in evaluation. In evaluation/testing, RNNs only need to maintain a hidden", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 141, + 187, + 506, + 199 + ], + "spans": [ + { + "bbox": [ + 141, + 187, + 277, + 199 + ], + "score": 1.0, + "content": "state and take in a current input", + "type": "text" + }, + { + "bbox": [ + 277, + 189, + 288, + 198 + ], + "score": 0.84, + "content": "x _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 288, + 187, + 506, + 199 + ], + "score": 1.0, + "content": "in order to generate a prediction. In other words, a", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 198, + 506, + 211 + ], + "spans": [ + { + "bbox": [ + 141, + 198, + 462, + 211 + ], + "score": 1.0, + "content": "“summary” of the entire history is provided by the fixed-length set of vectors", + "type": "text" + }, + { + "bbox": [ + 463, + 198, + 473, + 209 + ], + "score": 0.88, + "content": "h _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 473, + 198, + 506, + 211 + ], + "score": 1.0, + "content": ", which", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 209, + 506, + 222 + ], + "spans": [ + { + "bbox": [ + 141, + 209, + 506, + 222 + ], + "score": 1.0, + "content": "means that the actual observed sequence can be discarded (and indeed, the hidden state can", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 142, + 221, + 505, + 232 + ], + "spans": [ + { + "bbox": [ + 142, + 221, + 505, + 232 + ], + "score": 1.0, + "content": "be used as a kind of encoder for all the observed history). In contrast, the TCN still needs", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 141, + 231, + 505, + 243 + ], + "spans": [ + { + "bbox": [ + 141, + 231, + 505, + 243 + ], + "score": 1.0, + "content": "to take in a sequence with non-trivial length (precisely the effective history length) in order", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 242, + 412, + 255 + ], + "spans": [ + { + "bbox": [ + 141, + 242, + 412, + 255 + ], + "score": 1.0, + "content": "to predict, thus possibly requiring more memory during evaluation.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 133, + 258, + 505, + 270 + ], + "spans": [ + { + "bbox": [ + 133, + 258, + 505, + 270 + ], + "score": 1.0, + "content": "• Potential parameter change for a transfer of domain. Different domains can have dif-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 268, + 506, + 282 + ], + "spans": [ + { + "bbox": [ + 141, + 268, + 506, + 282 + ], + "score": 1.0, + "content": "ferent requirements on the amount of history the model needs to memorize. Therefore,", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 281, + 504, + 293 + ], + "spans": [ + { + "bbox": [ + 141, + 281, + 497, + 293 + ], + "score": 1.0, + "content": "when transferring a model from a domain where only little memory is needed (i.e., small", + "type": "text" + }, + { + "bbox": [ + 497, + 281, + 504, + 290 + ], + "score": 0.78, + "content": "k", + "type": "inline_equation" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 291, + 506, + 304 + ], + "spans": [ + { + "bbox": [ + 141, + 291, + 159, + 304 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 159, + 292, + 166, + 302 + ], + "score": 0.62, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 166, + 291, + 444, + 304 + ], + "score": 1.0, + "content": ") to a domain where much larger memory is required (i.e., much larger", + "type": "text" + }, + { + "bbox": [ + 445, + 292, + 452, + 301 + ], + "score": 0.8, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 291, + 469, + 304 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 469, + 292, + 477, + 302 + ], + "score": 0.73, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 477, + 291, + 506, + 304 + ], + "score": 1.0, + "content": "), TCN", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 303, + 421, + 315 + ], + "spans": [ + { + "bbox": [ + 141, + 303, + 421, + 315 + ], + "score": 1.0, + "content": "may perform poorly for not having a sufficiently large receptive field.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 10.5, + "bbox_fs": [ + 132, + 176, + 506, + 315 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 325, + 504, + 359 + ], + "lines": [ + { + "bbox": [ + 106, + 325, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 106, + 325, + 506, + 338 + ], + "score": 1.0, + "content": "We want to emphasize, though, that we believe the notable lack of “infinite memory” for a TCN is", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 337, + 504, + 349 + ], + "spans": [ + { + "bbox": [ + 106, + 337, + 504, + 349 + ], + "score": 1.0, + "content": "decidedly not a practical disadvantage, since, as we show in Section 4, the TCN method actually", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 347, + 439, + 360 + ], + "spans": [ + { + "bbox": [ + 106, + 347, + 439, + 360 + ], + "score": 1.0, + "content": "outperforms RNNs in terms of the ability to deal with long temporal dependencies.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18, + "bbox_fs": [ + 106, + 325, + 506, + 360 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 377, + 200, + 389 + ], + "lines": [ + { + "bbox": [ + 105, + 376, + 201, + 391 + ], + "spans": [ + { + "bbox": [ + 105, + 376, + 201, + 391 + ], + "score": 1.0, + "content": "4 EXPERIMENTS", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 107, + 403, + 505, + 480 + ], + "lines": [ + { + "bbox": [ + 105, + 403, + 505, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 403, + 505, + 416 + ], + "score": 1.0, + "content": "In this section, we conduct a series of experiments using the baseline TCN (described in section 3)", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 414, + 505, + 427 + ], + "spans": [ + { + "bbox": [ + 105, + 414, + 505, + 427 + ], + "score": 1.0, + "content": "and generic RNNs (namely LSTMs, GRUs, and vanilla RNNs). These experiments cover tasks and", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 424, + 505, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 424, + 505, + 439 + ], + "score": 1.0, + "content": "datasets from various domains, aiming to test different aspects of a model’s ability to learn sequence", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 435, + 505, + 449 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 505, + 449 + ], + "score": 1.0, + "content": "modeling. In several cases, specialized RNN models, or methods with particular forms of regulariza-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 447, + 505, + 460 + ], + "spans": [ + { + "bbox": [ + 105, + 447, + 505, + 460 + ], + "score": 1.0, + "content": "tion can indeed vastly outperform both generic RNNs and the TCN on particular problems, which", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 457, + 506, + 471 + ], + "spans": [ + { + "bbox": [ + 105, + 457, + 506, + 471 + ], + "score": 1.0, + "content": "we highlight when applicable. But as a general-purpose architecture, we believe the experiments", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 469, + 503, + 482 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 503, + 482 + ], + "score": 1.0, + "content": "make a compelling case for the TCN as the “first attempt” approach for many sequential problems.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 24, + "bbox_fs": [ + 105, + 403, + 506, + 482 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 486, + 505, + 617 + ], + "lines": [ + { + "bbox": [ + 106, + 486, + 505, + 498 + ], + "spans": [ + { + "bbox": [ + 106, + 486, + 505, + 498 + ], + "score": 1.0, + "content": "All experiments reported in this section used the same TCN architecture, just varying the depth of the", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 496, + 505, + 510 + ], + "spans": [ + { + "bbox": [ + 105, + 496, + 402, + 510 + ], + "score": 1.0, + "content": "network and occasionally the kernel size. We use an exponential dilation", + "type": "text" + }, + { + "bbox": [ + 402, + 497, + 433, + 507 + ], + "score": 0.91, + "content": "d = 2 ^ { n }", + "type": "inline_equation" + }, + { + "bbox": [ + 433, + 496, + 471, + 510 + ], + "score": 1.0, + "content": "for layer", + "type": "text" + }, + { + "bbox": [ + 471, + 499, + 478, + 507 + ], + "score": 0.73, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 479, + 496, + 505, + 510 + ], + "score": 1.0, + "content": "in the", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 508, + 505, + 520 + ], + "spans": [ + { + "bbox": [ + 105, + 508, + 505, + 520 + ], + "score": 1.0, + "content": "network, and the Adam optimizer (Kingma & Ba, 2015) with learning rate 0.002 for TCN (unless", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 518, + 506, + 532 + ], + "spans": [ + { + "bbox": [ + 105, + 518, + 506, + 532 + ], + "score": 1.0, + "content": "otherwise noted). We also empirically find that gradient clipping helped training convergence of", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 529, + 505, + 542 + ], + "spans": [ + { + "bbox": [ + 106, + 529, + 505, + 542 + ], + "score": 1.0, + "content": "TCN, and we pick the maximum norm to clip from [0.3, 1]. When training recurrent models, we", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 541, + 506, + 553 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 506, + 553 + ], + "score": 1.0, + "content": "use a simple grid search to find a good set of hyperparameters (in particular, optimizer, recurrent", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 550, + 505, + 566 + ], + "spans": [ + { + "bbox": [ + 105, + 550, + 127, + 566 + ], + "score": 1.0, + "content": "drop", + "type": "text" + }, + { + "bbox": [ + 127, + 552, + 186, + 563 + ], + "score": 0.88, + "content": "p \\in [ 0 . 0 5 , 0 . 5 ]", + "type": "inline_equation" + }, + { + "bbox": [ + 186, + 550, + 505, + 566 + ], + "score": 1.0, + "content": ", the learning rate, gradient clipping, and initial forget-gate bias), while keeping", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 561, + 506, + 576 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 506, + 576 + ], + "score": 1.0, + "content": "the network around the same size as TCN. No other optimizations, such as gating mechanism (see", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 574, + 506, + 586 + ], + "spans": [ + { + "bbox": [ + 106, + 574, + 506, + 586 + ], + "score": 1.0, + "content": "Appendix D), or highway network, were added to TCN or the RNNs. The hyperparameters we use", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 585, + 505, + 597 + ], + "spans": [ + { + "bbox": [ + 105, + 585, + 505, + 597 + ], + "score": 1.0, + "content": "for TCN on different tasks are reported in Table 2 in Appendix B. In addition, we conduct a series", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 596, + 506, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 596, + 506, + 608 + ], + "score": 1.0, + "content": "controlled experiments to investigate the effects of filter size and residual function on the TCN’s", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 607, + 335, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 607, + 335, + 618 + ], + "score": 1.0, + "content": "performance. These results can be found in Appendix C.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 33.5, + "bbox_fs": [ + 105, + 486, + 506, + 618 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 633, + 269, + 645 + ], + "lines": [ + { + "bbox": [ + 106, + 633, + 271, + 646 + ], + "spans": [ + { + "bbox": [ + 106, + 633, + 271, + 646 + ], + "score": 1.0, + "content": "4.1 TASKS AND RESULTS SUMMARY", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 40 + }, + { + "type": "text", + "bbox": [ + 107, + 654, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 654, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 654, + 505, + 668 + ], + "score": 1.0, + "content": "In this section we highlight the general performance of generic TCNs vs generic LSTMs for a variety", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 505, + 678 + ], + "score": 1.0, + "content": "of domains from the sequential modeling literature. A complete description of each task, as well", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "as references to some prior works that evaluated them, is given in Appendix A. In brief, the tasks", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 104, + 685, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 104, + 685, + 506, + 702 + ], + "score": 1.0, + "content": "we consider are: the adding problem, sequential MNIST, permuted MNIST (P-MNIST), the copy", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "score": 1.0, + "content": "memory task, the Nottingham and JSB Chorales polyphonic music tasks, Penn Treebank (PTB),", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "Wikitext-103 and LAMBADA word-level language modeling, as well as PTB and text8 character-", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 720, + 209, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 209, + 734 + ], + "score": 1.0, + "content": "level language modeling.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 44, + "bbox_fs": [ + 104, + 654, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 108, + 101, + 503, + 280 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 108, + 80, + 498, + 92 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 79, + 498, + 93 + ], + "spans": [ + { + "bbox": [ + 109, + 79, + 498, + 93 + ], + "score": 1.0, + "content": "Table 1: Complete comparison of the TCN to regularized recurrent architectures in various tasks.", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table_body", + "bbox": [ + 108, + 101, + 503, + 280 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 101, + 503, + 280 + ], + "spans": [ + { + "bbox": [ + 108, + 101, + 503, + 280 + ], + "score": 0.874, + "html": "
Sequential TasksModel Size (≈)Models
LSTMGRURNNTCN (ours)
Seq. MNIST (accuracy)70K87.296.221.599.0
P-Seq. MNIST (accuracy)70K85.787.325.397.2
The Adding Problem T=600 (loss)70K0.1645.3e-50.1775.8e-5
Copy Memory T=1000 (loss)16K0.02040.019713.5e-5
Music JSB Chorales (loss)300K8.458.438.918.10
Music Nottingham (loss)1M3.293.46-3.07
Word-level PTB (ppl)13M84.7792.48114.5090.17
Word-level Wiki-103 (ppl)-48.4 (large)-145.19
Word-level LAMBADA (ppl)-4186-147251279
Char-level PTB (bpc)3M1.411.421.521.35
Char-level text8 (bpc)5M1.521.561.691.45
", + "type": "table", + "image_path": "485ef4d84d63fbb7a42ef34ab9f14eb9b1e460efa37c5d30a34144e32499ce5c.jpg" + } + ] + } + ], + "index": 2, + "virtual_lines": [ + { + "bbox": [ + 108, + 101, + 503, + 160.66666666666666 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 108, + 160.66666666666666, + 503, + 220.33333333333331 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 108, + 220.33333333333331, + 503, + 280.0 + ], + "spans": [], + "index": 3 + } + ] + } + ], + "index": 1.0 + }, + { + "type": "image", + "bbox": [ + 106, + 295, + 509, + 412 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 295, + 509, + 412 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 295, + 509, + 412 + ], + "spans": [ + { + "bbox": [ + 106, + 295, + 509, + 412 + ], + "score": 0.933, + "type": "image", + "image_path": "ea6a8e859d355bb1c75732fd3c99b5619813b7328366f413036a0d184b56a648.jpg" + } + ] + } + ], + "index": 5, + "virtual_lines": [ + { + "bbox": [ + 106, + 295, + 509, + 334.0 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 106, + 334.0, + 509, + 373.0 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 106, + 373.0, + 509, + 412.0 + ], + "spans": [], + "index": 6 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 152, + 421, + 455, + 433 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 152, + 420, + 456, + 434 + ], + "spans": [ + { + "bbox": [ + 152, + 420, + 456, + 434 + ], + "score": 1.0, + "content": "Figure 4: Results of TCN vs. recurrent architectures on the adding problem", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + } + ], + "index": 6.0 + }, + { + "type": "text", + "bbox": [ + 106, + 448, + 505, + 537 + ], + "lines": [ + { + "bbox": [ + 105, + 448, + 506, + 461 + ], + "spans": [ + { + "bbox": [ + 105, + 448, + 506, + 461 + ], + "score": 1.0, + "content": "A summary comparison of TCNs to the standard RNN architectures (LSTM, GRU, and vanilla", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 459, + 505, + 471 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 505, + 471 + ], + "score": 1.0, + "content": "RNN) is shown in Table 1. We will highlight many of these results below, and want to emphasize", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 469, + 505, + 482 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 505, + 482 + ], + "score": 1.0, + "content": "that for several tasks the baseline RNN architectures are still far from the state of the art (see Table", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 482, + 504, + 494 + ], + "spans": [ + { + "bbox": [ + 106, + 482, + 504, + 494 + ], + "score": 1.0, + "content": "4), but in total the results make a strong case that the TCN architecture, as a generic sequence mod-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 492, + 505, + 505 + ], + "spans": [ + { + "bbox": [ + 106, + 492, + 505, + 505 + ], + "score": 1.0, + "content": "eling framework, is often superior to generic RNN approaches. We now consider several of these", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 503, + 506, + 516 + ], + "spans": [ + { + "bbox": [ + 105, + 503, + 506, + 516 + ], + "score": 1.0, + "content": "experiments in detail, generally distinguishing between the “recurrent benchmark” tasks designed", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 515, + 505, + 527 + ], + "spans": [ + { + "bbox": [ + 105, + 515, + 505, + 527 + ], + "score": 1.0, + "content": "to show the limitations of networks for sequence modeling (adding problem, sequential & permuted", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 525, + 477, + 538 + ], + "spans": [ + { + "bbox": [ + 105, + 525, + 477, + 538 + ], + "score": 1.0, + "content": "MNIST, copy memory), and the “applied” tasks (polyphonic music and language modeling).", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 11.5 + }, + { + "type": "title", + "bbox": [ + 108, + 551, + 262, + 562 + ], + "lines": [ + { + "bbox": [ + 106, + 551, + 263, + 563 + ], + "spans": [ + { + "bbox": [ + 106, + 551, + 263, + 563 + ], + "score": 1.0, + "content": "4.2 BASELINE RECURRENT TASKS", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 107, + 572, + 505, + 617 + ], + "lines": [ + { + "bbox": [ + 105, + 572, + 505, + 585 + ], + "spans": [ + { + "bbox": [ + 105, + 572, + 505, + 585 + ], + "score": 1.0, + "content": "We first compare the results of the TCN architecture to those of RNNs on the toy baseline tasks", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 583, + 506, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 583, + 506, + 596 + ], + "score": 1.0, + "content": "that have been frequently used to evaluate sequential modeling (Hochreiter & Schmidhuber, 1997;", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 593, + 506, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 593, + 506, + 608 + ], + "score": 1.0, + "content": "Martens & Sutskever, 2011; Pascanu et al., 2013; Le et al., 2015; Cooijmans et al., 2016; Zhang", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 605, + 418, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 418, + 618 + ], + "score": 1.0, + "content": "et al., 2016; Krueger et al., 2017; Wisdom et al., 2016; Arjovsky et al., 2016).", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 18.5 + }, + { + "type": "text", + "bbox": [ + 107, + 630, + 505, + 685 + ], + "lines": [ + { + "bbox": [ + 105, + 629, + 504, + 644 + ], + "spans": [ + { + "bbox": [ + 105, + 629, + 480, + 644 + ], + "score": 1.0, + "content": "The Adding Problem. Convergence results for the adding problem, for problem sizes", + "type": "text" + }, + { + "bbox": [ + 481, + 630, + 504, + 641 + ], + "score": 0.86, + "content": "T =", + "type": "inline_equation" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 640, + 504, + 653 + ], + "spans": [ + { + "bbox": [ + 105, + 640, + 504, + 653 + ], + "score": 1.0, + "content": "200, 400, 600, are shown in Figure 4; all models were chosen to have roughly 70K parameters.", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 652, + 505, + 665 + ], + "spans": [ + { + "bbox": [ + 105, + 652, + 505, + 665 + ], + "score": 1.0, + "content": "In all three cases, TCNs quickly converged to a virtually perfect solution (i.e., an MSE loss very", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 663, + 505, + 675 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 505, + 675 + ], + "score": 1.0, + "content": "close to 0). LSTMs and vanilla RNNs performed significantly worse, while on this task GRUs also", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 674, + 446, + 687 + ], + "spans": [ + { + "bbox": [ + 105, + 674, + 446, + 687 + ], + "score": 1.0, + "content": "performed quite well, even though their convergence was slightly slower than TCNs.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "Sequential MNIST and P-MNIST. Results on sequential and permuted MNIST, run over 10", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "epochs, are shown in Figures 5a and 5b; all models were picked to have roughly 70K parameters.", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 720, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 733 + ], + "score": 1.0, + "content": "For both problems, TCNs substantially outperform the alternative architectures, both in terms of con-", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27 + } + ], + "page_idx": 7, + "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, + 752, + 308, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 761 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 761 + ], + "score": 1.0, + "content": "8", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 108, + 101, + 503, + 280 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 108, + 80, + 498, + 92 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 79, + 498, + 93 + ], + "spans": [ + { + "bbox": [ + 109, + 79, + 498, + 93 + ], + "score": 1.0, + "content": "Table 1: Complete comparison of the TCN to regularized recurrent architectures in various tasks.", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table_body", + "bbox": [ + 108, + 101, + 503, + 280 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 101, + 503, + 280 + ], + "spans": [ + { + "bbox": [ + 108, + 101, + 503, + 280 + ], + "score": 0.874, + "html": "
Sequential TasksModel Size (≈)Models
LSTMGRURNNTCN (ours)
Seq. MNIST (accuracy)70K87.296.221.599.0
P-Seq. MNIST (accuracy)70K85.787.325.397.2
The Adding Problem T=600 (loss)70K0.1645.3e-50.1775.8e-5
Copy Memory T=1000 (loss)16K0.02040.019713.5e-5
Music JSB Chorales (loss)300K8.458.438.918.10
Music Nottingham (loss)1M3.293.46-3.07
Word-level PTB (ppl)13M84.7792.48114.5090.17
Word-level Wiki-103 (ppl)-48.4 (large)-145.19
Word-level LAMBADA (ppl)-4186-147251279
Char-level PTB (bpc)3M1.411.421.521.35
Char-level text8 (bpc)5M1.521.561.691.45
", + "type": "table", + "image_path": "485ef4d84d63fbb7a42ef34ab9f14eb9b1e460efa37c5d30a34144e32499ce5c.jpg" + } + ] + } + ], + "index": 2, + "virtual_lines": [ + { + "bbox": [ + 108, + 101, + 503, + 160.66666666666666 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 108, + 160.66666666666666, + 503, + 220.33333333333331 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 108, + 220.33333333333331, + 503, + 280.0 + ], + "spans": [], + "index": 3 + } + ] + } + ], + "index": 1.0 + }, + { + "type": "image", + "bbox": [ + 106, + 295, + 509, + 412 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 295, + 509, + 412 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 295, + 509, + 412 + ], + "spans": [ + { + "bbox": [ + 106, + 295, + 509, + 412 + ], + "score": 0.933, + "type": "image", + "image_path": "ea6a8e859d355bb1c75732fd3c99b5619813b7328366f413036a0d184b56a648.jpg" + } + ] + } + ], + "index": 5, + "virtual_lines": [ + { + "bbox": [ + 106, + 295, + 509, + 334.0 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 106, + 334.0, + 509, + 373.0 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 106, + 373.0, + 509, + 412.0 + ], + "spans": [], + "index": 6 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 152, + 421, + 455, + 433 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 152, + 420, + 456, + 434 + ], + "spans": [ + { + "bbox": [ + 152, + 420, + 456, + 434 + ], + "score": 1.0, + "content": "Figure 4: Results of TCN vs. recurrent architectures on the adding problem", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + } + ], + "index": 6.0 + }, + { + "type": "text", + "bbox": [ + 106, + 448, + 505, + 537 + ], + "lines": [ + { + "bbox": [ + 105, + 448, + 506, + 461 + ], + "spans": [ + { + "bbox": [ + 105, + 448, + 506, + 461 + ], + "score": 1.0, + "content": "A summary comparison of TCNs to the standard RNN architectures (LSTM, GRU, and vanilla", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 459, + 505, + 471 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 505, + 471 + ], + "score": 1.0, + "content": "RNN) is shown in Table 1. We will highlight many of these results below, and want to emphasize", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 469, + 505, + 482 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 505, + 482 + ], + "score": 1.0, + "content": "that for several tasks the baseline RNN architectures are still far from the state of the art (see Table", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 482, + 504, + 494 + ], + "spans": [ + { + "bbox": [ + 106, + 482, + 504, + 494 + ], + "score": 1.0, + "content": "4), but in total the results make a strong case that the TCN architecture, as a generic sequence mod-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 492, + 505, + 505 + ], + "spans": [ + { + "bbox": [ + 106, + 492, + 505, + 505 + ], + "score": 1.0, + "content": "eling framework, is often superior to generic RNN approaches. We now consider several of these", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 503, + 506, + 516 + ], + "spans": [ + { + "bbox": [ + 105, + 503, + 506, + 516 + ], + "score": 1.0, + "content": "experiments in detail, generally distinguishing between the “recurrent benchmark” tasks designed", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 515, + 505, + 527 + ], + "spans": [ + { + "bbox": [ + 105, + 515, + 505, + 527 + ], + "score": 1.0, + "content": "to show the limitations of networks for sequence modeling (adding problem, sequential & permuted", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 525, + 477, + 538 + ], + "spans": [ + { + "bbox": [ + 105, + 525, + 477, + 538 + ], + "score": 1.0, + "content": "MNIST, copy memory), and the “applied” tasks (polyphonic music and language modeling).", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 11.5, + "bbox_fs": [ + 105, + 448, + 506, + 538 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 551, + 262, + 562 + ], + "lines": [ + { + "bbox": [ + 106, + 551, + 263, + 563 + ], + "spans": [ + { + "bbox": [ + 106, + 551, + 263, + 563 + ], + "score": 1.0, + "content": "4.2 BASELINE RECURRENT TASKS", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 107, + 572, + 505, + 617 + ], + "lines": [ + { + "bbox": [ + 105, + 572, + 505, + 585 + ], + "spans": [ + { + "bbox": [ + 105, + 572, + 505, + 585 + ], + "score": 1.0, + "content": "We first compare the results of the TCN architecture to those of RNNs on the toy baseline tasks", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 583, + 506, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 583, + 506, + 596 + ], + "score": 1.0, + "content": "that have been frequently used to evaluate sequential modeling (Hochreiter & Schmidhuber, 1997;", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 593, + 506, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 593, + 506, + 608 + ], + "score": 1.0, + "content": "Martens & Sutskever, 2011; Pascanu et al., 2013; Le et al., 2015; Cooijmans et al., 2016; Zhang", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 605, + 418, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 418, + 618 + ], + "score": 1.0, + "content": "et al., 2016; Krueger et al., 2017; Wisdom et al., 2016; Arjovsky et al., 2016).", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 18.5, + "bbox_fs": [ + 105, + 572, + 506, + 618 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 630, + 505, + 685 + ], + "lines": [ + { + "bbox": [ + 105, + 629, + 504, + 644 + ], + "spans": [ + { + "bbox": [ + 105, + 629, + 480, + 644 + ], + "score": 1.0, + "content": "The Adding Problem. Convergence results for the adding problem, for problem sizes", + "type": "text" + }, + { + "bbox": [ + 481, + 630, + 504, + 641 + ], + "score": 0.86, + "content": "T =", + "type": "inline_equation" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 640, + 504, + 653 + ], + "spans": [ + { + "bbox": [ + 105, + 640, + 504, + 653 + ], + "score": 1.0, + "content": "200, 400, 600, are shown in Figure 4; all models were chosen to have roughly 70K parameters.", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 652, + 505, + 665 + ], + "spans": [ + { + "bbox": [ + 105, + 652, + 505, + 665 + ], + "score": 1.0, + "content": "In all three cases, TCNs quickly converged to a virtually perfect solution (i.e., an MSE loss very", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 663, + 505, + 675 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 505, + 675 + ], + "score": 1.0, + "content": "close to 0). LSTMs and vanilla RNNs performed significantly worse, while on this task GRUs also", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 674, + 446, + 687 + ], + "spans": [ + { + "bbox": [ + 105, + 674, + 446, + 687 + ], + "score": 1.0, + "content": "performed quite well, even though their convergence was slightly slower than TCNs.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23, + "bbox_fs": [ + 105, + 629, + 505, + 687 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "Sequential MNIST and P-MNIST. Results on sequential and permuted MNIST, run over 10", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "epochs, are shown in Figures 5a and 5b; all models were picked to have roughly 70K parameters.", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 720, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 733 + ], + "score": 1.0, + "content": "For both problems, TCNs substantially outperform the alternative architectures, both in terms of con-", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 417, + 505, + 430 + ], + "spans": [ + { + "bbox": [ + 106, + 417, + 505, + 430 + ], + "score": 1.0, + "content": "vergence time and final performance level on the task. For the permuted sequential MNIST, TCNs", + "type": "text", + "cross_page": true + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 429, + 505, + 441 + ], + "spans": [ + { + "bbox": [ + 106, + 429, + 321, + 441 + ], + "score": 1.0, + "content": "outperform state of the art results using recurrent nets", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 321, + 429, + 354, + 440 + ], + "score": 0.87, + "content": "( 9 5 . 9 \\% )", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 354, + 429, + 505, + 441 + ], + "score": 1.0, + "content": "with Zoneout+Recurrent BatchNorm", + "type": "text", + "cross_page": true + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 439, + 497, + 452 + ], + "spans": [ + { + "bbox": [ + 106, + 439, + 497, + 452 + ], + "score": 1.0, + "content": "(Cooijmans et al., 2016; Krueger et al., 2017), a highly optimized method for regularizing RNNs.", + "type": "text", + "cross_page": true + } + ], + "index": 10 + } + ], + "index": 27, + "bbox_fs": [ + 105, + 698, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 118, + 77, + 489, + 236 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 118, + 77, + 489, + 236 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 118, + 77, + 489, + 236 + ], + "spans": [ + { + "bbox": [ + 118, + 77, + 489, + 236 + ], + "score": 0.953, + "type": "image", + "image_path": "404df7deb85ffa4ae5c1945673693b1c2d442023841918eb5df6debfac1e9251.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 118, + 77, + 489, + 130.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 118, + 130.0, + 489, + 183.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 118, + 183.0, + 489, + 236.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 114, + 242, + 494, + 254 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 117, + 240, + 494, + 255 + ], + "spans": [ + { + "bbox": [ + 117, + 240, + 494, + 255 + ], + "score": 1.0, + "content": "Figure 5: Results of TCN vs. recurrent architectures on the Sequential MNIST and P-MNIST", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "image", + "bbox": [ + 106, + 264, + 503, + 378 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 264, + 503, + 378 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 264, + 503, + 378 + ], + "spans": [ + { + "bbox": [ + 106, + 264, + 503, + 378 + ], + "score": 0.959, + "type": "image", + "image_path": "4cc3f571686b4edc1e41610e5d0966fcd5f75e40a815be1d639a5bcb8bd1de0b.jpg" + } + ] + } + ], + "index": 5, + "virtual_lines": [ + { + "bbox": [ + 106, + 264, + 503, + 302.0 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 106, + 302.0, + 503, + 340.0 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 106, + 340.0, + 503, + 378.0 + ], + "spans": [], + "index": 6 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 112, + 384, + 492, + 396 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 114, + 382, + 493, + 397 + ], + "spans": [ + { + "bbox": [ + 114, + 382, + 484, + 397 + ], + "score": 1.0, + "content": "Figure 6: Result of TCN vs. recurrent architectures on the Copy Memory Task, for different", + "type": "text" + }, + { + "bbox": [ + 484, + 384, + 493, + 394 + ], + "score": 0.74, + "content": "T", + "type": "inline_equation" + } + ], + "index": 7 + } + ], + "index": 7 + } + ], + "index": 6.0 + }, + { + "type": "text", + "bbox": [ + 107, + 417, + 505, + 451 + ], + "lines": [ + { + "bbox": [ + 106, + 417, + 505, + 430 + ], + "spans": [ + { + "bbox": [ + 106, + 417, + 505, + 430 + ], + "score": 1.0, + "content": "vergence time and final performance level on the task. For the permuted sequential MNIST, TCNs", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 429, + 505, + 441 + ], + "spans": [ + { + "bbox": [ + 106, + 429, + 321, + 441 + ], + "score": 1.0, + "content": "outperform state of the art results using recurrent nets", + "type": "text" + }, + { + "bbox": [ + 321, + 429, + 354, + 440 + ], + "score": 0.87, + "content": "( 9 5 . 9 \\% )", + "type": "inline_equation" + }, + { + "bbox": [ + 354, + 429, + 505, + 441 + ], + "score": 1.0, + "content": "with Zoneout+Recurrent BatchNorm", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 439, + 497, + 452 + ], + "spans": [ + { + "bbox": [ + 106, + 439, + 497, + 452 + ], + "score": 1.0, + "content": "(Cooijmans et al., 2016; Krueger et al., 2017), a highly optimized method for regularizing RNNs.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 107, + 463, + 505, + 529 + ], + "lines": [ + { + "bbox": [ + 105, + 463, + 505, + 476 + ], + "spans": [ + { + "bbox": [ + 105, + 463, + 505, + 476 + ], + "score": 1.0, + "content": "Copy Memory Task. Finally, Figure 6 shows the results of the different methods (with roughly", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 474, + 505, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 474, + 505, + 488 + ], + "score": 1.0, + "content": "the same size) on the copy memory task. Again, the TCNs quickly converge to correct answers,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 485, + 506, + 498 + ], + "spans": [ + { + "bbox": [ + 105, + 485, + 506, + 498 + ], + "score": 1.0, + "content": "while the LSTM and GRU simply converge to the same loss as predicting all zeros. In this case we", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 496, + 505, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 496, + 505, + 509 + ], + "score": 1.0, + "content": "also compare to the recently-proposed EURNN (Jing et al., 2017), which was highlighted to perform", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 507, + 505, + 519 + ], + "spans": [ + { + "bbox": [ + 106, + 508, + 358, + 519 + ], + "score": 1.0, + "content": "well on this task. While both perform well for sequence length", + "type": "text" + }, + { + "bbox": [ + 359, + 507, + 396, + 518 + ], + "score": 0.9, + "content": "T = 5 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 396, + 508, + 505, + 519 + ], + "score": 1.0, + "content": ", the TCN again has a clear", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 518, + 428, + 531 + ], + "spans": [ + { + "bbox": [ + 106, + 518, + 163, + 531 + ], + "score": 1.0, + "content": "advantage for", + "type": "text" + }, + { + "bbox": [ + 163, + 519, + 205, + 529 + ], + "score": 0.9, + "content": "T = 1 0 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 518, + 223, + 531 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 223, + 519, + 265, + 529 + ], + "score": 0.89, + "content": "T = 2 0 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 265, + 518, + 428, + 531 + ], + "score": 1.0, + "content": "(in terms of both loss and convergence).", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 13.5 + }, + { + "type": "title", + "bbox": [ + 107, + 543, + 398, + 555 + ], + "lines": [ + { + "bbox": [ + 105, + 543, + 400, + 557 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 400, + 557 + ], + "score": 1.0, + "content": "4.3 RESULTS ON POLYPHONIC MUSIC AND LANGUAGE MODELING", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 106, + 564, + 505, + 653 + ], + "lines": [ + { + "bbox": [ + 106, + 565, + 505, + 577 + ], + "spans": [ + { + "bbox": [ + 106, + 565, + 505, + 577 + ], + "score": 1.0, + "content": "Next, we compare the results of the TCN architecture to recurrent architectures on 6 different real", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 576, + 505, + 588 + ], + "spans": [ + { + "bbox": [ + 106, + 576, + 505, + 588 + ], + "score": 1.0, + "content": "datasets in polyphonic music as well as word- and character-level language modeling. These are", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 587, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 505, + 599 + ], + "score": 1.0, + "content": "areas where sequence modeling has been used most frequently. As domains where there is consider-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 104, + 596, + 506, + 612 + ], + "spans": [ + { + "bbox": [ + 104, + 596, + 506, + 612 + ], + "score": 1.0, + "content": "able practical interests, there have also been many specialized RNNs developed for these tasks (e.g.,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 609, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 105, + 609, + 505, + 621 + ], + "score": 1.0, + "content": "Zhang et al. (2016); Ha et al. (2017); Krueger et al. (2017); Grave et al. (2016); Greff et al. (2017);", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 104, + 619, + 506, + 633 + ], + "spans": [ + { + "bbox": [ + 104, + 619, + 506, + 633 + ], + "score": 1.0, + "content": "Merity et al. (2017)). We mention some of these comparisons when useful, but the primary goal", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 104, + 630, + 505, + 645 + ], + "spans": [ + { + "bbox": [ + 104, + 630, + 505, + 645 + ], + "score": 1.0, + "content": "here is to compare the generic TCN model to other generic RNN architectures, so we focus mainly", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 641, + 197, + 655 + ], + "spans": [ + { + "bbox": [ + 105, + 641, + 197, + 655 + ], + "score": 1.0, + "content": "on these comparisons.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 21.5 + }, + { + "type": "text", + "bbox": [ + 107, + 666, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 665, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 506, + 678 + ], + "score": 1.0, + "content": "Polyphonic Music. On the Nottingham and JSB Chorales datasets, the TCN with virtually no", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 677, + 506, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 689 + ], + "score": 1.0, + "content": "tuning is again able to beat the other models by a considerable margin (see Table 1), and even out-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 688, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 505, + 700 + ], + "score": 1.0, + "content": "performs some improved recurrent models for this task such as HF-RNN (Boulanger-Lewandowski", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "score": 1.0, + "content": "et al., 2012) and Diagonal RNN (Subakan & Smaragdis, 2017). Note however that other models", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "such as the Deep Belief Net LSTM (Vohra et al., 2015) perform substantially better on this task;", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "score": 1.0, + "content": "we believe this is likely due to the fact that the datasets involved in polyphonic music are relatively", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 28.5 + } + ], + "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": [ + 118, + 77, + 489, + 236 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 118, + 77, + 489, + 236 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 118, + 77, + 489, + 236 + ], + "spans": [ + { + "bbox": [ + 118, + 77, + 489, + 236 + ], + "score": 0.953, + "type": "image", + "image_path": "404df7deb85ffa4ae5c1945673693b1c2d442023841918eb5df6debfac1e9251.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 118, + 77, + 489, + 130.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 118, + 130.0, + 489, + 183.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 118, + 183.0, + 489, + 236.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 114, + 242, + 494, + 254 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 117, + 240, + 494, + 255 + ], + "spans": [ + { + "bbox": [ + 117, + 240, + 494, + 255 + ], + "score": 1.0, + "content": "Figure 5: Results of TCN vs. recurrent architectures on the Sequential MNIST and P-MNIST", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "image", + "bbox": [ + 106, + 264, + 503, + 378 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 264, + 503, + 378 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 264, + 503, + 378 + ], + "spans": [ + { + "bbox": [ + 106, + 264, + 503, + 378 + ], + "score": 0.959, + "type": "image", + "image_path": "4cc3f571686b4edc1e41610e5d0966fcd5f75e40a815be1d639a5bcb8bd1de0b.jpg" + } + ] + } + ], + "index": 5, + "virtual_lines": [ + { + "bbox": [ + 106, + 264, + 503, + 302.0 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 106, + 302.0, + 503, + 340.0 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 106, + 340.0, + 503, + 378.0 + ], + "spans": [], + "index": 6 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 112, + 384, + 492, + 396 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 114, + 382, + 493, + 397 + ], + "spans": [ + { + "bbox": [ + 114, + 382, + 484, + 397 + ], + "score": 1.0, + "content": "Figure 6: Result of TCN vs. recurrent architectures on the Copy Memory Task, for different", + "type": "text" + }, + { + "bbox": [ + 484, + 384, + 493, + 394 + ], + "score": 0.74, + "content": "T", + "type": "inline_equation" + } + ], + "index": 7 + } + ], + "index": 7 + } + ], + "index": 6.0 + }, + { + "type": "text", + "bbox": [ + 107, + 417, + 505, + 451 + ], + "lines": [], + "index": 9, + "bbox_fs": [ + 106, + 417, + 505, + 452 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 463, + 505, + 529 + ], + "lines": [ + { + "bbox": [ + 105, + 463, + 505, + 476 + ], + "spans": [ + { + "bbox": [ + 105, + 463, + 505, + 476 + ], + "score": 1.0, + "content": "Copy Memory Task. Finally, Figure 6 shows the results of the different methods (with roughly", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 474, + 505, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 474, + 505, + 488 + ], + "score": 1.0, + "content": "the same size) on the copy memory task. Again, the TCNs quickly converge to correct answers,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 485, + 506, + 498 + ], + "spans": [ + { + "bbox": [ + 105, + 485, + 506, + 498 + ], + "score": 1.0, + "content": "while the LSTM and GRU simply converge to the same loss as predicting all zeros. In this case we", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 496, + 505, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 496, + 505, + 509 + ], + "score": 1.0, + "content": "also compare to the recently-proposed EURNN (Jing et al., 2017), which was highlighted to perform", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 507, + 505, + 519 + ], + "spans": [ + { + "bbox": [ + 106, + 508, + 358, + 519 + ], + "score": 1.0, + "content": "well on this task. While both perform well for sequence length", + "type": "text" + }, + { + "bbox": [ + 359, + 507, + 396, + 518 + ], + "score": 0.9, + "content": "T = 5 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 396, + 508, + 505, + 519 + ], + "score": 1.0, + "content": ", the TCN again has a clear", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 518, + 428, + 531 + ], + "spans": [ + { + "bbox": [ + 106, + 518, + 163, + 531 + ], + "score": 1.0, + "content": "advantage for", + "type": "text" + }, + { + "bbox": [ + 163, + 519, + 205, + 529 + ], + "score": 0.9, + "content": "T = 1 0 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 518, + 223, + 531 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 223, + 519, + 265, + 529 + ], + "score": 0.89, + "content": "T = 2 0 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 265, + 518, + 428, + 531 + ], + "score": 1.0, + "content": "(in terms of both loss and convergence).", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 13.5, + "bbox_fs": [ + 105, + 463, + 506, + 531 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 543, + 398, + 555 + ], + "lines": [ + { + "bbox": [ + 105, + 543, + 400, + 557 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 400, + 557 + ], + "score": 1.0, + "content": "4.3 RESULTS ON POLYPHONIC MUSIC AND LANGUAGE MODELING", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 106, + 564, + 505, + 653 + ], + "lines": [ + { + "bbox": [ + 106, + 565, + 505, + 577 + ], + "spans": [ + { + "bbox": [ + 106, + 565, + 505, + 577 + ], + "score": 1.0, + "content": "Next, we compare the results of the TCN architecture to recurrent architectures on 6 different real", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 576, + 505, + 588 + ], + "spans": [ + { + "bbox": [ + 106, + 576, + 505, + 588 + ], + "score": 1.0, + "content": "datasets in polyphonic music as well as word- and character-level language modeling. These are", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 587, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 505, + 599 + ], + "score": 1.0, + "content": "areas where sequence modeling has been used most frequently. As domains where there is consider-", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 104, + 596, + 506, + 612 + ], + "spans": [ + { + "bbox": [ + 104, + 596, + 506, + 612 + ], + "score": 1.0, + "content": "able practical interests, there have also been many specialized RNNs developed for these tasks (e.g.,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 609, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 105, + 609, + 505, + 621 + ], + "score": 1.0, + "content": "Zhang et al. (2016); Ha et al. (2017); Krueger et al. (2017); Grave et al. (2016); Greff et al. (2017);", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 104, + 619, + 506, + 633 + ], + "spans": [ + { + "bbox": [ + 104, + 619, + 506, + 633 + ], + "score": 1.0, + "content": "Merity et al. (2017)). We mention some of these comparisons when useful, but the primary goal", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 104, + 630, + 505, + 645 + ], + "spans": [ + { + "bbox": [ + 104, + 630, + 505, + 645 + ], + "score": 1.0, + "content": "here is to compare the generic TCN model to other generic RNN architectures, so we focus mainly", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 641, + 197, + 655 + ], + "spans": [ + { + "bbox": [ + 105, + 641, + 197, + 655 + ], + "score": 1.0, + "content": "on these comparisons.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 21.5, + "bbox_fs": [ + 104, + 565, + 506, + 655 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 666, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 665, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 506, + 678 + ], + "score": 1.0, + "content": "Polyphonic Music. On the Nottingham and JSB Chorales datasets, the TCN with virtually no", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 677, + 506, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 689 + ], + "score": 1.0, + "content": "tuning is again able to beat the other models by a considerable margin (see Table 1), and even out-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 688, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 505, + 700 + ], + "score": 1.0, + "content": "performs some improved recurrent models for this task such as HF-RNN (Boulanger-Lewandowski", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "score": 1.0, + "content": "et al., 2012) and Diagonal RNN (Subakan & Smaragdis, 2017). Note however that other models", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "such as the Deep Belief Net LSTM (Vohra et al., 2015) perform substantially better on this task;", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 505, + 733 + ], + "score": 1.0, + "content": "we believe this is likely due to the fact that the datasets involved in polyphonic music are relatively", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "score": 1.0, + "content": "small, and thus the right regularization method or generative modeling procedure can improve per-", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "formance significantly. This is largely orthogonal to the RNN/TCN distinction, as a similar variant", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 105, + 229, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 105, + 229, + 117 + ], + "score": 1.0, + "content": "of TCN may well be possible.", + "type": "text", + "cross_page": true + } + ], + "index": 2 + } + ], + "index": 28.5, + "bbox_fs": [ + 105, + 665, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "score": 1.0, + "content": "small, and thus the right regularization method or generative modeling procedure can improve per-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "formance significantly. This is largely orthogonal to the RNN/TCN distinction, as a similar variant", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 105, + 229, + 117 + ], + "spans": [ + { + "bbox": [ + 106, + 105, + 229, + 117 + ], + "score": 1.0, + "content": "of TCN may well be possible.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 107, + 130, + 505, + 207 + ], + "lines": [ + { + "bbox": [ + 105, + 129, + 505, + 144 + ], + "spans": [ + { + "bbox": [ + 105, + 129, + 505, + 144 + ], + "score": 1.0, + "content": "Word-level Language Modeling. Language modeling remains one of the primary applications", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 141, + 505, + 154 + ], + "spans": [ + { + "bbox": [ + 105, + 141, + 505, + 154 + ], + "score": 1.0, + "content": "of recurrent networks in general, where many recent works have been focusing on optimizing the", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 151, + 505, + 165 + ], + "spans": [ + { + "bbox": [ + 105, + 151, + 505, + 165 + ], + "score": 1.0, + "content": "usage of LSTMs (see Krueger et al. (2017); Merity et al. (2017)). In our implementation, we follow", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 163, + 505, + 175 + ], + "spans": [ + { + "bbox": [ + 105, + 163, + 505, + 175 + ], + "score": 1.0, + "content": "standard practices such as tying the weights of encoder and decoder layers for both TCN and RNNs", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 174, + 505, + 186 + ], + "spans": [ + { + "bbox": [ + 105, + 174, + 505, + 186 + ], + "score": 1.0, + "content": "(Press & Wolf, 2016), which significantly reduces the number of parameters in the model. When", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 184, + 506, + 199 + ], + "spans": [ + { + "bbox": [ + 105, + 184, + 506, + 199 + ], + "score": 1.0, + "content": "training the language modeling tasks, we use SGD optimizer with annealing learning rate (by a", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 196, + 244, + 207 + ], + "spans": [ + { + "bbox": [ + 106, + 196, + 244, + 207 + ], + "score": 1.0, + "content": "factor of 0.5) for TCN and RNNs.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 107, + 212, + 505, + 312 + ], + "lines": [ + { + "bbox": [ + 105, + 212, + 505, + 225 + ], + "spans": [ + { + "bbox": [ + 105, + 212, + 505, + 225 + ], + "score": 1.0, + "content": "Results on word-level language modeling are reported in Table 1. With a fine-tuned LSTM (i.e., with", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 224, + 505, + 236 + ], + "spans": [ + { + "bbox": [ + 105, + 224, + 505, + 236 + ], + "score": 1.0, + "content": "recurrent and embedding dropout, etc.), we find LSTM can outperform TCN in perplexity on the", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 235, + 505, + 246 + ], + "spans": [ + { + "bbox": [ + 106, + 235, + 505, + 246 + ], + "score": 1.0, + "content": "Penn TreeBank (PTB) dataset, where the TCN model still beats both GRU and vanilla RNN. On the", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 245, + 506, + 258 + ], + "spans": [ + { + "bbox": [ + 105, + 245, + 506, + 258 + ], + "score": 1.0, + "content": "much larger Wikitext-103 corpus, however, without performing much hyperparameter search (due", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 256, + 506, + 270 + ], + "spans": [ + { + "bbox": [ + 105, + 256, + 506, + 270 + ], + "score": 1.0, + "content": "to lengthy training process), we still observe that TCN outperforms the state of the art LSTM results", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 267, + 505, + 280 + ], + "spans": [ + { + "bbox": [ + 105, + 267, + 505, + 280 + ], + "score": 1.0, + "content": "(48.4 in perplexity) by Grave et al. (2016) (without continuous cache pointer; see Table 4). The", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 279, + 506, + 291 + ], + "spans": [ + { + "bbox": [ + 105, + 279, + 506, + 291 + ], + "score": 1.0, + "content": "same superiority is observed on the LAMBADA test (Paperno et al., 2016), where TCN achieves", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 104, + 288, + 505, + 304 + ], + "spans": [ + { + "bbox": [ + 104, + 288, + 505, + 304 + ], + "score": 1.0, + "content": "a much lower perplexity than its recurrent counterparts in predicting the last word based on a very", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 300, + 405, + 313 + ], + "spans": [ + { + "bbox": [ + 105, + 300, + 405, + 313 + ], + "score": 1.0, + "content": "long context (see Appendix A). We will further analyze this in section 4.4.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 107, + 326, + 505, + 403 + ], + "lines": [ + { + "bbox": [ + 106, + 325, + 505, + 339 + ], + "spans": [ + { + "bbox": [ + 106, + 325, + 505, + 339 + ], + "score": 1.0, + "content": "Character-level Language Modeling. The results of applying TCN and alternative models on", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 336, + 505, + 349 + ], + "spans": [ + { + "bbox": [ + 105, + 336, + 505, + 349 + ], + "score": 1.0, + "content": "PTB and text8 data for character-level language modeling are shown in Table 1, with performance", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 348, + 504, + 360 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 504, + 360 + ], + "score": 1.0, + "content": "measured in bits per character (bpc). While beaten by the state of the art (see Table 4), the generic", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 359, + 505, + 370 + ], + "spans": [ + { + "bbox": [ + 106, + 359, + 505, + 370 + ], + "score": 1.0, + "content": "TCN outperforms regularized LSTM and GRU as well as methods such as Norm-stabilized LSTM", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 370, + 505, + 382 + ], + "spans": [ + { + "bbox": [ + 106, + 370, + 407, + 382 + ], + "score": 1.0, + "content": "(Krueger & Memisevic, 2015). Moreover, we note that using a filter size of", + "type": "text" + }, + { + "bbox": [ + 408, + 370, + 433, + 381 + ], + "score": 0.9, + "content": "k \\leq 4", + "type": "inline_equation" + }, + { + "bbox": [ + 433, + 370, + 505, + 382 + ], + "score": 1.0, + "content": "works better than", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 379, + 505, + 395 + ], + "spans": [ + { + "bbox": [ + 105, + 379, + 505, + 395 + ], + "score": 1.0, + "content": "larger filter sizes in character-level language modeling, which suggests that capturing short history", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 393, + 342, + 403 + ], + "spans": [ + { + "bbox": [ + 105, + 393, + 342, + 403 + ], + "score": 1.0, + "content": "is more important than longer dependencies in these tasks.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22 + }, + { + "type": "title", + "bbox": [ + 108, + 418, + 282, + 429 + ], + "lines": [ + { + "bbox": [ + 106, + 417, + 283, + 430 + ], + "spans": [ + { + "bbox": [ + 106, + 417, + 283, + 430 + ], + "score": 1.0, + "content": "4.4 MEMORY SIZE OF TCN AND RNNS", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 107, + 439, + 504, + 484 + ], + "lines": [ + { + "bbox": [ + 105, + 440, + 505, + 452 + ], + "spans": [ + { + "bbox": [ + 105, + 440, + 505, + 452 + ], + "score": 1.0, + "content": "Finally, one of the important reasons why RNNs have been preferred over CNNs for general se-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 451, + 506, + 463 + ], + "spans": [ + { + "bbox": [ + 105, + 451, + 506, + 463 + ], + "score": 1.0, + "content": "quence modeling is that theoretically, recurrent architectures are capable of an infinite memory.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 462, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 462, + 505, + 475 + ], + "score": 1.0, + "content": "We therefore attempt to study here how much memory TCN and LSTM/GRU are able to actually", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 471, + 442, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 442, + 486 + ], + "score": 1.0, + "content": "“backtrack”, via the copy memory task and the LAMBADA language modeling task.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 28.5 + }, + { + "type": "text", + "bbox": [ + 295, + 489, + 504, + 588 + ], + "lines": [ + { + "bbox": [ + 294, + 489, + 505, + 501 + ], + "spans": [ + { + "bbox": [ + 294, + 489, + 505, + 501 + ], + "score": 1.0, + "content": "The copy memory task is a simple but perfect task", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 293, + 499, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 293, + 499, + 505, + 514 + ], + "score": 1.0, + "content": "to examine a model’s ability to pick up its memory", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 294, + 511, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 294, + 511, + 505, + 523 + ], + "score": 1.0, + "content": "from a (possibly) distant past (by varying the value", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 294, + 522, + 505, + 534 + ], + "spans": [ + { + "bbox": [ + 294, + 522, + 372, + 534 + ], + "score": 1.0, + "content": "of sequence length", + "type": "text" + }, + { + "bbox": [ + 373, + 523, + 382, + 533 + ], + "score": 0.61, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 382, + 522, + 505, + 534 + ], + "score": 1.0, + "content": "). However, different from the", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 294, + 533, + 505, + 545 + ], + "spans": [ + { + "bbox": [ + 294, + 533, + 505, + 545 + ], + "score": 1.0, + "content": "setting in Section 4.2, in order to compare the results", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 293, + 544, + 505, + 556 + ], + "spans": [ + { + "bbox": [ + 293, + 544, + 505, + 556 + ], + "score": 1.0, + "content": "for different sequence lengths, here we only report", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 294, + 555, + 505, + 567 + ], + "spans": [ + { + "bbox": [ + 294, + 555, + 397, + 567 + ], + "score": 1.0, + "content": "the accuracy on the last", + "type": "text" + }, + { + "bbox": [ + 397, + 555, + 409, + 565 + ], + "score": 0.35, + "content": "I O", + "type": "inline_equation" + }, + { + "bbox": [ + 409, + 555, + 505, + 567 + ], + "score": 1.0, + "content": "elements of the output", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 293, + 566, + 505, + 577 + ], + "spans": [ + { + "bbox": [ + 293, + 566, + 505, + 577 + ], + "score": 1.0, + "content": "sequence. We used a model size of 10K for both", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 294, + 577, + 363, + 588 + ], + "spans": [ + { + "bbox": [ + 294, + 577, + 363, + 588 + ], + "score": 1.0, + "content": "TCN and RNNs.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 42 + }, + { + "type": "image", + "bbox": [ + 106, + 501, + 284, + 642 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 501, + 284, + 642 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 501, + 284, + 642 + ], + "spans": [ + { + "bbox": [ + 106, + 501, + 284, + 642 + ], + "score": 0.966, + "type": "image", + "image_path": "294b6d1f2397e8ec063d0643ac527f33c030df7f7c912acd3fc3b3fa37f37eaa.jpg" + } + ] + } + ], + "index": 36, + "virtual_lines": [ + { + "bbox": [ + 106, + 501, + 284, + 513.8181818181819 + ], + "spans": [], + "index": 31 + }, + { + "bbox": [ + 106, + 513.8181818181819, + 284, + 526.6363636363637 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 106, + 526.6363636363637, + 284, + 539.4545454545456 + ], + "spans": [], + "index": 33 + }, + { + "bbox": [ + 106, + 539.4545454545456, + 284, + 552.2727272727275 + ], + "spans": [], + "index": 34 + }, + { + "bbox": [ + 106, + 552.2727272727275, + 284, + 565.0909090909093 + ], + "spans": [], + "index": 35 + }, + { + "bbox": [ + 106, + 565.0909090909093, + 284, + 577.9090909090912 + ], + "spans": [], + "index": 36 + }, + { + "bbox": [ + 106, + 577.9090909090912, + 284, + 590.7272727272731 + ], + "spans": [], + "index": 37 + }, + { + "bbox": [ + 106, + 590.7272727272731, + 284, + 603.545454545455 + ], + "spans": [], + "index": 47 + }, + { + "bbox": [ + 106, + 603.545454545455, + 284, + 616.3636363636368 + ], + "spans": [], + "index": 48 + }, + { + "bbox": [ + 106, + 616.3636363636368, + 284, + 629.1818181818187 + ], + "spans": [], + "index": 49 + }, + { + "bbox": [ + 106, + 629.1818181818187, + 284, + 642.0000000000006 + ], + "spans": [], + "index": 50 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 658, + 286, + 681 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 657, + 287, + 671 + ], + "spans": [ + { + "bbox": [ + 106, + 657, + 287, + 671 + ], + "score": 1.0, + "content": "Figure 7: Accuracy on the copy memory task", + "type": "text" + } + ], + "index": 56 + }, + { + "bbox": [ + 105, + 669, + 232, + 682 + ], + "spans": [ + { + "bbox": [ + 105, + 669, + 219, + 682 + ], + "score": 1.0, + "content": "for varying sequence length", + "type": "text" + }, + { + "bbox": [ + 220, + 669, + 228, + 679 + ], + "score": 0.78, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 669, + 232, + 682 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 55 + } + ], + "index": 55.5 + } + ], + "index": 45.75 + }, + { + "type": "text", + "bbox": [ + 295, + 594, + 504, + 682 + ], + "lines": [ + { + "bbox": [ + 294, + 594, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 294, + 594, + 505, + 606 + ], + "score": 1.0, + "content": "The results are shown in Figure 7. TCNs consis-", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 293, + 604, + 505, + 618 + ], + "spans": [ + { + "bbox": [ + 293, + 604, + 372, + 618 + ], + "score": 1.0, + "content": "tently converge to", + "type": "text" + }, + { + "bbox": [ + 372, + 605, + 396, + 615 + ], + "score": 0.86, + "content": "100 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 604, + 505, + 618 + ], + "score": 1.0, + "content": "accuracy for all sequence", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 294, + 616, + 505, + 628 + ], + "spans": [ + { + "bbox": [ + 294, + 616, + 505, + 628 + ], + "score": 1.0, + "content": "lengths, whereas it is increasingly challenging for re-", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 294, + 627, + 504, + 638 + ], + "spans": [ + { + "bbox": [ + 294, + 627, + 420, + 638 + ], + "score": 1.0, + "content": "current models to memorize as", + "type": "text" + }, + { + "bbox": [ + 421, + 627, + 430, + 637 + ], + "score": 0.77, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 430, + 627, + 504, + 638 + ], + "score": 1.0, + "content": "grows (with accu-", + "type": "text" + } + ], + "index": 54 + }, + { + "bbox": [ + 293, + 639, + 505, + 649 + ], + "spans": [ + { + "bbox": [ + 293, + 639, + 505, + 649 + ], + "score": 1.0, + "content": "racy converging to that of a random guess). LSTM’s", + "type": "text" + } + ], + "index": 57 + }, + { + "bbox": [ + 293, + 649, + 505, + 660 + ], + "spans": [ + { + "bbox": [ + 293, + 649, + 409, + 660 + ], + "score": 1.0, + "content": "accuracy quickly falls below", + "type": "text" + }, + { + "bbox": [ + 409, + 649, + 429, + 659 + ], + "score": 0.88, + "content": "20 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 429, + 649, + 443, + 660 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 443, + 649, + 475, + 660 + ], + "score": 0.91, + "content": "T \\geq 5 0", + "type": "inline_equation" + }, + { + "bbox": [ + 475, + 649, + 505, + 660 + ], + "score": 1.0, + "content": ", which", + "type": "text" + } + ], + "index": 58 + }, + { + "bbox": [ + 293, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 293, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "suggests that instead of infinite memory, LSTMs are", + "type": "text" + } + ], + "index": 59 + }, + { + "bbox": [ + 294, + 671, + 477, + 684 + ], + "spans": [ + { + "bbox": [ + 294, + 671, + 477, + 684 + ], + "score": 1.0, + "content": "only good at recalling a short history instead.", + "type": "text" + } + ], + "index": 60 + } + ], + "index": 55.5 + }, + { + "type": "text", + "bbox": [ + 295, + 688, + 504, + 710 + ], + "lines": [ + { + "bbox": [ + 294, + 686, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 294, + 686, + 505, + 700 + ], + "score": 1.0, + "content": "This observation is also backed up by the experi-", + "type": "text" + } + ], + "index": 61 + }, + { + "bbox": [ + 294, + 698, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 294, + 698, + 506, + 711 + ], + "score": 1.0, + "content": "ments of TCN on the LAMBADA dataset, which is", + "type": "text" + } + ], + "index": 62 + } + ], + "index": 61.5 + }, + { + "type": "text", + "bbox": [ + 105, + 710, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "specifically designed to test a model’s textual understanding in a broader discourse. The objective", + "type": "text" + } + ], + "index": 63 + }, + { + "bbox": [ + 105, + 718, + 505, + 735 + ], + "spans": [ + { + "bbox": [ + 105, + 718, + 505, + 735 + ], + "score": 1.0, + "content": "of LAMBADA dataset is to predict the last word of the target sentence given a sufficiently long", + "type": "text" + } + ], + "index": 64 + } + ], + "index": 63.5 + } + ], + "page_idx": 9, + "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": [ + 301, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 765 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 765 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 15, + "width": 14 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 504, + 116 + ], + "lines": [], + "index": 1, + "bbox_fs": [ + 105, + 81, + 505, + 117 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 130, + 505, + 207 + ], + "lines": [ + { + "bbox": [ + 105, + 129, + 505, + 144 + ], + "spans": [ + { + "bbox": [ + 105, + 129, + 505, + 144 + ], + "score": 1.0, + "content": "Word-level Language Modeling. Language modeling remains one of the primary applications", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 141, + 505, + 154 + ], + "spans": [ + { + "bbox": [ + 105, + 141, + 505, + 154 + ], + "score": 1.0, + "content": "of recurrent networks in general, where many recent works have been focusing on optimizing the", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 151, + 505, + 165 + ], + "spans": [ + { + "bbox": [ + 105, + 151, + 505, + 165 + ], + "score": 1.0, + "content": "usage of LSTMs (see Krueger et al. (2017); Merity et al. (2017)). In our implementation, we follow", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 163, + 505, + 175 + ], + "spans": [ + { + "bbox": [ + 105, + 163, + 505, + 175 + ], + "score": 1.0, + "content": "standard practices such as tying the weights of encoder and decoder layers for both TCN and RNNs", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 174, + 505, + 186 + ], + "spans": [ + { + "bbox": [ + 105, + 174, + 505, + 186 + ], + "score": 1.0, + "content": "(Press & Wolf, 2016), which significantly reduces the number of parameters in the model. When", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 184, + 506, + 199 + ], + "spans": [ + { + "bbox": [ + 105, + 184, + 506, + 199 + ], + "score": 1.0, + "content": "training the language modeling tasks, we use SGD optimizer with annealing learning rate (by a", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 196, + 244, + 207 + ], + "spans": [ + { + "bbox": [ + 106, + 196, + 244, + 207 + ], + "score": 1.0, + "content": "factor of 0.5) for TCN and RNNs.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 6, + "bbox_fs": [ + 105, + 129, + 506, + 207 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 212, + 505, + 312 + ], + "lines": [ + { + "bbox": [ + 105, + 212, + 505, + 225 + ], + "spans": [ + { + "bbox": [ + 105, + 212, + 505, + 225 + ], + "score": 1.0, + "content": "Results on word-level language modeling are reported in Table 1. With a fine-tuned LSTM (i.e., with", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 224, + 505, + 236 + ], + "spans": [ + { + "bbox": [ + 105, + 224, + 505, + 236 + ], + "score": 1.0, + "content": "recurrent and embedding dropout, etc.), we find LSTM can outperform TCN in perplexity on the", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 235, + 505, + 246 + ], + "spans": [ + { + "bbox": [ + 106, + 235, + 505, + 246 + ], + "score": 1.0, + "content": "Penn TreeBank (PTB) dataset, where the TCN model still beats both GRU and vanilla RNN. On the", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 245, + 506, + 258 + ], + "spans": [ + { + "bbox": [ + 105, + 245, + 506, + 258 + ], + "score": 1.0, + "content": "much larger Wikitext-103 corpus, however, without performing much hyperparameter search (due", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 256, + 506, + 270 + ], + "spans": [ + { + "bbox": [ + 105, + 256, + 506, + 270 + ], + "score": 1.0, + "content": "to lengthy training process), we still observe that TCN outperforms the state of the art LSTM results", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 267, + 505, + 280 + ], + "spans": [ + { + "bbox": [ + 105, + 267, + 505, + 280 + ], + "score": 1.0, + "content": "(48.4 in perplexity) by Grave et al. (2016) (without continuous cache pointer; see Table 4). The", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 279, + 506, + 291 + ], + "spans": [ + { + "bbox": [ + 105, + 279, + 506, + 291 + ], + "score": 1.0, + "content": "same superiority is observed on the LAMBADA test (Paperno et al., 2016), where TCN achieves", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 104, + 288, + 505, + 304 + ], + "spans": [ + { + "bbox": [ + 104, + 288, + 505, + 304 + ], + "score": 1.0, + "content": "a much lower perplexity than its recurrent counterparts in predicting the last word based on a very", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 300, + 405, + 313 + ], + "spans": [ + { + "bbox": [ + 105, + 300, + 405, + 313 + ], + "score": 1.0, + "content": "long context (see Appendix A). We will further analyze this in section 4.4.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 14, + "bbox_fs": [ + 104, + 212, + 506, + 313 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 326, + 505, + 403 + ], + "lines": [ + { + "bbox": [ + 106, + 325, + 505, + 339 + ], + "spans": [ + { + "bbox": [ + 106, + 325, + 505, + 339 + ], + "score": 1.0, + "content": "Character-level Language Modeling. The results of applying TCN and alternative models on", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 336, + 505, + 349 + ], + "spans": [ + { + "bbox": [ + 105, + 336, + 505, + 349 + ], + "score": 1.0, + "content": "PTB and text8 data for character-level language modeling are shown in Table 1, with performance", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 348, + 504, + 360 + ], + "spans": [ + { + "bbox": [ + 105, + 348, + 504, + 360 + ], + "score": 1.0, + "content": "measured in bits per character (bpc). While beaten by the state of the art (see Table 4), the generic", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 359, + 505, + 370 + ], + "spans": [ + { + "bbox": [ + 106, + 359, + 505, + 370 + ], + "score": 1.0, + "content": "TCN outperforms regularized LSTM and GRU as well as methods such as Norm-stabilized LSTM", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 370, + 505, + 382 + ], + "spans": [ + { + "bbox": [ + 106, + 370, + 407, + 382 + ], + "score": 1.0, + "content": "(Krueger & Memisevic, 2015). Moreover, we note that using a filter size of", + "type": "text" + }, + { + "bbox": [ + 408, + 370, + 433, + 381 + ], + "score": 0.9, + "content": "k \\leq 4", + "type": "inline_equation" + }, + { + "bbox": [ + 433, + 370, + 505, + 382 + ], + "score": 1.0, + "content": "works better than", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 379, + 505, + 395 + ], + "spans": [ + { + "bbox": [ + 105, + 379, + 505, + 395 + ], + "score": 1.0, + "content": "larger filter sizes in character-level language modeling, which suggests that capturing short history", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 393, + 342, + 403 + ], + "spans": [ + { + "bbox": [ + 105, + 393, + 342, + 403 + ], + "score": 1.0, + "content": "is more important than longer dependencies in these tasks.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22, + "bbox_fs": [ + 105, + 325, + 505, + 403 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 418, + 282, + 429 + ], + "lines": [ + { + "bbox": [ + 106, + 417, + 283, + 430 + ], + "spans": [ + { + "bbox": [ + 106, + 417, + 283, + 430 + ], + "score": 1.0, + "content": "4.4 MEMORY SIZE OF TCN AND RNNS", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 107, + 439, + 504, + 484 + ], + "lines": [ + { + "bbox": [ + 105, + 440, + 505, + 452 + ], + "spans": [ + { + "bbox": [ + 105, + 440, + 505, + 452 + ], + "score": 1.0, + "content": "Finally, one of the important reasons why RNNs have been preferred over CNNs for general se-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 451, + 506, + 463 + ], + "spans": [ + { + "bbox": [ + 105, + 451, + 506, + 463 + ], + "score": 1.0, + "content": "quence modeling is that theoretically, recurrent architectures are capable of an infinite memory.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 462, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 462, + 505, + 475 + ], + "score": 1.0, + "content": "We therefore attempt to study here how much memory TCN and LSTM/GRU are able to actually", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 471, + 442, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 442, + 486 + ], + "score": 1.0, + "content": "“backtrack”, via the copy memory task and the LAMBADA language modeling task.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 28.5, + "bbox_fs": [ + 105, + 440, + 506, + 486 + ] + }, + { + "type": "text", + "bbox": [ + 295, + 489, + 504, + 588 + ], + "lines": [ + { + "bbox": [ + 294, + 489, + 505, + 501 + ], + "spans": [ + { + "bbox": [ + 294, + 489, + 505, + 501 + ], + "score": 1.0, + "content": "The copy memory task is a simple but perfect task", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 293, + 499, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 293, + 499, + 505, + 514 + ], + "score": 1.0, + "content": "to examine a model’s ability to pick up its memory", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 294, + 511, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 294, + 511, + 505, + 523 + ], + "score": 1.0, + "content": "from a (possibly) distant past (by varying the value", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 294, + 522, + 505, + 534 + ], + "spans": [ + { + "bbox": [ + 294, + 522, + 372, + 534 + ], + "score": 1.0, + "content": "of sequence length", + "type": "text" + }, + { + "bbox": [ + 373, + 523, + 382, + 533 + ], + "score": 0.61, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 382, + 522, + 505, + 534 + ], + "score": 1.0, + "content": "). However, different from the", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 294, + 533, + 505, + 545 + ], + "spans": [ + { + "bbox": [ + 294, + 533, + 505, + 545 + ], + "score": 1.0, + "content": "setting in Section 4.2, in order to compare the results", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 293, + 544, + 505, + 556 + ], + "spans": [ + { + "bbox": [ + 293, + 544, + 505, + 556 + ], + "score": 1.0, + "content": "for different sequence lengths, here we only report", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 294, + 555, + 505, + 567 + ], + "spans": [ + { + "bbox": [ + 294, + 555, + 397, + 567 + ], + "score": 1.0, + "content": "the accuracy on the last", + "type": "text" + }, + { + "bbox": [ + 397, + 555, + 409, + 565 + ], + "score": 0.35, + "content": "I O", + "type": "inline_equation" + }, + { + "bbox": [ + 409, + 555, + 505, + 567 + ], + "score": 1.0, + "content": "elements of the output", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 293, + 566, + 505, + 577 + ], + "spans": [ + { + "bbox": [ + 293, + 566, + 505, + 577 + ], + "score": 1.0, + "content": "sequence. We used a model size of 10K for both", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 294, + 577, + 363, + 588 + ], + "spans": [ + { + "bbox": [ + 294, + 577, + 363, + 588 + ], + "score": 1.0, + "content": "TCN and RNNs.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 42, + "bbox_fs": [ + 293, + 489, + 505, + 588 + ] + }, + { + "type": "image", + "bbox": [ + 106, + 501, + 284, + 642 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 106, + 501, + 284, + 642 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 501, + 284, + 642 + ], + "spans": [ + { + "bbox": [ + 106, + 501, + 284, + 642 + ], + "score": 0.966, + "type": "image", + "image_path": "294b6d1f2397e8ec063d0643ac527f33c030df7f7c912acd3fc3b3fa37f37eaa.jpg" + } + ] + } + ], + "index": 36, + "virtual_lines": [ + { + "bbox": [ + 106, + 501, + 284, + 513.8181818181819 + ], + "spans": [], + "index": 31 + }, + { + "bbox": [ + 106, + 513.8181818181819, + 284, + 526.6363636363637 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 106, + 526.6363636363637, + 284, + 539.4545454545456 + ], + "spans": [], + "index": 33 + }, + { + "bbox": [ + 106, + 539.4545454545456, + 284, + 552.2727272727275 + ], + "spans": [], + "index": 34 + }, + { + "bbox": [ + 106, + 552.2727272727275, + 284, + 565.0909090909093 + ], + "spans": [], + "index": 35 + }, + { + "bbox": [ + 106, + 565.0909090909093, + 284, + 577.9090909090912 + ], + "spans": [], + "index": 36 + }, + { + "bbox": [ + 106, + 577.9090909090912, + 284, + 590.7272727272731 + ], + "spans": [], + "index": 37 + }, + { + "bbox": [ + 106, + 590.7272727272731, + 284, + 603.545454545455 + ], + "spans": [], + "index": 47 + }, + { + "bbox": [ + 106, + 603.545454545455, + 284, + 616.3636363636368 + ], + "spans": [], + "index": 48 + }, + { + "bbox": [ + 106, + 616.3636363636368, + 284, + 629.1818181818187 + ], + "spans": [], + "index": 49 + }, + { + "bbox": [ + 106, + 629.1818181818187, + 284, + 642.0000000000006 + ], + "spans": [], + "index": 50 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 658, + 286, + 681 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 657, + 287, + 671 + ], + "spans": [ + { + "bbox": [ + 106, + 657, + 287, + 671 + ], + "score": 1.0, + "content": "Figure 7: Accuracy on the copy memory task", + "type": "text" + } + ], + "index": 56 + }, + { + "bbox": [ + 105, + 669, + 232, + 682 + ], + "spans": [ + { + "bbox": [ + 105, + 669, + 219, + 682 + ], + "score": 1.0, + "content": "for varying sequence length", + "type": "text" + }, + { + "bbox": [ + 220, + 669, + 228, + 679 + ], + "score": 0.78, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 669, + 232, + 682 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 55 + } + ], + "index": 55.5 + } + ], + "index": 45.75 + }, + { + "type": "text", + "bbox": [ + 295, + 594, + 504, + 682 + ], + "lines": [ + { + "bbox": [ + 294, + 594, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 294, + 594, + 505, + 606 + ], + "score": 1.0, + "content": "The results are shown in Figure 7. TCNs consis-", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 293, + 604, + 505, + 618 + ], + "spans": [ + { + "bbox": [ + 293, + 604, + 372, + 618 + ], + "score": 1.0, + "content": "tently converge to", + "type": "text" + }, + { + "bbox": [ + 372, + 605, + 396, + 615 + ], + "score": 0.86, + "content": "100 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 397, + 604, + 505, + 618 + ], + "score": 1.0, + "content": "accuracy for all sequence", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 294, + 616, + 505, + 628 + ], + "spans": [ + { + "bbox": [ + 294, + 616, + 505, + 628 + ], + "score": 1.0, + "content": "lengths, whereas it is increasingly challenging for re-", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 294, + 627, + 504, + 638 + ], + "spans": [ + { + "bbox": [ + 294, + 627, + 420, + 638 + ], + "score": 1.0, + "content": "current models to memorize as", + "type": "text" + }, + { + "bbox": [ + 421, + 627, + 430, + 637 + ], + "score": 0.77, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 430, + 627, + 504, + 638 + ], + "score": 1.0, + "content": "grows (with accu-", + "type": "text" + } + ], + "index": 54 + }, + { + "bbox": [ + 293, + 639, + 505, + 649 + ], + "spans": [ + { + "bbox": [ + 293, + 639, + 505, + 649 + ], + "score": 1.0, + "content": "racy converging to that of a random guess). LSTM’s", + "type": "text" + } + ], + "index": 57 + }, + { + "bbox": [ + 293, + 649, + 505, + 660 + ], + "spans": [ + { + "bbox": [ + 293, + 649, + 409, + 660 + ], + "score": 1.0, + "content": "accuracy quickly falls below", + "type": "text" + }, + { + "bbox": [ + 409, + 649, + 429, + 659 + ], + "score": 0.88, + "content": "20 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 429, + 649, + 443, + 660 + ], + "score": 1.0, + "content": "for", + "type": "text" + }, + { + "bbox": [ + 443, + 649, + 475, + 660 + ], + "score": 0.91, + "content": "T \\geq 5 0", + "type": "inline_equation" + }, + { + "bbox": [ + 475, + 649, + 505, + 660 + ], + "score": 1.0, + "content": ", which", + "type": "text" + } + ], + "index": 58 + }, + { + "bbox": [ + 293, + 660, + 505, + 672 + ], + "spans": [ + { + "bbox": [ + 293, + 660, + 505, + 672 + ], + "score": 1.0, + "content": "suggests that instead of infinite memory, LSTMs are", + "type": "text" + } + ], + "index": 59 + }, + { + "bbox": [ + 294, + 671, + 477, + 684 + ], + "spans": [ + { + "bbox": [ + 294, + 671, + 477, + 684 + ], + "score": 1.0, + "content": "only good at recalling a short history instead.", + "type": "text" + } + ], + "index": 60 + } + ], + "index": 55.5, + "bbox_fs": [ + 293, + 594, + 505, + 684 + ] + }, + { + "type": "text", + "bbox": [ + 295, + 688, + 504, + 710 + ], + "lines": [ + { + "bbox": [ + 294, + 686, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 294, + 686, + 505, + 700 + ], + "score": 1.0, + "content": "This observation is also backed up by the experi-", + "type": "text" + } + ], + "index": 61 + }, + { + "bbox": [ + 294, + 698, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 294, + 698, + 506, + 711 + ], + "score": 1.0, + "content": "ments of TCN on the LAMBADA dataset, which is", + "type": "text" + } + ], + "index": 62 + }, + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "specifically designed to test a model’s textual understanding in a broader discourse. The objective", + "type": "text" + } + ], + "index": 63 + }, + { + "bbox": [ + 105, + 718, + 505, + 735 + ], + "spans": [ + { + "bbox": [ + 105, + 718, + 505, + 735 + ], + "score": 1.0, + "content": "of LAMBADA dataset is to predict the last word of the target sentence given a sufficiently long", + "type": "text" + } + ], + "index": 64 + }, + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "context (see Appendix A for more details). Most of the existing models fail to guess accurately on", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "this task. As shown in Table 1, TCN outperforms LSTMs by a significant margin in perplexity on", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 355, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 355, + 117 + ], + "score": 1.0, + "content": "LAMBADA (with a smaller network and virtually no tuning).", + "type": "text", + "cross_page": true + } + ], + "index": 2 + } + ], + "index": 61.5, + "bbox_fs": [ + 294, + 686, + 506, + 711 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 710, + 504, + 732 + ], + "lines": [], + "index": 63.5, + "bbox_fs": [ + 105, + 709, + 505, + 735 + ], + "lines_deleted": true + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "context (see Appendix A for more details). Most of the existing models fail to guess accurately on", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "this task. As shown in Table 1, TCN outperforms LSTMs by a significant margin in perplexity on", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 355, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 355, + 117 + ], + "score": 1.0, + "content": "LAMBADA (with a smaller network and virtually no tuning).", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 107, + 121, + 504, + 187 + ], + "lines": [ + { + "bbox": [ + 105, + 120, + 506, + 134 + ], + "spans": [ + { + "bbox": [ + 105, + 120, + 506, + 134 + ], + "score": 1.0, + "content": "These results indicate that TCNs, despite their apparent finite history, in practice maintain a longer", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 132, + 505, + 145 + ], + "spans": [ + { + "bbox": [ + 105, + 132, + 505, + 145 + ], + "score": 1.0, + "content": "effective history than their recurrent counterparts. We would like to emphasize that this empirical", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 144, + 505, + 155 + ], + "spans": [ + { + "bbox": [ + 106, + 144, + 505, + 155 + ], + "score": 1.0, + "content": "observation does not contradict the good results that prior works have achieved using LSTM, such", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 154, + 506, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 154, + 356, + 167 + ], + "score": 1.0, + "content": "as in language modeling on PTB. In fact, the very success of", + "type": "text" + }, + { + "bbox": [ + 356, + 156, + 363, + 164 + ], + "score": 0.76, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 364, + 154, + 506, + 167 + ], + "score": 1.0, + "content": "-gram models (Brown et al., 1992)", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 165, + 506, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 165, + 506, + 178 + ], + "score": 1.0, + "content": "suggested that language modeling might not need a very long memory, a conclusion also reached by", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 177, + 276, + 188 + ], + "spans": [ + { + "bbox": [ + 105, + 177, + 276, + 188 + ], + "score": 1.0, + "content": "prior works such as Dauphin et al. (2017).", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 5.5 + }, + { + "type": "title", + "bbox": [ + 107, + 203, + 190, + 216 + ], + "lines": [ + { + "bbox": [ + 105, + 202, + 192, + 218 + ], + "spans": [ + { + "bbox": [ + 105, + 202, + 192, + 218 + ], + "score": 1.0, + "content": "5 DISCUSSION", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 107, + 227, + 505, + 327 + ], + "lines": [ + { + "bbox": [ + 105, + 227, + 505, + 240 + ], + "spans": [ + { + "bbox": [ + 105, + 227, + 505, + 240 + ], + "score": 1.0, + "content": "In this work, we revisited the topic of modeling sequence predictions using convolutional archi-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 240, + 505, + 252 + ], + "spans": [ + { + "bbox": [ + 106, + 240, + 505, + 252 + ], + "score": 1.0, + "content": "tectures. We introduced the key components of the TCN and analyzed some vital advantages and", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 250, + 505, + 262 + ], + "spans": [ + { + "bbox": [ + 106, + 250, + 505, + 262 + ], + "score": 1.0, + "content": "disadvantages of using TCN for sequence predictions instead of RNNs. Further, we compared our", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 261, + 506, + 274 + ], + "spans": [ + { + "bbox": [ + 105, + 261, + 506, + 274 + ], + "score": 1.0, + "content": "generic TCN model to the recurrent architectures on a set of experiments that span a wide range of", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 270, + 506, + 286 + ], + "spans": [ + { + "bbox": [ + 105, + 270, + 506, + 286 + ], + "score": 1.0, + "content": "domains and datasets. Through these experiments, we have shown that TCN with minimal tuning", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 282, + 506, + 295 + ], + "spans": [ + { + "bbox": [ + 105, + 282, + 506, + 295 + ], + "score": 1.0, + "content": "can outperform LSTM/GRU of the same model size (and with standard regularizations) in most of", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 294, + 505, + 307 + ], + "spans": [ + { + "bbox": [ + 105, + 294, + 505, + 307 + ], + "score": 1.0, + "content": "the tasks. Further experiments on the copy memory task and LAMBADA task revealed that TCNs", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 304, + 506, + 319 + ], + "spans": [ + { + "bbox": [ + 105, + 304, + 506, + 319 + ], + "score": 1.0, + "content": "actually has a better capability for long-term memory than the comparable recurrent architectures,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 316, + 338, + 329 + ], + "spans": [ + { + "bbox": [ + 105, + 316, + 338, + 329 + ], + "score": 1.0, + "content": "which are commonly believed to have unlimited memory.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 107, + 333, + 505, + 410 + ], + "lines": [ + { + "bbox": [ + 104, + 331, + 505, + 346 + ], + "spans": [ + { + "bbox": [ + 104, + 331, + 505, + 346 + ], + "score": 1.0, + "content": "It is still important to note that, however, we only presented a generic architecture here, with com-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 343, + 505, + 357 + ], + "spans": [ + { + "bbox": [ + 105, + 343, + 505, + 357 + ], + "score": 1.0, + "content": "ponents all coming from standard modern convolutional networks (e.g., normalization, dropout,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 354, + 505, + 368 + ], + "spans": [ + { + "bbox": [ + 105, + 354, + 505, + 368 + ], + "score": 1.0, + "content": "residual network). And indeed, on specific problems, the TCN model can still be beaten by some", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 365, + 506, + 378 + ], + "spans": [ + { + "bbox": [ + 105, + 365, + 506, + 378 + ], + "score": 1.0, + "content": "specialized RNNs that adopt carefully designed optimization strategies. Nevertheless, we believe", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 376, + 505, + 389 + ], + "spans": [ + { + "bbox": [ + 105, + 376, + 505, + 389 + ], + "score": 1.0, + "content": "the experiment results in Section 4 might be a good signal that instead of considering RNNs as the", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 386, + 506, + 401 + ], + "spans": [ + { + "bbox": [ + 105, + 386, + 506, + 401 + ], + "score": 1.0, + "content": "“default” methodology for sequence modeling, convolutional networks too, can be a promising and", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 398, + 289, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 398, + 289, + 411 + ], + "score": 1.0, + "content": "powerful toolkit in studying time-series data.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22 + }, + { + "type": "title", + "bbox": [ + 108, + 448, + 175, + 460 + ], + "lines": [ + { + "bbox": [ + 106, + 447, + 176, + 461 + ], + "spans": [ + { + "bbox": [ + 106, + 447, + 176, + 461 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 105, + 465, + 507, + 733 + ], + "lines": [ + { + "bbox": [ + 105, + 465, + 506, + 479 + ], + "spans": [ + { + "bbox": [ + 105, + 465, + 506, + 479 + ], + "score": 1.0, + "content": "Allan, M. and Williams, C. Harmonising chorales by probabilistic inference. In Advances in neural", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 115, + 477, + 317, + 490 + ], + "spans": [ + { + "bbox": [ + 115, + 477, + 317, + 490 + ], + "score": 1.0, + "content": "information processing systems, pp. 25–32, 2005.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 495, + 506, + 508 + ], + "spans": [ + { + "bbox": [ + 106, + 495, + 506, + 508 + ], + "score": 1.0, + "content": "Arjovsky, M., Shah, A., and Bengio, Y. Unitary evolution recurrent neural networks. In International", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 116, + 505, + 392, + 520 + ], + "spans": [ + { + "bbox": [ + 116, + 505, + 392, + 520 + ], + "score": 1.0, + "content": "Conference on Machine Learning (ICML-16), pp. 1120–1128, 2016.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 524, + 505, + 537 + ], + "spans": [ + { + "bbox": [ + 105, + 524, + 505, + 537 + ], + "score": 1.0, + "content": "Bengio, Y., Simard, P., and Frasconi, P. Learning long-term dependencies with gradient descent is", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 115, + 534, + 396, + 548 + ], + "spans": [ + { + "bbox": [ + 115, + 534, + 396, + 548 + ], + "score": 1.0, + "content": "difficult. IEEE transactions on neural networks, 5(2):157–166, 1994.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 552, + 505, + 566 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 505, + 566 + ], + "score": 1.0, + "content": "Borovykh, A., Bohte, S., and Oosterlee, C. W. Conditional time series forecasting with convolutional", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 115, + 564, + 349, + 577 + ], + "spans": [ + { + "bbox": [ + 115, + 564, + 349, + 577 + ], + "score": 1.0, + "content": "neural networks. arXiv preprint arXiv:1703.04691, 2017.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 581, + 505, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 581, + 505, + 596 + ], + "score": 1.0, + "content": "Bottou, L., Soulie, F. F., Blanchet, P., and Lienard, J.-S. Speaker-independent isolated digit recog- ´", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 115, + 594, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 115, + 594, + 505, + 606 + ], + "score": 1.0, + "content": "nition: Multilayer perceptrons vs. dynamic time warping. Neural Networks, 3(4):453–465, 1990.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 611, + 505, + 624 + ], + "spans": [ + { + "bbox": [ + 106, + 611, + 505, + 624 + ], + "score": 1.0, + "content": "Boulanger-Lewandowski, N., Bengio, Y., and Vincent, P. Modeling temporal dependencies in high-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 115, + 622, + 506, + 637 + ], + "spans": [ + { + "bbox": [ + 115, + 622, + 506, + 637 + ], + "score": 1.0, + "content": "dimensional sequences: Application to polyphonic music generation and transcription. arXiv", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 115, + 634, + 249, + 646 + ], + "spans": [ + { + "bbox": [ + 115, + 634, + 249, + 646 + ], + "score": 1.0, + "content": "preprint arXiv:1206.6392, 2012.", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 651, + 505, + 664 + ], + "spans": [ + { + "bbox": [ + 105, + 651, + 505, + 664 + ], + "score": 1.0, + "content": "Brown, P. F., Desouza, P. V., Mercer, R. L., Pietra, V. J. D., and Lai, J. C. Class-based n-gram models", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 116, + 663, + 396, + 676 + ], + "spans": [ + { + "bbox": [ + 116, + 663, + 396, + 676 + ], + "score": 1.0, + "content": "of natural language. Computational linguistics, 18(4):467–479, 1992.", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 680, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 680, + 505, + 694 + ], + "score": 1.0, + "content": "Chang, S., Zhang, Y., Han, W., Yu, M., Guo, X., Tan, W., Cui, X., Witbrock, M., Hasegawa-Johnson,", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 115, + 692, + 495, + 706 + ], + "spans": [ + { + "bbox": [ + 115, + 692, + 495, + 706 + ], + "score": 1.0, + "content": "M., and Huang, T. Dilated recurrent neural networks. arXiv preprint arXiv:1710.02224, 2017.", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "Cho, K., Van Merrienboer, B., Bahdanau, D., and Bengio, Y. On the properties of neural machine ¨", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 117, + 721, + 443, + 733 + ], + "spans": [ + { + "bbox": [ + 117, + 721, + 443, + 733 + ], + "score": 1.0, + "content": "translation: Encoder-decoder approaches. arXiv preprint arXiv:1409.1259, 2014.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 36 + } + ], + "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, + 765 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 765 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 15, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 504, + 116 + ], + "lines": [], + "index": 1, + "bbox_fs": [ + 105, + 82, + 505, + 117 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 121, + 504, + 187 + ], + "lines": [ + { + "bbox": [ + 105, + 120, + 506, + 134 + ], + "spans": [ + { + "bbox": [ + 105, + 120, + 506, + 134 + ], + "score": 1.0, + "content": "These results indicate that TCNs, despite their apparent finite history, in practice maintain a longer", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 132, + 505, + 145 + ], + "spans": [ + { + "bbox": [ + 105, + 132, + 505, + 145 + ], + "score": 1.0, + "content": "effective history than their recurrent counterparts. We would like to emphasize that this empirical", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 144, + 505, + 155 + ], + "spans": [ + { + "bbox": [ + 106, + 144, + 505, + 155 + ], + "score": 1.0, + "content": "observation does not contradict the good results that prior works have achieved using LSTM, such", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 154, + 506, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 154, + 356, + 167 + ], + "score": 1.0, + "content": "as in language modeling on PTB. In fact, the very success of", + "type": "text" + }, + { + "bbox": [ + 356, + 156, + 363, + 164 + ], + "score": 0.76, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 364, + 154, + 506, + 167 + ], + "score": 1.0, + "content": "-gram models (Brown et al., 1992)", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 165, + 506, + 178 + ], + "spans": [ + { + "bbox": [ + 105, + 165, + 506, + 178 + ], + "score": 1.0, + "content": "suggested that language modeling might not need a very long memory, a conclusion also reached by", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 177, + 276, + 188 + ], + "spans": [ + { + "bbox": [ + 105, + 177, + 276, + 188 + ], + "score": 1.0, + "content": "prior works such as Dauphin et al. (2017).", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 5.5, + "bbox_fs": [ + 105, + 120, + 506, + 188 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 203, + 190, + 216 + ], + "lines": [ + { + "bbox": [ + 105, + 202, + 192, + 218 + ], + "spans": [ + { + "bbox": [ + 105, + 202, + 192, + 218 + ], + "score": 1.0, + "content": "5 DISCUSSION", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 107, + 227, + 505, + 327 + ], + "lines": [ + { + "bbox": [ + 105, + 227, + 505, + 240 + ], + "spans": [ + { + "bbox": [ + 105, + 227, + 505, + 240 + ], + "score": 1.0, + "content": "In this work, we revisited the topic of modeling sequence predictions using convolutional archi-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 240, + 505, + 252 + ], + "spans": [ + { + "bbox": [ + 106, + 240, + 505, + 252 + ], + "score": 1.0, + "content": "tectures. We introduced the key components of the TCN and analyzed some vital advantages and", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 250, + 505, + 262 + ], + "spans": [ + { + "bbox": [ + 106, + 250, + 505, + 262 + ], + "score": 1.0, + "content": "disadvantages of using TCN for sequence predictions instead of RNNs. Further, we compared our", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 261, + 506, + 274 + ], + "spans": [ + { + "bbox": [ + 105, + 261, + 506, + 274 + ], + "score": 1.0, + "content": "generic TCN model to the recurrent architectures on a set of experiments that span a wide range of", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 270, + 506, + 286 + ], + "spans": [ + { + "bbox": [ + 105, + 270, + 506, + 286 + ], + "score": 1.0, + "content": "domains and datasets. Through these experiments, we have shown that TCN with minimal tuning", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 282, + 506, + 295 + ], + "spans": [ + { + "bbox": [ + 105, + 282, + 506, + 295 + ], + "score": 1.0, + "content": "can outperform LSTM/GRU of the same model size (and with standard regularizations) in most of", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 294, + 505, + 307 + ], + "spans": [ + { + "bbox": [ + 105, + 294, + 505, + 307 + ], + "score": 1.0, + "content": "the tasks. Further experiments on the copy memory task and LAMBADA task revealed that TCNs", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 304, + 506, + 319 + ], + "spans": [ + { + "bbox": [ + 105, + 304, + 506, + 319 + ], + "score": 1.0, + "content": "actually has a better capability for long-term memory than the comparable recurrent architectures,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 316, + 338, + 329 + ], + "spans": [ + { + "bbox": [ + 105, + 316, + 338, + 329 + ], + "score": 1.0, + "content": "which are commonly believed to have unlimited memory.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 14, + "bbox_fs": [ + 105, + 227, + 506, + 329 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 333, + 505, + 410 + ], + "lines": [ + { + "bbox": [ + 104, + 331, + 505, + 346 + ], + "spans": [ + { + "bbox": [ + 104, + 331, + 505, + 346 + ], + "score": 1.0, + "content": "It is still important to note that, however, we only presented a generic architecture here, with com-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 343, + 505, + 357 + ], + "spans": [ + { + "bbox": [ + 105, + 343, + 505, + 357 + ], + "score": 1.0, + "content": "ponents all coming from standard modern convolutional networks (e.g., normalization, dropout,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 354, + 505, + 368 + ], + "spans": [ + { + "bbox": [ + 105, + 354, + 505, + 368 + ], + "score": 1.0, + "content": "residual network). And indeed, on specific problems, the TCN model can still be beaten by some", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 365, + 506, + 378 + ], + "spans": [ + { + "bbox": [ + 105, + 365, + 506, + 378 + ], + "score": 1.0, + "content": "specialized RNNs that adopt carefully designed optimization strategies. Nevertheless, we believe", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 376, + 505, + 389 + ], + "spans": [ + { + "bbox": [ + 105, + 376, + 505, + 389 + ], + "score": 1.0, + "content": "the experiment results in Section 4 might be a good signal that instead of considering RNNs as the", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 386, + 506, + 401 + ], + "spans": [ + { + "bbox": [ + 105, + 386, + 506, + 401 + ], + "score": 1.0, + "content": "“default” methodology for sequence modeling, convolutional networks too, can be a promising and", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 398, + 289, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 398, + 289, + 411 + ], + "score": 1.0, + "content": "powerful toolkit in studying time-series data.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22, + "bbox_fs": [ + 104, + 331, + 506, + 411 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 448, + 175, + 460 + ], + "lines": [ + { + "bbox": [ + 106, + 447, + 176, + 461 + ], + "spans": [ + { + "bbox": [ + 106, + 447, + 176, + 461 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "list", + "bbox": [ + 105, + 465, + 507, + 733 + ], + "lines": [ + { + "bbox": [ + 105, + 465, + 506, + 479 + ], + "spans": [ + { + "bbox": [ + 105, + 465, + 506, + 479 + ], + "score": 1.0, + "content": "Allan, M. and Williams, C. Harmonising chorales by probabilistic inference. In Advances in neural", + "type": "text" + } + ], + "index": 27, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 477, + 317, + 490 + ], + "spans": [ + { + "bbox": [ + 115, + 477, + 317, + 490 + ], + "score": 1.0, + "content": "information processing systems, pp. 25–32, 2005.", + "type": "text" + } + ], + "index": 28, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 495, + 506, + 508 + ], + "spans": [ + { + "bbox": [ + 106, + 495, + 506, + 508 + ], + "score": 1.0, + "content": "Arjovsky, M., Shah, A., and Bengio, Y. Unitary evolution recurrent neural networks. In International", + "type": "text" + } + ], + "index": 29, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 505, + 392, + 520 + ], + "spans": [ + { + "bbox": [ + 116, + 505, + 392, + 520 + ], + "score": 1.0, + "content": "Conference on Machine Learning (ICML-16), pp. 1120–1128, 2016.", + "type": "text" + } + ], + "index": 30, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 524, + 505, + 537 + ], + "spans": [ + { + "bbox": [ + 105, + 524, + 505, + 537 + ], + "score": 1.0, + "content": "Bengio, Y., Simard, P., and Frasconi, P. Learning long-term dependencies with gradient descent is", + "type": "text" + } + ], + "index": 31, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 534, + 396, + 548 + ], + "spans": [ + { + "bbox": [ + 115, + 534, + 396, + 548 + ], + "score": 1.0, + "content": "difficult. IEEE transactions on neural networks, 5(2):157–166, 1994.", + "type": "text" + } + ], + "index": 32, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 552, + 505, + 566 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 505, + 566 + ], + "score": 1.0, + "content": "Borovykh, A., Bohte, S., and Oosterlee, C. W. Conditional time series forecasting with convolutional", + "type": "text" + } + ], + "index": 33, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 564, + 349, + 577 + ], + "spans": [ + { + "bbox": [ + 115, + 564, + 349, + 577 + ], + "score": 1.0, + "content": "neural networks. arXiv preprint arXiv:1703.04691, 2017.", + "type": "text" + } + ], + "index": 34, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 581, + 505, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 581, + 505, + 596 + ], + "score": 1.0, + "content": "Bottou, L., Soulie, F. F., Blanchet, P., and Lienard, J.-S. Speaker-independent isolated digit recog- ´", + "type": "text" + } + ], + "index": 35, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 594, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 115, + 594, + 505, + 606 + ], + "score": 1.0, + "content": "nition: Multilayer perceptrons vs. dynamic time warping. Neural Networks, 3(4):453–465, 1990.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 611, + 505, + 624 + ], + "spans": [ + { + "bbox": [ + 106, + 611, + 505, + 624 + ], + "score": 1.0, + "content": "Boulanger-Lewandowski, N., Bengio, Y., and Vincent, P. Modeling temporal dependencies in high-", + "type": "text" + } + ], + "index": 37, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 622, + 506, + 637 + ], + "spans": [ + { + "bbox": [ + 115, + 622, + 506, + 637 + ], + "score": 1.0, + "content": "dimensional sequences: Application to polyphonic music generation and transcription. arXiv", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 115, + 634, + 249, + 646 + ], + "spans": [ + { + "bbox": [ + 115, + 634, + 249, + 646 + ], + "score": 1.0, + "content": "preprint arXiv:1206.6392, 2012.", + "type": "text" + } + ], + "index": 39, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 651, + 505, + 664 + ], + "spans": [ + { + "bbox": [ + 105, + 651, + 505, + 664 + ], + "score": 1.0, + "content": "Brown, P. F., Desouza, P. V., Mercer, R. L., Pietra, V. J. D., and Lai, J. C. Class-based n-gram models", + "type": "text" + } + ], + "index": 40, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 663, + 396, + 676 + ], + "spans": [ + { + "bbox": [ + 116, + 663, + 396, + 676 + ], + "score": 1.0, + "content": "of natural language. Computational linguistics, 18(4):467–479, 1992.", + "type": "text" + } + ], + "index": 41, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 680, + 505, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 680, + 505, + 694 + ], + "score": 1.0, + "content": "Chang, S., Zhang, Y., Han, W., Yu, M., Guo, X., Tan, W., Cui, X., Witbrock, M., Hasegawa-Johnson,", + "type": "text" + } + ], + "index": 42, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 692, + 495, + 706 + ], + "spans": [ + { + "bbox": [ + 115, + 692, + 495, + 706 + ], + "score": 1.0, + "content": "M., and Huang, T. Dilated recurrent neural networks. arXiv preprint arXiv:1710.02224, 2017.", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "Cho, K., Van Merrienboer, B., Bahdanau, D., and Bengio, Y. On the properties of neural machine ¨", + "type": "text" + } + ], + "index": 44, + "is_list_start_line": true + }, + { + "bbox": [ + 117, + 721, + 443, + 733 + ], + "spans": [ + { + "bbox": [ + 117, + 721, + 443, + 733 + ], + "score": 1.0, + "content": "translation: Encoder-decoder approaches. arXiv preprint arXiv:1409.1259, 2014.", + "type": "text" + } + ], + "index": 45, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 81, + 507, + 97 + ], + "spans": [ + { + "bbox": [ + 104, + 81, + 507, + 97 + ], + "score": 1.0, + "content": "Chung, J., Gulcehre, C., Cho, K., and Bengio, Y. Empirical evaluation of gated recurrent neural", + "type": "text", + "cross_page": true + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 93, + 408, + 108 + ], + "spans": [ + { + "bbox": [ + 114, + 93, + 408, + 108 + ], + "score": 1.0, + "content": "networks on sequence modeling. arXiv preprint arXiv:1412.3555, 2014.", + "type": "text", + "cross_page": true + } + ], + "index": 1, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 112, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 112, + 505, + 128 + ], + "score": 1.0, + "content": "Chung, J., Ahn, S., and Bengio, Y. Hierarchical multiscale recurrent neural networks. arXiv preprint", + "type": "text", + "cross_page": true + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 124, + 220, + 137 + ], + "spans": [ + { + "bbox": [ + 114, + 124, + 220, + 137 + ], + "score": 1.0, + "content": "arXiv:1609.01704, 2016.", + "type": "text", + "cross_page": true + } + ], + "index": 3, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 144, + 505, + 158 + ], + "spans": [ + { + "bbox": [ + 105, + 144, + 505, + 158 + ], + "score": 1.0, + "content": "Cooijmans, T., Ballas, N., Laurent, C., Gulc¸ehre, C¸ ., and Courville, A. Recurrent batch normaliza- ¨", + "type": "text", + "cross_page": true + } + ], + "index": 4, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 155, + 397, + 168 + ], + "spans": [ + { + "bbox": [ + 114, + 155, + 397, + 168 + ], + "score": 1.0, + "content": "tion. In International Conference on Learning Representations, 2016.", + "type": "text", + "cross_page": true + } + ], + "index": 5, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "score": 1.0, + "content": "Dauphin, Y. N., Fan, A., Auli, M., and Grangier, D. Language modeling with gated convolutional", + "type": "text", + "cross_page": true + } + ], + "index": 6, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 186, + 491, + 200 + ], + "spans": [ + { + "bbox": [ + 114, + 186, + 491, + 200 + ], + "score": 1.0, + "content": "networks. In International Conference on Machine Learning (ICML-17), pp. 933–941, 2017.", + "type": "text", + "cross_page": true + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 205, + 428, + 218 + ], + "spans": [ + { + "bbox": [ + 105, + 205, + 428, + 218 + ], + "score": 1.0, + "content": "Elman, J. L. Finding structure in time. Cognitive science, 14(2):179–211, 1990.", + "type": "text", + "cross_page": true + } + ], + "index": 8, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 225, + 506, + 239 + ], + "spans": [ + { + "bbox": [ + 106, + 225, + 506, + 239 + ], + "score": 1.0, + "content": "Gehring, J., Auli, M., Grangier, D., Yarats, D., and Dauphin, Y. N. Convolutional sequence to", + "type": "text", + "cross_page": true + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 237, + 358, + 251 + ], + "spans": [ + { + "bbox": [ + 115, + 237, + 358, + 251 + ], + "score": 1.0, + "content": "sequence learning. arXiv preprint arXiv:1705.03122, 2017.", + "type": "text", + "cross_page": true + } + ], + "index": 10, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 255, + 506, + 270 + ], + "spans": [ + { + "bbox": [ + 104, + 255, + 506, + 270 + ], + "score": 1.0, + "content": "Gers, F. A., Schraudolph, N. N., and Schmidhuber, J. Learning precise timing with lstm recurrent", + "type": "text", + "cross_page": true + } + ], + "index": 11, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 267, + 410, + 280 + ], + "spans": [ + { + "bbox": [ + 114, + 267, + 410, + 280 + ], + "score": 1.0, + "content": "networks. Journal of machine learning research, 3(Aug):115–143, 2002.", + "type": "text", + "cross_page": true + } + ], + "index": 12, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 286, + 505, + 301 + ], + "spans": [ + { + "bbox": [ + 105, + 286, + 505, + 301 + ], + "score": 1.0, + "content": "Grave, E., Joulin, A., and Usunier, N. Improving neural language models with a continuous cache.", + "type": "text", + "cross_page": true + } + ], + "index": 13, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 299, + 375, + 311 + ], + "spans": [ + { + "bbox": [ + 115, + 299, + 375, + 311 + ], + "score": 1.0, + "content": "In International Conference on Learning Representations, 2016.", + "type": "text", + "cross_page": true + } + ], + "index": 14, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 317, + 505, + 331 + ], + "spans": [ + { + "bbox": [ + 106, + 317, + 505, + 331 + ], + "score": 1.0, + "content": "Greff, K., Srivastava, R. K., Koutn´ık, J., Steunebrink, B. R., and Schmidhuber, J. Lstm: A search", + "type": "text", + "cross_page": true + } + ], + "index": 15, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 330, + 448, + 342 + ], + "spans": [ + { + "bbox": [ + 114, + 330, + 448, + 342 + ], + "score": 1.0, + "content": "space odyssey. IEEE transactions on neural networks and learning systems, 2017.", + "type": "text", + "cross_page": true + } + ], + "index": 16, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 348, + 505, + 363 + ], + "spans": [ + { + "bbox": [ + 104, + 348, + 505, + 363 + ], + "score": 1.0, + "content": "Ha, D., Dai, A., and Le, Q. V. Hypernetworks. In International Conference on Learning Represen-", + "type": "text", + "cross_page": true + } + ], + "index": 17, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 359, + 175, + 373 + ], + "spans": [ + { + "bbox": [ + 114, + 359, + 175, + 373 + ], + "score": 1.0, + "content": "tations, 2017.", + "type": "text", + "cross_page": true + } + ], + "index": 18, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 379, + 506, + 393 + ], + "spans": [ + { + "bbox": [ + 104, + 379, + 506, + 393 + ], + "score": 1.0, + "content": "He, K., Zhang, X., Ren, S., and Sun, J. Deep residual learning for image recognition. In Computer", + "type": "text", + "cross_page": true + } + ], + "index": 19, + "is_list_start_line": true + }, + { + "bbox": [ + 117, + 391, + 326, + 405 + ], + "spans": [ + { + "bbox": [ + 117, + 391, + 326, + 405 + ], + "score": 1.0, + "content": "Vision and Pattern Recognition, pp. 770–778, 2016.", + "type": "text", + "cross_page": true + } + ], + "index": 20, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 410, + 493, + 424 + ], + "spans": [ + { + "bbox": [ + 105, + 410, + 493, + 424 + ], + "score": 1.0, + "content": "Hinton, G. E. Connectionist learning procedures. Artificial intelligence, 40(1-3):185–234, 1989.", + "type": "text", + "cross_page": true + } + ], + "index": 21, + "is_list_start_line": true + }, + { + "bbox": [ + 104, + 428, + 507, + 445 + ], + "spans": [ + { + "bbox": [ + 104, + 428, + 507, + 445 + ], + "score": 1.0, + "content": "Hochreiter, S. and Schmidhuber, J. Long short-term memory. Neural computation, 9(8):1735–1780,", + "type": "text", + "cross_page": true + } + ], + "index": 22, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 441, + 144, + 455 + ], + "spans": [ + { + "bbox": [ + 115, + 441, + 144, + 455 + ], + "score": 1.0, + "content": "1997.", + "type": "text", + "cross_page": true + } + ], + "index": 23, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 461, + 506, + 475 + ], + "spans": [ + { + "bbox": [ + 106, + 461, + 506, + 475 + ], + "score": 1.0, + "content": "Jing, L., Shen, Y., Dubcek, T., Peurifoy, J., Skirlo, S., LeCun, Y., Tegmark, M., and Soljaciˇ c, M. ´", + "type": "text", + "cross_page": true + } + ], + "index": 24, + "is_list_start_line": true + }, + { + "bbox": [ + 117, + 473, + 505, + 485 + ], + "spans": [ + { + "bbox": [ + 117, + 473, + 505, + 485 + ], + "score": 1.0, + "content": "Tunable efficient unitary neural networks (EUNN) and their application to RNNs. In International", + "type": "text", + "cross_page": true + } + ], + "index": 25 + }, + { + "bbox": [ + 116, + 483, + 393, + 497 + ], + "spans": [ + { + "bbox": [ + 116, + 483, + 393, + 497 + ], + "score": 1.0, + "content": "Conference on Machine Learning (ICML-17), pp. 1733–1741, 2017.", + "type": "text", + "cross_page": true + } + ], + "index": 26, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 502, + 506, + 516 + ], + "spans": [ + { + "bbox": [ + 105, + 502, + 506, + 516 + ], + "score": 1.0, + "content": "Jozefowicz, R., Zaremba, W., and Sutskever, I. An empirical exploration of recurrent network", + "type": "text", + "cross_page": true + } + ], + "index": 27, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 514, + 506, + 528 + ], + "spans": [ + { + "bbox": [ + 114, + 514, + 506, + 528 + ], + "score": 1.0, + "content": "architectures. In International Conference on Machine Learning (ICML-15), pp. 2342–2350,", + "type": "text", + "cross_page": true + } + ], + "index": 28 + }, + { + "bbox": [ + 114, + 524, + 143, + 539 + ], + "spans": [ + { + "bbox": [ + 114, + 524, + 143, + 539 + ], + "score": 1.0, + "content": "2015.", + "type": "text", + "cross_page": true + } + ], + "index": 29, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 545, + 505, + 559 + ], + "spans": [ + { + "bbox": [ + 106, + 545, + 505, + 559 + ], + "score": 1.0, + "content": "Kalchbrenner, N., Espeholt, L., Simonyan, K., Oord, A. v. d., Graves, A., and Kavukcuoglu, K.", + "type": "text", + "cross_page": true + } + ], + "index": 30, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 556, + 448, + 570 + ], + "spans": [ + { + "bbox": [ + 114, + 556, + 448, + 570 + ], + "score": 1.0, + "content": "Neural machine translation in linear time. arXiv preprint arXiv:1610.10099, 2016.", + "type": "text", + "cross_page": true + } + ], + "index": 31, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 575, + 506, + 589 + ], + "spans": [ + { + "bbox": [ + 106, + 575, + 506, + 589 + ], + "score": 1.0, + "content": "Kingma, D. and Ba, J. Adam: A method for stochastic optimization. In International Conference", + "type": "text", + "cross_page": true + } + ], + "index": 32, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 587, + 262, + 600 + ], + "spans": [ + { + "bbox": [ + 114, + 587, + 262, + 600 + ], + "score": 1.0, + "content": "on Learning Representations, 2015.", + "type": "text", + "cross_page": true + } + ], + "index": 33, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 606, + 505, + 620 + ], + "spans": [ + { + "bbox": [ + 106, + 606, + 505, + 620 + ], + "score": 1.0, + "content": "Koutnik, J., Greff, K., Gomez, F., and Schmidhuber, J. A clockwork rnn. In International Confer-", + "type": "text", + "cross_page": true + } + ], + "index": 34, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 617, + 364, + 631 + ], + "spans": [ + { + "bbox": [ + 115, + 617, + 364, + 631 + ], + "score": 1.0, + "content": "ence on Machine Learning (ICML-14), pp. 1863–1871, 2014.", + "type": "text", + "cross_page": true + } + ], + "index": 35, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 637, + 506, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 506, + 651 + ], + "score": 1.0, + "content": "Krueger, D. and Memisevic, R. Regularizing rnns by stabilizing activations. arXiv preprint", + "type": "text", + "cross_page": true + } + ], + "index": 36, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 648, + 222, + 662 + ], + "spans": [ + { + "bbox": [ + 114, + 648, + 222, + 662 + ], + "score": 1.0, + "content": "arXiv:1511.08400, 2015.", + "type": "text", + "cross_page": true + } + ], + "index": 37, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 668, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 106, + 668, + 505, + 680 + ], + "score": 1.0, + "content": "Krueger, D., Maharaj, T., Kramar, J., Pezeshki, M., Ballas, N., Ke, N. R., Goyal, A., Bengio, Y., ´", + "type": "text", + "cross_page": true + } + ], + "index": 38, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 677, + 507, + 694 + ], + "spans": [ + { + "bbox": [ + 113, + 677, + 507, + 694 + ], + "score": 1.0, + "content": "Larochelle, H., Courville, A., et al. Zoneout: Regularizing rnns by randomly preserving hidden", + "type": "text", + "cross_page": true + } + ], + "index": 39 + }, + { + "bbox": [ + 115, + 690, + 425, + 704 + ], + "spans": [ + { + "bbox": [ + 115, + 690, + 425, + 704 + ], + "score": 1.0, + "content": "activations. In International Conference on Learning Representations, 2017.", + "type": "text", + "cross_page": true + } + ], + "index": 40, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "score": 1.0, + "content": "Le, Q. V., Jaitly, N., and Hinton, G. E. A simple way to initialize recurrent networks of rectified", + "type": "text", + "cross_page": true + } + ], + "index": 41, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 720, + 330, + 734 + ], + "spans": [ + { + "bbox": [ + 115, + 720, + 330, + 734 + ], + "score": 1.0, + "content": "linear units. arXiv preprint arXiv:1504.00941, 2015.", + "type": "text", + "cross_page": true + } + ], + "index": 42, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 82, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 506, + 96 + ], + "score": 1.0, + "content": "LeCun, Y., Bengio, Y., et al. Convolutional networks for images, speech, and time series. In The", + "type": "text", + "cross_page": true + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 93, + 429, + 106 + ], + "spans": [ + { + "bbox": [ + 113, + 93, + 429, + 106 + ], + "score": 1.0, + "content": "handbook of brain theory and neural networks, volume 3361, pp. 1995. 1995.", + "type": "text", + "cross_page": true + } + ], + "index": 1, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 113, + 506, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 113, + 506, + 127 + ], + "score": 1.0, + "content": "Lecun, Y., Bottou, L., Bengio, Y., and Haffner, P. Gradient-based learning applied to document", + "type": "text", + "cross_page": true + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 124, + 372, + 138 + ], + "spans": [ + { + "bbox": [ + 114, + 124, + 372, + 138 + ], + "score": 1.0, + "content": "recognition. In Proceedings of the IEEE, pp. 2278–2324, 1998.", + "type": "text", + "cross_page": true + } + ], + "index": 3, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 145, + 506, + 159 + ], + "spans": [ + { + "bbox": [ + 105, + 145, + 506, + 159 + ], + "score": 1.0, + "content": "Long, J., Shelhamer, E., and Darrell, T. Fully convolutional networks for semantic segmentation. In", + "type": "text", + "cross_page": true + } + ], + "index": 4, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 155, + 379, + 171 + ], + "spans": [ + { + "bbox": [ + 114, + 155, + 379, + 171 + ], + "score": 1.0, + "content": "Computer Vision and Pattern Recognition, pp. 3431–3440, 2015.", + "type": "text", + "cross_page": true + } + ], + "index": 5, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 175, + 505, + 190 + ], + "spans": [ + { + "bbox": [ + 104, + 175, + 505, + 190 + ], + "score": 1.0, + "content": "Marcus, M. P., Marcinkiewicz, M. A., and Santorini, B. Building a large annotated corpus of english:", + "type": "text", + "cross_page": true + } + ], + "index": 6, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 187, + 394, + 200 + ], + "spans": [ + { + "bbox": [ + 115, + 187, + 394, + 200 + ], + "score": 1.0, + "content": "The penn treebank. Computational linguistics, 19(2):313–330, 1993.", + "type": "text", + "cross_page": true + } + ], + "index": 7, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 207, + 506, + 221 + ], + "spans": [ + { + "bbox": [ + 105, + 207, + 506, + 221 + ], + "score": 1.0, + "content": "Martens, J. and Sutskever, I. Learning recurrent neural networks with hessian-free optimization. In", + "type": "text", + "cross_page": true + } + ], + "index": 8, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 218, + 447, + 232 + ], + "spans": [ + { + "bbox": [ + 114, + 218, + 447, + 232 + ], + "score": 1.0, + "content": "International Conference on Machine Learning (ICML-11), pp. 1033–1040, 2011.", + "type": "text", + "cross_page": true + } + ], + "index": 9, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 238, + 506, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 238, + 506, + 252 + ], + "score": 1.0, + "content": "Merity, S., Xiong, C., Bradbury, J., and Socher, R. Pointer sentinel mixture models. arXiv preprint", + "type": "text", + "cross_page": true + } + ], + "index": 10, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 249, + 220, + 263 + ], + "spans": [ + { + "bbox": [ + 113, + 249, + 220, + 263 + ], + "score": 1.0, + "content": "arXiv:1609.07843, 2016.", + "type": "text", + "cross_page": true + } + ], + "index": 11, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 269, + 505, + 283 + ], + "spans": [ + { + "bbox": [ + 105, + 269, + 505, + 283 + ], + "score": 1.0, + "content": "Merity, S., Keskar, N. S., and Socher, R. Regularizing and Optimizing LSTM Language Models.", + "type": "text", + "cross_page": true + } + ], + "index": 12, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 281, + 279, + 294 + ], + "spans": [ + { + "bbox": [ + 113, + 281, + 279, + 294 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:1708.02182, 2017.", + "type": "text", + "cross_page": true + } + ], + "index": 13, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 298, + 506, + 316 + ], + "spans": [ + { + "bbox": [ + 104, + 298, + 506, + 316 + ], + "score": 1.0, + "content": "Mikolov, T., Sutskever, I., Deoras, A., Le, H.-S., Kombrink, S., and Cernocky, J. Subword language", + "type": "text", + "cross_page": true + } + ], + "index": 14, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 312, + 309, + 326 + ], + "spans": [ + { + "bbox": [ + 115, + 312, + 309, + 326 + ], + "score": 1.0, + "content": "modeling with neural networks. preprint, 2012.", + "type": "text", + "cross_page": true + } + ], + "index": 15, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 332, + 506, + 346 + ], + "spans": [ + { + "bbox": [ + 105, + 332, + 506, + 346 + ], + "score": 1.0, + "content": "Miyamoto, Y. and Cho, K. Gated word-character recurrent language model. arXiv preprint", + "type": "text", + "cross_page": true + } + ], + "index": 16, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 344, + 222, + 356 + ], + "spans": [ + { + "bbox": [ + 115, + 344, + 222, + 356 + ], + "score": 1.0, + "content": "arXiv:1606.01700, 2016.", + "type": "text", + "cross_page": true + } + ], + "index": 17, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 363, + 505, + 377 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 505, + 377 + ], + "score": 1.0, + "content": "Nair, V. and Hinton, G. E. Rectified linear units improve restricted boltzmann machines. In Inter-", + "type": "text", + "cross_page": true + } + ], + "index": 18, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 375, + 416, + 387 + ], + "spans": [ + { + "bbox": [ + 115, + 375, + 416, + 387 + ], + "score": 1.0, + "content": "national Conference on Machine Learning (ICML-10), pp. 807–814, 2010.", + "type": "text", + "cross_page": true + } + ], + "index": 19, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 394, + 506, + 408 + ], + "spans": [ + { + "bbox": [ + 106, + 394, + 506, + 408 + ], + "score": 1.0, + "content": "Oord, A. v. d., Dieleman, S., Zen, H., Simonyan, K., Vinyals, O., Graves, A., Kalchbrenner, N.,", + "type": "text", + "cross_page": true + } + ], + "index": 20, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 406, + 506, + 420 + ], + "spans": [ + { + "bbox": [ + 115, + 406, + 506, + 420 + ], + "score": 1.0, + "content": "Senior, A., and Kavukcuoglu, K. Wavenet: A generative model for raw audio. In International", + "type": "text", + "cross_page": true + } + ], + "index": 21 + }, + { + "bbox": [ + 116, + 417, + 315, + 431 + ], + "spans": [ + { + "bbox": [ + 116, + 417, + 315, + 431 + ], + "score": 1.0, + "content": "Conference on Learning Representations, 2016a.", + "type": "text", + "cross_page": true + } + ], + "index": 22, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 437, + 505, + 449 + ], + "spans": [ + { + "bbox": [ + 106, + 437, + 505, + 449 + ], + "score": 1.0, + "content": "Oord, A. v. d., Kalchbrenner, N., Vinyals, O., Espeholt, L., Graves, A., and Kavukcuoglu, K. Con-", + "type": "text", + "cross_page": true + } + ], + "index": 23, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 446, + 506, + 463 + ], + "spans": [ + { + "bbox": [ + 113, + 446, + 506, + 463 + ], + "score": 1.0, + "content": "ditional image generation with pixelcnn decoders. In Advances in Neural Information Processing", + "type": "text", + "cross_page": true + } + ], + "index": 24 + }, + { + "bbox": [ + 114, + 459, + 248, + 472 + ], + "spans": [ + { + "bbox": [ + 114, + 459, + 248, + 472 + ], + "score": 1.0, + "content": "Systems, pp. 4790–4798, 2016b.", + "type": "text", + "cross_page": true + } + ], + "index": 25, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 478, + 506, + 493 + ], + "spans": [ + { + "bbox": [ + 105, + 478, + 506, + 493 + ], + "score": 1.0, + "content": "Paperno, D., Kruszewski, G., Lazaridou, A., Pham, Q. N., Bernardi, R., Pezzelle, S., Baroni, M.,", + "type": "text", + "cross_page": true + } + ], + "index": 26, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 489, + 506, + 504 + ], + "spans": [ + { + "bbox": [ + 114, + 489, + 506, + 504 + ], + "score": 1.0, + "content": "Boleda, G., and Fernandez, R. The lambada dataset: Word prediction requiring a broad discourse ´", + "type": "text", + "cross_page": true + } + ], + "index": 27 + }, + { + "bbox": [ + 115, + 500, + 314, + 514 + ], + "spans": [ + { + "bbox": [ + 115, + 500, + 314, + 514 + ], + "score": 1.0, + "content": "context. arXiv preprint arXiv:1606.06031, 2016.", + "type": "text", + "cross_page": true + } + ], + "index": 28, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 521, + 506, + 535 + ], + "spans": [ + { + "bbox": [ + 105, + 521, + 506, + 535 + ], + "score": 1.0, + "content": "Pascanu, R., Mikolov, T., and Bengio, Y. On the difficulty of training recurrent neural networks. In", + "type": "text", + "cross_page": true + } + ], + "index": 29, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 532, + 447, + 545 + ], + "spans": [ + { + "bbox": [ + 113, + 532, + 447, + 545 + ], + "score": 1.0, + "content": "International Conference on Machine Learning (ICML-13), pp. 1310–1318, 2013.", + "type": "text", + "cross_page": true + } + ], + "index": 30, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 552, + 506, + 566 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 506, + 566 + ], + "score": 1.0, + "content": "Press, O. and Wolf, L. Using the output embedding to improve language models. arXiv preprint", + "type": "text", + "cross_page": true + } + ], + "index": 31, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 563, + 221, + 577 + ], + "spans": [ + { + "bbox": [ + 114, + 563, + 221, + 577 + ], + "score": 1.0, + "content": "arXiv:1608.05859, 2016.", + "type": "text", + "cross_page": true + } + ], + "index": 32, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 584, + 505, + 596 + ], + "spans": [ + { + "bbox": [ + 106, + 584, + 505, + 596 + ], + "score": 1.0, + "content": "Salimans, T. and Kingma, D. P. Weight normalization: A simple reparameterization to accelerate", + "type": "text", + "cross_page": true + } + ], + "index": 33, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 592, + 506, + 610 + ], + "spans": [ + { + "bbox": [ + 113, + 592, + 506, + 610 + ], + "score": 1.0, + "content": "training of deep neural networks. In Advances in Neural Information Processing Systems, pp.", + "type": "text", + "cross_page": true + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 605, + 183, + 619 + ], + "spans": [ + { + "bbox": [ + 115, + 605, + 183, + 619 + ], + "score": 1.0, + "content": "901–909. 2016.", + "type": "text", + "cross_page": true + } + ], + "index": 35, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 625, + 506, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 625, + 506, + 639 + ], + "score": 1.0, + "content": "Srivastava, N., Hinton, G. E., Krizhevsky, A., Sutskever, I., and Salakhutdinov, R. Dropout: a simple", + "type": "text", + "cross_page": true + } + ], + "index": 36, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 636, + 506, + 650 + ], + "spans": [ + { + "bbox": [ + 115, + 636, + 506, + 650 + ], + "score": 1.0, + "content": "way to prevent neural networks from overfitting. Journal of machine learning research, 15(1):", + "type": "text", + "cross_page": true + } + ], + "index": 37 + }, + { + "bbox": [ + 116, + 647, + 192, + 661 + ], + "spans": [ + { + "bbox": [ + 116, + 647, + 192, + 661 + ], + "score": 1.0, + "content": "1929–1958, 2014.", + "type": "text", + "cross_page": true + } + ], + "index": 38, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 667, + 506, + 681 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 506, + 681 + ], + "score": 1.0, + "content": "Subakan, Y. C. and Smaragdis, P. Diagonal rnns in symbolic music modeling. arXiv preprint", + "type": "text", + "cross_page": true + } + ], + "index": 39, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 678, + 221, + 693 + ], + "spans": [ + { + "bbox": [ + 114, + 678, + 221, + 693 + ], + "score": 1.0, + "content": "arXiv:1704.05420, 2017.", + "type": "text", + "cross_page": true + } + ], + "index": 40, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 696, + 506, + 713 + ], + "spans": [ + { + "bbox": [ + 104, + 696, + 506, + 713 + ], + "score": 1.0, + "content": "Vohra, R., Goel, K., and Sahoo, J. Modeling temporal dependencies in data using a dbn-lstm. In", + "type": "text", + "cross_page": true + } + ], + "index": 41, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 709, + 506, + 724 + ], + "spans": [ + { + "bbox": [ + 114, + 709, + 506, + 724 + ], + "score": 1.0, + "content": "Data Science and Advanced Analytics (DSAA), 2015. 36678 2015. IEEE International Conference", + "type": "text", + "cross_page": true + } + ], + "index": 42 + }, + { + "bbox": [ + 114, + 720, + 218, + 732 + ], + "spans": [ + { + "bbox": [ + 114, + 720, + 218, + 732 + ], + "score": 1.0, + "content": "on, pp. 1–4. IEEE, 2015.", + "type": "text", + "cross_page": true + } + ], + "index": 43, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "score": 1.0, + "content": "Waibel, A., Hanazawa, T., Hinton, G., Shikano, K., and Lang, K. J. Phoneme recognition using", + "type": "text", + "cross_page": true + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 116, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "time-delay neural networks. IEEE transactions on acoustics, speech, and signal processing, 37", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 117, + 105, + 195, + 117 + ], + "spans": [ + { + "bbox": [ + 117, + 105, + 195, + 117 + ], + "score": 1.0, + "content": "(3):328–339, 1989.", + "type": "text", + "cross_page": true + } + ], + "index": 2, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 123, + 505, + 136 + ], + "spans": [ + { + "bbox": [ + 106, + 123, + 505, + 136 + ], + "score": 1.0, + "content": "Wisdom, S., Powers, T., Hershey, J., Le Roux, J., and Atlas, L. Full-capacity unitary recurrent neural", + "type": "text", + "cross_page": true + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 134, + 474, + 147 + ], + "spans": [ + { + "bbox": [ + 115, + 134, + 474, + 147 + ], + "score": 1.0, + "content": "networks. In Advances in Neural Information Processing Systems, pp. 4880–4888, 2016.", + "type": "text", + "cross_page": true + } + ], + "index": 4, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 153, + 505, + 166 + ], + "spans": [ + { + "bbox": [ + 106, + 153, + 505, + 166 + ], + "score": 1.0, + "content": "Wu, Y., Zhang, S., Zhang, Y., Bengio, Y., and Salakhutdinov, R. R. On multiplicative integration", + "type": "text", + "cross_page": true + } + ], + "index": 5, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 164, + 505, + 177 + ], + "spans": [ + { + "bbox": [ + 115, + 164, + 505, + 177 + ], + "score": 1.0, + "content": "with recurrent neural networks. In Advances in Neural Information Processing Systems, pp. 2856–", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 116, + 174, + 166, + 187 + ], + "spans": [ + { + "bbox": [ + 116, + 174, + 166, + 187 + ], + "score": 1.0, + "content": "2864, 2016.", + "type": "text", + "cross_page": true + } + ], + "index": 7, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 194, + 505, + 207 + ], + "spans": [ + { + "bbox": [ + 106, + 194, + 505, + 207 + ], + "score": 1.0, + "content": "Yu, F. and Koltun, V. Multi-scale context aggregation by dilated convolutions. In International", + "type": "text", + "cross_page": true + } + ], + "index": 8, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 205, + 311, + 217 + ], + "spans": [ + { + "bbox": [ + 116, + 205, + 311, + 217 + ], + "score": 1.0, + "content": "Conference on Learning Representations, 2015.", + "type": "text", + "cross_page": true + } + ], + "index": 9, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 224, + 505, + 236 + ], + "spans": [ + { + "bbox": [ + 106, + 224, + 505, + 236 + ], + "score": 1.0, + "content": "Zhang, S., Wu, Y., Che, T., Lin, Z., Memisevic, R., Salakhutdinov, R. R., and Bengio, Y. Archi-", + "type": "text", + "cross_page": true + } + ], + "index": 10, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 235, + 505, + 248 + ], + "spans": [ + { + "bbox": [ + 116, + 235, + 505, + 248 + ], + "score": 1.0, + "content": "tectural complexity measures of recurrent neural networks. In Advances in Neural Information", + "type": "text", + "cross_page": true + } + ], + "index": 11 + }, + { + "bbox": [ + 116, + 246, + 289, + 258 + ], + "spans": [ + { + "bbox": [ + 116, + 246, + 289, + 258 + ], + "score": 1.0, + "content": "Processing Systems, pp. 1822–1830. 2016.", + "type": "text", + "cross_page": true + } + ], + "index": 12, + "is_list_end_line": true + } + ], + "index": 36, + "bbox_fs": [ + 105, + 465, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 61, + 507, + 733 + ], + "lines": [ + { + "bbox": [ + 104, + 81, + 507, + 97 + ], + "spans": [ + { + "bbox": [ + 104, + 81, + 507, + 97 + ], + "score": 1.0, + "content": "Chung, J., Gulcehre, C., Cho, K., and Bengio, Y. Empirical evaluation of gated recurrent neural", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 114, + 93, + 408, + 108 + ], + "spans": [ + { + "bbox": [ + 114, + 93, + 408, + 108 + ], + "score": 1.0, + "content": "networks on sequence modeling. arXiv preprint arXiv:1412.3555, 2014.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 112, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 112, + 505, + 128 + ], + "score": 1.0, + "content": "Chung, J., Ahn, S., and Bengio, Y. Hierarchical multiscale recurrent neural networks. arXiv preprint", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 114, + 124, + 220, + 137 + ], + "spans": [ + { + "bbox": [ + 114, + 124, + 220, + 137 + ], + "score": 1.0, + "content": "arXiv:1609.01704, 2016.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 144, + 505, + 158 + ], + "spans": [ + { + "bbox": [ + 105, + 144, + 505, + 158 + ], + "score": 1.0, + "content": "Cooijmans, T., Ballas, N., Laurent, C., Gulc¸ehre, C¸ ., and Courville, A. Recurrent batch normaliza- ¨", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 114, + 155, + 397, + 168 + ], + "spans": [ + { + "bbox": [ + 114, + 155, + 397, + 168 + ], + "score": 1.0, + "content": "tion. In International Conference on Learning Representations, 2016.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "spans": [ + { + "bbox": [ + 105, + 175, + 505, + 189 + ], + "score": 1.0, + "content": "Dauphin, Y. N., Fan, A., Auli, M., and Grangier, D. Language modeling with gated convolutional", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 114, + 186, + 491, + 200 + ], + "spans": [ + { + "bbox": [ + 114, + 186, + 491, + 200 + ], + "score": 1.0, + "content": "networks. In International Conference on Machine Learning (ICML-17), pp. 933–941, 2017.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 205, + 428, + 218 + ], + "spans": [ + { + "bbox": [ + 105, + 205, + 428, + 218 + ], + "score": 1.0, + "content": "Elman, J. L. Finding structure in time. Cognitive science, 14(2):179–211, 1990.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 225, + 506, + 239 + ], + "spans": [ + { + "bbox": [ + 106, + 225, + 506, + 239 + ], + "score": 1.0, + "content": "Gehring, J., Auli, M., Grangier, D., Yarats, D., and Dauphin, Y. N. Convolutional sequence to", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 237, + 358, + 251 + ], + "spans": [ + { + "bbox": [ + 115, + 237, + 358, + 251 + ], + "score": 1.0, + "content": "sequence learning. arXiv preprint arXiv:1705.03122, 2017.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 104, + 255, + 506, + 270 + ], + "spans": [ + { + "bbox": [ + 104, + 255, + 506, + 270 + ], + "score": 1.0, + "content": "Gers, F. A., Schraudolph, N. N., and Schmidhuber, J. Learning precise timing with lstm recurrent", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 114, + 267, + 410, + 280 + ], + "spans": [ + { + "bbox": [ + 114, + 267, + 410, + 280 + ], + "score": 1.0, + "content": "networks. Journal of machine learning research, 3(Aug):115–143, 2002.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 286, + 505, + 301 + ], + "spans": [ + { + "bbox": [ + 105, + 286, + 505, + 301 + ], + "score": 1.0, + "content": "Grave, E., Joulin, A., and Usunier, N. Improving neural language models with a continuous cache.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 115, + 299, + 375, + 311 + ], + "spans": [ + { + "bbox": [ + 115, + 299, + 375, + 311 + ], + "score": 1.0, + "content": "In International Conference on Learning Representations, 2016.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 317, + 505, + 331 + ], + "spans": [ + { + "bbox": [ + 106, + 317, + 505, + 331 + ], + "score": 1.0, + "content": "Greff, K., Srivastava, R. K., Koutn´ık, J., Steunebrink, B. R., and Schmidhuber, J. Lstm: A search", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 114, + 330, + 448, + 342 + ], + "spans": [ + { + "bbox": [ + 114, + 330, + 448, + 342 + ], + "score": 1.0, + "content": "space odyssey. IEEE transactions on neural networks and learning systems, 2017.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 104, + 348, + 505, + 363 + ], + "spans": [ + { + "bbox": [ + 104, + 348, + 505, + 363 + ], + "score": 1.0, + "content": "Ha, D., Dai, A., and Le, Q. V. Hypernetworks. In International Conference on Learning Represen-", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 114, + 359, + 175, + 373 + ], + "spans": [ + { + "bbox": [ + 114, + 359, + 175, + 373 + ], + "score": 1.0, + "content": "tations, 2017.", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 104, + 379, + 506, + 393 + ], + "spans": [ + { + "bbox": [ + 104, + 379, + 506, + 393 + ], + "score": 1.0, + "content": "He, K., Zhang, X., Ren, S., and Sun, J. Deep residual learning for image recognition. In Computer", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 117, + 391, + 326, + 405 + ], + "spans": [ + { + "bbox": [ + 117, + 391, + 326, + 405 + ], + "score": 1.0, + "content": "Vision and Pattern Recognition, pp. 770–778, 2016.", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 410, + 493, + 424 + ], + "spans": [ + { + "bbox": [ + 105, + 410, + 493, + 424 + ], + "score": 1.0, + "content": "Hinton, G. E. Connectionist learning procedures. Artificial intelligence, 40(1-3):185–234, 1989.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 104, + 428, + 507, + 445 + ], + "spans": [ + { + "bbox": [ + 104, + 428, + 507, + 445 + ], + "score": 1.0, + "content": "Hochreiter, S. and Schmidhuber, J. Long short-term memory. Neural computation, 9(8):1735–1780,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 115, + 441, + 144, + 455 + ], + "spans": [ + { + "bbox": [ + 115, + 441, + 144, + 455 + ], + "score": 1.0, + "content": "1997.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 461, + 506, + 475 + ], + "spans": [ + { + "bbox": [ + 106, + 461, + 506, + 475 + ], + "score": 1.0, + "content": "Jing, L., Shen, Y., Dubcek, T., Peurifoy, J., Skirlo, S., LeCun, Y., Tegmark, M., and Soljaciˇ c, M. ´", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 117, + 473, + 505, + 485 + ], + "spans": [ + { + "bbox": [ + 117, + 473, + 505, + 485 + ], + "score": 1.0, + "content": "Tunable efficient unitary neural networks (EUNN) and their application to RNNs. In International", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 116, + 483, + 393, + 497 + ], + "spans": [ + { + "bbox": [ + 116, + 483, + 393, + 497 + ], + "score": 1.0, + "content": "Conference on Machine Learning (ICML-17), pp. 1733–1741, 2017.", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 502, + 506, + 516 + ], + "spans": [ + { + "bbox": [ + 105, + 502, + 506, + 516 + ], + "score": 1.0, + "content": "Jozefowicz, R., Zaremba, W., and Sutskever, I. An empirical exploration of recurrent network", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 114, + 514, + 506, + 528 + ], + "spans": [ + { + "bbox": [ + 114, + 514, + 506, + 528 + ], + "score": 1.0, + "content": "architectures. In International Conference on Machine Learning (ICML-15), pp. 2342–2350,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 114, + 524, + 143, + 539 + ], + "spans": [ + { + "bbox": [ + 114, + 524, + 143, + 539 + ], + "score": 1.0, + "content": "2015.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 545, + 505, + 559 + ], + "spans": [ + { + "bbox": [ + 106, + 545, + 505, + 559 + ], + "score": 1.0, + "content": "Kalchbrenner, N., Espeholt, L., Simonyan, K., Oord, A. v. d., Graves, A., and Kavukcuoglu, K.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 114, + 556, + 448, + 570 + ], + "spans": [ + { + "bbox": [ + 114, + 556, + 448, + 570 + ], + "score": 1.0, + "content": "Neural machine translation in linear time. arXiv preprint arXiv:1610.10099, 2016.", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 575, + 506, + 589 + ], + "spans": [ + { + "bbox": [ + 106, + 575, + 506, + 589 + ], + "score": 1.0, + "content": "Kingma, D. and Ba, J. Adam: A method for stochastic optimization. In International Conference", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 114, + 587, + 262, + 600 + ], + "spans": [ + { + "bbox": [ + 114, + 587, + 262, + 600 + ], + "score": 1.0, + "content": "on Learning Representations, 2015.", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 606, + 505, + 620 + ], + "spans": [ + { + "bbox": [ + 106, + 606, + 505, + 620 + ], + "score": 1.0, + "content": "Koutnik, J., Greff, K., Gomez, F., and Schmidhuber, J. A clockwork rnn. In International Confer-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 617, + 364, + 631 + ], + "spans": [ + { + "bbox": [ + 115, + 617, + 364, + 631 + ], + "score": 1.0, + "content": "ence on Machine Learning (ICML-14), pp. 1863–1871, 2014.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 637, + 506, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 506, + 651 + ], + "score": 1.0, + "content": "Krueger, D. and Memisevic, R. Regularizing rnns by stabilizing activations. arXiv preprint", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 114, + 648, + 222, + 662 + ], + "spans": [ + { + "bbox": [ + 114, + 648, + 222, + 662 + ], + "score": 1.0, + "content": "arXiv:1511.08400, 2015.", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 668, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 106, + 668, + 505, + 680 + ], + "score": 1.0, + "content": "Krueger, D., Maharaj, T., Kramar, J., Pezeshki, M., Ballas, N., Ke, N. R., Goyal, A., Bengio, Y., ´", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 113, + 677, + 507, + 694 + ], + "spans": [ + { + "bbox": [ + 113, + 677, + 507, + 694 + ], + "score": 1.0, + "content": "Larochelle, H., Courville, A., et al. Zoneout: Regularizing rnns by randomly preserving hidden", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 115, + 690, + 425, + 704 + ], + "spans": [ + { + "bbox": [ + 115, + 690, + 425, + 704 + ], + "score": 1.0, + "content": "activations. In International Conference on Learning Representations, 2017.", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "score": 1.0, + "content": "Le, Q. V., Jaitly, N., and Hinton, G. E. A simple way to initialize recurrent networks of rectified", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 720, + 330, + 734 + ], + "spans": [ + { + "bbox": [ + 115, + 720, + 330, + 734 + ], + "score": 1.0, + "content": "linear units. arXiv preprint arXiv:1504.00941, 2015.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 21 + } + ], + "page_idx": 11, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 308, + 38 + ], + "lines": [ + { + "bbox": [ + 107, + 25, + 308, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 25, + 308, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 761 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "12", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "list", + "bbox": [ + 105, + 61, + 507, + 733 + ], + "lines": [], + "index": 21, + "bbox_fs": [ + 104, + 81, + 507, + 734 + ], + "lines_deleted": true + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 104, + 62, + 507, + 740 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 506, + 96 + ], + "score": 1.0, + "content": "LeCun, Y., Bengio, Y., et al. Convolutional networks for images, speech, and time series. In The", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 113, + 93, + 429, + 106 + ], + "spans": [ + { + "bbox": [ + 113, + 93, + 429, + 106 + ], + "score": 1.0, + "content": "handbook of brain theory and neural networks, volume 3361, pp. 1995. 1995.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 113, + 506, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 113, + 506, + 127 + ], + "score": 1.0, + "content": "Lecun, Y., Bottou, L., Bengio, Y., and Haffner, P. Gradient-based learning applied to document", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 114, + 124, + 372, + 138 + ], + "spans": [ + { + "bbox": [ + 114, + 124, + 372, + 138 + ], + "score": 1.0, + "content": "recognition. In Proceedings of the IEEE, pp. 2278–2324, 1998.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 145, + 506, + 159 + ], + "spans": [ + { + "bbox": [ + 105, + 145, + 506, + 159 + ], + "score": 1.0, + "content": "Long, J., Shelhamer, E., and Darrell, T. Fully convolutional networks for semantic segmentation. In", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 114, + 155, + 379, + 171 + ], + "spans": [ + { + "bbox": [ + 114, + 155, + 379, + 171 + ], + "score": 1.0, + "content": "Computer Vision and Pattern Recognition, pp. 3431–3440, 2015.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 104, + 175, + 505, + 190 + ], + "spans": [ + { + "bbox": [ + 104, + 175, + 505, + 190 + ], + "score": 1.0, + "content": "Marcus, M. P., Marcinkiewicz, M. A., and Santorini, B. Building a large annotated corpus of english:", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 115, + 187, + 394, + 200 + ], + "spans": [ + { + "bbox": [ + 115, + 187, + 394, + 200 + ], + "score": 1.0, + "content": "The penn treebank. Computational linguistics, 19(2):313–330, 1993.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 207, + 506, + 221 + ], + "spans": [ + { + "bbox": [ + 105, + 207, + 506, + 221 + ], + "score": 1.0, + "content": "Martens, J. and Sutskever, I. Learning recurrent neural networks with hessian-free optimization. In", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 114, + 218, + 447, + 232 + ], + "spans": [ + { + "bbox": [ + 114, + 218, + 447, + 232 + ], + "score": 1.0, + "content": "International Conference on Machine Learning (ICML-11), pp. 1033–1040, 2011.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 238, + 506, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 238, + 506, + 252 + ], + "score": 1.0, + "content": "Merity, S., Xiong, C., Bradbury, J., and Socher, R. Pointer sentinel mixture models. arXiv preprint", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 113, + 249, + 220, + 263 + ], + "spans": [ + { + "bbox": [ + 113, + 249, + 220, + 263 + ], + "score": 1.0, + "content": "arXiv:1609.07843, 2016.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 269, + 505, + 283 + ], + "spans": [ + { + "bbox": [ + 105, + 269, + 505, + 283 + ], + "score": 1.0, + "content": "Merity, S., Keskar, N. S., and Socher, R. Regularizing and Optimizing LSTM Language Models.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 113, + 281, + 279, + 294 + ], + "spans": [ + { + "bbox": [ + 113, + 281, + 279, + 294 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:1708.02182, 2017.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 104, + 298, + 506, + 316 + ], + "spans": [ + { + "bbox": [ + 104, + 298, + 506, + 316 + ], + "score": 1.0, + "content": "Mikolov, T., Sutskever, I., Deoras, A., Le, H.-S., Kombrink, S., and Cernocky, J. Subword language", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 312, + 309, + 326 + ], + "spans": [ + { + "bbox": [ + 115, + 312, + 309, + 326 + ], + "score": 1.0, + "content": "modeling with neural networks. preprint, 2012.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 332, + 506, + 346 + ], + "spans": [ + { + "bbox": [ + 105, + 332, + 506, + 346 + ], + "score": 1.0, + "content": "Miyamoto, Y. and Cho, K. Gated word-character recurrent language model. arXiv preprint", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 115, + 344, + 222, + 356 + ], + "spans": [ + { + "bbox": [ + 115, + 344, + 222, + 356 + ], + "score": 1.0, + "content": "arXiv:1606.01700, 2016.", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 363, + 505, + 377 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 505, + 377 + ], + "score": 1.0, + "content": "Nair, V. and Hinton, G. E. Rectified linear units improve restricted boltzmann machines. In Inter-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 115, + 375, + 416, + 387 + ], + "spans": [ + { + "bbox": [ + 115, + 375, + 416, + 387 + ], + "score": 1.0, + "content": "national Conference on Machine Learning (ICML-10), pp. 807–814, 2010.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 394, + 506, + 408 + ], + "spans": [ + { + "bbox": [ + 106, + 394, + 506, + 408 + ], + "score": 1.0, + "content": "Oord, A. v. d., Dieleman, S., Zen, H., Simonyan, K., Vinyals, O., Graves, A., Kalchbrenner, N.,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 115, + 406, + 506, + 420 + ], + "spans": [ + { + "bbox": [ + 115, + 406, + 506, + 420 + ], + "score": 1.0, + "content": "Senior, A., and Kavukcuoglu, K. Wavenet: A generative model for raw audio. In International", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 116, + 417, + 315, + 431 + ], + "spans": [ + { + "bbox": [ + 116, + 417, + 315, + 431 + ], + "score": 1.0, + "content": "Conference on Learning Representations, 2016a.", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 437, + 505, + 449 + ], + "spans": [ + { + "bbox": [ + 106, + 437, + 505, + 449 + ], + "score": 1.0, + "content": "Oord, A. v. d., Kalchbrenner, N., Vinyals, O., Espeholt, L., Graves, A., and Kavukcuoglu, K. Con-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 113, + 446, + 506, + 463 + ], + "spans": [ + { + "bbox": [ + 113, + 446, + 506, + 463 + ], + "score": 1.0, + "content": "ditional image generation with pixelcnn decoders. In Advances in Neural Information Processing", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 114, + 459, + 248, + 472 + ], + "spans": [ + { + "bbox": [ + 114, + 459, + 248, + 472 + ], + "score": 1.0, + "content": "Systems, pp. 4790–4798, 2016b.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 478, + 506, + 493 + ], + "spans": [ + { + "bbox": [ + 105, + 478, + 506, + 493 + ], + "score": 1.0, + "content": "Paperno, D., Kruszewski, G., Lazaridou, A., Pham, Q. N., Bernardi, R., Pezzelle, S., Baroni, M.,", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 114, + 489, + 506, + 504 + ], + "spans": [ + { + "bbox": [ + 114, + 489, + 506, + 504 + ], + "score": 1.0, + "content": "Boleda, G., and Fernandez, R. The lambada dataset: Word prediction requiring a broad discourse ´", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 115, + 500, + 314, + 514 + ], + "spans": [ + { + "bbox": [ + 115, + 500, + 314, + 514 + ], + "score": 1.0, + "content": "context. arXiv preprint arXiv:1606.06031, 2016.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 521, + 506, + 535 + ], + "spans": [ + { + "bbox": [ + 105, + 521, + 506, + 535 + ], + "score": 1.0, + "content": "Pascanu, R., Mikolov, T., and Bengio, Y. On the difficulty of training recurrent neural networks. In", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 113, + 532, + 447, + 545 + ], + "spans": [ + { + "bbox": [ + 113, + 532, + 447, + 545 + ], + "score": 1.0, + "content": "International Conference on Machine Learning (ICML-13), pp. 1310–1318, 2013.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 552, + 506, + 566 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 506, + 566 + ], + "score": 1.0, + "content": "Press, O. and Wolf, L. Using the output embedding to improve language models. arXiv preprint", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 114, + 563, + 221, + 577 + ], + "spans": [ + { + "bbox": [ + 114, + 563, + 221, + 577 + ], + "score": 1.0, + "content": "arXiv:1608.05859, 2016.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 584, + 505, + 596 + ], + "spans": [ + { + "bbox": [ + 106, + 584, + 505, + 596 + ], + "score": 1.0, + "content": "Salimans, T. and Kingma, D. P. Weight normalization: A simple reparameterization to accelerate", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 113, + 592, + 506, + 610 + ], + "spans": [ + { + "bbox": [ + 113, + 592, + 506, + 610 + ], + "score": 1.0, + "content": "training of deep neural networks. In Advances in Neural Information Processing Systems, pp.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 605, + 183, + 619 + ], + "spans": [ + { + "bbox": [ + 115, + 605, + 183, + 619 + ], + "score": 1.0, + "content": "901–909. 2016.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 625, + 506, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 625, + 506, + 639 + ], + "score": 1.0, + "content": "Srivastava, N., Hinton, G. E., Krizhevsky, A., Sutskever, I., and Salakhutdinov, R. Dropout: a simple", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 115, + 636, + 506, + 650 + ], + "spans": [ + { + "bbox": [ + 115, + 636, + 506, + 650 + ], + "score": 1.0, + "content": "way to prevent neural networks from overfitting. Journal of machine learning research, 15(1):", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 116, + 647, + 192, + 661 + ], + "spans": [ + { + "bbox": [ + 116, + 647, + 192, + 661 + ], + "score": 1.0, + "content": "1929–1958, 2014.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 667, + 506, + 681 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 506, + 681 + ], + "score": 1.0, + "content": "Subakan, Y. C. and Smaragdis, P. Diagonal rnns in symbolic music modeling. arXiv preprint", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 114, + 678, + 221, + 693 + ], + "spans": [ + { + "bbox": [ + 114, + 678, + 221, + 693 + ], + "score": 1.0, + "content": "arXiv:1704.05420, 2017.", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 104, + 696, + 506, + 713 + ], + "spans": [ + { + "bbox": [ + 104, + 696, + 506, + 713 + ], + "score": 1.0, + "content": "Vohra, R., Goel, K., and Sahoo, J. Modeling temporal dependencies in data using a dbn-lstm. In", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 114, + 709, + 506, + 724 + ], + "spans": [ + { + "bbox": [ + 114, + 709, + 506, + 724 + ], + "score": 1.0, + "content": "Data Science and Advanced Analytics (DSAA), 2015. 36678 2015. IEEE International Conference", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 114, + 720, + 218, + 732 + ], + "spans": [ + { + "bbox": [ + 114, + 720, + 218, + 732 + ], + "score": 1.0, + "content": "on, pp. 1–4. IEEE, 2015.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 21.5 + } + ], + "page_idx": 12, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 27, + 308, + 38 + ], + "lines": [ + { + "bbox": [ + 107, + 25, + 309, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 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": "13", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "list", + "bbox": [ + 104, + 62, + 507, + 740 + ], + "lines": [], + "index": 21.5, + "bbox_fs": [ + 104, + 82, + 506, + 732 + ], + "lines_deleted": true + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 506, + 258 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 505, + 96 + ], + "score": 1.0, + "content": "Waibel, A., Hanazawa, T., Hinton, G., Shikano, K., and Lang, K. J. Phoneme recognition using", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 116, + 93, + 505, + 106 + ], + "spans": [ + { + "bbox": [ + 116, + 93, + 505, + 106 + ], + "score": 1.0, + "content": "time-delay neural networks. IEEE transactions on acoustics, speech, and signal processing, 37", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 117, + 105, + 195, + 117 + ], + "spans": [ + { + "bbox": [ + 117, + 105, + 195, + 117 + ], + "score": 1.0, + "content": "(3):328–339, 1989.", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 123, + 505, + 136 + ], + "spans": [ + { + "bbox": [ + 106, + 123, + 505, + 136 + ], + "score": 1.0, + "content": "Wisdom, S., Powers, T., Hershey, J., Le Roux, J., and Atlas, L. Full-capacity unitary recurrent neural", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 115, + 134, + 474, + 147 + ], + "spans": [ + { + "bbox": [ + 115, + 134, + 474, + 147 + ], + "score": 1.0, + "content": "networks. In Advances in Neural Information Processing Systems, pp. 4880–4888, 2016.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 153, + 505, + 166 + ], + "spans": [ + { + "bbox": [ + 106, + 153, + 505, + 166 + ], + "score": 1.0, + "content": "Wu, Y., Zhang, S., Zhang, Y., Bengio, Y., and Salakhutdinov, R. R. On multiplicative integration", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 164, + 505, + 177 + ], + "spans": [ + { + "bbox": [ + 115, + 164, + 505, + 177 + ], + "score": 1.0, + "content": "with recurrent neural networks. In Advances in Neural Information Processing Systems, pp. 2856–", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 116, + 174, + 166, + 187 + ], + "spans": [ + { + "bbox": [ + 116, + 174, + 166, + 187 + ], + "score": 1.0, + "content": "2864, 2016.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 194, + 505, + 207 + ], + "spans": [ + { + "bbox": [ + 106, + 194, + 505, + 207 + ], + "score": 1.0, + "content": "Yu, F. and Koltun, V. Multi-scale context aggregation by dilated convolutions. In International", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 116, + 205, + 311, + 217 + ], + "spans": [ + { + "bbox": [ + 116, + 205, + 311, + 217 + ], + "score": 1.0, + "content": "Conference on Learning Representations, 2015.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 224, + 505, + 236 + ], + "spans": [ + { + "bbox": [ + 106, + 224, + 505, + 236 + ], + "score": 1.0, + "content": "Zhang, S., Wu, Y., Che, T., Lin, Z., Memisevic, R., Salakhutdinov, R. R., and Bengio, Y. Archi-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 116, + 235, + 505, + 248 + ], + "spans": [ + { + "bbox": [ + 116, + 235, + 505, + 248 + ], + "score": 1.0, + "content": "tectural complexity measures of recurrent neural networks. In Advances in Neural Information", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 116, + 246, + 289, + 258 + ], + "spans": [ + { + "bbox": [ + 116, + 246, + 289, + 258 + ], + "score": 1.0, + "content": "Processing Systems, pp. 1822–1830. 2016.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 6 + } + ], + "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": "list", + "bbox": [ + 105, + 82, + 506, + 258 + ], + "lines": [], + "index": 6, + "bbox_fs": [ + 105, + 81, + 505, + 258 + ], + "lines_deleted": true + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 82, + 320, + 93 + ], + "lines": [ + { + "bbox": [ + 106, + 81, + 322, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 322, + 95 + ], + "score": 1.0, + "content": "A DESCRIPTION OF BENCHMARK TASKS", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 108, + 505, + 185 + ], + "lines": [ + { + "bbox": [ + 106, + 108, + 504, + 120 + ], + "spans": [ + { + "bbox": [ + 106, + 108, + 378, + 120 + ], + "score": 1.0, + "content": "The Adding Problem: In this task, each input consists of a length-", + "type": "text" + }, + { + "bbox": [ + 378, + 110, + 385, + 118 + ], + "score": 0.74, + "content": "\\mathbf { \\nabla } \\cdot n", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 108, + 504, + 120 + ], + "score": 1.0, + "content": "sequence of depth 2, with all", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 119, + 505, + 131 + ], + "spans": [ + { + "bbox": [ + 106, + 119, + 505, + 131 + ], + "score": 1.0, + "content": "values randomly chosen in [0, 1], and the second dimension being all zeros expect for two elements", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 130, + 505, + 142 + ], + "spans": [ + { + "bbox": [ + 105, + 130, + 505, + 142 + ], + "score": 1.0, + "content": "that are marked by 1. The objective is to sum the two random values whose second dimensions", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 141, + 506, + 153 + ], + "spans": [ + { + "bbox": [ + 105, + 141, + 506, + 153 + ], + "score": 1.0, + "content": "are marked by 1. Simply predicting the sum to be 1 should give an MSE of about 0.1767. First", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 151, + 505, + 163 + ], + "spans": [ + { + "bbox": [ + 105, + 151, + 505, + 163 + ], + "score": 1.0, + "content": "introduced by Hochreiter & Schmidhuber (1997), the addition problem have been consistently used", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 163, + 505, + 175 + ], + "spans": [ + { + "bbox": [ + 105, + 163, + 505, + 175 + ], + "score": 1.0, + "content": "as a pathological test for evaluating sequential models (Pascanu et al., 2013; Le et al., 2015; Zhang", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 173, + 248, + 187 + ], + "spans": [ + { + "bbox": [ + 105, + 173, + 248, + 187 + ], + "score": 1.0, + "content": "et al., 2016; Arjovsky et al., 2016).", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 107, + 190, + 505, + 256 + ], + "lines": [ + { + "bbox": [ + 106, + 190, + 505, + 202 + ], + "spans": [ + { + "bbox": [ + 106, + 190, + 505, + 202 + ], + "score": 1.0, + "content": "Sequential MNIST & P-MNIST: Sequential MNIST is frequently used to test a recurrent network’s", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 201, + 505, + 214 + ], + "spans": [ + { + "bbox": [ + 105, + 201, + 505, + 214 + ], + "score": 1.0, + "content": "ability to combine its information from a long memory context in order to make classification pre-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 212, + 505, + 225 + ], + "spans": [ + { + "bbox": [ + 105, + 212, + 505, + 225 + ], + "score": 1.0, + "content": "diction (Le et al., 2015; Zhang et al., 2016; Cooijmans et al., 2016; Krueger et al., 2017; Jing et al.,", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 222, + 504, + 237 + ], + "spans": [ + { + "bbox": [ + 105, + 222, + 469, + 237 + ], + "score": 1.0, + "content": "2017). In this task, MNIST (Lecun et al., 1998) images are presented to the model as a", + "type": "text" + }, + { + "bbox": [ + 469, + 223, + 504, + 234 + ], + "score": 0.9, + "content": "7 8 4 \\times 1", + "type": "inline_equation" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 234, + 505, + 246 + ], + "spans": [ + { + "bbox": [ + 105, + 234, + 505, + 246 + ], + "score": 1.0, + "content": "sequence for digit classification In a more challenging setting, we also permuted the order of the", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 245, + 503, + 258 + ], + "spans": [ + { + "bbox": [ + 105, + 245, + 503, + 258 + ], + "score": 1.0, + "content": "sequence by a random (fixed) order and tested the TCN on this permuted MNIST (P-MNIST) task.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 10.5 + }, + { + "type": "text", + "bbox": [ + 106, + 262, + 505, + 339 + ], + "lines": [ + { + "bbox": [ + 106, + 262, + 506, + 275 + ], + "spans": [ + { + "bbox": [ + 106, + 262, + 418, + 275 + ], + "score": 1.0, + "content": "Copy Memory Task: In copy memory task, each input sequence has length", + "type": "text" + }, + { + "bbox": [ + 418, + 262, + 450, + 273 + ], + "score": 0.89, + "content": "T + 2 0", + "type": "inline_equation" + }, + { + "bbox": [ + 450, + 262, + 506, + 275 + ], + "score": 1.0, + "content": ". The first 10", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 273, + 504, + 285 + ], + "spans": [ + { + "bbox": [ + 106, + 273, + 504, + 285 + ], + "score": 1.0, + "content": "values are chosen randomly from digit [1-8] with the rest being all zeros, except for the last 11", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 104, + 282, + 506, + 298 + ], + "spans": [ + { + "bbox": [ + 104, + 282, + 269, + 298 + ], + "score": 1.0, + "content": "entries which are marked by 9 (the first", + "type": "text" + }, + { + "bbox": [ + 270, + 284, + 285, + 294 + ], + "score": 0.38, + "content": "\" 9 \"", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 282, + 506, + 298 + ], + "score": 1.0, + "content": "is a delimiter). The goal of this task is to generate an", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 295, + 505, + 307 + ], + "spans": [ + { + "bbox": [ + 105, + 295, + 505, + 307 + ], + "score": 1.0, + "content": "output of same length that is zero everywhere, except the last 10 values after the delimiter, where", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 306, + 505, + 318 + ], + "spans": [ + { + "bbox": [ + 106, + 306, + 505, + 318 + ], + "score": 1.0, + "content": "the model is expected to repeat the same 10 values at the start of the input. This was used by prior", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 316, + 506, + 330 + ], + "spans": [ + { + "bbox": [ + 105, + 316, + 506, + 330 + ], + "score": 1.0, + "content": "works such as Arjovsky et al. (2016); Wisdom et al. (2016); Jing et al. (2017); but we also extended", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 328, + 270, + 340 + ], + "spans": [ + { + "bbox": [ + 106, + 328, + 224, + 340 + ], + "score": 1.0, + "content": "the sequence lengths to up to", + "type": "text" + }, + { + "bbox": [ + 225, + 328, + 266, + 338 + ], + "score": 0.89, + "content": "T = 2 0 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 266, + 328, + 270, + 340 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 344, + 504, + 400 + ], + "lines": [ + { + "bbox": [ + 106, + 345, + 505, + 357 + ], + "spans": [ + { + "bbox": [ + 106, + 345, + 505, + 357 + ], + "score": 1.0, + "content": "JSB Chorales: JSB Chorales dataset (Allan & Williams, 2005) is a polyphonic music dataset con-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 355, + 506, + 369 + ], + "spans": [ + { + "bbox": [ + 105, + 355, + 506, + 369 + ], + "score": 1.0, + "content": "sisting of the entire corpus of 382 four-part harmonized chorales by J. S. Bach. In a polyphonic", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 366, + 506, + 380 + ], + "spans": [ + { + "bbox": [ + 105, + 366, + 506, + 380 + ], + "score": 1.0, + "content": "music dataset, each input is a sequence of elements having 88 dimensions, representing the 88 keys", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 104, + 377, + 506, + 391 + ], + "spans": [ + { + "bbox": [ + 104, + 377, + 250, + 391 + ], + "score": 1.0, + "content": "on a piano. Therefore, each element", + "type": "text" + }, + { + "bbox": [ + 250, + 379, + 261, + 389 + ], + "score": 0.86, + "content": "x _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 261, + 377, + 506, + 391 + ], + "score": 1.0, + "content": "is a chord written in as binary vector, in which a “1” indicates", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 104, + 389, + 165, + 402 + ], + "spans": [ + { + "bbox": [ + 104, + 389, + 165, + 402 + ], + "score": 1.0, + "content": "a key pressed.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 107, + 405, + 504, + 460 + ], + "lines": [ + { + "bbox": [ + 106, + 405, + 505, + 417 + ], + "spans": [ + { + "bbox": [ + 106, + 405, + 505, + 417 + ], + "score": 1.0, + "content": "Nottingham: Nottingham dataset 2 is a collection of 1200 British and American folk tunes. Not-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 416, + 506, + 430 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 506, + 430 + ], + "score": 1.0, + "content": "tingham is a much larger dataset than JSB Chorales. Along with JSB Chorales, Nottingham has", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 426, + 505, + 441 + ], + "spans": [ + { + "bbox": [ + 105, + 426, + 505, + 441 + ], + "score": 1.0, + "content": "been used in a number of works that investigated recurrent models’ applicability in polyphonic mu-", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 438, + 506, + 451 + ], + "spans": [ + { + "bbox": [ + 105, + 438, + 506, + 451 + ], + "score": 1.0, + "content": "sic (Greff et al., 2017; Chung et al., 2014), and the performance for both tasks are measured in terms", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 449, + 261, + 462 + ], + "spans": [ + { + "bbox": [ + 105, + 449, + 261, + 462 + ], + "score": 1.0, + "content": "of negative log-likelihood (NLL) loss.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 107, + 466, + 505, + 543 + ], + "lines": [ + { + "bbox": [ + 105, + 466, + 505, + 478 + ], + "spans": [ + { + "bbox": [ + 105, + 466, + 505, + 478 + ], + "score": 1.0, + "content": "PennTreebank: We evaluated TCN on the PennTreebank (PTB) dataset (Marcus et al., 1993), for", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 104, + 475, + 506, + 491 + ], + "spans": [ + { + "bbox": [ + 104, + 475, + 506, + 491 + ], + "score": 1.0, + "content": "both character-level and word-level language modeling. When used as a character-level language", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 488, + 506, + 501 + ], + "spans": [ + { + "bbox": [ + 105, + 488, + 506, + 501 + ], + "score": 1.0, + "content": "corpus, PTB contains 5059K characters for training, 396K for validation and 446K for testing, with", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 499, + 505, + 511 + ], + "spans": [ + { + "bbox": [ + 105, + 499, + 505, + 511 + ], + "score": 1.0, + "content": "an alphabet size of 50. When used as a word-level language corpus, PTB contains 888K words", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 510, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 505, + 523 + ], + "score": 1.0, + "content": "for training, 70K for validation and 79K for testing, with vocabulary size 10000. This is a highly", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 521, + 505, + 533 + ], + "spans": [ + { + "bbox": [ + 105, + 521, + 505, + 533 + ], + "score": 1.0, + "content": "studied dataset in the field of language modeling (Miyamoto & Cho, 2016; Krueger et al., 2017;", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 531, + 503, + 545 + ], + "spans": [ + { + "bbox": [ + 105, + 531, + 503, + 545 + ], + "score": 1.0, + "content": "Merity et al., 2017), with exceptional results have been achieved by some highly optimized RNNs.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 107, + 549, + 505, + 604 + ], + "lines": [ + { + "bbox": [ + 105, + 548, + 505, + 562 + ], + "spans": [ + { + "bbox": [ + 105, + 548, + 505, + 562 + ], + "score": 1.0, + "content": "Wikitext-103: Wikitext-103 (Merity et al., 2016) is almost 110 times as large as PTB, featuring", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 559, + 505, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 559, + 505, + 572 + ], + "score": 1.0, + "content": "a vocabulary size of about 268K. The dataset contains 28K Wikipedia articles (about 103 million", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 571, + 505, + 583 + ], + "spans": [ + { + "bbox": [ + 106, + 571, + 505, + 583 + ], + "score": 1.0, + "content": "words) for training, 60 articles (about 218K words) for validation and 60 articles (246K words) for", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 581, + 506, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 581, + 506, + 596 + ], + "score": 1.0, + "content": "testing. This is a more representative (and realistic) dataset than PTB as it contains a much larger", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 592, + 292, + 606 + ], + "spans": [ + { + "bbox": [ + 106, + 592, + 292, + 606 + ], + "score": 1.0, + "content": "vocabulary, including many rare vocabularies.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 40 + }, + { + "type": "text", + "bbox": [ + 107, + 609, + 505, + 698 + ], + "lines": [ + { + "bbox": [ + 105, + 610, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 505, + 622 + ], + "score": 1.0, + "content": "LAMBADA: Introduced by Paperno et al. (2016), LAMBADA (LA nguage Modeling Boadened to", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 621, + 505, + 633 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 505, + 633 + ], + "score": 1.0, + "content": "Account for Discourse Aspects) is a dataset consisting of 10K passages extracted from novels, with", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 632, + 505, + 643 + ], + "spans": [ + { + "bbox": [ + 105, + 632, + 505, + 643 + ], + "score": 1.0, + "content": "on average 4.6 sentences as context, and 1 target sentence whose last word is to be predicted. This", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 643, + 505, + 655 + ], + "spans": [ + { + "bbox": [ + 105, + 643, + 505, + 655 + ], + "score": 1.0, + "content": "dataset was built so that human can guess naturally and perfectly when given the context, but would", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 652, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 105, + 652, + 505, + 667 + ], + "score": 1.0, + "content": "fail to do so when only given the target sentence. Therefore, LAMBADA is a very challenging", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 664, + 505, + 676 + ], + "spans": [ + { + "bbox": [ + 106, + 664, + 505, + 676 + ], + "score": 1.0, + "content": "dataset that evaluates a model’s textual understanding and ability to keep track of information in", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 675, + 505, + 687 + ], + "spans": [ + { + "bbox": [ + 105, + 675, + 505, + 687 + ], + "score": 1.0, + "content": "the broader discourse. Here is an example of a test in the LAMBADA dataset, where the last word", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 106, + 687, + 352, + 698 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 352, + 698 + ], + "score": 1.0, + "content": "“miscarriage” is to be predicted (which is not in the context):", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 46.5 + } + ], + "page_idx": 14, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 119, + 721, + 331, + 732 + ], + "lines": [ + { + "bbox": [ + 119, + 720, + 332, + 734 + ], + "spans": [ + { + "bbox": [ + 119, + 720, + 186, + 734 + ], + "score": 1.0, + "content": "2See http://ifdo.ca", + "type": "text" + }, + { + "bbox": [ + 187, + 723, + 194, + 730 + ], + "score": 0.27, + "content": "\\sim", + "type": "inline_equation" + }, + { + "bbox": [ + 195, + 720, + 332, + 734 + ], + "score": 1.0, + "content": "seymour/nottingham/nottingham.html", + "type": "text" + } + ] + } + ] + }, + { + "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, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "15", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 82, + 320, + 93 + ], + "lines": [ + { + "bbox": [ + 106, + 81, + 322, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 322, + 95 + ], + "score": 1.0, + "content": "A DESCRIPTION OF BENCHMARK TASKS", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 108, + 505, + 185 + ], + "lines": [ + { + "bbox": [ + 106, + 108, + 504, + 120 + ], + "spans": [ + { + "bbox": [ + 106, + 108, + 378, + 120 + ], + "score": 1.0, + "content": "The Adding Problem: In this task, each input consists of a length-", + "type": "text" + }, + { + "bbox": [ + 378, + 110, + 385, + 118 + ], + "score": 0.74, + "content": "\\mathbf { \\nabla } \\cdot n", + "type": "inline_equation" + }, + { + "bbox": [ + 385, + 108, + 504, + 120 + ], + "score": 1.0, + "content": "sequence of depth 2, with all", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 119, + 505, + 131 + ], + "spans": [ + { + "bbox": [ + 106, + 119, + 505, + 131 + ], + "score": 1.0, + "content": "values randomly chosen in [0, 1], and the second dimension being all zeros expect for two elements", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 130, + 505, + 142 + ], + "spans": [ + { + "bbox": [ + 105, + 130, + 505, + 142 + ], + "score": 1.0, + "content": "that are marked by 1. The objective is to sum the two random values whose second dimensions", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 141, + 506, + 153 + ], + "spans": [ + { + "bbox": [ + 105, + 141, + 506, + 153 + ], + "score": 1.0, + "content": "are marked by 1. Simply predicting the sum to be 1 should give an MSE of about 0.1767. First", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 151, + 505, + 163 + ], + "spans": [ + { + "bbox": [ + 105, + 151, + 505, + 163 + ], + "score": 1.0, + "content": "introduced by Hochreiter & Schmidhuber (1997), the addition problem have been consistently used", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 163, + 505, + 175 + ], + "spans": [ + { + "bbox": [ + 105, + 163, + 505, + 175 + ], + "score": 1.0, + "content": "as a pathological test for evaluating sequential models (Pascanu et al., 2013; Le et al., 2015; Zhang", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 173, + 248, + 187 + ], + "spans": [ + { + "bbox": [ + 105, + 173, + 248, + 187 + ], + "score": 1.0, + "content": "et al., 2016; Arjovsky et al., 2016).", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 4, + "bbox_fs": [ + 105, + 108, + 506, + 187 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 190, + 505, + 256 + ], + "lines": [ + { + "bbox": [ + 106, + 190, + 505, + 202 + ], + "spans": [ + { + "bbox": [ + 106, + 190, + 505, + 202 + ], + "score": 1.0, + "content": "Sequential MNIST & P-MNIST: Sequential MNIST is frequently used to test a recurrent network’s", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 201, + 505, + 214 + ], + "spans": [ + { + "bbox": [ + 105, + 201, + 505, + 214 + ], + "score": 1.0, + "content": "ability to combine its information from a long memory context in order to make classification pre-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 212, + 505, + 225 + ], + "spans": [ + { + "bbox": [ + 105, + 212, + 505, + 225 + ], + "score": 1.0, + "content": "diction (Le et al., 2015; Zhang et al., 2016; Cooijmans et al., 2016; Krueger et al., 2017; Jing et al.,", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 222, + 504, + 237 + ], + "spans": [ + { + "bbox": [ + 105, + 222, + 469, + 237 + ], + "score": 1.0, + "content": "2017). In this task, MNIST (Lecun et al., 1998) images are presented to the model as a", + "type": "text" + }, + { + "bbox": [ + 469, + 223, + 504, + 234 + ], + "score": 0.9, + "content": "7 8 4 \\times 1", + "type": "inline_equation" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 234, + 505, + 246 + ], + "spans": [ + { + "bbox": [ + 105, + 234, + 505, + 246 + ], + "score": 1.0, + "content": "sequence for digit classification In a more challenging setting, we also permuted the order of the", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 245, + 503, + 258 + ], + "spans": [ + { + "bbox": [ + 105, + 245, + 503, + 258 + ], + "score": 1.0, + "content": "sequence by a random (fixed) order and tested the TCN on this permuted MNIST (P-MNIST) task.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 10.5, + "bbox_fs": [ + 105, + 190, + 505, + 258 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 262, + 505, + 339 + ], + "lines": [ + { + "bbox": [ + 106, + 262, + 506, + 275 + ], + "spans": [ + { + "bbox": [ + 106, + 262, + 418, + 275 + ], + "score": 1.0, + "content": "Copy Memory Task: In copy memory task, each input sequence has length", + "type": "text" + }, + { + "bbox": [ + 418, + 262, + 450, + 273 + ], + "score": 0.89, + "content": "T + 2 0", + "type": "inline_equation" + }, + { + "bbox": [ + 450, + 262, + 506, + 275 + ], + "score": 1.0, + "content": ". The first 10", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 273, + 504, + 285 + ], + "spans": [ + { + "bbox": [ + 106, + 273, + 504, + 285 + ], + "score": 1.0, + "content": "values are chosen randomly from digit [1-8] with the rest being all zeros, except for the last 11", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 104, + 282, + 506, + 298 + ], + "spans": [ + { + "bbox": [ + 104, + 282, + 269, + 298 + ], + "score": 1.0, + "content": "entries which are marked by 9 (the first", + "type": "text" + }, + { + "bbox": [ + 270, + 284, + 285, + 294 + ], + "score": 0.38, + "content": "\" 9 \"", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 282, + 506, + 298 + ], + "score": 1.0, + "content": "is a delimiter). The goal of this task is to generate an", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 295, + 505, + 307 + ], + "spans": [ + { + "bbox": [ + 105, + 295, + 505, + 307 + ], + "score": 1.0, + "content": "output of same length that is zero everywhere, except the last 10 values after the delimiter, where", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 306, + 505, + 318 + ], + "spans": [ + { + "bbox": [ + 106, + 306, + 505, + 318 + ], + "score": 1.0, + "content": "the model is expected to repeat the same 10 values at the start of the input. This was used by prior", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 316, + 506, + 330 + ], + "spans": [ + { + "bbox": [ + 105, + 316, + 506, + 330 + ], + "score": 1.0, + "content": "works such as Arjovsky et al. (2016); Wisdom et al. (2016); Jing et al. (2017); but we also extended", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 328, + 270, + 340 + ], + "spans": [ + { + "bbox": [ + 106, + 328, + 224, + 340 + ], + "score": 1.0, + "content": "the sequence lengths to up to", + "type": "text" + }, + { + "bbox": [ + 225, + 328, + 266, + 338 + ], + "score": 0.89, + "content": "T = 2 0 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 266, + 328, + 270, + 340 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 17, + "bbox_fs": [ + 104, + 262, + 506, + 340 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 344, + 504, + 400 + ], + "lines": [ + { + "bbox": [ + 106, + 345, + 505, + 357 + ], + "spans": [ + { + "bbox": [ + 106, + 345, + 505, + 357 + ], + "score": 1.0, + "content": "JSB Chorales: JSB Chorales dataset (Allan & Williams, 2005) is a polyphonic music dataset con-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 355, + 506, + 369 + ], + "spans": [ + { + "bbox": [ + 105, + 355, + 506, + 369 + ], + "score": 1.0, + "content": "sisting of the entire corpus of 382 four-part harmonized chorales by J. S. Bach. In a polyphonic", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 366, + 506, + 380 + ], + "spans": [ + { + "bbox": [ + 105, + 366, + 506, + 380 + ], + "score": 1.0, + "content": "music dataset, each input is a sequence of elements having 88 dimensions, representing the 88 keys", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 104, + 377, + 506, + 391 + ], + "spans": [ + { + "bbox": [ + 104, + 377, + 250, + 391 + ], + "score": 1.0, + "content": "on a piano. Therefore, each element", + "type": "text" + }, + { + "bbox": [ + 250, + 379, + 261, + 389 + ], + "score": 0.86, + "content": "x _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 261, + 377, + 506, + 391 + ], + "score": 1.0, + "content": "is a chord written in as binary vector, in which a “1” indicates", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 104, + 389, + 165, + 402 + ], + "spans": [ + { + "bbox": [ + 104, + 389, + 165, + 402 + ], + "score": 1.0, + "content": "a key pressed.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23, + "bbox_fs": [ + 104, + 345, + 506, + 402 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 405, + 504, + 460 + ], + "lines": [ + { + "bbox": [ + 106, + 405, + 505, + 417 + ], + "spans": [ + { + "bbox": [ + 106, + 405, + 505, + 417 + ], + "score": 1.0, + "content": "Nottingham: Nottingham dataset 2 is a collection of 1200 British and American folk tunes. Not-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 416, + 506, + 430 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 506, + 430 + ], + "score": 1.0, + "content": "tingham is a much larger dataset than JSB Chorales. Along with JSB Chorales, Nottingham has", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 426, + 505, + 441 + ], + "spans": [ + { + "bbox": [ + 105, + 426, + 505, + 441 + ], + "score": 1.0, + "content": "been used in a number of works that investigated recurrent models’ applicability in polyphonic mu-", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 438, + 506, + 451 + ], + "spans": [ + { + "bbox": [ + 105, + 438, + 506, + 451 + ], + "score": 1.0, + "content": "sic (Greff et al., 2017; Chung et al., 2014), and the performance for both tasks are measured in terms", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 449, + 261, + 462 + ], + "spans": [ + { + "bbox": [ + 105, + 449, + 261, + 462 + ], + "score": 1.0, + "content": "of negative log-likelihood (NLL) loss.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 28, + "bbox_fs": [ + 105, + 405, + 506, + 462 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 466, + 505, + 543 + ], + "lines": [ + { + "bbox": [ + 105, + 466, + 505, + 478 + ], + "spans": [ + { + "bbox": [ + 105, + 466, + 505, + 478 + ], + "score": 1.0, + "content": "PennTreebank: We evaluated TCN on the PennTreebank (PTB) dataset (Marcus et al., 1993), for", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 104, + 475, + 506, + 491 + ], + "spans": [ + { + "bbox": [ + 104, + 475, + 506, + 491 + ], + "score": 1.0, + "content": "both character-level and word-level language modeling. When used as a character-level language", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 488, + 506, + 501 + ], + "spans": [ + { + "bbox": [ + 105, + 488, + 506, + 501 + ], + "score": 1.0, + "content": "corpus, PTB contains 5059K characters for training, 396K for validation and 446K for testing, with", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 499, + 505, + 511 + ], + "spans": [ + { + "bbox": [ + 105, + 499, + 505, + 511 + ], + "score": 1.0, + "content": "an alphabet size of 50. When used as a word-level language corpus, PTB contains 888K words", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 510, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 505, + 523 + ], + "score": 1.0, + "content": "for training, 70K for validation and 79K for testing, with vocabulary size 10000. This is a highly", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 521, + 505, + 533 + ], + "spans": [ + { + "bbox": [ + 105, + 521, + 505, + 533 + ], + "score": 1.0, + "content": "studied dataset in the field of language modeling (Miyamoto & Cho, 2016; Krueger et al., 2017;", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 531, + 503, + 545 + ], + "spans": [ + { + "bbox": [ + 105, + 531, + 503, + 545 + ], + "score": 1.0, + "content": "Merity et al., 2017), with exceptional results have been achieved by some highly optimized RNNs.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 34, + "bbox_fs": [ + 104, + 466, + 506, + 545 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 549, + 505, + 604 + ], + "lines": [ + { + "bbox": [ + 105, + 548, + 505, + 562 + ], + "spans": [ + { + "bbox": [ + 105, + 548, + 505, + 562 + ], + "score": 1.0, + "content": "Wikitext-103: Wikitext-103 (Merity et al., 2016) is almost 110 times as large as PTB, featuring", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 559, + 505, + 572 + ], + "spans": [ + { + "bbox": [ + 105, + 559, + 505, + 572 + ], + "score": 1.0, + "content": "a vocabulary size of about 268K. The dataset contains 28K Wikipedia articles (about 103 million", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 571, + 505, + 583 + ], + "spans": [ + { + "bbox": [ + 106, + 571, + 505, + 583 + ], + "score": 1.0, + "content": "words) for training, 60 articles (about 218K words) for validation and 60 articles (246K words) for", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 581, + 506, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 581, + 506, + 596 + ], + "score": 1.0, + "content": "testing. This is a more representative (and realistic) dataset than PTB as it contains a much larger", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 592, + 292, + 606 + ], + "spans": [ + { + "bbox": [ + 106, + 592, + 292, + 606 + ], + "score": 1.0, + "content": "vocabulary, including many rare vocabularies.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 40, + "bbox_fs": [ + 105, + 548, + 506, + 606 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 609, + 505, + 698 + ], + "lines": [ + { + "bbox": [ + 105, + 610, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 505, + 622 + ], + "score": 1.0, + "content": "LAMBADA: Introduced by Paperno et al. (2016), LAMBADA (LA nguage Modeling Boadened to", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 621, + 505, + 633 + ], + "spans": [ + { + "bbox": [ + 105, + 621, + 505, + 633 + ], + "score": 1.0, + "content": "Account for Discourse Aspects) is a dataset consisting of 10K passages extracted from novels, with", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 632, + 505, + 643 + ], + "spans": [ + { + "bbox": [ + 105, + 632, + 505, + 643 + ], + "score": 1.0, + "content": "on average 4.6 sentences as context, and 1 target sentence whose last word is to be predicted. This", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 643, + 505, + 655 + ], + "spans": [ + { + "bbox": [ + 105, + 643, + 505, + 655 + ], + "score": 1.0, + "content": "dataset was built so that human can guess naturally and perfectly when given the context, but would", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 652, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 105, + 652, + 505, + 667 + ], + "score": 1.0, + "content": "fail to do so when only given the target sentence. Therefore, LAMBADA is a very challenging", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 664, + 505, + 676 + ], + "spans": [ + { + "bbox": [ + 106, + 664, + 505, + 676 + ], + "score": 1.0, + "content": "dataset that evaluates a model’s textual understanding and ability to keep track of information in", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 675, + 505, + 687 + ], + "spans": [ + { + "bbox": [ + 105, + 675, + 505, + 687 + ], + "score": 1.0, + "content": "the broader discourse. Here is an example of a test in the LAMBADA dataset, where the last word", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 106, + 687, + 352, + 698 + ], + "spans": [ + { + "bbox": [ + 106, + 687, + 352, + 698 + ], + "score": 1.0, + "content": "“miscarriage” is to be predicted (which is not in the context):", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 46.5, + "bbox_fs": [ + 105, + 610, + 505, + 698 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 113, + 92, + 496, + 126 + ], + "lines": [ + { + "bbox": [ + 115, + 91, + 496, + 106 + ], + "spans": [ + { + "bbox": [ + 115, + 91, + 496, + 106 + ], + "score": 1.0, + "content": "Context: “Yes, I thought I was going to lose the baby.”“I was scared too.” he stated, sincerity", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 103, + 496, + 117 + ], + "spans": [ + { + "bbox": [ + 115, + 103, + 496, + 117 + ], + "score": 1.0, + "content": "flooding his eyes. “You were?”“Yes, of course. Why do you even ask?”“This baby wasn’t", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 114, + 114, + 201, + 126 + ], + "spans": [ + { + "bbox": [ + 114, + 114, + 201, + 126 + ], + "score": 1.0, + "content": "exactly planned for.”", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 115, + 131, + 433, + 143 + ], + "lines": [ + { + "bbox": [ + 114, + 129, + 432, + 146 + ], + "spans": [ + { + "bbox": [ + 114, + 129, + 432, + 146 + ], + "score": 1.0, + "content": "Target Sentence: “Do you honestly think that I would want you to have a ”", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 116, + 148, + 219, + 160 + ], + "lines": [ + { + "bbox": [ + 115, + 146, + 219, + 163 + ], + "spans": [ + { + "bbox": [ + 115, + 146, + 219, + 163 + ], + "score": 1.0, + "content": "Target Word: miscarriage", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 107, + 180, + 505, + 225 + ], + "lines": [ + { + "bbox": [ + 106, + 181, + 505, + 192 + ], + "spans": [ + { + "bbox": [ + 106, + 181, + 505, + 192 + ], + "score": 1.0, + "content": "This dataset was evaluated in prior works such as Paperno et al. (2016); Grave et al. (2016). In", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 192, + 505, + 204 + ], + "spans": [ + { + "bbox": [ + 105, + 192, + 505, + 204 + ], + "score": 1.0, + "content": "general, better results on LAMBADA indicate that a model is better at capturing information from", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 203, + 505, + 214 + ], + "spans": [ + { + "bbox": [ + 105, + 203, + 505, + 214 + ], + "score": 1.0, + "content": "longer and broader context. The training data for LAMBADA is the full text of 2,662 novels with", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 213, + 363, + 226 + ], + "spans": [ + { + "bbox": [ + 105, + 213, + 363, + 226 + ], + "score": 1.0, + "content": "more than 200M words 3, and the vocabulary size is about 93K.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 6.5 + }, + { + "type": "text", + "bbox": [ + 106, + 231, + 505, + 264 + ], + "lines": [ + { + "bbox": [ + 105, + 229, + 505, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 229, + 208, + 244 + ], + "score": 1.0, + "content": "text8: We also used tex", + "type": "text" + }, + { + "bbox": [ + 208, + 230, + 218, + 241 + ], + "score": 0.46, + "content": "8 ^ { 4 }", + "type": "inline_equation" + }, + { + "bbox": [ + 219, + 229, + 505, + 244 + ], + "score": 1.0, + "content": "dataset for character level language modeling (Mikolov et al., 2012).", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 241, + 505, + 253 + ], + "spans": [ + { + "bbox": [ + 106, + 241, + 505, + 253 + ], + "score": 1.0, + "content": "Compared to PTB, text8 is about 20 times as large, with about 100 million characters from Wikipedia", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 252, + 505, + 266 + ], + "spans": [ + { + "bbox": [ + 105, + 252, + 505, + 266 + ], + "score": 1.0, + "content": "(90M for training, 5M for validation and 5M for testing). The corpus contains 27 unique alphabets.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10 + } + ], + "page_idx": 15, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 118, + 711, + 423, + 732 + ], + "lines": [ + { + "bbox": [ + 118, + 708, + 424, + 723 + ], + "spans": [ + { + "bbox": [ + 118, + 708, + 424, + 723 + ], + "score": 1.0, + "content": "3LAMBADA and training dataset can be found at http://clic.cimec.unitn.it/lambada/", + "type": "text" + } + ] + }, + { + "bbox": [ + 119, + 719, + 297, + 734 + ], + "spans": [ + { + "bbox": [ + 119, + 719, + 297, + 734 + ], + "score": 1.0, + "content": "4Available at http://mattmahoney.net/dc/text8.zip", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 752, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 14 + } + ] + } + ] + }, + { + "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": "text", + "bbox": [ + 113, + 92, + 496, + 126 + ], + "lines": [ + { + "bbox": [ + 115, + 91, + 496, + 106 + ], + "spans": [ + { + "bbox": [ + 115, + 91, + 496, + 106 + ], + "score": 1.0, + "content": "Context: “Yes, I thought I was going to lose the baby.”“I was scared too.” he stated, sincerity", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 103, + 496, + 117 + ], + "spans": [ + { + "bbox": [ + 115, + 103, + 496, + 117 + ], + "score": 1.0, + "content": "flooding his eyes. “You were?”“Yes, of course. Why do you even ask?”“This baby wasn’t", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 114, + 114, + 201, + 126 + ], + "spans": [ + { + "bbox": [ + 114, + 114, + 201, + 126 + ], + "score": 1.0, + "content": "exactly planned for.”", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1, + "bbox_fs": [ + 114, + 91, + 496, + 126 + ] + }, + { + "type": "text", + "bbox": [ + 115, + 131, + 433, + 143 + ], + "lines": [ + { + "bbox": [ + 114, + 129, + 432, + 146 + ], + "spans": [ + { + "bbox": [ + 114, + 129, + 432, + 146 + ], + "score": 1.0, + "content": "Target Sentence: “Do you honestly think that I would want you to have a ”", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3, + "bbox_fs": [ + 114, + 129, + 432, + 146 + ] + }, + { + "type": "text", + "bbox": [ + 116, + 148, + 219, + 160 + ], + "lines": [ + { + "bbox": [ + 115, + 146, + 219, + 163 + ], + "spans": [ + { + "bbox": [ + 115, + 146, + 219, + 163 + ], + "score": 1.0, + "content": "Target Word: miscarriage", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4, + "bbox_fs": [ + 115, + 146, + 219, + 163 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 180, + 505, + 225 + ], + "lines": [ + { + "bbox": [ + 106, + 181, + 505, + 192 + ], + "spans": [ + { + "bbox": [ + 106, + 181, + 505, + 192 + ], + "score": 1.0, + "content": "This dataset was evaluated in prior works such as Paperno et al. (2016); Grave et al. (2016). In", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 192, + 505, + 204 + ], + "spans": [ + { + "bbox": [ + 105, + 192, + 505, + 204 + ], + "score": 1.0, + "content": "general, better results on LAMBADA indicate that a model is better at capturing information from", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 203, + 505, + 214 + ], + "spans": [ + { + "bbox": [ + 105, + 203, + 505, + 214 + ], + "score": 1.0, + "content": "longer and broader context. The training data for LAMBADA is the full text of 2,662 novels with", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 213, + 363, + 226 + ], + "spans": [ + { + "bbox": [ + 105, + 213, + 363, + 226 + ], + "score": 1.0, + "content": "more than 200M words 3, and the vocabulary size is about 93K.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 6.5, + "bbox_fs": [ + 105, + 181, + 505, + 226 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 231, + 505, + 264 + ], + "lines": [ + { + "bbox": [ + 105, + 229, + 505, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 229, + 208, + 244 + ], + "score": 1.0, + "content": "text8: We also used tex", + "type": "text" + }, + { + "bbox": [ + 208, + 230, + 218, + 241 + ], + "score": 0.46, + "content": "8 ^ { 4 }", + "type": "inline_equation" + }, + { + "bbox": [ + 219, + 229, + 505, + 244 + ], + "score": 1.0, + "content": "dataset for character level language modeling (Mikolov et al., 2012).", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 241, + 505, + 253 + ], + "spans": [ + { + "bbox": [ + 106, + 241, + 505, + 253 + ], + "score": 1.0, + "content": "Compared to PTB, text8 is about 20 times as large, with about 100 million characters from Wikipedia", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 252, + 505, + 266 + ], + "spans": [ + { + "bbox": [ + 105, + 252, + 505, + 266 + ], + "score": 1.0, + "content": "(90M for training, 5M for validation and 5M for testing). The corpus contains 27 unique alphabets.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10, + "bbox_fs": [ + 105, + 229, + 505, + 266 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 81, + 287, + 94 + ], + "lines": [ + { + "bbox": [ + 105, + 80, + 288, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 80, + 288, + 95 + ], + "score": 1.0, + "content": "B HYPERPARAMETERS SETTINGS", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "title", + "bbox": [ + 108, + 106, + 264, + 118 + ], + "lines": [ + { + "bbox": [ + 106, + 106, + 264, + 118 + ], + "spans": [ + { + "bbox": [ + 106, + 106, + 264, + 118 + ], + "score": 1.0, + "content": "B.1 HYPERPARAMETERS FOR TCN", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 107, + 127, + 505, + 171 + ], + "lines": [ + { + "bbox": [ + 105, + 127, + 505, + 138 + ], + "spans": [ + { + "bbox": [ + 105, + 127, + 505, + 138 + ], + "score": 1.0, + "content": "In this supplementary section, we report in a table (see Table 2) the hyperparameters we used when", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 137, + 506, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 506, + 150 + ], + "score": 1.0, + "content": "applying the generic TCN model on the different tasks/datasets. The most important factor for", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 149, + 505, + 162 + ], + "spans": [ + { + "bbox": [ + 105, + 149, + 505, + 162 + ], + "score": 1.0, + "content": "picking parameters is to make sure that the TCN has a sufficiently large receptive field by choosing", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 160, + 368, + 171 + ], + "spans": [ + { + "bbox": [ + 106, + 160, + 113, + 169 + ], + "score": 0.8, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 114, + 160, + 131, + 171 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 132, + 162, + 139, + 169 + ], + "score": 0.74, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 139, + 160, + 368, + 171 + ], + "score": 1.0, + "content": "that can cover the amount of context needed for the task.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3.5 + }, + { + "type": "table", + "bbox": [ + 110, + 200, + 500, + 452 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 178, + 179, + 430, + 191 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 179, + 179, + 430, + 192 + ], + "spans": [ + { + "bbox": [ + 179, + 179, + 430, + 192 + ], + "score": 1.0, + "content": "Table 2: TCN parameter settings for experiments in Section. 4", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "table_body", + "bbox": [ + 110, + 200, + 500, + 452 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 110, + 200, + 500, + 452 + ], + "spans": [ + { + "bbox": [ + 110, + 200, + 500, + 452 + ], + "score": 0.986, + "html": "
TCN SETTINGS
Dataset/TaskSubtaskk nHiddenDropoutGrad ClipNote
The Adding ProblemT=20067 27
T= 40077 270.0N/A
T= 60088 24
Seq. MNIST78250.0N/A
68 20
Permuted MNIST7 68 825 0.0 20N/A
Copy Memory TaskT=5006910
T= 10008810 0.051.0RMSprop 5e-4
T= 200089 10
Music JSB Chorales1321500.5 0.4
Music Nottingham1641500.2 0.4
Word-level LMPTB34 600Embed. size 600
Wiki-10335 10000.40.3Embed. size 400
LAMBADA45 500Embed. size 500
Char-level LMPTB33450
text8250.1 5200.15Embed. size 100
", + "type": "table", + "image_path": "76aa35637f066cfd3da1a6b9ca33c35b99a6465fab4e4050d8a492b8f6c554f1.jpg" + } + ] + } + ], + "index": 8, + "virtual_lines": [ + { + "bbox": [ + 110, + 200, + 500, + 284.0 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 110, + 284.0, + 500, + 368.0 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 110, + 368.0, + 500, + 452.0 + ], + "spans": [], + "index": 9 + } + ] + } + ], + "index": 7.0 + }, + { + "type": "text", + "bbox": [ + 107, + 470, + 505, + 526 + ], + "lines": [ + { + "bbox": [ + 106, + 471, + 504, + 483 + ], + "spans": [ + { + "bbox": [ + 106, + 471, + 469, + 483 + ], + "score": 1.0, + "content": "As previously mentioned in Section 4, the number of hidden units was chosen based on", + "type": "text" + }, + { + "bbox": [ + 470, + 471, + 477, + 481 + ], + "score": 0.8, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 477, + 471, + 496, + 483 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 497, + 473, + 504, + 481 + ], + "score": 0.67, + "content": "n", + "type": "inline_equation" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 482, + 505, + 494 + ], + "spans": [ + { + "bbox": [ + 106, + 482, + 505, + 494 + ], + "score": 1.0, + "content": "such that the model size is approximately at the same level as the recurrent models. In the table", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 493, + 505, + 506 + ], + "spans": [ + { + "bbox": [ + 106, + 493, + 505, + 506 + ], + "score": 1.0, + "content": "above, a gradient clip of N/A means no gradient clipping was applied. However, in larger tasks,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 504, + 505, + 516 + ], + "spans": [ + { + "bbox": [ + 105, + 504, + 505, + 516 + ], + "score": 1.0, + "content": "we empirically found that adding a gradient clip value (we randomly picked from [0.2, 1]) helps the", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 515, + 194, + 528 + ], + "spans": [ + { + "bbox": [ + 106, + 515, + 194, + 528 + ], + "score": 1.0, + "content": "training convergence.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 12 + }, + { + "type": "title", + "bbox": [ + 108, + 539, + 296, + 551 + ], + "lines": [ + { + "bbox": [ + 105, + 539, + 297, + 552 + ], + "spans": [ + { + "bbox": [ + 105, + 539, + 297, + 552 + ], + "score": 1.0, + "content": "B.2 HYPERPARAMETERS FOR LSTM/GRU", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 107, + 560, + 505, + 594 + ], + "lines": [ + { + "bbox": [ + 105, + 558, + 505, + 573 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 505, + 573 + ], + "score": 1.0, + "content": "We also report the parameter setting for LSTM in Table 3. These values are picked from hyper-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 570, + 505, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 570, + 505, + 583 + ], + "score": 1.0, + "content": "parameter search for LSTMs that have up to 3 layers, and the optimizers are chosen from {SGD,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 582, + 225, + 595 + ], + "spans": [ + { + "bbox": [ + 106, + 582, + 225, + 595 + ], + "score": 1.0, + "content": "Adam, RMSprop, Adagrad}.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 599, + 504, + 621 + ], + "lines": [ + { + "bbox": [ + 106, + 599, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 106, + 599, + 505, + 612 + ], + "score": 1.0, + "content": "GRU hyperparameters were chosen in a similar fashion, but with more hidden units to keep the total", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 610, + 369, + 621 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 369, + 621 + ], + "score": 1.0, + "content": "model size approximately the same (since a GRU cell is smaller).", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19.5 + }, + { + "type": "title", + "bbox": [ + 107, + 635, + 334, + 646 + ], + "lines": [ + { + "bbox": [ + 105, + 633, + 335, + 648 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 335, + 648 + ], + "score": 1.0, + "content": "B.3 COMPARE TO THE STATE OF THE ART RESULTS", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 106, + 655, + 504, + 677 + ], + "lines": [ + { + "bbox": [ + 105, + 655, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 505, + 668 + ], + "score": 1.0, + "content": "As previously noted, TCN can still be outperformed by optimized RNNs in some of the tasks, whose", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 667, + 479, + 678 + ], + "spans": [ + { + "bbox": [ + 106, + 667, + 479, + 678 + ], + "score": 1.0, + "content": "results are summarized in Table 4 below. The same TCN architecture is used across all tasks.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 107, + 683, + 429, + 695 + ], + "lines": [ + { + "bbox": [ + 106, + 683, + 429, + 695 + ], + "spans": [ + { + "bbox": [ + 106, + 683, + 429, + 695 + ], + "score": 1.0, + "content": "Note that the size of the SoTA model may be different from the size of the TCN.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + } + ], + "page_idx": 16, + "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, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "17", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 81, + 287, + 94 + ], + "lines": [ + { + "bbox": [ + 105, + 80, + 288, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 80, + 288, + 95 + ], + "score": 1.0, + "content": "B HYPERPARAMETERS SETTINGS", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "title", + "bbox": [ + 108, + 106, + 264, + 118 + ], + "lines": [ + { + "bbox": [ + 106, + 106, + 264, + 118 + ], + "spans": [ + { + "bbox": [ + 106, + 106, + 264, + 118 + ], + "score": 1.0, + "content": "B.1 HYPERPARAMETERS FOR TCN", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 107, + 127, + 505, + 171 + ], + "lines": [ + { + "bbox": [ + 105, + 127, + 505, + 138 + ], + "spans": [ + { + "bbox": [ + 105, + 127, + 505, + 138 + ], + "score": 1.0, + "content": "In this supplementary section, we report in a table (see Table 2) the hyperparameters we used when", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 137, + 506, + 150 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 506, + 150 + ], + "score": 1.0, + "content": "applying the generic TCN model on the different tasks/datasets. The most important factor for", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 149, + 505, + 162 + ], + "spans": [ + { + "bbox": [ + 105, + 149, + 505, + 162 + ], + "score": 1.0, + "content": "picking parameters is to make sure that the TCN has a sufficiently large receptive field by choosing", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 160, + 368, + 171 + ], + "spans": [ + { + "bbox": [ + 106, + 160, + 113, + 169 + ], + "score": 0.8, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 114, + 160, + 131, + 171 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 132, + 162, + 139, + 169 + ], + "score": 0.74, + "content": "n", + "type": "inline_equation" + }, + { + "bbox": [ + 139, + 160, + 368, + 171 + ], + "score": 1.0, + "content": "that can cover the amount of context needed for the task.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3.5, + "bbox_fs": [ + 105, + 127, + 506, + 171 + ] + }, + { + "type": "table", + "bbox": [ + 110, + 200, + 500, + 452 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 178, + 179, + 430, + 191 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 179, + 179, + 430, + 192 + ], + "spans": [ + { + "bbox": [ + 179, + 179, + 430, + 192 + ], + "score": 1.0, + "content": "Table 2: TCN parameter settings for experiments in Section. 4", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "table_body", + "bbox": [ + 110, + 200, + 500, + 452 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 110, + 200, + 500, + 452 + ], + "spans": [ + { + "bbox": [ + 110, + 200, + 500, + 452 + ], + "score": 0.986, + "html": "
TCN SETTINGS
Dataset/TaskSubtaskk nHiddenDropoutGrad ClipNote
The Adding ProblemT=20067 27
T= 40077 270.0N/A
T= 60088 24
Seq. MNIST78250.0N/A
68 20
Permuted MNIST7 68 825 0.0 20N/A
Copy Memory TaskT=5006910
T= 10008810 0.051.0RMSprop 5e-4
T= 200089 10
Music JSB Chorales1321500.5 0.4
Music Nottingham1641500.2 0.4
Word-level LMPTB34 600Embed. size 600
Wiki-10335 10000.40.3Embed. size 400
LAMBADA45 500Embed. size 500
Char-level LMPTB33450
text8250.1 5200.15Embed. size 100
", + "type": "table", + "image_path": "76aa35637f066cfd3da1a6b9ca33c35b99a6465fab4e4050d8a492b8f6c554f1.jpg" + } + ] + } + ], + "index": 8, + "virtual_lines": [ + { + "bbox": [ + 110, + 200, + 500, + 284.0 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 110, + 284.0, + 500, + 368.0 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 110, + 368.0, + 500, + 452.0 + ], + "spans": [], + "index": 9 + } + ] + } + ], + "index": 7.0 + }, + { + "type": "text", + "bbox": [ + 107, + 470, + 505, + 526 + ], + "lines": [ + { + "bbox": [ + 106, + 471, + 504, + 483 + ], + "spans": [ + { + "bbox": [ + 106, + 471, + 469, + 483 + ], + "score": 1.0, + "content": "As previously mentioned in Section 4, the number of hidden units was chosen based on", + "type": "text" + }, + { + "bbox": [ + 470, + 471, + 477, + 481 + ], + "score": 0.8, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 477, + 471, + 496, + 483 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 497, + 473, + 504, + 481 + ], + "score": 0.67, + "content": "n", + "type": "inline_equation" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 482, + 505, + 494 + ], + "spans": [ + { + "bbox": [ + 106, + 482, + 505, + 494 + ], + "score": 1.0, + "content": "such that the model size is approximately at the same level as the recurrent models. In the table", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 493, + 505, + 506 + ], + "spans": [ + { + "bbox": [ + 106, + 493, + 505, + 506 + ], + "score": 1.0, + "content": "above, a gradient clip of N/A means no gradient clipping was applied. However, in larger tasks,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 504, + 505, + 516 + ], + "spans": [ + { + "bbox": [ + 105, + 504, + 505, + 516 + ], + "score": 1.0, + "content": "we empirically found that adding a gradient clip value (we randomly picked from [0.2, 1]) helps the", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 515, + 194, + 528 + ], + "spans": [ + { + "bbox": [ + 106, + 515, + 194, + 528 + ], + "score": 1.0, + "content": "training convergence.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 12, + "bbox_fs": [ + 105, + 471, + 505, + 528 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 539, + 296, + 551 + ], + "lines": [ + { + "bbox": [ + 105, + 539, + 297, + 552 + ], + "spans": [ + { + "bbox": [ + 105, + 539, + 297, + 552 + ], + "score": 1.0, + "content": "B.2 HYPERPARAMETERS FOR LSTM/GRU", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 107, + 560, + 505, + 594 + ], + "lines": [ + { + "bbox": [ + 105, + 558, + 505, + 573 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 505, + 573 + ], + "score": 1.0, + "content": "We also report the parameter setting for LSTM in Table 3. These values are picked from hyper-", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 570, + 505, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 570, + 505, + 583 + ], + "score": 1.0, + "content": "parameter search for LSTMs that have up to 3 layers, and the optimizers are chosen from {SGD,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 582, + 225, + 595 + ], + "spans": [ + { + "bbox": [ + 106, + 582, + 225, + 595 + ], + "score": 1.0, + "content": "Adam, RMSprop, Adagrad}.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17, + "bbox_fs": [ + 105, + 558, + 505, + 595 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 599, + 504, + 621 + ], + "lines": [ + { + "bbox": [ + 106, + 599, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 106, + 599, + 505, + 612 + ], + "score": 1.0, + "content": "GRU hyperparameters were chosen in a similar fashion, but with more hidden units to keep the total", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 610, + 369, + 621 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 369, + 621 + ], + "score": 1.0, + "content": "model size approximately the same (since a GRU cell is smaller).", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19.5, + "bbox_fs": [ + 105, + 599, + 505, + 621 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 635, + 334, + 646 + ], + "lines": [ + { + "bbox": [ + 105, + 633, + 335, + 648 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 335, + 648 + ], + "score": 1.0, + "content": "B.3 COMPARE TO THE STATE OF THE ART RESULTS", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 106, + 655, + 504, + 677 + ], + "lines": [ + { + "bbox": [ + 105, + 655, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 505, + 668 + ], + "score": 1.0, + "content": "As previously noted, TCN can still be outperformed by optimized RNNs in some of the tasks, whose", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 667, + 479, + 678 + ], + "spans": [ + { + "bbox": [ + 106, + 667, + 479, + 678 + ], + "score": 1.0, + "content": "results are summarized in Table 4 below. The same TCN architecture is used across all tasks.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5, + "bbox_fs": [ + 105, + 655, + 505, + 678 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 683, + 429, + 695 + ], + "lines": [ + { + "bbox": [ + 106, + 683, + 429, + 695 + ], + "spans": [ + { + "bbox": [ + 106, + 683, + 429, + 695 + ], + "score": 1.0, + "content": "Note that the size of the SoTA model may be different from the size of the TCN.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24, + "bbox_fs": [ + 106, + 683, + 429, + 695 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 106, + 132, + 533, + 372 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 174, + 111, + 432, + 123 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 176, + 110, + 433, + 124 + ], + "spans": [ + { + "bbox": [ + 176, + 110, + 433, + 124 + ], + "score": 1.0, + "content": "Table 3: LSTM parameter settings for experiments in Section 4.", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table_body", + "bbox": [ + 106, + 132, + 533, + 372 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 132, + 533, + 372 + ], + "spans": [ + { + "bbox": [ + 106, + 132, + 533, + 372 + ], + "score": 0.987, + "html": "
LSTM SETTINGS(KEY PARAMETERS)
Dataset/TaskSubtasknHiddenDropoutGrad ClipBiasNote
The Adding ProblemT= 200277505.0SGD 1e-3
T= 4002770.05010.0Adam 2e-3
T= 600113051.01
Seq. MNIST:11300.011.0RMSprop 1e-3
Permuted MNIST111300.0110.0RMSprop 1e-3
Copy Memory TaskT= 5001500.25
T=10001500.0511RMSprop/Adam
T= 20003281
Music JSB Chorales122000.2110.0SGD/Adam
Music Nottingham-32800.10.5-Adam 4e-3
Word-level LM15001-
PTB37000.40.31.0SGD 30,Emb. 700, etc.
Wiki-103--···Grave et al. (2016)
LAMBADA---1-Grave et al. (2016)
Char-level LMPTB6000.10.5-Emb. size 120
text82110240.150.51Adam 1e-2
", + "type": "table", + "image_path": "73d40644ba73244a6c32276d6302ef92fc2e7e143437b73c5e720fe7870168fc.jpg" + } + ] + } + ], + "index": 2, + "virtual_lines": [ + { + "bbox": [ + 106, + 132, + 533, + 212.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 212.0, + 533, + 292.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 106, + 292.0, + 533, + 372.0 + ], + "spans": [], + "index": 3 + } + ] + } + ], + "index": 1.0 + }, + { + "type": "table", + "bbox": [ + 106, + 466, + 519, + 695 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 181, + 444, + 426, + 456 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 181, + 444, + 427, + 457 + ], + "spans": [ + { + "bbox": [ + 181, + 444, + 427, + 457 + ], + "score": 1.0, + "content": "Table 4: State of the art (SoTA) results for tasks in Section 4.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "table_body", + "bbox": [ + 106, + 466, + 519, + 695 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 466, + 519, + 695 + ], + "spans": [ + { + "bbox": [ + 106, + 466, + 519, + 695 + ], + "score": 0.985, + "html": "
TCN VS. SoTA RESULTS
TaskTCN ResultSizeSoTASizeModel
Seq. MNIST (acc.)99.021K99.021KDilated GRU (Chang et al., 2017)
P-MNIST (acc.)97.242K95.942K Zoneout (Krueger et al., 2017)
Adding Prob. 600 (loss)5.8e-570K5.3e-570KRegularized GRU
Copy Memory 1000 (loss)3.5e-570K0.01170KEURNN (Jing et al., 2017)
JSB Chorales (loss)8.10300K3.47：DBN+LSTM(Vohra et al., 2015)
Nottingham (loss)3.071M1.32-DBN+LSTM (Vohra et al., 2015)
Word PTB (ppl)90.1713M52.824MAWD-LSTM + Cont.Cache(Merity et al., 2017)
Word Wiki-103 (ppl)45.19148M40.4>300MNeural Cache Model (Large)(Grave et al., 2016)
Word LAMBADA (ppl)127956M138>100MNeural Cache Model (Large)(Grave et al., 2016)
Char PTB (bpc)1.353M1.2214M2-LayerNorm HyperLSTM(Ha et al., 2017)
Char text8 (bpc)1.454.6M1.29>12MHM-LSTM (Chung et al., 2016)
", + "type": "table", + "image_path": "278d38dcdbaf08f00e3539a54c3a34cbb2dc66d4ae477cbd1ad7a96a3913491a.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 106, + 466, + 519, + 542.3333333333334 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 106, + 542.3333333333334, + 519, + 618.6666666666667 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 106, + 618.6666666666667, + 519, + 695.0000000000001 + ], + "spans": [], + "index": 7 + } + ] + } + ], + "index": 5.0 + } + ], + "page_idx": 17, + "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": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 313, + 763 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 313, + 763 + ], + "score": 1.0, + "content": "18", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 106, + 132, + 533, + 372 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 174, + 111, + 432, + 123 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 176, + 110, + 433, + 124 + ], + "spans": [ + { + "bbox": [ + 176, + 110, + 433, + 124 + ], + "score": 1.0, + "content": "Table 3: LSTM parameter settings for experiments in Section 4.", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table_body", + "bbox": [ + 106, + 132, + 533, + 372 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 132, + 533, + 372 + ], + "spans": [ + { + "bbox": [ + 106, + 132, + 533, + 372 + ], + "score": 0.987, + "html": "
LSTM SETTINGS(KEY PARAMETERS)
Dataset/TaskSubtasknHiddenDropoutGrad ClipBiasNote
The Adding ProblemT= 200277505.0SGD 1e-3
T= 4002770.05010.0Adam 2e-3
T= 600113051.01
Seq. MNIST:11300.011.0RMSprop 1e-3
Permuted MNIST111300.0110.0RMSprop 1e-3
Copy Memory TaskT= 5001500.25
T=10001500.0511RMSprop/Adam
T= 20003281
Music JSB Chorales122000.2110.0SGD/Adam
Music Nottingham-32800.10.5-Adam 4e-3
Word-level LM15001-
PTB37000.40.31.0SGD 30,Emb. 700, etc.
Wiki-103--···Grave et al. (2016)
LAMBADA---1-Grave et al. (2016)
Char-level LMPTB6000.10.5-Emb. size 120
text82110240.150.51Adam 1e-2
", + "type": "table", + "image_path": "73d40644ba73244a6c32276d6302ef92fc2e7e143437b73c5e720fe7870168fc.jpg" + } + ] + } + ], + "index": 2, + "virtual_lines": [ + { + "bbox": [ + 106, + 132, + 533, + 212.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 212.0, + 533, + 292.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 106, + 292.0, + 533, + 372.0 + ], + "spans": [], + "index": 3 + } + ] + } + ], + "index": 1.0 + }, + { + "type": "table", + "bbox": [ + 106, + 466, + 519, + 695 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 181, + 444, + 426, + 456 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 181, + 444, + 427, + 457 + ], + "spans": [ + { + "bbox": [ + 181, + 444, + 427, + 457 + ], + "score": 1.0, + "content": "Table 4: State of the art (SoTA) results for tasks in Section 4.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "table_body", + "bbox": [ + 106, + 466, + 519, + 695 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 466, + 519, + 695 + ], + "spans": [ + { + "bbox": [ + 106, + 466, + 519, + 695 + ], + "score": 0.985, + "html": "
TCN VS. SoTA RESULTS
TaskTCN ResultSizeSoTASizeModel
Seq. MNIST (acc.)99.021K99.021KDilated GRU (Chang et al., 2017)
P-MNIST (acc.)97.242K95.942K Zoneout (Krueger et al., 2017)
Adding Prob. 600 (loss)5.8e-570K5.3e-570KRegularized GRU
Copy Memory 1000 (loss)3.5e-570K0.01170KEURNN (Jing et al., 2017)
JSB Chorales (loss)8.10300K3.47：DBN+LSTM(Vohra et al., 2015)
Nottingham (loss)3.071M1.32-DBN+LSTM (Vohra et al., 2015)
Word PTB (ppl)90.1713M52.824MAWD-LSTM + Cont.Cache(Merity et al., 2017)
Word Wiki-103 (ppl)45.19148M40.4>300MNeural Cache Model (Large)(Grave et al., 2016)
Word LAMBADA (ppl)127956M138>100MNeural Cache Model (Large)(Grave et al., 2016)
Char PTB (bpc)1.353M1.2214M2-LayerNorm HyperLSTM(Ha et al., 2017)
Char text8 (bpc)1.454.6M1.29>12MHM-LSTM (Chung et al., 2016)
", + "type": "table", + "image_path": "278d38dcdbaf08f00e3539a54c3a34cbb2dc66d4ae477cbd1ad7a96a3913491a.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 106, + 466, + 519, + 542.3333333333334 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 106, + 542.3333333333334, + 519, + 618.6666666666667 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 106, + 618.6666666666667, + 519, + 695.0000000000001 + ], + "spans": [], + "index": 7 + } + ] + } + ], + "index": 5.0 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 107, + 106, + 503, + 347 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 107, + 106, + 503, + 347 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 107, + 106, + 503, + 347 + ], + "spans": [ + { + "bbox": [ + 107, + 106, + 503, + 347 + ], + "score": 0.975, + "type": "image", + "image_path": "5e61b9b3ee15df3f95a75c0ba19ebb15a423e433d11b444e7c29d44ad108a8d4.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 107, + 106, + 503, + 186.33333333333331 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 107, + 186.33333333333331, + 503, + 266.66666666666663 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 107, + 266.66666666666663, + 503, + 346.99999999999994 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 126, + 358, + 480, + 370 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 128, + 357, + 481, + 371 + ], + "spans": [ + { + "bbox": [ + 128, + 357, + 481, + 371 + ], + "score": 1.0, + "content": "Figure 8: Controlled experiments that examine different components of the TCN model", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "text", + "bbox": [ + 106, + 384, + 505, + 450 + ], + "lines": [ + { + "bbox": [ + 106, + 384, + 505, + 395 + ], + "spans": [ + { + "bbox": [ + 106, + 384, + 505, + 395 + ], + "score": 1.0, + "content": "In this section we briefly study, via controlled experiments, the effect of filter size and residual", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 394, + 505, + 407 + ], + "spans": [ + { + "bbox": [ + 105, + 394, + 505, + 407 + ], + "score": 1.0, + "content": "block on the TCN’s ability to model different sequential tasks. Figure 8 shows the results of this", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 405, + 505, + 418 + ], + "spans": [ + { + "bbox": [ + 106, + 405, + 505, + 418 + ], + "score": 1.0, + "content": "ablative analysis. We kept the model size and the depth of the networks exactly the same within each", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 416, + 506, + 429 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 506, + 429 + ], + "score": 1.0, + "content": "experiment so that dilation factor is controlled. We conducted the experiment on three very different", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 104, + 426, + 506, + 441 + ], + "spans": [ + { + "bbox": [ + 104, + 426, + 506, + 441 + ], + "score": 1.0, + "content": "tasks: the copy memory task, permuted MNIST (P-MNIST), as well as word-level PTB language", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 437, + 150, + 452 + ], + "spans": [ + { + "bbox": [ + 105, + 437, + 150, + 452 + ], + "score": 1.0, + "content": "modeling.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 6.5 + }, + { + "type": "text", + "bbox": [ + 106, + 455, + 505, + 522 + ], + "lines": [ + { + "bbox": [ + 106, + 455, + 505, + 468 + ], + "spans": [ + { + "bbox": [ + 106, + 455, + 505, + 468 + ], + "score": 1.0, + "content": "Through these experiments, we empirically confirm that both filter sizes and residuals play important", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 467, + 505, + 479 + ], + "spans": [ + { + "bbox": [ + 106, + 467, + 505, + 479 + ], + "score": 1.0, + "content": "roles in TCN’s capability of modeling potentially long dependencies. In both the copy memory and", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 477, + 505, + 490 + ], + "spans": [ + { + "bbox": [ + 106, + 477, + 505, + 490 + ], + "score": 1.0, + "content": "the permuted MNIST task, we observed faster convergence and better result for larger filter sizes", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 489, + 505, + 501 + ], + "spans": [ + { + "bbox": [ + 105, + 489, + 274, + 501 + ], + "score": 1.0, + "content": "(e.g. in the copy memory task, a filter size", + "type": "text" + }, + { + "bbox": [ + 274, + 489, + 300, + 500 + ], + "score": 0.9, + "content": "k \\geq 3", + "type": "inline_equation" + }, + { + "bbox": [ + 300, + 489, + 505, + 501 + ], + "score": 1.0, + "content": "led to only suboptimal convergence). In word-level", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 498, + 506, + 512 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 221, + 512 + ], + "score": 1.0, + "content": "PTB, we find a filter size of", + "type": "text" + }, + { + "bbox": [ + 221, + 500, + 247, + 510 + ], + "score": 0.9, + "content": "k = 3", + "type": "inline_equation" + }, + { + "bbox": [ + 247, + 498, + 475, + 512 + ], + "score": 1.0, + "content": "works best. This is not a complete surprise, since a size-", + "type": "text" + }, + { + "bbox": [ + 476, + 500, + 482, + 509 + ], + "score": 0.8, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 483, + 498, + 506, + 512 + ], + "score": 1.0, + "content": "filter", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 510, + 380, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 230, + 524 + ], + "score": 1.0, + "content": "on the inputs is analogous to a", + "type": "text" + }, + { + "bbox": [ + 230, + 511, + 236, + 520 + ], + "score": 0.81, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 237, + 510, + 380, + 524 + ], + "score": 1.0, + "content": "-gram model in language modeling.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 12.5 + }, + { + "type": "text", + "bbox": [ + 107, + 527, + 504, + 560 + ], + "lines": [ + { + "bbox": [ + 106, + 528, + 504, + 539 + ], + "spans": [ + { + "bbox": [ + 106, + 528, + 504, + 539 + ], + "score": 1.0, + "content": "Results of control experiments on the residual function are shown in Figure 8d, 8e and 8f. In all", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 538, + 505, + 551 + ], + "spans": [ + { + "bbox": [ + 105, + 538, + 505, + 551 + ], + "score": 1.0, + "content": "three scenarios, we observe that the residual stabilizes the training by bringing a faster convergence", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 549, + 491, + 561 + ], + "spans": [ + { + "bbox": [ + 105, + 549, + 491, + 561 + ], + "score": 1.0, + "content": "as well as better final results, compared to TCN with the same model size but no residual block.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17 + } + ], + "page_idx": 18, + "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": "19", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 105, + 81, + 443, + 94 + ], + "lines": [ + { + "bbox": [ + 105, + 79, + 444, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 79, + 444, + 96 + ], + "score": 1.0, + "content": "C THE EFFECT OF FILTER SIZE AND RESIDUAL BLOCK ON TCN", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 107, + 106, + 503, + 347 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 107, + 106, + 503, + 347 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 107, + 106, + 503, + 347 + ], + "spans": [ + { + "bbox": [ + 107, + 106, + 503, + 347 + ], + "score": 0.975, + "type": "image", + "image_path": "5e61b9b3ee15df3f95a75c0ba19ebb15a423e433d11b444e7c29d44ad108a8d4.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 107, + 106, + 503, + 186.33333333333331 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 107, + 186.33333333333331, + 503, + 266.66666666666663 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 107, + 266.66666666666663, + 503, + 346.99999999999994 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 126, + 358, + 480, + 370 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 128, + 357, + 481, + 371 + ], + "spans": [ + { + "bbox": [ + 128, + 357, + 481, + 371 + ], + "score": 1.0, + "content": "Figure 8: Controlled experiments that examine different components of the TCN model", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "text", + "bbox": [ + 106, + 384, + 505, + 450 + ], + "lines": [ + { + "bbox": [ + 106, + 384, + 505, + 395 + ], + "spans": [ + { + "bbox": [ + 106, + 384, + 505, + 395 + ], + "score": 1.0, + "content": "In this section we briefly study, via controlled experiments, the effect of filter size and residual", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 394, + 505, + 407 + ], + "spans": [ + { + "bbox": [ + 105, + 394, + 505, + 407 + ], + "score": 1.0, + "content": "block on the TCN’s ability to model different sequential tasks. Figure 8 shows the results of this", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 405, + 505, + 418 + ], + "spans": [ + { + "bbox": [ + 106, + 405, + 505, + 418 + ], + "score": 1.0, + "content": "ablative analysis. We kept the model size and the depth of the networks exactly the same within each", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 416, + 506, + 429 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 506, + 429 + ], + "score": 1.0, + "content": "experiment so that dilation factor is controlled. We conducted the experiment on three very different", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 104, + 426, + 506, + 441 + ], + "spans": [ + { + "bbox": [ + 104, + 426, + 506, + 441 + ], + "score": 1.0, + "content": "tasks: the copy memory task, permuted MNIST (P-MNIST), as well as word-level PTB language", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 437, + 150, + 452 + ], + "spans": [ + { + "bbox": [ + 105, + 437, + 150, + 452 + ], + "score": 1.0, + "content": "modeling.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 6.5, + "bbox_fs": [ + 104, + 384, + 506, + 452 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 455, + 505, + 522 + ], + "lines": [ + { + "bbox": [ + 106, + 455, + 505, + 468 + ], + "spans": [ + { + "bbox": [ + 106, + 455, + 505, + 468 + ], + "score": 1.0, + "content": "Through these experiments, we empirically confirm that both filter sizes and residuals play important", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 467, + 505, + 479 + ], + "spans": [ + { + "bbox": [ + 106, + 467, + 505, + 479 + ], + "score": 1.0, + "content": "roles in TCN’s capability of modeling potentially long dependencies. In both the copy memory and", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 477, + 505, + 490 + ], + "spans": [ + { + "bbox": [ + 106, + 477, + 505, + 490 + ], + "score": 1.0, + "content": "the permuted MNIST task, we observed faster convergence and better result for larger filter sizes", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 489, + 505, + 501 + ], + "spans": [ + { + "bbox": [ + 105, + 489, + 274, + 501 + ], + "score": 1.0, + "content": "(e.g. in the copy memory task, a filter size", + "type": "text" + }, + { + "bbox": [ + 274, + 489, + 300, + 500 + ], + "score": 0.9, + "content": "k \\geq 3", + "type": "inline_equation" + }, + { + "bbox": [ + 300, + 489, + 505, + 501 + ], + "score": 1.0, + "content": "led to only suboptimal convergence). In word-level", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 498, + 506, + 512 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 221, + 512 + ], + "score": 1.0, + "content": "PTB, we find a filter size of", + "type": "text" + }, + { + "bbox": [ + 221, + 500, + 247, + 510 + ], + "score": 0.9, + "content": "k = 3", + "type": "inline_equation" + }, + { + "bbox": [ + 247, + 498, + 475, + 512 + ], + "score": 1.0, + "content": "works best. This is not a complete surprise, since a size-", + "type": "text" + }, + { + "bbox": [ + 476, + 500, + 482, + 509 + ], + "score": 0.8, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 483, + 498, + 506, + 512 + ], + "score": 1.0, + "content": "filter", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 510, + 380, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 230, + 524 + ], + "score": 1.0, + "content": "on the inputs is analogous to a", + "type": "text" + }, + { + "bbox": [ + 230, + 511, + 236, + 520 + ], + "score": 0.81, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 237, + 510, + 380, + 524 + ], + "score": 1.0, + "content": "-gram model in language modeling.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 12.5, + "bbox_fs": [ + 105, + 455, + 506, + 524 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 527, + 504, + 560 + ], + "lines": [ + { + "bbox": [ + 106, + 528, + 504, + 539 + ], + "spans": [ + { + "bbox": [ + 106, + 528, + 504, + 539 + ], + "score": 1.0, + "content": "Results of control experiments on the residual function are shown in Figure 8d, 8e and 8f. In all", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 538, + 505, + 551 + ], + "spans": [ + { + "bbox": [ + 105, + 538, + 505, + 551 + ], + "score": 1.0, + "content": "three scenarios, we observe that the residual stabilizes the training by bringing a faster convergence", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 549, + 491, + 561 + ], + "spans": [ + { + "bbox": [ + 105, + 549, + 491, + 561 + ], + "score": 1.0, + "content": "as well as better final results, compared to TCN with the same model size but no residual block.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17, + "bbox_fs": [ + 105, + 528, + 505, + 561 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 106, + 81, + 367, + 94 + ], + "lines": [ + { + "bbox": [ + 106, + 80, + 368, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 80, + 368, + 96 + ], + "score": 1.0, + "content": "D EXPERIMENTS: GATING MECHANISM ON TCN", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 106, + 106, + 505, + 140 + ], + "lines": [ + { + "bbox": [ + 105, + 104, + 505, + 120 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 505, + 120 + ], + "score": 1.0, + "content": "One component that has shown to be effective in adapting a TCN to language modeling is the gating", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 117, + 505, + 129 + ], + "spans": [ + { + "bbox": [ + 105, + 117, + 505, + 129 + ], + "score": 1.0, + "content": "mechanism within the residual block, which was used in works such as Dauphin et al. (2017). In", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 128, + 419, + 140 + ], + "spans": [ + { + "bbox": [ + 105, + 128, + 419, + 140 + ], + "score": 1.0, + "content": "this section, we empirically evaluate the effects of adding gated units to TCN.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 107, + 145, + 505, + 200 + ], + "lines": [ + { + "bbox": [ + 106, + 145, + 505, + 158 + ], + "spans": [ + { + "bbox": [ + 106, + 145, + 505, + 158 + ], + "score": 1.0, + "content": "We replace the ReLU within the TCN residual block with a gating mechanism, represented by", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 156, + 505, + 168 + ], + "spans": [ + { + "bbox": [ + 106, + 156, + 505, + 168 + ], + "score": 1.0, + "content": "an elementwise product between two convolutional layers, with one of them also passing through", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 104, + 165, + 506, + 181 + ], + "spans": [ + { + "bbox": [ + 104, + 165, + 187, + 181 + ], + "score": 1.0, + "content": "a sigmoid function", + "type": "text" + }, + { + "bbox": [ + 187, + 167, + 211, + 179 + ], + "score": 0.92, + "content": "\\sigma ( x ) ^ { 5 }", + "type": "inline_equation" + }, + { + "bbox": [ + 212, + 165, + 506, + 181 + ], + "score": 1.0, + "content": ". Prior works such as Dauphin et al. (2017) has used similar gating to", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 177, + 506, + 192 + ], + "spans": [ + { + "bbox": [ + 105, + 177, + 506, + 192 + ], + "score": 1.0, + "content": "control the path through which information flows in the network, and achieved great performance", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 189, + 222, + 201 + ], + "spans": [ + { + "bbox": [ + 106, + 189, + 222, + 201 + ], + "score": 1.0, + "content": "on language modeling tasks.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 6 + }, + { + "type": "table", + "bbox": [ + 199, + 231, + 411, + 407 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 178, + 210, + 428, + 222 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 178, + 209, + 429, + 223 + ], + "spans": [ + { + "bbox": [ + 178, + 209, + 429, + 223 + ], + "score": 1.0, + "content": "Table 5: TCN with Gating Mechanism within Residual Block.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 9 + }, + { + "type": "table_body", + "bbox": [ + 199, + 231, + 411, + 407 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 199, + 231, + 411, + 407 + ], + "spans": [ + { + "bbox": [ + 199, + 231, + 411, + 407 + ], + "score": 0.98, + "html": "
RELU TCN VS.GATED TCN RESULTS
TaskTCNTCN + Gating
Seq. MNIST (acc.)99.099.0
P-MNIST (acc.)97.296.9
Adding Prob. 600 (loss)5.8e-55.6e-5
CopyMemory 11000 (loss)3.5e-50.00508
JSB Chorales (loss)8.108.13
Nottingham (loss)3.073.12
Word PTB (ppl)90.1788.91
Char PTB (bpc)1.351.343
Char text8 (bpc)1.451.48
", + "type": "table", + "image_path": "5f6f9c7e069590d701d2fd81496ef2a036bcc6446052a5d148a33ffb57b1e7e2.jpg" + } + ] + } + ], + "index": 15.5, + "virtual_lines": [ + { + "bbox": [ + 199, + 231, + 411, + 245.66666666666666 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 199, + 245.66666666666666, + 411, + 260.3333333333333 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 199, + 260.3333333333333, + 411, + 275.0 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 199, + 275.0, + 411, + 289.6666666666667 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 199, + 289.6666666666667, + 411, + 304.33333333333337 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 199, + 304.33333333333337, + 411, + 319.00000000000006 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 199, + 319.00000000000006, + 411, + 333.66666666666674 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 199, + 333.66666666666674, + 411, + 348.3333333333334 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 199, + 348.3333333333334, + 411, + 363.0000000000001 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 199, + 363.0000000000001, + 411, + 377.6666666666668 + ], + "spans": [], + "index": 19 + }, + { + "bbox": [ + 199, + 377.6666666666668, + 411, + 392.3333333333335 + ], + "spans": [], + "index": 20 + }, + { + "bbox": [ + 199, + 392.3333333333335, + 411, + 407.00000000000017 + ], + "spans": [], + "index": 21 + } + ] + } + ], + "index": 12.25 + }, + { + "type": "text", + "bbox": [ + 106, + 422, + 505, + 489 + ], + "lines": [ + { + "bbox": [ + 106, + 421, + 505, + 436 + ], + "spans": [ + { + "bbox": [ + 106, + 421, + 505, + 436 + ], + "score": 1.0, + "content": "Through these comparisons, we notice that gating components do further improve the TCN results", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 434, + 504, + 445 + ], + "spans": [ + { + "bbox": [ + 106, + 434, + 504, + 445 + ], + "score": 1.0, + "content": "on certain language modeling datasets like PTB, which agrees with prior works. However, we do not", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 443, + 506, + 458 + ], + "spans": [ + { + "bbox": [ + 105, + 443, + 506, + 458 + ], + "score": 1.0, + "content": "observe such benefits to exist in general on sequence prediction tasks, such as on polyphonic music", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 455, + 505, + 469 + ], + "spans": [ + { + "bbox": [ + 105, + 455, + 505, + 469 + ], + "score": 1.0, + "content": "datasets, and those simpler benchmark tasks requiring more long-term memories. For example, on", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 466, + 506, + 479 + ], + "spans": [ + { + "bbox": [ + 106, + 466, + 217, + 479 + ], + "score": 1.0, + "content": "the copy memory task with", + "type": "text" + }, + { + "bbox": [ + 218, + 467, + 260, + 477 + ], + "score": 0.9, + "content": "T = 1 0 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 260, + 466, + 506, + 479 + ], + "score": 1.0, + "content": ", we find that gating mechanism deteriorates the convergence", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 477, + 412, + 491 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 412, + 491 + ], + "score": 1.0, + "content": "of TCN to a suboptimal result that is only slightly better than random guess.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 24.5 + } + ], + "page_idx": 19, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 105, + 712, + 506, + 732 + ], + "lines": [ + { + "bbox": [ + 118, + 710, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 118, + 710, + 505, + 723 + ], + "score": 1.0, + "content": "5Note that this introduces approximately twice as many convolutional layers than in generic TCN described", + "type": "text" + } + ] + }, + { + "bbox": [ + 106, + 721, + 476, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 476, + 732 + ], + "score": 1.0, + "content": "in section 3. In Table 5, we keep the number of parameters for both architecture at about the same size", + "type": "text" + } + ] + } + ] + }, + { + "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": [ + 298, + 749, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 298, + 749, + 313, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 15, + "width": 15 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 106, + 81, + 367, + 94 + ], + "lines": [ + { + "bbox": [ + 106, + 80, + 368, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 80, + 368, + 96 + ], + "score": 1.0, + "content": "D EXPERIMENTS: GATING MECHANISM ON TCN", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 106, + 106, + 505, + 140 + ], + "lines": [ + { + "bbox": [ + 105, + 104, + 505, + 120 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 505, + 120 + ], + "score": 1.0, + "content": "One component that has shown to be effective in adapting a TCN to language modeling is the gating", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 117, + 505, + 129 + ], + "spans": [ + { + "bbox": [ + 105, + 117, + 505, + 129 + ], + "score": 1.0, + "content": "mechanism within the residual block, which was used in works such as Dauphin et al. (2017). In", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 128, + 419, + 140 + ], + "spans": [ + { + "bbox": [ + 105, + 128, + 419, + 140 + ], + "score": 1.0, + "content": "this section, we empirically evaluate the effects of adding gated units to TCN.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2, + "bbox_fs": [ + 105, + 104, + 505, + 140 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 145, + 505, + 200 + ], + "lines": [ + { + "bbox": [ + 106, + 145, + 505, + 158 + ], + "spans": [ + { + "bbox": [ + 106, + 145, + 505, + 158 + ], + "score": 1.0, + "content": "We replace the ReLU within the TCN residual block with a gating mechanism, represented by", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 156, + 505, + 168 + ], + "spans": [ + { + "bbox": [ + 106, + 156, + 505, + 168 + ], + "score": 1.0, + "content": "an elementwise product between two convolutional layers, with one of them also passing through", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 104, + 165, + 506, + 181 + ], + "spans": [ + { + "bbox": [ + 104, + 165, + 187, + 181 + ], + "score": 1.0, + "content": "a sigmoid function", + "type": "text" + }, + { + "bbox": [ + 187, + 167, + 211, + 179 + ], + "score": 0.92, + "content": "\\sigma ( x ) ^ { 5 }", + "type": "inline_equation" + }, + { + "bbox": [ + 212, + 165, + 506, + 181 + ], + "score": 1.0, + "content": ". Prior works such as Dauphin et al. (2017) has used similar gating to", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 177, + 506, + 192 + ], + "spans": [ + { + "bbox": [ + 105, + 177, + 506, + 192 + ], + "score": 1.0, + "content": "control the path through which information flows in the network, and achieved great performance", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 189, + 222, + 201 + ], + "spans": [ + { + "bbox": [ + 106, + 189, + 222, + 201 + ], + "score": 1.0, + "content": "on language modeling tasks.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 6, + "bbox_fs": [ + 104, + 145, + 506, + 201 + ] + }, + { + "type": "table", + "bbox": [ + 199, + 231, + 411, + 407 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 178, + 210, + 428, + 222 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 178, + 209, + 429, + 223 + ], + "spans": [ + { + "bbox": [ + 178, + 209, + 429, + 223 + ], + "score": 1.0, + "content": "Table 5: TCN with Gating Mechanism within Residual Block.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 9 + }, + { + "type": "table_body", + "bbox": [ + 199, + 231, + 411, + 407 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 199, + 231, + 411, + 407 + ], + "spans": [ + { + "bbox": [ + 199, + 231, + 411, + 407 + ], + "score": 0.98, + "html": "
RELU TCN VS.GATED TCN RESULTS
TaskTCNTCN + Gating
Seq. MNIST (acc.)99.099.0
P-MNIST (acc.)97.296.9
Adding Prob. 600 (loss)5.8e-55.6e-5
CopyMemory 11000 (loss)3.5e-50.00508
JSB Chorales (loss)8.108.13
Nottingham (loss)3.073.12
Word PTB (ppl)90.1788.91
Char PTB (bpc)1.351.343
Char text8 (bpc)1.451.48
", + "type": "table", + "image_path": "5f6f9c7e069590d701d2fd81496ef2a036bcc6446052a5d148a33ffb57b1e7e2.jpg" + } + ] + } + ], + "index": 15.5, + "virtual_lines": [ + { + "bbox": [ + 199, + 231, + 411, + 245.66666666666666 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 199, + 245.66666666666666, + 411, + 260.3333333333333 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 199, + 260.3333333333333, + 411, + 275.0 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 199, + 275.0, + 411, + 289.6666666666667 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 199, + 289.6666666666667, + 411, + 304.33333333333337 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 199, + 304.33333333333337, + 411, + 319.00000000000006 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 199, + 319.00000000000006, + 411, + 333.66666666666674 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 199, + 333.66666666666674, + 411, + 348.3333333333334 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 199, + 348.3333333333334, + 411, + 363.0000000000001 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 199, + 363.0000000000001, + 411, + 377.6666666666668 + ], + "spans": [], + "index": 19 + }, + { + "bbox": [ + 199, + 377.6666666666668, + 411, + 392.3333333333335 + ], + "spans": [], + "index": 20 + }, + { + "bbox": [ + 199, + 392.3333333333335, + 411, + 407.00000000000017 + ], + "spans": [], + "index": 21 + } + ] + } + ], + "index": 12.25 + }, + { + "type": "text", + "bbox": [ + 106, + 422, + 505, + 489 + ], + "lines": [ + { + "bbox": [ + 106, + 421, + 505, + 436 + ], + "spans": [ + { + "bbox": [ + 106, + 421, + 505, + 436 + ], + "score": 1.0, + "content": "Through these comparisons, we notice that gating components do further improve the TCN results", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 434, + 504, + 445 + ], + "spans": [ + { + "bbox": [ + 106, + 434, + 504, + 445 + ], + "score": 1.0, + "content": "on certain language modeling datasets like PTB, which agrees with prior works. However, we do not", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 443, + 506, + 458 + ], + "spans": [ + { + "bbox": [ + 105, + 443, + 506, + 458 + ], + "score": 1.0, + "content": "observe such benefits to exist in general on sequence prediction tasks, such as on polyphonic music", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 455, + 505, + 469 + ], + "spans": [ + { + "bbox": [ + 105, + 455, + 505, + 469 + ], + "score": 1.0, + "content": "datasets, and those simpler benchmark tasks requiring more long-term memories. For example, on", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 466, + 506, + 479 + ], + "spans": [ + { + "bbox": [ + 106, + 466, + 217, + 479 + ], + "score": 1.0, + "content": "the copy memory task with", + "type": "text" + }, + { + "bbox": [ + 218, + 467, + 260, + 477 + ], + "score": 0.9, + "content": "T = 1 0 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 260, + 466, + 506, + 479 + ], + "score": 1.0, + "content": ", we find that gating mechanism deteriorates the convergence", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 477, + 412, + 491 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 412, + 491 + ], + "score": 1.0, + "content": "of TCN to a suboptimal result that is only slightly better than random guess.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 24.5, + "bbox_fs": [ + 105, + 421, + 506, + 491 + ] + } + ] + } + ], + "_backend": "pipeline", + "_version_name": "2.2.2" +} \ No newline at end of file