diff --git "a/parse/test/AL1fq05o7H/AL1fq05o7H_middle.json" "b/parse/test/AL1fq05o7H/AL1fq05o7H_middle.json" new file mode 100644--- /dev/null +++ "b/parse/test/AL1fq05o7H/AL1fq05o7H_middle.json" @@ -0,0 +1,77875 @@ +{ + "pdf_info": [ + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 78, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 106, + 78, + 505, + 98 + ], + "spans": [ + { + "bbox": [ + 106, + 78, + 505, + 98 + ], + "score": 1.0, + "content": "MAMBA: LINEAR-TIME SEQUENCE MODELING WITH", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 97, + 301, + 118 + ], + "spans": [ + { + "bbox": [ + 106, + 97, + 301, + 118 + ], + "score": 1.0, + "content": "SELECTIVE STATE SPACES", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 109, + 134, + 240, + 156 + ], + "lines": [ + { + "bbox": [ + 109, + 134, + 198, + 146 + ], + "spans": [ + { + "bbox": [ + 109, + 134, + 198, + 146 + ], + "score": 1.0, + "content": "Anonymous authors", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 108, + 145, + 241, + 156 + ], + "spans": [ + { + "bbox": [ + 108, + 145, + 241, + 156 + ], + "score": 1.0, + "content": "Paper under double-blind review", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2.5 + }, + { + "type": "title", + "bbox": [ + 278, + 185, + 333, + 196 + ], + "lines": [ + { + "bbox": [ + 276, + 183, + 336, + 199 + ], + "spans": [ + { + "bbox": [ + 276, + 183, + 336, + 199 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 143, + 208, + 469, + 435 + ], + "lines": [ + { + "bbox": [ + 141, + 208, + 469, + 222 + ], + "spans": [ + { + "bbox": [ + 141, + 208, + 469, + 222 + ], + "score": 1.0, + "content": "Foundation models, now powering most of the exciting applications in deep", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 141, + 219, + 469, + 231 + ], + "spans": [ + { + "bbox": [ + 141, + 219, + 469, + 231 + ], + "score": 1.0, + "content": "learning, are almost universally based on the Transformer architecture and its core", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 230, + 470, + 242 + ], + "spans": [ + { + "bbox": [ + 141, + 230, + 470, + 242 + ], + "score": 1.0, + "content": "attention module. Many subquadratic-time architectures such as linear attention,", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 241, + 470, + 254 + ], + "spans": [ + { + "bbox": [ + 141, + 241, + 470, + 254 + ], + "score": 1.0, + "content": "gated convolution and recurrent models, and structured state space models (SSMs)", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 252, + 469, + 264 + ], + "spans": [ + { + "bbox": [ + 141, + 252, + 469, + 264 + ], + "score": 1.0, + "content": "have been developed to address Transformers’ computational inefficiency on", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 141, + 263, + 470, + 275 + ], + "spans": [ + { + "bbox": [ + 141, + 263, + 470, + 275 + ], + "score": 1.0, + "content": "long sequences, but they have not performed as well as attention on important", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 273, + 470, + 285 + ], + "spans": [ + { + "bbox": [ + 141, + 273, + 470, + 285 + ], + "score": 1.0, + "content": "modalities such as language. We identify that a key weakness of such models is", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 284, + 471, + 296 + ], + "spans": [ + { + "bbox": [ + 141, + 284, + 471, + 296 + ], + "score": 1.0, + "content": "their inability to perform content-based reasoning, and make several improvements.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 295, + 470, + 307 + ], + "spans": [ + { + "bbox": [ + 141, + 295, + 470, + 307 + ], + "score": 1.0, + "content": "First, simply letting the SSM parameters be functions of the input addresses their", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 305, + 469, + 318 + ], + "spans": [ + { + "bbox": [ + 141, + 305, + 469, + 318 + ], + "score": 1.0, + "content": "weakness with discrete modalities, allowing the model to selectively propagate or", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 316, + 470, + 329 + ], + "spans": [ + { + "bbox": [ + 141, + 316, + 470, + 329 + ], + "score": 1.0, + "content": "forget information along the sequence length dimension depending on the current", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 327, + 470, + 339 + ], + "spans": [ + { + "bbox": [ + 141, + 327, + 470, + 339 + ], + "score": 1.0, + "content": "token. Second, even though this change prevents the use of efficient convolutions,", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 337, + 469, + 351 + ], + "spans": [ + { + "bbox": [ + 141, + 337, + 469, + 351 + ], + "score": 1.0, + "content": "we design a hardware-aware parallel algorithm in recurrent mode. We integrate", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 141, + 348, + 469, + 360 + ], + "spans": [ + { + "bbox": [ + 141, + 348, + 469, + 360 + ], + "score": 1.0, + "content": "these selective SSMs into a simplified end-to-end neural network architecture", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 141, + 359, + 469, + 371 + ], + "spans": [ + { + "bbox": [ + 141, + 359, + 452, + 371 + ], + "score": 1.0, + "content": "without attention or even MLP blocks (Mamba). Mamba enjoys fast inference", + "type": "text" + }, + { + "bbox": [ + 452, + 359, + 469, + 370 + ], + "score": 0.81, + "content": "( 5 \\times", + "type": "inline_equation" + } + ], + "index": 19 + }, + { + "bbox": [ + 141, + 370, + 470, + 383 + ], + "spans": [ + { + "bbox": [ + 141, + 370, + 470, + 383 + ], + "score": 1.0, + "content": "higher throughput than Transformers) and linear scaling in sequence length, and", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 141, + 381, + 470, + 393 + ], + "spans": [ + { + "bbox": [ + 141, + 381, + 470, + 393 + ], + "score": 1.0, + "content": "its performance improves on real data up to million-length sequences. As a general", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 141, + 392, + 470, + 404 + ], + "spans": [ + { + "bbox": [ + 141, + 392, + 470, + 404 + ], + "score": 1.0, + "content": "sequence model backbone, Mamba achieves state-of-the-art performance across", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 141, + 402, + 470, + 415 + ], + "spans": [ + { + "bbox": [ + 141, + 402, + 470, + 415 + ], + "score": 1.0, + "content": "several modalities such as language, audio, and genomics. On language modeling,", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 142, + 414, + 469, + 424 + ], + "spans": [ + { + "bbox": [ + 142, + 414, + 469, + 424 + ], + "score": 1.0, + "content": "our Mamba-1.4B model outperforms Transformers of the same size and matches", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 141, + 423, + 440, + 435 + ], + "spans": [ + { + "bbox": [ + 141, + 423, + 440, + 435 + ], + "score": 1.0, + "content": "Transformers twice its size, both in pretraining and downstream evaluation.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 15 + }, + { + "type": "title", + "bbox": [ + 108, + 450, + 206, + 463 + ], + "lines": [ + { + "bbox": [ + 105, + 449, + 208, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 449, + 208, + 466 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 107, + 468, + 505, + 608 + ], + "lines": [ + { + "bbox": [ + 106, + 469, + 505, + 480 + ], + "spans": [ + { + "bbox": [ + 106, + 469, + 505, + 480 + ], + "score": 1.0, + "content": "Foundation models (FMs), or large models pretrained on massive data then adapted for downstream", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 479, + 505, + 491 + ], + "spans": [ + { + "bbox": [ + 106, + 479, + 505, + 491 + ], + "score": 1.0, + "content": "tasks, have emerged as an effective paradigm in modern machine learning. The backbone of these FMs", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 490, + 505, + 501 + ], + "spans": [ + { + "bbox": [ + 106, + 490, + 505, + 501 + ], + "score": 1.0, + "content": "are often sequence models, operating on arbitrary sequences of inputs from a wide variety of domains", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 499, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 499, + 505, + 514 + ], + "score": 1.0, + "content": "such as language, images, speech, audio, time series, and genomics (Sutskever et al., 2014; Dosovitskiy", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 511, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 505, + 523 + ], + "score": 1.0, + "content": "et al., 2020; Oord et al., 2016; Brown et al., 2020; Ismail Fawaz et al., 2019; Poli et al., 2023). While this", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 522, + 505, + 534 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 505, + 534 + ], + "score": 1.0, + "content": "concept is agnostic to a particular choice of model architecture, modern FMs are predominantly based", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 533, + 506, + 545 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 506, + 545 + ], + "score": 1.0, + "content": "on a single type of sequence model: the Transformer (Vaswani et al., 2017) and its core attention layer.", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 543, + 506, + 556 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 506, + 556 + ], + "score": 1.0, + "content": "The efficacy of self-attention is attributed to its ability to route information densely within a context", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 554, + 506, + 567 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 506, + 567 + ], + "score": 1.0, + "content": "window, allowing it to model complex data. However, this property brings fundamental drawbacks: an", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 565, + 505, + 577 + ], + "spans": [ + { + "bbox": [ + 106, + 565, + 505, + 577 + ], + "score": 1.0, + "content": "inability to model anything outside of a finite window, and quadratic scaling with respect to the window", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 575, + 505, + 588 + ], + "spans": [ + { + "bbox": [ + 105, + 575, + 505, + 588 + ], + "score": 1.0, + "content": "length. An enormous body of research has appeared on more efficient variants of attention to overcome", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 586, + 506, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 586, + 506, + 599 + ], + "score": 1.0, + "content": "these drawbacks (Tay et al., 2022), but often at the expense of the very properties that makes it effective.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 597, + 504, + 609 + ], + "spans": [ + { + "bbox": [ + 106, + 597, + 504, + 609 + ], + "score": 1.0, + "content": "As of yet, none of these variants have been shown to be empirically effective at scale across domains.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 33 + }, + { + "type": "text", + "bbox": [ + 107, + 613, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 613, + 505, + 625 + ], + "spans": [ + { + "bbox": [ + 105, + 613, + 505, + 625 + ], + "score": 1.0, + "content": "Recently, structured state space sequence models (SSMs) (Gu et al., 2021; 2022a) have emerged", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 624, + 506, + 636 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 506, + 636 + ], + "score": 1.0, + "content": "as a promising class of architectures for sequence modeling. These models can be interpreted as a", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 635, + 504, + 646 + ], + "spans": [ + { + "bbox": [ + 106, + 635, + 504, + 646 + ], + "score": 1.0, + "content": "combination of recurrent neural networks (RNNs) and convolutional neural networks (CNNs), with", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 645, + 505, + 657 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 505, + 657 + ], + "score": 1.0, + "content": "inspiration from classical state space models (Kalman, 1960). This class of models can be computed", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 656, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 656, + 505, + 668 + ], + "score": 1.0, + "content": "very efficiently as either a recurrence or convolution, with linear or near-linear scaling in sequence", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 667, + 505, + 679 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 505, + 679 + ], + "score": 1.0, + "content": "length. Additionally, they have principled mechanisms for modeling long-range dependencies (Gu", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 676, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 505, + 690 + ], + "score": 1.0, + "content": "et al., 2020a) in certain data modalities, and have dominated benchmarks such as the Long Range", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 689, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 689, + 505, + 700 + ], + "score": 1.0, + "content": "Arena (Tay et al., 2021). Many flavors of SSMs (Gu et al., 2022a; Gupta, 2022; Gu et al., 2022b; Li et al.,", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "2023; Ma et al., 2023; Smith et al., 2023; Orvieto et al., 2023) have been successful in domains involving", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 710, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 506, + 722 + ], + "score": 1.0, + "content": "continuous signal data such as audio and vision (Goel et al., 2022; Saon et al., 2023; Nguyen et al., 2022).", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 106, + 720, + 501, + 731 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 501, + 731 + ], + "score": 1.0, + "content": "However, they have been less effective at modeling discrete and information-dense data such as text.", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 45 + } + ], + "page_idx": 0, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 304, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 305, + 39 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 305, + 39 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 308, + 761 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 308, + 761 + ], + "score": 1.0, + "content": "1", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 78, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 106, + 78, + 505, + 98 + ], + "spans": [ + { + "bbox": [ + 106, + 78, + 505, + 98 + ], + "score": 1.0, + "content": "MAMBA: LINEAR-TIME SEQUENCE MODELING WITH", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 97, + 301, + 118 + ], + "spans": [ + { + "bbox": [ + 106, + 97, + 301, + 118 + ], + "score": 1.0, + "content": "SELECTIVE STATE SPACES", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 109, + 134, + 240, + 156 + ], + "lines": [ + { + "bbox": [ + 109, + 134, + 198, + 146 + ], + "spans": [ + { + "bbox": [ + 109, + 134, + 198, + 146 + ], + "score": 1.0, + "content": "Anonymous authors", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 108, + 145, + 241, + 156 + ], + "spans": [ + { + "bbox": [ + 108, + 145, + 241, + 156 + ], + "score": 1.0, + "content": "Paper under double-blind review", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 2.5, + "bbox_fs": [ + 108, + 134, + 241, + 156 + ] + }, + { + "type": "title", + "bbox": [ + 278, + 185, + 333, + 196 + ], + "lines": [ + { + "bbox": [ + 276, + 183, + 336, + 199 + ], + "spans": [ + { + "bbox": [ + 276, + 183, + 336, + 199 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 143, + 208, + 469, + 435 + ], + "lines": [ + { + "bbox": [ + 141, + 208, + 469, + 222 + ], + "spans": [ + { + "bbox": [ + 141, + 208, + 469, + 222 + ], + "score": 1.0, + "content": "Foundation models, now powering most of the exciting applications in deep", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 141, + 219, + 469, + 231 + ], + "spans": [ + { + "bbox": [ + 141, + 219, + 469, + 231 + ], + "score": 1.0, + "content": "learning, are almost universally based on the Transformer architecture and its core", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 230, + 470, + 242 + ], + "spans": [ + { + "bbox": [ + 141, + 230, + 470, + 242 + ], + "score": 1.0, + "content": "attention module. Many subquadratic-time architectures such as linear attention,", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 241, + 470, + 254 + ], + "spans": [ + { + "bbox": [ + 141, + 241, + 470, + 254 + ], + "score": 1.0, + "content": "gated convolution and recurrent models, and structured state space models (SSMs)", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 252, + 469, + 264 + ], + "spans": [ + { + "bbox": [ + 141, + 252, + 469, + 264 + ], + "score": 1.0, + "content": "have been developed to address Transformers’ computational inefficiency on", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 141, + 263, + 470, + 275 + ], + "spans": [ + { + "bbox": [ + 141, + 263, + 470, + 275 + ], + "score": 1.0, + "content": "long sequences, but they have not performed as well as attention on important", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 273, + 470, + 285 + ], + "spans": [ + { + "bbox": [ + 141, + 273, + 470, + 285 + ], + "score": 1.0, + "content": "modalities such as language. We identify that a key weakness of such models is", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 284, + 471, + 296 + ], + "spans": [ + { + "bbox": [ + 141, + 284, + 471, + 296 + ], + "score": 1.0, + "content": "their inability to perform content-based reasoning, and make several improvements.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 295, + 470, + 307 + ], + "spans": [ + { + "bbox": [ + 141, + 295, + 470, + 307 + ], + "score": 1.0, + "content": "First, simply letting the SSM parameters be functions of the input addresses their", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 305, + 469, + 318 + ], + "spans": [ + { + "bbox": [ + 141, + 305, + 469, + 318 + ], + "score": 1.0, + "content": "weakness with discrete modalities, allowing the model to selectively propagate or", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 316, + 470, + 329 + ], + "spans": [ + { + "bbox": [ + 141, + 316, + 470, + 329 + ], + "score": 1.0, + "content": "forget information along the sequence length dimension depending on the current", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 327, + 470, + 339 + ], + "spans": [ + { + "bbox": [ + 141, + 327, + 470, + 339 + ], + "score": 1.0, + "content": "token. Second, even though this change prevents the use of efficient convolutions,", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 337, + 469, + 351 + ], + "spans": [ + { + "bbox": [ + 141, + 337, + 469, + 351 + ], + "score": 1.0, + "content": "we design a hardware-aware parallel algorithm in recurrent mode. We integrate", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 141, + 348, + 469, + 360 + ], + "spans": [ + { + "bbox": [ + 141, + 348, + 469, + 360 + ], + "score": 1.0, + "content": "these selective SSMs into a simplified end-to-end neural network architecture", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 141, + 359, + 469, + 371 + ], + "spans": [ + { + "bbox": [ + 141, + 359, + 452, + 371 + ], + "score": 1.0, + "content": "without attention or even MLP blocks (Mamba). Mamba enjoys fast inference", + "type": "text" + }, + { + "bbox": [ + 452, + 359, + 469, + 370 + ], + "score": 0.81, + "content": "( 5 \\times", + "type": "inline_equation" + } + ], + "index": 19 + }, + { + "bbox": [ + 141, + 370, + 470, + 383 + ], + "spans": [ + { + "bbox": [ + 141, + 370, + 470, + 383 + ], + "score": 1.0, + "content": "higher throughput than Transformers) and linear scaling in sequence length, and", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 141, + 381, + 470, + 393 + ], + "spans": [ + { + "bbox": [ + 141, + 381, + 470, + 393 + ], + "score": 1.0, + "content": "its performance improves on real data up to million-length sequences. As a general", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 141, + 392, + 470, + 404 + ], + "spans": [ + { + "bbox": [ + 141, + 392, + 470, + 404 + ], + "score": 1.0, + "content": "sequence model backbone, Mamba achieves state-of-the-art performance across", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 141, + 402, + 470, + 415 + ], + "spans": [ + { + "bbox": [ + 141, + 402, + 470, + 415 + ], + "score": 1.0, + "content": "several modalities such as language, audio, and genomics. On language modeling,", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 142, + 414, + 469, + 424 + ], + "spans": [ + { + "bbox": [ + 142, + 414, + 469, + 424 + ], + "score": 1.0, + "content": "our Mamba-1.4B model outperforms Transformers of the same size and matches", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 141, + 423, + 440, + 435 + ], + "spans": [ + { + "bbox": [ + 141, + 423, + 440, + 435 + ], + "score": 1.0, + "content": "Transformers twice its size, both in pretraining and downstream evaluation.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 15, + "bbox_fs": [ + 141, + 208, + 471, + 435 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 450, + 206, + 463 + ], + "lines": [ + { + "bbox": [ + 105, + 449, + 208, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 449, + 208, + 466 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 107, + 468, + 505, + 608 + ], + "lines": [ + { + "bbox": [ + 106, + 469, + 505, + 480 + ], + "spans": [ + { + "bbox": [ + 106, + 469, + 505, + 480 + ], + "score": 1.0, + "content": "Foundation models (FMs), or large models pretrained on massive data then adapted for downstream", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 479, + 505, + 491 + ], + "spans": [ + { + "bbox": [ + 106, + 479, + 505, + 491 + ], + "score": 1.0, + "content": "tasks, have emerged as an effective paradigm in modern machine learning. The backbone of these FMs", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 490, + 505, + 501 + ], + "spans": [ + { + "bbox": [ + 106, + 490, + 505, + 501 + ], + "score": 1.0, + "content": "are often sequence models, operating on arbitrary sequences of inputs from a wide variety of domains", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 499, + 505, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 499, + 505, + 514 + ], + "score": 1.0, + "content": "such as language, images, speech, audio, time series, and genomics (Sutskever et al., 2014; Dosovitskiy", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 511, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 505, + 523 + ], + "score": 1.0, + "content": "et al., 2020; Oord et al., 2016; Brown et al., 2020; Ismail Fawaz et al., 2019; Poli et al., 2023). While this", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 522, + 505, + 534 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 505, + 534 + ], + "score": 1.0, + "content": "concept is agnostic to a particular choice of model architecture, modern FMs are predominantly based", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 533, + 506, + 545 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 506, + 545 + ], + "score": 1.0, + "content": "on a single type of sequence model: the Transformer (Vaswani et al., 2017) and its core attention layer.", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 543, + 506, + 556 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 506, + 556 + ], + "score": 1.0, + "content": "The efficacy of self-attention is attributed to its ability to route information densely within a context", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 554, + 506, + 567 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 506, + 567 + ], + "score": 1.0, + "content": "window, allowing it to model complex data. However, this property brings fundamental drawbacks: an", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 565, + 505, + 577 + ], + "spans": [ + { + "bbox": [ + 106, + 565, + 505, + 577 + ], + "score": 1.0, + "content": "inability to model anything outside of a finite window, and quadratic scaling with respect to the window", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 575, + 505, + 588 + ], + "spans": [ + { + "bbox": [ + 105, + 575, + 505, + 588 + ], + "score": 1.0, + "content": "length. An enormous body of research has appeared on more efficient variants of attention to overcome", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 586, + 506, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 586, + 506, + 599 + ], + "score": 1.0, + "content": "these drawbacks (Tay et al., 2022), but often at the expense of the very properties that makes it effective.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 597, + 504, + 609 + ], + "spans": [ + { + "bbox": [ + 106, + 597, + 504, + 609 + ], + "score": 1.0, + "content": "As of yet, none of these variants have been shown to be empirically effective at scale across domains.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 33, + "bbox_fs": [ + 105, + 469, + 506, + 609 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 613, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 613, + 505, + 625 + ], + "spans": [ + { + "bbox": [ + 105, + 613, + 505, + 625 + ], + "score": 1.0, + "content": "Recently, structured state space sequence models (SSMs) (Gu et al., 2021; 2022a) have emerged", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 624, + 506, + 636 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 506, + 636 + ], + "score": 1.0, + "content": "as a promising class of architectures for sequence modeling. These models can be interpreted as a", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 635, + 504, + 646 + ], + "spans": [ + { + "bbox": [ + 106, + 635, + 504, + 646 + ], + "score": 1.0, + "content": "combination of recurrent neural networks (RNNs) and convolutional neural networks (CNNs), with", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 645, + 505, + 657 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 505, + 657 + ], + "score": 1.0, + "content": "inspiration from classical state space models (Kalman, 1960). This class of models can be computed", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 656, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 656, + 505, + 668 + ], + "score": 1.0, + "content": "very efficiently as either a recurrence or convolution, with linear or near-linear scaling in sequence", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 667, + 505, + 679 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 505, + 679 + ], + "score": 1.0, + "content": "length. Additionally, they have principled mechanisms for modeling long-range dependencies (Gu", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 676, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 505, + 690 + ], + "score": 1.0, + "content": "et al., 2020a) in certain data modalities, and have dominated benchmarks such as the Long Range", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 689, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 689, + 505, + 700 + ], + "score": 1.0, + "content": "Arena (Tay et al., 2021). Many flavors of SSMs (Gu et al., 2022a; Gupta, 2022; Gu et al., 2022b; Li et al.,", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "score": 1.0, + "content": "2023; Ma et al., 2023; Smith et al., 2023; Orvieto et al., 2023) have been successful in domains involving", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 710, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 506, + 722 + ], + "score": 1.0, + "content": "continuous signal data such as audio and vision (Goel et al., 2022; Saon et al., 2023; Nguyen et al., 2022).", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 106, + 720, + 501, + 731 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 501, + 731 + ], + "score": 1.0, + "content": "However, they have been less effective at modeling discrete and information-dense data such as text.", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 45, + "bbox_fs": [ + 105, + 613, + 506, + 731 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 503, + 105 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "We propose a new class of selective state space models, that improves on prior work on several axes", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 93, + 459, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 93, + 459, + 106 + ], + "score": 1.0, + "content": "to achieve the modeling power of Transformers while scaling linearly in sequence length.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 107, + 109, + 504, + 163 + ], + "lines": [ + { + "bbox": [ + 105, + 108, + 506, + 122 + ], + "spans": [ + { + "bbox": [ + 105, + 108, + 506, + 122 + ], + "score": 1.0, + "content": "Selection Mechanism. First, we identify a key limitation of prior models: the ability to efficiently", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 119, + 506, + 133 + ], + "spans": [ + { + "bbox": [ + 105, + 119, + 506, + 133 + ], + "score": 1.0, + "content": "select data in an input-dependent manner (i.e. focus on or ignore particular inputs). Building on", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 130, + 506, + 144 + ], + "spans": [ + { + "bbox": [ + 105, + 130, + 506, + 144 + ], + "score": 1.0, + "content": "intuition based on important synthetic tasks such as selective copy and induction heads, we design", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 140, + 506, + 154 + ], + "spans": [ + { + "bbox": [ + 105, + 140, + 506, + 154 + ], + "score": 1.0, + "content": "a simple selection mechanism by parameterizing the SSM parameters based on the input. This allows", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 151, + 472, + 164 + ], + "spans": [ + { + "bbox": [ + 105, + 151, + 472, + 164 + ], + "score": 1.0, + "content": "the model to filter out irrelevant information and remember relevant information indefinitely.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 107, + 168, + 505, + 244 + ], + "lines": [ + { + "bbox": [ + 105, + 167, + 506, + 181 + ], + "spans": [ + { + "bbox": [ + 105, + 167, + 506, + 181 + ], + "score": 1.0, + "content": "Hardware-aware Algorithm. This simple change poses a technical challenge for the computation of", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 178, + 506, + 191 + ], + "spans": [ + { + "bbox": [ + 105, + 178, + 506, + 191 + ], + "score": 1.0, + "content": "the model; in fact, all prior SSMs models must be time- and input-invariant in order to be computation-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 188, + 505, + 202 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 505, + 202 + ], + "score": 1.0, + "content": "ally efficient. We overcome this with a hardware-aware algorithm that computes the model recurrently", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 200, + 504, + 211 + ], + "spans": [ + { + "bbox": [ + 106, + 200, + 504, + 211 + ], + "score": 1.0, + "content": "with a scan instead of convolution, but does not materialize the expanded state in order to avoid IO", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 210, + 505, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 210, + 505, + 223 + ], + "score": 1.0, + "content": "access between different levels of the GPU memory hierarchy. The resulting implementation is faster", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 222, + 506, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 222, + 506, + 234 + ], + "score": 1.0, + "content": "than previous methods both in theory (scaling linearly in sequence length, compared to pseudo-linear", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 231, + 468, + 245 + ], + "spans": [ + { + "bbox": [ + 105, + 231, + 361, + 245 + ], + "score": 1.0, + "content": "for all convolution-based SSMs) and on modern hardware (up to", + "type": "text" + }, + { + "bbox": [ + 361, + 233, + 375, + 243 + ], + "score": 0.87, + "content": "3 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 375, + 231, + 468, + 245 + ], + "score": 1.0, + "content": "faster on A100 GPUs).", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 107, + 248, + 505, + 281 + ], + "lines": [ + { + "bbox": [ + 105, + 247, + 506, + 261 + ], + "spans": [ + { + "bbox": [ + 105, + 247, + 506, + 261 + ], + "score": 1.0, + "content": "Architecture. We simplify prior deep sequence model architectures by combining the design of prior", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 256, + 505, + 273 + ], + "spans": [ + { + "bbox": [ + 105, + 256, + 505, + 273 + ], + "score": 1.0, + "content": "SSM architectures (Dao et al., 2023) with the MLP block of Transformers into a single block, leading", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 269, + 482, + 283 + ], + "spans": [ + { + "bbox": [ + 105, + 269, + 482, + 283 + ], + "score": 1.0, + "content": "to a simple and homogenous architecture design (Mamba) incorporating selective state spaces.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 107, + 285, + 505, + 361 + ], + "lines": [ + { + "bbox": [ + 105, + 284, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 505, + 299 + ], + "score": 1.0, + "content": "Selective SSMs, and by extension the Mamba architecture, are fully recurrent models with key", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 295, + 505, + 309 + ], + "spans": [ + { + "bbox": [ + 105, + 295, + 505, + 309 + ], + "score": 1.0, + "content": "properties that make them suitable as the backbone of general foundation models operating on", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 307, + 505, + 319 + ], + "spans": [ + { + "bbox": [ + 105, + 307, + 505, + 319 + ], + "score": 1.0, + "content": "sequences. (i) High quality: selectivity brings strong performance on dense modalities such as", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 317, + 505, + 330 + ], + "spans": [ + { + "bbox": [ + 105, + 317, + 505, + 330 + ], + "score": 1.0, + "content": "language and genomics. (ii) Fast training and inference: computation and memory scales linearly", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 329, + 505, + 341 + ], + "spans": [ + { + "bbox": [ + 105, + 329, + 505, + 341 + ], + "score": 1.0, + "content": "in sequence length during training, and unrolling the model autoregressively during inference requires", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 338, + 505, + 352 + ], + "spans": [ + { + "bbox": [ + 105, + 338, + 505, + 352 + ], + "score": 1.0, + "content": "only constant time per step since it does not require a cache of previous elements. (iii) Long context: the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 349, + 507, + 363 + ], + "spans": [ + { + "bbox": [ + 105, + 349, + 507, + 363 + ], + "score": 1.0, + "content": "quality and efficiency together yield performance improvements on real data up to sequence length 1M.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 108, + 365, + 503, + 387 + ], + "lines": [ + { + "bbox": [ + 105, + 364, + 505, + 379 + ], + "spans": [ + { + "bbox": [ + 105, + 364, + 505, + 379 + ], + "score": 1.0, + "content": "We empirically validate Mamba’s potential as a general sequence FM backbone, in both pretraining", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 376, + 462, + 389 + ], + "spans": [ + { + "bbox": [ + 105, + 376, + 462, + 389 + ], + "score": 1.0, + "content": "quality and domain-specific task performance, on several types of modalities and settings:", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24.5 + }, + { + "type": "text", + "bbox": [ + 106, + 392, + 506, + 554 + ], + "lines": [ + { + "bbox": [ + 105, + 390, + 506, + 405 + ], + "spans": [ + { + "bbox": [ + 105, + 390, + 506, + 405 + ], + "score": 1.0, + "content": "• Synthetics. On important synthetic tasks such as copying and induction heads that have been", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 113, + 402, + 505, + 415 + ], + "spans": [ + { + "bbox": [ + 113, + 402, + 505, + 415 + ], + "score": 1.0, + "content": "proposed as being key to large language models, Mamba not only solves them easily but can", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 114, + 414, + 327, + 425 + ], + "spans": [ + { + "bbox": [ + 114, + 414, + 269, + 425 + ], + "score": 1.0, + "content": "extrapolate solutions indefinitely long", + "type": "text" + }, + { + "bbox": [ + 269, + 414, + 293, + 424 + ], + "score": 0.81, + "content": "{ \\bf \\Phi } > 1 { \\bf M }", + "type": "inline_equation" + }, + { + "bbox": [ + 293, + 414, + 327, + 425 + ], + "score": 1.0, + "content": "tokens).", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 429, + 506, + 442 + ], + "spans": [ + { + "bbox": [ + 106, + 429, + 506, + 442 + ], + "score": 1.0, + "content": "• Audio and Genomics. Mamba out-performs prior state-of-the-art models such as SaShiMi, Hyena,", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 113, + 440, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 113, + 440, + 505, + 453 + ], + "score": 1.0, + "content": "and Transformers on modeling audio waveforms and DNA sequences, both in pretraining quality", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 114, + 451, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 114, + 451, + 505, + 464 + ], + "score": 1.0, + "content": "and downstream metrics (e.g. reducing FID on a challenging speech generation dataset by more than", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 113, + 461, + 506, + 475 + ], + "spans": [ + { + "bbox": [ + 113, + 461, + 506, + 475 + ], + "score": 1.0, + "content": "half). In both settings, its performance improves with longer context up to million-length sequences.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 107, + 478, + 506, + 491 + ], + "spans": [ + { + "bbox": [ + 107, + 478, + 506, + 491 + ], + "score": 1.0, + "content": "• Language Modeling. Mamba is the first linear-time sequence model that truly achieves", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 114, + 489, + 506, + 502 + ], + "spans": [ + { + "bbox": [ + 114, + 489, + 506, + 502 + ], + "score": 1.0, + "content": "Transformer-quality performance, both in pretraining perplexity and downstream evaluations. With", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 113, + 498, + 506, + 514 + ], + "spans": [ + { + "bbox": [ + 113, + 498, + 506, + 514 + ], + "score": 1.0, + "content": "scaling laws up to 1B parameters, we show that Mamba exceeds the performance of a large range", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 114, + 511, + 506, + 523 + ], + "spans": [ + { + "bbox": [ + 114, + 511, + 506, + 523 + ], + "score": 1.0, + "content": "of baselines, including very strong modern Transformer training recipes based on LLaMa (Touvron", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 113, + 521, + 506, + 534 + ], + "spans": [ + { + "bbox": [ + 113, + 521, + 343, + 534 + ], + "score": 1.0, + "content": "et al., 2023). Our 1.4B Mamba language model has", + "type": "text" + }, + { + "bbox": [ + 343, + 522, + 358, + 532 + ], + "score": 0.87, + "content": "5 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 358, + 521, + 506, + 534 + ], + "score": 1.0, + "content": "inference throughput compared to", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 113, + 531, + 506, + 546 + ], + "spans": [ + { + "bbox": [ + 113, + 531, + 506, + 546 + ], + "score": 1.0, + "content": "Transformers of similar size, and its quality matches that of Transformers twice its size (e.g. 5 points", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 113, + 542, + 487, + 556 + ], + "spans": [ + { + "bbox": [ + 113, + 542, + 487, + 556 + ], + "score": 1.0, + "content": "higher avg. on common sense reasoning compared to Pythia-1.4B and matching Pythia-2.8B).", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 32.5 + }, + { + "type": "title", + "bbox": [ + 107, + 569, + 241, + 582 + ], + "lines": [ + { + "bbox": [ + 105, + 568, + 242, + 585 + ], + "spans": [ + { + "bbox": [ + 105, + 568, + 242, + 585 + ], + "score": 1.0, + "content": "2 STATE SPACE MODELS", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 40 + }, + { + "type": "text", + "bbox": [ + 107, + 587, + 504, + 643 + ], + "lines": [ + { + "bbox": [ + 105, + 587, + 506, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 506, + 601 + ], + "score": 1.0, + "content": "Structured state space sequence models (S4) are a recent class of sequence models for deep learning", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 597, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 597, + 505, + 612 + ], + "score": 1.0, + "content": "that are broadly related to RNNs, and CNNs, and classical state space models. They are inspired by", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 609, + 504, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 609, + 425, + 622 + ], + "score": 1.0, + "content": "a particular continuous system (1) that maps a 1-dimensional function or sequence", + "type": "text" + }, + { + "bbox": [ + 425, + 609, + 504, + 621 + ], + "score": 0.91, + "content": "x ( t ) \\in \\mathbb { R } \\mapsto y ( t ) \\in \\mathbb { R }", + "type": "inline_equation" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 619, + 506, + 635 + ], + "spans": [ + { + "bbox": [ + 105, + 619, + 231, + 635 + ], + "score": 1.0, + "content": "through an implicit latent state", + "type": "text" + }, + { + "bbox": [ + 231, + 621, + 272, + 633 + ], + "score": 0.92, + "content": "h ( t ) \\in \\mathbb { R } ^ { N }", + "type": "inline_equation" + }, + { + "bbox": [ + 273, + 619, + 506, + 635 + ], + "score": 1.0, + "content": ". Concretely, S4 models are defined with four parameters", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 631, + 426, + 645 + ], + "spans": [ + { + "bbox": [ + 106, + 632, + 157, + 644 + ], + "score": 0.85, + "content": "( \\Delta , A , B , C )", + "type": "inline_equation" + }, + { + "bbox": [ + 157, + 631, + 426, + 645 + ], + "score": 1.0, + "content": ", which define a sequence-to-sequence transformation in two stages.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 43 + }, + { + "type": "interline_equation", + "bbox": [ + 113, + 649, + 487, + 682 + ], + "lines": [ + { + "bbox": [ + 113, + 649, + 487, + 682 + ], + "spans": [ + { + "bbox": [ + 113, + 649, + 487, + 682 + ], + "score": 0.92, + "content": "\\begin{array} { r l r l r l } & { h ^ { \\prime } ( t ) = A h ( t ) + B x ( t ) } & { } & { ( 1 ) } & { \\quad h _ { k } = \\overline { A } h _ { k - 1 } + \\overline { B } x _ { k } } & { \\quad ( 2 \\mathbf { a } ) } & { \\overline { K } = ( C \\overline { B } , C \\overline { A } B , . . . , C \\overline { A } ^ { k } \\overline { B } , . . . ) } \\\\ & { y ( t ) = C h ( t ) } & { } & { y _ { k } = C h _ { k } } & { \\quad ( 2 \\mathbf { b } ) } & { y = x * \\overline { K } } \\end{array}", + "type": "interline_equation", + "image_path": "8e5eafa5d2465f7371dad1c7d8f03f69711bf43a103db356ab0d729b6c1171af.jpg" + } + ] + } + ], + "index": 47, + "virtual_lines": [ + { + "bbox": [ + 113, + 649, + 487, + 660.0 + ], + "spans": [], + "index": 46 + }, + { + "bbox": [ + 113, + 660.0, + 487, + 671.0 + ], + "spans": [], + "index": 47 + }, + { + "bbox": [ + 113, + 671.0, + 487, + 682.0 + ], + "spans": [], + "index": 48 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 685, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 684, + 506, + 698 + ], + "spans": [ + { + "bbox": [ + 105, + 684, + 406, + 698 + ], + "score": 1.0, + "content": "Discretization The first stage transforms the “continuous parameters”", + "type": "text" + }, + { + "bbox": [ + 407, + 685, + 451, + 697 + ], + "score": 0.9, + "content": "( \\Delta , A , B )", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 684, + 506, + 698 + ], + "score": 1.0, + "content": "to “discrete", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 696, + 506, + 710 + ], + "spans": [ + { + "bbox": [ + 105, + 696, + 158, + 710 + ], + "score": 1.0, + "content": "parameters”", + "type": "text" + }, + { + "bbox": [ + 159, + 696, + 188, + 709 + ], + "score": 0.91, + "content": "( \\overline { { A } } , \\overline { { B } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 696, + 286, + 710 + ], + "score": 1.0, + "content": "through fixed formulas", + "type": "text" + }, + { + "bbox": [ + 286, + 696, + 347, + 709 + ], + "score": 0.93, + "content": "\\overline { { { \\cal A } } } = f _ { A } ( \\Delta , A )", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 696, + 366, + 710 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 366, + 696, + 440, + 709 + ], + "score": 0.92, + "content": "\\overline { { B } } = f _ { B } ( \\Delta , A , B )", + "type": "inline_equation" + }, + { + "bbox": [ + 441, + 696, + 506, + 710 + ], + "score": 1.0, + "content": ", where the pair", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 106, + 708, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 708, + 141, + 720 + ], + "score": 0.9, + "content": "\\bar { ( } f _ { A } , f _ { B } )", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 708, + 505, + 721 + ], + "score": 1.0, + "content": "is called a discretization rule. The most common is zero-order hold (ZOH) defined by", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 107, + 720, + 327, + 733 + ], + "spans": [ + { + "bbox": [ + 107, + 720, + 166, + 732 + ], + "score": 0.9, + "content": "\\overline { { { \\cal A } } } = \\exp ( \\Delta { \\cal A } )", + "type": "inline_equation" + }, + { + "bbox": [ + 166, + 720, + 184, + 733 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 184, + 720, + 323, + 733 + ], + "score": 0.9, + "content": "\\overline { { B } } = ( \\Delta A ) ^ { - 1 } ( \\exp ( \\Delta A ) - I ) \\cdot \\Delta B", + "type": "inline_equation" + }, + { + "bbox": [ + 323, + 720, + 327, + 733 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 52 + } + ], + "index": 50.5 + } + ], + "page_idx": 1, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 304, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 304, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 304, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "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": [ + 106, + 82, + 503, + 105 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "We propose a new class of selective state space models, that improves on prior work on several axes", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 93, + 459, + 106 + ], + "spans": [ + { + "bbox": [ + 106, + 93, + 459, + 106 + ], + "score": 1.0, + "content": "to achieve the modeling power of Transformers while scaling linearly in sequence length.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5, + "bbox_fs": [ + 106, + 82, + 505, + 106 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 109, + 504, + 163 + ], + "lines": [ + { + "bbox": [ + 105, + 108, + 506, + 122 + ], + "spans": [ + { + "bbox": [ + 105, + 108, + 506, + 122 + ], + "score": 1.0, + "content": "Selection Mechanism. First, we identify a key limitation of prior models: the ability to efficiently", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 119, + 506, + 133 + ], + "spans": [ + { + "bbox": [ + 105, + 119, + 506, + 133 + ], + "score": 1.0, + "content": "select data in an input-dependent manner (i.e. focus on or ignore particular inputs). Building on", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 130, + 506, + 144 + ], + "spans": [ + { + "bbox": [ + 105, + 130, + 506, + 144 + ], + "score": 1.0, + "content": "intuition based on important synthetic tasks such as selective copy and induction heads, we design", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 140, + 506, + 154 + ], + "spans": [ + { + "bbox": [ + 105, + 140, + 506, + 154 + ], + "score": 1.0, + "content": "a simple selection mechanism by parameterizing the SSM parameters based on the input. This allows", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 151, + 472, + 164 + ], + "spans": [ + { + "bbox": [ + 105, + 151, + 472, + 164 + ], + "score": 1.0, + "content": "the model to filter out irrelevant information and remember relevant information indefinitely.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4, + "bbox_fs": [ + 105, + 108, + 506, + 164 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 168, + 505, + 244 + ], + "lines": [ + { + "bbox": [ + 105, + 167, + 506, + 181 + ], + "spans": [ + { + "bbox": [ + 105, + 167, + 506, + 181 + ], + "score": 1.0, + "content": "Hardware-aware Algorithm. This simple change poses a technical challenge for the computation of", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 178, + 506, + 191 + ], + "spans": [ + { + "bbox": [ + 105, + 178, + 506, + 191 + ], + "score": 1.0, + "content": "the model; in fact, all prior SSMs models must be time- and input-invariant in order to be computation-", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 188, + 505, + 202 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 505, + 202 + ], + "score": 1.0, + "content": "ally efficient. We overcome this with a hardware-aware algorithm that computes the model recurrently", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 200, + 504, + 211 + ], + "spans": [ + { + "bbox": [ + 106, + 200, + 504, + 211 + ], + "score": 1.0, + "content": "with a scan instead of convolution, but does not materialize the expanded state in order to avoid IO", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 210, + 505, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 210, + 505, + 223 + ], + "score": 1.0, + "content": "access between different levels of the GPU memory hierarchy. The resulting implementation is faster", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 222, + 506, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 222, + 506, + 234 + ], + "score": 1.0, + "content": "than previous methods both in theory (scaling linearly in sequence length, compared to pseudo-linear", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 231, + 468, + 245 + ], + "spans": [ + { + "bbox": [ + 105, + 231, + 361, + 245 + ], + "score": 1.0, + "content": "for all convolution-based SSMs) and on modern hardware (up to", + "type": "text" + }, + { + "bbox": [ + 361, + 233, + 375, + 243 + ], + "score": 0.87, + "content": "3 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 375, + 231, + 468, + 245 + ], + "score": 1.0, + "content": "faster on A100 GPUs).", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 10, + "bbox_fs": [ + 105, + 167, + 506, + 245 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 248, + 505, + 281 + ], + "lines": [ + { + "bbox": [ + 105, + 247, + 506, + 261 + ], + "spans": [ + { + "bbox": [ + 105, + 247, + 506, + 261 + ], + "score": 1.0, + "content": "Architecture. We simplify prior deep sequence model architectures by combining the design of prior", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 256, + 505, + 273 + ], + "spans": [ + { + "bbox": [ + 105, + 256, + 505, + 273 + ], + "score": 1.0, + "content": "SSM architectures (Dao et al., 2023) with the MLP block of Transformers into a single block, leading", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 269, + 482, + 283 + ], + "spans": [ + { + "bbox": [ + 105, + 269, + 482, + 283 + ], + "score": 1.0, + "content": "to a simple and homogenous architecture design (Mamba) incorporating selective state spaces.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15, + "bbox_fs": [ + 105, + 247, + 506, + 283 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 285, + 505, + 361 + ], + "lines": [ + { + "bbox": [ + 105, + 284, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 505, + 299 + ], + "score": 1.0, + "content": "Selective SSMs, and by extension the Mamba architecture, are fully recurrent models with key", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 295, + 505, + 309 + ], + "spans": [ + { + "bbox": [ + 105, + 295, + 505, + 309 + ], + "score": 1.0, + "content": "properties that make them suitable as the backbone of general foundation models operating on", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 307, + 505, + 319 + ], + "spans": [ + { + "bbox": [ + 105, + 307, + 505, + 319 + ], + "score": 1.0, + "content": "sequences. (i) High quality: selectivity brings strong performance on dense modalities such as", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 317, + 505, + 330 + ], + "spans": [ + { + "bbox": [ + 105, + 317, + 505, + 330 + ], + "score": 1.0, + "content": "language and genomics. (ii) Fast training and inference: computation and memory scales linearly", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 329, + 505, + 341 + ], + "spans": [ + { + "bbox": [ + 105, + 329, + 505, + 341 + ], + "score": 1.0, + "content": "in sequence length during training, and unrolling the model autoregressively during inference requires", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 338, + 505, + 352 + ], + "spans": [ + { + "bbox": [ + 105, + 338, + 505, + 352 + ], + "score": 1.0, + "content": "only constant time per step since it does not require a cache of previous elements. (iii) Long context: the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 349, + 507, + 363 + ], + "spans": [ + { + "bbox": [ + 105, + 349, + 507, + 363 + ], + "score": 1.0, + "content": "quality and efficiency together yield performance improvements on real data up to sequence length 1M.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 20, + "bbox_fs": [ + 105, + 284, + 507, + 363 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 365, + 503, + 387 + ], + "lines": [ + { + "bbox": [ + 105, + 364, + 505, + 379 + ], + "spans": [ + { + "bbox": [ + 105, + 364, + 505, + 379 + ], + "score": 1.0, + "content": "We empirically validate Mamba’s potential as a general sequence FM backbone, in both pretraining", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 376, + 462, + 389 + ], + "spans": [ + { + "bbox": [ + 105, + 376, + 462, + 389 + ], + "score": 1.0, + "content": "quality and domain-specific task performance, on several types of modalities and settings:", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24.5, + "bbox_fs": [ + 105, + 364, + 505, + 389 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 392, + 506, + 554 + ], + "lines": [ + { + "bbox": [ + 105, + 390, + 506, + 405 + ], + "spans": [ + { + "bbox": [ + 105, + 390, + 506, + 405 + ], + "score": 1.0, + "content": "• Synthetics. On important synthetic tasks such as copying and induction heads that have been", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 113, + 402, + 505, + 415 + ], + "spans": [ + { + "bbox": [ + 113, + 402, + 505, + 415 + ], + "score": 1.0, + "content": "proposed as being key to large language models, Mamba not only solves them easily but can", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 114, + 414, + 327, + 425 + ], + "spans": [ + { + "bbox": [ + 114, + 414, + 269, + 425 + ], + "score": 1.0, + "content": "extrapolate solutions indefinitely long", + "type": "text" + }, + { + "bbox": [ + 269, + 414, + 293, + 424 + ], + "score": 0.81, + "content": "{ \\bf \\Phi } > 1 { \\bf M }", + "type": "inline_equation" + }, + { + "bbox": [ + 293, + 414, + 327, + 425 + ], + "score": 1.0, + "content": "tokens).", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 429, + 506, + 442 + ], + "spans": [ + { + "bbox": [ + 106, + 429, + 506, + 442 + ], + "score": 1.0, + "content": "• Audio and Genomics. Mamba out-performs prior state-of-the-art models such as SaShiMi, Hyena,", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 113, + 440, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 113, + 440, + 505, + 453 + ], + "score": 1.0, + "content": "and Transformers on modeling audio waveforms and DNA sequences, both in pretraining quality", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 114, + 451, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 114, + 451, + 505, + 464 + ], + "score": 1.0, + "content": "and downstream metrics (e.g. reducing FID on a challenging speech generation dataset by more than", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 113, + 461, + 506, + 475 + ], + "spans": [ + { + "bbox": [ + 113, + 461, + 506, + 475 + ], + "score": 1.0, + "content": "half). In both settings, its performance improves with longer context up to million-length sequences.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 107, + 478, + 506, + 491 + ], + "spans": [ + { + "bbox": [ + 107, + 478, + 506, + 491 + ], + "score": 1.0, + "content": "• Language Modeling. Mamba is the first linear-time sequence model that truly achieves", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 114, + 489, + 506, + 502 + ], + "spans": [ + { + "bbox": [ + 114, + 489, + 506, + 502 + ], + "score": 1.0, + "content": "Transformer-quality performance, both in pretraining perplexity and downstream evaluations. With", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 113, + 498, + 506, + 514 + ], + "spans": [ + { + "bbox": [ + 113, + 498, + 506, + 514 + ], + "score": 1.0, + "content": "scaling laws up to 1B parameters, we show that Mamba exceeds the performance of a large range", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 114, + 511, + 506, + 523 + ], + "spans": [ + { + "bbox": [ + 114, + 511, + 506, + 523 + ], + "score": 1.0, + "content": "of baselines, including very strong modern Transformer training recipes based on LLaMa (Touvron", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 113, + 521, + 506, + 534 + ], + "spans": [ + { + "bbox": [ + 113, + 521, + 343, + 534 + ], + "score": 1.0, + "content": "et al., 2023). Our 1.4B Mamba language model has", + "type": "text" + }, + { + "bbox": [ + 343, + 522, + 358, + 532 + ], + "score": 0.87, + "content": "5 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 358, + 521, + 506, + 534 + ], + "score": 1.0, + "content": "inference throughput compared to", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 113, + 531, + 506, + 546 + ], + "spans": [ + { + "bbox": [ + 113, + 531, + 506, + 546 + ], + "score": 1.0, + "content": "Transformers of similar size, and its quality matches that of Transformers twice its size (e.g. 5 points", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 113, + 542, + 487, + 556 + ], + "spans": [ + { + "bbox": [ + 113, + 542, + 487, + 556 + ], + "score": 1.0, + "content": "higher avg. on common sense reasoning compared to Pythia-1.4B and matching Pythia-2.8B).", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 32.5, + "bbox_fs": [ + 105, + 390, + 506, + 556 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 569, + 241, + 582 + ], + "lines": [ + { + "bbox": [ + 105, + 568, + 242, + 585 + ], + "spans": [ + { + "bbox": [ + 105, + 568, + 242, + 585 + ], + "score": 1.0, + "content": "2 STATE SPACE MODELS", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 40 + }, + { + "type": "text", + "bbox": [ + 107, + 587, + 504, + 643 + ], + "lines": [ + { + "bbox": [ + 105, + 587, + 506, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 506, + 601 + ], + "score": 1.0, + "content": "Structured state space sequence models (S4) are a recent class of sequence models for deep learning", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 597, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 597, + 505, + 612 + ], + "score": 1.0, + "content": "that are broadly related to RNNs, and CNNs, and classical state space models. They are inspired by", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 609, + 504, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 609, + 425, + 622 + ], + "score": 1.0, + "content": "a particular continuous system (1) that maps a 1-dimensional function or sequence", + "type": "text" + }, + { + "bbox": [ + 425, + 609, + 504, + 621 + ], + "score": 0.91, + "content": "x ( t ) \\in \\mathbb { R } \\mapsto y ( t ) \\in \\mathbb { R }", + "type": "inline_equation" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 619, + 506, + 635 + ], + "spans": [ + { + "bbox": [ + 105, + 619, + 231, + 635 + ], + "score": 1.0, + "content": "through an implicit latent state", + "type": "text" + }, + { + "bbox": [ + 231, + 621, + 272, + 633 + ], + "score": 0.92, + "content": "h ( t ) \\in \\mathbb { R } ^ { N }", + "type": "inline_equation" + }, + { + "bbox": [ + 273, + 619, + 506, + 635 + ], + "score": 1.0, + "content": ". Concretely, S4 models are defined with four parameters", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 631, + 426, + 645 + ], + "spans": [ + { + "bbox": [ + 106, + 632, + 157, + 644 + ], + "score": 0.85, + "content": "( \\Delta , A , B , C )", + "type": "inline_equation" + }, + { + "bbox": [ + 157, + 631, + 426, + 645 + ], + "score": 1.0, + "content": ", which define a sequence-to-sequence transformation in two stages.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 43, + "bbox_fs": [ + 105, + 587, + 506, + 645 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 113, + 649, + 487, + 682 + ], + "lines": [ + { + "bbox": [ + 113, + 649, + 487, + 682 + ], + "spans": [ + { + "bbox": [ + 113, + 649, + 487, + 682 + ], + "score": 0.92, + "content": "\\begin{array} { r l r l r l } & { h ^ { \\prime } ( t ) = A h ( t ) + B x ( t ) } & { } & { ( 1 ) } & { \\quad h _ { k } = \\overline { A } h _ { k - 1 } + \\overline { B } x _ { k } } & { \\quad ( 2 \\mathbf { a } ) } & { \\overline { K } = ( C \\overline { B } , C \\overline { A } B , . . . , C \\overline { A } ^ { k } \\overline { B } , . . . ) } \\\\ & { y ( t ) = C h ( t ) } & { } & { y _ { k } = C h _ { k } } & { \\quad ( 2 \\mathbf { b } ) } & { y = x * \\overline { K } } \\end{array}", + "type": "interline_equation", + "image_path": "8e5eafa5d2465f7371dad1c7d8f03f69711bf43a103db356ab0d729b6c1171af.jpg" + } + ] + } + ], + "index": 47, + "virtual_lines": [ + { + "bbox": [ + 113, + 649, + 487, + 660.0 + ], + "spans": [], + "index": 46 + }, + { + "bbox": [ + 113, + 660.0, + 487, + 671.0 + ], + "spans": [], + "index": 47 + }, + { + "bbox": [ + 113, + 671.0, + 487, + 682.0 + ], + "spans": [], + "index": 48 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 685, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 684, + 506, + 698 + ], + "spans": [ + { + "bbox": [ + 105, + 684, + 406, + 698 + ], + "score": 1.0, + "content": "Discretization The first stage transforms the “continuous parameters”", + "type": "text" + }, + { + "bbox": [ + 407, + 685, + 451, + 697 + ], + "score": 0.9, + "content": "( \\Delta , A , B )", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 684, + 506, + 698 + ], + "score": 1.0, + "content": "to “discrete", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 696, + 506, + 710 + ], + "spans": [ + { + "bbox": [ + 105, + 696, + 158, + 710 + ], + "score": 1.0, + "content": "parameters”", + "type": "text" + }, + { + "bbox": [ + 159, + 696, + 188, + 709 + ], + "score": 0.91, + "content": "( \\overline { { A } } , \\overline { { B } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 189, + 696, + 286, + 710 + ], + "score": 1.0, + "content": "through fixed formulas", + "type": "text" + }, + { + "bbox": [ + 286, + 696, + 347, + 709 + ], + "score": 0.93, + "content": "\\overline { { { \\cal A } } } = f _ { A } ( \\Delta , A )", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 696, + 366, + 710 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 366, + 696, + 440, + 709 + ], + "score": 0.92, + "content": "\\overline { { B } } = f _ { B } ( \\Delta , A , B )", + "type": "inline_equation" + }, + { + "bbox": [ + 441, + 696, + 506, + 710 + ], + "score": 1.0, + "content": ", where the pair", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 106, + 708, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 708, + 141, + 720 + ], + "score": 0.9, + "content": "\\bar { ( } f _ { A } , f _ { B } )", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 708, + 505, + 721 + ], + "score": 1.0, + "content": "is called a discretization rule. The most common is zero-order hold (ZOH) defined by", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 107, + 720, + 327, + 733 + ], + "spans": [ + { + "bbox": [ + 107, + 720, + 166, + 732 + ], + "score": 0.9, + "content": "\\overline { { { \\cal A } } } = \\exp ( \\Delta { \\cal A } )", + "type": "inline_equation" + }, + { + "bbox": [ + 166, + 720, + 184, + 733 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 184, + 720, + 323, + 733 + ], + "score": 0.9, + "content": "\\overline { { B } } = ( \\Delta A ) ^ { - 1 } ( \\exp ( \\Delta A ) - I ) \\cdot \\Delta B", + "type": "inline_equation" + }, + { + "bbox": [ + 323, + 720, + 327, + 733 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 52 + } + ], + "index": 50.5, + "bbox_fs": [ + 105, + 684, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 147 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "Discretization has deep connections to continuous-time systems which can endow them with additional", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 105 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 105 + ], + "score": 1.0, + "content": "properties such as resolution invariance (Nguyen et al., 2022) and automatically ensuring that the", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 103, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 103, + 505, + 117 + ], + "score": 1.0, + "content": "model is properly normalized (Gu et al., 2023; Orvieto et al., 2023). It also has connections to gating", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 115, + 506, + 126 + ], + "spans": [ + { + "bbox": [ + 106, + 115, + 506, + 126 + ], + "score": 1.0, + "content": "mechanisms of RNNs (Tallec & Ollivier, 2018; Gu et al., 2020b) which we will revisit in Section 3.5.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 125, + 506, + 137 + ], + "spans": [ + { + "bbox": [ + 105, + 125, + 506, + 137 + ], + "score": 1.0, + "content": "However, from a mechanical point of view discretization can simply be viewed as the first step of", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 136, + 320, + 148 + ], + "spans": [ + { + "bbox": [ + 106, + 136, + 320, + 148 + ], + "score": 1.0, + "content": "the computation graph in the forward pass of an SSM.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 106, + 153, + 504, + 175 + ], + "lines": [ + { + "bbox": [ + 106, + 152, + 505, + 165 + ], + "spans": [ + { + "bbox": [ + 106, + 152, + 357, + 165 + ], + "score": 1.0, + "content": "Computation After the parameters have been transformed from", + "type": "text" + }, + { + "bbox": [ + 357, + 152, + 461, + 165 + ], + "score": 0.93, + "content": "( \\Delta , A , B , C ) \\mapsto ( { \\overline { { A } } } , { \\overline { { B } } } , C )", + "type": "inline_equation" + }, + { + "bbox": [ + 461, + 152, + 505, + 165 + ], + "score": 1.0, + "content": ", the model", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 163, + 469, + 176 + ], + "spans": [ + { + "bbox": [ + 106, + 163, + 469, + 176 + ], + "score": 1.0, + "content": "can be computed in two ways, either as a linear recurrence (2) or a global convolution (3).", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6.5 + }, + { + "type": "text", + "bbox": [ + 108, + 180, + 503, + 212 + ], + "lines": [ + { + "bbox": [ + 106, + 179, + 505, + 192 + ], + "spans": [ + { + "bbox": [ + 106, + 179, + 505, + 192 + ], + "score": 1.0, + "content": "Commonly, the model uses the convolutional mode (3) for efficient parallelizable training (where", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 191, + 505, + 203 + ], + "spans": [ + { + "bbox": [ + 106, + 191, + 505, + 203 + ], + "score": 1.0, + "content": "the whole input sequence is seen ahead of time), and switched into recurrent mode (2) for efficient", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 202, + 402, + 214 + ], + "spans": [ + { + "bbox": [ + 106, + 202, + 402, + 214 + ], + "score": 1.0, + "content": "autoregressive inference (where the inputs are seen one timestep at a time).", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 107, + 216, + 505, + 272 + ], + "lines": [ + { + "bbox": [ + 105, + 216, + 506, + 230 + ], + "spans": [ + { + "bbox": [ + 105, + 216, + 506, + 230 + ], + "score": 1.0, + "content": "Linear Time Invariance (LTI) An important property of equations (1) to (3) is that the model’s", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 227, + 506, + 241 + ], + "spans": [ + { + "bbox": [ + 106, + 227, + 315, + 241 + ], + "score": 1.0, + "content": "dynamics are constant through time. In other words", + "type": "text" + }, + { + "bbox": [ + 315, + 228, + 367, + 240 + ], + "score": 0.91, + "content": "( \\Delta , A , B , C )", + "type": "inline_equation" + }, + { + "bbox": [ + 367, + 227, + 443, + 241 + ], + "score": 1.0, + "content": ", and consequently", + "type": "text" + }, + { + "bbox": [ + 443, + 227, + 472, + 240 + ], + "score": 0.9, + "content": "( \\overline { { A } } , \\overline { { B } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 473, + 227, + 506, + 241 + ], + "score": 1.0, + "content": "as well,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 237, + 506, + 253 + ], + "spans": [ + { + "bbox": [ + 105, + 237, + 412, + 253 + ], + "score": 1.0, + "content": "are fixed for all time-steps. This property is called linear time invariance", + "type": "text" + }, + { + "bbox": [ + 412, + 240, + 434, + 250 + ], + "score": 0.4, + "content": "( L T I )", + "type": "inline_equation" + }, + { + "bbox": [ + 434, + 237, + 506, + 253 + ], + "score": 1.0, + "content": ", which is deeply", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 248, + 506, + 264 + ], + "spans": [ + { + "bbox": [ + 105, + 248, + 506, + 264 + ], + "score": 1.0, + "content": "connected to recurrence and convolutions. Informally, we think of LTI SSMs as being equivalent to any", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 261, + 506, + 273 + ], + "spans": [ + { + "bbox": [ + 106, + 261, + 506, + 273 + ], + "score": 1.0, + "content": "linear recurrence (2a) or convolution (3b), and use LTI as an umbrella term for these classes of models.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 107, + 277, + 505, + 320 + ], + "lines": [ + { + "bbox": [ + 105, + 276, + 506, + 290 + ], + "spans": [ + { + "bbox": [ + 105, + 276, + 506, + 290 + ], + "score": 1.0, + "content": "Thus far, all structured SSMs have been LTI (e.g. computed as convolutions) because of fundamental", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 287, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 106, + 287, + 505, + 299 + ], + "score": 1.0, + "content": "efficiency constraints, discussed in Section 3.3. However, a core insight of this work is that LTI models", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 298, + 504, + 310 + ], + "spans": [ + { + "bbox": [ + 106, + 298, + 504, + 310 + ], + "score": 1.0, + "content": "have fundamental limitations in modeling certain types of data, and our technical contributions involve", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 309, + 397, + 321 + ], + "spans": [ + { + "bbox": [ + 105, + 309, + 397, + 321 + ], + "score": 1.0, + "content": "removing the LTI constraint while overcoming the efficiency bottlenecks.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 17.5 + }, + { + "type": "text", + "bbox": [ + 107, + 325, + 505, + 357 + ], + "lines": [ + { + "bbox": [ + 106, + 324, + 505, + 337 + ], + "spans": [ + { + "bbox": [ + 106, + 324, + 505, + 337 + ], + "score": 1.0, + "content": "Structure Finally, we note that structured SSMs are so named because computing them efficiently also", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 335, + 507, + 349 + ], + "spans": [ + { + "bbox": [ + 105, + 335, + 244, + 349 + ], + "score": 1.0, + "content": "requires imposing structure on the", + "type": "text" + }, + { + "bbox": [ + 245, + 336, + 254, + 345 + ], + "score": 0.52, + "content": "\\pmb { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 335, + 507, + 349 + ], + "score": 1.0, + "content": "matrix. The most popular form of structure is diagonal (Gupta,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 345, + 352, + 358 + ], + "spans": [ + { + "bbox": [ + 106, + 345, + 352, + 358 + ], + "score": 1.0, + "content": "2022; Gu et al., 2022b; Smith et al., 2023), which we also use.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 360, + 505, + 416 + ], + "lines": [ + { + "bbox": [ + 105, + 359, + 507, + 375 + ], + "spans": [ + { + "bbox": [ + 105, + 359, + 172, + 375 + ], + "score": 1.0, + "content": "In this case, the", + "type": "text" + }, + { + "bbox": [ + 172, + 360, + 314, + 373 + ], + "score": 0.32, + "content": "\\pmb { A } \\in \\mathbb { R } ^ { N \\times N } , \\pmb { B } \\in \\mathbb { R } ^ { N \\times 1 } , \\pmb { C } \\in \\mathbb { R } ^ { 1 \\times N }", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 359, + 455, + 375 + ], + "score": 1.0, + "content": "matrices can all be represented by", + "type": "text" + }, + { + "bbox": [ + 456, + 362, + 466, + 372 + ], + "score": 0.8, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 466, + 359, + 507, + 375 + ], + "score": 1.0, + "content": "numbers.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 372, + 505, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 372, + 240, + 385 + ], + "score": 1.0, + "content": "To operate over an input sequence", + "type": "text" + }, + { + "bbox": [ + 240, + 375, + 247, + 383 + ], + "score": 0.79, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 372, + 298, + 385 + ], + "score": 1.0, + "content": "of batch size", + "type": "text" + }, + { + "bbox": [ + 299, + 373, + 308, + 383 + ], + "score": 0.79, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 308, + 372, + 351, + 385 + ], + "score": 1.0, + "content": "and length", + "type": "text" + }, + { + "bbox": [ + 352, + 373, + 360, + 383 + ], + "score": 0.8, + "content": "L", + "type": "inline_equation" + }, + { + "bbox": [ + 360, + 372, + 380, + 385 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 380, + 373, + 389, + 383 + ], + "score": 0.79, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 390, + 372, + 505, + 385 + ], + "score": 1.0, + "content": "channels, the SSM is applied", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 383, + 506, + 397 + ], + "spans": [ + { + "bbox": [ + 105, + 383, + 470, + 397 + ], + "score": 1.0, + "content": "independently to each channel. Note that in this case, the total hidden state has dimension", + "type": "text" + }, + { + "bbox": [ + 470, + 384, + 489, + 393 + ], + "score": 0.77, + "content": "D N", + "type": "inline_equation" + }, + { + "bbox": [ + 489, + 383, + 506, + 397 + ], + "score": 1.0, + "content": "per", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 394, + 505, + 407 + ], + "spans": [ + { + "bbox": [ + 105, + 394, + 338, + 407 + ], + "score": 1.0, + "content": "input, and computing it over the sequence length requires", + "type": "text" + }, + { + "bbox": [ + 339, + 394, + 387, + 406 + ], + "score": 0.91, + "content": "O ( B L D N )", + "type": "inline_equation" + }, + { + "bbox": [ + 388, + 394, + 505, + 407 + ], + "score": 1.0, + "content": "time and memory; this is the", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 405, + 385, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 405, + 385, + 416 + ], + "score": 1.0, + "content": "root of the fundamental efficiency bottleneck addressed in Section 3.3.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 107, + 420, + 505, + 464 + ], + "lines": [ + { + "bbox": [ + 106, + 420, + 505, + 433 + ], + "spans": [ + { + "bbox": [ + 106, + 420, + 505, + 433 + ], + "score": 1.0, + "content": "SSM Architectures SSMs are standalone sequence transformations that can be incorporated into", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 430, + 507, + 444 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 507, + 444 + ], + "score": 1.0, + "content": "end-to-end neural network architectures. We discuss some of the most well-known SSM architectures,", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 443, + 505, + 455 + ], + "spans": [ + { + "bbox": [ + 106, + 443, + 505, + 455 + ], + "score": 1.0, + "content": "many of which will also serve as our primary baselines. Other closely related SSMs and architectures", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 453, + 358, + 465 + ], + "spans": [ + { + "bbox": [ + 106, + 453, + 358, + 465 + ], + "score": 1.0, + "content": "are discussed further in an extended related work (Appendix B).", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29.5 + }, + { + "type": "text", + "bbox": [ + 106, + 468, + 506, + 567 + ], + "lines": [ + { + "bbox": [ + 105, + 466, + 506, + 480 + ], + "spans": [ + { + "bbox": [ + 105, + 466, + 506, + 480 + ], + "score": 1.0, + "content": "• Linear attention (Katharopoulos et al., 2020) is an approximation of self-attention (Bahdanau et al.,", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 113, + 478, + 425, + 491 + ], + "spans": [ + { + "bbox": [ + 113, + 478, + 425, + 491 + ], + "score": 1.0, + "content": "2014) involving a recurrence which can be viewed as a degenerate linear SSM.", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 488, + 505, + 503 + ], + "spans": [ + { + "bbox": [ + 106, + 488, + 505, + 503 + ], + "score": 1.0, + "content": "• H3 (Dao et al., 2023) generalized this recurrence to use S4; it can be viewed as an architecture", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 113, + 500, + 505, + 513 + ], + "spans": [ + { + "bbox": [ + 113, + 500, + 505, + 513 + ], + "score": 1.0, + "content": "with an SSM sandwiched by two gated connections (Figure 2). H3 also inserts a standard local", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 113, + 511, + 409, + 523 + ], + "spans": [ + { + "bbox": [ + 113, + 511, + 409, + 523 + ], + "score": 1.0, + "content": "convolution, which they frame as a shift-SSM, before the main SSM layer.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 521, + 506, + 534 + ], + "spans": [ + { + "bbox": [ + 106, + 521, + 506, + 534 + ], + "score": 1.0, + "content": "• Hyena (Poli et al., 2023) uses the same architecture but replaces the S4 layer with an MLP-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 113, + 533, + 338, + 545 + ], + "spans": [ + { + "bbox": [ + 113, + 533, + 338, + 545 + ], + "score": 1.0, + "content": "parameterized global convolution (Romero et al., 2021).", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 542, + 505, + 556 + ], + "spans": [ + { + "bbox": [ + 106, + 542, + 505, + 556 + ], + "score": 1.0, + "content": "• RetNet (Sun et al., 2023) adds an additional gate to the architecture and simplifies the SSM, allowing", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 114, + 555, + 503, + 566 + ], + "spans": [ + { + "bbox": [ + 114, + 555, + 503, + 566 + ], + "score": 1.0, + "content": "an alternative parallelizable computation path, using a variant of attention instead of convolutions.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 36 + }, + { + "type": "title", + "bbox": [ + 108, + 578, + 301, + 591 + ], + "lines": [ + { + "bbox": [ + 104, + 576, + 302, + 593 + ], + "spans": [ + { + "bbox": [ + 104, + 576, + 302, + 593 + ], + "score": 1.0, + "content": "3 SELECTIVE STATE SPACE MODELS", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 106, + 596, + 505, + 662 + ], + "lines": [ + { + "bbox": [ + 106, + 596, + 505, + 609 + ], + "spans": [ + { + "bbox": [ + 106, + 596, + 505, + 609 + ], + "score": 1.0, + "content": "We motivate our selection mechanism using intuition from synthetic tasks (Section 3.1), then explain", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 104, + 605, + 507, + 622 + ], + "spans": [ + { + "bbox": [ + 104, + 605, + 507, + 622 + ], + "score": 1.0, + "content": "how to incorporate this mechanism into state space models (Section 3.2). The resulting time-varying", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 617, + 506, + 631 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 506, + 631 + ], + "score": 1.0, + "content": "SSMs cannot use convolutions, presenting a technical challenge of how to compute them efficiently.", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 629, + 506, + 641 + ], + "spans": [ + { + "bbox": [ + 105, + 629, + 506, + 641 + ], + "score": 1.0, + "content": "We overcome this with a hardware-aware algorithm that exploits the memory hierarchy on modern hard-", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 640, + 505, + 651 + ], + "spans": [ + { + "bbox": [ + 106, + 640, + 505, + 651 + ], + "score": 1.0, + "content": "ware (Section 3.3). We then describe a simple SSM architecture without attention or even MLP blocks", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 650, + 501, + 663 + ], + "spans": [ + { + "bbox": [ + 106, + 650, + 501, + 663 + ], + "score": 1.0, + "content": "(Section 3.4). Finally, we discuss some additional properties of selection mechanisms (Section 3.5).", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 44.5 + }, + { + "type": "title", + "bbox": [ + 107, + 672, + 375, + 684 + ], + "lines": [ + { + "bbox": [ + 106, + 672, + 376, + 685 + ], + "spans": [ + { + "bbox": [ + 106, + 672, + 376, + 685 + ], + "score": 1.0, + "content": "3.1 MOTIVATION: SELECTION AS A MEANS OF COMPRESSION", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 48 + }, + { + "type": "text", + "bbox": [ + 107, + 689, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 507, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 507, + 702 + ], + "score": 1.0, + "content": "We argue that a fundamental problem of sequence modeling is compressing context into a smaller state.", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 698, + 507, + 713 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 507, + 713 + ], + "score": 1.0, + "content": "In fact, we can view the tradeoffs of popular sequence models from this point of view. For example,", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "attention is both effective and inefficient because it explicitly does not compress context at all. This", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 105, + 719, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 719, + 506, + 734 + ], + "score": 1.0, + "content": "can be seen from the fact that autoregressive inference requires explicitly storing the entire context", + "type": "text" + } + ], + "index": 52 + } + ], + "index": 50.5 + } + ], + "page_idx": 2, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 304, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 304, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 304, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "score": 1.0, + "content": "3", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 147 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "Discretization has deep connections to continuous-time systems which can endow them with additional", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 505, + 105 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 505, + 105 + ], + "score": 1.0, + "content": "properties such as resolution invariance (Nguyen et al., 2022) and automatically ensuring that the", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 103, + 505, + 117 + ], + "spans": [ + { + "bbox": [ + 105, + 103, + 505, + 117 + ], + "score": 1.0, + "content": "model is properly normalized (Gu et al., 2023; Orvieto et al., 2023). It also has connections to gating", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 115, + 506, + 126 + ], + "spans": [ + { + "bbox": [ + 106, + 115, + 506, + 126 + ], + "score": 1.0, + "content": "mechanisms of RNNs (Tallec & Ollivier, 2018; Gu et al., 2020b) which we will revisit in Section 3.5.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 125, + 506, + 137 + ], + "spans": [ + { + "bbox": [ + 105, + 125, + 506, + 137 + ], + "score": 1.0, + "content": "However, from a mechanical point of view discretization can simply be viewed as the first step of", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 136, + 320, + 148 + ], + "spans": [ + { + "bbox": [ + 106, + 136, + 320, + 148 + ], + "score": 1.0, + "content": "the computation graph in the forward pass of an SSM.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 2.5, + "bbox_fs": [ + 105, + 82, + 506, + 148 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 153, + 504, + 175 + ], + "lines": [ + { + "bbox": [ + 106, + 152, + 505, + 165 + ], + "spans": [ + { + "bbox": [ + 106, + 152, + 357, + 165 + ], + "score": 1.0, + "content": "Computation After the parameters have been transformed from", + "type": "text" + }, + { + "bbox": [ + 357, + 152, + 461, + 165 + ], + "score": 0.93, + "content": "( \\Delta , A , B , C ) \\mapsto ( { \\overline { { A } } } , { \\overline { { B } } } , C )", + "type": "inline_equation" + }, + { + "bbox": [ + 461, + 152, + 505, + 165 + ], + "score": 1.0, + "content": ", the model", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 163, + 469, + 176 + ], + "spans": [ + { + "bbox": [ + 106, + 163, + 469, + 176 + ], + "score": 1.0, + "content": "can be computed in two ways, either as a linear recurrence (2) or a global convolution (3).", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6.5, + "bbox_fs": [ + 106, + 152, + 505, + 176 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 180, + 503, + 212 + ], + "lines": [ + { + "bbox": [ + 106, + 179, + 505, + 192 + ], + "spans": [ + { + "bbox": [ + 106, + 179, + 505, + 192 + ], + "score": 1.0, + "content": "Commonly, the model uses the convolutional mode (3) for efficient parallelizable training (where", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 191, + 505, + 203 + ], + "spans": [ + { + "bbox": [ + 106, + 191, + 505, + 203 + ], + "score": 1.0, + "content": "the whole input sequence is seen ahead of time), and switched into recurrent mode (2) for efficient", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 202, + 402, + 214 + ], + "spans": [ + { + "bbox": [ + 106, + 202, + 402, + 214 + ], + "score": 1.0, + "content": "autoregressive inference (where the inputs are seen one timestep at a time).", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9, + "bbox_fs": [ + 106, + 179, + 505, + 214 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 216, + 505, + 272 + ], + "lines": [ + { + "bbox": [ + 105, + 216, + 506, + 230 + ], + "spans": [ + { + "bbox": [ + 105, + 216, + 506, + 230 + ], + "score": 1.0, + "content": "Linear Time Invariance (LTI) An important property of equations (1) to (3) is that the model’s", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 227, + 506, + 241 + ], + "spans": [ + { + "bbox": [ + 106, + 227, + 315, + 241 + ], + "score": 1.0, + "content": "dynamics are constant through time. In other words", + "type": "text" + }, + { + "bbox": [ + 315, + 228, + 367, + 240 + ], + "score": 0.91, + "content": "( \\Delta , A , B , C )", + "type": "inline_equation" + }, + { + "bbox": [ + 367, + 227, + 443, + 241 + ], + "score": 1.0, + "content": ", and consequently", + "type": "text" + }, + { + "bbox": [ + 443, + 227, + 472, + 240 + ], + "score": 0.9, + "content": "( \\overline { { A } } , \\overline { { B } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 473, + 227, + 506, + 241 + ], + "score": 1.0, + "content": "as well,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 237, + 506, + 253 + ], + "spans": [ + { + "bbox": [ + 105, + 237, + 412, + 253 + ], + "score": 1.0, + "content": "are fixed for all time-steps. This property is called linear time invariance", + "type": "text" + }, + { + "bbox": [ + 412, + 240, + 434, + 250 + ], + "score": 0.4, + "content": "( L T I )", + "type": "inline_equation" + }, + { + "bbox": [ + 434, + 237, + 506, + 253 + ], + "score": 1.0, + "content": ", which is deeply", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 248, + 506, + 264 + ], + "spans": [ + { + "bbox": [ + 105, + 248, + 506, + 264 + ], + "score": 1.0, + "content": "connected to recurrence and convolutions. Informally, we think of LTI SSMs as being equivalent to any", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 261, + 506, + 273 + ], + "spans": [ + { + "bbox": [ + 106, + 261, + 506, + 273 + ], + "score": 1.0, + "content": "linear recurrence (2a) or convolution (3b), and use LTI as an umbrella term for these classes of models.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 13, + "bbox_fs": [ + 105, + 216, + 506, + 273 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 277, + 505, + 320 + ], + "lines": [ + { + "bbox": [ + 105, + 276, + 506, + 290 + ], + "spans": [ + { + "bbox": [ + 105, + 276, + 506, + 290 + ], + "score": 1.0, + "content": "Thus far, all structured SSMs have been LTI (e.g. computed as convolutions) because of fundamental", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 287, + 505, + 299 + ], + "spans": [ + { + "bbox": [ + 106, + 287, + 505, + 299 + ], + "score": 1.0, + "content": "efficiency constraints, discussed in Section 3.3. However, a core insight of this work is that LTI models", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 298, + 504, + 310 + ], + "spans": [ + { + "bbox": [ + 106, + 298, + 504, + 310 + ], + "score": 1.0, + "content": "have fundamental limitations in modeling certain types of data, and our technical contributions involve", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 309, + 397, + 321 + ], + "spans": [ + { + "bbox": [ + 105, + 309, + 397, + 321 + ], + "score": 1.0, + "content": "removing the LTI constraint while overcoming the efficiency bottlenecks.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 17.5, + "bbox_fs": [ + 105, + 276, + 506, + 321 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 325, + 505, + 357 + ], + "lines": [ + { + "bbox": [ + 106, + 324, + 505, + 337 + ], + "spans": [ + { + "bbox": [ + 106, + 324, + 505, + 337 + ], + "score": 1.0, + "content": "Structure Finally, we note that structured SSMs are so named because computing them efficiently also", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 335, + 507, + 349 + ], + "spans": [ + { + "bbox": [ + 105, + 335, + 244, + 349 + ], + "score": 1.0, + "content": "requires imposing structure on the", + "type": "text" + }, + { + "bbox": [ + 245, + 336, + 254, + 345 + ], + "score": 0.52, + "content": "\\pmb { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 335, + 507, + 349 + ], + "score": 1.0, + "content": "matrix. The most popular form of structure is diagonal (Gupta,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 345, + 352, + 358 + ], + "spans": [ + { + "bbox": [ + 106, + 345, + 352, + 358 + ], + "score": 1.0, + "content": "2022; Gu et al., 2022b; Smith et al., 2023), which we also use.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21, + "bbox_fs": [ + 105, + 324, + 507, + 358 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 360, + 505, + 416 + ], + "lines": [ + { + "bbox": [ + 105, + 359, + 507, + 375 + ], + "spans": [ + { + "bbox": [ + 105, + 359, + 172, + 375 + ], + "score": 1.0, + "content": "In this case, the", + "type": "text" + }, + { + "bbox": [ + 172, + 360, + 314, + 373 + ], + "score": 0.32, + "content": "\\pmb { A } \\in \\mathbb { R } ^ { N \\times N } , \\pmb { B } \\in \\mathbb { R } ^ { N \\times 1 } , \\pmb { C } \\in \\mathbb { R } ^ { 1 \\times N }", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 359, + 455, + 375 + ], + "score": 1.0, + "content": "matrices can all be represented by", + "type": "text" + }, + { + "bbox": [ + 456, + 362, + 466, + 372 + ], + "score": 0.8, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 466, + 359, + 507, + 375 + ], + "score": 1.0, + "content": "numbers.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 372, + 505, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 372, + 240, + 385 + ], + "score": 1.0, + "content": "To operate over an input sequence", + "type": "text" + }, + { + "bbox": [ + 240, + 375, + 247, + 383 + ], + "score": 0.79, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 372, + 298, + 385 + ], + "score": 1.0, + "content": "of batch size", + "type": "text" + }, + { + "bbox": [ + 299, + 373, + 308, + 383 + ], + "score": 0.79, + "content": "B", + "type": "inline_equation" + }, + { + "bbox": [ + 308, + 372, + 351, + 385 + ], + "score": 1.0, + "content": "and length", + "type": "text" + }, + { + "bbox": [ + 352, + 373, + 360, + 383 + ], + "score": 0.8, + "content": "L", + "type": "inline_equation" + }, + { + "bbox": [ + 360, + 372, + 380, + 385 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 380, + 373, + 389, + 383 + ], + "score": 0.79, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 390, + 372, + 505, + 385 + ], + "score": 1.0, + "content": "channels, the SSM is applied", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 383, + 506, + 397 + ], + "spans": [ + { + "bbox": [ + 105, + 383, + 470, + 397 + ], + "score": 1.0, + "content": "independently to each channel. Note that in this case, the total hidden state has dimension", + "type": "text" + }, + { + "bbox": [ + 470, + 384, + 489, + 393 + ], + "score": 0.77, + "content": "D N", + "type": "inline_equation" + }, + { + "bbox": [ + 489, + 383, + 506, + 397 + ], + "score": 1.0, + "content": "per", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 394, + 505, + 407 + ], + "spans": [ + { + "bbox": [ + 105, + 394, + 338, + 407 + ], + "score": 1.0, + "content": "input, and computing it over the sequence length requires", + "type": "text" + }, + { + "bbox": [ + 339, + 394, + 387, + 406 + ], + "score": 0.91, + "content": "O ( B L D N )", + "type": "inline_equation" + }, + { + "bbox": [ + 388, + 394, + 505, + 407 + ], + "score": 1.0, + "content": "time and memory; this is the", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 405, + 385, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 405, + 385, + 416 + ], + "score": 1.0, + "content": "root of the fundamental efficiency bottleneck addressed in Section 3.3.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 25, + "bbox_fs": [ + 105, + 359, + 507, + 416 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 420, + 505, + 464 + ], + "lines": [ + { + "bbox": [ + 106, + 420, + 505, + 433 + ], + "spans": [ + { + "bbox": [ + 106, + 420, + 505, + 433 + ], + "score": 1.0, + "content": "SSM Architectures SSMs are standalone sequence transformations that can be incorporated into", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 430, + 507, + 444 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 507, + 444 + ], + "score": 1.0, + "content": "end-to-end neural network architectures. We discuss some of the most well-known SSM architectures,", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 443, + 505, + 455 + ], + "spans": [ + { + "bbox": [ + 106, + 443, + 505, + 455 + ], + "score": 1.0, + "content": "many of which will also serve as our primary baselines. Other closely related SSMs and architectures", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 453, + 358, + 465 + ], + "spans": [ + { + "bbox": [ + 106, + 453, + 358, + 465 + ], + "score": 1.0, + "content": "are discussed further in an extended related work (Appendix B).", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29.5, + "bbox_fs": [ + 105, + 420, + 507, + 465 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 468, + 506, + 567 + ], + "lines": [ + { + "bbox": [ + 105, + 466, + 506, + 480 + ], + "spans": [ + { + "bbox": [ + 105, + 466, + 506, + 480 + ], + "score": 1.0, + "content": "• Linear attention (Katharopoulos et al., 2020) is an approximation of self-attention (Bahdanau et al.,", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 113, + 478, + 425, + 491 + ], + "spans": [ + { + "bbox": [ + 113, + 478, + 425, + 491 + ], + "score": 1.0, + "content": "2014) involving a recurrence which can be viewed as a degenerate linear SSM.", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 488, + 505, + 503 + ], + "spans": [ + { + "bbox": [ + 106, + 488, + 505, + 503 + ], + "score": 1.0, + "content": "• H3 (Dao et al., 2023) generalized this recurrence to use S4; it can be viewed as an architecture", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 113, + 500, + 505, + 513 + ], + "spans": [ + { + "bbox": [ + 113, + 500, + 505, + 513 + ], + "score": 1.0, + "content": "with an SSM sandwiched by two gated connections (Figure 2). H3 also inserts a standard local", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 113, + 511, + 409, + 523 + ], + "spans": [ + { + "bbox": [ + 113, + 511, + 409, + 523 + ], + "score": 1.0, + "content": "convolution, which they frame as a shift-SSM, before the main SSM layer.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 521, + 506, + 534 + ], + "spans": [ + { + "bbox": [ + 106, + 521, + 506, + 534 + ], + "score": 1.0, + "content": "• Hyena (Poli et al., 2023) uses the same architecture but replaces the S4 layer with an MLP-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 113, + 533, + 338, + 545 + ], + "spans": [ + { + "bbox": [ + 113, + 533, + 338, + 545 + ], + "score": 1.0, + "content": "parameterized global convolution (Romero et al., 2021).", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 542, + 505, + 556 + ], + "spans": [ + { + "bbox": [ + 106, + 542, + 505, + 556 + ], + "score": 1.0, + "content": "• RetNet (Sun et al., 2023) adds an additional gate to the architecture and simplifies the SSM, allowing", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 114, + 555, + 503, + 566 + ], + "spans": [ + { + "bbox": [ + 114, + 555, + 503, + 566 + ], + "score": 1.0, + "content": "an alternative parallelizable computation path, using a variant of attention instead of convolutions.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 36, + "bbox_fs": [ + 105, + 466, + 506, + 566 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 578, + 301, + 591 + ], + "lines": [ + { + "bbox": [ + 104, + 576, + 302, + 593 + ], + "spans": [ + { + "bbox": [ + 104, + 576, + 302, + 593 + ], + "score": 1.0, + "content": "3 SELECTIVE STATE SPACE MODELS", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 106, + 596, + 505, + 662 + ], + "lines": [ + { + "bbox": [ + 106, + 596, + 505, + 609 + ], + "spans": [ + { + "bbox": [ + 106, + 596, + 505, + 609 + ], + "score": 1.0, + "content": "We motivate our selection mechanism using intuition from synthetic tasks (Section 3.1), then explain", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 104, + 605, + 507, + 622 + ], + "spans": [ + { + "bbox": [ + 104, + 605, + 507, + 622 + ], + "score": 1.0, + "content": "how to incorporate this mechanism into state space models (Section 3.2). The resulting time-varying", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 617, + 506, + 631 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 506, + 631 + ], + "score": 1.0, + "content": "SSMs cannot use convolutions, presenting a technical challenge of how to compute them efficiently.", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 629, + 506, + 641 + ], + "spans": [ + { + "bbox": [ + 105, + 629, + 506, + 641 + ], + "score": 1.0, + "content": "We overcome this with a hardware-aware algorithm that exploits the memory hierarchy on modern hard-", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 640, + 505, + 651 + ], + "spans": [ + { + "bbox": [ + 106, + 640, + 505, + 651 + ], + "score": 1.0, + "content": "ware (Section 3.3). We then describe a simple SSM architecture without attention or even MLP blocks", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 650, + 501, + 663 + ], + "spans": [ + { + "bbox": [ + 106, + 650, + 501, + 663 + ], + "score": 1.0, + "content": "(Section 3.4). Finally, we discuss some additional properties of selection mechanisms (Section 3.5).", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 44.5, + "bbox_fs": [ + 104, + 596, + 507, + 663 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 672, + 375, + 684 + ], + "lines": [ + { + "bbox": [ + 106, + 672, + 376, + 685 + ], + "spans": [ + { + "bbox": [ + 106, + 672, + 376, + 685 + ], + "score": 1.0, + "content": "3.1 MOTIVATION: SELECTION AS A MEANS OF COMPRESSION", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 48 + }, + { + "type": "text", + "bbox": [ + 107, + 689, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 507, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 507, + 702 + ], + "score": 1.0, + "content": "We argue that a fundamental problem of sequence modeling is compressing context into a smaller state.", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 698, + 507, + 713 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 507, + 713 + ], + "score": 1.0, + "content": "In fact, we can view the tradeoffs of popular sequence models from this point of view. For example,", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 505, + 722 + ], + "score": 1.0, + "content": "attention is both effective and inefficient because it explicitly does not compress context at all. This", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 105, + 719, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 719, + 506, + 734 + ], + "score": 1.0, + "content": "can be seen from the fact that autoregressive inference requires explicitly storing the entire context", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 104, + 237, + 506, + 254 + ], + "spans": [ + { + "bbox": [ + 104, + 237, + 506, + 254 + ], + "score": 1.0, + "content": "(i.e. the KV cache), which directly causes the slow linear-time inference and quadratic-time training", + "type": "text", + "cross_page": true + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 248, + 506, + 263 + ], + "spans": [ + { + "bbox": [ + 105, + 248, + 506, + 263 + ], + "score": 1.0, + "content": "of Transformers. On the other hand, recurrent models are efficient because they have a finite state,", + "type": "text", + "cross_page": true + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 261, + 505, + 273 + ], + "spans": [ + { + "bbox": [ + 106, + 261, + 505, + 273 + ], + "score": 1.0, + "content": "implying constant-time inference and linear-time training. However, their effectiveness is limited", + "type": "text", + "cross_page": true + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 271, + 306, + 284 + ], + "spans": [ + { + "bbox": [ + 106, + 271, + 306, + 284 + ], + "score": 1.0, + "content": "by how well this state has compressed the context.", + "type": "text", + "cross_page": true + } + ], + "index": 11 + } + ], + "index": 50.5, + "bbox_fs": [ + 105, + 687, + 507, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 107, + 78, + 504, + 174 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 107, + 78, + 504, + 174 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 107, + 78, + 504, + 174 + ], + "spans": [ + { + "bbox": [ + 107, + 78, + 504, + 174 + ], + "score": 0.967, + "type": "image", + "image_path": "b89480ae226b79d85c42d818542d10470c69bd199a250e4332dba21aa4f5cf97.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 107, + 78, + 504, + 110.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 107, + 110.0, + 504, + 142.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 107, + 142.0, + 504, + 174.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 182, + 505, + 232 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 182, + 505, + 193 + ], + "spans": [ + { + "bbox": [ + 106, + 182, + 505, + 193 + ], + "score": 1.0, + "content": "Figure 1: (Left) The standard version of the Copying task involves constant spacing between input and output", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 191, + 505, + 203 + ], + "spans": [ + { + "bbox": [ + 105, + 191, + 505, + 203 + ], + "score": 1.0, + "content": "elements and is easily solved by time-invariant models such as linear recurrences and global convolutions. (Right", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 201, + 505, + 213 + ], + "spans": [ + { + "bbox": [ + 106, + 201, + 505, + 213 + ], + "score": 1.0, + "content": "Top) The Selective Copying task has random spacing in between inputs and requires time-varying models that can", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 211, + 506, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 211, + 506, + 223 + ], + "score": 1.0, + "content": "selectively remember or ignore inputs depending on their content. (Right Bottom) The Induction Heads task is an", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 221, + 478, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 221, + 478, + 234 + ], + "score": 1.0, + "content": "example of associative recall that requires retrieving an answer based on context, a key ability for LLMs.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5 + } + ], + "index": 3.0 + }, + { + "type": "text", + "bbox": [ + 106, + 239, + 506, + 282 + ], + "lines": [ + { + "bbox": [ + 104, + 237, + 506, + 254 + ], + "spans": [ + { + "bbox": [ + 104, + 237, + 506, + 254 + ], + "score": 1.0, + "content": "(i.e. the KV cache), which directly causes the slow linear-time inference and quadratic-time training", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 248, + 506, + 263 + ], + "spans": [ + { + "bbox": [ + 105, + 248, + 506, + 263 + ], + "score": 1.0, + "content": "of Transformers. On the other hand, recurrent models are efficient because they have a finite state,", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 261, + 505, + 273 + ], + "spans": [ + { + "bbox": [ + 106, + 261, + 505, + 273 + ], + "score": 1.0, + "content": "implying constant-time inference and linear-time training. However, their effectiveness is limited", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 271, + 306, + 284 + ], + "spans": [ + { + "bbox": [ + 106, + 271, + 306, + 284 + ], + "score": 1.0, + "content": "by how well this state has compressed the context.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 9.5 + }, + { + "type": "text", + "bbox": [ + 105, + 287, + 472, + 299 + ], + "lines": [ + { + "bbox": [ + 105, + 286, + 474, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 286, + 474, + 300 + ], + "score": 1.0, + "content": "To understand this principle, we focus on two running examples of synthetic tasks (Figure 1).", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 107, + 303, + 505, + 370 + ], + "lines": [ + { + "bbox": [ + 105, + 301, + 505, + 316 + ], + "spans": [ + { + "bbox": [ + 105, + 301, + 505, + 316 + ], + "score": 1.0, + "content": "• The Selective Copying task modifies the popular Copying task (Arjovsky et al., 2016) by varying", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 114, + 313, + 505, + 326 + ], + "spans": [ + { + "bbox": [ + 114, + 313, + 505, + 326 + ], + "score": 1.0, + "content": "the position of the tokens to memorize. It requires content-aware reasoning to be able to memorize", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 114, + 324, + 388, + 336 + ], + "spans": [ + { + "bbox": [ + 114, + 324, + 388, + 336 + ], + "score": 1.0, + "content": "the relevant tokens (colored) and filter out the irrelevant ones (white).", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 336, + 506, + 350 + ], + "spans": [ + { + "bbox": [ + 105, + 336, + 506, + 350 + ], + "score": 1.0, + "content": "• The Induction Heads task is a well-known mechanism hypothesized to explain the majority of", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 113, + 347, + 506, + 361 + ], + "spans": [ + { + "bbox": [ + 113, + 347, + 506, + 361 + ], + "score": 1.0, + "content": "in-context learning abilities of LLMs (Olsson et al., 2022). It requires context-aware reasoning to", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 114, + 358, + 413, + 371 + ], + "spans": [ + { + "bbox": [ + 114, + 358, + 413, + 371 + ], + "score": 1.0, + "content": "know when to produce the correct output in the appropriate context (black).", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 15.5 + }, + { + "type": "text", + "bbox": [ + 106, + 374, + 505, + 451 + ], + "lines": [ + { + "bbox": [ + 106, + 374, + 505, + 387 + ], + "spans": [ + { + "bbox": [ + 106, + 374, + 505, + 387 + ], + "score": 1.0, + "content": "These tasks reveal the failure mode of LTI models. From the recurrent view, their constant dynamics", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 385, + 506, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 141, + 399 + ], + "score": 1.0, + "content": "(e.g. the", + "type": "text" + }, + { + "bbox": [ + 142, + 385, + 171, + 398 + ], + "score": 0.91, + "content": "( \\overline { { A } } , \\overline { { B } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 171, + 385, + 506, + 399 + ], + "score": 1.0, + "content": "transitions in (2)) cannot let them select the correct information from their context,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 397, + 506, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 397, + 506, + 410 + ], + "score": 1.0, + "content": "or affect the hidden state passed along the sequence an in input-dependent way. From the convolutional", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 408, + 505, + 421 + ], + "spans": [ + { + "bbox": [ + 106, + 408, + 505, + 421 + ], + "score": 1.0, + "content": "view, it is known that global convolutions can solve the vanilla Copying task (Romero et al., 2021)", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 417, + 506, + 433 + ], + "spans": [ + { + "bbox": [ + 105, + 417, + 506, + 433 + ], + "score": 1.0, + "content": "because it only requires time-awareness, but that they have difficulty with the Selective Copying", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 429, + 505, + 442 + ], + "spans": [ + { + "bbox": [ + 106, + 429, + 505, + 442 + ], + "score": 1.0, + "content": "task because of lack of content-awareness (Figure 1). More concretely, the spacing between", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 441, + 427, + 452 + ], + "spans": [ + { + "bbox": [ + 106, + 441, + 427, + 452 + ], + "score": 1.0, + "content": "inputs-to-outputs is varying and cannot be modeled by static convolution kernels.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 107, + 456, + 505, + 521 + ], + "lines": [ + { + "bbox": [ + 106, + 456, + 505, + 468 + ], + "spans": [ + { + "bbox": [ + 106, + 456, + 505, + 468 + ], + "score": 1.0, + "content": "In summary, the efficiency vs. effectiveness tradeoff of sequence models is characterized by how well", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 466, + 505, + 478 + ], + "spans": [ + { + "bbox": [ + 105, + 466, + 505, + 478 + ], + "score": 1.0, + "content": "they compress their state: efficient models must have a small state, while effective models must have", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 478, + 506, + 489 + ], + "spans": [ + { + "bbox": [ + 105, + 478, + 506, + 489 + ], + "score": 1.0, + "content": "a state that contains all necessary information from the context. In turn, we propose that a fundamental", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 488, + 506, + 500 + ], + "spans": [ + { + "bbox": [ + 105, + 488, + 506, + 500 + ], + "score": 1.0, + "content": "principle for building sequence models is selectivity: or the context-aware ability to focus on or", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 498, + 506, + 511 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 506, + 511 + ], + "score": 1.0, + "content": "filter out inputs into a sequential state. In particular, a selection mechanism controls how information", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 510, + 468, + 522 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 468, + 522 + ], + "score": 1.0, + "content": "propagates or interacts along the sequence dimension (see Section 3.5 for more discussion).", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 28.5 + }, + { + "type": "title", + "bbox": [ + 108, + 529, + 285, + 541 + ], + "lines": [ + { + "bbox": [ + 106, + 529, + 286, + 542 + ], + "spans": [ + { + "bbox": [ + 106, + 529, + 286, + 542 + ], + "score": 1.0, + "content": "3.2 IMPROVING SSMS WITH SELECTION", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 107, + 545, + 505, + 578 + ], + "lines": [ + { + "bbox": [ + 106, + 545, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 106, + 545, + 505, + 558 + ], + "score": 1.0, + "content": "One method of incorporating a selection mechanism into models is by letting their parameters that", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 556, + 506, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 506, + 569 + ], + "score": 1.0, + "content": "affect interactions along the sequence (e.g. the recurrent dynamics of an RNN or the convolution kernel", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 567, + 231, + 579 + ], + "spans": [ + { + "bbox": [ + 106, + 567, + 231, + 579 + ], + "score": 1.0, + "content": "of a CNN) be input-dependent.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 107, + 583, + 505, + 637 + ], + "lines": [ + { + "bbox": [ + 105, + 582, + 505, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 505, + 596 + ], + "score": 1.0, + "content": "Algorithms 1 and 2 illustrates the main selection mechanism that we use. The main difference is simply", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 594, + 506, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 213, + 606 + ], + "score": 1.0, + "content": "making several parameters", + "type": "text" + }, + { + "bbox": [ + 213, + 594, + 246, + 605 + ], + "score": 0.66, + "content": "^ { \\Delta , B , C }", + "type": "inline_equation" + }, + { + "bbox": [ + 246, + 594, + 506, + 606 + ], + "score": 1.0, + "content": "functions of the input, along with the associated changes to tensor", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 604, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 505, + 617 + ], + "score": 1.0, + "content": "shapes throughout. In particular, we highlight that these parameters now have a length dimension", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 107, + 613, + 506, + 629 + ], + "spans": [ + { + "bbox": [ + 107, + 615, + 114, + 625 + ], + "score": 0.74, + "content": "L", + "type": "inline_equation" + }, + { + "bbox": [ + 115, + 613, + 506, + 629 + ], + "score": 1.0, + "content": ", meaning that the model has changed from time-invariant to time-varying. This loses the equivalence", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 626, + 383, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 383, + 639 + ], + "score": 1.0, + "content": "to convolutions (3) with implications for its efficiency, discussed next.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 38 + }, + { + "type": "text", + "bbox": [ + 107, + 641, + 505, + 674 + ], + "lines": [ + { + "bbox": [ + 105, + 641, + 506, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 641, + 201, + 654 + ], + "score": 1.0, + "content": "We specifically choose", + "type": "text" + }, + { + "bbox": [ + 202, + 641, + 287, + 653 + ], + "score": 0.82, + "content": "s _ { B } ( x ) = \\mathsf { L i n e a r } _ { N } ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 287, + 641, + 291, + 654 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 291, + 641, + 375, + 654 + ], + "score": 0.81, + "content": "s _ { C } ( x ) = \\mathsf { L i n e a r } _ { N } ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 376, + 641, + 379, + 654 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 380, + 641, + 502, + 654 + ], + "score": 0.8, + "content": "s _ { \\Delta } ( x ) = \\mathsf { L i n e a r } _ { D } ( \\mathsf { L i n e a r } _ { 1 } ( x ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 641, + 506, + 654 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 653, + 506, + 664 + ], + "spans": [ + { + "bbox": [ + 106, + 653, + 123, + 664 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 123, + 653, + 145, + 663 + ], + "score": 0.72, + "content": "\\tau _ { \\Delta } =", + "type": "inline_equation" + }, + { + "bbox": [ + 146, + 653, + 232, + 664 + ], + "score": 1.0, + "content": "softplus, where Linea", + "type": "text" + }, + { + "bbox": [ + 233, + 655, + 238, + 663 + ], + "score": 0.35, + "content": "\\dot { } d", + "type": "inline_equation" + }, + { + "bbox": [ + 239, + 653, + 408, + 664 + ], + "score": 1.0, + "content": "is a parameterized projection to dimension", + "type": "text" + }, + { + "bbox": [ + 408, + 654, + 415, + 662 + ], + "score": 0.75, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 415, + 653, + 474, + 664 + ], + "score": 1.0, + "content": ". The choice of", + "type": "text" + }, + { + "bbox": [ + 475, + 654, + 487, + 663 + ], + "score": 0.84, + "content": "s _ { \\Delta }", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 653, + 506, + 664 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 663, + 418, + 675 + ], + "spans": [ + { + "bbox": [ + 106, + 664, + 119, + 674 + ], + "score": 0.85, + "content": "\\tau _ { \\Delta }", + "type": "inline_equation" + }, + { + "bbox": [ + 119, + 663, + 418, + 675 + ], + "score": 1.0, + "content": "is due to a connection to RNN gating mechanisms explained in Section 3.5.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42 + }, + { + "type": "title", + "bbox": [ + 107, + 683, + 347, + 694 + ], + "lines": [ + { + "bbox": [ + 106, + 683, + 348, + 696 + ], + "spans": [ + { + "bbox": [ + 106, + 683, + 348, + 696 + ], + "score": 1.0, + "content": "3.3 EFFICIENT IMPLEMENTATION OF SELECTIVE SSMS", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 44 + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "Hardware-friendly architectures such as convolutions (Krizhevsky et al., 2012) and Transform-", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 710, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 506, + 722 + ], + "score": 1.0, + "content": "ers (Vaswani et al., 2017) enjoy widespread application. Here we aim to make selective SSMs efficient", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 720, + 505, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 505, + 732 + ], + "score": 1.0, + "content": "on modern hardware (GPU) as well. The selection mechanism is quite natural, and earlier works", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 46 + } + ], + "page_idx": 3, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 304, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 305, + 39 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 305, + 39 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 759 + ], + "lines": [] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 107, + 78, + 504, + 174 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 107, + 78, + 504, + 174 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 107, + 78, + 504, + 174 + ], + "spans": [ + { + "bbox": [ + 107, + 78, + 504, + 174 + ], + "score": 0.967, + "type": "image", + "image_path": "b89480ae226b79d85c42d818542d10470c69bd199a250e4332dba21aa4f5cf97.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 107, + 78, + 504, + 110.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 107, + 110.0, + 504, + 142.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 107, + 142.0, + 504, + 174.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 182, + 505, + 232 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 182, + 505, + 193 + ], + "spans": [ + { + "bbox": [ + 106, + 182, + 505, + 193 + ], + "score": 1.0, + "content": "Figure 1: (Left) The standard version of the Copying task involves constant spacing between input and output", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 191, + 505, + 203 + ], + "spans": [ + { + "bbox": [ + 105, + 191, + 505, + 203 + ], + "score": 1.0, + "content": "elements and is easily solved by time-invariant models such as linear recurrences and global convolutions. (Right", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 201, + 505, + 213 + ], + "spans": [ + { + "bbox": [ + 106, + 201, + 505, + 213 + ], + "score": 1.0, + "content": "Top) The Selective Copying task has random spacing in between inputs and requires time-varying models that can", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 211, + 506, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 211, + 506, + 223 + ], + "score": 1.0, + "content": "selectively remember or ignore inputs depending on their content. (Right Bottom) The Induction Heads task is an", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 221, + 478, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 221, + 478, + 234 + ], + "score": 1.0, + "content": "example of associative recall that requires retrieving an answer based on context, a key ability for LLMs.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5 + } + ], + "index": 3.0 + }, + { + "type": "text", + "bbox": [ + 106, + 239, + 506, + 282 + ], + "lines": [], + "index": 9.5, + "bbox_fs": [ + 104, + 237, + 506, + 284 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 105, + 287, + 472, + 299 + ], + "lines": [ + { + "bbox": [ + 105, + 286, + 474, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 286, + 474, + 300 + ], + "score": 1.0, + "content": "To understand this principle, we focus on two running examples of synthetic tasks (Figure 1).", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12, + "bbox_fs": [ + 105, + 286, + 474, + 300 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 303, + 505, + 370 + ], + "lines": [ + { + "bbox": [ + 105, + 301, + 505, + 316 + ], + "spans": [ + { + "bbox": [ + 105, + 301, + 505, + 316 + ], + "score": 1.0, + "content": "• The Selective Copying task modifies the popular Copying task (Arjovsky et al., 2016) by varying", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 114, + 313, + 505, + 326 + ], + "spans": [ + { + "bbox": [ + 114, + 313, + 505, + 326 + ], + "score": 1.0, + "content": "the position of the tokens to memorize. It requires content-aware reasoning to be able to memorize", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 114, + 324, + 388, + 336 + ], + "spans": [ + { + "bbox": [ + 114, + 324, + 388, + 336 + ], + "score": 1.0, + "content": "the relevant tokens (colored) and filter out the irrelevant ones (white).", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 336, + 506, + 350 + ], + "spans": [ + { + "bbox": [ + 105, + 336, + 506, + 350 + ], + "score": 1.0, + "content": "• The Induction Heads task is a well-known mechanism hypothesized to explain the majority of", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 113, + 347, + 506, + 361 + ], + "spans": [ + { + "bbox": [ + 113, + 347, + 506, + 361 + ], + "score": 1.0, + "content": "in-context learning abilities of LLMs (Olsson et al., 2022). It requires context-aware reasoning to", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 114, + 358, + 413, + 371 + ], + "spans": [ + { + "bbox": [ + 114, + 358, + 413, + 371 + ], + "score": 1.0, + "content": "know when to produce the correct output in the appropriate context (black).", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 15.5, + "bbox_fs": [ + 105, + 301, + 506, + 371 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 374, + 505, + 451 + ], + "lines": [ + { + "bbox": [ + 106, + 374, + 505, + 387 + ], + "spans": [ + { + "bbox": [ + 106, + 374, + 505, + 387 + ], + "score": 1.0, + "content": "These tasks reveal the failure mode of LTI models. From the recurrent view, their constant dynamics", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 385, + 506, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 141, + 399 + ], + "score": 1.0, + "content": "(e.g. the", + "type": "text" + }, + { + "bbox": [ + 142, + 385, + 171, + 398 + ], + "score": 0.91, + "content": "( \\overline { { A } } , \\overline { { B } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 171, + 385, + 506, + 399 + ], + "score": 1.0, + "content": "transitions in (2)) cannot let them select the correct information from their context,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 397, + 506, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 397, + 506, + 410 + ], + "score": 1.0, + "content": "or affect the hidden state passed along the sequence an in input-dependent way. From the convolutional", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 408, + 505, + 421 + ], + "spans": [ + { + "bbox": [ + 106, + 408, + 505, + 421 + ], + "score": 1.0, + "content": "view, it is known that global convolutions can solve the vanilla Copying task (Romero et al., 2021)", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 417, + 506, + 433 + ], + "spans": [ + { + "bbox": [ + 105, + 417, + 506, + 433 + ], + "score": 1.0, + "content": "because it only requires time-awareness, but that they have difficulty with the Selective Copying", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 429, + 505, + 442 + ], + "spans": [ + { + "bbox": [ + 106, + 429, + 505, + 442 + ], + "score": 1.0, + "content": "task because of lack of content-awareness (Figure 1). More concretely, the spacing between", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 441, + 427, + 452 + ], + "spans": [ + { + "bbox": [ + 106, + 441, + 427, + 452 + ], + "score": 1.0, + "content": "inputs-to-outputs is varying and cannot be modeled by static convolution kernels.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22, + "bbox_fs": [ + 105, + 374, + 506, + 452 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 456, + 505, + 521 + ], + "lines": [ + { + "bbox": [ + 106, + 456, + 505, + 468 + ], + "spans": [ + { + "bbox": [ + 106, + 456, + 505, + 468 + ], + "score": 1.0, + "content": "In summary, the efficiency vs. effectiveness tradeoff of sequence models is characterized by how well", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 466, + 505, + 478 + ], + "spans": [ + { + "bbox": [ + 105, + 466, + 505, + 478 + ], + "score": 1.0, + "content": "they compress their state: efficient models must have a small state, while effective models must have", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 478, + 506, + 489 + ], + "spans": [ + { + "bbox": [ + 105, + 478, + 506, + 489 + ], + "score": 1.0, + "content": "a state that contains all necessary information from the context. In turn, we propose that a fundamental", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 488, + 506, + 500 + ], + "spans": [ + { + "bbox": [ + 105, + 488, + 506, + 500 + ], + "score": 1.0, + "content": "principle for building sequence models is selectivity: or the context-aware ability to focus on or", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 498, + 506, + 511 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 506, + 511 + ], + "score": 1.0, + "content": "filter out inputs into a sequential state. In particular, a selection mechanism controls how information", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 510, + 468, + 522 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 468, + 522 + ], + "score": 1.0, + "content": "propagates or interacts along the sequence dimension (see Section 3.5 for more discussion).", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 28.5, + "bbox_fs": [ + 105, + 456, + 506, + 522 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 529, + 285, + 541 + ], + "lines": [ + { + "bbox": [ + 106, + 529, + 286, + 542 + ], + "spans": [ + { + "bbox": [ + 106, + 529, + 286, + 542 + ], + "score": 1.0, + "content": "3.2 IMPROVING SSMS WITH SELECTION", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 107, + 545, + 505, + 578 + ], + "lines": [ + { + "bbox": [ + 106, + 545, + 505, + 558 + ], + "spans": [ + { + "bbox": [ + 106, + 545, + 505, + 558 + ], + "score": 1.0, + "content": "One method of incorporating a selection mechanism into models is by letting their parameters that", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 556, + 506, + 569 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 506, + 569 + ], + "score": 1.0, + "content": "affect interactions along the sequence (e.g. the recurrent dynamics of an RNN or the convolution kernel", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 567, + 231, + 579 + ], + "spans": [ + { + "bbox": [ + 106, + 567, + 231, + 579 + ], + "score": 1.0, + "content": "of a CNN) be input-dependent.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34, + "bbox_fs": [ + 105, + 545, + 506, + 579 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 583, + 505, + 637 + ], + "lines": [ + { + "bbox": [ + 105, + 582, + 505, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 505, + 596 + ], + "score": 1.0, + "content": "Algorithms 1 and 2 illustrates the main selection mechanism that we use. The main difference is simply", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 594, + 506, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 213, + 606 + ], + "score": 1.0, + "content": "making several parameters", + "type": "text" + }, + { + "bbox": [ + 213, + 594, + 246, + 605 + ], + "score": 0.66, + "content": "^ { \\Delta , B , C }", + "type": "inline_equation" + }, + { + "bbox": [ + 246, + 594, + 506, + 606 + ], + "score": 1.0, + "content": "functions of the input, along with the associated changes to tensor", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 604, + 505, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 505, + 617 + ], + "score": 1.0, + "content": "shapes throughout. In particular, we highlight that these parameters now have a length dimension", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 107, + 613, + 506, + 629 + ], + "spans": [ + { + "bbox": [ + 107, + 615, + 114, + 625 + ], + "score": 0.74, + "content": "L", + "type": "inline_equation" + }, + { + "bbox": [ + 115, + 613, + 506, + 629 + ], + "score": 1.0, + "content": ", meaning that the model has changed from time-invariant to time-varying. This loses the equivalence", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 626, + 383, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 383, + 639 + ], + "score": 1.0, + "content": "to convolutions (3) with implications for its efficiency, discussed next.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 38, + "bbox_fs": [ + 105, + 582, + 506, + 639 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 641, + 505, + 674 + ], + "lines": [ + { + "bbox": [ + 105, + 641, + 506, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 641, + 201, + 654 + ], + "score": 1.0, + "content": "We specifically choose", + "type": "text" + }, + { + "bbox": [ + 202, + 641, + 287, + 653 + ], + "score": 0.82, + "content": "s _ { B } ( x ) = \\mathsf { L i n e a r } _ { N } ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 287, + 641, + 291, + 654 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 291, + 641, + 375, + 654 + ], + "score": 0.81, + "content": "s _ { C } ( x ) = \\mathsf { L i n e a r } _ { N } ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 376, + 641, + 379, + 654 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 380, + 641, + 502, + 654 + ], + "score": 0.8, + "content": "s _ { \\Delta } ( x ) = \\mathsf { L i n e a r } _ { D } ( \\mathsf { L i n e a r } _ { 1 } ( x ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 641, + 506, + 654 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 653, + 506, + 664 + ], + "spans": [ + { + "bbox": [ + 106, + 653, + 123, + 664 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 123, + 653, + 145, + 663 + ], + "score": 0.72, + "content": "\\tau _ { \\Delta } =", + "type": "inline_equation" + }, + { + "bbox": [ + 146, + 653, + 232, + 664 + ], + "score": 1.0, + "content": "softplus, where Linea", + "type": "text" + }, + { + "bbox": [ + 233, + 655, + 238, + 663 + ], + "score": 0.35, + "content": "\\dot { } d", + "type": "inline_equation" + }, + { + "bbox": [ + 239, + 653, + 408, + 664 + ], + "score": 1.0, + "content": "is a parameterized projection to dimension", + "type": "text" + }, + { + "bbox": [ + 408, + 654, + 415, + 662 + ], + "score": 0.75, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 415, + 653, + 474, + 664 + ], + "score": 1.0, + "content": ". The choice of", + "type": "text" + }, + { + "bbox": [ + 475, + 654, + 487, + 663 + ], + "score": 0.84, + "content": "s _ { \\Delta }", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 653, + 506, + 664 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 663, + 418, + 675 + ], + "spans": [ + { + "bbox": [ + 106, + 664, + 119, + 674 + ], + "score": 0.85, + "content": "\\tau _ { \\Delta }", + "type": "inline_equation" + }, + { + "bbox": [ + 119, + 663, + 418, + 675 + ], + "score": 1.0, + "content": "is due to a connection to RNN gating mechanisms explained in Section 3.5.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42, + "bbox_fs": [ + 105, + 641, + 506, + 675 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 683, + 347, + 694 + ], + "lines": [ + { + "bbox": [ + 106, + 683, + 348, + 696 + ], + "spans": [ + { + "bbox": [ + 106, + 683, + 348, + 696 + ], + "score": 1.0, + "content": "3.3 EFFICIENT IMPLEMENTATION OF SELECTIVE SSMS", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 44 + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "Hardware-friendly architectures such as convolutions (Krizhevsky et al., 2012) and Transform-", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 710, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 506, + 722 + ], + "score": 1.0, + "content": "ers (Vaswani et al., 2017) enjoy widespread application. Here we aim to make selective SSMs efficient", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 720, + 505, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 505, + 732 + ], + "score": 1.0, + "content": "on modern hardware (GPU) as well. The selection mechanism is quite natural, and earlier works", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 231, + 504, + 243 + ], + "spans": [ + { + "bbox": [ + 106, + 231, + 381, + 243 + ], + "score": 1.0, + "content": "attempted to incorporate special cases of selection, such as letting", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 381, + 231, + 391, + 241 + ], + "score": 0.78, + "content": "\\Delta", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 391, + 231, + 504, + 243 + ], + "score": 1.0, + "content": "vary over time in recurrent", + "type": "text", + "cross_page": true + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 240, + 504, + 254 + ], + "spans": [ + { + "bbox": [ + 106, + 240, + 504, + 254 + ], + "score": 1.0, + "content": "SSMs (Gu et al., 2020a). However, this was computationally difficult, which was why S4 and all", + "type": "text", + "cross_page": true + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 252, + 487, + 265 + ], + "spans": [ + { + "bbox": [ + 106, + 252, + 487, + 265 + ], + "score": 1.0, + "content": "derivatives used LTI (non-selective) models, most commonly in the form of global convolutions.", + "type": "text", + "cross_page": true + } + ], + "index": 5 + } + ], + "index": 46, + "bbox_fs": [ + 105, + 698, + 506, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 106, + 91, + 501, + 223 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 106, + 91, + 501, + 223 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 91, + 501, + 223 + ], + "spans": [ + { + "bbox": [ + 106, + 91, + 501, + 223 + ], + "score": 0.956, + "html": "
Algorithm 1 SSM (S4)Algorithm 2 SSM + Selection (S6)
Input: x : (B,L,D)Input: x : (B,L,D)
Output: y:(B,L,D)Output: y: (B,L,D)
1:A:(D,N)←Parameter1:A:(D,N)←Parameter
Represents structured N × N matrix>Represents structured N × N matrix
2:B:(D,N)←Parameter2: B:(B,L,N)← SB(𝑥)
3: C:(D,N)←Parameter 3: C:(B,L,N)←sc(x)
4:△:(D)←T△(Parameter)4: △:(B,L,D)←T△(Parameter+s△(x))
5: A,B:(D,N)←discretize(△,A,B) 5: A,B:(B,L,D,N)←discretize(△,A,B)
6: y←SSM(A,B,C)(x)6: y←SSM(A,B,C)(x)
> Time-invariant: recurrence or convolution 7: return yTime-varying: recurrence (scan) only 7: return y
", + "type": "table", + "image_path": "1cc809589f51a34f27ff26fcb8db77db7b7e9bf7ddd2741fe757d13ad118b0b3.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 91, + 501, + 135.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 135.0, + 501, + 179.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 179.0, + 501, + 223.0 + ], + "spans": [], + "index": 2 + } + ] + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 108, + 231, + 502, + 264 + ], + "lines": [ + { + "bbox": [ + 106, + 231, + 504, + 243 + ], + "spans": [ + { + "bbox": [ + 106, + 231, + 381, + 243 + ], + "score": 1.0, + "content": "attempted to incorporate special cases of selection, such as letting", + "type": "text" + }, + { + "bbox": [ + 381, + 231, + 391, + 241 + ], + "score": 0.78, + "content": "\\Delta", + "type": "inline_equation" + }, + { + "bbox": [ + 391, + 231, + 504, + 243 + ], + "score": 1.0, + "content": "vary over time in recurrent", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 240, + 504, + 254 + ], + "spans": [ + { + "bbox": [ + 106, + 240, + 504, + 254 + ], + "score": 1.0, + "content": "SSMs (Gu et al., 2020a). However, this was computationally difficult, which was why S4 and all", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 252, + 487, + 265 + ], + "spans": [ + { + "bbox": [ + 106, + 252, + 487, + 265 + ], + "score": 1.0, + "content": "derivatives used LTI (non-selective) models, most commonly in the form of global convolutions.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 107, + 268, + 504, + 301 + ], + "lines": [ + { + "bbox": [ + 105, + 267, + 506, + 281 + ], + "spans": [ + { + "bbox": [ + 105, + 267, + 506, + 281 + ], + "score": 1.0, + "content": "The selection mechanism is designed to overcome the limitations of LTI models; at the same time,", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 279, + 505, + 291 + ], + "spans": [ + { + "bbox": [ + 106, + 279, + 505, + 291 + ], + "score": 1.0, + "content": "we therefore need to revisit the computation problem of SSMs. We address this with three classical", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 290, + 476, + 302 + ], + "spans": [ + { + "bbox": [ + 106, + 290, + 476, + 302 + ], + "score": 1.0, + "content": "techniques: kernel fusion, parallel scan, and recomputation. We make two main observations:", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 106, + 305, + 505, + 363 + ], + "lines": [ + { + "bbox": [ + 105, + 304, + 505, + 318 + ], + "spans": [ + { + "bbox": [ + 105, + 304, + 271, + 318 + ], + "score": 1.0, + "content": "• The naive recurrent computation uses", + "type": "text" + }, + { + "bbox": [ + 271, + 305, + 320, + 317 + ], + "score": 0.91, + "content": "O ( B L D N )", + "type": "inline_equation" + }, + { + "bbox": [ + 320, + 304, + 505, + 318 + ], + "score": 1.0, + "content": "FLOPs while the convolutional computation", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 114, + 316, + 505, + 329 + ], + "spans": [ + { + "bbox": [ + 114, + 316, + 134, + 329 + ], + "score": 1.0, + "content": "uses", + "type": "text" + }, + { + "bbox": [ + 135, + 316, + 201, + 328 + ], + "score": 0.86, + "content": "O ( B L D \\log ( L ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 201, + 316, + 505, + 329 + ], + "score": 1.0, + "content": "FLOPs, and the former has a lower constant factor. Thus for long sequences", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 114, + 327, + 460, + 339 + ], + "spans": [ + { + "bbox": [ + 114, + 327, + 249, + 339 + ], + "score": 1.0, + "content": "and not-too-large state dimension", + "type": "text" + }, + { + "bbox": [ + 249, + 327, + 259, + 337 + ], + "score": 0.78, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 259, + 327, + 460, + 339 + ], + "score": 1.0, + "content": ", the recurrent mode can actually use fewer FLOPs.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 339, + 505, + 353 + ], + "spans": [ + { + "bbox": [ + 106, + 339, + 505, + 353 + ], + "score": 1.0, + "content": "• The two challenges are the sequential nature of recurrence, and the large memory usage. To address", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 114, + 351, + 503, + 365 + ], + "spans": [ + { + "bbox": [ + 114, + 351, + 496, + 365 + ], + "score": 1.0, + "content": "the latter, just like the convolutional mode, we can attempt to not actually materialize the full state", + "type": "text" + }, + { + "bbox": [ + 496, + 352, + 503, + 361 + ], + "score": 0.74, + "content": "h", + "type": "inline_equation" + } + ], + "index": 13 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 107, + 367, + 505, + 422 + ], + "lines": [ + { + "bbox": [ + 106, + 367, + 504, + 379 + ], + "spans": [ + { + "bbox": [ + 106, + 367, + 496, + 379 + ], + "score": 1.0, + "content": "The main idea is to leverage properties of modern accelerators (GPUs) to materialize the state", + "type": "text" + }, + { + "bbox": [ + 497, + 367, + 504, + 377 + ], + "score": 0.71, + "content": "h", + "type": "inline_equation" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 378, + 505, + 390 + ], + "spans": [ + { + "bbox": [ + 106, + 378, + 505, + 390 + ], + "score": 1.0, + "content": "only in more efficient levels of the memory hierarchy. In particular, most operations (except matrix", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 388, + 505, + 400 + ], + "spans": [ + { + "bbox": [ + 105, + 388, + 505, + 400 + ], + "score": 1.0, + "content": "multiplication) are bounded by memory bandwidth (Williams et al., 2009; Ivanov et al., 2021; Dao", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 398, + 506, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 398, + 506, + 411 + ], + "score": 1.0, + "content": "et al., 2022). This includes our scan operation, and we use kernel fusion to reduce the amount of", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 410, + 447, + 422 + ], + "spans": [ + { + "bbox": [ + 105, + 410, + 447, + 422 + ], + "score": 1.0, + "content": "memory IOs, leading to a significant speedup compared to a standard implementation.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 107, + 426, + 505, + 460 + ], + "lines": [ + { + "bbox": [ + 106, + 426, + 505, + 439 + ], + "spans": [ + { + "bbox": [ + 106, + 426, + 287, + 439 + ], + "score": 1.0, + "content": "Concretely, instead of preparing the scan input", + "type": "text" + }, + { + "bbox": [ + 287, + 426, + 316, + 438 + ], + "score": 0.87, + "content": "( \\overline { { A } } , \\overline { { B } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 316, + 426, + 505, + 439 + ], + "score": 1.0, + "content": "of size (B,L,D,N) in GPU HBM (high-bandwidth", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 438, + 505, + 450 + ], + "spans": [ + { + "bbox": [ + 106, + 438, + 261, + 450 + ], + "score": 1.0, + "content": "memory), we load the SSM parameters", + "type": "text" + }, + { + "bbox": [ + 262, + 438, + 313, + 450 + ], + "score": 0.88, + "content": "( \\Delta , A , B , C )", + "type": "inline_equation" + }, + { + "bbox": [ + 313, + 438, + 505, + 450 + ], + "score": 1.0, + "content": "directly from slow HBM to fast SRAM, perform", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 448, + 507, + 461 + ], + "spans": [ + { + "bbox": [ + 105, + 448, + 507, + 461 + ], + "score": 1.0, + "content": "the discretization and recurrence in SRAM, and then write the final outputs of size (B,L,D) back to HBM.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 108, + 464, + 505, + 486 + ], + "lines": [ + { + "bbox": [ + 107, + 464, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 107, + 464, + 505, + 475 + ], + "score": 1.0, + "content": "To avoid the sequential recurrence, we observe that despite not being linear it can still be parallelized", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 473, + 506, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 506, + 487 + ], + "score": 1.0, + "content": "with a work-efficient parallel scan algorithm (Blelloch, 1990; Martin & Cundy, 2018; Smith et al., 2023).", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 107, + 491, + 505, + 534 + ], + "lines": [ + { + "bbox": [ + 105, + 491, + 507, + 504 + ], + "spans": [ + { + "bbox": [ + 105, + 491, + 507, + 504 + ], + "score": 1.0, + "content": "Finally, we must also avoid saving the intermediate states, which are necessary for backpropagation.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 501, + 506, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 501, + 506, + 514 + ], + "score": 1.0, + "content": "We carefully apply the classic technique of recomputation to reduce the memory requirements: the", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 513, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 513, + 505, + 525 + ], + "score": 1.0, + "content": "intermediate states are not stored but recomputed in the backward pass when the inputs are loaded", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 523, + 454, + 536 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 454, + 536 + ], + "score": 1.0, + "content": "from HBM to SRAM. Details of the fused kernel and recomputation are in Appendix D.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 25.5 + }, + { + "type": "title", + "bbox": [ + 108, + 544, + 284, + 555 + ], + "lines": [ + { + "bbox": [ + 106, + 544, + 286, + 556 + ], + "spans": [ + { + "bbox": [ + 106, + 544, + 286, + 556 + ], + "score": 1.0, + "content": "3.4 A SIMPLIFIED SSM ARCHITECTURE", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 107, + 560, + 505, + 614 + ], + "lines": [ + { + "bbox": [ + 106, + 560, + 505, + 572 + ], + "spans": [ + { + "bbox": [ + 106, + 560, + 505, + 572 + ], + "score": 1.0, + "content": "As with structured SSMs, selective SSMs are standalone sequence transformations that can be flexibly", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 571, + 505, + 583 + ], + "spans": [ + { + "bbox": [ + 106, + 571, + 505, + 583 + ], + "score": 1.0, + "content": "incorporated into neural networks. The H3 architecture is the basis for the most well-known SSM", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 582, + 505, + 595 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 505, + 595 + ], + "score": 1.0, + "content": "architectures (Section 2), which are generally comprised of a block inspired by linear attention", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 590, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 590, + 505, + 606 + ], + "score": 1.0, + "content": "interleaved with an MLP (multi-layer perceptron) block. We simplify this architecture by combining", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 603, + 404, + 617 + ], + "spans": [ + { + "bbox": [ + 106, + 603, + 404, + 617 + ], + "score": 1.0, + "content": "these two components into one, which is stacked homogenously (Figure 2).", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 107, + 619, + 505, + 662 + ], + "lines": [ + { + "bbox": [ + 105, + 618, + 503, + 631 + ], + "spans": [ + { + "bbox": [ + 105, + 618, + 344, + 631 + ], + "score": 1.0, + "content": "This architecture involves expanding the model dimension", + "type": "text" + }, + { + "bbox": [ + 344, + 619, + 354, + 629 + ], + "score": 0.75, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 354, + 618, + 494, + 631 + ], + "score": 1.0, + "content": "by a controllable expansion factor", + "type": "text" + }, + { + "bbox": [ + 494, + 619, + 503, + 629 + ], + "score": 0.79, + "content": "E", + "type": "inline_equation" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 629, + 506, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 629, + 269, + 642 + ], + "score": 1.0, + "content": "For each block, most of the parameters", + "type": "text" + }, + { + "bbox": [ + 269, + 630, + 302, + 641 + ], + "score": 0.9, + "content": "( 3 E D ^ { 2 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 302, + 629, + 506, + 642 + ], + "score": 1.0, + "content": "are in the linear projections while the inner SSM", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 641, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 106, + 641, + 241, + 653 + ], + "score": 1.0, + "content": "contributes less. We always fix to", + "type": "text" + }, + { + "bbox": [ + 241, + 641, + 266, + 650 + ], + "score": 0.9, + "content": "E = 2", + "type": "inline_equation" + }, + { + "bbox": [ + 266, + 641, + 505, + 653 + ], + "score": 1.0, + "content": "in our experiments and use two stacks of the block to match", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 650, + 496, + 664 + ], + "spans": [ + { + "bbox": [ + 105, + 650, + 120, + 664 + ], + "score": 1.0, + "content": "the", + "type": "text" + }, + { + "bbox": [ + 121, + 650, + 145, + 661 + ], + "score": 0.89, + "content": "1 2 D ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 650, + 496, + 664 + ], + "score": 1.0, + "content": "parameters of a Transformer’s interleaved MHA (multi-head attention) and MLP blocks.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35.5 + }, + { + "type": "title", + "bbox": [ + 107, + 672, + 310, + 684 + ], + "lines": [ + { + "bbox": [ + 105, + 671, + 312, + 685 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 312, + 685 + ], + "score": 1.0, + "content": "3.5 PROPERTIES OF SELECTION MECHANISMS", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 38 + }, + { + "type": "text", + "bbox": [ + 108, + 689, + 505, + 731 + ], + "lines": [ + { + "bbox": [ + 106, + 688, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 506, + 702 + ], + "score": 1.0, + "content": "The selection mechanism is a broader concept that can be applied in different ways, such as to", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 355, + 712 + ], + "score": 1.0, + "content": "more traditional RNNs or CNNs, to different parameters (e.g.", + "type": "text" + }, + { + "bbox": [ + 356, + 700, + 365, + 709 + ], + "score": 0.63, + "content": "\\pmb { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 699, + 506, + 712 + ], + "score": 1.0, + "content": "in Algorithm 2), or using different", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 170, + 722 + ], + "score": 1.0, + "content": "transformations", + "type": "text" + }, + { + "bbox": [ + 171, + 710, + 189, + 722 + ], + "score": 0.92, + "content": "s ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 190, + 709, + 505, + 722 + ], + "score": 1.0, + "content": ". We highlight the most important connection: the classical gating mechanism of", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 720, + 505, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 505, + 732 + ], + "score": 1.0, + "content": "RNNs is an instance of our selection mechanism for SSMs. We note that the connection between RNN", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 40.5 + } + ], + "page_idx": 4, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 303, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 305, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 305, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "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": "table", + "bbox": [ + 106, + 91, + 501, + 223 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 106, + 91, + 501, + 223 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 91, + 501, + 223 + ], + "spans": [ + { + "bbox": [ + 106, + 91, + 501, + 223 + ], + "score": 0.956, + "html": "
Algorithm 1 SSM (S4)Algorithm 2 SSM + Selection (S6)
Input: x : (B,L,D)Input: x : (B,L,D)
Output: y:(B,L,D)Output: y: (B,L,D)
1:A:(D,N)←Parameter1:A:(D,N)←Parameter
Represents structured N × N matrix>Represents structured N × N matrix
2:B:(D,N)←Parameter2: B:(B,L,N)← SB(𝑥)
3: C:(D,N)←Parameter 3: C:(B,L,N)←sc(x)
4:△:(D)←T△(Parameter)4: △:(B,L,D)←T△(Parameter+s△(x))
5: A,B:(D,N)←discretize(△,A,B) 5: A,B:(B,L,D,N)←discretize(△,A,B)
6: y←SSM(A,B,C)(x)6: y←SSM(A,B,C)(x)
> Time-invariant: recurrence or convolution 7: return yTime-varying: recurrence (scan) only 7: return y
", + "type": "table", + "image_path": "1cc809589f51a34f27ff26fcb8db77db7b7e9bf7ddd2741fe757d13ad118b0b3.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 91, + 501, + 135.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 135.0, + 501, + 179.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 179.0, + 501, + 223.0 + ], + "spans": [], + "index": 2 + } + ] + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 108, + 231, + 502, + 264 + ], + "lines": [], + "index": 4, + "bbox_fs": [ + 106, + 231, + 504, + 265 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 268, + 504, + 301 + ], + "lines": [ + { + "bbox": [ + 105, + 267, + 506, + 281 + ], + "spans": [ + { + "bbox": [ + 105, + 267, + 506, + 281 + ], + "score": 1.0, + "content": "The selection mechanism is designed to overcome the limitations of LTI models; at the same time,", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 279, + 505, + 291 + ], + "spans": [ + { + "bbox": [ + 106, + 279, + 505, + 291 + ], + "score": 1.0, + "content": "we therefore need to revisit the computation problem of SSMs. We address this with three classical", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 290, + 476, + 302 + ], + "spans": [ + { + "bbox": [ + 106, + 290, + 476, + 302 + ], + "score": 1.0, + "content": "techniques: kernel fusion, parallel scan, and recomputation. We make two main observations:", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7, + "bbox_fs": [ + 105, + 267, + 506, + 302 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 305, + 505, + 363 + ], + "lines": [ + { + "bbox": [ + 105, + 304, + 505, + 318 + ], + "spans": [ + { + "bbox": [ + 105, + 304, + 271, + 318 + ], + "score": 1.0, + "content": "• The naive recurrent computation uses", + "type": "text" + }, + { + "bbox": [ + 271, + 305, + 320, + 317 + ], + "score": 0.91, + "content": "O ( B L D N )", + "type": "inline_equation" + }, + { + "bbox": [ + 320, + 304, + 505, + 318 + ], + "score": 1.0, + "content": "FLOPs while the convolutional computation", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 114, + 316, + 505, + 329 + ], + "spans": [ + { + "bbox": [ + 114, + 316, + 134, + 329 + ], + "score": 1.0, + "content": "uses", + "type": "text" + }, + { + "bbox": [ + 135, + 316, + 201, + 328 + ], + "score": 0.86, + "content": "O ( B L D \\log ( L ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 201, + 316, + 505, + 329 + ], + "score": 1.0, + "content": "FLOPs, and the former has a lower constant factor. Thus for long sequences", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 114, + 327, + 460, + 339 + ], + "spans": [ + { + "bbox": [ + 114, + 327, + 249, + 339 + ], + "score": 1.0, + "content": "and not-too-large state dimension", + "type": "text" + }, + { + "bbox": [ + 249, + 327, + 259, + 337 + ], + "score": 0.78, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 259, + 327, + 460, + 339 + ], + "score": 1.0, + "content": ", the recurrent mode can actually use fewer FLOPs.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 339, + 505, + 353 + ], + "spans": [ + { + "bbox": [ + 106, + 339, + 505, + 353 + ], + "score": 1.0, + "content": "• The two challenges are the sequential nature of recurrence, and the large memory usage. To address", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 114, + 351, + 503, + 365 + ], + "spans": [ + { + "bbox": [ + 114, + 351, + 496, + 365 + ], + "score": 1.0, + "content": "the latter, just like the convolutional mode, we can attempt to not actually materialize the full state", + "type": "text" + }, + { + "bbox": [ + 496, + 352, + 503, + 361 + ], + "score": 0.74, + "content": "h", + "type": "inline_equation" + } + ], + "index": 13 + } + ], + "index": 11, + "bbox_fs": [ + 105, + 304, + 505, + 365 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 367, + 505, + 422 + ], + "lines": [ + { + "bbox": [ + 106, + 367, + 504, + 379 + ], + "spans": [ + { + "bbox": [ + 106, + 367, + 496, + 379 + ], + "score": 1.0, + "content": "The main idea is to leverage properties of modern accelerators (GPUs) to materialize the state", + "type": "text" + }, + { + "bbox": [ + 497, + 367, + 504, + 377 + ], + "score": 0.71, + "content": "h", + "type": "inline_equation" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 378, + 505, + 390 + ], + "spans": [ + { + "bbox": [ + 106, + 378, + 505, + 390 + ], + "score": 1.0, + "content": "only in more efficient levels of the memory hierarchy. In particular, most operations (except matrix", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 388, + 505, + 400 + ], + "spans": [ + { + "bbox": [ + 105, + 388, + 505, + 400 + ], + "score": 1.0, + "content": "multiplication) are bounded by memory bandwidth (Williams et al., 2009; Ivanov et al., 2021; Dao", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 398, + 506, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 398, + 506, + 411 + ], + "score": 1.0, + "content": "et al., 2022). This includes our scan operation, and we use kernel fusion to reduce the amount of", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 410, + 447, + 422 + ], + "spans": [ + { + "bbox": [ + 105, + 410, + 447, + 422 + ], + "score": 1.0, + "content": "memory IOs, leading to a significant speedup compared to a standard implementation.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 16, + "bbox_fs": [ + 105, + 367, + 506, + 422 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 426, + 505, + 460 + ], + "lines": [ + { + "bbox": [ + 106, + 426, + 505, + 439 + ], + "spans": [ + { + "bbox": [ + 106, + 426, + 287, + 439 + ], + "score": 1.0, + "content": "Concretely, instead of preparing the scan input", + "type": "text" + }, + { + "bbox": [ + 287, + 426, + 316, + 438 + ], + "score": 0.87, + "content": "( \\overline { { A } } , \\overline { { B } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 316, + 426, + 505, + 439 + ], + "score": 1.0, + "content": "of size (B,L,D,N) in GPU HBM (high-bandwidth", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 438, + 505, + 450 + ], + "spans": [ + { + "bbox": [ + 106, + 438, + 261, + 450 + ], + "score": 1.0, + "content": "memory), we load the SSM parameters", + "type": "text" + }, + { + "bbox": [ + 262, + 438, + 313, + 450 + ], + "score": 0.88, + "content": "( \\Delta , A , B , C )", + "type": "inline_equation" + }, + { + "bbox": [ + 313, + 438, + 505, + 450 + ], + "score": 1.0, + "content": "directly from slow HBM to fast SRAM, perform", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 448, + 507, + 461 + ], + "spans": [ + { + "bbox": [ + 105, + 448, + 507, + 461 + ], + "score": 1.0, + "content": "the discretization and recurrence in SRAM, and then write the final outputs of size (B,L,D) back to HBM.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20, + "bbox_fs": [ + 105, + 426, + 507, + 461 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 464, + 505, + 486 + ], + "lines": [ + { + "bbox": [ + 107, + 464, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 107, + 464, + 505, + 475 + ], + "score": 1.0, + "content": "To avoid the sequential recurrence, we observe that despite not being linear it can still be parallelized", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 473, + 506, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 473, + 506, + 487 + ], + "score": 1.0, + "content": "with a work-efficient parallel scan algorithm (Blelloch, 1990; Martin & Cundy, 2018; Smith et al., 2023).", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5, + "bbox_fs": [ + 105, + 464, + 506, + 487 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 491, + 505, + 534 + ], + "lines": [ + { + "bbox": [ + 105, + 491, + 507, + 504 + ], + "spans": [ + { + "bbox": [ + 105, + 491, + 507, + 504 + ], + "score": 1.0, + "content": "Finally, we must also avoid saving the intermediate states, which are necessary for backpropagation.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 501, + 506, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 501, + 506, + 514 + ], + "score": 1.0, + "content": "We carefully apply the classic technique of recomputation to reduce the memory requirements: the", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 513, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 513, + 505, + 525 + ], + "score": 1.0, + "content": "intermediate states are not stored but recomputed in the backward pass when the inputs are loaded", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 523, + 454, + 536 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 454, + 536 + ], + "score": 1.0, + "content": "from HBM to SRAM. Details of the fused kernel and recomputation are in Appendix D.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 25.5, + "bbox_fs": [ + 105, + 491, + 507, + 536 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 544, + 284, + 555 + ], + "lines": [ + { + "bbox": [ + 106, + 544, + 286, + 556 + ], + "spans": [ + { + "bbox": [ + 106, + 544, + 286, + 556 + ], + "score": 1.0, + "content": "3.4 A SIMPLIFIED SSM ARCHITECTURE", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 107, + 560, + 505, + 614 + ], + "lines": [ + { + "bbox": [ + 106, + 560, + 505, + 572 + ], + "spans": [ + { + "bbox": [ + 106, + 560, + 505, + 572 + ], + "score": 1.0, + "content": "As with structured SSMs, selective SSMs are standalone sequence transformations that can be flexibly", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 571, + 505, + 583 + ], + "spans": [ + { + "bbox": [ + 106, + 571, + 505, + 583 + ], + "score": 1.0, + "content": "incorporated into neural networks. The H3 architecture is the basis for the most well-known SSM", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 582, + 505, + 595 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 505, + 595 + ], + "score": 1.0, + "content": "architectures (Section 2), which are generally comprised of a block inspired by linear attention", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 590, + 505, + 606 + ], + "spans": [ + { + "bbox": [ + 105, + 590, + 505, + 606 + ], + "score": 1.0, + "content": "interleaved with an MLP (multi-layer perceptron) block. We simplify this architecture by combining", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 603, + 404, + 617 + ], + "spans": [ + { + "bbox": [ + 106, + 603, + 404, + 617 + ], + "score": 1.0, + "content": "these two components into one, which is stacked homogenously (Figure 2).", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 31, + "bbox_fs": [ + 105, + 560, + 505, + 617 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 619, + 505, + 662 + ], + "lines": [ + { + "bbox": [ + 105, + 618, + 503, + 631 + ], + "spans": [ + { + "bbox": [ + 105, + 618, + 344, + 631 + ], + "score": 1.0, + "content": "This architecture involves expanding the model dimension", + "type": "text" + }, + { + "bbox": [ + 344, + 619, + 354, + 629 + ], + "score": 0.75, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 354, + 618, + 494, + 631 + ], + "score": 1.0, + "content": "by a controllable expansion factor", + "type": "text" + }, + { + "bbox": [ + 494, + 619, + 503, + 629 + ], + "score": 0.79, + "content": "E", + "type": "inline_equation" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 629, + 506, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 629, + 269, + 642 + ], + "score": 1.0, + "content": "For each block, most of the parameters", + "type": "text" + }, + { + "bbox": [ + 269, + 630, + 302, + 641 + ], + "score": 0.9, + "content": "( 3 E D ^ { 2 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 302, + 629, + 506, + 642 + ], + "score": 1.0, + "content": "are in the linear projections while the inner SSM", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 641, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 106, + 641, + 241, + 653 + ], + "score": 1.0, + "content": "contributes less. We always fix to", + "type": "text" + }, + { + "bbox": [ + 241, + 641, + 266, + 650 + ], + "score": 0.9, + "content": "E = 2", + "type": "inline_equation" + }, + { + "bbox": [ + 266, + 641, + 505, + 653 + ], + "score": 1.0, + "content": "in our experiments and use two stacks of the block to match", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 650, + 496, + 664 + ], + "spans": [ + { + "bbox": [ + 105, + 650, + 120, + 664 + ], + "score": 1.0, + "content": "the", + "type": "text" + }, + { + "bbox": [ + 121, + 650, + 145, + 661 + ], + "score": 0.89, + "content": "1 2 D ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 145, + 650, + 496, + 664 + ], + "score": 1.0, + "content": "parameters of a Transformer’s interleaved MHA (multi-head attention) and MLP blocks.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35.5, + "bbox_fs": [ + 105, + 618, + 506, + 664 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 672, + 310, + 684 + ], + "lines": [ + { + "bbox": [ + 105, + 671, + 312, + 685 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 312, + 685 + ], + "score": 1.0, + "content": "3.5 PROPERTIES OF SELECTION MECHANISMS", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 38 + }, + { + "type": "text", + "bbox": [ + 108, + 689, + 505, + 731 + ], + "lines": [ + { + "bbox": [ + 106, + 688, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 506, + 702 + ], + "score": 1.0, + "content": "The selection mechanism is a broader concept that can be applied in different ways, such as to", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 355, + 712 + ], + "score": 1.0, + "content": "more traditional RNNs or CNNs, to different parameters (e.g.", + "type": "text" + }, + { + "bbox": [ + 356, + 700, + 365, + 709 + ], + "score": 0.63, + "content": "\\pmb { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 365, + 699, + 506, + 712 + ], + "score": 1.0, + "content": "in Algorithm 2), or using different", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 170, + 722 + ], + "score": 1.0, + "content": "transformations", + "type": "text" + }, + { + "bbox": [ + 171, + 710, + 189, + 722 + ], + "score": 0.92, + "content": "s ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 190, + 709, + 505, + 722 + ], + "score": 1.0, + "content": ". We highlight the most important connection: the classical gating mechanism of", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 720, + 505, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 505, + 732 + ], + "score": 1.0, + "content": "RNNs is an instance of our selection mechanism for SSMs. We note that the connection between RNN", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 261, + 507, + 274 + ], + "spans": [ + { + "bbox": [ + 105, + 261, + 507, + 274 + ], + "score": 1.0, + "content": "gating and the discretization of continuous-time systems is well established (Funahashi & Nakamura,", + "type": "text", + "cross_page": true + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 271, + 506, + 284 + ], + "spans": [ + { + "bbox": [ + 105, + 271, + 506, + 284 + ], + "score": 1.0, + "content": "1993; Tallec & Ollivier, 2018). In fact, Theorem 1 is an improvement of Gu et al. (2021, Lemma", + "type": "text", + "cross_page": true + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 282, + 505, + 295 + ], + "spans": [ + { + "bbox": [ + 105, + 282, + 505, + 295 + ], + "score": 1.0, + "content": "3.1) generalizing to the ZOH discretization and input-dependent gates (proof in Appendix C). More", + "type": "text", + "cross_page": true + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 293, + 459, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 293, + 141, + 306 + ], + "score": 1.0, + "content": "broadly,", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 141, + 294, + 150, + 303 + ], + "score": 0.8, + "content": "\\Delta", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 151, + 293, + 459, + 306 + ], + "score": 1.0, + "content": "in SSMs can be seen to play a generalized role of the RNN gating mechanism.", + "type": "text", + "cross_page": true + } + ], + "index": 11 + } + ], + "index": 40.5, + "bbox_fs": [ + 105, + 688, + 506, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 156, + 80, + 455, + 198 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 156, + 80, + 455, + 198 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 156, + 80, + 455, + 198 + ], + "spans": [ + { + "bbox": [ + 156, + 80, + 455, + 198 + ], + "score": 0.974, + "type": "image", + "image_path": "5fd969173aa404aa9688b66726cef87ddc5376286f900bcca5dcb0b9ddb454db.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 156, + 80, + 455, + 119.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 156, + 119.33333333333334, + 455, + 158.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 156, + 158.66666666666669, + 455, + 198.00000000000003 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 207, + 505, + 257 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 208, + 505, + 218 + ], + "spans": [ + { + "bbox": [ + 106, + 208, + 505, + 218 + ], + "score": 1.0, + "content": "Figure 2: (Architecture.) Our simplified block design combines the H3 block, which is the basis of most SSM", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 216, + 505, + 228 + ], + "spans": [ + { + "bbox": [ + 105, + 216, + 505, + 228 + ], + "score": 1.0, + "content": "architectures, with the ubiquitous MLP block of modern neural networks. Instead of interleaving these two", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 227, + 506, + 238 + ], + "spans": [ + { + "bbox": [ + 106, + 227, + 506, + 238 + ], + "score": 1.0, + "content": "blocks, we simply repeat the Mamba block homogenously. Compared to the H3 block, Mamba replaces the first", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 237, + 505, + 248 + ], + "spans": [ + { + "bbox": [ + 106, + 237, + 505, + 248 + ], + "score": 1.0, + "content": "multiplicative gate with an activation function. Compared to the MLP block, Mamba adds an SSM to the main", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 246, + 488, + 258 + ], + "spans": [ + { + "bbox": [ + 106, + 246, + 149, + 258 + ], + "score": 1.0, + "content": "branch. For", + "type": "text" + }, + { + "bbox": [ + 150, + 249, + 156, + 256 + ], + "score": 0.76, + "content": "\\sigma", + "type": "inline_equation" + }, + { + "bbox": [ + 157, + 246, + 488, + 258 + ], + "score": 1.0, + "content": "we use the SiLU / Swish activation (Hendrycks & Gimpel, 2016; Ramachandran et al., 2017).", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5 + } + ], + "index": 3.0 + }, + { + "type": "text", + "bbox": [ + 107, + 261, + 505, + 305 + ], + "lines": [ + { + "bbox": [ + 105, + 261, + 507, + 274 + ], + "spans": [ + { + "bbox": [ + 105, + 261, + 507, + 274 + ], + "score": 1.0, + "content": "gating and the discretization of continuous-time systems is well established (Funahashi & Nakamura,", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 271, + 506, + 284 + ], + "spans": [ + { + "bbox": [ + 105, + 271, + 506, + 284 + ], + "score": 1.0, + "content": "1993; Tallec & Ollivier, 2018). In fact, Theorem 1 is an improvement of Gu et al. (2021, Lemma", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 282, + 505, + 295 + ], + "spans": [ + { + "bbox": [ + 105, + 282, + 505, + 295 + ], + "score": 1.0, + "content": "3.1) generalizing to the ZOH discretization and input-dependent gates (proof in Appendix C). More", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 293, + 459, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 293, + 141, + 306 + ], + "score": 1.0, + "content": "broadly,", + "type": "text" + }, + { + "bbox": [ + 141, + 294, + 150, + 303 + ], + "score": 0.8, + "content": "\\Delta", + "type": "inline_equation" + }, + { + "bbox": [ + 151, + 293, + 459, + 306 + ], + "score": 1.0, + "content": "in SSMs can be seen to play a generalized role of the RNN gating mechanism.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 9.5 + }, + { + "type": "text", + "bbox": [ + 105, + 308, + 505, + 331 + ], + "lines": [ + { + "bbox": [ + 105, + 307, + 506, + 321 + ], + "spans": [ + { + "bbox": [ + 105, + 307, + 185, + 321 + ], + "score": 1.0, + "content": "Theorem 1. When", + "type": "text" + }, + { + "bbox": [ + 186, + 308, + 334, + 319 + ], + "score": 0.77, + "content": "N = 1 , \\pmb { A } = - 1 , \\pmb { B } = 1 , s _ { \\Delta } = \\mathsf { L i n e a r } ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 307, + 355, + 321 + ], + "score": 1.0, + "content": ", and", + "type": "text" + }, + { + "bbox": [ + 355, + 309, + 377, + 319 + ], + "score": 0.87, + "content": "\\tau _ { \\Delta } =", + "type": "inline_equation" + }, + { + "bbox": [ + 377, + 307, + 506, + 321 + ], + "score": 1.0, + "content": "softplus, then the selective SSM", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 318, + 503, + 333 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 265, + 333 + ], + "score": 1.0, + "content": "recurrence (Algorithm 2) takes the form", + "type": "text" + }, + { + "bbox": [ + 266, + 320, + 342, + 331 + ], + "score": 0.82, + "content": "g _ { k } { = } \\sigma ( { \\mathsf { L i n e a r } } ( x _ { k } ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 343, + 318, + 400, + 333 + ], + "score": 1.0, + "content": "(the gate) and", + "type": "text" + }, + { + "bbox": [ + 401, + 319, + 503, + 331 + ], + "score": 0.93, + "content": "h _ { k } = ( 1 - g _ { k } ) h _ { k - 1 } + g _ { k } x _ { k }", + "type": "inline_equation" + } + ], + "index": 13 + } + ], + "index": 12.5 + }, + { + "type": "text", + "bbox": [ + 107, + 338, + 505, + 393 + ], + "lines": [ + { + "bbox": [ + 106, + 338, + 506, + 352 + ], + "spans": [ + { + "bbox": [ + 106, + 338, + 321, + 352 + ], + "score": 1.0, + "content": "As mentioned in Section 3.2, our specific choices of", + "type": "text" + }, + { + "bbox": [ + 322, + 341, + 349, + 350 + ], + "score": 0.9, + "content": "s \\Delta , \\tau _ { \\Delta }", + "type": "inline_equation" + }, + { + "bbox": [ + 349, + 338, + 506, + 352 + ], + "score": 1.0, + "content": "is from this connection. In particular,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 349, + 505, + 362 + ], + "spans": [ + { + "bbox": [ + 105, + 349, + 207, + 362 + ], + "score": 1.0, + "content": "note that if a given input", + "type": "text" + }, + { + "bbox": [ + 208, + 351, + 219, + 361 + ], + "score": 0.86, + "content": "x _ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 220, + 349, + 505, + 362 + ], + "score": 1.0, + "content": "should be completely ignored (as necessary in the synthetic tasks), all", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 107, + 360, + 506, + 373 + ], + "spans": [ + { + "bbox": [ + 107, + 361, + 116, + 370 + ], + "score": 0.78, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 117, + 360, + 506, + 373 + ], + "score": 1.0, + "content": "channels should ignore it, and so we project the input down to 1 dimension before broadcasting with", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 370, + 507, + 384 + ], + "spans": [ + { + "bbox": [ + 106, + 372, + 115, + 381 + ], + "score": 0.72, + "content": "\\Delta", + "type": "inline_equation" + }, + { + "bbox": [ + 115, + 370, + 261, + 384 + ], + "score": 1.0, + "content": ". Finally, we observe that the function", + "type": "text" + }, + { + "bbox": [ + 261, + 371, + 380, + 383 + ], + "score": 0.85, + "content": "s \\bar { \\Delta ( x ) } = \\mathsf { L i n e a r } _ { D } ( \\mathsf { L i n e a r } _ { 1 } ( x ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 370, + 507, + 384 + ], + "score": 1.0, + "content": "is simply a low-rank projection,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 381, + 461, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 381, + 461, + 394 + ], + "score": 1.0, + "content": "and relax the 1 dimension to a larger dimension R, generally set to be a small fraction of D.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 106, + 397, + 356, + 408 + ], + "lines": [ + { + "bbox": [ + 106, + 397, + 356, + 410 + ], + "spans": [ + { + "bbox": [ + 106, + 397, + 356, + 410 + ], + "score": 1.0, + "content": "We elaborate on two particular mechanistic effects of selection.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 106, + 413, + 505, + 468 + ], + "lines": [ + { + "bbox": [ + 106, + 414, + 505, + 425 + ], + "spans": [ + { + "bbox": [ + 106, + 414, + 505, + 425 + ], + "score": 1.0, + "content": "Variable spacing. Selectivity allows filtering out irrelevant noise tokens that may occur between inputs", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 423, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 505, + 437 + ], + "score": 1.0, + "content": "of interest. This is exemplified by the Selective Copying task, but occurs ubiquitously in common", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 434, + 506, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 434, + 506, + 447 + ], + "score": 1.0, + "content": "data modalities, particularly for discrete data – for example the presence of language fillers such as", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 104, + 443, + 507, + 460 + ], + "spans": [ + { + "bbox": [ + 104, + 443, + 490, + 460 + ], + "score": 1.0, + "content": "“um”. This property arises because the model can mechanistically filter out any particular input", + "type": "text" + }, + { + "bbox": [ + 491, + 447, + 502, + 457 + ], + "score": 0.85, + "content": "x _ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 443, + 507, + 460 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 456, + 353, + 469 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 320, + 469 + ], + "score": 1.0, + "content": "for example in the gated RNN case (Theorem 1) when", + "type": "text" + }, + { + "bbox": [ + 321, + 457, + 348, + 468 + ], + "score": 0.9, + "content": "g _ { k } \\to 0", + "type": "inline_equation" + }, + { + "bbox": [ + 349, + 456, + 353, + 469 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 106, + 472, + 505, + 537 + ], + "lines": [ + { + "bbox": [ + 105, + 471, + 505, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 505, + 484 + ], + "score": 1.0, + "content": "Filtering context. It has been empirically observed that many sequence models do not improve with", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 482, + 506, + 495 + ], + "spans": [ + { + "bbox": [ + 106, + 482, + 506, + 495 + ], + "score": 1.0, + "content": "longer context (Shi et al., 2023a), despite the principle that more context should lead to strictly better", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 493, + 506, + 506 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 506, + 506 + ], + "score": 1.0, + "content": "performance. An explanation is that many sequence models cannot effectively ignore irrelevant context", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 504, + 506, + 516 + ], + "spans": [ + { + "bbox": [ + 105, + 504, + 506, + 516 + ], + "score": 1.0, + "content": "when necessary; an intuitive example are global convolutions (and general LTI models). On the other", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 514, + 505, + 527 + ], + "spans": [ + { + "bbox": [ + 105, + 514, + 505, + 527 + ], + "score": 1.0, + "content": "hand, selective models can simply reset their state at any time to remove extraneous history, and thus", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 525, + 485, + 538 + ], + "spans": [ + { + "bbox": [ + 106, + 525, + 485, + 538 + ], + "score": 1.0, + "content": "their performance in principle improves monotonicly with context length (e.g. Appendix E.2.2).", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 27.5 + }, + { + "type": "text", + "bbox": [ + 107, + 541, + 505, + 588 + ], + "lines": [ + { + "bbox": [ + 106, + 542, + 505, + 554 + ], + "spans": [ + { + "bbox": [ + 106, + 542, + 210, + 554 + ], + "score": 1.0, + "content": "We remark that while the", + "type": "text" + }, + { + "bbox": [ + 211, + 542, + 221, + 551 + ], + "score": 0.68, + "content": "\\pmb { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 221, + 542, + 505, + 554 + ], + "score": 1.0, + "content": "parameter could also be selective, it ultimately affects the model only", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 552, + 505, + 566 + ], + "spans": [ + { + "bbox": [ + 105, + 553, + 215, + 566 + ], + "score": 1.0, + "content": "through its interaction with", + "type": "text" + }, + { + "bbox": [ + 216, + 554, + 225, + 563 + ], + "score": 0.8, + "content": "\\Delta", + "type": "inline_equation" + }, + { + "bbox": [ + 225, + 553, + 240, + 566 + ], + "score": 1.0, + "content": "via", + "type": "text" + }, + { + "bbox": [ + 240, + 552, + 299, + 565 + ], + "score": 0.93, + "content": "\\overline { { A } } = \\exp ( \\Delta A )", + "type": "inline_equation" + }, + { + "bbox": [ + 300, + 553, + 454, + 566 + ], + "score": 1.0, + "content": "(the discretization). Thus selectivity in", + "type": "text" + }, + { + "bbox": [ + 454, + 554, + 464, + 564 + ], + "score": 0.77, + "content": "\\Delta", + "type": "inline_equation" + }, + { + "bbox": [ + 464, + 553, + 505, + 566 + ], + "score": 1.0, + "content": "is enough", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 564, + 504, + 578 + ], + "spans": [ + { + "bbox": [ + 106, + 566, + 195, + 578 + ], + "score": 1.0, + "content": "to ensure selectivity in", + "type": "text" + }, + { + "bbox": [ + 196, + 564, + 224, + 578 + ], + "score": 0.9, + "content": "( \\overline { { A } } , \\overline { { B } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 225, + 566, + 494, + 578 + ], + "score": 1.0, + "content": ", and is the main source of improvement. We hypothesize that making", + "type": "text" + }, + { + "bbox": [ + 494, + 566, + 504, + 576 + ], + "score": 0.56, + "content": "\\pmb { A }", + "type": "inline_equation" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 575, + 507, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 575, + 251, + 590 + ], + "score": 1.0, + "content": "selective in addition to (or instead of)", + "type": "text" + }, + { + "bbox": [ + 252, + 577, + 261, + 586 + ], + "score": 0.79, + "content": "\\Delta", + "type": "inline_equation" + }, + { + "bbox": [ + 261, + 575, + 507, + 590 + ], + "score": 1.0, + "content": "would have similar performance, and leave it out for simplicity.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 106, + 591, + 504, + 613 + ], + "lines": [ + { + "bbox": [ + 106, + 590, + 505, + 604 + ], + "spans": [ + { + "bbox": [ + 106, + 590, + 505, + 604 + ], + "score": 1.0, + "content": "Remark 3.1. For brevity in our experimental results, we sometimes abbreviate selective SSMs as", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 601, + 478, + 615 + ], + "spans": [ + { + "bbox": [ + 105, + 601, + 219, + 615 + ], + "score": 1.0, + "content": "S6 models, because they are", + "type": "text" + }, + { + "bbox": [ + 219, + 603, + 231, + 612 + ], + "score": 0.38, + "content": "S 4", + "type": "inline_equation" + }, + { + "bbox": [ + 231, + 601, + 478, + 615 + ], + "score": 1.0, + "content": "models with a selection mechanism and computed with a scan.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35.5 + }, + { + "type": "title", + "bbox": [ + 108, + 623, + 254, + 636 + ], + "lines": [ + { + "bbox": [ + 105, + 622, + 255, + 638 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 255, + 638 + ], + "score": 1.0, + "content": "4 EMPIRICAL EVALUATION", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 107, + 642, + 505, + 675 + ], + "lines": [ + { + "bbox": [ + 105, + 641, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 641, + 505, + 654 + ], + "score": 1.0, + "content": "Mamba achieves state-of-the-art results on the synthetic tasks (Section 4.1) and three different domains", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 651, + 506, + 666 + ], + "spans": [ + { + "bbox": [ + 105, + 651, + 506, + 666 + ], + "score": 1.0, + "content": "(language, DNA, audio) (Sections 4.2 to 4.4) on both pretraining and downstream tasks, while being", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 663, + 283, + 675 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 283, + 675 + ], + "score": 1.0, + "content": "very computationally efficient (Section 4.5).", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39 + }, + { + "type": "title", + "bbox": [ + 107, + 683, + 212, + 694 + ], + "lines": [ + { + "bbox": [ + 105, + 681, + 213, + 696 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 213, + 696 + ], + "score": 1.0, + "content": "4.1 SYNTHETIC TASKS", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 107, + 699, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "score": 1.0, + "content": "Table 1 and Figure 3 show results for the synthetic tasks. On Selective Copying, the selective SSM layer", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 711, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 711, + 505, + 721 + ], + "score": 1.0, + "content": "is enough to solve the task independently of the architecture used, while previous LTI SSMs cannot even", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 721, + 505, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 505, + 732 + ], + "score": 1.0, + "content": "when combined with more powerful architectures. On Induction Heads, Mamba learns the task perfectly", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43 + } + ], + "page_idx": 5, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 304, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 305, + 39 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 305, + 39 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "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": "image", + "bbox": [ + 156, + 80, + 455, + 198 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 156, + 80, + 455, + 198 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 156, + 80, + 455, + 198 + ], + "spans": [ + { + "bbox": [ + 156, + 80, + 455, + 198 + ], + "score": 0.974, + "type": "image", + "image_path": "5fd969173aa404aa9688b66726cef87ddc5376286f900bcca5dcb0b9ddb454db.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 156, + 80, + 455, + 119.33333333333334 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 156, + 119.33333333333334, + 455, + 158.66666666666669 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 156, + 158.66666666666669, + 455, + 198.00000000000003 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 207, + 505, + 257 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 208, + 505, + 218 + ], + "spans": [ + { + "bbox": [ + 106, + 208, + 505, + 218 + ], + "score": 1.0, + "content": "Figure 2: (Architecture.) Our simplified block design combines the H3 block, which is the basis of most SSM", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 216, + 505, + 228 + ], + "spans": [ + { + "bbox": [ + 105, + 216, + 505, + 228 + ], + "score": 1.0, + "content": "architectures, with the ubiquitous MLP block of modern neural networks. Instead of interleaving these two", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 227, + 506, + 238 + ], + "spans": [ + { + "bbox": [ + 106, + 227, + 506, + 238 + ], + "score": 1.0, + "content": "blocks, we simply repeat the Mamba block homogenously. Compared to the H3 block, Mamba replaces the first", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 237, + 505, + 248 + ], + "spans": [ + { + "bbox": [ + 106, + 237, + 505, + 248 + ], + "score": 1.0, + "content": "multiplicative gate with an activation function. Compared to the MLP block, Mamba adds an SSM to the main", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 246, + 488, + 258 + ], + "spans": [ + { + "bbox": [ + 106, + 246, + 149, + 258 + ], + "score": 1.0, + "content": "branch. For", + "type": "text" + }, + { + "bbox": [ + 150, + 249, + 156, + 256 + ], + "score": 0.76, + "content": "\\sigma", + "type": "inline_equation" + }, + { + "bbox": [ + 157, + 246, + 488, + 258 + ], + "score": 1.0, + "content": "we use the SiLU / Swish activation (Hendrycks & Gimpel, 2016; Ramachandran et al., 2017).", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 5 + } + ], + "index": 3.0 + }, + { + "type": "text", + "bbox": [ + 107, + 261, + 505, + 305 + ], + "lines": [], + "index": 9.5, + "bbox_fs": [ + 105, + 261, + 507, + 306 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 105, + 308, + 505, + 331 + ], + "lines": [ + { + "bbox": [ + 105, + 307, + 506, + 321 + ], + "spans": [ + { + "bbox": [ + 105, + 307, + 185, + 321 + ], + "score": 1.0, + "content": "Theorem 1. When", + "type": "text" + }, + { + "bbox": [ + 186, + 308, + 334, + 319 + ], + "score": 0.77, + "content": "N = 1 , \\pmb { A } = - 1 , \\pmb { B } = 1 , s _ { \\Delta } = \\mathsf { L i n e a r } ( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 307, + 355, + 321 + ], + "score": 1.0, + "content": ", and", + "type": "text" + }, + { + "bbox": [ + 355, + 309, + 377, + 319 + ], + "score": 0.87, + "content": "\\tau _ { \\Delta } =", + "type": "inline_equation" + }, + { + "bbox": [ + 377, + 307, + 506, + 321 + ], + "score": 1.0, + "content": "softplus, then the selective SSM", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 318, + 503, + 333 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 265, + 333 + ], + "score": 1.0, + "content": "recurrence (Algorithm 2) takes the form", + "type": "text" + }, + { + "bbox": [ + 266, + 320, + 342, + 331 + ], + "score": 0.82, + "content": "g _ { k } { = } \\sigma ( { \\mathsf { L i n e a r } } ( x _ { k } ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 343, + 318, + 400, + 333 + ], + "score": 1.0, + "content": "(the gate) and", + "type": "text" + }, + { + "bbox": [ + 401, + 319, + 503, + 331 + ], + "score": 0.93, + "content": "h _ { k } = ( 1 - g _ { k } ) h _ { k - 1 } + g _ { k } x _ { k }", + "type": "inline_equation" + } + ], + "index": 13 + } + ], + "index": 12.5, + "bbox_fs": [ + 105, + 307, + 506, + 333 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 338, + 505, + 393 + ], + "lines": [ + { + "bbox": [ + 106, + 338, + 506, + 352 + ], + "spans": [ + { + "bbox": [ + 106, + 338, + 321, + 352 + ], + "score": 1.0, + "content": "As mentioned in Section 3.2, our specific choices of", + "type": "text" + }, + { + "bbox": [ + 322, + 341, + 349, + 350 + ], + "score": 0.9, + "content": "s \\Delta , \\tau _ { \\Delta }", + "type": "inline_equation" + }, + { + "bbox": [ + 349, + 338, + 506, + 352 + ], + "score": 1.0, + "content": "is from this connection. In particular,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 349, + 505, + 362 + ], + "spans": [ + { + "bbox": [ + 105, + 349, + 207, + 362 + ], + "score": 1.0, + "content": "note that if a given input", + "type": "text" + }, + { + "bbox": [ + 208, + 351, + 219, + 361 + ], + "score": 0.86, + "content": "x _ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 220, + 349, + 505, + 362 + ], + "score": 1.0, + "content": "should be completely ignored (as necessary in the synthetic tasks), all", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 107, + 360, + 506, + 373 + ], + "spans": [ + { + "bbox": [ + 107, + 361, + 116, + 370 + ], + "score": 0.78, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 117, + 360, + 506, + 373 + ], + "score": 1.0, + "content": "channels should ignore it, and so we project the input down to 1 dimension before broadcasting with", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 370, + 507, + 384 + ], + "spans": [ + { + "bbox": [ + 106, + 372, + 115, + 381 + ], + "score": 0.72, + "content": "\\Delta", + "type": "inline_equation" + }, + { + "bbox": [ + 115, + 370, + 261, + 384 + ], + "score": 1.0, + "content": ". Finally, we observe that the function", + "type": "text" + }, + { + "bbox": [ + 261, + 371, + 380, + 383 + ], + "score": 0.85, + "content": "s \\bar { \\Delta ( x ) } = \\mathsf { L i n e a r } _ { D } ( \\mathsf { L i n e a r } _ { 1 } ( x ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 381, + 370, + 507, + 384 + ], + "score": 1.0, + "content": "is simply a low-rank projection,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 381, + 461, + 394 + ], + "spans": [ + { + "bbox": [ + 105, + 381, + 461, + 394 + ], + "score": 1.0, + "content": "and relax the 1 dimension to a larger dimension R, generally set to be a small fraction of D.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 16, + "bbox_fs": [ + 105, + 338, + 507, + 394 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 397, + 356, + 408 + ], + "lines": [ + { + "bbox": [ + 106, + 397, + 356, + 410 + ], + "spans": [ + { + "bbox": [ + 106, + 397, + 356, + 410 + ], + "score": 1.0, + "content": "We elaborate on two particular mechanistic effects of selection.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19, + "bbox_fs": [ + 106, + 397, + 356, + 410 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 413, + 505, + 468 + ], + "lines": [ + { + "bbox": [ + 106, + 414, + 505, + 425 + ], + "spans": [ + { + "bbox": [ + 106, + 414, + 505, + 425 + ], + "score": 1.0, + "content": "Variable spacing. Selectivity allows filtering out irrelevant noise tokens that may occur between inputs", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 423, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 505, + 437 + ], + "score": 1.0, + "content": "of interest. This is exemplified by the Selective Copying task, but occurs ubiquitously in common", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 434, + 506, + 447 + ], + "spans": [ + { + "bbox": [ + 105, + 434, + 506, + 447 + ], + "score": 1.0, + "content": "data modalities, particularly for discrete data – for example the presence of language fillers such as", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 104, + 443, + 507, + 460 + ], + "spans": [ + { + "bbox": [ + 104, + 443, + 490, + 460 + ], + "score": 1.0, + "content": "“um”. This property arises because the model can mechanistically filter out any particular input", + "type": "text" + }, + { + "bbox": [ + 491, + 447, + 502, + 457 + ], + "score": 0.85, + "content": "x _ { k }", + "type": "inline_equation" + }, + { + "bbox": [ + 502, + 443, + 507, + 460 + ], + "score": 1.0, + "content": ",", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 456, + 353, + 469 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 320, + 469 + ], + "score": 1.0, + "content": "for example in the gated RNN case (Theorem 1) when", + "type": "text" + }, + { + "bbox": [ + 321, + 457, + 348, + 468 + ], + "score": 0.9, + "content": "g _ { k } \\to 0", + "type": "inline_equation" + }, + { + "bbox": [ + 349, + 456, + 353, + 469 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 22, + "bbox_fs": [ + 104, + 414, + 507, + 469 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 472, + 505, + 537 + ], + "lines": [ + { + "bbox": [ + 105, + 471, + 505, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 505, + 484 + ], + "score": 1.0, + "content": "Filtering context. It has been empirically observed that many sequence models do not improve with", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 482, + 506, + 495 + ], + "spans": [ + { + "bbox": [ + 106, + 482, + 506, + 495 + ], + "score": 1.0, + "content": "longer context (Shi et al., 2023a), despite the principle that more context should lead to strictly better", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 493, + 506, + 506 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 506, + 506 + ], + "score": 1.0, + "content": "performance. An explanation is that many sequence models cannot effectively ignore irrelevant context", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 504, + 506, + 516 + ], + "spans": [ + { + "bbox": [ + 105, + 504, + 506, + 516 + ], + "score": 1.0, + "content": "when necessary; an intuitive example are global convolutions (and general LTI models). On the other", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 514, + 505, + 527 + ], + "spans": [ + { + "bbox": [ + 105, + 514, + 505, + 527 + ], + "score": 1.0, + "content": "hand, selective models can simply reset their state at any time to remove extraneous history, and thus", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 525, + 485, + 538 + ], + "spans": [ + { + "bbox": [ + 106, + 525, + 485, + 538 + ], + "score": 1.0, + "content": "their performance in principle improves monotonicly with context length (e.g. Appendix E.2.2).", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 27.5, + "bbox_fs": [ + 105, + 471, + 506, + 538 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 541, + 505, + 588 + ], + "lines": [ + { + "bbox": [ + 106, + 542, + 505, + 554 + ], + "spans": [ + { + "bbox": [ + 106, + 542, + 210, + 554 + ], + "score": 1.0, + "content": "We remark that while the", + "type": "text" + }, + { + "bbox": [ + 211, + 542, + 221, + 551 + ], + "score": 0.68, + "content": "\\pmb { A }", + "type": "inline_equation" + }, + { + "bbox": [ + 221, + 542, + 505, + 554 + ], + "score": 1.0, + "content": "parameter could also be selective, it ultimately affects the model only", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 552, + 505, + 566 + ], + "spans": [ + { + "bbox": [ + 105, + 553, + 215, + 566 + ], + "score": 1.0, + "content": "through its interaction with", + "type": "text" + }, + { + "bbox": [ + 216, + 554, + 225, + 563 + ], + "score": 0.8, + "content": "\\Delta", + "type": "inline_equation" + }, + { + "bbox": [ + 225, + 553, + 240, + 566 + ], + "score": 1.0, + "content": "via", + "type": "text" + }, + { + "bbox": [ + 240, + 552, + 299, + 565 + ], + "score": 0.93, + "content": "\\overline { { A } } = \\exp ( \\Delta A )", + "type": "inline_equation" + }, + { + "bbox": [ + 300, + 553, + 454, + 566 + ], + "score": 1.0, + "content": "(the discretization). Thus selectivity in", + "type": "text" + }, + { + "bbox": [ + 454, + 554, + 464, + 564 + ], + "score": 0.77, + "content": "\\Delta", + "type": "inline_equation" + }, + { + "bbox": [ + 464, + 553, + 505, + 566 + ], + "score": 1.0, + "content": "is enough", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 564, + 504, + 578 + ], + "spans": [ + { + "bbox": [ + 106, + 566, + 195, + 578 + ], + "score": 1.0, + "content": "to ensure selectivity in", + "type": "text" + }, + { + "bbox": [ + 196, + 564, + 224, + 578 + ], + "score": 0.9, + "content": "( \\overline { { A } } , \\overline { { B } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 225, + 566, + 494, + 578 + ], + "score": 1.0, + "content": ", and is the main source of improvement. We hypothesize that making", + "type": "text" + }, + { + "bbox": [ + 494, + 566, + 504, + 576 + ], + "score": 0.56, + "content": "\\pmb { A }", + "type": "inline_equation" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 575, + 507, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 575, + 251, + 590 + ], + "score": 1.0, + "content": "selective in addition to (or instead of)", + "type": "text" + }, + { + "bbox": [ + 252, + 577, + 261, + 586 + ], + "score": 0.79, + "content": "\\Delta", + "type": "inline_equation" + }, + { + "bbox": [ + 261, + 575, + 507, + 590 + ], + "score": 1.0, + "content": "would have similar performance, and leave it out for simplicity.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32.5, + "bbox_fs": [ + 105, + 542, + 507, + 590 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 591, + 504, + 613 + ], + "lines": [ + { + "bbox": [ + 106, + 590, + 505, + 604 + ], + "spans": [ + { + "bbox": [ + 106, + 590, + 505, + 604 + ], + "score": 1.0, + "content": "Remark 3.1. For brevity in our experimental results, we sometimes abbreviate selective SSMs as", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 601, + 478, + 615 + ], + "spans": [ + { + "bbox": [ + 105, + 601, + 219, + 615 + ], + "score": 1.0, + "content": "S6 models, because they are", + "type": "text" + }, + { + "bbox": [ + 219, + 603, + 231, + 612 + ], + "score": 0.38, + "content": "S 4", + "type": "inline_equation" + }, + { + "bbox": [ + 231, + 601, + 478, + 615 + ], + "score": 1.0, + "content": "models with a selection mechanism and computed with a scan.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 35.5, + "bbox_fs": [ + 105, + 590, + 505, + 615 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 623, + 254, + 636 + ], + "lines": [ + { + "bbox": [ + 105, + 622, + 255, + 638 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 255, + 638 + ], + "score": 1.0, + "content": "4 EMPIRICAL EVALUATION", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 107, + 642, + 505, + 675 + ], + "lines": [ + { + "bbox": [ + 105, + 641, + 505, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 641, + 505, + 654 + ], + "score": 1.0, + "content": "Mamba achieves state-of-the-art results on the synthetic tasks (Section 4.1) and three different domains", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 651, + 506, + 666 + ], + "spans": [ + { + "bbox": [ + 105, + 651, + 506, + 666 + ], + "score": 1.0, + "content": "(language, DNA, audio) (Sections 4.2 to 4.4) on both pretraining and downstream tasks, while being", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 663, + 283, + 675 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 283, + 675 + ], + "score": 1.0, + "content": "very computationally efficient (Section 4.5).", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39, + "bbox_fs": [ + 105, + 641, + 506, + 675 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 683, + 212, + 694 + ], + "lines": [ + { + "bbox": [ + 105, + 681, + 213, + 696 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 213, + 696 + ], + "score": 1.0, + "content": "4.1 SYNTHETIC TASKS", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 107, + 699, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "score": 1.0, + "content": "Table 1 and Figure 3 show results for the synthetic tasks. On Selective Copying, the selective SSM layer", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 711, + 505, + 721 + ], + "spans": [ + { + "bbox": [ + 106, + 711, + 505, + 721 + ], + "score": 1.0, + "content": "is enough to solve the task independently of the architecture used, while previous LTI SSMs cannot even", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 721, + 505, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 505, + 732 + ], + "score": 1.0, + "content": "when combined with more powerful architectures. On Induction Heads, Mamba learns the task perfectly", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43, + "bbox_fs": [ + 105, + 698, + 505, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 109, + 80, + 234, + 191 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 109, + 80, + 234, + 191 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 80, + 234, + 191 + ], + "spans": [ + { + "bbox": [ + 109, + 80, + 234, + 191 + ], + "score": 0.908, + "html": "
MODEL ARCH.LAYER ACC.
S4No gate S4 No gate S618.3 97.0
H3H3S457.0
HyenaH3Hyena30.1
1H3S699.7
Mamba S456.4
Mamba Hyena28.4
MambaMamba S699.8
", + "type": "table", + "image_path": "277588017c3983620171c24625a0eb409c312b2f46bdda72ce562793b1faa647.jpg" + } + ] + } + ], + "index": 0.5, + "virtual_lines": [ + { + "bbox": [ + 109, + 80, + 234, + 135.5 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 109, + 135.5, + 234, + 191.0 + ], + "spans": [], + "index": 1 + } + ] + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 106, + 201, + 239, + 231 + ], + "lines": [ + { + "bbox": [ + 105, + 199, + 215, + 214 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 215, + 214 + ], + "score": 1.0, + "content": "Table 1: (Selective Copying.)", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 211, + 241, + 221 + ], + "spans": [ + { + "bbox": [ + 106, + 211, + 241, + 221 + ], + "score": 1.0, + "content": "Accuracy for combinations of archi-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 221, + 232, + 232 + ], + "spans": [ + { + "bbox": [ + 106, + 221, + 232, + 232 + ], + "score": 1.0, + "content": "tectures and inner sequence layers.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3 + }, + { + "type": "image", + "bbox": [ + 256, + 85, + 501, + 197 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 256, + 85, + 501, + 197 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 256, + 85, + 501, + 197 + ], + "spans": [ + { + "bbox": [ + 256, + 85, + 501, + 197 + ], + "score": 0.965, + "type": "image", + "image_path": "f69b759105d19813c86e3230b2579ef8e0c264126b0cc0b2657bf26e763023a6.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 256, + 85, + 501, + 122.33333333333334 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 256, + 122.33333333333334, + 501, + 159.66666666666669 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 256, + 159.66666666666669, + 501, + 197.00000000000003 + ], + "spans": [], + "index": 7 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 252, + 198, + 504, + 228 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 252, + 198, + 505, + 209 + ], + "spans": [ + { + "bbox": [ + 252, + 198, + 505, + 209 + ], + "score": 1.0, + "content": "Figure 3: (Induction Heads.) Models are trained on sequence length", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 253, + 205, + 506, + 220 + ], + "spans": [ + { + "bbox": [ + 253, + 207, + 287, + 217 + ], + "score": 0.89, + "content": "2 ^ { 8 } = 2 5 6", + "type": "inline_equation" + }, + { + "bbox": [ + 287, + 205, + 453, + 220 + ], + "score": 1.0, + "content": ", and tested on increasing sequence lengths of", + "type": "text" + }, + { + "bbox": [ + 454, + 207, + 484, + 217 + ], + "score": 0.91, + "content": "2 ^ { 6 } = 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 205, + 506, + 220 + ], + "score": 1.0, + "content": "up to", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 253, + 215, + 405, + 230 + ], + "spans": [ + { + "bbox": [ + 253, + 217, + 308, + 228 + ], + "score": 0.85, + "content": "2 ^ { 2 0 } = 1 0 4 8 5 7 6", + "type": "inline_equation" + }, + { + "bbox": [ + 308, + 215, + 405, + 230 + ], + "score": 1.0, + "content": ". Full numbers in Table 10.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9 + } + ], + "index": 7.5 + }, + { + "type": "image", + "bbox": [ + 111, + 261, + 500, + 350 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 111, + 261, + 500, + 350 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 111, + 261, + 500, + 350 + ], + "spans": [ + { + "bbox": [ + 111, + 261, + 500, + 350 + ], + "score": 0.963, + "type": "image", + "image_path": "9db8fba5b9f20e0b9c38d467bc8134fd8fb8345b39ed7a657d05892ed382ad40.jpg" + } + ] + } + ], + "index": 12, + "virtual_lines": [ + { + "bbox": [ + 111, + 261, + 500, + 290.6666666666667 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 111, + 290.6666666666667, + 500, + 320.33333333333337 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 111, + 320.33333333333337, + 500, + 350.00000000000006 + ], + "spans": [], + "index": 13 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 360, + 505, + 390 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 360, + 505, + 371 + ], + "spans": [ + { + "bbox": [ + 105, + 360, + 291, + 371 + ], + "score": 1.0, + "content": "Figure 4: (Chinchilla scaling laws.) Models of size", + "type": "text" + }, + { + "bbox": [ + 292, + 360, + 325, + 369 + ], + "score": 0.88, + "content": "\\approx 1 2 5 M", + "type": "inline_equation" + }, + { + "bbox": [ + 325, + 360, + 334, + 371 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 334, + 360, + 363, + 369 + ], + "score": 0.88, + "content": "{ \\approx } 1 . 3 B", + "type": "inline_equation" + }, + { + "bbox": [ + 363, + 360, + 505, + 371 + ], + "score": 1.0, + "content": "parameters, trained on the Pile. Mamba", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 368, + 506, + 382 + ], + "spans": [ + { + "bbox": [ + 105, + 368, + 506, + 382 + ], + "score": 1.0, + "content": "scales better than all other attention-free models and is the first to match the performance of a very strong", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 378, + 454, + 391 + ], + "spans": [ + { + "bbox": [ + 105, + 378, + 154, + 391 + ], + "score": 1.0, + "content": "“Transformer", + "type": "text" + }, + { + "bbox": [ + 155, + 380, + 166, + 389 + ], + "score": 0.46, + "content": "+ + ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 167, + 378, + 454, + 391 + ], + "score": 1.0, + "content": "” recipe that has now become standard, particularly as the sequence length grows.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15 + } + ], + "index": 13.5 + }, + { + "type": "text", + "bbox": [ + 106, + 413, + 505, + 435 + ], + "lines": [ + { + "bbox": [ + 105, + 411, + 507, + 427 + ], + "spans": [ + { + "bbox": [ + 105, + 411, + 336, + 427 + ], + "score": 1.0, + "content": "and can even extrapolate to million-length sequences, or", + "type": "text" + }, + { + "bbox": [ + 336, + 414, + 365, + 424 + ], + "score": 0.88, + "content": "4 0 0 0 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 366, + 411, + 507, + 427 + ], + "score": 1.0, + "content": "longer than it saw during training,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 423, + 484, + 436 + ], + "spans": [ + { + "bbox": [ + 106, + 423, + 248, + 436 + ], + "score": 1.0, + "content": "while no other method goes beyond", + "type": "text" + }, + { + "bbox": [ + 248, + 424, + 262, + 434 + ], + "score": 0.86, + "content": "2 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 262, + 423, + 484, + 436 + ], + "score": 1.0, + "content": ". Full discussion for synthetic tasks are in Appendix E.1.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5 + }, + { + "type": "title", + "bbox": [ + 108, + 455, + 231, + 466 + ], + "lines": [ + { + "bbox": [ + 106, + 454, + 232, + 467 + ], + "spans": [ + { + "bbox": [ + 106, + 454, + 232, + 467 + ], + "score": 1.0, + "content": "4.2 LANGUAGE MODELING", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 107, + 471, + 505, + 514 + ], + "lines": [ + { + "bbox": [ + 105, + 470, + 505, + 483 + ], + "spans": [ + { + "bbox": [ + 105, + 470, + 505, + 483 + ], + "score": 1.0, + "content": "We evaluate the Mamba architecture on standard autoregressive language modeling against other", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 481, + 506, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 481, + 506, + 494 + ], + "score": 1.0, + "content": "architectures, on both pretraining metrics (perplexity) and zero-shot evaluations. We set the model", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 492, + 505, + 504 + ], + "spans": [ + { + "bbox": [ + 105, + 492, + 505, + 504 + ], + "score": 1.0, + "content": "sizes (depth and width) to mirror GPT3 specifications. We use the Pile dataset (Gao et al., 2020), and", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 502, + 497, + 515 + ], + "spans": [ + { + "bbox": [ + 105, + 502, + 497, + 515 + ], + "score": 1.0, + "content": "follow the training recipe described in Brown et al. (2020). All training details are in Appendix F.2.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 21.5 + }, + { + "type": "text", + "bbox": [ + 107, + 518, + 505, + 562 + ], + "lines": [ + { + "bbox": [ + 106, + 519, + 506, + 530 + ], + "spans": [ + { + "bbox": [ + 106, + 519, + 506, + 530 + ], + "score": 1.0, + "content": "Scaling Laws. For baselines, we compare against the standard Transformer architecture (GPT3 archi-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 529, + 506, + 541 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 487, + 541 + ], + "score": 1.0, + "content": "tecture), as well as the strongest Transformer recipe we know of (here referred to as Transformer", + "type": "text" + }, + { + "bbox": [ + 488, + 531, + 500, + 540 + ], + "score": 0.45, + "content": "^ { + + }", + "type": "inline_equation" + }, + { + "bbox": [ + 500, + 529, + 506, + 541 + ], + "score": 1.0, + "content": "),", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 540, + 506, + 552 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 506, + 552 + ], + "score": 1.0, + "content": "based on the PaLM and LLaMa architectures (e.g. rotary embedding, SwiGLU MLP, etc.). We also com-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 551, + 506, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 506, + 564 + ], + "score": 1.0, + "content": "pare against other recent subquadratic architectures (Figure 4). All model details are in Appendix F.2.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 25.5 + }, + { + "type": "text", + "bbox": [ + 107, + 566, + 505, + 610 + ], + "lines": [ + { + "bbox": [ + 105, + 565, + 506, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 506, + 579 + ], + "score": 1.0, + "content": "Downstream Evaluations. Table 2 shows the performance of Mamba on a range of popular", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 577, + 506, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 506, + 590 + ], + "score": 1.0, + "content": "downstream zero-shot evaluation tasks. We compare against the most well-known open source models", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 588, + 505, + 600 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 505, + 600 + ], + "score": 1.0, + "content": "at these sizes, most importantly Pythia (Biderman et al., 2023) and RWKV (Peng et al., 2023) which", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 599, + 480, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 480, + 612 + ], + "score": 1.0, + "content": "were trained with the same tokenizer, dataset, and training length (300B tokens) as our models.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29.5 + }, + { + "type": "title", + "bbox": [ + 107, + 630, + 205, + 641 + ], + "lines": [ + { + "bbox": [ + 105, + 628, + 206, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 628, + 206, + 642 + ], + "score": 1.0, + "content": "4.3 DNA MODELING", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 107, + 645, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 645, + 506, + 659 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 506, + 659 + ], + "score": 1.0, + "content": "Motivated by the success of large language models, there has been recent exploration into using the", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 655, + 506, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 506, + 669 + ], + "score": 1.0, + "content": "foundation model paradigm for genomics. DNA has been likened to language in that it consists of", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 666, + 506, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 506, + 680 + ], + "score": 1.0, + "content": "sequences of discrete tokens with a finite vocab. It is also known for requiring long-range dependencies", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 104, + 675, + 506, + 692 + ], + "spans": [ + { + "bbox": [ + 104, + 675, + 506, + 692 + ], + "score": 1.0, + "content": "to model (Avsec et al., 2021). We investigate Mamba as a FM backbone for pretraining and fine-tuning", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "score": 1.0, + "content": "in the same setting as recent works on long-sequence models for DNA (Nguyen et al., 2023). In", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "score": 1.0, + "content": "particular, we focus on two explorations of scaling laws across model size and sequence length", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 709, + 507, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 507, + 723 + ], + "score": 1.0, + "content": "(Figure 5), and a difficult downstream synthetic classification task requiring long context (Figure 6).", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 720, + 303, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 303, + 732 + ], + "score": 1.0, + "content": "Full discussion for these tasks is in Appendix E.2.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 36.5 + } + ], + "page_idx": 6, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 303, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 305, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 305, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 762 + ], + "score": 1.0, + "content": "7", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 109, + 80, + 234, + 191 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 109, + 80, + 234, + 191 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 80, + 234, + 191 + ], + "spans": [ + { + "bbox": [ + 109, + 80, + 234, + 191 + ], + "score": 0.908, + "html": "
MODEL ARCH.LAYER ACC.
S4No gate S4 No gate S618.3 97.0
H3H3S457.0
HyenaH3Hyena30.1
1H3S699.7
Mamba S456.4
Mamba Hyena28.4
MambaMamba S699.8
", + "type": "table", + "image_path": "277588017c3983620171c24625a0eb409c312b2f46bdda72ce562793b1faa647.jpg" + } + ] + } + ], + "index": 0.5, + "virtual_lines": [ + { + "bbox": [ + 109, + 80, + 234, + 135.5 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 109, + 135.5, + 234, + 191.0 + ], + "spans": [], + "index": 1 + } + ] + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 106, + 201, + 239, + 231 + ], + "lines": [ + { + "bbox": [ + 105, + 199, + 215, + 214 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 215, + 214 + ], + "score": 1.0, + "content": "Table 1: (Selective Copying.)", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 211, + 241, + 221 + ], + "spans": [ + { + "bbox": [ + 106, + 211, + 241, + 221 + ], + "score": 1.0, + "content": "Accuracy for combinations of archi-", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 221, + 232, + 232 + ], + "spans": [ + { + "bbox": [ + 106, + 221, + 232, + 232 + ], + "score": 1.0, + "content": "tectures and inner sequence layers.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3, + "bbox_fs": [ + 105, + 199, + 241, + 232 + ] + }, + { + "type": "image", + "bbox": [ + 256, + 85, + 501, + 197 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 256, + 85, + 501, + 197 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 256, + 85, + 501, + 197 + ], + "spans": [ + { + "bbox": [ + 256, + 85, + 501, + 197 + ], + "score": 0.965, + "type": "image", + "image_path": "f69b759105d19813c86e3230b2579ef8e0c264126b0cc0b2657bf26e763023a6.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 256, + 85, + 501, + 122.33333333333334 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 256, + 122.33333333333334, + 501, + 159.66666666666669 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 256, + 159.66666666666669, + 501, + 197.00000000000003 + ], + "spans": [], + "index": 7 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 252, + 198, + 504, + 228 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 252, + 198, + 505, + 209 + ], + "spans": [ + { + "bbox": [ + 252, + 198, + 505, + 209 + ], + "score": 1.0, + "content": "Figure 3: (Induction Heads.) Models are trained on sequence length", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 253, + 205, + 506, + 220 + ], + "spans": [ + { + "bbox": [ + 253, + 207, + 287, + 217 + ], + "score": 0.89, + "content": "2 ^ { 8 } = 2 5 6", + "type": "inline_equation" + }, + { + "bbox": [ + 287, + 205, + 453, + 220 + ], + "score": 1.0, + "content": ", and tested on increasing sequence lengths of", + "type": "text" + }, + { + "bbox": [ + 454, + 207, + 484, + 217 + ], + "score": 0.91, + "content": "2 ^ { 6 } = 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 205, + 506, + 220 + ], + "score": 1.0, + "content": "up to", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 253, + 215, + 405, + 230 + ], + "spans": [ + { + "bbox": [ + 253, + 217, + 308, + 228 + ], + "score": 0.85, + "content": "2 ^ { 2 0 } = 1 0 4 8 5 7 6", + "type": "inline_equation" + }, + { + "bbox": [ + 308, + 215, + 405, + 230 + ], + "score": 1.0, + "content": ". Full numbers in Table 10.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9 + } + ], + "index": 7.5 + }, + { + "type": "image", + "bbox": [ + 111, + 261, + 500, + 350 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 111, + 261, + 500, + 350 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 111, + 261, + 500, + 350 + ], + "spans": [ + { + "bbox": [ + 111, + 261, + 500, + 350 + ], + "score": 0.963, + "type": "image", + "image_path": "9db8fba5b9f20e0b9c38d467bc8134fd8fb8345b39ed7a657d05892ed382ad40.jpg" + } + ] + } + ], + "index": 12, + "virtual_lines": [ + { + "bbox": [ + 111, + 261, + 500, + 290.6666666666667 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 111, + 290.6666666666667, + 500, + 320.33333333333337 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 111, + 320.33333333333337, + 500, + 350.00000000000006 + ], + "spans": [], + "index": 13 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 360, + 505, + 390 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 360, + 505, + 371 + ], + "spans": [ + { + "bbox": [ + 105, + 360, + 291, + 371 + ], + "score": 1.0, + "content": "Figure 4: (Chinchilla scaling laws.) Models of size", + "type": "text" + }, + { + "bbox": [ + 292, + 360, + 325, + 369 + ], + "score": 0.88, + "content": "\\approx 1 2 5 M", + "type": "inline_equation" + }, + { + "bbox": [ + 325, + 360, + 334, + 371 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 334, + 360, + 363, + 369 + ], + "score": 0.88, + "content": "{ \\approx } 1 . 3 B", + "type": "inline_equation" + }, + { + "bbox": [ + 363, + 360, + 505, + 371 + ], + "score": 1.0, + "content": "parameters, trained on the Pile. Mamba", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 368, + 506, + 382 + ], + "spans": [ + { + "bbox": [ + 105, + 368, + 506, + 382 + ], + "score": 1.0, + "content": "scales better than all other attention-free models and is the first to match the performance of a very strong", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 378, + 454, + 391 + ], + "spans": [ + { + "bbox": [ + 105, + 378, + 154, + 391 + ], + "score": 1.0, + "content": "“Transformer", + "type": "text" + }, + { + "bbox": [ + 155, + 380, + 166, + 389 + ], + "score": 0.46, + "content": "+ + ^ { \\prime }", + "type": "inline_equation" + }, + { + "bbox": [ + 167, + 378, + 454, + 391 + ], + "score": 1.0, + "content": "” recipe that has now become standard, particularly as the sequence length grows.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15 + } + ], + "index": 13.5 + }, + { + "type": "text", + "bbox": [ + 106, + 413, + 505, + 435 + ], + "lines": [ + { + "bbox": [ + 105, + 411, + 507, + 427 + ], + "spans": [ + { + "bbox": [ + 105, + 411, + 336, + 427 + ], + "score": 1.0, + "content": "and can even extrapolate to million-length sequences, or", + "type": "text" + }, + { + "bbox": [ + 336, + 414, + 365, + 424 + ], + "score": 0.88, + "content": "4 0 0 0 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 366, + 411, + 507, + 427 + ], + "score": 1.0, + "content": "longer than it saw during training,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 423, + 484, + 436 + ], + "spans": [ + { + "bbox": [ + 106, + 423, + 248, + 436 + ], + "score": 1.0, + "content": "while no other method goes beyond", + "type": "text" + }, + { + "bbox": [ + 248, + 424, + 262, + 434 + ], + "score": 0.86, + "content": "2 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 262, + 423, + 484, + 436 + ], + "score": 1.0, + "content": ". Full discussion for synthetic tasks are in Appendix E.1.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 17.5, + "bbox_fs": [ + 105, + 411, + 507, + 436 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 455, + 231, + 466 + ], + "lines": [ + { + "bbox": [ + 106, + 454, + 232, + 467 + ], + "spans": [ + { + "bbox": [ + 106, + 454, + 232, + 467 + ], + "score": 1.0, + "content": "4.2 LANGUAGE MODELING", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 107, + 471, + 505, + 514 + ], + "lines": [ + { + "bbox": [ + 105, + 470, + 505, + 483 + ], + "spans": [ + { + "bbox": [ + 105, + 470, + 505, + 483 + ], + "score": 1.0, + "content": "We evaluate the Mamba architecture on standard autoregressive language modeling against other", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 481, + 506, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 481, + 506, + 494 + ], + "score": 1.0, + "content": "architectures, on both pretraining metrics (perplexity) and zero-shot evaluations. We set the model", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 492, + 505, + 504 + ], + "spans": [ + { + "bbox": [ + 105, + 492, + 505, + 504 + ], + "score": 1.0, + "content": "sizes (depth and width) to mirror GPT3 specifications. We use the Pile dataset (Gao et al., 2020), and", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 502, + 497, + 515 + ], + "spans": [ + { + "bbox": [ + 105, + 502, + 497, + 515 + ], + "score": 1.0, + "content": "follow the training recipe described in Brown et al. (2020). All training details are in Appendix F.2.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 21.5, + "bbox_fs": [ + 105, + 470, + 506, + 515 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 518, + 505, + 562 + ], + "lines": [ + { + "bbox": [ + 106, + 519, + 506, + 530 + ], + "spans": [ + { + "bbox": [ + 106, + 519, + 506, + 530 + ], + "score": 1.0, + "content": "Scaling Laws. For baselines, we compare against the standard Transformer architecture (GPT3 archi-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 529, + 506, + 541 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 487, + 541 + ], + "score": 1.0, + "content": "tecture), as well as the strongest Transformer recipe we know of (here referred to as Transformer", + "type": "text" + }, + { + "bbox": [ + 488, + 531, + 500, + 540 + ], + "score": 0.45, + "content": "^ { + + }", + "type": "inline_equation" + }, + { + "bbox": [ + 500, + 529, + 506, + 541 + ], + "score": 1.0, + "content": "),", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 540, + 506, + 552 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 506, + 552 + ], + "score": 1.0, + "content": "based on the PaLM and LLaMa architectures (e.g. rotary embedding, SwiGLU MLP, etc.). We also com-", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 551, + 506, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 506, + 564 + ], + "score": 1.0, + "content": "pare against other recent subquadratic architectures (Figure 4). All model details are in Appendix F.2.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 25.5, + "bbox_fs": [ + 105, + 519, + 506, + 564 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 566, + 505, + 610 + ], + "lines": [ + { + "bbox": [ + 105, + 565, + 506, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 506, + 579 + ], + "score": 1.0, + "content": "Downstream Evaluations. Table 2 shows the performance of Mamba on a range of popular", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 577, + 506, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 506, + 590 + ], + "score": 1.0, + "content": "downstream zero-shot evaluation tasks. We compare against the most well-known open source models", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 588, + 505, + 600 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 505, + 600 + ], + "score": 1.0, + "content": "at these sizes, most importantly Pythia (Biderman et al., 2023) and RWKV (Peng et al., 2023) which", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 599, + 480, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 480, + 612 + ], + "score": 1.0, + "content": "were trained with the same tokenizer, dataset, and training length (300B tokens) as our models.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29.5, + "bbox_fs": [ + 105, + 565, + 506, + 612 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 630, + 205, + 641 + ], + "lines": [ + { + "bbox": [ + 105, + 628, + 206, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 628, + 206, + 642 + ], + "score": 1.0, + "content": "4.3 DNA MODELING", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 107, + 645, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 645, + 506, + 659 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 506, + 659 + ], + "score": 1.0, + "content": "Motivated by the success of large language models, there has been recent exploration into using the", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 655, + 506, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 506, + 669 + ], + "score": 1.0, + "content": "foundation model paradigm for genomics. DNA has been likened to language in that it consists of", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 666, + 506, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 506, + 680 + ], + "score": 1.0, + "content": "sequences of discrete tokens with a finite vocab. It is also known for requiring long-range dependencies", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 104, + 675, + 506, + 692 + ], + "spans": [ + { + "bbox": [ + 104, + 675, + 506, + 692 + ], + "score": 1.0, + "content": "to model (Avsec et al., 2021). We investigate Mamba as a FM backbone for pretraining and fine-tuning", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "score": 1.0, + "content": "in the same setting as recent works on long-sequence models for DNA (Nguyen et al., 2023). In", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "score": 1.0, + "content": "particular, we focus on two explorations of scaling laws across model size and sequence length", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 709, + 507, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 709, + 507, + 723 + ], + "score": 1.0, + "content": "(Figure 5), and a difficult downstream synthetic classification task requiring long context (Figure 6).", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 720, + 303, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 303, + 732 + ], + "score": 1.0, + "content": "Full discussion for these tasks is in Appendix E.2.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 36.5, + "bbox_fs": [ + 104, + 645, + 507, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 108, + 128, + 501, + 304 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 80, + 505, + 120 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 78, + 505, + 92 + ], + "spans": [ + { + "bbox": [ + 105, + 78, + 505, + 92 + ], + "score": 1.0, + "content": "Table 2: Zero-shot performance. Best results for each size in bold. We compare against open source LMs with", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 90, + 505, + 101 + ], + "spans": [ + { + "bbox": [ + 106, + 90, + 505, + 101 + ], + "score": 1.0, + "content": "various tokenizers, trained for up to 300B tokens. Pile refers to the validation split, comparing only against models", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 97, + 505, + 113 + ], + "spans": [ + { + "bbox": [ + 105, + 97, + 505, + 113 + ], + "score": 1.0, + "content": "trained on the same dataset and tokenizer (GPT-NeoX-20B). For each model size, Mamba is best-in-class on every", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 107, + 110, + 393, + 120 + ], + "spans": [ + { + "bbox": [ + 107, + 110, + 393, + 120 + ], + "score": 1.0, + "content": "single evaluation result, and generally matches baselines at twice the model size.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 1.5 + }, + { + "type": "table_body", + "bbox": [ + 108, + 128, + 501, + 304 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 128, + 501, + 304 + ], + "spans": [ + { + "bbox": [ + 108, + 128, + 501, + 304 + ], + "score": 0.983, + "html": "
MODELPPL↓PPL↓TOKEN. PILE LAMBADA LAMBADA HellSwag PIQA Arc-E Arc-C WinoGrande Average ACC个ACC个ACC个ACC↑ACC↑ACC个ACC↑
Pythia-160MNeoX29.64 38.1033.030.261.443.224.151.940.6
Mamba-130M NeoX10.5616.0744.335.364.548.024.351.944.7
Pythia-410MNeoX9.9510.8451.440.666.952.124.653.848.2
Mamba-370M NeoX8.288.1455.646.569.555.128.055.350.0
Pythia-1BNeoX7.827.9256.147.270.757.027.153.551.9
Mamba-790M NeoX7.336.0262.755.172.161.229.556.157.1
GPT-Neo 1.3BGPT2一7.5057.248.971.156.225.954.952.4
OPT-1.3BOPT6.6458.053.772.456.729.659.555.0
Pythia-1.4BNeoX7.516.0861.752.171.060.528.557.255.2
RWKV-1.5BNeoX7.707.0456.452.572.460.529.454.654.3
Mamba-1.4BNeoX6.805.0465.059.174.265.532.861.559.7
GPT-Neo 2.7BGPT25.6362.255.872.161.130.257.656.5
OPT-2.7BOPT5.1263.660.674.860.831.361.058.7
Pythia-2.8BNeoX6.735.0464.759.374.064.132.959.759.1
RWKV-3BNeoX7.005.2463.959.673.767.833.159.659.6
", + "type": "table", + "image_path": "386f47e4a95bf2d222f5ac59453ce7db370780e75c174f793691931217ccbd45.jpg" + } + ] + } + ], + "index": 5, + "virtual_lines": [ + { + "bbox": [ + 108, + 128, + 501, + 186.66666666666666 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 108, + 186.66666666666666, + 501, + 245.33333333333331 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 108, + 245.33333333333331, + 501, + 304.0 + ], + "spans": [], + "index": 6 + } + ] + } + ], + "index": 3.25 + }, + { + "type": "image", + "bbox": [ + 309, + 321, + 499, + 409 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 309, + 321, + 499, + 409 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 309, + 322, + 499, + 409 + ], + "spans": [ + { + "bbox": [ + 309, + 322, + 499, + 409 + ], + "score": 0.644, + "type": "image", + "image_path": "0d9d514c9d42bba0d244934c2c760a369c77bfefd9b11389bac4bcefb657b82c.jpg" + } + ] + } + ], + "index": 13.0, + "virtual_lines": [ + { + "bbox": [ + 309, + 321, + 499, + 335.6666666666667 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 309, + 335.6666666666667, + 499, + 350.33333333333337 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 309, + 350.33333333333337, + 499, + 365.00000000000006 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 309, + 365.00000000000006, + 499, + 379.66666666666674 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 309, + 379.66666666666674, + 499, + 394.3333333333334 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 309, + 394.3333333333334, + 499, + 409.0000000000001 + ], + "spans": [], + "index": 18 + } + ] + } + ], + "index": 13.0 + }, + { + "type": "image", + "bbox": [ + 111, + 321, + 303, + 409 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 111, + 321, + 303, + 409 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 111, + 321, + 303, + 409 + ], + "spans": [ + { + "bbox": [ + 111, + 321, + 303, + 409 + ], + "score": 0.74, + "type": "image", + "image_path": "c653397fc6d5871b2c1c54b23d398ecff2caaaf0f81f90e87b26a8618c4744d5.jpg" + } + ] + } + ], + "index": 12.0, + "virtual_lines": [ + { + "bbox": [ + 111, + 321, + 303, + 335.6666666666667 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 111, + 335.6666666666667, + 303, + 350.33333333333337 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 111, + 350.33333333333337, + 303, + 365.00000000000006 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 111, + 365.00000000000006, + 303, + 379.66666666666674 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 111, + 379.66666666666674, + 303, + 394.3333333333334 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 111, + 394.3333333333334, + 303, + 409.0000000000001 + ], + "spans": [], + "index": 17 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 419, + 505, + 459 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 419, + 506, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 419, + 506, + 432 + ], + "score": 1.0, + "content": "Figure 5: (DNA Scaling Laws.) Pretraining on the HG38 (human genome) dataset. (Left) Fixing short context", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 104, + 426, + 507, + 441 + ], + "spans": [ + { + "bbox": [ + 104, + 426, + 131, + 441 + ], + "score": 1.0, + "content": "length", + "type": "text" + }, + { + "bbox": [ + 131, + 429, + 172, + 438 + ], + "score": 0.91, + "content": "2 ^ { 1 0 } = 1 0 2 4", + "type": "inline_equation" + }, + { + "bbox": [ + 173, + 426, + 262, + 441 + ], + "score": 1.0, + "content": "and increasing size from", + "type": "text" + }, + { + "bbox": [ + 262, + 429, + 294, + 438 + ], + "score": 0.91, + "content": "{ \\approx } 2 0 0 K", + "type": "inline_equation" + }, + { + "bbox": [ + 294, + 426, + 303, + 441 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 303, + 429, + 331, + 438 + ], + "score": 0.89, + "content": "\\approx 4 0 M", + "type": "inline_equation" + }, + { + "bbox": [ + 332, + 426, + 507, + 441 + ], + "score": 1.0, + "content": "parameters, Mamba scales better than baselines.", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 107, + 438, + 506, + 450 + ], + "spans": [ + { + "bbox": [ + 107, + 439, + 133, + 449 + ], + "score": 0.26, + "content": "( R i g h t )", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 438, + 506, + 450 + ], + "score": 1.0, + "content": "Fixing model size and increasing sequence lengths while controlling for computation. Unlike baselines,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 448, + 450, + 460 + ], + "spans": [ + { + "bbox": [ + 106, + 448, + 450, + 460 + ], + "score": 1.0, + "content": "the selection mechanism of Mamba facilitates better performance with increasing context length.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 20.5 + } + ], + "index": 16.25 + }, + { + "type": "image", + "bbox": [ + 109, + 476, + 301, + 564 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 109, + 476, + 301, + 564 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 109, + 476, + 301, + 564 + ], + "spans": [ + { + "bbox": [ + 109, + 476, + 301, + 564 + ], + "score": 0.967, + "type": "image", + "image_path": "448ad1f3bed286f5faa192e080b08e71e188250422a49386b177036f6f62d92e.jpg" + } + ] + } + ], + "index": 28.0, + "virtual_lines": [ + { + "bbox": [ + 109, + 476, + 301, + 490.6666666666667 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 109, + 490.6666666666667, + 301, + 505.33333333333337 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 109, + 505.33333333333337, + 301, + 520.0 + ], + "spans": [], + "index": 27 + }, + { + "bbox": [ + 109, + 520.0, + 301, + 534.6666666666666 + ], + "spans": [], + "index": 29 + }, + { + "bbox": [ + 109, + 534.6666666666666, + 301, + 549.3333333333333 + ], + "spans": [], + "index": 31 + }, + { + "bbox": [ + 109, + 549.3333333333333, + 301, + 563.9999999999999 + ], + "spans": [], + "index": 33 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 585, + 302, + 625 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 105, + 583, + 304, + 598 + ], + "spans": [ + { + "bbox": [ + 105, + 583, + 304, + 598 + ], + "score": 1.0, + "content": "Figure 6: (Great Apes DNA Classification.) Accuracy", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 593, + 304, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 593, + 249, + 608 + ], + "score": 1.0, + "content": "after fine-tuning on sequences of length", + "type": "text" + }, + { + "bbox": [ + 250, + 595, + 292, + 605 + ], + "score": 0.82, + "content": "2 ^ { 1 0 } = 1 0 2 4", + "type": "inline_equation" + }, + { + "bbox": [ + 292, + 593, + 304, + 608 + ], + "score": 1.0, + "content": "up", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 603, + 304, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 603, + 115, + 617 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 116, + 604, + 171, + 615 + ], + "score": 0.9, + "content": "2 ^ { 2 0 } = 1 0 4 8 5 7 6", + "type": "inline_equation" + }, + { + "bbox": [ + 171, + 603, + 304, + 617 + ], + "score": 1.0, + "content": "with pre-trained models of the same", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 615, + 270, + 625 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 270, + 625 + ], + "score": 1.0, + "content": "context length. Numerical results in Table 12.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 37.0 + } + ], + "index": 32.5 + }, + { + "type": "image", + "bbox": [ + 311, + 477, + 502, + 565 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 311, + 477, + 502, + 565 + ], + "group_id": 3, + "lines": [ + { + "bbox": [ + 311, + 477, + 502, + 565 + ], + "spans": [ + { + "bbox": [ + 311, + 477, + 502, + 565 + ], + "score": 0.966, + "type": "image", + "image_path": "3f5119da16eaf7168bdbb9d8d38b51002de61cba78ae36ee42185cf92261533e.jpg" + } + ] + } + ], + "index": 29.0, + "virtual_lines": [ + { + "bbox": [ + 311, + 477, + 502, + 491.6666666666667 + ], + "spans": [], + "index": 24 + }, + { + "bbox": [ + 311, + 491.6666666666667, + 502, + 506.33333333333337 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 311, + 506.33333333333337, + 502, + 521.0 + ], + "spans": [], + "index": 28 + }, + { + "bbox": [ + 311, + 521.0, + 502, + 535.6666666666666 + ], + "spans": [], + "index": 30 + }, + { + "bbox": [ + 311, + 535.6666666666666, + 502, + 550.3333333333333 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 311, + 550.3333333333333, + 502, + 564.9999999999999 + ], + "spans": [], + "index": 34 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 308, + 586, + 505, + 626 + ], + "group_id": 3, + "lines": [ + { + "bbox": [ + 307, + 585, + 506, + 597 + ], + "spans": [ + { + "bbox": [ + 307, + 585, + 506, + 597 + ], + "score": 1.0, + "content": "Figure 7: (Audio Pretraining.) Mamba improves per-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 308, + 595, + 506, + 606 + ], + "spans": [ + { + "bbox": [ + 308, + 595, + 506, + 606 + ], + "score": 1.0, + "content": "formance over prior state-of-the-art (Sashimi) in autore-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 307, + 605, + 507, + 617 + ], + "spans": [ + { + "bbox": [ + 307, + 605, + 507, + 617 + ], + "score": 1.0, + "content": "gressive audio modeling, while improving up to minute-", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 308, + 616, + 457, + 626 + ], + "spans": [ + { + "bbox": [ + 308, + 616, + 457, + 626 + ], + "score": 1.0, + "content": "long context or million-length sequences.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 40.5 + } + ], + "index": 34.75 + }, + { + "type": "title", + "bbox": [ + 108, + 646, + 290, + 657 + ], + "lines": [ + { + "bbox": [ + 106, + 646, + 292, + 658 + ], + "spans": [ + { + "bbox": [ + 106, + 646, + 292, + 658 + ], + "score": 1.0, + "content": "4.4 AUDIO MODELING AND GENERATION", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 43 + }, + { + "type": "text", + "bbox": [ + 107, + 662, + 505, + 695 + ], + "lines": [ + { + "bbox": [ + 105, + 660, + 505, + 675 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 505, + 675 + ], + "score": 1.0, + "content": "For the audio waveform modality, we compare primarily to the SaShiMi architecture and training", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 672, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 672, + 505, + 684 + ], + "score": 1.0, + "content": "protocols (Goel et al., 2022). The architecture is a UNet with alternating S4 and MLP blocks, which", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 683, + 411, + 696 + ], + "spans": [ + { + "bbox": [ + 105, + 683, + 411, + 696 + ], + "score": 1.0, + "content": "we consider replacing with Mamba. Experiment details are in Appendix F.4.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 45 + }, + { + "type": "text", + "bbox": [ + 107, + 699, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 697, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 697, + 506, + 712 + ], + "score": 1.0, + "content": "Long-Context Autoregressive Pretraining. We evaluate pretraining quality on YouTubeMix (Deep-", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "score": 1.0, + "content": "Sound, 2017), a standard piano music dataset. Figure 7 evaluates the effect of increasing training", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 719, + 429, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 719, + 197, + 734 + ], + "score": 1.0, + "content": "sequence lengths from", + "type": "text" + }, + { + "bbox": [ + 198, + 720, + 242, + 731 + ], + "score": 0.9, + "content": "2 ^ { 1 3 } = 8 1 9 2", + "type": "inline_equation" + }, + { + "bbox": [ + 242, + 719, + 252, + 734 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 253, + 720, + 291, + 731 + ], + "score": 0.92, + "content": "2 ^ { 2 0 } \\approx 1 0 ^ { 6 }", + "type": "inline_equation" + }, + { + "bbox": [ + 291, + 719, + 429, + 734 + ], + "score": 1.0, + "content": ", while keeping computation fixed.", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 48 + } + ], + "page_idx": 7, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 304, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 304, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 304, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "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, + 128, + 501, + 304 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 80, + 505, + 120 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 78, + 505, + 92 + ], + "spans": [ + { + "bbox": [ + 105, + 78, + 505, + 92 + ], + "score": 1.0, + "content": "Table 2: Zero-shot performance. Best results for each size in bold. We compare against open source LMs with", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 90, + 505, + 101 + ], + "spans": [ + { + "bbox": [ + 106, + 90, + 505, + 101 + ], + "score": 1.0, + "content": "various tokenizers, trained for up to 300B tokens. Pile refers to the validation split, comparing only against models", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 97, + 505, + 113 + ], + "spans": [ + { + "bbox": [ + 105, + 97, + 505, + 113 + ], + "score": 1.0, + "content": "trained on the same dataset and tokenizer (GPT-NeoX-20B). For each model size, Mamba is best-in-class on every", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 107, + 110, + 393, + 120 + ], + "spans": [ + { + "bbox": [ + 107, + 110, + 393, + 120 + ], + "score": 1.0, + "content": "single evaluation result, and generally matches baselines at twice the model size.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 1.5 + }, + { + "type": "table_body", + "bbox": [ + 108, + 128, + 501, + 304 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 128, + 501, + 304 + ], + "spans": [ + { + "bbox": [ + 108, + 128, + 501, + 304 + ], + "score": 0.983, + "html": "
MODELPPL↓PPL↓TOKEN. PILE LAMBADA LAMBADA HellSwag PIQA Arc-E Arc-C WinoGrande Average ACC个ACC个ACC个ACC↑ACC↑ACC个ACC↑
Pythia-160MNeoX29.64 38.1033.030.261.443.224.151.940.6
Mamba-130M NeoX10.5616.0744.335.364.548.024.351.944.7
Pythia-410MNeoX9.9510.8451.440.666.952.124.653.848.2
Mamba-370M NeoX8.288.1455.646.569.555.128.055.350.0
Pythia-1BNeoX7.827.9256.147.270.757.027.153.551.9
Mamba-790M NeoX7.336.0262.755.172.161.229.556.157.1
GPT-Neo 1.3BGPT2一7.5057.248.971.156.225.954.952.4
OPT-1.3BOPT6.6458.053.772.456.729.659.555.0
Pythia-1.4BNeoX7.516.0861.752.171.060.528.557.255.2
RWKV-1.5BNeoX7.707.0456.452.572.460.529.454.654.3
Mamba-1.4BNeoX6.805.0465.059.174.265.532.861.559.7
GPT-Neo 2.7BGPT25.6362.255.872.161.130.257.656.5
OPT-2.7BOPT5.1263.660.674.860.831.361.058.7
Pythia-2.8BNeoX6.735.0464.759.374.064.132.959.759.1
RWKV-3BNeoX7.005.2463.959.673.767.833.159.659.6
", + "type": "table", + "image_path": "386f47e4a95bf2d222f5ac59453ce7db370780e75c174f793691931217ccbd45.jpg" + } + ] + } + ], + "index": 5, + "virtual_lines": [ + { + "bbox": [ + 108, + 128, + 501, + 186.66666666666666 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 108, + 186.66666666666666, + 501, + 245.33333333333331 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 108, + 245.33333333333331, + 501, + 304.0 + ], + "spans": [], + "index": 6 + } + ] + } + ], + "index": 3.25 + }, + { + "type": "image", + "bbox": [ + 309, + 321, + 499, + 409 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 309, + 321, + 499, + 409 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 309, + 322, + 499, + 409 + ], + "spans": [ + { + "bbox": [ + 309, + 322, + 499, + 409 + ], + "score": 0.644, + "type": "image", + "image_path": "0d9d514c9d42bba0d244934c2c760a369c77bfefd9b11389bac4bcefb657b82c.jpg" + } + ] + } + ], + "index": 13.0, + "virtual_lines": [ + { + "bbox": [ + 309, + 321, + 499, + 335.6666666666667 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 309, + 335.6666666666667, + 499, + 350.33333333333337 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 309, + 350.33333333333337, + 499, + 365.00000000000006 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 309, + 365.00000000000006, + 499, + 379.66666666666674 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 309, + 379.66666666666674, + 499, + 394.3333333333334 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 309, + 394.3333333333334, + 499, + 409.0000000000001 + ], + "spans": [], + "index": 18 + } + ] + } + ], + "index": 13.0 + }, + { + "type": "image", + "bbox": [ + 111, + 321, + 303, + 409 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 111, + 321, + 303, + 409 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 111, + 321, + 303, + 409 + ], + "spans": [ + { + "bbox": [ + 111, + 321, + 303, + 409 + ], + "score": 0.74, + "type": "image", + "image_path": "c653397fc6d5871b2c1c54b23d398ecff2caaaf0f81f90e87b26a8618c4744d5.jpg" + } + ] + } + ], + "index": 12.0, + "virtual_lines": [ + { + "bbox": [ + 111, + 321, + 303, + 335.6666666666667 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 111, + 335.6666666666667, + 303, + 350.33333333333337 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 111, + 350.33333333333337, + 303, + 365.00000000000006 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 111, + 365.00000000000006, + 303, + 379.66666666666674 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 111, + 379.66666666666674, + 303, + 394.3333333333334 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 111, + 394.3333333333334, + 303, + 409.0000000000001 + ], + "spans": [], + "index": 17 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 419, + 505, + 459 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 419, + 506, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 419, + 506, + 432 + ], + "score": 1.0, + "content": "Figure 5: (DNA Scaling Laws.) Pretraining on the HG38 (human genome) dataset. (Left) Fixing short context", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 104, + 426, + 507, + 441 + ], + "spans": [ + { + "bbox": [ + 104, + 426, + 131, + 441 + ], + "score": 1.0, + "content": "length", + "type": "text" + }, + { + "bbox": [ + 131, + 429, + 172, + 438 + ], + "score": 0.91, + "content": "2 ^ { 1 0 } = 1 0 2 4", + "type": "inline_equation" + }, + { + "bbox": [ + 173, + 426, + 262, + 441 + ], + "score": 1.0, + "content": "and increasing size from", + "type": "text" + }, + { + "bbox": [ + 262, + 429, + 294, + 438 + ], + "score": 0.91, + "content": "{ \\approx } 2 0 0 K", + "type": "inline_equation" + }, + { + "bbox": [ + 294, + 426, + 303, + 441 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 303, + 429, + 331, + 438 + ], + "score": 0.89, + "content": "\\approx 4 0 M", + "type": "inline_equation" + }, + { + "bbox": [ + 332, + 426, + 507, + 441 + ], + "score": 1.0, + "content": "parameters, Mamba scales better than baselines.", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 107, + 438, + 506, + 450 + ], + "spans": [ + { + "bbox": [ + 107, + 439, + 133, + 449 + ], + "score": 0.26, + "content": "( R i g h t )", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 438, + 506, + 450 + ], + "score": 1.0, + "content": "Fixing model size and increasing sequence lengths while controlling for computation. Unlike baselines,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 448, + 450, + 460 + ], + "spans": [ + { + "bbox": [ + 106, + 448, + 450, + 460 + ], + "score": 1.0, + "content": "the selection mechanism of Mamba facilitates better performance with increasing context length.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 20.5 + } + ], + "index": 16.25 + }, + { + "type": "image", + "bbox": [ + 109, + 476, + 301, + 564 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 109, + 476, + 301, + 564 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 109, + 476, + 301, + 564 + ], + "spans": [ + { + "bbox": [ + 109, + 476, + 301, + 564 + ], + "score": 0.967, + "type": "image", + "image_path": "448ad1f3bed286f5faa192e080b08e71e188250422a49386b177036f6f62d92e.jpg" + } + ] + } + ], + "index": 28.0, + "virtual_lines": [ + { + "bbox": [ + 109, + 476, + 301, + 490.6666666666667 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 109, + 490.6666666666667, + 301, + 505.33333333333337 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 109, + 505.33333333333337, + 301, + 520.0 + ], + "spans": [], + "index": 27 + }, + { + "bbox": [ + 109, + 520.0, + 301, + 534.6666666666666 + ], + "spans": [], + "index": 29 + }, + { + "bbox": [ + 109, + 534.6666666666666, + 301, + 549.3333333333333 + ], + "spans": [], + "index": 31 + }, + { + "bbox": [ + 109, + 549.3333333333333, + 301, + 563.9999999999999 + ], + "spans": [], + "index": 33 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 585, + 302, + 625 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 105, + 583, + 304, + 598 + ], + "spans": [ + { + "bbox": [ + 105, + 583, + 304, + 598 + ], + "score": 1.0, + "content": "Figure 6: (Great Apes DNA Classification.) Accuracy", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 593, + 304, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 593, + 249, + 608 + ], + "score": 1.0, + "content": "after fine-tuning on sequences of length", + "type": "text" + }, + { + "bbox": [ + 250, + 595, + 292, + 605 + ], + "score": 0.82, + "content": "2 ^ { 1 0 } = 1 0 2 4", + "type": "inline_equation" + }, + { + "bbox": [ + 292, + 593, + 304, + 608 + ], + "score": 1.0, + "content": "up", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 603, + 304, + 617 + ], + "spans": [ + { + "bbox": [ + 105, + 603, + 115, + 617 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 116, + 604, + 171, + 615 + ], + "score": 0.9, + "content": "2 ^ { 2 0 } = 1 0 4 8 5 7 6", + "type": "inline_equation" + }, + { + "bbox": [ + 171, + 603, + 304, + 617 + ], + "score": 1.0, + "content": "with pre-trained models of the same", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 615, + 270, + 625 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 270, + 625 + ], + "score": 1.0, + "content": "context length. Numerical results in Table 12.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 37.0 + } + ], + "index": 32.5 + }, + { + "type": "image", + "bbox": [ + 311, + 477, + 502, + 565 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 311, + 477, + 502, + 565 + ], + "group_id": 3, + "lines": [ + { + "bbox": [ + 311, + 477, + 502, + 565 + ], + "spans": [ + { + "bbox": [ + 311, + 477, + 502, + 565 + ], + "score": 0.966, + "type": "image", + "image_path": "3f5119da16eaf7168bdbb9d8d38b51002de61cba78ae36ee42185cf92261533e.jpg" + } + ] + } + ], + "index": 29.0, + "virtual_lines": [ + { + "bbox": [ + 311, + 477, + 502, + 491.6666666666667 + ], + "spans": [], + "index": 24 + }, + { + "bbox": [ + 311, + 491.6666666666667, + 502, + 506.33333333333337 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 311, + 506.33333333333337, + 502, + 521.0 + ], + "spans": [], + "index": 28 + }, + { + "bbox": [ + 311, + 521.0, + 502, + 535.6666666666666 + ], + "spans": [], + "index": 30 + }, + { + "bbox": [ + 311, + 535.6666666666666, + 502, + 550.3333333333333 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 311, + 550.3333333333333, + 502, + 564.9999999999999 + ], + "spans": [], + "index": 34 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 308, + 586, + 505, + 626 + ], + "group_id": 3, + "lines": [ + { + "bbox": [ + 307, + 585, + 506, + 597 + ], + "spans": [ + { + "bbox": [ + 307, + 585, + 506, + 597 + ], + "score": 1.0, + "content": "Figure 7: (Audio Pretraining.) Mamba improves per-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 308, + 595, + 506, + 606 + ], + "spans": [ + { + "bbox": [ + 308, + 595, + 506, + 606 + ], + "score": 1.0, + "content": "formance over prior state-of-the-art (Sashimi) in autore-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 307, + 605, + 507, + 617 + ], + "spans": [ + { + "bbox": [ + 307, + 605, + 507, + 617 + ], + "score": 1.0, + "content": "gressive audio modeling, while improving up to minute-", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 308, + 616, + 457, + 626 + ], + "spans": [ + { + "bbox": [ + 308, + 616, + 457, + 626 + ], + "score": 1.0, + "content": "long context or million-length sequences.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 40.5 + } + ], + "index": 34.75 + }, + { + "type": "title", + "bbox": [ + 108, + 646, + 290, + 657 + ], + "lines": [ + { + "bbox": [ + 106, + 646, + 292, + 658 + ], + "spans": [ + { + "bbox": [ + 106, + 646, + 292, + 658 + ], + "score": 1.0, + "content": "4.4 AUDIO MODELING AND GENERATION", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 43 + }, + { + "type": "text", + "bbox": [ + 107, + 662, + 505, + 695 + ], + "lines": [ + { + "bbox": [ + 105, + 660, + 505, + 675 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 505, + 675 + ], + "score": 1.0, + "content": "For the audio waveform modality, we compare primarily to the SaShiMi architecture and training", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 672, + 505, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 672, + 505, + 684 + ], + "score": 1.0, + "content": "protocols (Goel et al., 2022). The architecture is a UNet with alternating S4 and MLP blocks, which", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 683, + 411, + 696 + ], + "spans": [ + { + "bbox": [ + 105, + 683, + 411, + 696 + ], + "score": 1.0, + "content": "we consider replacing with Mamba. Experiment details are in Appendix F.4.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 45, + "bbox_fs": [ + 105, + 660, + 505, + 696 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 699, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 697, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 697, + 506, + 712 + ], + "score": 1.0, + "content": "Long-Context Autoregressive Pretraining. We evaluate pretraining quality on YouTubeMix (Deep-", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "score": 1.0, + "content": "Sound, 2017), a standard piano music dataset. Figure 7 evaluates the effect of increasing training", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 719, + 429, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 719, + 197, + 734 + ], + "score": 1.0, + "content": "sequence lengths from", + "type": "text" + }, + { + "bbox": [ + 198, + 720, + 242, + 731 + ], + "score": 0.9, + "content": "2 ^ { 1 3 } = 8 1 9 2", + "type": "inline_equation" + }, + { + "bbox": [ + 242, + 719, + 252, + 734 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 253, + 720, + 291, + 731 + ], + "score": 0.92, + "content": "2 ^ { 2 0 } \\approx 1 0 ^ { 6 }", + "type": "inline_equation" + }, + { + "bbox": [ + 291, + 719, + 429, + 734 + ], + "score": 1.0, + "content": ", while keeping computation fixed.", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 48, + "bbox_fs": [ + 105, + 697, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 109, + 129, + 302, + 243 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 79, + 307, + 120 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 80, + 307, + 91 + ], + "spans": [ + { + "bbox": [ + 106, + 80, + 307, + 91 + ], + "score": 1.0, + "content": "Table 3: (SC09) Automated metrics for unconditional", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 90, + 307, + 101 + ], + "spans": [ + { + "bbox": [ + 105, + 90, + 307, + 101 + ], + "score": 1.0, + "content": "generation on a challenging dataset of fixed-length speech", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 100, + 308, + 111 + ], + "spans": [ + { + "bbox": [ + 106, + 100, + 308, + 111 + ], + "score": 1.0, + "content": "clips. (Top to Bottom) Autoregressive baselines, non-", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 110, + 300, + 120 + ], + "spans": [ + { + "bbox": [ + 106, + 110, + 300, + 120 + ], + "score": 1.0, + "content": "autoregressive baselines, Mamba, and dataset metrics.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 1.5 + }, + { + "type": "table_body", + "bbox": [ + 109, + 129, + 302, + 243 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 129, + 302, + 243 + ], + "spans": [ + { + "bbox": [ + 109, + 129, + 302, + 243 + ], + "score": 0.975, + "html": "
MODELPARAMSNLL↓FID↓IS↑MIS个AM↓
SampleRNN35.0M2.0428.961.713.021.76
WaveNet4.2M1.9255.082.275.801.47
SaShiMi5.8M1.8731.995.1342.570.74
WaveGAN19.1M2.034.9036.100.80
DiffWave24.1M1.925.2651.210.68
+ SaShiMi23.0M1.425.9469.170.59
Mamba6.1M1.8520.946.2688.540.52
Mamba24.3M1.8600.677.33144.90.36
Train0.008.56292.50.16
Test0.028.33257.60.19
", + "type": "table", + "image_path": "c721a1484f1f2d6e68677dd53111bd67d74ac6bd9cd9992fd659393ec6cbd942.jpg" + } + ] + } + ], + "index": 8, + "virtual_lines": [ + { + "bbox": [ + 109, + 129, + 302, + 141.66666666666666 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 109, + 141.66666666666666, + 302, + 154.33333333333331 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 109, + 154.33333333333331, + 302, + 166.99999999999997 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 109, + 166.99999999999997, + 302, + 179.66666666666663 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 109, + 179.66666666666663, + 302, + 192.3333333333333 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 109, + 192.3333333333333, + 302, + 204.99999999999994 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 109, + 204.99999999999994, + 302, + 217.6666666666666 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 109, + 217.6666666666666, + 302, + 230.33333333333326 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 109, + 230.33333333333326, + 302, + 242.99999999999991 + ], + "spans": [], + "index": 12 + } + ] + } + ], + "index": 4.75 + }, + { + "type": "text", + "bbox": [ + 309, + 79, + 504, + 168 + ], + "lines": [ + { + "bbox": [ + 308, + 80, + 505, + 90 + ], + "spans": [ + { + "bbox": [ + 308, + 80, + 505, + 90 + ], + "score": 1.0, + "content": "Table 4: (SC09 Model Ablations) Models with 6M", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 307, + 90, + 506, + 101 + ], + "spans": [ + { + "bbox": [ + 307, + 90, + 506, + 101 + ], + "score": 1.0, + "content": "parameters. In SaShiMi’s UNet backbone, there are 8", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 307, + 100, + 506, + 111 + ], + "spans": [ + { + "bbox": [ + 307, + 100, + 506, + 111 + ], + "score": 1.0, + "content": "center layers operating on sequence length 1000, sand-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 307, + 109, + 506, + 122 + ], + "spans": [ + { + "bbox": [ + 307, + 109, + 506, + 122 + ], + "score": 1.0, + "content": "wiched on each side by 8 outer layers on sequence length", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 308, + 119, + 505, + 130 + ], + "spans": [ + { + "bbox": [ + 308, + 119, + 505, + 130 + ], + "score": 1.0, + "content": "4000, sandwiched by 8 outer layers on sequence length", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 307, + 128, + 506, + 140 + ], + "spans": [ + { + "bbox": [ + 307, + 128, + 506, + 140 + ], + "score": 1.0, + "content": "16000 (40 layers total). The architecture of the 8 center", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 308, + 139, + 505, + 149 + ], + "spans": [ + { + "bbox": [ + 308, + 139, + 505, + 149 + ], + "score": 1.0, + "content": "layers are ablated independently of the rest. Note that", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 308, + 148, + 505, + 159 + ], + "spans": [ + { + "bbox": [ + 308, + 148, + 358, + 159 + ], + "score": 1.0, + "content": "Transformers", + "type": "text" + }, + { + "bbox": [ + 359, + 149, + 407, + 158 + ], + "score": 0.48, + "content": "( \\mathbf { M H A + M L P } )", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 148, + 505, + 159 + ], + "score": 1.0, + "content": "were not tested in the more", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 308, + 159, + 505, + 170 + ], + "spans": [ + { + "bbox": [ + 308, + 159, + 505, + 170 + ], + "score": 1.0, + "content": "important outer layers because of efficiency constraints.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 17 + }, + { + "type": "table", + "bbox": [ + 310, + 178, + 501, + 245 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 310, + 178, + 501, + 245 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 310, + 178, + 501, + 245 + ], + "spans": [ + { + "bbox": [ + 310, + 178, + 501, + 245 + ], + "score": 0.963, + "html": "
OUTERCENTERNLL↓FID↓IS↑MIS个AM↓
S4+MLPMHA+MLP1.8591.455.0647.030.70
S4+MLPS4+MLP1.8671.435.4253.540.65
S4+MLPMamba1.8591.425.7156.510.64
MambaMHA+MLP1.8501.375.6358.230.62
MambaS4+MLP1.8531.076.0573.340.55
MambaMamba1.8520.946.2688.540.52
", + "type": "table", + "image_path": "ca6e77abd75d2677870395ce91c3429fd10e0edc4eaba299da66b3866c8dd450.jpg" + } + ] + } + ], + "index": 24, + "virtual_lines": [ + { + "bbox": [ + 310, + 178, + 501, + 191.4 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 310, + 191.4, + 501, + 204.8 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 310, + 204.8, + 501, + 218.20000000000002 + ], + "spans": [], + "index": 24 + }, + { + "bbox": [ + 310, + 218.20000000000002, + 501, + 231.60000000000002 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 310, + 231.60000000000002, + 501, + 245.00000000000003 + ], + "spans": [], + "index": 26 + } + ] + } + ], + "index": 24 + }, + { + "type": "image", + "bbox": [ + 113, + 265, + 299, + 343 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 153, + 258, + 279, + 264 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 153, + 258, + 279, + 265 + ], + "spans": [ + { + "bbox": [ + 153, + 258, + 279, + 265 + ], + "score": 1.0, + "content": "Scan vs Convolution vs Attention time (A100 80GB PCIe)", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "image_body", + "bbox": [ + 113, + 265, + 299, + 343 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 113, + 265, + 299, + 343 + ], + "spans": [ + { + "bbox": [ + 113, + 265, + 299, + 343 + ], + "score": 0.95, + "type": "image", + "image_path": "1c4d4295f413e5d32e62c791beef08b49e9977ff781f93fd7cecaa7195861f6e.jpg" + } + ] + } + ], + "index": 30.5, + "virtual_lines": [ + { + "bbox": [ + 113, + 265, + 299, + 278.0 + ], + "spans": [], + "index": 28 + }, + { + "bbox": [ + 113, + 278.0, + 299, + 291.0 + ], + "spans": [], + "index": 29 + }, + { + "bbox": [ + 113, + 291.0, + 299, + 304.0 + ], + "spans": [], + "index": 30 + }, + { + "bbox": [ + 113, + 304.0, + 299, + 317.0 + ], + "spans": [], + "index": 31 + }, + { + "bbox": [ + 113, + 317.0, + 299, + 330.0 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 113, + 330.0, + 299, + 343.0 + ], + "spans": [], + "index": 33 + } + ] + } + ], + "index": 28.75 + }, + { + "type": "image", + "bbox": [ + 311, + 261, + 498, + 343 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 357, + 258, + 468, + 264 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 357, + 258, + 468, + 265 + ], + "spans": [ + { + "bbox": [ + 357, + 258, + 468, + 265 + ], + "score": 1.0, + "content": "Inference throughput on A100 80GB (prompt length 2048)", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 34 + }, + { + "type": "image_body", + "bbox": [ + 311, + 261, + 498, + 343 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 311, + 261, + 498, + 343 + ], + "spans": [ + { + "bbox": [ + 311, + 261, + 498, + 343 + ], + "score": 0.928, + "type": "image", + "image_path": "1793f5aa5ab93915890c680ef9d91f1b58962ae7e5a30f0311781e69071fd586.jpg" + } + ] + } + ], + "index": 37.5, + "virtual_lines": [ + { + "bbox": [ + 311, + 261, + 498, + 274.6666666666667 + ], + "spans": [], + "index": 35 + }, + { + "bbox": [ + 311, + 274.6666666666667, + 498, + 288.33333333333337 + ], + "spans": [], + "index": 36 + }, + { + "bbox": [ + 311, + 288.33333333333337, + 498, + 302.00000000000006 + ], + "spans": [], + "index": 37 + }, + { + "bbox": [ + 311, + 302.00000000000006, + 498, + 315.66666666666674 + ], + "spans": [], + "index": 38 + }, + { + "bbox": [ + 311, + 315.66666666666674, + 498, + 329.3333333333334 + ], + "spans": [], + "index": 39 + }, + { + "bbox": [ + 311, + 329.3333333333334, + 498, + 343.0000000000001 + ], + "spans": [], + "index": 40 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 104, + 353, + 505, + 374 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 353, + 506, + 364 + ], + "spans": [ + { + "bbox": [ + 106, + 353, + 365, + 364 + ], + "score": 1.0, + "content": "Figure 8: (Efficiency Benchmarks.) (Left) Training: our efficient scan is", + "type": "text" + }, + { + "bbox": [ + 365, + 354, + 382, + 363 + ], + "score": 0.87, + "content": "4 0 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 353, + 506, + 364 + ], + "score": 1.0, + "content": "faster than a standard implementa-", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 362, + 488, + 375 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 338, + 375 + ], + "score": 1.0, + "content": "tion. (Right) Inference: as a recurrent model, Mamba can achieve", + "type": "text" + }, + { + "bbox": [ + 339, + 363, + 352, + 373 + ], + "score": 0.86, + "content": "5 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 352, + 362, + 488, + 375 + ], + "score": 1.0, + "content": "higher throughput than Transformers.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5 + } + ], + "index": 37.5 + }, + { + "type": "text", + "bbox": [ + 108, + 390, + 505, + 423 + ], + "lines": [ + { + "bbox": [ + 105, + 388, + 505, + 404 + ], + "spans": [ + { + "bbox": [ + 105, + 388, + 505, + 404 + ], + "score": 1.0, + "content": "Autoregressive Speech Generation. Tables 3 and 4 show results on the SC09 dataset for generating", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 400, + 506, + 413 + ], + "spans": [ + { + "bbox": [ + 105, + 400, + 506, + 413 + ], + "score": 1.0, + "content": "speech clips of the digits 0-9 (Warden, 2018; Donahue et al., 2019). Mamba sets significant state-of-", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 410, + 503, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 410, + 503, + 425 + ], + "score": 1.0, + "content": "the-art results, and is consistently better than attention or S4 blocks in a parameter-controlled setting.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44 + }, + { + "type": "title", + "bbox": [ + 108, + 432, + 281, + 443 + ], + "lines": [ + { + "bbox": [ + 106, + 431, + 282, + 444 + ], + "spans": [ + { + "bbox": [ + 106, + 431, + 282, + 444 + ], + "score": 1.0, + "content": "4.5 SPEED AND MEMORY BENCHMARK", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 46 + }, + { + "type": "text", + "bbox": [ + 107, + 447, + 505, + 523 + ], + "lines": [ + { + "bbox": [ + 106, + 447, + 505, + 459 + ], + "spans": [ + { + "bbox": [ + 106, + 447, + 322, + 459 + ], + "score": 1.0, + "content": "We benchmark the speed of the SSM scan operation", + "type": "text" + }, + { + "bbox": [ + 322, + 448, + 355, + 458 + ], + "score": 0.87, + "content": "N = 1 6", + "type": "inline_equation" + }, + { + "bbox": [ + 355, + 447, + 505, + 459 + ], + "score": 1.0, + "content": "), as well as the end-to-end inference", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 458, + 505, + 470 + ], + "spans": [ + { + "bbox": [ + 106, + 458, + 505, + 470 + ], + "score": 1.0, + "content": "throughput of Mamba, in Figure 8. Our efficient SSM scan is faster than the best attention", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 469, + 505, + 481 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 505, + 481 + ], + "score": 1.0, + "content": "implementation that we know of (FlashAttention-2 (Dao, 2023)) beyond sequence length 2K, and", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 479, + 506, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 479, + 128, + 492 + ], + "score": 1.0, + "content": "up to", + "type": "text" + }, + { + "bbox": [ + 129, + 480, + 161, + 490 + ], + "score": 0.88, + "content": "2 0 – 4 0 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 162, + 479, + 453, + 492 + ], + "score": 1.0, + "content": "faster than a standard scan implementation in PyTorch. Mamba achieves", + "type": "text" + }, + { + "bbox": [ + 453, + 480, + 476, + 491 + ], + "score": 0.86, + "content": "4 { - } 5 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 477, + 479, + 506, + 492 + ], + "score": 1.0, + "content": "higher", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 490, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 490, + 505, + 502 + ], + "score": 1.0, + "content": "inference throughput than a Transformer of similar size, since without the KV cache it can use much", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 105, + 501, + 506, + 513 + ], + "spans": [ + { + "bbox": [ + 105, + 501, + 506, + 513 + ], + "score": 1.0, + "content": "higher batch sizes. For example, Mamba 6.9B (untrained) has higher inference throughput than a", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 106, + 512, + 327, + 524 + ], + "spans": [ + { + "bbox": [ + 106, + 512, + 120, + 522 + ], + "score": 0.86, + "content": "5 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 120, + 512, + 327, + 524 + ], + "score": 1.0, + "content": "smaller Transformer-1.3B. Details in Appendix F.5.", + "type": "text" + } + ], + "index": 53 + } + ], + "index": 50 + }, + { + "type": "title", + "bbox": [ + 107, + 532, + 217, + 543 + ], + "lines": [ + { + "bbox": [ + 106, + 531, + 217, + 544 + ], + "spans": [ + { + "bbox": [ + 106, + 531, + 217, + 544 + ], + "score": 1.0, + "content": "4.6 MODEL ABLATIONS", + "type": "text" + } + ], + "index": 54 + } + ], + "index": 54 + }, + { + "type": "text", + "bbox": [ + 106, + 547, + 505, + 612 + ], + "lines": [ + { + "bbox": [ + 106, + 548, + 505, + 559 + ], + "spans": [ + { + "bbox": [ + 106, + 548, + 505, + 559 + ], + "score": 1.0, + "content": "We perform a series of detailed ablations on components of our model, focusing on the setting of", + "type": "text" + } + ], + "index": 55 + }, + { + "bbox": [ + 105, + 557, + 506, + 571 + ], + "spans": [ + { + "bbox": [ + 105, + 557, + 223, + 571 + ], + "score": 1.0, + "content": "language modeling with size", + "type": "text" + }, + { + "bbox": [ + 224, + 559, + 259, + 569 + ], + "score": 0.82, + "content": "\\approx 3 5 0 \\mathbf { M }", + "type": "inline_equation" + }, + { + "bbox": [ + 259, + 557, + 506, + 571 + ], + "score": 1.0, + "content": "models at Chinchilla token counts (same setting as Figure 4).", + "type": "text" + } + ], + "index": 56 + }, + { + "bbox": [ + 105, + 569, + 505, + 581 + ], + "spans": [ + { + "bbox": [ + 105, + 569, + 505, + 581 + ], + "score": 1.0, + "content": "These include (i) combinations of the outer architecture block vs. inner SSM layer (ii) parameterizations", + "type": "text" + } + ], + "index": 57 + }, + { + "bbox": [ + 105, + 579, + 506, + 592 + ], + "spans": [ + { + "bbox": [ + 105, + 579, + 506, + 592 + ], + "score": 1.0, + "content": "of the selective SSM. Results are in Appendix E.3. Of particular note is the dramatic improvement", + "type": "text" + } + ], + "index": 58 + }, + { + "bbox": [ + 106, + 590, + 506, + 603 + ], + "spans": [ + { + "bbox": [ + 106, + 590, + 268, + 603 + ], + "score": 1.0, + "content": "of the selective SSM when the state size", + "type": "text" + }, + { + "bbox": [ + 268, + 591, + 278, + 600 + ], + "score": 0.83, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 590, + 506, + 603 + ], + "score": 1.0, + "content": "is increased, with over a 1.0 perplexity improvement for", + "type": "text" + } + ], + "index": 59 + }, + { + "bbox": [ + 105, + 601, + 497, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 602, + 161, + 612 + ], + "score": 1.0, + "content": "a cost of only", + "type": "text" + }, + { + "bbox": [ + 161, + 601, + 176, + 612 + ], + "score": 0.86, + "content": "1 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 176, + 602, + 497, + 612 + ], + "score": 1.0, + "content": "additional parameters. This validates our core motivation in Sections 3.1 and 3.3.", + "type": "text" + } + ], + "index": 60 + } + ], + "index": 57.5 + }, + { + "type": "title", + "bbox": [ + 107, + 623, + 195, + 635 + ], + "lines": [ + { + "bbox": [ + 104, + 621, + 198, + 639 + ], + "spans": [ + { + "bbox": [ + 104, + 621, + 198, + 639 + ], + "score": 1.0, + "content": "5 CONCLUSION", + "type": "text" + } + ], + "index": 61 + } + ], + "index": 61 + }, + { + "type": "text", + "bbox": [ + 107, + 641, + 506, + 717 + ], + "lines": [ + { + "bbox": [ + 106, + 641, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 106, + 641, + 505, + 653 + ], + "score": 1.0, + "content": "We introduce a selection mechanism to structured state space models, allowing them to perform", + "type": "text" + } + ], + "index": 62 + }, + { + "bbox": [ + 106, + 652, + 506, + 664 + ], + "spans": [ + { + "bbox": [ + 106, + 652, + 506, + 664 + ], + "score": 1.0, + "content": "context-dependent reasoning while scaling linearly in sequence length. When incorporated into a sim-", + "type": "text" + } + ], + "index": 63 + }, + { + "bbox": [ + 105, + 663, + 506, + 675 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 506, + 675 + ], + "score": 1.0, + "content": "ple attention-free architecture, Mamba achieves state-of-the-art results on a diverse set of domains: most", + "type": "text" + } + ], + "index": 64 + }, + { + "bbox": [ + 105, + 673, + 506, + 685 + ], + "spans": [ + { + "bbox": [ + 105, + 673, + 506, + 685 + ], + "score": 1.0, + "content": "notably language, where it matches or exceeds the performance of strong Transformer models. We are", + "type": "text" + } + ], + "index": 65 + }, + { + "bbox": [ + 105, + 684, + 506, + 696 + ], + "spans": [ + { + "bbox": [ + 105, + 684, + 506, + 696 + ], + "score": 1.0, + "content": "excited about the broad applications of selective state space models to build foundation models for dif-", + "type": "text" + } + ], + "index": 66 + }, + { + "bbox": [ + 105, + 694, + 506, + 708 + ], + "spans": [ + { + "bbox": [ + 105, + 694, + 506, + 708 + ], + "score": 1.0, + "content": "ferent domains, especially in emerging modalities requiring long context such as genomics, audio, and", + "type": "text" + } + ], + "index": 67 + }, + { + "bbox": [ + 106, + 705, + 503, + 718 + ], + "spans": [ + { + "bbox": [ + 106, + 705, + 503, + 718 + ], + "score": 1.0, + "content": "video. Our results suggest that Mamba is a strong candidate to be a general sequence model backbone.", + "type": "text" + } + ], + "index": 68 + } + ], + "index": 65 + } + ], + "page_idx": 8, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 303, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 305, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 305, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "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": "table", + "bbox": [ + 109, + 129, + 302, + 243 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 79, + 307, + 120 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 80, + 307, + 91 + ], + "spans": [ + { + "bbox": [ + 106, + 80, + 307, + 91 + ], + "score": 1.0, + "content": "Table 3: (SC09) Automated metrics for unconditional", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 90, + 307, + 101 + ], + "spans": [ + { + "bbox": [ + 105, + 90, + 307, + 101 + ], + "score": 1.0, + "content": "generation on a challenging dataset of fixed-length speech", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 100, + 308, + 111 + ], + "spans": [ + { + "bbox": [ + 106, + 100, + 308, + 111 + ], + "score": 1.0, + "content": "clips. (Top to Bottom) Autoregressive baselines, non-", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 110, + 300, + 120 + ], + "spans": [ + { + "bbox": [ + 106, + 110, + 300, + 120 + ], + "score": 1.0, + "content": "autoregressive baselines, Mamba, and dataset metrics.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 1.5 + }, + { + "type": "table_body", + "bbox": [ + 109, + 129, + 302, + 243 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 129, + 302, + 243 + ], + "spans": [ + { + "bbox": [ + 109, + 129, + 302, + 243 + ], + "score": 0.975, + "html": "
MODELPARAMSNLL↓FID↓IS↑MIS个AM↓
SampleRNN35.0M2.0428.961.713.021.76
WaveNet4.2M1.9255.082.275.801.47
SaShiMi5.8M1.8731.995.1342.570.74
WaveGAN19.1M2.034.9036.100.80
DiffWave24.1M1.925.2651.210.68
+ SaShiMi23.0M1.425.9469.170.59
Mamba6.1M1.8520.946.2688.540.52
Mamba24.3M1.8600.677.33144.90.36
Train0.008.56292.50.16
Test0.028.33257.60.19
", + "type": "table", + "image_path": "c721a1484f1f2d6e68677dd53111bd67d74ac6bd9cd9992fd659393ec6cbd942.jpg" + } + ] + } + ], + "index": 8, + "virtual_lines": [ + { + "bbox": [ + 109, + 129, + 302, + 141.66666666666666 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 109, + 141.66666666666666, + 302, + 154.33333333333331 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 109, + 154.33333333333331, + 302, + 166.99999999999997 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 109, + 166.99999999999997, + 302, + 179.66666666666663 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 109, + 179.66666666666663, + 302, + 192.3333333333333 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 109, + 192.3333333333333, + 302, + 204.99999999999994 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 109, + 204.99999999999994, + 302, + 217.6666666666666 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 109, + 217.6666666666666, + 302, + 230.33333333333326 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 109, + 230.33333333333326, + 302, + 242.99999999999991 + ], + "spans": [], + "index": 12 + } + ] + } + ], + "index": 4.75 + }, + { + "type": "text", + "bbox": [ + 309, + 79, + 504, + 168 + ], + "lines": [ + { + "bbox": [ + 308, + 80, + 505, + 90 + ], + "spans": [ + { + "bbox": [ + 308, + 80, + 505, + 90 + ], + "score": 1.0, + "content": "Table 4: (SC09 Model Ablations) Models with 6M", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 307, + 90, + 506, + 101 + ], + "spans": [ + { + "bbox": [ + 307, + 90, + 506, + 101 + ], + "score": 1.0, + "content": "parameters. In SaShiMi’s UNet backbone, there are 8", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 307, + 100, + 506, + 111 + ], + "spans": [ + { + "bbox": [ + 307, + 100, + 506, + 111 + ], + "score": 1.0, + "content": "center layers operating on sequence length 1000, sand-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 307, + 109, + 506, + 122 + ], + "spans": [ + { + "bbox": [ + 307, + 109, + 506, + 122 + ], + "score": 1.0, + "content": "wiched on each side by 8 outer layers on sequence length", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 308, + 119, + 505, + 130 + ], + "spans": [ + { + "bbox": [ + 308, + 119, + 505, + 130 + ], + "score": 1.0, + "content": "4000, sandwiched by 8 outer layers on sequence length", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 307, + 128, + 506, + 140 + ], + "spans": [ + { + "bbox": [ + 307, + 128, + 506, + 140 + ], + "score": 1.0, + "content": "16000 (40 layers total). The architecture of the 8 center", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 308, + 139, + 505, + 149 + ], + "spans": [ + { + "bbox": [ + 308, + 139, + 505, + 149 + ], + "score": 1.0, + "content": "layers are ablated independently of the rest. Note that", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 308, + 148, + 505, + 159 + ], + "spans": [ + { + "bbox": [ + 308, + 148, + 358, + 159 + ], + "score": 1.0, + "content": "Transformers", + "type": "text" + }, + { + "bbox": [ + 359, + 149, + 407, + 158 + ], + "score": 0.48, + "content": "( \\mathbf { M H A + M L P } )", + "type": "inline_equation" + }, + { + "bbox": [ + 407, + 148, + 505, + 159 + ], + "score": 1.0, + "content": "were not tested in the more", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 308, + 159, + 505, + 170 + ], + "spans": [ + { + "bbox": [ + 308, + 159, + 505, + 170 + ], + "score": 1.0, + "content": "important outer layers because of efficiency constraints.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 17, + "bbox_fs": [ + 307, + 80, + 506, + 170 + ] + }, + { + "type": "table", + "bbox": [ + 310, + 178, + 501, + 245 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 310, + 178, + 501, + 245 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 310, + 178, + 501, + 245 + ], + "spans": [ + { + "bbox": [ + 310, + 178, + 501, + 245 + ], + "score": 0.963, + "html": "
OUTERCENTERNLL↓FID↓IS↑MIS个AM↓
S4+MLPMHA+MLP1.8591.455.0647.030.70
S4+MLPS4+MLP1.8671.435.4253.540.65
S4+MLPMamba1.8591.425.7156.510.64
MambaMHA+MLP1.8501.375.6358.230.62
MambaS4+MLP1.8531.076.0573.340.55
MambaMamba1.8520.946.2688.540.52
", + "type": "table", + "image_path": "ca6e77abd75d2677870395ce91c3429fd10e0edc4eaba299da66b3866c8dd450.jpg" + } + ] + } + ], + "index": 24, + "virtual_lines": [ + { + "bbox": [ + 310, + 178, + 501, + 191.4 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 310, + 191.4, + 501, + 204.8 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 310, + 204.8, + 501, + 218.20000000000002 + ], + "spans": [], + "index": 24 + }, + { + "bbox": [ + 310, + 218.20000000000002, + 501, + 231.60000000000002 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 310, + 231.60000000000002, + 501, + 245.00000000000003 + ], + "spans": [], + "index": 26 + } + ] + } + ], + "index": 24 + }, + { + "type": "image", + "bbox": [ + 113, + 265, + 299, + 343 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 153, + 258, + 279, + 264 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 153, + 258, + 279, + 265 + ], + "spans": [ + { + "bbox": [ + 153, + 258, + 279, + 265 + ], + "score": 1.0, + "content": "Scan vs Convolution vs Attention time (A100 80GB PCIe)", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "image_body", + "bbox": [ + 113, + 265, + 299, + 343 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 113, + 265, + 299, + 343 + ], + "spans": [ + { + "bbox": [ + 113, + 265, + 299, + 343 + ], + "score": 0.95, + "type": "image", + "image_path": "1c4d4295f413e5d32e62c791beef08b49e9977ff781f93fd7cecaa7195861f6e.jpg" + } + ] + } + ], + "index": 30.5, + "virtual_lines": [ + { + "bbox": [ + 113, + 265, + 299, + 278.0 + ], + "spans": [], + "index": 28 + }, + { + "bbox": [ + 113, + 278.0, + 299, + 291.0 + ], + "spans": [], + "index": 29 + }, + { + "bbox": [ + 113, + 291.0, + 299, + 304.0 + ], + "spans": [], + "index": 30 + }, + { + "bbox": [ + 113, + 304.0, + 299, + 317.0 + ], + "spans": [], + "index": 31 + }, + { + "bbox": [ + 113, + 317.0, + 299, + 330.0 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 113, + 330.0, + 299, + 343.0 + ], + "spans": [], + "index": 33 + } + ] + } + ], + "index": 28.75 + }, + { + "type": "image", + "bbox": [ + 311, + 261, + 498, + 343 + ], + "blocks": [ + { + "type": "image_caption", + "bbox": [ + 357, + 258, + 468, + 264 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 357, + 258, + 468, + 265 + ], + "spans": [ + { + "bbox": [ + 357, + 258, + 468, + 265 + ], + "score": 1.0, + "content": "Inference throughput on A100 80GB (prompt length 2048)", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 34 + }, + { + "type": "image_body", + "bbox": [ + 311, + 261, + 498, + 343 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 311, + 261, + 498, + 343 + ], + "spans": [ + { + "bbox": [ + 311, + 261, + 498, + 343 + ], + "score": 0.928, + "type": "image", + "image_path": "1793f5aa5ab93915890c680ef9d91f1b58962ae7e5a30f0311781e69071fd586.jpg" + } + ] + } + ], + "index": 37.5, + "virtual_lines": [ + { + "bbox": [ + 311, + 261, + 498, + 274.6666666666667 + ], + "spans": [], + "index": 35 + }, + { + "bbox": [ + 311, + 274.6666666666667, + 498, + 288.33333333333337 + ], + "spans": [], + "index": 36 + }, + { + "bbox": [ + 311, + 288.33333333333337, + 498, + 302.00000000000006 + ], + "spans": [], + "index": 37 + }, + { + "bbox": [ + 311, + 302.00000000000006, + 498, + 315.66666666666674 + ], + "spans": [], + "index": 38 + }, + { + "bbox": [ + 311, + 315.66666666666674, + 498, + 329.3333333333334 + ], + "spans": [], + "index": 39 + }, + { + "bbox": [ + 311, + 329.3333333333334, + 498, + 343.0000000000001 + ], + "spans": [], + "index": 40 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 104, + 353, + 505, + 374 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 353, + 506, + 364 + ], + "spans": [ + { + "bbox": [ + 106, + 353, + 365, + 364 + ], + "score": 1.0, + "content": "Figure 8: (Efficiency Benchmarks.) (Left) Training: our efficient scan is", + "type": "text" + }, + { + "bbox": [ + 365, + 354, + 382, + 363 + ], + "score": 0.87, + "content": "4 0 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 353, + 506, + 364 + ], + "score": 1.0, + "content": "faster than a standard implementa-", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 362, + 488, + 375 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 338, + 375 + ], + "score": 1.0, + "content": "tion. (Right) Inference: as a recurrent model, Mamba can achieve", + "type": "text" + }, + { + "bbox": [ + 339, + 363, + 352, + 373 + ], + "score": 0.86, + "content": "5 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 352, + 362, + 488, + 375 + ], + "score": 1.0, + "content": "higher throughput than Transformers.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 41.5 + } + ], + "index": 37.5 + }, + { + "type": "text", + "bbox": [ + 108, + 390, + 505, + 423 + ], + "lines": [ + { + "bbox": [ + 105, + 388, + 505, + 404 + ], + "spans": [ + { + "bbox": [ + 105, + 388, + 505, + 404 + ], + "score": 1.0, + "content": "Autoregressive Speech Generation. Tables 3 and 4 show results on the SC09 dataset for generating", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 400, + 506, + 413 + ], + "spans": [ + { + "bbox": [ + 105, + 400, + 506, + 413 + ], + "score": 1.0, + "content": "speech clips of the digits 0-9 (Warden, 2018; Donahue et al., 2019). Mamba sets significant state-of-", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 410, + 503, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 410, + 503, + 425 + ], + "score": 1.0, + "content": "the-art results, and is consistently better than attention or S4 blocks in a parameter-controlled setting.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44, + "bbox_fs": [ + 105, + 388, + 506, + 425 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 432, + 281, + 443 + ], + "lines": [ + { + "bbox": [ + 106, + 431, + 282, + 444 + ], + "spans": [ + { + "bbox": [ + 106, + 431, + 282, + 444 + ], + "score": 1.0, + "content": "4.5 SPEED AND MEMORY BENCHMARK", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 46 + }, + { + "type": "text", + "bbox": [ + 107, + 447, + 505, + 523 + ], + "lines": [ + { + "bbox": [ + 106, + 447, + 505, + 459 + ], + "spans": [ + { + "bbox": [ + 106, + 447, + 322, + 459 + ], + "score": 1.0, + "content": "We benchmark the speed of the SSM scan operation", + "type": "text" + }, + { + "bbox": [ + 322, + 448, + 355, + 458 + ], + "score": 0.87, + "content": "N = 1 6", + "type": "inline_equation" + }, + { + "bbox": [ + 355, + 447, + 505, + 459 + ], + "score": 1.0, + "content": "), as well as the end-to-end inference", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 458, + 505, + 470 + ], + "spans": [ + { + "bbox": [ + 106, + 458, + 505, + 470 + ], + "score": 1.0, + "content": "throughput of Mamba, in Figure 8. Our efficient SSM scan is faster than the best attention", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 469, + 505, + 481 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 505, + 481 + ], + "score": 1.0, + "content": "implementation that we know of (FlashAttention-2 (Dao, 2023)) beyond sequence length 2K, and", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 479, + 506, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 479, + 128, + 492 + ], + "score": 1.0, + "content": "up to", + "type": "text" + }, + { + "bbox": [ + 129, + 480, + 161, + 490 + ], + "score": 0.88, + "content": "2 0 – 4 0 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 162, + 479, + 453, + 492 + ], + "score": 1.0, + "content": "faster than a standard scan implementation in PyTorch. Mamba achieves", + "type": "text" + }, + { + "bbox": [ + 453, + 480, + 476, + 491 + ], + "score": 0.86, + "content": "4 { - } 5 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 477, + 479, + 506, + 492 + ], + "score": 1.0, + "content": "higher", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 490, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 490, + 505, + 502 + ], + "score": 1.0, + "content": "inference throughput than a Transformer of similar size, since without the KV cache it can use much", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 105, + 501, + 506, + 513 + ], + "spans": [ + { + "bbox": [ + 105, + 501, + 506, + 513 + ], + "score": 1.0, + "content": "higher batch sizes. For example, Mamba 6.9B (untrained) has higher inference throughput than a", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 106, + 512, + 327, + 524 + ], + "spans": [ + { + "bbox": [ + 106, + 512, + 120, + 522 + ], + "score": 0.86, + "content": "5 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 120, + 512, + 327, + 524 + ], + "score": 1.0, + "content": "smaller Transformer-1.3B. Details in Appendix F.5.", + "type": "text" + } + ], + "index": 53 + } + ], + "index": 50, + "bbox_fs": [ + 105, + 447, + 506, + 524 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 532, + 217, + 543 + ], + "lines": [ + { + "bbox": [ + 106, + 531, + 217, + 544 + ], + "spans": [ + { + "bbox": [ + 106, + 531, + 217, + 544 + ], + "score": 1.0, + "content": "4.6 MODEL ABLATIONS", + "type": "text" + } + ], + "index": 54 + } + ], + "index": 54 + }, + { + "type": "text", + "bbox": [ + 106, + 547, + 505, + 612 + ], + "lines": [ + { + "bbox": [ + 106, + 548, + 505, + 559 + ], + "spans": [ + { + "bbox": [ + 106, + 548, + 505, + 559 + ], + "score": 1.0, + "content": "We perform a series of detailed ablations on components of our model, focusing on the setting of", + "type": "text" + } + ], + "index": 55 + }, + { + "bbox": [ + 105, + 557, + 506, + 571 + ], + "spans": [ + { + "bbox": [ + 105, + 557, + 223, + 571 + ], + "score": 1.0, + "content": "language modeling with size", + "type": "text" + }, + { + "bbox": [ + 224, + 559, + 259, + 569 + ], + "score": 0.82, + "content": "\\approx 3 5 0 \\mathbf { M }", + "type": "inline_equation" + }, + { + "bbox": [ + 259, + 557, + 506, + 571 + ], + "score": 1.0, + "content": "models at Chinchilla token counts (same setting as Figure 4).", + "type": "text" + } + ], + "index": 56 + }, + { + "bbox": [ + 105, + 569, + 505, + 581 + ], + "spans": [ + { + "bbox": [ + 105, + 569, + 505, + 581 + ], + "score": 1.0, + "content": "These include (i) combinations of the outer architecture block vs. inner SSM layer (ii) parameterizations", + "type": "text" + } + ], + "index": 57 + }, + { + "bbox": [ + 105, + 579, + 506, + 592 + ], + "spans": [ + { + "bbox": [ + 105, + 579, + 506, + 592 + ], + "score": 1.0, + "content": "of the selective SSM. Results are in Appendix E.3. Of particular note is the dramatic improvement", + "type": "text" + } + ], + "index": 58 + }, + { + "bbox": [ + 106, + 590, + 506, + 603 + ], + "spans": [ + { + "bbox": [ + 106, + 590, + 268, + 603 + ], + "score": 1.0, + "content": "of the selective SSM when the state size", + "type": "text" + }, + { + "bbox": [ + 268, + 591, + 278, + 600 + ], + "score": 0.83, + "content": "N", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 590, + 506, + 603 + ], + "score": 1.0, + "content": "is increased, with over a 1.0 perplexity improvement for", + "type": "text" + } + ], + "index": 59 + }, + { + "bbox": [ + 105, + 601, + 497, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 602, + 161, + 612 + ], + "score": 1.0, + "content": "a cost of only", + "type": "text" + }, + { + "bbox": [ + 161, + 601, + 176, + 612 + ], + "score": 0.86, + "content": "1 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 176, + 602, + 497, + 612 + ], + "score": 1.0, + "content": "additional parameters. This validates our core motivation in Sections 3.1 and 3.3.", + "type": "text" + } + ], + "index": 60 + } + ], + "index": 57.5, + "bbox_fs": [ + 105, + 548, + 506, + 612 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 623, + 195, + 635 + ], + "lines": [ + { + "bbox": [ + 104, + 621, + 198, + 639 + ], + "spans": [ + { + "bbox": [ + 104, + 621, + 198, + 639 + ], + "score": 1.0, + "content": "5 CONCLUSION", + "type": "text" + } + ], + "index": 61 + } + ], + "index": 61 + }, + { + "type": "text", + "bbox": [ + 107, + 641, + 506, + 717 + ], + "lines": [ + { + "bbox": [ + 106, + 641, + 505, + 653 + ], + "spans": [ + { + "bbox": [ + 106, + 641, + 505, + 653 + ], + "score": 1.0, + "content": "We introduce a selection mechanism to structured state space models, allowing them to perform", + "type": "text" + } + ], + "index": 62 + }, + { + "bbox": [ + 106, + 652, + 506, + 664 + ], + "spans": [ + { + "bbox": [ + 106, + 652, + 506, + 664 + ], + "score": 1.0, + "content": "context-dependent reasoning while scaling linearly in sequence length. When incorporated into a sim-", + "type": "text" + } + ], + "index": 63 + }, + { + "bbox": [ + 105, + 663, + 506, + 675 + ], + "spans": [ + { + "bbox": [ + 105, + 663, + 506, + 675 + ], + "score": 1.0, + "content": "ple attention-free architecture, Mamba achieves state-of-the-art results on a diverse set of domains: most", + "type": "text" + } + ], + "index": 64 + }, + { + "bbox": [ + 105, + 673, + 506, + 685 + ], + "spans": [ + { + "bbox": [ + 105, + 673, + 506, + 685 + ], + "score": 1.0, + "content": "notably language, where it matches or exceeds the performance of strong Transformer models. We are", + "type": "text" + } + ], + "index": 65 + }, + { + "bbox": [ + 105, + 684, + 506, + 696 + ], + "spans": [ + { + "bbox": [ + 105, + 684, + 506, + 696 + ], + "score": 1.0, + "content": "excited about the broad applications of selective state space models to build foundation models for dif-", + "type": "text" + } + ], + "index": 66 + }, + { + "bbox": [ + 105, + 694, + 506, + 708 + ], + "spans": [ + { + "bbox": [ + 105, + 694, + 506, + 708 + ], + "score": 1.0, + "content": "ferent domains, especially in emerging modalities requiring long context such as genomics, audio, and", + "type": "text" + } + ], + "index": 67 + }, + { + "bbox": [ + 106, + 705, + 503, + 718 + ], + "spans": [ + { + "bbox": [ + 106, + 705, + 503, + 718 + ], + "score": 1.0, + "content": "video. Our results suggest that Mamba is a strong candidate to be a general sequence model backbone.", + "type": "text" + } + ], + "index": 68 + } + ], + "index": 65, + "bbox_fs": [ + 105, + 641, + 506, + 718 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 81, + 176, + 93 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 176, + 94 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 176, + 94 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 101, + 96, + 506, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 99, + 506, + 112 + ], + "spans": [ + { + "bbox": [ + 105, + 99, + 506, + 112 + ], + "score": 1.0, + "content": "Martin Arjovsky, Amar Shah, and Yoshua Bengio. Unitary evolution recurrent neural networks. In", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 115, + 110, + 446, + 123 + ], + "spans": [ + { + "bbox": [ + 115, + 110, + 446, + 123 + ], + "score": 1.0, + "content": "The International Conference on Machine Learning (ICML), pp. 1120–1128, 2016.", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 104, + 126, + 508, + 145 + ], + "spans": [ + { + "bbox": [ + 104, + 126, + 508, + 145 + ], + "score": 1.0, + "content": "Ziga Avsec, Vikram Agarwal, Daniel Visentin, Joseph R Ledsam, Agnieszka Grabska-Barwinska, ˇ", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 114, + 139, + 506, + 155 + ], + "spans": [ + { + "bbox": [ + 114, + 139, + 506, + 155 + ], + "score": 1.0, + "content": "Kyle R Taylor, Yannis Assael, John Jumper, Pushmeet Kohli, and David R Kelley. Effective gene", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 115, + 151, + 505, + 165 + ], + "spans": [ + { + "bbox": [ + 115, + 151, + 505, + 165 + ], + "score": 1.0, + "content": "expression prediction from sequence by integrating long-range interactions. Nature methods, 18", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 114, + 162, + 211, + 174 + ], + "spans": [ + { + "bbox": [ + 114, + 162, + 211, + 174 + ], + "score": 1.0, + "content": "(10):1196–1203, 2021.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 180, + 505, + 194 + ], + "spans": [ + { + "bbox": [ + 105, + 180, + 505, + 194 + ], + "score": 1.0, + "content": "Jimmy Ba, Geoffrey E Hinton, Volodymyr Mnih, Joel Z Leibo, and Catalin Ionescu. Using fast weights", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 114, + 190, + 471, + 205 + ], + "spans": [ + { + "bbox": [ + 114, + 190, + 471, + 205 + ], + "score": 1.0, + "content": "to attend to the recent past. Advances in neural information processing systems, 29, 2016.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 208, + 505, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 208, + 505, + 223 + ], + "score": 1.0, + "content": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 114, + 221, + 394, + 233 + ], + "spans": [ + { + "bbox": [ + 114, + 221, + 394, + 233 + ], + "score": 1.0, + "content": "learning to align and translate. arXiv preprint arXiv:1409.0473, 2014.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 238, + 506, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 238, + 506, + 252 + ], + "score": 1.0, + "content": "David Balduzzi and Muhammad Ghifary. Strongly-typed recurrent neural networks. In International", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 115, + 249, + 374, + 263 + ], + "spans": [ + { + "bbox": [ + 115, + 249, + 374, + 263 + ], + "score": 1.0, + "content": "Conference on Machine Learning, pp. 1292–1300. PMLR, 2016.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 266, + 506, + 280 + ], + "spans": [ + { + "bbox": [ + 105, + 266, + 506, + 280 + ], + "score": 1.0, + "content": "Stella Biderman, Hailey Schoelkopf, Quentin Gregory Anthony, Herbie Bradley, Kyle O’Brien, Eric", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 115, + 278, + 507, + 291 + ], + "spans": [ + { + "bbox": [ + 115, + 278, + 507, + 291 + ], + "score": 1.0, + "content": "Hallahan, Mohammad Aflah Khan, Shivanshu Purohit, USVSN Sai Prashanth, Edward Raff, et al.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 116, + 289, + 506, + 303 + ], + "spans": [ + { + "bbox": [ + 116, + 289, + 506, + 303 + ], + "score": 1.0, + "content": "Pythia: A suite for analyzing large language models across training and scaling. In International", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 116, + 300, + 374, + 313 + ], + "spans": [ + { + "bbox": [ + 116, + 300, + 374, + 313 + ], + "score": 1.0, + "content": "Conference on Machine Learning, pp. 2397–2430. PMLR, 2023.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 317, + 505, + 331 + ], + "spans": [ + { + "bbox": [ + 105, + 317, + 505, + 331 + ], + "score": 1.0, + "content": "Yonatan Bisk, Rowan Zellers, Jianfeng Gao, Yejin Choi, et al. Piqa: Reasoning about physical", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 329, + 506, + 343 + ], + "spans": [ + { + "bbox": [ + 115, + 329, + 506, + 343 + ], + "score": 1.0, + "content": "commonsense in natural language. In Proceedings of the AAAI conference on artificial intelligence,", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 115, + 340, + 252, + 353 + ], + "spans": [ + { + "bbox": [ + 115, + 340, + 252, + 353 + ], + "score": 1.0, + "content": "volume 34, pp. 7432–7439, 2020.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 359, + 335, + 370 + ], + "spans": [ + { + "bbox": [ + 106, + 359, + 335, + 370 + ], + "score": 1.0, + "content": "Guy E Blelloch. Prefix sums and their applications. 1990.", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 376, + 506, + 389 + ], + "spans": [ + { + "bbox": [ + 105, + 376, + 506, + 389 + ], + "score": 1.0, + "content": "James Bradbury, Stephen Merity, Caiming Xiong, and Richard Socher. Quasi-recurrent neural", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 115, + 387, + 320, + 400 + ], + "spans": [ + { + "bbox": [ + 115, + 387, + 320, + 400 + ], + "score": 1.0, + "content": "networks. arXiv preprint arXiv:1611.01576, 2016.", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 405, + 505, + 418 + ], + "spans": [ + { + "bbox": [ + 106, + 405, + 505, + 418 + ], + "score": 1.0, + "content": "Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal,", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 115, + 416, + 505, + 429 + ], + "spans": [ + { + "bbox": [ + 115, + 416, + 505, + 429 + ], + "score": 1.0, + "content": "Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 114, + 426, + 484, + 441 + ], + "spans": [ + { + "bbox": [ + 114, + 426, + 484, + 441 + ], + "score": 1.0, + "content": "few-shot learners. Advances in neural information processing systems, 33:1877–1901, 2020.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 445, + 505, + 458 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 505, + 458 + ], + "score": 1.0, + "content": "Aydar Bulatov, Yuri Kuratov, and Mikhail S Burtsev. Scaling transformer to 1m tokens and beyond", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 116, + 457, + 315, + 468 + ], + "spans": [ + { + "bbox": [ + 116, + 457, + 315, + 468 + ], + "score": 1.0, + "content": "with rmt. arXiv preprint arXiv:2304.11062, 2023.", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 474, + 506, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 474, + 506, + 488 + ], + "score": 1.0, + "content": "Aakanksha Chowdhery, Sharan Narang, Jacob Devlin, Maarten Bosma, Gaurav Mishra, Adam Roberts,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 114, + 484, + 506, + 500 + ], + "spans": [ + { + "bbox": [ + 114, + 484, + 506, + 500 + ], + "score": 1.0, + "content": "Paul Barham, Hyung Won Chung, Charles Sutton, Sebastian Gehrmann, et al. Palm: Scaling", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 115, + 496, + 417, + 509 + ], + "spans": [ + { + "bbox": [ + 115, + 496, + 417, + 509 + ], + "score": 1.0, + "content": "language modeling with pathways. arXiv preprint arXiv:2204.02311, 2022.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 514, + 506, + 527 + ], + "spans": [ + { + "bbox": [ + 105, + 514, + 506, + 527 + ], + "score": 1.0, + "content": "Junyoung Chung, Caglar Gulcehre, KyungHyun Cho, and Yoshua Bengio. Empirical evaluation of", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 114, + 524, + 493, + 539 + ], + "spans": [ + { + "bbox": [ + 114, + 524, + 493, + 539 + ], + "score": 1.0, + "content": "gated recurrent neural networks on sequence modeling. arXiv preprint arXiv:1412.3555, 2014.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 543, + 505, + 556 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 505, + 556 + ], + "score": 1.0, + "content": "Peter Clark, Isaac Cowhey, Oren Etzioni, Tushar Khot, Ashish Sabharwal, Carissa Schoenick, and", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 116, + 554, + 507, + 567 + ], + "spans": [ + { + "bbox": [ + 116, + 554, + 507, + 567 + ], + "score": 1.0, + "content": "Oyvind Tafjord. Think you have solved question answering? try arc, the ai2 reasoning challenge.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 565, + 277, + 578 + ], + "spans": [ + { + "bbox": [ + 115, + 565, + 277, + 578 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:1803.05457, 2018.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 583, + 484, + 596 + ], + "spans": [ + { + "bbox": [ + 106, + 583, + 484, + 596 + ], + "score": 1.0, + "content": "Tri Dao. FlashAttention-2: Faster attention with better parallelism and work partitioning. 2023.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 601, + 505, + 614 + ], + "spans": [ + { + "bbox": [ + 106, + 601, + 505, + 614 + ], + "score": 1.0, + "content": "Tri Dao, Daniel Y. Fu, Stefano Ermon, Atri Rudra, and Christopher Re. FlashAttention: Fast and ´", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 114, + 610, + 506, + 627 + ], + "spans": [ + { + "bbox": [ + 114, + 610, + 506, + 627 + ], + "score": 1.0, + "content": "memory-efficient exact attention with IO-awareness. In Advances in Neural Information Processing", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 114, + 623, + 177, + 635 + ], + "spans": [ + { + "bbox": [ + 114, + 623, + 177, + 635 + ], + "score": 1.0, + "content": "Systems, 2022.", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 639, + 505, + 656 + ], + "spans": [ + { + "bbox": [ + 105, + 639, + 505, + 656 + ], + "score": 1.0, + "content": "Tri Dao, Daniel Y Fu, Khaled K Saab, Armin W Thomas, Atri Rudra, and Christopher Re. Hungry ´", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 114, + 651, + 506, + 666 + ], + "spans": [ + { + "bbox": [ + 114, + 651, + 506, + 666 + ], + "score": 1.0, + "content": "hungry hippos: Towards language modeling with state space models. In The International", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 663, + 339, + 676 + ], + "spans": [ + { + "bbox": [ + 115, + 663, + 339, + 676 + ], + "score": 1.0, + "content": "Conference on Learning Representations (ICLR), 2023.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 680, + 506, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 680, + 506, + 694 + ], + "score": 1.0, + "content": "Yann N Dauphin, Angela Fan, Michael Auli, and David Grangier. Language modeling with gated con-", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 115, + 692, + 507, + 705 + ], + "spans": [ + { + "bbox": [ + 115, + 692, + 507, + 705 + ], + "score": 1.0, + "content": "volutional networks. In International conference on machine learning, pp. 933–941. PMLR, 2017.", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 160, + 723 + ], + "score": 1.0, + "content": "DeepSound.", + "type": "text" + }, + { + "bbox": [ + 194, + 708, + 247, + 723 + ], + "score": 1.0, + "content": "Samplernn.", + "type": "text" + }, + { + "bbox": [ + 280, + 710, + 505, + 723 + ], + "score": 1.0, + "content": "https://github.com/deepsound-project/", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 114, + 721, + 250, + 734 + ], + "spans": [ + { + "bbox": [ + 114, + 721, + 250, + 734 + ], + "score": 1.0, + "content": "samplernn-pytorch, 2017.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 23.5 + } + ], + "page_idx": 9, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 304, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 305, + 39 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 305, + 39 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "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": "10", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 81, + 176, + 93 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 176, + 94 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 176, + 94 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "list", + "bbox": [ + 101, + 96, + 506, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 99, + 506, + 112 + ], + "spans": [ + { + "bbox": [ + 105, + 99, + 506, + 112 + ], + "score": 1.0, + "content": "Martin Arjovsky, Amar Shah, and Yoshua Bengio. Unitary evolution recurrent neural networks. In", + "type": "text" + } + ], + "index": 1, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 110, + 446, + 123 + ], + "spans": [ + { + "bbox": [ + 115, + 110, + 446, + 123 + ], + "score": 1.0, + "content": "The International Conference on Machine Learning (ICML), pp. 1120–1128, 2016.", + "type": "text" + } + ], + "index": 2, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 126, + 508, + 145 + ], + "spans": [ + { + "bbox": [ + 104, + 126, + 508, + 145 + ], + "score": 1.0, + "content": "Ziga Avsec, Vikram Agarwal, Daniel Visentin, Joseph R Ledsam, Agnieszka Grabska-Barwinska, ˇ", + "type": "text" + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 139, + 506, + 155 + ], + "spans": [ + { + "bbox": [ + 114, + 139, + 506, + 155 + ], + "score": 1.0, + "content": "Kyle R Taylor, Yannis Assael, John Jumper, Pushmeet Kohli, and David R Kelley. Effective gene", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 115, + 151, + 505, + 165 + ], + "spans": [ + { + "bbox": [ + 115, + 151, + 505, + 165 + ], + "score": 1.0, + "content": "expression prediction from sequence by integrating long-range interactions. Nature methods, 18", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 114, + 162, + 211, + 174 + ], + "spans": [ + { + "bbox": [ + 114, + 162, + 211, + 174 + ], + "score": 1.0, + "content": "(10):1196–1203, 2021.", + "type": "text" + } + ], + "index": 6, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 180, + 505, + 194 + ], + "spans": [ + { + "bbox": [ + 105, + 180, + 505, + 194 + ], + "score": 1.0, + "content": "Jimmy Ba, Geoffrey E Hinton, Volodymyr Mnih, Joel Z Leibo, and Catalin Ionescu. Using fast weights", + "type": "text" + } + ], + "index": 7, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 190, + 471, + 205 + ], + "spans": [ + { + "bbox": [ + 114, + 190, + 471, + 205 + ], + "score": 1.0, + "content": "to attend to the recent past. Advances in neural information processing systems, 29, 2016.", + "type": "text" + } + ], + "index": 8, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 208, + 505, + 223 + ], + "spans": [ + { + "bbox": [ + 105, + 208, + 505, + 223 + ], + "score": 1.0, + "content": "Dzmitry Bahdanau, Kyunghyun Cho, and Yoshua Bengio. Neural machine translation by jointly", + "type": "text" + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 221, + 394, + 233 + ], + "spans": [ + { + "bbox": [ + 114, + 221, + 394, + 233 + ], + "score": 1.0, + "content": "learning to align and translate. arXiv preprint arXiv:1409.0473, 2014.", + "type": "text" + } + ], + "index": 10, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 238, + 506, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 238, + 506, + 252 + ], + "score": 1.0, + "content": "David Balduzzi and Muhammad Ghifary. Strongly-typed recurrent neural networks. In International", + "type": "text" + } + ], + "index": 11, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 249, + 374, + 263 + ], + "spans": [ + { + "bbox": [ + 115, + 249, + 374, + 263 + ], + "score": 1.0, + "content": "Conference on Machine Learning, pp. 1292–1300. PMLR, 2016.", + "type": "text" + } + ], + "index": 12, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 266, + 506, + 280 + ], + "spans": [ + { + "bbox": [ + 105, + 266, + 506, + 280 + ], + "score": 1.0, + "content": "Stella Biderman, Hailey Schoelkopf, Quentin Gregory Anthony, Herbie Bradley, Kyle O’Brien, Eric", + "type": "text" + } + ], + "index": 13, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 278, + 507, + 291 + ], + "spans": [ + { + "bbox": [ + 115, + 278, + 507, + 291 + ], + "score": 1.0, + "content": "Hallahan, Mohammad Aflah Khan, Shivanshu Purohit, USVSN Sai Prashanth, Edward Raff, et al.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 116, + 289, + 506, + 303 + ], + "spans": [ + { + "bbox": [ + 116, + 289, + 506, + 303 + ], + "score": 1.0, + "content": "Pythia: A suite for analyzing large language models across training and scaling. In International", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 116, + 300, + 374, + 313 + ], + "spans": [ + { + "bbox": [ + 116, + 300, + 374, + 313 + ], + "score": 1.0, + "content": "Conference on Machine Learning, pp. 2397–2430. PMLR, 2023.", + "type": "text" + } + ], + "index": 16, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 317, + 505, + 331 + ], + "spans": [ + { + "bbox": [ + 105, + 317, + 505, + 331 + ], + "score": 1.0, + "content": "Yonatan Bisk, Rowan Zellers, Jianfeng Gao, Yejin Choi, et al. Piqa: Reasoning about physical", + "type": "text" + } + ], + "index": 17, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 329, + 506, + 343 + ], + "spans": [ + { + "bbox": [ + 115, + 329, + 506, + 343 + ], + "score": 1.0, + "content": "commonsense in natural language. In Proceedings of the AAAI conference on artificial intelligence,", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 115, + 340, + 252, + 353 + ], + "spans": [ + { + "bbox": [ + 115, + 340, + 252, + 353 + ], + "score": 1.0, + "content": "volume 34, pp. 7432–7439, 2020.", + "type": "text" + } + ], + "index": 19, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 359, + 335, + 370 + ], + "spans": [ + { + "bbox": [ + 106, + 359, + 335, + 370 + ], + "score": 1.0, + "content": "Guy E Blelloch. Prefix sums and their applications. 1990.", + "type": "text" + } + ], + "index": 20, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 376, + 506, + 389 + ], + "spans": [ + { + "bbox": [ + 105, + 376, + 506, + 389 + ], + "score": 1.0, + "content": "James Bradbury, Stephen Merity, Caiming Xiong, and Richard Socher. Quasi-recurrent neural", + "type": "text" + } + ], + "index": 21, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 387, + 320, + 400 + ], + "spans": [ + { + "bbox": [ + 115, + 387, + 320, + 400 + ], + "score": 1.0, + "content": "networks. arXiv preprint arXiv:1611.01576, 2016.", + "type": "text" + } + ], + "index": 22, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 405, + 505, + 418 + ], + "spans": [ + { + "bbox": [ + 106, + 405, + 505, + 418 + ], + "score": 1.0, + "content": "Tom Brown, Benjamin Mann, Nick Ryder, Melanie Subbiah, Jared D Kaplan, Prafulla Dhariwal,", + "type": "text" + } + ], + "index": 23, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 416, + 505, + 429 + ], + "spans": [ + { + "bbox": [ + 115, + 416, + 505, + 429 + ], + "score": 1.0, + "content": "Arvind Neelakantan, Pranav Shyam, Girish Sastry, Amanda Askell, et al. Language models are", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 114, + 426, + 484, + 441 + ], + "spans": [ + { + "bbox": [ + 114, + 426, + 484, + 441 + ], + "score": 1.0, + "content": "few-shot learners. Advances in neural information processing systems, 33:1877–1901, 2020.", + "type": "text" + } + ], + "index": 25, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 445, + 505, + 458 + ], + "spans": [ + { + "bbox": [ + 105, + 445, + 505, + 458 + ], + "score": 1.0, + "content": "Aydar Bulatov, Yuri Kuratov, and Mikhail S Burtsev. Scaling transformer to 1m tokens and beyond", + "type": "text" + } + ], + "index": 26, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 457, + 315, + 468 + ], + "spans": [ + { + "bbox": [ + 116, + 457, + 315, + 468 + ], + "score": 1.0, + "content": "with rmt. arXiv preprint arXiv:2304.11062, 2023.", + "type": "text" + } + ], + "index": 27, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 474, + 506, + 488 + ], + "spans": [ + { + "bbox": [ + 105, + 474, + 506, + 488 + ], + "score": 1.0, + "content": "Aakanksha Chowdhery, Sharan Narang, Jacob Devlin, Maarten Bosma, Gaurav Mishra, Adam Roberts,", + "type": "text" + } + ], + "index": 28, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 484, + 506, + 500 + ], + "spans": [ + { + "bbox": [ + 114, + 484, + 506, + 500 + ], + "score": 1.0, + "content": "Paul Barham, Hyung Won Chung, Charles Sutton, Sebastian Gehrmann, et al. Palm: Scaling", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 115, + 496, + 417, + 509 + ], + "spans": [ + { + "bbox": [ + 115, + 496, + 417, + 509 + ], + "score": 1.0, + "content": "language modeling with pathways. arXiv preprint arXiv:2204.02311, 2022.", + "type": "text" + } + ], + "index": 30, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 514, + 506, + 527 + ], + "spans": [ + { + "bbox": [ + 105, + 514, + 506, + 527 + ], + "score": 1.0, + "content": "Junyoung Chung, Caglar Gulcehre, KyungHyun Cho, and Yoshua Bengio. Empirical evaluation of", + "type": "text" + } + ], + "index": 31, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 524, + 493, + 539 + ], + "spans": [ + { + "bbox": [ + 114, + 524, + 493, + 539 + ], + "score": 1.0, + "content": "gated recurrent neural networks on sequence modeling. arXiv preprint arXiv:1412.3555, 2014.", + "type": "text" + } + ], + "index": 32, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 543, + 505, + 556 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 505, + 556 + ], + "score": 1.0, + "content": "Peter Clark, Isaac Cowhey, Oren Etzioni, Tushar Khot, Ashish Sabharwal, Carissa Schoenick, and", + "type": "text" + } + ], + "index": 33, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 554, + 507, + 567 + ], + "spans": [ + { + "bbox": [ + 116, + 554, + 507, + 567 + ], + "score": 1.0, + "content": "Oyvind Tafjord. Think you have solved question answering? try arc, the ai2 reasoning challenge.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 565, + 277, + 578 + ], + "spans": [ + { + "bbox": [ + 115, + 565, + 277, + 578 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:1803.05457, 2018.", + "type": "text" + } + ], + "index": 35, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 583, + 484, + 596 + ], + "spans": [ + { + "bbox": [ + 106, + 583, + 484, + 596 + ], + "score": 1.0, + "content": "Tri Dao. FlashAttention-2: Faster attention with better parallelism and work partitioning. 2023.", + "type": "text" + } + ], + "index": 36, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 601, + 505, + 614 + ], + "spans": [ + { + "bbox": [ + 106, + 601, + 505, + 614 + ], + "score": 1.0, + "content": "Tri Dao, Daniel Y. Fu, Stefano Ermon, Atri Rudra, and Christopher Re. FlashAttention: Fast and ´", + "type": "text" + } + ], + "index": 37, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 610, + 506, + 627 + ], + "spans": [ + { + "bbox": [ + 114, + 610, + 506, + 627 + ], + "score": 1.0, + "content": "memory-efficient exact attention with IO-awareness. In Advances in Neural Information Processing", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 114, + 623, + 177, + 635 + ], + "spans": [ + { + "bbox": [ + 114, + 623, + 177, + 635 + ], + "score": 1.0, + "content": "Systems, 2022.", + "type": "text" + } + ], + "index": 39, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 639, + 505, + 656 + ], + "spans": [ + { + "bbox": [ + 105, + 639, + 505, + 656 + ], + "score": 1.0, + "content": "Tri Dao, Daniel Y Fu, Khaled K Saab, Armin W Thomas, Atri Rudra, and Christopher Re. Hungry ´", + "type": "text" + } + ], + "index": 40, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 651, + 506, + 666 + ], + "spans": [ + { + "bbox": [ + 114, + 651, + 506, + 666 + ], + "score": 1.0, + "content": "hungry hippos: Towards language modeling with state space models. In The International", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 663, + 339, + 676 + ], + "spans": [ + { + "bbox": [ + 115, + 663, + 339, + 676 + ], + "score": 1.0, + "content": "Conference on Learning Representations (ICLR), 2023.", + "type": "text" + } + ], + "index": 42, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 680, + 506, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 680, + 506, + 694 + ], + "score": 1.0, + "content": "Yann N Dauphin, Angela Fan, Michael Auli, and David Grangier. Language modeling with gated con-", + "type": "text" + } + ], + "index": 43, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 692, + 507, + 705 + ], + "spans": [ + { + "bbox": [ + 115, + 692, + 507, + 705 + ], + "score": 1.0, + "content": "volutional networks. In International conference on machine learning, pp. 933–941. PMLR, 2017.", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 160, + 723 + ], + "score": 1.0, + "content": "DeepSound.", + "type": "text" + }, + { + "bbox": [ + 194, + 708, + 247, + 723 + ], + "score": 1.0, + "content": "Samplernn.", + "type": "text" + }, + { + "bbox": [ + 280, + 710, + 505, + 723 + ], + "score": 1.0, + "content": "https://github.com/deepsound-project/", + "type": "text" + } + ], + "index": 45, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 721, + 250, + 734 + ], + "spans": [ + { + "bbox": [ + 114, + 721, + 250, + 734 + ], + "score": 1.0, + "content": "samplernn-pytorch, 2017.", + "type": "text" + } + ], + "index": 46, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 82, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 506, + 96 + ], + "score": 1.0, + "content": "Jiayu Ding, Shuming Ma, Li Dong, Xingxing Zhang, Shaohan Huang, Wenhui Wang, and Furu Wei.", + "type": "text", + "cross_page": true + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 93, + 501, + 107 + ], + "spans": [ + { + "bbox": [ + 114, + 93, + 501, + 107 + ], + "score": 1.0, + "content": "Longnet: Scaling transformers to 1,000,000,000 tokens. arXiv preprint arXiv:2307.02486, 2023.", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 110, + 506, + 124 + ], + "spans": [ + { + "bbox": [ + 106, + 110, + 506, + 124 + ], + "score": 1.0, + "content": "Chris Donahue, Julian McAuley, and Miller Puckette. Adversarial audio synthesis. In International", + "type": "text", + "cross_page": true + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 122, + 307, + 136 + ], + "spans": [ + { + "bbox": [ + 115, + 122, + 307, + 136 + ], + "score": 1.0, + "content": "Conference on Learning Representations, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 3, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 141, + 505, + 153 + ], + "spans": [ + { + "bbox": [ + 106, + 141, + 505, + 153 + ], + "score": 1.0, + "content": "Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas", + "type": "text", + "cross_page": true + } + ], + "index": 4, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 152, + 505, + 164 + ], + "spans": [ + { + "bbox": [ + 116, + 152, + 505, + 164 + ], + "score": 1.0, + "content": "Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is", + "type": "text", + "cross_page": true + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 162, + 506, + 176 + ], + "spans": [ + { + "bbox": [ + 115, + 162, + 506, + 176 + ], + "score": 1.0, + "content": "worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929,", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 114, + 172, + 144, + 187 + ], + "spans": [ + { + "bbox": [ + 114, + 172, + 144, + 187 + ], + "score": 1.0, + "content": "2020.", + "type": "text", + "cross_page": true + } + ], + "index": 7, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 192, + 505, + 203 + ], + "spans": [ + { + "bbox": [ + 106, + 192, + 505, + 203 + ], + "score": 1.0, + "content": "Nelson Elhage, Neel Nanda, Catherine Olsson, Tom Henighan, Nicholas Joseph, Ben Mann, Amanda", + "type": "text", + "cross_page": true + } + ], + "index": 8, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 201, + 506, + 215 + ], + "spans": [ + { + "bbox": [ + 115, + 201, + 506, + 215 + ], + "score": 1.0, + "content": "Askell, Yuntao Bai, Anna Chen, Tom Conerly, Nova DasSarma, Dawn Drain, Deep Ganguli,", + "type": "text", + "cross_page": true + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 212, + 506, + 226 + ], + "spans": [ + { + "bbox": [ + 115, + 212, + 506, + 226 + ], + "score": 1.0, + "content": "Zac Hatfield-Dodds, Danny Hernandez, Andy Jones, Jackson Kernion, Liane Lovitt, Kamal", + "type": "text", + "cross_page": true + } + ], + "index": 10 + }, + { + "bbox": [ + 116, + 224, + 505, + 235 + ], + "spans": [ + { + "bbox": [ + 116, + 224, + 505, + 235 + ], + "score": 1.0, + "content": "Ndousse, Dario Amodei, Tom Brown, Jack Clark, Jared Kaplan, Sam McCandlish, and Chris", + "type": "text", + "cross_page": true + } + ], + "index": 11 + }, + { + "bbox": [ + 116, + 235, + 506, + 246 + ], + "spans": [ + { + "bbox": [ + 116, + 235, + 506, + 246 + ], + "score": 1.0, + "content": "Olah. A mathematical framework for transformer circuits. Transformer Circuits Thread, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 12 + }, + { + "bbox": [ + 116, + 246, + 359, + 257 + ], + "spans": [ + { + "bbox": [ + 116, + 246, + 359, + 257 + ], + "score": 1.0, + "content": "https://transformer-circuits.pub/2021/framework/index.html.", + "type": "text", + "cross_page": true + } + ], + "index": 13, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 263, + 506, + 276 + ], + "spans": [ + { + "bbox": [ + 106, + 263, + 506, + 276 + ], + "score": 1.0, + "content": "Daniel Y Fu, Elliot L Epstein, Eric Nguyen, Armin W Thomas, Michael Zhang, Tri Dao, Atri Rudra,", + "type": "text", + "cross_page": true + } + ], + "index": 14, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 274, + 506, + 288 + ], + "spans": [ + { + "bbox": [ + 114, + 274, + 506, + 288 + ], + "score": 1.0, + "content": "and Christopher Re. Simple hardware-efficient long convolutions for sequence modeling. ´ The", + "type": "text", + "cross_page": true + } + ], + "index": 15 + }, + { + "bbox": [ + 115, + 284, + 365, + 298 + ], + "spans": [ + { + "bbox": [ + 115, + 284, + 365, + 298 + ], + "score": 1.0, + "content": "International Conference on Machine Learning (ICML), 2023.", + "type": "text", + "cross_page": true + } + ], + "index": 16, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 303, + 506, + 317 + ], + "spans": [ + { + "bbox": [ + 106, + 303, + 506, + 317 + ], + "score": 1.0, + "content": "Ken-ichi Funahashi and Yuichi Nakamura. Approximation of dynamical systems by continuous time", + "type": "text", + "cross_page": true + } + ], + "index": 17, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 315, + 376, + 326 + ], + "spans": [ + { + "bbox": [ + 116, + 315, + 376, + 326 + ], + "score": 1.0, + "content": "recurrent neural networks. Neural networks, 6(6):801–806, 1993.", + "type": "text", + "cross_page": true + } + ], + "index": 18, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 330, + 507, + 347 + ], + "spans": [ + { + "bbox": [ + 104, + 330, + 507, + 347 + ], + "score": 1.0, + "content": "Leo Gao, Stella Biderman, Sid Black, Laurence Golding, Travis Hoppe, Charles Foster, Jason Phang,", + "type": "text", + "cross_page": true + } + ], + "index": 19, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 343, + 506, + 357 + ], + "spans": [ + { + "bbox": [ + 115, + 343, + 506, + 357 + ], + "score": 1.0, + "content": "Horace He, Anish Thite, Noa Nabeshima, Shawn Presser, and Connor Leahy. The Pile: An 800gb", + "type": "text", + "cross_page": true + } + ], + "index": 20 + }, + { + "bbox": [ + 114, + 353, + 460, + 366 + ], + "spans": [ + { + "bbox": [ + 114, + 353, + 460, + 366 + ], + "score": 1.0, + "content": "dataset of diverse text for language modeling. arXiv preprint arXiv:2101.00027, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 21, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 371, + 506, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 371, + 506, + 385 + ], + "score": 1.0, + "content": "Leo Gao, Jonathan Tow, Stella Biderman, Sid Black, Anthony DiPofi, Charles Foster, Laurence", + "type": "text", + "cross_page": true + } + ], + "index": 22, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 381, + 507, + 398 + ], + "spans": [ + { + "bbox": [ + 114, + 381, + 507, + 398 + ], + "score": 1.0, + "content": "Golding, Jeffrey Hsu, Kyle McDonell, Niklas Muennighoff, Jason Phang, Laria Reynolds, Eric Tang,", + "type": "text", + "cross_page": true + } + ], + "index": 23 + }, + { + "bbox": [ + 115, + 393, + 506, + 407 + ], + "spans": [ + { + "bbox": [ + 115, + 393, + 506, + 407 + ], + "score": 1.0, + "content": "Anish Thite, Ben Wang, Kevin Wang, and Andy Zou. A framework for few-shot language model", + "type": "text", + "cross_page": true + } + ], + "index": 24 + }, + { + "bbox": [ + 115, + 404, + 485, + 418 + ], + "spans": [ + { + "bbox": [ + 115, + 404, + 485, + 418 + ], + "score": 1.0, + "content": "evaluation, September 2021. URL https://doi.org/10.5281/zenodo.5371628.", + "type": "text", + "cross_page": true + } + ], + "index": 25, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 422, + 506, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 422, + 506, + 437 + ], + "score": 1.0, + "content": "Karan Goel, Albert Gu, Chris Donahue, and Christopher Re. It’s raw! audio generation with state-space ´", + "type": "text", + "cross_page": true + } + ], + "index": 26, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 433, + 426, + 447 + ], + "spans": [ + { + "bbox": [ + 115, + 433, + 426, + 447 + ], + "score": 1.0, + "content": "models. In The International Conference on Machine Learning (ICML), 2022.", + "type": "text", + "cross_page": true + } + ], + "index": 27, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 452, + 506, + 466 + ], + "spans": [ + { + "bbox": [ + 106, + 452, + 506, + 466 + ], + "score": 1.0, + "content": "Albert Gu, Tri Dao, Stefano Ermon, Atri Rudra, and Christopher Re. Hippo: Recurrent memory with ´", + "type": "text", + "cross_page": true + } + ], + "index": 28, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 463, + 506, + 477 + ], + "spans": [ + { + "bbox": [ + 115, + 463, + 506, + 477 + ], + "score": 1.0, + "content": "optimal polynomial projections. In Advances in Neural Information Processing Systems (NeurIPS),", + "type": "text", + "cross_page": true + } + ], + "index": 29 + }, + { + "bbox": [ + 115, + 472, + 147, + 487 + ], + "spans": [ + { + "bbox": [ + 115, + 472, + 147, + 487 + ], + "score": 1.0, + "content": "2020a.", + "type": "text", + "cross_page": true + } + ], + "index": 30, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 491, + 506, + 506 + ], + "spans": [ + { + "bbox": [ + 105, + 491, + 506, + 506 + ], + "score": 1.0, + "content": "Albert Gu, Caglar Gulcehre, Tom Le Paine, Matt Hoffman, and Razvan Pascanu. Improving the gating", + "type": "text", + "cross_page": true + } + ], + "index": 31, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 501, + 506, + 518 + ], + "spans": [ + { + "bbox": [ + 113, + 501, + 506, + 518 + ], + "score": 1.0, + "content": "mechanism of recurrent neural networks. In The International Conference on Machine Learning", + "type": "text", + "cross_page": true + } + ], + "index": 32 + }, + { + "bbox": [ + 115, + 514, + 181, + 525 + ], + "spans": [ + { + "bbox": [ + 115, + 514, + 181, + 525 + ], + "score": 1.0, + "content": "(ICML), 2020b.", + "type": "text", + "cross_page": true + } + ], + "index": 33, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 532, + 505, + 544 + ], + "spans": [ + { + "bbox": [ + 106, + 532, + 505, + 544 + ], + "score": 1.0, + "content": "Albert Gu, Isys Johnson, Karan Goel, Khaled Saab, Tri Dao, Atri Rudra, and Christopher Re.´", + "type": "text", + "cross_page": true + } + ], + "index": 34, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 542, + 506, + 556 + ], + "spans": [ + { + "bbox": [ + 115, + 542, + 506, + 556 + ], + "score": 1.0, + "content": "Combining recurrent, convolutional, and continuous-time models with the structured learnable", + "type": "text", + "cross_page": true + } + ], + "index": 35 + }, + { + "bbox": [ + 116, + 554, + 500, + 566 + ], + "spans": [ + { + "bbox": [ + 116, + 554, + 500, + 566 + ], + "score": 1.0, + "content": "linear state space layer. In Advances in Neural Information Processing Systems (NeurIPS), 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 570, + 506, + 585 + ], + "spans": [ + { + "bbox": [ + 106, + 570, + 506, + 585 + ], + "score": 1.0, + "content": "Albert Gu, Karan Goel, and Christopher Re. Efficiently modeling long sequences with structured ´", + "type": "text", + "cross_page": true + } + ], + "index": 37, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 583, + 475, + 595 + ], + "spans": [ + { + "bbox": [ + 116, + 583, + 475, + 595 + ], + "score": 1.0, + "content": "state spaces. In The International Conference on Learning Representations (ICLR), 2022a.", + "type": "text", + "cross_page": true + } + ], + "index": 38, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 599, + 505, + 613 + ], + "spans": [ + { + "bbox": [ + 106, + 599, + 505, + 613 + ], + "score": 1.0, + "content": "Albert Gu, Ankit Gupta, Karan Goel, and Christopher Re. On the parameterization and initialization ´", + "type": "text", + "cross_page": true + } + ], + "index": 39, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 613, + 506, + 624 + ], + "spans": [ + { + "bbox": [ + 116, + 613, + 506, + 624 + ], + "score": 1.0, + "content": "of diagonal state space models. In Advances in Neural Information Processing Systems (NeurIPS),", + "type": "text", + "cross_page": true + } + ], + "index": 40 + }, + { + "bbox": [ + 115, + 621, + 148, + 636 + ], + "spans": [ + { + "bbox": [ + 115, + 621, + 148, + 636 + ], + "score": 1.0, + "content": "2022b.", + "type": "text", + "cross_page": true + } + ], + "index": 41, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 640, + 507, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 640, + 507, + 654 + ], + "score": 1.0, + "content": "Albert Gu, Isys Johnson, Aman Timalsina, Atri Rudra, and Christopher Re. How to train your hippo: ´", + "type": "text", + "cross_page": true + } + ], + "index": 42, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 650, + 506, + 666 + ], + "spans": [ + { + "bbox": [ + 114, + 650, + 506, + 666 + ], + "score": 1.0, + "content": "State space models with generalized basis projections. In The International Conference on Learning", + "type": "text", + "cross_page": true + } + ], + "index": 43 + }, + { + "bbox": [ + 115, + 662, + 240, + 676 + ], + "spans": [ + { + "bbox": [ + 115, + 662, + 240, + 676 + ], + "score": 1.0, + "content": "Representations (ICLR), 2023.", + "type": "text", + "cross_page": true + } + ], + "index": 44, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 680, + 506, + 694 + ], + "spans": [ + { + "bbox": [ + 106, + 680, + 506, + 694 + ], + "score": 1.0, + "content": "Ankit Gupta. Diagonal state spaces are as effective as structured state spaces. In Advances in Neural", + "type": "text", + "cross_page": true + } + ], + "index": 45, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 691, + 315, + 704 + ], + "spans": [ + { + "bbox": [ + 114, + 691, + 315, + 704 + ], + "score": 1.0, + "content": "Information Processing Systems (NeurIPS), 2022.", + "type": "text", + "cross_page": true + } + ], + "index": 46, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 707, + 507, + 725 + ], + "spans": [ + { + "bbox": [ + 104, + 707, + 507, + 725 + ], + "score": 1.0, + "content": "David Ha, Andrew Dai, and Quoc V. Le. Hypernetworks. In International Conference on Learning", + "type": "text", + "cross_page": true + } + ], + "index": 47, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 720, + 210, + 734 + ], + "spans": [ + { + "bbox": [ + 114, + 720, + 210, + 734 + ], + "score": 1.0, + "content": "Representations, 2017.", + "type": "text", + "cross_page": true + } + ], + "index": 48, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 81, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 506, + 96 + ], + "score": 1.0, + "content": "Ramin Hasani, Mathias Lechner, Tsun-Hsuan Wang, Makram Chahine, Alexander Amini, and", + "type": "text", + "cross_page": true + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 91, + 506, + 109 + ], + "spans": [ + { + "bbox": [ + 114, + 91, + 506, + 109 + ], + "score": 1.0, + "content": "Daniela Rus. Liquid structural state-space models. In The International Conference on Learning", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 115, + 104, + 240, + 117 + ], + "spans": [ + { + "bbox": [ + 115, + 104, + 240, + 117 + ], + "score": 1.0, + "content": "Representations (ICLR), 2023.", + "type": "text", + "cross_page": true + } + ], + "index": 2, + "is_list_end_line": true + }, + { + "bbox": [ + 103, + 120, + 506, + 137 + ], + "spans": [ + { + "bbox": [ + 103, + 120, + 506, + 137 + ], + "score": 1.0, + "content": "Mikael Henaff, Arthur Szlam, and Yann LeCun. Recurrent orthogonal networks and long-memory", + "type": "text", + "cross_page": true + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 135, + 419, + 146 + ], + "spans": [ + { + "bbox": [ + 116, + 135, + 419, + 146 + ], + "score": 1.0, + "content": "tasks. In The International Conference on Machine Learning (ICML), 2016.", + "type": "text", + "cross_page": true + } + ], + "index": 4, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 152, + 506, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 152, + 506, + 167 + ], + "score": 1.0, + "content": "Dan Hendrycks and Kevin Gimpel. Gaussian error linear units (gelus). arXiv preprint", + "type": "text", + "cross_page": true + } + ], + "index": 5, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 163, + 219, + 177 + ], + "spans": [ + { + "bbox": [ + 115, + 163, + 219, + 177 + ], + "score": 1.0, + "content": "arXiv:1606.08415, 2016.", + "type": "text", + "cross_page": true + } + ], + "index": 6, + "is_list_end_line": true + }, + { + "bbox": [ + 103, + 180, + 507, + 197 + ], + "spans": [ + { + "bbox": [ + 103, + 180, + 507, + 197 + ], + "score": 1.0, + "content": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8):", + "type": "text", + "cross_page": true + } + ], + "index": 7, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 193, + 191, + 205 + ], + "spans": [ + { + "bbox": [ + 116, + 193, + 191, + 205 + ], + "score": 1.0, + "content": "1735–1780, 1997.", + "type": "text", + "cross_page": true + } + ], + "index": 8, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 210, + 506, + 225 + ], + "spans": [ + { + "bbox": [ + 104, + 210, + 506, + 225 + ], + "score": 1.0, + "content": "Jordan Hoffmann, Sebastian Borgeaud, Arthur Mensch, Elena Buchatskaya, Trevor Cai, Eliza", + "type": "text", + "cross_page": true + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 222, + 507, + 235 + ], + "spans": [ + { + "bbox": [ + 115, + 222, + 507, + 235 + ], + "score": 1.0, + "content": "Rutherford, Diego de Las Casas, Lisa Anne Hendricks, Johannes Welbl, Aidan Clark, et al.", + "type": "text", + "cross_page": true + } + ], + "index": 10 + }, + { + "bbox": [ + 115, + 233, + 506, + 247 + ], + "spans": [ + { + "bbox": [ + 115, + 233, + 506, + 247 + ], + "score": 1.0, + "content": "An empirical analysis of compute-optimal large language model training. Advances in Neural", + "type": "text", + "cross_page": true + } + ], + "index": 11 + }, + { + "bbox": [ + 116, + 245, + 344, + 256 + ], + "spans": [ + { + "bbox": [ + 116, + 245, + 344, + 256 + ], + "score": 1.0, + "content": "Information Processing Systems, 35:30016–30030, 2022.", + "type": "text", + "cross_page": true + } + ], + "index": 12, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 262, + 506, + 276 + ], + "spans": [ + { + "bbox": [ + 106, + 262, + 506, + 276 + ], + "score": 1.0, + "content": "Weizhe Hua, Zihang Dai, Hanxiao Liu, and Quoc Le. Transformer quality in linear time. In", + "type": "text", + "cross_page": true + } + ], + "index": 13, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 272, + 429, + 288 + ], + "spans": [ + { + "bbox": [ + 114, + 272, + 429, + 288 + ], + "score": 1.0, + "content": "International Conference on Machine Learning, pp. 9099–9117. PMLR, 2022.", + "type": "text", + "cross_page": true + } + ], + "index": 14, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 293, + 505, + 304 + ], + "spans": [ + { + "bbox": [ + 105, + 293, + 505, + 304 + ], + "score": 1.0, + "content": "Hassan Ismail Fawaz, Germain Forestier, Jonathan Weber, Lhassane Idoumghar, and Pierre-Alain", + "type": "text", + "cross_page": true + } + ], + "index": 15, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 300, + 508, + 318 + ], + "spans": [ + { + "bbox": [ + 114, + 300, + 508, + 318 + ], + "score": 1.0, + "content": "Muller. Deep learning for time series classification: a review. Data mining and knowledge discovery,", + "type": "text", + "cross_page": true + } + ], + "index": 16 + }, + { + "bbox": [ + 114, + 312, + 205, + 326 + ], + "spans": [ + { + "bbox": [ + 114, + 312, + 205, + 326 + ], + "score": 1.0, + "content": "33(4):917–963, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 17, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 331, + 506, + 345 + ], + "spans": [ + { + "bbox": [ + 105, + 331, + 506, + 345 + ], + "score": 1.0, + "content": "Andrei Ivanov, Nikoli Dryden, Tal Ben-Nun, Shigang Li, and Torsten Hoefler. Data movement is all", + "type": "text", + "cross_page": true + } + ], + "index": 18, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 342, + 508, + 358 + ], + "spans": [ + { + "bbox": [ + 114, + 342, + 508, + 358 + ], + "score": 1.0, + "content": "you need: A case study on optimizing transformers. Proceedings of Machine Learning and Systems,", + "type": "text", + "cross_page": true + } + ], + "index": 19 + }, + { + "bbox": [ + 116, + 354, + 190, + 366 + ], + "spans": [ + { + "bbox": [ + 116, + 354, + 190, + 366 + ], + "score": 1.0, + "content": "3:711–732, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 20, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 371, + 506, + 385 + ], + "spans": [ + { + "bbox": [ + 104, + 371, + 506, + 385 + ], + "score": 1.0, + "content": "Li Jing, Caglar Gulcehre, John Peurifoy, Yichen Shen, Max Tegmark, Marin Soljacic, and Yoshua", + "type": "text", + "cross_page": true + } + ], + "index": 21, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 383, + 506, + 397 + ], + "spans": [ + { + "bbox": [ + 116, + 383, + 506, + 397 + ], + "score": 1.0, + "content": "Bengio. Gated orthogonal recurrent units: On learning to forget. Neural computation, 31(4):", + "type": "text", + "cross_page": true + } + ], + "index": 22 + }, + { + "bbox": [ + 114, + 392, + 182, + 408 + ], + "spans": [ + { + "bbox": [ + 114, + 392, + 182, + 408 + ], + "score": 1.0, + "content": "765–783, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 23, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 413, + 461, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 413, + 461, + 426 + ], + "score": 1.0, + "content": "Rudolph Emil Kalman. A new approach to linear filtering and prediction problems. 1960.", + "type": "text", + "cross_page": true + } + ], + "index": 24, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 431, + 507, + 444 + ], + "spans": [ + { + "bbox": [ + 105, + 431, + 507, + 444 + ], + "score": 1.0, + "content": "Angelos Katharopoulos, Apoorv Vyas, Nikolaos Pappas, and Franc¸ois Fleuret. Transformers are rnns:", + "type": "text", + "cross_page": true + } + ], + "index": 25, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 441, + 506, + 455 + ], + "spans": [ + { + "bbox": [ + 115, + 441, + 506, + 455 + ], + "score": 1.0, + "content": "Fast autoregressive transformers with linear attention. In International Conference on Machine", + "type": "text", + "cross_page": true + } + ], + "index": 26 + }, + { + "bbox": [ + 114, + 452, + 278, + 465 + ], + "spans": [ + { + "bbox": [ + 114, + 452, + 278, + 465 + ], + "score": 1.0, + "content": "Learning, pp. 5156–5165. PMLR, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 27, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 472, + 505, + 484 + ], + "spans": [ + { + "bbox": [ + 106, + 472, + 505, + 484 + ], + "score": 1.0, + "content": "Chrysoula Kosma, Giannis Nikolentzos, and Michalis Vazirgiannis. Time-parameterized convolutional", + "type": "text", + "cross_page": true + } + ], + "index": 28, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 482, + 483, + 496 + ], + "spans": [ + { + "bbox": [ + 115, + 482, + 483, + 496 + ], + "score": 1.0, + "content": "neural networks for irregularly sampled time series. arXiv preprint arXiv:2308.03210, 2023.", + "type": "text", + "cross_page": true + } + ], + "index": 29, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 500, + 506, + 515 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 506, + 515 + ], + "score": 1.0, + "content": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep", + "type": "text", + "cross_page": true + } + ], + "index": 30, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 512, + 487, + 525 + ], + "spans": [ + { + "bbox": [ + 115, + 512, + 487, + 525 + ], + "score": 1.0, + "content": "convolutional neural networks. Advances in neural information processing systems, 25, 2012.", + "type": "text", + "cross_page": true + } + ], + "index": 31, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 529, + 506, + 544 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 506, + 544 + ], + "score": 1.0, + "content": "Tao Lei. When attention meets fast recurrence: Training language models with reduced compute.", + "type": "text", + "cross_page": true + } + ], + "index": 32, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 541, + 279, + 554 + ], + "spans": [ + { + "bbox": [ + 114, + 541, + 279, + 554 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:2102.12459, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 33, + "is_list_end_line": true + }, + { + "bbox": [ + 103, + 558, + 506, + 575 + ], + "spans": [ + { + "bbox": [ + 103, + 558, + 506, + 575 + ], + "score": 1.0, + "content": "Tao Lei, Yu Zhang, Sida I Wang, Hui Dai, and Yoav Artzi. Simple recurrent units for highly", + "type": "text", + "cross_page": true + } + ], + "index": 34, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 570, + 382, + 584 + ], + "spans": [ + { + "bbox": [ + 113, + 570, + 382, + 584 + ], + "score": 1.0, + "content": "parallelizable recurrence. arXiv preprint arXiv:1709.02755, 2017.", + "type": "text", + "cross_page": true + } + ], + "index": 35, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 588, + 507, + 603 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 507, + 603 + ], + "score": 1.0, + "content": "Mario Lezcano-Casado and David Mart´ınez-Rubio. Cheap orthogonal constraints in neural networks:", + "type": "text", + "cross_page": true + } + ], + "index": 36, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 600, + 506, + 614 + ], + "spans": [ + { + "bbox": [ + 115, + 600, + 506, + 614 + ], + "score": 1.0, + "content": "A simple parametrization of the orthogonal and unitary group. In The International Conference", + "type": "text", + "cross_page": true + } + ], + "index": 37 + }, + { + "bbox": [ + 114, + 610, + 265, + 623 + ], + "spans": [ + { + "bbox": [ + 114, + 610, + 265, + 623 + ], + "score": 1.0, + "content": "on Machine Learning (ICML), 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 38, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 629, + 506, + 643 + ], + "spans": [ + { + "bbox": [ + 106, + 629, + 506, + 643 + ], + "score": 1.0, + "content": "Yuhong Li, Tianle Cai, Yi Zhang, Deming Chen, and Debadeepta Dey. What makes convolutional", + "type": "text", + "cross_page": true + } + ], + "index": 39, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 639, + 506, + 655 + ], + "spans": [ + { + "bbox": [ + 114, + 639, + 506, + 655 + ], + "score": 1.0, + "content": "models great on long sequence modeling? In The International Conference on Learning", + "type": "text", + "cross_page": true + } + ], + "index": 40 + }, + { + "bbox": [ + 116, + 651, + 240, + 665 + ], + "spans": [ + { + "bbox": [ + 116, + 651, + 240, + 665 + ], + "score": 1.0, + "content": "Representations (ICLR), 2023.", + "type": "text", + "cross_page": true + } + ], + "index": 41, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 670, + 507, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 670, + 507, + 684 + ], + "score": 1.0, + "content": "Xuezhe Ma, Chunting Zhou, Xiang Kong, Junxian He, Liangke Gui, Graham Neubig, Jonathan May,", + "type": "text", + "cross_page": true + } + ], + "index": 42, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 681, + 506, + 694 + ], + "spans": [ + { + "bbox": [ + 115, + 681, + 506, + 694 + ], + "score": 1.0, + "content": "and Luke Zettlemoyer. Mega: moving average equipped gated attention. In The International", + "type": "text", + "cross_page": true + } + ], + "index": 43 + }, + { + "bbox": [ + 116, + 691, + 340, + 705 + ], + "spans": [ + { + "bbox": [ + 116, + 691, + 340, + 705 + ], + "score": 1.0, + "content": "Conference on Learning Representations (ICLR), 2023.", + "type": "text", + "cross_page": true + } + ], + "index": 44, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "score": 1.0, + "content": "Eric Martin and Chris Cundy. Parallelizing linear recurrent neural nets over sequence length. In", + "type": "text", + "cross_page": true + } + ], + "index": 45, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 720, + 363, + 734 + ], + "spans": [ + { + "bbox": [ + 115, + 720, + 363, + 734 + ], + "score": 1.0, + "content": "International Conference on Learning Representations, 2018.", + "type": "text", + "cross_page": true + } + ], + "index": 46, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 80, + 507, + 97 + ], + "spans": [ + { + "bbox": [ + 104, + 80, + 507, + 97 + ], + "score": 1.0, + "content": "Harsh Mehta, Ankit Gupta, Ashok Cutkosky, and Behnam Neyshabur. Long range language modeling", + "type": "text", + "cross_page": true + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 93, + 506, + 107 + ], + "spans": [ + { + "bbox": [ + 114, + 93, + 506, + 107 + ], + "score": 1.0, + "content": "via gated state spaces. In The International Conference on Learning Representations (ICLR), 2023.", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 111, + 506, + 125 + ], + "spans": [ + { + "bbox": [ + 105, + 111, + 506, + 125 + ], + "score": 1.0, + "content": "Zakaria Mhammedi, Andrew Hellicar, Ashfaqur Rahman, and James Bailey. Efficient orthogonal", + "type": "text", + "cross_page": true + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 122, + 506, + 135 + ], + "spans": [ + { + "bbox": [ + 114, + 122, + 506, + 135 + ], + "score": 1.0, + "content": "parametrisation of recurrent neural networks using householder reflections. In International", + "type": "text", + "cross_page": true + } + ], + "index": 3 + }, + { + "bbox": [ + 114, + 132, + 375, + 146 + ], + "spans": [ + { + "bbox": [ + 114, + 132, + 375, + 146 + ], + "score": 1.0, + "content": "Conference on Machine Learning, pp. 2401–2409. PMLR, 2017.", + "type": "text", + "cross_page": true + } + ], + "index": 4, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 149, + 505, + 163 + ], + "spans": [ + { + "bbox": [ + 105, + 149, + 505, + 163 + ], + "score": 1.0, + "content": "Eric Nguyen, Karan Goel, Albert Gu, Gordon Downs, Preey Shah, Tri Dao, Stephen Baccus, and", + "type": "text", + "cross_page": true + } + ], + "index": 5, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 161, + 507, + 175 + ], + "spans": [ + { + "bbox": [ + 115, + 161, + 507, + 175 + ], + "score": 1.0, + "content": "Christopher Re. S4nd: Modeling images and videos as multidimensional signals with state spaces. ´", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 115, + 173, + 363, + 185 + ], + "spans": [ + { + "bbox": [ + 115, + 173, + 363, + 185 + ], + "score": 1.0, + "content": "In Advances in Neural Information Processing Systems, 2022.", + "type": "text", + "cross_page": true + } + ], + "index": 7, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 189, + 506, + 203 + ], + "spans": [ + { + "bbox": [ + 105, + 189, + 506, + 203 + ], + "score": 1.0, + "content": "Eric Nguyen, Michael Poli, Marjan Faizi, Armin Thomas, Callum Birch-Sykes, Michael Wornow,", + "type": "text", + "cross_page": true + } + ], + "index": 8, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 200, + 506, + 215 + ], + "spans": [ + { + "bbox": [ + 114, + 200, + 506, + 215 + ], + "score": 1.0, + "content": "Aman Patel, Clayton Rabideau, Stefano Massaroli, Yoshua Bengio, et al. Hyenadna: Long-range", + "type": "text", + "cross_page": true + } + ], + "index": 9 + }, + { + "bbox": [ + 113, + 211, + 507, + 226 + ], + "spans": [ + { + "bbox": [ + 113, + 211, + 507, + 226 + ], + "score": 1.0, + "content": "genomic sequence modeling at single nucleotide resolution. arXiv preprint arXiv:2306.15794, 2023.", + "type": "text", + "cross_page": true + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 229, + 505, + 241 + ], + "spans": [ + { + "bbox": [ + 106, + 229, + 505, + 241 + ], + "score": 1.0, + "content": "Catherine Olsson, Nelson Elhage, Neel Nanda, Nicholas Joseph, Nova DasSarma, Tom Henighan,", + "type": "text", + "cross_page": true + } + ], + "index": 11, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 240, + 505, + 252 + ], + "spans": [ + { + "bbox": [ + 115, + 240, + 505, + 252 + ], + "score": 1.0, + "content": "Ben Mann, Amanda Askell, Yuntao Bai, Anna Chen, Tom Conerly, Dawn Drain, Deep Ganguli,", + "type": "text", + "cross_page": true + } + ], + "index": 12 + }, + { + "bbox": [ + 114, + 251, + 506, + 265 + ], + "spans": [ + { + "bbox": [ + 114, + 251, + 506, + 265 + ], + "score": 1.0, + "content": "Zac Hatfield-Dodds, Danny Hernandez, Scott Johnston, Andy Jones, Jackson Kernion, Liane", + "type": "text", + "cross_page": true + } + ], + "index": 13 + }, + { + "bbox": [ + 115, + 263, + 506, + 275 + ], + "spans": [ + { + "bbox": [ + 115, + 263, + 506, + 275 + ], + "score": 1.0, + "content": "Lovitt, Kamal Ndousse, Dario Amodei, Tom Brown, Jack Clark, Jared Kaplan, Sam McCandlish,", + "type": "text", + "cross_page": true + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 272, + 507, + 286 + ], + "spans": [ + { + "bbox": [ + 115, + 272, + 507, + 286 + ], + "score": 1.0, + "content": "and Chris Olah. In-context learning and induction heads. Transformer Circuits Thread, 2022.", + "type": "text", + "cross_page": true + } + ], + "index": 15 + }, + { + "bbox": [ + 115, + 284, + 477, + 296 + ], + "spans": [ + { + "bbox": [ + 115, + 284, + 477, + 296 + ], + "score": 1.0, + "content": "https://transformer-circuits.pub/2022/in-context-learning-and-induction-heads/index.html.", + "type": "text", + "cross_page": true + } + ], + "index": 16, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 302, + 506, + 313 + ], + "spans": [ + { + "bbox": [ + 106, + 302, + 506, + 313 + ], + "score": 1.0, + "content": "Aaron van den Oord, Sander Dieleman, Heiga Zen, Karen Simonyan, Oriol Vinyals, Alex Graves,", + "type": "text", + "cross_page": true + } + ], + "index": 17, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 312, + 505, + 324 + ], + "spans": [ + { + "bbox": [ + 115, + 312, + 505, + 324 + ], + "score": 1.0, + "content": "Nal Kalchbrenner, Andrew Senior, and Koray Kavukcuoglu. Wavenet: A generative model for", + "type": "text", + "cross_page": true + } + ], + "index": 18 + }, + { + "bbox": [ + 114, + 322, + 322, + 336 + ], + "spans": [ + { + "bbox": [ + 114, + 322, + 322, + 336 + ], + "score": 1.0, + "content": "raw audio. arXiv preprint arXiv:1609.03499, 2016.", + "type": "text", + "cross_page": true + } + ], + "index": 19, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 339, + 506, + 354 + ], + "spans": [ + { + "bbox": [ + 105, + 339, + 506, + 354 + ], + "score": 1.0, + "content": "Antonio Orvieto, Samuel L Smith, Albert Gu, Anushan Fernando, Caglar Gulcehre, Razvan Pascanu,", + "type": "text", + "cross_page": true + } + ], + "index": 20, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 351, + 506, + 365 + ], + "spans": [ + { + "bbox": [ + 114, + 351, + 506, + 365 + ], + "score": 1.0, + "content": "and Soham De. Resurrecting recurrent neural networks for long sequences. arXiv preprint", + "type": "text", + "cross_page": true + } + ], + "index": 21 + }, + { + "bbox": [ + 114, + 362, + 220, + 376 + ], + "spans": [ + { + "bbox": [ + 114, + 362, + 220, + 376 + ], + "score": 1.0, + "content": "arXiv:2303.06349, 2023.", + "type": "text", + "cross_page": true + } + ], + "index": 22, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 380, + 506, + 392 + ], + "spans": [ + { + "bbox": [ + 106, + 380, + 506, + 392 + ], + "score": 1.0, + "content": "Denis Paperno, German Kruszewski, Angeliki Lazaridou, Quan Ngoc Pham, Raffaella Bernardi, ´", + "type": "text", + "cross_page": true + } + ], + "index": 23, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 390, + 507, + 405 + ], + "spans": [ + { + "bbox": [ + 114, + 390, + 507, + 405 + ], + "score": 1.0, + "content": "Sandro Pezzelle, Marco Baroni, Gemma Boleda, and Raquel Fernandez. The lambada dataset: ´", + "type": "text", + "cross_page": true + } + ], + "index": 24 + }, + { + "bbox": [ + 114, + 400, + 487, + 416 + ], + "spans": [ + { + "bbox": [ + 114, + 400, + 487, + 416 + ], + "score": 1.0, + "content": "Word prediction requiring a broad discourse context. arXiv preprint arXiv:1606.06031, 2016.", + "type": "text", + "cross_page": true + } + ], + "index": 25, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 420, + 505, + 432 + ], + "spans": [ + { + "bbox": [ + 106, + 420, + 505, + 432 + ], + "score": 1.0, + "content": "Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural", + "type": "text", + "cross_page": true + } + ], + "index": 26, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 430, + 443, + 444 + ], + "spans": [ + { + "bbox": [ + 114, + 430, + 443, + 444 + ], + "score": 1.0, + "content": "networks. In International conference on machine learning, pp. 1310–1318, 2013.", + "type": "text", + "cross_page": true + } + ], + "index": 27, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 445, + 507, + 464 + ], + "spans": [ + { + "bbox": [ + 104, + 445, + 507, + 464 + ], + "score": 1.0, + "content": "Bo Peng, Eric Alcaide, Quentin Anthony, Alon Albalak, Samuel Arcadinho, Huanqi Cao, Xin Cheng,", + "type": "text", + "cross_page": true + } + ], + "index": 28, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 458, + 506, + 473 + ], + "spans": [ + { + "bbox": [ + 114, + 458, + 506, + 473 + ], + "score": 1.0, + "content": "Michael Chung, Matteo Grella, Kranthi Kiran GV, et al. Rwkv: Reinventing rnns for the transformer", + "type": "text", + "cross_page": true + } + ], + "index": 29 + }, + { + "bbox": [ + 114, + 469, + 295, + 483 + ], + "spans": [ + { + "bbox": [ + 114, + 469, + 295, + 483 + ], + "score": 1.0, + "content": "era. arXiv preprint arXiv:2305.13048, 2023.", + "type": "text", + "cross_page": true + } + ], + "index": 30, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 486, + 507, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 486, + 507, + 502 + ], + "score": 1.0, + "content": "Michael Poli, Stefano Massaroli, Eric Nguyen, Daniel Y Fu, Tri Dao, Stephen Baccus, Yoshua Bengio,", + "type": "text", + "cross_page": true + } + ], + "index": 31, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 496, + 506, + 514 + ], + "spans": [ + { + "bbox": [ + 114, + 496, + 506, + 514 + ], + "score": 1.0, + "content": "Stefano Ermon, and Christopher Re. Hyena hierarchy: Towards larger convolutional language ´", + "type": "text", + "cross_page": true + } + ], + "index": 32 + }, + { + "bbox": [ + 114, + 507, + 311, + 522 + ], + "spans": [ + { + "bbox": [ + 114, + 507, + 311, + 522 + ], + "score": 1.0, + "content": "models. arXiv preprint arXiv:2302.10866, 2023.", + "type": "text", + "cross_page": true + } + ], + "index": 33, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 527, + 506, + 541 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 506, + 541 + ], + "score": 1.0, + "content": "Prajit Ramachandran, Barret Zoph, and Quoc V Le. Swish: a self-gated activation function. arXiv", + "type": "text", + "cross_page": true + } + ], + "index": 34, + "is_list_start_line": true + }, + { + "bbox": [ + 112, + 537, + 282, + 551 + ], + "spans": [ + { + "bbox": [ + 112, + 537, + 282, + 551 + ], + "score": 1.0, + "content": "preprint arXiv:1710.05941, 7(1):5, 2017.", + "type": "text", + "cross_page": true + } + ], + "index": 35, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 556, + 506, + 568 + ], + "spans": [ + { + "bbox": [ + 106, + 556, + 506, + 568 + ], + "score": 1.0, + "content": "David W Romero, Anna Kuzina, Erik J Bekkers, Jakub M Tomczak, and Mark Hoogendoorn. Ckconv:", + "type": "text", + "cross_page": true + } + ], + "index": 36, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 567, + 480, + 581 + ], + "spans": [ + { + "bbox": [ + 114, + 567, + 480, + 581 + ], + "score": 1.0, + "content": "Continuous kernel convolution for sequential data. arXiv preprint arXiv:2102.02611, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 37, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 584, + 506, + 598 + ], + "spans": [ + { + "bbox": [ + 105, + 584, + 506, + 598 + ], + "score": 1.0, + "content": "Keisuke Sakaguchi, Ronan Le Bras, Chandra Bhagavatula, and Yejin Choi. Winogrande: An", + "type": "text", + "cross_page": true + } + ], + "index": 38, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 595, + 508, + 609 + ], + "spans": [ + { + "bbox": [ + 114, + 595, + 508, + 609 + ], + "score": 1.0, + "content": "adversarial winograd schema challenge at scale. Communications of the ACM, 64(9):99–106, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 612, + 506, + 627 + ], + "spans": [ + { + "bbox": [ + 105, + 612, + 506, + 627 + ], + "score": 1.0, + "content": "George Saon, Ankit Gupta, and Xiaodong Cui. Diagonal state space augmented transformers for", + "type": "text", + "cross_page": true + } + ], + "index": 40, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 623, + 507, + 639 + ], + "spans": [ + { + "bbox": [ + 113, + 623, + 507, + 639 + ], + "score": 1.0, + "content": "speech recognition. In ICASSP 2023-2023 IEEE International Conference on Acoustics, Speech", + "type": "text", + "cross_page": true + } + ], + "index": 41 + }, + { + "bbox": [ + 114, + 634, + 336, + 648 + ], + "spans": [ + { + "bbox": [ + 114, + 634, + 336, + 648 + ], + "score": 1.0, + "content": "and Signal Processing (ICASSP), pp. 1–5. IEEE, 2023.", + "type": "text", + "cross_page": true + } + ], + "index": 42, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 653, + 505, + 665 + ], + "spans": [ + { + "bbox": [ + 106, + 653, + 505, + 665 + ], + "score": 1.0, + "content": "Imanol Schlag, Kazuki Irie, and Jurgen Schmidhuber. Linear transformers are secretly fast weight ¨", + "type": "text", + "cross_page": true + } + ], + "index": 43, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 664, + 499, + 678 + ], + "spans": [ + { + "bbox": [ + 114, + 664, + 499, + 678 + ], + "score": 1.0, + "content": "programmers. In International Conference on Machine Learning, pp. 9355–9366. PMLR, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 680, + 467, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 680, + 467, + 695 + ], + "score": 1.0, + "content": "Noam Shazeer. Glu variants improve transformer. arXiv preprint arXiv:2002.05202, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 45, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "Freda Shi, Xinyun Chen, Kanishka Misra, Nathan Scales, David Dohan, Ed H Chi, Nathanael", + "type": "text", + "cross_page": true + } + ], + "index": 46, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 709, + 507, + 724 + ], + "spans": [ + { + "bbox": [ + 114, + 709, + 507, + 724 + ], + "score": 1.0, + "content": "Scharli, and Denny Zhou. Large language models can be easily distracted by irrelevant context. ¨", + "type": "text", + "cross_page": true + } + ], + "index": 47 + }, + { + "bbox": [ + 115, + 721, + 454, + 735 + ], + "spans": [ + { + "bbox": [ + 115, + 721, + 454, + 735 + ], + "score": 1.0, + "content": "In International Conference on Machine Learning, pp. 31210–31227. PMLR, 2023a.", + "type": "text", + "cross_page": true + } + ], + "index": 48, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 83, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 83, + 505, + 95 + ], + "score": 1.0, + "content": "Jiaxin Shi, Ke Alexander Wang, and Emily B Fox. Sequence modeling with multiresolution", + "type": "text", + "cross_page": true + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 94, + 376, + 106 + ], + "spans": [ + { + "bbox": [ + 115, + 94, + 376, + 106 + ], + "score": 1.0, + "content": "convolutional memory. arXiv preprint arXiv:2305.01638, 2023b.", + "type": "text", + "cross_page": true + } + ], + "index": 1, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 112, + 506, + 126 + ], + "spans": [ + { + "bbox": [ + 105, + 112, + 506, + 126 + ], + "score": 1.0, + "content": "Jimmy TH Smith, Andrew Warrington, and Scott W Linderman. Simplified state space layers for", + "type": "text", + "cross_page": true + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 123, + 503, + 137 + ], + "spans": [ + { + "bbox": [ + 113, + 123, + 503, + 137 + ], + "score": 1.0, + "content": "sequence modeling. In The International Conference on Learning Representations (ICLR), 2023.", + "type": "text", + "cross_page": true + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 141, + 506, + 155 + ], + "spans": [ + { + "bbox": [ + 105, + 141, + 506, + 155 + ], + "score": 1.0, + "content": "Jianlin Su, Yu Lu, Shengfeng Pan, Ahmed Murtadha, Bo Wen, and Yunfeng Liu. Roformer: Enhanced", + "type": "text", + "cross_page": true + } + ], + "index": 4, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 152, + 454, + 165 + ], + "spans": [ + { + "bbox": [ + 115, + 152, + 454, + 165 + ], + "score": 1.0, + "content": "transformer with rotary position embedding. arXiv preprint arXiv:2104.09864, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 5, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 171, + 505, + 184 + ], + "spans": [ + { + "bbox": [ + 106, + 171, + 505, + 184 + ], + "score": 1.0, + "content": "Yutao Sun, Li Dong, Shaohan Huang, Shuming Ma, Yuqing Xia, Jilong Xue, Jianyong Wang, and", + "type": "text", + "cross_page": true + } + ], + "index": 6, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 181, + 506, + 195 + ], + "spans": [ + { + "bbox": [ + 115, + 181, + 506, + 195 + ], + "score": 1.0, + "content": "Furu Wei. Retentive network: A successor to transformer for large language models. arXiv preprint", + "type": "text", + "cross_page": true + } + ], + "index": 7 + }, + { + "bbox": [ + 115, + 193, + 218, + 205 + ], + "spans": [ + { + "bbox": [ + 115, + 193, + 218, + 205 + ], + "score": 1.0, + "content": "arXiv:2307.08621, 2023.", + "type": "text", + "cross_page": true + } + ], + "index": 8, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 211, + 506, + 224 + ], + "spans": [ + { + "bbox": [ + 105, + 211, + 506, + 224 + ], + "score": 1.0, + "content": "Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks.", + "type": "text", + "cross_page": true + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 222, + 362, + 235 + ], + "spans": [ + { + "bbox": [ + 113, + 222, + 362, + 235 + ], + "score": 1.0, + "content": "Advances in neural information processing systems, 27, 2014.", + "type": "text", + "cross_page": true + } + ], + "index": 10, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 240, + 506, + 254 + ], + "spans": [ + { + "bbox": [ + 105, + 240, + 506, + 254 + ], + "score": 1.0, + "content": "Corentin Tallec and Yann Ollivier. Can recurrent neural networks warp time? In The International", + "type": "text", + "cross_page": true + } + ], + "index": 11, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 252, + 337, + 264 + ], + "spans": [ + { + "bbox": [ + 116, + 252, + 337, + 264 + ], + "score": 1.0, + "content": "Conference on Learning Representations (ICLR), 2018.", + "type": "text", + "cross_page": true + } + ], + "index": 12, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 268, + 506, + 285 + ], + "spans": [ + { + "bbox": [ + 105, + 268, + 506, + 285 + ], + "score": 1.0, + "content": "Yi Tay, Mostafa Dehghani, Samira Abnar, Yikang Shen, Dara Bahri, Philip Pham, Jinfeng", + "type": "text", + "cross_page": true + } + ], + "index": 13, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 281, + 506, + 295 + ], + "spans": [ + { + "bbox": [ + 115, + 281, + 506, + 295 + ], + "score": 1.0, + "content": "Rao, Liu Yang, Sebastian Ruder, and Donald Metzler. Long range arena : A benchmark for", + "type": "text", + "cross_page": true + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 291, + 506, + 305 + ], + "spans": [ + { + "bbox": [ + 115, + 291, + 506, + 305 + ], + "score": 1.0, + "content": "efficient transformers. In International Conference on Learning Representations, 2021. URL", + "type": "text", + "cross_page": true + } + ], + "index": 15 + }, + { + "bbox": [ + 115, + 303, + 380, + 316 + ], + "spans": [ + { + "bbox": [ + 115, + 303, + 380, + 316 + ], + "score": 1.0, + "content": "https://openreview.net/forum?id=qVyeW-grC2k.", + "type": "text", + "cross_page": true + } + ], + "index": 16, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 320, + 506, + 334 + ], + "spans": [ + { + "bbox": [ + 106, + 320, + 506, + 334 + ], + "score": 1.0, + "content": "Yi Tay, Mostafa Dehghani, Dara Bahri, and Donald Metzler. Efficient transformers: A survey. ACM", + "type": "text", + "cross_page": true + } + ], + "index": 17, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 331, + 271, + 345 + ], + "spans": [ + { + "bbox": [ + 115, + 331, + 271, + 345 + ], + "score": 1.0, + "content": "Computing Surveys, 55(6):1–28, 2022.", + "type": "text", + "cross_page": true + } + ], + "index": 18, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 351, + 505, + 363 + ], + "spans": [ + { + "bbox": [ + 106, + 351, + 505, + 363 + ], + "score": 1.0, + "content": "Hugo Touvron, Thibaut Lavril, Gautier Izacard, Xavier Martinet, Marie-Anne Lachaux, Timothee´", + "type": "text", + "cross_page": true + } + ], + "index": 19, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 362, + 505, + 374 + ], + "spans": [ + { + "bbox": [ + 116, + 362, + 505, + 374 + ], + "score": 1.0, + "content": "Lacroix, Baptiste Roziere, Naman Goyal, Eric Hambro, Faisal Azhar, et al. Llama: Open and `", + "type": "text", + "cross_page": true + } + ], + "index": 20 + }, + { + "bbox": [ + 114, + 371, + 430, + 386 + ], + "spans": [ + { + "bbox": [ + 114, + 371, + 430, + 386 + ], + "score": 1.0, + "content": "efficient foundation language models. arXiv preprint arXiv:2302.13971, 2023.", + "type": "text", + "cross_page": true + } + ], + "index": 21, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 389, + 506, + 405 + ], + "spans": [ + { + "bbox": [ + 105, + 389, + 506, + 405 + ], + "score": 1.0, + "content": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez,", + "type": "text", + "cross_page": true + } + ], + "index": 22, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 401, + 506, + 415 + ], + "spans": [ + { + "bbox": [ + 114, + 401, + 506, + 415 + ], + "score": 1.0, + "content": "Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information", + "type": "text", + "cross_page": true + } + ], + "index": 23 + }, + { + "bbox": [ + 115, + 412, + 267, + 425 + ], + "spans": [ + { + "bbox": [ + 115, + 412, + 267, + 425 + ], + "score": 1.0, + "content": "Processing Systems (NeurIPS), 2017.", + "type": "text", + "cross_page": true + } + ], + "index": 24, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 429, + 506, + 446 + ], + "spans": [ + { + "bbox": [ + 104, + 429, + 506, + 446 + ], + "score": 1.0, + "content": "Eugene Vorontsov, Chiheb Trabelsi, Samuel Kadoury, and Chris Pal. On orthogonality and learning", + "type": "text", + "cross_page": true + } + ], + "index": 25, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 440, + 507, + 456 + ], + "spans": [ + { + "bbox": [ + 113, + 440, + 507, + 456 + ], + "score": 1.0, + "content": "recurrent networks with long term dependencies. In International Conference on Machine Learning,", + "type": "text", + "cross_page": true + } + ], + "index": 26 + }, + { + "bbox": [ + 115, + 452, + 237, + 465 + ], + "spans": [ + { + "bbox": [ + 115, + 452, + 237, + 465 + ], + "score": 1.0, + "content": "pp. 3570–3578. PMLR, 2017.", + "type": "text", + "cross_page": true + } + ], + "index": 27, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 471, + 506, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 506, + 484 + ], + "score": 1.0, + "content": "Jue Wang, Wentao Zhu, Pichao Wang, Xiang Yu, Linda Liu, Mohamed Omar, and Raffay Hamid.", + "type": "text", + "cross_page": true + } + ], + "index": 28, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 482, + 506, + 496 + ], + "spans": [ + { + "bbox": [ + 115, + 482, + 506, + 496 + ], + "score": 1.0, + "content": "Selective structured state-spaces for long-form video understanding. In Proceedings of the", + "type": "text", + "cross_page": true + } + ], + "index": 29 + }, + { + "bbox": [ + 115, + 493, + 478, + 506 + ], + "spans": [ + { + "bbox": [ + 115, + 493, + 478, + 506 + ], + "score": 1.0, + "content": "IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 6387–6397, 2023.", + "type": "text", + "cross_page": true + } + ], + "index": 30, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 510, + 507, + 526 + ], + "spans": [ + { + "bbox": [ + 104, + 510, + 507, + 526 + ], + "score": 1.0, + "content": "Pete Warden. Speech commands: A dataset for limited-vocabulary speech recognition. ArXiv,", + "type": "text", + "cross_page": true + } + ], + "index": 31, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 522, + 209, + 535 + ], + "spans": [ + { + "bbox": [ + 115, + 522, + 209, + 535 + ], + "score": 1.0, + "content": "abs/1804.03209, 2018.", + "type": "text", + "cross_page": true + } + ], + "index": 32, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 540, + 506, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 506, + 554 + ], + "score": 1.0, + "content": "Samuel Williams, Andrew Waterman, and David Patterson. Roofline: an insightful visual performance", + "type": "text", + "cross_page": true + } + ], + "index": 33, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 551, + 451, + 564 + ], + "spans": [ + { + "bbox": [ + 115, + 551, + 451, + 564 + ], + "score": 1.0, + "content": "model for multicore architectures. Communications of the ACM, 52(4):65–76, 2009.", + "type": "text", + "cross_page": true + } + ], + "index": 34, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 570, + 506, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 570, + 506, + 583 + ], + "score": 1.0, + "content": "Brandon Yang, Gabriel Bender, Quoc V Le, and Jiquan Ngiam. Condconv: Conditionally parameterized", + "type": "text", + "cross_page": true + } + ], + "index": 35, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 581, + 506, + 594 + ], + "spans": [ + { + "bbox": [ + 115, + 581, + 506, + 594 + ], + "score": 1.0, + "content": "convolutions for efficient inference. Advances in neural information processing systems, 32, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 599, + 506, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 506, + 613 + ], + "score": 1.0, + "content": "Shuangfei Zhai, Walter Talbott, Nitish Srivastava, Chen Huang, Hanlin Goh, Ruixiang Zhang, and", + "type": "text", + "cross_page": true + } + ], + "index": 37, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 610, + 457, + 624 + ], + "spans": [ + { + "bbox": [ + 115, + 610, + 457, + 624 + ], + "score": 1.0, + "content": "Josh Susskind. An attention free transformer. arXiv preprint arXiv:2105.14103, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 38, + "is_list_end_line": true + } + ], + "index": 23.5, + "bbox_fs": [ + 104, + 99, + 508, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 100, + 66, + 506, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 506, + 96 + ], + "score": 1.0, + "content": "Jiayu Ding, Shuming Ma, Li Dong, Xingxing Zhang, Shaohan Huang, Wenhui Wang, and Furu Wei.", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 114, + 93, + 501, + 107 + ], + "spans": [ + { + "bbox": [ + 114, + 93, + 501, + 107 + ], + "score": 1.0, + "content": "Longnet: Scaling transformers to 1,000,000,000 tokens. arXiv preprint arXiv:2307.02486, 2023.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 110, + 506, + 124 + ], + "spans": [ + { + "bbox": [ + 106, + 110, + 506, + 124 + ], + "score": 1.0, + "content": "Chris Donahue, Julian McAuley, and Miller Puckette. Adversarial audio synthesis. In International", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 115, + 122, + 307, + 136 + ], + "spans": [ + { + "bbox": [ + 115, + 122, + 307, + 136 + ], + "score": 1.0, + "content": "Conference on Learning Representations, 2019.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 141, + 505, + 153 + ], + "spans": [ + { + "bbox": [ + 106, + 141, + 505, + 153 + ], + "score": 1.0, + "content": "Alexey Dosovitskiy, Lucas Beyer, Alexander Kolesnikov, Dirk Weissenborn, Xiaohua Zhai, Thomas", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 116, + 152, + 505, + 164 + ], + "spans": [ + { + "bbox": [ + 116, + 152, + 505, + 164 + ], + "score": 1.0, + "content": "Unterthiner, Mostafa Dehghani, Matthias Minderer, Georg Heigold, Sylvain Gelly, et al. An image is", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 162, + 506, + 176 + ], + "spans": [ + { + "bbox": [ + 115, + 162, + 506, + 176 + ], + "score": 1.0, + "content": "worth 16x16 words: Transformers for image recognition at scale. arXiv preprint arXiv:2010.11929,", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 114, + 172, + 144, + 187 + ], + "spans": [ + { + "bbox": [ + 114, + 172, + 144, + 187 + ], + "score": 1.0, + "content": "2020.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 192, + 505, + 203 + ], + "spans": [ + { + "bbox": [ + 106, + 192, + 505, + 203 + ], + "score": 1.0, + "content": "Nelson Elhage, Neel Nanda, Catherine Olsson, Tom Henighan, Nicholas Joseph, Ben Mann, Amanda", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 115, + 201, + 506, + 215 + ], + "spans": [ + { + "bbox": [ + 115, + 201, + 506, + 215 + ], + "score": 1.0, + "content": "Askell, Yuntao Bai, Anna Chen, Tom Conerly, Nova DasSarma, Dawn Drain, Deep Ganguli,", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 212, + 506, + 226 + ], + "spans": [ + { + "bbox": [ + 115, + 212, + 506, + 226 + ], + "score": 1.0, + "content": "Zac Hatfield-Dodds, Danny Hernandez, Andy Jones, Jackson Kernion, Liane Lovitt, Kamal", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 116, + 224, + 505, + 235 + ], + "spans": [ + { + "bbox": [ + 116, + 224, + 505, + 235 + ], + "score": 1.0, + "content": "Ndousse, Dario Amodei, Tom Brown, Jack Clark, Jared Kaplan, Sam McCandlish, and Chris", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 116, + 235, + 506, + 246 + ], + "spans": [ + { + "bbox": [ + 116, + 235, + 506, + 246 + ], + "score": 1.0, + "content": "Olah. A mathematical framework for transformer circuits. Transformer Circuits Thread, 2021.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 116, + 246, + 359, + 257 + ], + "spans": [ + { + "bbox": [ + 116, + 246, + 359, + 257 + ], + "score": 1.0, + "content": "https://transformer-circuits.pub/2021/framework/index.html.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 263, + 506, + 276 + ], + "spans": [ + { + "bbox": [ + 106, + 263, + 506, + 276 + ], + "score": 1.0, + "content": "Daniel Y Fu, Elliot L Epstein, Eric Nguyen, Armin W Thomas, Michael Zhang, Tri Dao, Atri Rudra,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 114, + 274, + 506, + 288 + ], + "spans": [ + { + "bbox": [ + 114, + 274, + 506, + 288 + ], + "score": 1.0, + "content": "and Christopher Re. Simple hardware-efficient long convolutions for sequence modeling. ´ The", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 115, + 284, + 365, + 298 + ], + "spans": [ + { + "bbox": [ + 115, + 284, + 365, + 298 + ], + "score": 1.0, + "content": "International Conference on Machine Learning (ICML), 2023.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 303, + 506, + 317 + ], + "spans": [ + { + "bbox": [ + 106, + 303, + 506, + 317 + ], + "score": 1.0, + "content": "Ken-ichi Funahashi and Yuichi Nakamura. Approximation of dynamical systems by continuous time", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 116, + 315, + 376, + 326 + ], + "spans": [ + { + "bbox": [ + 116, + 315, + 376, + 326 + ], + "score": 1.0, + "content": "recurrent neural networks. Neural networks, 6(6):801–806, 1993.", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 104, + 330, + 507, + 347 + ], + "spans": [ + { + "bbox": [ + 104, + 330, + 507, + 347 + ], + "score": 1.0, + "content": "Leo Gao, Stella Biderman, Sid Black, Laurence Golding, Travis Hoppe, Charles Foster, Jason Phang,", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 115, + 343, + 506, + 357 + ], + "spans": [ + { + "bbox": [ + 115, + 343, + 506, + 357 + ], + "score": 1.0, + "content": "Horace He, Anish Thite, Noa Nabeshima, Shawn Presser, and Connor Leahy. The Pile: An 800gb", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 114, + 353, + 460, + 366 + ], + "spans": [ + { + "bbox": [ + 114, + 353, + 460, + 366 + ], + "score": 1.0, + "content": "dataset of diverse text for language modeling. arXiv preprint arXiv:2101.00027, 2020.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 371, + 506, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 371, + 506, + 385 + ], + "score": 1.0, + "content": "Leo Gao, Jonathan Tow, Stella Biderman, Sid Black, Anthony DiPofi, Charles Foster, Laurence", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 114, + 381, + 507, + 398 + ], + "spans": [ + { + "bbox": [ + 114, + 381, + 507, + 398 + ], + "score": 1.0, + "content": "Golding, Jeffrey Hsu, Kyle McDonell, Niklas Muennighoff, Jason Phang, Laria Reynolds, Eric Tang,", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 115, + 393, + 506, + 407 + ], + "spans": [ + { + "bbox": [ + 115, + 393, + 506, + 407 + ], + "score": 1.0, + "content": "Anish Thite, Ben Wang, Kevin Wang, and Andy Zou. A framework for few-shot language model", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 115, + 404, + 485, + 418 + ], + "spans": [ + { + "bbox": [ + 115, + 404, + 485, + 418 + ], + "score": 1.0, + "content": "evaluation, September 2021. URL https://doi.org/10.5281/zenodo.5371628.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 422, + 506, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 422, + 506, + 437 + ], + "score": 1.0, + "content": "Karan Goel, Albert Gu, Chris Donahue, and Christopher Re. It’s raw! audio generation with state-space ´", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 115, + 433, + 426, + 447 + ], + "spans": [ + { + "bbox": [ + 115, + 433, + 426, + 447 + ], + "score": 1.0, + "content": "models. In The International Conference on Machine Learning (ICML), 2022.", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 452, + 506, + 466 + ], + "spans": [ + { + "bbox": [ + 106, + 452, + 506, + 466 + ], + "score": 1.0, + "content": "Albert Gu, Tri Dao, Stefano Ermon, Atri Rudra, and Christopher Re. Hippo: Recurrent memory with ´", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 463, + 506, + 477 + ], + "spans": [ + { + "bbox": [ + 115, + 463, + 506, + 477 + ], + "score": 1.0, + "content": "optimal polynomial projections. In Advances in Neural Information Processing Systems (NeurIPS),", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 115, + 472, + 147, + 487 + ], + "spans": [ + { + "bbox": [ + 115, + 472, + 147, + 487 + ], + "score": 1.0, + "content": "2020a.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 491, + 506, + 506 + ], + "spans": [ + { + "bbox": [ + 105, + 491, + 506, + 506 + ], + "score": 1.0, + "content": "Albert Gu, Caglar Gulcehre, Tom Le Paine, Matt Hoffman, and Razvan Pascanu. Improving the gating", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 113, + 501, + 506, + 518 + ], + "spans": [ + { + "bbox": [ + 113, + 501, + 506, + 518 + ], + "score": 1.0, + "content": "mechanism of recurrent neural networks. In The International Conference on Machine Learning", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 115, + 514, + 181, + 525 + ], + "spans": [ + { + "bbox": [ + 115, + 514, + 181, + 525 + ], + "score": 1.0, + "content": "(ICML), 2020b.", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 532, + 505, + 544 + ], + "spans": [ + { + "bbox": [ + 106, + 532, + 505, + 544 + ], + "score": 1.0, + "content": "Albert Gu, Isys Johnson, Karan Goel, Khaled Saab, Tri Dao, Atri Rudra, and Christopher Re.´", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 542, + 506, + 556 + ], + "spans": [ + { + "bbox": [ + 115, + 542, + 506, + 556 + ], + "score": 1.0, + "content": "Combining recurrent, convolutional, and continuous-time models with the structured learnable", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 116, + 554, + 500, + 566 + ], + "spans": [ + { + "bbox": [ + 116, + 554, + 500, + 566 + ], + "score": 1.0, + "content": "linear state space layer. In Advances in Neural Information Processing Systems (NeurIPS), 2021.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 570, + 506, + 585 + ], + "spans": [ + { + "bbox": [ + 106, + 570, + 506, + 585 + ], + "score": 1.0, + "content": "Albert Gu, Karan Goel, and Christopher Re. Efficiently modeling long sequences with structured ´", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 116, + 583, + 475, + 595 + ], + "spans": [ + { + "bbox": [ + 116, + 583, + 475, + 595 + ], + "score": 1.0, + "content": "state spaces. In The International Conference on Learning Representations (ICLR), 2022a.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 599, + 505, + 613 + ], + "spans": [ + { + "bbox": [ + 106, + 599, + 505, + 613 + ], + "score": 1.0, + "content": "Albert Gu, Ankit Gupta, Karan Goel, and Christopher Re. On the parameterization and initialization ´", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 116, + 613, + 506, + 624 + ], + "spans": [ + { + "bbox": [ + 116, + 613, + 506, + 624 + ], + "score": 1.0, + "content": "of diagonal state space models. In Advances in Neural Information Processing Systems (NeurIPS),", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 115, + 621, + 148, + 636 + ], + "spans": [ + { + "bbox": [ + 115, + 621, + 148, + 636 + ], + "score": 1.0, + "content": "2022b.", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 640, + 507, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 640, + 507, + 654 + ], + "score": 1.0, + "content": "Albert Gu, Isys Johnson, Aman Timalsina, Atri Rudra, and Christopher Re. How to train your hippo: ´", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 114, + 650, + 506, + 666 + ], + "spans": [ + { + "bbox": [ + 114, + 650, + 506, + 666 + ], + "score": 1.0, + "content": "State space models with generalized basis projections. In The International Conference on Learning", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 115, + 662, + 240, + 676 + ], + "spans": [ + { + "bbox": [ + 115, + 662, + 240, + 676 + ], + "score": 1.0, + "content": "Representations (ICLR), 2023.", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 680, + 506, + 694 + ], + "spans": [ + { + "bbox": [ + 106, + 680, + 506, + 694 + ], + "score": 1.0, + "content": "Ankit Gupta. Diagonal state spaces are as effective as structured state spaces. In Advances in Neural", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 114, + 691, + 315, + 704 + ], + "spans": [ + { + "bbox": [ + 114, + 691, + 315, + 704 + ], + "score": 1.0, + "content": "Information Processing Systems (NeurIPS), 2022.", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 104, + 707, + 507, + 725 + ], + "spans": [ + { + "bbox": [ + 104, + 707, + 507, + 725 + ], + "score": 1.0, + "content": "David Ha, Andrew Dai, and Quoc V. Le. Hypernetworks. In International Conference on Learning", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 114, + 720, + 210, + 734 + ], + "spans": [ + { + "bbox": [ + 114, + 720, + 210, + 734 + ], + "score": 1.0, + "content": "Representations, 2017.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 24 + } + ], + "page_idx": 10, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 304, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 305, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 305, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 309, + 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": "list", + "bbox": [ + 100, + 66, + 506, + 732 + ], + "lines": [], + "index": 24, + "bbox_fs": [ + 104, + 82, + 507, + 734 + ], + "lines_deleted": true + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 103, + 79, + 508, + 739 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 506, + 96 + ], + "score": 1.0, + "content": "Ramin Hasani, Mathias Lechner, Tsun-Hsuan Wang, Makram Chahine, Alexander Amini, and", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 114, + 91, + 506, + 109 + ], + "spans": [ + { + "bbox": [ + 114, + 91, + 506, + 109 + ], + "score": 1.0, + "content": "Daniela Rus. Liquid structural state-space models. In The International Conference on Learning", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 115, + 104, + 240, + 117 + ], + "spans": [ + { + "bbox": [ + 115, + 104, + 240, + 117 + ], + "score": 1.0, + "content": "Representations (ICLR), 2023.", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 103, + 120, + 506, + 137 + ], + "spans": [ + { + "bbox": [ + 103, + 120, + 506, + 137 + ], + "score": 1.0, + "content": "Mikael Henaff, Arthur Szlam, and Yann LeCun. Recurrent orthogonal networks and long-memory", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 116, + 135, + 419, + 146 + ], + "spans": [ + { + "bbox": [ + 116, + 135, + 419, + 146 + ], + "score": 1.0, + "content": "tasks. In The International Conference on Machine Learning (ICML), 2016.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 152, + 506, + 167 + ], + "spans": [ + { + "bbox": [ + 105, + 152, + 506, + 167 + ], + "score": 1.0, + "content": "Dan Hendrycks and Kevin Gimpel. Gaussian error linear units (gelus). arXiv preprint", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 163, + 219, + 177 + ], + "spans": [ + { + "bbox": [ + 115, + 163, + 219, + 177 + ], + "score": 1.0, + "content": "arXiv:1606.08415, 2016.", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 103, + 180, + 507, + 197 + ], + "spans": [ + { + "bbox": [ + 103, + 180, + 507, + 197 + ], + "score": 1.0, + "content": "Sepp Hochreiter and Jurgen Schmidhuber. Long short-term memory. ¨ Neural computation, 9(8):", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 116, + 193, + 191, + 205 + ], + "spans": [ + { + "bbox": [ + 116, + 193, + 191, + 205 + ], + "score": 1.0, + "content": "1735–1780, 1997.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 104, + 210, + 506, + 225 + ], + "spans": [ + { + "bbox": [ + 104, + 210, + 506, + 225 + ], + "score": 1.0, + "content": "Jordan Hoffmann, Sebastian Borgeaud, Arthur Mensch, Elena Buchatskaya, Trevor Cai, Eliza", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 222, + 507, + 235 + ], + "spans": [ + { + "bbox": [ + 115, + 222, + 507, + 235 + ], + "score": 1.0, + "content": "Rutherford, Diego de Las Casas, Lisa Anne Hendricks, Johannes Welbl, Aidan Clark, et al.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 115, + 233, + 506, + 247 + ], + "spans": [ + { + "bbox": [ + 115, + 233, + 506, + 247 + ], + "score": 1.0, + "content": "An empirical analysis of compute-optimal large language model training. Advances in Neural", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 116, + 245, + 344, + 256 + ], + "spans": [ + { + "bbox": [ + 116, + 245, + 344, + 256 + ], + "score": 1.0, + "content": "Information Processing Systems, 35:30016–30030, 2022.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 262, + 506, + 276 + ], + "spans": [ + { + "bbox": [ + 106, + 262, + 506, + 276 + ], + "score": 1.0, + "content": "Weizhe Hua, Zihang Dai, Hanxiao Liu, and Quoc Le. Transformer quality in linear time. In", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 114, + 272, + 429, + 288 + ], + "spans": [ + { + "bbox": [ + 114, + 272, + 429, + 288 + ], + "score": 1.0, + "content": "International Conference on Machine Learning, pp. 9099–9117. PMLR, 2022.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 293, + 505, + 304 + ], + "spans": [ + { + "bbox": [ + 105, + 293, + 505, + 304 + ], + "score": 1.0, + "content": "Hassan Ismail Fawaz, Germain Forestier, Jonathan Weber, Lhassane Idoumghar, and Pierre-Alain", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 114, + 300, + 508, + 318 + ], + "spans": [ + { + "bbox": [ + 114, + 300, + 508, + 318 + ], + "score": 1.0, + "content": "Muller. Deep learning for time series classification: a review. Data mining and knowledge discovery,", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 114, + 312, + 205, + 326 + ], + "spans": [ + { + "bbox": [ + 114, + 312, + 205, + 326 + ], + "score": 1.0, + "content": "33(4):917–963, 2019.", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 331, + 506, + 345 + ], + "spans": [ + { + "bbox": [ + 105, + 331, + 506, + 345 + ], + "score": 1.0, + "content": "Andrei Ivanov, Nikoli Dryden, Tal Ben-Nun, Shigang Li, and Torsten Hoefler. Data movement is all", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 114, + 342, + 508, + 358 + ], + "spans": [ + { + "bbox": [ + 114, + 342, + 508, + 358 + ], + "score": 1.0, + "content": "you need: A case study on optimizing transformers. Proceedings of Machine Learning and Systems,", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 116, + 354, + 190, + 366 + ], + "spans": [ + { + "bbox": [ + 116, + 354, + 190, + 366 + ], + "score": 1.0, + "content": "3:711–732, 2021.", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 104, + 371, + 506, + 385 + ], + "spans": [ + { + "bbox": [ + 104, + 371, + 506, + 385 + ], + "score": 1.0, + "content": "Li Jing, Caglar Gulcehre, John Peurifoy, Yichen Shen, Max Tegmark, Marin Soljacic, and Yoshua", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 116, + 383, + 506, + 397 + ], + "spans": [ + { + "bbox": [ + 116, + 383, + 506, + 397 + ], + "score": 1.0, + "content": "Bengio. Gated orthogonal recurrent units: On learning to forget. Neural computation, 31(4):", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 114, + 392, + 182, + 408 + ], + "spans": [ + { + "bbox": [ + 114, + 392, + 182, + 408 + ], + "score": 1.0, + "content": "765–783, 2019.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 413, + 461, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 413, + 461, + 426 + ], + "score": 1.0, + "content": "Rudolph Emil Kalman. A new approach to linear filtering and prediction problems. 1960.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 431, + 507, + 444 + ], + "spans": [ + { + "bbox": [ + 105, + 431, + 507, + 444 + ], + "score": 1.0, + "content": "Angelos Katharopoulos, Apoorv Vyas, Nikolaos Pappas, and Franc¸ois Fleuret. Transformers are rnns:", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 115, + 441, + 506, + 455 + ], + "spans": [ + { + "bbox": [ + 115, + 441, + 506, + 455 + ], + "score": 1.0, + "content": "Fast autoregressive transformers with linear attention. In International Conference on Machine", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 114, + 452, + 278, + 465 + ], + "spans": [ + { + "bbox": [ + 114, + 452, + 278, + 465 + ], + "score": 1.0, + "content": "Learning, pp. 5156–5165. PMLR, 2020.", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 472, + 505, + 484 + ], + "spans": [ + { + "bbox": [ + 106, + 472, + 505, + 484 + ], + "score": 1.0, + "content": "Chrysoula Kosma, Giannis Nikolentzos, and Michalis Vazirgiannis. Time-parameterized convolutional", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 482, + 483, + 496 + ], + "spans": [ + { + "bbox": [ + 115, + 482, + 483, + 496 + ], + "score": 1.0, + "content": "neural networks for irregularly sampled time series. arXiv preprint arXiv:2308.03210, 2023.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 500, + 506, + 515 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 506, + 515 + ], + "score": 1.0, + "content": "Alex Krizhevsky, Ilya Sutskever, and Geoffrey E Hinton. Imagenet classification with deep", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 115, + 512, + 487, + 525 + ], + "spans": [ + { + "bbox": [ + 115, + 512, + 487, + 525 + ], + "score": 1.0, + "content": "convolutional neural networks. Advances in neural information processing systems, 25, 2012.", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 529, + 506, + 544 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 506, + 544 + ], + "score": 1.0, + "content": "Tao Lei. When attention meets fast recurrence: Training language models with reduced compute.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 114, + 541, + 279, + 554 + ], + "spans": [ + { + "bbox": [ + 114, + 541, + 279, + 554 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:2102.12459, 2021.", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 103, + 558, + 506, + 575 + ], + "spans": [ + { + "bbox": [ + 103, + 558, + 506, + 575 + ], + "score": 1.0, + "content": "Tao Lei, Yu Zhang, Sida I Wang, Hui Dai, and Yoav Artzi. Simple recurrent units for highly", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 113, + 570, + 382, + 584 + ], + "spans": [ + { + "bbox": [ + 113, + 570, + 382, + 584 + ], + "score": 1.0, + "content": "parallelizable recurrence. arXiv preprint arXiv:1709.02755, 2017.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 588, + 507, + 603 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 507, + 603 + ], + "score": 1.0, + "content": "Mario Lezcano-Casado and David Mart´ınez-Rubio. Cheap orthogonal constraints in neural networks:", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 115, + 600, + 506, + 614 + ], + "spans": [ + { + "bbox": [ + 115, + 600, + 506, + 614 + ], + "score": 1.0, + "content": "A simple parametrization of the orthogonal and unitary group. In The International Conference", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 114, + 610, + 265, + 623 + ], + "spans": [ + { + "bbox": [ + 114, + 610, + 265, + 623 + ], + "score": 1.0, + "content": "on Machine Learning (ICML), 2019.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 629, + 506, + 643 + ], + "spans": [ + { + "bbox": [ + 106, + 629, + 506, + 643 + ], + "score": 1.0, + "content": "Yuhong Li, Tianle Cai, Yi Zhang, Deming Chen, and Debadeepta Dey. What makes convolutional", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 114, + 639, + 506, + 655 + ], + "spans": [ + { + "bbox": [ + 114, + 639, + 506, + 655 + ], + "score": 1.0, + "content": "models great on long sequence modeling? In The International Conference on Learning", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 116, + 651, + 240, + 665 + ], + "spans": [ + { + "bbox": [ + 116, + 651, + 240, + 665 + ], + "score": 1.0, + "content": "Representations (ICLR), 2023.", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 670, + 507, + 684 + ], + "spans": [ + { + "bbox": [ + 105, + 670, + 507, + 684 + ], + "score": 1.0, + "content": "Xuezhe Ma, Chunting Zhou, Xiang Kong, Junxian He, Liangke Gui, Graham Neubig, Jonathan May,", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 115, + 681, + 506, + 694 + ], + "spans": [ + { + "bbox": [ + 115, + 681, + 506, + 694 + ], + "score": 1.0, + "content": "and Luke Zettlemoyer. Mega: moving average equipped gated attention. In The International", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 116, + 691, + 340, + 705 + ], + "spans": [ + { + "bbox": [ + 116, + 691, + 340, + 705 + ], + "score": 1.0, + "content": "Conference on Learning Representations (ICLR), 2023.", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "score": 1.0, + "content": "Eric Martin and Chris Cundy. Parallelizing linear recurrent neural nets over sequence length. In", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 115, + 720, + 363, + 734 + ], + "spans": [ + { + "bbox": [ + 115, + 720, + 363, + 734 + ], + "score": 1.0, + "content": "International Conference on Learning Representations, 2018.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 23 + } + ], + "page_idx": 11, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 304, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 305, + 39 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 305, + 39 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "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": "12", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "list", + "bbox": [ + 103, + 79, + 508, + 739 + ], + "lines": [], + "index": 23, + "bbox_fs": [ + 103, + 81, + 508, + 734 + ], + "lines_deleted": true + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 104, + 58, + 507, + 732 + ], + "lines": [ + { + "bbox": [ + 104, + 80, + 507, + 97 + ], + "spans": [ + { + "bbox": [ + 104, + 80, + 507, + 97 + ], + "score": 1.0, + "content": "Harsh Mehta, Ankit Gupta, Ashok Cutkosky, and Behnam Neyshabur. Long range language modeling", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 114, + 93, + 506, + 107 + ], + "spans": [ + { + "bbox": [ + 114, + 93, + 506, + 107 + ], + "score": 1.0, + "content": "via gated state spaces. In The International Conference on Learning Representations (ICLR), 2023.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 111, + 506, + 125 + ], + "spans": [ + { + "bbox": [ + 105, + 111, + 506, + 125 + ], + "score": 1.0, + "content": "Zakaria Mhammedi, Andrew Hellicar, Ashfaqur Rahman, and James Bailey. Efficient orthogonal", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 114, + 122, + 506, + 135 + ], + "spans": [ + { + "bbox": [ + 114, + 122, + 506, + 135 + ], + "score": 1.0, + "content": "parametrisation of recurrent neural networks using householder reflections. In International", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 114, + 132, + 375, + 146 + ], + "spans": [ + { + "bbox": [ + 114, + 132, + 375, + 146 + ], + "score": 1.0, + "content": "Conference on Machine Learning, pp. 2401–2409. PMLR, 2017.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 149, + 505, + 163 + ], + "spans": [ + { + "bbox": [ + 105, + 149, + 505, + 163 + ], + "score": 1.0, + "content": "Eric Nguyen, Karan Goel, Albert Gu, Gordon Downs, Preey Shah, Tri Dao, Stephen Baccus, and", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 161, + 507, + 175 + ], + "spans": [ + { + "bbox": [ + 115, + 161, + 507, + 175 + ], + "score": 1.0, + "content": "Christopher Re. S4nd: Modeling images and videos as multidimensional signals with state spaces. ´", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 115, + 173, + 363, + 185 + ], + "spans": [ + { + "bbox": [ + 115, + 173, + 363, + 185 + ], + "score": 1.0, + "content": "In Advances in Neural Information Processing Systems, 2022.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 189, + 506, + 203 + ], + "spans": [ + { + "bbox": [ + 105, + 189, + 506, + 203 + ], + "score": 1.0, + "content": "Eric Nguyen, Michael Poli, Marjan Faizi, Armin Thomas, Callum Birch-Sykes, Michael Wornow,", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 114, + 200, + 506, + 215 + ], + "spans": [ + { + "bbox": [ + 114, + 200, + 506, + 215 + ], + "score": 1.0, + "content": "Aman Patel, Clayton Rabideau, Stefano Massaroli, Yoshua Bengio, et al. Hyenadna: Long-range", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 113, + 211, + 507, + 226 + ], + "spans": [ + { + "bbox": [ + 113, + 211, + 507, + 226 + ], + "score": 1.0, + "content": "genomic sequence modeling at single nucleotide resolution. arXiv preprint arXiv:2306.15794, 2023.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 229, + 505, + 241 + ], + "spans": [ + { + "bbox": [ + 106, + 229, + 505, + 241 + ], + "score": 1.0, + "content": "Catherine Olsson, Nelson Elhage, Neel Nanda, Nicholas Joseph, Nova DasSarma, Tom Henighan,", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 115, + 240, + 505, + 252 + ], + "spans": [ + { + "bbox": [ + 115, + 240, + 505, + 252 + ], + "score": 1.0, + "content": "Ben Mann, Amanda Askell, Yuntao Bai, Anna Chen, Tom Conerly, Dawn Drain, Deep Ganguli,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 114, + 251, + 506, + 265 + ], + "spans": [ + { + "bbox": [ + 114, + 251, + 506, + 265 + ], + "score": 1.0, + "content": "Zac Hatfield-Dodds, Danny Hernandez, Scott Johnston, Andy Jones, Jackson Kernion, Liane", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 115, + 263, + 506, + 275 + ], + "spans": [ + { + "bbox": [ + 115, + 263, + 506, + 275 + ], + "score": 1.0, + "content": "Lovitt, Kamal Ndousse, Dario Amodei, Tom Brown, Jack Clark, Jared Kaplan, Sam McCandlish,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 272, + 507, + 286 + ], + "spans": [ + { + "bbox": [ + 115, + 272, + 507, + 286 + ], + "score": 1.0, + "content": "and Chris Olah. In-context learning and induction heads. Transformer Circuits Thread, 2022.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 115, + 284, + 477, + 296 + ], + "spans": [ + { + "bbox": [ + 115, + 284, + 477, + 296 + ], + "score": 1.0, + "content": "https://transformer-circuits.pub/2022/in-context-learning-and-induction-heads/index.html.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 302, + 506, + 313 + ], + "spans": [ + { + "bbox": [ + 106, + 302, + 506, + 313 + ], + "score": 1.0, + "content": "Aaron van den Oord, Sander Dieleman, Heiga Zen, Karen Simonyan, Oriol Vinyals, Alex Graves,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 312, + 505, + 324 + ], + "spans": [ + { + "bbox": [ + 115, + 312, + 505, + 324 + ], + "score": 1.0, + "content": "Nal Kalchbrenner, Andrew Senior, and Koray Kavukcuoglu. Wavenet: A generative model for", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 114, + 322, + 322, + 336 + ], + "spans": [ + { + "bbox": [ + 114, + 322, + 322, + 336 + ], + "score": 1.0, + "content": "raw audio. arXiv preprint arXiv:1609.03499, 2016.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 339, + 506, + 354 + ], + "spans": [ + { + "bbox": [ + 105, + 339, + 506, + 354 + ], + "score": 1.0, + "content": "Antonio Orvieto, Samuel L Smith, Albert Gu, Anushan Fernando, Caglar Gulcehre, Razvan Pascanu,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 114, + 351, + 506, + 365 + ], + "spans": [ + { + "bbox": [ + 114, + 351, + 506, + 365 + ], + "score": 1.0, + "content": "and Soham De. Resurrecting recurrent neural networks for long sequences. arXiv preprint", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 114, + 362, + 220, + 376 + ], + "spans": [ + { + "bbox": [ + 114, + 362, + 220, + 376 + ], + "score": 1.0, + "content": "arXiv:2303.06349, 2023.", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 380, + 506, + 392 + ], + "spans": [ + { + "bbox": [ + 106, + 380, + 506, + 392 + ], + "score": 1.0, + "content": "Denis Paperno, German Kruszewski, Angeliki Lazaridou, Quan Ngoc Pham, Raffaella Bernardi, ´", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 114, + 390, + 507, + 405 + ], + "spans": [ + { + "bbox": [ + 114, + 390, + 507, + 405 + ], + "score": 1.0, + "content": "Sandro Pezzelle, Marco Baroni, Gemma Boleda, and Raquel Fernandez. The lambada dataset: ´", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 114, + 400, + 487, + 416 + ], + "spans": [ + { + "bbox": [ + 114, + 400, + 487, + 416 + ], + "score": 1.0, + "content": "Word prediction requiring a broad discourse context. arXiv preprint arXiv:1606.06031, 2016.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 420, + 505, + 432 + ], + "spans": [ + { + "bbox": [ + 106, + 420, + 505, + 432 + ], + "score": 1.0, + "content": "Razvan Pascanu, Tomas Mikolov, and Yoshua Bengio. On the difficulty of training recurrent neural", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 114, + 430, + 443, + 444 + ], + "spans": [ + { + "bbox": [ + 114, + 430, + 443, + 444 + ], + "score": 1.0, + "content": "networks. In International conference on machine learning, pp. 1310–1318, 2013.", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 104, + 445, + 507, + 464 + ], + "spans": [ + { + "bbox": [ + 104, + 445, + 507, + 464 + ], + "score": 1.0, + "content": "Bo Peng, Eric Alcaide, Quentin Anthony, Alon Albalak, Samuel Arcadinho, Huanqi Cao, Xin Cheng,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 114, + 458, + 506, + 473 + ], + "spans": [ + { + "bbox": [ + 114, + 458, + 506, + 473 + ], + "score": 1.0, + "content": "Michael Chung, Matteo Grella, Kranthi Kiran GV, et al. Rwkv: Reinventing rnns for the transformer", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 114, + 469, + 295, + 483 + ], + "spans": [ + { + "bbox": [ + 114, + 469, + 295, + 483 + ], + "score": 1.0, + "content": "era. arXiv preprint arXiv:2305.13048, 2023.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 486, + 507, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 486, + 507, + 502 + ], + "score": 1.0, + "content": "Michael Poli, Stefano Massaroli, Eric Nguyen, Daniel Y Fu, Tri Dao, Stephen Baccus, Yoshua Bengio,", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 114, + 496, + 506, + 514 + ], + "spans": [ + { + "bbox": [ + 114, + 496, + 506, + 514 + ], + "score": 1.0, + "content": "Stefano Ermon, and Christopher Re. Hyena hierarchy: Towards larger convolutional language ´", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 114, + 507, + 311, + 522 + ], + "spans": [ + { + "bbox": [ + 114, + 507, + 311, + 522 + ], + "score": 1.0, + "content": "models. arXiv preprint arXiv:2302.10866, 2023.", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 527, + 506, + 541 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 506, + 541 + ], + "score": 1.0, + "content": "Prajit Ramachandran, Barret Zoph, and Quoc V Le. Swish: a self-gated activation function. arXiv", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 112, + 537, + 282, + 551 + ], + "spans": [ + { + "bbox": [ + 112, + 537, + 282, + 551 + ], + "score": 1.0, + "content": "preprint arXiv:1710.05941, 7(1):5, 2017.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 556, + 506, + 568 + ], + "spans": [ + { + "bbox": [ + 106, + 556, + 506, + 568 + ], + "score": 1.0, + "content": "David W Romero, Anna Kuzina, Erik J Bekkers, Jakub M Tomczak, and Mark Hoogendoorn. Ckconv:", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 114, + 567, + 480, + 581 + ], + "spans": [ + { + "bbox": [ + 114, + 567, + 480, + 581 + ], + "score": 1.0, + "content": "Continuous kernel convolution for sequential data. arXiv preprint arXiv:2102.02611, 2021.", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 584, + 506, + 598 + ], + "spans": [ + { + "bbox": [ + 105, + 584, + 506, + 598 + ], + "score": 1.0, + "content": "Keisuke Sakaguchi, Ronan Le Bras, Chandra Bhagavatula, and Yejin Choi. Winogrande: An", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 114, + 595, + 508, + 609 + ], + "spans": [ + { + "bbox": [ + 114, + 595, + 508, + 609 + ], + "score": 1.0, + "content": "adversarial winograd schema challenge at scale. Communications of the ACM, 64(9):99–106, 2021.", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 612, + 506, + 627 + ], + "spans": [ + { + "bbox": [ + 105, + 612, + 506, + 627 + ], + "score": 1.0, + "content": "George Saon, Ankit Gupta, and Xiaodong Cui. Diagonal state space augmented transformers for", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 113, + 623, + 507, + 639 + ], + "spans": [ + { + "bbox": [ + 113, + 623, + 507, + 639 + ], + "score": 1.0, + "content": "speech recognition. In ICASSP 2023-2023 IEEE International Conference on Acoustics, Speech", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 114, + 634, + 336, + 648 + ], + "spans": [ + { + "bbox": [ + 114, + 634, + 336, + 648 + ], + "score": 1.0, + "content": "and Signal Processing (ICASSP), pp. 1–5. IEEE, 2023.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 653, + 505, + 665 + ], + "spans": [ + { + "bbox": [ + 106, + 653, + 505, + 665 + ], + "score": 1.0, + "content": "Imanol Schlag, Kazuki Irie, and Jurgen Schmidhuber. Linear transformers are secretly fast weight ¨", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 114, + 664, + 499, + 678 + ], + "spans": [ + { + "bbox": [ + 114, + 664, + 499, + 678 + ], + "score": 1.0, + "content": "programmers. In International Conference on Machine Learning, pp. 9355–9366. PMLR, 2021.", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 680, + 467, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 680, + 467, + 695 + ], + "score": 1.0, + "content": "Noam Shazeer. Glu variants improve transformer. arXiv preprint arXiv:2002.05202, 2020.", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "Freda Shi, Xinyun Chen, Kanishka Misra, Nathan Scales, David Dohan, Ed H Chi, Nathanael", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 114, + 709, + 507, + 724 + ], + "spans": [ + { + "bbox": [ + 114, + 709, + 507, + 724 + ], + "score": 1.0, + "content": "Scharli, and Denny Zhou. Large language models can be easily distracted by irrelevant context. ¨", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 115, + 721, + 454, + 735 + ], + "spans": [ + { + "bbox": [ + 115, + 721, + 454, + 735 + ], + "score": 1.0, + "content": "In International Conference on Machine Learning, pp. 31210–31227. PMLR, 2023a.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 24 + } + ], + "page_idx": 12, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 304, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 305, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 305, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "list", + "bbox": [ + 104, + 58, + 507, + 732 + ], + "lines": [], + "index": 24, + "bbox_fs": [ + 104, + 80, + 508, + 735 + ], + "lines_deleted": true + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 74, + 507, + 626 + ], + "lines": [ + { + "bbox": [ + 106, + 83, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 83, + 505, + 95 + ], + "score": 1.0, + "content": "Jiaxin Shi, Ke Alexander Wang, and Emily B Fox. Sequence modeling with multiresolution", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 94, + 376, + 106 + ], + "spans": [ + { + "bbox": [ + 115, + 94, + 376, + 106 + ], + "score": 1.0, + "content": "convolutional memory. arXiv preprint arXiv:2305.01638, 2023b.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 112, + 506, + 126 + ], + "spans": [ + { + "bbox": [ + 105, + 112, + 506, + 126 + ], + "score": 1.0, + "content": "Jimmy TH Smith, Andrew Warrington, and Scott W Linderman. Simplified state space layers for", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 113, + 123, + 503, + 137 + ], + "spans": [ + { + "bbox": [ + 113, + 123, + 503, + 137 + ], + "score": 1.0, + "content": "sequence modeling. In The International Conference on Learning Representations (ICLR), 2023.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 141, + 506, + 155 + ], + "spans": [ + { + "bbox": [ + 105, + 141, + 506, + 155 + ], + "score": 1.0, + "content": "Jianlin Su, Yu Lu, Shengfeng Pan, Ahmed Murtadha, Bo Wen, and Yunfeng Liu. Roformer: Enhanced", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 115, + 152, + 454, + 165 + ], + "spans": [ + { + "bbox": [ + 115, + 152, + 454, + 165 + ], + "score": 1.0, + "content": "transformer with rotary position embedding. arXiv preprint arXiv:2104.09864, 2021.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 171, + 505, + 184 + ], + "spans": [ + { + "bbox": [ + 106, + 171, + 505, + 184 + ], + "score": 1.0, + "content": "Yutao Sun, Li Dong, Shaohan Huang, Shuming Ma, Yuqing Xia, Jilong Xue, Jianyong Wang, and", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 115, + 181, + 506, + 195 + ], + "spans": [ + { + "bbox": [ + 115, + 181, + 506, + 195 + ], + "score": 1.0, + "content": "Furu Wei. Retentive network: A successor to transformer for large language models. arXiv preprint", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 115, + 193, + 218, + 205 + ], + "spans": [ + { + "bbox": [ + 115, + 193, + 218, + 205 + ], + "score": 1.0, + "content": "arXiv:2307.08621, 2023.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 211, + 506, + 224 + ], + "spans": [ + { + "bbox": [ + 105, + 211, + 506, + 224 + ], + "score": 1.0, + "content": "Ilya Sutskever, Oriol Vinyals, and Quoc V Le. Sequence to sequence learning with neural networks.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 113, + 222, + 362, + 235 + ], + "spans": [ + { + "bbox": [ + 113, + 222, + 362, + 235 + ], + "score": 1.0, + "content": "Advances in neural information processing systems, 27, 2014.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 240, + 506, + 254 + ], + "spans": [ + { + "bbox": [ + 105, + 240, + 506, + 254 + ], + "score": 1.0, + "content": "Corentin Tallec and Yann Ollivier. Can recurrent neural networks warp time? In The International", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 116, + 252, + 337, + 264 + ], + "spans": [ + { + "bbox": [ + 116, + 252, + 337, + 264 + ], + "score": 1.0, + "content": "Conference on Learning Representations (ICLR), 2018.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 268, + 506, + 285 + ], + "spans": [ + { + "bbox": [ + 105, + 268, + 506, + 285 + ], + "score": 1.0, + "content": "Yi Tay, Mostafa Dehghani, Samira Abnar, Yikang Shen, Dara Bahri, Philip Pham, Jinfeng", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 115, + 281, + 506, + 295 + ], + "spans": [ + { + "bbox": [ + 115, + 281, + 506, + 295 + ], + "score": 1.0, + "content": "Rao, Liu Yang, Sebastian Ruder, and Donald Metzler. Long range arena : A benchmark for", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 291, + 506, + 305 + ], + "spans": [ + { + "bbox": [ + 115, + 291, + 506, + 305 + ], + "score": 1.0, + "content": "efficient transformers. In International Conference on Learning Representations, 2021. URL", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 115, + 303, + 380, + 316 + ], + "spans": [ + { + "bbox": [ + 115, + 303, + 380, + 316 + ], + "score": 1.0, + "content": "https://openreview.net/forum?id=qVyeW-grC2k.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 320, + 506, + 334 + ], + "spans": [ + { + "bbox": [ + 106, + 320, + 506, + 334 + ], + "score": 1.0, + "content": "Yi Tay, Mostafa Dehghani, Dara Bahri, and Donald Metzler. Efficient transformers: A survey. ACM", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 331, + 271, + 345 + ], + "spans": [ + { + "bbox": [ + 115, + 331, + 271, + 345 + ], + "score": 1.0, + "content": "Computing Surveys, 55(6):1–28, 2022.", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 351, + 505, + 363 + ], + "spans": [ + { + "bbox": [ + 106, + 351, + 505, + 363 + ], + "score": 1.0, + "content": "Hugo Touvron, Thibaut Lavril, Gautier Izacard, Xavier Martinet, Marie-Anne Lachaux, Timothee´", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 116, + 362, + 505, + 374 + ], + "spans": [ + { + "bbox": [ + 116, + 362, + 505, + 374 + ], + "score": 1.0, + "content": "Lacroix, Baptiste Roziere, Naman Goyal, Eric Hambro, Faisal Azhar, et al. Llama: Open and `", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 114, + 371, + 430, + 386 + ], + "spans": [ + { + "bbox": [ + 114, + 371, + 430, + 386 + ], + "score": 1.0, + "content": "efficient foundation language models. arXiv preprint arXiv:2302.13971, 2023.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 389, + 506, + 405 + ], + "spans": [ + { + "bbox": [ + 105, + 389, + 506, + 405 + ], + "score": 1.0, + "content": "Ashish Vaswani, Noam Shazeer, Niki Parmar, Jakob Uszkoreit, Llion Jones, Aidan N. Gomez,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 114, + 401, + 506, + 415 + ], + "spans": [ + { + "bbox": [ + 114, + 401, + 506, + 415 + ], + "score": 1.0, + "content": "Lukasz Kaiser, and Illia Polosukhin. Attention is all you need. In Advances in Neural Information", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 115, + 412, + 267, + 425 + ], + "spans": [ + { + "bbox": [ + 115, + 412, + 267, + 425 + ], + "score": 1.0, + "content": "Processing Systems (NeurIPS), 2017.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 104, + 429, + 506, + 446 + ], + "spans": [ + { + "bbox": [ + 104, + 429, + 506, + 446 + ], + "score": 1.0, + "content": "Eugene Vorontsov, Chiheb Trabelsi, Samuel Kadoury, and Chris Pal. On orthogonality and learning", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 113, + 440, + 507, + 456 + ], + "spans": [ + { + "bbox": [ + 113, + 440, + 507, + 456 + ], + "score": 1.0, + "content": "recurrent networks with long term dependencies. In International Conference on Machine Learning,", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 115, + 452, + 237, + 465 + ], + "spans": [ + { + "bbox": [ + 115, + 452, + 237, + 465 + ], + "score": 1.0, + "content": "pp. 3570–3578. PMLR, 2017.", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 471, + 506, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 506, + 484 + ], + "score": 1.0, + "content": "Jue Wang, Wentao Zhu, Pichao Wang, Xiang Yu, Linda Liu, Mohamed Omar, and Raffay Hamid.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 482, + 506, + 496 + ], + "spans": [ + { + "bbox": [ + 115, + 482, + 506, + 496 + ], + "score": 1.0, + "content": "Selective structured state-spaces for long-form video understanding. In Proceedings of the", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 115, + 493, + 478, + 506 + ], + "spans": [ + { + "bbox": [ + 115, + 493, + 478, + 506 + ], + "score": 1.0, + "content": "IEEE/CVF Conference on Computer Vision and Pattern Recognition, pp. 6387–6397, 2023.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 104, + 510, + 507, + 526 + ], + "spans": [ + { + "bbox": [ + 104, + 510, + 507, + 526 + ], + "score": 1.0, + "content": "Pete Warden. Speech commands: A dataset for limited-vocabulary speech recognition. ArXiv,", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 115, + 522, + 209, + 535 + ], + "spans": [ + { + "bbox": [ + 115, + 522, + 209, + 535 + ], + "score": 1.0, + "content": "abs/1804.03209, 2018.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 540, + 506, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 506, + 554 + ], + "score": 1.0, + "content": "Samuel Williams, Andrew Waterman, and David Patterson. Roofline: an insightful visual performance", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 115, + 551, + 451, + 564 + ], + "spans": [ + { + "bbox": [ + 115, + 551, + 451, + 564 + ], + "score": 1.0, + "content": "model for multicore architectures. Communications of the ACM, 52(4):65–76, 2009.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 570, + 506, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 570, + 506, + 583 + ], + "score": 1.0, + "content": "Brandon Yang, Gabriel Bender, Quoc V Le, and Jiquan Ngiam. Condconv: Conditionally parameterized", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 115, + 581, + 506, + 594 + ], + "spans": [ + { + "bbox": [ + 115, + 581, + 506, + 594 + ], + "score": 1.0, + "content": "convolutions for efficient inference. Advances in neural information processing systems, 32, 2019.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 599, + 506, + 613 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 506, + 613 + ], + "score": 1.0, + "content": "Shuangfei Zhai, Walter Talbott, Nitish Srivastava, Chen Huang, Hanlin Goh, Ruixiang Zhang, and", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 115, + 610, + 457, + 624 + ], + "spans": [ + { + "bbox": [ + 115, + 610, + 457, + 624 + ], + "score": 1.0, + "content": "Josh Susskind. An attention free transformer. arXiv preprint arXiv:2105.14103, 2021.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 19 + } + ], + "page_idx": 13, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 304, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 305, + 39 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 305, + 39 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "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": "14", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "list", + "bbox": [ + 105, + 74, + 507, + 626 + ], + "lines": [], + "index": 19, + "bbox_fs": [ + 104, + 83, + 507, + 624 + ], + "lines_deleted": true + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 81, + 193, + 94 + ], + "lines": [ + { + "bbox": [ + 105, + 80, + 195, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 80, + 195, + 96 + ], + "score": 1.0, + "content": "A DISCUSSION", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "title", + "bbox": [ + 107, + 100, + 362, + 111 + ], + "lines": [ + { + "bbox": [ + 106, + 100, + 363, + 113 + ], + "spans": [ + { + "bbox": [ + 106, + 100, + 363, + 113 + ], + "score": 1.0, + "content": "A.1 RELATED CONCEPTS TO THE SELECTION MECHANISM", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 107, + 116, + 505, + 159 + ], + "lines": [ + { + "bbox": [ + 105, + 115, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 505, + 128 + ], + "score": 1.0, + "content": "Our selection mechanism is inspired by and related to concepts such as gating, hypernetworks, and", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 126, + 506, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 506, + 139 + ], + "score": 1.0, + "content": "data-dependence. It can also be viewed as related to “fast weights” (Ba et al., 2016), which connects", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 137, + 505, + 149 + ], + "spans": [ + { + "bbox": [ + 106, + 137, + 505, + 149 + ], + "score": 1.0, + "content": "classical RNNs with the mechanism of linear attention (Schlag et al., 2021). However, we believe", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 147, + 305, + 162 + ], + "spans": [ + { + "bbox": [ + 105, + 147, + 305, + 162 + ], + "score": 1.0, + "content": "that it is a distinct concept that is worth clarifying.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 107, + 175, + 505, + 229 + ], + "lines": [ + { + "bbox": [ + 106, + 176, + 506, + 187 + ], + "spans": [ + { + "bbox": [ + 106, + 176, + 506, + 187 + ], + "score": 1.0, + "content": "Gating Gating originally referred to the gating mechanisms of RNNs such as the LSTM (Hochreiter", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 185, + 505, + 198 + ], + "spans": [ + { + "bbox": [ + 105, + 185, + 505, + 198 + ], + "score": 1.0, + "content": "& Schmidhuber, 1997) and GRU (Chung et al., 2014), or the gated equation in Theorem 1. This was", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 196, + 505, + 208 + ], + "spans": [ + { + "bbox": [ + 105, + 196, + 505, + 208 + ], + "score": 1.0, + "content": "interpreted as a particular mechanism for controlling whether to let an input into the hidden state of", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 207, + 506, + 220 + ], + "spans": [ + { + "bbox": [ + 105, + 207, + 506, + 220 + ], + "score": 1.0, + "content": "an RNN. In particular, this affects the propagation of signal through time and causes inputs to interact", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 219, + 256, + 230 + ], + "spans": [ + { + "bbox": [ + 106, + 219, + 256, + 230 + ], + "score": 1.0, + "content": "along the sequence length dimension.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 107, + 234, + 505, + 299 + ], + "lines": [ + { + "bbox": [ + 105, + 233, + 505, + 247 + ], + "spans": [ + { + "bbox": [ + 105, + 233, + 505, + 247 + ], + "score": 1.0, + "content": "However, the concept of gating has since been relaxed in popular usage to simply mean any", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 244, + 505, + 257 + ], + "spans": [ + { + "bbox": [ + 105, + 244, + 505, + 257 + ], + "score": 1.0, + "content": "multiplicative interaction (often with an activation function). For example, elementwise multiplicative", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 255, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 255, + 505, + 267 + ], + "score": 1.0, + "content": "components of neural network architectures (that do not interact along sequence length) are now", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 264, + 505, + 280 + ], + "spans": [ + { + "bbox": [ + 105, + 264, + 505, + 280 + ], + "score": 1.0, + "content": "commonly referred to as gated architectures (Hua et al., 2022; Mehta et al., 2023), despite a very", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 275, + 505, + 291 + ], + "spans": [ + { + "bbox": [ + 105, + 275, + 505, + 291 + ], + "score": 1.0, + "content": "different meaning than the original RNN sense. Thus we believe the original concept of RNN gating", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 287, + 492, + 301 + ], + "spans": [ + { + "bbox": [ + 105, + 287, + 492, + 301 + ], + "score": 1.0, + "content": "versus the popular usage of multiplicative gating actually have a very different semantic meaning.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 13.5 + }, + { + "type": "text", + "bbox": [ + 107, + 315, + 505, + 347 + ], + "lines": [ + { + "bbox": [ + 106, + 315, + 505, + 327 + ], + "spans": [ + { + "bbox": [ + 106, + 315, + 505, + 327 + ], + "score": 1.0, + "content": "Hypernetworks Hypernetworks refer to neural networks whose parameters are themselves", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 326, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 326, + 506, + 338 + ], + "score": 1.0, + "content": "generated by smaller neural networks. The original idea (Ha et al., 2017) used it in a narrow sense", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 336, + 435, + 349 + ], + "spans": [ + { + "bbox": [ + 105, + 336, + 435, + 349 + ], + "score": 1.0, + "content": "to define a large RNN whose recurrent parameters are generated by a smaller RNN.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 108, + 364, + 502, + 385 + ], + "lines": [ + { + "bbox": [ + 105, + 362, + 504, + 377 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 504, + 377 + ], + "score": 1.0, + "content": "Data-dependence Similar to hypernetworks, data-dependence can refer to any notion where some", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 374, + 352, + 387 + ], + "spans": [ + { + "bbox": [ + 105, + 374, + 352, + 387 + ], + "score": 1.0, + "content": "parameters of the model depend on the data (Poli et al., 2023).", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20.5 + }, + { + "type": "text", + "bbox": [ + 108, + 390, + 505, + 434 + ], + "lines": [ + { + "bbox": [ + 105, + 389, + 505, + 402 + ], + "spans": [ + { + "bbox": [ + 105, + 389, + 442, + 402 + ], + "score": 1.0, + "content": "To illustrate the issues with these concepts, consider a simple diagonal linear layer", + "type": "text" + }, + { + "bbox": [ + 442, + 390, + 474, + 401 + ], + "score": 0.92, + "content": "y = D x", + "type": "inline_equation" + }, + { + "bbox": [ + 474, + 389, + 505, + 402 + ], + "score": 1.0, + "content": ", where", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 107, + 401, + 505, + 412 + ], + "spans": [ + { + "bbox": [ + 107, + 401, + 116, + 411 + ], + "score": 0.81, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 117, + 401, + 271, + 412 + ], + "score": 1.0, + "content": "is a diagonal matrix. Now suppose that", + "type": "text" + }, + { + "bbox": [ + 271, + 401, + 281, + 411 + ], + "score": 0.83, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 281, + 401, + 475, + 412 + ], + "score": 1.0, + "content": "is itself generated from a linear transformation of", + "type": "text" + }, + { + "bbox": [ + 475, + 403, + 482, + 411 + ], + "score": 0.74, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 482, + 401, + 505, + 412 + ], + "score": 1.0, + "content": ", with", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 411, + 505, + 424 + ], + "spans": [ + { + "bbox": [ + 105, + 411, + 204, + 424 + ], + "score": 1.0, + "content": "an optional nonlinearity:", + "type": "text" + }, + { + "bbox": [ + 205, + 412, + 254, + 424 + ], + "score": 0.93, + "content": "D = \\sigma ( W x )", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 411, + 505, + 424 + ], + "score": 1.0, + "content": ". Since it is diagonal, the multiplication becomes an elementwise", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 422, + 205, + 435 + ], + "spans": [ + { + "bbox": [ + 106, + 423, + 142, + 435 + ], + "score": 1.0, + "content": "product:", + "type": "text" + }, + { + "bbox": [ + 142, + 422, + 201, + 434 + ], + "score": 0.93, + "content": "y = \\sigma ( W x ) \\circ \\dot { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 201, + 423, + 205, + 435 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23.5 + }, + { + "type": "text", + "bbox": [ + 107, + 438, + 505, + 492 + ], + "lines": [ + { + "bbox": [ + 105, + 437, + 505, + 450 + ], + "spans": [ + { + "bbox": [ + 105, + 437, + 505, + 450 + ], + "score": 1.0, + "content": "This is a rather trivial transformation, yet it technically satisfies the common meanings of gating (since", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 448, + 505, + 461 + ], + "spans": [ + { + "bbox": [ + 105, + 448, + 376, + 461 + ], + "score": 1.0, + "content": "it has a multiplicative “branch”), hypernetworks (since the parameter", + "type": "text" + }, + { + "bbox": [ + 376, + 449, + 385, + 459 + ], + "score": 0.79, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 386, + 448, + 505, + 461 + ], + "score": 1.0, + "content": "is generated by another layer),", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 459, + 505, + 471 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 215, + 471 + ], + "score": 1.0, + "content": "and data-dependent (since", + "type": "text" + }, + { + "bbox": [ + 216, + 460, + 225, + 469 + ], + "score": 0.77, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 226, + 459, + 309, + 471 + ], + "score": 1.0, + "content": "depends on the data", + "type": "text" + }, + { + "bbox": [ + 310, + 462, + 317, + 470 + ], + "score": 0.75, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 459, + 505, + 471 + ], + "score": 1.0, + "content": "). However, this in fact simply defines a GLU", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 469, + 506, + 483 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 506, + 483 + ], + "score": 1.0, + "content": "function, which is so simple that it is often considered just an activation function (Dauphin et al., 2017;", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 480, + 286, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 480, + 286, + 494 + ], + "score": 1.0, + "content": "Shazeer, 2020) instead of a meaningful layer.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 108, + 497, + 505, + 540 + ], + "lines": [ + { + "bbox": [ + 106, + 496, + 506, + 509 + ], + "spans": [ + { + "bbox": [ + 106, + 496, + 506, + 509 + ], + "score": 1.0, + "content": "Thus, while selection mechanisms could be considered a special case of ideas such as architectural gat-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 507, + 505, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 507, + 505, + 519 + ], + "score": 1.0, + "content": "ing, hypernetworks, or data-dependence, so can an enormous range of other constructions—essentially", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 518, + 506, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 518, + 506, + 529 + ], + "score": 1.0, + "content": "anything with a multiplication, including standard attention mechanisms (Bahdanau et al., 2014;", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 107, + 529, + 438, + 540 + ], + "spans": [ + { + "bbox": [ + 107, + 529, + 438, + 540 + ], + "score": 1.0, + "content": "Vaswani et al., 2017) as well—and we find it uninformative to think of them as such.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 107, + 545, + 505, + 631 + ], + "lines": [ + { + "bbox": [ + 105, + 544, + 506, + 557 + ], + "spans": [ + { + "bbox": [ + 105, + 544, + 506, + 557 + ], + "score": 1.0, + "content": "Instead, we view it as most closely related to the gating mechanism of traditional RNNs (LSTM and", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 554, + 506, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 506, + 568 + ], + "score": 1.0, + "content": "GRU), which is a special case (Theorem 1) and also has a deeper history of connections to SSMs", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 566, + 506, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 322, + 578 + ], + "score": 1.0, + "content": "through variable (input-dependent) discretization of", + "type": "text" + }, + { + "bbox": [ + 323, + 567, + 332, + 576 + ], + "score": 0.77, + "content": "\\Delta", + "type": "inline_equation" + }, + { + "bbox": [ + 333, + 566, + 506, + 578 + ], + "score": 1.0, + "content": "(Funahashi & Nakamura, 1993; Tallec &", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 576, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 106, + 576, + 505, + 590 + ], + "score": 1.0, + "content": "Ollivier, 2018; Gu et al., 2020a). We also eschew the term “gating” in favor of selection to clarify the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 587, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 505, + 599 + ], + "score": 1.0, + "content": "overloaded use of former. More narrowly, we use selection to refer to the mechanistic action of a model", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 599, + 504, + 609 + ], + "spans": [ + { + "bbox": [ + 106, + 599, + 504, + 609 + ], + "score": 1.0, + "content": "to select or ignore inputs and facilitate data interaction along the sequence length (Section 3.1). Beyond", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 608, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 608, + 505, + 622 + ], + "score": 1.0, + "content": "selective SSMs and gated RNNs, other examples may include input-dependent convolutions (Yang", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 619, + 309, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 619, + 309, + 632 + ], + "score": 1.0, + "content": "et al., 2019; Kosma et al., 2023) and even attention.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 38.5 + }, + { + "type": "title", + "bbox": [ + 108, + 648, + 212, + 661 + ], + "lines": [ + { + "bbox": [ + 105, + 647, + 214, + 663 + ], + "spans": [ + { + "bbox": [ + 105, + 647, + 214, + 663 + ], + "score": 1.0, + "content": "B RELATED WORK", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 43 + }, + { + "type": "text", + "bbox": [ + 109, + 667, + 327, + 678 + ], + "lines": [ + { + "bbox": [ + 107, + 667, + 329, + 680 + ], + "spans": [ + { + "bbox": [ + 107, + 667, + 329, + 680 + ], + "score": 1.0, + "content": "We highlight several prior works related to our methods.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 44 + }, + { + "type": "title", + "bbox": [ + 108, + 694, + 271, + 705 + ], + "lines": [ + { + "bbox": [ + 105, + 693, + 273, + 707 + ], + "spans": [ + { + "bbox": [ + 105, + 693, + 273, + 707 + ], + "score": 1.0, + "content": "B.1 S4 VARIANTS AND DERIVATIVES", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 45 + }, + { + "type": "text", + "bbox": [ + 107, + 710, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "score": 1.0, + "content": "We describe a brief overview of some structured SSMs from past work, particularly those that have", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 721, + 205, + 731 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 205, + 731 + ], + "score": 1.0, + "content": "a relation to our method.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 46.5 + } + ], + "page_idx": 14, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 304, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 304, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 304, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 81, + 193, + 94 + ], + "lines": [ + { + "bbox": [ + 105, + 80, + 195, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 80, + 195, + 96 + ], + "score": 1.0, + "content": "A DISCUSSION", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "title", + "bbox": [ + 107, + 100, + 362, + 111 + ], + "lines": [ + { + "bbox": [ + 106, + 100, + 363, + 113 + ], + "spans": [ + { + "bbox": [ + 106, + 100, + 363, + 113 + ], + "score": 1.0, + "content": "A.1 RELATED CONCEPTS TO THE SELECTION MECHANISM", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 107, + 116, + 505, + 159 + ], + "lines": [ + { + "bbox": [ + 105, + 115, + 505, + 128 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 505, + 128 + ], + "score": 1.0, + "content": "Our selection mechanism is inspired by and related to concepts such as gating, hypernetworks, and", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 126, + 506, + 139 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 506, + 139 + ], + "score": 1.0, + "content": "data-dependence. It can also be viewed as related to “fast weights” (Ba et al., 2016), which connects", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 137, + 505, + 149 + ], + "spans": [ + { + "bbox": [ + 106, + 137, + 505, + 149 + ], + "score": 1.0, + "content": "classical RNNs with the mechanism of linear attention (Schlag et al., 2021). However, we believe", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 147, + 305, + 162 + ], + "spans": [ + { + "bbox": [ + 105, + 147, + 305, + 162 + ], + "score": 1.0, + "content": "that it is a distinct concept that is worth clarifying.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3.5, + "bbox_fs": [ + 105, + 115, + 506, + 162 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 175, + 505, + 229 + ], + "lines": [ + { + "bbox": [ + 106, + 176, + 506, + 187 + ], + "spans": [ + { + "bbox": [ + 106, + 176, + 506, + 187 + ], + "score": 1.0, + "content": "Gating Gating originally referred to the gating mechanisms of RNNs such as the LSTM (Hochreiter", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 185, + 505, + 198 + ], + "spans": [ + { + "bbox": [ + 105, + 185, + 505, + 198 + ], + "score": 1.0, + "content": "& Schmidhuber, 1997) and GRU (Chung et al., 2014), or the gated equation in Theorem 1. This was", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 196, + 505, + 208 + ], + "spans": [ + { + "bbox": [ + 105, + 196, + 505, + 208 + ], + "score": 1.0, + "content": "interpreted as a particular mechanism for controlling whether to let an input into the hidden state of", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 207, + 506, + 220 + ], + "spans": [ + { + "bbox": [ + 105, + 207, + 506, + 220 + ], + "score": 1.0, + "content": "an RNN. In particular, this affects the propagation of signal through time and causes inputs to interact", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 219, + 256, + 230 + ], + "spans": [ + { + "bbox": [ + 106, + 219, + 256, + 230 + ], + "score": 1.0, + "content": "along the sequence length dimension.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 8, + "bbox_fs": [ + 105, + 176, + 506, + 230 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 234, + 505, + 299 + ], + "lines": [ + { + "bbox": [ + 105, + 233, + 505, + 247 + ], + "spans": [ + { + "bbox": [ + 105, + 233, + 505, + 247 + ], + "score": 1.0, + "content": "However, the concept of gating has since been relaxed in popular usage to simply mean any", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 244, + 505, + 257 + ], + "spans": [ + { + "bbox": [ + 105, + 244, + 505, + 257 + ], + "score": 1.0, + "content": "multiplicative interaction (often with an activation function). For example, elementwise multiplicative", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 255, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 255, + 505, + 267 + ], + "score": 1.0, + "content": "components of neural network architectures (that do not interact along sequence length) are now", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 264, + 505, + 280 + ], + "spans": [ + { + "bbox": [ + 105, + 264, + 505, + 280 + ], + "score": 1.0, + "content": "commonly referred to as gated architectures (Hua et al., 2022; Mehta et al., 2023), despite a very", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 275, + 505, + 291 + ], + "spans": [ + { + "bbox": [ + 105, + 275, + 505, + 291 + ], + "score": 1.0, + "content": "different meaning than the original RNN sense. Thus we believe the original concept of RNN gating", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 287, + 492, + 301 + ], + "spans": [ + { + "bbox": [ + 105, + 287, + 492, + 301 + ], + "score": 1.0, + "content": "versus the popular usage of multiplicative gating actually have a very different semantic meaning.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 13.5, + "bbox_fs": [ + 105, + 233, + 505, + 301 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 315, + 505, + 347 + ], + "lines": [ + { + "bbox": [ + 106, + 315, + 505, + 327 + ], + "spans": [ + { + "bbox": [ + 106, + 315, + 505, + 327 + ], + "score": 1.0, + "content": "Hypernetworks Hypernetworks refer to neural networks whose parameters are themselves", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 326, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 326, + 506, + 338 + ], + "score": 1.0, + "content": "generated by smaller neural networks. The original idea (Ha et al., 2017) used it in a narrow sense", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 336, + 435, + 349 + ], + "spans": [ + { + "bbox": [ + 105, + 336, + 435, + 349 + ], + "score": 1.0, + "content": "to define a large RNN whose recurrent parameters are generated by a smaller RNN.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18, + "bbox_fs": [ + 105, + 315, + 506, + 349 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 364, + 502, + 385 + ], + "lines": [ + { + "bbox": [ + 105, + 362, + 504, + 377 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 504, + 377 + ], + "score": 1.0, + "content": "Data-dependence Similar to hypernetworks, data-dependence can refer to any notion where some", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 374, + 352, + 387 + ], + "spans": [ + { + "bbox": [ + 105, + 374, + 352, + 387 + ], + "score": 1.0, + "content": "parameters of the model depend on the data (Poli et al., 2023).", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20.5, + "bbox_fs": [ + 105, + 362, + 504, + 387 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 390, + 505, + 434 + ], + "lines": [ + { + "bbox": [ + 105, + 389, + 505, + 402 + ], + "spans": [ + { + "bbox": [ + 105, + 389, + 442, + 402 + ], + "score": 1.0, + "content": "To illustrate the issues with these concepts, consider a simple diagonal linear layer", + "type": "text" + }, + { + "bbox": [ + 442, + 390, + 474, + 401 + ], + "score": 0.92, + "content": "y = D x", + "type": "inline_equation" + }, + { + "bbox": [ + 474, + 389, + 505, + 402 + ], + "score": 1.0, + "content": ", where", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 107, + 401, + 505, + 412 + ], + "spans": [ + { + "bbox": [ + 107, + 401, + 116, + 411 + ], + "score": 0.81, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 117, + 401, + 271, + 412 + ], + "score": 1.0, + "content": "is a diagonal matrix. Now suppose that", + "type": "text" + }, + { + "bbox": [ + 271, + 401, + 281, + 411 + ], + "score": 0.83, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 281, + 401, + 475, + 412 + ], + "score": 1.0, + "content": "is itself generated from a linear transformation of", + "type": "text" + }, + { + "bbox": [ + 475, + 403, + 482, + 411 + ], + "score": 0.74, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 482, + 401, + 505, + 412 + ], + "score": 1.0, + "content": ", with", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 411, + 505, + 424 + ], + "spans": [ + { + "bbox": [ + 105, + 411, + 204, + 424 + ], + "score": 1.0, + "content": "an optional nonlinearity:", + "type": "text" + }, + { + "bbox": [ + 205, + 412, + 254, + 424 + ], + "score": 0.93, + "content": "D = \\sigma ( W x )", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 411, + 505, + 424 + ], + "score": 1.0, + "content": ". Since it is diagonal, the multiplication becomes an elementwise", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 422, + 205, + 435 + ], + "spans": [ + { + "bbox": [ + 106, + 423, + 142, + 435 + ], + "score": 1.0, + "content": "product:", + "type": "text" + }, + { + "bbox": [ + 142, + 422, + 201, + 434 + ], + "score": 0.93, + "content": "y = \\sigma ( W x ) \\circ \\dot { x }", + "type": "inline_equation" + }, + { + "bbox": [ + 201, + 423, + 205, + 435 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23.5, + "bbox_fs": [ + 105, + 389, + 505, + 435 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 438, + 505, + 492 + ], + "lines": [ + { + "bbox": [ + 105, + 437, + 505, + 450 + ], + "spans": [ + { + "bbox": [ + 105, + 437, + 505, + 450 + ], + "score": 1.0, + "content": "This is a rather trivial transformation, yet it technically satisfies the common meanings of gating (since", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 448, + 505, + 461 + ], + "spans": [ + { + "bbox": [ + 105, + 448, + 376, + 461 + ], + "score": 1.0, + "content": "it has a multiplicative “branch”), hypernetworks (since the parameter", + "type": "text" + }, + { + "bbox": [ + 376, + 449, + 385, + 459 + ], + "score": 0.79, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 386, + 448, + 505, + 461 + ], + "score": 1.0, + "content": "is generated by another layer),", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 459, + 505, + 471 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 215, + 471 + ], + "score": 1.0, + "content": "and data-dependent (since", + "type": "text" + }, + { + "bbox": [ + 216, + 460, + 225, + 469 + ], + "score": 0.77, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 226, + 459, + 309, + 471 + ], + "score": 1.0, + "content": "depends on the data", + "type": "text" + }, + { + "bbox": [ + 310, + 462, + 317, + 470 + ], + "score": 0.75, + "content": "x", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 459, + 505, + 471 + ], + "score": 1.0, + "content": "). However, this in fact simply defines a GLU", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 469, + 506, + 483 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 506, + 483 + ], + "score": 1.0, + "content": "function, which is so simple that it is often considered just an activation function (Dauphin et al., 2017;", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 480, + 286, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 480, + 286, + 494 + ], + "score": 1.0, + "content": "Shazeer, 2020) instead of a meaningful layer.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 28, + "bbox_fs": [ + 105, + 437, + 506, + 494 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 497, + 505, + 540 + ], + "lines": [ + { + "bbox": [ + 106, + 496, + 506, + 509 + ], + "spans": [ + { + "bbox": [ + 106, + 496, + 506, + 509 + ], + "score": 1.0, + "content": "Thus, while selection mechanisms could be considered a special case of ideas such as architectural gat-", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 507, + 505, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 507, + 505, + 519 + ], + "score": 1.0, + "content": "ing, hypernetworks, or data-dependence, so can an enormous range of other constructions—essentially", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 518, + 506, + 529 + ], + "spans": [ + { + "bbox": [ + 105, + 518, + 506, + 529 + ], + "score": 1.0, + "content": "anything with a multiplication, including standard attention mechanisms (Bahdanau et al., 2014;", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 107, + 529, + 438, + 540 + ], + "spans": [ + { + "bbox": [ + 107, + 529, + 438, + 540 + ], + "score": 1.0, + "content": "Vaswani et al., 2017) as well—and we find it uninformative to think of them as such.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32.5, + "bbox_fs": [ + 105, + 496, + 506, + 540 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 545, + 505, + 631 + ], + "lines": [ + { + "bbox": [ + 105, + 544, + 506, + 557 + ], + "spans": [ + { + "bbox": [ + 105, + 544, + 506, + 557 + ], + "score": 1.0, + "content": "Instead, we view it as most closely related to the gating mechanism of traditional RNNs (LSTM and", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 554, + 506, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 506, + 568 + ], + "score": 1.0, + "content": "GRU), which is a special case (Theorem 1) and also has a deeper history of connections to SSMs", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 566, + 506, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 322, + 578 + ], + "score": 1.0, + "content": "through variable (input-dependent) discretization of", + "type": "text" + }, + { + "bbox": [ + 323, + 567, + 332, + 576 + ], + "score": 0.77, + "content": "\\Delta", + "type": "inline_equation" + }, + { + "bbox": [ + 333, + 566, + 506, + 578 + ], + "score": 1.0, + "content": "(Funahashi & Nakamura, 1993; Tallec &", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 576, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 106, + 576, + 505, + 590 + ], + "score": 1.0, + "content": "Ollivier, 2018; Gu et al., 2020a). We also eschew the term “gating” in favor of selection to clarify the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 587, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 505, + 599 + ], + "score": 1.0, + "content": "overloaded use of former. More narrowly, we use selection to refer to the mechanistic action of a model", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 599, + 504, + 609 + ], + "spans": [ + { + "bbox": [ + 106, + 599, + 504, + 609 + ], + "score": 1.0, + "content": "to select or ignore inputs and facilitate data interaction along the sequence length (Section 3.1). Beyond", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 608, + 505, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 608, + 505, + 622 + ], + "score": 1.0, + "content": "selective SSMs and gated RNNs, other examples may include input-dependent convolutions (Yang", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 619, + 309, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 619, + 309, + 632 + ], + "score": 1.0, + "content": "et al., 2019; Kosma et al., 2023) and even attention.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 38.5, + "bbox_fs": [ + 105, + 544, + 506, + 632 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 648, + 212, + 661 + ], + "lines": [ + { + "bbox": [ + 105, + 647, + 214, + 663 + ], + "spans": [ + { + "bbox": [ + 105, + 647, + 214, + 663 + ], + "score": 1.0, + "content": "B RELATED WORK", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 43 + }, + { + "type": "text", + "bbox": [ + 109, + 667, + 327, + 678 + ], + "lines": [ + { + "bbox": [ + 107, + 667, + 329, + 680 + ], + "spans": [ + { + "bbox": [ + 107, + 667, + 329, + 680 + ], + "score": 1.0, + "content": "We highlight several prior works related to our methods.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 44, + "bbox_fs": [ + 107, + 667, + 329, + 680 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 694, + 271, + 705 + ], + "lines": [ + { + "bbox": [ + 105, + 693, + 273, + 707 + ], + "spans": [ + { + "bbox": [ + 105, + 693, + 273, + 707 + ], + "score": 1.0, + "content": "B.1 S4 VARIANTS AND DERIVATIVES", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 45 + }, + { + "type": "text", + "bbox": [ + 107, + 710, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "score": 1.0, + "content": "We describe a brief overview of some structured SSMs from past work, particularly those that have", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 721, + 205, + 731 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 205, + 731 + ], + "score": 1.0, + "content": "a relation to our method.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 46.5, + "bbox_fs": [ + 105, + 709, + 505, + 731 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 506, + 320 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 505, + 95 + ], + "score": 1.0, + "content": "• S4 (Gu et al., 2021; 2022a) introduced the first structured SSM, describing diagonal structure and", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 114, + 93, + 505, + 105 + ], + "spans": [ + { + "bbox": [ + 114, + 93, + 505, + 105 + ], + "score": 1.0, + "content": "diagonal plus low-rank (DPLR). It focused on efficient convolutional algorithms for DPLR SSMs", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 113, + 104, + 464, + 116 + ], + "spans": [ + { + "bbox": [ + 113, + 104, + 464, + 116 + ], + "score": 1.0, + "content": "due to a connection to continuous-time online memorization (HIPPO) (Gu et al., 2020a).", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 107, + 116, + 505, + 129 + ], + "spans": [ + { + "bbox": [ + 107, + 116, + 505, + 129 + ], + "score": 1.0, + "content": "• DSS (Gupta, 2022) first discovered the empirical effectiveness of diagonal structured SSMs by", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 112, + 127, + 506, + 140 + ], + "spans": [ + { + "bbox": [ + 112, + 127, + 506, + 140 + ], + "score": 1.0, + "content": "approximating the HIPPO initialization. This was expanded on theoretically in S4D (Gu et al., 2022b).", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 107, + 140, + 505, + 153 + ], + "spans": [ + { + "bbox": [ + 107, + 140, + 505, + 153 + ], + "score": 1.0, + "content": "• S5 (Smith et al., 2023) independently discovered the diagonal SSM approximation, and is the first", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 114, + 151, + 505, + 164 + ], + "spans": [ + { + "bbox": [ + 114, + 151, + 505, + 164 + ], + "score": 1.0, + "content": "S4 model to be computed recurrently with the parallel scan. However, this required lowering the", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 114, + 162, + 505, + 174 + ], + "spans": [ + { + "bbox": [ + 114, + 162, + 505, + 174 + ], + "score": 1.0, + "content": "effective state dimension, which they accomplished by switching the SSM dimensions from a SISO", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 114, + 173, + 423, + 185 + ], + "spans": [ + { + "bbox": [ + 114, + 173, + 423, + 185 + ], + "score": 1.0, + "content": "(single-input single-output) to MIMO (multi-input multi-output) formulation.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 107, + 185, + 506, + 198 + ], + "spans": [ + { + "bbox": [ + 107, + 185, + 506, + 198 + ], + "score": 1.0, + "content": "• Mega (Ma et al., 2023) introduced a simplification of S4 to be real- instead of complex- valued,", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 114, + 196, + 505, + 209 + ], + "spans": [ + { + "bbox": [ + 114, + 196, + 505, + 209 + ], + "score": 1.0, + "content": "giving it an interpretation of being an exponential moving average (EMA). They additionally make", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 113, + 206, + 505, + 220 + ], + "spans": [ + { + "bbox": [ + 113, + 206, + 505, + 220 + ], + "score": 1.0, + "content": "an interesting connection of the discretization step of SSMs to an EMA damping term. Contrary", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 113, + 217, + 505, + 231 + ], + "spans": [ + { + "bbox": [ + 113, + 217, + 505, + 231 + ], + "score": 1.0, + "content": "to findings in the original S4 papers, this was the first model to show that real-valued SSMs are", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 114, + 229, + 505, + 241 + ], + "spans": [ + { + "bbox": [ + 114, + 229, + 505, + 241 + ], + "score": 1.0, + "content": "empirically effective in certain settings or when combined with different architectural components.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 107, + 241, + 505, + 254 + ], + "spans": [ + { + "bbox": [ + 107, + 241, + 505, + 254 + ], + "score": 1.0, + "content": "• Liquid S4 (Hasani et al., 2023) is also motivated by augmenting S4 with an input-dependent state", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 114, + 253, + 505, + 264 + ], + "spans": [ + { + "bbox": [ + 114, + 253, + 505, + 264 + ], + "score": 1.0, + "content": "transition. From this perspective it shares similarity to selection mechanisms, although in a limited", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 114, + 263, + 361, + 275 + ], + "spans": [ + { + "bbox": [ + 114, + 263, + 361, + 275 + ], + "score": 1.0, + "content": "form which is still computed convolutionally and close to LTI.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 274, + 506, + 289 + ], + "spans": [ + { + "bbox": [ + 106, + 274, + 506, + 289 + ], + "score": 1.0, + "content": "• SGConv (Li et al., 2023), Hyena (Poli et al., 2023), LongConv (Fu et al., 2023), MultiresConv (Shi", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 114, + 287, + 505, + 298 + ], + "spans": [ + { + "bbox": [ + 114, + 287, + 505, + 298 + ], + "score": 1.0, + "content": "et al., 2023b) all focus on the convolutional representation of S4 and create global or long convolution", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 114, + 297, + 505, + 311 + ], + "spans": [ + { + "bbox": [ + 114, + 297, + 505, + 311 + ], + "score": 1.0, + "content": "kernels with different parameterizations. However, these methods cannot do fast autoregressive", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 114, + 308, + 189, + 320 + ], + "spans": [ + { + "bbox": [ + 114, + 308, + 189, + 320 + ], + "score": 1.0, + "content": "inference directly.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 107, + 325, + 504, + 347 + ], + "lines": [ + { + "bbox": [ + 105, + 324, + 505, + 337 + ], + "spans": [ + { + "bbox": [ + 105, + 324, + 505, + 337 + ], + "score": 1.0, + "content": "Notably, all of these methods, and all other structured SSMs that we are aware of, have been", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 335, + 346, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 335, + 346, + 348 + ], + "score": 1.0, + "content": "non-selective and usually strictly LTI (linear time invariant).", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21.5 + }, + { + "type": "title", + "bbox": [ + 107, + 356, + 230, + 367 + ], + "lines": [ + { + "bbox": [ + 105, + 355, + 231, + 369 + ], + "spans": [ + { + "bbox": [ + 105, + 355, + 231, + 369 + ], + "score": 1.0, + "content": "B.2 SSM ARCHITECTURES", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 107, + 372, + 504, + 394 + ], + "lines": [ + { + "bbox": [ + 106, + 371, + 505, + 384 + ], + "spans": [ + { + "bbox": [ + 106, + 371, + 505, + 384 + ], + "score": 1.0, + "content": "We use SSM architectures or state space neural networks (SSNN) to refer to deep neural network", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 382, + 399, + 395 + ], + "spans": [ + { + "bbox": [ + 106, + 382, + 399, + 395 + ], + "score": 1.0, + "content": "architectures incorporating one of the previous SSMs as a black box layer.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24.5 + }, + { + "type": "text", + "bbox": [ + 106, + 400, + 506, + 657 + ], + "lines": [ + { + "bbox": [ + 107, + 399, + 505, + 411 + ], + "spans": [ + { + "bbox": [ + 107, + 399, + 505, + 411 + ], + "score": 1.0, + "content": "• GSS (Mehta et al., 2023) was the first gated neural network architecture incorporating SSMs. It is", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 114, + 410, + 505, + 421 + ], + "spans": [ + { + "bbox": [ + 114, + 410, + 505, + 421 + ], + "score": 1.0, + "content": "motivated by the gated attention unit (GAU) of Hua et al. (2022) and looks quite similar to our block,", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 114, + 420, + 505, + 432 + ], + "spans": [ + { + "bbox": [ + 114, + 420, + 505, + 432 + ], + "score": 1.0, + "content": "except with additional projections. Most importantly, its projection contracts the model dimension", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 114, + 431, + 505, + 443 + ], + "spans": [ + { + "bbox": [ + 114, + 431, + 505, + 443 + ], + "score": 1.0, + "content": "to reduce the state size of the SSM, while ours expands the model dimension in order to increase", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 114, + 442, + 323, + 453 + ], + "spans": [ + { + "bbox": [ + 114, + 442, + 323, + 453 + ], + "score": 1.0, + "content": "the state size, based on the motivation in Section 3.1.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 454, + 505, + 467 + ], + "spans": [ + { + "bbox": [ + 106, + 454, + 505, + 467 + ], + "score": 1.0, + "content": "• Mega (Ma et al., 2023) combined the EMA simplification of S4 described above into a hybrid", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 112, + 466, + 333, + 478 + ], + "spans": [ + { + "bbox": [ + 112, + 466, + 333, + 478 + ], + "score": 1.0, + "content": "architecture using an efficient attention approximation.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 477, + 506, + 491 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 506, + 491 + ], + "score": 1.0, + "content": "• H3 (Dao et al., 2023) is motivated by combining S4 with linear attention (Katharopoulos et al., 2020).", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 113, + 488, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 113, + 488, + 505, + 502 + ], + "score": 1.0, + "content": "It is the first to generalize this formulation of linear attention to more general recurrences, which", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 113, + 500, + 264, + 512 + ], + "spans": [ + { + "bbox": [ + 113, + 500, + 264, + 512 + ], + "score": 1.0, + "content": "is also the basis of later architectures.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 107, + 513, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 107, + 513, + 505, + 525 + ], + "score": 1.0, + "content": "• Selective S4 (Wang et al., 2023) incorporates S4 as a black box to generate a binary mask which", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 114, + 523, + 505, + 535 + ], + "spans": [ + { + "bbox": [ + 114, + 523, + 505, + 535 + ], + "score": 1.0, + "content": "is multiplied on the input. While sharing the “selection” name, we consider this an architectural", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 114, + 534, + 505, + 546 + ], + "spans": [ + { + "bbox": [ + 114, + 534, + 505, + 546 + ], + "score": 1.0, + "content": "modification that is closer to architectural gating than a selection mechanism (Appendix A.1). For", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 114, + 544, + 506, + 558 + ], + "spans": [ + { + "bbox": [ + 114, + 544, + 506, + 558 + ], + "score": 1.0, + "content": "example, we hypothesize that it would not solve the Selective Copying task because simply masking", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 114, + 555, + 506, + 568 + ], + "spans": [ + { + "bbox": [ + 114, + 555, + 506, + 568 + ], + "score": 1.0, + "content": "out the irrelevant inputs does not affect the spacing between the relevant ones (indeed, the Selective", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 114, + 567, + 490, + 578 + ], + "spans": [ + { + "bbox": [ + 114, + 567, + 490, + 578 + ], + "score": 1.0, + "content": "Copying task can even be viewed as coming pre-masked if the noise tokens are embedded to 0).", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 108, + 579, + 505, + 591 + ], + "spans": [ + { + "bbox": [ + 108, + 579, + 505, + 591 + ], + "score": 1.0, + "content": "• RetNet (Sun et al., 2023) is also based on Linear Attention and very similar to H3, but reduces the inner", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 113, + 590, + 506, + 603 + ], + "spans": [ + { + "bbox": [ + 113, + 590, + 322, + 603 + ], + "score": 1.0, + "content": "S4 layer to a special case where the state dimension is", + "type": "text" + }, + { + "bbox": [ + 322, + 591, + 348, + 601 + ], + "score": 0.9, + "content": "N = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 348, + 590, + 506, + 603 + ], + "score": 1.0, + "content": ". This simplification leads to an alternate", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 113, + 601, + 507, + 613 + ], + "spans": [ + { + "bbox": [ + 113, + 601, + 507, + 613 + ], + "score": 1.0, + "content": "way to parallelize the computation with a variant of standard multi-head attention instead of convo-", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 113, + 611, + 506, + 624 + ], + "spans": [ + { + "bbox": [ + 113, + 611, + 506, + 624 + ], + "score": 1.0, + "content": "lutions. Although not framed as such, its recurrence can be viewed as a special case of a linear SSM.", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 624, + 505, + 637 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 505, + 637 + ], + "score": 1.0, + "content": "• RWKV (Peng et al., 2023) is another recent RNN designed for language modeling. It is based on", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 113, + 635, + 505, + 648 + ], + "spans": [ + { + "bbox": [ + 113, + 635, + 505, + 648 + ], + "score": 1.0, + "content": "AFT (attention-free Transformer (Zhai et al., 2021)), another variant of linear attention. Its main", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 113, + 645, + 460, + 658 + ], + "spans": [ + { + "bbox": [ + 113, + 645, + 460, + 658 + ], + "score": 1.0, + "content": "“WKV” mechanism involves LTI recurrences and can be seen as the ratio of two SSMs.", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 107, + 663, + 505, + 696 + ], + "lines": [ + { + "bbox": [ + 106, + 663, + 505, + 675 + ], + "spans": [ + { + "bbox": [ + 106, + 663, + 505, + 675 + ], + "score": 1.0, + "content": "We also highlight the gated attention unit (GAU) from Hua et al. (2022), which was motivated", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 673, + 506, + 687 + ], + "spans": [ + { + "bbox": [ + 105, + 673, + 506, + 687 + ], + "score": 1.0, + "content": "by combining the Transformer’s MHA and MLP blocks together and was an inspiration for our", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 106, + 685, + 351, + 697 + ], + "spans": [ + { + "bbox": [ + 106, + 685, + 351, + 697 + ], + "score": 1.0, + "content": "architecture (Section 3.4) combining the H3 and MLP blocks.", + "type": "text" + } + ], + "index": 51 + } + ], + "index": 50 + }, + { + "type": "title", + "bbox": [ + 108, + 705, + 240, + 716 + ], + "lines": [ + { + "bbox": [ + 105, + 704, + 241, + 718 + ], + "spans": [ + { + "bbox": [ + 105, + 704, + 241, + 718 + ], + "score": 1.0, + "content": "B.3 RELATIONSHIP TO RNNS", + "type": "text" + } + ], + "index": 52 + } + ], + "index": 52 + }, + { + "type": "text", + "bbox": [ + 108, + 721, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 719, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 719, + 506, + 733 + ], + "score": 1.0, + "content": "RNNs and SSMs are broadly related, as they both involve the concepts of recurrence on a latent state.", + "type": "text" + } + ], + "index": 53 + } + ], + "index": 53 + } + ], + "page_idx": 15, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 304, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 304, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 304, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 752, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "list", + "bbox": [ + 106, + 82, + 506, + 320 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 505, + 95 + ], + "score": 1.0, + "content": "• S4 (Gu et al., 2021; 2022a) introduced the first structured SSM, describing diagonal structure and", + "type": "text" + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 93, + 505, + 105 + ], + "spans": [ + { + "bbox": [ + 114, + 93, + 505, + 105 + ], + "score": 1.0, + "content": "diagonal plus low-rank (DPLR). It focused on efficient convolutional algorithms for DPLR SSMs", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 113, + 104, + 464, + 116 + ], + "spans": [ + { + "bbox": [ + 113, + 104, + 464, + 116 + ], + "score": 1.0, + "content": "due to a connection to continuous-time online memorization (HIPPO) (Gu et al., 2020a).", + "type": "text" + } + ], + "index": 2, + "is_list_end_line": true + }, + { + "bbox": [ + 107, + 116, + 505, + 129 + ], + "spans": [ + { + "bbox": [ + 107, + 116, + 505, + 129 + ], + "score": 1.0, + "content": "• DSS (Gupta, 2022) first discovered the empirical effectiveness of diagonal structured SSMs by", + "type": "text" + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 112, + 127, + 506, + 140 + ], + "spans": [ + { + "bbox": [ + 112, + 127, + 506, + 140 + ], + "score": 1.0, + "content": "approximating the HIPPO initialization. This was expanded on theoretically in S4D (Gu et al., 2022b).", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 107, + 140, + 505, + 153 + ], + "spans": [ + { + "bbox": [ + 107, + 140, + 505, + 153 + ], + "score": 1.0, + "content": "• S5 (Smith et al., 2023) independently discovered the diagonal SSM approximation, and is the first", + "type": "text" + } + ], + "index": 5, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 151, + 505, + 164 + ], + "spans": [ + { + "bbox": [ + 114, + 151, + 505, + 164 + ], + "score": 1.0, + "content": "S4 model to be computed recurrently with the parallel scan. However, this required lowering the", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 114, + 162, + 505, + 174 + ], + "spans": [ + { + "bbox": [ + 114, + 162, + 505, + 174 + ], + "score": 1.0, + "content": "effective state dimension, which they accomplished by switching the SSM dimensions from a SISO", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 114, + 173, + 423, + 185 + ], + "spans": [ + { + "bbox": [ + 114, + 173, + 423, + 185 + ], + "score": 1.0, + "content": "(single-input single-output) to MIMO (multi-input multi-output) formulation.", + "type": "text" + } + ], + "index": 8, + "is_list_end_line": true + }, + { + "bbox": [ + 107, + 185, + 506, + 198 + ], + "spans": [ + { + "bbox": [ + 107, + 185, + 506, + 198 + ], + "score": 1.0, + "content": "• Mega (Ma et al., 2023) introduced a simplification of S4 to be real- instead of complex- valued,", + "type": "text" + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 196, + 505, + 209 + ], + "spans": [ + { + "bbox": [ + 114, + 196, + 505, + 209 + ], + "score": 1.0, + "content": "giving it an interpretation of being an exponential moving average (EMA). They additionally make", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 113, + 206, + 505, + 220 + ], + "spans": [ + { + "bbox": [ + 113, + 206, + 505, + 220 + ], + "score": 1.0, + "content": "an interesting connection of the discretization step of SSMs to an EMA damping term. Contrary", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 113, + 217, + 505, + 231 + ], + "spans": [ + { + "bbox": [ + 113, + 217, + 505, + 231 + ], + "score": 1.0, + "content": "to findings in the original S4 papers, this was the first model to show that real-valued SSMs are", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 114, + 229, + 505, + 241 + ], + "spans": [ + { + "bbox": [ + 114, + 229, + 505, + 241 + ], + "score": 1.0, + "content": "empirically effective in certain settings or when combined with different architectural components.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 107, + 241, + 505, + 254 + ], + "spans": [ + { + "bbox": [ + 107, + 241, + 505, + 254 + ], + "score": 1.0, + "content": "• Liquid S4 (Hasani et al., 2023) is also motivated by augmenting S4 with an input-dependent state", + "type": "text" + } + ], + "index": 14, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 253, + 505, + 264 + ], + "spans": [ + { + "bbox": [ + 114, + 253, + 505, + 264 + ], + "score": 1.0, + "content": "transition. From this perspective it shares similarity to selection mechanisms, although in a limited", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 114, + 263, + 361, + 275 + ], + "spans": [ + { + "bbox": [ + 114, + 263, + 361, + 275 + ], + "score": 1.0, + "content": "form which is still computed convolutionally and close to LTI.", + "type": "text" + } + ], + "index": 16, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 274, + 506, + 289 + ], + "spans": [ + { + "bbox": [ + 106, + 274, + 506, + 289 + ], + "score": 1.0, + "content": "• SGConv (Li et al., 2023), Hyena (Poli et al., 2023), LongConv (Fu et al., 2023), MultiresConv (Shi", + "type": "text" + } + ], + "index": 17, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 287, + 505, + 298 + ], + "spans": [ + { + "bbox": [ + 114, + 287, + 505, + 298 + ], + "score": 1.0, + "content": "et al., 2023b) all focus on the convolutional representation of S4 and create global or long convolution", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 114, + 297, + 505, + 311 + ], + "spans": [ + { + "bbox": [ + 114, + 297, + 505, + 311 + ], + "score": 1.0, + "content": "kernels with different parameterizations. However, these methods cannot do fast autoregressive", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 114, + 308, + 189, + 320 + ], + "spans": [ + { + "bbox": [ + 114, + 308, + 189, + 320 + ], + "score": 1.0, + "content": "inference directly.", + "type": "text" + } + ], + "index": 20, + "is_list_end_line": true + } + ], + "index": 10, + "bbox_fs": [ + 105, + 81, + 506, + 320 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 325, + 504, + 347 + ], + "lines": [ + { + "bbox": [ + 105, + 324, + 505, + 337 + ], + "spans": [ + { + "bbox": [ + 105, + 324, + 505, + 337 + ], + "score": 1.0, + "content": "Notably, all of these methods, and all other structured SSMs that we are aware of, have been", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 335, + 346, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 335, + 346, + 348 + ], + "score": 1.0, + "content": "non-selective and usually strictly LTI (linear time invariant).", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21.5, + "bbox_fs": [ + 105, + 324, + 505, + 348 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 356, + 230, + 367 + ], + "lines": [ + { + "bbox": [ + 105, + 355, + 231, + 369 + ], + "spans": [ + { + "bbox": [ + 105, + 355, + 231, + 369 + ], + "score": 1.0, + "content": "B.2 SSM ARCHITECTURES", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 107, + 372, + 504, + 394 + ], + "lines": [ + { + "bbox": [ + 106, + 371, + 505, + 384 + ], + "spans": [ + { + "bbox": [ + 106, + 371, + 505, + 384 + ], + "score": 1.0, + "content": "We use SSM architectures or state space neural networks (SSNN) to refer to deep neural network", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 382, + 399, + 395 + ], + "spans": [ + { + "bbox": [ + 106, + 382, + 399, + 395 + ], + "score": 1.0, + "content": "architectures incorporating one of the previous SSMs as a black box layer.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24.5, + "bbox_fs": [ + 106, + 371, + 505, + 395 + ] + }, + { + "type": "list", + "bbox": [ + 106, + 400, + 506, + 657 + ], + "lines": [ + { + "bbox": [ + 107, + 399, + 505, + 411 + ], + "spans": [ + { + "bbox": [ + 107, + 399, + 505, + 411 + ], + "score": 1.0, + "content": "• GSS (Mehta et al., 2023) was the first gated neural network architecture incorporating SSMs. It is", + "type": "text" + } + ], + "index": 26, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 410, + 505, + 421 + ], + "spans": [ + { + "bbox": [ + 114, + 410, + 505, + 421 + ], + "score": 1.0, + "content": "motivated by the gated attention unit (GAU) of Hua et al. (2022) and looks quite similar to our block,", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 114, + 420, + 505, + 432 + ], + "spans": [ + { + "bbox": [ + 114, + 420, + 505, + 432 + ], + "score": 1.0, + "content": "except with additional projections. Most importantly, its projection contracts the model dimension", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 114, + 431, + 505, + 443 + ], + "spans": [ + { + "bbox": [ + 114, + 431, + 505, + 443 + ], + "score": 1.0, + "content": "to reduce the state size of the SSM, while ours expands the model dimension in order to increase", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 114, + 442, + 323, + 453 + ], + "spans": [ + { + "bbox": [ + 114, + 442, + 323, + 453 + ], + "score": 1.0, + "content": "the state size, based on the motivation in Section 3.1.", + "type": "text" + } + ], + "index": 30, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 454, + 505, + 467 + ], + "spans": [ + { + "bbox": [ + 106, + 454, + 505, + 467 + ], + "score": 1.0, + "content": "• Mega (Ma et al., 2023) combined the EMA simplification of S4 described above into a hybrid", + "type": "text" + } + ], + "index": 31, + "is_list_start_line": true + }, + { + "bbox": [ + 112, + 466, + 333, + 478 + ], + "spans": [ + { + "bbox": [ + 112, + 466, + 333, + 478 + ], + "score": 1.0, + "content": "architecture using an efficient attention approximation.", + "type": "text" + } + ], + "index": 32, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 477, + 506, + 491 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 506, + 491 + ], + "score": 1.0, + "content": "• H3 (Dao et al., 2023) is motivated by combining S4 with linear attention (Katharopoulos et al., 2020).", + "type": "text" + } + ], + "index": 33, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 488, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 113, + 488, + 505, + 502 + ], + "score": 1.0, + "content": "It is the first to generalize this formulation of linear attention to more general recurrences, which", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 113, + 500, + 264, + 512 + ], + "spans": [ + { + "bbox": [ + 113, + 500, + 264, + 512 + ], + "score": 1.0, + "content": "is also the basis of later architectures.", + "type": "text" + } + ], + "index": 35, + "is_list_end_line": true + }, + { + "bbox": [ + 107, + 513, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 107, + 513, + 505, + 525 + ], + "score": 1.0, + "content": "• Selective S4 (Wang et al., 2023) incorporates S4 as a black box to generate a binary mask which", + "type": "text" + } + ], + "index": 36, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 523, + 505, + 535 + ], + "spans": [ + { + "bbox": [ + 114, + 523, + 505, + 535 + ], + "score": 1.0, + "content": "is multiplied on the input. While sharing the “selection” name, we consider this an architectural", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 114, + 534, + 505, + 546 + ], + "spans": [ + { + "bbox": [ + 114, + 534, + 505, + 546 + ], + "score": 1.0, + "content": "modification that is closer to architectural gating than a selection mechanism (Appendix A.1). For", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 114, + 544, + 506, + 558 + ], + "spans": [ + { + "bbox": [ + 114, + 544, + 506, + 558 + ], + "score": 1.0, + "content": "example, we hypothesize that it would not solve the Selective Copying task because simply masking", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 114, + 555, + 506, + 568 + ], + "spans": [ + { + "bbox": [ + 114, + 555, + 506, + 568 + ], + "score": 1.0, + "content": "out the irrelevant inputs does not affect the spacing between the relevant ones (indeed, the Selective", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 114, + 567, + 490, + 578 + ], + "spans": [ + { + "bbox": [ + 114, + 567, + 490, + 578 + ], + "score": 1.0, + "content": "Copying task can even be viewed as coming pre-masked if the noise tokens are embedded to 0).", + "type": "text" + } + ], + "index": 41, + "is_list_end_line": true + }, + { + "bbox": [ + 108, + 579, + 505, + 591 + ], + "spans": [ + { + "bbox": [ + 108, + 579, + 505, + 591 + ], + "score": 1.0, + "content": "• RetNet (Sun et al., 2023) is also based on Linear Attention and very similar to H3, but reduces the inner", + "type": "text" + } + ], + "index": 42, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 590, + 506, + 603 + ], + "spans": [ + { + "bbox": [ + 113, + 590, + 322, + 603 + ], + "score": 1.0, + "content": "S4 layer to a special case where the state dimension is", + "type": "text" + }, + { + "bbox": [ + 322, + 591, + 348, + 601 + ], + "score": 0.9, + "content": "N = 1", + "type": "inline_equation" + }, + { + "bbox": [ + 348, + 590, + 506, + 603 + ], + "score": 1.0, + "content": ". This simplification leads to an alternate", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 113, + 601, + 507, + 613 + ], + "spans": [ + { + "bbox": [ + 113, + 601, + 507, + 613 + ], + "score": 1.0, + "content": "way to parallelize the computation with a variant of standard multi-head attention instead of convo-", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 113, + 611, + 506, + 624 + ], + "spans": [ + { + "bbox": [ + 113, + 611, + 506, + 624 + ], + "score": 1.0, + "content": "lutions. Although not framed as such, its recurrence can be viewed as a special case of a linear SSM.", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 624, + 505, + 637 + ], + "spans": [ + { + "bbox": [ + 105, + 624, + 505, + 637 + ], + "score": 1.0, + "content": "• RWKV (Peng et al., 2023) is another recent RNN designed for language modeling. It is based on", + "type": "text" + } + ], + "index": 46, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 635, + 505, + 648 + ], + "spans": [ + { + "bbox": [ + 113, + 635, + 505, + 648 + ], + "score": 1.0, + "content": "AFT (attention-free Transformer (Zhai et al., 2021)), another variant of linear attention. Its main", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 113, + 645, + 460, + 658 + ], + "spans": [ + { + "bbox": [ + 113, + 645, + 460, + 658 + ], + "score": 1.0, + "content": "“WKV” mechanism involves LTI recurrences and can be seen as the ratio of two SSMs.", + "type": "text" + } + ], + "index": 48, + "is_list_end_line": true + } + ], + "index": 37, + "bbox_fs": [ + 105, + 399, + 507, + 658 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 663, + 505, + 696 + ], + "lines": [ + { + "bbox": [ + 106, + 663, + 505, + 675 + ], + "spans": [ + { + "bbox": [ + 106, + 663, + 505, + 675 + ], + "score": 1.0, + "content": "We also highlight the gated attention unit (GAU) from Hua et al. (2022), which was motivated", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 673, + 506, + 687 + ], + "spans": [ + { + "bbox": [ + 105, + 673, + 506, + 687 + ], + "score": 1.0, + "content": "by combining the Transformer’s MHA and MLP blocks together and was an inspiration for our", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 106, + 685, + 351, + 697 + ], + "spans": [ + { + "bbox": [ + 106, + 685, + 351, + 697 + ], + "score": 1.0, + "content": "architecture (Section 3.4) combining the H3 and MLP blocks.", + "type": "text" + } + ], + "index": 51 + } + ], + "index": 50, + "bbox_fs": [ + 105, + 663, + 506, + 697 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 705, + 240, + 716 + ], + "lines": [ + { + "bbox": [ + 105, + 704, + 241, + 718 + ], + "spans": [ + { + "bbox": [ + 105, + 704, + 241, + 718 + ], + "score": 1.0, + "content": "B.3 RELATIONSHIP TO RNNS", + "type": "text" + } + ], + "index": 52 + } + ], + "index": 52 + }, + { + "type": "text", + "bbox": [ + 108, + 721, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 719, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 719, + 506, + 733 + ], + "score": 1.0, + "content": "RNNs and SSMs are broadly related, as they both involve the concepts of recurrence on a latent state.", + "type": "text" + } + ], + "index": 53 + } + ], + "index": 53, + "bbox_fs": [ + 106, + 719, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 148 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 506, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 506, + 95 + ], + "score": 1.0, + "content": "Several older RNNs such as the strongly typed RNN (Balduzzi & Ghifary, 2016), quasi RNN (QRNN)", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 506, + 105 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 506, + 105 + ], + "score": 1.0, + "content": "(Bradbury et al., 2016), and simple recurrent unit (SRU) (Lei et al., 2017; Lei, 2021) involve forms", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 505, + 116 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 505, + 116 + ], + "score": 1.0, + "content": "of gated RNNs without time-wise nonlinearities. Because of the connections of gating mechanisms", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 114, + 505, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 114, + 505, + 127 + ], + "score": 1.0, + "content": "and selection mechanisms, these can be viewed as cases of selective SSMs, and are thus more powerful", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 505, + 137 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 505, + 137 + ], + "score": 1.0, + "content": "in a sense than the family of LTI structured SSMs above. However, they do not use state expansion", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 109, + 135, + 489, + 149 + ], + "spans": [ + { + "bbox": [ + 109, + 136, + 136, + 147 + ], + "score": 0.85, + "content": "N { = } 1", + "type": "inline_equation" + }, + { + "bbox": [ + 136, + 135, + 185, + 149 + ], + "score": 1.0, + "content": ") or selective", + "type": "text" + }, + { + "bbox": [ + 186, + 136, + 208, + 147 + ], + "score": 0.69, + "content": "^ { _ { B , C } }", + "type": "inline_equation" + }, + { + "bbox": [ + 208, + 135, + 489, + 149 + ], + "score": 1.0, + "content": "parameters, both of which are important for performance (Section 4.6).", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 107, + 151, + 505, + 217 + ], + "lines": [ + { + "bbox": [ + 105, + 151, + 505, + 164 + ], + "spans": [ + { + "bbox": [ + 105, + 151, + 505, + 164 + ], + "score": 1.0, + "content": "Additionally, older RNNs famously suffered from efficiency issues and the vanishing gradients", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 163, + 505, + 175 + ], + "spans": [ + { + "bbox": [ + 105, + 163, + 505, + 175 + ], + "score": 1.0, + "content": "problem (Pascanu et al., 2013), both caused by their sequential nature. The latter could be solved", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 173, + 506, + 186 + ], + "spans": [ + { + "bbox": [ + 105, + 173, + 506, + 186 + ], + "score": 1.0, + "content": "for some of the above RNNs by leveraging the parallel scan (Martin & Cundy, 2018), but the former", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 184, + 506, + 196 + ], + "spans": [ + { + "bbox": [ + 105, + 184, + 506, + 196 + ], + "score": 1.0, + "content": "was difficult without theory later developed for SSMs. For example, modern structured SSMs differ", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 193, + 507, + 209 + ], + "spans": [ + { + "bbox": [ + 105, + 193, + 507, + 209 + ], + "score": 1.0, + "content": "in more careful parameterization of the recurrent dynamics inspired by classical SSM theory (e.g.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 206, + 451, + 217 + ], + "spans": [ + { + "bbox": [ + 106, + 206, + 451, + 217 + ], + "score": 1.0, + "content": "through discretization (Gu et al., 2021; 2023)), or direct analysis (Orvieto et al., 2023)).", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 8.5 + }, + { + "type": "text", + "bbox": [ + 107, + 221, + 505, + 298 + ], + "lines": [ + { + "bbox": [ + 106, + 221, + 506, + 233 + ], + "spans": [ + { + "bbox": [ + 106, + 221, + 506, + 233 + ], + "score": 1.0, + "content": "We also note that there is a long line of work on orthogonal RNNs (Arjovsky et al., 2016; Henaff", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 231, + 506, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 231, + 506, + 244 + ], + "score": 1.0, + "content": "et al., 2016; Mhammedi et al., 2017; Vorontsov et al., 2017; Lezcano-Casado & Mart´ınez-Rubio,", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 241, + 506, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 241, + 299, + 255 + ], + "score": 1.0, + "content": "2019) which are motivated by constraining the", + "type": "text" + }, + { + "bbox": [ + 299, + 243, + 309, + 253 + ], + "score": 0.84, + "content": "\\overline { { A } }", + "type": "inline_equation" + }, + { + "bbox": [ + 309, + 241, + 506, + 255 + ], + "score": 1.0, + "content": "transition matrix to be orthogonal or unitary, in", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 253, + 506, + 266 + ], + "spans": [ + { + "bbox": [ + 106, + 253, + 506, + 266 + ], + "score": 1.0, + "content": "order to control its eigenvalues and prevent the vanishing gradient problem. However, these had other", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 264, + 505, + 275 + ], + "spans": [ + { + "bbox": [ + 106, + 264, + 505, + 275 + ], + "score": 1.0, + "content": "limitations; we believe that these stem from the fact that orthogonal/unitary RNNs are also LTI. For", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 276, + 505, + 287 + ], + "spans": [ + { + "bbox": [ + 106, + 276, + 505, + 287 + ], + "score": 1.0, + "content": "example, they are almost always evaluated on the Copying task which they can solve perfectly, but", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 286, + 379, + 298 + ], + "spans": [ + { + "bbox": [ + 106, + 286, + 379, + 298 + ], + "score": 1.0, + "content": "observed to struggle on the Selective Copying task (Jing et al., 2019).", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 15 + }, + { + "type": "title", + "bbox": [ + 107, + 307, + 242, + 318 + ], + "lines": [ + { + "bbox": [ + 105, + 306, + 244, + 320 + ], + "spans": [ + { + "bbox": [ + 105, + 306, + 244, + 320 + ], + "score": 1.0, + "content": "B.4 LONG CONTEXT MODELS", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 107, + 323, + 505, + 356 + ], + "lines": [ + { + "bbox": [ + 105, + 322, + 505, + 336 + ], + "spans": [ + { + "bbox": [ + 105, + 322, + 505, + 336 + ], + "score": 1.0, + "content": "Long context has become a popular subject, and several recent models have claimed to scale to longer", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 334, + 505, + 346 + ], + "spans": [ + { + "bbox": [ + 106, + 334, + 505, + 346 + ], + "score": 1.0, + "content": "and longer sequences. However, these are often from a computational standpoint and have not been", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 345, + 255, + 356 + ], + "spans": [ + { + "bbox": [ + 105, + 345, + 255, + 356 + ], + "score": 1.0, + "content": "extensively validated. These include:", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 106, + 360, + 505, + 453 + ], + "lines": [ + { + "bbox": [ + 105, + 359, + 505, + 373 + ], + "spans": [ + { + "bbox": [ + 105, + 359, + 505, + 373 + ], + "score": 1.0, + "content": "• Recurrent Memory Transformer (Bulatov et al., 2023), a lightweight wrapper around a Transformer", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 114, + 370, + 505, + 383 + ], + "spans": [ + { + "bbox": [ + 114, + 370, + 505, + 383 + ], + "score": 1.0, + "content": "backbone. It showed ability to generalize up to 1M sequences but only on synthetic memorization", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 114, + 381, + 456, + 393 + ], + "spans": [ + { + "bbox": [ + 114, + 381, + 456, + 393 + ], + "score": 1.0, + "content": "tasks; this result is similar to our Induction Heads extrapolation experiment (Figure 3).", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 394, + 505, + 408 + ], + "spans": [ + { + "bbox": [ + 105, + 394, + 505, + 408 + ], + "score": 1.0, + "content": "• LongNet (Ding et al., 2023), which claimed to scale to 1B length but only evaluated on length", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 114, + 406, + 214, + 418 + ], + "spans": [ + { + "bbox": [ + 114, + 407, + 149, + 417 + ], + "score": 0.87, + "content": "< 1 0 0 K", + "type": "inline_equation" + }, + { + "bbox": [ + 150, + 406, + 214, + 418 + ], + "score": 1.0, + "content": "for actual tasks.", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 420, + 505, + 433 + ], + "spans": [ + { + "bbox": [ + 106, + 420, + 505, + 433 + ], + "score": 1.0, + "content": "• Hyena and HyenaDNA (Poli et al., 2023; Nguyen et al., 2023), which claimed to leverage up to 1M", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 114, + 430, + 505, + 444 + ], + "spans": [ + { + "bbox": [ + 114, + 430, + 505, + 444 + ], + "score": 1.0, + "content": "context, but did not control for computation time. In fact, its claims about efficiency and performance", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 114, + 442, + 361, + 453 + ], + "spans": [ + { + "bbox": [ + 114, + 442, + 361, + 453 + ], + "score": 1.0, + "content": "would be largely matched by any of the LTI S4 variants above.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 26.5 + }, + { + "type": "text", + "bbox": [ + 105, + 457, + 504, + 479 + ], + "lines": [ + { + "bbox": [ + 105, + 457, + 505, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 457, + 505, + 470 + ], + "score": 1.0, + "content": "In contrast, we believe this work presents one of the first approaches to meaningfully demonstrate", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 468, + 283, + 480 + ], + "spans": [ + { + "bbox": [ + 106, + 468, + 283, + 480 + ], + "score": 1.0, + "content": "increasing performance with longer context.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 31.5 + }, + { + "type": "title", + "bbox": [ + 107, + 491, + 303, + 504 + ], + "lines": [ + { + "bbox": [ + 106, + 490, + 303, + 505 + ], + "spans": [ + { + "bbox": [ + 106, + 490, + 303, + 505 + ], + "score": 1.0, + "content": "C MECHANICS OF SELECTIVE SSMS", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 33 + }, + { + "type": "text", + "bbox": [ + 108, + 509, + 504, + 532 + ], + "lines": [ + { + "bbox": [ + 105, + 507, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 507, + 379, + 523 + ], + "score": 1.0, + "content": "Proof of Theorem 1. Consider a selective SSM (Algorithm 2) with", + "type": "text" + }, + { + "bbox": [ + 380, + 509, + 505, + 521 + ], + "score": 0.91, + "content": "N = 1 , A = - 1 , B = 1 , s _ { \\Delta } =", + "type": "inline_equation" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 520, + 395, + 533 + ], + "spans": [ + { + "bbox": [ + 106, + 520, + 132, + 533 + ], + "score": 1.0, + "content": "Linear", + "type": "text" + }, + { + "bbox": [ + 133, + 521, + 146, + 532 + ], + "score": 0.58, + "content": "( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 147, + 520, + 148, + 533 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 148, + 521, + 170, + 532 + ], + "score": 0.62, + "content": "\\tau _ { \\Delta } =", + "type": "inline_equation" + }, + { + "bbox": [ + 171, + 520, + 395, + 533 + ], + "score": 1.0, + "content": "softplus. The corresponding continuous-time SSM (1) is", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34.5 + }, + { + "type": "interline_equation", + "bbox": [ + 265, + 533, + 345, + 547 + ], + "lines": [ + { + "bbox": [ + 265, + 533, + 345, + 547 + ], + "spans": [ + { + "bbox": [ + 265, + 533, + 345, + 547 + ], + "score": 0.91, + "content": "h ( t ) = - h ( t ) + x ( t )", + "type": "interline_equation", + "image_path": "dba09118da2d3e0caed8ebffe36921e7ea2fdb63a46b6a1226a0bb0b7beae895.jpg" + } + ] + } + ], + "index": 36, + "virtual_lines": [ + { + "bbox": [ + 265, + 533, + 345, + 547 + ], + "spans": [], + "index": 36 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 549, + 258, + 560 + ], + "lines": [ + { + "bbox": [ + 106, + 547, + 259, + 562 + ], + "spans": [ + { + "bbox": [ + 106, + 547, + 259, + 562 + ], + "score": 1.0, + "content": "which is also called a leaky integrator.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 107, + 564, + 223, + 576 + ], + "lines": [ + { + "bbox": [ + 105, + 563, + 224, + 577 + ], + "spans": [ + { + "bbox": [ + 105, + 563, + 224, + 577 + ], + "score": 1.0, + "content": "The discretization step size is", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 38 + }, + { + "type": "interline_equation", + "bbox": [ + 225, + 577, + 387, + 619 + ], + "lines": [ + { + "bbox": [ + 225, + 577, + 387, + 619 + ], + "spans": [ + { + "bbox": [ + 225, + 577, + 387, + 619 + ], + "score": 0.92, + "content": "\\begin{array} { r l } & { \\Delta _ { k } = \\tau _ { \\Delta } ( \\mathsf { P a r a m e t e r } + s _ { \\Delta } ( x _ { k } ) ) } \\\\ & { \\quad = \\mathsf { s o f t p l u s } ( \\mathsf { P a r a m e t e r } + \\mathsf { L i n e a r } ( x _ { k } ) ) } \\\\ & { \\quad = \\mathsf { s o f t p l u s } ( \\mathsf { L i n e a r } ( x _ { k } ) ) } \\end{array}", + "type": "interline_equation", + "image_path": "51c7742c9bf92ac5d3e292d0572618641f2e1af7a0286f586aea5d126933eb1b.jpg" + } + ] + } + ], + "index": 40, + "virtual_lines": [ + { + "bbox": [ + 225, + 577, + 387, + 591.0 + ], + "spans": [], + "index": 39 + }, + { + "bbox": [ + 225, + 591.0, + 387, + 605.0 + ], + "spans": [], + "index": 40 + }, + { + "bbox": [ + 225, + 605.0, + 387, + 619.0 + ], + "spans": [], + "index": 41 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 621, + 502, + 643 + ], + "lines": [ + { + "bbox": [ + 105, + 619, + 504, + 633 + ], + "spans": [ + { + "bbox": [ + 105, + 619, + 504, + 633 + ], + "score": 1.0, + "content": "where we observe that the parameter can be viewed as a learnable bias and folded into the linear", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 104, + 631, + 152, + 644 + ], + "spans": [ + { + "bbox": [ + 104, + 631, + 152, + 644 + ], + "score": 1.0, + "content": "projection.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42.5 + }, + { + "type": "text", + "bbox": [ + 106, + 646, + 369, + 659 + ], + "lines": [ + { + "bbox": [ + 105, + 646, + 367, + 660 + ], + "spans": [ + { + "bbox": [ + 105, + 646, + 367, + 660 + ], + "score": 1.0, + "content": "Now applying the zero-order hold (ZOH) discretization formulas:", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 44 + }, + { + "type": "interline_equation", + "bbox": [ + 175, + 660, + 437, + 731 + ], + "lines": [ + { + "bbox": [ + 175, + 660, + 437, + 731 + ], + "spans": [ + { + "bbox": [ + 175, + 660, + 437, + 731 + ], + "score": 0.92, + "content": "\\begin{array} { r l } & { \\overline { { \\pmb { A } } } _ { k } = \\mathrm { e x p } ( \\Delta \\pmb { A } ) = \\frac { 1 } { 1 + \\mathrm { e x p } \\left( \\mathsf { L i n e a r } \\left( x _ { k } \\right) \\right) } = \\sigma ( - \\mathsf { L i n e a r } \\left( x _ { k } \\right) ) } \\\\ & { \\qquad = 1 - \\sigma ( \\mathsf { L i n e a r } \\left( x _ { k } \\right) ) } \\\\ & { \\overline { { \\pmb { B } } } _ { k } = ( \\Delta \\pmb { A } ) ^ { - 1 } ( \\mathrm { e x p } ( \\Delta \\pmb { A } ) - \\pmb { I } ) \\cdot \\Delta \\pmb { B } = - ( \\mathrm { e x p } ( \\Delta \\pmb { A } ) - \\pmb { I } ) = 1 - \\overline { { \\pmb { A } } } } \\\\ & { \\qquad = \\sigma ( \\mathsf { L i n e a r } ( x _ { k } ) ) . } \\end{array}", + "type": "interline_equation", + "image_path": "9680cb2ac64f8ba75a14878d5016a367fe39ef89d7f7fb19e50ff993bc836edd.jpg" + } + ] + } + ], + "index": 46, + "virtual_lines": [ + { + "bbox": [ + 175, + 660, + 437, + 683.6666666666666 + ], + "spans": [], + "index": 45 + }, + { + "bbox": [ + 175, + 683.6666666666666, + 437, + 707.3333333333333 + ], + "spans": [], + "index": 46 + }, + { + "bbox": [ + 175, + 707.3333333333333, + 437, + 730.9999999999999 + ], + "spans": [], + "index": 47 + } + ] + } + ], + "page_idx": 16, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 304, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 304, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 304, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 82, + 505, + 148 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 506, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 506, + 95 + ], + "score": 1.0, + "content": "Several older RNNs such as the strongly typed RNN (Balduzzi & Ghifary, 2016), quasi RNN (QRNN)", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 506, + 105 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 506, + 105 + ], + "score": 1.0, + "content": "(Bradbury et al., 2016), and simple recurrent unit (SRU) (Lei et al., 2017; Lei, 2021) involve forms", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 505, + 116 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 505, + 116 + ], + "score": 1.0, + "content": "of gated RNNs without time-wise nonlinearities. Because of the connections of gating mechanisms", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 114, + 505, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 114, + 505, + 127 + ], + "score": 1.0, + "content": "and selection mechanisms, these can be viewed as cases of selective SSMs, and are thus more powerful", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 126, + 505, + 137 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 505, + 137 + ], + "score": 1.0, + "content": "in a sense than the family of LTI structured SSMs above. However, they do not use state expansion", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 109, + 135, + 489, + 149 + ], + "spans": [ + { + "bbox": [ + 109, + 136, + 136, + 147 + ], + "score": 0.85, + "content": "N { = } 1", + "type": "inline_equation" + }, + { + "bbox": [ + 136, + 135, + 185, + 149 + ], + "score": 1.0, + "content": ") or selective", + "type": "text" + }, + { + "bbox": [ + 186, + 136, + 208, + 147 + ], + "score": 0.69, + "content": "^ { _ { B , C } }", + "type": "inline_equation" + }, + { + "bbox": [ + 208, + 135, + 489, + 149 + ], + "score": 1.0, + "content": "parameters, both of which are important for performance (Section 4.6).", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 2.5, + "bbox_fs": [ + 105, + 81, + 506, + 149 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 151, + 505, + 217 + ], + "lines": [ + { + "bbox": [ + 105, + 151, + 505, + 164 + ], + "spans": [ + { + "bbox": [ + 105, + 151, + 505, + 164 + ], + "score": 1.0, + "content": "Additionally, older RNNs famously suffered from efficiency issues and the vanishing gradients", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 163, + 505, + 175 + ], + "spans": [ + { + "bbox": [ + 105, + 163, + 505, + 175 + ], + "score": 1.0, + "content": "problem (Pascanu et al., 2013), both caused by their sequential nature. The latter could be solved", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 173, + 506, + 186 + ], + "spans": [ + { + "bbox": [ + 105, + 173, + 506, + 186 + ], + "score": 1.0, + "content": "for some of the above RNNs by leveraging the parallel scan (Martin & Cundy, 2018), but the former", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 184, + 506, + 196 + ], + "spans": [ + { + "bbox": [ + 105, + 184, + 506, + 196 + ], + "score": 1.0, + "content": "was difficult without theory later developed for SSMs. For example, modern structured SSMs differ", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 193, + 507, + 209 + ], + "spans": [ + { + "bbox": [ + 105, + 193, + 507, + 209 + ], + "score": 1.0, + "content": "in more careful parameterization of the recurrent dynamics inspired by classical SSM theory (e.g.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 206, + 451, + 217 + ], + "spans": [ + { + "bbox": [ + 106, + 206, + 451, + 217 + ], + "score": 1.0, + "content": "through discretization (Gu et al., 2021; 2023)), or direct analysis (Orvieto et al., 2023)).", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 8.5, + "bbox_fs": [ + 105, + 151, + 507, + 217 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 221, + 505, + 298 + ], + "lines": [ + { + "bbox": [ + 106, + 221, + 506, + 233 + ], + "spans": [ + { + "bbox": [ + 106, + 221, + 506, + 233 + ], + "score": 1.0, + "content": "We also note that there is a long line of work on orthogonal RNNs (Arjovsky et al., 2016; Henaff", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 231, + 506, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 231, + 506, + 244 + ], + "score": 1.0, + "content": "et al., 2016; Mhammedi et al., 2017; Vorontsov et al., 2017; Lezcano-Casado & Mart´ınez-Rubio,", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 241, + 506, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 241, + 299, + 255 + ], + "score": 1.0, + "content": "2019) which are motivated by constraining the", + "type": "text" + }, + { + "bbox": [ + 299, + 243, + 309, + 253 + ], + "score": 0.84, + "content": "\\overline { { A } }", + "type": "inline_equation" + }, + { + "bbox": [ + 309, + 241, + 506, + 255 + ], + "score": 1.0, + "content": "transition matrix to be orthogonal or unitary, in", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 253, + 506, + 266 + ], + "spans": [ + { + "bbox": [ + 106, + 253, + 506, + 266 + ], + "score": 1.0, + "content": "order to control its eigenvalues and prevent the vanishing gradient problem. However, these had other", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 264, + 505, + 275 + ], + "spans": [ + { + "bbox": [ + 106, + 264, + 505, + 275 + ], + "score": 1.0, + "content": "limitations; we believe that these stem from the fact that orthogonal/unitary RNNs are also LTI. For", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 276, + 505, + 287 + ], + "spans": [ + { + "bbox": [ + 106, + 276, + 505, + 287 + ], + "score": 1.0, + "content": "example, they are almost always evaluated on the Copying task which they can solve perfectly, but", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 286, + 379, + 298 + ], + "spans": [ + { + "bbox": [ + 106, + 286, + 379, + 298 + ], + "score": 1.0, + "content": "observed to struggle on the Selective Copying task (Jing et al., 2019).", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 15, + "bbox_fs": [ + 105, + 221, + 506, + 298 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 307, + 242, + 318 + ], + "lines": [ + { + "bbox": [ + 105, + 306, + 244, + 320 + ], + "spans": [ + { + "bbox": [ + 105, + 306, + 244, + 320 + ], + "score": 1.0, + "content": "B.4 LONG CONTEXT MODELS", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 107, + 323, + 505, + 356 + ], + "lines": [ + { + "bbox": [ + 105, + 322, + 505, + 336 + ], + "spans": [ + { + "bbox": [ + 105, + 322, + 505, + 336 + ], + "score": 1.0, + "content": "Long context has become a popular subject, and several recent models have claimed to scale to longer", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 334, + 505, + 346 + ], + "spans": [ + { + "bbox": [ + 106, + 334, + 505, + 346 + ], + "score": 1.0, + "content": "and longer sequences. However, these are often from a computational standpoint and have not been", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 345, + 255, + 356 + ], + "spans": [ + { + "bbox": [ + 105, + 345, + 255, + 356 + ], + "score": 1.0, + "content": "extensively validated. These include:", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 21, + "bbox_fs": [ + 105, + 322, + 505, + 356 + ] + }, + { + "type": "list", + "bbox": [ + 106, + 360, + 505, + 453 + ], + "lines": [ + { + "bbox": [ + 105, + 359, + 505, + 373 + ], + "spans": [ + { + "bbox": [ + 105, + 359, + 505, + 373 + ], + "score": 1.0, + "content": "• Recurrent Memory Transformer (Bulatov et al., 2023), a lightweight wrapper around a Transformer", + "type": "text" + } + ], + "index": 23, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 370, + 505, + 383 + ], + "spans": [ + { + "bbox": [ + 114, + 370, + 505, + 383 + ], + "score": 1.0, + "content": "backbone. It showed ability to generalize up to 1M sequences but only on synthetic memorization", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 114, + 381, + 456, + 393 + ], + "spans": [ + { + "bbox": [ + 114, + 381, + 456, + 393 + ], + "score": 1.0, + "content": "tasks; this result is similar to our Induction Heads extrapolation experiment (Figure 3).", + "type": "text" + } + ], + "index": 25, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 394, + 505, + 408 + ], + "spans": [ + { + "bbox": [ + 105, + 394, + 505, + 408 + ], + "score": 1.0, + "content": "• LongNet (Ding et al., 2023), which claimed to scale to 1B length but only evaluated on length", + "type": "text" + } + ], + "index": 26, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 406, + 214, + 418 + ], + "spans": [ + { + "bbox": [ + 114, + 407, + 149, + 417 + ], + "score": 0.87, + "content": "< 1 0 0 K", + "type": "inline_equation" + }, + { + "bbox": [ + 150, + 406, + 214, + 418 + ], + "score": 1.0, + "content": "for actual tasks.", + "type": "text" + } + ], + "index": 27, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 420, + 505, + 433 + ], + "spans": [ + { + "bbox": [ + 106, + 420, + 505, + 433 + ], + "score": 1.0, + "content": "• Hyena and HyenaDNA (Poli et al., 2023; Nguyen et al., 2023), which claimed to leverage up to 1M", + "type": "text" + } + ], + "index": 28, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 430, + 505, + 444 + ], + "spans": [ + { + "bbox": [ + 114, + 430, + 505, + 444 + ], + "score": 1.0, + "content": "context, but did not control for computation time. In fact, its claims about efficiency and performance", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 114, + 442, + 361, + 453 + ], + "spans": [ + { + "bbox": [ + 114, + 442, + 361, + 453 + ], + "score": 1.0, + "content": "would be largely matched by any of the LTI S4 variants above.", + "type": "text" + } + ], + "index": 30, + "is_list_end_line": true + } + ], + "index": 26.5, + "bbox_fs": [ + 105, + 359, + 505, + 453 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 457, + 504, + 479 + ], + "lines": [ + { + "bbox": [ + 105, + 457, + 505, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 457, + 505, + 470 + ], + "score": 1.0, + "content": "In contrast, we believe this work presents one of the first approaches to meaningfully demonstrate", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 468, + 283, + 480 + ], + "spans": [ + { + "bbox": [ + 106, + 468, + 283, + 480 + ], + "score": 1.0, + "content": "increasing performance with longer context.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 31.5, + "bbox_fs": [ + 105, + 457, + 505, + 480 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 491, + 303, + 504 + ], + "lines": [ + { + "bbox": [ + 106, + 490, + 303, + 505 + ], + "spans": [ + { + "bbox": [ + 106, + 490, + 303, + 505 + ], + "score": 1.0, + "content": "C MECHANICS OF SELECTIVE SSMS", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 33 + }, + { + "type": "text", + "bbox": [ + 108, + 509, + 504, + 532 + ], + "lines": [ + { + "bbox": [ + 105, + 507, + 505, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 507, + 379, + 523 + ], + "score": 1.0, + "content": "Proof of Theorem 1. Consider a selective SSM (Algorithm 2) with", + "type": "text" + }, + { + "bbox": [ + 380, + 509, + 505, + 521 + ], + "score": 0.91, + "content": "N = 1 , A = - 1 , B = 1 , s _ { \\Delta } =", + "type": "inline_equation" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 520, + 395, + 533 + ], + "spans": [ + { + "bbox": [ + 106, + 520, + 132, + 533 + ], + "score": 1.0, + "content": "Linear", + "type": "text" + }, + { + "bbox": [ + 133, + 521, + 146, + 532 + ], + "score": 0.58, + "content": "( x )", + "type": "inline_equation" + }, + { + "bbox": [ + 147, + 520, + 148, + 533 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 148, + 521, + 170, + 532 + ], + "score": 0.62, + "content": "\\tau _ { \\Delta } =", + "type": "inline_equation" + }, + { + "bbox": [ + 171, + 520, + 395, + 533 + ], + "score": 1.0, + "content": "softplus. The corresponding continuous-time SSM (1) is", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34.5, + "bbox_fs": [ + 105, + 507, + 505, + 533 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 265, + 533, + 345, + 547 + ], + "lines": [ + { + "bbox": [ + 265, + 533, + 345, + 547 + ], + "spans": [ + { + "bbox": [ + 265, + 533, + 345, + 547 + ], + "score": 0.91, + "content": "h ( t ) = - h ( t ) + x ( t )", + "type": "interline_equation", + "image_path": "dba09118da2d3e0caed8ebffe36921e7ea2fdb63a46b6a1226a0bb0b7beae895.jpg" + } + ] + } + ], + "index": 36, + "virtual_lines": [ + { + "bbox": [ + 265, + 533, + 345, + 547 + ], + "spans": [], + "index": 36 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 549, + 258, + 560 + ], + "lines": [ + { + "bbox": [ + 106, + 547, + 259, + 562 + ], + "spans": [ + { + "bbox": [ + 106, + 547, + 259, + 562 + ], + "score": 1.0, + "content": "which is also called a leaky integrator.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37, + "bbox_fs": [ + 106, + 547, + 259, + 562 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 564, + 223, + 576 + ], + "lines": [ + { + "bbox": [ + 105, + 563, + 224, + 577 + ], + "spans": [ + { + "bbox": [ + 105, + 563, + 224, + 577 + ], + "score": 1.0, + "content": "The discretization step size is", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 38, + "bbox_fs": [ + 105, + 563, + 224, + 577 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 225, + 577, + 387, + 619 + ], + "lines": [ + { + "bbox": [ + 225, + 577, + 387, + 619 + ], + "spans": [ + { + "bbox": [ + 225, + 577, + 387, + 619 + ], + "score": 0.92, + "content": "\\begin{array} { r l } & { \\Delta _ { k } = \\tau _ { \\Delta } ( \\mathsf { P a r a m e t e r } + s _ { \\Delta } ( x _ { k } ) ) } \\\\ & { \\quad = \\mathsf { s o f t p l u s } ( \\mathsf { P a r a m e t e r } + \\mathsf { L i n e a r } ( x _ { k } ) ) } \\\\ & { \\quad = \\mathsf { s o f t p l u s } ( \\mathsf { L i n e a r } ( x _ { k } ) ) } \\end{array}", + "type": "interline_equation", + "image_path": "51c7742c9bf92ac5d3e292d0572618641f2e1af7a0286f586aea5d126933eb1b.jpg" + } + ] + } + ], + "index": 40, + "virtual_lines": [ + { + "bbox": [ + 225, + 577, + 387, + 591.0 + ], + "spans": [], + "index": 39 + }, + { + "bbox": [ + 225, + 591.0, + 387, + 605.0 + ], + "spans": [], + "index": 40 + }, + { + "bbox": [ + 225, + 605.0, + 387, + 619.0 + ], + "spans": [], + "index": 41 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 621, + 502, + 643 + ], + "lines": [ + { + "bbox": [ + 105, + 619, + 504, + 633 + ], + "spans": [ + { + "bbox": [ + 105, + 619, + 504, + 633 + ], + "score": 1.0, + "content": "where we observe that the parameter can be viewed as a learnable bias and folded into the linear", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 104, + 631, + 152, + 644 + ], + "spans": [ + { + "bbox": [ + 104, + 631, + 152, + 644 + ], + "score": 1.0, + "content": "projection.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42.5, + "bbox_fs": [ + 104, + 619, + 504, + 644 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 646, + 369, + 659 + ], + "lines": [ + { + "bbox": [ + 105, + 646, + 367, + 660 + ], + "spans": [ + { + "bbox": [ + 105, + 646, + 367, + 660 + ], + "score": 1.0, + "content": "Now applying the zero-order hold (ZOH) discretization formulas:", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 44, + "bbox_fs": [ + 105, + 646, + 367, + 660 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 175, + 660, + 437, + 731 + ], + "lines": [ + { + "bbox": [ + 175, + 660, + 437, + 731 + ], + "spans": [ + { + "bbox": [ + 175, + 660, + 437, + 731 + ], + "score": 0.92, + "content": "\\begin{array} { r l } & { \\overline { { \\pmb { A } } } _ { k } = \\mathrm { e x p } ( \\Delta \\pmb { A } ) = \\frac { 1 } { 1 + \\mathrm { e x p } \\left( \\mathsf { L i n e a r } \\left( x _ { k } \\right) \\right) } = \\sigma ( - \\mathsf { L i n e a r } \\left( x _ { k } \\right) ) } \\\\ & { \\qquad = 1 - \\sigma ( \\mathsf { L i n e a r } \\left( x _ { k } \\right) ) } \\\\ & { \\overline { { \\pmb { B } } } _ { k } = ( \\Delta \\pmb { A } ) ^ { - 1 } ( \\mathrm { e x p } ( \\Delta \\pmb { A } ) - \\pmb { I } ) \\cdot \\Delta \\pmb { B } = - ( \\mathrm { e x p } ( \\Delta \\pmb { A } ) - \\pmb { I } ) = 1 - \\overline { { \\pmb { A } } } } \\\\ & { \\qquad = \\sigma ( \\mathsf { L i n e a r } ( x _ { k } ) ) . } \\end{array}", + "type": "interline_equation", + "image_path": "9680cb2ac64f8ba75a14878d5016a367fe39ef89d7f7fb19e50ff993bc836edd.jpg" + } + ] + } + ], + "index": 46, + "virtual_lines": [ + { + "bbox": [ + 175, + 660, + 437, + 683.6666666666666 + ], + "spans": [], + "index": 45 + }, + { + "bbox": [ + 175, + 683.6666666666666, + 437, + 707.3333333333333 + ], + "spans": [], + "index": 46 + }, + { + "bbox": [ + 175, + 707.3333333333333, + 437, + 730.9999999999999 + ], + "spans": [], + "index": 47 + } + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 82, + 264, + 93 + ], + "lines": [ + { + "bbox": [ + 106, + 80, + 267, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 80, + 267, + 95 + ], + "score": 1.0, + "content": "Thus the final discrete recurrence (2a) is", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "interline_equation", + "bbox": [ + 252, + 92, + 358, + 121 + ], + "lines": [ + { + "bbox": [ + 252, + 92, + 358, + 121 + ], + "spans": [ + { + "bbox": [ + 252, + 92, + 358, + 121 + ], + "score": 0.87, + "content": "\\begin{array} { l } { g _ { k } = \\sigma ( \\mathsf { L i n e a r } ( x _ { k } ) ) } \\\\ { h _ { k } = ( 1 - g _ { k } ) h _ { k - 1 } + g _ { k } x _ { k } } \\end{array}", + "type": "interline_equation", + "image_path": "7bdb05ee7e5171720bf82b576796e8053a73c7dfcb369c4f0eb60ba57531675e.jpg" + } + ] + } + ], + "index": 1.5, + "virtual_lines": [ + { + "bbox": [ + 252, + 92, + 358, + 106.5 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 252, + 106.5, + 358, + 121.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 119, + 149, + 130 + ], + "lines": [ + { + "bbox": [ + 105, + 118, + 151, + 131 + ], + "spans": [ + { + "bbox": [ + 105, + 118, + 151, + 131 + ], + "score": 1.0, + "content": "as desired.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + }, + { + "type": "title", + "bbox": [ + 108, + 145, + 415, + 158 + ], + "lines": [ + { + "bbox": [ + 106, + 145, + 415, + 159 + ], + "spans": [ + { + "bbox": [ + 106, + 145, + 415, + 159 + ], + "score": 1.0, + "content": "D HARDWARE-AWARE ALGORITHM FOR SELECTIVE SSMS", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 106, + 163, + 505, + 261 + ], + "lines": [ + { + "bbox": [ + 106, + 163, + 506, + 176 + ], + "spans": [ + { + "bbox": [ + 106, + 163, + 506, + 176 + ], + "score": 1.0, + "content": "Without input-dependent selectivity, SSMs can be efficiently implemented as a convolution (Gu", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 174, + 505, + 187 + ], + "spans": [ + { + "bbox": [ + 105, + 174, + 505, + 187 + ], + "score": 1.0, + "content": "et al., 2022a; Dao et al., 2023), which leverages the fast Fourier transform (FFT) as primitive. With", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 185, + 505, + 196 + ], + "spans": [ + { + "bbox": [ + 106, + 185, + 505, + 196 + ], + "score": 1.0, + "content": "selectivity, SSMs are no-longer equivalent to convolution, but we leverage the parallel associative", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 104, + 194, + 506, + 209 + ], + "spans": [ + { + "bbox": [ + 104, + 194, + 306, + 209 + ], + "score": 1.0, + "content": "scan. While SSM scans are theoretically efficient", + "type": "text" + }, + { + "bbox": [ + 306, + 195, + 357, + 207 + ], + "score": 0.86, + "content": "( O ( B L D N )", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 194, + 456, + 209 + ], + "score": 1.0, + "content": "FLOPs, scaling linear in", + "type": "text" + }, + { + "bbox": [ + 456, + 196, + 464, + 205 + ], + "score": 0.69, + "content": "L", + "type": "inline_equation" + }, + { + "bbox": [ + 465, + 194, + 506, + 209 + ], + "score": 1.0, + "content": "), training", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 207, + 506, + 218 + ], + "spans": [ + { + "bbox": [ + 106, + 207, + 506, + 218 + ], + "score": 1.0, + "content": "foundation models with selective SSMs requires them to be efficient on modern hardware (GPUs)", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 217, + 506, + 230 + ], + "spans": [ + { + "bbox": [ + 105, + 217, + 506, + 230 + ], + "score": 1.0, + "content": "as well. We describe how we use kernel fusion and recomputation to make SSM scan fast and", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 228, + 505, + 240 + ], + "spans": [ + { + "bbox": [ + 106, + 228, + 505, + 240 + ], + "score": 1.0, + "content": "memory-efficient. We evaluate the speed of our scan implementation compared to convolution and", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 239, + 506, + 252 + ], + "spans": [ + { + "bbox": [ + 106, + 239, + 291, + 252 + ], + "score": 1.0, + "content": "attention in Section 4.5, showing that it is up to", + "type": "text" + }, + { + "bbox": [ + 291, + 239, + 306, + 249 + ], + "score": 0.87, + "content": "7 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 239, + 506, + 252 + ], + "score": 1.0, + "content": "times faster than attention at sequence length 32K,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 250, + 427, + 261 + ], + "spans": [ + { + "bbox": [ + 106, + 250, + 427, + 261 + ], + "score": 1.0, + "content": "and is as memory-efficient as the best attention implementation (FlashAttention).", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 107, + 270, + 505, + 313 + ], + "lines": [ + { + "bbox": [ + 106, + 270, + 505, + 282 + ], + "spans": [ + { + "bbox": [ + 106, + 270, + 505, + 282 + ], + "score": 1.0, + "content": "Speed. On modern hardware accelerators (GPUs) most operations (except matrix multiply) are", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 280, + 505, + 292 + ], + "spans": [ + { + "bbox": [ + 106, + 280, + 505, + 292 + ], + "score": 1.0, + "content": "bounded by memory-bandwidth (Williams et al., 2009; Ivanov et al., 2021; Dao et al., 2022). This the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 290, + 505, + 305 + ], + "spans": [ + { + "bbox": [ + 105, + 290, + 505, + 305 + ], + "score": 1.0, + "content": "case with our scan operation, and we use kernel fusion to reduce the amount of memory IOs, leading", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 302, + 355, + 314 + ], + "spans": [ + { + "bbox": [ + 106, + 302, + 355, + 314 + ], + "score": 1.0, + "content": "to significant speedup compared to a standard implementation.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15.5 + }, + { + "type": "text", + "bbox": [ + 107, + 318, + 505, + 384 + ], + "lines": [ + { + "bbox": [ + 105, + 317, + 505, + 331 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 482, + 331 + ], + "score": 1.0, + "content": "The standard way to implement the scan algorithm in Section 3.2 is to prepare the scan input", + "type": "text" + }, + { + "bbox": [ + 482, + 317, + 505, + 330 + ], + "score": 0.66, + "content": "{ \\overline { { A } } } , { \\overline { { B } } }", + "type": "inline_equation" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 328, + 507, + 343 + ], + "spans": [ + { + "bbox": [ + 105, + 328, + 135, + 343 + ], + "score": 1.0, + "content": "of size", + "type": "text" + }, + { + "bbox": [ + 135, + 329, + 183, + 342 + ], + "score": 0.88, + "content": "( B , L , D , \\dot { N } )", + "type": "inline_equation" + }, + { + "bbox": [ + 184, + 328, + 507, + 343 + ], + "score": 1.0, + "content": "in GPU HBM (high-bandwidth memory, commonly referred to as GPU memory),", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 340, + 505, + 353 + ], + "spans": [ + { + "bbox": [ + 105, + 340, + 421, + 353 + ], + "score": 1.0, + "content": "call a parallel associative scan implementation to write the scan output of size", + "type": "text" + }, + { + "bbox": [ + 422, + 340, + 471, + 352 + ], + "score": 0.87, + "content": "( B , L , D , N )", + "type": "inline_equation" + }, + { + "bbox": [ + 471, + 340, + 505, + 353 + ], + "score": 1.0, + "content": "to GPU", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 349, + 506, + 364 + ], + "spans": [ + { + "bbox": [ + 105, + 349, + 277, + 364 + ], + "score": 1.0, + "content": "HBM, then multiply that scan output with", + "type": "text" + }, + { + "bbox": [ + 278, + 352, + 288, + 361 + ], + "score": 0.81, + "content": "C", + "type": "inline_equation" + }, + { + "bbox": [ + 288, + 349, + 403, + 364 + ], + "score": 1.0, + "content": "to produce an output of size", + "type": "text" + }, + { + "bbox": [ + 404, + 351, + 441, + 363 + ], + "score": 0.9, + "content": "( B , \\dot { L } , D )", + "type": "inline_equation" + }, + { + "bbox": [ + 442, + 349, + 506, + 364 + ], + "score": 1.0, + "content": ". However, this", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 361, + 506, + 374 + ], + "spans": [ + { + "bbox": [ + 105, + 361, + 352, + 374 + ], + "score": 1.0, + "content": "requires the number of memory reads/writes on the order of", + "type": "text" + }, + { + "bbox": [ + 352, + 362, + 401, + 374 + ], + "score": 0.92, + "content": "\\bar { O ( } B L D N )", + "type": "inline_equation" + }, + { + "bbox": [ + 401, + 361, + 506, + 374 + ], + "score": 1.0, + "content": ". We can instead fuse the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 372, + 403, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 372, + 327, + 385 + ], + "score": 1.0, + "content": "discretization step, the scan, and the multiplication with", + "type": "text" + }, + { + "bbox": [ + 327, + 373, + 337, + 383 + ], + "score": 0.83, + "content": "C", + "type": "inline_equation" + }, + { + "bbox": [ + 338, + 372, + 403, + 385 + ], + "score": 1.0, + "content": "into one kernel:", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 20.5 + }, + { + "type": "text", + "bbox": [ + 125, + 392, + 505, + 462 + ], + "lines": [ + { + "bbox": [ + 130, + 392, + 499, + 405 + ], + "spans": [ + { + "bbox": [ + 130, + 392, + 186, + 405 + ], + "score": 1.0, + "content": "1. We read in", + "type": "text" + }, + { + "bbox": [ + 186, + 392, + 252, + 405 + ], + "score": 0.9, + "content": "O ( B L D + D N )", + "type": "inline_equation" + }, + { + "bbox": [ + 252, + 392, + 323, + 405 + ], + "score": 1.0, + "content": "bytes of memory", + "type": "text" + }, + { + "bbox": [ + 323, + 392, + 372, + 404 + ], + "score": 0.63, + "content": "( \\Delta , A , B , C )", + "type": "inline_equation" + }, + { + "bbox": [ + 373, + 392, + 499, + 405 + ], + "score": 1.0, + "content": "from slow HBM to fast SRAM.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 129, + 408, + 384, + 421 + ], + "spans": [ + { + "bbox": [ + 129, + 408, + 241, + 421 + ], + "score": 1.0, + "content": "2. We discretize to produce", + "type": "text" + }, + { + "bbox": [ + 241, + 408, + 263, + 420 + ], + "score": 0.47, + "content": "\\overline { { A } } , \\overline { { B } }", + "type": "inline_equation" + }, + { + "bbox": [ + 263, + 408, + 292, + 421 + ], + "score": 1.0, + "content": "of size", + "type": "text" + }, + { + "bbox": [ + 292, + 409, + 340, + 421 + ], + "score": 0.63, + "content": "( B , L , D , N )", + "type": "inline_equation" + }, + { + "bbox": [ + 341, + 408, + 384, + 421 + ], + "score": 1.0, + "content": "in SRAM.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 129, + 424, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 129, + 424, + 444, + 437 + ], + "score": 1.0, + "content": "3. We perform a parallel associative scan, yielding intermediate states of size", + "type": "text" + }, + { + "bbox": [ + 444, + 424, + 493, + 436 + ], + "score": 0.74, + "content": "( B , L , D , N )", + "type": "inline_equation" + }, + { + "bbox": [ + 494, + 424, + 505, + 437 + ], + "score": 1.0, + "content": "in", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 141, + 435, + 176, + 447 + ], + "spans": [ + { + "bbox": [ + 141, + 435, + 176, + 447 + ], + "score": 1.0, + "content": "SRAM.", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 129, + 450, + 484, + 463 + ], + "spans": [ + { + "bbox": [ + 129, + 450, + 247, + 463 + ], + "score": 1.0, + "content": "4. We multiply and sum with", + "type": "text" + }, + { + "bbox": [ + 248, + 451, + 257, + 460 + ], + "score": 0.82, + "content": "C", + "type": "inline_equation" + }, + { + "bbox": [ + 258, + 450, + 363, + 463 + ], + "score": 1.0, + "content": ", producing outputs of size", + "type": "text" + }, + { + "bbox": [ + 363, + 450, + 399, + 462 + ], + "score": 0.45, + "content": "( \\boldsymbol { B } , \\boldsymbol { L } , \\boldsymbol { D } )", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 450, + 484, + 463 + ], + "score": 1.0, + "content": "and write it to HBM.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 108, + 470, + 504, + 493 + ], + "lines": [ + { + "bbox": [ + 106, + 469, + 505, + 484 + ], + "spans": [ + { + "bbox": [ + 106, + 469, + 262, + 484 + ], + "score": 1.0, + "content": "This way, we reduce IOs by a factor of", + "type": "text" + }, + { + "bbox": [ + 262, + 470, + 288, + 483 + ], + "score": 0.92, + "content": "O ( N )", + "type": "inline_equation" + }, + { + "bbox": [ + 288, + 469, + 505, + 484 + ], + "score": 1.0, + "content": "(the state dimension), which in practice speeds up the", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 480, + 263, + 494 + ], + "spans": [ + { + "bbox": [ + 106, + 480, + 263, + 494 + ], + "score": 1.0, + "content": "operation by 20-40 times (Section 4.5).", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29.5 + }, + { + "type": "text", + "bbox": [ + 108, + 497, + 503, + 530 + ], + "lines": [ + { + "bbox": [ + 106, + 496, + 505, + 510 + ], + "spans": [ + { + "bbox": [ + 106, + 496, + 189, + 510 + ], + "score": 1.0, + "content": "For sequence length", + "type": "text" + }, + { + "bbox": [ + 189, + 497, + 198, + 507 + ], + "score": 0.71, + "content": "L", + "type": "inline_equation" + }, + { + "bbox": [ + 198, + 496, + 505, + 510 + ], + "score": 1.0, + "content": "too long where we cannot fit the sequence in SRAM (which is much smaller", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 507, + 505, + 521 + ], + "spans": [ + { + "bbox": [ + 105, + 507, + 505, + 521 + ], + "score": 1.0, + "content": "than HBM), we split the sequences into chunks and perform the fused scan on each chunk. As long", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 519, + 444, + 530 + ], + "spans": [ + { + "bbox": [ + 105, + 519, + 444, + 530 + ], + "score": 1.0, + "content": "as we have the intermediate scan states, we can continue the scan with the next chunk.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 106, + 538, + 504, + 561 + ], + "lines": [ + { + "bbox": [ + 106, + 539, + 504, + 550 + ], + "spans": [ + { + "bbox": [ + 106, + 539, + 504, + 550 + ], + "score": 1.0, + "content": "Memory. We describe how we use the classical technique of recomputation to reduce the total", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 550, + 335, + 561 + ], + "spans": [ + { + "bbox": [ + 106, + 550, + 335, + 561 + ], + "score": 1.0, + "content": "amount of memory required to train selective SSM layers.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34.5 + }, + { + "type": "text", + "bbox": [ + 107, + 565, + 505, + 641 + ], + "lines": [ + { + "bbox": [ + 105, + 565, + 505, + 577 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 454, + 577 + ], + "score": 1.0, + "content": "From the way we fuse the forward pass, we do not save the intermediate states of size", + "type": "text" + }, + { + "bbox": [ + 455, + 565, + 505, + 577 + ], + "score": 0.85, + "content": "( B , L , D , N )", + "type": "inline_equation" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 577, + 506, + 589 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 506, + 589 + ], + "score": 1.0, + "content": "to avoid memory blowup. However, these intermediate states are necessary for the backward pass", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 587, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 505, + 599 + ], + "score": 1.0, + "content": "to compute gradients. We instead recompute those intermediate states in the backward pass. Since the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 597, + 505, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 597, + 133, + 609 + ], + "score": 1.0, + "content": "inputs", + "type": "text" + }, + { + "bbox": [ + 133, + 597, + 177, + 608 + ], + "score": 0.87, + "content": "\\bar { \\Delta } , \\bar { A , } \\bar { B , } C", + "type": "inline_equation" + }, + { + "bbox": [ + 178, + 597, + 403, + 609 + ], + "score": 1.0, + "content": "and output gradient read from HBM to SRAM are of size", + "type": "text" + }, + { + "bbox": [ + 404, + 597, + 470, + 609 + ], + "score": 0.89, + "content": "O ( B L N { + } D N )", + "type": "inline_equation" + }, + { + "bbox": [ + 471, + 597, + 505, + 609 + ], + "score": 1.0, + "content": ", and the", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 104, + 608, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 104, + 608, + 226, + 621 + ], + "score": 1.0, + "content": "input gradients are also of size", + "type": "text" + }, + { + "bbox": [ + 226, + 608, + 293, + 620 + ], + "score": 0.93, + "content": "O ( B L N + D N )", + "type": "inline_equation" + }, + { + "bbox": [ + 293, + 608, + 456, + 621 + ], + "score": 1.0, + "content": ", recomputation avoids the cost of reading", + "type": "text" + }, + { + "bbox": [ + 456, + 608, + 505, + 620 + ], + "score": 0.91, + "content": "O ( B L N D )", + "type": "inline_equation" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 619, + 506, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 619, + 506, + 632 + ], + "score": 1.0, + "content": "elements from HBM. This means that recomputation of the SSM states in the backward pass speeds", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 630, + 406, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 630, + 406, + 642 + ], + "score": 1.0, + "content": "up the computation compared to storing them and reading them from HBM.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 39 + }, + { + "type": "text", + "bbox": [ + 107, + 645, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 646, + 505, + 658 + ], + "spans": [ + { + "bbox": [ + 106, + 646, + 505, + 658 + ], + "score": 1.0, + "content": "Beyond optimizing for the memory requirement of just the scan operation, we also use recomputation", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 656, + 506, + 669 + ], + "spans": [ + { + "bbox": [ + 106, + 656, + 506, + 669 + ], + "score": 1.0, + "content": "to optimize the memory requirement of the entire selective SSM block (input projection, convolution,", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 667, + 505, + 679 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 505, + 679 + ], + "score": 1.0, + "content": "activation, scan, output projection). In particular, we do not save intermediate activations that take", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 677, + 506, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 691 + ], + "score": 1.0, + "content": "a lot of memory but are fast to recompute (e.g. output of activation function or short convolution).", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "score": 1.0, + "content": "As a result, the selective SSM layer has the same memory requirement as an optimized Transformer", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "implementation with FlashAttention. In particular, each attention layer (FlashAttention) stores around", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "score": 1.0, + "content": "12 bytes of activations per token, an each MLP layer stores around 20 bytes of activations per token,", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 720, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 733 + ], + "score": 1.0, + "content": "for a total of 32 bytes ((assuming mixed-precision training in FP16 or BF16)). Each selective SSM", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 46.5 + } + ], + "page_idx": 17, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 304, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 305, + 39 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 305, + 39 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 763 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 763 + ], + "score": 1.0, + "content": "18", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 495, + 119, + 505, + 130 + ], + "lines": [ + { + "bbox": [ + 496, + 121, + 504, + 129 + ], + "spans": [ + { + "bbox": [ + 496, + 121, + 504, + 129 + ], + "score": 0.994, + "content": "□", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 108, + 82, + 264, + 93 + ], + "lines": [ + { + "bbox": [ + 106, + 80, + 267, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 80, + 267, + 95 + ], + "score": 1.0, + "content": "Thus the final discrete recurrence (2a) is", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0, + "bbox_fs": [ + 106, + 80, + 267, + 95 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 252, + 92, + 358, + 121 + ], + "lines": [ + { + "bbox": [ + 252, + 92, + 358, + 121 + ], + "spans": [ + { + "bbox": [ + 252, + 92, + 358, + 121 + ], + "score": 0.87, + "content": "\\begin{array} { l } { g _ { k } = \\sigma ( \\mathsf { L i n e a r } ( x _ { k } ) ) } \\\\ { h _ { k } = ( 1 - g _ { k } ) h _ { k - 1 } + g _ { k } x _ { k } } \\end{array}", + "type": "interline_equation", + "image_path": "7bdb05ee7e5171720bf82b576796e8053a73c7dfcb369c4f0eb60ba57531675e.jpg" + } + ] + } + ], + "index": 1.5, + "virtual_lines": [ + { + "bbox": [ + 252, + 92, + 358, + 106.5 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 252, + 106.5, + 358, + 121.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 119, + 149, + 130 + ], + "lines": [ + { + "bbox": [ + 105, + 118, + 151, + 131 + ], + "spans": [ + { + "bbox": [ + 105, + 118, + 151, + 131 + ], + "score": 1.0, + "content": "as desired.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3, + "bbox_fs": [ + 105, + 118, + 151, + 131 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 145, + 415, + 158 + ], + "lines": [ + { + "bbox": [ + 106, + 145, + 415, + 159 + ], + "spans": [ + { + "bbox": [ + 106, + 145, + 415, + 159 + ], + "score": 1.0, + "content": "D HARDWARE-AWARE ALGORITHM FOR SELECTIVE SSMS", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "text", + "bbox": [ + 106, + 163, + 505, + 261 + ], + "lines": [ + { + "bbox": [ + 106, + 163, + 506, + 176 + ], + "spans": [ + { + "bbox": [ + 106, + 163, + 506, + 176 + ], + "score": 1.0, + "content": "Without input-dependent selectivity, SSMs can be efficiently implemented as a convolution (Gu", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 174, + 505, + 187 + ], + "spans": [ + { + "bbox": [ + 105, + 174, + 505, + 187 + ], + "score": 1.0, + "content": "et al., 2022a; Dao et al., 2023), which leverages the fast Fourier transform (FFT) as primitive. With", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 185, + 505, + 196 + ], + "spans": [ + { + "bbox": [ + 106, + 185, + 505, + 196 + ], + "score": 1.0, + "content": "selectivity, SSMs are no-longer equivalent to convolution, but we leverage the parallel associative", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 104, + 194, + 506, + 209 + ], + "spans": [ + { + "bbox": [ + 104, + 194, + 306, + 209 + ], + "score": 1.0, + "content": "scan. While SSM scans are theoretically efficient", + "type": "text" + }, + { + "bbox": [ + 306, + 195, + 357, + 207 + ], + "score": 0.86, + "content": "( O ( B L D N )", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 194, + 456, + 209 + ], + "score": 1.0, + "content": "FLOPs, scaling linear in", + "type": "text" + }, + { + "bbox": [ + 456, + 196, + 464, + 205 + ], + "score": 0.69, + "content": "L", + "type": "inline_equation" + }, + { + "bbox": [ + 465, + 194, + 506, + 209 + ], + "score": 1.0, + "content": "), training", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 207, + 506, + 218 + ], + "spans": [ + { + "bbox": [ + 106, + 207, + 506, + 218 + ], + "score": 1.0, + "content": "foundation models with selective SSMs requires them to be efficient on modern hardware (GPUs)", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 217, + 506, + 230 + ], + "spans": [ + { + "bbox": [ + 105, + 217, + 506, + 230 + ], + "score": 1.0, + "content": "as well. We describe how we use kernel fusion and recomputation to make SSM scan fast and", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 228, + 505, + 240 + ], + "spans": [ + { + "bbox": [ + 106, + 228, + 505, + 240 + ], + "score": 1.0, + "content": "memory-efficient. We evaluate the speed of our scan implementation compared to convolution and", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 239, + 506, + 252 + ], + "spans": [ + { + "bbox": [ + 106, + 239, + 291, + 252 + ], + "score": 1.0, + "content": "attention in Section 4.5, showing that it is up to", + "type": "text" + }, + { + "bbox": [ + 291, + 239, + 306, + 249 + ], + "score": 0.87, + "content": "7 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 239, + 506, + 252 + ], + "score": 1.0, + "content": "times faster than attention at sequence length 32K,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 250, + 427, + 261 + ], + "spans": [ + { + "bbox": [ + 106, + 250, + 427, + 261 + ], + "score": 1.0, + "content": "and is as memory-efficient as the best attention implementation (FlashAttention).", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 9, + "bbox_fs": [ + 104, + 163, + 506, + 261 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 270, + 505, + 313 + ], + "lines": [ + { + "bbox": [ + 106, + 270, + 505, + 282 + ], + "spans": [ + { + "bbox": [ + 106, + 270, + 505, + 282 + ], + "score": 1.0, + "content": "Speed. On modern hardware accelerators (GPUs) most operations (except matrix multiply) are", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 280, + 505, + 292 + ], + "spans": [ + { + "bbox": [ + 106, + 280, + 505, + 292 + ], + "score": 1.0, + "content": "bounded by memory-bandwidth (Williams et al., 2009; Ivanov et al., 2021; Dao et al., 2022). This the", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 290, + 505, + 305 + ], + "spans": [ + { + "bbox": [ + 105, + 290, + 505, + 305 + ], + "score": 1.0, + "content": "case with our scan operation, and we use kernel fusion to reduce the amount of memory IOs, leading", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 302, + 355, + 314 + ], + "spans": [ + { + "bbox": [ + 106, + 302, + 355, + 314 + ], + "score": 1.0, + "content": "to significant speedup compared to a standard implementation.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15.5, + "bbox_fs": [ + 105, + 270, + 505, + 314 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 318, + 505, + 384 + ], + "lines": [ + { + "bbox": [ + 105, + 317, + 505, + 331 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 482, + 331 + ], + "score": 1.0, + "content": "The standard way to implement the scan algorithm in Section 3.2 is to prepare the scan input", + "type": "text" + }, + { + "bbox": [ + 482, + 317, + 505, + 330 + ], + "score": 0.66, + "content": "{ \\overline { { A } } } , { \\overline { { B } } }", + "type": "inline_equation" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 328, + 507, + 343 + ], + "spans": [ + { + "bbox": [ + 105, + 328, + 135, + 343 + ], + "score": 1.0, + "content": "of size", + "type": "text" + }, + { + "bbox": [ + 135, + 329, + 183, + 342 + ], + "score": 0.88, + "content": "( B , L , D , \\dot { N } )", + "type": "inline_equation" + }, + { + "bbox": [ + 184, + 328, + 507, + 343 + ], + "score": 1.0, + "content": "in GPU HBM (high-bandwidth memory, commonly referred to as GPU memory),", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 340, + 505, + 353 + ], + "spans": [ + { + "bbox": [ + 105, + 340, + 421, + 353 + ], + "score": 1.0, + "content": "call a parallel associative scan implementation to write the scan output of size", + "type": "text" + }, + { + "bbox": [ + 422, + 340, + 471, + 352 + ], + "score": 0.87, + "content": "( B , L , D , N )", + "type": "inline_equation" + }, + { + "bbox": [ + 471, + 340, + 505, + 353 + ], + "score": 1.0, + "content": "to GPU", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 349, + 506, + 364 + ], + "spans": [ + { + "bbox": [ + 105, + 349, + 277, + 364 + ], + "score": 1.0, + "content": "HBM, then multiply that scan output with", + "type": "text" + }, + { + "bbox": [ + 278, + 352, + 288, + 361 + ], + "score": 0.81, + "content": "C", + "type": "inline_equation" + }, + { + "bbox": [ + 288, + 349, + 403, + 364 + ], + "score": 1.0, + "content": "to produce an output of size", + "type": "text" + }, + { + "bbox": [ + 404, + 351, + 441, + 363 + ], + "score": 0.9, + "content": "( B , \\dot { L } , D )", + "type": "inline_equation" + }, + { + "bbox": [ + 442, + 349, + 506, + 364 + ], + "score": 1.0, + "content": ". However, this", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 361, + 506, + 374 + ], + "spans": [ + { + "bbox": [ + 105, + 361, + 352, + 374 + ], + "score": 1.0, + "content": "requires the number of memory reads/writes on the order of", + "type": "text" + }, + { + "bbox": [ + 352, + 362, + 401, + 374 + ], + "score": 0.92, + "content": "\\bar { O ( } B L D N )", + "type": "inline_equation" + }, + { + "bbox": [ + 401, + 361, + 506, + 374 + ], + "score": 1.0, + "content": ". We can instead fuse the", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 372, + 403, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 372, + 327, + 385 + ], + "score": 1.0, + "content": "discretization step, the scan, and the multiplication with", + "type": "text" + }, + { + "bbox": [ + 327, + 373, + 337, + 383 + ], + "score": 0.83, + "content": "C", + "type": "inline_equation" + }, + { + "bbox": [ + 338, + 372, + 403, + 385 + ], + "score": 1.0, + "content": "into one kernel:", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 20.5, + "bbox_fs": [ + 105, + 317, + 507, + 385 + ] + }, + { + "type": "index", + "bbox": [ + 125, + 392, + 505, + 462 + ], + "lines": [ + { + "bbox": [ + 130, + 392, + 499, + 405 + ], + "spans": [ + { + "bbox": [ + 130, + 392, + 186, + 405 + ], + "score": 1.0, + "content": "1. We read in", + "type": "text" + }, + { + "bbox": [ + 186, + 392, + 252, + 405 + ], + "score": 0.9, + "content": "O ( B L D + D N )", + "type": "inline_equation" + }, + { + "bbox": [ + 252, + 392, + 323, + 405 + ], + "score": 1.0, + "content": "bytes of memory", + "type": "text" + }, + { + "bbox": [ + 323, + 392, + 372, + 404 + ], + "score": 0.63, + "content": "( \\Delta , A , B , C )", + "type": "inline_equation" + }, + { + "bbox": [ + 373, + 392, + 499, + 405 + ], + "score": 1.0, + "content": "from slow HBM to fast SRAM.", + "type": "text" + } + ], + "index": 24, + "is_list_start_line": true + }, + { + "bbox": [ + 129, + 408, + 384, + 421 + ], + "spans": [ + { + "bbox": [ + 129, + 408, + 241, + 421 + ], + "score": 1.0, + "content": "2. We discretize to produce", + "type": "text" + }, + { + "bbox": [ + 241, + 408, + 263, + 420 + ], + "score": 0.47, + "content": "\\overline { { A } } , \\overline { { B } }", + "type": "inline_equation" + }, + { + "bbox": [ + 263, + 408, + 292, + 421 + ], + "score": 1.0, + "content": "of size", + "type": "text" + }, + { + "bbox": [ + 292, + 409, + 340, + 421 + ], + "score": 0.63, + "content": "( B , L , D , N )", + "type": "inline_equation" + }, + { + "bbox": [ + 341, + 408, + 384, + 421 + ], + "score": 1.0, + "content": "in SRAM.", + "type": "text" + } + ], + "index": 25, + "is_list_start_line": true + }, + { + "bbox": [ + 129, + 424, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 129, + 424, + 444, + 437 + ], + "score": 1.0, + "content": "3. We perform a parallel associative scan, yielding intermediate states of size", + "type": "text" + }, + { + "bbox": [ + 444, + 424, + 493, + 436 + ], + "score": 0.74, + "content": "( B , L , D , N )", + "type": "inline_equation" + }, + { + "bbox": [ + 494, + 424, + 505, + 437 + ], + "score": 1.0, + "content": "in", + "type": "text" + } + ], + "index": 26, + "is_list_start_line": true + }, + { + "bbox": [ + 141, + 435, + 176, + 447 + ], + "spans": [ + { + "bbox": [ + 141, + 435, + 176, + 447 + ], + "score": 1.0, + "content": "SRAM.", + "type": "text" + } + ], + "index": 27, + "is_list_start_line": true + }, + { + "bbox": [ + 129, + 450, + 484, + 463 + ], + "spans": [ + { + "bbox": [ + 129, + 450, + 247, + 463 + ], + "score": 1.0, + "content": "4. We multiply and sum with", + "type": "text" + }, + { + "bbox": [ + 248, + 451, + 257, + 460 + ], + "score": 0.82, + "content": "C", + "type": "inline_equation" + }, + { + "bbox": [ + 258, + 450, + 363, + 463 + ], + "score": 1.0, + "content": ", producing outputs of size", + "type": "text" + }, + { + "bbox": [ + 363, + 450, + 399, + 462 + ], + "score": 0.45, + "content": "( \\boldsymbol { B } , \\boldsymbol { L } , \\boldsymbol { D } )", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 450, + 484, + 463 + ], + "score": 1.0, + "content": "and write it to HBM.", + "type": "text" + } + ], + "index": 28, + "is_list_start_line": true + } + ], + "index": 26, + "bbox_fs": [ + 129, + 392, + 505, + 463 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 470, + 504, + 493 + ], + "lines": [ + { + "bbox": [ + 106, + 469, + 505, + 484 + ], + "spans": [ + { + "bbox": [ + 106, + 469, + 262, + 484 + ], + "score": 1.0, + "content": "This way, we reduce IOs by a factor of", + "type": "text" + }, + { + "bbox": [ + 262, + 470, + 288, + 483 + ], + "score": 0.92, + "content": "O ( N )", + "type": "inline_equation" + }, + { + "bbox": [ + 288, + 469, + 505, + 484 + ], + "score": 1.0, + "content": "(the state dimension), which in practice speeds up the", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 480, + 263, + 494 + ], + "spans": [ + { + "bbox": [ + 106, + 480, + 263, + 494 + ], + "score": 1.0, + "content": "operation by 20-40 times (Section 4.5).", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29.5, + "bbox_fs": [ + 106, + 469, + 505, + 494 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 497, + 503, + 530 + ], + "lines": [ + { + "bbox": [ + 106, + 496, + 505, + 510 + ], + "spans": [ + { + "bbox": [ + 106, + 496, + 189, + 510 + ], + "score": 1.0, + "content": "For sequence length", + "type": "text" + }, + { + "bbox": [ + 189, + 497, + 198, + 507 + ], + "score": 0.71, + "content": "L", + "type": "inline_equation" + }, + { + "bbox": [ + 198, + 496, + 505, + 510 + ], + "score": 1.0, + "content": "too long where we cannot fit the sequence in SRAM (which is much smaller", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 507, + 505, + 521 + ], + "spans": [ + { + "bbox": [ + 105, + 507, + 505, + 521 + ], + "score": 1.0, + "content": "than HBM), we split the sequences into chunks and perform the fused scan on each chunk. As long", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 519, + 444, + 530 + ], + "spans": [ + { + "bbox": [ + 105, + 519, + 444, + 530 + ], + "score": 1.0, + "content": "as we have the intermediate scan states, we can continue the scan with the next chunk.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32, + "bbox_fs": [ + 105, + 496, + 505, + 530 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 538, + 504, + 561 + ], + "lines": [ + { + "bbox": [ + 106, + 539, + 504, + 550 + ], + "spans": [ + { + "bbox": [ + 106, + 539, + 504, + 550 + ], + "score": 1.0, + "content": "Memory. We describe how we use the classical technique of recomputation to reduce the total", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 550, + 335, + 561 + ], + "spans": [ + { + "bbox": [ + 106, + 550, + 335, + 561 + ], + "score": 1.0, + "content": "amount of memory required to train selective SSM layers.", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 34.5, + "bbox_fs": [ + 106, + 539, + 504, + 561 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 565, + 505, + 641 + ], + "lines": [ + { + "bbox": [ + 105, + 565, + 505, + 577 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 454, + 577 + ], + "score": 1.0, + "content": "From the way we fuse the forward pass, we do not save the intermediate states of size", + "type": "text" + }, + { + "bbox": [ + 455, + 565, + 505, + 577 + ], + "score": 0.85, + "content": "( B , L , D , N )", + "type": "inline_equation" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 577, + 506, + 589 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 506, + 589 + ], + "score": 1.0, + "content": "to avoid memory blowup. However, these intermediate states are necessary for the backward pass", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 587, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 505, + 599 + ], + "score": 1.0, + "content": "to compute gradients. We instead recompute those intermediate states in the backward pass. Since the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 597, + 505, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 597, + 133, + 609 + ], + "score": 1.0, + "content": "inputs", + "type": "text" + }, + { + "bbox": [ + 133, + 597, + 177, + 608 + ], + "score": 0.87, + "content": "\\bar { \\Delta } , \\bar { A , } \\bar { B , } C", + "type": "inline_equation" + }, + { + "bbox": [ + 178, + 597, + 403, + 609 + ], + "score": 1.0, + "content": "and output gradient read from HBM to SRAM are of size", + "type": "text" + }, + { + "bbox": [ + 404, + 597, + 470, + 609 + ], + "score": 0.89, + "content": "O ( B L N { + } D N )", + "type": "inline_equation" + }, + { + "bbox": [ + 471, + 597, + 505, + 609 + ], + "score": 1.0, + "content": ", and the", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 104, + 608, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 104, + 608, + 226, + 621 + ], + "score": 1.0, + "content": "input gradients are also of size", + "type": "text" + }, + { + "bbox": [ + 226, + 608, + 293, + 620 + ], + "score": 0.93, + "content": "O ( B L N + D N )", + "type": "inline_equation" + }, + { + "bbox": [ + 293, + 608, + 456, + 621 + ], + "score": 1.0, + "content": ", recomputation avoids the cost of reading", + "type": "text" + }, + { + "bbox": [ + 456, + 608, + 505, + 620 + ], + "score": 0.91, + "content": "O ( B L N D )", + "type": "inline_equation" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 619, + 506, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 619, + 506, + 632 + ], + "score": 1.0, + "content": "elements from HBM. This means that recomputation of the SSM states in the backward pass speeds", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 630, + 406, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 630, + 406, + 642 + ], + "score": 1.0, + "content": "up the computation compared to storing them and reading them from HBM.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 39, + "bbox_fs": [ + 104, + 565, + 506, + 642 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 645, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 646, + 505, + 658 + ], + "spans": [ + { + "bbox": [ + 106, + 646, + 505, + 658 + ], + "score": 1.0, + "content": "Beyond optimizing for the memory requirement of just the scan operation, we also use recomputation", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 656, + 506, + 669 + ], + "spans": [ + { + "bbox": [ + 106, + 656, + 506, + 669 + ], + "score": 1.0, + "content": "to optimize the memory requirement of the entire selective SSM block (input projection, convolution,", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 667, + 505, + 679 + ], + "spans": [ + { + "bbox": [ + 105, + 667, + 505, + 679 + ], + "score": 1.0, + "content": "activation, scan, output projection). In particular, we do not save intermediate activations that take", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 677, + 506, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 691 + ], + "score": 1.0, + "content": "a lot of memory but are fast to recompute (e.g. output of activation function or short convolution).", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "score": 1.0, + "content": "As a result, the selective SSM layer has the same memory requirement as an optimized Transformer", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "implementation with FlashAttention. In particular, each attention layer (FlashAttention) stores around", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "score": 1.0, + "content": "12 bytes of activations per token, an each MLP layer stores around 20 bytes of activations per token,", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 720, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 733 + ], + "score": 1.0, + "content": "for a total of 32 bytes ((assuming mixed-precision training in FP16 or BF16)). Each selective SSM", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "stores around 16 bytes of activations per token. Hence two layers of selective SSMs have around the", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 360, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 360, + 106 + ], + "score": 1.0, + "content": "same activation memory as an attention layer and an MLP layer.", + "type": "text", + "cross_page": true + } + ], + "index": 1 + } + ], + "index": 46.5, + "bbox_fs": [ + 105, + 646, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "stores around 16 bytes of activations per token. Hence two layers of selective SSMs have around the", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 360, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 360, + 106 + ], + "score": 1.0, + "content": "same activation memory as an attention layer and an MLP layer.", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "title", + "bbox": [ + 107, + 117, + 232, + 129 + ], + "lines": [ + { + "bbox": [ + 105, + 116, + 232, + 131 + ], + "spans": [ + { + "bbox": [ + 105, + 116, + 232, + 131 + ], + "score": 1.0, + "content": "E FULL EXPERIMENTS", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 2 + }, + { + "type": "title", + "bbox": [ + 107, + 136, + 213, + 147 + ], + "lines": [ + { + "bbox": [ + 105, + 135, + 214, + 148 + ], + "spans": [ + { + "bbox": [ + 105, + 135, + 214, + 148 + ], + "score": 1.0, + "content": "E.1 SYNTHETIC TASKS", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 106, + 151, + 504, + 163 + ], + "lines": [ + { + "bbox": [ + 106, + 151, + 505, + 165 + ], + "spans": [ + { + "bbox": [ + 106, + 151, + 505, + 165 + ], + "score": 1.0, + "content": "Full experiment details for these tasks including task details and training protocol are in Appendix F.1.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "title", + "bbox": [ + 107, + 173, + 232, + 185 + ], + "lines": [ + { + "bbox": [ + 106, + 173, + 232, + 185 + ], + "spans": [ + { + "bbox": [ + 106, + 173, + 232, + 185 + ], + "score": 1.0, + "content": "E.1.1 SELECTIVE COPYING", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 106, + 194, + 505, + 270 + ], + "lines": [ + { + "bbox": [ + 106, + 194, + 505, + 206 + ], + "spans": [ + { + "bbox": [ + 106, + 194, + 505, + 206 + ], + "score": 1.0, + "content": "The Copying task is one of the most well-studied synthetic tasks for sequence modeling, originally", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 204, + 505, + 216 + ], + "spans": [ + { + "bbox": [ + 105, + 204, + 505, + 216 + ], + "score": 1.0, + "content": "designed to test the memorization abilities of recurrent models. As discussed in Section 3.1, LTI SSMs", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 216, + 504, + 227 + ], + "spans": [ + { + "bbox": [ + 106, + 216, + 504, + 227 + ], + "score": 1.0, + "content": "(linear recurrences and global convolutions) can easily solve this task by only keeping track of time", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 227, + 504, + 238 + ], + "spans": [ + { + "bbox": [ + 106, + 227, + 504, + 238 + ], + "score": 1.0, + "content": "instead of reasoning about the data; for example, by constructing a convolution kernel of exactly the", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 104, + 236, + 506, + 249 + ], + "spans": [ + { + "bbox": [ + 104, + 236, + 506, + 249 + ], + "score": 1.0, + "content": "right length (Figure 1). This was explicitly validated in earlier work on global convolutions (Romero", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 247, + 505, + 260 + ], + "spans": [ + { + "bbox": [ + 105, + 247, + 505, + 260 + ], + "score": 1.0, + "content": "et al., 2021). The Selective Copying task prevents this shortcut by randomizing the spacing between", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 258, + 476, + 270 + ], + "spans": [ + { + "bbox": [ + 106, + 258, + 476, + 270 + ], + "score": 1.0, + "content": "tokens. Note that this task has been introduced before as the Denoising task (Jing et al., 2019).", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 9 + }, + { + "type": "text", + "bbox": [ + 107, + 274, + 505, + 329 + ], + "lines": [ + { + "bbox": [ + 106, + 275, + 505, + 286 + ], + "spans": [ + { + "bbox": [ + 106, + 275, + 505, + 286 + ], + "score": 1.0, + "content": "Note that many previous works argue that adding architecture gating (multiplicative interactions) can", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 284, + 505, + 296 + ], + "spans": [ + { + "bbox": [ + 106, + 284, + 505, + 296 + ], + "score": 1.0, + "content": "endow models with “data-dependence” and solve related tasks (Dao et al., 2023; Poli et al., 2023).", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 294, + 506, + 309 + ], + "spans": [ + { + "bbox": [ + 105, + 294, + 506, + 309 + ], + "score": 1.0, + "content": "However, we find this explanation insufficient intuitively because such gating does not interact along", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 306, + 506, + 319 + ], + "spans": [ + { + "bbox": [ + 105, + 306, + 506, + 319 + ], + "score": 1.0, + "content": "the sequence axis, and cannot affect the spacing between tokens. In particular architecture gating is", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 317, + 336, + 329 + ], + "spans": [ + { + "bbox": [ + 105, + 317, + 336, + 329 + ], + "score": 1.0, + "content": "not an instance of a selection mechanism (Appendix A.1).", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 107, + 333, + 505, + 366 + ], + "lines": [ + { + "bbox": [ + 105, + 331, + 506, + 347 + ], + "spans": [ + { + "bbox": [ + 105, + 331, + 506, + 347 + ], + "score": 1.0, + "content": "Table 1 confirms that gated architectures such as H3 and Mamba only partially improve performance,", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 344, + 505, + 356 + ], + "spans": [ + { + "bbox": [ + 106, + 344, + 505, + 356 + ], + "score": 1.0, + "content": "while the selection mechanism (modifying S4 to S6) easily solves this task, particularly when combined", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 355, + 264, + 366 + ], + "spans": [ + { + "bbox": [ + 106, + 355, + 264, + 366 + ], + "score": 1.0, + "content": "with these more powerful architectures.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19 + }, + { + "type": "title", + "bbox": [ + 107, + 376, + 223, + 388 + ], + "lines": [ + { + "bbox": [ + 106, + 376, + 224, + 389 + ], + "spans": [ + { + "bbox": [ + 106, + 376, + 224, + 389 + ], + "score": 1.0, + "content": "E.1.2 INDUCTION HEADS", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 397, + 505, + 451 + ], + "lines": [ + { + "bbox": [ + 105, + 395, + 505, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 395, + 505, + 410 + ], + "score": 1.0, + "content": "Induction heads (Olsson et al., 2022) is a simple task from the mechanistic interpretability lens (Elhage", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 408, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 505, + 420 + ], + "score": 1.0, + "content": "et al., 2021) that is surprisingly predictive of the in-context learning ability of LLMs. It requires models", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 418, + 505, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 418, + 505, + 432 + ], + "score": 1.0, + "content": "to perform associative recall and copy: for example, if the model has seen a bigram such as “Harry", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 429, + 505, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 429, + 505, + 442 + ], + "score": 1.0, + "content": "Potter” in the sequence, then the next time “Harry” appears in the same sequence, the model should", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 439, + 310, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 439, + 310, + 453 + ], + "score": 1.0, + "content": "be able to predict “Potter” by copying from history.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 107, + 462, + 505, + 505 + ], + "lines": [ + { + "bbox": [ + 106, + 461, + 505, + 473 + ], + "spans": [ + { + "bbox": [ + 106, + 461, + 505, + 473 + ], + "score": 1.0, + "content": "Dataset We train a 2-layer model on the induction heads task at sequence length 256, with a vocab", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 472, + 507, + 485 + ], + "spans": [ + { + "bbox": [ + 105, + 472, + 507, + 485 + ], + "score": 1.0, + "content": "size of 16, which is comparable to prior work on this task (Dao et al., 2023) but with longer sequences.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 483, + 506, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 506, + 496 + ], + "score": 1.0, + "content": "We additionally investigate generalization and extrapolation abilities by evaluating on a range of", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 493, + 359, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 197, + 507 + ], + "score": 1.0, + "content": "sequence lengths from", + "type": "text" + }, + { + "bbox": [ + 198, + 494, + 228, + 505 + ], + "score": 0.9, + "content": "2 ^ { \\overline { { 6 } } } = 6 \\overline { { 4 } }", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 493, + 250, + 507 + ], + "score": 1.0, + "content": "up to", + "type": "text" + }, + { + "bbox": [ + 250, + 494, + 310, + 505 + ], + "score": 0.89, + "content": "2 ^ { 2 0 } = 1 0 4 8 5 7 6", + "type": "inline_equation" + }, + { + "bbox": [ + 310, + 493, + 359, + 507 + ], + "score": 1.0, + "content": "at test time.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 28.5 + }, + { + "type": "text", + "bbox": [ + 107, + 516, + 505, + 559 + ], + "lines": [ + { + "bbox": [ + 105, + 515, + 505, + 528 + ], + "spans": [ + { + "bbox": [ + 105, + 515, + 505, + 528 + ], + "score": 1.0, + "content": "Models Following established work on induction heads, we use 2 layer models, which allows", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 527, + 505, + 538 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 505, + 538 + ], + "score": 1.0, + "content": "attention to mechanistically solve the induction heads task (Olsson et al., 2022). We test both", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 538, + 505, + 550 + ], + "spans": [ + { + "bbox": [ + 105, + 538, + 505, + 550 + ], + "score": 1.0, + "content": "multi-head attention (8 heads, with various positional encodings) and SSM variants. We use a model", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 549, + 346, + 559 + ], + "spans": [ + { + "bbox": [ + 106, + 549, + 150, + 559 + ], + "score": 1.0, + "content": "dimension", + "type": "text" + }, + { + "bbox": [ + 150, + 549, + 160, + 558 + ], + "score": 0.78, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 160, + 549, + 346, + 559 + ], + "score": 1.0, + "content": "of 64 for Mamba and 128 for the other models.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 107, + 570, + 505, + 614 + ], + "lines": [ + { + "bbox": [ + 105, + 569, + 505, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 569, + 505, + 583 + ], + "score": 1.0, + "content": "Results Figure 3 shows that Mamba—or more precisely, its selective SSM layer—has the ability to", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 580, + 506, + 594 + ], + "spans": [ + { + "bbox": [ + 105, + 580, + 506, + 594 + ], + "score": 1.0, + "content": "solve the task perfectly because of its ability to selectively remember the relevant token while ignoring", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 592, + 506, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 592, + 446, + 605 + ], + "score": 1.0, + "content": "everything else in between. It generalizes perfectly to million-length sequences, or", + "type": "text" + }, + { + "bbox": [ + 446, + 592, + 475, + 603 + ], + "score": 0.87, + "content": "4 0 0 0 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 476, + 592, + 506, + 605 + ], + "score": 1.0, + "content": "longer", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 603, + 374, + 615 + ], + "spans": [ + { + "bbox": [ + 106, + 603, + 356, + 615 + ], + "score": 1.0, + "content": "than it saw during training, while no other method goes beyond", + "type": "text" + }, + { + "bbox": [ + 356, + 603, + 370, + 613 + ], + "score": 0.86, + "content": "2 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 370, + 603, + 374, + 615 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 36.5 + }, + { + "type": "text", + "bbox": [ + 107, + 618, + 505, + 662 + ], + "lines": [ + { + "bbox": [ + 106, + 619, + 505, + 630 + ], + "spans": [ + { + "bbox": [ + 106, + 619, + 505, + 630 + ], + "score": 1.0, + "content": "Out of positional encoding variants for attention models, xPos (which was designed for length", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 630, + 505, + 641 + ], + "spans": [ + { + "bbox": [ + 105, + 630, + 505, + 641 + ], + "score": 1.0, + "content": "extrapolation) is slightly better than the others; also note that all attention models were only tested", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 104, + 638, + 506, + 653 + ], + "spans": [ + { + "bbox": [ + 104, + 638, + 197, + 653 + ], + "score": 1.0, + "content": "up to sequence length", + "type": "text" + }, + { + "bbox": [ + 197, + 639, + 248, + 650 + ], + "score": 0.9, + "content": "\\dot { 2 } ^ { 1 4 } = 1 6 3 8 4", + "type": "inline_equation" + }, + { + "bbox": [ + 249, + 638, + 506, + 653 + ], + "score": 1.0, + "content": "due to memory limitations. Out of other SSMs, H3 and Hyena", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 650, + 325, + 663 + ], + "spans": [ + { + "bbox": [ + 105, + 650, + 325, + 663 + ], + "score": 1.0, + "content": "are similar, contrary to the findings in Poli et al. (2023).", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 40.5 + }, + { + "type": "title", + "bbox": [ + 107, + 672, + 206, + 684 + ], + "lines": [ + { + "bbox": [ + 105, + 671, + 207, + 685 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 207, + 685 + ], + "score": 1.0, + "content": "E.2 DNA MODELING", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 43 + }, + { + "type": "text", + "bbox": [ + 108, + 689, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 688, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 506, + 702 + ], + "score": 1.0, + "content": "For pretraining, we largely follow a standard causal language modeling (next token prediction) setup", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "score": 1.0, + "content": "for the training and model details (see also Appendix F.2). For the dataset, we largely follow the", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 708, + 506, + 724 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 506, + 724 + ], + "score": 1.0, + "content": "setup of HyenaDNA (Nguyen et al., 2023), which uses the HG38 dataset for pretraining consisting", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 721, + 475, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 475, + 733 + ], + "score": 1.0, + "content": "of a single human genome with about 4.5 billion tokens (DNA base pairs) in the training split.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 45.5 + } + ], + "page_idx": 18, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 304, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 305, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 305, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 299, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 504, + 105 + ], + "lines": [], + "index": 0.5, + "bbox_fs": [ + 105, + 82, + 505, + 106 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 107, + 117, + 232, + 129 + ], + "lines": [ + { + "bbox": [ + 105, + 116, + 232, + 131 + ], + "spans": [ + { + "bbox": [ + 105, + 116, + 232, + 131 + ], + "score": 1.0, + "content": "E FULL EXPERIMENTS", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 2 + }, + { + "type": "title", + "bbox": [ + 107, + 136, + 213, + 147 + ], + "lines": [ + { + "bbox": [ + 105, + 135, + 214, + 148 + ], + "spans": [ + { + "bbox": [ + 105, + 135, + 214, + 148 + ], + "score": 1.0, + "content": "E.1 SYNTHETIC TASKS", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 106, + 151, + 504, + 163 + ], + "lines": [ + { + "bbox": [ + 106, + 151, + 505, + 165 + ], + "spans": [ + { + "bbox": [ + 106, + 151, + 505, + 165 + ], + "score": 1.0, + "content": "Full experiment details for these tasks including task details and training protocol are in Appendix F.1.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4, + "bbox_fs": [ + 106, + 151, + 505, + 165 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 173, + 232, + 185 + ], + "lines": [ + { + "bbox": [ + 106, + 173, + 232, + 185 + ], + "spans": [ + { + "bbox": [ + 106, + 173, + 232, + 185 + ], + "score": 1.0, + "content": "E.1.1 SELECTIVE COPYING", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 106, + 194, + 505, + 270 + ], + "lines": [ + { + "bbox": [ + 106, + 194, + 505, + 206 + ], + "spans": [ + { + "bbox": [ + 106, + 194, + 505, + 206 + ], + "score": 1.0, + "content": "The Copying task is one of the most well-studied synthetic tasks for sequence modeling, originally", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 204, + 505, + 216 + ], + "spans": [ + { + "bbox": [ + 105, + 204, + 505, + 216 + ], + "score": 1.0, + "content": "designed to test the memorization abilities of recurrent models. As discussed in Section 3.1, LTI SSMs", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 216, + 504, + 227 + ], + "spans": [ + { + "bbox": [ + 106, + 216, + 504, + 227 + ], + "score": 1.0, + "content": "(linear recurrences and global convolutions) can easily solve this task by only keeping track of time", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 227, + 504, + 238 + ], + "spans": [ + { + "bbox": [ + 106, + 227, + 504, + 238 + ], + "score": 1.0, + "content": "instead of reasoning about the data; for example, by constructing a convolution kernel of exactly the", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 104, + 236, + 506, + 249 + ], + "spans": [ + { + "bbox": [ + 104, + 236, + 506, + 249 + ], + "score": 1.0, + "content": "right length (Figure 1). This was explicitly validated in earlier work on global convolutions (Romero", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 247, + 505, + 260 + ], + "spans": [ + { + "bbox": [ + 105, + 247, + 505, + 260 + ], + "score": 1.0, + "content": "et al., 2021). The Selective Copying task prevents this shortcut by randomizing the spacing between", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 258, + 476, + 270 + ], + "spans": [ + { + "bbox": [ + 106, + 258, + 476, + 270 + ], + "score": 1.0, + "content": "tokens. Note that this task has been introduced before as the Denoising task (Jing et al., 2019).", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 9, + "bbox_fs": [ + 104, + 194, + 506, + 270 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 274, + 505, + 329 + ], + "lines": [ + { + "bbox": [ + 106, + 275, + 505, + 286 + ], + "spans": [ + { + "bbox": [ + 106, + 275, + 505, + 286 + ], + "score": 1.0, + "content": "Note that many previous works argue that adding architecture gating (multiplicative interactions) can", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 284, + 505, + 296 + ], + "spans": [ + { + "bbox": [ + 106, + 284, + 505, + 296 + ], + "score": 1.0, + "content": "endow models with “data-dependence” and solve related tasks (Dao et al., 2023; Poli et al., 2023).", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 294, + 506, + 309 + ], + "spans": [ + { + "bbox": [ + 105, + 294, + 506, + 309 + ], + "score": 1.0, + "content": "However, we find this explanation insufficient intuitively because such gating does not interact along", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 306, + 506, + 319 + ], + "spans": [ + { + "bbox": [ + 105, + 306, + 506, + 319 + ], + "score": 1.0, + "content": "the sequence axis, and cannot affect the spacing between tokens. In particular architecture gating is", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 317, + 336, + 329 + ], + "spans": [ + { + "bbox": [ + 105, + 317, + 336, + 329 + ], + "score": 1.0, + "content": "not an instance of a selection mechanism (Appendix A.1).", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15, + "bbox_fs": [ + 105, + 275, + 506, + 329 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 333, + 505, + 366 + ], + "lines": [ + { + "bbox": [ + 105, + 331, + 506, + 347 + ], + "spans": [ + { + "bbox": [ + 105, + 331, + 506, + 347 + ], + "score": 1.0, + "content": "Table 1 confirms that gated architectures such as H3 and Mamba only partially improve performance,", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 344, + 505, + 356 + ], + "spans": [ + { + "bbox": [ + 106, + 344, + 505, + 356 + ], + "score": 1.0, + "content": "while the selection mechanism (modifying S4 to S6) easily solves this task, particularly when combined", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 355, + 264, + 366 + ], + "spans": [ + { + "bbox": [ + 106, + 355, + 264, + 366 + ], + "score": 1.0, + "content": "with these more powerful architectures.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 19, + "bbox_fs": [ + 105, + 331, + 506, + 366 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 376, + 223, + 388 + ], + "lines": [ + { + "bbox": [ + 106, + 376, + 224, + 389 + ], + "spans": [ + { + "bbox": [ + 106, + 376, + 224, + 389 + ], + "score": 1.0, + "content": "E.1.2 INDUCTION HEADS", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 397, + 505, + 451 + ], + "lines": [ + { + "bbox": [ + 105, + 395, + 505, + 410 + ], + "spans": [ + { + "bbox": [ + 105, + 395, + 505, + 410 + ], + "score": 1.0, + "content": "Induction heads (Olsson et al., 2022) is a simple task from the mechanistic interpretability lens (Elhage", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 408, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 105, + 408, + 505, + 420 + ], + "score": 1.0, + "content": "et al., 2021) that is surprisingly predictive of the in-context learning ability of LLMs. It requires models", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 418, + 505, + 432 + ], + "spans": [ + { + "bbox": [ + 105, + 418, + 505, + 432 + ], + "score": 1.0, + "content": "to perform associative recall and copy: for example, if the model has seen a bigram such as “Harry", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 429, + 505, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 429, + 505, + 442 + ], + "score": 1.0, + "content": "Potter” in the sequence, then the next time “Harry” appears in the same sequence, the model should", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 439, + 310, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 439, + 310, + 453 + ], + "score": 1.0, + "content": "be able to predict “Potter” by copying from history.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 24, + "bbox_fs": [ + 105, + 395, + 505, + 453 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 462, + 505, + 505 + ], + "lines": [ + { + "bbox": [ + 106, + 461, + 505, + 473 + ], + "spans": [ + { + "bbox": [ + 106, + 461, + 505, + 473 + ], + "score": 1.0, + "content": "Dataset We train a 2-layer model on the induction heads task at sequence length 256, with a vocab", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 472, + 507, + 485 + ], + "spans": [ + { + "bbox": [ + 105, + 472, + 507, + 485 + ], + "score": 1.0, + "content": "size of 16, which is comparable to prior work on this task (Dao et al., 2023) but with longer sequences.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 483, + 506, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 506, + 496 + ], + "score": 1.0, + "content": "We additionally investigate generalization and extrapolation abilities by evaluating on a range of", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 493, + 359, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 493, + 197, + 507 + ], + "score": 1.0, + "content": "sequence lengths from", + "type": "text" + }, + { + "bbox": [ + 198, + 494, + 228, + 505 + ], + "score": 0.9, + "content": "2 ^ { \\overline { { 6 } } } = 6 \\overline { { 4 } }", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 493, + 250, + 507 + ], + "score": 1.0, + "content": "up to", + "type": "text" + }, + { + "bbox": [ + 250, + 494, + 310, + 505 + ], + "score": 0.89, + "content": "2 ^ { 2 0 } = 1 0 4 8 5 7 6", + "type": "inline_equation" + }, + { + "bbox": [ + 310, + 493, + 359, + 507 + ], + "score": 1.0, + "content": "at test time.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 28.5, + "bbox_fs": [ + 105, + 461, + 507, + 507 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 516, + 505, + 559 + ], + "lines": [ + { + "bbox": [ + 105, + 515, + 505, + 528 + ], + "spans": [ + { + "bbox": [ + 105, + 515, + 505, + 528 + ], + "score": 1.0, + "content": "Models Following established work on induction heads, we use 2 layer models, which allows", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 527, + 505, + 538 + ], + "spans": [ + { + "bbox": [ + 105, + 527, + 505, + 538 + ], + "score": 1.0, + "content": "attention to mechanistically solve the induction heads task (Olsson et al., 2022). We test both", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 538, + 505, + 550 + ], + "spans": [ + { + "bbox": [ + 105, + 538, + 505, + 550 + ], + "score": 1.0, + "content": "multi-head attention (8 heads, with various positional encodings) and SSM variants. We use a model", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 549, + 346, + 559 + ], + "spans": [ + { + "bbox": [ + 106, + 549, + 150, + 559 + ], + "score": 1.0, + "content": "dimension", + "type": "text" + }, + { + "bbox": [ + 150, + 549, + 160, + 558 + ], + "score": 0.78, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 160, + 549, + 346, + 559 + ], + "score": 1.0, + "content": "of 64 for Mamba and 128 for the other models.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32.5, + "bbox_fs": [ + 105, + 515, + 505, + 559 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 570, + 505, + 614 + ], + "lines": [ + { + "bbox": [ + 105, + 569, + 505, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 569, + 505, + 583 + ], + "score": 1.0, + "content": "Results Figure 3 shows that Mamba—or more precisely, its selective SSM layer—has the ability to", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 580, + 506, + 594 + ], + "spans": [ + { + "bbox": [ + 105, + 580, + 506, + 594 + ], + "score": 1.0, + "content": "solve the task perfectly because of its ability to selectively remember the relevant token while ignoring", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 592, + 506, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 592, + 446, + 605 + ], + "score": 1.0, + "content": "everything else in between. It generalizes perfectly to million-length sequences, or", + "type": "text" + }, + { + "bbox": [ + 446, + 592, + 475, + 603 + ], + "score": 0.87, + "content": "4 0 0 0 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 476, + 592, + 506, + 605 + ], + "score": 1.0, + "content": "longer", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 603, + 374, + 615 + ], + "spans": [ + { + "bbox": [ + 106, + 603, + 356, + 615 + ], + "score": 1.0, + "content": "than it saw during training, while no other method goes beyond", + "type": "text" + }, + { + "bbox": [ + 356, + 603, + 370, + 613 + ], + "score": 0.86, + "content": "2 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 370, + 603, + 374, + 615 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 36.5, + "bbox_fs": [ + 105, + 569, + 506, + 615 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 618, + 505, + 662 + ], + "lines": [ + { + "bbox": [ + 106, + 619, + 505, + 630 + ], + "spans": [ + { + "bbox": [ + 106, + 619, + 505, + 630 + ], + "score": 1.0, + "content": "Out of positional encoding variants for attention models, xPos (which was designed for length", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 630, + 505, + 641 + ], + "spans": [ + { + "bbox": [ + 105, + 630, + 505, + 641 + ], + "score": 1.0, + "content": "extrapolation) is slightly better than the others; also note that all attention models were only tested", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 104, + 638, + 506, + 653 + ], + "spans": [ + { + "bbox": [ + 104, + 638, + 197, + 653 + ], + "score": 1.0, + "content": "up to sequence length", + "type": "text" + }, + { + "bbox": [ + 197, + 639, + 248, + 650 + ], + "score": 0.9, + "content": "\\dot { 2 } ^ { 1 4 } = 1 6 3 8 4", + "type": "inline_equation" + }, + { + "bbox": [ + 249, + 638, + 506, + 653 + ], + "score": 1.0, + "content": "due to memory limitations. Out of other SSMs, H3 and Hyena", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 650, + 325, + 663 + ], + "spans": [ + { + "bbox": [ + 105, + 650, + 325, + 663 + ], + "score": 1.0, + "content": "are similar, contrary to the findings in Poli et al. (2023).", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 40.5, + "bbox_fs": [ + 104, + 619, + 506, + 663 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 672, + 206, + 684 + ], + "lines": [ + { + "bbox": [ + 105, + 671, + 207, + 685 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 207, + 685 + ], + "score": 1.0, + "content": "E.2 DNA MODELING", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 43 + }, + { + "type": "text", + "bbox": [ + 108, + 689, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 688, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 506, + 702 + ], + "score": 1.0, + "content": "For pretraining, we largely follow a standard causal language modeling (next token prediction) setup", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 505, + 712 + ], + "score": 1.0, + "content": "for the training and model details (see also Appendix F.2). For the dataset, we largely follow the", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 708, + 506, + 724 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 506, + 724 + ], + "score": 1.0, + "content": "setup of HyenaDNA (Nguyen et al., 2023), which uses the HG38 dataset for pretraining consisting", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 721, + 475, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 475, + 733 + ], + "score": 1.0, + "content": "of a single human genome with about 4.5 billion tokens (DNA base pairs) in the training split.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 45.5, + "bbox_fs": [ + 105, + 688, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 103, + 504, + 125 + ], + "lines": [ + { + "bbox": [ + 105, + 102, + 505, + 115 + ], + "spans": [ + { + "bbox": [ + 105, + 102, + 505, + 115 + ], + "score": 1.0, + "content": "In this experiment, we investigate the scaling properties of genomics foundation models with various", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 114, + 240, + 126 + ], + "spans": [ + { + "bbox": [ + 106, + 114, + 240, + 126 + ], + "score": 1.0, + "content": "model backbones (Figure 5 Left).", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 107, + 129, + 505, + 172 + ], + "lines": [ + { + "bbox": [ + 105, + 128, + 505, + 142 + ], + "spans": [ + { + "bbox": [ + 105, + 128, + 505, + 142 + ], + "score": 1.0, + "content": "Training To advantage the baselines, we train on a short sequence length of 1024; as shown in", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 139, + 506, + 153 + ], + "spans": [ + { + "bbox": [ + 105, + 139, + 506, + 153 + ], + "score": 1.0, + "content": "Appendix E.2.2, we expect results to favor Mamba even more at longer sequence lengths. We fix", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 149, + 504, + 164 + ], + "spans": [ + { + "bbox": [ + 105, + 149, + 270, + 164 + ], + "score": 1.0, + "content": "a global batch size of 1024, for a total of", + "type": "text" + }, + { + "bbox": [ + 271, + 150, + 312, + 161 + ], + "score": 0.92, + "content": "2 ^ { 2 0 } \\approx 1 M", + "type": "inline_equation" + }, + { + "bbox": [ + 312, + 149, + 483, + 164 + ], + "score": 1.0, + "content": "tokens per batch. Models were trained for", + "type": "text" + }, + { + "bbox": [ + 484, + 151, + 504, + 161 + ], + "score": 0.78, + "content": "1 0 K", + "type": "inline_equation" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 161, + 264, + 174 + ], + "spans": [ + { + "bbox": [ + 105, + 161, + 213, + 174 + ], + "score": 1.0, + "content": "gradient steps for a total of", + "type": "text" + }, + { + "bbox": [ + 213, + 162, + 232, + 172 + ], + "score": 0.82, + "content": "1 0 B", + "type": "inline_equation" + }, + { + "bbox": [ + 233, + 161, + 264, + 174 + ], + "score": 1.0, + "content": "tokens.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 107, + 177, + 505, + 221 + ], + "lines": [ + { + "bbox": [ + 105, + 177, + 505, + 190 + ], + "spans": [ + { + "bbox": [ + 105, + 177, + 505, + 190 + ], + "score": 1.0, + "content": "Results Figure 5 (Left) shows that Mamba’s pretraining perplexity improves smoothly with model", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 188, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 407, + 200 + ], + "score": 1.0, + "content": "size, and that Mamba scales better than both HyenaDNA and Transformer", + "type": "text" + }, + { + "bbox": [ + 407, + 190, + 419, + 198 + ], + "score": 0.56, + "content": "^ { + + }", + "type": "inline_equation" + }, + { + "bbox": [ + 420, + 188, + 505, + 200 + ], + "score": 1.0, + "content": ". For example, at the", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 199, + 507, + 211 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 190, + 211 + ], + "score": 1.0, + "content": "largest model size of", + "type": "text" + }, + { + "bbox": [ + 190, + 199, + 221, + 209 + ], + "score": 0.89, + "content": "{ \\approx } 4 0 M", + "type": "inline_equation" + }, + { + "bbox": [ + 222, + 199, + 507, + 211 + ], + "score": 1.0, + "content": "parameters, the curve shows that Mamba can match the Transformer++", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 210, + 367, + 222 + ], + "spans": [ + { + "bbox": [ + 106, + 210, + 255, + 222 + ], + "score": 1.0, + "content": "and HyenaDNA models with roughly", + "type": "text" + }, + { + "bbox": [ + 255, + 210, + 270, + 220 + ], + "score": 0.87, + "content": "3 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 210, + 280, + 222 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 280, + 210, + 294, + 220 + ], + "score": 0.87, + "content": "4 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 294, + 210, + 367, + 222 + ], + "score": 1.0, + "content": "fewer parameters.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 7.5 + }, + { + "type": "title", + "bbox": [ + 108, + 230, + 266, + 241 + ], + "lines": [ + { + "bbox": [ + 105, + 228, + 268, + 243 + ], + "spans": [ + { + "bbox": [ + 105, + 228, + 268, + 243 + ], + "score": 1.0, + "content": "E.2.2 SCALING: CONTEXT LENGTH", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 107, + 250, + 505, + 326 + ], + "lines": [ + { + "bbox": [ + 105, + 249, + 506, + 264 + ], + "spans": [ + { + "bbox": [ + 105, + 249, + 506, + 264 + ], + "score": 1.0, + "content": "In the next DNA experiment, we investigate the scaling properties of models with respect to sequence", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 262, + 505, + 274 + ], + "spans": [ + { + "bbox": [ + 105, + 262, + 505, + 274 + ], + "score": 1.0, + "content": "length. We only compare the HyenaDNA and Mamba models, as quadratic attention becomes", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 272, + 505, + 284 + ], + "spans": [ + { + "bbox": [ + 105, + 272, + 505, + 284 + ], + "score": 1.0, + "content": "prohibitively expensive at longer sequence lengths. We pretrain models on sequence lengths", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 280, + 506, + 295 + ], + "spans": [ + { + "bbox": [ + 106, + 282, + 152, + 293 + ], + "score": 0.88, + "content": "\\dot { 2 } ^ { 1 0 } = 1 0 2 4", + "type": "inline_equation" + }, + { + "bbox": [ + 153, + 280, + 156, + 295 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 156, + 282, + 202, + 294 + ], + "score": 0.86, + "content": "2 ^ { 1 2 } = 4 0 9 6", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 280, + 206, + 295 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 206, + 282, + 257, + 293 + ], + "score": 0.86, + "content": "2 ^ { 1 4 } = \\bar { 1 } 6 3 8 4", + "type": "inline_equation" + }, + { + "bbox": [ + 257, + 280, + 261, + 295 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 261, + 282, + 312, + 293 + ], + "score": 0.87, + "content": "2 ^ { 1 6 } = 6 5 5 \\bar { 3 6 }", + "type": "inline_equation" + }, + { + "bbox": [ + 312, + 280, + 315, + 295 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 316, + 282, + 371, + 293 + ], + "score": 0.84, + "content": "2 ^ { 1 8 } = 2 \\dot { 6 } 2 1 4 4", + "type": "inline_equation" + }, + { + "bbox": [ + 372, + 280, + 375, + 295 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 376, + 282, + 436, + 293 + ], + "score": 0.88, + "content": "2 ^ { 2 0 } = 1 0 4 8 5 7 6", + "type": "inline_equation" + }, + { + "bbox": [ + 437, + 280, + 506, + 295 + ], + "score": 1.0, + "content": ". We fix a model", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 293, + 505, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 293, + 448, + 306 + ], + "score": 1.0, + "content": "size of 6 layers by width 128 (about 1.3M-1.4M parameters). Models were trained for", + "type": "text" + }, + { + "bbox": [ + 448, + 294, + 469, + 304 + ], + "score": 0.83, + "content": "2 0 K", + "type": "inline_equation" + }, + { + "bbox": [ + 469, + 293, + 505, + 306 + ], + "score": 1.0, + "content": "gradient", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 303, + 506, + 317 + ], + "spans": [ + { + "bbox": [ + 105, + 303, + 178, + 317 + ], + "score": 1.0, + "content": "steps for a total of", + "type": "text" + }, + { + "bbox": [ + 178, + 304, + 211, + 315 + ], + "score": 0.91, + "content": "{ \\approx } 3 3 0 B", + "type": "inline_equation" + }, + { + "bbox": [ + 211, + 303, + 506, + 317 + ], + "score": 1.0, + "content": "tokens. The longer sequence lengths used sequence length warmup similar", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 315, + 204, + 327 + ], + "spans": [ + { + "bbox": [ + 105, + 315, + 204, + 327 + ], + "score": 1.0, + "content": "to (Nguyen et al., 2023).", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 107, + 331, + 505, + 407 + ], + "lines": [ + { + "bbox": [ + 106, + 330, + 505, + 343 + ], + "spans": [ + { + "bbox": [ + 106, + 330, + 505, + 343 + ], + "score": 1.0, + "content": "Results Figure 5 (Right) shows that Mamba is able to make use of longer context even up to extremely", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 341, + 506, + 355 + ], + "spans": [ + { + "bbox": [ + 105, + 341, + 506, + 355 + ], + "score": 1.0, + "content": "long sequences of length 1M, and its pretraining perplexity improves as the context increases. On the", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 353, + 505, + 365 + ], + "spans": [ + { + "bbox": [ + 105, + 353, + 505, + 365 + ], + "score": 1.0, + "content": "other hand, the HyenaDNA model gets worse with sequence length. This is intuitive from the discussion", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 362, + 505, + 375 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 505, + 375 + ], + "score": 1.0, + "content": "in Section 3.5 that motivated the selection mechanism. In particular, LTI models cannot selectively", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 373, + 505, + 387 + ], + "spans": [ + { + "bbox": [ + 105, + 373, + 505, + 387 + ], + "score": 1.0, + "content": "ignore information; from a convolutional perspective, a very long convolution kernel is aggregating", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 384, + 506, + 398 + ], + "spans": [ + { + "bbox": [ + 105, + 384, + 506, + 398 + ], + "score": 1.0, + "content": "all information across a long sequence which may be very noisy. Note that while Nguyen et al. (2023)", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 396, + 492, + 408 + ], + "spans": [ + { + "bbox": [ + 105, + 396, + 492, + 408 + ], + "score": 1.0, + "content": "claims that Hyena improves with longer context, their results do not control for computation time.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 21 + }, + { + "type": "title", + "bbox": [ + 108, + 416, + 302, + 427 + ], + "lines": [ + { + "bbox": [ + 105, + 415, + 304, + 429 + ], + "spans": [ + { + "bbox": [ + 105, + 415, + 304, + 429 + ], + "score": 1.0, + "content": "E.2.3 SYNTHETIC SPECIES CLASSIFICATION", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 107, + 437, + 505, + 480 + ], + "lines": [ + { + "bbox": [ + 106, + 437, + 505, + 448 + ], + "spans": [ + { + "bbox": [ + 106, + 437, + 505, + 448 + ], + "score": 1.0, + "content": "We evaluate models on a downstream task of classifying between 5 different species by randomly", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 447, + 505, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 447, + 505, + 459 + ], + "score": 1.0, + "content": "sampling a contiguous segment of their DNA. This task is adapted from HyenaDNA, which used the", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 104, + 457, + 506, + 472 + ], + "spans": [ + { + "bbox": [ + 104, + 457, + 137, + 472 + ], + "score": 1.0, + "content": "species", + "type": "text" + }, + { + "bbox": [ + 137, + 458, + 143, + 470 + ], + "score": 0.55, + "content": "\\{", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 457, + 275, + 472 + ], + "score": 1.0, + "content": "human, lemur, mouse, pig, hippo", + "type": "text" + }, + { + "bbox": [ + 275, + 458, + 281, + 470 + ], + "score": 0.51, + "content": "\\}", + "type": "inline_equation" + }, + { + "bbox": [ + 281, + 457, + 506, + 472 + ], + "score": 1.0, + "content": ". We modify the task to be significantly more challenging", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 469, + 503, + 482 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 299, + 482 + ], + "score": 1.0, + "content": "by classifying between the five great apes species", + "type": "text" + }, + { + "bbox": [ + 299, + 469, + 306, + 481 + ], + "score": 0.26, + "content": "\\{", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 469, + 492, + 482 + ], + "score": 1.0, + "content": "human, chimpanzee, gorilla, orangutan, bonobo", + "type": "text" + }, + { + "bbox": [ + 493, + 469, + 498, + 481 + ], + "score": 0.41, + "content": "\\}", + "type": "inline_equation" + }, + { + "bbox": [ + 499, + 469, + 503, + 482 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 27.5 + }, + { + "type": "title", + "bbox": [ + 107, + 489, + 217, + 501 + ], + "lines": [ + { + "bbox": [ + 105, + 488, + 219, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 488, + 219, + 502 + ], + "score": 1.0, + "content": "E.3 MODEL ABLATIONS", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 30 + }, + { + "type": "text", + "bbox": [ + 105, + 505, + 504, + 517 + ], + "lines": [ + { + "bbox": [ + 106, + 505, + 506, + 519 + ], + "spans": [ + { + "bbox": [ + 106, + 505, + 506, + 519 + ], + "score": 1.0, + "content": "Table 5 investigates the effects of the architecture (block) and its inner SSM layer (Figure 2). We find that", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 106, + 525, + 505, + 631 + ], + "lines": [ + { + "bbox": [ + 104, + 525, + 505, + 540 + ], + "spans": [ + { + "bbox": [ + 104, + 525, + 505, + 540 + ], + "score": 1.0, + "content": "• Among previous non-selective (LTI) SSMs, which are equivalent to global convolutions, performance", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 112, + 536, + 175, + 550 + ], + "spans": [ + { + "bbox": [ + 112, + 536, + 175, + 550 + ], + "score": 1.0, + "content": "is very similar.", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 104, + 549, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 104, + 549, + 505, + 563 + ], + "score": 1.0, + "content": "• Replacing the complex-valued S4 variant from previous work with a real-valued one does not affect", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 113, + 561, + 505, + 573 + ], + "spans": [ + { + "bbox": [ + 113, + 561, + 505, + 573 + ], + "score": 1.0, + "content": "performance much, suggesting that (at least for LM) real-valued SSMs may be a better choice when", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 113, + 572, + 256, + 585 + ], + "spans": [ + { + "bbox": [ + 113, + 572, + 256, + 585 + ], + "score": 1.0, + "content": "accounting for hardware efficiency.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 584, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 584, + 505, + 599 + ], + "score": 1.0, + "content": "• Replacing any of these with a selective SSM (S6) significantly improves performance, validating", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 113, + 596, + 226, + 608 + ], + "spans": [ + { + "bbox": [ + 113, + 596, + 226, + 608 + ], + "score": 1.0, + "content": "the motivation of Section 3.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 104, + 607, + 505, + 623 + ], + "spans": [ + { + "bbox": [ + 104, + 607, + 505, + 623 + ], + "score": 1.0, + "content": "• The Mamba architecture performs similarly to the H3 architecture (and seems slightly better when", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 114, + 620, + 209, + 632 + ], + "spans": [ + { + "bbox": [ + 114, + 620, + 209, + 632 + ], + "score": 1.0, + "content": "using a selective layer).", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 36 + }, + { + "type": "text", + "bbox": [ + 107, + 640, + 505, + 673 + ], + "lines": [ + { + "bbox": [ + 105, + 640, + 506, + 653 + ], + "spans": [ + { + "bbox": [ + 105, + 640, + 461, + 653 + ], + "score": 1.0, + "content": "Table 6 ablates the selective SSM layer by considering different combinations of selective", + "type": "text" + }, + { + "bbox": [ + 462, + 641, + 485, + 651 + ], + "score": 0.63, + "content": "\\Delta , B", + "type": "inline_equation" + }, + { + "bbox": [ + 485, + 640, + 506, + 653 + ], + "score": 1.0, + "content": ", and", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 107, + 651, + 505, + 663 + ], + "spans": [ + { + "bbox": [ + 107, + 652, + 117, + 662 + ], + "score": 0.77, + "content": "C", + "type": "inline_equation" + }, + { + "bbox": [ + 117, + 651, + 279, + 663 + ], + "score": 1.0, + "content": "parameters (Algorithm 2), showing that", + "type": "text" + }, + { + "bbox": [ + 279, + 652, + 289, + 661 + ], + "score": 0.81, + "content": "\\Delta", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 651, + 505, + 663 + ], + "score": 1.0, + "content": "is the most important parameter due to its connection", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 662, + 221, + 674 + ], + "spans": [ + { + "bbox": [ + 106, + 662, + 221, + 674 + ], + "score": 1.0, + "content": "to RNN gating (Theorem 1).", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42 + }, + { + "type": "text", + "bbox": [ + 107, + 677, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 677, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 690 + ], + "score": 1.0, + "content": "Table 7 considers different initializations of the SSM, which have been shown to make a large", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "score": 1.0, + "content": "difference in some data modalities and settings (Gu et al., 2022a;b). On language modeling, we", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "find that simpler real-valued diagonal initializations (S4D-Real, row 3) instead of more standard", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 710, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 506, + 722 + ], + "score": 1.0, + "content": "complex-valued parameterizations (S4D-Lin, row 1) perform better. Random initializations also work", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 720, + 369, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 369, + 732 + ], + "score": 1.0, + "content": "well, consistent with findings from prior work (Mehta et al., 2023).", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 46 + } + ], + "page_idx": 19, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 304, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 305, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 305, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 298, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 298, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 15 + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 82, + 241, + 93 + ], + "lines": [ + { + "bbox": [ + 105, + 81, + 243, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 81, + 243, + 95 + ], + "score": 1.0, + "content": "E.2.1 SCALING: MODEL SIZE", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 103, + 504, + 125 + ], + "lines": [ + { + "bbox": [ + 105, + 102, + 505, + 115 + ], + "spans": [ + { + "bbox": [ + 105, + 102, + 505, + 115 + ], + "score": 1.0, + "content": "In this experiment, we investigate the scaling properties of genomics foundation models with various", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 114, + 240, + 126 + ], + "spans": [ + { + "bbox": [ + 106, + 114, + 240, + 126 + ], + "score": 1.0, + "content": "model backbones (Figure 5 Left).", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5, + "bbox_fs": [ + 105, + 102, + 505, + 126 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 129, + 505, + 172 + ], + "lines": [ + { + "bbox": [ + 105, + 128, + 505, + 142 + ], + "spans": [ + { + "bbox": [ + 105, + 128, + 505, + 142 + ], + "score": 1.0, + "content": "Training To advantage the baselines, we train on a short sequence length of 1024; as shown in", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 139, + 506, + 153 + ], + "spans": [ + { + "bbox": [ + 105, + 139, + 506, + 153 + ], + "score": 1.0, + "content": "Appendix E.2.2, we expect results to favor Mamba even more at longer sequence lengths. We fix", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 149, + 504, + 164 + ], + "spans": [ + { + "bbox": [ + 105, + 149, + 270, + 164 + ], + "score": 1.0, + "content": "a global batch size of 1024, for a total of", + "type": "text" + }, + { + "bbox": [ + 271, + 150, + 312, + 161 + ], + "score": 0.92, + "content": "2 ^ { 2 0 } \\approx 1 M", + "type": "inline_equation" + }, + { + "bbox": [ + 312, + 149, + 483, + 164 + ], + "score": 1.0, + "content": "tokens per batch. Models were trained for", + "type": "text" + }, + { + "bbox": [ + 484, + 151, + 504, + 161 + ], + "score": 0.78, + "content": "1 0 K", + "type": "inline_equation" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 161, + 264, + 174 + ], + "spans": [ + { + "bbox": [ + 105, + 161, + 213, + 174 + ], + "score": 1.0, + "content": "gradient steps for a total of", + "type": "text" + }, + { + "bbox": [ + 213, + 162, + 232, + 172 + ], + "score": 0.82, + "content": "1 0 B", + "type": "inline_equation" + }, + { + "bbox": [ + 233, + 161, + 264, + 174 + ], + "score": 1.0, + "content": "tokens.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 3.5, + "bbox_fs": [ + 105, + 128, + 506, + 174 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 177, + 505, + 221 + ], + "lines": [ + { + "bbox": [ + 105, + 177, + 505, + 190 + ], + "spans": [ + { + "bbox": [ + 105, + 177, + 505, + 190 + ], + "score": 1.0, + "content": "Results Figure 5 (Left) shows that Mamba’s pretraining perplexity improves smoothly with model", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 188, + 505, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 407, + 200 + ], + "score": 1.0, + "content": "size, and that Mamba scales better than both HyenaDNA and Transformer", + "type": "text" + }, + { + "bbox": [ + 407, + 190, + 419, + 198 + ], + "score": 0.56, + "content": "^ { + + }", + "type": "inline_equation" + }, + { + "bbox": [ + 420, + 188, + 505, + 200 + ], + "score": 1.0, + "content": ". For example, at the", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 199, + 507, + 211 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 190, + 211 + ], + "score": 1.0, + "content": "largest model size of", + "type": "text" + }, + { + "bbox": [ + 190, + 199, + 221, + 209 + ], + "score": 0.89, + "content": "{ \\approx } 4 0 M", + "type": "inline_equation" + }, + { + "bbox": [ + 222, + 199, + 507, + 211 + ], + "score": 1.0, + "content": "parameters, the curve shows that Mamba can match the Transformer++", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 210, + 367, + 222 + ], + "spans": [ + { + "bbox": [ + 106, + 210, + 255, + 222 + ], + "score": 1.0, + "content": "and HyenaDNA models with roughly", + "type": "text" + }, + { + "bbox": [ + 255, + 210, + 270, + 220 + ], + "score": 0.87, + "content": "3 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 210, + 280, + 222 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 280, + 210, + 294, + 220 + ], + "score": 0.87, + "content": "4 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 294, + 210, + 367, + 222 + ], + "score": 1.0, + "content": "fewer parameters.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 7.5, + "bbox_fs": [ + 105, + 177, + 507, + 222 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 230, + 266, + 241 + ], + "lines": [ + { + "bbox": [ + 105, + 228, + 268, + 243 + ], + "spans": [ + { + "bbox": [ + 105, + 228, + 268, + 243 + ], + "score": 1.0, + "content": "E.2.2 SCALING: CONTEXT LENGTH", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 10 + }, + { + "type": "text", + "bbox": [ + 107, + 250, + 505, + 326 + ], + "lines": [ + { + "bbox": [ + 105, + 249, + 506, + 264 + ], + "spans": [ + { + "bbox": [ + 105, + 249, + 506, + 264 + ], + "score": 1.0, + "content": "In the next DNA experiment, we investigate the scaling properties of models with respect to sequence", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 262, + 505, + 274 + ], + "spans": [ + { + "bbox": [ + 105, + 262, + 505, + 274 + ], + "score": 1.0, + "content": "length. We only compare the HyenaDNA and Mamba models, as quadratic attention becomes", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 272, + 505, + 284 + ], + "spans": [ + { + "bbox": [ + 105, + 272, + 505, + 284 + ], + "score": 1.0, + "content": "prohibitively expensive at longer sequence lengths. We pretrain models on sequence lengths", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 280, + 506, + 295 + ], + "spans": [ + { + "bbox": [ + 106, + 282, + 152, + 293 + ], + "score": 0.88, + "content": "\\dot { 2 } ^ { 1 0 } = 1 0 2 4", + "type": "inline_equation" + }, + { + "bbox": [ + 153, + 280, + 156, + 295 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 156, + 282, + 202, + 294 + ], + "score": 0.86, + "content": "2 ^ { 1 2 } = 4 0 9 6", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 280, + 206, + 295 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 206, + 282, + 257, + 293 + ], + "score": 0.86, + "content": "2 ^ { 1 4 } = \\bar { 1 } 6 3 8 4", + "type": "inline_equation" + }, + { + "bbox": [ + 257, + 280, + 261, + 295 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 261, + 282, + 312, + 293 + ], + "score": 0.87, + "content": "2 ^ { 1 6 } = 6 5 5 \\bar { 3 6 }", + "type": "inline_equation" + }, + { + "bbox": [ + 312, + 280, + 315, + 295 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 316, + 282, + 371, + 293 + ], + "score": 0.84, + "content": "2 ^ { 1 8 } = 2 \\dot { 6 } 2 1 4 4", + "type": "inline_equation" + }, + { + "bbox": [ + 372, + 280, + 375, + 295 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 376, + 282, + 436, + 293 + ], + "score": 0.88, + "content": "2 ^ { 2 0 } = 1 0 4 8 5 7 6", + "type": "inline_equation" + }, + { + "bbox": [ + 437, + 280, + 506, + 295 + ], + "score": 1.0, + "content": ". We fix a model", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 293, + 505, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 293, + 448, + 306 + ], + "score": 1.0, + "content": "size of 6 layers by width 128 (about 1.3M-1.4M parameters). Models were trained for", + "type": "text" + }, + { + "bbox": [ + 448, + 294, + 469, + 304 + ], + "score": 0.83, + "content": "2 0 K", + "type": "inline_equation" + }, + { + "bbox": [ + 469, + 293, + 505, + 306 + ], + "score": 1.0, + "content": "gradient", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 303, + 506, + 317 + ], + "spans": [ + { + "bbox": [ + 105, + 303, + 178, + 317 + ], + "score": 1.0, + "content": "steps for a total of", + "type": "text" + }, + { + "bbox": [ + 178, + 304, + 211, + 315 + ], + "score": 0.91, + "content": "{ \\approx } 3 3 0 B", + "type": "inline_equation" + }, + { + "bbox": [ + 211, + 303, + 506, + 317 + ], + "score": 1.0, + "content": "tokens. The longer sequence lengths used sequence length warmup similar", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 315, + 204, + 327 + ], + "spans": [ + { + "bbox": [ + 105, + 315, + 204, + 327 + ], + "score": 1.0, + "content": "to (Nguyen et al., 2023).", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 14, + "bbox_fs": [ + 105, + 249, + 506, + 327 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 331, + 505, + 407 + ], + "lines": [ + { + "bbox": [ + 106, + 330, + 505, + 343 + ], + "spans": [ + { + "bbox": [ + 106, + 330, + 505, + 343 + ], + "score": 1.0, + "content": "Results Figure 5 (Right) shows that Mamba is able to make use of longer context even up to extremely", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 341, + 506, + 355 + ], + "spans": [ + { + "bbox": [ + 105, + 341, + 506, + 355 + ], + "score": 1.0, + "content": "long sequences of length 1M, and its pretraining perplexity improves as the context increases. On the", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 353, + 505, + 365 + ], + "spans": [ + { + "bbox": [ + 105, + 353, + 505, + 365 + ], + "score": 1.0, + "content": "other hand, the HyenaDNA model gets worse with sequence length. This is intuitive from the discussion", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 362, + 505, + 375 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 505, + 375 + ], + "score": 1.0, + "content": "in Section 3.5 that motivated the selection mechanism. In particular, LTI models cannot selectively", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 373, + 505, + 387 + ], + "spans": [ + { + "bbox": [ + 105, + 373, + 505, + 387 + ], + "score": 1.0, + "content": "ignore information; from a convolutional perspective, a very long convolution kernel is aggregating", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 384, + 506, + 398 + ], + "spans": [ + { + "bbox": [ + 105, + 384, + 506, + 398 + ], + "score": 1.0, + "content": "all information across a long sequence which may be very noisy. Note that while Nguyen et al. (2023)", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 396, + 492, + 408 + ], + "spans": [ + { + "bbox": [ + 105, + 396, + 492, + 408 + ], + "score": 1.0, + "content": "claims that Hyena improves with longer context, their results do not control for computation time.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 21, + "bbox_fs": [ + 105, + 330, + 506, + 408 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 416, + 302, + 427 + ], + "lines": [ + { + "bbox": [ + 105, + 415, + 304, + 429 + ], + "spans": [ + { + "bbox": [ + 105, + 415, + 304, + 429 + ], + "score": 1.0, + "content": "E.2.3 SYNTHETIC SPECIES CLASSIFICATION", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 107, + 437, + 505, + 480 + ], + "lines": [ + { + "bbox": [ + 106, + 437, + 505, + 448 + ], + "spans": [ + { + "bbox": [ + 106, + 437, + 505, + 448 + ], + "score": 1.0, + "content": "We evaluate models on a downstream task of classifying between 5 different species by randomly", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 447, + 505, + 459 + ], + "spans": [ + { + "bbox": [ + 105, + 447, + 505, + 459 + ], + "score": 1.0, + "content": "sampling a contiguous segment of their DNA. This task is adapted from HyenaDNA, which used the", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 104, + 457, + 506, + 472 + ], + "spans": [ + { + "bbox": [ + 104, + 457, + 137, + 472 + ], + "score": 1.0, + "content": "species", + "type": "text" + }, + { + "bbox": [ + 137, + 458, + 143, + 470 + ], + "score": 0.55, + "content": "\\{", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 457, + 275, + 472 + ], + "score": 1.0, + "content": "human, lemur, mouse, pig, hippo", + "type": "text" + }, + { + "bbox": [ + 275, + 458, + 281, + 470 + ], + "score": 0.51, + "content": "\\}", + "type": "inline_equation" + }, + { + "bbox": [ + 281, + 457, + 506, + 472 + ], + "score": 1.0, + "content": ". We modify the task to be significantly more challenging", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 469, + 503, + 482 + ], + "spans": [ + { + "bbox": [ + 105, + 469, + 299, + 482 + ], + "score": 1.0, + "content": "by classifying between the five great apes species", + "type": "text" + }, + { + "bbox": [ + 299, + 469, + 306, + 481 + ], + "score": 0.26, + "content": "\\{", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 469, + 492, + 482 + ], + "score": 1.0, + "content": "human, chimpanzee, gorilla, orangutan, bonobo", + "type": "text" + }, + { + "bbox": [ + 493, + 469, + 498, + 481 + ], + "score": 0.41, + "content": "\\}", + "type": "inline_equation" + }, + { + "bbox": [ + 499, + 469, + 503, + 482 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 27.5, + "bbox_fs": [ + 104, + 437, + 506, + 482 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 489, + 217, + 501 + ], + "lines": [ + { + "bbox": [ + 105, + 488, + 219, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 488, + 219, + 502 + ], + "score": 1.0, + "content": "E.3 MODEL ABLATIONS", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 30 + }, + { + "type": "text", + "bbox": [ + 105, + 505, + 504, + 517 + ], + "lines": [ + { + "bbox": [ + 106, + 505, + 506, + 519 + ], + "spans": [ + { + "bbox": [ + 106, + 505, + 506, + 519 + ], + "score": 1.0, + "content": "Table 5 investigates the effects of the architecture (block) and its inner SSM layer (Figure 2). We find that", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 31, + "bbox_fs": [ + 106, + 505, + 506, + 519 + ] + }, + { + "type": "list", + "bbox": [ + 106, + 525, + 505, + 631 + ], + "lines": [ + { + "bbox": [ + 104, + 525, + 505, + 540 + ], + "spans": [ + { + "bbox": [ + 104, + 525, + 505, + 540 + ], + "score": 1.0, + "content": "• Among previous non-selective (LTI) SSMs, which are equivalent to global convolutions, performance", + "type": "text" + } + ], + "index": 32, + "is_list_start_line": true + }, + { + "bbox": [ + 112, + 536, + 175, + 550 + ], + "spans": [ + { + "bbox": [ + 112, + 536, + 175, + 550 + ], + "score": 1.0, + "content": "is very similar.", + "type": "text" + } + ], + "index": 33, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 549, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 104, + 549, + 505, + 563 + ], + "score": 1.0, + "content": "• Replacing the complex-valued S4 variant from previous work with a real-valued one does not affect", + "type": "text" + } + ], + "index": 34, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 561, + 505, + 573 + ], + "spans": [ + { + "bbox": [ + 113, + 561, + 505, + 573 + ], + "score": 1.0, + "content": "performance much, suggesting that (at least for LM) real-valued SSMs may be a better choice when", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 113, + 572, + 256, + 585 + ], + "spans": [ + { + "bbox": [ + 113, + 572, + 256, + 585 + ], + "score": 1.0, + "content": "accounting for hardware efficiency.", + "type": "text" + } + ], + "index": 36, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 584, + 505, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 584, + 505, + 599 + ], + "score": 1.0, + "content": "• Replacing any of these with a selective SSM (S6) significantly improves performance, validating", + "type": "text" + } + ], + "index": 37, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 596, + 226, + 608 + ], + "spans": [ + { + "bbox": [ + 113, + 596, + 226, + 608 + ], + "score": 1.0, + "content": "the motivation of Section 3.", + "type": "text" + } + ], + "index": 38, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 607, + 505, + 623 + ], + "spans": [ + { + "bbox": [ + 104, + 607, + 505, + 623 + ], + "score": 1.0, + "content": "• The Mamba architecture performs similarly to the H3 architecture (and seems slightly better when", + "type": "text" + } + ], + "index": 39, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 620, + 209, + 632 + ], + "spans": [ + { + "bbox": [ + 114, + 620, + 209, + 632 + ], + "score": 1.0, + "content": "using a selective layer).", + "type": "text" + } + ], + "index": 40, + "is_list_end_line": true + } + ], + "index": 36, + "bbox_fs": [ + 104, + 525, + 505, + 632 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 640, + 505, + 673 + ], + "lines": [ + { + "bbox": [ + 105, + 640, + 506, + 653 + ], + "spans": [ + { + "bbox": [ + 105, + 640, + 461, + 653 + ], + "score": 1.0, + "content": "Table 6 ablates the selective SSM layer by considering different combinations of selective", + "type": "text" + }, + { + "bbox": [ + 462, + 641, + 485, + 651 + ], + "score": 0.63, + "content": "\\Delta , B", + "type": "inline_equation" + }, + { + "bbox": [ + 485, + 640, + 506, + 653 + ], + "score": 1.0, + "content": ", and", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 107, + 651, + 505, + 663 + ], + "spans": [ + { + "bbox": [ + 107, + 652, + 117, + 662 + ], + "score": 0.77, + "content": "C", + "type": "inline_equation" + }, + { + "bbox": [ + 117, + 651, + 279, + 663 + ], + "score": 1.0, + "content": "parameters (Algorithm 2), showing that", + "type": "text" + }, + { + "bbox": [ + 279, + 652, + 289, + 661 + ], + "score": 0.81, + "content": "\\Delta", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 651, + 505, + 663 + ], + "score": 1.0, + "content": "is the most important parameter due to its connection", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 662, + 221, + 674 + ], + "spans": [ + { + "bbox": [ + 106, + 662, + 221, + 674 + ], + "score": 1.0, + "content": "to RNN gating (Theorem 1).", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42, + "bbox_fs": [ + 105, + 640, + 506, + 674 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 677, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 677, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 690 + ], + "score": 1.0, + "content": "Table 7 considers different initializations of the SSM, which have been shown to make a large", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 701 + ], + "score": 1.0, + "content": "difference in some data modalities and settings (Gu et al., 2022a;b). On language modeling, we", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "find that simpler real-valued diagonal initializations (S4D-Real, row 3) instead of more standard", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 710, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 710, + 506, + 722 + ], + "score": 1.0, + "content": "complex-valued parameterizations (S4D-Lin, row 1) perform better. Random initializations also work", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 106, + 720, + 369, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 720, + 369, + 732 + ], + "score": 1.0, + "content": "well, consistent with findings from prior work (Mehta et al., 2023).", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 46, + "bbox_fs": [ + 105, + 677, + 506, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 208, + 129, + 399, + 244 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 107, + 79, + 504, + 120 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 78, + 506, + 93 + ], + "spans": [ + { + "bbox": [ + 105, + 78, + 506, + 93 + ], + "score": 1.0, + "content": "Table 5: (Ablations: Architecture and SSM layer.) The Mamba block performs similarly to H3 while being", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 90, + 505, + 101 + ], + "spans": [ + { + "bbox": [ + 105, + 90, + 505, + 101 + ], + "score": 1.0, + "content": "simpler. In the inner layer, there is little difference among different parameterizations of LTI models, while", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 100, + 505, + 111 + ], + "spans": [ + { + "bbox": [ + 106, + 100, + 505, + 111 + ], + "score": 1.0, + "content": "selective SSMs (S6) provide a large improvement. More specifically, the S4 (real) variant is S4D-Real and the S4", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 110, + 215, + 122 + ], + "spans": [ + { + "bbox": [ + 106, + 110, + 215, + 122 + ], + "score": 1.0, + "content": "(complex) variant is S4D-Lin.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 1.5 + }, + { + "type": "table_body", + "bbox": [ + 208, + 129, + 399, + 244 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 208, + 129, + 399, + 244 + ], + "spans": [ + { + "bbox": [ + 208, + 129, + 399, + 244 + ], + "score": 0.978, + "html": "
MODELBLOCKSSMLAYERPERPLEXITY
HyenaH3Hyena10.24
-H3S4 (real)10.34
H3H3S4 (complex)10.30
H3S68.95
=MambaHyena10.75
MambaS4 (real)10.56
MambaS4 (complex) 10.54
MambaMambaS68.69
", + "type": "table", + "image_path": "5b62988e74374320e41661ec3f6a8372efcd62576d86975682c6dce947269abc.jpg" + } + ] + } + ], + "index": 8.5, + "virtual_lines": [ + { + "bbox": [ + 208, + 129, + 399, + 140.5 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 208, + 140.5, + 399, + 152.0 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 208, + 152.0, + 399, + 163.5 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 208, + 163.5, + 399, + 175.0 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 208, + 175.0, + 399, + 186.5 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 208, + 186.5, + 399, + 198.0 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 208, + 198.0, + 399, + 209.5 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 208, + 209.5, + 399, + 221.0 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 208, + 221.0, + 399, + 232.5 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 208, + 232.5, + 399, + 244.0 + ], + "spans": [], + "index": 13 + } + ] + } + ], + "index": 5.0 + }, + { + "type": "table", + "bbox": [ + 106, + 294, + 308, + 372 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 255, + 307, + 285 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 255, + 307, + 266 + ], + "spans": [ + { + "bbox": [ + 106, + 255, + 275, + 266 + ], + "score": 1.0, + "content": "Table 6: (Ablations: Selective parameters.)", + "type": "text" + }, + { + "bbox": [ + 275, + 255, + 284, + 264 + ], + "score": 0.76, + "content": "\\Delta", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 255, + 307, + 266 + ], + "score": 1.0, + "content": "is the", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 265, + 307, + 275 + ], + "spans": [ + { + "bbox": [ + 106, + 265, + 307, + 275 + ], + "score": 1.0, + "content": "most important parameter (Theorem 1, but using them all", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 275, + 180, + 286 + ], + "spans": [ + { + "bbox": [ + 106, + 275, + 180, + 286 + ], + "score": 1.0, + "content": "together synergizes.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15 + }, + { + "type": "table_body", + "bbox": [ + 106, + 294, + 308, + 372 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 294, + 308, + 372 + ], + "spans": [ + { + "bbox": [ + 106, + 294, + 308, + 372 + ], + "score": 0.978, + "html": "
Selective△ Selective B Selective C Perplexity
X10.93
Xxx<x> 10.15
x√9.98
x<xx> √9.81 8.71
", + "type": "table", + "image_path": "583427fe5905dbc03a3913f389bd3246936c9b44f8c12590d29d8848b30d3b52.jpg" + } + ] + } + ], + "index": 24, + "virtual_lines": [ + { + "bbox": [ + 106, + 294, + 308, + 305.14285714285717 + ], + "spans": [], + "index": 21 + }, + { + "bbox": [ + 106, + 305.14285714285717, + 308, + 316.28571428571433 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 106, + 316.28571428571433, + 308, + 327.4285714285715 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 106, + 327.4285714285715, + 308, + 338.57142857142867 + ], + "spans": [], + "index": 24 + }, + { + "bbox": [ + 106, + 338.57142857142867, + 308, + 349.71428571428584 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 106, + 349.71428571428584, + 308, + 360.857142857143 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 106, + 360.857142857143, + 308, + 372.00000000000017 + ], + "spans": [], + "index": 27 + } + ] + } + ], + "index": 19.5 + }, + { + "type": "table", + "bbox": [ + 328, + 303, + 498, + 373 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 324, + 255, + 505, + 294 + ], + "group_id": 3, + "lines": [ + { + "bbox": [ + 323, + 254, + 505, + 266 + ], + "spans": [ + { + "bbox": [ + 323, + 254, + 474, + 266 + ], + "score": 1.0, + "content": "Table 7: (Ablations: Parameterization of", + "type": "text" + }, + { + "bbox": [ + 474, + 255, + 483, + 264 + ], + "score": 0.41, + "content": "\\pmb { A } .", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 254, + 505, + 266 + ], + "score": 1.0, + "content": ".) The", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 323, + 264, + 505, + 275 + ], + "spans": [ + { + "bbox": [ + 323, + 264, + 505, + 275 + ], + "score": 1.0, + "content": "more standard initializations based on S4D-Lin (Gu", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 323, + 274, + 506, + 285 + ], + "spans": [ + { + "bbox": [ + 323, + 274, + 506, + 285 + ], + "score": 1.0, + "content": "et al., 2022b) perform worse than S4D-Real or a", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 324, + 285, + 404, + 294 + ], + "spans": [ + { + "bbox": [ + 324, + 285, + 404, + 294 + ], + "score": 1.0, + "content": "random initialization.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 18.5 + }, + { + "type": "table_body", + "bbox": [ + 328, + 303, + 498, + 373 + ], + "group_id": 3, + "lines": [ + { + "bbox": [ + 328, + 303, + 498, + 373 + ], + "spans": [ + { + "bbox": [ + 328, + 303, + 498, + 373 + ], + "score": 0.973, + "html": "
An InitializationFieldPerplexity
A=+miComplex 9.16
An=-Real8.85
An=-(n+1)Real8.71
An ~exp(N (0,1))Real8.71
", + "type": "table", + "image_path": "25897887b6002ad482b0abab73d236383f4b4326dc4504dd8fcf2a2a346a7aa8.jpg" + } + ] + } + ], + "index": 30.5, + "virtual_lines": [ + { + "bbox": [ + 328, + 303, + 498, + 314.6666666666667 + ], + "spans": [], + "index": 28 + }, + { + "bbox": [ + 328, + 314.6666666666667, + 498, + 326.33333333333337 + ], + "spans": [], + "index": 29 + }, + { + "bbox": [ + 328, + 326.33333333333337, + 498, + 338.00000000000006 + ], + "spans": [], + "index": 30 + }, + { + "bbox": [ + 328, + 338.00000000000006, + 498, + 349.66666666666674 + ], + "spans": [], + "index": 31 + }, + { + "bbox": [ + 328, + 349.66666666666674, + 498, + 361.3333333333334 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 328, + 361.3333333333334, + 498, + 373.0000000000001 + ], + "spans": [], + "index": 33 + } + ] + } + ], + "index": 24.5 + }, + { + "type": "text", + "bbox": [ + 106, + 383, + 228, + 472 + ], + "lines": [ + { + "bbox": [ + 105, + 383, + 229, + 395 + ], + "spans": [ + { + "bbox": [ + 105, + 383, + 229, + 395 + ], + "score": 1.0, + "content": "Table 8: (Ablations: Expressiv-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 393, + 229, + 404 + ], + "spans": [ + { + "bbox": [ + 105, + 393, + 130, + 404 + ], + "score": 1.0, + "content": "ity of", + "type": "text" + }, + { + "bbox": [ + 130, + 394, + 139, + 403 + ], + "score": 0.72, + "content": "\\Delta", + "type": "inline_equation" + }, + { + "bbox": [ + 139, + 393, + 229, + 404 + ], + "score": 1.0, + "content": ".) The selection mecha-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 403, + 229, + 414 + ], + "spans": [ + { + "bbox": [ + 106, + 403, + 135, + 414 + ], + "score": 1.0, + "content": "nism of", + "type": "text" + }, + { + "bbox": [ + 135, + 404, + 144, + 412 + ], + "score": 0.79, + "content": "\\Delta", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 403, + 229, + 414 + ], + "score": 1.0, + "content": "constructs it with a low-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 413, + 229, + 424 + ], + "spans": [ + { + "bbox": [ + 105, + 413, + 229, + 424 + ], + "score": 1.0, + "content": "rank projection of the input. Pro-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 423, + 228, + 433 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 228, + 433 + ], + "score": 1.0, + "content": "jecting it even to rank 1 provides", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 433, + 228, + 443 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 228, + 443 + ], + "score": 1.0, + "content": "a large increase in performance;", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 443, + 228, + 453 + ], + "spans": [ + { + "bbox": [ + 106, + 443, + 228, + 453 + ], + "score": 1.0, + "content": "increasing it further provides fur-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 452, + 228, + 463 + ], + "spans": [ + { + "bbox": [ + 106, + 452, + 228, + 463 + ], + "score": 1.0, + "content": "ther improvements at the cost of a", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 462, + 218, + 473 + ], + "spans": [ + { + "bbox": [ + 106, + 462, + 218, + 473 + ], + "score": 1.0, + "content": "modest increase in parameters.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 38 + }, + { + "type": "table", + "bbox": [ + 304, + 444, + 443, + 581 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 244, + 385, + 504, + 434 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 244, + 385, + 505, + 397 + ], + "spans": [ + { + "bbox": [ + 244, + 385, + 399, + 397 + ], + "score": 1.0, + "content": "Table 9: (Ablations: SSM state dimension", + "type": "text" + }, + { + "bbox": [ + 400, + 386, + 410, + 395 + ], + "score": 0.64, + "content": "N _ { \\cdot }", + "type": "inline_equation" + }, + { + "bbox": [ + 410, + 385, + 479, + 397 + ], + "score": 1.0, + "content": ".) (Top) No variable", + "type": "text" + }, + { + "bbox": [ + 480, + 386, + 489, + 394 + ], + "score": 0.72, + "content": "_ B", + "type": "inline_equation" + }, + { + "bbox": [ + 489, + 385, + 505, + 397 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 245, + 395, + 505, + 406 + ], + "spans": [ + { + "bbox": [ + 245, + 395, + 255, + 405 + ], + "score": 0.6, + "content": "_ { C }", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 395, + 324, + 406 + ], + "score": 1.0, + "content": "(Bottom) Variable", + "type": "text" + }, + { + "bbox": [ + 324, + 396, + 334, + 405 + ], + "score": 0.73, + "content": "_ B", + "type": "inline_equation" + }, + { + "bbox": [ + 334, + 395, + 350, + 406 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 351, + 396, + 360, + 404 + ], + "score": 0.75, + "content": "_ { C }", + "type": "inline_equation" + }, + { + "bbox": [ + 360, + 395, + 505, + 406 + ], + "score": 1.0, + "content": ". Increasing the state dimension, which", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 245, + 406, + 505, + 415 + ], + "spans": [ + { + "bbox": [ + 245, + 406, + 505, + 415 + ], + "score": 1.0, + "content": "can be viewed as an expansion factor on the dimension of the recurrent", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 244, + 414, + 506, + 427 + ], + "spans": [ + { + "bbox": [ + 244, + 414, + 506, + 427 + ], + "score": 1.0, + "content": "state, can significantly improve performance for a negligible cost in pa-", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 244, + 424, + 460, + 436 + ], + "spans": [ + { + "bbox": [ + 244, + 424, + 360, + 436 + ], + "score": 1.0, + "content": "rameters/FLOPs, but only when", + "type": "text" + }, + { + "bbox": [ + 360, + 425, + 369, + 433 + ], + "score": 0.76, + "content": "_ B", + "type": "inline_equation" + }, + { + "bbox": [ + 370, + 424, + 385, + 436 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 385, + 425, + 394, + 433 + ], + "score": 0.81, + "content": "_ { C }", + "type": "inline_equation" + }, + { + "bbox": [ + 395, + 424, + 460, + 436 + ], + "score": 1.0, + "content": "are also selective.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 45 + }, + { + "type": "table_body", + "bbox": [ + 304, + 444, + 443, + 581 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 304, + 444, + 443, + 581 + ], + "spans": [ + { + "bbox": [ + 304, + 444, + 443, + 581 + ], + "score": 0.973, + "html": "
State dim. N Params Perplexity
1367.1M 9.88
2367.4M 9.86
4368.0M 9.82
8369.1M 9.82
16371.5M 9.81
1367.1M 9.73
2367.4M 9.40
4368.0M 9.09
8369.1M 8.84
16371.5M 8.71
", + "type": "table", + "image_path": "8a1f0be611ad2fb96f163644946fd2fec4c4ba76da241d8e8f7a84a190daee34.jpg" + } + ] + } + ], + "index": 50.0, + "virtual_lines": [ + { + "bbox": [ + 304, + 444, + 443, + 512.5 + ], + "spans": [], + "index": 49 + }, + { + "bbox": [ + 304, + 512.5, + 443, + 581.0 + ], + "spans": [], + "index": 51 + } + ] + } + ], + "index": 47.5 + }, + { + "type": "table", + "bbox": [ + 105, + 481, + 255, + 581 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 105, + 481, + 255, + 581 + ], + "group_id": 4, + "lines": [ + { + "bbox": [ + 105, + 481, + 255, + 581 + ], + "spans": [ + { + "bbox": [ + 105, + 481, + 255, + 581 + ], + "score": 0.931, + "html": "
Rank of△ proj. ParamsPerplexity
= 358.9M 9.12
1 359.1M 8.97
2 359.3M 8.97
359.7M 8.91
4 8 360.5M 8.83
16 362.1M 8.84
32 365.2M 8.80
", + "type": "table", + "image_path": "01cff6c9b54253f8d1653c7f3272fb680ada67a23179a1effbba6e80fc06059c.jpg" + } + ] + } + ], + "index": 49.0, + "virtual_lines": [ + { + "bbox": [ + 105, + 481, + 255, + 531.0 + ], + "spans": [], + "index": 48 + }, + { + "bbox": [ + 105, + 531.0, + 255, + 581.0 + ], + "spans": [], + "index": 50 + } + ] + } + ], + "index": 49.0 + }, + { + "type": "text", + "bbox": [ + 107, + 597, + 505, + 631 + ], + "lines": [ + { + "bbox": [ + 105, + 597, + 507, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 597, + 345, + 611 + ], + "score": 1.0, + "content": "Table 8 and Table 9 consider varying the dimension of the", + "type": "text" + }, + { + "bbox": [ + 346, + 598, + 356, + 608 + ], + "score": 0.79, + "content": "\\Delta", + "type": "inline_equation" + }, + { + "bbox": [ + 356, + 597, + 374, + 611 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 375, + 598, + 404, + 610 + ], + "score": 0.92, + "content": "( B , C )", + "type": "inline_equation" + }, + { + "bbox": [ + 405, + 597, + 507, + 611 + ], + "score": 1.0, + "content": "projections respectively.", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 105, + 608, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 105, + 608, + 505, + 621 + ], + "score": 1.0, + "content": "Changing them from static to selective provides the most benefit, while increasing the dimensions", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 106, + 619, + 467, + 632 + ], + "spans": [ + { + "bbox": [ + 106, + 619, + 467, + 632 + ], + "score": 1.0, + "content": "further generally improves performance modestly with a small increase in parameter count.", + "type": "text" + } + ], + "index": 54 + } + ], + "index": 53 + }, + { + "type": "title", + "bbox": [ + 108, + 642, + 398, + 654 + ], + "lines": [ + { + "bbox": [ + 104, + 640, + 399, + 657 + ], + "spans": [ + { + "bbox": [ + 104, + 640, + 399, + 657 + ], + "score": 1.0, + "content": "F EXPERIMENTAL DETAILS AND ADDITIONAL RESULTS", + "type": "text" + } + ], + "index": 55 + } + ], + "index": 55 + }, + { + "type": "text", + "bbox": [ + 107, + 660, + 212, + 672 + ], + "lines": [ + { + "bbox": [ + 105, + 659, + 213, + 673 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 213, + 673 + ], + "score": 1.0, + "content": "F.1 SYNTHETIC TASKS", + "type": "text" + } + ], + "index": 56 + } + ], + "index": 56 + }, + { + "type": "text", + "bbox": [ + 108, + 676, + 506, + 709 + ], + "lines": [ + { + "bbox": [ + 105, + 676, + 506, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 506, + 689 + ], + "score": 1.0, + "content": "Selective Copying Our setting is on sequences of length 4096, with a vocab size of 16 possible", + "type": "text" + } + ], + "index": 57 + }, + { + "bbox": [ + 105, + 686, + 507, + 699 + ], + "spans": [ + { + "bbox": [ + 105, + 686, + 507, + 699 + ], + "score": 1.0, + "content": "tokens (including the white “noise” token from Figure 1) and requiring models to memorize 16 “data”", + "type": "text" + } + ], + "index": 58 + }, + { + "bbox": [ + 106, + 698, + 368, + 710 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 334, + 710 + ], + "score": 1.0, + "content": "tokens. We use 2 layer models with a model dimension of", + "type": "text" + }, + { + "bbox": [ + 335, + 698, + 364, + 708 + ], + "score": 0.9, + "content": "D { = } 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 364, + 698, + 368, + 710 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 59 + } + ], + "index": 58 + }, + { + "type": "text", + "bbox": [ + 104, + 713, + 475, + 725 + ], + "lines": [ + { + "bbox": [ + 105, + 713, + 477, + 726 + ], + "spans": [ + { + "bbox": [ + 105, + 713, + 477, + 726 + ], + "score": 1.0, + "content": "Models are trained for 400K steps at a constant learning rate of 0.0001 with a batch size of 64.", + "type": "text" + } + ], + "index": 60 + } + ], + "index": 60 + } + ], + "page_idx": 20, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 304, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 305, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 305, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 310, + 760 + ], + "lines": [ + { + "bbox": [ + 298, + 750, + 312, + 765 + ], + "spans": [ + { + "bbox": [ + 298, + 750, + 312, + 765 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 15, + "width": 14 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 208, + 129, + 399, + 244 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 107, + 79, + 504, + 120 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 78, + 506, + 93 + ], + "spans": [ + { + "bbox": [ + 105, + 78, + 506, + 93 + ], + "score": 1.0, + "content": "Table 5: (Ablations: Architecture and SSM layer.) The Mamba block performs similarly to H3 while being", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 90, + 505, + 101 + ], + "spans": [ + { + "bbox": [ + 105, + 90, + 505, + 101 + ], + "score": 1.0, + "content": "simpler. In the inner layer, there is little difference among different parameterizations of LTI models, while", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 100, + 505, + 111 + ], + "spans": [ + { + "bbox": [ + 106, + 100, + 505, + 111 + ], + "score": 1.0, + "content": "selective SSMs (S6) provide a large improvement. More specifically, the S4 (real) variant is S4D-Real and the S4", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 110, + 215, + 122 + ], + "spans": [ + { + "bbox": [ + 106, + 110, + 215, + 122 + ], + "score": 1.0, + "content": "(complex) variant is S4D-Lin.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 1.5 + }, + { + "type": "table_body", + "bbox": [ + 208, + 129, + 399, + 244 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 208, + 129, + 399, + 244 + ], + "spans": [ + { + "bbox": [ + 208, + 129, + 399, + 244 + ], + "score": 0.978, + "html": "
MODELBLOCKSSMLAYERPERPLEXITY
HyenaH3Hyena10.24
-H3S4 (real)10.34
H3H3S4 (complex)10.30
H3S68.95
=MambaHyena10.75
MambaS4 (real)10.56
MambaS4 (complex) 10.54
MambaMambaS68.69
", + "type": "table", + "image_path": "5b62988e74374320e41661ec3f6a8372efcd62576d86975682c6dce947269abc.jpg" + } + ] + } + ], + "index": 8.5, + "virtual_lines": [ + { + "bbox": [ + 208, + 129, + 399, + 140.5 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 208, + 140.5, + 399, + 152.0 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 208, + 152.0, + 399, + 163.5 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 208, + 163.5, + 399, + 175.0 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 208, + 175.0, + 399, + 186.5 + ], + "spans": [], + "index": 8 + }, + { + "bbox": [ + 208, + 186.5, + 399, + 198.0 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 208, + 198.0, + 399, + 209.5 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 208, + 209.5, + 399, + 221.0 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 208, + 221.0, + 399, + 232.5 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 208, + 232.5, + 399, + 244.0 + ], + "spans": [], + "index": 13 + } + ] + } + ], + "index": 5.0 + }, + { + "type": "table", + "bbox": [ + 106, + 294, + 308, + 372 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 255, + 307, + 285 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 255, + 307, + 266 + ], + "spans": [ + { + "bbox": [ + 106, + 255, + 275, + 266 + ], + "score": 1.0, + "content": "Table 6: (Ablations: Selective parameters.)", + "type": "text" + }, + { + "bbox": [ + 275, + 255, + 284, + 264 + ], + "score": 0.76, + "content": "\\Delta", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 255, + 307, + 266 + ], + "score": 1.0, + "content": "is the", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 265, + 307, + 275 + ], + "spans": [ + { + "bbox": [ + 106, + 265, + 307, + 275 + ], + "score": 1.0, + "content": "most important parameter (Theorem 1, but using them all", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 275, + 180, + 286 + ], + "spans": [ + { + "bbox": [ + 106, + 275, + 180, + 286 + ], + "score": 1.0, + "content": "together synergizes.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15 + }, + { + "type": "table_body", + "bbox": [ + 106, + 294, + 308, + 372 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 294, + 308, + 372 + ], + "spans": [ + { + "bbox": [ + 106, + 294, + 308, + 372 + ], + "score": 0.978, + "html": "
Selective△ Selective B Selective C Perplexity
X10.93
Xxx<x> 10.15
x√9.98
x<xx> √9.81 8.71
", + "type": "table", + "image_path": "583427fe5905dbc03a3913f389bd3246936c9b44f8c12590d29d8848b30d3b52.jpg" + } + ] + } + ], + "index": 24, + "virtual_lines": [ + { + "bbox": [ + 106, + 294, + 308, + 305.14285714285717 + ], + "spans": [], + "index": 21 + }, + { + "bbox": [ + 106, + 305.14285714285717, + 308, + 316.28571428571433 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 106, + 316.28571428571433, + 308, + 327.4285714285715 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 106, + 327.4285714285715, + 308, + 338.57142857142867 + ], + "spans": [], + "index": 24 + }, + { + "bbox": [ + 106, + 338.57142857142867, + 308, + 349.71428571428584 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 106, + 349.71428571428584, + 308, + 360.857142857143 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 106, + 360.857142857143, + 308, + 372.00000000000017 + ], + "spans": [], + "index": 27 + } + ] + } + ], + "index": 19.5 + }, + { + "type": "table", + "bbox": [ + 328, + 303, + 498, + 373 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 324, + 255, + 505, + 294 + ], + "group_id": 3, + "lines": [ + { + "bbox": [ + 323, + 254, + 505, + 266 + ], + "spans": [ + { + "bbox": [ + 323, + 254, + 474, + 266 + ], + "score": 1.0, + "content": "Table 7: (Ablations: Parameterization of", + "type": "text" + }, + { + "bbox": [ + 474, + 255, + 483, + 264 + ], + "score": 0.41, + "content": "\\pmb { A } .", + "type": "inline_equation" + }, + { + "bbox": [ + 484, + 254, + 505, + 266 + ], + "score": 1.0, + "content": ".) The", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 323, + 264, + 505, + 275 + ], + "spans": [ + { + "bbox": [ + 323, + 264, + 505, + 275 + ], + "score": 1.0, + "content": "more standard initializations based on S4D-Lin (Gu", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 323, + 274, + 506, + 285 + ], + "spans": [ + { + "bbox": [ + 323, + 274, + 506, + 285 + ], + "score": 1.0, + "content": "et al., 2022b) perform worse than S4D-Real or a", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 324, + 285, + 404, + 294 + ], + "spans": [ + { + "bbox": [ + 324, + 285, + 404, + 294 + ], + "score": 1.0, + "content": "random initialization.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 18.5 + }, + { + "type": "table_body", + "bbox": [ + 328, + 303, + 498, + 373 + ], + "group_id": 3, + "lines": [ + { + "bbox": [ + 328, + 303, + 498, + 373 + ], + "spans": [ + { + "bbox": [ + 328, + 303, + 498, + 373 + ], + "score": 0.973, + "html": "
An InitializationFieldPerplexity
A=+miComplex 9.16
An=-Real8.85
An=-(n+1)Real8.71
An ~exp(N (0,1))Real8.71
", + "type": "table", + "image_path": "25897887b6002ad482b0abab73d236383f4b4326dc4504dd8fcf2a2a346a7aa8.jpg" + } + ] + } + ], + "index": 30.5, + "virtual_lines": [ + { + "bbox": [ + 328, + 303, + 498, + 314.6666666666667 + ], + "spans": [], + "index": 28 + }, + { + "bbox": [ + 328, + 314.6666666666667, + 498, + 326.33333333333337 + ], + "spans": [], + "index": 29 + }, + { + "bbox": [ + 328, + 326.33333333333337, + 498, + 338.00000000000006 + ], + "spans": [], + "index": 30 + }, + { + "bbox": [ + 328, + 338.00000000000006, + 498, + 349.66666666666674 + ], + "spans": [], + "index": 31 + }, + { + "bbox": [ + 328, + 349.66666666666674, + 498, + 361.3333333333334 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 328, + 361.3333333333334, + 498, + 373.0000000000001 + ], + "spans": [], + "index": 33 + } + ] + } + ], + "index": 24.5 + }, + { + "type": "text", + "bbox": [ + 106, + 383, + 228, + 472 + ], + "lines": [ + { + "bbox": [ + 105, + 383, + 229, + 395 + ], + "spans": [ + { + "bbox": [ + 105, + 383, + 229, + 395 + ], + "score": 1.0, + "content": "Table 8: (Ablations: Expressiv-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 393, + 229, + 404 + ], + "spans": [ + { + "bbox": [ + 105, + 393, + 130, + 404 + ], + "score": 1.0, + "content": "ity of", + "type": "text" + }, + { + "bbox": [ + 130, + 394, + 139, + 403 + ], + "score": 0.72, + "content": "\\Delta", + "type": "inline_equation" + }, + { + "bbox": [ + 139, + 393, + 229, + 404 + ], + "score": 1.0, + "content": ".) The selection mecha-", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 403, + 229, + 414 + ], + "spans": [ + { + "bbox": [ + 106, + 403, + 135, + 414 + ], + "score": 1.0, + "content": "nism of", + "type": "text" + }, + { + "bbox": [ + 135, + 404, + 144, + 412 + ], + "score": 0.79, + "content": "\\Delta", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 403, + 229, + 414 + ], + "score": 1.0, + "content": "constructs it with a low-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 413, + 229, + 424 + ], + "spans": [ + { + "bbox": [ + 105, + 413, + 229, + 424 + ], + "score": 1.0, + "content": "rank projection of the input. Pro-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 423, + 228, + 433 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 228, + 433 + ], + "score": 1.0, + "content": "jecting it even to rank 1 provides", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 433, + 228, + 443 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 228, + 443 + ], + "score": 1.0, + "content": "a large increase in performance;", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 443, + 228, + 453 + ], + "spans": [ + { + "bbox": [ + 106, + 443, + 228, + 453 + ], + "score": 1.0, + "content": "increasing it further provides fur-", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 452, + 228, + 463 + ], + "spans": [ + { + "bbox": [ + 106, + 452, + 228, + 463 + ], + "score": 1.0, + "content": "ther improvements at the cost of a", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 462, + 218, + 473 + ], + "spans": [ + { + "bbox": [ + 106, + 462, + 218, + 473 + ], + "score": 1.0, + "content": "modest increase in parameters.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 38, + "bbox_fs": [ + 105, + 383, + 229, + 473 + ] + }, + { + "type": "table", + "bbox": [ + 304, + 444, + 443, + 581 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 244, + 385, + 504, + 434 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 244, + 385, + 505, + 397 + ], + "spans": [ + { + "bbox": [ + 244, + 385, + 399, + 397 + ], + "score": 1.0, + "content": "Table 9: (Ablations: SSM state dimension", + "type": "text" + }, + { + "bbox": [ + 400, + 386, + 410, + 395 + ], + "score": 0.64, + "content": "N _ { \\cdot }", + "type": "inline_equation" + }, + { + "bbox": [ + 410, + 385, + 479, + 397 + ], + "score": 1.0, + "content": ".) (Top) No variable", + "type": "text" + }, + { + "bbox": [ + 480, + 386, + 489, + 394 + ], + "score": 0.72, + "content": "_ B", + "type": "inline_equation" + }, + { + "bbox": [ + 489, + 385, + 505, + 397 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 245, + 395, + 505, + 406 + ], + "spans": [ + { + "bbox": [ + 245, + 395, + 255, + 405 + ], + "score": 0.6, + "content": "_ { C }", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 395, + 324, + 406 + ], + "score": 1.0, + "content": "(Bottom) Variable", + "type": "text" + }, + { + "bbox": [ + 324, + 396, + 334, + 405 + ], + "score": 0.73, + "content": "_ B", + "type": "inline_equation" + }, + { + "bbox": [ + 334, + 395, + 350, + 406 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 351, + 396, + 360, + 404 + ], + "score": 0.75, + "content": "_ { C }", + "type": "inline_equation" + }, + { + "bbox": [ + 360, + 395, + 505, + 406 + ], + "score": 1.0, + "content": ". Increasing the state dimension, which", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 245, + 406, + 505, + 415 + ], + "spans": [ + { + "bbox": [ + 245, + 406, + 505, + 415 + ], + "score": 1.0, + "content": "can be viewed as an expansion factor on the dimension of the recurrent", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 244, + 414, + 506, + 427 + ], + "spans": [ + { + "bbox": [ + 244, + 414, + 506, + 427 + ], + "score": 1.0, + "content": "state, can significantly improve performance for a negligible cost in pa-", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 244, + 424, + 460, + 436 + ], + "spans": [ + { + "bbox": [ + 244, + 424, + 360, + 436 + ], + "score": 1.0, + "content": "rameters/FLOPs, but only when", + "type": "text" + }, + { + "bbox": [ + 360, + 425, + 369, + 433 + ], + "score": 0.76, + "content": "_ B", + "type": "inline_equation" + }, + { + "bbox": [ + 370, + 424, + 385, + 436 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 385, + 425, + 394, + 433 + ], + "score": 0.81, + "content": "_ { C }", + "type": "inline_equation" + }, + { + "bbox": [ + 395, + 424, + 460, + 436 + ], + "score": 1.0, + "content": "are also selective.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 45 + }, + { + "type": "table_body", + "bbox": [ + 304, + 444, + 443, + 581 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 304, + 444, + 443, + 581 + ], + "spans": [ + { + "bbox": [ + 304, + 444, + 443, + 581 + ], + "score": 0.973, + "html": "
State dim. N Params Perplexity
1367.1M 9.88
2367.4M 9.86
4368.0M 9.82
8369.1M 9.82
16371.5M 9.81
1367.1M 9.73
2367.4M 9.40
4368.0M 9.09
8369.1M 8.84
16371.5M 8.71
", + "type": "table", + "image_path": "8a1f0be611ad2fb96f163644946fd2fec4c4ba76da241d8e8f7a84a190daee34.jpg" + } + ] + } + ], + "index": 50.0, + "virtual_lines": [ + { + "bbox": [ + 304, + 444, + 443, + 512.5 + ], + "spans": [], + "index": 49 + }, + { + "bbox": [ + 304, + 512.5, + 443, + 581.0 + ], + "spans": [], + "index": 51 + } + ] + } + ], + "index": 47.5 + }, + { + "type": "table", + "bbox": [ + 105, + 481, + 255, + 581 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 105, + 481, + 255, + 581 + ], + "group_id": 4, + "lines": [ + { + "bbox": [ + 105, + 481, + 255, + 581 + ], + "spans": [ + { + "bbox": [ + 105, + 481, + 255, + 581 + ], + "score": 0.931, + "html": "
Rank of△ proj. ParamsPerplexity
= 358.9M 9.12
1 359.1M 8.97
2 359.3M 8.97
359.7M 8.91
4 8 360.5M 8.83
16 362.1M 8.84
32 365.2M 8.80
", + "type": "table", + "image_path": "01cff6c9b54253f8d1653c7f3272fb680ada67a23179a1effbba6e80fc06059c.jpg" + } + ] + } + ], + "index": 49.0, + "virtual_lines": [ + { + "bbox": [ + 105, + 481, + 255, + 531.0 + ], + "spans": [], + "index": 48 + }, + { + "bbox": [ + 105, + 531.0, + 255, + 581.0 + ], + "spans": [], + "index": 50 + } + ] + } + ], + "index": 49.0 + }, + { + "type": "text", + "bbox": [ + 107, + 597, + 505, + 631 + ], + "lines": [ + { + "bbox": [ + 105, + 597, + 507, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 597, + 345, + 611 + ], + "score": 1.0, + "content": "Table 8 and Table 9 consider varying the dimension of the", + "type": "text" + }, + { + "bbox": [ + 346, + 598, + 356, + 608 + ], + "score": 0.79, + "content": "\\Delta", + "type": "inline_equation" + }, + { + "bbox": [ + 356, + 597, + 374, + 611 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 375, + 598, + 404, + 610 + ], + "score": 0.92, + "content": "( B , C )", + "type": "inline_equation" + }, + { + "bbox": [ + 405, + 597, + 507, + 611 + ], + "score": 1.0, + "content": "projections respectively.", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 105, + 608, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 105, + 608, + 505, + 621 + ], + "score": 1.0, + "content": "Changing them from static to selective provides the most benefit, while increasing the dimensions", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 106, + 619, + 467, + 632 + ], + "spans": [ + { + "bbox": [ + 106, + 619, + 467, + 632 + ], + "score": 1.0, + "content": "further generally improves performance modestly with a small increase in parameter count.", + "type": "text" + } + ], + "index": 54 + } + ], + "index": 53, + "bbox_fs": [ + 105, + 597, + 507, + 632 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 642, + 398, + 654 + ], + "lines": [ + { + "bbox": [ + 104, + 640, + 399, + 657 + ], + "spans": [ + { + "bbox": [ + 104, + 640, + 399, + 657 + ], + "score": 1.0, + "content": "F EXPERIMENTAL DETAILS AND ADDITIONAL RESULTS", + "type": "text" + } + ], + "index": 55 + } + ], + "index": 55 + }, + { + "type": "text", + "bbox": [ + 107, + 660, + 212, + 672 + ], + "lines": [ + { + "bbox": [ + 105, + 659, + 213, + 673 + ], + "spans": [ + { + "bbox": [ + 105, + 659, + 213, + 673 + ], + "score": 1.0, + "content": "F.1 SYNTHETIC TASKS", + "type": "text" + } + ], + "index": 56 + } + ], + "index": 56, + "bbox_fs": [ + 105, + 659, + 213, + 673 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 676, + 506, + 709 + ], + "lines": [ + { + "bbox": [ + 105, + 676, + 506, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 506, + 689 + ], + "score": 1.0, + "content": "Selective Copying Our setting is on sequences of length 4096, with a vocab size of 16 possible", + "type": "text" + } + ], + "index": 57 + }, + { + "bbox": [ + 105, + 686, + 507, + 699 + ], + "spans": [ + { + "bbox": [ + 105, + 686, + 507, + 699 + ], + "score": 1.0, + "content": "tokens (including the white “noise” token from Figure 1) and requiring models to memorize 16 “data”", + "type": "text" + } + ], + "index": 58 + }, + { + "bbox": [ + 106, + 698, + 368, + 710 + ], + "spans": [ + { + "bbox": [ + 106, + 698, + 334, + 710 + ], + "score": 1.0, + "content": "tokens. We use 2 layer models with a model dimension of", + "type": "text" + }, + { + "bbox": [ + 335, + 698, + 364, + 708 + ], + "score": 0.9, + "content": "D { = } 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 364, + 698, + 368, + 710 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 59 + } + ], + "index": 58, + "bbox_fs": [ + 105, + 676, + 507, + 710 + ] + }, + { + "type": "text", + "bbox": [ + 104, + 713, + 475, + 725 + ], + "lines": [ + { + "bbox": [ + 105, + 713, + 477, + 726 + ], + "spans": [ + { + "bbox": [ + 105, + 713, + 477, + 726 + ], + "score": 1.0, + "content": "Models are trained for 400K steps at a constant learning rate of 0.0001 with a batch size of 64.", + "type": "text" + } + ], + "index": 60 + } + ], + "index": 60, + "bbox_fs": [ + 105, + 713, + 477, + 726 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 110, + 120, + 498, + 216 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 107, + 81, + 505, + 111 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 104, + 79, + 506, + 93 + ], + "spans": [ + { + "bbox": [ + 104, + 79, + 355, + 93 + ], + "score": 1.0, + "content": "Table 10: (Induction heads.) Models are trained on sequence length", + "type": "text" + }, + { + "bbox": [ + 356, + 80, + 389, + 91 + ], + "score": 0.91, + "content": "2 ^ { 8 } = 2 5 6", + "type": "inline_equation" + }, + { + "bbox": [ + 389, + 79, + 506, + 93 + ], + "score": 1.0, + "content": ", and tested on various sequence", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 104, + 88, + 507, + 103 + ], + "spans": [ + { + "bbox": [ + 104, + 88, + 145, + 103 + ], + "score": 1.0, + "content": "lengths of", + "type": "text" + }, + { + "bbox": [ + 146, + 90, + 177, + 100 + ], + "score": 0.69, + "content": "2 ^ { 6 } = 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 177, + 88, + 199, + 103 + ], + "score": 1.0, + "content": "up to", + "type": "text" + }, + { + "bbox": [ + 199, + 90, + 257, + 101 + ], + "score": 0.88, + "content": "2 ^ { 2 0 } = 1 0 4 8 5 7 6", + "type": "inline_equation" + }, + { + "bbox": [ + 257, + 88, + 261, + 103 + ], + "score": 1.0, + "content": ".", + "type": "text" + }, + { + "bbox": [ + 261, + 91, + 270, + 100 + ], + "score": 0.27, + "content": "\\checkmark", + "type": "inline_equation" + }, + { + "bbox": [ + 271, + 88, + 442, + 103 + ], + "score": 1.0, + "content": "denotes perfect generalization accuracy, while", + "type": "text" + }, + { + "bbox": [ + 442, + 92, + 450, + 100 + ], + "score": 0.63, + "content": "\\pmb { \\chi }", + "type": "inline_equation" + }, + { + "bbox": [ + 450, + 88, + 507, + 103 + ], + "score": 1.0, + "content": "denotes out of", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 100, + 142, + 113 + ], + "spans": [ + { + "bbox": [ + 105, + 100, + 142, + 113 + ], + "score": 1.0, + "content": "memory.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "table_body", + "bbox": [ + 110, + 120, + 498, + 216 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 110, + 120, + 498, + 216 + ], + "spans": [ + { + "bbox": [ + 110, + 120, + 498, + 216 + ], + "score": 0.98, + "html": "
ModelParamsTest Accuracy (%) at Sequence Length
26272829210211212213214 215 216 217 218 219220
MHA-Abs137K99.6100.0 58.6 26.6 18.8 9.810.97.8XX×XX×
MHA-RoPE 137K√100.0 83.6 31.318.4 8.69.05.5X×XXX
MHA-xPos137K√100.0 99.6 67.6 25.4 7.09.07.8 x×X×X
H3153K100.080.9 39.5 23.814.8 8.25.9 6.68.24.78.2 6.3 7.4
Hyena69M*97.7100.044.1 12.5 6.65.17.0 5.9 6.6 6.6 5.96.3 9.8
Mamba74K100.0√√√√√√
", + "type": "table", + "image_path": "3e5ab4e41e9cbdd9618b51c8e245e3618367993a0d541f8e2027c9f9a4a51469.jpg" + } + ] + } + ], + "index": 4, + "virtual_lines": [ + { + "bbox": [ + 110, + 120, + 498, + 152.0 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 110, + 152.0, + 498, + 184.0 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 110, + 184.0, + 498, + 216.0 + ], + "spans": [], + "index": 5 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 113, + 216, + 337, + 226 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 112, + 213, + 338, + 228 + ], + "spans": [ + { + "bbox": [ + 112, + 213, + 338, + 228 + ], + "score": 1.0, + "content": "∗ Most of the parameters are in learnable positional encodings.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + } + ], + "index": 4 + }, + { + "type": "table", + "bbox": [ + 117, + 266, + 492, + 328 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 107, + 236, + 504, + 257 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 236, + 505, + 248 + ], + "spans": [ + { + "bbox": [ + 105, + 236, + 505, + 248 + ], + "score": 1.0, + "content": "Table 11: (Scaling Law Model Sizes.) Our model sizes and hyperparameters for scaling experiments. (Model", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 246, + 354, + 257 + ], + "spans": [ + { + "bbox": [ + 106, + 246, + 354, + 257 + ], + "score": 1.0, + "content": "dimension and number of heads applies only to Transformer models.)", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5 + }, + { + "type": "table_body", + "bbox": [ + 117, + 266, + 492, + 328 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 117, + 266, + 492, + 328 + ], + "spans": [ + { + "bbox": [ + 117, + 266, + 492, + 328 + ], + "score": 0.98, + "html": "
Params n_layers dmodel n_heads /d_head Training steps Learning Rate Batch SizeTokens
125M1276812/6448006e-40.5M tokens2.5B
350M24102416/64135003e-40.5Mtokens7B
760M24153616/96290002.5e-40.5Mtokens15B
1.3B24204832/64500002e-40.5Mtokens26B
", + "type": "table", + "image_path": "759d3e6e46218a9cf9203fbfcef0527c9a99037c9441814bfe77e2c513c54f42.jpg" + } + ] + } + ], + "index": 10, + "virtual_lines": [ + { + "bbox": [ + 117, + 266, + 492, + 286.6666666666667 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 117, + 286.6666666666667, + 492, + 307.33333333333337 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 117, + 307.33333333333337, + 492, + 328.00000000000006 + ], + "spans": [], + "index": 11 + } + ] + } + ], + "index": 8.75 + }, + { + "type": "text", + "bbox": [ + 106, + 341, + 505, + 417 + ], + "lines": [ + { + "bbox": [ + 105, + 341, + 506, + 354 + ], + "spans": [ + { + "bbox": [ + 105, + 341, + 506, + 354 + ], + "score": 1.0, + "content": "Induction Heads Training consists of randomly generating data every step, with a batch size of", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 352, + 505, + 365 + ], + "spans": [ + { + "bbox": [ + 106, + 352, + 505, + 365 + ], + "score": 1.0, + "content": "8. We choose an “epoch” size of 8192 steps, and track the accuracy on fixed validation sets (also", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 362, + 505, + 375 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 505, + 375 + ], + "score": 1.0, + "content": "randomly generated) of each target sequence length. For the MHA-Abs and Mamba models, results", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 373, + 505, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 373, + 242, + 385 + ], + "score": 1.0, + "content": "are reported after the 25th epoch", + "type": "text" + }, + { + "bbox": [ + 242, + 374, + 325, + 384 + ], + "score": 0.9, + "content": "\\mathrm { 8 1 9 2 \\times 2 5 = 2 0 4 8 0 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 325, + 373, + 505, + 385 + ], + "score": 1.0, + "content": "steps). For the MHA-RoPE and MHA-xPos", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 384, + 504, + 396 + ], + "spans": [ + { + "bbox": [ + 106, + 385, + 307, + 396 + ], + "score": 1.0, + "content": "models, results are reported after the 50th epoch", + "type": "text" + }, + { + "bbox": [ + 307, + 384, + 393, + 395 + ], + "score": 0.9, + "content": "( 8 1 9 2 \\times 5 0 = 4 0 9 6 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 393, + 385, + 504, + 396 + ], + "score": 1.0, + "content": "steps). For the LTI H3 and", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 395, + 505, + 407 + ], + "spans": [ + { + "bbox": [ + 106, + 395, + 505, + 407 + ], + "score": 1.0, + "content": "Hyena models, results are reported after the 10th epoch (81920 steps) because they had converged", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 406, + 255, + 417 + ], + "spans": [ + { + "bbox": [ + 106, + 406, + 255, + 417 + ], + "score": 1.0, + "content": "by then and failed to improve further.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 107, + 421, + 505, + 476 + ], + "lines": [ + { + "bbox": [ + 105, + 420, + 506, + 434 + ], + "spans": [ + { + "bbox": [ + 105, + 420, + 506, + 434 + ], + "score": 1.0, + "content": "We use the Adam optimizer with no weight decay. All models are trained at constant learning rates", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 431, + 505, + 445 + ], + "spans": [ + { + "bbox": [ + 106, + 432, + 133, + 443 + ], + "score": 0.8, + "content": "2 e - 4", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 431, + 151, + 445 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 152, + 433, + 178, + 443 + ], + "score": 0.81, + "content": "1 e - 3", + "type": "inline_equation" + }, + { + "bbox": [ + 179, + 431, + 388, + 445 + ], + "score": 1.0, + "content": ", and the better results are reported for each model", + "type": "text" + }, + { + "bbox": [ + 388, + 433, + 416, + 443 + ], + "score": 0.81, + "content": "2 e - 4", + "type": "inline_equation" + }, + { + "bbox": [ + 416, + 431, + 505, + 445 + ], + "score": 1.0, + "content": "for all models except", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 443, + 505, + 455 + ], + "spans": [ + { + "bbox": [ + 105, + 443, + 360, + 455 + ], + "score": 1.0, + "content": "Mamba). The attention and Hyena models did not learn at LR", + "type": "text" + }, + { + "bbox": [ + 360, + 443, + 385, + 453 + ], + "score": 0.8, + "content": "1 e - 3", + "type": "inline_equation" + }, + { + "bbox": [ + 386, + 443, + 505, + 455 + ], + "score": 1.0, + "content": ". H3 learned at both LRs, but", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 453, + 506, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 400, + 466 + ], + "score": 1.0, + "content": "interestingly generalized better to shorter sequences at the smaller LR of", + "type": "text" + }, + { + "bbox": [ + 400, + 454, + 425, + 464 + ], + "score": 0.85, + "content": "2 e - 4", + "type": "inline_equation" + }, + { + "bbox": [ + 426, + 453, + 506, + 466 + ], + "score": 1.0, + "content": ". Mamba learned at", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 464, + 340, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 464, + 311, + 477 + ], + "score": 1.0, + "content": "both LRs, but extrapolated better at the larger LR of", + "type": "text" + }, + { + "bbox": [ + 312, + 465, + 335, + 475 + ], + "score": 0.8, + "content": "1 e - 3", + "type": "inline_equation" + }, + { + "bbox": [ + 336, + 464, + 340, + 477 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 21 + }, + { + "type": "title", + "bbox": [ + 108, + 484, + 231, + 495 + ], + "lines": [ + { + "bbox": [ + 105, + 484, + 231, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 484, + 231, + 497 + ], + "score": 1.0, + "content": "F.2 LANGUAGE MODELING", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 107, + 500, + 241, + 511 + ], + "lines": [ + { + "bbox": [ + 105, + 498, + 242, + 513 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 242, + 513 + ], + "score": 1.0, + "content": "F.2.1 SCALING LAW DETAILS", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 108, + 519, + 248, + 531 + ], + "lines": [ + { + "bbox": [ + 106, + 519, + 249, + 532 + ], + "spans": [ + { + "bbox": [ + 106, + 519, + 249, + 532 + ], + "score": 1.0, + "content": "All models were trained on the Pile.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 106, + 540, + 505, + 605 + ], + "lines": [ + { + "bbox": [ + 105, + 539, + 505, + 552 + ], + "spans": [ + { + "bbox": [ + 105, + 539, + 505, + 552 + ], + "score": 1.0, + "content": "Model sizes. Table 11 specifies the model sizes we use for scaling laws. This is taken directly", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 549, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 549, + 505, + 563 + ], + "score": 1.0, + "content": "from the GPT3 specifications (Brown et al., 2020), with very minor modifications. First, we changed", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 560, + 505, + 574 + ], + "spans": [ + { + "bbox": [ + 105, + 560, + 326, + 574 + ], + "score": 1.0, + "content": "the batch size of the 1.3B model from 1M tokens to", + "type": "text" + }, + { + "bbox": [ + 326, + 561, + 350, + 572 + ], + "score": 0.29, + "content": "0 . 5 \\mathbf { M }", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 560, + 505, + 574 + ], + "score": 1.0, + "content": "tokens, since we did not use enough", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 572, + 506, + 585 + ], + "spans": [ + { + "bbox": [ + 105, + 572, + 506, + 585 + ], + "score": 1.0, + "content": "parallelization to require the larger batch size. Second, we changed the number of training steps and", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 583, + 506, + 595 + ], + "spans": [ + { + "bbox": [ + 105, + 583, + 506, + 595 + ], + "score": 1.0, + "content": "total tokens to roughly match Chinchilla scaling laws (Hoffmann et al., 2022), which specify that", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 594, + 347, + 606 + ], + "spans": [ + { + "bbox": [ + 106, + 594, + 347, + 606 + ], + "score": 1.0, + "content": "training tokens should increase proportionally to model size.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 29.5 + }, + { + "type": "text", + "bbox": [ + 107, + 613, + 363, + 625 + ], + "lines": [ + { + "bbox": [ + 105, + 612, + 364, + 627 + ], + "spans": [ + { + "bbox": [ + 105, + 612, + 364, + 627 + ], + "score": 1.0, + "content": "Training recipes. All models used the AdamW optimizer with", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 33 + }, + { + "type": "text", + "bbox": [ + 134, + 632, + 326, + 687 + ], + "lines": [ + { + "bbox": [ + 132, + 632, + 232, + 644 + ], + "spans": [ + { + "bbox": [ + 132, + 632, + 232, + 644 + ], + "score": 1.0, + "content": "• gradient clip value 1.0", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 133, + 646, + 211, + 659 + ], + "spans": [ + { + "bbox": [ + 133, + 646, + 211, + 659 + ], + "score": 1.0, + "content": "• weight decay 0.1", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 133, + 660, + 189, + 674 + ], + "spans": [ + { + "bbox": [ + 133, + 660, + 189, + 674 + ], + "score": 1.0, + "content": "• no dropout", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 133, + 674, + 326, + 689 + ], + "spans": [ + { + "bbox": [ + 133, + 674, + 326, + 689 + ], + "score": 1.0, + "content": "• linear learning rate warmup with cosine decay", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 35.5 + }, + { + "type": "text", + "bbox": [ + 107, + 694, + 342, + 705 + ], + "lines": [ + { + "bbox": [ + 106, + 693, + 343, + 708 + ], + "spans": [ + { + "bbox": [ + 106, + 693, + 343, + 708 + ], + "score": 1.0, + "content": "By default, the peak learning rate is the GPT3 specification.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 38 + }, + { + "type": "text", + "bbox": [ + 105, + 710, + 506, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "score": 1.0, + "content": "We give several models an “improved recipe”, inspired by changes adopted by popular large language", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 720, + 494, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 494, + 732 + ], + "score": 1.0, + "content": "models such as PaLM (Chowdhery et al., 2022) and LLaMa (Touvron et al., 2023). These include:", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39.5 + } + ], + "page_idx": 21, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 304, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 305, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 305, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "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": "22", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 110, + 120, + 498, + 216 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 107, + 81, + 505, + 111 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 104, + 79, + 506, + 93 + ], + "spans": [ + { + "bbox": [ + 104, + 79, + 355, + 93 + ], + "score": 1.0, + "content": "Table 10: (Induction heads.) Models are trained on sequence length", + "type": "text" + }, + { + "bbox": [ + 356, + 80, + 389, + 91 + ], + "score": 0.91, + "content": "2 ^ { 8 } = 2 5 6", + "type": "inline_equation" + }, + { + "bbox": [ + 389, + 79, + 506, + 93 + ], + "score": 1.0, + "content": ", and tested on various sequence", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 104, + 88, + 507, + 103 + ], + "spans": [ + { + "bbox": [ + 104, + 88, + 145, + 103 + ], + "score": 1.0, + "content": "lengths of", + "type": "text" + }, + { + "bbox": [ + 146, + 90, + 177, + 100 + ], + "score": 0.69, + "content": "2 ^ { 6 } = 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 177, + 88, + 199, + 103 + ], + "score": 1.0, + "content": "up to", + "type": "text" + }, + { + "bbox": [ + 199, + 90, + 257, + 101 + ], + "score": 0.88, + "content": "2 ^ { 2 0 } = 1 0 4 8 5 7 6", + "type": "inline_equation" + }, + { + "bbox": [ + 257, + 88, + 261, + 103 + ], + "score": 1.0, + "content": ".", + "type": "text" + }, + { + "bbox": [ + 261, + 91, + 270, + 100 + ], + "score": 0.27, + "content": "\\checkmark", + "type": "inline_equation" + }, + { + "bbox": [ + 271, + 88, + 442, + 103 + ], + "score": 1.0, + "content": "denotes perfect generalization accuracy, while", + "type": "text" + }, + { + "bbox": [ + 442, + 92, + 450, + 100 + ], + "score": 0.63, + "content": "\\pmb { \\chi }", + "type": "inline_equation" + }, + { + "bbox": [ + 450, + 88, + 507, + 103 + ], + "score": 1.0, + "content": "denotes out of", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 100, + 142, + 113 + ], + "spans": [ + { + "bbox": [ + 105, + 100, + 142, + 113 + ], + "score": 1.0, + "content": "memory.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "table_body", + "bbox": [ + 110, + 120, + 498, + 216 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 110, + 120, + 498, + 216 + ], + "spans": [ + { + "bbox": [ + 110, + 120, + 498, + 216 + ], + "score": 0.98, + "html": "
ModelParamsTest Accuracy (%) at Sequence Length
26272829210211212213214 215 216 217 218 219220
MHA-Abs137K99.6100.0 58.6 26.6 18.8 9.810.97.8XX×XX×
MHA-RoPE 137K√100.0 83.6 31.318.4 8.69.05.5X×XXX
MHA-xPos137K√100.0 99.6 67.6 25.4 7.09.07.8 x×X×X
H3153K100.080.9 39.5 23.814.8 8.25.9 6.68.24.78.2 6.3 7.4
Hyena69M*97.7100.044.1 12.5 6.65.17.0 5.9 6.6 6.6 5.96.3 9.8
Mamba74K100.0√√√√√√
", + "type": "table", + "image_path": "3e5ab4e41e9cbdd9618b51c8e245e3618367993a0d541f8e2027c9f9a4a51469.jpg" + } + ] + } + ], + "index": 4, + "virtual_lines": [ + { + "bbox": [ + 110, + 120, + 498, + 152.0 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 110, + 152.0, + 498, + 184.0 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 110, + 184.0, + 498, + 216.0 + ], + "spans": [], + "index": 5 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 113, + 216, + 337, + 226 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 112, + 213, + 338, + 228 + ], + "spans": [ + { + "bbox": [ + 112, + 213, + 338, + 228 + ], + "score": 1.0, + "content": "∗ Most of the parameters are in learnable positional encodings.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + } + ], + "index": 4 + }, + { + "type": "table", + "bbox": [ + 117, + 266, + 492, + 328 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 107, + 236, + 504, + 257 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 236, + 505, + 248 + ], + "spans": [ + { + "bbox": [ + 105, + 236, + 505, + 248 + ], + "score": 1.0, + "content": "Table 11: (Scaling Law Model Sizes.) Our model sizes and hyperparameters for scaling experiments. (Model", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 246, + 354, + 257 + ], + "spans": [ + { + "bbox": [ + 106, + 246, + 354, + 257 + ], + "score": 1.0, + "content": "dimension and number of heads applies only to Transformer models.)", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5 + }, + { + "type": "table_body", + "bbox": [ + 117, + 266, + 492, + 328 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 117, + 266, + 492, + 328 + ], + "spans": [ + { + "bbox": [ + 117, + 266, + 492, + 328 + ], + "score": 0.98, + "html": "
Params n_layers dmodel n_heads /d_head Training steps Learning Rate Batch SizeTokens
125M1276812/6448006e-40.5M tokens2.5B
350M24102416/64135003e-40.5Mtokens7B
760M24153616/96290002.5e-40.5Mtokens15B
1.3B24204832/64500002e-40.5Mtokens26B
", + "type": "table", + "image_path": "759d3e6e46218a9cf9203fbfcef0527c9a99037c9441814bfe77e2c513c54f42.jpg" + } + ] + } + ], + "index": 10, + "virtual_lines": [ + { + "bbox": [ + 117, + 266, + 492, + 286.6666666666667 + ], + "spans": [], + "index": 9 + }, + { + "bbox": [ + 117, + 286.6666666666667, + 492, + 307.33333333333337 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 117, + 307.33333333333337, + 492, + 328.00000000000006 + ], + "spans": [], + "index": 11 + } + ] + } + ], + "index": 8.75 + }, + { + "type": "text", + "bbox": [ + 106, + 341, + 505, + 417 + ], + "lines": [ + { + "bbox": [ + 105, + 341, + 506, + 354 + ], + "spans": [ + { + "bbox": [ + 105, + 341, + 506, + 354 + ], + "score": 1.0, + "content": "Induction Heads Training consists of randomly generating data every step, with a batch size of", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 352, + 505, + 365 + ], + "spans": [ + { + "bbox": [ + 106, + 352, + 505, + 365 + ], + "score": 1.0, + "content": "8. We choose an “epoch” size of 8192 steps, and track the accuracy on fixed validation sets (also", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 362, + 505, + 375 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 505, + 375 + ], + "score": 1.0, + "content": "randomly generated) of each target sequence length. For the MHA-Abs and Mamba models, results", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 373, + 505, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 373, + 242, + 385 + ], + "score": 1.0, + "content": "are reported after the 25th epoch", + "type": "text" + }, + { + "bbox": [ + 242, + 374, + 325, + 384 + ], + "score": 0.9, + "content": "\\mathrm { 8 1 9 2 \\times 2 5 = 2 0 4 8 0 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 325, + 373, + 505, + 385 + ], + "score": 1.0, + "content": "steps). For the MHA-RoPE and MHA-xPos", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 384, + 504, + 396 + ], + "spans": [ + { + "bbox": [ + 106, + 385, + 307, + 396 + ], + "score": 1.0, + "content": "models, results are reported after the 50th epoch", + "type": "text" + }, + { + "bbox": [ + 307, + 384, + 393, + 395 + ], + "score": 0.9, + "content": "( 8 1 9 2 \\times 5 0 = 4 0 9 6 0 0", + "type": "inline_equation" + }, + { + "bbox": [ + 393, + 385, + 504, + 396 + ], + "score": 1.0, + "content": "steps). For the LTI H3 and", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 395, + 505, + 407 + ], + "spans": [ + { + "bbox": [ + 106, + 395, + 505, + 407 + ], + "score": 1.0, + "content": "Hyena models, results are reported after the 10th epoch (81920 steps) because they had converged", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 406, + 255, + 417 + ], + "spans": [ + { + "bbox": [ + 106, + 406, + 255, + 417 + ], + "score": 1.0, + "content": "by then and failed to improve further.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 15, + "bbox_fs": [ + 105, + 341, + 506, + 417 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 421, + 505, + 476 + ], + "lines": [ + { + "bbox": [ + 105, + 420, + 506, + 434 + ], + "spans": [ + { + "bbox": [ + 105, + 420, + 506, + 434 + ], + "score": 1.0, + "content": "We use the Adam optimizer with no weight decay. All models are trained at constant learning rates", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 431, + 505, + 445 + ], + "spans": [ + { + "bbox": [ + 106, + 432, + 133, + 443 + ], + "score": 0.8, + "content": "2 e - 4", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 431, + 151, + 445 + ], + "score": 1.0, + "content": "and", + "type": "text" + }, + { + "bbox": [ + 152, + 433, + 178, + 443 + ], + "score": 0.81, + "content": "1 e - 3", + "type": "inline_equation" + }, + { + "bbox": [ + 179, + 431, + 388, + 445 + ], + "score": 1.0, + "content": ", and the better results are reported for each model", + "type": "text" + }, + { + "bbox": [ + 388, + 433, + 416, + 443 + ], + "score": 0.81, + "content": "2 e - 4", + "type": "inline_equation" + }, + { + "bbox": [ + 416, + 431, + 505, + 445 + ], + "score": 1.0, + "content": "for all models except", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 443, + 505, + 455 + ], + "spans": [ + { + "bbox": [ + 105, + 443, + 360, + 455 + ], + "score": 1.0, + "content": "Mamba). The attention and Hyena models did not learn at LR", + "type": "text" + }, + { + "bbox": [ + 360, + 443, + 385, + 453 + ], + "score": 0.8, + "content": "1 e - 3", + "type": "inline_equation" + }, + { + "bbox": [ + 386, + 443, + 505, + 455 + ], + "score": 1.0, + "content": ". H3 learned at both LRs, but", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 453, + 506, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 400, + 466 + ], + "score": 1.0, + "content": "interestingly generalized better to shorter sequences at the smaller LR of", + "type": "text" + }, + { + "bbox": [ + 400, + 454, + 425, + 464 + ], + "score": 0.85, + "content": "2 e - 4", + "type": "inline_equation" + }, + { + "bbox": [ + 426, + 453, + 506, + 466 + ], + "score": 1.0, + "content": ". Mamba learned at", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 464, + 340, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 464, + 311, + 477 + ], + "score": 1.0, + "content": "both LRs, but extrapolated better at the larger LR of", + "type": "text" + }, + { + "bbox": [ + 312, + 465, + 335, + 475 + ], + "score": 0.8, + "content": "1 e - 3", + "type": "inline_equation" + }, + { + "bbox": [ + 336, + 464, + 340, + 477 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 21, + "bbox_fs": [ + 105, + 420, + 506, + 477 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 484, + 231, + 495 + ], + "lines": [ + { + "bbox": [ + 105, + 484, + 231, + 497 + ], + "spans": [ + { + "bbox": [ + 105, + 484, + 231, + 497 + ], + "score": 1.0, + "content": "F.2 LANGUAGE MODELING", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 107, + 500, + 241, + 511 + ], + "lines": [ + { + "bbox": [ + 105, + 498, + 242, + 513 + ], + "spans": [ + { + "bbox": [ + 105, + 498, + 242, + 513 + ], + "score": 1.0, + "content": "F.2.1 SCALING LAW DETAILS", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25, + "bbox_fs": [ + 105, + 498, + 242, + 513 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 519, + 248, + 531 + ], + "lines": [ + { + "bbox": [ + 106, + 519, + 249, + 532 + ], + "spans": [ + { + "bbox": [ + 106, + 519, + 249, + 532 + ], + "score": 1.0, + "content": "All models were trained on the Pile.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26, + "bbox_fs": [ + 106, + 519, + 249, + 532 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 540, + 505, + 605 + ], + "lines": [ + { + "bbox": [ + 105, + 539, + 505, + 552 + ], + "spans": [ + { + "bbox": [ + 105, + 539, + 505, + 552 + ], + "score": 1.0, + "content": "Model sizes. Table 11 specifies the model sizes we use for scaling laws. This is taken directly", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 549, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 549, + 505, + 563 + ], + "score": 1.0, + "content": "from the GPT3 specifications (Brown et al., 2020), with very minor modifications. First, we changed", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 560, + 505, + 574 + ], + "spans": [ + { + "bbox": [ + 105, + 560, + 326, + 574 + ], + "score": 1.0, + "content": "the batch size of the 1.3B model from 1M tokens to", + "type": "text" + }, + { + "bbox": [ + 326, + 561, + 350, + 572 + ], + "score": 0.29, + "content": "0 . 5 \\mathbf { M }", + "type": "inline_equation" + }, + { + "bbox": [ + 351, + 560, + 505, + 574 + ], + "score": 1.0, + "content": "tokens, since we did not use enough", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 572, + 506, + 585 + ], + "spans": [ + { + "bbox": [ + 105, + 572, + 506, + 585 + ], + "score": 1.0, + "content": "parallelization to require the larger batch size. Second, we changed the number of training steps and", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 583, + 506, + 595 + ], + "spans": [ + { + "bbox": [ + 105, + 583, + 506, + 595 + ], + "score": 1.0, + "content": "total tokens to roughly match Chinchilla scaling laws (Hoffmann et al., 2022), which specify that", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 594, + 347, + 606 + ], + "spans": [ + { + "bbox": [ + 106, + 594, + 347, + 606 + ], + "score": 1.0, + "content": "training tokens should increase proportionally to model size.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 29.5, + "bbox_fs": [ + 105, + 539, + 506, + 606 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 613, + 363, + 625 + ], + "lines": [ + { + "bbox": [ + 105, + 612, + 364, + 627 + ], + "spans": [ + { + "bbox": [ + 105, + 612, + 364, + 627 + ], + "score": 1.0, + "content": "Training recipes. All models used the AdamW optimizer with", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 33, + "bbox_fs": [ + 105, + 612, + 364, + 627 + ] + }, + { + "type": "list", + "bbox": [ + 134, + 632, + 326, + 687 + ], + "lines": [ + { + "bbox": [ + 132, + 632, + 232, + 644 + ], + "spans": [ + { + "bbox": [ + 132, + 632, + 232, + 644 + ], + "score": 1.0, + "content": "• gradient clip value 1.0", + "type": "text" + } + ], + "index": 34, + "is_list_start_line": true + }, + { + "bbox": [ + 133, + 646, + 211, + 659 + ], + "spans": [ + { + "bbox": [ + 133, + 646, + 211, + 659 + ], + "score": 1.0, + "content": "• weight decay 0.1", + "type": "text" + } + ], + "index": 35, + "is_list_start_line": true + }, + { + "bbox": [ + 133, + 660, + 189, + 674 + ], + "spans": [ + { + "bbox": [ + 133, + 660, + 189, + 674 + ], + "score": 1.0, + "content": "• no dropout", + "type": "text" + } + ], + "index": 36, + "is_list_start_line": true + }, + { + "bbox": [ + 133, + 674, + 326, + 689 + ], + "spans": [ + { + "bbox": [ + 133, + 674, + 326, + 689 + ], + "score": 1.0, + "content": "• linear learning rate warmup with cosine decay", + "type": "text" + } + ], + "index": 37, + "is_list_start_line": true + } + ], + "index": 35.5, + "bbox_fs": [ + 132, + 632, + 326, + 689 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 694, + 342, + 705 + ], + "lines": [ + { + "bbox": [ + 106, + 693, + 343, + 708 + ], + "spans": [ + { + "bbox": [ + 106, + 693, + 343, + 708 + ], + "score": 1.0, + "content": "By default, the peak learning rate is the GPT3 specification.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 38, + "bbox_fs": [ + 106, + 693, + 343, + 708 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 710, + 506, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 708, + 505, + 723 + ], + "score": 1.0, + "content": "We give several models an “improved recipe”, inspired by changes adopted by popular large language", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 720, + 494, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 494, + 732 + ], + "score": 1.0, + "content": "models such as PaLM (Chowdhery et al., 2022) and LLaMa (Touvron et al., 2023). These include:", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39.5, + "bbox_fs": [ + 105, + 708, + 505, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 133, + 82, + 505, + 162 + ], + "lines": [ + { + "bbox": [ + 132, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 132, + 82, + 339, + 95 + ], + "score": 1.0, + "content": "• linear learning rate warmup with cosine decay to", + "type": "text" + }, + { + "bbox": [ + 339, + 83, + 363, + 93 + ], + "score": 0.72, + "content": "1 e - 5", + "type": "inline_equation" + }, + { + "bbox": [ + 364, + 82, + 449, + 95 + ], + "score": 1.0, + "content": ", with a peak value of", + "type": "text" + }, + { + "bbox": [ + 449, + 83, + 463, + 93 + ], + "score": 0.85, + "content": "5 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 464, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "the GPT3", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 141, + 93, + 167, + 105 + ], + "spans": [ + { + "bbox": [ + 141, + 93, + 167, + 105 + ], + "score": 1.0, + "content": "value", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 133, + 109, + 222, + 120 + ], + "spans": [ + { + "bbox": [ + 133, + 109, + 222, + 120 + ], + "score": 1.0, + "content": "• no linear bias terms", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 132, + 122, + 279, + 136 + ], + "spans": [ + { + "bbox": [ + 132, + 122, + 279, + 136 + ], + "score": 1.0, + "content": "• RMSNorm instead of LayerNorm", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 132, + 137, + 506, + 152 + ], + "spans": [ + { + "bbox": [ + 132, + 137, + 245, + 152 + ], + "score": 1.0, + "content": "• AdamW hyperparameter", + "type": "text" + }, + { + "bbox": [ + 245, + 139, + 295, + 151 + ], + "score": 0.89, + "content": "\\beta = ( . 9 , . 9 5 )", + "type": "inline_equation" + }, + { + "bbox": [ + 296, + 137, + 506, + 152 + ], + "score": 1.0, + "content": "(the GPT3 value) instead of the PyTorch default of", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 142, + 150, + 195, + 162 + ], + "spans": [ + { + "bbox": [ + 142, + 150, + 195, + 162 + ], + "score": 0.85, + "content": "\\beta = ( . 9 , . 9 9 9 )", + "type": "inline_equation" + } + ], + "index": 5 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 106, + 170, + 322, + 181 + ], + "lines": [ + { + "bbox": [ + 106, + 168, + 322, + 183 + ], + "spans": [ + { + "bbox": [ + 106, + 168, + 322, + 183 + ], + "score": 1.0, + "content": "Architecture and training details. Our models are:", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 105, + 189, + 506, + 355 + ], + "lines": [ + { + "bbox": [ + 105, + 189, + 387, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 189, + 387, + 201 + ], + "score": 1.0, + "content": "• Transformer: The standard Transformer based on GPT3 (Table 11).", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 201, + 505, + 216 + ], + "spans": [ + { + "bbox": [ + 105, + 201, + 169, + 216 + ], + "score": 1.0, + "content": "• Transformer", + "type": "text" + }, + { + "bbox": [ + 169, + 204, + 181, + 213 + ], + "score": 0.65, + "content": "^ { + + }", + "type": "inline_equation" + }, + { + "bbox": [ + 181, + 201, + 505, + 216 + ], + "score": 1.0, + "content": ": A Transformer with an improved architecture, namely rotary positional encodings", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 113, + 213, + 480, + 226 + ], + "spans": [ + { + "bbox": [ + 113, + 213, + 480, + 226 + ], + "score": 1.0, + "content": "(Su et al., 2021) and SwiGLU MLP (Shazeer, 2020), and the improved training recipe above.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 226, + 505, + 239 + ], + "spans": [ + { + "bbox": [ + 106, + 226, + 505, + 239 + ], + "score": 1.0, + "content": "• Hyena: Interleaving a Hyena block (the H3 block with S4 replaced by a global convolution param-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 114, + 237, + 505, + 250 + ], + "spans": [ + { + "bbox": [ + 114, + 237, + 505, + 250 + ], + "score": 1.0, + "content": "eterized by an MLP) with standard MLP blocks. The MLP blocks have expansion factor 2 instead", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 113, + 248, + 495, + 261 + ], + "spans": [ + { + "bbox": [ + 113, + 248, + 358, + 261 + ], + "score": 1.0, + "content": "of 4 and the number of layers is correspondingly increased by", + "type": "text" + }, + { + "bbox": [ + 358, + 248, + 380, + 259 + ], + "score": 0.86, + "content": "1 . 5 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 380, + 248, + 495, + 261 + ], + "score": 1.0, + "content": "to preserve parameter count.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 260, + 506, + 273 + ], + "spans": [ + { + "bbox": [ + 106, + 260, + 114, + 273 + ], + "score": 1.0, + "content": "•", + "type": "text" + }, + { + "bbox": [ + 114, + 261, + 141, + 272 + ], + "score": 0.85, + "content": "\\mathbf { H } 3 { + } +", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 260, + 506, + 273 + ], + "score": 1.0, + "content": ": The H3 architecture with a few modifications, including (i) using the same “thin” Hyena", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 113, + 272, + 507, + 284 + ], + "spans": [ + { + "bbox": [ + 113, + 272, + 507, + 284 + ], + "score": 1.0, + "content": "dimensions above (ii) the improved training recipe above (iii) a linear attention head dimension of 8.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 107, + 284, + 505, + 297 + ], + "spans": [ + { + "bbox": [ + 107, + 284, + 505, + 297 + ], + "score": 1.0, + "content": "• RWKV: The default RWKV model from Peng et al. (2023), including its modified MLP block. We", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 113, + 296, + 505, + 308 + ], + "spans": [ + { + "bbox": [ + 113, + 296, + 505, + 308 + ], + "score": 1.0, + "content": "also used as much of its specified training recipe as possible, such as increasing the learning rates", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 114, + 307, + 257, + 318 + ], + "spans": [ + { + "bbox": [ + 114, + 307, + 127, + 318 + ], + "score": 1.0, + "content": "by", + "type": "text" + }, + { + "bbox": [ + 127, + 307, + 141, + 317 + ], + "score": 0.86, + "content": "2 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 307, + 151, + 318 + ], + "score": 1.0, + "content": "or", + "type": "text" + }, + { + "bbox": [ + 152, + 307, + 166, + 317 + ], + "score": 0.87, + "content": "3 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 167, + 307, + 257, + 318 + ], + "score": 1.0, + "content": "on certain parameters.", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 318, + 505, + 332 + ], + "spans": [ + { + "bbox": [ + 106, + 318, + 505, + 332 + ], + "score": 1.0, + "content": "• RetNet: The default RetNet model from Sun et al. (2023). We also gave it the improved training", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 113, + 330, + 170, + 342 + ], + "spans": [ + { + "bbox": [ + 113, + 330, + 170, + 342 + ], + "score": 1.0, + "content": "recipe above.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 341, + 426, + 356 + ], + "spans": [ + { + "bbox": [ + 105, + 341, + 426, + 356 + ], + "score": 1.0, + "content": "• Mamba: The standard Mamba architecture, with the improved training recipe.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 13.5 + }, + { + "type": "title", + "bbox": [ + 106, + 363, + 301, + 374 + ], + "lines": [ + { + "bbox": [ + 105, + 362, + 301, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 301, + 376 + ], + "score": 1.0, + "content": "F.2.2 DOWNSTREAM EVALUATION DETAILS", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 383, + 505, + 427 + ], + "lines": [ + { + "bbox": [ + 105, + 383, + 506, + 396 + ], + "spans": [ + { + "bbox": [ + 105, + 383, + 506, + 396 + ], + "score": 1.0, + "content": "This pretraining procedure is the same as the scaling law protocol, but extended to 300B tokens. For", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 394, + 505, + 406 + ], + "spans": [ + { + "bbox": [ + 106, + 394, + 505, + 406 + ], + "score": 1.0, + "content": "the 1.3B model, we use a batch size of 1M tokens to be consistent with the GPT3 specifications. We", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 405, + 506, + 417 + ], + "spans": [ + { + "bbox": [ + 105, + 405, + 506, + 417 + ], + "score": 1.0, + "content": "report the perplexity on the Pile validation set, and for this metric only compare to models trained", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 416, + 426, + 427 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 426, + 427 + ], + "score": 1.0, + "content": "on the same dataset and with the same tokenizer, in particular Pythia and RWKV.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23.5 + }, + { + "type": "text", + "bbox": [ + 107, + 431, + 505, + 464 + ], + "lines": [ + { + "bbox": [ + 105, + 430, + 507, + 444 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 507, + 444 + ], + "score": 1.0, + "content": "For downstream evaluation, we use the LM evaluation harness from EleutherAI (Gao et al., 2021),", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 442, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 106, + 442, + 505, + 453 + ], + "score": 1.0, + "content": "as done by most work in this area. We evaluate on the following tasks/datasets that measure common", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 453, + 174, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 174, + 466 + ], + "score": 1.0, + "content": "sense reasoning:", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 133, + 472, + 323, + 560 + ], + "lines": [ + { + "bbox": [ + 134, + 472, + 282, + 485 + ], + "spans": [ + { + "bbox": [ + 134, + 472, + 282, + 485 + ], + "score": 1.0, + "content": "• LAMBADA (Paperno et al., 2016).", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 133, + 487, + 277, + 500 + ], + "spans": [ + { + "bbox": [ + 133, + 487, + 277, + 500 + ], + "score": 1.0, + "content": "• HellaSwag (Paperno et al., 2016).", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 133, + 502, + 242, + 515 + ], + "spans": [ + { + "bbox": [ + 133, + 502, + 242, + 515 + ], + "score": 1.0, + "content": "• PIQA (Bisk et al., 2020).", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 133, + 516, + 324, + 531 + ], + "spans": [ + { + "bbox": [ + 133, + 516, + 324, + 531 + ], + "score": 1.0, + "content": "• ARC-easy: an easy subset of ARC-challenge.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 134, + 533, + 284, + 545 + ], + "spans": [ + { + "bbox": [ + 134, + 533, + 284, + 545 + ], + "score": 1.0, + "content": "• ARC-challenge (Clark et al., 2018).", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 133, + 547, + 293, + 561 + ], + "spans": [ + { + "bbox": [ + 133, + 547, + 293, + 561 + ], + "score": 1.0, + "content": "• WinoGrande (Sakaguchi et al., 2021).", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 31.5 + }, + { + "type": "text", + "bbox": [ + 108, + 568, + 505, + 601 + ], + "lines": [ + { + "bbox": [ + 106, + 568, + 505, + 581 + ], + "spans": [ + { + "bbox": [ + 106, + 568, + 505, + 581 + ], + "score": 1.0, + "content": "We report accuracy for LAMBADA, WinoGrande, PIQA, and ARC-easy, and accuracy normalized", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 579, + 505, + 592 + ], + "spans": [ + { + "bbox": [ + 106, + 579, + 505, + 592 + ], + "score": 1.0, + "content": "by sequence length for HellaSwag and ARC-challenge (since normalized accuracy is higher for almost", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 590, + 210, + 602 + ], + "spans": [ + { + "bbox": [ + 106, + 590, + 210, + 602 + ], + "score": 1.0, + "content": "all models for these task).", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36 + }, + { + "type": "title", + "bbox": [ + 107, + 610, + 205, + 621 + ], + "lines": [ + { + "bbox": [ + 106, + 610, + 205, + 623 + ], + "spans": [ + { + "bbox": [ + 106, + 610, + 205, + 623 + ], + "score": 1.0, + "content": "F.3 DNA MODELING", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 38 + }, + { + "type": "title", + "bbox": [ + 107, + 626, + 240, + 637 + ], + "lines": [ + { + "bbox": [ + 105, + 625, + 240, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 625, + 240, + 639 + ], + "score": 1.0, + "content": "F.3.1 PRETRAINING DETAILS", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 39 + }, + { + "type": "text", + "bbox": [ + 105, + 646, + 464, + 658 + ], + "lines": [ + { + "bbox": [ + 105, + 645, + 465, + 659 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 465, + 659 + ], + "score": 1.0, + "content": "We describe the dataset and training procedure of the HG38 pretraining task in more detail.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 40 + }, + { + "type": "text", + "bbox": [ + 107, + 662, + 505, + 705 + ], + "lines": [ + { + "bbox": [ + 105, + 661, + 505, + 674 + ], + "spans": [ + { + "bbox": [ + 105, + 661, + 505, + 674 + ], + "score": 1.0, + "content": "The dataset follows the splits from the prior Enformer work on genomics (Avsec et al., 2021); the", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 671, + 506, + 685 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 228, + 685 + ], + "score": 1.0, + "content": "training split contains a total of", + "type": "text" + }, + { + "bbox": [ + 228, + 673, + 271, + 683 + ], + "score": 0.9, + "content": "S { = } 3 4 0 2 1", + "type": "inline_equation" + }, + { + "bbox": [ + 271, + 671, + 347, + 685 + ], + "score": 1.0, + "content": "segments of length", + "type": "text" + }, + { + "bbox": [ + 347, + 672, + 401, + 683 + ], + "score": 0.9, + "content": "2 ^ { 1 7 } = 1 3 1 0 7 2", + "type": "inline_equation" + }, + { + "bbox": [ + 402, + 671, + 506, + 685 + ], + "score": 1.0, + "content": "that cover the genome, for", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 684, + 505, + 696 + ], + "spans": [ + { + "bbox": [ + 105, + 684, + 505, + 696 + ], + "score": 1.0, + "content": "a total of approximately 4.5 billion tokens (DNA base pairs). These segments are pairs of (chromosome", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 694, + 504, + 706 + ], + "spans": [ + { + "bbox": [ + 106, + 694, + 504, + 706 + ], + "score": 1.0, + "content": "number, starting index, ending index), and can be extended if necessary (e.g. to get longer segments).", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 42.5 + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 384, + 723 + ], + "score": 1.0, + "content": "We deviate from HyenaDNA when the training sequence length is not", + "type": "text" + }, + { + "bbox": [ + 384, + 709, + 398, + 720 + ], + "score": 0.83, + "content": "2 ^ { 1 7 }", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 709, + 505, + 723 + ], + "score": 1.0, + "content": ". HyenaDNA always takes", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 719, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 719, + 506, + 734 + ], + "score": 1.0, + "content": "a fixed sub-segment (e.g. the beginning or middle of the prescribed segment), and thus for any training", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 45.5 + } + ], + "page_idx": 22, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 304, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 305, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 305, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 298, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 298, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 15 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "list", + "bbox": [ + 133, + 82, + 505, + 162 + ], + "lines": [ + { + "bbox": [ + 132, + 82, + 505, + 95 + ], + "spans": [ + { + "bbox": [ + 132, + 82, + 339, + 95 + ], + "score": 1.0, + "content": "• linear learning rate warmup with cosine decay to", + "type": "text" + }, + { + "bbox": [ + 339, + 83, + 363, + 93 + ], + "score": 0.72, + "content": "1 e - 5", + "type": "inline_equation" + }, + { + "bbox": [ + 364, + 82, + 449, + 95 + ], + "score": 1.0, + "content": ", with a peak value of", + "type": "text" + }, + { + "bbox": [ + 449, + 83, + 463, + 93 + ], + "score": 0.85, + "content": "5 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 464, + 82, + 505, + 95 + ], + "score": 1.0, + "content": "the GPT3", + "type": "text" + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 141, + 93, + 167, + 105 + ], + "spans": [ + { + "bbox": [ + 141, + 93, + 167, + 105 + ], + "score": 1.0, + "content": "value", + "type": "text" + } + ], + "index": 1, + "is_list_end_line": true + }, + { + "bbox": [ + 133, + 109, + 222, + 120 + ], + "spans": [ + { + "bbox": [ + 133, + 109, + 222, + 120 + ], + "score": 1.0, + "content": "• no linear bias terms", + "type": "text" + } + ], + "index": 2, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 132, + 122, + 279, + 136 + ], + "spans": [ + { + "bbox": [ + 132, + 122, + 279, + 136 + ], + "score": 1.0, + "content": "• RMSNorm instead of LayerNorm", + "type": "text" + } + ], + "index": 3, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 132, + 137, + 506, + 152 + ], + "spans": [ + { + "bbox": [ + 132, + 137, + 245, + 152 + ], + "score": 1.0, + "content": "• AdamW hyperparameter", + "type": "text" + }, + { + "bbox": [ + 245, + 139, + 295, + 151 + ], + "score": 0.89, + "content": "\\beta = ( . 9 , . 9 5 )", + "type": "inline_equation" + }, + { + "bbox": [ + 296, + 137, + 506, + 152 + ], + "score": 1.0, + "content": "(the GPT3 value) instead of the PyTorch default of", + "type": "text" + } + ], + "index": 4, + "is_list_start_line": true + }, + { + "bbox": [ + 142, + 150, + 195, + 162 + ], + "spans": [ + { + "bbox": [ + 142, + 150, + 195, + 162 + ], + "score": 0.85, + "content": "\\beta = ( . 9 , . 9 9 9 )", + "type": "inline_equation" + } + ], + "index": 5, + "is_list_end_line": true + } + ], + "index": 2.5, + "bbox_fs": [ + 132, + 82, + 506, + 162 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 170, + 322, + 181 + ], + "lines": [ + { + "bbox": [ + 106, + 168, + 322, + 183 + ], + "spans": [ + { + "bbox": [ + 106, + 168, + 322, + 183 + ], + "score": 1.0, + "content": "Architecture and training details. Our models are:", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6, + "bbox_fs": [ + 106, + 168, + 322, + 183 + ] + }, + { + "type": "list", + "bbox": [ + 105, + 189, + 506, + 355 + ], + "lines": [ + { + "bbox": [ + 105, + 189, + 387, + 201 + ], + "spans": [ + { + "bbox": [ + 105, + 189, + 387, + 201 + ], + "score": 1.0, + "content": "• Transformer: The standard Transformer based on GPT3 (Table 11).", + "type": "text" + } + ], + "index": 7, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 201, + 505, + 216 + ], + "spans": [ + { + "bbox": [ + 105, + 201, + 169, + 216 + ], + "score": 1.0, + "content": "• Transformer", + "type": "text" + }, + { + "bbox": [ + 169, + 204, + 181, + 213 + ], + "score": 0.65, + "content": "^ { + + }", + "type": "inline_equation" + }, + { + "bbox": [ + 181, + 201, + 505, + 216 + ], + "score": 1.0, + "content": ": A Transformer with an improved architecture, namely rotary positional encodings", + "type": "text" + } + ], + "index": 8, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 213, + 480, + 226 + ], + "spans": [ + { + "bbox": [ + 113, + 213, + 480, + 226 + ], + "score": 1.0, + "content": "(Su et al., 2021) and SwiGLU MLP (Shazeer, 2020), and the improved training recipe above.", + "type": "text" + } + ], + "index": 9, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 226, + 505, + 239 + ], + "spans": [ + { + "bbox": [ + 106, + 226, + 505, + 239 + ], + "score": 1.0, + "content": "• Hyena: Interleaving a Hyena block (the H3 block with S4 replaced by a global convolution param-", + "type": "text" + } + ], + "index": 10, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 237, + 505, + 250 + ], + "spans": [ + { + "bbox": [ + 114, + 237, + 505, + 250 + ], + "score": 1.0, + "content": "eterized by an MLP) with standard MLP blocks. The MLP blocks have expansion factor 2 instead", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 113, + 248, + 495, + 261 + ], + "spans": [ + { + "bbox": [ + 113, + 248, + 358, + 261 + ], + "score": 1.0, + "content": "of 4 and the number of layers is correspondingly increased by", + "type": "text" + }, + { + "bbox": [ + 358, + 248, + 380, + 259 + ], + "score": 0.86, + "content": "1 . 5 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 380, + 248, + 495, + 261 + ], + "score": 1.0, + "content": "to preserve parameter count.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 260, + 506, + 273 + ], + "spans": [ + { + "bbox": [ + 106, + 260, + 114, + 273 + ], + "score": 1.0, + "content": "•", + "type": "text" + }, + { + "bbox": [ + 114, + 261, + 141, + 272 + ], + "score": 0.85, + "content": "\\mathbf { H } 3 { + } +", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 260, + 506, + 273 + ], + "score": 1.0, + "content": ": The H3 architecture with a few modifications, including (i) using the same “thin” Hyena", + "type": "text" + } + ], + "index": 13, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 272, + 507, + 284 + ], + "spans": [ + { + "bbox": [ + 113, + 272, + 507, + 284 + ], + "score": 1.0, + "content": "dimensions above (ii) the improved training recipe above (iii) a linear attention head dimension of 8.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 107, + 284, + 505, + 297 + ], + "spans": [ + { + "bbox": [ + 107, + 284, + 505, + 297 + ], + "score": 1.0, + "content": "• RWKV: The default RWKV model from Peng et al. (2023), including its modified MLP block. We", + "type": "text" + } + ], + "index": 15, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 296, + 505, + 308 + ], + "spans": [ + { + "bbox": [ + 113, + 296, + 505, + 308 + ], + "score": 1.0, + "content": "also used as much of its specified training recipe as possible, such as increasing the learning rates", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 114, + 307, + 257, + 318 + ], + "spans": [ + { + "bbox": [ + 114, + 307, + 127, + 318 + ], + "score": 1.0, + "content": "by", + "type": "text" + }, + { + "bbox": [ + 127, + 307, + 141, + 317 + ], + "score": 0.86, + "content": "2 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 141, + 307, + 151, + 318 + ], + "score": 1.0, + "content": "or", + "type": "text" + }, + { + "bbox": [ + 152, + 307, + 166, + 317 + ], + "score": 0.87, + "content": "3 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 167, + 307, + 257, + 318 + ], + "score": 1.0, + "content": "on certain parameters.", + "type": "text" + } + ], + "index": 17, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 318, + 505, + 332 + ], + "spans": [ + { + "bbox": [ + 106, + 318, + 505, + 332 + ], + "score": 1.0, + "content": "• RetNet: The default RetNet model from Sun et al. (2023). We also gave it the improved training", + "type": "text" + } + ], + "index": 18, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 330, + 170, + 342 + ], + "spans": [ + { + "bbox": [ + 113, + 330, + 170, + 342 + ], + "score": 1.0, + "content": "recipe above.", + "type": "text" + } + ], + "index": 19, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 341, + 426, + 356 + ], + "spans": [ + { + "bbox": [ + 105, + 341, + 426, + 356 + ], + "score": 1.0, + "content": "• Mamba: The standard Mamba architecture, with the improved training recipe.", + "type": "text" + } + ], + "index": 20, + "is_list_start_line": true, + "is_list_end_line": true + } + ], + "index": 13.5, + "bbox_fs": [ + 105, + 189, + 507, + 356 + ] + }, + { + "type": "title", + "bbox": [ + 106, + 363, + 301, + 374 + ], + "lines": [ + { + "bbox": [ + 105, + 362, + 301, + 376 + ], + "spans": [ + { + "bbox": [ + 105, + 362, + 301, + 376 + ], + "score": 1.0, + "content": "F.2.2 DOWNSTREAM EVALUATION DETAILS", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 383, + 505, + 427 + ], + "lines": [ + { + "bbox": [ + 105, + 383, + 506, + 396 + ], + "spans": [ + { + "bbox": [ + 105, + 383, + 506, + 396 + ], + "score": 1.0, + "content": "This pretraining procedure is the same as the scaling law protocol, but extended to 300B tokens. For", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 394, + 505, + 406 + ], + "spans": [ + { + "bbox": [ + 106, + 394, + 505, + 406 + ], + "score": 1.0, + "content": "the 1.3B model, we use a batch size of 1M tokens to be consistent with the GPT3 specifications. We", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 405, + 506, + 417 + ], + "spans": [ + { + "bbox": [ + 105, + 405, + 506, + 417 + ], + "score": 1.0, + "content": "report the perplexity on the Pile validation set, and for this metric only compare to models trained", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 416, + 426, + 427 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 426, + 427 + ], + "score": 1.0, + "content": "on the same dataset and with the same tokenizer, in particular Pythia and RWKV.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23.5, + "bbox_fs": [ + 105, + 383, + 506, + 427 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 431, + 505, + 464 + ], + "lines": [ + { + "bbox": [ + 105, + 430, + 507, + 444 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 507, + 444 + ], + "score": 1.0, + "content": "For downstream evaluation, we use the LM evaluation harness from EleutherAI (Gao et al., 2021),", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 442, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 106, + 442, + 505, + 453 + ], + "score": 1.0, + "content": "as done by most work in this area. We evaluate on the following tasks/datasets that measure common", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 453, + 174, + 466 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 174, + 466 + ], + "score": 1.0, + "content": "sense reasoning:", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27, + "bbox_fs": [ + 105, + 430, + 507, + 466 + ] + }, + { + "type": "list", + "bbox": [ + 133, + 472, + 323, + 560 + ], + "lines": [ + { + "bbox": [ + 134, + 472, + 282, + 485 + ], + "spans": [ + { + "bbox": [ + 134, + 472, + 282, + 485 + ], + "score": 1.0, + "content": "• LAMBADA (Paperno et al., 2016).", + "type": "text" + } + ], + "index": 29, + "is_list_end_line": true + }, + { + "bbox": [ + 133, + 487, + 277, + 500 + ], + "spans": [ + { + "bbox": [ + 133, + 487, + 277, + 500 + ], + "score": 1.0, + "content": "• HellaSwag (Paperno et al., 2016).", + "type": "text" + } + ], + "index": 30, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 133, + 502, + 242, + 515 + ], + "spans": [ + { + "bbox": [ + 133, + 502, + 242, + 515 + ], + "score": 1.0, + "content": "• PIQA (Bisk et al., 2020).", + "type": "text" + } + ], + "index": 31, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 133, + 516, + 324, + 531 + ], + "spans": [ + { + "bbox": [ + 133, + 516, + 324, + 531 + ], + "score": 1.0, + "content": "• ARC-easy: an easy subset of ARC-challenge.", + "type": "text" + } + ], + "index": 32, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 134, + 533, + 284, + 545 + ], + "spans": [ + { + "bbox": [ + 134, + 533, + 284, + 545 + ], + "score": 1.0, + "content": "• ARC-challenge (Clark et al., 2018).", + "type": "text" + } + ], + "index": 33, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 133, + 547, + 293, + 561 + ], + "spans": [ + { + "bbox": [ + 133, + 547, + 293, + 561 + ], + "score": 1.0, + "content": "• WinoGrande (Sakaguchi et al., 2021).", + "type": "text" + } + ], + "index": 34, + "is_list_start_line": true, + "is_list_end_line": true + } + ], + "index": 31.5, + "bbox_fs": [ + 133, + 472, + 324, + 561 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 568, + 505, + 601 + ], + "lines": [ + { + "bbox": [ + 106, + 568, + 505, + 581 + ], + "spans": [ + { + "bbox": [ + 106, + 568, + 505, + 581 + ], + "score": 1.0, + "content": "We report accuracy for LAMBADA, WinoGrande, PIQA, and ARC-easy, and accuracy normalized", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 579, + 505, + 592 + ], + "spans": [ + { + "bbox": [ + 106, + 579, + 505, + 592 + ], + "score": 1.0, + "content": "by sequence length for HellaSwag and ARC-challenge (since normalized accuracy is higher for almost", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 590, + 210, + 602 + ], + "spans": [ + { + "bbox": [ + 106, + 590, + 210, + 602 + ], + "score": 1.0, + "content": "all models for these task).", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36, + "bbox_fs": [ + 106, + 568, + 505, + 602 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 610, + 205, + 621 + ], + "lines": [ + { + "bbox": [ + 106, + 610, + 205, + 623 + ], + "spans": [ + { + "bbox": [ + 106, + 610, + 205, + 623 + ], + "score": 1.0, + "content": "F.3 DNA MODELING", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 38 + }, + { + "type": "title", + "bbox": [ + 107, + 626, + 240, + 637 + ], + "lines": [ + { + "bbox": [ + 105, + 625, + 240, + 639 + ], + "spans": [ + { + "bbox": [ + 105, + 625, + 240, + 639 + ], + "score": 1.0, + "content": "F.3.1 PRETRAINING DETAILS", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 39 + }, + { + "type": "text", + "bbox": [ + 105, + 646, + 464, + 658 + ], + "lines": [ + { + "bbox": [ + 105, + 645, + 465, + 659 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 465, + 659 + ], + "score": 1.0, + "content": "We describe the dataset and training procedure of the HG38 pretraining task in more detail.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 40, + "bbox_fs": [ + 105, + 645, + 465, + 659 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 662, + 505, + 705 + ], + "lines": [ + { + "bbox": [ + 105, + 661, + 505, + 674 + ], + "spans": [ + { + "bbox": [ + 105, + 661, + 505, + 674 + ], + "score": 1.0, + "content": "The dataset follows the splits from the prior Enformer work on genomics (Avsec et al., 2021); the", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 671, + 506, + 685 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 228, + 685 + ], + "score": 1.0, + "content": "training split contains a total of", + "type": "text" + }, + { + "bbox": [ + 228, + 673, + 271, + 683 + ], + "score": 0.9, + "content": "S { = } 3 4 0 2 1", + "type": "inline_equation" + }, + { + "bbox": [ + 271, + 671, + 347, + 685 + ], + "score": 1.0, + "content": "segments of length", + "type": "text" + }, + { + "bbox": [ + 347, + 672, + 401, + 683 + ], + "score": 0.9, + "content": "2 ^ { 1 7 } = 1 3 1 0 7 2", + "type": "inline_equation" + }, + { + "bbox": [ + 402, + 671, + 506, + 685 + ], + "score": 1.0, + "content": "that cover the genome, for", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 684, + 505, + 696 + ], + "spans": [ + { + "bbox": [ + 105, + 684, + 505, + 696 + ], + "score": 1.0, + "content": "a total of approximately 4.5 billion tokens (DNA base pairs). These segments are pairs of (chromosome", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 694, + 504, + 706 + ], + "spans": [ + { + "bbox": [ + 106, + 694, + 504, + 706 + ], + "score": 1.0, + "content": "number, starting index, ending index), and can be extended if necessary (e.g. to get longer segments).", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 42.5, + "bbox_fs": [ + 105, + 661, + 506, + 706 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 384, + 723 + ], + "score": 1.0, + "content": "We deviate from HyenaDNA when the training sequence length is not", + "type": "text" + }, + { + "bbox": [ + 384, + 709, + 398, + 720 + ], + "score": 0.83, + "content": "2 ^ { 1 7 }", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 709, + 505, + 723 + ], + "score": 1.0, + "content": ". HyenaDNA always takes", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 719, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 719, + 506, + 734 + ], + "score": 1.0, + "content": "a fixed sub-segment (e.g. the beginning or middle of the prescribed segment), and thus for any training", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "score": 1.0, + "content": "sequence length each epoch is fixed to 34021 samples and doesn’t necessarily go through the whole", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 340, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 340, + 106 + ], + "score": 1.0, + "content": "genome. On the other hand, we use the entire training data:", + "type": "text", + "cross_page": true + } + ], + "index": 1 + } + ], + "index": 45.5, + "bbox_fs": [ + 105, + 709, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 504, + 105 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 505, + 96 + ], + "score": 1.0, + "content": "sequence length each epoch is fixed to 34021 samples and doesn’t necessarily go through the whole", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 93, + 340, + 106 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 340, + 106 + ], + "score": 1.0, + "content": "genome. On the other hand, we use the entire training data:", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 106, + 108, + 506, + 192 + ], + "lines": [ + { + "bbox": [ + 104, + 106, + 507, + 123 + ], + "spans": [ + { + "bbox": [ + 104, + 106, + 218, + 123 + ], + "score": 1.0, + "content": "• When the context length", + "type": "text" + }, + { + "bbox": [ + 219, + 110, + 227, + 119 + ], + "score": 0.77, + "content": "L", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 106, + 332, + 123 + ], + "score": 1.0, + "content": "is less than (or equal to)", + "type": "text" + }, + { + "bbox": [ + 332, + 108, + 347, + 119 + ], + "score": 0.82, + "content": "2 ^ { 1 7 }", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 106, + 507, + 123 + ], + "score": 1.0, + "content": ", we divide up each segment into non-", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 110, + 115, + 504, + 137 + ], + "spans": [ + { + "bbox": [ + 110, + 115, + 261, + 137 + ], + "score": 1.0, + "content": "overlapping sub-segments of length", + "type": "text" + }, + { + "bbox": [ + 261, + 123, + 269, + 132 + ], + "score": 0.78, + "content": "L", + "type": "inline_equation" + }, + { + "bbox": [ + 269, + 115, + 338, + 137 + ], + "score": 1.0, + "content": ", so that there are", + "type": "text" + }, + { + "bbox": [ + 338, + 119, + 369, + 135 + ], + "score": 0.93, + "content": "\\begin{array} { r } { S \\times \\frac { 2 ^ { 1 7 } } { L } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 369, + 115, + 442, + 137 + ], + "score": 1.0, + "content": "total samples and", + "type": "text" + }, + { + "bbox": [ + 442, + 121, + 504, + 133 + ], + "score": 0.91, + "content": "S \\times 2 ^ { 1 7 } \\approx 4 . 5 B", + "type": "inline_equation" + } + ], + "index": 3 + }, + { + "bbox": [ + 114, + 133, + 186, + 145 + ], + "spans": [ + { + "bbox": [ + 114, + 133, + 186, + 145 + ], + "score": 1.0, + "content": "tokens per epoch.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 146, + 506, + 163 + ], + "spans": [ + { + "bbox": [ + 106, + 146, + 216, + 163 + ], + "score": 1.0, + "content": "• When the context length", + "type": "text" + }, + { + "bbox": [ + 217, + 150, + 225, + 159 + ], + "score": 0.78, + "content": "L", + "type": "inline_equation" + }, + { + "bbox": [ + 225, + 146, + 286, + 163 + ], + "score": 1.0, + "content": "is greater than", + "type": "text" + }, + { + "bbox": [ + 286, + 149, + 300, + 159 + ], + "score": 0.82, + "content": "2 ^ { 1 7 }", + "type": "inline_equation" + }, + { + "bbox": [ + 301, + 146, + 506, + 163 + ], + "score": 1.0, + "content": ", we turn each segment into two samples, one that", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 114, + 159, + 506, + 172 + ], + "spans": [ + { + "bbox": [ + 114, + 159, + 506, + 172 + ], + "score": 1.0, + "content": "begins with the prescribed segment and one that ends with the prescribed segment. Thus each epoch", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 113, + 168, + 506, + 184 + ], + "spans": [ + { + "bbox": [ + 113, + 168, + 131, + 184 + ], + "score": 1.0, + "content": "has", + "type": "text" + }, + { + "bbox": [ + 131, + 171, + 144, + 181 + ], + "score": 0.77, + "content": "2 S", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 168, + 185, + 184 + ], + "score": 1.0, + "content": "items and", + "type": "text" + }, + { + "bbox": [ + 186, + 171, + 205, + 181 + ], + "score": 0.79, + "content": "2 S L", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 168, + 411, + 184 + ], + "score": 1.0, + "content": "tokens per epoch. For example, at sequence length", + "type": "text" + }, + { + "bbox": [ + 412, + 170, + 467, + 181 + ], + "score": 0.9, + "content": "2 ^ { 1 8 } = 2 6 2 1 4 4", + "type": "inline_equation" + }, + { + "bbox": [ + 468, + 168, + 506, + 184 + ], + "score": 1.0, + "content": "there are", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 114, + 179, + 476, + 195 + ], + "spans": [ + { + "bbox": [ + 114, + 182, + 128, + 192 + ], + "score": 0.85, + "content": "4 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 129, + 179, + 339, + 195 + ], + "score": 1.0, + "content": "as many tokens as the default, and at sequence length", + "type": "text" + }, + { + "bbox": [ + 339, + 181, + 353, + 191 + ], + "score": 0.86, + "content": "2 ^ { 2 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 354, + 179, + 390, + 195 + ], + "score": 1.0, + "content": "there are", + "type": "text" + }, + { + "bbox": [ + 390, + 182, + 410, + 192 + ], + "score": 0.87, + "content": "1 6 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 410, + 179, + 476, + 195 + ], + "score": 1.0, + "content": "as many tokens.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 107, + 197, + 505, + 230 + ], + "lines": [ + { + "bbox": [ + 105, + 196, + 505, + 210 + ], + "spans": [ + { + "bbox": [ + 105, + 196, + 505, + 210 + ], + "score": 1.0, + "content": "Other training details generally follow the same protocol as our language modeling experiments", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 207, + 505, + 222 + ], + "spans": [ + { + "bbox": [ + 105, + 207, + 319, + 222 + ], + "score": 1.0, + "content": "(Appendix F.2). For example, we use the AdamW with", + "type": "text" + }, + { + "bbox": [ + 320, + 208, + 402, + 220 + ], + "score": 0.92, + "content": "( \\beta _ { 1 } , \\beta _ { 2 } ) = ( 0 . 9 , 0 . 9 5 ) ^ { \\mathrm { ~ ~ } }", + "type": "inline_equation" + }, + { + "bbox": [ + 402, + 207, + 505, + 222 + ], + "score": 1.0, + "content": ", no dropout, weight decay", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 217, + 449, + 232 + ], + "spans": [ + { + "bbox": [ + 105, + 217, + 373, + 232 + ], + "score": 1.0, + "content": "0.1. We use a cosine learning rate scheduler with linear warmup for", + "type": "text" + }, + { + "bbox": [ + 373, + 219, + 392, + 228 + ], + "score": 0.83, + "content": "10 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 393, + 217, + 449, + 232 + ], + "score": 1.0, + "content": "of total steps.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10 + }, + { + "type": "title", + "bbox": [ + 107, + 239, + 279, + 250 + ], + "lines": [ + { + "bbox": [ + 105, + 237, + 280, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 237, + 280, + 252 + ], + "score": 1.0, + "content": "F.3.2 SCALING: MODEL SIZE DETAILS", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 107, + 259, + 219, + 271 + ], + "lines": [ + { + "bbox": [ + 106, + 258, + 221, + 272 + ], + "spans": [ + { + "bbox": [ + 106, + 258, + 221, + 272 + ], + "score": 1.0, + "content": "The models we consider are:", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 106, + 280, + 506, + 361 + ], + "lines": [ + { + "bbox": [ + 105, + 278, + 505, + 292 + ], + "spans": [ + { + "bbox": [ + 105, + 278, + 505, + 292 + ], + "score": 1.0, + "content": "• Transformer++: a Transformer with improved architecture, notably the usage of RoPE positional", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 114, + 290, + 505, + 302 + ], + "spans": [ + { + "bbox": [ + 114, + 290, + 505, + 302 + ], + "score": 1.0, + "content": "encodings (Su et al., 2021). Informally, we found these to be noticeably better than vanilla positional", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 114, + 302, + 268, + 313 + ], + "spans": [ + { + "bbox": [ + 114, + 302, + 268, + 313 + ], + "score": 1.0, + "content": "encodings from (Vaswani et al., 2017).", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 313, + 506, + 327 + ], + "spans": [ + { + "bbox": [ + 105, + 313, + 506, + 327 + ], + "score": 1.0, + "content": "• HyenaDNA: the Hyena model from Poli et al. (2023); Nguyen et al. (2023), which is roughly a", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 112, + 323, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 112, + 323, + 506, + 338 + ], + "score": 1.0, + "content": "Transformer with the MHA block replaced by an H3 block using a global convolution parameterized", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 114, + 336, + 163, + 348 + ], + "spans": [ + { + "bbox": [ + 114, + 336, + 163, + 348 + ], + "score": 1.0, + "content": "by an MLP.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 349, + 285, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 349, + 285, + 361 + ], + "score": 1.0, + "content": "• Mamba: the standard Mamba architecture.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 106, + 370, + 241, + 381 + ], + "lines": [ + { + "bbox": [ + 106, + 368, + 242, + 383 + ], + "spans": [ + { + "bbox": [ + 106, + 368, + 242, + 383 + ], + "score": 1.0, + "content": "We use the following model sizes.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "table", + "bbox": [ + 167, + 390, + 443, + 430 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 167, + 390, + 443, + 430 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 167, + 390, + 443, + 430 + ], + "spans": [ + { + "bbox": [ + 167, + 390, + 443, + 430 + ], + "score": 0.966, + "html": "
Blocks456781012
Model Dim.6496128192256384512
Params (Appr0X.） 250K 700K 1.4M 3.5M 7.0M 19.3M 40.7M
", + "type": "table", + "image_path": "246aa648cc008435708b7c075d019657d0764e4f0a5dad70d6b416bc72380394.jpg" + } + ] + } + ], + "index": 23, + "virtual_lines": [ + { + "bbox": [ + 167, + 390, + 443, + 403.3333333333333 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 167, + 403.3333333333333, + 443, + 416.66666666666663 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 167, + 416.66666666666663, + 443, + 429.99999999999994 + ], + "spans": [], + "index": 24 + } + ] + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 106, + 438, + 504, + 460 + ], + "lines": [ + { + "bbox": [ + 106, + 438, + 505, + 450 + ], + "spans": [ + { + "bbox": [ + 106, + 438, + 505, + 450 + ], + "score": 1.0, + "content": "Note that the number of blocks for Mamba is doubled, because one Transformer “layer” includes both", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 448, + 488, + 462 + ], + "spans": [ + { + "bbox": [ + 105, + 448, + 488, + 462 + ], + "score": 1.0, + "content": "the MHA and MLP blocks which requires two Mamba blocks to match parameters (Section 3.4).", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5 + }, + { + "type": "text", + "bbox": [ + 107, + 464, + 506, + 519 + ], + "lines": [ + { + "bbox": [ + 105, + 464, + 505, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 464, + 221, + 477 + ], + "score": 1.0, + "content": "For each model (Transformer", + "type": "text" + }, + { + "bbox": [ + 221, + 466, + 232, + 475 + ], + "score": 0.57, + "content": "^ { + + }", + "type": "inline_equation" + }, + { + "bbox": [ + 232, + 464, + 453, + 477 + ], + "score": 1.0, + "content": ", HyenaDNA, Mamba), we swept the learning rate across", + "type": "text" + }, + { + "bbox": [ + 454, + 464, + 505, + 476 + ], + "score": 0.89, + "content": "\\{ 1 e - 3 , 2 e -", + "type": "inline_equation" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 474, + 506, + 488 + ], + "spans": [ + { + "bbox": [ + 106, + 475, + 170, + 487 + ], + "score": 0.91, + "content": "3 , 4 e - 3 , 8 e - 3 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 170, + 474, + 506, + 488 + ], + "score": 1.0, + "content": ". The optimal Transformer and HyenaDNA learning rates were 2e-3 across all sizes.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 486, + 506, + 499 + ], + "spans": [ + { + "bbox": [ + 106, + 486, + 506, + 499 + ], + "score": 1.0, + "content": "The optimal Mamba learning rate was 8e-3; note that Mamba performed better than baselines with", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 496, + 506, + 510 + ], + "spans": [ + { + "bbox": [ + 106, + 496, + 506, + 510 + ], + "score": 1.0, + "content": "matched learning rates (2e-3), but was more stable and improved even more at higher learning rates. (Fur-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 507, + 506, + 521 + ], + "spans": [ + { + "bbox": [ + 106, + 507, + 506, + 521 + ], + "score": 1.0, + "content": "thermore, as this LR is on the upper range of the sweep, it is possible that our results are still suboptimal.)", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 107, + 523, + 505, + 556 + ], + "lines": [ + { + "bbox": [ + 106, + 523, + 505, + 535 + ], + "spans": [ + { + "bbox": [ + 106, + 523, + 505, + 535 + ], + "score": 1.0, + "content": "Note that, in contrast to standard LM scaling laws (Table 11), our LR held constant across model sizes", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 534, + 506, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 534, + 506, + 546 + ], + "score": 1.0, + "content": "for simplicity. The optimal LR should go down for larger models, but we didn’t find a noticeable effect", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 545, + 400, + 557 + ], + "spans": [ + { + "bbox": [ + 105, + 545, + 400, + 557 + ], + "score": 1.0, + "content": "at the small model sizes (at most a few million parameters) we considered.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33 + }, + { + "type": "title", + "bbox": [ + 108, + 565, + 304, + 577 + ], + "lines": [ + { + "bbox": [ + 105, + 564, + 306, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 564, + 306, + 578 + ], + "score": 1.0, + "content": "F.3.3 SCALING: CONTEXT LENGTH DETAILS", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 107, + 586, + 505, + 641 + ], + "lines": [ + { + "bbox": [ + 105, + 585, + 507, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 585, + 219, + 601 + ], + "score": 1.0, + "content": "We use a total batch size of", + "type": "text" + }, + { + "bbox": [ + 219, + 586, + 267, + 597 + ], + "score": 0.92, + "content": "2 ^ { 2 4 } \\approx 1 6 M", + "type": "inline_equation" + }, + { + "bbox": [ + 267, + 585, + 507, + 601 + ], + "score": 1.0, + "content": "tokens per training step, for every sequence length (e.g. at", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 595, + 506, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 133, + 612 + ], + "score": 1.0, + "content": "length", + "type": "text" + }, + { + "bbox": [ + 133, + 597, + 147, + 608 + ], + "score": 0.85, + "content": "2 ^ { 2 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 148, + 595, + 324, + 612 + ], + "score": 1.0, + "content": "there are 16 segments per batch and at length", + "type": "text" + }, + { + "bbox": [ + 324, + 597, + 339, + 608 + ], + "score": 0.82, + "content": "2 ^ { 1 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 595, + 506, + 612 + ], + "score": 1.0, + "content": "there are 16384 segments per batch). This", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 104, + 607, + 504, + 621 + ], + "spans": [ + { + "bbox": [ + 104, + 607, + 489, + 621 + ], + "score": 1.0, + "content": "is a large batch size relative to the model size by usual LM standards, but note that a batch size of", + "type": "text" + }, + { + "bbox": [ + 490, + 608, + 504, + 619 + ], + "score": 0.84, + "content": "2 ^ { 2 3 }", + "type": "inline_equation" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 619, + 506, + 631 + ], + "spans": [ + { + "bbox": [ + 105, + 619, + 403, + 631 + ], + "score": 1.0, + "content": "is the minimum possible on a machine with 8 GPUs and sequence length of", + "type": "text" + }, + { + "bbox": [ + 404, + 619, + 419, + 630 + ], + "score": 0.89, + "content": "2 ^ { 2 } 0", + "type": "inline_equation" + }, + { + "bbox": [ + 419, + 619, + 506, + 631 + ], + "score": 1.0, + "content": ", and that HyenaDNA", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 629, + 236, + 644 + ], + "spans": [ + { + "bbox": [ + 105, + 629, + 236, + 644 + ], + "score": 1.0, + "content": "used much larger batches of 228.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 38 + }, + { + "type": "text", + "bbox": [ + 108, + 645, + 504, + 679 + ], + "lines": [ + { + "bbox": [ + 105, + 645, + 505, + 659 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 217, + 659 + ], + "score": 1.0, + "content": "The learning rate used was", + "type": "text" + }, + { + "bbox": [ + 217, + 646, + 243, + 657 + ], + "score": 0.75, + "content": "8 e - 3", + "type": "inline_equation" + }, + { + "bbox": [ + 243, + 645, + 309, + 659 + ], + "score": 1.0, + "content": "for Mamba and", + "type": "text" + }, + { + "bbox": [ + 309, + 646, + 335, + 657 + ], + "score": 0.79, + "content": "1 e - 3", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 645, + 505, + 659 + ], + "score": 1.0, + "content": "for HyenaDNA; we initially attempted to", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 657, + 505, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 657, + 254, + 669 + ], + "score": 1.0, + "content": "use the same optimal learning rate of", + "type": "text" + }, + { + "bbox": [ + 254, + 657, + 279, + 667 + ], + "score": 0.75, + "content": "2 e - 3", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 657, + 505, + 669 + ], + "score": 1.0, + "content": "from the previous section for HyenaDNA, but found that", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 668, + 281, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 668, + 281, + 680 + ], + "score": 1.0, + "content": "it was unstable at the longest context length.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42 + }, + { + "type": "text", + "bbox": [ + 107, + 688, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 505, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 702 + ], + "score": 1.0, + "content": "Sequence Length Warmup. Following (Nguyen et al., 2023), we use sequence length warmup", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 699, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 712 + ], + "score": 1.0, + "content": "(SLW) during pretraining. We choose a simple schedule of 2 epochs at each power-of-two sequence", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 189, + 723 + ], + "score": 1.0, + "content": "length starting from", + "type": "text" + }, + { + "bbox": [ + 189, + 709, + 234, + 720 + ], + "score": 0.9, + "content": "2 ^ { 1 0 } = 1 0 2 4", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 709, + 505, + 723 + ], + "score": 1.0, + "content": ". (Note that because of how data is curated, at the longest sequence", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 104, + 720, + 504, + 734 + ], + "spans": [ + { + "bbox": [ + 104, + 720, + 489, + 734 + ], + "score": 1.0, + "content": "lengths more steps and tokens are spent proportionally. In particular, each stage up to length", + "type": "text" + }, + { + "bbox": [ + 489, + 720, + 504, + 730 + ], + "score": 0.79, + "content": "2 ^ { 1 7 }", + "type": "inline_equation" + } + ], + "index": 47 + } + ], + "index": 45.5 + } + ], + "page_idx": 23, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 304, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 305, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 305, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 298, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 298, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 15 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 82, + 504, + 105 + ], + "lines": [], + "index": 0.5, + "bbox_fs": [ + 105, + 82, + 505, + 106 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 106, + 108, + 506, + 192 + ], + "lines": [ + { + "bbox": [ + 104, + 106, + 507, + 123 + ], + "spans": [ + { + "bbox": [ + 104, + 106, + 218, + 123 + ], + "score": 1.0, + "content": "• When the context length", + "type": "text" + }, + { + "bbox": [ + 219, + 110, + 227, + 119 + ], + "score": 0.77, + "content": "L", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 106, + 332, + 123 + ], + "score": 1.0, + "content": "is less than (or equal to)", + "type": "text" + }, + { + "bbox": [ + 332, + 108, + 347, + 119 + ], + "score": 0.82, + "content": "2 ^ { 1 7 }", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 106, + 507, + 123 + ], + "score": 1.0, + "content": ", we divide up each segment into non-", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 110, + 115, + 504, + 137 + ], + "spans": [ + { + "bbox": [ + 110, + 115, + 261, + 137 + ], + "score": 1.0, + "content": "overlapping sub-segments of length", + "type": "text" + }, + { + "bbox": [ + 261, + 123, + 269, + 132 + ], + "score": 0.78, + "content": "L", + "type": "inline_equation" + }, + { + "bbox": [ + 269, + 115, + 338, + 137 + ], + "score": 1.0, + "content": ", so that there are", + "type": "text" + }, + { + "bbox": [ + 338, + 119, + 369, + 135 + ], + "score": 0.93, + "content": "\\begin{array} { r } { S \\times \\frac { 2 ^ { 1 7 } } { L } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 369, + 115, + 442, + 137 + ], + "score": 1.0, + "content": "total samples and", + "type": "text" + }, + { + "bbox": [ + 442, + 121, + 504, + 133 + ], + "score": 0.91, + "content": "S \\times 2 ^ { 1 7 } \\approx 4 . 5 B", + "type": "inline_equation" + } + ], + "index": 3 + }, + { + "bbox": [ + 114, + 133, + 186, + 145 + ], + "spans": [ + { + "bbox": [ + 114, + 133, + 186, + 145 + ], + "score": 1.0, + "content": "tokens per epoch.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 146, + 506, + 163 + ], + "spans": [ + { + "bbox": [ + 106, + 146, + 216, + 163 + ], + "score": 1.0, + "content": "• When the context length", + "type": "text" + }, + { + "bbox": [ + 217, + 150, + 225, + 159 + ], + "score": 0.78, + "content": "L", + "type": "inline_equation" + }, + { + "bbox": [ + 225, + 146, + 286, + 163 + ], + "score": 1.0, + "content": "is greater than", + "type": "text" + }, + { + "bbox": [ + 286, + 149, + 300, + 159 + ], + "score": 0.82, + "content": "2 ^ { 1 7 }", + "type": "inline_equation" + }, + { + "bbox": [ + 301, + 146, + 506, + 163 + ], + "score": 1.0, + "content": ", we turn each segment into two samples, one that", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 114, + 159, + 506, + 172 + ], + "spans": [ + { + "bbox": [ + 114, + 159, + 506, + 172 + ], + "score": 1.0, + "content": "begins with the prescribed segment and one that ends with the prescribed segment. Thus each epoch", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 113, + 168, + 506, + 184 + ], + "spans": [ + { + "bbox": [ + 113, + 168, + 131, + 184 + ], + "score": 1.0, + "content": "has", + "type": "text" + }, + { + "bbox": [ + 131, + 171, + 144, + 181 + ], + "score": 0.77, + "content": "2 S", + "type": "inline_equation" + }, + { + "bbox": [ + 144, + 168, + 185, + 184 + ], + "score": 1.0, + "content": "items and", + "type": "text" + }, + { + "bbox": [ + 186, + 171, + 205, + 181 + ], + "score": 0.79, + "content": "2 S L", + "type": "inline_equation" + }, + { + "bbox": [ + 205, + 168, + 411, + 184 + ], + "score": 1.0, + "content": "tokens per epoch. For example, at sequence length", + "type": "text" + }, + { + "bbox": [ + 412, + 170, + 467, + 181 + ], + "score": 0.9, + "content": "2 ^ { 1 8 } = 2 6 2 1 4 4", + "type": "inline_equation" + }, + { + "bbox": [ + 468, + 168, + 506, + 184 + ], + "score": 1.0, + "content": "there are", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 114, + 179, + 476, + 195 + ], + "spans": [ + { + "bbox": [ + 114, + 182, + 128, + 192 + ], + "score": 0.85, + "content": "4 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 129, + 179, + 339, + 195 + ], + "score": 1.0, + "content": "as many tokens as the default, and at sequence length", + "type": "text" + }, + { + "bbox": [ + 339, + 181, + 353, + 191 + ], + "score": 0.86, + "content": "2 ^ { 2 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 354, + 179, + 390, + 195 + ], + "score": 1.0, + "content": "there are", + "type": "text" + }, + { + "bbox": [ + 390, + 182, + 410, + 192 + ], + "score": 0.87, + "content": "1 6 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 410, + 179, + 476, + 195 + ], + "score": 1.0, + "content": "as many tokens.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 5, + "bbox_fs": [ + 104, + 106, + 507, + 195 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 197, + 505, + 230 + ], + "lines": [ + { + "bbox": [ + 105, + 196, + 505, + 210 + ], + "spans": [ + { + "bbox": [ + 105, + 196, + 505, + 210 + ], + "score": 1.0, + "content": "Other training details generally follow the same protocol as our language modeling experiments", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 207, + 505, + 222 + ], + "spans": [ + { + "bbox": [ + 105, + 207, + 319, + 222 + ], + "score": 1.0, + "content": "(Appendix F.2). For example, we use the AdamW with", + "type": "text" + }, + { + "bbox": [ + 320, + 208, + 402, + 220 + ], + "score": 0.92, + "content": "( \\beta _ { 1 } , \\beta _ { 2 } ) = ( 0 . 9 , 0 . 9 5 ) ^ { \\mathrm { ~ ~ } }", + "type": "inline_equation" + }, + { + "bbox": [ + 402, + 207, + 505, + 222 + ], + "score": 1.0, + "content": ", no dropout, weight decay", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 217, + 449, + 232 + ], + "spans": [ + { + "bbox": [ + 105, + 217, + 373, + 232 + ], + "score": 1.0, + "content": "0.1. We use a cosine learning rate scheduler with linear warmup for", + "type": "text" + }, + { + "bbox": [ + 373, + 219, + 392, + 228 + ], + "score": 0.83, + "content": "10 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 393, + 217, + 449, + 232 + ], + "score": 1.0, + "content": "of total steps.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10, + "bbox_fs": [ + 105, + 196, + 505, + 232 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 239, + 279, + 250 + ], + "lines": [ + { + "bbox": [ + 105, + 237, + 280, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 237, + 280, + 252 + ], + "score": 1.0, + "content": "F.3.2 SCALING: MODEL SIZE DETAILS", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 107, + 259, + 219, + 271 + ], + "lines": [ + { + "bbox": [ + 106, + 258, + 221, + 272 + ], + "spans": [ + { + "bbox": [ + 106, + 258, + 221, + 272 + ], + "score": 1.0, + "content": "The models we consider are:", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13, + "bbox_fs": [ + 106, + 258, + 221, + 272 + ] + }, + { + "type": "list", + "bbox": [ + 106, + 280, + 506, + 361 + ], + "lines": [ + { + "bbox": [ + 105, + 278, + 505, + 292 + ], + "spans": [ + { + "bbox": [ + 105, + 278, + 505, + 292 + ], + "score": 1.0, + "content": "• Transformer++: a Transformer with improved architecture, notably the usage of RoPE positional", + "type": "text" + } + ], + "index": 14, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 290, + 505, + 302 + ], + "spans": [ + { + "bbox": [ + 114, + 290, + 505, + 302 + ], + "score": 1.0, + "content": "encodings (Su et al., 2021). Informally, we found these to be noticeably better than vanilla positional", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 114, + 302, + 268, + 313 + ], + "spans": [ + { + "bbox": [ + 114, + 302, + 268, + 313 + ], + "score": 1.0, + "content": "encodings from (Vaswani et al., 2017).", + "type": "text" + } + ], + "index": 16, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 313, + 506, + 327 + ], + "spans": [ + { + "bbox": [ + 105, + 313, + 506, + 327 + ], + "score": 1.0, + "content": "• HyenaDNA: the Hyena model from Poli et al. (2023); Nguyen et al. (2023), which is roughly a", + "type": "text" + } + ], + "index": 17, + "is_list_start_line": true + }, + { + "bbox": [ + 112, + 323, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 112, + 323, + 506, + 338 + ], + "score": 1.0, + "content": "Transformer with the MHA block replaced by an H3 block using a global convolution parameterized", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 114, + 336, + 163, + 348 + ], + "spans": [ + { + "bbox": [ + 114, + 336, + 163, + 348 + ], + "score": 1.0, + "content": "by an MLP.", + "type": "text" + } + ], + "index": 19, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 349, + 285, + 361 + ], + "spans": [ + { + "bbox": [ + 105, + 349, + 285, + 361 + ], + "score": 1.0, + "content": "• Mamba: the standard Mamba architecture.", + "type": "text" + } + ], + "index": 20, + "is_list_start_line": true, + "is_list_end_line": true + } + ], + "index": 17, + "bbox_fs": [ + 105, + 278, + 506, + 361 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 370, + 241, + 381 + ], + "lines": [ + { + "bbox": [ + 106, + 368, + 242, + 383 + ], + "spans": [ + { + "bbox": [ + 106, + 368, + 242, + 383 + ], + "score": 1.0, + "content": "We use the following model sizes.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21, + "bbox_fs": [ + 106, + 368, + 242, + 383 + ] + }, + { + "type": "table", + "bbox": [ + 167, + 390, + 443, + 430 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 167, + 390, + 443, + 430 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 167, + 390, + 443, + 430 + ], + "spans": [ + { + "bbox": [ + 167, + 390, + 443, + 430 + ], + "score": 0.966, + "html": "
Blocks456781012
Model Dim.6496128192256384512
Params (Appr0X.） 250K 700K 1.4M 3.5M 7.0M 19.3M 40.7M
", + "type": "table", + "image_path": "246aa648cc008435708b7c075d019657d0764e4f0a5dad70d6b416bc72380394.jpg" + } + ] + } + ], + "index": 23, + "virtual_lines": [ + { + "bbox": [ + 167, + 390, + 443, + 403.3333333333333 + ], + "spans": [], + "index": 22 + }, + { + "bbox": [ + 167, + 403.3333333333333, + 443, + 416.66666666666663 + ], + "spans": [], + "index": 23 + }, + { + "bbox": [ + 167, + 416.66666666666663, + 443, + 429.99999999999994 + ], + "spans": [], + "index": 24 + } + ] + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 106, + 438, + 504, + 460 + ], + "lines": [ + { + "bbox": [ + 106, + 438, + 505, + 450 + ], + "spans": [ + { + "bbox": [ + 106, + 438, + 505, + 450 + ], + "score": 1.0, + "content": "Note that the number of blocks for Mamba is doubled, because one Transformer “layer” includes both", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 448, + 488, + 462 + ], + "spans": [ + { + "bbox": [ + 105, + 448, + 488, + 462 + ], + "score": 1.0, + "content": "the MHA and MLP blocks which requires two Mamba blocks to match parameters (Section 3.4).", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 25.5, + "bbox_fs": [ + 105, + 438, + 505, + 462 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 464, + 506, + 519 + ], + "lines": [ + { + "bbox": [ + 105, + 464, + 505, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 464, + 221, + 477 + ], + "score": 1.0, + "content": "For each model (Transformer", + "type": "text" + }, + { + "bbox": [ + 221, + 466, + 232, + 475 + ], + "score": 0.57, + "content": "^ { + + }", + "type": "inline_equation" + }, + { + "bbox": [ + 232, + 464, + 453, + 477 + ], + "score": 1.0, + "content": ", HyenaDNA, Mamba), we swept the learning rate across", + "type": "text" + }, + { + "bbox": [ + 454, + 464, + 505, + 476 + ], + "score": 0.89, + "content": "\\{ 1 e - 3 , 2 e -", + "type": "inline_equation" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 474, + 506, + 488 + ], + "spans": [ + { + "bbox": [ + 106, + 475, + 170, + 487 + ], + "score": 0.91, + "content": "3 , 4 e - 3 , 8 e - 3 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 170, + 474, + 506, + 488 + ], + "score": 1.0, + "content": ". The optimal Transformer and HyenaDNA learning rates were 2e-3 across all sizes.", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 486, + 506, + 499 + ], + "spans": [ + { + "bbox": [ + 106, + 486, + 506, + 499 + ], + "score": 1.0, + "content": "The optimal Mamba learning rate was 8e-3; note that Mamba performed better than baselines with", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 496, + 506, + 510 + ], + "spans": [ + { + "bbox": [ + 106, + 496, + 506, + 510 + ], + "score": 1.0, + "content": "matched learning rates (2e-3), but was more stable and improved even more at higher learning rates. (Fur-", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 507, + 506, + 521 + ], + "spans": [ + { + "bbox": [ + 106, + 507, + 506, + 521 + ], + "score": 1.0, + "content": "thermore, as this LR is on the upper range of the sweep, it is possible that our results are still suboptimal.)", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29, + "bbox_fs": [ + 105, + 464, + 506, + 521 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 523, + 505, + 556 + ], + "lines": [ + { + "bbox": [ + 106, + 523, + 505, + 535 + ], + "spans": [ + { + "bbox": [ + 106, + 523, + 505, + 535 + ], + "score": 1.0, + "content": "Note that, in contrast to standard LM scaling laws (Table 11), our LR held constant across model sizes", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 534, + 506, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 534, + 506, + 546 + ], + "score": 1.0, + "content": "for simplicity. The optimal LR should go down for larger models, but we didn’t find a noticeable effect", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 545, + 400, + 557 + ], + "spans": [ + { + "bbox": [ + 105, + 545, + 400, + 557 + ], + "score": 1.0, + "content": "at the small model sizes (at most a few million parameters) we considered.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 33, + "bbox_fs": [ + 105, + 523, + 506, + 557 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 565, + 304, + 577 + ], + "lines": [ + { + "bbox": [ + 105, + 564, + 306, + 578 + ], + "spans": [ + { + "bbox": [ + 105, + 564, + 306, + 578 + ], + "score": 1.0, + "content": "F.3.3 SCALING: CONTEXT LENGTH DETAILS", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 107, + 586, + 505, + 641 + ], + "lines": [ + { + "bbox": [ + 105, + 585, + 507, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 585, + 219, + 601 + ], + "score": 1.0, + "content": "We use a total batch size of", + "type": "text" + }, + { + "bbox": [ + 219, + 586, + 267, + 597 + ], + "score": 0.92, + "content": "2 ^ { 2 4 } \\approx 1 6 M", + "type": "inline_equation" + }, + { + "bbox": [ + 267, + 585, + 507, + 601 + ], + "score": 1.0, + "content": "tokens per training step, for every sequence length (e.g. at", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 595, + 506, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 133, + 612 + ], + "score": 1.0, + "content": "length", + "type": "text" + }, + { + "bbox": [ + 133, + 597, + 147, + 608 + ], + "score": 0.85, + "content": "2 ^ { 2 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 148, + 595, + 324, + 612 + ], + "score": 1.0, + "content": "there are 16 segments per batch and at length", + "type": "text" + }, + { + "bbox": [ + 324, + 597, + 339, + 608 + ], + "score": 0.82, + "content": "2 ^ { 1 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 339, + 595, + 506, + 612 + ], + "score": 1.0, + "content": "there are 16384 segments per batch). This", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 104, + 607, + 504, + 621 + ], + "spans": [ + { + "bbox": [ + 104, + 607, + 489, + 621 + ], + "score": 1.0, + "content": "is a large batch size relative to the model size by usual LM standards, but note that a batch size of", + "type": "text" + }, + { + "bbox": [ + 490, + 608, + 504, + 619 + ], + "score": 0.84, + "content": "2 ^ { 2 3 }", + "type": "inline_equation" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 619, + 506, + 631 + ], + "spans": [ + { + "bbox": [ + 105, + 619, + 403, + 631 + ], + "score": 1.0, + "content": "is the minimum possible on a machine with 8 GPUs and sequence length of", + "type": "text" + }, + { + "bbox": [ + 404, + 619, + 419, + 630 + ], + "score": 0.89, + "content": "2 ^ { 2 } 0", + "type": "inline_equation" + }, + { + "bbox": [ + 419, + 619, + 506, + 631 + ], + "score": 1.0, + "content": ", and that HyenaDNA", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 629, + 236, + 644 + ], + "spans": [ + { + "bbox": [ + 105, + 629, + 236, + 644 + ], + "score": 1.0, + "content": "used much larger batches of 228.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 38, + "bbox_fs": [ + 104, + 585, + 507, + 644 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 645, + 504, + 679 + ], + "lines": [ + { + "bbox": [ + 105, + 645, + 505, + 659 + ], + "spans": [ + { + "bbox": [ + 105, + 645, + 217, + 659 + ], + "score": 1.0, + "content": "The learning rate used was", + "type": "text" + }, + { + "bbox": [ + 217, + 646, + 243, + 657 + ], + "score": 0.75, + "content": "8 e - 3", + "type": "inline_equation" + }, + { + "bbox": [ + 243, + 645, + 309, + 659 + ], + "score": 1.0, + "content": "for Mamba and", + "type": "text" + }, + { + "bbox": [ + 309, + 646, + 335, + 657 + ], + "score": 0.79, + "content": "1 e - 3", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 645, + 505, + 659 + ], + "score": 1.0, + "content": "for HyenaDNA; we initially attempted to", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 657, + 505, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 657, + 254, + 669 + ], + "score": 1.0, + "content": "use the same optimal learning rate of", + "type": "text" + }, + { + "bbox": [ + 254, + 657, + 279, + 667 + ], + "score": 0.75, + "content": "2 e - 3", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 657, + 505, + 669 + ], + "score": 1.0, + "content": "from the previous section for HyenaDNA, but found that", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 668, + 281, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 668, + 281, + 680 + ], + "score": 1.0, + "content": "it was unstable at the longest context length.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42, + "bbox_fs": [ + 105, + 645, + 505, + 680 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 688, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 687, + 505, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 702 + ], + "score": 1.0, + "content": "Sequence Length Warmup. Following (Nguyen et al., 2023), we use sequence length warmup", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 699, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 712 + ], + "score": 1.0, + "content": "(SLW) during pretraining. We choose a simple schedule of 2 epochs at each power-of-two sequence", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 709, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 189, + 723 + ], + "score": 1.0, + "content": "length starting from", + "type": "text" + }, + { + "bbox": [ + 189, + 709, + 234, + 720 + ], + "score": 0.9, + "content": "2 ^ { 1 0 } = 1 0 2 4", + "type": "inline_equation" + }, + { + "bbox": [ + 235, + 709, + 505, + 723 + ], + "score": 1.0, + "content": ". (Note that because of how data is curated, at the longest sequence", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 104, + 720, + 504, + 734 + ], + "spans": [ + { + "bbox": [ + 104, + 720, + 489, + 734 + ], + "score": 1.0, + "content": "lengths more steps and tokens are spent proportionally. In particular, each stage up to length", + "type": "text" + }, + { + "bbox": [ + 489, + 720, + 504, + 730 + ], + "score": 0.79, + "content": "2 ^ { 1 7 }", + "type": "inline_equation" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 202, + 505, + 219 + ], + "spans": [ + { + "bbox": [ + 105, + 202, + 270, + 219 + ], + "score": 1.0, + "content": "processes the same number of tokens, but", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 270, + 205, + 284, + 215 + ], + "score": 0.87, + "content": "4 \\times", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 285, + 202, + 438, + 219 + ], + "score": 1.0, + "content": "as many tokens are processed at length", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 438, + 204, + 452, + 215 + ], + "score": 0.75, + "content": "2 ^ { 1 8 }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 452, + 202, + 455, + 219 + ], + "score": 1.0, + "content": ",", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 456, + 205, + 470, + 216 + ], + "score": 0.84, + "content": "8 \\times", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 470, + 202, + 505, + 219 + ], + "score": 1.0, + "content": "as many", + "type": "text", + "cross_page": true + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 213, + 289, + 228 + ], + "spans": [ + { + "bbox": [ + 105, + 213, + 142, + 228 + ], + "score": 1.0, + "content": "at length", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 142, + 215, + 157, + 226 + ], + "score": 0.74, + "content": "2 ^ { 1 9 }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 157, + 213, + 177, + 228 + ], + "score": 1.0, + "content": ", and", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 177, + 216, + 196, + 226 + ], + "score": 0.88, + "content": "1 6 \\times", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 196, + 213, + 267, + 228 + ], + "score": 1.0, + "content": "as many at length", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 267, + 216, + 281, + 226 + ], + "score": 0.85, + "content": "2 ^ { 2 0 }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 282, + 213, + 289, + 228 + ], + "score": 1.0, + "content": ".)", + "type": "text", + "cross_page": true + } + ], + "index": 6 + } + ], + "index": 45.5, + "bbox_fs": [ + 104, + 687, + 505, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 164, + 110, + 444, + 188 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 81, + 504, + 102 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 104, + 79, + 506, + 92 + ], + "spans": [ + { + "bbox": [ + 104, + 79, + 443, + 92 + ], + "score": 1.0, + "content": "Table 12: (Great Apes DNA Classification.) Accuracy after fine-tuning on sequences of length", + "type": "text" + }, + { + "bbox": [ + 443, + 80, + 485, + 91 + ], + "score": 0.86, + "content": "2 ^ { 1 0 } = 1 0 2 4", + "type": "inline_equation" + }, + { + "bbox": [ + 485, + 79, + 506, + 92 + ], + "score": 1.0, + "content": "up to", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 107, + 88, + 441, + 103 + ], + "spans": [ + { + "bbox": [ + 107, + 90, + 161, + 101 + ], + "score": 0.89, + "content": "2 ^ { 2 0 } = 1 0 4 \\dot { 8 } 5 7 6", + "type": "inline_equation" + }, + { + "bbox": [ + 162, + 88, + 419, + 103 + ], + "score": 1.0, + "content": "with pre-trained models of the same context length. Random guessing is", + "type": "text" + }, + { + "bbox": [ + 419, + 91, + 437, + 100 + ], + "score": 0.86, + "content": "20 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 437, + 88, + 441, + 103 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "table_body", + "bbox": [ + 164, + 110, + 444, + 188 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 164, + 110, + 444, + 188 + ], + "spans": [ + { + "bbox": [ + 164, + 110, + 444, + 188 + ], + "score": 0.981, + "html": "
ModelParams Accuracy (%) at Sequence Length
210212214216218220
HyenaDNA 1.4M28.04 28.43 41.17 42.22 31.10 54.87
Mamba 1.4M31.47 27.50 27.66 40.72 42.41 71.67
Mamba 7M30.00 29.01 31.48 43.73 56.60 81.31
", + "type": "table", + "image_path": "322902973b786f344c4c1a1c13a880b9aa2443d395ab6c91b42430387a7cfd46.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 164, + 110, + 444, + 136.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 164, + 136.0, + 444, + 162.0 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 164, + 162.0, + 444, + 188.0 + ], + "spans": [], + "index": 4 + } + ] + } + ], + "index": 1.75 + }, + { + "type": "text", + "bbox": [ + 108, + 205, + 503, + 227 + ], + "lines": [ + { + "bbox": [ + 105, + 202, + 505, + 219 + ], + "spans": [ + { + "bbox": [ + 105, + 202, + 270, + 219 + ], + "score": 1.0, + "content": "processes the same number of tokens, but", + "type": "text" + }, + { + "bbox": [ + 270, + 205, + 284, + 215 + ], + "score": 0.87, + "content": "4 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 202, + 438, + 219 + ], + "score": 1.0, + "content": "as many tokens are processed at length", + "type": "text" + }, + { + "bbox": [ + 438, + 204, + 452, + 215 + ], + "score": 0.75, + "content": "2 ^ { 1 8 }", + "type": "inline_equation" + }, + { + "bbox": [ + 452, + 202, + 455, + 219 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 456, + 205, + 470, + 216 + ], + "score": 0.84, + "content": "8 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 470, + 202, + 505, + 219 + ], + "score": 1.0, + "content": "as many", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 213, + 289, + 228 + ], + "spans": [ + { + "bbox": [ + 105, + 213, + 142, + 228 + ], + "score": 1.0, + "content": "at length", + "type": "text" + }, + { + "bbox": [ + 142, + 215, + 157, + 226 + ], + "score": 0.74, + "content": "2 ^ { 1 9 }", + "type": "inline_equation" + }, + { + "bbox": [ + 157, + 213, + 177, + 228 + ], + "score": 1.0, + "content": ", and", + "type": "text" + }, + { + "bbox": [ + 177, + 216, + 196, + 226 + ], + "score": 0.88, + "content": "1 6 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 196, + 213, + 267, + 228 + ], + "score": 1.0, + "content": "as many at length", + "type": "text" + }, + { + "bbox": [ + 267, + 216, + 281, + 226 + ], + "score": 0.85, + "content": "2 ^ { 2 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 282, + 213, + 289, + 228 + ], + "score": 1.0, + "content": ".)", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 5.5 + }, + { + "type": "text", + "bbox": [ + 106, + 231, + 503, + 254 + ], + "lines": [ + { + "bbox": [ + 106, + 230, + 505, + 245 + ], + "spans": [ + { + "bbox": [ + 106, + 230, + 505, + 245 + ], + "score": 1.0, + "content": "Unlike HyenaDNA, we always control for the number of tokens per gradient update, so the batch size", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 242, + 392, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 242, + 392, + 255 + ], + "score": 1.0, + "content": "is successively halved as the sequence lengths are doubled in each stage.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5 + }, + { + "type": "text", + "bbox": [ + 106, + 257, + 505, + 302 + ], + "lines": [ + { + "bbox": [ + 105, + 257, + 505, + 270 + ], + "spans": [ + { + "bbox": [ + 105, + 257, + 505, + 270 + ], + "score": 1.0, + "content": "Remark F.1. We also note that the schedule was not tuned, and we never experimented with turning", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 268, + 506, + 281 + ], + "spans": [ + { + "bbox": [ + 106, + 268, + 506, + 281 + ], + "score": 1.0, + "content": "off sequence length warmup for these pretraining experiments. We later found that SLW did not", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 280, + 505, + 291 + ], + "spans": [ + { + "bbox": [ + 106, + 280, + 505, + 291 + ], + "score": 1.0, + "content": "help noticeably for audio pretraining at similar lengths (Section 4.4), and it is possible that it is not", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 290, + 257, + 302 + ], + "spans": [ + { + "bbox": [ + 105, + 290, + 257, + 302 + ], + "score": 1.0, + "content": "necessary for DNA pretraining either.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10.5 + }, + { + "type": "title", + "bbox": [ + 108, + 311, + 312, + 322 + ], + "lines": [ + { + "bbox": [ + 105, + 310, + 315, + 325 + ], + "spans": [ + { + "bbox": [ + 105, + 310, + 315, + 325 + ], + "score": 1.0, + "content": "F.3.4 SPECIES (GREAT APES) CLASSIFICATION", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 107, + 331, + 505, + 408 + ], + "lines": [ + { + "bbox": [ + 105, + 331, + 506, + 344 + ], + "spans": [ + { + "bbox": [ + 105, + 331, + 506, + 344 + ], + "score": 1.0, + "content": "Models are causal and therefore only the last element (across the sequence length) of the model’s", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 343, + 505, + 354 + ], + "spans": [ + { + "bbox": [ + 106, + 343, + 505, + 354 + ], + "score": 1.0, + "content": "output is used for the classification head. Note that we control for the total number of elements in", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 352, + 506, + 367 + ], + "spans": [ + { + "bbox": [ + 105, + 352, + 506, + 367 + ], + "score": 1.0, + "content": "the loss function per gradient step. The pretraining objective includes all positions across the sequence", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 363, + 506, + 377 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 220, + 377 + ], + "score": 1.0, + "content": "length, so that batch size", + "type": "text" + }, + { + "bbox": [ + 221, + 365, + 230, + 374 + ], + "score": 0.74, + "content": "\\times", + "type": "inline_equation" + }, + { + "bbox": [ + 231, + 363, + 506, + 377 + ], + "score": 1.0, + "content": "sequence length is held constant; in other words, the batch size", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 375, + 505, + 387 + ], + "spans": [ + { + "bbox": [ + 106, + 375, + 505, + 387 + ], + "score": 1.0, + "content": "decreases as the sequence length increases. However, for a classification task, since only the last", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 385, + 506, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 506, + 399 + ], + "score": 1.0, + "content": "position enters the loss, the batch size itself is held constant. Note that this also means that fine-tuning", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 397, + 396, + 409 + ], + "spans": [ + { + "bbox": [ + 105, + 397, + 396, + 409 + ], + "score": 1.0, + "content": "models with longer sequence lengths is more computationally expensive.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 107, + 412, + 505, + 445 + ], + "lines": [ + { + "bbox": [ + 105, + 411, + 505, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 411, + 505, + 425 + ], + "score": 1.0, + "content": "Training consists of 10 epochs, each of which has 1024 gradient steps. Each gradient step uses batch", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 423, + 505, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 505, + 436 + ], + "score": 1.0, + "content": "size 64, which are all independently randomly drawn by uniformly picking a species, uniformly", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 433, + 434, + 446 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 434, + 446 + ], + "score": 1.0, + "content": "picking a chromosome, and then uniformly picking a contiguous segment of DNA.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 107, + 449, + 505, + 504 + ], + "lines": [ + { + "bbox": [ + 105, + 448, + 505, + 461 + ], + "spans": [ + { + "bbox": [ + 105, + 448, + 453, + 461 + ], + "score": 1.0, + "content": "Following (Nguyen et al., 2023), models with a maximum context length greater than", + "type": "text" + }, + { + "bbox": [ + 454, + 448, + 505, + 459 + ], + "score": 0.89, + "content": "2 ^ { 1 4 } = 1 6 3 8 4", + "type": "inline_equation" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 459, + 506, + 472 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 317, + 472 + ], + "score": 1.0, + "content": "use sequence length warmup with 1 epoch at length", + "type": "text" + }, + { + "bbox": [ + 317, + 460, + 368, + 471 + ], + "score": 0.86, + "content": "2 ^ { 1 4 } = 1 6 3 8 4", + "type": "inline_equation" + }, + { + "bbox": [ + 369, + 459, + 443, + 472 + ], + "score": 1.0, + "content": ", 1 epoch at length", + "type": "text" + }, + { + "bbox": [ + 443, + 460, + 495, + 470 + ], + "score": 0.83, + "content": "2 ^ { 1 5 } = 3 2 7 6 8", + "type": "inline_equation" + }, + { + "bbox": [ + 495, + 459, + 506, + 472 + ], + "score": 1.0, + "content": ", 1", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 104, + 468, + 506, + 484 + ], + "spans": [ + { + "bbox": [ + 104, + 468, + 169, + 484 + ], + "score": 1.0, + "content": "epoch at length", + "type": "text" + }, + { + "bbox": [ + 169, + 470, + 218, + 481 + ], + "score": 0.9, + "content": "2 ^ { \\mathrm { 1 6 } } = 6 5 5 3 6", + "type": "inline_equation" + }, + { + "bbox": [ + 218, + 468, + 506, + 484 + ], + "score": 1.0, + "content": ", and so on up to the maximum sequence length. For example, the model", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 104, + 478, + 506, + 496 + ], + "spans": [ + { + "bbox": [ + 104, + 478, + 126, + 496 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 127, + 481, + 187, + 492 + ], + "score": 0.9, + "content": "2 ^ { 2 0 } = \\bar { 1 0 } 4 8 5 7 6", + "type": "inline_equation" + }, + { + "bbox": [ + 188, + 478, + 506, + 496 + ], + "score": 1.0, + "content": "context undergoes 6 epochs of sequence length warmup before 4 more epochs", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 492, + 237, + 505 + ], + "spans": [ + { + "bbox": [ + 105, + 492, + 237, + 505 + ], + "score": 1.0, + "content": "at its maximum sequence length.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 106, + 507, + 506, + 616 + ], + "lines": [ + { + "bbox": [ + 105, + 507, + 507, + 520 + ], + "spans": [ + { + "bbox": [ + 105, + 507, + 284, + 520 + ], + "score": 1.0, + "content": "The learning rate for all Hyena models is", + "type": "text" + }, + { + "bbox": [ + 285, + 509, + 315, + 519 + ], + "score": 0.84, + "content": "4 e \\mathrm { ~ - ~ } 5", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 507, + 507, + 520 + ], + "score": 1.0, + "content": ", while the learning rate for all Mamba mod-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 516, + 506, + 533 + ], + "spans": [ + { + "bbox": [ + 104, + 516, + 132, + 533 + ], + "score": 1.0, + "content": "els is", + "type": "text" + }, + { + "bbox": [ + 132, + 519, + 163, + 529 + ], + "score": 0.85, + "content": "1 e \\mathrm { ~ - ~ } 4", + "type": "inline_equation" + }, + { + "bbox": [ + 164, + 516, + 506, + 533 + ], + "score": 1.0, + "content": ". These were found by performing learning rate sweeps for each model among", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 523, + 508, + 545 + ], + "spans": [ + { + "bbox": [ + 106, + 529, + 254, + 541 + ], + "score": 0.9, + "content": "\\{ 1 e - 5 , 2 e - 5 , 4 e - 5 , 1 e - 4 , 2 e - 4 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 523, + 389, + 545 + ], + "score": 1.0, + "content": "for the smaller sequence lengths", + "type": "text" + }, + { + "bbox": [ + 389, + 529, + 460, + 541 + ], + "score": 0.92, + "content": "( \\dot { 2 } ^ { 1 0 } , 2 ^ { 1 2 } , 2 ^ { 1 4 } , 2 ^ { 1 6 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 461, + 523, + 508, + 545 + ], + "score": 1.0, + "content": ", and these", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 538, + 506, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 538, + 506, + 554 + ], + "score": 1.0, + "content": "values were consistently found to be the best for each model. An abridged learning rate sweep was", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 550, + 506, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 550, + 165, + 564 + ], + "score": 1.0, + "content": "done at length", + "type": "text" + }, + { + "bbox": [ + 165, + 550, + 179, + 561 + ], + "score": 0.78, + "content": "2 ^ { 1 8 }", + "type": "inline_equation" + }, + { + "bbox": [ + 180, + 550, + 413, + 564 + ], + "score": 1.0, + "content": ", which agreed with these values, and a single run at length", + "type": "text" + }, + { + "bbox": [ + 414, + 550, + 428, + 561 + ], + "score": 0.87, + "content": "2 ^ { 2 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 428, + 550, + 506, + 564 + ], + "score": 1.0, + "content": "was performed (as", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 561, + 506, + 574 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 506, + 574 + ], + "score": 1.0, + "content": "described above, the computational cost of these experiments is proportional to the sequence length).", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 572, + 506, + 585 + ], + "spans": [ + { + "bbox": [ + 105, + 572, + 506, + 585 + ], + "score": 1.0, + "content": "The learning rate followed a cosine decay schedule with warmup with 5 epochs of linear warmup to", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 104, + 582, + 506, + 597 + ], + "spans": [ + { + "bbox": [ + 104, + 582, + 364, + 597 + ], + "score": 1.0, + "content": "the maximum learning rate, and 5 epochs of cosine decay down to", + "type": "text" + }, + { + "bbox": [ + 365, + 584, + 389, + 594 + ], + "score": 0.62, + "content": "1 e { - } 6", + "type": "inline_equation" + }, + { + "bbox": [ + 389, + 582, + 506, + 597 + ], + "score": 1.0, + "content": ". The unusually long learning", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 594, + 505, + 607 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 505, + 607 + ], + "score": 1.0, + "content": "rate warmup schedule was chosen because the sequence length warmup was also long (e.g. comprising", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 104, + 603, + 492, + 618 + ], + "spans": [ + { + "bbox": [ + 104, + 603, + 312, + 618 + ], + "score": 1.0, + "content": "6 out of 10 epochs for the model with context length", + "type": "text" + }, + { + "bbox": [ + 313, + 604, + 327, + 615 + ], + "score": 0.85, + "content": "2 ^ { 2 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 327, + 603, + 492, + 618 + ], + "score": 1.0, + "content": "); we did not experiment with this choice.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 33.5 + }, + { + "type": "text", + "bbox": [ + 107, + 620, + 331, + 631 + ], + "lines": [ + { + "bbox": [ + 106, + 620, + 332, + 633 + ], + "spans": [ + { + "bbox": [ + 106, + 620, + 332, + 633 + ], + "score": 1.0, + "content": "Results for the Species classification task are in Table 12.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 39 + }, + { + "type": "title", + "bbox": [ + 108, + 641, + 200, + 653 + ], + "lines": [ + { + "bbox": [ + 105, + 640, + 201, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 640, + 201, + 654 + ], + "score": 1.0, + "content": "F.4 AUDIO DETAILS", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 40 + }, + { + "type": "title", + "bbox": [ + 106, + 657, + 295, + 669 + ], + "lines": [ + { + "bbox": [ + 106, + 657, + 297, + 669 + ], + "spans": [ + { + "bbox": [ + 106, + 657, + 297, + 669 + ], + "score": 1.0, + "content": "F.4.1 YOUTUBEMIX AUDIO PRETRAINING", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 105, + 678, + 505, + 700 + ], + "lines": [ + { + "bbox": [ + 105, + 677, + 505, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 312, + 691 + ], + "score": 1.0, + "content": "Model. We use a model with 3 blocks per stage", + "type": "text" + }, + { + "bbox": [ + 312, + 678, + 356, + 689 + ], + "score": 0.88, + "content": "3 \\times 5 = 1 5", + "type": "inline_equation" + }, + { + "bbox": [ + 356, + 677, + 505, + 691 + ], + "score": 1.0, + "content": "total Mamba blocks), pooling factor", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 688, + 361, + 702 + ], + "spans": [ + { + "bbox": [ + 106, + 689, + 133, + 700 + ], + "score": 0.92, + "content": "p { = } 1 6", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 688, + 218, + 702 + ], + "score": 1.0, + "content": ", and outer dimension", + "type": "text" + }, + { + "bbox": [ + 218, + 689, + 248, + 699 + ], + "score": 0.89, + "content": "D = 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 688, + 289, + 702 + ], + "score": 1.0, + "content": ", for about", + "type": "text" + }, + { + "bbox": [ + 289, + 689, + 312, + 699 + ], + "score": 0.5, + "content": "3 . 5 \\mathrm { M }", + "type": "inline_equation" + }, + { + "bbox": [ + 312, + 688, + 361, + 702 + ], + "score": 1.0, + "content": "parameters.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42.5 + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 504, + 731 + ], + "lines": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "Dataset. The data is mu-law encoded at 8 bits, so the model is modeling discrete tokens with a vocab", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 720, + 155, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 155, + 732 + ], + "score": 1.0, + "content": "size of 256.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44.5 + } + ], + "page_idx": 24, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 304, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 305, + 39 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 305, + 39 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 298, + 750, + 313, + 764 + ], + "spans": [ + { + "bbox": [ + 298, + 750, + 313, + 764 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 15 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 164, + 110, + 444, + 188 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 106, + 81, + 504, + 102 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 104, + 79, + 506, + 92 + ], + "spans": [ + { + "bbox": [ + 104, + 79, + 443, + 92 + ], + "score": 1.0, + "content": "Table 12: (Great Apes DNA Classification.) Accuracy after fine-tuning on sequences of length", + "type": "text" + }, + { + "bbox": [ + 443, + 80, + 485, + 91 + ], + "score": 0.86, + "content": "2 ^ { 1 0 } = 1 0 2 4", + "type": "inline_equation" + }, + { + "bbox": [ + 485, + 79, + 506, + 92 + ], + "score": 1.0, + "content": "up to", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 107, + 88, + 441, + 103 + ], + "spans": [ + { + "bbox": [ + 107, + 90, + 161, + 101 + ], + "score": 0.89, + "content": "2 ^ { 2 0 } = 1 0 4 \\dot { 8 } 5 7 6", + "type": "inline_equation" + }, + { + "bbox": [ + 162, + 88, + 419, + 103 + ], + "score": 1.0, + "content": "with pre-trained models of the same context length. Random guessing is", + "type": "text" + }, + { + "bbox": [ + 419, + 91, + 437, + 100 + ], + "score": 0.86, + "content": "20 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 437, + 88, + 441, + 103 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "table_body", + "bbox": [ + 164, + 110, + 444, + 188 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 164, + 110, + 444, + 188 + ], + "spans": [ + { + "bbox": [ + 164, + 110, + 444, + 188 + ], + "score": 0.981, + "html": "
ModelParams Accuracy (%) at Sequence Length
210212214216218220
HyenaDNA 1.4M28.04 28.43 41.17 42.22 31.10 54.87
Mamba 1.4M31.47 27.50 27.66 40.72 42.41 71.67
Mamba 7M30.00 29.01 31.48 43.73 56.60 81.31
", + "type": "table", + "image_path": "322902973b786f344c4c1a1c13a880b9aa2443d395ab6c91b42430387a7cfd46.jpg" + } + ] + } + ], + "index": 3, + "virtual_lines": [ + { + "bbox": [ + 164, + 110, + 444, + 136.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 164, + 136.0, + 444, + 162.0 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 164, + 162.0, + 444, + 188.0 + ], + "spans": [], + "index": 4 + } + ] + } + ], + "index": 1.75 + }, + { + "type": "text", + "bbox": [ + 108, + 205, + 503, + 227 + ], + "lines": [], + "index": 5.5, + "bbox_fs": [ + 105, + 202, + 505, + 228 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 106, + 231, + 503, + 254 + ], + "lines": [ + { + "bbox": [ + 106, + 230, + 505, + 245 + ], + "spans": [ + { + "bbox": [ + 106, + 230, + 505, + 245 + ], + "score": 1.0, + "content": "Unlike HyenaDNA, we always control for the number of tokens per gradient update, so the batch size", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 242, + 392, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 242, + 392, + 255 + ], + "score": 1.0, + "content": "is successively halved as the sequence lengths are doubled in each stage.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 7.5, + "bbox_fs": [ + 105, + 230, + 505, + 255 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 257, + 505, + 302 + ], + "lines": [ + { + "bbox": [ + 105, + 257, + 505, + 270 + ], + "spans": [ + { + "bbox": [ + 105, + 257, + 505, + 270 + ], + "score": 1.0, + "content": "Remark F.1. We also note that the schedule was not tuned, and we never experimented with turning", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 268, + 506, + 281 + ], + "spans": [ + { + "bbox": [ + 106, + 268, + 506, + 281 + ], + "score": 1.0, + "content": "off sequence length warmup for these pretraining experiments. We later found that SLW did not", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 280, + 505, + 291 + ], + "spans": [ + { + "bbox": [ + 106, + 280, + 505, + 291 + ], + "score": 1.0, + "content": "help noticeably for audio pretraining at similar lengths (Section 4.4), and it is possible that it is not", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 290, + 257, + 302 + ], + "spans": [ + { + "bbox": [ + 105, + 290, + 257, + 302 + ], + "score": 1.0, + "content": "necessary for DNA pretraining either.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10.5, + "bbox_fs": [ + 105, + 257, + 506, + 302 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 311, + 312, + 322 + ], + "lines": [ + { + "bbox": [ + 105, + 310, + 315, + 325 + ], + "spans": [ + { + "bbox": [ + 105, + 310, + 315, + 325 + ], + "score": 1.0, + "content": "F.3.4 SPECIES (GREAT APES) CLASSIFICATION", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 107, + 331, + 505, + 408 + ], + "lines": [ + { + "bbox": [ + 105, + 331, + 506, + 344 + ], + "spans": [ + { + "bbox": [ + 105, + 331, + 506, + 344 + ], + "score": 1.0, + "content": "Models are causal and therefore only the last element (across the sequence length) of the model’s", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 343, + 505, + 354 + ], + "spans": [ + { + "bbox": [ + 106, + 343, + 505, + 354 + ], + "score": 1.0, + "content": "output is used for the classification head. Note that we control for the total number of elements in", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 352, + 506, + 367 + ], + "spans": [ + { + "bbox": [ + 105, + 352, + 506, + 367 + ], + "score": 1.0, + "content": "the loss function per gradient step. The pretraining objective includes all positions across the sequence", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 363, + 506, + 377 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 220, + 377 + ], + "score": 1.0, + "content": "length, so that batch size", + "type": "text" + }, + { + "bbox": [ + 221, + 365, + 230, + 374 + ], + "score": 0.74, + "content": "\\times", + "type": "inline_equation" + }, + { + "bbox": [ + 231, + 363, + 506, + 377 + ], + "score": 1.0, + "content": "sequence length is held constant; in other words, the batch size", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 375, + 505, + 387 + ], + "spans": [ + { + "bbox": [ + 106, + 375, + 505, + 387 + ], + "score": 1.0, + "content": "decreases as the sequence length increases. However, for a classification task, since only the last", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 385, + 506, + 399 + ], + "spans": [ + { + "bbox": [ + 105, + 385, + 506, + 399 + ], + "score": 1.0, + "content": "position enters the loss, the batch size itself is held constant. Note that this also means that fine-tuning", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 397, + 396, + 409 + ], + "spans": [ + { + "bbox": [ + 105, + 397, + 396, + 409 + ], + "score": 1.0, + "content": "models with longer sequence lengths is more computationally expensive.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 17, + "bbox_fs": [ + 105, + 331, + 506, + 409 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 412, + 505, + 445 + ], + "lines": [ + { + "bbox": [ + 105, + 411, + 505, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 411, + 505, + 425 + ], + "score": 1.0, + "content": "Training consists of 10 epochs, each of which has 1024 gradient steps. Each gradient step uses batch", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 423, + 505, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 505, + 436 + ], + "score": 1.0, + "content": "size 64, which are all independently randomly drawn by uniformly picking a species, uniformly", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 433, + 434, + 446 + ], + "spans": [ + { + "bbox": [ + 105, + 433, + 434, + 446 + ], + "score": 1.0, + "content": "picking a chromosome, and then uniformly picking a contiguous segment of DNA.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22, + "bbox_fs": [ + 105, + 411, + 505, + 446 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 449, + 505, + 504 + ], + "lines": [ + { + "bbox": [ + 105, + 448, + 505, + 461 + ], + "spans": [ + { + "bbox": [ + 105, + 448, + 453, + 461 + ], + "score": 1.0, + "content": "Following (Nguyen et al., 2023), models with a maximum context length greater than", + "type": "text" + }, + { + "bbox": [ + 454, + 448, + 505, + 459 + ], + "score": 0.89, + "content": "2 ^ { 1 4 } = 1 6 3 8 4", + "type": "inline_equation" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 459, + 506, + 472 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 317, + 472 + ], + "score": 1.0, + "content": "use sequence length warmup with 1 epoch at length", + "type": "text" + }, + { + "bbox": [ + 317, + 460, + 368, + 471 + ], + "score": 0.86, + "content": "2 ^ { 1 4 } = 1 6 3 8 4", + "type": "inline_equation" + }, + { + "bbox": [ + 369, + 459, + 443, + 472 + ], + "score": 1.0, + "content": ", 1 epoch at length", + "type": "text" + }, + { + "bbox": [ + 443, + 460, + 495, + 470 + ], + "score": 0.83, + "content": "2 ^ { 1 5 } = 3 2 7 6 8", + "type": "inline_equation" + }, + { + "bbox": [ + 495, + 459, + 506, + 472 + ], + "score": 1.0, + "content": ", 1", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 104, + 468, + 506, + 484 + ], + "spans": [ + { + "bbox": [ + 104, + 468, + 169, + 484 + ], + "score": 1.0, + "content": "epoch at length", + "type": "text" + }, + { + "bbox": [ + 169, + 470, + 218, + 481 + ], + "score": 0.9, + "content": "2 ^ { \\mathrm { 1 6 } } = 6 5 5 3 6", + "type": "inline_equation" + }, + { + "bbox": [ + 218, + 468, + 506, + 484 + ], + "score": 1.0, + "content": ", and so on up to the maximum sequence length. For example, the model", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 104, + 478, + 506, + 496 + ], + "spans": [ + { + "bbox": [ + 104, + 478, + 126, + 496 + ], + "score": 1.0, + "content": "with", + "type": "text" + }, + { + "bbox": [ + 127, + 481, + 187, + 492 + ], + "score": 0.9, + "content": "2 ^ { 2 0 } = \\bar { 1 0 } 4 8 5 7 6", + "type": "inline_equation" + }, + { + "bbox": [ + 188, + 478, + 506, + 496 + ], + "score": 1.0, + "content": "context undergoes 6 epochs of sequence length warmup before 4 more epochs", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 492, + 237, + 505 + ], + "spans": [ + { + "bbox": [ + 105, + 492, + 237, + 505 + ], + "score": 1.0, + "content": "at its maximum sequence length.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 26, + "bbox_fs": [ + 104, + 448, + 506, + 505 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 507, + 506, + 616 + ], + "lines": [ + { + "bbox": [ + 105, + 507, + 507, + 520 + ], + "spans": [ + { + "bbox": [ + 105, + 507, + 284, + 520 + ], + "score": 1.0, + "content": "The learning rate for all Hyena models is", + "type": "text" + }, + { + "bbox": [ + 285, + 509, + 315, + 519 + ], + "score": 0.84, + "content": "4 e \\mathrm { ~ - ~ } 5", + "type": "inline_equation" + }, + { + "bbox": [ + 315, + 507, + 507, + 520 + ], + "score": 1.0, + "content": ", while the learning rate for all Mamba mod-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 104, + 516, + 506, + 533 + ], + "spans": [ + { + "bbox": [ + 104, + 516, + 132, + 533 + ], + "score": 1.0, + "content": "els is", + "type": "text" + }, + { + "bbox": [ + 132, + 519, + 163, + 529 + ], + "score": 0.85, + "content": "1 e \\mathrm { ~ - ~ } 4", + "type": "inline_equation" + }, + { + "bbox": [ + 164, + 516, + 506, + 533 + ], + "score": 1.0, + "content": ". These were found by performing learning rate sweeps for each model among", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 523, + 508, + 545 + ], + "spans": [ + { + "bbox": [ + 106, + 529, + 254, + 541 + ], + "score": 0.9, + "content": "\\{ 1 e - 5 , 2 e - 5 , 4 e - 5 , 1 e - 4 , 2 e - 4 \\}", + "type": "inline_equation" + }, + { + "bbox": [ + 254, + 523, + 389, + 545 + ], + "score": 1.0, + "content": "for the smaller sequence lengths", + "type": "text" + }, + { + "bbox": [ + 389, + 529, + 460, + 541 + ], + "score": 0.92, + "content": "( \\dot { 2 } ^ { 1 0 } , 2 ^ { 1 2 } , 2 ^ { 1 4 } , 2 ^ { 1 6 } )", + "type": "inline_equation" + }, + { + "bbox": [ + 461, + 523, + 508, + 545 + ], + "score": 1.0, + "content": ", and these", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 538, + 506, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 538, + 506, + 554 + ], + "score": 1.0, + "content": "values were consistently found to be the best for each model. An abridged learning rate sweep was", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 550, + 506, + 564 + ], + "spans": [ + { + "bbox": [ + 105, + 550, + 165, + 564 + ], + "score": 1.0, + "content": "done at length", + "type": "text" + }, + { + "bbox": [ + 165, + 550, + 179, + 561 + ], + "score": 0.78, + "content": "2 ^ { 1 8 }", + "type": "inline_equation" + }, + { + "bbox": [ + 180, + 550, + 413, + 564 + ], + "score": 1.0, + "content": ", which agreed with these values, and a single run at length", + "type": "text" + }, + { + "bbox": [ + 414, + 550, + 428, + 561 + ], + "score": 0.87, + "content": "2 ^ { 2 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 428, + 550, + 506, + 564 + ], + "score": 1.0, + "content": "was performed (as", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 561, + 506, + 574 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 506, + 574 + ], + "score": 1.0, + "content": "described above, the computational cost of these experiments is proportional to the sequence length).", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 572, + 506, + 585 + ], + "spans": [ + { + "bbox": [ + 105, + 572, + 506, + 585 + ], + "score": 1.0, + "content": "The learning rate followed a cosine decay schedule with warmup with 5 epochs of linear warmup to", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 104, + 582, + 506, + 597 + ], + "spans": [ + { + "bbox": [ + 104, + 582, + 364, + 597 + ], + "score": 1.0, + "content": "the maximum learning rate, and 5 epochs of cosine decay down to", + "type": "text" + }, + { + "bbox": [ + 365, + 584, + 389, + 594 + ], + "score": 0.62, + "content": "1 e { - } 6", + "type": "inline_equation" + }, + { + "bbox": [ + 389, + 582, + 506, + 597 + ], + "score": 1.0, + "content": ". The unusually long learning", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 594, + 505, + 607 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 505, + 607 + ], + "score": 1.0, + "content": "rate warmup schedule was chosen because the sequence length warmup was also long (e.g. comprising", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 104, + 603, + 492, + 618 + ], + "spans": [ + { + "bbox": [ + 104, + 603, + 312, + 618 + ], + "score": 1.0, + "content": "6 out of 10 epochs for the model with context length", + "type": "text" + }, + { + "bbox": [ + 313, + 604, + 327, + 615 + ], + "score": 0.85, + "content": "2 ^ { 2 0 }", + "type": "inline_equation" + }, + { + "bbox": [ + 327, + 603, + 492, + 618 + ], + "score": 1.0, + "content": "); we did not experiment with this choice.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 33.5, + "bbox_fs": [ + 104, + 507, + 508, + 618 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 620, + 331, + 631 + ], + "lines": [ + { + "bbox": [ + 106, + 620, + 332, + 633 + ], + "spans": [ + { + "bbox": [ + 106, + 620, + 332, + 633 + ], + "score": 1.0, + "content": "Results for the Species classification task are in Table 12.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 39, + "bbox_fs": [ + 106, + 620, + 332, + 633 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 641, + 200, + 653 + ], + "lines": [ + { + "bbox": [ + 105, + 640, + 201, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 640, + 201, + 654 + ], + "score": 1.0, + "content": "F.4 AUDIO DETAILS", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 40 + }, + { + "type": "title", + "bbox": [ + 106, + 657, + 295, + 669 + ], + "lines": [ + { + "bbox": [ + 106, + 657, + 297, + 669 + ], + "spans": [ + { + "bbox": [ + 106, + 657, + 297, + 669 + ], + "score": 1.0, + "content": "F.4.1 YOUTUBEMIX AUDIO PRETRAINING", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 105, + 678, + 505, + 700 + ], + "lines": [ + { + "bbox": [ + 105, + 677, + 505, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 312, + 691 + ], + "score": 1.0, + "content": "Model. We use a model with 3 blocks per stage", + "type": "text" + }, + { + "bbox": [ + 312, + 678, + 356, + 689 + ], + "score": 0.88, + "content": "3 \\times 5 = 1 5", + "type": "inline_equation" + }, + { + "bbox": [ + 356, + 677, + 505, + 691 + ], + "score": 1.0, + "content": "total Mamba blocks), pooling factor", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 688, + 361, + 702 + ], + "spans": [ + { + "bbox": [ + 106, + 689, + 133, + 700 + ], + "score": 0.92, + "content": "p { = } 1 6", + "type": "inline_equation" + }, + { + "bbox": [ + 133, + 688, + 218, + 702 + ], + "score": 1.0, + "content": ", and outer dimension", + "type": "text" + }, + { + "bbox": [ + 218, + 689, + 248, + 699 + ], + "score": 0.89, + "content": "D = 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 248, + 688, + 289, + 702 + ], + "score": 1.0, + "content": ", for about", + "type": "text" + }, + { + "bbox": [ + 289, + 689, + 312, + 699 + ], + "score": 0.5, + "content": "3 . 5 \\mathrm { M }", + "type": "inline_equation" + }, + { + "bbox": [ + 312, + 688, + 361, + 702 + ], + "score": 1.0, + "content": "parameters.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 42.5, + "bbox_fs": [ + 105, + 677, + 505, + 702 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 709, + 504, + 731 + ], + "lines": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "Dataset. The data is mu-law encoded at 8 bits, so the model is modeling discrete tokens with a vocab", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 720, + 155, + 732 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 155, + 732 + ], + "score": 1.0, + "content": "size of 256.", + "type": "text" + } + ], + "index": 45 + } + ], + "index": 44.5, + "bbox_fs": [ + 105, + 709, + 505, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 201, + 99, + 407, + 209 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 177, + 80, + 433, + 91 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 177, + 79, + 434, + 92 + ], + "spans": [ + { + "bbox": [ + 177, + 79, + 434, + 92 + ], + "score": 1.0, + "content": "Table 13: YouTubeMix length scaling sequence lengths and batch sizes.", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table_body", + "bbox": [ + 201, + 99, + 407, + 209 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 201, + 99, + 407, + 209 + ], + "spans": [ + { + "bbox": [ + 201, + 99, + 407, + 209 + ], + "score": 0.98, + "html": "
Sequence length Batch size Tokens per batch
468×2048=958464 1958464
234×2048=479232 2958464
117×2048=239616 4958464
59×2048=120832 8966656
30×2048=61440 16983040
15×2048=30720 32983040
8×2048=16384 641048576
4×2048=8192 1281048576
", + "type": "table", + "image_path": "3b17858478af9cf1adccbf8a84f43d29e8feed28f6198ef701e87d4f92ded65f.jpg" + } + ] + } + ], + "index": 4.5, + "virtual_lines": [ + { + "bbox": [ + 201, + 99, + 407, + 112.75 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 201, + 112.75, + 407, + 126.5 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 201, + 126.5, + 407, + 140.25 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 201, + 140.25, + 407, + 154.0 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 201, + 154.0, + 407, + 167.75 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 201, + 167.75, + 407, + 181.5 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 201, + 181.5, + 407, + 195.25 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 201, + 195.25, + 407, + 209.0 + ], + "spans": [], + "index": 8 + } + ] + } + ], + "index": 2.25 + }, + { + "type": "text", + "bbox": [ + 107, + 227, + 505, + 282 + ], + "lines": [ + { + "bbox": [ + 106, + 227, + 505, + 239 + ], + "spans": [ + { + "bbox": [ + 106, + 227, + 505, + 239 + ], + "score": 1.0, + "content": "The dataset consists of clips of up to 1 minute long, or length 960000, which is subsampled and divided", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 237, + 505, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 237, + 505, + 252 + ], + "score": 1.0, + "content": "into segments of any desired sequence length. Since the architecture involves two stages of pooling by", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 104, + 246, + 507, + 263 + ], + "spans": [ + { + "bbox": [ + 104, + 246, + 507, + 263 + ], + "score": 1.0, + "content": "a factor of 16, and we want the resulting sequence length to be a a multiple of 8 for hardware efficiency,", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 259, + 505, + 272 + ], + "spans": [ + { + "bbox": [ + 106, + 259, + 236, + 272 + ], + "score": 1.0, + "content": "the longest possible sequence is", + "type": "text" + }, + { + "bbox": [ + 236, + 260, + 322, + 270 + ], + "score": 0.91, + "content": "4 6 8 \\times 2 0 4 8 = 9 5 8 4 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 322, + 259, + 505, + 272 + ], + "score": 1.0, + "content": ". The rest of our sequence lengths are defined", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 270, + 409, + 282 + ], + "spans": [ + { + "bbox": [ + 105, + 270, + 409, + 282 + ], + "score": 1.0, + "content": "by successively halving this and rounding up to the nearest multiple of 2048.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 107, + 285, + 505, + 330 + ], + "lines": [ + { + "bbox": [ + 105, + 285, + 505, + 298 + ], + "spans": [ + { + "bbox": [ + 105, + 285, + 505, + 298 + ], + "score": 1.0, + "content": "Table 13 lists the specifications used in Figure 7. Beyond the varying batch sizes, the number of valid", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 296, + 506, + 311 + ], + "spans": [ + { + "bbox": [ + 105, + 296, + 506, + 311 + ], + "score": 1.0, + "content": "segments in the training set varied between different sequence lengths (e.g. the number of training", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 308, + 505, + 320 + ], + "spans": [ + { + "bbox": [ + 105, + 308, + 505, + 320 + ], + "score": 1.0, + "content": "steps per epoch was not constant for different points in the graph), which may have contributed to", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 318, + 215, + 331 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 215, + 331 + ], + "score": 1.0, + "content": "kinks in the scaling curves.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15.5 + }, + { + "type": "text", + "bbox": [ + 106, + 339, + 505, + 362 + ], + "lines": [ + { + "bbox": [ + 106, + 339, + 504, + 352 + ], + "spans": [ + { + "bbox": [ + 106, + 339, + 249, + 352 + ], + "score": 1.0, + "content": "Training. Models were trained for", + "type": "text" + }, + { + "bbox": [ + 249, + 340, + 275, + 350 + ], + "score": 0.87, + "content": "2 0 0 K", + "type": "inline_equation" + }, + { + "bbox": [ + 275, + 339, + 483, + 352 + ], + "score": 1.0, + "content": "training steps with a maximum learning rate of 0.002,", + "type": "text" + }, + { + "bbox": [ + 483, + 339, + 504, + 350 + ], + "score": 0.54, + "content": "2 0 K", + "type": "inline_equation" + } + ], + "index": 18 + }, + { + "bbox": [ + 107, + 350, + 506, + 363 + ], + "spans": [ + { + "bbox": [ + 107, + 351, + 132, + 362 + ], + "score": 0.79, + "content": "( 1 0 \\% )", + "type": "inline_equation" + }, + { + "bbox": [ + 132, + 350, + 506, + 363 + ], + "score": 1.0, + "content": "warmup steps, and weight decay 0.1 (similar to our general pretraining recipe across domains).", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18.5 + }, + { + "type": "title", + "bbox": [ + 108, + 371, + 259, + 383 + ], + "lines": [ + { + "bbox": [ + 105, + 370, + 260, + 384 + ], + "spans": [ + { + "bbox": [ + 105, + 370, + 260, + 384 + ], + "score": 1.0, + "content": "F.4.2 SC09 SPEECH GENERATION", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 106, + 392, + 486, + 404 + ], + "lines": [ + { + "bbox": [ + 105, + 390, + 488, + 407 + ], + "spans": [ + { + "bbox": [ + 105, + 390, + 488, + 407 + ], + "score": 1.0, + "content": "Autoregressive training largely followed the autoregressive language modeling protocol, such as", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 133, + 413, + 317, + 476 + ], + "lines": [ + { + "bbox": [ + 133, + 412, + 213, + 427 + ], + "spans": [ + { + "bbox": [ + 133, + 412, + 213, + 427 + ], + "score": 1.0, + "content": "• Weight decay 0.1", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 133, + 430, + 318, + 443 + ], + "spans": [ + { + "bbox": [ + 133, + 430, + 245, + 443 + ], + "score": 1.0, + "content": "• Learning rate warmup for", + "type": "text" + }, + { + "bbox": [ + 246, + 430, + 265, + 441 + ], + "score": 0.86, + "content": "10 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 265, + 430, + 318, + 443 + ], + "score": 1.0, + "content": "of total steps", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 133, + 447, + 295, + 460 + ], + "spans": [ + { + "bbox": [ + 133, + 447, + 237, + 460 + ], + "score": 1.0, + "content": "• AdamW optimizer with", + "type": "text" + }, + { + "bbox": [ + 238, + 447, + 295, + 460 + ], + "score": 0.8, + "content": "\\beta = ( 0 . 9 , 0 . 9 5 )", + "type": "inline_equation" + } + ], + "index": 24 + }, + { + "bbox": [ + 133, + 464, + 234, + 477 + ], + "spans": [ + { + "bbox": [ + 133, + 464, + 234, + 477 + ], + "score": 1.0, + "content": "• Gradient clip value 0.1", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23.5 + }, + { + "type": "text", + "bbox": [ + 107, + 485, + 418, + 497 + ], + "lines": [ + { + "bbox": [ + 106, + 484, + 419, + 498 + ], + "spans": [ + { + "bbox": [ + 106, + 484, + 419, + 498 + ], + "score": 1.0, + "content": "We used a learning rate of 0.002 and 200000 training steps at a batch size of 16.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 107, + 501, + 506, + 545 + ], + "lines": [ + { + "bbox": [ + 105, + 500, + 506, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 456, + 514 + ], + "score": 1.0, + "content": "The large Mamba model in Table 3 has 15 layers per stage with an outer dimension of", + "type": "text" + }, + { + "bbox": [ + 456, + 501, + 487, + 511 + ], + "score": 0.9, + "content": "D = 9 6", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 500, + 506, + 514 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 511, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 505, + 525 + ], + "score": 1.0, + "content": "pooling factor 4. We note that this dataset is small (training went through 100 epochs) and for this large", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 522, + 505, + 535 + ], + "spans": [ + { + "bbox": [ + 106, + 522, + 505, + 535 + ], + "score": 1.0, + "content": "model, there was significant overfitting of the BPB or NLL. However, automated metrics of generated", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 532, + 312, + 547 + ], + "spans": [ + { + "bbox": [ + 105, + 532, + 312, + 547 + ], + "score": 1.0, + "content": "samples continually improving throughout training.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 28.5 + }, + { + "type": "text", + "bbox": [ + 106, + 549, + 505, + 593 + ], + "lines": [ + { + "bbox": [ + 105, + 549, + 506, + 561 + ], + "spans": [ + { + "bbox": [ + 105, + 549, + 506, + 561 + ], + "score": 1.0, + "content": "The models in the architecture ablations in Table 4 all have 8 layers per stage with an outer dimension of", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 559, + 506, + 572 + ], + "spans": [ + { + "bbox": [ + 106, + 560, + 133, + 570 + ], + "score": 0.88, + "content": "\\mathtt { D } = 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 134, + 559, + 234, + 572 + ], + "score": 1.0, + "content": "and pooling factor 4. The", + "type": "text" + }, + { + "bbox": [ + 234, + 560, + 271, + 570 + ], + "score": 0.73, + "content": "_ { \\mathbf { S 4 + M L P } }", + "type": "inline_equation" + }, + { + "bbox": [ + 271, + 559, + 343, + 572 + ], + "score": 1.0, + "content": "block has roughly", + "type": "text" + }, + { + "bbox": [ + 343, + 559, + 389, + 570 + ], + "score": 0.92, + "content": "\\dot { 2 } D ^ { 2 } \\dot { + } 4 D ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 389, + 559, + 506, + 572 + ], + "score": 1.0, + "content": "parameters (expansion factor", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 104, + 570, + 507, + 583 + ], + "spans": [ + { + "bbox": [ + 104, + 570, + 278, + 583 + ], + "score": 1.0, + "content": "2 in the MLP). The Transformer block has", + "type": "text" + }, + { + "bbox": [ + 279, + 570, + 325, + 581 + ], + "score": 0.92, + "content": "4 D ^ { 2 } + 2 D ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 326, + 570, + 507, + 583 + ], + "score": 1.0, + "content": "parameters (expansion factor 1 in the MLP).", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 104, + 579, + 493, + 594 + ], + "spans": [ + { + "bbox": [ + 104, + 579, + 232, + 594 + ], + "score": 1.0, + "content": "The Mamba block has the usual", + "type": "text" + }, + { + "bbox": [ + 232, + 581, + 261, + 591 + ], + "score": 0.9, + "content": "{ \\approx } 6 D ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 261, + 579, + 493, + 594 + ], + "score": 1.0, + "content": "parameters. All models have roughly 6M total parameters.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32.5 + }, + { + "type": "title", + "bbox": [ + 107, + 602, + 218, + 614 + ], + "lines": [ + { + "bbox": [ + 105, + 602, + 219, + 615 + ], + "spans": [ + { + "bbox": [ + 105, + 602, + 219, + 615 + ], + "score": 1.0, + "content": "F.5 SPEED BENCHMARK", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 107, + 618, + 504, + 640 + ], + "lines": [ + { + "bbox": [ + 106, + 618, + 505, + 631 + ], + "spans": [ + { + "bbox": [ + 106, + 618, + 505, + 631 + ], + "score": 1.0, + "content": "Scan operation. We compare the core operation of selective SSMs, which is the parallel scan", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 630, + 458, + 641 + ], + "spans": [ + { + "bbox": [ + 105, + 630, + 458, + 641 + ], + "score": 1.0, + "content": "(Section 3.3), against convolution and attention, measured on an A100 80GB PCIe GPU.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36.5 + }, + { + "type": "text", + "bbox": [ + 107, + 644, + 504, + 668 + ], + "lines": [ + { + "bbox": [ + 106, + 644, + 505, + 657 + ], + "spans": [ + { + "bbox": [ + 106, + 644, + 505, + 657 + ], + "score": 1.0, + "content": "As a baseline, we implement a standard parallel scan in PyTorch with no kernel fusion. This requires", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 655, + 292, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 657, + 223, + 669 + ], + "score": 1.0, + "content": "materializing the parameters", + "type": "text" + }, + { + "bbox": [ + 223, + 655, + 254, + 668 + ], + "score": 0.34, + "content": "{ \\overline { { A } } } , { \\overline { { B } } } , C", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 657, + 292, + 669 + ], + "score": 1.0, + "content": "in HBM.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38.5 + }, + { + "type": "text", + "bbox": [ + 108, + 672, + 504, + 695 + ], + "lines": [ + { + "bbox": [ + 106, + 672, + 505, + 685 + ], + "spans": [ + { + "bbox": [ + 106, + 672, + 505, + 685 + ], + "score": 1.0, + "content": "Our scan implementation fuses the discretization step and the parallel scan, avoiding the cost of", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 683, + 292, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 683, + 292, + 695 + ], + "score": 1.0, + "content": "materializing all the large parameters in HBM.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40.5 + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "score": 1.0, + "content": "For convolution, we use the standard implementation in PyTorch, which separately performs FFTs on", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "the inputs and the filters, multiply them in frequency domain, then performs an inverse FFT to obtain", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 720, + 408, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 265, + 734 + ], + "score": 1.0, + "content": "the result. The theoretical complexity is", + "type": "text" + }, + { + "bbox": [ + 265, + 721, + 315, + 732 + ], + "score": 0.92, + "content": "O ( L \\log ( L ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 316, + 720, + 396, + 734 + ], + "score": 1.0, + "content": "for sequence length", + "type": "text" + }, + { + "bbox": [ + 396, + 721, + 403, + 730 + ], + "score": 0.74, + "content": "L", + "type": "inline_equation" + }, + { + "bbox": [ + 404, + 720, + 408, + 734 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43 + } + ], + "page_idx": 25, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "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 + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 304, + 37 + ], + "lines": [ + { + "bbox": [ + 107, + 25, + 304, + 38 + ], + "spans": [ + { + "bbox": [ + 107, + 25, + 304, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 201, + 99, + 407, + 209 + ], + "blocks": [ + { + "type": "table_caption", + "bbox": [ + 177, + 80, + 433, + 91 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 177, + 79, + 434, + 92 + ], + "spans": [ + { + "bbox": [ + 177, + 79, + 434, + 92 + ], + "score": 1.0, + "content": "Table 13: YouTubeMix length scaling sequence lengths and batch sizes.", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "table_body", + "bbox": [ + 201, + 99, + 407, + 209 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 201, + 99, + 407, + 209 + ], + "spans": [ + { + "bbox": [ + 201, + 99, + 407, + 209 + ], + "score": 0.98, + "html": "
Sequence length Batch size Tokens per batch
468×2048=958464 1958464
234×2048=479232 2958464
117×2048=239616 4958464
59×2048=120832 8966656
30×2048=61440 16983040
15×2048=30720 32983040
8×2048=16384 641048576
4×2048=8192 1281048576
", + "type": "table", + "image_path": "3b17858478af9cf1adccbf8a84f43d29e8feed28f6198ef701e87d4f92ded65f.jpg" + } + ] + } + ], + "index": 4.5, + "virtual_lines": [ + { + "bbox": [ + 201, + 99, + 407, + 112.75 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 201, + 112.75, + 407, + 126.5 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 201, + 126.5, + 407, + 140.25 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 201, + 140.25, + 407, + 154.0 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 201, + 154.0, + 407, + 167.75 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 201, + 167.75, + 407, + 181.5 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 201, + 181.5, + 407, + 195.25 + ], + "spans": [], + "index": 7 + }, + { + "bbox": [ + 201, + 195.25, + 407, + 209.0 + ], + "spans": [], + "index": 8 + } + ] + } + ], + "index": 2.25 + }, + { + "type": "text", + "bbox": [ + 107, + 227, + 505, + 282 + ], + "lines": [ + { + "bbox": [ + 106, + 227, + 505, + 239 + ], + "spans": [ + { + "bbox": [ + 106, + 227, + 505, + 239 + ], + "score": 1.0, + "content": "The dataset consists of clips of up to 1 minute long, or length 960000, which is subsampled and divided", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 237, + 505, + 252 + ], + "spans": [ + { + "bbox": [ + 105, + 237, + 505, + 252 + ], + "score": 1.0, + "content": "into segments of any desired sequence length. Since the architecture involves two stages of pooling by", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 104, + 246, + 507, + 263 + ], + "spans": [ + { + "bbox": [ + 104, + 246, + 507, + 263 + ], + "score": 1.0, + "content": "a factor of 16, and we want the resulting sequence length to be a a multiple of 8 for hardware efficiency,", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 259, + 505, + 272 + ], + "spans": [ + { + "bbox": [ + 106, + 259, + 236, + 272 + ], + "score": 1.0, + "content": "the longest possible sequence is", + "type": "text" + }, + { + "bbox": [ + 236, + 260, + 322, + 270 + ], + "score": 0.91, + "content": "4 6 8 \\times 2 0 4 8 = 9 5 8 4 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 322, + 259, + 505, + 272 + ], + "score": 1.0, + "content": ". The rest of our sequence lengths are defined", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 270, + 409, + 282 + ], + "spans": [ + { + "bbox": [ + 105, + 270, + 409, + 282 + ], + "score": 1.0, + "content": "by successively halving this and rounding up to the nearest multiple of 2048.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 11, + "bbox_fs": [ + 104, + 227, + 507, + 282 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 285, + 505, + 330 + ], + "lines": [ + { + "bbox": [ + 105, + 285, + 505, + 298 + ], + "spans": [ + { + "bbox": [ + 105, + 285, + 505, + 298 + ], + "score": 1.0, + "content": "Table 13 lists the specifications used in Figure 7. Beyond the varying batch sizes, the number of valid", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 296, + 506, + 311 + ], + "spans": [ + { + "bbox": [ + 105, + 296, + 506, + 311 + ], + "score": 1.0, + "content": "segments in the training set varied between different sequence lengths (e.g. the number of training", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 308, + 505, + 320 + ], + "spans": [ + { + "bbox": [ + 105, + 308, + 505, + 320 + ], + "score": 1.0, + "content": "steps per epoch was not constant for different points in the graph), which may have contributed to", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 318, + 215, + 331 + ], + "spans": [ + { + "bbox": [ + 105, + 318, + 215, + 331 + ], + "score": 1.0, + "content": "kinks in the scaling curves.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15.5, + "bbox_fs": [ + 105, + 285, + 506, + 331 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 339, + 505, + 362 + ], + "lines": [ + { + "bbox": [ + 106, + 339, + 504, + 352 + ], + "spans": [ + { + "bbox": [ + 106, + 339, + 249, + 352 + ], + "score": 1.0, + "content": "Training. Models were trained for", + "type": "text" + }, + { + "bbox": [ + 249, + 340, + 275, + 350 + ], + "score": 0.87, + "content": "2 0 0 K", + "type": "inline_equation" + }, + { + "bbox": [ + 275, + 339, + 483, + 352 + ], + "score": 1.0, + "content": "training steps with a maximum learning rate of 0.002,", + "type": "text" + }, + { + "bbox": [ + 483, + 339, + 504, + 350 + ], + "score": 0.54, + "content": "2 0 K", + "type": "inline_equation" + } + ], + "index": 18 + }, + { + "bbox": [ + 107, + 350, + 506, + 363 + ], + "spans": [ + { + "bbox": [ + 107, + 351, + 132, + 362 + ], + "score": 0.79, + "content": "( 1 0 \\% )", + "type": "inline_equation" + }, + { + "bbox": [ + 132, + 350, + 506, + 363 + ], + "score": 1.0, + "content": "warmup steps, and weight decay 0.1 (similar to our general pretraining recipe across domains).", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18.5, + "bbox_fs": [ + 106, + 339, + 506, + 363 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 371, + 259, + 383 + ], + "lines": [ + { + "bbox": [ + 105, + 370, + 260, + 384 + ], + "spans": [ + { + "bbox": [ + 105, + 370, + 260, + 384 + ], + "score": 1.0, + "content": "F.4.2 SC09 SPEECH GENERATION", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 106, + 392, + 486, + 404 + ], + "lines": [ + { + "bbox": [ + 105, + 390, + 488, + 407 + ], + "spans": [ + { + "bbox": [ + 105, + 390, + 488, + 407 + ], + "score": 1.0, + "content": "Autoregressive training largely followed the autoregressive language modeling protocol, such as", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21, + "bbox_fs": [ + 105, + 390, + 488, + 407 + ] + }, + { + "type": "list", + "bbox": [ + 133, + 413, + 317, + 476 + ], + "lines": [ + { + "bbox": [ + 133, + 412, + 213, + 427 + ], + "spans": [ + { + "bbox": [ + 133, + 412, + 213, + 427 + ], + "score": 1.0, + "content": "• Weight decay 0.1", + "type": "text" + } + ], + "index": 22, + "is_list_start_line": true + }, + { + "bbox": [ + 133, + 430, + 318, + 443 + ], + "spans": [ + { + "bbox": [ + 133, + 430, + 245, + 443 + ], + "score": 1.0, + "content": "• Learning rate warmup for", + "type": "text" + }, + { + "bbox": [ + 246, + 430, + 265, + 441 + ], + "score": 0.86, + "content": "10 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 265, + 430, + 318, + 443 + ], + "score": 1.0, + "content": "of total steps", + "type": "text" + } + ], + "index": 23, + "is_list_start_line": true + }, + { + "bbox": [ + 133, + 447, + 295, + 460 + ], + "spans": [ + { + "bbox": [ + 133, + 447, + 237, + 460 + ], + "score": 1.0, + "content": "• AdamW optimizer with", + "type": "text" + }, + { + "bbox": [ + 238, + 447, + 295, + 460 + ], + "score": 0.8, + "content": "\\beta = ( 0 . 9 , 0 . 9 5 )", + "type": "inline_equation" + } + ], + "index": 24, + "is_list_start_line": true + }, + { + "bbox": [ + 133, + 464, + 234, + 477 + ], + "spans": [ + { + "bbox": [ + 133, + 464, + 234, + 477 + ], + "score": 1.0, + "content": "• Gradient clip value 0.1", + "type": "text" + } + ], + "index": 25, + "is_list_start_line": true + } + ], + "index": 23.5, + "bbox_fs": [ + 133, + 412, + 318, + 477 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 485, + 418, + 497 + ], + "lines": [ + { + "bbox": [ + 106, + 484, + 419, + 498 + ], + "spans": [ + { + "bbox": [ + 106, + 484, + 419, + 498 + ], + "score": 1.0, + "content": "We used a learning rate of 0.002 and 200000 training steps at a batch size of 16.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 26, + "bbox_fs": [ + 106, + 484, + 419, + 498 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 501, + 506, + 545 + ], + "lines": [ + { + "bbox": [ + 105, + 500, + 506, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 456, + 514 + ], + "score": 1.0, + "content": "The large Mamba model in Table 3 has 15 layers per stage with an outer dimension of", + "type": "text" + }, + { + "bbox": [ + 456, + 501, + 487, + 511 + ], + "score": 0.9, + "content": "D = 9 6", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 500, + 506, + 514 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 511, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 505, + 525 + ], + "score": 1.0, + "content": "pooling factor 4. We note that this dataset is small (training went through 100 epochs) and for this large", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 522, + 505, + 535 + ], + "spans": [ + { + "bbox": [ + 106, + 522, + 505, + 535 + ], + "score": 1.0, + "content": "model, there was significant overfitting of the BPB or NLL. However, automated metrics of generated", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 532, + 312, + 547 + ], + "spans": [ + { + "bbox": [ + 105, + 532, + 312, + 547 + ], + "score": 1.0, + "content": "samples continually improving throughout training.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 28.5, + "bbox_fs": [ + 105, + 500, + 506, + 547 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 549, + 505, + 593 + ], + "lines": [ + { + "bbox": [ + 105, + 549, + 506, + 561 + ], + "spans": [ + { + "bbox": [ + 105, + 549, + 506, + 561 + ], + "score": 1.0, + "content": "The models in the architecture ablations in Table 4 all have 8 layers per stage with an outer dimension of", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 559, + 506, + 572 + ], + "spans": [ + { + "bbox": [ + 106, + 560, + 133, + 570 + ], + "score": 0.88, + "content": "\\mathtt { D } = 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 134, + 559, + 234, + 572 + ], + "score": 1.0, + "content": "and pooling factor 4. The", + "type": "text" + }, + { + "bbox": [ + 234, + 560, + 271, + 570 + ], + "score": 0.73, + "content": "_ { \\mathbf { S 4 + M L P } }", + "type": "inline_equation" + }, + { + "bbox": [ + 271, + 559, + 343, + 572 + ], + "score": 1.0, + "content": "block has roughly", + "type": "text" + }, + { + "bbox": [ + 343, + 559, + 389, + 570 + ], + "score": 0.92, + "content": "\\dot { 2 } D ^ { 2 } \\dot { + } 4 D ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 389, + 559, + 506, + 572 + ], + "score": 1.0, + "content": "parameters (expansion factor", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 104, + 570, + 507, + 583 + ], + "spans": [ + { + "bbox": [ + 104, + 570, + 278, + 583 + ], + "score": 1.0, + "content": "2 in the MLP). The Transformer block has", + "type": "text" + }, + { + "bbox": [ + 279, + 570, + 325, + 581 + ], + "score": 0.92, + "content": "4 D ^ { 2 } + 2 D ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 326, + 570, + 507, + 583 + ], + "score": 1.0, + "content": "parameters (expansion factor 1 in the MLP).", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 104, + 579, + 493, + 594 + ], + "spans": [ + { + "bbox": [ + 104, + 579, + 232, + 594 + ], + "score": 1.0, + "content": "The Mamba block has the usual", + "type": "text" + }, + { + "bbox": [ + 232, + 581, + 261, + 591 + ], + "score": 0.9, + "content": "{ \\approx } 6 D ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 261, + 579, + 493, + 594 + ], + "score": 1.0, + "content": "parameters. All models have roughly 6M total parameters.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32.5, + "bbox_fs": [ + 104, + 549, + 507, + 594 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 602, + 218, + 614 + ], + "lines": [ + { + "bbox": [ + 105, + 602, + 219, + 615 + ], + "spans": [ + { + "bbox": [ + 105, + 602, + 219, + 615 + ], + "score": 1.0, + "content": "F.5 SPEED BENCHMARK", + "type": "text" + } + ], + "index": 35 + } + ], + "index": 35 + }, + { + "type": "text", + "bbox": [ + 107, + 618, + 504, + 640 + ], + "lines": [ + { + "bbox": [ + 106, + 618, + 505, + 631 + ], + "spans": [ + { + "bbox": [ + 106, + 618, + 505, + 631 + ], + "score": 1.0, + "content": "Scan operation. We compare the core operation of selective SSMs, which is the parallel scan", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 630, + 458, + 641 + ], + "spans": [ + { + "bbox": [ + 105, + 630, + 458, + 641 + ], + "score": 1.0, + "content": "(Section 3.3), against convolution and attention, measured on an A100 80GB PCIe GPU.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36.5, + "bbox_fs": [ + 105, + 618, + 505, + 641 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 644, + 504, + 668 + ], + "lines": [ + { + "bbox": [ + 106, + 644, + 505, + 657 + ], + "spans": [ + { + "bbox": [ + 106, + 644, + 505, + 657 + ], + "score": 1.0, + "content": "As a baseline, we implement a standard parallel scan in PyTorch with no kernel fusion. This requires", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 655, + 292, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 657, + 223, + 669 + ], + "score": 1.0, + "content": "materializing the parameters", + "type": "text" + }, + { + "bbox": [ + 223, + 655, + 254, + 668 + ], + "score": 0.34, + "content": "{ \\overline { { A } } } , { \\overline { { B } } } , C", + "type": "inline_equation" + }, + { + "bbox": [ + 255, + 657, + 292, + 669 + ], + "score": 1.0, + "content": "in HBM.", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38.5, + "bbox_fs": [ + 105, + 644, + 505, + 669 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 672, + 504, + 695 + ], + "lines": [ + { + "bbox": [ + 106, + 672, + 505, + 685 + ], + "spans": [ + { + "bbox": [ + 106, + 672, + 505, + 685 + ], + "score": 1.0, + "content": "Our scan implementation fuses the discretization step and the parallel scan, avoiding the cost of", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 683, + 292, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 683, + 292, + 695 + ], + "score": 1.0, + "content": "materializing all the large parameters in HBM.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40.5, + "bbox_fs": [ + 105, + 672, + 505, + 695 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 712 + ], + "score": 1.0, + "content": "For convolution, we use the standard implementation in PyTorch, which separately performs FFTs on", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "the inputs and the filters, multiply them in frequency domain, then performs an inverse FFT to obtain", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 720, + 408, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 265, + 734 + ], + "score": 1.0, + "content": "the result. The theoretical complexity is", + "type": "text" + }, + { + "bbox": [ + 265, + 721, + 315, + 732 + ], + "score": 0.92, + "content": "O ( L \\log ( L ) )", + "type": "inline_equation" + }, + { + "bbox": [ + 316, + 720, + 396, + 734 + ], + "score": 1.0, + "content": "for sequence length", + "type": "text" + }, + { + "bbox": [ + 396, + 721, + 403, + 730 + ], + "score": 0.74, + "content": "L", + "type": "inline_equation" + }, + { + "bbox": [ + 404, + 720, + 408, + 734 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 43, + "bbox_fs": [ + 105, + 699, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 504, + 115 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 506, + 94 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 506, + 94 + ], + "score": 1.0, + "content": "For attention, we compare against the fastest implementation that we are aware of (FlashAttention-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 93, + 506, + 105 + ], + "spans": [ + { + "bbox": [ + 106, + 93, + 458, + 105 + ], + "score": 1.0, + "content": "2 (Dao, 2023)), with causal mask. Note that FlashAttention-2 with causal mask is about", + "type": "text" + }, + { + "bbox": [ + 458, + 93, + 480, + 104 + ], + "score": 0.9, + "content": "1 . 7 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 480, + 93, + 506, + 105 + ], + "score": 1.0, + "content": "faster", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 478, + 116 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 478, + 116 + ], + "score": 1.0, + "content": "than without causal mask, since approximately only half of the attention entries are computed.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 107, + 119, + 505, + 163 + ], + "lines": [ + { + "bbox": [ + 105, + 119, + 505, + 132 + ], + "spans": [ + { + "bbox": [ + 105, + 119, + 505, + 132 + ], + "score": 1.0, + "content": "We use batch size of 1 and increase the sequence length from 512, 1K, 2K, ... to 512K (some of the", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 130, + 506, + 142 + ], + "spans": [ + { + "bbox": [ + 105, + 130, + 445, + 142 + ], + "score": 1.0, + "content": "baselines run out of memory before reaching 512K). We use a model dimension of", + "type": "text" + }, + { + "bbox": [ + 445, + 131, + 487, + 141 + ], + "score": 0.91, + "content": "D = 1 0 2 4", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 130, + 506, + 142 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 140, + 506, + 154 + ], + "spans": [ + { + "bbox": [ + 105, + 140, + 171, + 154 + ], + "score": 1.0, + "content": "state dimension", + "type": "text" + }, + { + "bbox": [ + 171, + 141, + 201, + 151 + ], + "score": 0.89, + "content": "N { = } 1 6", + "type": "inline_equation" + }, + { + "bbox": [ + 202, + 140, + 506, + 154 + ], + "score": 1.0, + "content": ". We measure with BF16 inputs, which is the data type most commonly used", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 151, + 200, + 165 + ], + "spans": [ + { + "bbox": [ + 105, + 151, + 200, + 165 + ], + "score": 1.0, + "content": "for large scale training.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + }, + { + "type": "text", + "bbox": [ + 107, + 171, + 504, + 205 + ], + "lines": [ + { + "bbox": [ + 106, + 172, + 505, + 183 + ], + "spans": [ + { + "bbox": [ + 106, + 172, + 505, + 183 + ], + "score": 1.0, + "content": "End-to-end inference. We measure the inference throughput of a Mamba 1.4B model and an", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 182, + 505, + 194 + ], + "spans": [ + { + "bbox": [ + 105, + 182, + 505, + 194 + ], + "score": 1.0, + "content": "untrained Mamba 6.9B model, against a standard Transformer (GPT3 architecture) at 1.3B and 6.7B", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 193, + 505, + 206 + ], + "spans": [ + { + "bbox": [ + 105, + 193, + 505, + 206 + ], + "score": 1.0, + "content": "size. We use the standard Transformer implementation in the Huggingface transformers library.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 107, + 209, + 505, + 252 + ], + "lines": [ + { + "bbox": [ + 105, + 209, + 505, + 222 + ], + "spans": [ + { + "bbox": [ + 105, + 209, + 505, + 222 + ], + "score": 1.0, + "content": "We set the prompt length to be 2048 and the generation length to be 128. We vary the batch size from", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 220, + 506, + 232 + ], + "spans": [ + { + "bbox": [ + 105, + 220, + 506, + 232 + ], + "score": 1.0, + "content": "1, 2, 4, 8, 16, 32, 64, to 128, and measure time time taken to generate 128 tokens. We then calculate", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 230, + 506, + 243 + ], + "spans": [ + { + "bbox": [ + 105, + 230, + 245, + 243 + ], + "score": 1.0, + "content": "the throughput (tokens/s) as batch", + "type": "text" + }, + { + "bbox": [ + 245, + 231, + 288, + 241 + ], + "score": 0.58, + "content": "{ \\mathrm { s i z e } } \\times 1 2 8 ", + "type": "inline_equation" + }, + { + "bbox": [ + 288, + 230, + 506, + 243 + ], + "score": 1.0, + "content": "/time taken. We repeat the measurements 3 times and", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 242, + 390, + 253 + ], + "spans": [ + { + "bbox": [ + 105, + 242, + 390, + 253 + ], + "score": 1.0, + "content": "take the average. Measurements are done on an A100 80GB PCIe GPU.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 11.5 + } + ], + "page_idx": 26, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 108, + 27, + 304, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 305, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 305, + 38 + ], + "score": 1.0, + "content": "Under review as a conference paper at ICLR 2024", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 298, + 750, + 313, + 765 + ], + "spans": [ + { + "bbox": [ + 298, + 750, + 313, + 765 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 15, + "width": 15 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 106, + 82, + 504, + 115 + ], + "lines": [ + { + "bbox": [ + 106, + 82, + 506, + 94 + ], + "spans": [ + { + "bbox": [ + 106, + 82, + 506, + 94 + ], + "score": 1.0, + "content": "For attention, we compare against the fastest implementation that we are aware of (FlashAttention-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 93, + 506, + 105 + ], + "spans": [ + { + "bbox": [ + 106, + 93, + 458, + 105 + ], + "score": 1.0, + "content": "2 (Dao, 2023)), with causal mask. Note that FlashAttention-2 with causal mask is about", + "type": "text" + }, + { + "bbox": [ + 458, + 93, + 480, + 104 + ], + "score": 0.9, + "content": "1 . 7 \\times", + "type": "inline_equation" + }, + { + "bbox": [ + 480, + 93, + 506, + 105 + ], + "score": 1.0, + "content": "faster", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 104, + 478, + 116 + ], + "spans": [ + { + "bbox": [ + 105, + 104, + 478, + 116 + ], + "score": 1.0, + "content": "than without causal mask, since approximately only half of the attention entries are computed.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1, + "bbox_fs": [ + 105, + 82, + 506, + 116 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 119, + 505, + 163 + ], + "lines": [ + { + "bbox": [ + 105, + 119, + 505, + 132 + ], + "spans": [ + { + "bbox": [ + 105, + 119, + 505, + 132 + ], + "score": 1.0, + "content": "We use batch size of 1 and increase the sequence length from 512, 1K, 2K, ... to 512K (some of the", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 130, + 506, + 142 + ], + "spans": [ + { + "bbox": [ + 105, + 130, + 445, + 142 + ], + "score": 1.0, + "content": "baselines run out of memory before reaching 512K). We use a model dimension of", + "type": "text" + }, + { + "bbox": [ + 445, + 131, + 487, + 141 + ], + "score": 0.91, + "content": "D = 1 0 2 4", + "type": "inline_equation" + }, + { + "bbox": [ + 487, + 130, + 506, + 142 + ], + "score": 1.0, + "content": "and", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 140, + 506, + 154 + ], + "spans": [ + { + "bbox": [ + 105, + 140, + 171, + 154 + ], + "score": 1.0, + "content": "state dimension", + "type": "text" + }, + { + "bbox": [ + 171, + 141, + 201, + 151 + ], + "score": 0.89, + "content": "N { = } 1 6", + "type": "inline_equation" + }, + { + "bbox": [ + 202, + 140, + 506, + 154 + ], + "score": 1.0, + "content": ". We measure with BF16 inputs, which is the data type most commonly used", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 151, + 200, + 165 + ], + "spans": [ + { + "bbox": [ + 105, + 151, + 200, + 165 + ], + "score": 1.0, + "content": "for large scale training.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5, + "bbox_fs": [ + 105, + 119, + 506, + 165 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 171, + 504, + 205 + ], + "lines": [ + { + "bbox": [ + 106, + 172, + 505, + 183 + ], + "spans": [ + { + "bbox": [ + 106, + 172, + 505, + 183 + ], + "score": 1.0, + "content": "End-to-end inference. We measure the inference throughput of a Mamba 1.4B model and an", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 182, + 505, + 194 + ], + "spans": [ + { + "bbox": [ + 105, + 182, + 505, + 194 + ], + "score": 1.0, + "content": "untrained Mamba 6.9B model, against a standard Transformer (GPT3 architecture) at 1.3B and 6.7B", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 193, + 505, + 206 + ], + "spans": [ + { + "bbox": [ + 105, + 193, + 505, + 206 + ], + "score": 1.0, + "content": "size. We use the standard Transformer implementation in the Huggingface transformers library.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8, + "bbox_fs": [ + 105, + 172, + 505, + 206 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 209, + 505, + 252 + ], + "lines": [ + { + "bbox": [ + 105, + 209, + 505, + 222 + ], + "spans": [ + { + "bbox": [ + 105, + 209, + 505, + 222 + ], + "score": 1.0, + "content": "We set the prompt length to be 2048 and the generation length to be 128. We vary the batch size from", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 220, + 506, + 232 + ], + "spans": [ + { + "bbox": [ + 105, + 220, + 506, + 232 + ], + "score": 1.0, + "content": "1, 2, 4, 8, 16, 32, 64, to 128, and measure time time taken to generate 128 tokens. We then calculate", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 230, + 506, + 243 + ], + "spans": [ + { + "bbox": [ + 105, + 230, + 245, + 243 + ], + "score": 1.0, + "content": "the throughput (tokens/s) as batch", + "type": "text" + }, + { + "bbox": [ + 245, + 231, + 288, + 241 + ], + "score": 0.58, + "content": "{ \\mathrm { s i z e } } \\times 1 2 8 ", + "type": "inline_equation" + }, + { + "bbox": [ + 288, + 230, + 506, + 243 + ], + "score": 1.0, + "content": "/time taken. We repeat the measurements 3 times and", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 242, + 390, + 253 + ], + "spans": [ + { + "bbox": [ + 105, + 242, + 390, + 253 + ], + "score": 1.0, + "content": "take the average. Measurements are done on an A100 80GB PCIe GPU.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 11.5, + "bbox_fs": [ + 105, + 209, + 506, + 253 + ] + } + ] + } + ], + "_backend": "pipeline", + "_version_name": "2.1.11" +} \ No newline at end of file