diff --git "a/parse/dev/JTmO2V9Xpz/JTmO2V9Xpz_middle.json" "b/parse/dev/JTmO2V9Xpz/JTmO2V9Xpz_middle.json" new file mode 100644--- /dev/null +++ "b/parse/dev/JTmO2V9Xpz/JTmO2V9Xpz_middle.json" @@ -0,0 +1,43730 @@ +{ + "pdf_info": [ + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 112, + 97, + 500, + 137 + ], + "lines": [ + { + "bbox": [ + 110, + 96, + 500, + 119 + ], + "spans": [ + { + "bbox": [ + 110, + 96, + 500, + 119 + ], + "score": 1.0, + "content": "MEGABYTE: Modeling Million-byte Sequences with", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 212, + 117, + 398, + 138 + ], + "spans": [ + { + "bbox": [ + 212, + 117, + 398, + 138 + ], + "score": 1.0, + "content": "Multiscale Transformers", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 160, + 175, + 452, + 188 + ], + "lines": [ + { + "bbox": [ + 158, + 173, + 454, + 191 + ], + "spans": [ + { + "bbox": [ + 158, + 173, + 454, + 191 + ], + "score": 1.0, + "content": "Lili Yu∗ Dániel Simig∗ Colin Flaherty∗ Armen Aghajanyan", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 235, + 204, + 376, + 216 + ], + "lines": [ + { + "bbox": [ + 232, + 203, + 378, + 218 + ], + "spans": [ + { + "bbox": [ + 232, + 203, + 378, + 218 + ], + "score": 1.0, + "content": "Luke Zettlemoyer Mike Lewis", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 288, + 226, + 322, + 237 + ], + "lines": [ + { + "bbox": [ + 286, + 225, + 325, + 238 + ], + "spans": [ + { + "bbox": [ + 286, + 225, + 325, + 238 + ], + "score": 1.0, + "content": "Meta AI", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4 + }, + { + "type": "title", + "bbox": [ + 283, + 266, + 328, + 279 + ], + "lines": [ + { + "bbox": [ + 281, + 265, + 330, + 281 + ], + "spans": [ + { + "bbox": [ + 281, + 265, + 330, + 281 + ], + "score": 1.0, + "content": "Abstract", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 143, + 291, + 469, + 433 + ], + "lines": [ + { + "bbox": [ + 141, + 291, + 469, + 303 + ], + "spans": [ + { + "bbox": [ + 141, + 291, + 469, + 303 + ], + "score": 1.0, + "content": "Autoregressive transformers are spectacular models for short sequences but scale", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 302, + 471, + 314 + ], + "spans": [ + { + "bbox": [ + 141, + 302, + 471, + 314 + ], + "score": 1.0, + "content": "poorly to long sequences such as high-resolution images, podcasts, code, or books.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 313, + 471, + 326 + ], + "spans": [ + { + "bbox": [ + 141, + 313, + 471, + 326 + ], + "score": 1.0, + "content": "We propose MEGABYTE, a multi-scale decoder architecture that enables end-to-ModModelModelModel", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 324, + 470, + 336 + ], + "spans": [ + { + "bbox": [ + 141, + 324, + 470, + 336 + ], + "score": 1.0, + "content": "end differentiable modeling of sequences of over one million bytes. MEGABYTE", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 141, + 336, + 470, + 347 + ], + "spans": [ + { + "bbox": [ + 141, + 336, + 470, + 347 + ], + "score": 1.0, + "content": "segments sequences into patches and uses a local submodel within patches and a_ m e g _ b y t _ ' ' t r _ n", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 347, + 469, + 358 + ], + "spans": [ + { + "bbox": [ + 141, + 347, + 469, + 358 + ], + "score": 1.0, + "content": "global model between patches. This enables sub-quadratic self-attention, much", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 357, + 470, + 370 + ], + "spans": [ + { + "bbox": [ + 141, + 357, + 470, + 370 + ], + "score": 1.0, + "content": "larger feedforward layers for the same compute, and improved parallelism during", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 367, + 470, + 380 + ], + "spans": [ + { + "bbox": [ + 141, + 367, + 470, + 380 + ], + "score": 1.0, + "content": "decoding—unlocking better performance at reduced cost for both training and gen-Global Model", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 379, + 470, + 390 + ], + "spans": [ + { + "bbox": [ + 141, + 379, + 470, + 390 + ], + "score": 1.0, + "content": "eration. Extensive experiments show that MEGABYTE allows byte-level models", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 390, + 470, + 401 + ], + "spans": [ + { + "bbox": [ + 141, + 390, + 470, + 401 + ], + "score": 1.0, + "content": "to perform competitively with subword models on long context language mod-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 401, + 469, + 413 + ], + "spans": [ + { + "bbox": [ + 141, + 401, + 469, + 413 + ], + "score": 1.0, + "content": "eling, achieve state-of-the-art density estimation on ImageNet, and model audio", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 411, + 469, + 424 + ], + "spans": [ + { + "bbox": [ + 141, + 411, + 469, + 424 + ], + "score": 1.0, + "content": "from raw files. Together, these results establish the viability of tokenization-free", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 141, + 423, + 316, + 435 + ], + "spans": [ + { + "bbox": [ + 141, + 423, + 316, + 435 + ], + "score": 1.0, + "content": "autoregressive sequence modeling at scale.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 12 + }, + { + "type": "title", + "bbox": [ + 107, + 447, + 191, + 461 + ], + "lines": [ + { + "bbox": [ + 105, + 446, + 192, + 464 + ], + "spans": [ + { + "bbox": [ + 105, + 446, + 192, + 464 + ], + "score": 1.0, + "content": "1 Introduction", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 107, + 467, + 297, + 587 + ], + "lines": [ + { + "bbox": [ + 106, + 467, + 298, + 479 + ], + "spans": [ + { + "bbox": [ + 106, + 467, + 298, + 479 + ], + "score": 1.0, + "content": "Sequences of millions of bytes are ubiquitous;", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 478, + 298, + 490 + ], + "spans": [ + { + "bbox": [ + 106, + 478, + 298, + 490 + ], + "score": 1.0, + "content": "for example, music, image, or video files typi-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 489, + 298, + 501 + ], + "spans": [ + { + "bbox": [ + 106, + 489, + 298, + 501 + ], + "score": 1.0, + "content": "cally consist of multiple megabytes. However,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 499, + 298, + 513 + ], + "spans": [ + { + "bbox": [ + 105, + 499, + 298, + 513 + ], + "score": 1.0, + "content": "large transformer decoders (LLMs) typically", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 511, + 297, + 522 + ], + "spans": [ + { + "bbox": [ + 106, + 511, + 297, + 522 + ], + "score": 1.0, + "content": "only use several thousand tokens of context", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 522, + 297, + 533 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 297, + 533 + ], + "score": 1.0, + "content": "(Brown et al., 2020; Zhang et al., 2022a)—both", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 533, + 297, + 545 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 297, + 545 + ], + "score": 1.0, + "content": "because of the quadratic cost of self-attention", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 543, + 298, + 555 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 298, + 555 + ], + "score": 1.0, + "content": "but also, more importantly, the cost of large feed-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 554, + 298, + 567 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 298, + 567 + ], + "score": 1.0, + "content": "forward networks per-position. This severely", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 564, + 299, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 564, + 299, + 579 + ], + "score": 1.0, + "content": "limits the set of tasks where LLMs can be ap-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 576, + 132, + 589 + ], + "spans": [ + { + "bbox": [ + 105, + 576, + 132, + 589 + ], + "score": 1.0, + "content": "plied.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 107, + 593, + 297, + 702 + ], + "lines": [ + { + "bbox": [ + 105, + 591, + 297, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 591, + 297, + 605 + ], + "score": 1.0, + "content": "We introduce MEGABYTE, a new approach to", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 604, + 298, + 616 + ], + "spans": [ + { + "bbox": [ + 106, + 604, + 298, + 616 + ], + "score": 1.0, + "content": "modeling long byte sequences. First, byte se-", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 614, + 298, + 627 + ], + "spans": [ + { + "bbox": [ + 105, + 614, + 298, + 627 + ], + "score": 1.0, + "content": "quences are segmented into fixed-sized patches,", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 626, + 297, + 637 + ], + "spans": [ + { + "bbox": [ + 106, + 626, + 297, + 637 + ], + "score": 1.0, + "content": "loosely analogous to tokens. Our model then", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 636, + 298, + 649 + ], + "spans": [ + { + "bbox": [ + 105, + 636, + 298, + 649 + ], + "score": 1.0, + "content": "consists of three parts: (1) a patch embedder,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 648, + 298, + 659 + ], + "spans": [ + { + "bbox": [ + 106, + 648, + 298, + 659 + ], + "score": 1.0, + "content": "which simply encodes a patch by losslessly con-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 658, + 298, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 298, + 669 + ], + "score": 1.0, + "content": "catenating embeddings of each byte, (2) a global", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 669, + 298, + 681 + ], + "spans": [ + { + "bbox": [ + 106, + 669, + 298, + 681 + ], + "score": 1.0, + "content": "module, a large autoregressive transformer that", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 680, + 298, + 692 + ], + "spans": [ + { + "bbox": [ + 106, + 680, + 298, + 692 + ], + "score": 1.0, + "content": "inputs and outputs patch representations and (3)", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 691, + 297, + 703 + ], + "spans": [ + { + "bbox": [ + 105, + 691, + 297, + 703 + ], + "score": 1.0, + "content": "a local module, a small autoregressive model", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 35.5 + }, + { + "type": "image", + "bbox": [ + 311, + 462, + 498, + 618 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 311, + 462, + 498, + 618 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 311, + 462, + 498, + 618 + ], + "spans": [ + { + "bbox": [ + 311, + 462, + 498, + 618 + ], + "score": 0.971, + "type": "image", + "image_path": "9c9eaf2be8ee5fc0f21f129f854af58487fc6fdfd0633343e83fb1ee0b2baf18.jpg" + } + ] + } + ], + "index": 47, + "virtual_lines": [ + { + "bbox": [ + 311, + 462, + 498, + 474.0 + ], + "spans": [], + "index": 41 + }, + { + "bbox": [ + 311, + 474.0, + 498, + 486.0 + ], + "spans": [], + "index": 42 + }, + { + "bbox": [ + 311, + 486.0, + 498, + 498.0 + ], + "spans": [], + "index": 43 + }, + { + "bbox": [ + 311, + 498.0, + 498, + 510.0 + ], + "spans": [], + "index": 44 + }, + { + "bbox": [ + 311, + 510.0, + 498, + 522.0 + ], + "spans": [], + "index": 45 + }, + { + "bbox": [ + 311, + 522.0, + 498, + 534.0 + ], + "spans": [], + "index": 46 + }, + { + "bbox": [ + 311, + 534.0, + 498, + 546.0 + ], + "spans": [], + "index": 47 + }, + { + "bbox": [ + 311, + 546.0, + 498, + 558.0 + ], + "spans": [], + "index": 48 + }, + { + "bbox": [ + 311, + 558.0, + 498, + 570.0 + ], + "spans": [], + "index": 49 + }, + { + "bbox": [ + 311, + 570.0, + 498, + 582.0 + ], + "spans": [], + "index": 50 + }, + { + "bbox": [ + 311, + 582.0, + 498, + 594.0 + ], + "spans": [], + "index": 51 + }, + { + "bbox": [ + 311, + 594.0, + 498, + 606.0 + ], + "spans": [], + "index": 52 + }, + { + "bbox": [ + 311, + 606.0, + 498, + 618.0 + ], + "spans": [], + "index": 53 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 304, + 626, + 505, + 686 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 303, + 626, + 505, + 637 + ], + "spans": [ + { + "bbox": [ + 303, + 626, + 486, + 637 + ], + "score": 1.0, + "content": "Figure 1: Overview of MEGABYTE with patch size", + "type": "text" + }, + { + "bbox": [ + 486, + 627, + 505, + 636 + ], + "score": 0.85, + "content": "P =", + "type": "inline_equation" + } + ], + "index": 54 + }, + { + "bbox": [ + 303, + 636, + 505, + 648 + ], + "spans": [ + { + "bbox": [ + 303, + 636, + 505, + 648 + ], + "score": 1.0, + "content": "4. A small local model autoregressively predicts each", + "type": "text" + } + ], + "index": 55 + }, + { + "bbox": [ + 303, + 646, + 506, + 657 + ], + "spans": [ + { + "bbox": [ + 303, + 646, + 506, + 657 + ], + "score": 1.0, + "content": "patch byte-by-byte, using the output of a larger global", + "type": "text" + } + ], + "index": 56 + }, + { + "bbox": [ + 303, + 657, + 506, + 668 + ], + "spans": [ + { + "bbox": [ + 303, + 657, + 506, + 668 + ], + "score": 1.0, + "content": "model to condition on previous patches. Global and", + "type": "text" + } + ], + "index": 57 + }, + { + "bbox": [ + 303, + 666, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 303, + 666, + 405, + 678 + ], + "score": 1.0, + "content": "Local inputs are padded by", + "type": "text" + }, + { + "bbox": [ + 406, + 667, + 414, + 675 + ], + "score": 0.81, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 414, + 666, + 505, + 678 + ], + "score": 1.0, + "content": "and 1 token respectively", + "type": "text" + } + ], + "index": 58 + }, + { + "bbox": [ + 303, + 676, + 483, + 687 + ], + "spans": [ + { + "bbox": [ + 303, + 676, + 483, + 687 + ], + "score": 1.0, + "content": "to avoid leaking information about future tokens.", + "type": "text" + } + ], + "index": 59 + } + ], + "index": 56.5 + } + ], + "index": 51.75 + }, + { + "type": "text", + "bbox": [ + 106, + 703, + 503, + 714 + ], + "lines": [ + { + "bbox": [ + 106, + 700, + 505, + 716 + ], + "spans": [ + { + "bbox": [ + 106, + 700, + 505, + 716 + ], + "score": 1.0, + "content": "that predicts bytes within a patch. Crucially, we observe that for many tasks, most byte predictions", + "type": "text" + } + ], + "index": 60 + } + ], + "index": 60 + } + ], + "page_idx": 0, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 731, + 385, + 742 + ], + "lines": [ + { + "bbox": [ + 105, + 730, + 386, + 743 + ], + "spans": [ + { + "bbox": [ + 105, + 730, + 386, + 743 + ], + "score": 1.0, + "content": "37th Conference on Neural Information Processing Systems (NeurIPS 2023).", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 112, + 97, + 500, + 137 + ], + "lines": [ + { + "bbox": [ + 110, + 96, + 500, + 119 + ], + "spans": [ + { + "bbox": [ + 110, + 96, + 500, + 119 + ], + "score": 1.0, + "content": "MEGABYTE: Modeling Million-byte Sequences with", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 212, + 117, + 398, + 138 + ], + "spans": [ + { + "bbox": [ + 212, + 117, + 398, + 138 + ], + "score": 1.0, + "content": "Multiscale Transformers", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 160, + 175, + 452, + 188 + ], + "lines": [ + { + "bbox": [ + 158, + 173, + 454, + 191 + ], + "spans": [ + { + "bbox": [ + 158, + 173, + 454, + 191 + ], + "score": 1.0, + "content": "Lili Yu∗ Dániel Simig∗ Colin Flaherty∗ Armen Aghajanyan", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 2, + "bbox_fs": [ + 158, + 173, + 454, + 191 + ] + }, + { + "type": "text", + "bbox": [ + 235, + 204, + 376, + 216 + ], + "lines": [ + { + "bbox": [ + 232, + 203, + 378, + 218 + ], + "spans": [ + { + "bbox": [ + 232, + 203, + 378, + 218 + ], + "score": 1.0, + "content": "Luke Zettlemoyer Mike Lewis", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3, + "bbox_fs": [ + 232, + 203, + 378, + 218 + ] + }, + { + "type": "text", + "bbox": [ + 288, + 226, + 322, + 237 + ], + "lines": [ + { + "bbox": [ + 286, + 225, + 325, + 238 + ], + "spans": [ + { + "bbox": [ + 286, + 225, + 325, + 238 + ], + "score": 1.0, + "content": "Meta AI", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 4, + "bbox_fs": [ + 286, + 225, + 325, + 238 + ] + }, + { + "type": "title", + "bbox": [ + 283, + 266, + 328, + 279 + ], + "lines": [ + { + "bbox": [ + 281, + 265, + 330, + 281 + ], + "spans": [ + { + "bbox": [ + 281, + 265, + 330, + 281 + ], + "score": 1.0, + "content": "Abstract", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 143, + 291, + 469, + 433 + ], + "lines": [ + { + "bbox": [ + 141, + 291, + 469, + 303 + ], + "spans": [ + { + "bbox": [ + 141, + 291, + 469, + 303 + ], + "score": 1.0, + "content": "Autoregressive transformers are spectacular models for short sequences but scale", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 302, + 471, + 314 + ], + "spans": [ + { + "bbox": [ + 141, + 302, + 471, + 314 + ], + "score": 1.0, + "content": "poorly to long sequences such as high-resolution images, podcasts, code, or books.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 313, + 471, + 326 + ], + "spans": [ + { + "bbox": [ + 141, + 313, + 471, + 326 + ], + "score": 1.0, + "content": "We propose MEGABYTE, a multi-scale decoder architecture that enables end-to-ModModelModelModel", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 141, + 324, + 470, + 336 + ], + "spans": [ + { + "bbox": [ + 141, + 324, + 470, + 336 + ], + "score": 1.0, + "content": "end differentiable modeling of sequences of over one million bytes. MEGABYTE", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 141, + 336, + 470, + 347 + ], + "spans": [ + { + "bbox": [ + 141, + 336, + 470, + 347 + ], + "score": 1.0, + "content": "segments sequences into patches and uses a local submodel within patches and a_ m e g _ b y t _ ' ' t r _ n", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 347, + 469, + 358 + ], + "spans": [ + { + "bbox": [ + 141, + 347, + 469, + 358 + ], + "score": 1.0, + "content": "global model between patches. This enables sub-quadratic self-attention, much", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 357, + 470, + 370 + ], + "spans": [ + { + "bbox": [ + 141, + 357, + 470, + 370 + ], + "score": 1.0, + "content": "larger feedforward layers for the same compute, and improved parallelism during", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 367, + 470, + 380 + ], + "spans": [ + { + "bbox": [ + 141, + 367, + 470, + 380 + ], + "score": 1.0, + "content": "decoding—unlocking better performance at reduced cost for both training and gen-Global Model", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 379, + 470, + 390 + ], + "spans": [ + { + "bbox": [ + 141, + 379, + 470, + 390 + ], + "score": 1.0, + "content": "eration. Extensive experiments show that MEGABYTE allows byte-level models", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 390, + 470, + 401 + ], + "spans": [ + { + "bbox": [ + 141, + 390, + 470, + 401 + ], + "score": 1.0, + "content": "to perform competitively with subword models on long context language mod-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 141, + 401, + 469, + 413 + ], + "spans": [ + { + "bbox": [ + 141, + 401, + 469, + 413 + ], + "score": 1.0, + "content": "eling, achieve state-of-the-art density estimation on ImageNet, and model audio", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 411, + 469, + 424 + ], + "spans": [ + { + "bbox": [ + 141, + 411, + 469, + 424 + ], + "score": 1.0, + "content": "from raw files. Together, these results establish the viability of tokenization-free", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 141, + 423, + 316, + 435 + ], + "spans": [ + { + "bbox": [ + 141, + 423, + 316, + 435 + ], + "score": 1.0, + "content": "autoregressive sequence modeling at scale.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 12, + "bbox_fs": [ + 141, + 291, + 471, + 435 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 447, + 191, + 461 + ], + "lines": [ + { + "bbox": [ + 105, + 446, + 192, + 464 + ], + "spans": [ + { + "bbox": [ + 105, + 446, + 192, + 464 + ], + "score": 1.0, + "content": "1 Introduction", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 107, + 467, + 297, + 587 + ], + "lines": [ + { + "bbox": [ + 106, + 467, + 298, + 479 + ], + "spans": [ + { + "bbox": [ + 106, + 467, + 298, + 479 + ], + "score": 1.0, + "content": "Sequences of millions of bytes are ubiquitous;", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 478, + 298, + 490 + ], + "spans": [ + { + "bbox": [ + 106, + 478, + 298, + 490 + ], + "score": 1.0, + "content": "for example, music, image, or video files typi-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 489, + 298, + 501 + ], + "spans": [ + { + "bbox": [ + 106, + 489, + 298, + 501 + ], + "score": 1.0, + "content": "cally consist of multiple megabytes. However,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 499, + 298, + 513 + ], + "spans": [ + { + "bbox": [ + 105, + 499, + 298, + 513 + ], + "score": 1.0, + "content": "large transformer decoders (LLMs) typically", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 511, + 297, + 522 + ], + "spans": [ + { + "bbox": [ + 106, + 511, + 297, + 522 + ], + "score": 1.0, + "content": "only use several thousand tokens of context", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 522, + 297, + 533 + ], + "spans": [ + { + "bbox": [ + 105, + 522, + 297, + 533 + ], + "score": 1.0, + "content": "(Brown et al., 2020; Zhang et al., 2022a)—both", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 533, + 297, + 545 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 297, + 545 + ], + "score": 1.0, + "content": "because of the quadratic cost of self-attention", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 543, + 298, + 555 + ], + "spans": [ + { + "bbox": [ + 105, + 543, + 298, + 555 + ], + "score": 1.0, + "content": "but also, more importantly, the cost of large feed-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 554, + 298, + 567 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 298, + 567 + ], + "score": 1.0, + "content": "forward networks per-position. This severely", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 564, + 299, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 564, + 299, + 579 + ], + "score": 1.0, + "content": "limits the set of tasks where LLMs can be ap-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 576, + 132, + 589 + ], + "spans": [ + { + "bbox": [ + 105, + 576, + 132, + 589 + ], + "score": 1.0, + "content": "plied.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 25, + "bbox_fs": [ + 105, + 467, + 299, + 589 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 593, + 297, + 702 + ], + "lines": [ + { + "bbox": [ + 105, + 591, + 297, + 605 + ], + "spans": [ + { + "bbox": [ + 105, + 591, + 297, + 605 + ], + "score": 1.0, + "content": "We introduce MEGABYTE, a new approach to", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 604, + 298, + 616 + ], + "spans": [ + { + "bbox": [ + 106, + 604, + 298, + 616 + ], + "score": 1.0, + "content": "modeling long byte sequences. First, byte se-", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 614, + 298, + 627 + ], + "spans": [ + { + "bbox": [ + 105, + 614, + 298, + 627 + ], + "score": 1.0, + "content": "quences are segmented into fixed-sized patches,", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 626, + 297, + 637 + ], + "spans": [ + { + "bbox": [ + 106, + 626, + 297, + 637 + ], + "score": 1.0, + "content": "loosely analogous to tokens. Our model then", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 636, + 298, + 649 + ], + "spans": [ + { + "bbox": [ + 105, + 636, + 298, + 649 + ], + "score": 1.0, + "content": "consists of three parts: (1) a patch embedder,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 648, + 298, + 659 + ], + "spans": [ + { + "bbox": [ + 106, + 648, + 298, + 659 + ], + "score": 1.0, + "content": "which simply encodes a patch by losslessly con-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 658, + 298, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 658, + 298, + 669 + ], + "score": 1.0, + "content": "catenating embeddings of each byte, (2) a global", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 669, + 298, + 681 + ], + "spans": [ + { + "bbox": [ + 106, + 669, + 298, + 681 + ], + "score": 1.0, + "content": "module, a large autoregressive transformer that", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 680, + 298, + 692 + ], + "spans": [ + { + "bbox": [ + 106, + 680, + 298, + 692 + ], + "score": 1.0, + "content": "inputs and outputs patch representations and (3)", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 691, + 297, + 703 + ], + "spans": [ + { + "bbox": [ + 105, + 691, + 297, + 703 + ], + "score": 1.0, + "content": "a local module, a small autoregressive model", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 35.5, + "bbox_fs": [ + 105, + 591, + 298, + 703 + ] + }, + { + "type": "image", + "bbox": [ + 311, + 462, + 498, + 618 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 311, + 462, + 498, + 618 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 311, + 462, + 498, + 618 + ], + "spans": [ + { + "bbox": [ + 311, + 462, + 498, + 618 + ], + "score": 0.971, + "type": "image", + "image_path": "9c9eaf2be8ee5fc0f21f129f854af58487fc6fdfd0633343e83fb1ee0b2baf18.jpg" + } + ] + } + ], + "index": 47, + "virtual_lines": [ + { + "bbox": [ + 311, + 462, + 498, + 474.0 + ], + "spans": [], + "index": 41 + }, + { + "bbox": [ + 311, + 474.0, + 498, + 486.0 + ], + "spans": [], + "index": 42 + }, + { + "bbox": [ + 311, + 486.0, + 498, + 498.0 + ], + "spans": [], + "index": 43 + }, + { + "bbox": [ + 311, + 498.0, + 498, + 510.0 + ], + "spans": [], + "index": 44 + }, + { + "bbox": [ + 311, + 510.0, + 498, + 522.0 + ], + "spans": [], + "index": 45 + }, + { + "bbox": [ + 311, + 522.0, + 498, + 534.0 + ], + "spans": [], + "index": 46 + }, + { + "bbox": [ + 311, + 534.0, + 498, + 546.0 + ], + "spans": [], + "index": 47 + }, + { + "bbox": [ + 311, + 546.0, + 498, + 558.0 + ], + "spans": [], + "index": 48 + }, + { + "bbox": [ + 311, + 558.0, + 498, + 570.0 + ], + "spans": [], + "index": 49 + }, + { + "bbox": [ + 311, + 570.0, + 498, + 582.0 + ], + "spans": [], + "index": 50 + }, + { + "bbox": [ + 311, + 582.0, + 498, + 594.0 + ], + "spans": [], + "index": 51 + }, + { + "bbox": [ + 311, + 594.0, + 498, + 606.0 + ], + "spans": [], + "index": 52 + }, + { + "bbox": [ + 311, + 606.0, + 498, + 618.0 + ], + "spans": [], + "index": 53 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 304, + 626, + 505, + 686 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 303, + 626, + 505, + 637 + ], + "spans": [ + { + "bbox": [ + 303, + 626, + 486, + 637 + ], + "score": 1.0, + "content": "Figure 1: Overview of MEGABYTE with patch size", + "type": "text" + }, + { + "bbox": [ + 486, + 627, + 505, + 636 + ], + "score": 0.85, + "content": "P =", + "type": "inline_equation" + } + ], + "index": 54 + }, + { + "bbox": [ + 303, + 636, + 505, + 648 + ], + "spans": [ + { + "bbox": [ + 303, + 636, + 505, + 648 + ], + "score": 1.0, + "content": "4. A small local model autoregressively predicts each", + "type": "text" + } + ], + "index": 55 + }, + { + "bbox": [ + 303, + 646, + 506, + 657 + ], + "spans": [ + { + "bbox": [ + 303, + 646, + 506, + 657 + ], + "score": 1.0, + "content": "patch byte-by-byte, using the output of a larger global", + "type": "text" + } + ], + "index": 56 + }, + { + "bbox": [ + 303, + 657, + 506, + 668 + ], + "spans": [ + { + "bbox": [ + 303, + 657, + 506, + 668 + ], + "score": 1.0, + "content": "model to condition on previous patches. Global and", + "type": "text" + } + ], + "index": 57 + }, + { + "bbox": [ + 303, + 666, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 303, + 666, + 405, + 678 + ], + "score": 1.0, + "content": "Local inputs are padded by", + "type": "text" + }, + { + "bbox": [ + 406, + 667, + 414, + 675 + ], + "score": 0.81, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 414, + 666, + 505, + 678 + ], + "score": 1.0, + "content": "and 1 token respectively", + "type": "text" + } + ], + "index": 58 + }, + { + "bbox": [ + 303, + 676, + 483, + 687 + ], + "spans": [ + { + "bbox": [ + 303, + 676, + 483, + 687 + ], + "score": 1.0, + "content": "to avoid leaking information about future tokens.", + "type": "text" + } + ], + "index": 59 + } + ], + "index": 56.5 + } + ], + "index": 51.75 + }, + { + "type": "text", + "bbox": [ + 106, + 703, + 503, + 714 + ], + "lines": [ + { + "bbox": [ + 106, + 700, + 505, + 716 + ], + "spans": [ + { + "bbox": [ + 106, + 700, + 505, + 716 + ], + "score": 1.0, + "content": "that predicts bytes within a patch. Crucially, we observe that for many tasks, most byte predictions", + "type": "text" + } + ], + "index": 60 + } + ], + "index": 60, + "bbox_fs": [ + 106, + 700, + 505, + 716 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "interline_equation", + "bbox": [ + 111, + 70, + 505, + 201 + ], + "lines": [ + { + "bbox": [ + 111, + 70, + 505, + 201 + ], + "spans": [ + { + "bbox": [ + 111, + 70, + 505, + 201 + ], + "score": 0.91, + "content": "\\begin{array} { r l r } { \\iota _ { t } ^ { \\mathrm { c o b i s c d } } } & { = E _ { x _ { t } } ^ { \\mathrm { i o b o l . } \\mathrm { c o n b e d } } + E _ { t } ^ { \\mathrm { i o s } } } & { t \\in [ 0 . . T ) , E ^ { \\mathrm { g l o b a i c m e d } } \\ \\in \\mathbb { R } ^ { N \\times D G } , } \\\\ & { } & { E ^ { \\mathrm { p o s } } \\in \\mathbb { R } ^ { T \\times N \\times D G } , \\ k ^ { \\mathrm { c o b d . } } \\in \\mathbb { R } ^ { T \\times N \\times D _ { G } } } \\\\ & { } & { E ^ { \\mathrm { p l o b a i s i n } } } \\\\ & { \\iota _ { k } ^ { \\mathrm { g l o b a i s a l } } } & { = \\left\\{ \\begin{array} { l l } { E ^ { \\mathrm { g l o b a l . } \\mathrm { p o s d . } } } & { \\mathrm { i f } \\ k = 0 , } \\\\ { h _ { t } ^ { \\mathrm { i o s } } ( \\mathrm { p . e } - 1 ) \\cdot p \\cdot ( k \\cdot p ) } & { k \\in [ 1 , \\ldots , K ) , } \\\\ { w _ { 0 } \\times \\mathrm { c o n . } \\mathrm { c o n } } & { 1 } \\end{array} \\right. } \\\\ & { } & { \\mathrm { p l o b . ~ } } \\\\ { \\iota _ { t , k } ^ { \\mathrm { p o t a i n } } } & { = \\mathrm { t r a s i o n ~ c l o b a i ~ } \\left( b _ { 0 , k } ^ { \\mathrm { g l o b a i . } } \\right) } \\\\ & { } & { \\mathrm { i f ~ } \\mu _ { k , p } ^ { \\mathrm { c o s i s a l } } + \\frac { \\mu _ { k } ^ { \\mathrm { i n d . } } \\mu _ { k } ^ { \\mathrm { f l o c a l . } } } { \\mu _ { k , p } ^ { \\mathrm { i n d . } } } } \\end{array}", + "type": "interline_equation", + "image_path": "296dd6a15492835d98ce52c74a3fa97f29f0dfda31eed36c12172bec4d5a2b6b.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 111, + 70, + 505, + 113.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 111, + 113.66666666666666, + 505, + 157.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 111, + 157.33333333333331, + 505, + 200.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 246, + 504, + 269 + ], + "lines": [ + { + "bbox": [ + 105, + 245, + 506, + 261 + ], + "spans": [ + { + "bbox": [ + 105, + 245, + 506, + 261 + ], + "score": 1.0, + "content": "are relatively easy (for example, completing a word given the first few characters), meaning that large", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 257, + 506, + 272 + ], + "spans": [ + { + "bbox": [ + 105, + 257, + 506, + 272 + ], + "score": 1.0, + "content": "networks per-byte are unnecessary, and a much smaller model can be used for intra-patch modelling.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 106, + 274, + 458, + 285 + ], + "lines": [ + { + "bbox": [ + 104, + 271, + 460, + 289 + ], + "spans": [ + { + "bbox": [ + 104, + 271, + 460, + 289 + ], + "score": 1.0, + "content": "MEGABYTE has three main advantages over Transformers for long sequence modeling:", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 131, + 301, + 505, + 347 + ], + "lines": [ + { + "bbox": [ + 129, + 300, + 506, + 313 + ], + "spans": [ + { + "bbox": [ + 129, + 300, + 506, + 313 + ], + "score": 1.0, + "content": "1. Sub-quadratic self-attention Most work on long sequence models has focused on mitigat-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 312, + 506, + 325 + ], + "spans": [ + { + "bbox": [ + 141, + 312, + 506, + 325 + ], + "score": 1.0, + "content": "ing the quadratic cost of self-attention. MEGABYTE decomposes long sequences into two", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 323, + 505, + 337 + ], + "spans": [ + { + "bbox": [ + 141, + 324, + 442, + 337 + ], + "score": 1.0, + "content": "shorter sequences, and optimal patch sizes reduces the self-attention cost to", + "type": "text" + }, + { + "bbox": [ + 443, + 323, + 474, + 337 + ], + "score": 0.94, + "content": "O ( N ^ { \\frac { 4 } { 3 } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 475, + 324, + 505, + 337 + ], + "score": 1.0, + "content": ", which", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 142, + 335, + 313, + 348 + ], + "spans": [ + { + "bbox": [ + 142, + 335, + 313, + 348 + ], + "score": 1.0, + "content": "remains tractable for even long sequences.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 7.5 + }, + { + "type": "text", + "bbox": [ + 131, + 363, + 505, + 430 + ], + "lines": [ + { + "bbox": [ + 129, + 364, + 506, + 376 + ], + "spans": [ + { + "bbox": [ + 129, + 364, + 397, + 376 + ], + "score": 1.0, + "content": "2. Per-patch feedforward layers In GPT3-size models, more than", + "type": "text" + }, + { + "bbox": [ + 397, + 364, + 416, + 375 + ], + "score": 0.86, + "content": "9 8 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 417, + 364, + 506, + 376 + ], + "score": 1.0, + "content": "of FLOPS are used in", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 374, + 506, + 388 + ], + "spans": [ + { + "bbox": [ + 141, + 374, + 506, + 388 + ], + "score": 1.0, + "content": "computing position-wise feedforward layers. MEGABYTE uses large feedforward layers", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 386, + 506, + 399 + ], + "spans": [ + { + "bbox": [ + 141, + 386, + 506, + 399 + ], + "score": 1.0, + "content": "per-patch rather than per-position, enabling much larger and more expressive models for the", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 397, + 505, + 408 + ], + "spans": [ + { + "bbox": [ + 141, + 397, + 248, + 408 + ], + "score": 1.0, + "content": "same cost. With patch size", + "type": "text" + }, + { + "bbox": [ + 249, + 397, + 257, + 407 + ], + "score": 0.83, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 258, + 397, + 505, + 408 + ], + "score": 1.0, + "content": ", where a baseline transformer would use the same feedforward", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 407, + 506, + 421 + ], + "spans": [ + { + "bbox": [ + 141, + 407, + 185, + 421 + ], + "score": 1.0, + "content": "layer with", + "type": "text" + }, + { + "bbox": [ + 185, + 409, + 196, + 418 + ], + "score": 0.73, + "content": "m", + "type": "inline_equation" + }, + { + "bbox": [ + 196, + 407, + 243, + 421 + ], + "score": 1.0, + "content": "parameters", + "type": "text" + }, + { + "bbox": [ + 244, + 408, + 253, + 417 + ], + "score": 0.83, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 253, + 407, + 417, + 421 + ], + "score": 1.0, + "content": "times, MEGABYTE can use a layer with", + "type": "text" + }, + { + "bbox": [ + 418, + 408, + 435, + 418 + ], + "score": 0.82, + "content": "m P", + "type": "inline_equation" + }, + { + "bbox": [ + 436, + 407, + 506, + 421 + ], + "score": 1.0, + "content": "parameters once", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 419, + 215, + 431 + ], + "spans": [ + { + "bbox": [ + 141, + 419, + 215, + 431 + ], + "score": 1.0, + "content": "for the same cost.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 12.5 + }, + { + "type": "text", + "bbox": [ + 131, + 447, + 505, + 513 + ], + "lines": [ + { + "bbox": [ + 128, + 446, + 506, + 461 + ], + "spans": [ + { + "bbox": [ + 128, + 446, + 506, + 461 + ], + "score": 1.0, + "content": "3. Parallelism in Decoding Transformers must perform all computations serially during", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 458, + 506, + 471 + ], + "spans": [ + { + "bbox": [ + 141, + 458, + 506, + 471 + ], + "score": 1.0, + "content": "generation because the input to each timestep is the output from the previous timestep. By", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 140, + 468, + 506, + 482 + ], + "spans": [ + { + "bbox": [ + 140, + 468, + 506, + 482 + ], + "score": 1.0, + "content": "reusing the global representation over multiple time steps during local model decoding,", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 141, + 479, + 506, + 492 + ], + "spans": [ + { + "bbox": [ + 141, + 479, + 506, + 492 + ], + "score": 1.0, + "content": "MEGABYTE allows greater parallelism during generation. For example, a MEGABYTE", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 141, + 490, + 506, + 503 + ], + "spans": [ + { + "bbox": [ + 141, + 490, + 362, + 503 + ], + "score": 1.0, + "content": "model with 1.5B parameters can generate sequences", + "type": "text" + }, + { + "bbox": [ + 363, + 491, + 383, + 502 + ], + "score": 0.83, + "content": "40 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 490, + 506, + 503 + ], + "score": 1.0, + "content": "faster than a standard 350M", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 141, + 502, + 479, + 514 + ], + "spans": [ + { + "bbox": [ + 141, + 502, + 479, + 514 + ], + "score": 1.0, + "content": "Transformer, whilst also improving perplexity when trained with the same compute.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 18.5 + }, + { + "type": "text", + "bbox": [ + 109, + 528, + 504, + 551 + ], + "lines": [ + { + "bbox": [ + 107, + 528, + 505, + 541 + ], + "spans": [ + { + "bbox": [ + 107, + 528, + 505, + 541 + ], + "score": 1.0, + "content": "Together, these improvements allow us to train much larger and better-performing models for the same", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 107, + 540, + 496, + 553 + ], + "spans": [ + { + "bbox": [ + 107, + 540, + 496, + 553 + ], + "score": 1.0, + "content": "compute budget, scale to very long sequences, and improve generation speed during deployment.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 107, + 555, + 505, + 644 + ], + "lines": [ + { + "bbox": [ + 106, + 555, + 505, + 569 + ], + "spans": [ + { + "bbox": [ + 106, + 555, + 505, + 569 + ], + "score": 1.0, + "content": "MEGABYTE also provides a strong contrast to existing autoregressive models that typically use some", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 567, + 506, + 580 + ], + "spans": [ + { + "bbox": [ + 105, + 567, + 506, + 580 + ], + "score": 1.0, + "content": "form of tokenization, where sequences of bytes are mapped to larger discrete tokens (Sennrich et al.,", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 577, + 506, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 506, + 591 + ], + "score": 1.0, + "content": "2015; Ramesh et al., 2021; Hsu et al., 2021). Tokenization complicates pre-processing, multi-modal", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 588, + 506, + 602 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 506, + 602 + ], + "score": 1.0, + "content": "modelling, and transfer to new domains, while hiding useful structure from the model. It also means", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 599, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 505, + 612 + ], + "score": 1.0, + "content": "that most state-of-the-art models are not truly end to end. The most widely used approaches to", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 611, + 505, + 623 + ], + "spans": [ + { + "bbox": [ + 105, + 611, + 505, + 623 + ], + "score": 1.0, + "content": "tokenization require language-specific heuristics (Radford et al., 2019) or lose information (Ramesh", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 622, + 505, + 634 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 505, + 634 + ], + "score": 1.0, + "content": "et al., 2021). Replacing tokenization with efficient and performant byte models would therefore have", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 631, + 180, + 646 + ], + "spans": [ + { + "bbox": [ + 105, + 631, + 180, + 646 + ], + "score": 1.0, + "content": "many advantages.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 27.5 + }, + { + "type": "text", + "bbox": [ + 107, + 649, + 505, + 726 + ], + "lines": [ + { + "bbox": [ + 106, + 649, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 505, + 661 + ], + "score": 1.0, + "content": "We conduct extensive experiments for both MEGABYTE and strong baselines. We use a fixed compute", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 660, + 506, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 506, + 672 + ], + "score": 1.0, + "content": "and data budget across all models to focus our comparisons solely on the model architecture rather", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 671, + 505, + 683 + ], + "spans": [ + { + "bbox": [ + 106, + 671, + 505, + 683 + ], + "score": 1.0, + "content": "than training resources, which are known to benefit all models. We find that MEGABYTE allows", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 681, + 506, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 506, + 695 + ], + "score": 1.0, + "content": "byte-level models to perform competitively with subword models on long context language modeling,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 691, + 505, + 706 + ], + "spans": [ + { + "bbox": [ + 105, + 691, + 505, + 706 + ], + "score": 1.0, + "content": "achieve state-of-the-art perplexities for density estimation on ImageNet, and allow audio modelling", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 703, + 505, + 716 + ], + "spans": [ + { + "bbox": [ + 105, + 703, + 505, + 716 + ], + "score": 1.0, + "content": "from raw audio files. Together, these results establish the viability of tokenization-free autoregressive", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 715, + 221, + 727 + ], + "spans": [ + { + "bbox": [ + 105, + 715, + 221, + 727 + ], + "score": 1.0, + "content": "sequence modeling at scale.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 35 + } + ], + "page_idx": 1, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 308, + 750 + ], + "lines": [ + { + "bbox": [ + 302, + 740, + 310, + 753 + ], + "spans": [ + { + "bbox": [ + 302, + 740, + 310, + 753 + ], + "score": 1.0, + "content": "2", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "interline_equation", + "bbox": [ + 111, + 70, + 505, + 201 + ], + "lines": [ + { + "bbox": [ + 111, + 70, + 505, + 201 + ], + "spans": [ + { + "bbox": [ + 111, + 70, + 505, + 201 + ], + "score": 0.91, + "content": "\\begin{array} { r l r } { \\iota _ { t } ^ { \\mathrm { c o b i s c d } } } & { = E _ { x _ { t } } ^ { \\mathrm { i o b o l . } \\mathrm { c o n b e d } } + E _ { t } ^ { \\mathrm { i o s } } } & { t \\in [ 0 . . T ) , E ^ { \\mathrm { g l o b a i c m e d } } \\ \\in \\mathbb { R } ^ { N \\times D G } , } \\\\ & { } & { E ^ { \\mathrm { p o s } } \\in \\mathbb { R } ^ { T \\times N \\times D G } , \\ k ^ { \\mathrm { c o b d . } } \\in \\mathbb { R } ^ { T \\times N \\times D _ { G } } } \\\\ & { } & { E ^ { \\mathrm { p l o b a i s i n } } } \\\\ & { \\iota _ { k } ^ { \\mathrm { g l o b a i s a l } } } & { = \\left\\{ \\begin{array} { l l } { E ^ { \\mathrm { g l o b a l . } \\mathrm { p o s d . } } } & { \\mathrm { i f } \\ k = 0 , } \\\\ { h _ { t } ^ { \\mathrm { i o s } } ( \\mathrm { p . e } - 1 ) \\cdot p \\cdot ( k \\cdot p ) } & { k \\in [ 1 , \\ldots , K ) , } \\\\ { w _ { 0 } \\times \\mathrm { c o n . } \\mathrm { c o n } } & { 1 } \\end{array} \\right. } \\\\ & { } & { \\mathrm { p l o b . ~ } } \\\\ { \\iota _ { t , k } ^ { \\mathrm { p o t a i n } } } & { = \\mathrm { t r a s i o n ~ c l o b a i ~ } \\left( b _ { 0 , k } ^ { \\mathrm { g l o b a i . } } \\right) } \\\\ & { } & { \\mathrm { i f ~ } \\mu _ { k , p } ^ { \\mathrm { c o s i s a l } } + \\frac { \\mu _ { k } ^ { \\mathrm { i n d . } } \\mu _ { k } ^ { \\mathrm { f l o c a l . } } } { \\mu _ { k , p } ^ { \\mathrm { i n d . } } } } \\end{array}", + "type": "interline_equation", + "image_path": "296dd6a15492835d98ce52c74a3fa97f29f0dfda31eed36c12172bec4d5a2b6b.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 111, + 70, + 505, + 113.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 111, + 113.66666666666666, + 505, + 157.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 111, + 157.33333333333331, + 505, + 200.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 246, + 504, + 269 + ], + "lines": [ + { + "bbox": [ + 105, + 245, + 506, + 261 + ], + "spans": [ + { + "bbox": [ + 105, + 245, + 506, + 261 + ], + "score": 1.0, + "content": "are relatively easy (for example, completing a word given the first few characters), meaning that large", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 257, + 506, + 272 + ], + "spans": [ + { + "bbox": [ + 105, + 257, + 506, + 272 + ], + "score": 1.0, + "content": "networks per-byte are unnecessary, and a much smaller model can be used for intra-patch modelling.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5, + "bbox_fs": [ + 105, + 245, + 506, + 272 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 274, + 458, + 285 + ], + "lines": [ + { + "bbox": [ + 104, + 271, + 460, + 289 + ], + "spans": [ + { + "bbox": [ + 104, + 271, + 460, + 289 + ], + "score": 1.0, + "content": "MEGABYTE has three main advantages over Transformers for long sequence modeling:", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 5, + "bbox_fs": [ + 104, + 271, + 460, + 289 + ] + }, + { + "type": "text", + "bbox": [ + 131, + 301, + 505, + 347 + ], + "lines": [ + { + "bbox": [ + 129, + 300, + 506, + 313 + ], + "spans": [ + { + "bbox": [ + 129, + 300, + 506, + 313 + ], + "score": 1.0, + "content": "1. Sub-quadratic self-attention Most work on long sequence models has focused on mitigat-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 141, + 312, + 506, + 325 + ], + "spans": [ + { + "bbox": [ + 141, + 312, + 506, + 325 + ], + "score": 1.0, + "content": "ing the quadratic cost of self-attention. MEGABYTE decomposes long sequences into two", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 141, + 323, + 505, + 337 + ], + "spans": [ + { + "bbox": [ + 141, + 324, + 442, + 337 + ], + "score": 1.0, + "content": "shorter sequences, and optimal patch sizes reduces the self-attention cost to", + "type": "text" + }, + { + "bbox": [ + 443, + 323, + 474, + 337 + ], + "score": 0.94, + "content": "O ( N ^ { \\frac { 4 } { 3 } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 475, + 324, + 505, + 337 + ], + "score": 1.0, + "content": ", which", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 142, + 335, + 313, + 348 + ], + "spans": [ + { + "bbox": [ + 142, + 335, + 313, + 348 + ], + "score": 1.0, + "content": "remains tractable for even long sequences.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 7.5, + "bbox_fs": [ + 129, + 300, + 506, + 348 + ] + }, + { + "type": "text", + "bbox": [ + 131, + 363, + 505, + 430 + ], + "lines": [ + { + "bbox": [ + 129, + 364, + 506, + 376 + ], + "spans": [ + { + "bbox": [ + 129, + 364, + 397, + 376 + ], + "score": 1.0, + "content": "2. Per-patch feedforward layers In GPT3-size models, more than", + "type": "text" + }, + { + "bbox": [ + 397, + 364, + 416, + 375 + ], + "score": 0.86, + "content": "9 8 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 417, + 364, + 506, + 376 + ], + "score": 1.0, + "content": "of FLOPS are used in", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 141, + 374, + 506, + 388 + ], + "spans": [ + { + "bbox": [ + 141, + 374, + 506, + 388 + ], + "score": 1.0, + "content": "computing position-wise feedforward layers. MEGABYTE uses large feedforward layers", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 141, + 386, + 506, + 399 + ], + "spans": [ + { + "bbox": [ + 141, + 386, + 506, + 399 + ], + "score": 1.0, + "content": "per-patch rather than per-position, enabling much larger and more expressive models for the", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 141, + 397, + 505, + 408 + ], + "spans": [ + { + "bbox": [ + 141, + 397, + 248, + 408 + ], + "score": 1.0, + "content": "same cost. With patch size", + "type": "text" + }, + { + "bbox": [ + 249, + 397, + 257, + 407 + ], + "score": 0.83, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 258, + 397, + 505, + 408 + ], + "score": 1.0, + "content": ", where a baseline transformer would use the same feedforward", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 141, + 407, + 506, + 421 + ], + "spans": [ + { + "bbox": [ + 141, + 407, + 185, + 421 + ], + "score": 1.0, + "content": "layer with", + "type": "text" + }, + { + "bbox": [ + 185, + 409, + 196, + 418 + ], + "score": 0.73, + "content": "m", + "type": "inline_equation" + }, + { + "bbox": [ + 196, + 407, + 243, + 421 + ], + "score": 1.0, + "content": "parameters", + "type": "text" + }, + { + "bbox": [ + 244, + 408, + 253, + 417 + ], + "score": 0.83, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 253, + 407, + 417, + 421 + ], + "score": 1.0, + "content": "times, MEGABYTE can use a layer with", + "type": "text" + }, + { + "bbox": [ + 418, + 408, + 435, + 418 + ], + "score": 0.82, + "content": "m P", + "type": "inline_equation" + }, + { + "bbox": [ + 436, + 407, + 506, + 421 + ], + "score": 1.0, + "content": "parameters once", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 141, + 419, + 215, + 431 + ], + "spans": [ + { + "bbox": [ + 141, + 419, + 215, + 431 + ], + "score": 1.0, + "content": "for the same cost.", + "type": "text" + } + ], + "index": 15 + } + ], + "index": 12.5, + "bbox_fs": [ + 129, + 364, + 506, + 431 + ] + }, + { + "type": "text", + "bbox": [ + 131, + 447, + 505, + 513 + ], + "lines": [ + { + "bbox": [ + 128, + 446, + 506, + 461 + ], + "spans": [ + { + "bbox": [ + 128, + 446, + 506, + 461 + ], + "score": 1.0, + "content": "3. Parallelism in Decoding Transformers must perform all computations serially during", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 141, + 458, + 506, + 471 + ], + "spans": [ + { + "bbox": [ + 141, + 458, + 506, + 471 + ], + "score": 1.0, + "content": "generation because the input to each timestep is the output from the previous timestep. By", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 140, + 468, + 506, + 482 + ], + "spans": [ + { + "bbox": [ + 140, + 468, + 506, + 482 + ], + "score": 1.0, + "content": "reusing the global representation over multiple time steps during local model decoding,", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 141, + 479, + 506, + 492 + ], + "spans": [ + { + "bbox": [ + 141, + 479, + 506, + 492 + ], + "score": 1.0, + "content": "MEGABYTE allows greater parallelism during generation. For example, a MEGABYTE", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 141, + 490, + 506, + 503 + ], + "spans": [ + { + "bbox": [ + 141, + 490, + 362, + 503 + ], + "score": 1.0, + "content": "model with 1.5B parameters can generate sequences", + "type": "text" + }, + { + "bbox": [ + 363, + 491, + 383, + 502 + ], + "score": 0.83, + "content": "40 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 490, + 506, + 503 + ], + "score": 1.0, + "content": "faster than a standard 350M", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 141, + 502, + 479, + 514 + ], + "spans": [ + { + "bbox": [ + 141, + 502, + 479, + 514 + ], + "score": 1.0, + "content": "Transformer, whilst also improving perplexity when trained with the same compute.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 18.5, + "bbox_fs": [ + 128, + 446, + 506, + 514 + ] + }, + { + "type": "text", + "bbox": [ + 109, + 528, + 504, + 551 + ], + "lines": [ + { + "bbox": [ + 107, + 528, + 505, + 541 + ], + "spans": [ + { + "bbox": [ + 107, + 528, + 505, + 541 + ], + "score": 1.0, + "content": "Together, these improvements allow us to train much larger and better-performing models for the same", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 107, + 540, + 496, + 553 + ], + "spans": [ + { + "bbox": [ + 107, + 540, + 496, + 553 + ], + "score": 1.0, + "content": "compute budget, scale to very long sequences, and improve generation speed during deployment.", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 22.5, + "bbox_fs": [ + 107, + 528, + 505, + 553 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 555, + 505, + 644 + ], + "lines": [ + { + "bbox": [ + 106, + 555, + 505, + 569 + ], + "spans": [ + { + "bbox": [ + 106, + 555, + 505, + 569 + ], + "score": 1.0, + "content": "MEGABYTE also provides a strong contrast to existing autoregressive models that typically use some", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 567, + 506, + 580 + ], + "spans": [ + { + "bbox": [ + 105, + 567, + 506, + 580 + ], + "score": 1.0, + "content": "form of tokenization, where sequences of bytes are mapped to larger discrete tokens (Sennrich et al.,", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 577, + 506, + 591 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 506, + 591 + ], + "score": 1.0, + "content": "2015; Ramesh et al., 2021; Hsu et al., 2021). Tokenization complicates pre-processing, multi-modal", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 588, + 506, + 602 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 506, + 602 + ], + "score": 1.0, + "content": "modelling, and transfer to new domains, while hiding useful structure from the model. It also means", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 599, + 505, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 505, + 612 + ], + "score": 1.0, + "content": "that most state-of-the-art models are not truly end to end. The most widely used approaches to", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 611, + 505, + 623 + ], + "spans": [ + { + "bbox": [ + 105, + 611, + 505, + 623 + ], + "score": 1.0, + "content": "tokenization require language-specific heuristics (Radford et al., 2019) or lose information (Ramesh", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 622, + 505, + 634 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 505, + 634 + ], + "score": 1.0, + "content": "et al., 2021). Replacing tokenization with efficient and performant byte models would therefore have", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 631, + 180, + 646 + ], + "spans": [ + { + "bbox": [ + 105, + 631, + 180, + 646 + ], + "score": 1.0, + "content": "many advantages.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 27.5, + "bbox_fs": [ + 105, + 555, + 506, + 646 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 649, + 505, + 726 + ], + "lines": [ + { + "bbox": [ + 106, + 649, + 505, + 661 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 505, + 661 + ], + "score": 1.0, + "content": "We conduct extensive experiments for both MEGABYTE and strong baselines. We use a fixed compute", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 660, + 506, + 672 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 506, + 672 + ], + "score": 1.0, + "content": "and data budget across all models to focus our comparisons solely on the model architecture rather", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 671, + 505, + 683 + ], + "spans": [ + { + "bbox": [ + 106, + 671, + 505, + 683 + ], + "score": 1.0, + "content": "than training resources, which are known to benefit all models. We find that MEGABYTE allows", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 681, + 506, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 681, + 506, + 695 + ], + "score": 1.0, + "content": "byte-level models to perform competitively with subword models on long context language modeling,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 691, + 505, + 706 + ], + "spans": [ + { + "bbox": [ + 105, + 691, + 505, + 706 + ], + "score": 1.0, + "content": "achieve state-of-the-art perplexities for density estimation on ImageNet, and allow audio modelling", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 703, + 505, + 716 + ], + "spans": [ + { + "bbox": [ + 105, + 703, + 505, + 716 + ], + "score": 1.0, + "content": "from raw audio files. Together, these results establish the viability of tokenization-free autoregressive", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 715, + 221, + 727 + ], + "spans": [ + { + "bbox": [ + 105, + 715, + 221, + 727 + ], + "score": 1.0, + "content": "sequence modeling at scale.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 35, + "bbox_fs": [ + 105, + 649, + 506, + 727 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 70, + 259, + 85 + ], + "lines": [ + { + "bbox": [ + 104, + 69, + 260, + 86 + ], + "spans": [ + { + "bbox": [ + 104, + 69, + 260, + 86 + ], + "score": 1.0, + "content": "2 MEGABYTE Transformer", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "title", + "bbox": [ + 107, + 90, + 172, + 101 + ], + "lines": [ + { + "bbox": [ + 105, + 88, + 172, + 104 + ], + "spans": [ + { + "bbox": [ + 105, + 88, + 172, + 104 + ], + "score": 1.0, + "content": "2.1 Overview", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 106, + 104, + 505, + 171 + ], + "lines": [ + { + "bbox": [ + 106, + 104, + 505, + 116 + ], + "spans": [ + { + "bbox": [ + 106, + 104, + 505, + 116 + ], + "score": 1.0, + "content": "MEGABYTE is an autoregressive model for efficiently modeling long input sequences. MEGABYTE", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 114, + 505, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 114, + 505, + 127 + ], + "score": 1.0, + "content": "is comprised of 3 components: (1) a patch embedder that inputs a discrete sequence, embeds each", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 127, + 505, + 138 + ], + "spans": [ + { + "bbox": [ + 106, + 127, + 279, + 138 + ], + "score": 1.0, + "content": "element, and chunks it into patches of length", + "type": "text" + }, + { + "bbox": [ + 280, + 127, + 289, + 136 + ], + "score": 0.73, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 127, + 505, + 138 + ], + "score": 1.0, + "content": "(2) a large global Transformer that contextualizes patch", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 137, + 506, + 149 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 506, + 149 + ], + "score": 1.0, + "content": "representations by performing self-attention over previous patches, and (3) a smaller local Transformer", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 147, + 506, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 147, + 506, + 161 + ], + "score": 1.0, + "content": "that inputs a contextualized patch representation from the global model, and autoregressively predict", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 159, + 166, + 171 + ], + "spans": [ + { + "bbox": [ + 105, + 159, + 166, + 171 + ], + "score": 1.0, + "content": "the next patch.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 4.5 + }, + { + "type": "title", + "bbox": [ + 106, + 177, + 185, + 189 + ], + "lines": [ + { + "bbox": [ + 105, + 176, + 186, + 191 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 186, + 191 + ], + "score": 1.0, + "content": "2.2 Components", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 106, + 191, + 504, + 214 + ], + "lines": [ + { + "bbox": [ + 105, + 190, + 505, + 205 + ], + "spans": [ + { + "bbox": [ + 105, + 190, + 250, + 205 + ], + "score": 1.0, + "content": "Patch Embedder with patch size of", + "type": "text" + }, + { + "bbox": [ + 250, + 192, + 259, + 201 + ], + "score": 0.85, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 259, + 190, + 345, + 205 + ], + "score": 1.0, + "content": "maps a byte sequence", + "type": "text" + }, + { + "bbox": [ + 345, + 194, + 367, + 203 + ], + "score": 0.88, + "content": "x _ { 0 . . T }", + "type": "inline_equation" + }, + { + "bbox": [ + 368, + 190, + 505, + 205 + ], + "score": 1.0, + "content": "to a sequence of patch embeddings", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 200, + 275, + 216 + ], + "spans": [ + { + "bbox": [ + 105, + 200, + 145, + 216 + ], + "score": 1.0, + "content": "of length", + "type": "text" + }, + { + "bbox": [ + 145, + 202, + 177, + 216 + ], + "score": 0.93, + "content": "\\begin{array} { r } { K = { \\frac { T } { P } } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 177, + 200, + 239, + 216 + ], + "score": 1.0, + "content": "and dimension", + "type": "text" + }, + { + "bbox": [ + 239, + 203, + 270, + 214 + ], + "score": 0.91, + "content": "P \\cdot D _ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 200, + 275, + 216 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9.5 + }, + { + "type": "text", + "bbox": [ + 104, + 219, + 504, + 244 + ], + "lines": [ + { + "bbox": [ + 103, + 215, + 504, + 236 + ], + "spans": [ + { + "bbox": [ + 103, + 215, + 298, + 236 + ], + "score": 1.0, + "content": "First, each byte is embedded with a lookup table", + "type": "text" + }, + { + "bbox": [ + 298, + 221, + 307, + 231 + ], + "score": 0.27, + "content": "E", + "type": "inline_equation" + }, + { + "bbox": [ + 307, + 215, + 347, + 236 + ], + "score": 1.0, + "content": "global-embed", + "type": "text" + }, + { + "bbox": [ + 347, + 219, + 390, + 231 + ], + "score": 0.8, + "content": "\\in \\mathbb { R } ^ { V \\times D _ { G } }", + "type": "inline_equation" + }, + { + "bbox": [ + 390, + 215, + 487, + 236 + ], + "score": 1.0, + "content": "to an embedding of size", + "type": "text" + }, + { + "bbox": [ + 488, + 221, + 504, + 232 + ], + "score": 0.88, + "content": "D _ { G }", + "type": "inline_equation" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 232, + 258, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 232, + 258, + 244 + ], + "score": 1.0, + "content": "and positional embeddings are added.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5 + }, + { + "type": "interline_equation", + "bbox": [ + 186, + 262, + 425, + 279 + ], + "lines": [ + { + "bbox": [ + 186, + 262, + 425, + 279 + ], + "spans": [ + { + "bbox": [ + 186, + 262, + 425, + 279 + ], + "score": 0.87, + "content": "h _ { t } ^ { \\mathrm { e m b e d } } = E _ { x _ { t } } ^ { \\mathrm { g l o b a l - e m b e d } } + E _ { t } ^ { \\mathrm { p o s } } \\qquad t \\in [ 0 . . T ]", + "type": "interline_equation", + "image_path": "fbd371f83072666d11f3dbac6272c1233685ffd57721ec010b8c94921894f6ee.jpg" + } + ] + } + ], + "index": 13, + "virtual_lines": [ + { + "bbox": [ + 186, + 262, + 425, + 279 + ], + "spans": [], + "index": 13 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 287, + 506, + 333 + ], + "lines": [ + { + "bbox": [ + 105, + 286, + 507, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 286, + 325, + 300 + ], + "score": 1.0, + "content": "Then, byte embeddings are reshaped into a sequence of", + "type": "text" + }, + { + "bbox": [ + 325, + 288, + 335, + 297 + ], + "score": 0.83, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 286, + 472, + 300 + ], + "score": 1.0, + "content": "patch embeddings with dimension", + "type": "text" + }, + { + "bbox": [ + 473, + 288, + 503, + 299 + ], + "score": 0.9, + "content": "P \\cdot D _ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 503, + 286, + 507, + 300 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 297, + 506, + 311 + ], + "spans": [ + { + "bbox": [ + 105, + 297, + 506, + 311 + ], + "score": 1.0, + "content": "To allow autoregressive modelling, the patch sequence is padded to start with a trainable patch-sized", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 104, + 307, + 506, + 322 + ], + "spans": [ + { + "bbox": [ + 104, + 307, + 192, + 322 + ], + "score": 1.0, + "content": "padding embedding", + "type": "text" + }, + { + "bbox": [ + 192, + 309, + 283, + 320 + ], + "score": 0.79, + "content": "( E ^ { \\mathrm { g l o b a l - p a d } } \\ \\in \\ \\mathbb { R } ^ { P \\times D _ { G } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 284, + 307, + 506, + 322 + ], + "score": 1.0, + "content": "), and the last patch is removed from the input. This", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 320, + 432, + 333 + ], + "spans": [ + { + "bbox": [ + 105, + 320, + 432, + 333 + ], + "score": 1.0, + "content": "sequence is the input to the global model, and is denoted hglobal-in ∈ RK×(P ·DG).", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15.5 + }, + { + "type": "interline_equation", + "bbox": [ + 211, + 337, + 398, + 371 + ], + "lines": [ + { + "bbox": [ + 211, + 337, + 398, + 371 + ], + "spans": [ + { + "bbox": [ + 211, + 337, + 398, + 371 + ], + "score": 0.94, + "content": "\\begin{array} { r } { h _ { k } ^ { \\mathrm { g l o b a l - i n } } = \\left\\{ \\begin{array} { l l } { E ^ { \\mathrm { g l o b a l - p a d } } , } & { \\mathrm { i f } k = 0 , } \\\\ { h _ { ( ( k - 1 ) \\cdot P ) : ( k \\cdot P ) } ^ { \\mathrm { e m b e d } } , } & { k \\in [ 1 , . . , K ) , } \\end{array} \\right. } \\end{array}", + "type": "interline_equation", + "image_path": "e2fe38df9666626c0b52e08c0b29c77900098e6684701c587264e108576d9877.jpg" + } + ] + } + ], + "index": 18.5, + "virtual_lines": [ + { + "bbox": [ + 211, + 337, + 398, + 354.0 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 211, + 354.0, + 398, + 371.0 + ], + "spans": [], + "index": 19 + } + ] + }, + { + "type": "text", + "bbox": [ + 107, + 379, + 505, + 429 + ], + "lines": [ + { + "bbox": [ + 106, + 379, + 505, + 392 + ], + "spans": [ + { + "bbox": [ + 106, + 379, + 352, + 392 + ], + "score": 1.0, + "content": "Global Model is a decoder-only Transformer with dimension", + "type": "text" + }, + { + "bbox": [ + 352, + 380, + 383, + 390 + ], + "score": 0.92, + "content": "P \\cdot D _ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 379, + 505, + 392 + ], + "score": 1.0, + "content": "that operates on a sequence of", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 107, + 390, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 107, + 391, + 117, + 401 + ], + "score": 0.79, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 117, + 390, + 165, + 437 + ], + "score": 1.0, + "content": "tween patchpresentation", + "type": "text" + }, + { + "bbox": [ + 201, + 390, + 272, + 437 + ], + "score": 1.0, + "content": "uts a sequence of by performing se", + "type": "text" + }, + { + "bbox": [ + 283, + 390, + 372, + 437 + ], + "score": 1.0, + "content": "patch representations attention over previous", + "type": "text" + }, + { + "bbox": [ + 405, + 390, + 505, + 437 + ], + "score": 1.0, + "content": ", and outputs an updated.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 273, + 402, + 405, + 416 + ], + "spans": [ + { + "bbox": [ + 273, + 403, + 283, + 413 + ], + "score": 0.83, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 372, + 402, + 405, + 416 + ], + "score": 0.91, + "content": "h _ { 0 : K } ^ { \\mathrm { g l o b a l - i n } }", + "type": "inline_equation" + } + ], + "index": 22 + }, + { + "bbox": [ + 165, + 415, + 201, + 430 + ], + "spans": [ + { + "bbox": [ + 165, + 415, + 201, + 430 + ], + "score": 0.74, + "content": "h _ { 0 : K } ^ { \\mathrm { g l o b a l - o u t } }", + "type": "inline_equation" + } + ], + "index": 23 + } + ], + "index": 21.5 + }, + { + "type": "interline_equation", + "bbox": [ + 227, + 447, + 383, + 464 + ], + "lines": [ + { + "bbox": [ + 227, + 447, + 383, + 464 + ], + "spans": [ + { + "bbox": [ + 227, + 447, + 383, + 464 + ], + "score": 0.89, + "content": "h _ { 0 ; K } ^ { \\mathrm { g l o b a l - o u t } } = \\mathrm { t r a n s f o r m e r } ^ { \\mathrm { g l o b a l } } ( h _ { 0 : K } ^ { \\mathrm { g l o b a l - i n } } )", + "type": "interline_equation", + "image_path": "47b32affd6e4d369b5584e179987c1e82555ea48ccb3f5d9746a22a161ea1831.jpg" + } + ] + } + ], + "index": 24, + "virtual_lines": [ + { + "bbox": [ + 227, + 447, + 383, + 464 + ], + "spans": [], + "index": 24 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 473, + 506, + 556 + ], + "lines": [ + { + "bbox": [ + 100, + 470, + 507, + 496 + ], + "spans": [ + { + "bbox": [ + 100, + 470, + 251, + 496 + ], + "score": 1.0, + "content": "The output of the final global layer", + "type": "text" + }, + { + "bbox": [ + 252, + 474, + 276, + 488 + ], + "score": 0.9, + "content": "h _ { 0 : K } ^ { \\mathrm { g l o b a l } }", + "type": "inline_equation" + }, + { + "bbox": [ + 277, + 470, + 314, + 496 + ], + "score": 1.0, + "content": "contains", + "type": "text" + }, + { + "bbox": [ + 315, + 476, + 325, + 486 + ], + "score": 0.83, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 325, + 470, + 346, + 496 + ], + "score": 1.0, + "content": "patc", + "type": "text" + }, + { + "bbox": [ + 356, + 470, + 416, + 496 + ], + "score": 1.0, + "content": "epresentations", + "type": "text" + }, + { + "bbox": [ + 433, + 470, + 471, + 496 + ], + "score": 1.0, + "content": "imension", + "type": "text" + }, + { + "bbox": [ + 472, + 476, + 502, + 487 + ], + "score": 0.9, + "content": "P \\cdot D _ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 503, + 470, + 507, + 496 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 485, + 504, + 500 + ], + "spans": [ + { + "bbox": [ + 105, + 485, + 346, + 500 + ], + "score": 1.0, + "content": "For each of these, we reshape them into sequences of length", + "type": "text" + }, + { + "bbox": [ + 346, + 487, + 355, + 496 + ], + "score": 0.83, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 417, + 487, + 433, + 497 + ], + "score": 0.89, + "content": "D _ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 433, + 485, + 497, + 500 + ], + "score": 1.0, + "content": ", where position", + "type": "text" + }, + { + "bbox": [ + 498, + 489, + 504, + 498 + ], + "score": 0.75, + "content": "p", + "type": "inline_equation" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 497, + 506, + 510 + ], + "spans": [ + { + "bbox": [ + 105, + 497, + 172, + 510 + ], + "score": 1.0, + "content": "uses dimensions", + "type": "text" + }, + { + "bbox": [ + 173, + 498, + 200, + 509 + ], + "score": 0.9, + "content": "p \\cdot D _ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 201, + 497, + 212, + 510 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 213, + 497, + 264, + 509 + ], + "score": 0.85, + "content": "( p + 1 ) \\cdot D _ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 264, + 497, + 506, + 510 + ], + "score": 1.0, + "content": ". Each position is then projected to the dimension of the local", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 101, + 506, + 510, + 547 + ], + "spans": [ + { + "bbox": [ + 101, + 506, + 192, + 547 + ], + "score": 1.0, + "content": "model with a matrix these with byte embe", + "type": "text" + }, + { + "bbox": [ + 192, + 508, + 261, + 518 + ], + "score": 0.84, + "content": "w ^ { \\mathrm { G L } } \\in \\mathbb { R } ^ { D _ { G } \\times D _ { L } }", + "type": "inline_equation" + }, + { + "bbox": [ + 265, + 506, + 290, + 547 + ], + "score": 1.0, + "content": "where for th", + "type": "text" + }, + { + "bbox": [ + 290, + 509, + 306, + 519 + ], + "score": 0.89, + "content": "D _ { L }", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 506, + 392, + 547 + ], + "score": 1.0, + "content": "is the local model dikens in the next patch", + "type": "text" + }, + { + "bbox": [ + 468, + 506, + 510, + 547 + ], + "score": 1.0, + "content": "combineocal byte", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 250, + 519, + 441, + 534 + ], + "spans": [ + { + "bbox": [ + 250, + 520, + 265, + 530 + ], + "score": 0.88, + "content": "D _ { L }", + "type": "inline_equation" + }, + { + "bbox": [ + 393, + 519, + 441, + 534 + ], + "score": 0.77, + "content": "E _ { x _ { ( k \\cdot P + p - 1 ) } } ^ { \\mathrm { l o c a l - e m b e d } }", + "type": "inline_equation" + } + ], + "index": 29 + }, + { + "bbox": [ + 395, + 533, + 467, + 543 + ], + "spans": [ + { + "bbox": [ + 395, + 533, + 467, + 543 + ], + "score": 0.46, + "content": "( E ^ { \\mathrm { l o c a l - p a d } } \\in \\mathbb { R } ^ { D _ { L } } )", + "type": "inline_equation" + } + ], + "index": 30 + }, + { + "bbox": [ + 104, + 542, + 455, + 558 + ], + "spans": [ + { + "bbox": [ + 104, + 542, + 455, + 558 + ], + "score": 1.0, + "content": "autoregressive modelling within a patch. This results in a tensor hlocal-in ∈ RK×P ×DL .", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 28 + }, + { + "type": "interline_equation", + "bbox": [ + 204, + 560, + 405, + 579 + ], + "lines": [ + { + "bbox": [ + 204, + 560, + 405, + 579 + ], + "spans": [ + { + "bbox": [ + 204, + 560, + 405, + 579 + ], + "score": 0.9, + "content": "h _ { k , p } ^ { \\mathrm { l o c a l - i n } } = w ^ { \\mathrm { G L } } h _ { k , ( p \\cdot D _ { G } ) : ( ( p + 1 ) \\cdot D _ { G } ) } ^ { \\mathrm { g l o b a l - o u t } } + E _ { x _ { ( k \\cdot P + p - 1 ) } } ^ { \\mathrm { l o c a l - e m b e d } }", + "type": "interline_equation", + "image_path": "57fac0566a900d9c6ee74281ba1af564352dc9aafd60b8d471eb346877a6dbcf.jpg" + } + ] + } + ], + "index": 32, + "virtual_lines": [ + { + "bbox": [ + 204, + 560, + 405, + 579 + ], + "spans": [], + "index": 32 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 587, + 505, + 633 + ], + "lines": [ + { + "bbox": [ + 105, + 587, + 505, + 600 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 383, + 600 + ], + "score": 1.0, + "content": "Local Model is a smaller decoder-only Transformer of dimension", + "type": "text" + }, + { + "bbox": [ + 383, + 588, + 398, + 599 + ], + "score": 0.9, + "content": "D _ { L }", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 587, + 505, + 600 + ], + "score": 1.0, + "content": "that operates on a single", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 599, + 506, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 130, + 611 + ], + "score": 1.0, + "content": "patch", + "type": "text" + }, + { + "bbox": [ + 131, + 599, + 137, + 609 + ], + "score": 0.81, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 138, + 599, + 183, + 611 + ], + "score": 1.0, + "content": "containing", + "type": "text" + }, + { + "bbox": [ + 183, + 599, + 192, + 609 + ], + "score": 0.8, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 192, + 599, + 506, + 611 + ], + "score": 1.0, + "content": "elements, each of which is the sum of an output from the global model and an", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 610, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 106, + 610, + 300, + 621 + ], + "score": 1.0, + "content": "embedding of the previous byte in the sequence.", + "type": "text" + }, + { + "bbox": [ + 300, + 610, + 311, + 619 + ], + "score": 0.81, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 312, + 610, + 505, + 621 + ], + "score": 1.0, + "content": "copies of the local models are run on each patch", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 104, + 619, + 499, + 634 + ], + "spans": [ + { + "bbox": [ + 104, + 619, + 407, + 634 + ], + "score": 1.0, + "content": "independently (and in parallel during training), computing a representation", + "type": "text" + }, + { + "bbox": [ + 407, + 620, + 492, + 631 + ], + "score": 0.93, + "content": "h ^ { \\mathrm { l o c a l - o u t } } \\in \\mathbb { R } ^ { K \\times P \\cdot \\hat { D } _ { L } }", + "type": "inline_equation" + }, + { + "bbox": [ + 493, + 619, + 499, + 634 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 34.5 + }, + { + "type": "interline_equation", + "bbox": [ + 234, + 651, + 377, + 667 + ], + "lines": [ + { + "bbox": [ + 234, + 651, + 377, + 667 + ], + "spans": [ + { + "bbox": [ + 234, + 651, + 377, + 667 + ], + "score": 0.92, + "content": "h _ { k , 0 : P } ^ { \\mathrm { l o c a l - o u t } } = \\mathrm { t r a n s f o r m e r } ^ { \\mathrm { l o c a l } } ( h _ { k , 0 : P } ^ { \\mathrm { l o c a l - i n } } )", + "type": "interline_equation", + "image_path": "28abec1b597658611fe17622707aa5bf47c656ea54da0e344c02f51c1540c634.jpg" + } + ] + } + ], + "index": 37, + "virtual_lines": [ + { + "bbox": [ + 234, + 651, + 377, + 667 + ], + "spans": [], + "index": 37 + } + ] + }, + { + "type": "text", + "bbox": [ + 104, + 676, + 505, + 699 + ], + "lines": [ + { + "bbox": [ + 106, + 676, + 504, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 676, + 489, + 689 + ], + "score": 1.0, + "content": "Finally, we can compute the probability distribution over the vocabulary at each position. The", + "type": "text" + }, + { + "bbox": [ + 490, + 678, + 496, + 687 + ], + "score": 0.46, + "content": "p", + "type": "inline_equation" + }, + { + "bbox": [ + 496, + 676, + 504, + 689 + ], + "score": 1.0, + "content": "th", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 686, + 500, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 686, + 166, + 700 + ], + "score": 1.0, + "content": "element of the", + "type": "text" + }, + { + "bbox": [ + 166, + 688, + 172, + 697 + ], + "score": 0.6, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 173, + 686, + 300, + 700 + ], + "score": 1.0, + "content": "th patch corresponds to element", + "type": "text" + }, + { + "bbox": [ + 301, + 688, + 306, + 697 + ], + "score": 0.79, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 686, + 439, + 700 + ], + "score": 1.0, + "content": "of the complete sequence, where", + "type": "text" + }, + { + "bbox": [ + 440, + 687, + 496, + 699 + ], + "score": 0.92, + "content": "t = k \\cdot P + p", + "type": "inline_equation" + }, + { + "bbox": [ + 496, + 686, + 500, + 700 + ], + "score": 1.0, + "content": ":", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38.5 + }, + { + "type": "interline_equation", + "bbox": [ + 216, + 703, + 394, + 720 + ], + "lines": [ + { + "bbox": [ + 216, + 703, + 394, + 720 + ], + "spans": [ + { + "bbox": [ + 216, + 703, + 394, + 720 + ], + "score": 0.91, + "content": "p ( x _ { t } | x _ { 0 : t } ) = \\mathrm { s o f t m a x } \\big ( E ^ { \\mathrm { l o c a l - e m b e d } } h _ { k , p } ^ { \\mathrm { l o c a l - o u t } } \\big ) _ { x _ { t } }", + "type": "interline_equation", + "image_path": "2ea6fe3ee1f071463d574625618e5740e8274338ccc31780995c69475c8f705a.jpg" + } + ] + } + ], + "index": 40, + "virtual_lines": [ + { + "bbox": [ + 216, + 703, + 394, + 720 + ], + "spans": [], + "index": 40 + } + ] + } + ], + "page_idx": 2, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 309, + 750 + ], + "lines": [ + { + "bbox": [ + 301, + 740, + 310, + 752 + ], + "spans": [ + { + "bbox": [ + 301, + 740, + 310, + 752 + ], + "score": 1.0, + "content": "3", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 70, + 259, + 85 + ], + "lines": [ + { + "bbox": [ + 104, + 69, + 260, + 86 + ], + "spans": [ + { + "bbox": [ + 104, + 69, + 260, + 86 + ], + "score": 1.0, + "content": "2 MEGABYTE Transformer", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "title", + "bbox": [ + 107, + 90, + 172, + 101 + ], + "lines": [ + { + "bbox": [ + 105, + 88, + 172, + 104 + ], + "spans": [ + { + "bbox": [ + 105, + 88, + 172, + 104 + ], + "score": 1.0, + "content": "2.1 Overview", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 106, + 104, + 505, + 171 + ], + "lines": [ + { + "bbox": [ + 106, + 104, + 505, + 116 + ], + "spans": [ + { + "bbox": [ + 106, + 104, + 505, + 116 + ], + "score": 1.0, + "content": "MEGABYTE is an autoregressive model for efficiently modeling long input sequences. MEGABYTE", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 114, + 505, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 114, + 505, + 127 + ], + "score": 1.0, + "content": "is comprised of 3 components: (1) a patch embedder that inputs a discrete sequence, embeds each", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 127, + 505, + 138 + ], + "spans": [ + { + "bbox": [ + 106, + 127, + 279, + 138 + ], + "score": 1.0, + "content": "element, and chunks it into patches of length", + "type": "text" + }, + { + "bbox": [ + 280, + 127, + 289, + 136 + ], + "score": 0.73, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 289, + 127, + 505, + 138 + ], + "score": 1.0, + "content": "(2) a large global Transformer that contextualizes patch", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 137, + 506, + 149 + ], + "spans": [ + { + "bbox": [ + 105, + 137, + 506, + 149 + ], + "score": 1.0, + "content": "representations by performing self-attention over previous patches, and (3) a smaller local Transformer", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 147, + 506, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 147, + 506, + 161 + ], + "score": 1.0, + "content": "that inputs a contextualized patch representation from the global model, and autoregressively predict", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 159, + 166, + 171 + ], + "spans": [ + { + "bbox": [ + 105, + 159, + 166, + 171 + ], + "score": 1.0, + "content": "the next patch.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 4.5, + "bbox_fs": [ + 105, + 104, + 506, + 171 + ] + }, + { + "type": "title", + "bbox": [ + 106, + 177, + 185, + 189 + ], + "lines": [ + { + "bbox": [ + 105, + 176, + 186, + 191 + ], + "spans": [ + { + "bbox": [ + 105, + 176, + 186, + 191 + ], + "score": 1.0, + "content": "2.2 Components", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 106, + 191, + 504, + 214 + ], + "lines": [ + { + "bbox": [ + 105, + 190, + 505, + 205 + ], + "spans": [ + { + "bbox": [ + 105, + 190, + 250, + 205 + ], + "score": 1.0, + "content": "Patch Embedder with patch size of", + "type": "text" + }, + { + "bbox": [ + 250, + 192, + 259, + 201 + ], + "score": 0.85, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 259, + 190, + 345, + 205 + ], + "score": 1.0, + "content": "maps a byte sequence", + "type": "text" + }, + { + "bbox": [ + 345, + 194, + 367, + 203 + ], + "score": 0.88, + "content": "x _ { 0 . . T }", + "type": "inline_equation" + }, + { + "bbox": [ + 368, + 190, + 505, + 205 + ], + "score": 1.0, + "content": "to a sequence of patch embeddings", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 200, + 275, + 216 + ], + "spans": [ + { + "bbox": [ + 105, + 200, + 145, + 216 + ], + "score": 1.0, + "content": "of length", + "type": "text" + }, + { + "bbox": [ + 145, + 202, + 177, + 216 + ], + "score": 0.93, + "content": "\\begin{array} { r } { K = { \\frac { T } { P } } } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 177, + 200, + 239, + 216 + ], + "score": 1.0, + "content": "and dimension", + "type": "text" + }, + { + "bbox": [ + 239, + 203, + 270, + 214 + ], + "score": 0.91, + "content": "P \\cdot D _ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 270, + 200, + 275, + 216 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9.5, + "bbox_fs": [ + 105, + 190, + 505, + 216 + ] + }, + { + "type": "text", + "bbox": [ + 104, + 219, + 504, + 244 + ], + "lines": [ + { + "bbox": [ + 103, + 215, + 504, + 236 + ], + "spans": [ + { + "bbox": [ + 103, + 215, + 298, + 236 + ], + "score": 1.0, + "content": "First, each byte is embedded with a lookup table", + "type": "text" + }, + { + "bbox": [ + 298, + 221, + 307, + 231 + ], + "score": 0.27, + "content": "E", + "type": "inline_equation" + }, + { + "bbox": [ + 307, + 215, + 347, + 236 + ], + "score": 1.0, + "content": "global-embed", + "type": "text" + }, + { + "bbox": [ + 347, + 219, + 390, + 231 + ], + "score": 0.8, + "content": "\\in \\mathbb { R } ^ { V \\times D _ { G } }", + "type": "inline_equation" + }, + { + "bbox": [ + 390, + 215, + 487, + 236 + ], + "score": 1.0, + "content": "to an embedding of size", + "type": "text" + }, + { + "bbox": [ + 488, + 221, + 504, + 232 + ], + "score": 0.88, + "content": "D _ { G }", + "type": "inline_equation" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 232, + 258, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 232, + 258, + 244 + ], + "score": 1.0, + "content": "and positional embeddings are added.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5, + "bbox_fs": [ + 103, + 215, + 504, + 244 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 186, + 262, + 425, + 279 + ], + "lines": [ + { + "bbox": [ + 186, + 262, + 425, + 279 + ], + "spans": [ + { + "bbox": [ + 186, + 262, + 425, + 279 + ], + "score": 0.87, + "content": "h _ { t } ^ { \\mathrm { e m b e d } } = E _ { x _ { t } } ^ { \\mathrm { g l o b a l - e m b e d } } + E _ { t } ^ { \\mathrm { p o s } } \\qquad t \\in [ 0 . . T ]", + "type": "interline_equation", + "image_path": "fbd371f83072666d11f3dbac6272c1233685ffd57721ec010b8c94921894f6ee.jpg" + } + ] + } + ], + "index": 13, + "virtual_lines": [ + { + "bbox": [ + 186, + 262, + 425, + 279 + ], + "spans": [], + "index": 13 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 287, + 506, + 333 + ], + "lines": [ + { + "bbox": [ + 105, + 286, + 507, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 286, + 325, + 300 + ], + "score": 1.0, + "content": "Then, byte embeddings are reshaped into a sequence of", + "type": "text" + }, + { + "bbox": [ + 325, + 288, + 335, + 297 + ], + "score": 0.83, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 335, + 286, + 472, + 300 + ], + "score": 1.0, + "content": "patch embeddings with dimension", + "type": "text" + }, + { + "bbox": [ + 473, + 288, + 503, + 299 + ], + "score": 0.9, + "content": "P \\cdot D _ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 503, + 286, + 507, + 300 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 297, + 506, + 311 + ], + "spans": [ + { + "bbox": [ + 105, + 297, + 506, + 311 + ], + "score": 1.0, + "content": "To allow autoregressive modelling, the patch sequence is padded to start with a trainable patch-sized", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 104, + 307, + 506, + 322 + ], + "spans": [ + { + "bbox": [ + 104, + 307, + 192, + 322 + ], + "score": 1.0, + "content": "padding embedding", + "type": "text" + }, + { + "bbox": [ + 192, + 309, + 283, + 320 + ], + "score": 0.79, + "content": "( E ^ { \\mathrm { g l o b a l - p a d } } \\ \\in \\ \\mathbb { R } ^ { P \\times D _ { G } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 284, + 307, + 506, + 322 + ], + "score": 1.0, + "content": "), and the last patch is removed from the input. This", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 320, + 432, + 333 + ], + "spans": [ + { + "bbox": [ + 105, + 320, + 432, + 333 + ], + "score": 1.0, + "content": "sequence is the input to the global model, and is denoted hglobal-in ∈ RK×(P ·DG).", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15.5, + "bbox_fs": [ + 104, + 286, + 507, + 333 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 211, + 337, + 398, + 371 + ], + "lines": [ + { + "bbox": [ + 211, + 337, + 398, + 371 + ], + "spans": [ + { + "bbox": [ + 211, + 337, + 398, + 371 + ], + "score": 0.94, + "content": "\\begin{array} { r } { h _ { k } ^ { \\mathrm { g l o b a l - i n } } = \\left\\{ \\begin{array} { l l } { E ^ { \\mathrm { g l o b a l - p a d } } , } & { \\mathrm { i f } k = 0 , } \\\\ { h _ { ( ( k - 1 ) \\cdot P ) : ( k \\cdot P ) } ^ { \\mathrm { e m b e d } } , } & { k \\in [ 1 , . . , K ) , } \\end{array} \\right. } \\end{array}", + "type": "interline_equation", + "image_path": "e2fe38df9666626c0b52e08c0b29c77900098e6684701c587264e108576d9877.jpg" + } + ] + } + ], + "index": 18.5, + "virtual_lines": [ + { + "bbox": [ + 211, + 337, + 398, + 354.0 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 211, + 354.0, + 398, + 371.0 + ], + "spans": [], + "index": 19 + } + ] + }, + { + "type": "list", + "bbox": [ + 107, + 379, + 505, + 429 + ], + "lines": [ + { + "bbox": [ + 106, + 379, + 505, + 392 + ], + "spans": [ + { + "bbox": [ + 106, + 379, + 352, + 392 + ], + "score": 1.0, + "content": "Global Model is a decoder-only Transformer with dimension", + "type": "text" + }, + { + "bbox": [ + 352, + 380, + 383, + 390 + ], + "score": 0.92, + "content": "P \\cdot D _ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 383, + 379, + 505, + 392 + ], + "score": 1.0, + "content": "that operates on a sequence of", + "type": "text" + } + ], + "index": 20, + "is_list_start_line": true + }, + { + "bbox": [ + 107, + 390, + 505, + 437 + ], + "spans": [ + { + "bbox": [ + 107, + 391, + 117, + 401 + ], + "score": 0.79, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 117, + 390, + 165, + 437 + ], + "score": 1.0, + "content": "tween patchpresentation", + "type": "text" + }, + { + "bbox": [ + 201, + 390, + 272, + 437 + ], + "score": 1.0, + "content": "uts a sequence of by performing se", + "type": "text" + }, + { + "bbox": [ + 283, + 390, + 372, + 437 + ], + "score": 1.0, + "content": "patch representations attention over previous", + "type": "text" + }, + { + "bbox": [ + 405, + 390, + 505, + 437 + ], + "score": 1.0, + "content": ", and outputs an updated.", + "type": "text" + } + ], + "index": 21, + "is_list_start_line": true + }, + { + "bbox": [ + 273, + 402, + 405, + 416 + ], + "spans": [ + { + "bbox": [ + 273, + 403, + 283, + 413 + ], + "score": 0.83, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 372, + 402, + 405, + 416 + ], + "score": 0.91, + "content": "h _ { 0 : K } ^ { \\mathrm { g l o b a l - i n } }", + "type": "inline_equation" + } + ], + "index": 22, + "is_list_end_line": true + }, + { + "bbox": [ + 165, + 415, + 201, + 430 + ], + "spans": [ + { + "bbox": [ + 165, + 415, + 201, + 430 + ], + "score": 0.74, + "content": "h _ { 0 : K } ^ { \\mathrm { g l o b a l - o u t } }", + "type": "inline_equation" + } + ], + "index": 23, + "is_list_end_line": true + } + ], + "index": 21.5, + "bbox_fs": [ + 106, + 379, + 505, + 437 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 227, + 447, + 383, + 464 + ], + "lines": [ + { + "bbox": [ + 227, + 447, + 383, + 464 + ], + "spans": [ + { + "bbox": [ + 227, + 447, + 383, + 464 + ], + "score": 0.89, + "content": "h _ { 0 ; K } ^ { \\mathrm { g l o b a l - o u t } } = \\mathrm { t r a n s f o r m e r } ^ { \\mathrm { g l o b a l } } ( h _ { 0 : K } ^ { \\mathrm { g l o b a l - i n } } )", + "type": "interline_equation", + "image_path": "47b32affd6e4d369b5584e179987c1e82555ea48ccb3f5d9746a22a161ea1831.jpg" + } + ] + } + ], + "index": 24, + "virtual_lines": [ + { + "bbox": [ + 227, + 447, + 383, + 464 + ], + "spans": [], + "index": 24 + } + ] + }, + { + "type": "list", + "bbox": [ + 106, + 473, + 506, + 556 + ], + "lines": [ + { + "bbox": [ + 100, + 470, + 507, + 496 + ], + "spans": [ + { + "bbox": [ + 100, + 470, + 251, + 496 + ], + "score": 1.0, + "content": "The output of the final global layer", + "type": "text" + }, + { + "bbox": [ + 252, + 474, + 276, + 488 + ], + "score": 0.9, + "content": "h _ { 0 : K } ^ { \\mathrm { g l o b a l } }", + "type": "inline_equation" + }, + { + "bbox": [ + 277, + 470, + 314, + 496 + ], + "score": 1.0, + "content": "contains", + "type": "text" + }, + { + "bbox": [ + 315, + 476, + 325, + 486 + ], + "score": 0.83, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 325, + 470, + 346, + 496 + ], + "score": 1.0, + "content": "patc", + "type": "text" + }, + { + "bbox": [ + 356, + 470, + 416, + 496 + ], + "score": 1.0, + "content": "epresentations", + "type": "text" + }, + { + "bbox": [ + 433, + 470, + 471, + 496 + ], + "score": 1.0, + "content": "imension", + "type": "text" + }, + { + "bbox": [ + 472, + 476, + 502, + 487 + ], + "score": 0.9, + "content": "P \\cdot D _ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 503, + 470, + 507, + 496 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 25, + "is_list_start_line": true + }, + { + "bbox": [ + 105, + 485, + 504, + 500 + ], + "spans": [ + { + "bbox": [ + 105, + 485, + 346, + 500 + ], + "score": 1.0, + "content": "For each of these, we reshape them into sequences of length", + "type": "text" + }, + { + "bbox": [ + 346, + 487, + 355, + 496 + ], + "score": 0.83, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 417, + 487, + 433, + 497 + ], + "score": 0.89, + "content": "D _ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 433, + 485, + 497, + 500 + ], + "score": 1.0, + "content": ", where position", + "type": "text" + }, + { + "bbox": [ + 498, + 489, + 504, + 498 + ], + "score": 0.75, + "content": "p", + "type": "inline_equation" + } + ], + "index": 26, + "is_list_start_line": true + }, + { + "bbox": [ + 105, + 497, + 506, + 510 + ], + "spans": [ + { + "bbox": [ + 105, + 497, + 172, + 510 + ], + "score": 1.0, + "content": "uses dimensions", + "type": "text" + }, + { + "bbox": [ + 173, + 498, + 200, + 509 + ], + "score": 0.9, + "content": "p \\cdot D _ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 201, + 497, + 212, + 510 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 213, + 497, + 264, + 509 + ], + "score": 0.85, + "content": "( p + 1 ) \\cdot D _ { G }", + "type": "inline_equation" + }, + { + "bbox": [ + 264, + 497, + 506, + 510 + ], + "score": 1.0, + "content": ". Each position is then projected to the dimension of the local", + "type": "text" + } + ], + "index": 27, + "is_list_start_line": true + }, + { + "bbox": [ + 101, + 506, + 510, + 547 + ], + "spans": [ + { + "bbox": [ + 101, + 506, + 192, + 547 + ], + "score": 1.0, + "content": "model with a matrix these with byte embe", + "type": "text" + }, + { + "bbox": [ + 192, + 508, + 261, + 518 + ], + "score": 0.84, + "content": "w ^ { \\mathrm { G L } } \\in \\mathbb { R } ^ { D _ { G } \\times D _ { L } }", + "type": "inline_equation" + }, + { + "bbox": [ + 265, + 506, + 290, + 547 + ], + "score": 1.0, + "content": "where for th", + "type": "text" + }, + { + "bbox": [ + 290, + 509, + 306, + 519 + ], + "score": 0.89, + "content": "D _ { L }", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 506, + 392, + 547 + ], + "score": 1.0, + "content": "is the local model dikens in the next patch", + "type": "text" + }, + { + "bbox": [ + 468, + 506, + 510, + 547 + ], + "score": 1.0, + "content": "combineocal byte", + "type": "text" + } + ], + "index": 28, + "is_list_start_line": true + }, + { + "bbox": [ + 250, + 519, + 441, + 534 + ], + "spans": [ + { + "bbox": [ + 250, + 520, + 265, + 530 + ], + "score": 0.88, + "content": "D _ { L }", + "type": "inline_equation" + }, + { + "bbox": [ + 393, + 519, + 441, + 534 + ], + "score": 0.77, + "content": "E _ { x _ { ( k \\cdot P + p - 1 ) } } ^ { \\mathrm { l o c a l - e m b e d } }", + "type": "inline_equation" + } + ], + "index": 29, + "is_list_end_line": true + }, + { + "bbox": [ + 395, + 533, + 467, + 543 + ], + "spans": [ + { + "bbox": [ + 395, + 533, + 467, + 543 + ], + "score": 0.46, + "content": "( E ^ { \\mathrm { l o c a l - p a d } } \\in \\mathbb { R } ^ { D _ { L } } )", + "type": "inline_equation" + } + ], + "index": 30, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 542, + 455, + 558 + ], + "spans": [ + { + "bbox": [ + 104, + 542, + 455, + 558 + ], + "score": 1.0, + "content": "autoregressive modelling within a patch. This results in a tensor hlocal-in ∈ RK×P ×DL .", + "type": "text" + } + ], + "index": 31, + "is_list_start_line": true, + "is_list_end_line": true + } + ], + "index": 28, + "bbox_fs": [ + 100, + 470, + 510, + 558 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 204, + 560, + 405, + 579 + ], + "lines": [ + { + "bbox": [ + 204, + 560, + 405, + 579 + ], + "spans": [ + { + "bbox": [ + 204, + 560, + 405, + 579 + ], + "score": 0.9, + "content": "h _ { k , p } ^ { \\mathrm { l o c a l - i n } } = w ^ { \\mathrm { G L } } h _ { k , ( p \\cdot D _ { G } ) : ( ( p + 1 ) \\cdot D _ { G } ) } ^ { \\mathrm { g l o b a l - o u t } } + E _ { x _ { ( k \\cdot P + p - 1 ) } } ^ { \\mathrm { l o c a l - e m b e d } }", + "type": "interline_equation", + "image_path": "57fac0566a900d9c6ee74281ba1af564352dc9aafd60b8d471eb346877a6dbcf.jpg" + } + ] + } + ], + "index": 32, + "virtual_lines": [ + { + "bbox": [ + 204, + 560, + 405, + 579 + ], + "spans": [], + "index": 32 + } + ] + }, + { + "type": "text", + "bbox": [ + 106, + 587, + 505, + 633 + ], + "lines": [ + { + "bbox": [ + 105, + 587, + 505, + 600 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 383, + 600 + ], + "score": 1.0, + "content": "Local Model is a smaller decoder-only Transformer of dimension", + "type": "text" + }, + { + "bbox": [ + 383, + 588, + 398, + 599 + ], + "score": 0.9, + "content": "D _ { L }", + "type": "inline_equation" + }, + { + "bbox": [ + 399, + 587, + 505, + 600 + ], + "score": 1.0, + "content": "that operates on a single", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 599, + 506, + 611 + ], + "spans": [ + { + "bbox": [ + 105, + 599, + 130, + 611 + ], + "score": 1.0, + "content": "patch", + "type": "text" + }, + { + "bbox": [ + 131, + 599, + 137, + 609 + ], + "score": 0.81, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 138, + 599, + 183, + 611 + ], + "score": 1.0, + "content": "containing", + "type": "text" + }, + { + "bbox": [ + 183, + 599, + 192, + 609 + ], + "score": 0.8, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 192, + 599, + 506, + 611 + ], + "score": 1.0, + "content": "elements, each of which is the sum of an output from the global model and an", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 610, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 106, + 610, + 300, + 621 + ], + "score": 1.0, + "content": "embedding of the previous byte in the sequence.", + "type": "text" + }, + { + "bbox": [ + 300, + 610, + 311, + 619 + ], + "score": 0.81, + "content": "K", + "type": "inline_equation" + }, + { + "bbox": [ + 312, + 610, + 505, + 621 + ], + "score": 1.0, + "content": "copies of the local models are run on each patch", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 104, + 619, + 499, + 634 + ], + "spans": [ + { + "bbox": [ + 104, + 619, + 407, + 634 + ], + "score": 1.0, + "content": "independently (and in parallel during training), computing a representation", + "type": "text" + }, + { + "bbox": [ + 407, + 620, + 492, + 631 + ], + "score": 0.93, + "content": "h ^ { \\mathrm { l o c a l - o u t } } \\in \\mathbb { R } ^ { K \\times P \\cdot \\hat { D } _ { L } }", + "type": "inline_equation" + }, + { + "bbox": [ + 493, + 619, + 499, + 634 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 34.5, + "bbox_fs": [ + 104, + 587, + 506, + 634 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 234, + 651, + 377, + 667 + ], + "lines": [ + { + "bbox": [ + 234, + 651, + 377, + 667 + ], + "spans": [ + { + "bbox": [ + 234, + 651, + 377, + 667 + ], + "score": 0.92, + "content": "h _ { k , 0 : P } ^ { \\mathrm { l o c a l - o u t } } = \\mathrm { t r a n s f o r m e r } ^ { \\mathrm { l o c a l } } ( h _ { k , 0 : P } ^ { \\mathrm { l o c a l - i n } } )", + "type": "interline_equation", + "image_path": "28abec1b597658611fe17622707aa5bf47c656ea54da0e344c02f51c1540c634.jpg" + } + ] + } + ], + "index": 37, + "virtual_lines": [ + { + "bbox": [ + 234, + 651, + 377, + 667 + ], + "spans": [], + "index": 37 + } + ] + }, + { + "type": "text", + "bbox": [ + 104, + 676, + 505, + 699 + ], + "lines": [ + { + "bbox": [ + 106, + 676, + 504, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 676, + 489, + 689 + ], + "score": 1.0, + "content": "Finally, we can compute the probability distribution over the vocabulary at each position. The", + "type": "text" + }, + { + "bbox": [ + 490, + 678, + 496, + 687 + ], + "score": 0.46, + "content": "p", + "type": "inline_equation" + }, + { + "bbox": [ + 496, + 676, + 504, + 689 + ], + "score": 1.0, + "content": "th", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 686, + 500, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 686, + 166, + 700 + ], + "score": 1.0, + "content": "element of the", + "type": "text" + }, + { + "bbox": [ + 166, + 688, + 172, + 697 + ], + "score": 0.6, + "content": "k", + "type": "inline_equation" + }, + { + "bbox": [ + 173, + 686, + 300, + 700 + ], + "score": 1.0, + "content": "th patch corresponds to element", + "type": "text" + }, + { + "bbox": [ + 301, + 688, + 306, + 697 + ], + "score": 0.79, + "content": "t", + "type": "inline_equation" + }, + { + "bbox": [ + 306, + 686, + 439, + 700 + ], + "score": 1.0, + "content": "of the complete sequence, where", + "type": "text" + }, + { + "bbox": [ + 440, + 687, + 496, + 699 + ], + "score": 0.92, + "content": "t = k \\cdot P + p", + "type": "inline_equation" + }, + { + "bbox": [ + 496, + 686, + 500, + 700 + ], + "score": 1.0, + "content": ":", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 38.5, + "bbox_fs": [ + 105, + 676, + 504, + 700 + ] + }, + { + "type": "interline_equation", + "bbox": [ + 216, + 703, + 394, + 720 + ], + "lines": [ + { + "bbox": [ + 216, + 703, + 394, + 720 + ], + "spans": [ + { + "bbox": [ + 216, + 703, + 394, + 720 + ], + "score": 0.91, + "content": "p ( x _ { t } | x _ { 0 : t } ) = \\mathrm { s o f t m a x } \\big ( E ^ { \\mathrm { l o c a l - e m b e d } } h _ { k , p } ^ { \\mathrm { l o c a l - o u t } } \\big ) _ { x _ { t } }", + "type": "interline_equation", + "image_path": "2ea6fe3ee1f071463d574625618e5740e8274338ccc31780995c69475c8f705a.jpg" + } + ] + } + ], + "index": 40, + "virtual_lines": [ + { + "bbox": [ + 216, + 703, + 394, + 720 + ], + "spans": [], + "index": 40 + } + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 73, + 242, + 84 + ], + "lines": [ + { + "bbox": [ + 106, + 72, + 242, + 85 + ], + "spans": [ + { + "bbox": [ + 106, + 72, + 242, + 85 + ], + "score": 1.0, + "content": "2.3 Variations and Extensions", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 87, + 505, + 153 + ], + "lines": [ + { + "bbox": [ + 106, + 86, + 505, + 100 + ], + "spans": [ + { + "bbox": [ + 106, + 86, + 505, + 100 + ], + "score": 1.0, + "content": "Convolutional Patch Encoder: One limitation of patchifying sequences is that it is not translation", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 99, + 505, + 110 + ], + "spans": [ + { + "bbox": [ + 106, + 99, + 505, + 110 + ], + "score": 1.0, + "content": "invariant, and byte sequences may receive a different representation depending on their position in", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 109, + 506, + 122 + ], + "spans": [ + { + "bbox": [ + 105, + 109, + 506, + 122 + ], + "score": 1.0, + "content": "the patch. This may mean, for example, that a model has to relearn the meaning of a word at different", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 119, + 506, + 132 + ], + "spans": [ + { + "bbox": [ + 105, + 119, + 506, + 132 + ], + "score": 1.0, + "content": "offsets. To mitigate this issue, we experimented with augmenting the Patch Embedder with causal", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 131, + 505, + 143 + ], + "spans": [ + { + "bbox": [ + 106, + 131, + 505, + 143 + ], + "score": 1.0, + "content": "convolutional layers, which allow translation-invariant contextual representations of the bytes before", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 142, + 507, + 154 + ], + "spans": [ + { + "bbox": [ + 105, + 142, + 507, + 154 + ], + "score": 1.0, + "content": "they are chunked into patches. We use a stack of convolutional layers, with filter sizes of 3, 5 and 7.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 107, + 158, + 505, + 246 + ], + "lines": [ + { + "bbox": [ + 106, + 158, + 505, + 170 + ], + "spans": [ + { + "bbox": [ + 106, + 158, + 505, + 170 + ], + "score": 1.0, + "content": "Cross-patch Attention: The Local model uses short sequences for efficiency, and relies on the", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 169, + 505, + 181 + ], + "spans": [ + { + "bbox": [ + 106, + 169, + 505, + 181 + ], + "score": 1.0, + "content": "Global model for long-range information. However, we can increase the context of the Local model", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 179, + 505, + 193 + ], + "spans": [ + { + "bbox": [ + 105, + 179, + 303, + 193 + ], + "score": 1.0, + "content": "with little overhead by allowing it to condition on", + "type": "text" + }, + { + "bbox": [ + 303, + 182, + 309, + 190 + ], + "score": 0.66, + "content": "r", + "type": "inline_equation" + }, + { + "bbox": [ + 310, + 179, + 505, + 193 + ], + "score": 1.0, + "content": "elements from the previous patch. This approach", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 190, + 506, + 203 + ], + "spans": [ + { + "bbox": [ + 105, + 190, + 506, + 203 + ], + "score": 1.0, + "content": "allows the Global model to focus on a longer-range context. Specifically, when computing self-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 202, + 505, + 214 + ], + "spans": [ + { + "bbox": [ + 105, + 202, + 403, + 214 + ], + "score": 1.0, + "content": "attention in each layer, we concatenate the keys and values with the last", + "type": "text" + }, + { + "bbox": [ + 404, + 204, + 410, + 212 + ], + "score": 0.63, + "content": "r", + "type": "inline_equation" + }, + { + "bbox": [ + 411, + 202, + 505, + 214 + ], + "score": 1.0, + "content": "keys and queries from", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 212, + 505, + 225 + ], + "spans": [ + { + "bbox": [ + 105, + 212, + 505, + 225 + ], + "score": 1.0, + "content": "the previous patch. We use rotary embeddings (Su et al., 2021) to model relative positions between", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 223, + 506, + 236 + ], + "spans": [ + { + "bbox": [ + 105, + 223, + 506, + 236 + ], + "score": 1.0, + "content": "elements in the sequence. This approach is reminiscent of TransformerXL (Dai et al., 2019) but", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 235, + 251, + 246 + ], + "spans": [ + { + "bbox": [ + 105, + 235, + 251, + 246 + ], + "score": 1.0, + "content": "differs by being fully differentiable.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 10.5 + }, + { + "type": "text", + "bbox": [ + 106, + 251, + 505, + 316 + ], + "lines": [ + { + "bbox": [ + 105, + 250, + 506, + 263 + ], + "spans": [ + { + "bbox": [ + 105, + 250, + 506, + 263 + ], + "score": 1.0, + "content": "Strided Inference: We observed empirically that the per-token loss within each patch increases", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 261, + 506, + 273 + ], + "spans": [ + { + "bbox": [ + 106, + 261, + 506, + 273 + ], + "score": 1.0, + "content": "towards the end of the patch, as the prediction relies more on the weaker Local model. To alleviate", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 273, + 505, + 285 + ], + "spans": [ + { + "bbox": [ + 106, + 273, + 505, + 285 + ], + "score": 1.0, + "content": "this issue, we propose strided inference, in which we predict the sequence with two forward passes of", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 284, + 505, + 296 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 275, + 296 + ], + "score": 1.0, + "content": "the full model, whose inputs are offset by", + "type": "text" + }, + { + "bbox": [ + 275, + 284, + 291, + 296 + ], + "score": 0.88, + "content": "p / 2", + "type": "inline_equation" + }, + { + "bbox": [ + 292, + 284, + 505, + 296 + ], + "score": 1.0, + "content": "positions from each other. We then combine the first", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 294, + 505, + 308 + ], + "spans": [ + { + "bbox": [ + 106, + 294, + 123, + 307 + ], + "score": 0.87, + "content": "p / 2", + "type": "inline_equation" + }, + { + "bbox": [ + 123, + 294, + 505, + 308 + ], + "score": 1.0, + "content": "positions in each patch for our predictions to predict the complete sequence. Similarly to sliding", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 305, + 506, + 318 + ], + "spans": [ + { + "bbox": [ + 105, + 305, + 506, + 318 + ], + "score": 1.0, + "content": "window methods (Press et al., 2020), this approach doubles the cost of inference but improves results.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 17.5 + }, + { + "type": "title", + "bbox": [ + 108, + 327, + 222, + 340 + ], + "lines": [ + { + "bbox": [ + 104, + 325, + 225, + 344 + ], + "spans": [ + { + "bbox": [ + 104, + 325, + 225, + 344 + ], + "score": 1.0, + "content": "3 Efficiency Analysis", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "title", + "bbox": [ + 107, + 347, + 212, + 358 + ], + "lines": [ + { + "bbox": [ + 104, + 344, + 213, + 362 + ], + "spans": [ + { + "bbox": [ + 104, + 344, + 213, + 362 + ], + "score": 1.0, + "content": "3.1 Training Efficiency", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 106, + 361, + 505, + 496 + ], + "lines": [ + { + "bbox": [ + 105, + 360, + 505, + 373 + ], + "spans": [ + { + "bbox": [ + 105, + 360, + 451, + 373 + ], + "score": 1.0, + "content": "Attention The cost of attention in a transformer architecture for a sequence of length", + "type": "text" + }, + { + "bbox": [ + 451, + 362, + 460, + 371 + ], + "score": 0.76, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 460, + 360, + 476, + 373 + ], + "score": 1.0, + "content": "has", + "type": "text" + }, + { + "bbox": [ + 477, + 361, + 505, + 373 + ], + "score": 0.91, + "content": "O ( T ^ { 2 } )", + "type": "inline_equation" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 372, + 505, + 384 + ], + "spans": [ + { + "bbox": [ + 105, + 372, + 505, + 384 + ], + "score": 1.0, + "content": "complexity. Much work has been explored reducing this; for example, Sparse Transformers (Child", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 382, + 505, + 396 + ], + "spans": [ + { + "bbox": [ + 105, + 382, + 505, + 396 + ], + "score": 1.0, + "content": "et al., 2019) and Routing Transformers (Roy et al., 2020) show strong results with a complexity", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 107, + 394, + 506, + 409 + ], + "spans": [ + { + "bbox": [ + 107, + 394, + 136, + 408 + ], + "score": 0.92, + "content": "O ( T ^ { \\frac { 3 } { 2 } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 137, + 394, + 506, + 409 + ], + "score": 1.0, + "content": ". Many linear attention mechanisms have also been proposed (Katharopoulos et al., 2020;", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 405, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 105, + 405, + 505, + 420 + ], + "score": 1.0, + "content": "Choromanski et al., 2020), although we are not aware of competitive results on large scale language", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 418, + 505, + 430 + ], + "spans": [ + { + "bbox": [ + 106, + 418, + 298, + 430 + ], + "score": 1.0, + "content": "modeling tasks. As a function of sequence length", + "type": "text" + }, + { + "bbox": [ + 298, + 418, + 307, + 428 + ], + "score": 0.82, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 307, + 418, + 364, + 430 + ], + "score": 1.0, + "content": "and patch size", + "type": "text" + }, + { + "bbox": [ + 364, + 418, + 373, + 428 + ], + "score": 0.82, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 373, + 418, + 505, + 430 + ], + "score": 1.0, + "content": ", the Global model has a sequence", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 104, + 428, + 506, + 446 + ], + "spans": [ + { + "bbox": [ + 104, + 428, + 145, + 446 + ], + "score": 1.0, + "content": "of length", + "type": "text" + }, + { + "bbox": [ + 146, + 429, + 155, + 444 + ], + "score": 0.88, + "content": "\\textstyle { \\frac { P } { T } }", + "type": "inline_equation" + }, + { + "bbox": [ + 155, + 428, + 187, + 446 + ], + "score": 1.0, + "content": "so uses", + "type": "text" + }, + { + "bbox": [ + 187, + 428, + 217, + 444 + ], + "score": 0.93, + "content": "\\scriptstyle O ( { \\frac { T ^ { 2 } } { P ^ { 2 } } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 217, + 428, + 370, + 446 + ], + "score": 1.0, + "content": "operations, and the Local model uses", + "type": "text" + }, + { + "bbox": [ + 371, + 430, + 380, + 444 + ], + "score": 0.89, + "content": "\\textstyle { \\frac { P } { T } }", + "type": "inline_equation" + }, + { + "bbox": [ + 380, + 428, + 463, + 446 + ], + "score": 1.0, + "content": "sequences of length", + "type": "text" + }, + { + "bbox": [ + 464, + 431, + 473, + 441 + ], + "score": 0.82, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 473, + 428, + 506, + 446 + ], + "score": 1.0, + "content": "so uses", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 107, + 442, + 507, + 460 + ], + "spans": [ + { + "bbox": [ + 107, + 443, + 186, + 459 + ], + "score": 0.93, + "content": "\\begin{array} { r } { O ( \\frac { T P ^ { 2 } } { P } ) = O ( P T ) } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 186, + 442, + 418, + 460 + ], + "score": 1.0, + "content": "operations. The overall cost of MEGABYTE is therefore in", + "type": "text" + }, + { + "bbox": [ + 419, + 443, + 474, + 459 + ], + "score": 0.92, + "content": "\\begin{array} { r } { O ( \\frac { T ^ { 2 } } { P ^ { 2 } } + T P ) } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 474, + 442, + 479, + 460 + ], + "score": 1.0, + "content": ".", + "type": "text" + }, + { + "bbox": [ + 479, + 445, + 488, + 456 + ], + "score": 0.77, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 488, + 442, + 507, + 460 + ], + "score": 1.0, + "content": "is a", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 104, + 457, + 503, + 473 + ], + "spans": [ + { + "bbox": [ + 104, + 458, + 412, + 473 + ], + "score": 1.0, + "content": "hyperparameter that is chosen to create an architecture for sequences of size", + "type": "text" + }, + { + "bbox": [ + 412, + 460, + 420, + 469 + ], + "score": 0.72, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 421, + 458, + 468, + 473 + ], + "score": 1.0, + "content": ". By setting", + "type": "text" + }, + { + "bbox": [ + 468, + 457, + 503, + 470 + ], + "score": 0.92, + "content": "P = T ^ { \\frac { 1 } { 3 } }", + "type": "inline_equation" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 470, + 506, + 485 + ], + "spans": [ + { + "bbox": [ + 105, + 470, + 190, + 485 + ], + "score": 1.0, + "content": "the complexity is in", + "type": "text" + }, + { + "bbox": [ + 190, + 470, + 220, + 484 + ], + "score": 0.93, + "content": "O ( T ^ { \\frac { 4 } { 3 } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 220, + 470, + 353, + 485 + ], + "score": 1.0, + "content": ". Using much shorter patches of", + "type": "text" + }, + { + "bbox": [ + 353, + 470, + 389, + 482 + ], + "score": 0.92, + "content": "P = T ^ { \\frac { 1 } { 5 } }", + "type": "inline_equation" + }, + { + "bbox": [ + 389, + 470, + 506, + 485 + ], + "score": 1.0, + "content": "would give a complexity of", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 107, + 482, + 497, + 498 + ], + "spans": [ + { + "bbox": [ + 107, + 483, + 136, + 497 + ], + "score": 0.92, + "content": "O ( T ^ { \\frac { 8 } { 5 } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 137, + 482, + 397, + 498 + ], + "score": 1.0, + "content": ". The cost is less than the transformer for all non-trivial values of", + "type": "text" + }, + { + "bbox": [ + 397, + 485, + 406, + 495 + ], + "score": 0.82, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 406, + 482, + 445, + 498 + ], + "score": 1.0, + "content": "such that", + "type": "text" + }, + { + "bbox": [ + 446, + 485, + 493, + 495 + ], + "score": 0.9, + "content": "1 < P < T", + "type": "inline_equation" + }, + { + "bbox": [ + 493, + 482, + 497, + 498 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 106, + 503, + 505, + 630 + ], + "lines": [ + { + "bbox": [ + 106, + 502, + 506, + 515 + ], + "spans": [ + { + "bbox": [ + 106, + 502, + 506, + 515 + ], + "score": 1.0, + "content": "Feedforward Layers However, attention is not the main cost in large transformers. Instead of", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 514, + 504, + 526 + ], + "spans": [ + { + "bbox": [ + 106, + 514, + 504, + 526 + ], + "score": 1.0, + "content": "increasing the sequence length, transformers are more commonly scaled by increasing the dimension", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 525, + 505, + 537 + ], + "spans": [ + { + "bbox": [ + 106, + 525, + 183, + 537 + ], + "score": 1.0, + "content": "of their latent state", + "type": "text" + }, + { + "bbox": [ + 183, + 525, + 190, + 535 + ], + "score": 0.76, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 190, + 525, + 505, + 537 + ], + "score": 1.0, + "content": ", and the feedforward network cost dominates the model’s overall cost (Kaplan", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 536, + 505, + 549 + ], + "spans": [ + { + "bbox": [ + 105, + 536, + 505, + 549 + ], + "score": 1.0, + "content": "et al., 2020). For example, in the GPT3 architecture, the quadratic self-attention computation accounts", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 546, + 505, + 560 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 141, + 560 + ], + "score": 1.0, + "content": "for only", + "type": "text" + }, + { + "bbox": [ + 141, + 547, + 163, + 558 + ], + "score": 0.87, + "content": "1 . 4 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 163, + 546, + 505, + 560 + ], + "score": 1.0, + "content": "of FLOPS. Following the approximation of (Kaplan et al., 2020), a forward pass with", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 558, + 505, + 571 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 210, + 571 + ], + "score": 1.0, + "content": "a large transformer with", + "type": "text" + }, + { + "bbox": [ + 210, + 560, + 220, + 568 + ], + "score": 0.72, + "content": "m", + "type": "inline_equation" + }, + { + "bbox": [ + 221, + 558, + 439, + 571 + ], + "score": 1.0, + "content": "non-embedding parameters on a sequence of length", + "type": "text" + }, + { + "bbox": [ + 440, + 558, + 448, + 568 + ], + "score": 0.79, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 449, + 558, + 505, + 571 + ], + "score": 1.0, + "content": "uses roughly", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 567, + 506, + 582 + ], + "spans": [ + { + "bbox": [ + 106, + 569, + 129, + 579 + ], + "score": 0.71, + "content": "2 m T", + "type": "inline_equation" + }, + { + "bbox": [ + 129, + 567, + 423, + 582 + ], + "score": 1.0, + "content": "FLOPS. MEGABYTE contains two transformers: the Global model uses", + "type": "text" + }, + { + "bbox": [ + 423, + 570, + 437, + 581 + ], + "score": 0.87, + "content": "m _ { g }", + "type": "inline_equation" + }, + { + "bbox": [ + 438, + 567, + 506, + 582 + ], + "score": 1.0, + "content": "parameters on a", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 102, + 575, + 502, + 600 + ], + "spans": [ + { + "bbox": [ + 102, + 575, + 186, + 600 + ], + "score": 1.0, + "content": "sequence of length", + "type": "text" + }, + { + "bbox": [ + 186, + 580, + 195, + 594 + ], + "score": 0.86, + "content": "\\textstyle { \\frac { T } { P } }", + "type": "inline_equation" + }, + { + "bbox": [ + 196, + 575, + 299, + 600 + ], + "score": 1.0, + "content": ", and a Local model with", + "type": "text" + }, + { + "bbox": [ + 299, + 582, + 312, + 592 + ], + "score": 0.82, + "content": "m _ { l }", + "type": "inline_equation" + }, + { + "bbox": [ + 313, + 575, + 399, + 600 + ], + "score": 1.0, + "content": "parameters that sees", + "type": "text" + }, + { + "bbox": [ + 399, + 580, + 409, + 594 + ], + "score": 0.89, + "content": "\\textstyle { \\frac { T } { P } }", + "type": "inline_equation" + }, + { + "bbox": [ + 409, + 575, + 493, + 600 + ], + "score": 1.0, + "content": "sequences of length", + "type": "text" + }, + { + "bbox": [ + 493, + 581, + 502, + 591 + ], + "score": 0.79, + "content": "P", + "type": "inline_equation" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 591, + 507, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 591, + 193, + 609 + ], + "score": 1.0, + "content": "giving an estimate of", + "type": "text" + }, + { + "bbox": [ + 194, + 593, + 252, + 606 + ], + "score": 0.92, + "content": "2 T ( \\frac { m _ { g } } { P } + m _ { l } )", + "type": "inline_equation" + }, + { + "bbox": [ + 252, + 591, + 315, + 609 + ], + "score": 1.0, + "content": "FLOPS. When", + "type": "text" + }, + { + "bbox": [ + 315, + 594, + 357, + 606 + ], + "score": 0.91, + "content": "m _ { g } \\gg m _ { l }", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 591, + 507, + 609 + ], + "score": 1.0, + "content": ", the FLOPS used by MEGABYTE is", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 601, + 509, + 626 + ], + "spans": [ + { + "bbox": [ + 105, + 601, + 168, + 626 + ], + "score": 1.0, + "content": "approximately", + "type": "text" + }, + { + "bbox": [ + 168, + 605, + 192, + 621 + ], + "score": 0.92, + "content": "\\frac { 2 T m _ { g } } { P }", + "type": "inline_equation" + }, + { + "bbox": [ + 192, + 601, + 268, + 626 + ], + "score": 1.0, + "content": ", allowing a model", + "type": "text" + }, + { + "bbox": [ + 269, + 608, + 278, + 618 + ], + "score": 0.81, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 278, + 601, + 509, + 626 + ], + "score": 1.0, + "content": "times larger than a transformer with equivalent FLOPS.", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 618, + 482, + 632 + ], + "spans": [ + { + "bbox": [ + 106, + 618, + 482, + 632 + ], + "score": 1.0, + "content": "This analysis holds irrespective of any efficient attention mechanisms used in the transformer.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 39 + }, + { + "type": "text", + "bbox": [ + 106, + 636, + 505, + 692 + ], + "lines": [ + { + "bbox": [ + 106, + 636, + 506, + 649 + ], + "spans": [ + { + "bbox": [ + 106, + 636, + 506, + 649 + ], + "score": 1.0, + "content": "Combined Analysis To understand efficiency at different sequence lengths and model sizes,", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 648, + 505, + 659 + ], + "spans": [ + { + "bbox": [ + 106, + 648, + 505, + 659 + ], + "score": 1.0, + "content": "we calculate the total FLOPS used by transformers, Linear Transformers and MEGABYTE. For", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 659, + 506, + 671 + ], + "spans": [ + { + "bbox": [ + 106, + 659, + 506, + 671 + ], + "score": 1.0, + "content": "each operation, we use FLOP estimates from (Kaplan et al., 2020), except for attention in Linear", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 668, + 506, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 668, + 249, + 683 + ], + "score": 1.0, + "content": "Transformers, which we estimate as", + "type": "text" + }, + { + "bbox": [ + 249, + 670, + 264, + 680 + ], + "score": 0.71, + "content": "9 D", + "type": "inline_equation" + }, + { + "bbox": [ + 264, + 668, + 354, + 683 + ], + "score": 1.0, + "content": "FLOPS/token1, where", + "type": "text" + }, + { + "bbox": [ + 354, + 670, + 364, + 680 + ], + "score": 0.81, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 364, + 668, + 506, + 683 + ], + "score": 1.0, + "content": "is the model embedding dimension.", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 680, + 506, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 680, + 506, + 694 + ], + "score": 1.0, + "content": "Figure 3 shows that for models of size 660M to 173B and sequence lengths of up to 1M tokens,", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 47 + } + ], + "page_idx": 3, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 701, + 504, + 722 + ], + "lines": [ + { + "bbox": [ + 118, + 699, + 506, + 714 + ], + "spans": [ + { + "bbox": [ + 118, + 699, + 506, + 714 + ], + "score": 1.0, + "content": "1This may underestimate the time taken by Linear Transformer decoders, which use a recurrence mechanism", + "type": "text" + } + ] + }, + { + "bbox": [ + 106, + 712, + 281, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 712, + 281, + 723 + ], + "score": 1.0, + "content": "that is harder to parallelize on current hardware.", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 742, + 308, + 750 + ], + "lines": [ + { + "bbox": [ + 301, + 741, + 310, + 752 + ], + "spans": [ + { + "bbox": [ + 301, + 741, + 310, + 752 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 11, + "width": 9 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 73, + 242, + 84 + ], + "lines": [ + { + "bbox": [ + 106, + 72, + 242, + 85 + ], + "spans": [ + { + "bbox": [ + 106, + 72, + 242, + 85 + ], + "score": 1.0, + "content": "2.3 Variations and Extensions", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 87, + 505, + 153 + ], + "lines": [ + { + "bbox": [ + 106, + 86, + 505, + 100 + ], + "spans": [ + { + "bbox": [ + 106, + 86, + 505, + 100 + ], + "score": 1.0, + "content": "Convolutional Patch Encoder: One limitation of patchifying sequences is that it is not translation", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 106, + 99, + 505, + 110 + ], + "spans": [ + { + "bbox": [ + 106, + 99, + 505, + 110 + ], + "score": 1.0, + "content": "invariant, and byte sequences may receive a different representation depending on their position in", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 109, + 506, + 122 + ], + "spans": [ + { + "bbox": [ + 105, + 109, + 506, + 122 + ], + "score": 1.0, + "content": "the patch. This may mean, for example, that a model has to relearn the meaning of a word at different", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 119, + 506, + 132 + ], + "spans": [ + { + "bbox": [ + 105, + 119, + 506, + 132 + ], + "score": 1.0, + "content": "offsets. To mitigate this issue, we experimented with augmenting the Patch Embedder with causal", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 131, + 505, + 143 + ], + "spans": [ + { + "bbox": [ + 106, + 131, + 505, + 143 + ], + "score": 1.0, + "content": "convolutional layers, which allow translation-invariant contextual representations of the bytes before", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 142, + 507, + 154 + ], + "spans": [ + { + "bbox": [ + 105, + 142, + 507, + 154 + ], + "score": 1.0, + "content": "they are chunked into patches. We use a stack of convolutional layers, with filter sizes of 3, 5 and 7.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 3.5, + "bbox_fs": [ + 105, + 86, + 507, + 154 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 158, + 505, + 246 + ], + "lines": [ + { + "bbox": [ + 106, + 158, + 505, + 170 + ], + "spans": [ + { + "bbox": [ + 106, + 158, + 505, + 170 + ], + "score": 1.0, + "content": "Cross-patch Attention: The Local model uses short sequences for efficiency, and relies on the", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 169, + 505, + 181 + ], + "spans": [ + { + "bbox": [ + 106, + 169, + 505, + 181 + ], + "score": 1.0, + "content": "Global model for long-range information. However, we can increase the context of the Local model", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 179, + 505, + 193 + ], + "spans": [ + { + "bbox": [ + 105, + 179, + 303, + 193 + ], + "score": 1.0, + "content": "with little overhead by allowing it to condition on", + "type": "text" + }, + { + "bbox": [ + 303, + 182, + 309, + 190 + ], + "score": 0.66, + "content": "r", + "type": "inline_equation" + }, + { + "bbox": [ + 310, + 179, + 505, + 193 + ], + "score": 1.0, + "content": "elements from the previous patch. This approach", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 190, + 506, + 203 + ], + "spans": [ + { + "bbox": [ + 105, + 190, + 506, + 203 + ], + "score": 1.0, + "content": "allows the Global model to focus on a longer-range context. Specifically, when computing self-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 202, + 505, + 214 + ], + "spans": [ + { + "bbox": [ + 105, + 202, + 403, + 214 + ], + "score": 1.0, + "content": "attention in each layer, we concatenate the keys and values with the last", + "type": "text" + }, + { + "bbox": [ + 404, + 204, + 410, + 212 + ], + "score": 0.63, + "content": "r", + "type": "inline_equation" + }, + { + "bbox": [ + 411, + 202, + 505, + 214 + ], + "score": 1.0, + "content": "keys and queries from", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 212, + 505, + 225 + ], + "spans": [ + { + "bbox": [ + 105, + 212, + 505, + 225 + ], + "score": 1.0, + "content": "the previous patch. We use rotary embeddings (Su et al., 2021) to model relative positions between", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 223, + 506, + 236 + ], + "spans": [ + { + "bbox": [ + 105, + 223, + 506, + 236 + ], + "score": 1.0, + "content": "elements in the sequence. This approach is reminiscent of TransformerXL (Dai et al., 2019) but", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 235, + 251, + 246 + ], + "spans": [ + { + "bbox": [ + 105, + 235, + 251, + 246 + ], + "score": 1.0, + "content": "differs by being fully differentiable.", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 10.5, + "bbox_fs": [ + 105, + 158, + 506, + 246 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 251, + 505, + 316 + ], + "lines": [ + { + "bbox": [ + 105, + 250, + 506, + 263 + ], + "spans": [ + { + "bbox": [ + 105, + 250, + 506, + 263 + ], + "score": 1.0, + "content": "Strided Inference: We observed empirically that the per-token loss within each patch increases", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 261, + 506, + 273 + ], + "spans": [ + { + "bbox": [ + 106, + 261, + 506, + 273 + ], + "score": 1.0, + "content": "towards the end of the patch, as the prediction relies more on the weaker Local model. To alleviate", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 273, + 505, + 285 + ], + "spans": [ + { + "bbox": [ + 106, + 273, + 505, + 285 + ], + "score": 1.0, + "content": "this issue, we propose strided inference, in which we predict the sequence with two forward passes of", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 284, + 505, + 296 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 275, + 296 + ], + "score": 1.0, + "content": "the full model, whose inputs are offset by", + "type": "text" + }, + { + "bbox": [ + 275, + 284, + 291, + 296 + ], + "score": 0.88, + "content": "p / 2", + "type": "inline_equation" + }, + { + "bbox": [ + 292, + 284, + 505, + 296 + ], + "score": 1.0, + "content": "positions from each other. We then combine the first", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 294, + 505, + 308 + ], + "spans": [ + { + "bbox": [ + 106, + 294, + 123, + 307 + ], + "score": 0.87, + "content": "p / 2", + "type": "inline_equation" + }, + { + "bbox": [ + 123, + 294, + 505, + 308 + ], + "score": 1.0, + "content": "positions in each patch for our predictions to predict the complete sequence. Similarly to sliding", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 305, + 506, + 318 + ], + "spans": [ + { + "bbox": [ + 105, + 305, + 506, + 318 + ], + "score": 1.0, + "content": "window methods (Press et al., 2020), this approach doubles the cost of inference but improves results.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 17.5, + "bbox_fs": [ + 105, + 250, + 506, + 318 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 327, + 222, + 340 + ], + "lines": [ + { + "bbox": [ + 104, + 325, + 225, + 344 + ], + "spans": [ + { + "bbox": [ + 104, + 325, + 225, + 344 + ], + "score": 1.0, + "content": "3 Efficiency Analysis", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "title", + "bbox": [ + 107, + 347, + 212, + 358 + ], + "lines": [ + { + "bbox": [ + 104, + 344, + 213, + 362 + ], + "spans": [ + { + "bbox": [ + 104, + 344, + 213, + 362 + ], + "score": 1.0, + "content": "3.1 Training Efficiency", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 22 + }, + { + "type": "text", + "bbox": [ + 106, + 361, + 505, + 496 + ], + "lines": [ + { + "bbox": [ + 105, + 360, + 505, + 373 + ], + "spans": [ + { + "bbox": [ + 105, + 360, + 451, + 373 + ], + "score": 1.0, + "content": "Attention The cost of attention in a transformer architecture for a sequence of length", + "type": "text" + }, + { + "bbox": [ + 451, + 362, + 460, + 371 + ], + "score": 0.76, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 460, + 360, + 476, + 373 + ], + "score": 1.0, + "content": "has", + "type": "text" + }, + { + "bbox": [ + 477, + 361, + 505, + 373 + ], + "score": 0.91, + "content": "O ( T ^ { 2 } )", + "type": "inline_equation" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 372, + 505, + 384 + ], + "spans": [ + { + "bbox": [ + 105, + 372, + 505, + 384 + ], + "score": 1.0, + "content": "complexity. Much work has been explored reducing this; for example, Sparse Transformers (Child", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 382, + 505, + 396 + ], + "spans": [ + { + "bbox": [ + 105, + 382, + 505, + 396 + ], + "score": 1.0, + "content": "et al., 2019) and Routing Transformers (Roy et al., 2020) show strong results with a complexity", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 107, + 394, + 506, + 409 + ], + "spans": [ + { + "bbox": [ + 107, + 394, + 136, + 408 + ], + "score": 0.92, + "content": "O ( T ^ { \\frac { 3 } { 2 } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 137, + 394, + 506, + 409 + ], + "score": 1.0, + "content": ". Many linear attention mechanisms have also been proposed (Katharopoulos et al., 2020;", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 405, + 505, + 420 + ], + "spans": [ + { + "bbox": [ + 105, + 405, + 505, + 420 + ], + "score": 1.0, + "content": "Choromanski et al., 2020), although we are not aware of competitive results on large scale language", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 418, + 505, + 430 + ], + "spans": [ + { + "bbox": [ + 106, + 418, + 298, + 430 + ], + "score": 1.0, + "content": "modeling tasks. As a function of sequence length", + "type": "text" + }, + { + "bbox": [ + 298, + 418, + 307, + 428 + ], + "score": 0.82, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 307, + 418, + 364, + 430 + ], + "score": 1.0, + "content": "and patch size", + "type": "text" + }, + { + "bbox": [ + 364, + 418, + 373, + 428 + ], + "score": 0.82, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 373, + 418, + 505, + 430 + ], + "score": 1.0, + "content": ", the Global model has a sequence", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 104, + 428, + 506, + 446 + ], + "spans": [ + { + "bbox": [ + 104, + 428, + 145, + 446 + ], + "score": 1.0, + "content": "of length", + "type": "text" + }, + { + "bbox": [ + 146, + 429, + 155, + 444 + ], + "score": 0.88, + "content": "\\textstyle { \\frac { P } { T } }", + "type": "inline_equation" + }, + { + "bbox": [ + 155, + 428, + 187, + 446 + ], + "score": 1.0, + "content": "so uses", + "type": "text" + }, + { + "bbox": [ + 187, + 428, + 217, + 444 + ], + "score": 0.93, + "content": "\\scriptstyle O ( { \\frac { T ^ { 2 } } { P ^ { 2 } } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 217, + 428, + 370, + 446 + ], + "score": 1.0, + "content": "operations, and the Local model uses", + "type": "text" + }, + { + "bbox": [ + 371, + 430, + 380, + 444 + ], + "score": 0.89, + "content": "\\textstyle { \\frac { P } { T } }", + "type": "inline_equation" + }, + { + "bbox": [ + 380, + 428, + 463, + 446 + ], + "score": 1.0, + "content": "sequences of length", + "type": "text" + }, + { + "bbox": [ + 464, + 431, + 473, + 441 + ], + "score": 0.82, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 473, + 428, + 506, + 446 + ], + "score": 1.0, + "content": "so uses", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 107, + 442, + 507, + 460 + ], + "spans": [ + { + "bbox": [ + 107, + 443, + 186, + 459 + ], + "score": 0.93, + "content": "\\begin{array} { r } { O ( \\frac { T P ^ { 2 } } { P } ) = O ( P T ) } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 186, + 442, + 418, + 460 + ], + "score": 1.0, + "content": "operations. The overall cost of MEGABYTE is therefore in", + "type": "text" + }, + { + "bbox": [ + 419, + 443, + 474, + 459 + ], + "score": 0.92, + "content": "\\begin{array} { r } { O ( \\frac { T ^ { 2 } } { P ^ { 2 } } + T P ) } \\end{array}", + "type": "inline_equation" + }, + { + "bbox": [ + 474, + 442, + 479, + 460 + ], + "score": 1.0, + "content": ".", + "type": "text" + }, + { + "bbox": [ + 479, + 445, + 488, + 456 + ], + "score": 0.77, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 488, + 442, + 507, + 460 + ], + "score": 1.0, + "content": "is a", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 104, + 457, + 503, + 473 + ], + "spans": [ + { + "bbox": [ + 104, + 458, + 412, + 473 + ], + "score": 1.0, + "content": "hyperparameter that is chosen to create an architecture for sequences of size", + "type": "text" + }, + { + "bbox": [ + 412, + 460, + 420, + 469 + ], + "score": 0.72, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 421, + 458, + 468, + 473 + ], + "score": 1.0, + "content": ". By setting", + "type": "text" + }, + { + "bbox": [ + 468, + 457, + 503, + 470 + ], + "score": 0.92, + "content": "P = T ^ { \\frac { 1 } { 3 } }", + "type": "inline_equation" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 470, + 506, + 485 + ], + "spans": [ + { + "bbox": [ + 105, + 470, + 190, + 485 + ], + "score": 1.0, + "content": "the complexity is in", + "type": "text" + }, + { + "bbox": [ + 190, + 470, + 220, + 484 + ], + "score": 0.93, + "content": "O ( T ^ { \\frac { 4 } { 3 } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 220, + 470, + 353, + 485 + ], + "score": 1.0, + "content": ". Using much shorter patches of", + "type": "text" + }, + { + "bbox": [ + 353, + 470, + 389, + 482 + ], + "score": 0.92, + "content": "P = T ^ { \\frac { 1 } { 5 } }", + "type": "inline_equation" + }, + { + "bbox": [ + 389, + 470, + 506, + 485 + ], + "score": 1.0, + "content": "would give a complexity of", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 107, + 482, + 497, + 498 + ], + "spans": [ + { + "bbox": [ + 107, + 483, + 136, + 497 + ], + "score": 0.92, + "content": "O ( T ^ { \\frac { 8 } { 5 } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 137, + 482, + 397, + 498 + ], + "score": 1.0, + "content": ". The cost is less than the transformer for all non-trivial values of", + "type": "text" + }, + { + "bbox": [ + 397, + 485, + 406, + 495 + ], + "score": 0.82, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 406, + 482, + 445, + 498 + ], + "score": 1.0, + "content": "such that", + "type": "text" + }, + { + "bbox": [ + 446, + 485, + 493, + 495 + ], + "score": 0.9, + "content": "1 < P < T", + "type": "inline_equation" + }, + { + "bbox": [ + 493, + 482, + 497, + 498 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 28, + "bbox_fs": [ + 104, + 360, + 507, + 498 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 503, + 505, + 630 + ], + "lines": [ + { + "bbox": [ + 106, + 502, + 506, + 515 + ], + "spans": [ + { + "bbox": [ + 106, + 502, + 506, + 515 + ], + "score": 1.0, + "content": "Feedforward Layers However, attention is not the main cost in large transformers. Instead of", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 514, + 504, + 526 + ], + "spans": [ + { + "bbox": [ + 106, + 514, + 504, + 526 + ], + "score": 1.0, + "content": "increasing the sequence length, transformers are more commonly scaled by increasing the dimension", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 525, + 505, + 537 + ], + "spans": [ + { + "bbox": [ + 106, + 525, + 183, + 537 + ], + "score": 1.0, + "content": "of their latent state", + "type": "text" + }, + { + "bbox": [ + 183, + 525, + 190, + 535 + ], + "score": 0.76, + "content": "d", + "type": "inline_equation" + }, + { + "bbox": [ + 190, + 525, + 505, + 537 + ], + "score": 1.0, + "content": ", and the feedforward network cost dominates the model’s overall cost (Kaplan", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 536, + 505, + 549 + ], + "spans": [ + { + "bbox": [ + 105, + 536, + 505, + 549 + ], + "score": 1.0, + "content": "et al., 2020). For example, in the GPT3 architecture, the quadratic self-attention computation accounts", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 546, + 505, + 560 + ], + "spans": [ + { + "bbox": [ + 105, + 546, + 141, + 560 + ], + "score": 1.0, + "content": "for only", + "type": "text" + }, + { + "bbox": [ + 141, + 547, + 163, + 558 + ], + "score": 0.87, + "content": "1 . 4 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 163, + 546, + 505, + 560 + ], + "score": 1.0, + "content": "of FLOPS. Following the approximation of (Kaplan et al., 2020), a forward pass with", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 558, + 505, + 571 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 210, + 571 + ], + "score": 1.0, + "content": "a large transformer with", + "type": "text" + }, + { + "bbox": [ + 210, + 560, + 220, + 568 + ], + "score": 0.72, + "content": "m", + "type": "inline_equation" + }, + { + "bbox": [ + 221, + 558, + 439, + 571 + ], + "score": 1.0, + "content": "non-embedding parameters on a sequence of length", + "type": "text" + }, + { + "bbox": [ + 440, + 558, + 448, + 568 + ], + "score": 0.79, + "content": "T", + "type": "inline_equation" + }, + { + "bbox": [ + 449, + 558, + 505, + 571 + ], + "score": 1.0, + "content": "uses roughly", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 567, + 506, + 582 + ], + "spans": [ + { + "bbox": [ + 106, + 569, + 129, + 579 + ], + "score": 0.71, + "content": "2 m T", + "type": "inline_equation" + }, + { + "bbox": [ + 129, + 567, + 423, + 582 + ], + "score": 1.0, + "content": "FLOPS. MEGABYTE contains two transformers: the Global model uses", + "type": "text" + }, + { + "bbox": [ + 423, + 570, + 437, + 581 + ], + "score": 0.87, + "content": "m _ { g }", + "type": "inline_equation" + }, + { + "bbox": [ + 438, + 567, + 506, + 582 + ], + "score": 1.0, + "content": "parameters on a", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 102, + 575, + 502, + 600 + ], + "spans": [ + { + "bbox": [ + 102, + 575, + 186, + 600 + ], + "score": 1.0, + "content": "sequence of length", + "type": "text" + }, + { + "bbox": [ + 186, + 580, + 195, + 594 + ], + "score": 0.86, + "content": "\\textstyle { \\frac { T } { P } }", + "type": "inline_equation" + }, + { + "bbox": [ + 196, + 575, + 299, + 600 + ], + "score": 1.0, + "content": ", and a Local model with", + "type": "text" + }, + { + "bbox": [ + 299, + 582, + 312, + 592 + ], + "score": 0.82, + "content": "m _ { l }", + "type": "inline_equation" + }, + { + "bbox": [ + 313, + 575, + 399, + 600 + ], + "score": 1.0, + "content": "parameters that sees", + "type": "text" + }, + { + "bbox": [ + 399, + 580, + 409, + 594 + ], + "score": 0.89, + "content": "\\textstyle { \\frac { T } { P } }", + "type": "inline_equation" + }, + { + "bbox": [ + 409, + 575, + 493, + 600 + ], + "score": 1.0, + "content": "sequences of length", + "type": "text" + }, + { + "bbox": [ + 493, + 581, + 502, + 591 + ], + "score": 0.79, + "content": "P", + "type": "inline_equation" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 591, + 507, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 591, + 193, + 609 + ], + "score": 1.0, + "content": "giving an estimate of", + "type": "text" + }, + { + "bbox": [ + 194, + 593, + 252, + 606 + ], + "score": 0.92, + "content": "2 T ( \\frac { m _ { g } } { P } + m _ { l } )", + "type": "inline_equation" + }, + { + "bbox": [ + 252, + 591, + 315, + 609 + ], + "score": 1.0, + "content": "FLOPS. When", + "type": "text" + }, + { + "bbox": [ + 315, + 594, + 357, + 606 + ], + "score": 0.91, + "content": "m _ { g } \\gg m _ { l }", + "type": "inline_equation" + }, + { + "bbox": [ + 357, + 591, + 507, + 609 + ], + "score": 1.0, + "content": ", the FLOPS used by MEGABYTE is", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 601, + 509, + 626 + ], + "spans": [ + { + "bbox": [ + 105, + 601, + 168, + 626 + ], + "score": 1.0, + "content": "approximately", + "type": "text" + }, + { + "bbox": [ + 168, + 605, + 192, + 621 + ], + "score": 0.92, + "content": "\\frac { 2 T m _ { g } } { P }", + "type": "inline_equation" + }, + { + "bbox": [ + 192, + 601, + 268, + 626 + ], + "score": 1.0, + "content": ", allowing a model", + "type": "text" + }, + { + "bbox": [ + 269, + 608, + 278, + 618 + ], + "score": 0.81, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 278, + 601, + 509, + 626 + ], + "score": 1.0, + "content": "times larger than a transformer with equivalent FLOPS.", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 618, + 482, + 632 + ], + "spans": [ + { + "bbox": [ + 106, + 618, + 482, + 632 + ], + "score": 1.0, + "content": "This analysis holds irrespective of any efficient attention mechanisms used in the transformer.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 39, + "bbox_fs": [ + 102, + 502, + 509, + 632 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 636, + 505, + 692 + ], + "lines": [ + { + "bbox": [ + 106, + 636, + 506, + 649 + ], + "spans": [ + { + "bbox": [ + 106, + 636, + 506, + 649 + ], + "score": 1.0, + "content": "Combined Analysis To understand efficiency at different sequence lengths and model sizes,", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 106, + 648, + 505, + 659 + ], + "spans": [ + { + "bbox": [ + 106, + 648, + 505, + 659 + ], + "score": 1.0, + "content": "we calculate the total FLOPS used by transformers, Linear Transformers and MEGABYTE. For", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 106, + 659, + 506, + 671 + ], + "spans": [ + { + "bbox": [ + 106, + 659, + 506, + 671 + ], + "score": 1.0, + "content": "each operation, we use FLOP estimates from (Kaplan et al., 2020), except for attention in Linear", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 668, + 506, + 683 + ], + "spans": [ + { + "bbox": [ + 105, + 668, + 249, + 683 + ], + "score": 1.0, + "content": "Transformers, which we estimate as", + "type": "text" + }, + { + "bbox": [ + 249, + 670, + 264, + 680 + ], + "score": 0.71, + "content": "9 D", + "type": "inline_equation" + }, + { + "bbox": [ + 264, + 668, + 354, + 683 + ], + "score": 1.0, + "content": "FLOPS/token1, where", + "type": "text" + }, + { + "bbox": [ + 354, + 670, + 364, + 680 + ], + "score": 0.81, + "content": "D", + "type": "inline_equation" + }, + { + "bbox": [ + 364, + 668, + 506, + 683 + ], + "score": 1.0, + "content": "is the model embedding dimension.", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 680, + 506, + 694 + ], + "spans": [ + { + "bbox": [ + 105, + 680, + 506, + 694 + ], + "score": 1.0, + "content": "Figure 3 shows that for models of size 660M to 173B and sequence lengths of up to 1M tokens,", + "type": "text" + } + ], + "index": 49 + } + ], + "index": 47, + "bbox_fs": [ + 105, + 636, + 506, + 694 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 72, + 506, + 106 + ], + "lines": [ + { + "bbox": [ + 105, + 72, + 505, + 84 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 179, + 84 + ], + "score": 1.0, + "content": "MEGABYTE with", + "type": "text" + }, + { + "bbox": [ + 179, + 73, + 207, + 83 + ], + "score": 0.9, + "content": "P = 8", + "type": "inline_equation" + }, + { + "bbox": [ + 207, + 72, + 505, + 84 + ], + "score": 1.0, + "content": "uses less FLOPS than either transformers or Linear Transformers. Baseline", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 83, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 83, + 506, + 96 + ], + "score": 1.0, + "content": "model architectures are based on GPT3, and Megabyte global/local model sizes are 452M/151M,", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 93, + 256, + 108 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 256, + 108 + ], + "score": 1.0, + "content": "5.8B/604M, 170B/3.2B respectively.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "title", + "bbox": [ + 108, + 118, + 222, + 129 + ], + "lines": [ + { + "bbox": [ + 104, + 115, + 225, + 133 + ], + "spans": [ + { + "bbox": [ + 104, + 115, + 225, + 133 + ], + "score": 1.0, + "content": "3.2 Generation Efficiency", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 107, + 133, + 297, + 352 + ], + "lines": [ + { + "bbox": [ + 106, + 134, + 297, + 146 + ], + "spans": [ + { + "bbox": [ + 106, + 134, + 297, + 146 + ], + "score": 1.0, + "content": "Generating long sequences with transformers is", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 144, + 297, + 157 + ], + "spans": [ + { + "bbox": [ + 105, + 144, + 297, + 157 + ], + "score": 1.0, + "content": "slow, because the input to each timestep is the", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 155, + 297, + 168 + ], + "spans": [ + { + "bbox": [ + 106, + 155, + 297, + 168 + ], + "score": 1.0, + "content": "output from the previous timestep, meaning each", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 167, + 298, + 179 + ], + "spans": [ + { + "bbox": [ + 105, + 167, + 298, + 179 + ], + "score": 1.0, + "content": "layer must be computed for each token serially.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 177, + 298, + 190 + ], + "spans": [ + { + "bbox": [ + 105, + 177, + 298, + 190 + ], + "score": 1.0, + "content": "As running a layer on a single token typically", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 188, + 298, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 298, + 200 + ], + "score": 1.0, + "content": "does not saturate the amount of parallelism avail-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 199, + 297, + 211 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 297, + 211 + ], + "score": 1.0, + "content": "able within a GPU, for analysis, we model each", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 211, + 299, + 222 + ], + "spans": [ + { + "bbox": [ + 106, + 211, + 299, + 222 + ], + "score": 1.0, + "content": "layer as a constant cost independently of size.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 220, + 299, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 220, + 253, + 234 + ], + "score": 1.0, + "content": "Consider a MEGABYTE model with", + "type": "text" + }, + { + "bbox": [ + 254, + 222, + 280, + 233 + ], + "score": 0.91, + "content": "L _ { \\mathrm { g l o b a l } }", + "type": "inline_equation" + }, + { + "bbox": [ + 280, + 220, + 299, + 234 + ], + "score": 1.0, + "content": "lay-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 232, + 298, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 232, + 221, + 244 + ], + "score": 1.0, + "content": "ers in the Global model and", + "type": "text" + }, + { + "bbox": [ + 222, + 232, + 244, + 243 + ], + "score": 0.91, + "content": "L _ { \\mathrm { l o c a l } }", + "type": "inline_equation" + }, + { + "bbox": [ + 244, + 232, + 298, + 244 + ], + "score": 1.0, + "content": "layers in the", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 242, + 297, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 242, + 221, + 255 + ], + "score": 1.0, + "content": "Local model and patch size", + "type": "text" + }, + { + "bbox": [ + 221, + 244, + 230, + 253 + ], + "score": 0.78, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 230, + 242, + 297, + 255 + ], + "score": 1.0, + "content": ", compared with", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 253, + 296, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 237, + 267 + ], + "score": 1.0, + "content": "a Transformer architecture with", + "type": "text" + }, + { + "bbox": [ + 237, + 254, + 296, + 266 + ], + "score": 0.92, + "content": "L _ { \\mathrm { l o c a l } } + L _ { \\mathrm { g l o b a l } }", + "type": "inline_equation" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 264, + 297, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 264, + 297, + 277 + ], + "score": 1.0, + "content": "layers. Generating each patch with MEGABYTE", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 276, + 297, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 276, + 204, + 289 + ], + "score": 1.0, + "content": "requires a sequence of", + "type": "text" + }, + { + "bbox": [ + 204, + 276, + 297, + 288 + ], + "score": 0.89, + "content": "O ( L _ { \\mathrm { g l o b a l } } + P \\cdot L _ { \\mathrm { l o c a l } } )", + "type": "inline_equation" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 286, + 299, + 299 + ], + "spans": [ + { + "bbox": [ + 106, + 286, + 299, + 299 + ], + "score": 1.0, + "content": "serial operations, whereas the Transformer re-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 297, + 299, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 297, + 133, + 310 + ], + "score": 1.0, + "content": "quires", + "type": "text" + }, + { + "bbox": [ + 133, + 297, + 228, + 309 + ], + "score": 0.9, + "content": "\\bar { O } ( P \\cdot L _ { \\mathrm { g l o b a l } } + P \\cdot L _ { \\mathrm { l o c a l } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 229, + 297, + 299, + 310 + ], + "score": 1.0, + "content": "serial operations.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 308, + 298, + 321 + ], + "spans": [ + { + "bbox": [ + 105, + 308, + 133, + 321 + ], + "score": 1.0, + "content": "When", + "type": "text" + }, + { + "bbox": [ + 134, + 309, + 199, + 321 + ], + "score": 0.88, + "content": "L _ { \\mathrm { g l o b a l } } \\gg L _ { \\mathrm { l o c a l } }", + "type": "inline_equation" + }, + { + "bbox": [ + 199, + 308, + 298, + 321 + ], + "score": 1.0, + "content": "(i.e. the Global model", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 319, + 298, + 332 + ], + "spans": [ + { + "bbox": [ + 105, + 319, + 298, + 332 + ], + "score": 1.0, + "content": "has many more layers than the Local model),", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 329, + 298, + 342 + ], + "spans": [ + { + "bbox": [ + 105, + 329, + 298, + 342 + ], + "score": 1.0, + "content": "MEGABYTE can reduce inference costs by a", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 342, + 178, + 352 + ], + "spans": [ + { + "bbox": [ + 106, + 342, + 165, + 352 + ], + "score": 1.0, + "content": "factor close to", + "type": "text" + }, + { + "bbox": [ + 165, + 342, + 174, + 351 + ], + "score": 0.82, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 175, + 342, + 178, + 352 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 13.5 + }, + { + "type": "image", + "bbox": [ + 308, + 124, + 498, + 284 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 308, + 124, + 498, + 284 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 308, + 124, + 498, + 284 + ], + "spans": [ + { + "bbox": [ + 308, + 124, + 498, + 284 + ], + "score": 0.968, + "type": "image", + "image_path": "e8f0a6e0f7c644ca9ccbba9ab18c4479b142ce34ba180bc4fb7aac86bb662f60.jpg" + } + ] + } + ], + "index": 29.5, + "virtual_lines": [ + { + "bbox": [ + 308, + 124, + 498, + 137.33333333333334 + ], + "spans": [], + "index": 24 + }, + { + "bbox": [ + 308, + 137.33333333333334, + 498, + 150.66666666666669 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 308, + 150.66666666666669, + 498, + 164.00000000000003 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 308, + 164.00000000000003, + 498, + 177.33333333333337 + ], + "spans": [], + "index": 27 + }, + { + "bbox": [ + 308, + 177.33333333333337, + 498, + 190.6666666666667 + ], + "spans": [], + "index": 28 + }, + { + "bbox": [ + 308, + 190.6666666666667, + 498, + 204.00000000000006 + ], + "spans": [], + "index": 29 + }, + { + "bbox": [ + 308, + 204.00000000000006, + 498, + 217.3333333333334 + ], + "spans": [], + "index": 30 + }, + { + "bbox": [ + 308, + 217.3333333333334, + 498, + 230.66666666666674 + ], + "spans": [], + "index": 31 + }, + { + "bbox": [ + 308, + 230.66666666666674, + 498, + 244.00000000000009 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 308, + 244.00000000000009, + 498, + 257.3333333333334 + ], + "spans": [], + "index": 33 + }, + { + "bbox": [ + 308, + 257.3333333333334, + 498, + 270.66666666666674 + ], + "spans": [], + "index": 34 + }, + { + "bbox": [ + 308, + 270.66666666666674, + 498, + 284.00000000000006 + ], + "spans": [], + "index": 35 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 304, + 291, + 505, + 361 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 303, + 291, + 506, + 303 + ], + "spans": [ + { + "bbox": [ + 303, + 291, + 506, + 303 + ], + "score": 1.0, + "content": "Figure 3: Computational cost (FLOPS/token) for differ-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 304, + 302, + 505, + 312 + ], + "spans": [ + { + "bbox": [ + 304, + 302, + 505, + 312 + ], + "score": 1.0, + "content": "ent model architectures at different scales. MEGABYTE", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 304, + 312, + 505, + 322 + ], + "spans": [ + { + "bbox": [ + 304, + 312, + 394, + 322 + ], + "score": 1.0, + "content": "architectures (here with", + "type": "text" + }, + { + "bbox": [ + 394, + 312, + 421, + 321 + ], + "score": 0.89, + "content": "P = 8", + "type": "inline_equation" + }, + { + "bbox": [ + 422, + 312, + 505, + 322 + ], + "score": 1.0, + "content": ") use less FLOPS than", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 304, + 322, + 506, + 331 + ], + "spans": [ + { + "bbox": [ + 304, + 322, + 506, + 331 + ], + "score": 1.0, + "content": "equivalently sized Transformers and Linear Transform-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 304, + 331, + 505, + 343 + ], + "spans": [ + { + "bbox": [ + 304, + 331, + 505, + 343 + ], + "score": 1.0, + "content": "ers (Katharopoulos et al., 2020) across a wide range of", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 304, + 342, + 506, + 353 + ], + "spans": [ + { + "bbox": [ + 304, + 342, + 506, + 353 + ], + "score": 1.0, + "content": "model sizes and sequence lengths, allowing larger mod-", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 304, + 351, + 474, + 362 + ], + "spans": [ + { + "bbox": [ + 304, + 351, + 474, + 362 + ], + "score": 1.0, + "content": "els to be used for the same computational cost.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 39 + } + ], + "index": 34.25 + }, + { + "type": "title", + "bbox": [ + 108, + 366, + 226, + 380 + ], + "lines": [ + { + "bbox": [ + 104, + 364, + 228, + 385 + ], + "spans": [ + { + "bbox": [ + 104, + 364, + 228, + 385 + ], + "score": 1.0, + "content": "4 Experimental setup", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 43 + }, + { + "type": "text", + "bbox": [ + 107, + 388, + 505, + 476 + ], + "lines": [ + { + "bbox": [ + 106, + 387, + 506, + 402 + ], + "spans": [ + { + "bbox": [ + 106, + 387, + 506, + 402 + ], + "score": 1.0, + "content": "Controlling for Compute and Data Models show consistent improvements when increasing", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 400, + 505, + 412 + ], + "spans": [ + { + "bbox": [ + 106, + 400, + 505, + 412 + ], + "score": 1.0, + "content": "both data and compute Kaplan et al. (2020); Hoffmann et al. (2022), meaning that one model can", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 410, + 506, + 423 + ], + "spans": [ + { + "bbox": [ + 105, + 410, + 506, + 423 + ], + "score": 1.0, + "content": "outperform another because of an increased training budget instead of an improved architecture.", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 421, + 505, + 434 + ], + "spans": [ + { + "bbox": [ + 105, + 421, + 505, + 434 + ], + "score": 1.0, + "content": "However, in practice, both compute and data are typically limited. We conduct experiments using a", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 432, + 505, + 445 + ], + "spans": [ + { + "bbox": [ + 105, + 432, + 505, + 445 + ], + "score": 1.0, + "content": "fixed compute and data budget across all models to focus comparisons solely on the model architecture", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 106, + 443, + 506, + 455 + ], + "spans": [ + { + "bbox": [ + 106, + 443, + 506, + 455 + ], + "score": 1.0, + "content": "rather than training resources. To achieve this, we adjust model hyperparameters (mainly, number of", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 106, + 454, + 505, + 466 + ], + "spans": [ + { + "bbox": [ + 106, + 454, + 505, + 466 + ], + "score": 1.0, + "content": "layers) within each architecture so that the forward pass time taken per byte is matched, and then", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 465, + 293, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 465, + 293, + 477 + ], + "score": 1.0, + "content": "train all models for the same number of bytes.", + "type": "text" + } + ], + "index": 51 + } + ], + "index": 47.5 + }, + { + "type": "text", + "bbox": [ + 107, + 487, + 505, + 552 + ], + "lines": [ + { + "bbox": [ + 106, + 487, + 506, + 499 + ], + "spans": [ + { + "bbox": [ + 106, + 487, + 506, + 499 + ], + "score": 1.0, + "content": "Comparison Systems We compare MEGABYTE with both a standard decoder-only Transformer", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 105, + 497, + 506, + 510 + ], + "spans": [ + { + "bbox": [ + 105, + 497, + 506, + 510 + ], + "score": 1.0, + "content": "and PerceiverAR (Hawthorne et al., 2022). PerceiverAR extends the original transformer with a", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 106, + 509, + 505, + 521 + ], + "spans": [ + { + "bbox": [ + 106, + 509, + 505, + 521 + ], + "score": 1.0, + "content": "single cross-attention layer over a much longer context sequence, and is the best performing general", + "type": "text" + } + ], + "index": 54 + }, + { + "bbox": [ + 105, + 520, + 506, + 532 + ], + "spans": [ + { + "bbox": [ + 105, + 520, + 506, + 532 + ], + "score": 1.0, + "content": "purpose autoregressive model we are aware of and achieves state-of-the-art results across several", + "type": "text" + } + ], + "index": 55 + }, + { + "bbox": [ + 105, + 531, + 505, + 542 + ], + "spans": [ + { + "bbox": [ + 105, + 531, + 505, + 542 + ], + "score": 1.0, + "content": "modalities. We implemented both models in the same codebase, and all models share a similar data", + "type": "text" + } + ], + "index": 56 + }, + { + "bbox": [ + 105, + 541, + 506, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 506, + 554 + ], + "score": 1.0, + "content": "loader, preprocessing step, and trainer to avoid any artifacts in our compute-controlled experiments.", + "type": "text" + } + ], + "index": 57 + } + ], + "index": 54.5 + }, + { + "type": "text", + "bbox": [ + 107, + 563, + 505, + 651 + ], + "lines": [ + { + "bbox": [ + 106, + 564, + 506, + 576 + ], + "spans": [ + { + "bbox": [ + 106, + 564, + 506, + 576 + ], + "score": 1.0, + "content": "Training Procedure All models were trained using the Metaseq2 code base Zhang et al. (2022b).", + "type": "text" + } + ], + "index": 58 + }, + { + "bbox": [ + 105, + 573, + 506, + 588 + ], + "spans": [ + { + "bbox": [ + 105, + 573, + 506, + 588 + ], + "score": 1.0, + "content": "The training used the PyTorch framework Paszke et al. (2019), with fairscale to improve memory", + "type": "text" + } + ], + "index": 59 + }, + { + "bbox": [ + 105, + 585, + 506, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 585, + 506, + 599 + ], + "score": 1.0, + "content": "efficiency through fully sharded model and optimizer states Baines et al. (2021). Mixed precision", + "type": "text" + } + ], + "index": 60 + }, + { + "bbox": [ + 105, + 595, + 506, + 610 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 506, + 610 + ], + "score": 1.0, + "content": "training was used to improve training efficiency at scale Micikevicius et al. (2017). More training", + "type": "text" + } + ], + "index": 61 + }, + { + "bbox": [ + 105, + 606, + 505, + 619 + ], + "spans": [ + { + "bbox": [ + 105, + 606, + 505, + 619 + ], + "score": 1.0, + "content": "details and various model parameters can be found in Section A.1 in the Appendix. To validate", + "type": "text" + } + ], + "index": 62 + }, + { + "bbox": [ + 105, + 618, + 506, + 631 + ], + "spans": [ + { + "bbox": [ + 105, + 618, + 506, + 631 + ], + "score": 1.0, + "content": "our implementation of PerceiverAR, we reproduced their experiments on downsized ImageNet at", + "type": "text" + } + ], + "index": 63 + }, + { + "bbox": [ + 105, + 629, + 506, + 641 + ], + "spans": [ + { + "bbox": [ + 105, + 629, + 506, + 641 + ], + "score": 1.0, + "content": "64 pixels. By carefully matching hyperparameters, we achieved a bits per byte (bpb) score of 3.53,", + "type": "text" + } + ], + "index": 64 + }, + { + "bbox": [ + 106, + 641, + 313, + 653 + ], + "spans": [ + { + "bbox": [ + 106, + 641, + 313, + 653 + ], + "score": 1.0, + "content": "compared to the reported 3.54 in the original paper.", + "type": "text" + } + ], + "index": 65 + } + ], + "index": 61.5 + }, + { + "type": "text", + "bbox": [ + 108, + 668, + 504, + 701 + ], + "lines": [ + { + "bbox": [ + 106, + 667, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 106, + 667, + 505, + 680 + ], + "score": 1.0, + "content": "Inference Methods Several techniques have been proposed for trading off speed for performance", + "type": "text" + } + ], + "index": 66 + }, + { + "bbox": [ + 106, + 678, + 506, + 691 + ], + "spans": [ + { + "bbox": [ + 106, + 678, + 506, + 691 + ], + "score": 1.0, + "content": "during inference with language models, including sliding windows Press et al. (2020) and our strided", + "type": "text" + } + ], + "index": 67 + }, + { + "bbox": [ + 105, + 689, + 505, + 703 + ], + "spans": [ + { + "bbox": [ + 105, + 689, + 505, + 703 + ], + "score": 1.0, + "content": "inference. We only use these methods when comparing with prior published work (Tables 2 and 3).", + "type": "text" + } + ], + "index": 68 + } + ], + "index": 67 + } + ], + "page_idx": 4, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 119, + 712, + 286, + 722 + ], + "lines": [ + { + "bbox": [ + 118, + 709, + 288, + 725 + ], + "spans": [ + { + "bbox": [ + 118, + 709, + 288, + 725 + ], + "score": 1.0, + "content": "2https://github.com/facebookresearch/metaseq", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 742, + 308, + 750 + ], + "lines": [ + { + "bbox": [ + 302, + 741, + 309, + 752 + ], + "spans": [ + { + "bbox": [ + 302, + 741, + 309, + 752 + ], + "score": 1.0, + "content": "5", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 72, + 506, + 106 + ], + "lines": [ + { + "bbox": [ + 105, + 72, + 505, + 84 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 179, + 84 + ], + "score": 1.0, + "content": "MEGABYTE with", + "type": "text" + }, + { + "bbox": [ + 179, + 73, + 207, + 83 + ], + "score": 0.9, + "content": "P = 8", + "type": "inline_equation" + }, + { + "bbox": [ + 207, + 72, + 505, + 84 + ], + "score": 1.0, + "content": "uses less FLOPS than either transformers or Linear Transformers. Baseline", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 83, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 83, + 506, + 96 + ], + "score": 1.0, + "content": "model architectures are based on GPT3, and Megabyte global/local model sizes are 452M/151M,", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 93, + 256, + 108 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 256, + 108 + ], + "score": 1.0, + "content": "5.8B/604M, 170B/3.2B respectively.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1, + "bbox_fs": [ + 105, + 72, + 506, + 108 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 118, + 222, + 129 + ], + "lines": [ + { + "bbox": [ + 104, + 115, + 225, + 133 + ], + "spans": [ + { + "bbox": [ + 104, + 115, + 225, + 133 + ], + "score": 1.0, + "content": "3.2 Generation Efficiency", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + }, + { + "type": "text", + "bbox": [ + 107, + 133, + 297, + 352 + ], + "lines": [ + { + "bbox": [ + 106, + 134, + 297, + 146 + ], + "spans": [ + { + "bbox": [ + 106, + 134, + 297, + 146 + ], + "score": 1.0, + "content": "Generating long sequences with transformers is", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 144, + 297, + 157 + ], + "spans": [ + { + "bbox": [ + 105, + 144, + 297, + 157 + ], + "score": 1.0, + "content": "slow, because the input to each timestep is the", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 155, + 297, + 168 + ], + "spans": [ + { + "bbox": [ + 106, + 155, + 297, + 168 + ], + "score": 1.0, + "content": "output from the previous timestep, meaning each", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 167, + 298, + 179 + ], + "spans": [ + { + "bbox": [ + 105, + 167, + 298, + 179 + ], + "score": 1.0, + "content": "layer must be computed for each token serially.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 177, + 298, + 190 + ], + "spans": [ + { + "bbox": [ + 105, + 177, + 298, + 190 + ], + "score": 1.0, + "content": "As running a layer on a single token typically", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 188, + 298, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 298, + 200 + ], + "score": 1.0, + "content": "does not saturate the amount of parallelism avail-", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 199, + 297, + 211 + ], + "spans": [ + { + "bbox": [ + 105, + 199, + 297, + 211 + ], + "score": 1.0, + "content": "able within a GPU, for analysis, we model each", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 211, + 299, + 222 + ], + "spans": [ + { + "bbox": [ + 106, + 211, + 299, + 222 + ], + "score": 1.0, + "content": "layer as a constant cost independently of size.", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 220, + 299, + 234 + ], + "spans": [ + { + "bbox": [ + 105, + 220, + 253, + 234 + ], + "score": 1.0, + "content": "Consider a MEGABYTE model with", + "type": "text" + }, + { + "bbox": [ + 254, + 222, + 280, + 233 + ], + "score": 0.91, + "content": "L _ { \\mathrm { g l o b a l } }", + "type": "inline_equation" + }, + { + "bbox": [ + 280, + 220, + 299, + 234 + ], + "score": 1.0, + "content": "lay-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 232, + 298, + 244 + ], + "spans": [ + { + "bbox": [ + 105, + 232, + 221, + 244 + ], + "score": 1.0, + "content": "ers in the Global model and", + "type": "text" + }, + { + "bbox": [ + 222, + 232, + 244, + 243 + ], + "score": 0.91, + "content": "L _ { \\mathrm { l o c a l } }", + "type": "inline_equation" + }, + { + "bbox": [ + 244, + 232, + 298, + 244 + ], + "score": 1.0, + "content": "layers in the", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 242, + 297, + 255 + ], + "spans": [ + { + "bbox": [ + 105, + 242, + 221, + 255 + ], + "score": 1.0, + "content": "Local model and patch size", + "type": "text" + }, + { + "bbox": [ + 221, + 244, + 230, + 253 + ], + "score": 0.78, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 230, + 242, + 297, + 255 + ], + "score": 1.0, + "content": ", compared with", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 253, + 296, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 237, + 267 + ], + "score": 1.0, + "content": "a Transformer architecture with", + "type": "text" + }, + { + "bbox": [ + 237, + 254, + 296, + 266 + ], + "score": 0.92, + "content": "L _ { \\mathrm { l o c a l } } + L _ { \\mathrm { g l o b a l } }", + "type": "inline_equation" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 264, + 297, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 264, + 297, + 277 + ], + "score": 1.0, + "content": "layers. Generating each patch with MEGABYTE", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 276, + 297, + 289 + ], + "spans": [ + { + "bbox": [ + 105, + 276, + 204, + 289 + ], + "score": 1.0, + "content": "requires a sequence of", + "type": "text" + }, + { + "bbox": [ + 204, + 276, + 297, + 288 + ], + "score": 0.89, + "content": "O ( L _ { \\mathrm { g l o b a l } } + P \\cdot L _ { \\mathrm { l o c a l } } )", + "type": "inline_equation" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 286, + 299, + 299 + ], + "spans": [ + { + "bbox": [ + 106, + 286, + 299, + 299 + ], + "score": 1.0, + "content": "serial operations, whereas the Transformer re-", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 297, + 299, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 297, + 133, + 310 + ], + "score": 1.0, + "content": "quires", + "type": "text" + }, + { + "bbox": [ + 133, + 297, + 228, + 309 + ], + "score": 0.9, + "content": "\\bar { O } ( P \\cdot L _ { \\mathrm { g l o b a l } } + P \\cdot L _ { \\mathrm { l o c a l } } )", + "type": "inline_equation" + }, + { + "bbox": [ + 229, + 297, + 299, + 310 + ], + "score": 1.0, + "content": "serial operations.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 308, + 298, + 321 + ], + "spans": [ + { + "bbox": [ + 105, + 308, + 133, + 321 + ], + "score": 1.0, + "content": "When", + "type": "text" + }, + { + "bbox": [ + 134, + 309, + 199, + 321 + ], + "score": 0.88, + "content": "L _ { \\mathrm { g l o b a l } } \\gg L _ { \\mathrm { l o c a l } }", + "type": "inline_equation" + }, + { + "bbox": [ + 199, + 308, + 298, + 321 + ], + "score": 1.0, + "content": "(i.e. the Global model", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 319, + 298, + 332 + ], + "spans": [ + { + "bbox": [ + 105, + 319, + 298, + 332 + ], + "score": 1.0, + "content": "has many more layers than the Local model),", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 329, + 298, + 342 + ], + "spans": [ + { + "bbox": [ + 105, + 329, + 298, + 342 + ], + "score": 1.0, + "content": "MEGABYTE can reduce inference costs by a", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 342, + 178, + 352 + ], + "spans": [ + { + "bbox": [ + 106, + 342, + 165, + 352 + ], + "score": 1.0, + "content": "factor close to", + "type": "text" + }, + { + "bbox": [ + 165, + 342, + 174, + 351 + ], + "score": 0.82, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 175, + 342, + 178, + 352 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 23 + } + ], + "index": 13.5, + "bbox_fs": [ + 105, + 134, + 299, + 352 + ] + }, + { + "type": "image", + "bbox": [ + 308, + 124, + 498, + 284 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 308, + 124, + 498, + 284 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 308, + 124, + 498, + 284 + ], + "spans": [ + { + "bbox": [ + 308, + 124, + 498, + 284 + ], + "score": 0.968, + "type": "image", + "image_path": "e8f0a6e0f7c644ca9ccbba9ab18c4479b142ce34ba180bc4fb7aac86bb662f60.jpg" + } + ] + } + ], + "index": 29.5, + "virtual_lines": [ + { + "bbox": [ + 308, + 124, + 498, + 137.33333333333334 + ], + "spans": [], + "index": 24 + }, + { + "bbox": [ + 308, + 137.33333333333334, + 498, + 150.66666666666669 + ], + "spans": [], + "index": 25 + }, + { + "bbox": [ + 308, + 150.66666666666669, + 498, + 164.00000000000003 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 308, + 164.00000000000003, + 498, + 177.33333333333337 + ], + "spans": [], + "index": 27 + }, + { + "bbox": [ + 308, + 177.33333333333337, + 498, + 190.6666666666667 + ], + "spans": [], + "index": 28 + }, + { + "bbox": [ + 308, + 190.6666666666667, + 498, + 204.00000000000006 + ], + "spans": [], + "index": 29 + }, + { + "bbox": [ + 308, + 204.00000000000006, + 498, + 217.3333333333334 + ], + "spans": [], + "index": 30 + }, + { + "bbox": [ + 308, + 217.3333333333334, + 498, + 230.66666666666674 + ], + "spans": [], + "index": 31 + }, + { + "bbox": [ + 308, + 230.66666666666674, + 498, + 244.00000000000009 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 308, + 244.00000000000009, + 498, + 257.3333333333334 + ], + "spans": [], + "index": 33 + }, + { + "bbox": [ + 308, + 257.3333333333334, + 498, + 270.66666666666674 + ], + "spans": [], + "index": 34 + }, + { + "bbox": [ + 308, + 270.66666666666674, + 498, + 284.00000000000006 + ], + "spans": [], + "index": 35 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 304, + 291, + 505, + 361 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 303, + 291, + 506, + 303 + ], + "spans": [ + { + "bbox": [ + 303, + 291, + 506, + 303 + ], + "score": 1.0, + "content": "Figure 3: Computational cost (FLOPS/token) for differ-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 304, + 302, + 505, + 312 + ], + "spans": [ + { + "bbox": [ + 304, + 302, + 505, + 312 + ], + "score": 1.0, + "content": "ent model architectures at different scales. MEGABYTE", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 304, + 312, + 505, + 322 + ], + "spans": [ + { + "bbox": [ + 304, + 312, + 394, + 322 + ], + "score": 1.0, + "content": "architectures (here with", + "type": "text" + }, + { + "bbox": [ + 394, + 312, + 421, + 321 + ], + "score": 0.89, + "content": "P = 8", + "type": "inline_equation" + }, + { + "bbox": [ + 422, + 312, + 505, + 322 + ], + "score": 1.0, + "content": ") use less FLOPS than", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 304, + 322, + 506, + 331 + ], + "spans": [ + { + "bbox": [ + 304, + 322, + 506, + 331 + ], + "score": 1.0, + "content": "equivalently sized Transformers and Linear Transform-", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 304, + 331, + 505, + 343 + ], + "spans": [ + { + "bbox": [ + 304, + 331, + 505, + 343 + ], + "score": 1.0, + "content": "ers (Katharopoulos et al., 2020) across a wide range of", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 304, + 342, + 506, + 353 + ], + "spans": [ + { + "bbox": [ + 304, + 342, + 506, + 353 + ], + "score": 1.0, + "content": "model sizes and sequence lengths, allowing larger mod-", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 304, + 351, + 474, + 362 + ], + "spans": [ + { + "bbox": [ + 304, + 351, + 474, + 362 + ], + "score": 1.0, + "content": "els to be used for the same computational cost.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 39 + } + ], + "index": 34.25 + }, + { + "type": "title", + "bbox": [ + 108, + 366, + 226, + 380 + ], + "lines": [ + { + "bbox": [ + 104, + 364, + 228, + 385 + ], + "spans": [ + { + "bbox": [ + 104, + 364, + 228, + 385 + ], + "score": 1.0, + "content": "4 Experimental setup", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 43 + }, + { + "type": "text", + "bbox": [ + 107, + 388, + 505, + 476 + ], + "lines": [ + { + "bbox": [ + 106, + 387, + 506, + 402 + ], + "spans": [ + { + "bbox": [ + 106, + 387, + 506, + 402 + ], + "score": 1.0, + "content": "Controlling for Compute and Data Models show consistent improvements when increasing", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 400, + 505, + 412 + ], + "spans": [ + { + "bbox": [ + 106, + 400, + 505, + 412 + ], + "score": 1.0, + "content": "both data and compute Kaplan et al. (2020); Hoffmann et al. (2022), meaning that one model can", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 410, + 506, + 423 + ], + "spans": [ + { + "bbox": [ + 105, + 410, + 506, + 423 + ], + "score": 1.0, + "content": "outperform another because of an increased training budget instead of an improved architecture.", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 421, + 505, + 434 + ], + "spans": [ + { + "bbox": [ + 105, + 421, + 505, + 434 + ], + "score": 1.0, + "content": "However, in practice, both compute and data are typically limited. We conduct experiments using a", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 432, + 505, + 445 + ], + "spans": [ + { + "bbox": [ + 105, + 432, + 505, + 445 + ], + "score": 1.0, + "content": "fixed compute and data budget across all models to focus comparisons solely on the model architecture", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 106, + 443, + 506, + 455 + ], + "spans": [ + { + "bbox": [ + 106, + 443, + 506, + 455 + ], + "score": 1.0, + "content": "rather than training resources. To achieve this, we adjust model hyperparameters (mainly, number of", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 106, + 454, + 505, + 466 + ], + "spans": [ + { + "bbox": [ + 106, + 454, + 505, + 466 + ], + "score": 1.0, + "content": "layers) within each architecture so that the forward pass time taken per byte is matched, and then", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 465, + 293, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 465, + 293, + 477 + ], + "score": 1.0, + "content": "train all models for the same number of bytes.", + "type": "text" + } + ], + "index": 51 + } + ], + "index": 47.5, + "bbox_fs": [ + 105, + 387, + 506, + 477 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 487, + 505, + 552 + ], + "lines": [ + { + "bbox": [ + 106, + 487, + 506, + 499 + ], + "spans": [ + { + "bbox": [ + 106, + 487, + 506, + 499 + ], + "score": 1.0, + "content": "Comparison Systems We compare MEGABYTE with both a standard decoder-only Transformer", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 105, + 497, + 506, + 510 + ], + "spans": [ + { + "bbox": [ + 105, + 497, + 506, + 510 + ], + "score": 1.0, + "content": "and PerceiverAR (Hawthorne et al., 2022). PerceiverAR extends the original transformer with a", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 106, + 509, + 505, + 521 + ], + "spans": [ + { + "bbox": [ + 106, + 509, + 505, + 521 + ], + "score": 1.0, + "content": "single cross-attention layer over a much longer context sequence, and is the best performing general", + "type": "text" + } + ], + "index": 54 + }, + { + "bbox": [ + 105, + 520, + 506, + 532 + ], + "spans": [ + { + "bbox": [ + 105, + 520, + 506, + 532 + ], + "score": 1.0, + "content": "purpose autoregressive model we are aware of and achieves state-of-the-art results across several", + "type": "text" + } + ], + "index": 55 + }, + { + "bbox": [ + 105, + 531, + 505, + 542 + ], + "spans": [ + { + "bbox": [ + 105, + 531, + 505, + 542 + ], + "score": 1.0, + "content": "modalities. We implemented both models in the same codebase, and all models share a similar data", + "type": "text" + } + ], + "index": 56 + }, + { + "bbox": [ + 105, + 541, + 506, + 554 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 506, + 554 + ], + "score": 1.0, + "content": "loader, preprocessing step, and trainer to avoid any artifacts in our compute-controlled experiments.", + "type": "text" + } + ], + "index": 57 + } + ], + "index": 54.5, + "bbox_fs": [ + 105, + 487, + 506, + 554 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 563, + 505, + 651 + ], + "lines": [ + { + "bbox": [ + 106, + 564, + 506, + 576 + ], + "spans": [ + { + "bbox": [ + 106, + 564, + 506, + 576 + ], + "score": 1.0, + "content": "Training Procedure All models were trained using the Metaseq2 code base Zhang et al. (2022b).", + "type": "text" + } + ], + "index": 58 + }, + { + "bbox": [ + 105, + 573, + 506, + 588 + ], + "spans": [ + { + "bbox": [ + 105, + 573, + 506, + 588 + ], + "score": 1.0, + "content": "The training used the PyTorch framework Paszke et al. (2019), with fairscale to improve memory", + "type": "text" + } + ], + "index": 59 + }, + { + "bbox": [ + 105, + 585, + 506, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 585, + 506, + 599 + ], + "score": 1.0, + "content": "efficiency through fully sharded model and optimizer states Baines et al. (2021). Mixed precision", + "type": "text" + } + ], + "index": 60 + }, + { + "bbox": [ + 105, + 595, + 506, + 610 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 506, + 610 + ], + "score": 1.0, + "content": "training was used to improve training efficiency at scale Micikevicius et al. (2017). More training", + "type": "text" + } + ], + "index": 61 + }, + { + "bbox": [ + 105, + 606, + 505, + 619 + ], + "spans": [ + { + "bbox": [ + 105, + 606, + 505, + 619 + ], + "score": 1.0, + "content": "details and various model parameters can be found in Section A.1 in the Appendix. To validate", + "type": "text" + } + ], + "index": 62 + }, + { + "bbox": [ + 105, + 618, + 506, + 631 + ], + "spans": [ + { + "bbox": [ + 105, + 618, + 506, + 631 + ], + "score": 1.0, + "content": "our implementation of PerceiverAR, we reproduced their experiments on downsized ImageNet at", + "type": "text" + } + ], + "index": 63 + }, + { + "bbox": [ + 105, + 629, + 506, + 641 + ], + "spans": [ + { + "bbox": [ + 105, + 629, + 506, + 641 + ], + "score": 1.0, + "content": "64 pixels. By carefully matching hyperparameters, we achieved a bits per byte (bpb) score of 3.53,", + "type": "text" + } + ], + "index": 64 + }, + { + "bbox": [ + 106, + 641, + 313, + 653 + ], + "spans": [ + { + "bbox": [ + 106, + 641, + 313, + 653 + ], + "score": 1.0, + "content": "compared to the reported 3.54 in the original paper.", + "type": "text" + } + ], + "index": 65 + } + ], + "index": 61.5, + "bbox_fs": [ + 105, + 564, + 506, + 653 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 668, + 504, + 701 + ], + "lines": [ + { + "bbox": [ + 106, + 667, + 505, + 680 + ], + "spans": [ + { + "bbox": [ + 106, + 667, + 505, + 680 + ], + "score": 1.0, + "content": "Inference Methods Several techniques have been proposed for trading off speed for performance", + "type": "text" + } + ], + "index": 66 + }, + { + "bbox": [ + 106, + 678, + 506, + 691 + ], + "spans": [ + { + "bbox": [ + 106, + 678, + 506, + 691 + ], + "score": 1.0, + "content": "during inference with language models, including sliding windows Press et al. (2020) and our strided", + "type": "text" + } + ], + "index": 67 + }, + { + "bbox": [ + 105, + 689, + 505, + 703 + ], + "spans": [ + { + "bbox": [ + 105, + 689, + 505, + 703 + ], + "score": 1.0, + "content": "inference. We only use these methods when comparing with prior published work (Tables 2 and 3).", + "type": "text" + } + ], + "index": 68 + } + ], + "index": 67, + "bbox_fs": [ + 105, + 667, + 506, + 703 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 149, + 70, + 462, + 142 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 149, + 70, + 462, + 142 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 149, + 70, + 462, + 142 + ], + "spans": [ + { + "bbox": [ + 149, + 70, + 462, + 142 + ], + "score": 0.978, + "html": "
DatasetTotal Bytesbytes/docTransformerPerceiverARMEGABYTE
PG-1910.1GB411,4041.0571.1041.000
Stories21.3GB35,2651.0641.0700.978
Books79.7GB509,5261.0971.1041.007
arXiv91.5GB58,5180.8160.7910.678
Code353.7GB7,4610.5750.5460.411
", + "type": "table", + "image_path": "fafe1bab78de4470dcbe5848c63413723a5f88b952b852e1018c954a9e255858.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 149, + 70, + 462, + 94.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 149, + 94.0, + 462, + 118.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 149, + 118.0, + 462, + 142.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 106, + 142, + 505, + 162 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 141, + 506, + 153 + ], + "spans": [ + { + "bbox": [ + 105, + 141, + 506, + 153 + ], + "score": 1.0, + "content": "Table 1: Text dataset sizes and mean document lengths. We also report bpb of various models (Transformer,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 150, + 339, + 164 + ], + "spans": [ + { + "bbox": [ + 105, + 150, + 339, + 164 + ], + "score": 1.0, + "content": "PerceiverAR, and MEGABYTE) trained with the same compute.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "index": 2.25 + }, + { + "type": "table", + "bbox": [ + 106, + 180, + 508, + 271 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 106, + 180, + 508, + 271 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 180, + 508, + 271 + ], + "spans": [ + { + "bbox": [ + 106, + 180, + 508, + 271 + ], + "score": 0.981, + "html": "
TokenizerVocabContext LengthValidationTest
TransformerXL Rae et al. (2019a)SentPiece32k512+102445.536.3
CompressiveTransformer Rae et al. (2019a)SentPiece32k512+512+2x51243.433.6
PerceiverAR Hawthorne et al. (2022)SentPiece32k204845.928.9
BlockRecurrent Hutchins et al. (2022)SentPiece32k1024+recurrence-26.5
Transformer byte-level (ours)Bytes256204881.669.4
PerceiverAR byte-level (ours)Bytes2568192119.188.8
MEGABYTEBytes256819242.836.4
", + "type": "table", + "image_path": "bd9457e48b6a56ca125b125716ec6a52eb5fd7b529642573e0c24f76093f36f6.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 106, + 180, + 508, + 210.33333333333334 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 106, + 210.33333333333334, + 508, + 240.66666666666669 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 106, + 240.66666666666669, + 508, + 271.0 + ], + "spans": [], + "index": 7 + } + ] + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 106, + 276, + 506, + 306 + ], + "lines": [ + { + "bbox": [ + 105, + 275, + 505, + 288 + ], + "spans": [ + { + "bbox": [ + 105, + 275, + 505, + 288 + ], + "score": 1.0, + "content": "Table 2: Larger scale experiments on PG19, converting bits-per-byte to word-level perplexities for comparison", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 286, + 506, + 297 + ], + "spans": [ + { + "bbox": [ + 105, + 286, + 506, + 297 + ], + "score": 1.0, + "content": "with prior work. Results below the line are compute-matched. MEGABYTE outperforms other byte models by a", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 296, + 441, + 308 + ], + "spans": [ + { + "bbox": [ + 105, + 296, + 441, + 308 + ], + "score": 1.0, + "content": "wide margin, and gives results competitive with state-of-the-art models trained on subwords.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9 + }, + { + "type": "title", + "bbox": [ + 107, + 312, + 229, + 326 + ], + "lines": [ + { + "bbox": [ + 104, + 310, + 230, + 330 + ], + "spans": [ + { + "bbox": [ + 104, + 310, + 230, + 330 + ], + "score": 1.0, + "content": "5 Language Modeling", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 106, + 331, + 505, + 354 + ], + "lines": [ + { + "bbox": [ + 106, + 330, + 505, + 344 + ], + "spans": [ + { + "bbox": [ + 106, + 330, + 505, + 344 + ], + "score": 1.0, + "content": "We evaluated the performance of MEGABYTE on language modeling on a set of 5 diverse datasets", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 342, + 506, + 355 + ], + "spans": [ + { + "bbox": [ + 106, + 342, + 506, + 355 + ], + "score": 1.0, + "content": "emphasizing long-range dependencies: Project Gutenberg (PG-19), Books, Stories, arXiv, and Code.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12.5 + }, + { + "type": "text", + "bbox": [ + 106, + 358, + 505, + 435 + ], + "lines": [ + { + "bbox": [ + 106, + 359, + 506, + 371 + ], + "spans": [ + { + "bbox": [ + 106, + 359, + 506, + 371 + ], + "score": 1.0, + "content": "Datasets We experiment on a range of long form text datasets. The PG-19 dataset Rae et al. (2019b)", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 368, + 506, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 368, + 506, + 383 + ], + "score": 1.0, + "content": "consists of English-language books written before 1919 and is extracted from the Project Gutenberg", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 380, + 506, + 393 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 506, + 393 + ], + "score": 1.0, + "content": "online library. The Stories dataset Trinh & Le (2018) is a subset of CommonCrawl data meant to", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 391, + 506, + 404 + ], + "spans": [ + { + "bbox": [ + 105, + 391, + 506, + 404 + ], + "score": 1.0, + "content": "emulate Winograd schemas. Books Gao et al. (2020) is another collection of English-language books.", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 401, + 506, + 415 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 353, + 415 + ], + "score": 1.0, + "content": "The arXiv dataset contains technical publications written in", + "type": "text" + }, + { + "bbox": [ + 354, + 402, + 379, + 414 + ], + "score": 0.41, + "content": "\\mathrm { I A T _ { E } X }", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 401, + 506, + 415 + ], + "score": 1.0, + "content": "from the arXiv online archive.", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 412, + 506, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 506, + 426 + ], + "score": 1.0, + "content": "Finally, the Code dataset is a large publicly available dataset of open source code, under Apache,", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 424, + 492, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 424, + 492, + 436 + ], + "score": 1.0, + "content": "BSD or MIT licenses. More details on dataset sizes and document lengths are shared in Table 1.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 106, + 441, + 505, + 517 + ], + "lines": [ + { + "bbox": [ + 105, + 439, + 506, + 454 + ], + "spans": [ + { + "bbox": [ + 105, + 439, + 506, + 454 + ], + "score": 1.0, + "content": "Controlled Experiments Table 1 lists bpb on each dataset. Each model is trained for 80 billion bytes,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 452, + 506, + 464 + ], + "spans": [ + { + "bbox": [ + 106, + 452, + 506, + 464 + ], + "score": 1.0, + "content": "and models are scaled to use the same compute budget. We carefully tune hyperparameters for all", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 462, + 505, + 474 + ], + "spans": [ + { + "bbox": [ + 105, + 462, + 505, + 474 + ], + "score": 1.0, + "content": "architectures to best utilize the available compute budget. MEGABYTE consistently outperforms both", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 473, + 506, + 486 + ], + "spans": [ + { + "bbox": [ + 106, + 473, + 506, + 486 + ], + "score": 1.0, + "content": "transformers and PerceiverAR across all datasets. We use the same sets of parameters on all dataset.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 484, + 506, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 484, + 506, + 496 + ], + "score": 1.0, + "content": "In all experiments presented in Table 1, transformer has size of 320M with context length of 1024,", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 496, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 106, + 496, + 505, + 507 + ], + "score": 1.0, + "content": "PerceiverAR has size of 248M with context size of 8192 and latent size of 1024, and MEGABYTE", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 506, + 465, + 518 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 465, + 518 + ], + "score": 1.0, + "content": "global/local model sizes are 758M/262M with context length of 8192 and patch size of 8.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 107, + 522, + 506, + 621 + ], + "lines": [ + { + "bbox": [ + 106, + 523, + 505, + 534 + ], + "spans": [ + { + "bbox": [ + 106, + 523, + 505, + 534 + ], + "score": 1.0, + "content": "Scaling Experiment We scale up our training data on PG-19 (Table 2), and compare MEGABYTE", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 533, + 506, + 545 + ], + "spans": [ + { + "bbox": [ + 106, + 533, + 506, + 545 + ], + "score": 1.0, + "content": "with byte baselines, as well as converting all results to word-level perplexities to benchmark with state-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 545, + 504, + 555 + ], + "spans": [ + { + "bbox": [ + 106, + 545, + 504, + 555 + ], + "score": 1.0, + "content": "of-art token based models. We train a byte-level Transformer, PerceiverAR and MEGABYTE models", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 555, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 555, + 505, + 568 + ], + "score": 1.0, + "content": "for 400B bytes and the same compute budget using same model parameters as in the controlled", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 566, + 506, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 506, + 579 + ], + "score": 1.0, + "content": "experiments. We find that MEGABYTE outperforms other byte-level models by a wide margin", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 576, + 506, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 576, + 506, + 590 + ], + "score": 1.0, + "content": "at this scale.3 We also compare with the best previously reported numbers for sub-word models.", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 587, + 506, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 506, + 601 + ], + "score": 1.0, + "content": "These results may be confounded by differing amounts of compute and tuning used, but show that", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 598, + 506, + 612 + ], + "spans": [ + { + "bbox": [ + 106, + 598, + 506, + 612 + ], + "score": 1.0, + "content": "MEGABYTE gives results competitive with state-of-the-art models trained on subwords. These results", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 610, + 467, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 467, + 622 + ], + "score": 1.0, + "content": "suggest that MEGABYTE may allow future large language models to be tokenization-free.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 32 + }, + { + "type": "title", + "bbox": [ + 107, + 631, + 210, + 645 + ], + "lines": [ + { + "bbox": [ + 104, + 628, + 211, + 648 + ], + "spans": [ + { + "bbox": [ + 104, + 628, + 211, + 648 + ], + "score": 1.0, + "content": "6 Image Modeling", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 107, + 650, + 505, + 683 + ], + "lines": [ + { + "bbox": [ + 105, + 649, + 505, + 663 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 505, + 663 + ], + "score": 1.0, + "content": "Sequence Modeling on ImageNet We test MEGABYTE on variants of the autoregressive image", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 660, + 507, + 674 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 507, + 674 + ], + "score": 1.0, + "content": "generation task on ImageNet (Oord et al., 2016), to measure its ability to efficiently use long context.", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 671, + 506, + 685 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 356, + 685 + ], + "score": 1.0, + "content": "We test on three different resolutions of images, ranging from", + "type": "text" + }, + { + "bbox": [ + 356, + 672, + 384, + 682 + ], + "score": 0.81, + "content": "6 4 { \\times } 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 384, + 671, + 395, + 685 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 395, + 672, + 433, + 682 + ], + "score": 0.76, + "content": "6 4 0 { \\times } 6 4 0", + "type": "inline_equation" + }, + { + "bbox": [ + 433, + 671, + 506, + 685 + ], + "score": 1.0, + "content": "pixels – the latter", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 39 + } + ], + "page_idx": 5, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 106, + 691, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 118, + 689, + 505, + 704 + ], + "spans": [ + { + "bbox": [ + 118, + 689, + 505, + 704 + ], + "score": 1.0, + "content": "3The only prior byte-level experiments we are aware of are at a smaller scale in Hutchins et al. (2022), who", + "type": "text" + } + ] + }, + { + "bbox": [ + 105, + 701, + 505, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 701, + 505, + 712 + ], + "score": 1.0, + "content": "report results equivalent to test perplexities of 46.5 with a version of the BlockRecurrent transformer, and 49.5", + "type": "text" + } + ] + }, + { + "bbox": [ + 105, + 711, + 408, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 711, + 408, + 723 + ], + "score": 1.0, + "content": "with Memorizing Transformers Wu et al. (2022), compared to 36.4 with our model.", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 742, + 309, + 750 + ], + "lines": [ + { + "bbox": [ + 302, + 741, + 310, + 752 + ], + "spans": [ + { + "bbox": [ + 302, + 741, + 310, + 752 + ], + "score": 1.0, + "content": "6", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 149, + 70, + 462, + 142 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 149, + 70, + 462, + 142 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 149, + 70, + 462, + 142 + ], + "spans": [ + { + "bbox": [ + 149, + 70, + 462, + 142 + ], + "score": 0.978, + "html": "
DatasetTotal Bytesbytes/docTransformerPerceiverARMEGABYTE
PG-1910.1GB411,4041.0571.1041.000
Stories21.3GB35,2651.0641.0700.978
Books79.7GB509,5261.0971.1041.007
arXiv91.5GB58,5180.8160.7910.678
Code353.7GB7,4610.5750.5460.411
", + "type": "table", + "image_path": "fafe1bab78de4470dcbe5848c63413723a5f88b952b852e1018c954a9e255858.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 149, + 70, + 462, + 94.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 149, + 94.0, + 462, + 118.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 149, + 118.0, + 462, + 142.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 106, + 142, + 505, + 162 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 141, + 506, + 153 + ], + "spans": [ + { + "bbox": [ + 105, + 141, + 506, + 153 + ], + "score": 1.0, + "content": "Table 1: Text dataset sizes and mean document lengths. We also report bpb of various models (Transformer,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 150, + 339, + 164 + ], + "spans": [ + { + "bbox": [ + 105, + 150, + 339, + 164 + ], + "score": 1.0, + "content": "PerceiverAR, and MEGABYTE) trained with the same compute.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + } + ], + "index": 2.25 + }, + { + "type": "table", + "bbox": [ + 106, + 180, + 508, + 271 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 106, + 180, + 508, + 271 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 180, + 508, + 271 + ], + "spans": [ + { + "bbox": [ + 106, + 180, + 508, + 271 + ], + "score": 0.981, + "html": "
TokenizerVocabContext LengthValidationTest
TransformerXL Rae et al. (2019a)SentPiece32k512+102445.536.3
CompressiveTransformer Rae et al. (2019a)SentPiece32k512+512+2x51243.433.6
PerceiverAR Hawthorne et al. (2022)SentPiece32k204845.928.9
BlockRecurrent Hutchins et al. (2022)SentPiece32k1024+recurrence-26.5
Transformer byte-level (ours)Bytes256204881.669.4
PerceiverAR byte-level (ours)Bytes2568192119.188.8
MEGABYTEBytes256819242.836.4
", + "type": "table", + "image_path": "bd9457e48b6a56ca125b125716ec6a52eb5fd7b529642573e0c24f76093f36f6.jpg" + } + ] + } + ], + "index": 6, + "virtual_lines": [ + { + "bbox": [ + 106, + 180, + 508, + 210.33333333333334 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 106, + 210.33333333333334, + 508, + 240.66666666666669 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 106, + 240.66666666666669, + 508, + 271.0 + ], + "spans": [], + "index": 7 + } + ] + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 106, + 276, + 506, + 306 + ], + "lines": [ + { + "bbox": [ + 105, + 275, + 505, + 288 + ], + "spans": [ + { + "bbox": [ + 105, + 275, + 505, + 288 + ], + "score": 1.0, + "content": "Table 2: Larger scale experiments on PG19, converting bits-per-byte to word-level perplexities for comparison", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 286, + 506, + 297 + ], + "spans": [ + { + "bbox": [ + 105, + 286, + 506, + 297 + ], + "score": 1.0, + "content": "with prior work. Results below the line are compute-matched. MEGABYTE outperforms other byte models by a", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 296, + 441, + 308 + ], + "spans": [ + { + "bbox": [ + 105, + 296, + 441, + 308 + ], + "score": 1.0, + "content": "wide margin, and gives results competitive with state-of-the-art models trained on subwords.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9, + "bbox_fs": [ + 105, + 275, + 506, + 308 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 312, + 229, + 326 + ], + "lines": [ + { + "bbox": [ + 104, + 310, + 230, + 330 + ], + "spans": [ + { + "bbox": [ + 104, + 310, + 230, + 330 + ], + "score": 1.0, + "content": "5 Language Modeling", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 106, + 331, + 505, + 354 + ], + "lines": [ + { + "bbox": [ + 106, + 330, + 505, + 344 + ], + "spans": [ + { + "bbox": [ + 106, + 330, + 505, + 344 + ], + "score": 1.0, + "content": "We evaluated the performance of MEGABYTE on language modeling on a set of 5 diverse datasets", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 342, + 506, + 355 + ], + "spans": [ + { + "bbox": [ + 106, + 342, + 506, + 355 + ], + "score": 1.0, + "content": "emphasizing long-range dependencies: Project Gutenberg (PG-19), Books, Stories, arXiv, and Code.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12.5, + "bbox_fs": [ + 106, + 330, + 506, + 355 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 358, + 505, + 435 + ], + "lines": [ + { + "bbox": [ + 106, + 359, + 506, + 371 + ], + "spans": [ + { + "bbox": [ + 106, + 359, + 506, + 371 + ], + "score": 1.0, + "content": "Datasets We experiment on a range of long form text datasets. The PG-19 dataset Rae et al. (2019b)", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 368, + 506, + 383 + ], + "spans": [ + { + "bbox": [ + 105, + 368, + 506, + 383 + ], + "score": 1.0, + "content": "consists of English-language books written before 1919 and is extracted from the Project Gutenberg", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 380, + 506, + 393 + ], + "spans": [ + { + "bbox": [ + 105, + 380, + 506, + 393 + ], + "score": 1.0, + "content": "online library. The Stories dataset Trinh & Le (2018) is a subset of CommonCrawl data meant to", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 391, + 506, + 404 + ], + "spans": [ + { + "bbox": [ + 105, + 391, + 506, + 404 + ], + "score": 1.0, + "content": "emulate Winograd schemas. Books Gao et al. (2020) is another collection of English-language books.", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 401, + 506, + 415 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 353, + 415 + ], + "score": 1.0, + "content": "The arXiv dataset contains technical publications written in", + "type": "text" + }, + { + "bbox": [ + 354, + 402, + 379, + 414 + ], + "score": 0.41, + "content": "\\mathrm { I A T _ { E } X }", + "type": "inline_equation" + }, + { + "bbox": [ + 379, + 401, + 506, + 415 + ], + "score": 1.0, + "content": "from the arXiv online archive.", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 412, + 506, + 426 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 506, + 426 + ], + "score": 1.0, + "content": "Finally, the Code dataset is a large publicly available dataset of open source code, under Apache,", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 424, + 492, + 436 + ], + "spans": [ + { + "bbox": [ + 105, + 424, + 492, + 436 + ], + "score": 1.0, + "content": "BSD or MIT licenses. More details on dataset sizes and document lengths are shared in Table 1.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 17, + "bbox_fs": [ + 105, + 359, + 506, + 436 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 441, + 505, + 517 + ], + "lines": [ + { + "bbox": [ + 105, + 439, + 506, + 454 + ], + "spans": [ + { + "bbox": [ + 105, + 439, + 506, + 454 + ], + "score": 1.0, + "content": "Controlled Experiments Table 1 lists bpb on each dataset. Each model is trained for 80 billion bytes,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 452, + 506, + 464 + ], + "spans": [ + { + "bbox": [ + 106, + 452, + 506, + 464 + ], + "score": 1.0, + "content": "and models are scaled to use the same compute budget. We carefully tune hyperparameters for all", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 462, + 505, + 474 + ], + "spans": [ + { + "bbox": [ + 105, + 462, + 505, + 474 + ], + "score": 1.0, + "content": "architectures to best utilize the available compute budget. MEGABYTE consistently outperforms both", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 473, + 506, + 486 + ], + "spans": [ + { + "bbox": [ + 106, + 473, + 506, + 486 + ], + "score": 1.0, + "content": "transformers and PerceiverAR across all datasets. We use the same sets of parameters on all dataset.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 484, + 506, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 484, + 506, + 496 + ], + "score": 1.0, + "content": "In all experiments presented in Table 1, transformer has size of 320M with context length of 1024,", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 496, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 106, + 496, + 505, + 507 + ], + "score": 1.0, + "content": "PerceiverAR has size of 248M with context size of 8192 and latent size of 1024, and MEGABYTE", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 506, + 465, + 518 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 465, + 518 + ], + "score": 1.0, + "content": "global/local model sizes are 758M/262M with context length of 8192 and patch size of 8.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 24, + "bbox_fs": [ + 105, + 439, + 506, + 518 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 522, + 506, + 621 + ], + "lines": [ + { + "bbox": [ + 106, + 523, + 505, + 534 + ], + "spans": [ + { + "bbox": [ + 106, + 523, + 505, + 534 + ], + "score": 1.0, + "content": "Scaling Experiment We scale up our training data on PG-19 (Table 2), and compare MEGABYTE", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 533, + 506, + 545 + ], + "spans": [ + { + "bbox": [ + 106, + 533, + 506, + 545 + ], + "score": 1.0, + "content": "with byte baselines, as well as converting all results to word-level perplexities to benchmark with state-", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 545, + 504, + 555 + ], + "spans": [ + { + "bbox": [ + 106, + 545, + 504, + 555 + ], + "score": 1.0, + "content": "of-art token based models. We train a byte-level Transformer, PerceiverAR and MEGABYTE models", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 555, + 505, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 555, + 505, + 568 + ], + "score": 1.0, + "content": "for 400B bytes and the same compute budget using same model parameters as in the controlled", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 566, + 506, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 566, + 506, + 579 + ], + "score": 1.0, + "content": "experiments. We find that MEGABYTE outperforms other byte-level models by a wide margin", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 576, + 506, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 576, + 506, + 590 + ], + "score": 1.0, + "content": "at this scale.3 We also compare with the best previously reported numbers for sub-word models.", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 587, + 506, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 587, + 506, + 601 + ], + "score": 1.0, + "content": "These results may be confounded by differing amounts of compute and tuning used, but show that", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 598, + 506, + 612 + ], + "spans": [ + { + "bbox": [ + 106, + 598, + 506, + 612 + ], + "score": 1.0, + "content": "MEGABYTE gives results competitive with state-of-the-art models trained on subwords. These results", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 610, + 467, + 622 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 467, + 622 + ], + "score": 1.0, + "content": "suggest that MEGABYTE may allow future large language models to be tokenization-free.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 32, + "bbox_fs": [ + 105, + 523, + 506, + 622 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 631, + 210, + 645 + ], + "lines": [ + { + "bbox": [ + 104, + 628, + 211, + 648 + ], + "spans": [ + { + "bbox": [ + 104, + 628, + 211, + 648 + ], + "score": 1.0, + "content": "6 Image Modeling", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 37 + }, + { + "type": "text", + "bbox": [ + 107, + 650, + 505, + 683 + ], + "lines": [ + { + "bbox": [ + 105, + 649, + 505, + 663 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 505, + 663 + ], + "score": 1.0, + "content": "Sequence Modeling on ImageNet We test MEGABYTE on variants of the autoregressive image", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 660, + 507, + 674 + ], + "spans": [ + { + "bbox": [ + 105, + 660, + 507, + 674 + ], + "score": 1.0, + "content": "generation task on ImageNet (Oord et al., 2016), to measure its ability to efficiently use long context.", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 671, + 506, + 685 + ], + "spans": [ + { + "bbox": [ + 105, + 671, + 356, + 685 + ], + "score": 1.0, + "content": "We test on three different resolutions of images, ranging from", + "type": "text" + }, + { + "bbox": [ + 356, + 672, + 384, + 682 + ], + "score": 0.81, + "content": "6 4 { \\times } 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 384, + 671, + 395, + 685 + ], + "score": 1.0, + "content": "to", + "type": "text" + }, + { + "bbox": [ + 395, + 672, + 433, + 682 + ], + "score": 0.76, + "content": "6 4 0 { \\times } 6 4 0", + "type": "inline_equation" + }, + { + "bbox": [ + 433, + 671, + 506, + 685 + ], + "score": 1.0, + "content": "pixels – the latter", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 72, + 506, + 86 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 506, + 86 + ], + "score": 1.0, + "content": "requiring the effective modeling of sequences with over 1.2M tokens. This generation task becomes", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 83, + 506, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 83, + 506, + 97 + ], + "score": 1.0, + "content": "increasingly challenging as the image’s resolution grows: doing well on this task requires the modeling", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 94, + 506, + 108 + ], + "spans": [ + { + "bbox": [ + 105, + 94, + 506, + 108 + ], + "score": 1.0, + "content": "of local patterns (textures, lines, etc.) and long-range context that provides information about the", + "type": "text", + "cross_page": true + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 105, + 507, + 119 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 507, + 119 + ], + "score": 1.0, + "content": "high level structure of the image. Inspired by recent works in Vision Transformers (Dosovitskiy et al.,", + "type": "text", + "cross_page": true + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 115, + 466, + 130 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 466, + 130 + ], + "score": 1.0, + "content": "2020), we model image data patch by patch (more details can be found in Appendix D.1).", + "type": "text", + "cross_page": true + } + ], + "index": 4 + } + ], + "index": 39, + "bbox_fs": [ + 105, + 649, + 507, + 685 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 72, + 505, + 128 + ], + "lines": [ + { + "bbox": [ + 105, + 72, + 506, + 86 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 506, + 86 + ], + "score": 1.0, + "content": "requiring the effective modeling of sequences with over 1.2M tokens. This generation task becomes", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 83, + 506, + 97 + ], + "spans": [ + { + "bbox": [ + 105, + 83, + 506, + 97 + ], + "score": 1.0, + "content": "increasingly challenging as the image’s resolution grows: doing well on this task requires the modeling", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 94, + 506, + 108 + ], + "spans": [ + { + "bbox": [ + 105, + 94, + 506, + 108 + ], + "score": 1.0, + "content": "of local patterns (textures, lines, etc.) and long-range context that provides information about the", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 105, + 507, + 119 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 507, + 119 + ], + "score": 1.0, + "content": "high level structure of the image. Inspired by recent works in Vision Transformers (Dosovitskiy et al.,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 115, + 466, + 130 + ], + "spans": [ + { + "bbox": [ + 105, + 115, + 466, + 130 + ], + "score": 1.0, + "content": "2020), we model image data patch by patch (more details can be found in Appendix D.1).", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 106, + 141, + 505, + 196 + ], + "lines": [ + { + "bbox": [ + 106, + 141, + 505, + 153 + ], + "spans": [ + { + "bbox": [ + 106, + 141, + 505, + 153 + ], + "score": 1.0, + "content": "Comparison with State of the Art We train a large MEGABYTE model on ImageNet 64x64 with", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 152, + 505, + 165 + ], + "spans": [ + { + "bbox": [ + 106, + 152, + 505, + 165 + ], + "score": 1.0, + "content": "Global and Local models sized 2.7B and 350M parameters, respectively, for 1.4T tokens. We estimate", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 162, + 505, + 176 + ], + "spans": [ + { + "bbox": [ + 105, + 162, + 505, + 176 + ], + "score": 1.0, + "content": "that training this model consumed less than half the GPU hours we would have needed to reproduce", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 173, + 505, + 187 + ], + "spans": [ + { + "bbox": [ + 105, + 173, + 505, + 187 + ], + "score": 1.0, + "content": "the best PerceiverAR model described by (Hawthorne et al., 2022). As shown in Table 2, MEGABYTE", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 184, + 478, + 198 + ], + "spans": [ + { + "bbox": [ + 105, + 184, + 478, + 198 + ], + "score": 1.0, + "content": "matches the state-of-the-art performance of PerceiverAR whilst using only half the compute.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 7 + }, + { + "type": "table", + "bbox": [ + 113, + 208, + 277, + 265 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 113, + 208, + 277, + 265 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 113, + 208, + 277, + 265 + ], + "spans": [ + { + "bbox": [ + 113, + 208, + 277, + 265 + ], + "score": 0.97, + "html": "
ImageNet64bpb
Routing Transformer (Roy et al.,2020)3.43
Combiner (Ren et al., 2021)3.42
Perceiver AR (Hawthorne et al.,2022)3.40
MEGABYTE3.40
", + "type": "table", + "image_path": "6853aa8b7679c08d0640c6249772388ed9ad2c000816a89fd641093272914bf6.jpg" + } + ] + } + ], + "index": 11.5, + "virtual_lines": [ + { + "bbox": [ + 113, + 208, + 277, + 222.25 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 113, + 222.25, + 277, + 236.5 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 113, + 236.5, + 277, + 250.75 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 113, + 250.75, + 277, + 265.0 + ], + "spans": [], + "index": 13 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 113, + 266, + 266, + 305 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 112, + 264, + 267, + 275 + ], + "spans": [ + { + "bbox": [ + 112, + 264, + 267, + 275 + ], + "score": 1.0, + "content": "Table 3: Bits per byte (bpb) on ImageNet", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 113, + 274, + 267, + 285 + ], + "spans": [ + { + "bbox": [ + 113, + 275, + 138, + 285 + ], + "score": 0.71, + "content": "6 4 { \\times } 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 138, + 274, + 267, + 285 + ], + "score": 1.0, + "content": ". MEGABYTE matches the current", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 113, + 285, + 266, + 295 + ], + "spans": [ + { + "bbox": [ + 113, + 285, + 266, + 295 + ], + "score": 1.0, + "content": "state-of-the-art while only using half the", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 113, + 295, + 225, + 305 + ], + "spans": [ + { + "bbox": [ + 113, + 295, + 225, + 305 + ], + "score": 1.0, + "content": "amount of GPU hours to train.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15.5 + } + ], + "index": 13.5 + }, + { + "type": "table", + "bbox": [ + 285, + 210, + 507, + 273 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 285, + 210, + 507, + 273 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 285, + 210, + 507, + 273 + ], + "spans": [ + { + "bbox": [ + 285, + 210, + 507, + 273 + ], + "score": 0.976, + "html": "
ContextImage64Image256Image640
Total len122881966081228800
Transformer10243.623.8012.847
Perceiver AR120003.553.3732.345
MEGABYTEFull3.523.1582.282
", + "type": "table", + "image_path": "1104e0915e55bbc64854d470e02d7c9a85ac7660e944d664af941f0b4a7d29d3.jpg" + } + ] + } + ], + "index": 19.5, + "virtual_lines": [ + { + "bbox": [ + 285, + 210, + 507, + 225.75 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 285, + 225.75, + 507, + 241.5 + ], + "spans": [], + "index": 19 + }, + { + "bbox": [ + 285, + 241.5, + 507, + 257.25 + ], + "spans": [], + "index": 20 + }, + { + "bbox": [ + 285, + 257.25, + 507, + 273.0 + ], + "spans": [], + "index": 21 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 286, + 273, + 500, + 303 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 284, + 271, + 499, + 284 + ], + "spans": [ + { + "bbox": [ + 284, + 271, + 499, + 284 + ], + "score": 1.0, + "content": "Table 4: Bits per byte (bpb) on ImageNet with different", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 284, + 281, + 500, + 294 + ], + "spans": [ + { + "bbox": [ + 284, + 281, + 500, + 294 + ], + "score": 1.0, + "content": "resolutions. All models use the same compute and data.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 285, + 292, + 496, + 303 + ], + "spans": [ + { + "bbox": [ + 285, + 292, + 496, + 303 + ], + "score": 1.0, + "content": "MEGABYTE scales well to sequences of over 1M tokens.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23 + } + ], + "index": 21.25 + }, + { + "type": "text", + "bbox": [ + 107, + 335, + 505, + 378 + ], + "lines": [ + { + "bbox": [ + 105, + 334, + 506, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 334, + 506, + 348 + ], + "score": 1.0, + "content": "Scaling to higher resolutions We compare three transformer variants (vanilla, PerceiverAR,", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 345, + 506, + 359 + ], + "spans": [ + { + "bbox": [ + 105, + 345, + 506, + 359 + ], + "score": 1.0, + "content": "MEGABYTE) to test scalability to long sequences on increasingly large image resolutions. We use", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 356, + 505, + 369 + ], + "spans": [ + { + "bbox": [ + 105, + 356, + 505, + 369 + ], + "score": 1.0, + "content": "our own implementations of these in the same framework and budget the same amount of GPU hours", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 367, + 292, + 380 + ], + "spans": [ + { + "bbox": [ + 105, + 367, + 292, + 380 + ], + "score": 1.0, + "content": "and data to train each of these model variants.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 26.5 + }, + { + "type": "text", + "bbox": [ + 106, + 384, + 505, + 493 + ], + "lines": [ + { + "bbox": [ + 105, + 383, + 506, + 396 + ], + "spans": [ + { + "bbox": [ + 105, + 383, + 506, + 396 + ], + "score": 1.0, + "content": "MEGABYTE is able to handle all sequence lengths with a single forward pass of up to 1.2M tokens.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 393, + 506, + 407 + ], + "spans": [ + { + "bbox": [ + 105, + 393, + 506, + 407 + ], + "score": 1.0, + "content": "We found neither the standard Transformer nor PerceiverAR could model such long sequences", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 405, + 505, + 418 + ], + "spans": [ + { + "bbox": [ + 105, + 405, + 505, + 418 + ], + "score": 1.0, + "content": "at a reasonable model size, so instead we split images into segments of size 1024 and 12000", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 416, + 506, + 429 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 506, + 429 + ], + "score": 1.0, + "content": "respectively. For Megabyte, we set patch size as 12 for Image64 and patch size as 192 for Image256", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 427, + 506, + 441 + ], + "spans": [ + { + "bbox": [ + 105, + 427, + 506, + 441 + ], + "score": 1.0, + "content": "and Image640 datasets. Model sizes are adjusted to match overall training speeds across models", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 438, + 506, + 451 + ], + "spans": [ + { + "bbox": [ + 106, + 438, + 506, + 451 + ], + "score": 1.0, + "content": "and we do not use any form of sliding window evaluation in this experiment. As seen in Table 4,", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 448, + 506, + 462 + ], + "spans": [ + { + "bbox": [ + 105, + 448, + 506, + 462 + ], + "score": 1.0, + "content": "MEGABYTE outperforms baselines across all resolutions in this compute-controlled setting. The", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 104, + 460, + 506, + 473 + ], + "spans": [ + { + "bbox": [ + 104, + 460, + 506, + 473 + ], + "score": 1.0, + "content": "precise settings used for each of the baseline models such as context length and number of latents", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 471, + 505, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 505, + 484 + ], + "score": 1.0, + "content": "are summarized in Table 12. Results show that MEGABYTE outperforms the other systems at all", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 482, + 417, + 495 + ], + "spans": [ + { + "bbox": [ + 105, + 482, + 417, + 495 + ], + "score": 1.0, + "content": "resolutions, demonstrating an effective model of sequences of over 1M bytes.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 33.5 + }, + { + "type": "title", + "bbox": [ + 107, + 505, + 208, + 519 + ], + "lines": [ + { + "bbox": [ + 104, + 502, + 210, + 522 + ], + "spans": [ + { + "bbox": [ + 104, + 502, + 210, + 522 + ], + "score": 1.0, + "content": "7 Audio Modeling", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 39 + }, + { + "type": "text", + "bbox": [ + 108, + 525, + 504, + 547 + ], + "lines": [ + { + "bbox": [ + 106, + 524, + 505, + 538 + ], + "spans": [ + { + "bbox": [ + 106, + 524, + 505, + 538 + ], + "score": 1.0, + "content": "Audio has aspects of both the sequential structure of text and the continuous nature of images, so is", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 536, + 279, + 547 + ], + "spans": [ + { + "bbox": [ + 106, + 536, + 279, + 547 + ], + "score": 1.0, + "content": "an interesting application for MEGABYTE.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40.5 + }, + { + "type": "text", + "bbox": [ + 107, + 552, + 505, + 662 + ], + "lines": [ + { + "bbox": [ + 105, + 552, + 506, + 565 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 506, + 565 + ], + "score": 1.0, + "content": "Raw audio is typically stored as a sequence of 16-bit integer values (one per timestep); a softmax layer", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 563, + 505, + 576 + ], + "spans": [ + { + "bbox": [ + 105, + 563, + 505, + 576 + ], + "score": 1.0, + "content": "would need to output 65,536 probabilities per timestep to model all possible values. To address this", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 574, + 505, + 587 + ], + "spans": [ + { + "bbox": [ + 105, + 574, + 505, + 587 + ], + "score": 1.0, + "content": "issue, various techniques have been developed to reduce the memory and computational requirements", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 585, + 505, + 598 + ], + "spans": [ + { + "bbox": [ + 105, + 585, + 369, + 598 + ], + "score": 1.0, + "content": "of the softmax layer. For instance, van den Oord et al. (2016) apply", + "type": "text" + }, + { + "bbox": [ + 369, + 587, + 376, + 597 + ], + "score": 0.81, + "content": "\\mu", + "type": "inline_equation" + }, + { + "bbox": [ + 377, + 585, + 505, + 598 + ], + "score": 1.0, + "content": "-law companding transformation", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 596, + 506, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 596, + 506, + 608 + ], + "score": 1.0, + "content": "and quantizes the input into 256 possible values. Alternatively, van den Oord et al. (2017) model the", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 607, + 506, + 619 + ], + "spans": [ + { + "bbox": [ + 105, + 607, + 506, + 619 + ], + "score": 1.0, + "content": "samples using the discretized mixture of logistics distribution introduced by Salimans et al. (2017).", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 617, + 507, + 631 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 507, + 631 + ], + "score": 1.0, + "content": "Finally, Kalchbrenner et al. (2018) use a dual softmax technique to produce 8 coarse and 8 fine bits.", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 629, + 506, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 629, + 506, + 642 + ], + "score": 1.0, + "content": "In our approach, we simplify the audio modeling process by directly reading the bytes (256 possible", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 639, + 506, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 639, + 506, + 654 + ], + "score": 1.0, + "content": "values) from the audio file and conducting an autoregressive language model on top of that. This", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 651, + 417, + 663 + ], + "spans": [ + { + "bbox": [ + 105, + 651, + 417, + 663 + ], + "score": 1.0, + "content": "greatly streamlines the modeling process, making it easier and more efficient.", + "type": "text" + } + ], + "index": 51 + } + ], + "index": 46.5 + }, + { + "type": "text", + "bbox": [ + 107, + 667, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 106, + 667, + 505, + 679 + ], + "spans": [ + { + "bbox": [ + 106, + 667, + 281, + 679 + ], + "score": 1.0, + "content": "Our audio modeling approach focuses on", + "type": "text" + }, + { + "bbox": [ + 281, + 667, + 313, + 678 + ], + "score": 0.66, + "content": "1 6 \\ \\mathrm { k H z }", + "type": "inline_equation" + }, + { + "bbox": [ + 313, + 667, + 505, + 679 + ], + "score": 1.0, + "content": ", 16-bit audio, which equates to 32k bytes per", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 105, + 677, + 506, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 691 + ], + "score": 1.0, + "content": "one-second clip. We use an extensive audio dataset consisting of 2 terabytes (roughly 18,000 hours)", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 105, + 688, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 506, + 701 + ], + "score": 1.0, + "content": "of audio. We use a sequence length of 524,288, a patch size of 32, and a batch size of 32 to facilitate", + "type": "text" + } + ], + "index": 54 + }, + { + "bbox": [ + 105, + 700, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 700, + 506, + 712 + ], + "score": 1.0, + "content": "model training. By utilizing these settings, we can effectively train our model on large volumes of", + "type": "text" + } + ], + "index": 55 + }, + { + "bbox": [ + 106, + 710, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 505, + 723 + ], + "score": 1.0, + "content": "audio data, helping to improve its accuracy and efficacy. Our model obtains bpb of 3.477, much", + "type": "text" + } + ], + "index": 56 + } + ], + "index": 54 + } + ], + "page_idx": 6, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 309, + 750 + ], + "lines": [ + { + "bbox": [ + 302, + 741, + 309, + 753 + ], + "spans": [ + { + "bbox": [ + 302, + 741, + 309, + 753 + ], + "score": 1.0, + "content": "7", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 72, + 505, + 128 + ], + "lines": [], + "index": 2, + "bbox_fs": [ + 105, + 72, + 507, + 130 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 106, + 141, + 505, + 196 + ], + "lines": [ + { + "bbox": [ + 106, + 141, + 505, + 153 + ], + "spans": [ + { + "bbox": [ + 106, + 141, + 505, + 153 + ], + "score": 1.0, + "content": "Comparison with State of the Art We train a large MEGABYTE model on ImageNet 64x64 with", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 152, + 505, + 165 + ], + "spans": [ + { + "bbox": [ + 106, + 152, + 505, + 165 + ], + "score": 1.0, + "content": "Global and Local models sized 2.7B and 350M parameters, respectively, for 1.4T tokens. We estimate", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 162, + 505, + 176 + ], + "spans": [ + { + "bbox": [ + 105, + 162, + 505, + 176 + ], + "score": 1.0, + "content": "that training this model consumed less than half the GPU hours we would have needed to reproduce", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 173, + 505, + 187 + ], + "spans": [ + { + "bbox": [ + 105, + 173, + 505, + 187 + ], + "score": 1.0, + "content": "the best PerceiverAR model described by (Hawthorne et al., 2022). As shown in Table 2, MEGABYTE", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 184, + 478, + 198 + ], + "spans": [ + { + "bbox": [ + 105, + 184, + 478, + 198 + ], + "score": 1.0, + "content": "matches the state-of-the-art performance of PerceiverAR whilst using only half the compute.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 7, + "bbox_fs": [ + 105, + 141, + 505, + 198 + ] + }, + { + "type": "table", + "bbox": [ + 113, + 208, + 277, + 265 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 113, + 208, + 277, + 265 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 113, + 208, + 277, + 265 + ], + "spans": [ + { + "bbox": [ + 113, + 208, + 277, + 265 + ], + "score": 0.97, + "html": "
ImageNet64bpb
Routing Transformer (Roy et al.,2020)3.43
Combiner (Ren et al., 2021)3.42
Perceiver AR (Hawthorne et al.,2022)3.40
MEGABYTE3.40
", + "type": "table", + "image_path": "6853aa8b7679c08d0640c6249772388ed9ad2c000816a89fd641093272914bf6.jpg" + } + ] + } + ], + "index": 11.5, + "virtual_lines": [ + { + "bbox": [ + 113, + 208, + 277, + 222.25 + ], + "spans": [], + "index": 10 + }, + { + "bbox": [ + 113, + 222.25, + 277, + 236.5 + ], + "spans": [], + "index": 11 + }, + { + "bbox": [ + 113, + 236.5, + 277, + 250.75 + ], + "spans": [], + "index": 12 + }, + { + "bbox": [ + 113, + 250.75, + 277, + 265.0 + ], + "spans": [], + "index": 13 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 113, + 266, + 266, + 305 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 112, + 264, + 267, + 275 + ], + "spans": [ + { + "bbox": [ + 112, + 264, + 267, + 275 + ], + "score": 1.0, + "content": "Table 3: Bits per byte (bpb) on ImageNet", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 113, + 274, + 267, + 285 + ], + "spans": [ + { + "bbox": [ + 113, + 275, + 138, + 285 + ], + "score": 0.71, + "content": "6 4 { \\times } 6 4", + "type": "inline_equation" + }, + { + "bbox": [ + 138, + 274, + 267, + 285 + ], + "score": 1.0, + "content": ". MEGABYTE matches the current", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 113, + 285, + 266, + 295 + ], + "spans": [ + { + "bbox": [ + 113, + 285, + 266, + 295 + ], + "score": 1.0, + "content": "state-of-the-art while only using half the", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 113, + 295, + 225, + 305 + ], + "spans": [ + { + "bbox": [ + 113, + 295, + 225, + 305 + ], + "score": 1.0, + "content": "amount of GPU hours to train.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 15.5 + } + ], + "index": 13.5 + }, + { + "type": "table", + "bbox": [ + 285, + 210, + 507, + 273 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 285, + 210, + 507, + 273 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 285, + 210, + 507, + 273 + ], + "spans": [ + { + "bbox": [ + 285, + 210, + 507, + 273 + ], + "score": 0.976, + "html": "
ContextImage64Image256Image640
Total len122881966081228800
Transformer10243.623.8012.847
Perceiver AR120003.553.3732.345
MEGABYTEFull3.523.1582.282
", + "type": "table", + "image_path": "1104e0915e55bbc64854d470e02d7c9a85ac7660e944d664af941f0b4a7d29d3.jpg" + } + ] + } + ], + "index": 19.5, + "virtual_lines": [ + { + "bbox": [ + 285, + 210, + 507, + 225.75 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 285, + 225.75, + 507, + 241.5 + ], + "spans": [], + "index": 19 + }, + { + "bbox": [ + 285, + 241.5, + 507, + 257.25 + ], + "spans": [], + "index": 20 + }, + { + "bbox": [ + 285, + 257.25, + 507, + 273.0 + ], + "spans": [], + "index": 21 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 286, + 273, + 500, + 303 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 284, + 271, + 499, + 284 + ], + "spans": [ + { + "bbox": [ + 284, + 271, + 499, + 284 + ], + "score": 1.0, + "content": "Table 4: Bits per byte (bpb) on ImageNet with different", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 284, + 281, + 500, + 294 + ], + "spans": [ + { + "bbox": [ + 284, + 281, + 500, + 294 + ], + "score": 1.0, + "content": "resolutions. All models use the same compute and data.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 285, + 292, + 496, + 303 + ], + "spans": [ + { + "bbox": [ + 285, + 292, + 496, + 303 + ], + "score": 1.0, + "content": "MEGABYTE scales well to sequences of over 1M tokens.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23 + } + ], + "index": 21.25 + }, + { + "type": "text", + "bbox": [ + 107, + 335, + 505, + 378 + ], + "lines": [ + { + "bbox": [ + 105, + 334, + 506, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 334, + 506, + 348 + ], + "score": 1.0, + "content": "Scaling to higher resolutions We compare three transformer variants (vanilla, PerceiverAR,", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 345, + 506, + 359 + ], + "spans": [ + { + "bbox": [ + 105, + 345, + 506, + 359 + ], + "score": 1.0, + "content": "MEGABYTE) to test scalability to long sequences on increasingly large image resolutions. We use", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 356, + 505, + 369 + ], + "spans": [ + { + "bbox": [ + 105, + 356, + 505, + 369 + ], + "score": 1.0, + "content": "our own implementations of these in the same framework and budget the same amount of GPU hours", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 367, + 292, + 380 + ], + "spans": [ + { + "bbox": [ + 105, + 367, + 292, + 380 + ], + "score": 1.0, + "content": "and data to train each of these model variants.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 26.5, + "bbox_fs": [ + 105, + 334, + 506, + 380 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 384, + 505, + 493 + ], + "lines": [ + { + "bbox": [ + 105, + 383, + 506, + 396 + ], + "spans": [ + { + "bbox": [ + 105, + 383, + 506, + 396 + ], + "score": 1.0, + "content": "MEGABYTE is able to handle all sequence lengths with a single forward pass of up to 1.2M tokens.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 393, + 506, + 407 + ], + "spans": [ + { + "bbox": [ + 105, + 393, + 506, + 407 + ], + "score": 1.0, + "content": "We found neither the standard Transformer nor PerceiverAR could model such long sequences", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 405, + 505, + 418 + ], + "spans": [ + { + "bbox": [ + 105, + 405, + 505, + 418 + ], + "score": 1.0, + "content": "at a reasonable model size, so instead we split images into segments of size 1024 and 12000", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 416, + 506, + 429 + ], + "spans": [ + { + "bbox": [ + 105, + 416, + 506, + 429 + ], + "score": 1.0, + "content": "respectively. For Megabyte, we set patch size as 12 for Image64 and patch size as 192 for Image256", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 427, + 506, + 441 + ], + "spans": [ + { + "bbox": [ + 105, + 427, + 506, + 441 + ], + "score": 1.0, + "content": "and Image640 datasets. Model sizes are adjusted to match overall training speeds across models", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 438, + 506, + 451 + ], + "spans": [ + { + "bbox": [ + 106, + 438, + 506, + 451 + ], + "score": 1.0, + "content": "and we do not use any form of sliding window evaluation in this experiment. As seen in Table 4,", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 448, + 506, + 462 + ], + "spans": [ + { + "bbox": [ + 105, + 448, + 506, + 462 + ], + "score": 1.0, + "content": "MEGABYTE outperforms baselines across all resolutions in this compute-controlled setting. The", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 104, + 460, + 506, + 473 + ], + "spans": [ + { + "bbox": [ + 104, + 460, + 506, + 473 + ], + "score": 1.0, + "content": "precise settings used for each of the baseline models such as context length and number of latents", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 471, + 505, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 505, + 484 + ], + "score": 1.0, + "content": "are summarized in Table 12. Results show that MEGABYTE outperforms the other systems at all", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 482, + 417, + 495 + ], + "spans": [ + { + "bbox": [ + 105, + 482, + 417, + 495 + ], + "score": 1.0, + "content": "resolutions, demonstrating an effective model of sequences of over 1M bytes.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 33.5, + "bbox_fs": [ + 104, + 383, + 506, + 495 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 505, + 208, + 519 + ], + "lines": [ + { + "bbox": [ + 104, + 502, + 210, + 522 + ], + "spans": [ + { + "bbox": [ + 104, + 502, + 210, + 522 + ], + "score": 1.0, + "content": "7 Audio Modeling", + "type": "text" + } + ], + "index": 39 + } + ], + "index": 39 + }, + { + "type": "text", + "bbox": [ + 108, + 525, + 504, + 547 + ], + "lines": [ + { + "bbox": [ + 106, + 524, + 505, + 538 + ], + "spans": [ + { + "bbox": [ + 106, + 524, + 505, + 538 + ], + "score": 1.0, + "content": "Audio has aspects of both the sequential structure of text and the continuous nature of images, so is", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 536, + 279, + 547 + ], + "spans": [ + { + "bbox": [ + 106, + 536, + 279, + 547 + ], + "score": 1.0, + "content": "an interesting application for MEGABYTE.", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 40.5, + "bbox_fs": [ + 106, + 524, + 505, + 547 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 552, + 505, + 662 + ], + "lines": [ + { + "bbox": [ + 105, + 552, + 506, + 565 + ], + "spans": [ + { + "bbox": [ + 105, + 552, + 506, + 565 + ], + "score": 1.0, + "content": "Raw audio is typically stored as a sequence of 16-bit integer values (one per timestep); a softmax layer", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 563, + 505, + 576 + ], + "spans": [ + { + "bbox": [ + 105, + 563, + 505, + 576 + ], + "score": 1.0, + "content": "would need to output 65,536 probabilities per timestep to model all possible values. To address this", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 574, + 505, + 587 + ], + "spans": [ + { + "bbox": [ + 105, + 574, + 505, + 587 + ], + "score": 1.0, + "content": "issue, various techniques have been developed to reduce the memory and computational requirements", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 585, + 505, + 598 + ], + "spans": [ + { + "bbox": [ + 105, + 585, + 369, + 598 + ], + "score": 1.0, + "content": "of the softmax layer. For instance, van den Oord et al. (2016) apply", + "type": "text" + }, + { + "bbox": [ + 369, + 587, + 376, + 597 + ], + "score": 0.81, + "content": "\\mu", + "type": "inline_equation" + }, + { + "bbox": [ + 377, + 585, + 505, + 598 + ], + "score": 1.0, + "content": "-law companding transformation", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 596, + 506, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 596, + 506, + 608 + ], + "score": 1.0, + "content": "and quantizes the input into 256 possible values. Alternatively, van den Oord et al. (2017) model the", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 607, + 506, + 619 + ], + "spans": [ + { + "bbox": [ + 105, + 607, + 506, + 619 + ], + "score": 1.0, + "content": "samples using the discretized mixture of logistics distribution introduced by Salimans et al. (2017).", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 617, + 507, + 631 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 507, + 631 + ], + "score": 1.0, + "content": "Finally, Kalchbrenner et al. (2018) use a dual softmax technique to produce 8 coarse and 8 fine bits.", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 629, + 506, + 642 + ], + "spans": [ + { + "bbox": [ + 105, + 629, + 506, + 642 + ], + "score": 1.0, + "content": "In our approach, we simplify the audio modeling process by directly reading the bytes (256 possible", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 639, + 506, + 654 + ], + "spans": [ + { + "bbox": [ + 105, + 639, + 506, + 654 + ], + "score": 1.0, + "content": "values) from the audio file and conducting an autoregressive language model on top of that. This", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 651, + 417, + 663 + ], + "spans": [ + { + "bbox": [ + 105, + 651, + 417, + 663 + ], + "score": 1.0, + "content": "greatly streamlines the modeling process, making it easier and more efficient.", + "type": "text" + } + ], + "index": 51 + } + ], + "index": 46.5, + "bbox_fs": [ + 105, + 552, + 507, + 663 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 667, + 505, + 722 + ], + "lines": [ + { + "bbox": [ + 106, + 667, + 505, + 679 + ], + "spans": [ + { + "bbox": [ + 106, + 667, + 281, + 679 + ], + "score": 1.0, + "content": "Our audio modeling approach focuses on", + "type": "text" + }, + { + "bbox": [ + 281, + 667, + 313, + 678 + ], + "score": 0.66, + "content": "1 6 \\ \\mathrm { k H z }", + "type": "inline_equation" + }, + { + "bbox": [ + 313, + 667, + 505, + 679 + ], + "score": 1.0, + "content": ", 16-bit audio, which equates to 32k bytes per", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 105, + 677, + 506, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 691 + ], + "score": 1.0, + "content": "one-second clip. We use an extensive audio dataset consisting of 2 terabytes (roughly 18,000 hours)", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 105, + 688, + 506, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 506, + 701 + ], + "score": 1.0, + "content": "of audio. We use a sequence length of 524,288, a patch size of 32, and a batch size of 32 to facilitate", + "type": "text" + } + ], + "index": 54 + }, + { + "bbox": [ + 105, + 700, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 700, + 506, + 712 + ], + "score": 1.0, + "content": "model training. By utilizing these settings, we can effectively train our model on large volumes of", + "type": "text" + } + ], + "index": 55 + }, + { + "bbox": [ + 106, + 710, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 505, + 723 + ], + "score": 1.0, + "content": "audio data, helping to improve its accuracy and efficacy. Our model obtains bpb of 3.477, much", + "type": "text" + } + ], + "index": 56 + }, + { + "bbox": [ + 106, + 171, + 505, + 183 + ], + "spans": [ + { + "bbox": [ + 106, + 171, + 505, + 183 + ], + "score": 1.0, + "content": "lower than the results with perceiverAR (3.543) and vanilla transformer model (3.567). More ablation", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 182, + 235, + 194 + ], + "spans": [ + { + "bbox": [ + 105, + 182, + 235, + 194 + ], + "score": 1.0, + "content": "results are presented in Table 6.", + "type": "text", + "cross_page": true + } + ], + "index": 7 + } + ], + "index": 54, + "bbox_fs": [ + 105, + 667, + 506, + 723 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 196, + 70, + 416, + 122 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 196, + 70, + 416, + 122 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 196, + 70, + 416, + 122 + ], + "spans": [ + { + "bbox": [ + 196, + 70, + 416, + 122 + ], + "score": 0.975, + "html": "
Global Size(Local) SizebpbGeneration Time (s)
Transformer1350M1.064132
MEGABYTE1.3B218M0.99193
", + "type": "table", + "image_path": "c7536b82290dc2757e2c61030a57add8f530d47ea0bd26a834ae8757386eee33.jpg" + } + ] + } + ], + "index": 1.5, + "virtual_lines": [ + { + "bbox": [ + 196, + 70, + 416, + 83.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 196, + 83.0, + 416, + 96.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 196, + 96.0, + 416, + 109.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 196, + 109.0, + 416, + 122.0 + ], + "spans": [], + "index": 3 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 104, + 123, + 504, + 142 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 121, + 505, + 133 + ], + "spans": [ + { + "bbox": [ + 105, + 121, + 505, + 133 + ], + "score": 1.0, + "content": "Table 5: Comparison of bits per byte (bpb) and generation speed of 8192 bytes of transformer model (with", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 132, + 401, + 142 + ], + "spans": [ + { + "bbox": [ + 105, + 132, + 401, + 142 + ], + "score": 1.0, + "content": "context length 1024) and MEGABYTE with context length 8192 and patch size 8.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5 + } + ], + "index": 3.0 + }, + { + "type": "text", + "bbox": [ + 105, + 171, + 504, + 193 + ], + "lines": [ + { + "bbox": [ + 106, + 171, + 505, + 183 + ], + "spans": [ + { + "bbox": [ + 106, + 171, + 505, + 183 + ], + "score": 1.0, + "content": "lower than the results with perceiverAR (3.543) and vanilla transformer model (3.567). More ablation", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 182, + 235, + 194 + ], + "spans": [ + { + "bbox": [ + 105, + 182, + 235, + 194 + ], + "score": 1.0, + "content": "results are presented in Table 6.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6.5 + }, + { + "type": "title", + "bbox": [ + 106, + 203, + 169, + 217 + ], + "lines": [ + { + "bbox": [ + 104, + 201, + 171, + 221 + ], + "spans": [ + { + "bbox": [ + 104, + 201, + 171, + 221 + ], + "score": 1.0, + "content": "8 Analysis", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 106, + 222, + 504, + 245 + ], + "lines": [ + { + "bbox": [ + 105, + 221, + 505, + 237 + ], + "spans": [ + { + "bbox": [ + 105, + 221, + 505, + 237 + ], + "score": 1.0, + "content": "We study different behaviors of MEGABYTE. All experiments in the same group use the same", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 234, + 147, + 248 + ], + "spans": [ + { + "bbox": [ + 105, + 234, + 147, + 248 + ], + "score": 1.0, + "content": "compute.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9.5 + }, + { + "type": "text", + "bbox": [ + 106, + 252, + 505, + 339 + ], + "lines": [ + { + "bbox": [ + 106, + 251, + 506, + 264 + ], + "spans": [ + { + "bbox": [ + 106, + 251, + 506, + 264 + ], + "score": 1.0, + "content": "Generation speed We also compare the text generation speed between MEGABYTE and a trans-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 262, + 505, + 274 + ], + "spans": [ + { + "bbox": [ + 105, + 262, + 505, + 274 + ], + "score": 1.0, + "content": "former. We compare a 350M parameter baseline transfomer and a MEGABYTE model with a 1.3B", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 273, + 506, + 287 + ], + "spans": [ + { + "bbox": [ + 105, + 273, + 506, + 287 + ], + "score": 1.0, + "content": "parameter Global model and a 218M parameter local model, trained on PG19 with equal compute.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 284, + 506, + 297 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 506, + 297 + ], + "score": 1.0, + "content": "As shown in Table 5, the MEGABYTE model achieves much lower perplexity as expected. However,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 294, + 506, + 309 + ], + "spans": [ + { + "bbox": [ + 105, + 294, + 327, + 309 + ], + "score": 1.0, + "content": "MEGABYTE also generates a sequence of 8192 tokens", + "type": "text" + }, + { + "bbox": [ + 327, + 295, + 347, + 306 + ], + "score": 0.84, + "content": "40 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 294, + 506, + 309 + ], + "score": 1.0, + "content": "faster than transformer, despite having", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 307, + 505, + 318 + ], + "spans": [ + { + "bbox": [ + 106, + 307, + 505, + 318 + ], + "score": 1.0, + "content": "over 4 times the parameters. This speed up is due to the bulk of the parameters being in the Global", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 317, + 505, + 329 + ], + "spans": [ + { + "bbox": [ + 106, + 317, + 505, + 329 + ], + "score": 1.0, + "content": "model, which only needs to be computed once for every 8 tokens, whereas all the parameters in the", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 328, + 268, + 340 + ], + "spans": [ + { + "bbox": [ + 105, + 328, + 268, + 340 + ], + "score": 1.0, + "content": "baseline model are used on every token.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 14.5 + }, + { + "type": "text", + "bbox": [ + 106, + 345, + 505, + 434 + ], + "lines": [ + { + "bbox": [ + 105, + 345, + 505, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 345, + 505, + 358 + ], + "score": 1.0, + "content": "Model Components In Table 6, we analyze the significance of different components in the", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 357, + 505, + 369 + ], + "spans": [ + { + "bbox": [ + 106, + 357, + 505, + 369 + ], + "score": 1.0, + "content": "MEGABYTE architecture by studying arXiv, Librilight-L and ImageNet256 datasets. Removing Local", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 368, + 505, + 380 + ], + "spans": [ + { + "bbox": [ + 106, + 368, + 505, + 380 + ], + "score": 1.0, + "content": "(w/o local model) or global (w/o global model) model, we observe a substantial increase in bpb on all", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 379, + 506, + 391 + ], + "spans": [ + { + "bbox": [ + 106, + 379, + 506, + 391 + ], + "score": 1.0, + "content": "datasets, showing that both parts are crucial. The performance of the model without the cross-patch", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 390, + 506, + 402 + ], + "spans": [ + { + "bbox": [ + 106, + 390, + 506, + 402 + ], + "score": 1.0, + "content": "local model (w/o cross-patch local model) is competitive, indicating that the architecture is robust to", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 399, + 505, + 414 + ], + "spans": [ + { + "bbox": [ + 105, + 399, + 505, + 414 + ], + "score": 1.0, + "content": "this modification. We observe slight improvement on the Librilight-L and ImageNet256 datasets by", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 412, + 505, + 424 + ], + "spans": [ + { + "bbox": [ + 106, + 412, + 505, + 424 + ], + "score": 1.0, + "content": "augmenting the MEGABYTE model with a CNN encoder (w/ CNN encoder). This suggests that the", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 422, + 461, + 435 + ], + "spans": [ + { + "bbox": [ + 105, + 422, + 461, + 435 + ], + "score": 1.0, + "content": "MEGABYTE architecture can benefit from integrating alternative encoding mechanisms.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 106, + 440, + 505, + 473 + ], + "lines": [ + { + "bbox": [ + 105, + 439, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 439, + 505, + 453 + ], + "score": 1.0, + "content": "Effective Use of Context Long-context models often struggle to benefit from the full context (Sun", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 451, + 506, + 463 + ], + "spans": [ + { + "bbox": [ + 106, + 451, + 506, + 463 + ], + "score": 1.0, + "content": "et al., 2021). Figure 7 shows that later tokens within each context window have a higher likelihood,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 461, + 491, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 461, + 491, + 475 + ], + "score": 1.0, + "content": "indicating that MEGABYTE can effectively use at least 8k bytes of context on the PG19 dataset.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28 + }, + { + "type": "table", + "bbox": [ + 106, + 493, + 315, + 560 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 106, + 493, + 315, + 560 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 493, + 315, + 560 + ], + "spans": [ + { + "bbox": [ + 106, + 493, + 315, + 560 + ], + "score": 0.702, + "html": "
ArxivAudioImage256
MEGABYTE0.68713.4773.158
w/o local model1.2635.9554.768
w/o global model1.3733.6593.181
w/o cross-patch attention0.67813.4813.259
w/ CNN encoder0.68713.4753.155
", + "type": "table", + "image_path": "ab22e4f8ecf30b34edaca7aa157b6adb491be69b7e9f57abb1daef5643bd685d.jpg" + } + ] + } + ], + "index": 32, + "virtual_lines": [ + { + "bbox": [ + 106, + 493, + 315, + 506.4 + ], + "spans": [], + "index": 30 + }, + { + "bbox": [ + 106, + 506.4, + 315, + 519.8 + ], + "spans": [], + "index": 31 + }, + { + "bbox": [ + 106, + 519.8, + 315, + 533.1999999999999 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 106, + 533.1999999999999, + 315, + 546.5999999999999 + ], + "spans": [], + "index": 33 + }, + { + "bbox": [ + 106, + 546.5999999999999, + 315, + 559.9999999999999 + ], + "spans": [], + "index": 34 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 106, + 560, + 315, + 589 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 558, + 317, + 570 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 317, + 570 + ], + "score": 1.0, + "content": "Table 6: Ablation of MEGABYTE model components.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 568, + 315, + 580 + ], + "spans": [ + { + "bbox": [ + 106, + 568, + 315, + 580 + ], + "score": 1.0, + "content": "Models with the same dataset are trained using the same", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 579, + 300, + 589 + ], + "spans": [ + { + "bbox": [ + 106, + 579, + 300, + 589 + ], + "score": 1.0, + "content": "compute. The hyperparameters are listed in Table 12.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36 + } + ], + "index": 34.0 + }, + { + "type": "image", + "bbox": [ + 339, + 486, + 501, + 568 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 339, + 486, + 501, + 568 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 339, + 486, + 501, + 568 + ], + "spans": [ + { + "bbox": [ + 339, + 486, + 501, + 568 + ], + "score": 0.966, + "type": "image", + "image_path": "90c84fe96cac33e09d97caa58837c9c14e67b272857b7839b989a5774524a4fd.jpg" + } + ] + } + ], + "index": 40.5, + "virtual_lines": [ + { + "bbox": [ + 339, + 486, + 501, + 499.6666666666667 + ], + "spans": [], + "index": 38 + }, + { + "bbox": [ + 339, + 499.6666666666667, + 501, + 513.3333333333334 + ], + "spans": [], + "index": 39 + }, + { + "bbox": [ + 339, + 513.3333333333334, + 501, + 527.0 + ], + "spans": [], + "index": 40 + }, + { + "bbox": [ + 339, + 527.0, + 501, + 540.6666666666666 + ], + "spans": [], + "index": 41 + }, + { + "bbox": [ + 339, + 540.6666666666666, + 501, + 554.3333333333333 + ], + "spans": [], + "index": 42 + }, + { + "bbox": [ + 339, + 554.3333333333333, + 501, + 567.9999999999999 + ], + "spans": [], + "index": 43 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 336, + 570, + 505, + 610 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 335, + 568, + 506, + 581 + ], + "spans": [ + { + "bbox": [ + 335, + 568, + 506, + 581 + ], + "score": 1.0, + "content": "Table 7: Average log probability assigned to", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 335, + 579, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 335, + 579, + 505, + 590 + ], + "score": 1.0, + "content": "different positions within the context length", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 335, + 589, + 506, + 601 + ], + "spans": [ + { + "bbox": [ + 335, + 589, + 506, + 601 + ], + "score": 1.0, + "content": "by MEGABYTE and by a vanilla transformer", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 335, + 598, + 425, + 610 + ], + "spans": [ + { + "bbox": [ + 335, + 598, + 425, + 610 + ], + "score": 1.0, + "content": "model on PG19 test set.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 45.5 + } + ], + "index": 43.0 + }, + { + "type": "image", + "bbox": [ + 109, + 612, + 308, + 663 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 109, + 612, + 308, + 663 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 612, + 308, + 663 + ], + "spans": [ + { + "bbox": [ + 109, + 612, + 308, + 663 + ], + "score": 0.953, + "type": "image", + "image_path": "1b1ce533147ed97a72fa744e530bc7463349ed2c77c8a979df6b2807e63b709d.jpg" + } + ] + } + ], + "index": 49.5, + "virtual_lines": [ + { + "bbox": [ + 109, + 612, + 308, + 624.75 + ], + "spans": [], + "index": 48 + }, + { + "bbox": [ + 109, + 624.75, + 308, + 637.5 + ], + "spans": [], + "index": 49 + }, + { + "bbox": [ + 109, + 637.5, + 308, + 650.25 + ], + "spans": [], + "index": 50 + }, + { + "bbox": [ + 109, + 650.25, + 308, + 663.0 + ], + "spans": [], + "index": 51 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 667, + 314, + 708 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 666, + 315, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 315, + 677 + ], + "score": 1.0, + "content": "Table 8: An illustration of strided inference with patch", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 106, + 677, + 315, + 687 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 315, + 687 + ], + "score": 1.0, + "content": "size 8. Blue and yellow represents two inferences that", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 105, + 687, + 315, + 697 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 315, + 697 + ], + "score": 1.0, + "content": "are shifted by half patch size. Solid line indicates final", + "type": "text" + } + ], + "index": 54 + }, + { + "bbox": [ + 105, + 696, + 283, + 708 + ], + "spans": [ + { + "bbox": [ + 105, + 696, + 283, + 708 + ], + "score": 1.0, + "content": "probablity being taking during strided inference.", + "type": "text" + } + ], + "index": 55 + } + ], + "index": 53.5 + } + ], + "index": 51.5 + }, + { + "type": "table", + "bbox": [ + 336, + 623, + 512, + 681 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 336, + 623, + 512, + 681 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 336, + 623, + 512, + 681 + ], + "spans": [ + { + "bbox": [ + 336, + 623, + 512, + 681 + ], + "score": 0.973, + "html": "
MethodInference Costbpb
Basic Inference1X0.9079
w/ Sliding Window2X0.8918
w/ Strided Inference2X0.8926
w/ Sliding& Strided4X0.8751
", + "type": "table", + "image_path": "2cdc9284060898074f51abd884273406d009861919534b8294b6270839317992.jpg" + } + ] + } + ], + "index": 57.5, + "virtual_lines": [ + { + "bbox": [ + 336, + 623, + 512, + 637.5 + ], + "spans": [], + "index": 56 + }, + { + "bbox": [ + 336, + 637.5, + 512, + 652.0 + ], + "spans": [], + "index": 57 + }, + { + "bbox": [ + 336, + 652.0, + 512, + 666.5 + ], + "spans": [], + "index": 58 + }, + { + "bbox": [ + 336, + 666.5, + 512, + 681.0 + ], + "spans": [], + "index": 59 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 336, + 682, + 506, + 711 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 335, + 680, + 506, + 691 + ], + "spans": [ + { + "bbox": [ + 335, + 680, + 506, + 691 + ], + "score": 1.0, + "content": "Table 9: Performance of various inference tech-", + "type": "text" + } + ], + "index": 60 + }, + { + "bbox": [ + 335, + 690, + 505, + 701 + ], + "spans": [ + { + "bbox": [ + 335, + 690, + 505, + 701 + ], + "score": 1.0, + "content": "niques on the PG19 test set using our best", + "type": "text" + } + ], + "index": 61 + }, + { + "bbox": [ + 336, + 700, + 412, + 710 + ], + "spans": [ + { + "bbox": [ + 336, + 700, + 412, + 710 + ], + "score": 1.0, + "content": "MEGABYTE model.", + "type": "text" + } + ], + "index": 62 + } + ], + "index": 61 + } + ], + "index": 59.25 + } + ], + "page_idx": 7, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 742, + 308, + 750 + ], + "lines": [ + { + "bbox": [ + 301, + 740, + 310, + 752 + ], + "spans": [ + { + "bbox": [ + 301, + 740, + 310, + 752 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 12, + "width": 9 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 196, + 70, + 416, + 122 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 196, + 70, + 416, + 122 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 196, + 70, + 416, + 122 + ], + "spans": [ + { + "bbox": [ + 196, + 70, + 416, + 122 + ], + "score": 0.975, + "html": "
Global Size(Local) SizebpbGeneration Time (s)
Transformer1350M1.064132
MEGABYTE1.3B218M0.99193
", + "type": "table", + "image_path": "c7536b82290dc2757e2c61030a57add8f530d47ea0bd26a834ae8757386eee33.jpg" + } + ] + } + ], + "index": 1.5, + "virtual_lines": [ + { + "bbox": [ + 196, + 70, + 416, + 83.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 196, + 83.0, + 416, + 96.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 196, + 96.0, + 416, + 109.0 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 196, + 109.0, + 416, + 122.0 + ], + "spans": [], + "index": 3 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 104, + 123, + 504, + 142 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 121, + 505, + 133 + ], + "spans": [ + { + "bbox": [ + 105, + 121, + 505, + 133 + ], + "score": 1.0, + "content": "Table 5: Comparison of bits per byte (bpb) and generation speed of 8192 bytes of transformer model (with", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 132, + 401, + 142 + ], + "spans": [ + { + "bbox": [ + 105, + 132, + 401, + 142 + ], + "score": 1.0, + "content": "context length 1024) and MEGABYTE with context length 8192 and patch size 8.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5 + } + ], + "index": 3.0 + }, + { + "type": "text", + "bbox": [ + 105, + 171, + 504, + 193 + ], + "lines": [], + "index": 6.5, + "bbox_fs": [ + 105, + 171, + 505, + 194 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 106, + 203, + 169, + 217 + ], + "lines": [ + { + "bbox": [ + 104, + 201, + 171, + 221 + ], + "spans": [ + { + "bbox": [ + 104, + 201, + 171, + 221 + ], + "score": 1.0, + "content": "8 Analysis", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + }, + { + "type": "text", + "bbox": [ + 106, + 222, + 504, + 245 + ], + "lines": [ + { + "bbox": [ + 105, + 221, + 505, + 237 + ], + "spans": [ + { + "bbox": [ + 105, + 221, + 505, + 237 + ], + "score": 1.0, + "content": "We study different behaviors of MEGABYTE. All experiments in the same group use the same", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 234, + 147, + 248 + ], + "spans": [ + { + "bbox": [ + 105, + 234, + 147, + 248 + ], + "score": 1.0, + "content": "compute.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9.5, + "bbox_fs": [ + 105, + 221, + 505, + 248 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 252, + 505, + 339 + ], + "lines": [ + { + "bbox": [ + 106, + 251, + 506, + 264 + ], + "spans": [ + { + "bbox": [ + 106, + 251, + 506, + 264 + ], + "score": 1.0, + "content": "Generation speed We also compare the text generation speed between MEGABYTE and a trans-", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 262, + 505, + 274 + ], + "spans": [ + { + "bbox": [ + 105, + 262, + 505, + 274 + ], + "score": 1.0, + "content": "former. We compare a 350M parameter baseline transfomer and a MEGABYTE model with a 1.3B", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 273, + 506, + 287 + ], + "spans": [ + { + "bbox": [ + 105, + 273, + 506, + 287 + ], + "score": 1.0, + "content": "parameter Global model and a 218M parameter local model, trained on PG19 with equal compute.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 284, + 506, + 297 + ], + "spans": [ + { + "bbox": [ + 105, + 284, + 506, + 297 + ], + "score": 1.0, + "content": "As shown in Table 5, the MEGABYTE model achieves much lower perplexity as expected. However,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 294, + 506, + 309 + ], + "spans": [ + { + "bbox": [ + 105, + 294, + 327, + 309 + ], + "score": 1.0, + "content": "MEGABYTE also generates a sequence of 8192 tokens", + "type": "text" + }, + { + "bbox": [ + 327, + 295, + 347, + 306 + ], + "score": 0.84, + "content": "40 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 347, + 294, + 506, + 309 + ], + "score": 1.0, + "content": "faster than transformer, despite having", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 307, + 505, + 318 + ], + "spans": [ + { + "bbox": [ + 106, + 307, + 505, + 318 + ], + "score": 1.0, + "content": "over 4 times the parameters. This speed up is due to the bulk of the parameters being in the Global", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 317, + 505, + 329 + ], + "spans": [ + { + "bbox": [ + 106, + 317, + 505, + 329 + ], + "score": 1.0, + "content": "model, which only needs to be computed once for every 8 tokens, whereas all the parameters in the", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 328, + 268, + 340 + ], + "spans": [ + { + "bbox": [ + 105, + 328, + 268, + 340 + ], + "score": 1.0, + "content": "baseline model are used on every token.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 14.5, + "bbox_fs": [ + 105, + 251, + 506, + 340 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 345, + 505, + 434 + ], + "lines": [ + { + "bbox": [ + 105, + 345, + 505, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 345, + 505, + 358 + ], + "score": 1.0, + "content": "Model Components In Table 6, we analyze the significance of different components in the", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 357, + 505, + 369 + ], + "spans": [ + { + "bbox": [ + 106, + 357, + 505, + 369 + ], + "score": 1.0, + "content": "MEGABYTE architecture by studying arXiv, Librilight-L and ImageNet256 datasets. Removing Local", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 368, + 505, + 380 + ], + "spans": [ + { + "bbox": [ + 106, + 368, + 505, + 380 + ], + "score": 1.0, + "content": "(w/o local model) or global (w/o global model) model, we observe a substantial increase in bpb on all", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 379, + 506, + 391 + ], + "spans": [ + { + "bbox": [ + 106, + 379, + 506, + 391 + ], + "score": 1.0, + "content": "datasets, showing that both parts are crucial. The performance of the model without the cross-patch", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 390, + 506, + 402 + ], + "spans": [ + { + "bbox": [ + 106, + 390, + 506, + 402 + ], + "score": 1.0, + "content": "local model (w/o cross-patch local model) is competitive, indicating that the architecture is robust to", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 399, + 505, + 414 + ], + "spans": [ + { + "bbox": [ + 105, + 399, + 505, + 414 + ], + "score": 1.0, + "content": "this modification. We observe slight improvement on the Librilight-L and ImageNet256 datasets by", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 412, + 505, + 424 + ], + "spans": [ + { + "bbox": [ + 106, + 412, + 505, + 424 + ], + "score": 1.0, + "content": "augmenting the MEGABYTE model with a CNN encoder (w/ CNN encoder). This suggests that the", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 422, + 461, + 435 + ], + "spans": [ + { + "bbox": [ + 105, + 422, + 461, + 435 + ], + "score": 1.0, + "content": "MEGABYTE architecture can benefit from integrating alternative encoding mechanisms.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 22.5, + "bbox_fs": [ + 105, + 345, + 506, + 435 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 440, + 505, + 473 + ], + "lines": [ + { + "bbox": [ + 105, + 439, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 105, + 439, + 505, + 453 + ], + "score": 1.0, + "content": "Effective Use of Context Long-context models often struggle to benefit from the full context (Sun", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 451, + 506, + 463 + ], + "spans": [ + { + "bbox": [ + 106, + 451, + 506, + 463 + ], + "score": 1.0, + "content": "et al., 2021). Figure 7 shows that later tokens within each context window have a higher likelihood,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 461, + 491, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 461, + 491, + 475 + ], + "score": 1.0, + "content": "indicating that MEGABYTE can effectively use at least 8k bytes of context on the PG19 dataset.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 28, + "bbox_fs": [ + 105, + 439, + 506, + 475 + ] + }, + { + "type": "table", + "bbox": [ + 106, + 493, + 315, + 560 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 106, + 493, + 315, + 560 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 493, + 315, + 560 + ], + "spans": [ + { + "bbox": [ + 106, + 493, + 315, + 560 + ], + "score": 0.702, + "html": "
ArxivAudioImage256
MEGABYTE0.68713.4773.158
w/o local model1.2635.9554.768
w/o global model1.3733.6593.181
w/o cross-patch attention0.67813.4813.259
w/ CNN encoder0.68713.4753.155
", + "type": "table", + "image_path": "ab22e4f8ecf30b34edaca7aa157b6adb491be69b7e9f57abb1daef5643bd685d.jpg" + } + ] + } + ], + "index": 32, + "virtual_lines": [ + { + "bbox": [ + 106, + 493, + 315, + 506.4 + ], + "spans": [], + "index": 30 + }, + { + "bbox": [ + 106, + 506.4, + 315, + 519.8 + ], + "spans": [], + "index": 31 + }, + { + "bbox": [ + 106, + 519.8, + 315, + 533.1999999999999 + ], + "spans": [], + "index": 32 + }, + { + "bbox": [ + 106, + 533.1999999999999, + 315, + 546.5999999999999 + ], + "spans": [], + "index": 33 + }, + { + "bbox": [ + 106, + 546.5999999999999, + 315, + 559.9999999999999 + ], + "spans": [], + "index": 34 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 106, + 560, + 315, + 589 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 105, + 558, + 317, + 570 + ], + "spans": [ + { + "bbox": [ + 105, + 558, + 317, + 570 + ], + "score": 1.0, + "content": "Table 6: Ablation of MEGABYTE model components.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 568, + 315, + 580 + ], + "spans": [ + { + "bbox": [ + 106, + 568, + 315, + 580 + ], + "score": 1.0, + "content": "Models with the same dataset are trained using the same", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 579, + 300, + 589 + ], + "spans": [ + { + "bbox": [ + 106, + 579, + 300, + 589 + ], + "score": 1.0, + "content": "compute. The hyperparameters are listed in Table 12.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 36 + } + ], + "index": 34.0 + }, + { + "type": "image", + "bbox": [ + 339, + 486, + 501, + 568 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 339, + 486, + 501, + 568 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 339, + 486, + 501, + 568 + ], + "spans": [ + { + "bbox": [ + 339, + 486, + 501, + 568 + ], + "score": 0.966, + "type": "image", + "image_path": "90c84fe96cac33e09d97caa58837c9c14e67b272857b7839b989a5774524a4fd.jpg" + } + ] + } + ], + "index": 40.5, + "virtual_lines": [ + { + "bbox": [ + 339, + 486, + 501, + 499.6666666666667 + ], + "spans": [], + "index": 38 + }, + { + "bbox": [ + 339, + 499.6666666666667, + 501, + 513.3333333333334 + ], + "spans": [], + "index": 39 + }, + { + "bbox": [ + 339, + 513.3333333333334, + 501, + 527.0 + ], + "spans": [], + "index": 40 + }, + { + "bbox": [ + 339, + 527.0, + 501, + 540.6666666666666 + ], + "spans": [], + "index": 41 + }, + { + "bbox": [ + 339, + 540.6666666666666, + 501, + 554.3333333333333 + ], + "spans": [], + "index": 42 + }, + { + "bbox": [ + 339, + 554.3333333333333, + 501, + 567.9999999999999 + ], + "spans": [], + "index": 43 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 336, + 570, + 505, + 610 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 335, + 568, + 506, + 581 + ], + "spans": [ + { + "bbox": [ + 335, + 568, + 506, + 581 + ], + "score": 1.0, + "content": "Table 7: Average log probability assigned to", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 335, + 579, + 505, + 590 + ], + "spans": [ + { + "bbox": [ + 335, + 579, + 505, + 590 + ], + "score": 1.0, + "content": "different positions within the context length", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 335, + 589, + 506, + 601 + ], + "spans": [ + { + "bbox": [ + 335, + 589, + 506, + 601 + ], + "score": 1.0, + "content": "by MEGABYTE and by a vanilla transformer", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 335, + 598, + 425, + 610 + ], + "spans": [ + { + "bbox": [ + 335, + 598, + 425, + 610 + ], + "score": 1.0, + "content": "model on PG19 test set.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 45.5 + } + ], + "index": 43.0 + }, + { + "type": "image", + "bbox": [ + 109, + 612, + 308, + 663 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 109, + 612, + 308, + 663 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 109, + 612, + 308, + 663 + ], + "spans": [ + { + "bbox": [ + 109, + 612, + 308, + 663 + ], + "score": 0.953, + "type": "image", + "image_path": "1b1ce533147ed97a72fa744e530bc7463349ed2c77c8a979df6b2807e63b709d.jpg" + } + ] + } + ], + "index": 49.5, + "virtual_lines": [ + { + "bbox": [ + 109, + 612, + 308, + 624.75 + ], + "spans": [], + "index": 48 + }, + { + "bbox": [ + 109, + 624.75, + 308, + 637.5 + ], + "spans": [], + "index": 49 + }, + { + "bbox": [ + 109, + 637.5, + 308, + 650.25 + ], + "spans": [], + "index": 50 + }, + { + "bbox": [ + 109, + 650.25, + 308, + 663.0 + ], + "spans": [], + "index": 51 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 106, + 667, + 314, + 708 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 666, + 315, + 677 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 315, + 677 + ], + "score": 1.0, + "content": "Table 8: An illustration of strided inference with patch", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 106, + 677, + 315, + 687 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 315, + 687 + ], + "score": 1.0, + "content": "size 8. Blue and yellow represents two inferences that", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 105, + 687, + 315, + 697 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 315, + 697 + ], + "score": 1.0, + "content": "are shifted by half patch size. Solid line indicates final", + "type": "text" + } + ], + "index": 54 + }, + { + "bbox": [ + 105, + 696, + 283, + 708 + ], + "spans": [ + { + "bbox": [ + 105, + 696, + 283, + 708 + ], + "score": 1.0, + "content": "probablity being taking during strided inference.", + "type": "text" + } + ], + "index": 55 + } + ], + "index": 53.5 + } + ], + "index": 51.5 + }, + { + "type": "table", + "bbox": [ + 336, + 623, + 512, + 681 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 336, + 623, + 512, + 681 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 336, + 623, + 512, + 681 + ], + "spans": [ + { + "bbox": [ + 336, + 623, + 512, + 681 + ], + "score": 0.973, + "html": "
MethodInference Costbpb
Basic Inference1X0.9079
w/ Sliding Window2X0.8918
w/ Strided Inference2X0.8926
w/ Sliding& Strided4X0.8751
", + "type": "table", + "image_path": "2cdc9284060898074f51abd884273406d009861919534b8294b6270839317992.jpg" + } + ] + } + ], + "index": 57.5, + "virtual_lines": [ + { + "bbox": [ + 336, + 623, + 512, + 637.5 + ], + "spans": [], + "index": 56 + }, + { + "bbox": [ + 336, + 637.5, + 512, + 652.0 + ], + "spans": [], + "index": 57 + }, + { + "bbox": [ + 336, + 652.0, + 512, + 666.5 + ], + "spans": [], + "index": 58 + }, + { + "bbox": [ + 336, + 666.5, + 512, + 681.0 + ], + "spans": [], + "index": 59 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 336, + 682, + 506, + 711 + ], + "group_id": 2, + "lines": [ + { + "bbox": [ + 335, + 680, + 506, + 691 + ], + "spans": [ + { + "bbox": [ + 335, + 680, + 506, + 691 + ], + "score": 1.0, + "content": "Table 9: Performance of various inference tech-", + "type": "text" + } + ], + "index": 60 + }, + { + "bbox": [ + 335, + 690, + 505, + 701 + ], + "spans": [ + { + "bbox": [ + 335, + 690, + 505, + 701 + ], + "score": 1.0, + "content": "niques on the PG19 test set using our best", + "type": "text" + } + ], + "index": 61 + }, + { + "bbox": [ + 336, + 700, + 412, + 710 + ], + "spans": [ + { + "bbox": [ + 336, + 700, + 412, + 710 + ], + "score": 1.0, + "content": "MEGABYTE model.", + "type": "text" + } + ], + "index": 62 + } + ], + "index": 61 + } + ], + "index": 59.25 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 72, + 505, + 128 + ], + "lines": [ + { + "bbox": [ + 106, + 73, + 505, + 85 + ], + "spans": [ + { + "bbox": [ + 106, + 73, + 505, + 85 + ], + "score": 1.0, + "content": "Strided Inference We find that within a single patch, on average, the MEGABYTE performs worse", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 84, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 84, + 506, + 96 + ], + "score": 1.0, + "content": "on later tokens within a patch (see Figure 8). Section 2.3 proposes strided inference as a solution,", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 93, + 506, + 108 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 311, + 108 + ], + "score": 1.0, + "content": "where two forward passes are performed offset by", + "type": "text" + }, + { + "bbox": [ + 312, + 93, + 321, + 108 + ], + "score": 0.88, + "content": "\\textstyle { \\frac { P } { 2 } }", + "type": "inline_equation" + }, + { + "bbox": [ + 321, + 93, + 506, + 108 + ], + "score": 1.0, + "content": "tokens, and results from the first half of each", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 105, + 505, + 119 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 505, + 119 + ], + "score": 1.0, + "content": "patch are combined. Table 9 shows performance improvements from strided inference, which are", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 117, + 277, + 128 + ], + "spans": [ + { + "bbox": [ + 106, + 117, + 277, + 128 + ], + "score": 1.0, + "content": "additive with the standard sliding window.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 2 + }, + { + "type": "text", + "bbox": [ + 106, + 132, + 504, + 166 + ], + "lines": [ + { + "bbox": [ + 104, + 130, + 506, + 147 + ], + "spans": [ + { + "bbox": [ + 104, + 130, + 506, + 147 + ], + "score": 1.0, + "content": "Patch Size. We experimented with various patch sizes on Image256 dataset and found a wide range", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 144, + 505, + 156 + ], + "spans": [ + { + "bbox": [ + 106, + 144, + 505, + 156 + ], + "score": 1.0, + "content": "of values where MEGABYTE performs similarly. We found similar robustness to patch size choices", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 155, + 481, + 167 + ], + "spans": [ + { + "bbox": [ + 106, + 155, + 481, + 167 + ], + "score": 1.0, + "content": "across all modalities, although the optimal patch size itself can be different across modalities.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 107, + 171, + 505, + 226 + ], + "lines": [ + { + "bbox": [ + 106, + 171, + 505, + 183 + ], + "spans": [ + { + "bbox": [ + 106, + 171, + 505, + 183 + ], + "score": 1.0, + "content": "Local to Global model Size Ratio. We experimented with different Local/Global model size ratios", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 182, + 505, + 194 + ], + "spans": [ + { + "bbox": [ + 106, + 182, + 424, + 194 + ], + "score": 1.0, + "content": "on PG19 dataset. By grouping bytes into patches, MEGABYTE effectively uses", + "type": "text" + }, + { + "bbox": [ + 425, + 182, + 434, + 192 + ], + "score": 0.8, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 434, + 182, + 505, + 194 + ], + "score": 1.0, + "content": "times less tokens", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 192, + 505, + 205 + ], + "spans": [ + { + "bbox": [ + 105, + 192, + 505, + 205 + ], + "score": 1.0, + "content": "for the Global model as on the Local model—enabling us to increase the size of the Global model", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 202, + 506, + 217 + ], + "spans": [ + { + "bbox": [ + 105, + 202, + 506, + 217 + ], + "score": 1.0, + "content": "with reduced cost. We find that a given compute budget is spent optimally when the Global model is", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 215, + 452, + 227 + ], + "spans": [ + { + "bbox": [ + 106, + 215, + 452, + 227 + ], + "score": 1.0, + "content": "larger than the Local model, consistently across all modalities and various patch sizes.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10 + }, + { + "type": "table", + "bbox": [ + 111, + 240, + 277, + 288 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 111, + 240, + 277, + 288 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 111, + 240, + 277, + 288 + ], + "spans": [ + { + "bbox": [ + 111, + 240, + 277, + 288 + ], + "score": 0.971, + "html": "
PatchGlobal SizeLocal Sizebpb
48125M114M (L=11)3.178
192125M125M (L=12)3.158
768125M83M(L=8)3.186
", + "type": "table", + "image_path": "b1f43e98a431f09037b9c4f7905b9094376f622781db1ac5c49e012f89191520.jpg" + } + ] + } + ], + "index": 15, + "virtual_lines": [ + { + "bbox": [ + 111, + 240, + 277, + 256.0 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 111, + 256.0, + 277, + 272.0 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 111, + 272.0, + 277, + 288.0 + ], + "spans": [], + "index": 17 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 111, + 289, + 273, + 318 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 110, + 287, + 273, + 298 + ], + "spans": [ + { + "bbox": [ + 110, + 287, + 273, + 298 + ], + "score": 1.0, + "content": "Table 10: Effects of patch size on perfor-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 110, + 297, + 272, + 308 + ], + "spans": [ + { + "bbox": [ + 110, + 297, + 272, + 308 + ], + "score": 1.0, + "content": "mance on the Image256 dataset. All versions", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 110, + 307, + 272, + 318 + ], + "spans": [ + { + "bbox": [ + 110, + 307, + 272, + 318 + ], + "score": 1.0, + "content": "use the same amount of GPU hours and data.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20 + } + ], + "index": 17.5 + }, + { + "type": "table", + "bbox": [ + 295, + 240, + 497, + 288 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 295, + 240, + 497, + 288 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 295, + 240, + 497, + 288 + ], + "spans": [ + { + "bbox": [ + 295, + 240, + 497, + 288 + ], + "score": 0.969, + "html": "
Global SizeLocal Sizebpb
350M (D=1024,L=24)290M (D=1024,L=20)1.014
760M (D=1536,L=24)262M (D=1024,L=18)1.002
1.3B (D=2048,L=24)218M (D=1024,L=15)0.991
", + "type": "table", + "image_path": "4efc0a7b623ddb94e7adf92c346c498c3232a0cbce63a2b1ddace9e253c9f80b.jpg" + } + ] + } + ], + "index": 16, + "virtual_lines": [ + { + "bbox": [ + 295, + 240, + 497, + 256.0 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 295, + 256.0, + 497, + 272.0 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 295, + 272.0, + 497, + 288.0 + ], + "spans": [], + "index": 18 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 291, + 288, + 500, + 318 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 291, + 288, + 500, + 298 + ], + "spans": [ + { + "bbox": [ + 291, + 288, + 500, + 298 + ], + "score": 1.0, + "content": "Table 11: Effects of Local / Global model size on the PG19", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 291, + 298, + 500, + 308 + ], + "spans": [ + { + "bbox": [ + 291, + 298, + 500, + 308 + ], + "score": 1.0, + "content": "dataset. Increasing the capacity of global model improves", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 291, + 307, + 485, + 318 + ], + "spans": [ + { + "bbox": [ + 291, + 307, + 485, + 318 + ], + "score": 1.0, + "content": "performance. Models are compute and data matched.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23 + } + ], + "index": 19.5 + }, + { + "type": "title", + "bbox": [ + 106, + 356, + 197, + 369 + ], + "lines": [ + { + "bbox": [ + 104, + 355, + 198, + 371 + ], + "spans": [ + { + "bbox": [ + 104, + 355, + 198, + 371 + ], + "score": 1.0, + "content": "9 Related Work", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 106, + 378, + 504, + 400 + ], + "lines": [ + { + "bbox": [ + 106, + 376, + 505, + 392 + ], + "spans": [ + { + "bbox": [ + 106, + 376, + 505, + 392 + ], + "score": 1.0, + "content": "Prior research has explored the possibility of improving the efficiency of Transformers on long", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 389, + 430, + 401 + ], + "spans": [ + { + "bbox": [ + 105, + 389, + 430, + 401 + ], + "score": 1.0, + "content": "sequences, primarily motivated by mitigating the quadratic cost of self-attention.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26.5 + }, + { + "type": "text", + "bbox": [ + 106, + 405, + 505, + 515 + ], + "lines": [ + { + "bbox": [ + 105, + 404, + 505, + 417 + ], + "spans": [ + { + "bbox": [ + 105, + 404, + 505, + 417 + ], + "score": 1.0, + "content": "Efficient Encoder Models Several related techniques to ours have been developed for transformer", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 414, + 506, + 430 + ], + "spans": [ + { + "bbox": [ + 105, + 414, + 506, + 430 + ], + "score": 1.0, + "content": "encoder architectures but cannot be straightforwardly applied to decoders. In particular, patchifying", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 427, + 506, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 427, + 506, + 439 + ], + "score": 1.0, + "content": "operations have previously been used in image encoder models such as ViT (Dosovitskiy et al., 2020),", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 438, + 505, + 450 + ], + "spans": [ + { + "bbox": [ + 106, + 438, + 505, + 450 + ], + "score": 1.0, + "content": "and down- and up-sampling operations have been used for text encoders (Clark et al., 2022), but such", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 450, + 505, + 461 + ], + "spans": [ + { + "bbox": [ + 106, + 450, + 505, + 461 + ], + "score": 1.0, + "content": "methods cannot be naively applied to decoder-only models without leaking information to future", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 460, + 505, + 472 + ], + "spans": [ + { + "bbox": [ + 105, + 460, + 505, + 472 + ], + "score": 1.0, + "content": "bytes in the same patch. MEGABYTE generalizes these approaches to an efficient decoder model", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 470, + 505, + 483 + ], + "spans": [ + { + "bbox": [ + 105, + 470, + 505, + 483 + ], + "score": 1.0, + "content": "by using a intra-patch transformer to predict each sequence element’s likelihood, and offseting the", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 482, + 506, + 494 + ], + "spans": [ + { + "bbox": [ + 106, + 482, + 506, + 494 + ], + "score": 1.0, + "content": "inputs to the two models to avoid leaking information. Jaegle et al. (2021) use self-attention on a", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 492, + 506, + 505 + ], + "spans": [ + { + "bbox": [ + 106, + 492, + 506, + 505 + ], + "score": 1.0, + "content": "shorter latent sequence also resembles patchification, but this technique cannot easily be applied to", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 502, + 387, + 517 + ], + "spans": [ + { + "bbox": [ + 105, + 502, + 387, + 517 + ], + "score": 1.0, + "content": "decoder architectures without leaking information to future timesteps.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 32.5 + }, + { + "type": "text", + "bbox": [ + 106, + 519, + 506, + 662 + ], + "lines": [ + { + "bbox": [ + 106, + 519, + 505, + 533 + ], + "spans": [ + { + "bbox": [ + 106, + 519, + 505, + 533 + ], + "score": 1.0, + "content": "Efficient Decoder models Improving the efficiency of decoder models is harder because of the need", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 530, + 506, + 544 + ], + "spans": [ + { + "bbox": [ + 105, + 530, + 506, + 544 + ], + "score": 1.0, + "content": "to make one prediction per timestep, and not leak information to future timesteps. The most popular", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 540, + 506, + 556 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 506, + 556 + ], + "score": 1.0, + "content": "approaches can be categorized as (1) chunking sequences into smaller blocks, and propagating", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 551, + 506, + 565 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 506, + 565 + ], + "score": 1.0, + "content": "information from previous blocks with either recurrence (Dai et al., 2019; Hutchins et al., 2022) or", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 564, + 506, + 576 + ], + "spans": [ + { + "bbox": [ + 106, + 564, + 506, + 576 + ], + "score": 1.0, + "content": "cross-attention (Hawthorne et al., 2022), (2) linear alternatives to attention, which typically involve", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 573, + 506, + 587 + ], + "spans": [ + { + "bbox": [ + 105, + 573, + 506, + 587 + ], + "score": 1.0, + "content": "forms of token-level recurrence (Katharopoulos et al., 2020) or state space models (Gu et al., 2021;", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 584, + 506, + 598 + ], + "spans": [ + { + "bbox": [ + 105, + 584, + 506, + 598 + ], + "score": 1.0, + "content": "Smith et al., 2022; Ma et al., 2022), or (3) sparse approximations of attention (Kitaev et al., 2020;", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 596, + 506, + 609 + ], + "spans": [ + { + "bbox": [ + 106, + 596, + 506, + 609 + ], + "score": 1.0, + "content": "Beltagy et al., 2020; Child et al., 2019; Wu et al., 2022). However, the performance of dense attention", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 607, + 506, + 620 + ], + "spans": [ + { + "bbox": [ + 105, + 607, + 506, + 620 + ], + "score": 1.0, + "content": "means it is typically still chosen for large scale decoders (Touvron et al., 2023; Chowdhery et al.,", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 617, + 506, + 631 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 506, + 631 + ], + "score": 1.0, + "content": "2022). MEGABYTE takes the alternative approach of decomposing the complete sequence into two", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 628, + 506, + 643 + ], + "spans": [ + { + "bbox": [ + 105, + 628, + 506, + 643 + ], + "score": 1.0, + "content": "shorter sequences, giving sub-quadratic attention. We also note that feedforward networks are the", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 106, + 640, + 506, + 653 + ], + "spans": [ + { + "bbox": [ + 106, + 640, + 506, + 653 + ], + "score": 1.0, + "content": "dominant cost in large decoders, not self-attention. Our approach to compressing sequences allows", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 649, + 507, + 664 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 507, + 664 + ], + "score": 1.0, + "content": "much larger models than would be possible when using large feedforward networks at every timestep.", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 44 + }, + { + "type": "text", + "bbox": [ + 107, + 667, + 504, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 666, + 506, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 506, + 680 + ], + "score": 1.0, + "content": "Tokenization The most common approach to shortening sequence lengths in Transformer decoders is", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 105, + 677, + 506, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 691 + ], + "score": 1.0, + "content": "to pre-process the input with a form of tokenization, in which multiple bytes are mapped to a single", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 105, + 688, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 506, + 702 + ], + "score": 1.0, + "content": "discrete token from a fixed vocabulary. For text, this can be done losslessly using methods such as", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 105, + 699, + 506, + 713 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 713 + ], + "score": 1.0, + "content": "BPE (Sennrich et al., 2015) and SentencePiece (Kudo & Richardson, 2018), but these approaches can", + "type": "text" + } + ], + "index": 54 + }, + { + "bbox": [ + 105, + 711, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 711, + 505, + 723 + ], + "score": 1.0, + "content": "require language-specific heuristics (Radford et al., 2019), limit out-of-domain performance (Sharami", + "type": "text" + } + ], + "index": 55 + } + ], + "index": 53 + } + ], + "page_idx": 8, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 302, + 741, + 308, + 750 + ], + "lines": [ + { + "bbox": [ + 302, + 741, + 309, + 752 + ], + "spans": [ + { + "bbox": [ + 302, + 741, + 309, + 752 + ], + "score": 1.0, + "content": "9", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 72, + 505, + 128 + ], + "lines": [ + { + "bbox": [ + 106, + 73, + 505, + 85 + ], + "spans": [ + { + "bbox": [ + 106, + 73, + 505, + 85 + ], + "score": 1.0, + "content": "Strided Inference We find that within a single patch, on average, the MEGABYTE performs worse", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 84, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 105, + 84, + 506, + 96 + ], + "score": 1.0, + "content": "on later tokens within a patch (see Figure 8). Section 2.3 proposes strided inference as a solution,", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 93, + 506, + 108 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 311, + 108 + ], + "score": 1.0, + "content": "where two forward passes are performed offset by", + "type": "text" + }, + { + "bbox": [ + 312, + 93, + 321, + 108 + ], + "score": 0.88, + "content": "\\textstyle { \\frac { P } { 2 } }", + "type": "inline_equation" + }, + { + "bbox": [ + 321, + 93, + 506, + 108 + ], + "score": 1.0, + "content": "tokens, and results from the first half of each", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 105, + 505, + 119 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 505, + 119 + ], + "score": 1.0, + "content": "patch are combined. Table 9 shows performance improvements from strided inference, which are", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 117, + 277, + 128 + ], + "spans": [ + { + "bbox": [ + 106, + 117, + 277, + 128 + ], + "score": 1.0, + "content": "additive with the standard sliding window.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 2, + "bbox_fs": [ + 105, + 73, + 506, + 128 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 132, + 504, + 166 + ], + "lines": [ + { + "bbox": [ + 104, + 130, + 506, + 147 + ], + "spans": [ + { + "bbox": [ + 104, + 130, + 506, + 147 + ], + "score": 1.0, + "content": "Patch Size. We experimented with various patch sizes on Image256 dataset and found a wide range", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 144, + 505, + 156 + ], + "spans": [ + { + "bbox": [ + 106, + 144, + 505, + 156 + ], + "score": 1.0, + "content": "of values where MEGABYTE performs similarly. We found similar robustness to patch size choices", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 155, + 481, + 167 + ], + "spans": [ + { + "bbox": [ + 106, + 155, + 481, + 167 + ], + "score": 1.0, + "content": "across all modalities, although the optimal patch size itself can be different across modalities.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6, + "bbox_fs": [ + 104, + 130, + 506, + 167 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 171, + 505, + 226 + ], + "lines": [ + { + "bbox": [ + 106, + 171, + 505, + 183 + ], + "spans": [ + { + "bbox": [ + 106, + 171, + 505, + 183 + ], + "score": 1.0, + "content": "Local to Global model Size Ratio. We experimented with different Local/Global model size ratios", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 182, + 505, + 194 + ], + "spans": [ + { + "bbox": [ + 106, + 182, + 424, + 194 + ], + "score": 1.0, + "content": "on PG19 dataset. By grouping bytes into patches, MEGABYTE effectively uses", + "type": "text" + }, + { + "bbox": [ + 425, + 182, + 434, + 192 + ], + "score": 0.8, + "content": "P", + "type": "inline_equation" + }, + { + "bbox": [ + 434, + 182, + 505, + 194 + ], + "score": 1.0, + "content": "times less tokens", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 192, + 505, + 205 + ], + "spans": [ + { + "bbox": [ + 105, + 192, + 505, + 205 + ], + "score": 1.0, + "content": "for the Global model as on the Local model—enabling us to increase the size of the Global model", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 202, + 506, + 217 + ], + "spans": [ + { + "bbox": [ + 105, + 202, + 506, + 217 + ], + "score": 1.0, + "content": "with reduced cost. We find that a given compute budget is spent optimally when the Global model is", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 215, + 452, + 227 + ], + "spans": [ + { + "bbox": [ + 106, + 215, + 452, + 227 + ], + "score": 1.0, + "content": "larger than the Local model, consistently across all modalities and various patch sizes.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10, + "bbox_fs": [ + 105, + 171, + 506, + 227 + ] + }, + { + "type": "table", + "bbox": [ + 111, + 240, + 277, + 288 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 111, + 240, + 277, + 288 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 111, + 240, + 277, + 288 + ], + "spans": [ + { + "bbox": [ + 111, + 240, + 277, + 288 + ], + "score": 0.971, + "html": "
PatchGlobal SizeLocal Sizebpb
48125M114M (L=11)3.178
192125M125M (L=12)3.158
768125M83M(L=8)3.186
", + "type": "table", + "image_path": "b1f43e98a431f09037b9c4f7905b9094376f622781db1ac5c49e012f89191520.jpg" + } + ] + } + ], + "index": 15, + "virtual_lines": [ + { + "bbox": [ + 111, + 240, + 277, + 256.0 + ], + "spans": [], + "index": 13 + }, + { + "bbox": [ + 111, + 256.0, + 277, + 272.0 + ], + "spans": [], + "index": 15 + }, + { + "bbox": [ + 111, + 272.0, + 277, + 288.0 + ], + "spans": [], + "index": 17 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 111, + 289, + 273, + 318 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 110, + 287, + 273, + 298 + ], + "spans": [ + { + "bbox": [ + 110, + 287, + 273, + 298 + ], + "score": 1.0, + "content": "Table 10: Effects of patch size on perfor-", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 110, + 297, + 272, + 308 + ], + "spans": [ + { + "bbox": [ + 110, + 297, + 272, + 308 + ], + "score": 1.0, + "content": "mance on the Image256 dataset. All versions", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 110, + 307, + 272, + 318 + ], + "spans": [ + { + "bbox": [ + 110, + 307, + 272, + 318 + ], + "score": 1.0, + "content": "use the same amount of GPU hours and data.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 20 + } + ], + "index": 17.5 + }, + { + "type": "table", + "bbox": [ + 295, + 240, + 497, + 288 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 295, + 240, + 497, + 288 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 295, + 240, + 497, + 288 + ], + "spans": [ + { + "bbox": [ + 295, + 240, + 497, + 288 + ], + "score": 0.969, + "html": "
Global SizeLocal Sizebpb
350M (D=1024,L=24)290M (D=1024,L=20)1.014
760M (D=1536,L=24)262M (D=1024,L=18)1.002
1.3B (D=2048,L=24)218M (D=1024,L=15)0.991
", + "type": "table", + "image_path": "4efc0a7b623ddb94e7adf92c346c498c3232a0cbce63a2b1ddace9e253c9f80b.jpg" + } + ] + } + ], + "index": 16, + "virtual_lines": [ + { + "bbox": [ + 295, + 240, + 497, + 256.0 + ], + "spans": [], + "index": 14 + }, + { + "bbox": [ + 295, + 256.0, + 497, + 272.0 + ], + "spans": [], + "index": 16 + }, + { + "bbox": [ + 295, + 272.0, + 497, + 288.0 + ], + "spans": [], + "index": 18 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 291, + 288, + 500, + 318 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 291, + 288, + 500, + 298 + ], + "spans": [ + { + "bbox": [ + 291, + 288, + 500, + 298 + ], + "score": 1.0, + "content": "Table 11: Effects of Local / Global model size on the PG19", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 291, + 298, + 500, + 308 + ], + "spans": [ + { + "bbox": [ + 291, + 298, + 500, + 308 + ], + "score": 1.0, + "content": "dataset. Increasing the capacity of global model improves", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 291, + 307, + 485, + 318 + ], + "spans": [ + { + "bbox": [ + 291, + 307, + 485, + 318 + ], + "score": 1.0, + "content": "performance. Models are compute and data matched.", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 23 + } + ], + "index": 19.5 + }, + { + "type": "title", + "bbox": [ + 106, + 356, + 197, + 369 + ], + "lines": [ + { + "bbox": [ + 104, + 355, + 198, + 371 + ], + "spans": [ + { + "bbox": [ + 104, + 355, + 198, + 371 + ], + "score": 1.0, + "content": "9 Related Work", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 25 + }, + { + "type": "text", + "bbox": [ + 106, + 378, + 504, + 400 + ], + "lines": [ + { + "bbox": [ + 106, + 376, + 505, + 392 + ], + "spans": [ + { + "bbox": [ + 106, + 376, + 505, + 392 + ], + "score": 1.0, + "content": "Prior research has explored the possibility of improving the efficiency of Transformers on long", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 389, + 430, + 401 + ], + "spans": [ + { + "bbox": [ + 105, + 389, + 430, + 401 + ], + "score": 1.0, + "content": "sequences, primarily motivated by mitigating the quadratic cost of self-attention.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26.5, + "bbox_fs": [ + 105, + 376, + 505, + 401 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 405, + 505, + 515 + ], + "lines": [ + { + "bbox": [ + 105, + 404, + 505, + 417 + ], + "spans": [ + { + "bbox": [ + 105, + 404, + 505, + 417 + ], + "score": 1.0, + "content": "Efficient Encoder Models Several related techniques to ours have been developed for transformer", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 414, + 506, + 430 + ], + "spans": [ + { + "bbox": [ + 105, + 414, + 506, + 430 + ], + "score": 1.0, + "content": "encoder architectures but cannot be straightforwardly applied to decoders. In particular, patchifying", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 427, + 506, + 439 + ], + "spans": [ + { + "bbox": [ + 105, + 427, + 506, + 439 + ], + "score": 1.0, + "content": "operations have previously been used in image encoder models such as ViT (Dosovitskiy et al., 2020),", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 438, + 505, + 450 + ], + "spans": [ + { + "bbox": [ + 106, + 438, + 505, + 450 + ], + "score": 1.0, + "content": "and down- and up-sampling operations have been used for text encoders (Clark et al., 2022), but such", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 450, + 505, + 461 + ], + "spans": [ + { + "bbox": [ + 106, + 450, + 505, + 461 + ], + "score": 1.0, + "content": "methods cannot be naively applied to decoder-only models without leaking information to future", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 460, + 505, + 472 + ], + "spans": [ + { + "bbox": [ + 105, + 460, + 505, + 472 + ], + "score": 1.0, + "content": "bytes in the same patch. MEGABYTE generalizes these approaches to an efficient decoder model", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 470, + 505, + 483 + ], + "spans": [ + { + "bbox": [ + 105, + 470, + 505, + 483 + ], + "score": 1.0, + "content": "by using a intra-patch transformer to predict each sequence element’s likelihood, and offseting the", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 482, + 506, + 494 + ], + "spans": [ + { + "bbox": [ + 106, + 482, + 506, + 494 + ], + "score": 1.0, + "content": "inputs to the two models to avoid leaking information. Jaegle et al. (2021) use self-attention on a", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 492, + 506, + 505 + ], + "spans": [ + { + "bbox": [ + 106, + 492, + 506, + 505 + ], + "score": 1.0, + "content": "shorter latent sequence also resembles patchification, but this technique cannot easily be applied to", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 502, + 387, + 517 + ], + "spans": [ + { + "bbox": [ + 105, + 502, + 387, + 517 + ], + "score": 1.0, + "content": "decoder architectures without leaking information to future timesteps.", + "type": "text" + } + ], + "index": 37 + } + ], + "index": 32.5, + "bbox_fs": [ + 105, + 404, + 506, + 517 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 519, + 506, + 662 + ], + "lines": [ + { + "bbox": [ + 106, + 519, + 505, + 533 + ], + "spans": [ + { + "bbox": [ + 106, + 519, + 505, + 533 + ], + "score": 1.0, + "content": "Efficient Decoder models Improving the efficiency of decoder models is harder because of the need", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 530, + 506, + 544 + ], + "spans": [ + { + "bbox": [ + 105, + 530, + 506, + 544 + ], + "score": 1.0, + "content": "to make one prediction per timestep, and not leak information to future timesteps. The most popular", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 540, + 506, + 556 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 506, + 556 + ], + "score": 1.0, + "content": "approaches can be categorized as (1) chunking sequences into smaller blocks, and propagating", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 551, + 506, + 565 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 506, + 565 + ], + "score": 1.0, + "content": "information from previous blocks with either recurrence (Dai et al., 2019; Hutchins et al., 2022) or", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 564, + 506, + 576 + ], + "spans": [ + { + "bbox": [ + 106, + 564, + 506, + 576 + ], + "score": 1.0, + "content": "cross-attention (Hawthorne et al., 2022), (2) linear alternatives to attention, which typically involve", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 573, + 506, + 587 + ], + "spans": [ + { + "bbox": [ + 105, + 573, + 506, + 587 + ], + "score": 1.0, + "content": "forms of token-level recurrence (Katharopoulos et al., 2020) or state space models (Gu et al., 2021;", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 105, + 584, + 506, + 598 + ], + "spans": [ + { + "bbox": [ + 105, + 584, + 506, + 598 + ], + "score": 1.0, + "content": "Smith et al., 2022; Ma et al., 2022), or (3) sparse approximations of attention (Kitaev et al., 2020;", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 106, + 596, + 506, + 609 + ], + "spans": [ + { + "bbox": [ + 106, + 596, + 506, + 609 + ], + "score": 1.0, + "content": "Beltagy et al., 2020; Child et al., 2019; Wu et al., 2022). However, the performance of dense attention", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 607, + 506, + 620 + ], + "spans": [ + { + "bbox": [ + 105, + 607, + 506, + 620 + ], + "score": 1.0, + "content": "means it is typically still chosen for large scale decoders (Touvron et al., 2023; Chowdhery et al.,", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 617, + 506, + 631 + ], + "spans": [ + { + "bbox": [ + 105, + 617, + 506, + 631 + ], + "score": 1.0, + "content": "2022). MEGABYTE takes the alternative approach of decomposing the complete sequence into two", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 628, + 506, + 643 + ], + "spans": [ + { + "bbox": [ + 105, + 628, + 506, + 643 + ], + "score": 1.0, + "content": "shorter sequences, giving sub-quadratic attention. We also note that feedforward networks are the", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 106, + 640, + 506, + 653 + ], + "spans": [ + { + "bbox": [ + 106, + 640, + 506, + 653 + ], + "score": 1.0, + "content": "dominant cost in large decoders, not self-attention. Our approach to compressing sequences allows", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 649, + 507, + 664 + ], + "spans": [ + { + "bbox": [ + 105, + 649, + 507, + 664 + ], + "score": 1.0, + "content": "much larger models than would be possible when using large feedforward networks at every timestep.", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 44, + "bbox_fs": [ + 105, + 519, + 507, + 664 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 667, + 504, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 666, + 506, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 506, + 680 + ], + "score": 1.0, + "content": "Tokenization The most common approach to shortening sequence lengths in Transformer decoders is", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 105, + 677, + 506, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 691 + ], + "score": 1.0, + "content": "to pre-process the input with a form of tokenization, in which multiple bytes are mapped to a single", + "type": "text" + } + ], + "index": 52 + }, + { + "bbox": [ + 105, + 688, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 506, + 702 + ], + "score": 1.0, + "content": "discrete token from a fixed vocabulary. For text, this can be done losslessly using methods such as", + "type": "text" + } + ], + "index": 53 + }, + { + "bbox": [ + 105, + 699, + 506, + 713 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 713 + ], + "score": 1.0, + "content": "BPE (Sennrich et al., 2015) and SentencePiece (Kudo & Richardson, 2018), but these approaches can", + "type": "text" + } + ], + "index": 54 + }, + { + "bbox": [ + 105, + 711, + 505, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 711, + 505, + 723 + ], + "score": 1.0, + "content": "require language-specific heuristics (Radford et al., 2019), limit out-of-domain performance (Sharami", + "type": "text" + } + ], + "index": 55 + }, + { + "bbox": [ + 105, + 72, + 505, + 85 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 505, + 85 + ], + "score": 1.0, + "content": "et al., 2023), and can affect prompting and truncated sampling in unpredictable ways.4 The amount", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 83, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 83, + 505, + 96 + ], + "score": 1.0, + "content": "of high-frequency information in images and audio means that tokenization cannot be performed", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 93, + 506, + 108 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 506, + 108 + ], + "score": 1.0, + "content": "losslessly, and instead clustering (Hsu et al., 2021) or discrete auto-encoders (Ramesh et al., 2021) are", + "type": "text", + "cross_page": true + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 105, + 506, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 506, + 118 + ], + "score": 1.0, + "content": "used to compress the inputs, which lose information and likely limit generative model performance.", + "type": "text", + "cross_page": true + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 117, + 506, + 128 + ], + "spans": [ + { + "bbox": [ + 106, + 117, + 506, + 128 + ], + "score": 1.0, + "content": "Our patches are analogous to traditional lossless tokens, and the Local model performs the role of", + "type": "text", + "cross_page": true + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 127, + 356, + 140 + ], + "spans": [ + { + "bbox": [ + 106, + 127, + 356, + 140 + ], + "score": 1.0, + "content": "mapping a hidden state to a distribution over possible patches.", + "type": "text", + "cross_page": true + } + ], + "index": 5 + } + ], + "index": 53, + "bbox_fs": [ + 105, + 666, + 506, + 723 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 72, + 505, + 138 + ], + "lines": [ + { + "bbox": [ + 105, + 72, + 505, + 85 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 505, + 85 + ], + "score": 1.0, + "content": "et al., 2023), and can affect prompting and truncated sampling in unpredictable ways.4 The amount", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 83, + 505, + 96 + ], + "spans": [ + { + "bbox": [ + 106, + 83, + 505, + 96 + ], + "score": 1.0, + "content": "of high-frequency information in images and audio means that tokenization cannot be performed", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 93, + 506, + 108 + ], + "spans": [ + { + "bbox": [ + 105, + 93, + 506, + 108 + ], + "score": 1.0, + "content": "losslessly, and instead clustering (Hsu et al., 2021) or discrete auto-encoders (Ramesh et al., 2021) are", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 105, + 506, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 105, + 506, + 118 + ], + "score": 1.0, + "content": "used to compress the inputs, which lose information and likely limit generative model performance.", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 117, + 506, + 128 + ], + "spans": [ + { + "bbox": [ + 106, + 117, + 506, + 128 + ], + "score": 1.0, + "content": "Our patches are analogous to traditional lossless tokens, and the Local model performs the role of", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 127, + 356, + 140 + ], + "spans": [ + { + "bbox": [ + 106, + 127, + 356, + 140 + ], + "score": 1.0, + "content": "mapping a hidden state to a distribution over possible patches.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 2.5 + }, + { + "type": "title", + "bbox": [ + 108, + 149, + 189, + 162 + ], + "lines": [ + { + "bbox": [ + 104, + 146, + 191, + 165 + ], + "spans": [ + { + "bbox": [ + 104, + 146, + 191, + 165 + ], + "score": 1.0, + "content": "10 Conclusion", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 106, + 168, + 505, + 235 + ], + "lines": [ + { + "bbox": [ + 105, + 167, + 506, + 181 + ], + "spans": [ + { + "bbox": [ + 105, + 167, + 506, + 181 + ], + "score": 1.0, + "content": "We introduced MEGABYTE, a scaleable architecture for modeling long sequences. MEGABYTE", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 179, + 505, + 191 + ], + "spans": [ + { + "bbox": [ + 106, + 179, + 505, + 191 + ], + "score": 1.0, + "content": "outperforms existing byte-level models across a range of tasks and modalities, allowing large models", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 190, + 505, + 203 + ], + "spans": [ + { + "bbox": [ + 105, + 190, + 505, + 203 + ], + "score": 1.0, + "content": "of sequences of over 1 million tokens. It also gives competitive language modeling results with", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 201, + 505, + 214 + ], + "spans": [ + { + "bbox": [ + 106, + 201, + 505, + 214 + ], + "score": 1.0, + "content": "subword models, which may allow byte-level models to replace tokenization. However, the scale", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 212, + 505, + 223 + ], + "spans": [ + { + "bbox": [ + 106, + 212, + 505, + 223 + ], + "score": 1.0, + "content": "of experiments here is far below those of state-of-the-art language models (Brown et al., 2020), and", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 224, + 446, + 235 + ], + "spans": [ + { + "bbox": [ + 106, + 224, + 446, + 235 + ], + "score": 1.0, + "content": "future work should explore scaling MEGABYTE to much larger models and datasets.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 9.5 + }, + { + "type": "title", + "bbox": [ + 107, + 251, + 163, + 264 + ], + "lines": [ + { + "bbox": [ + 106, + 250, + 165, + 266 + ], + "spans": [ + { + "bbox": [ + 106, + 250, + 165, + 266 + ], + "score": 1.0, + "content": "References", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 105, + 270, + 507, + 705 + ], + "lines": [ + { + "bbox": [ + 105, + 270, + 506, + 284 + ], + "spans": [ + { + "bbox": [ + 105, + 270, + 506, + 284 + ], + "score": 1.0, + "content": "Baines, M., Bhosale, S., Caggiano, V., Goyal, N., Goyal, S., Ott, M., Lefaudeux, B., Liptchin-", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 281, + 506, + 295 + ], + "spans": [ + { + "bbox": [ + 115, + 281, + 506, + 295 + ], + "score": 1.0, + "content": "sky, V., Rabbat, M., Sheiffer, S., Sridhar, A., and Xu, M. FairScale: A general purpose mod-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 116, + 293, + 505, + 307 + ], + "spans": [ + { + "bbox": [ + 116, + 293, + 505, + 307 + ], + "score": 1.0, + "content": "ular PyTorch library for high performance and large scale training. https://github.com/", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 115, + 304, + 282, + 316 + ], + "spans": [ + { + "bbox": [ + 115, + 304, + 282, + 316 + ], + "score": 1.0, + "content": "facebookresearch/fairscale, 2021.", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 104, + 322, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 104, + 322, + 506, + 338 + ], + "score": 1.0, + "content": "Beltagy, I., Peters, M. E., and Cohan, A. Longformer: The long-document transformer. arXiv preprint", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 115, + 334, + 219, + 348 + ], + "spans": [ + { + "bbox": [ + 115, + 334, + 219, + 348 + ], + "score": 1.0, + "content": "arXiv:2004.05150, 2020.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 353, + 506, + 369 + ], + "spans": [ + { + "bbox": [ + 105, + 353, + 506, + 369 + ], + "score": 1.0, + "content": "Brown, T., Mann, B., Ryder, N., Subbiah, M., Kaplan, J. D., Dhariwal, P., Neelakantan, A., Shyam,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 114, + 365, + 506, + 379 + ], + "spans": [ + { + "bbox": [ + 114, + 365, + 506, + 379 + ], + "score": 1.0, + "content": "P., Sastry, G., Askell, A., et al. Language models are few-shot learners. Advances in neural", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 116, + 377, + 334, + 390 + ], + "spans": [ + { + "bbox": [ + 116, + 377, + 334, + 390 + ], + "score": 1.0, + "content": "information processing systems, 33:1877–1901, 2020.", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 395, + 507, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 395, + 507, + 411 + ], + "score": 1.0, + "content": "Child, R., Gray, S., Radford, A., and Sutskever, I. Generating long sequences with sparse transformers.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 117, + 408, + 278, + 420 + ], + "spans": [ + { + "bbox": [ + 117, + 408, + 278, + 420 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:1904.10509, 2019.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 427, + 507, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 427, + 507, + 442 + ], + "score": 1.0, + "content": "Choromanski, K., Likhosherstov, V., Dohan, D., Song, X., Gane, A., Sarlos, T., Hawkins, P.,", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 114, + 438, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 114, + 438, + 505, + 453 + ], + "score": 1.0, + "content": "Davis, J., Mohiuddin, A., Kaiser, L., et al. Rethinking attention with performers. arXiv preprint", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 115, + 450, + 219, + 463 + ], + "spans": [ + { + "bbox": [ + 115, + 450, + 219, + 463 + ], + "score": 1.0, + "content": "arXiv:2009.14794, 2020.", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 104, + 467, + 507, + 485 + ], + "spans": [ + { + "bbox": [ + 104, + 467, + 507, + 485 + ], + "score": 1.0, + "content": "Chowdhery, A., Narang, S., Devlin, J., Bosma, M., Mishra, G., Roberts, A., Barham, P., Chung,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 114, + 480, + 505, + 495 + ], + "spans": [ + { + "bbox": [ + 114, + 480, + 505, + 495 + ], + "score": 1.0, + "content": "H. W., Sutton, C., Gehrmann, S., et al. Palm: Scaling language modeling with pathways. arXiv", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 114, + 492, + 253, + 504 + ], + "spans": [ + { + "bbox": [ + 114, + 492, + 253, + 504 + ], + "score": 1.0, + "content": "preprint arXiv:2204.02311, 2022.", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 512, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 512, + 505, + 525 + ], + "score": 1.0, + "content": "Clark, J. H., Garrette, D., Turc, I., and Wieting, J. Canine: Pre-training an efficient tokenization-free", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 114, + 522, + 507, + 538 + ], + "spans": [ + { + "bbox": [ + 114, + 522, + 507, + 538 + ], + "score": 1.0, + "content": "encoder for language representation. Transactions of the Association for Computational Linguistics,", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 116, + 533, + 183, + 547 + ], + "spans": [ + { + "bbox": [ + 116, + 533, + 183, + 547 + ], + "score": 1.0, + "content": "10:73–91, 2022.", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 554, + 506, + 567 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 506, + 567 + ], + "score": 1.0, + "content": "Dai, Z., Yang, Z., Yang, Y., Carbonell, J., Le, Q. V., and Salakhutdinov, R. Transformer-xl: Attentive", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 565, + 507, + 578 + ], + "spans": [ + { + "bbox": [ + 115, + 565, + 507, + 578 + ], + "score": 1.0, + "content": "language models beyond a fixed-length context, 2019. URL https://arxiv.org/abs/1901.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 117, + 576, + 147, + 588 + ], + "spans": [ + { + "bbox": [ + 117, + 576, + 147, + 588 + ], + "score": 1.0, + "content": "02860.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 595, + 506, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 506, + 609 + ], + "score": 1.0, + "content": "Dosovitskiy, A., Beyer, L., Kolesnikov, A., Weissenborn, D., Zhai, X., Unterthiner, T., Dehghani,", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 115, + 606, + 506, + 620 + ], + "spans": [ + { + "bbox": [ + 115, + 606, + 506, + 620 + ], + "score": 1.0, + "content": "M., Minderer, M., Heigold, G., Gelly, S., et al. An image is worth 16x16 words: Transformers for", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 115, + 617, + 388, + 631 + ], + "spans": [ + { + "bbox": [ + 115, + 617, + 388, + 631 + ], + "score": 1.0, + "content": "image recognition at scale. arXiv preprint arXiv:2010.11929, 2020.", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 637, + 506, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 506, + 651 + ], + "score": 1.0, + "content": "Gao, L., Biderman, S., Black, S., Golding, L., Hoppe, T., Foster, C., Phang, J., He, H., Thite, A.,", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 115, + 647, + 506, + 664 + ], + "spans": [ + { + "bbox": [ + 115, + 647, + 506, + 664 + ], + "score": 1.0, + "content": "Nabeshima, N., Presser, S., and Leahy, C. The pile: An 800gb dataset of diverse text for language", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 659, + 184, + 674 + ], + "spans": [ + { + "bbox": [ + 115, + 659, + 184, + 674 + ], + "score": 1.0, + "content": "modeling, 2020.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 105, + 678, + 506, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 678, + 506, + 695 + ], + "score": 1.0, + "content": "Gu, A., Goel, K., and Ré, C. Efficiently modeling long sequences with structured state spaces. arXiv", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 114, + 692, + 254, + 704 + ], + "spans": [ + { + "bbox": [ + 114, + 692, + 254, + 704 + ], + "score": 1.0, + "content": "preprint arXiv:2111.00396, 2021.", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 29 + } + ], + "page_idx": 9, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 741, + 311, + 750 + ], + "lines": [ + { + "bbox": [ + 299, + 740, + 313, + 754 + ], + "spans": [ + { + "bbox": [ + 299, + 740, + 313, + 754 + ], + "score": 1.0, + "content": "10", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 115, + 711, + 503, + 722 + ], + "lines": [ + { + "bbox": [ + 119, + 709, + 504, + 724 + ], + "spans": [ + { + "bbox": [ + 119, + 709, + 504, + 724 + ], + "score": 1.0, + "content": "4For example, whether or not a prompt should end in whitespace depends on details of the subword algorithm.", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 72, + 505, + 138 + ], + "lines": [], + "index": 2.5, + "bbox_fs": [ + 105, + 72, + 506, + 140 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 108, + 149, + 189, + 162 + ], + "lines": [ + { + "bbox": [ + 104, + 146, + 191, + 165 + ], + "spans": [ + { + "bbox": [ + 104, + 146, + 191, + 165 + ], + "score": 1.0, + "content": "10 Conclusion", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 106, + 168, + 505, + 235 + ], + "lines": [ + { + "bbox": [ + 105, + 167, + 506, + 181 + ], + "spans": [ + { + "bbox": [ + 105, + 167, + 506, + 181 + ], + "score": 1.0, + "content": "We introduced MEGABYTE, a scaleable architecture for modeling long sequences. MEGABYTE", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 179, + 505, + 191 + ], + "spans": [ + { + "bbox": [ + 106, + 179, + 505, + 191 + ], + "score": 1.0, + "content": "outperforms existing byte-level models across a range of tasks and modalities, allowing large models", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 190, + 505, + 203 + ], + "spans": [ + { + "bbox": [ + 105, + 190, + 505, + 203 + ], + "score": 1.0, + "content": "of sequences of over 1 million tokens. It also gives competitive language modeling results with", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 201, + 505, + 214 + ], + "spans": [ + { + "bbox": [ + 106, + 201, + 505, + 214 + ], + "score": 1.0, + "content": "subword models, which may allow byte-level models to replace tokenization. However, the scale", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 212, + 505, + 223 + ], + "spans": [ + { + "bbox": [ + 106, + 212, + 505, + 223 + ], + "score": 1.0, + "content": "of experiments here is far below those of state-of-the-art language models (Brown et al., 2020), and", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 224, + 446, + 235 + ], + "spans": [ + { + "bbox": [ + 106, + 224, + 446, + 235 + ], + "score": 1.0, + "content": "future work should explore scaling MEGABYTE to much larger models and datasets.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 9.5, + "bbox_fs": [ + 105, + 167, + 506, + 235 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 251, + 163, + 264 + ], + "lines": [ + { + "bbox": [ + 106, + 250, + 165, + 266 + ], + "spans": [ + { + "bbox": [ + 106, + 250, + 165, + 266 + ], + "score": 1.0, + "content": "References", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "list", + "bbox": [ + 105, + 270, + 507, + 705 + ], + "lines": [ + { + "bbox": [ + 105, + 270, + 506, + 284 + ], + "spans": [ + { + "bbox": [ + 105, + 270, + 506, + 284 + ], + "score": 1.0, + "content": "Baines, M., Bhosale, S., Caggiano, V., Goyal, N., Goyal, S., Ott, M., Lefaudeux, B., Liptchin-", + "type": "text" + } + ], + "index": 14, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 281, + 506, + 295 + ], + "spans": [ + { + "bbox": [ + 115, + 281, + 506, + 295 + ], + "score": 1.0, + "content": "sky, V., Rabbat, M., Sheiffer, S., Sridhar, A., and Xu, M. FairScale: A general purpose mod-", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 116, + 293, + 505, + 307 + ], + "spans": [ + { + "bbox": [ + 116, + 293, + 505, + 307 + ], + "score": 1.0, + "content": "ular PyTorch library for high performance and large scale training. https://github.com/", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 115, + 304, + 282, + 316 + ], + "spans": [ + { + "bbox": [ + 115, + 304, + 282, + 316 + ], + "score": 1.0, + "content": "facebookresearch/fairscale, 2021.", + "type": "text" + } + ], + "index": 17, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 322, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 104, + 322, + 506, + 338 + ], + "score": 1.0, + "content": "Beltagy, I., Peters, M. E., and Cohan, A. Longformer: The long-document transformer. arXiv preprint", + "type": "text" + } + ], + "index": 18, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 334, + 219, + 348 + ], + "spans": [ + { + "bbox": [ + 115, + 334, + 219, + 348 + ], + "score": 1.0, + "content": "arXiv:2004.05150, 2020.", + "type": "text" + } + ], + "index": 19, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 353, + 506, + 369 + ], + "spans": [ + { + "bbox": [ + 105, + 353, + 506, + 369 + ], + "score": 1.0, + "content": "Brown, T., Mann, B., Ryder, N., Subbiah, M., Kaplan, J. D., Dhariwal, P., Neelakantan, A., Shyam,", + "type": "text" + } + ], + "index": 20, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 365, + 506, + 379 + ], + "spans": [ + { + "bbox": [ + 114, + 365, + 506, + 379 + ], + "score": 1.0, + "content": "P., Sastry, G., Askell, A., et al. Language models are few-shot learners. Advances in neural", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 116, + 377, + 334, + 390 + ], + "spans": [ + { + "bbox": [ + 116, + 377, + 334, + 390 + ], + "score": 1.0, + "content": "information processing systems, 33:1877–1901, 2020.", + "type": "text" + } + ], + "index": 22, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 395, + 507, + 411 + ], + "spans": [ + { + "bbox": [ + 105, + 395, + 507, + 411 + ], + "score": 1.0, + "content": "Child, R., Gray, S., Radford, A., and Sutskever, I. Generating long sequences with sparse transformers.", + "type": "text" + } + ], + "index": 23, + "is_list_start_line": true + }, + { + "bbox": [ + 117, + 408, + 278, + 420 + ], + "spans": [ + { + "bbox": [ + 117, + 408, + 278, + 420 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:1904.10509, 2019.", + "type": "text" + } + ], + "index": 24, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 427, + 507, + 442 + ], + "spans": [ + { + "bbox": [ + 105, + 427, + 507, + 442 + ], + "score": 1.0, + "content": "Choromanski, K., Likhosherstov, V., Dohan, D., Song, X., Gane, A., Sarlos, T., Hawkins, P.,", + "type": "text" + } + ], + "index": 25, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 438, + 505, + 453 + ], + "spans": [ + { + "bbox": [ + 114, + 438, + 505, + 453 + ], + "score": 1.0, + "content": "Davis, J., Mohiuddin, A., Kaiser, L., et al. Rethinking attention with performers. arXiv preprint", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 115, + 450, + 219, + 463 + ], + "spans": [ + { + "bbox": [ + 115, + 450, + 219, + 463 + ], + "score": 1.0, + "content": "arXiv:2009.14794, 2020.", + "type": "text" + } + ], + "index": 27, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 467, + 507, + 485 + ], + "spans": [ + { + "bbox": [ + 104, + 467, + 507, + 485 + ], + "score": 1.0, + "content": "Chowdhery, A., Narang, S., Devlin, J., Bosma, M., Mishra, G., Roberts, A., Barham, P., Chung,", + "type": "text" + } + ], + "index": 28, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 480, + 505, + 495 + ], + "spans": [ + { + "bbox": [ + 114, + 480, + 505, + 495 + ], + "score": 1.0, + "content": "H. W., Sutton, C., Gehrmann, S., et al. Palm: Scaling language modeling with pathways. arXiv", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 114, + 492, + 253, + 504 + ], + "spans": [ + { + "bbox": [ + 114, + 492, + 253, + 504 + ], + "score": 1.0, + "content": "preprint arXiv:2204.02311, 2022.", + "type": "text" + } + ], + "index": 30, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 512, + 505, + 525 + ], + "spans": [ + { + "bbox": [ + 105, + 512, + 505, + 525 + ], + "score": 1.0, + "content": "Clark, J. H., Garrette, D., Turc, I., and Wieting, J. Canine: Pre-training an efficient tokenization-free", + "type": "text" + } + ], + "index": 31, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 522, + 507, + 538 + ], + "spans": [ + { + "bbox": [ + 114, + 522, + 507, + 538 + ], + "score": 1.0, + "content": "encoder for language representation. Transactions of the Association for Computational Linguistics,", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 116, + 533, + 183, + 547 + ], + "spans": [ + { + "bbox": [ + 116, + 533, + 183, + 547 + ], + "score": 1.0, + "content": "10:73–91, 2022.", + "type": "text" + } + ], + "index": 33, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 554, + 506, + 567 + ], + "spans": [ + { + "bbox": [ + 105, + 554, + 506, + 567 + ], + "score": 1.0, + "content": "Dai, Z., Yang, Z., Yang, Y., Carbonell, J., Le, Q. V., and Salakhutdinov, R. Transformer-xl: Attentive", + "type": "text" + } + ], + "index": 34, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 565, + 507, + 578 + ], + "spans": [ + { + "bbox": [ + 115, + 565, + 507, + 578 + ], + "score": 1.0, + "content": "language models beyond a fixed-length context, 2019. URL https://arxiv.org/abs/1901.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 117, + 576, + 147, + 588 + ], + "spans": [ + { + "bbox": [ + 117, + 576, + 147, + 588 + ], + "score": 1.0, + "content": "02860.", + "type": "text" + } + ], + "index": 36, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 595, + 506, + 609 + ], + "spans": [ + { + "bbox": [ + 105, + 595, + 506, + 609 + ], + "score": 1.0, + "content": "Dosovitskiy, A., Beyer, L., Kolesnikov, A., Weissenborn, D., Zhai, X., Unterthiner, T., Dehghani,", + "type": "text" + } + ], + "index": 37, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 606, + 506, + 620 + ], + "spans": [ + { + "bbox": [ + 115, + 606, + 506, + 620 + ], + "score": 1.0, + "content": "M., Minderer, M., Heigold, G., Gelly, S., et al. An image is worth 16x16 words: Transformers for", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 115, + 617, + 388, + 631 + ], + "spans": [ + { + "bbox": [ + 115, + 617, + 388, + 631 + ], + "score": 1.0, + "content": "image recognition at scale. arXiv preprint arXiv:2010.11929, 2020.", + "type": "text" + } + ], + "index": 39, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 637, + 506, + 651 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 506, + 651 + ], + "score": 1.0, + "content": "Gao, L., Biderman, S., Black, S., Golding, L., Hoppe, T., Foster, C., Phang, J., He, H., Thite, A.,", + "type": "text" + } + ], + "index": 40, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 647, + 506, + 664 + ], + "spans": [ + { + "bbox": [ + 115, + 647, + 506, + 664 + ], + "score": 1.0, + "content": "Nabeshima, N., Presser, S., and Leahy, C. The pile: An 800gb dataset of diverse text for language", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 659, + 184, + 674 + ], + "spans": [ + { + "bbox": [ + 115, + 659, + 184, + 674 + ], + "score": 1.0, + "content": "modeling, 2020.", + "type": "text" + } + ], + "index": 42, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 678, + 506, + 695 + ], + "spans": [ + { + "bbox": [ + 105, + 678, + 506, + 695 + ], + "score": 1.0, + "content": "Gu, A., Goel, K., and Ré, C. Efficiently modeling long sequences with structured state spaces. arXiv", + "type": "text" + } + ], + "index": 43, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 692, + 254, + 704 + ], + "spans": [ + { + "bbox": [ + 114, + 692, + 254, + 704 + ], + "score": 1.0, + "content": "preprint arXiv:2111.00396, 2021.", + "type": "text" + } + ], + "index": 44, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 73, + 507, + 86 + ], + "spans": [ + { + "bbox": [ + 105, + 73, + 507, + 86 + ], + "score": 1.0, + "content": "Hawthorne, C., Jaegle, A., Cangea, C., Borgeaud, S., Nash, C., Malinowski, M., Dieleman, S.,", + "type": "text", + "cross_page": true + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 83, + 507, + 98 + ], + "spans": [ + { + "bbox": [ + 115, + 83, + 507, + 98 + ], + "score": 1.0, + "content": "Vinyals, O., Botvinick, M., Simon, I., et al. General-purpose, long-context autoregressive modeling", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 115, + 94, + 507, + 109 + ], + "spans": [ + { + "bbox": [ + 115, + 94, + 507, + 109 + ], + "score": 1.0, + "content": "with perceiver ar. In International Conference on Machine Learning, pp. 8535–8558. PMLR, 2022.", + "type": "text", + "cross_page": true + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 114, + 506, + 126 + ], + "spans": [ + { + "bbox": [ + 106, + 114, + 506, + 126 + ], + "score": 1.0, + "content": "Hoffmann, J., Borgeaud, S., Mensch, A., Buchatskaya, E., Cai, T., Rutherford, E., Casas, D. d. L.,", + "type": "text", + "cross_page": true + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 123, + 506, + 137 + ], + "spans": [ + { + "bbox": [ + 115, + 123, + 506, + 137 + ], + "score": 1.0, + "content": "Hendricks, L. A., Welbl, J., Clark, A., et al. Training compute-optimal large language models.", + "type": "text", + "cross_page": true + } + ], + "index": 4 + }, + { + "bbox": [ + 114, + 135, + 279, + 148 + ], + "spans": [ + { + "bbox": [ + 114, + 135, + 279, + 148 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:2203.15556, 2022.", + "type": "text", + "cross_page": true + } + ], + "index": 5, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 154, + 506, + 166 + ], + "spans": [ + { + "bbox": [ + 106, + 154, + 506, + 166 + ], + "score": 1.0, + "content": "Hsu, W.-N., Bolte, B., Tsai, Y.-H. H., Lakhotia, K., Salakhutdinov, R., and Mohamed, A. Hubert:", + "type": "text", + "cross_page": true + } + ], + "index": 6, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 164, + 506, + 178 + ], + "spans": [ + { + "bbox": [ + 115, + 164, + 506, + 178 + ], + "score": 1.0, + "content": "Self-supervised speech representation learning by masked prediction of hidden units. IEEE/ACM", + "type": "text", + "cross_page": true + } + ], + "index": 7 + }, + { + "bbox": [ + 115, + 174, + 441, + 189 + ], + "spans": [ + { + "bbox": [ + 115, + 174, + 441, + 189 + ], + "score": 1.0, + "content": "Transactions on Audio, Speech, and Language Processing, 29:3451–3460, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 8, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 193, + 506, + 207 + ], + "spans": [ + { + "bbox": [ + 105, + 193, + 506, + 207 + ], + "score": 1.0, + "content": "Hutchins, D., Schlag, I., Wu, Y., Dyer, E., and Neyshabur, B. Block-recurrent transformers. arXiv", + "type": "text", + "cross_page": true + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 203, + 254, + 218 + ], + "spans": [ + { + "bbox": [ + 113, + 203, + 254, + 218 + ], + "score": 1.0, + "content": "preprint arXiv:2203.07852, 2022.", + "type": "text", + "cross_page": true + } + ], + "index": 10, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 223, + 505, + 236 + ], + "spans": [ + { + "bbox": [ + 106, + 223, + 505, + 236 + ], + "score": 1.0, + "content": "Jaegle, A., Gimeno, F., Brock, A., Vinyals, O., Zisserman, A., and Carreira, J. Perceiver: General", + "type": "text", + "cross_page": true + } + ], + "index": 11, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 233, + 507, + 248 + ], + "spans": [ + { + "bbox": [ + 113, + 233, + 507, + 248 + ], + "score": 1.0, + "content": "perception with iterative attention. In International conference on machine learning, pp. 4651–4664.", + "type": "text", + "cross_page": true + } + ], + "index": 12 + }, + { + "bbox": [ + 115, + 244, + 175, + 259 + ], + "spans": [ + { + "bbox": [ + 115, + 244, + 175, + 259 + ], + "score": 1.0, + "content": "PMLR, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 13, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 262, + 507, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 262, + 507, + 277 + ], + "score": 1.0, + "content": "Kalchbrenner, N., Elsen, E., Simonyan, K., Noury, S., Casagrande, N., Lockhart, E., Stimberg, F.,", + "type": "text", + "cross_page": true + } + ], + "index": 14, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 275, + 506, + 287 + ], + "spans": [ + { + "bbox": [ + 115, + 275, + 506, + 287 + ], + "score": 1.0, + "content": "van den Oord, A., Dieleman, S., and Kavukcuoglu, K. Efficient neural audio synthesis. CoRR,", + "type": "text", + "cross_page": true + } + ], + "index": 15 + }, + { + "bbox": [ + 115, + 284, + 401, + 299 + ], + "spans": [ + { + "bbox": [ + 115, + 284, + 401, + 299 + ], + "score": 1.0, + "content": "abs/1802.08435, 2018. URL http://arxiv.org/abs/1802.08435.", + "type": "text", + "cross_page": true + } + ], + "index": 16, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 304, + 506, + 316 + ], + "spans": [ + { + "bbox": [ + 106, + 304, + 506, + 316 + ], + "score": 1.0, + "content": "Kaplan, J., McCandlish, S., Henighan, T., Brown, T. B., Chess, B., Child, R., Gray, S., Radford, A.,", + "type": "text", + "cross_page": true + } + ], + "index": 17, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 314, + 507, + 329 + ], + "spans": [ + { + "bbox": [ + 115, + 314, + 507, + 329 + ], + "score": 1.0, + "content": "Wu, J., and Amodei, D. Scaling laws for neural language models. arXiv preprint arXiv:2001.08361,", + "type": "text", + "cross_page": true + } + ], + "index": 18 + }, + { + "bbox": [ + 115, + 325, + 143, + 339 + ], + "spans": [ + { + "bbox": [ + 115, + 325, + 143, + 339 + ], + "score": 1.0, + "content": "2020.", + "type": "text", + "cross_page": true + } + ], + "index": 19, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 342, + 506, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 342, + 506, + 358 + ], + "score": 1.0, + "content": "Katharopoulos, A., Vyas, A., Pappas, N., and Fleuret, F. Transformers are rnns: Fast autoregressive", + "type": "text", + "cross_page": true + } + ], + "index": 20, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 354, + 507, + 369 + ], + "spans": [ + { + "bbox": [ + 115, + 354, + 507, + 369 + ], + "score": 1.0, + "content": "transformers with linear attention. In International Conference on Machine Learning, pp. 5156–", + "type": "text", + "cross_page": true + } + ], + "index": 21 + }, + { + "bbox": [ + 115, + 366, + 199, + 378 + ], + "spans": [ + { + "bbox": [ + 115, + 366, + 199, + 378 + ], + "score": 1.0, + "content": "5165. PMLR, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 22, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 384, + 454, + 397 + ], + "spans": [ + { + "bbox": [ + 106, + 384, + 454, + 397 + ], + "score": 1.0, + "content": "Kingma, D. P. and Ba, J. Adam: A method for stochastic optimization. In ICLR, 2015.", + "type": "text", + "cross_page": true + } + ], + "index": 23, + "is_list_start_line": true, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 402, + 506, + 417 + ], + "spans": [ + { + "bbox": [ + 105, + 402, + 506, + 417 + ], + "score": 1.0, + "content": "Kitaev, N., Kaiser, Ł., and Levskaya, A. Reformer: The efficient transformer. arXiv preprint", + "type": "text", + "cross_page": true + } + ], + "index": 24, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 413, + 220, + 426 + ], + "spans": [ + { + "bbox": [ + 114, + 413, + 220, + 426 + ], + "score": 1.0, + "content": "arXiv:2001.04451, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 25, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 430, + 506, + 446 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 506, + 446 + ], + "score": 1.0, + "content": "Kudo, T. and Richardson, J. Sentencepiece: A simple and language independent subword tokenizer", + "type": "text", + "cross_page": true + } + ], + "index": 26, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 443, + 452, + 457 + ], + "spans": [ + { + "bbox": [ + 115, + 443, + 452, + 457 + ], + "score": 1.0, + "content": "and detokenizer for neural text processing. arXiv preprint arXiv:1808.06226, 2018.", + "type": "text", + "cross_page": true + } + ], + "index": 27, + "is_list_end_line": true + }, + { + "bbox": [ + 103, + 459, + 507, + 477 + ], + "spans": [ + { + "bbox": [ + 103, + 459, + 507, + 477 + ], + "score": 1.0, + "content": "Ma, X., Zhou, C., Kong, X., He, J., Gui, L., Neubig, G., May, J., and Zettlemoyer, L. Mega: moving", + "type": "text", + "cross_page": true + } + ], + "index": 28, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 473, + 415, + 486 + ], + "spans": [ + { + "bbox": [ + 114, + 473, + 415, + 486 + ], + "score": 1.0, + "content": "average equipped gated attention. arXiv preprint arXiv:2209.10655, 2022.", + "type": "text", + "cross_page": true + } + ], + "index": 29, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 490, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 490, + 505, + 502 + ], + "score": 1.0, + "content": "Micikevicius, P., Narang, S., Alben, J., Diamos, G., Elsen, E., Garcia, D., Ginsburg, B., Houston, M.,", + "type": "text", + "cross_page": true + } + ], + "index": 30, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 500, + 507, + 516 + ], + "spans": [ + { + "bbox": [ + 114, + 500, + 507, + 516 + ], + "score": 1.0, + "content": "Kuchaiev, O., Venkatesh, G., et al. Mixed precision training. arXiv preprint arXiv:1710.03740,", + "type": "text", + "cross_page": true + } + ], + "index": 31 + }, + { + "bbox": [ + 115, + 512, + 144, + 527 + ], + "spans": [ + { + "bbox": [ + 115, + 512, + 144, + 527 + ], + "score": 1.0, + "content": "2017.", + "type": "text", + "cross_page": true + } + ], + "index": 32, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 530, + 507, + 545 + ], + "spans": [ + { + "bbox": [ + 105, + 530, + 507, + 545 + ], + "score": 1.0, + "content": "Oord, A. v. d., Kalchbrenner, N., and Kavukcuoglu, K. Pixel Recurrent Neural Networks. ICML,", + "type": "text", + "cross_page": true + } + ], + "index": 33, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 541, + 507, + 556 + ], + "spans": [ + { + "bbox": [ + 114, + 541, + 507, + 556 + ], + "score": 1.0, + "content": "4:2611–2620, 1 2016. doi: 10.48550/arxiv.1601.06759. URL https://arxiv.org/abs/1601.", + "type": "text", + "cross_page": true + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 553, + 160, + 565 + ], + "spans": [ + { + "bbox": [ + 115, + 553, + 160, + 565 + ], + "score": 1.0, + "content": "06759v3.", + "type": "text", + "cross_page": true + } + ], + "index": 35, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 572, + 506, + 584 + ], + "spans": [ + { + "bbox": [ + 106, + 572, + 506, + 584 + ], + "score": 1.0, + "content": "Paszke, A., Gross, S., Massa, F., Lerer, A., Bradbury, J., Chanan, G., Killeen, T., Lin, Z., Gimelshein,", + "type": "text", + "cross_page": true + } + ], + "index": 36, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 582, + 506, + 596 + ], + "spans": [ + { + "bbox": [ + 115, + 582, + 506, + 596 + ], + "score": 1.0, + "content": "N., Antiga, L., et al. PyTorch: An imperative style, high-performance deep learning library. In", + "type": "text", + "cross_page": true + } + ], + "index": 37 + }, + { + "bbox": [ + 115, + 593, + 182, + 605 + ], + "spans": [ + { + "bbox": [ + 115, + 593, + 182, + 605 + ], + "score": 1.0, + "content": "NeurIPS, 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 38, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 610, + 507, + 626 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 507, + 626 + ], + "score": 1.0, + "content": "Press, O., Smith, N. A., and Lewis, M. Shortformer: Better language modeling using shorter inputs.", + "type": "text", + "cross_page": true + } + ], + "index": 39, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 622, + 280, + 637 + ], + "spans": [ + { + "bbox": [ + 115, + 622, + 280, + 637 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:2012.15832, 2020.", + "type": "text", + "cross_page": true + } + ], + "index": 40, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 641, + 506, + 655 + ], + "spans": [ + { + "bbox": [ + 105, + 641, + 506, + 655 + ], + "score": 1.0, + "content": "Radford, A., Wu, J., Child, R., Luan, D., Amodei, D., and Sutskever, I. Language models are", + "type": "text", + "cross_page": true + } + ], + "index": 41, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 652, + 275, + 664 + ], + "spans": [ + { + "bbox": [ + 114, + 652, + 275, + 664 + ], + "score": 1.0, + "content": "unsupervised multitask learners. 2019.", + "type": "text", + "cross_page": true + } + ], + "index": 42, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 671, + 505, + 683 + ], + "spans": [ + { + "bbox": [ + 106, + 671, + 505, + 683 + ], + "score": 1.0, + "content": "Rae, J. W., Potapenko, A., Jayakumar, S. M., and Lillicrap, T. P. Compressive transformers for", + "type": "text", + "cross_page": true + } + ], + "index": 43, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 681, + 414, + 694 + ], + "spans": [ + { + "bbox": [ + 114, + 681, + 414, + 694 + ], + "score": 1.0, + "content": "long-range sequence modelling. arXiv preprint arXiv:1911.05507, 2019a.", + "type": "text", + "cross_page": true + } + ], + "index": 44, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 698, + 506, + 713 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 713 + ], + "score": 1.0, + "content": "Rae, J. W., Potapenko, A., Jayakumar, S. M., and Lillicrap, T. P. Compressive transformers for", + "type": "text", + "cross_page": true + } + ], + "index": 45, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 711, + 415, + 725 + ], + "spans": [ + { + "bbox": [ + 115, + 711, + 415, + 725 + ], + "score": 1.0, + "content": "long-range sequence modelling. arXiv preprint arXiv:1911.05507, 2019b.", + "type": "text", + "cross_page": true + } + ], + "index": 46, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 72, + 506, + 85 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 506, + 85 + ], + "score": 1.0, + "content": "Ramesh, A., Pavlov, M., Goh, G., Gray, S., Voss, C., Radford, A., Chen, M., and Sutskever, I. Zero-", + "type": "text", + "cross_page": true + } + ], + "index": 0, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 83, + 508, + 99 + ], + "spans": [ + { + "bbox": [ + 115, + 83, + 508, + 99 + ], + "score": 1.0, + "content": "shot text-to-image generation. In International Conference on Machine Learning, pp. 8821–8831.", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 115, + 94, + 175, + 107 + ], + "spans": [ + { + "bbox": [ + 115, + 94, + 175, + 107 + ], + "score": 1.0, + "content": "PMLR, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 2, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 114, + 505, + 126 + ], + "spans": [ + { + "bbox": [ + 106, + 114, + 505, + 126 + ], + "score": 1.0, + "content": "Ren, H., Dai, H., Dai, Z., Yang, M., Leskovec, J., Schuurmans, D., and Dai, B. Combiner: Full", + "type": "text", + "cross_page": true + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 123, + 508, + 139 + ], + "spans": [ + { + "bbox": [ + 113, + 123, + 508, + 139 + ], + "score": 1.0, + "content": "attention transformer with sparse computation cost, 2021. URL https://arxiv.org/abs/2107.", + "type": "text", + "cross_page": true + } + ], + "index": 4 + }, + { + "bbox": [ + 115, + 135, + 148, + 149 + ], + "spans": [ + { + "bbox": [ + 115, + 135, + 148, + 149 + ], + "score": 1.0, + "content": "05768.", + "type": "text", + "cross_page": true + } + ], + "index": 5, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 153, + 506, + 169 + ], + "spans": [ + { + "bbox": [ + 105, + 153, + 506, + 169 + ], + "score": 1.0, + "content": "Roy, A., Saffar, M., Vaswani, A., and Grangier, D. Efficient content-based sparse attention with", + "type": "text", + "cross_page": true + } + ], + "index": 6, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 165, + 424, + 179 + ], + "spans": [ + { + "bbox": [ + 115, + 165, + 424, + 179 + ], + "score": 1.0, + "content": "routing transformers, 2020. URL https://arxiv.org/abs/2003.05997.", + "type": "text", + "cross_page": true + } + ], + "index": 7, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 184, + 505, + 197 + ], + "spans": [ + { + "bbox": [ + 105, + 184, + 371, + 197 + ], + "score": 1.0, + "content": "Salimans, T., Karpathy, A., Chen, X., and Kingma, D. P. Pixelcnn", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 371, + 186, + 384, + 194 + ], + "score": 0.61, + "content": "^ { + + }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 384, + 184, + 505, + 197 + ], + "score": 1.0, + "content": ": Improving the pixelcnn with", + "type": "text", + "cross_page": true + } + ], + "index": 8, + "is_list_start_line": true + }, + { + "bbox": [ + 116, + 196, + 505, + 207 + ], + "spans": [ + { + "bbox": [ + 116, + 196, + 505, + 207 + ], + "score": 1.0, + "content": "discretized logistic mixture likelihood and other modifications. CoRR, abs/1701.05517, 2017. URL", + "type": "text", + "cross_page": true + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 205, + 284, + 218 + ], + "spans": [ + { + "bbox": [ + 115, + 205, + 284, + 218 + ], + "score": 1.0, + "content": "http://arxiv.org/abs/1701.05517.", + "type": "text", + "cross_page": true + } + ], + "index": 10, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 225, + 506, + 238 + ], + "spans": [ + { + "bbox": [ + 105, + 225, + 506, + 238 + ], + "score": 1.0, + "content": "Sennrich, R., Haddow, B., and Birch, A. Neural machine translation of rare words with subword", + "type": "text", + "cross_page": true + } + ], + "index": 11, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 235, + 304, + 248 + ], + "spans": [ + { + "bbox": [ + 115, + 235, + 304, + 248 + ], + "score": 1.0, + "content": "units. arXiv preprint arXiv:1508.07909, 2015.", + "type": "text", + "cross_page": true + } + ], + "index": 12, + "is_list_end_line": true + }, + { + "bbox": [ + 107, + 255, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 107, + 255, + 505, + 267 + ], + "score": 1.0, + "content": "Sharami, J., Shterionov, D., and Spronck, P. A systematic analysis of vocabulary and bpe settings for", + "type": "text", + "cross_page": true + } + ], + "index": 13, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 266, + 506, + 279 + ], + "spans": [ + { + "bbox": [ + 115, + 266, + 506, + 279 + ], + "score": 1.0, + "content": "optimal fine-tuning of nmt: A case study of in-domain translation. arXiv preprint arXiv:2303.00722,", + "type": "text", + "cross_page": true + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 276, + 144, + 290 + ], + "spans": [ + { + "bbox": [ + 115, + 276, + 144, + 290 + ], + "score": 1.0, + "content": "2023.", + "type": "text", + "cross_page": true + } + ], + "index": 15, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 293, + 506, + 310 + ], + "spans": [ + { + "bbox": [ + 104, + 293, + 506, + 310 + ], + "score": 1.0, + "content": "Smith, J. T., Warrington, A., and Linderman, S. W. Simplified state space layers for sequence", + "type": "text", + "cross_page": true + } + ], + "index": 16, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 306, + 322, + 320 + ], + "spans": [ + { + "bbox": [ + 114, + 306, + 322, + 320 + ], + "score": 1.0, + "content": "modeling. arXiv preprint arXiv:2208.04933, 2022.", + "type": "text", + "cross_page": true + } + ], + "index": 17, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 325, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 506, + 338 + ], + "score": 1.0, + "content": "Su, J., Lu, Y., Pan, S., Murtadha, A., Wen, B., and Liu, Y. Roformer: Enhanced transformer with", + "type": "text", + "cross_page": true + } + ], + "index": 18, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 335, + 390, + 349 + ], + "spans": [ + { + "bbox": [ + 113, + 335, + 390, + 349 + ], + "score": 1.0, + "content": "rotary position embedding. arXiv preprint arXiv:2104.09864, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 19, + "is_list_end_line": true + }, + { + "bbox": [ + 104, + 353, + 506, + 369 + ], + "spans": [ + { + "bbox": [ + 104, + 353, + 506, + 369 + ], + "score": 1.0, + "content": "Sun, S., Krishna, K., Mattarella-Micke, A., and Iyyer, M. Do long-range language models actually", + "type": "text", + "cross_page": true + } + ], + "index": 20, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 365, + 379, + 380 + ], + "spans": [ + { + "bbox": [ + 114, + 365, + 379, + 380 + ], + "score": 1.0, + "content": "use long-range context? arXiv preprint arXiv:2109.09115, 2021.", + "type": "text", + "cross_page": true + } + ], + "index": 21, + "is_list_end_line": true + }, + { + "bbox": [ + 106, + 385, + 506, + 397 + ], + "spans": [ + { + "bbox": [ + 106, + 385, + 506, + 397 + ], + "score": 1.0, + "content": "Touvron, H., Lavril, T., Izacard, G., Martinet, X., Lachaux, M.-A., Lacroix, T., Rozière, B., Goyal,", + "type": "text", + "cross_page": true + } + ], + "index": 22, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 395, + 506, + 409 + ], + "spans": [ + { + "bbox": [ + 114, + 395, + 506, + 409 + ], + "score": 1.0, + "content": "N., Hambro, E., Azhar, F., et al. Llama: Open and efficient foundation language models. arXiv", + "type": "text", + "cross_page": true + } + ], + "index": 23 + }, + { + "bbox": [ + 113, + 406, + 254, + 419 + ], + "spans": [ + { + "bbox": [ + 113, + 406, + 254, + 419 + ], + "score": 1.0, + "content": "preprint arXiv:2302.13971, 2023.", + "type": "text", + "cross_page": true + } + ], + "index": 24, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 424, + 506, + 440 + ], + "spans": [ + { + "bbox": [ + 105, + 424, + 506, + 440 + ], + "score": 1.0, + "content": "Trinh, T. H. and Le, Q. V. A simple method for commonsense reasoning. arXiv preprint", + "type": "text", + "cross_page": true + } + ], + "index": 25, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 435, + 220, + 449 + ], + "spans": [ + { + "bbox": [ + 115, + 435, + 220, + 449 + ], + "score": 1.0, + "content": "arXiv:1806.02847, 2018.", + "type": "text", + "cross_page": true + } + ], + "index": 26, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 455, + 506, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 455, + 506, + 468 + ], + "score": 1.0, + "content": "van den Oord, A., Dieleman, S., Zen, H., Simonyan, K., Vinyals, O., Graves, A., Kalchbrenner,", + "type": "text", + "cross_page": true + } + ], + "index": 27, + "is_list_start_line": true + }, + { + "bbox": [ + 114, + 465, + 507, + 480 + ], + "spans": [ + { + "bbox": [ + 114, + 465, + 507, + 480 + ], + "score": 1.0, + "content": "N., Senior, A. W., and Kavukcuoglu, K. Wavenet: A generative model for raw audio. CoRR,", + "type": "text", + "cross_page": true + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 477, + 401, + 490 + ], + "spans": [ + { + "bbox": [ + 115, + 477, + 401, + 490 + ], + "score": 1.0, + "content": "abs/1609.03499, 2016. URL http://arxiv.org/abs/1609.03499.", + "type": "text", + "cross_page": true + } + ], + "index": 29, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 495, + 506, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 506, + 509 + ], + "score": 1.0, + "content": "van den Oord, A., Li, Y., Babuschkin, I., Simonyan, K., Vinyals, O., Kavukcuoglu, K., van den", + "type": "text", + "cross_page": true + } + ], + "index": 30, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 506, + 506, + 520 + ], + "spans": [ + { + "bbox": [ + 115, + 506, + 506, + 520 + ], + "score": 1.0, + "content": "Driessche, G., Lockhart, E., Cobo, L. C., Stimberg, F., Casagrande, N., Grewe, D., Noury, S.,", + "type": "text", + "cross_page": true + } + ], + "index": 31 + }, + { + "bbox": [ + 117, + 518, + 506, + 530 + ], + "spans": [ + { + "bbox": [ + 117, + 518, + 506, + 530 + ], + "score": 1.0, + "content": "Dieleman, S., Elsen, E., Kalchbrenner, N., Zen, H., Graves, A., King, H., Walters, T., Belov, D.,", + "type": "text", + "cross_page": true + } + ], + "index": 32 + }, + { + "bbox": [ + 115, + 528, + 506, + 542 + ], + "spans": [ + { + "bbox": [ + 115, + 528, + 506, + 542 + ], + "score": 1.0, + "content": "and Hassabis, D. Parallel wavenet: Fast high-fidelity speech synthesis. CoRR, abs/1711.10433,", + "type": "text", + "cross_page": true + } + ], + "index": 33 + }, + { + "bbox": [ + 115, + 540, + 332, + 553 + ], + "spans": [ + { + "bbox": [ + 115, + 540, + 332, + 553 + ], + "score": 1.0, + "content": "2017. URL http://arxiv.org/abs/1711.10433.", + "type": "text", + "cross_page": true + } + ], + "index": 34, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 556, + 506, + 573 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 506, + 573 + ], + "score": 1.0, + "content": "Wu, Y., Rabe, M. N., Hutchins, D., and Szegedy, C. Memorizing transformers. arXiv preprint", + "type": "text", + "cross_page": true + } + ], + "index": 35, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 570, + 219, + 581 + ], + "spans": [ + { + "bbox": [ + 115, + 570, + 219, + 581 + ], + "score": 1.0, + "content": "arXiv:2203.08913, 2022.", + "type": "text", + "cross_page": true + } + ], + "index": 36, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 588, + 506, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 506, + 601 + ], + "score": 1.0, + "content": "Zhang, S., Roller, S., Goyal, N., Artetxe, M., Chen, M., Chen, S., Dewan, C., Diab, M., Li, X., Lin,", + "type": "text", + "cross_page": true + } + ], + "index": 37, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 597, + 506, + 613 + ], + "spans": [ + { + "bbox": [ + 115, + 597, + 506, + 613 + ], + "score": 1.0, + "content": "V., Mihaylov, T., Ott, M., Shleifer, S., Shuster, K., Simig, D., Koura, S., Sridhar, A., Wang, T.,", + "type": "text", + "cross_page": true + } + ], + "index": 38 + }, + { + "bbox": [ + 115, + 610, + 507, + 623 + ], + "spans": [ + { + "bbox": [ + 115, + 610, + 507, + 623 + ], + "score": 1.0, + "content": "Zettlemoyer, L., and Ai, M. OPT: Open Pre-trained Transformer Language Models. 5 2022a. doi:", + "type": "text", + "cross_page": true + } + ], + "index": 39 + }, + { + "bbox": [ + 115, + 620, + 437, + 634 + ], + "spans": [ + { + "bbox": [ + 115, + 620, + 437, + 634 + ], + "score": 1.0, + "content": "10.48550/arxiv.2205.01068. URL https://arxiv.org/abs/2205.01068v4.", + "type": "text", + "cross_page": true + } + ], + "index": 40, + "is_list_end_line": true + }, + { + "bbox": [ + 105, + 639, + 506, + 653 + ], + "spans": [ + { + "bbox": [ + 105, + 639, + 506, + 653 + ], + "score": 1.0, + "content": "Zhang, S., Roller, S., Goyal, N., Artetxe, M., Chen, M., Chen, S., Dewan, C., Diab, M., Li, X., Lin,", + "type": "text", + "cross_page": true + } + ], + "index": 41, + "is_list_start_line": true + }, + { + "bbox": [ + 115, + 651, + 506, + 664 + ], + "spans": [ + { + "bbox": [ + 115, + 651, + 506, + 664 + ], + "score": 1.0, + "content": "X. V., et al. Opt: Open pre-trained transformer language models. arXiv preprint arXiv:2205.01068,", + "type": "text", + "cross_page": true + } + ], + "index": 42 + }, + { + "bbox": [ + 115, + 660, + 147, + 675 + ], + "spans": [ + { + "bbox": [ + 115, + 660, + 147, + 675 + ], + "score": 1.0, + "content": "2022b.", + "type": "text", + "cross_page": true + } + ], + "index": 43, + "is_list_end_line": true + } + ], + "index": 29, + "bbox_fs": [ + 104, + 270, + 507, + 704 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 104, + 29, + 507, + 729 + ], + "lines": [ + { + "bbox": [ + 105, + 73, + 507, + 86 + ], + "spans": [ + { + "bbox": [ + 105, + 73, + 507, + 86 + ], + "score": 1.0, + "content": "Hawthorne, C., Jaegle, A., Cangea, C., Borgeaud, S., Nash, C., Malinowski, M., Dieleman, S.,", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 83, + 507, + 98 + ], + "spans": [ + { + "bbox": [ + 115, + 83, + 507, + 98 + ], + "score": 1.0, + "content": "Vinyals, O., Botvinick, M., Simon, I., et al. General-purpose, long-context autoregressive modeling", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 115, + 94, + 507, + 109 + ], + "spans": [ + { + "bbox": [ + 115, + 94, + 507, + 109 + ], + "score": 1.0, + "content": "with perceiver ar. In International Conference on Machine Learning, pp. 8535–8558. PMLR, 2022.", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 114, + 506, + 126 + ], + "spans": [ + { + "bbox": [ + 106, + 114, + 506, + 126 + ], + "score": 1.0, + "content": "Hoffmann, J., Borgeaud, S., Mensch, A., Buchatskaya, E., Cai, T., Rutherford, E., Casas, D. d. L.,", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 115, + 123, + 506, + 137 + ], + "spans": [ + { + "bbox": [ + 115, + 123, + 506, + 137 + ], + "score": 1.0, + "content": "Hendricks, L. A., Welbl, J., Clark, A., et al. Training compute-optimal large language models.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 114, + 135, + 279, + 148 + ], + "spans": [ + { + "bbox": [ + 114, + 135, + 279, + 148 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:2203.15556, 2022.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 154, + 506, + 166 + ], + "spans": [ + { + "bbox": [ + 106, + 154, + 506, + 166 + ], + "score": 1.0, + "content": "Hsu, W.-N., Bolte, B., Tsai, Y.-H. H., Lakhotia, K., Salakhutdinov, R., and Mohamed, A. Hubert:", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 115, + 164, + 506, + 178 + ], + "spans": [ + { + "bbox": [ + 115, + 164, + 506, + 178 + ], + "score": 1.0, + "content": "Self-supervised speech representation learning by masked prediction of hidden units. IEEE/ACM", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 115, + 174, + 441, + 189 + ], + "spans": [ + { + "bbox": [ + 115, + 174, + 441, + 189 + ], + "score": 1.0, + "content": "Transactions on Audio, Speech, and Language Processing, 29:3451–3460, 2021.", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 193, + 506, + 207 + ], + "spans": [ + { + "bbox": [ + 105, + 193, + 506, + 207 + ], + "score": 1.0, + "content": "Hutchins, D., Schlag, I., Wu, Y., Dyer, E., and Neyshabur, B. Block-recurrent transformers. arXiv", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 113, + 203, + 254, + 218 + ], + "spans": [ + { + "bbox": [ + 113, + 203, + 254, + 218 + ], + "score": 1.0, + "content": "preprint arXiv:2203.07852, 2022.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 223, + 505, + 236 + ], + "spans": [ + { + "bbox": [ + 106, + 223, + 505, + 236 + ], + "score": 1.0, + "content": "Jaegle, A., Gimeno, F., Brock, A., Vinyals, O., Zisserman, A., and Carreira, J. Perceiver: General", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 113, + 233, + 507, + 248 + ], + "spans": [ + { + "bbox": [ + 113, + 233, + 507, + 248 + ], + "score": 1.0, + "content": "perception with iterative attention. In International conference on machine learning, pp. 4651–4664.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 115, + 244, + 175, + 259 + ], + "spans": [ + { + "bbox": [ + 115, + 244, + 175, + 259 + ], + "score": 1.0, + "content": "PMLR, 2021.", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 262, + 507, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 262, + 507, + 277 + ], + "score": 1.0, + "content": "Kalchbrenner, N., Elsen, E., Simonyan, K., Noury, S., Casagrande, N., Lockhart, E., Stimberg, F.,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 275, + 506, + 287 + ], + "spans": [ + { + "bbox": [ + 115, + 275, + 506, + 287 + ], + "score": 1.0, + "content": "van den Oord, A., Dieleman, S., and Kavukcuoglu, K. Efficient neural audio synthesis. CoRR,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 115, + 284, + 401, + 299 + ], + "spans": [ + { + "bbox": [ + 115, + 284, + 401, + 299 + ], + "score": 1.0, + "content": "abs/1802.08435, 2018. URL http://arxiv.org/abs/1802.08435.", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 304, + 506, + 316 + ], + "spans": [ + { + "bbox": [ + 106, + 304, + 506, + 316 + ], + "score": 1.0, + "content": "Kaplan, J., McCandlish, S., Henighan, T., Brown, T. B., Chess, B., Child, R., Gray, S., Radford, A.,", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 314, + 507, + 329 + ], + "spans": [ + { + "bbox": [ + 115, + 314, + 507, + 329 + ], + "score": 1.0, + "content": "Wu, J., and Amodei, D. Scaling laws for neural language models. arXiv preprint arXiv:2001.08361,", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 115, + 325, + 143, + 339 + ], + "spans": [ + { + "bbox": [ + 115, + 325, + 143, + 339 + ], + "score": 1.0, + "content": "2020.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 342, + 506, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 342, + 506, + 358 + ], + "score": 1.0, + "content": "Katharopoulos, A., Vyas, A., Pappas, N., and Fleuret, F. Transformers are rnns: Fast autoregressive", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 115, + 354, + 507, + 369 + ], + "spans": [ + { + "bbox": [ + 115, + 354, + 507, + 369 + ], + "score": 1.0, + "content": "transformers with linear attention. In International Conference on Machine Learning, pp. 5156–", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 115, + 366, + 199, + 378 + ], + "spans": [ + { + "bbox": [ + 115, + 366, + 199, + 378 + ], + "score": 1.0, + "content": "5165. PMLR, 2020.", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 384, + 454, + 397 + ], + "spans": [ + { + "bbox": [ + 106, + 384, + 454, + 397 + ], + "score": 1.0, + "content": "Kingma, D. P. and Ba, J. Adam: A method for stochastic optimization. In ICLR, 2015.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 402, + 506, + 417 + ], + "spans": [ + { + "bbox": [ + 105, + 402, + 506, + 417 + ], + "score": 1.0, + "content": "Kitaev, N., Kaiser, Ł., and Levskaya, A. Reformer: The efficient transformer. arXiv preprint", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 114, + 413, + 220, + 426 + ], + "spans": [ + { + "bbox": [ + 114, + 413, + 220, + 426 + ], + "score": 1.0, + "content": "arXiv:2001.04451, 2020.", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 430, + 506, + 446 + ], + "spans": [ + { + "bbox": [ + 105, + 430, + 506, + 446 + ], + "score": 1.0, + "content": "Kudo, T. and Richardson, J. Sentencepiece: A simple and language independent subword tokenizer", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 115, + 443, + 452, + 457 + ], + "spans": [ + { + "bbox": [ + 115, + 443, + 452, + 457 + ], + "score": 1.0, + "content": "and detokenizer for neural text processing. arXiv preprint arXiv:1808.06226, 2018.", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 103, + 459, + 507, + 477 + ], + "spans": [ + { + "bbox": [ + 103, + 459, + 507, + 477 + ], + "score": 1.0, + "content": "Ma, X., Zhou, C., Kong, X., He, J., Gui, L., Neubig, G., May, J., and Zettlemoyer, L. Mega: moving", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 114, + 473, + 415, + 486 + ], + "spans": [ + { + "bbox": [ + 114, + 473, + 415, + 486 + ], + "score": 1.0, + "content": "average equipped gated attention. arXiv preprint arXiv:2209.10655, 2022.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 490, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 490, + 505, + 502 + ], + "score": 1.0, + "content": "Micikevicius, P., Narang, S., Alben, J., Diamos, G., Elsen, E., Garcia, D., Ginsburg, B., Houston, M.,", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 114, + 500, + 507, + 516 + ], + "spans": [ + { + "bbox": [ + 114, + 500, + 507, + 516 + ], + "score": 1.0, + "content": "Kuchaiev, O., Venkatesh, G., et al. Mixed precision training. arXiv preprint arXiv:1710.03740,", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 115, + 512, + 144, + 527 + ], + "spans": [ + { + "bbox": [ + 115, + 512, + 144, + 527 + ], + "score": 1.0, + "content": "2017.", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 530, + 507, + 545 + ], + "spans": [ + { + "bbox": [ + 105, + 530, + 507, + 545 + ], + "score": 1.0, + "content": "Oord, A. v. d., Kalchbrenner, N., and Kavukcuoglu, K. Pixel Recurrent Neural Networks. ICML,", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 114, + 541, + 507, + 556 + ], + "spans": [ + { + "bbox": [ + 114, + 541, + 507, + 556 + ], + "score": 1.0, + "content": "4:2611–2620, 1 2016. doi: 10.48550/arxiv.1601.06759. URL https://arxiv.org/abs/1601.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 553, + 160, + 565 + ], + "spans": [ + { + "bbox": [ + 115, + 553, + 160, + 565 + ], + "score": 1.0, + "content": "06759v3.", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 572, + 506, + 584 + ], + "spans": [ + { + "bbox": [ + 106, + 572, + 506, + 584 + ], + "score": 1.0, + "content": "Paszke, A., Gross, S., Massa, F., Lerer, A., Bradbury, J., Chanan, G., Killeen, T., Lin, Z., Gimelshein,", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 115, + 582, + 506, + 596 + ], + "spans": [ + { + "bbox": [ + 115, + 582, + 506, + 596 + ], + "score": 1.0, + "content": "N., Antiga, L., et al. PyTorch: An imperative style, high-performance deep learning library. In", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 115, + 593, + 182, + 605 + ], + "spans": [ + { + "bbox": [ + 115, + 593, + 182, + 605 + ], + "score": 1.0, + "content": "NeurIPS, 2019.", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 610, + 507, + 626 + ], + "spans": [ + { + "bbox": [ + 105, + 610, + 507, + 626 + ], + "score": 1.0, + "content": "Press, O., Smith, N. A., and Lewis, M. Shortformer: Better language modeling using shorter inputs.", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 115, + 622, + 280, + 637 + ], + "spans": [ + { + "bbox": [ + 115, + 622, + 280, + 637 + ], + "score": 1.0, + "content": "arXiv preprint arXiv:2012.15832, 2020.", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 641, + 506, + 655 + ], + "spans": [ + { + "bbox": [ + 105, + 641, + 506, + 655 + ], + "score": 1.0, + "content": "Radford, A., Wu, J., Child, R., Luan, D., Amodei, D., and Sutskever, I. Language models are", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 114, + 652, + 275, + 664 + ], + "spans": [ + { + "bbox": [ + 114, + 652, + 275, + 664 + ], + "score": 1.0, + "content": "unsupervised multitask learners. 2019.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 671, + 505, + 683 + ], + "spans": [ + { + "bbox": [ + 106, + 671, + 505, + 683 + ], + "score": 1.0, + "content": "Rae, J. W., Potapenko, A., Jayakumar, S. M., and Lillicrap, T. P. Compressive transformers for", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 114, + 681, + 414, + 694 + ], + "spans": [ + { + "bbox": [ + 114, + 681, + 414, + 694 + ], + "score": 1.0, + "content": "long-range sequence modelling. arXiv preprint arXiv:1911.05507, 2019a.", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 698, + 506, + 713 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 713 + ], + "score": 1.0, + "content": "Rae, J. W., Potapenko, A., Jayakumar, S. M., and Lillicrap, T. P. Compressive transformers for", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 115, + 711, + 415, + 725 + ], + "spans": [ + { + "bbox": [ + 115, + 711, + 415, + 725 + ], + "score": 1.0, + "content": "long-range sequence modelling. arXiv preprint arXiv:1911.05507, 2019b.", + "type": "text" + } + ], + "index": 46 + } + ], + "index": 23 + } + ], + "page_idx": 10, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 741, + 311, + 751 + ], + "lines": [ + { + "bbox": [ + 299, + 740, + 312, + 754 + ], + "spans": [ + { + "bbox": [ + 299, + 740, + 312, + 754 + ], + "score": 1.0, + "content": "11", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "list", + "bbox": [ + 104, + 29, + 507, + 729 + ], + "lines": [], + "index": 23, + "bbox_fs": [ + 103, + 73, + 507, + 725 + ], + "lines_deleted": true + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 29, + 507, + 672 + ], + "lines": [ + { + "bbox": [ + 105, + 72, + 506, + 85 + ], + "spans": [ + { + "bbox": [ + 105, + 72, + 506, + 85 + ], + "score": 1.0, + "content": "Ramesh, A., Pavlov, M., Goh, G., Gray, S., Voss, C., Radford, A., Chen, M., and Sutskever, I. Zero-", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 83, + 508, + 99 + ], + "spans": [ + { + "bbox": [ + 115, + 83, + 508, + 99 + ], + "score": 1.0, + "content": "shot text-to-image generation. In International Conference on Machine Learning, pp. 8821–8831.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 115, + 94, + 175, + 107 + ], + "spans": [ + { + "bbox": [ + 115, + 94, + 175, + 107 + ], + "score": 1.0, + "content": "PMLR, 2021.", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 114, + 505, + 126 + ], + "spans": [ + { + "bbox": [ + 106, + 114, + 505, + 126 + ], + "score": 1.0, + "content": "Ren, H., Dai, H., Dai, Z., Yang, M., Leskovec, J., Schuurmans, D., and Dai, B. Combiner: Full", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 113, + 123, + 508, + 139 + ], + "spans": [ + { + "bbox": [ + 113, + 123, + 508, + 139 + ], + "score": 1.0, + "content": "attention transformer with sparse computation cost, 2021. URL https://arxiv.org/abs/2107.", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 115, + 135, + 148, + 149 + ], + "spans": [ + { + "bbox": [ + 115, + 135, + 148, + 149 + ], + "score": 1.0, + "content": "05768.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 153, + 506, + 169 + ], + "spans": [ + { + "bbox": [ + 105, + 153, + 506, + 169 + ], + "score": 1.0, + "content": "Roy, A., Saffar, M., Vaswani, A., and Grangier, D. Efficient content-based sparse attention with", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 115, + 165, + 424, + 179 + ], + "spans": [ + { + "bbox": [ + 115, + 165, + 424, + 179 + ], + "score": 1.0, + "content": "routing transformers, 2020. URL https://arxiv.org/abs/2003.05997.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 184, + 505, + 197 + ], + "spans": [ + { + "bbox": [ + 105, + 184, + 371, + 197 + ], + "score": 1.0, + "content": "Salimans, T., Karpathy, A., Chen, X., and Kingma, D. P. Pixelcnn", + "type": "text" + }, + { + "bbox": [ + 371, + 186, + 384, + 194 + ], + "score": 0.61, + "content": "^ { + + }", + "type": "inline_equation" + }, + { + "bbox": [ + 384, + 184, + 505, + 197 + ], + "score": 1.0, + "content": ": Improving the pixelcnn with", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 116, + 196, + 505, + 207 + ], + "spans": [ + { + "bbox": [ + 116, + 196, + 505, + 207 + ], + "score": 1.0, + "content": "discretized logistic mixture likelihood and other modifications. CoRR, abs/1701.05517, 2017. URL", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 115, + 205, + 284, + 218 + ], + "spans": [ + { + "bbox": [ + 115, + 205, + 284, + 218 + ], + "score": 1.0, + "content": "http://arxiv.org/abs/1701.05517.", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 225, + 506, + 238 + ], + "spans": [ + { + "bbox": [ + 105, + 225, + 506, + 238 + ], + "score": 1.0, + "content": "Sennrich, R., Haddow, B., and Birch, A. Neural machine translation of rare words with subword", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 115, + 235, + 304, + 248 + ], + "spans": [ + { + "bbox": [ + 115, + 235, + 304, + 248 + ], + "score": 1.0, + "content": "units. arXiv preprint arXiv:1508.07909, 2015.", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 107, + 255, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 107, + 255, + 505, + 267 + ], + "score": 1.0, + "content": "Sharami, J., Shterionov, D., and Spronck, P. A systematic analysis of vocabulary and bpe settings for", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 115, + 266, + 506, + 279 + ], + "spans": [ + { + "bbox": [ + 115, + 266, + 506, + 279 + ], + "score": 1.0, + "content": "optimal fine-tuning of nmt: A case study of in-domain translation. arXiv preprint arXiv:2303.00722,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 115, + 276, + 144, + 290 + ], + "spans": [ + { + "bbox": [ + 115, + 276, + 144, + 290 + ], + "score": 1.0, + "content": "2023.", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 104, + 293, + 506, + 310 + ], + "spans": [ + { + "bbox": [ + 104, + 293, + 506, + 310 + ], + "score": 1.0, + "content": "Smith, J. T., Warrington, A., and Linderman, S. W. Simplified state space layers for sequence", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 114, + 306, + 322, + 320 + ], + "spans": [ + { + "bbox": [ + 114, + 306, + 322, + 320 + ], + "score": 1.0, + "content": "modeling. arXiv preprint arXiv:2208.04933, 2022.", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 325, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 105, + 325, + 506, + 338 + ], + "score": 1.0, + "content": "Su, J., Lu, Y., Pan, S., Murtadha, A., Wen, B., and Liu, Y. Roformer: Enhanced transformer with", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 113, + 335, + 390, + 349 + ], + "spans": [ + { + "bbox": [ + 113, + 335, + 390, + 349 + ], + "score": 1.0, + "content": "rotary position embedding. arXiv preprint arXiv:2104.09864, 2021.", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 104, + 353, + 506, + 369 + ], + "spans": [ + { + "bbox": [ + 104, + 353, + 506, + 369 + ], + "score": 1.0, + "content": "Sun, S., Krishna, K., Mattarella-Micke, A., and Iyyer, M. Do long-range language models actually", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 114, + 365, + 379, + 380 + ], + "spans": [ + { + "bbox": [ + 114, + 365, + 379, + 380 + ], + "score": 1.0, + "content": "use long-range context? arXiv preprint arXiv:2109.09115, 2021.", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 385, + 506, + 397 + ], + "spans": [ + { + "bbox": [ + 106, + 385, + 506, + 397 + ], + "score": 1.0, + "content": "Touvron, H., Lavril, T., Izacard, G., Martinet, X., Lachaux, M.-A., Lacroix, T., Rozière, B., Goyal,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 114, + 395, + 506, + 409 + ], + "spans": [ + { + "bbox": [ + 114, + 395, + 506, + 409 + ], + "score": 1.0, + "content": "N., Hambro, E., Azhar, F., et al. Llama: Open and efficient foundation language models. arXiv", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 113, + 406, + 254, + 419 + ], + "spans": [ + { + "bbox": [ + 113, + 406, + 254, + 419 + ], + "score": 1.0, + "content": "preprint arXiv:2302.13971, 2023.", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 424, + 506, + 440 + ], + "spans": [ + { + "bbox": [ + 105, + 424, + 506, + 440 + ], + "score": 1.0, + "content": "Trinh, T. H. and Le, Q. V. A simple method for commonsense reasoning. arXiv preprint", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 115, + 435, + 220, + 449 + ], + "spans": [ + { + "bbox": [ + 115, + 435, + 220, + 449 + ], + "score": 1.0, + "content": "arXiv:1806.02847, 2018.", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 455, + 506, + 468 + ], + "spans": [ + { + "bbox": [ + 105, + 455, + 506, + 468 + ], + "score": 1.0, + "content": "van den Oord, A., Dieleman, S., Zen, H., Simonyan, K., Vinyals, O., Graves, A., Kalchbrenner,", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 114, + 465, + 507, + 480 + ], + "spans": [ + { + "bbox": [ + 114, + 465, + 507, + 480 + ], + "score": 1.0, + "content": "N., Senior, A. W., and Kavukcuoglu, K. Wavenet: A generative model for raw audio. CoRR,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 477, + 401, + 490 + ], + "spans": [ + { + "bbox": [ + 115, + 477, + 401, + 490 + ], + "score": 1.0, + "content": "abs/1609.03499, 2016. URL http://arxiv.org/abs/1609.03499.", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 495, + 506, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 495, + 506, + 509 + ], + "score": 1.0, + "content": "van den Oord, A., Li, Y., Babuschkin, I., Simonyan, K., Vinyals, O., Kavukcuoglu, K., van den", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 115, + 506, + 506, + 520 + ], + "spans": [ + { + "bbox": [ + 115, + 506, + 506, + 520 + ], + "score": 1.0, + "content": "Driessche, G., Lockhart, E., Cobo, L. C., Stimberg, F., Casagrande, N., Grewe, D., Noury, S.,", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 117, + 518, + 506, + 530 + ], + "spans": [ + { + "bbox": [ + 117, + 518, + 506, + 530 + ], + "score": 1.0, + "content": "Dieleman, S., Elsen, E., Kalchbrenner, N., Zen, H., Graves, A., King, H., Walters, T., Belov, D.,", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 115, + 528, + 506, + 542 + ], + "spans": [ + { + "bbox": [ + 115, + 528, + 506, + 542 + ], + "score": 1.0, + "content": "and Hassabis, D. Parallel wavenet: Fast high-fidelity speech synthesis. CoRR, abs/1711.10433,", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 115, + 540, + 332, + 553 + ], + "spans": [ + { + "bbox": [ + 115, + 540, + 332, + 553 + ], + "score": 1.0, + "content": "2017. URL http://arxiv.org/abs/1711.10433.", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 556, + 506, + 573 + ], + "spans": [ + { + "bbox": [ + 105, + 556, + 506, + 573 + ], + "score": 1.0, + "content": "Wu, Y., Rabe, M. N., Hutchins, D., and Szegedy, C. Memorizing transformers. arXiv preprint", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 115, + 570, + 219, + 581 + ], + "spans": [ + { + "bbox": [ + 115, + 570, + 219, + 581 + ], + "score": 1.0, + "content": "arXiv:2203.08913, 2022.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 588, + 506, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 506, + 601 + ], + "score": 1.0, + "content": "Zhang, S., Roller, S., Goyal, N., Artetxe, M., Chen, M., Chen, S., Dewan, C., Diab, M., Li, X., Lin,", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 115, + 597, + 506, + 613 + ], + "spans": [ + { + "bbox": [ + 115, + 597, + 506, + 613 + ], + "score": 1.0, + "content": "V., Mihaylov, T., Ott, M., Shleifer, S., Shuster, K., Simig, D., Koura, S., Sridhar, A., Wang, T.,", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 115, + 610, + 507, + 623 + ], + "spans": [ + { + "bbox": [ + 115, + 610, + 507, + 623 + ], + "score": 1.0, + "content": "Zettlemoyer, L., and Ai, M. OPT: Open Pre-trained Transformer Language Models. 5 2022a. doi:", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 115, + 620, + 437, + 634 + ], + "spans": [ + { + "bbox": [ + 115, + 620, + 437, + 634 + ], + "score": 1.0, + "content": "10.48550/arxiv.2205.01068. URL https://arxiv.org/abs/2205.01068v4.", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 639, + 506, + 653 + ], + "spans": [ + { + "bbox": [ + 105, + 639, + 506, + 653 + ], + "score": 1.0, + "content": "Zhang, S., Roller, S., Goyal, N., Artetxe, M., Chen, M., Chen, S., Dewan, C., Diab, M., Li, X., Lin,", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 651, + 506, + 664 + ], + "spans": [ + { + "bbox": [ + 115, + 651, + 506, + 664 + ], + "score": 1.0, + "content": "X. V., et al. Opt: Open pre-trained transformer language models. arXiv preprint arXiv:2205.01068,", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 115, + 660, + 147, + 675 + ], + "spans": [ + { + "bbox": [ + 115, + 660, + 147, + 675 + ], + "score": 1.0, + "content": "2022b.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 21.5 + } + ], + "page_idx": 11, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 741, + 311, + 750 + ], + "lines": [ + { + "bbox": [ + 299, + 740, + 313, + 754 + ], + "spans": [ + { + "bbox": [ + 299, + 740, + 313, + 754 + ], + "score": 1.0, + "content": "12", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "list", + "bbox": [ + 105, + 29, + 507, + 672 + ], + "lines": [], + "index": 21.5, + "bbox_fs": [ + 104, + 72, + 508, + 675 + ], + "lines_deleted": true + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 71, + 254, + 85 + ], + "lines": [ + { + "bbox": [ + 105, + 70, + 256, + 88 + ], + "spans": [ + { + "bbox": [ + 105, + 70, + 256, + 88 + ], + "score": 1.0, + "content": "A Supplementary Material", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "title", + "bbox": [ + 107, + 95, + 202, + 108 + ], + "lines": [ + { + "bbox": [ + 105, + 95, + 203, + 109 + ], + "spans": [ + { + "bbox": [ + 105, + 95, + 203, + 109 + ], + "score": 1.0, + "content": "A.1 Training Details", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 106, + 115, + 505, + 214 + ], + "lines": [ + { + "bbox": [ + 106, + 115, + 506, + 128 + ], + "spans": [ + { + "bbox": [ + 106, + 115, + 506, + 128 + ], + "score": 1.0, + "content": "To ensure stable training, we applied gradient clipping with a maximum norm of 1.0 and used the", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 127, + 505, + 140 + ], + "spans": [ + { + "bbox": [ + 106, + 127, + 195, + 140 + ], + "score": 1.0, + "content": "Adam optimizer with", + "type": "text" + }, + { + "bbox": [ + 195, + 127, + 232, + 138 + ], + "score": 0.89, + "content": "\\beta _ { 1 } = 0 . 9", + "type": "inline_equation" + }, + { + "bbox": [ + 233, + 127, + 236, + 140 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 236, + 127, + 279, + 138 + ], + "score": 0.87, + "content": "\\beta _ { 2 } = 0 . 9 8", + "type": "inline_equation" + }, + { + "bbox": [ + 280, + 127, + 505, + 140 + ], + "score": 1.0, + "content": "Kingma & Ba (2015). We used the built-in polynomial", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 137, + 506, + 150 + ], + "spans": [ + { + "bbox": [ + 106, + 137, + 506, + 150 + ], + "score": 1.0, + "content": "decay learning rate scheduler in MetaSeq with 500 warmup updates and the end learning rate set", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 148, + 506, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 148, + 506, + 161 + ], + "score": 1.0, + "content": "to 0. All models are trained with pre-norm and using ReLU activation. We apply a dropout of 0.1", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 159, + 506, + 173 + ], + "spans": [ + { + "bbox": [ + 106, + 159, + 506, + 173 + ], + "score": 1.0, + "content": "throughout, but we do not apply any dropout to embeddings. We also use weight decay of 0.1. To", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 168, + 506, + 184 + ], + "spans": [ + { + "bbox": [ + 105, + 168, + 506, + 184 + ], + "score": 1.0, + "content": "initialize the weights, we use a variant based on Megatron-LM codebase, which involves using a", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 182, + 505, + 192 + ], + "spans": [ + { + "bbox": [ + 106, + 182, + 505, + 192 + ], + "score": 1.0, + "content": "normal distribution with a mean of zero and a standard deviation of 0.006. We truncate this normal", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 191, + 505, + 205 + ], + "spans": [ + { + "bbox": [ + 105, + 191, + 505, + 205 + ], + "score": 1.0, + "content": "distribution within two standard deviations and observed substantial gain in both training stability", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 202, + 179, + 217 + ], + "spans": [ + { + "bbox": [ + 105, + 202, + 179, + 217 + ], + "score": 1.0, + "content": "and performance.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 6 + }, + { + "type": "title", + "bbox": [ + 107, + 227, + 180, + 239 + ], + "lines": [ + { + "bbox": [ + 105, + 227, + 181, + 240 + ], + "spans": [ + { + "bbox": [ + 105, + 227, + 181, + 240 + ], + "score": 1.0, + "content": "A.2 Motivation", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 106, + 247, + 505, + 347 + ], + "lines": [ + { + "bbox": [ + 106, + 247, + 506, + 260 + ], + "spans": [ + { + "bbox": [ + 106, + 247, + 506, + 260 + ], + "score": 1.0, + "content": "Why is the local model needed? Many of the efficiency advantages of the MEGABYTE design could", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 258, + 505, + 271 + ], + "spans": [ + { + "bbox": [ + 105, + 258, + 505, + 271 + ], + "score": 1.0, + "content": "be realized with the Global model alone, which would resemble a decoder version of ViT (Dosovitskiy", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 104, + 268, + 506, + 284 + ], + "spans": [ + { + "bbox": [ + 104, + 268, + 336, + 284 + ], + "score": 1.0, + "content": "et al., 2020). However, the joint distribution over the patch", + "type": "text" + }, + { + "bbox": [ + 336, + 270, + 426, + 281 + ], + "score": 0.91, + "content": "p ( x _ { t + 1 } , . . , x _ { t + P } | x _ { 0 . . t } )", + "type": "inline_equation" + }, + { + "bbox": [ + 426, + 268, + 506, + 284 + ], + "score": 1.0, + "content": "has an output space", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 278, + 506, + 293 + ], + "spans": [ + { + "bbox": [ + 104, + 278, + 136, + 293 + ], + "score": 1.0, + "content": "of size", + "type": "text" + }, + { + "bbox": [ + 137, + 280, + 159, + 291 + ], + "score": 0.89, + "content": "2 5 6 ^ { P }", + "type": "inline_equation" + }, + { + "bbox": [ + 159, + 278, + 506, + 293 + ], + "score": 1.0, + "content": "so direct modeling is only tractable for very small patches. We could instead factor", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 290, + 507, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 290, + 371, + 306 + ], + "score": 1.0, + "content": "the joint distribution into conditionally independent distributions", + "type": "text" + }, + { + "bbox": [ + 372, + 291, + 486, + 303 + ], + "score": 0.92, + "content": "p ( x _ { t + 1 } | x _ { 0 . . t } ) . . p ( x _ { t + P } | x _ { 0 . . t } )", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 290, + 507, + 306 + ], + "score": 1.0, + "content": ", but", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 302, + 506, + 315 + ], + "spans": [ + { + "bbox": [ + 106, + 302, + 506, + 315 + ], + "score": 1.0, + "content": "this would greatly limit the model’s expressive power. For example, it would be unable to express", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 313, + 505, + 326 + ], + "spans": [ + { + "bbox": [ + 105, + 313, + 221, + 326 + ], + "score": 1.0, + "content": "a patch distribution such as", + "type": "text" + }, + { + "bbox": [ + 222, + 313, + 242, + 324 + ], + "score": 0.85, + "content": "50 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 242, + 313, + 276, + 326 + ], + "score": 1.0, + "content": "cat and", + "type": "text" + }, + { + "bbox": [ + 277, + 313, + 297, + 324 + ], + "score": 0.84, + "content": "50 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 297, + 313, + 505, + 326 + ], + "score": 1.0, + "content": "dog, and would instead have to assign probability", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 324, + 505, + 336 + ], + "spans": [ + { + "bbox": [ + 106, + 324, + 505, + 336 + ], + "score": 1.0, + "content": "mass to strings such as cag and dot. Instead, our autoregressive Local model conditions on previous", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 335, + 455, + 348 + ], + "spans": [ + { + "bbox": [ + 106, + 335, + 455, + 348 + ], + "score": 1.0, + "content": "characters within the patch, allowing it to only assign probability to the desired strings.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 16 + }, + { + "type": "text", + "bbox": [ + 107, + 351, + 505, + 406 + ], + "lines": [ + { + "bbox": [ + 106, + 351, + 506, + 363 + ], + "spans": [ + { + "bbox": [ + 106, + 351, + 506, + 363 + ], + "score": 1.0, + "content": "Increasing Parameters for Fixed Compute Transformer models have shown consistent improve-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 362, + 506, + 375 + ], + "spans": [ + { + "bbox": [ + 106, + 362, + 506, + 375 + ], + "score": 1.0, + "content": "ments with parameter counts (Kaplan et al., 2020). However, the size of models is limited by their", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 373, + 506, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 373, + 506, + 385 + ], + "score": 1.0, + "content": "increasing computational cost. MEGABYTE allows larger models for the same cost, both by mak-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 384, + 505, + 397 + ], + "spans": [ + { + "bbox": [ + 106, + 384, + 505, + 397 + ], + "score": 1.0, + "content": "ing self attention sub-quadratic, and by using large feedforward layers across patches rather than", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 394, + 180, + 407 + ], + "spans": [ + { + "bbox": [ + 106, + 394, + 180, + 407 + ], + "score": 1.0, + "content": "individual tokens.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23 + }, + { + "type": "text", + "bbox": [ + 107, + 411, + 505, + 444 + ], + "lines": [ + { + "bbox": [ + 107, + 412, + 505, + 423 + ], + "spans": [ + { + "bbox": [ + 107, + 412, + 505, + 423 + ], + "score": 1.0, + "content": "Re-use of Established Components MEGABYTE consists of two transformer models interleaved", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 422, + 507, + 434 + ], + "spans": [ + { + "bbox": [ + 106, + 422, + 507, + 434 + ], + "score": 1.0, + "content": "with shifting, reshaping and a linear projection. This re-use increases the likelihood that the architec-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 433, + 364, + 446 + ], + "spans": [ + { + "bbox": [ + 106, + 433, + 364, + 446 + ], + "score": 1.0, + "content": "ture will inherit the desirable scaling properties of transformers.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27 + }, + { + "type": "title", + "bbox": [ + 107, + 457, + 192, + 468 + ], + "lines": [ + { + "bbox": [ + 105, + 456, + 193, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 193, + 470 + ], + "score": 1.0, + "content": "A.3 Model Details", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 106, + 477, + 505, + 532 + ], + "lines": [ + { + "bbox": [ + 106, + 477, + 504, + 489 + ], + "spans": [ + { + "bbox": [ + 106, + 477, + 504, + 489 + ], + "score": 1.0, + "content": "As discussed in Section 4, we conduct experiments using a fixed compute and data budget across all", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 488, + 505, + 500 + ], + "spans": [ + { + "bbox": [ + 106, + 488, + 505, + 500 + ], + "score": 1.0, + "content": "models to focus our comparisons solely on the model architecture rather than training resources. To", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 500, + 506, + 511 + ], + "spans": [ + { + "bbox": [ + 106, + 500, + 506, + 511 + ], + "score": 1.0, + "content": "achieve this, we adjust model hyperparameters within each architecture so that the time taken for a", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 510, + 506, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 506, + 523 + ], + "score": 1.0, + "content": "single update is matched and then train all models for the same number of updates. We list all of", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 521, + 266, + 532 + ], + "spans": [ + { + "bbox": [ + 105, + 521, + 266, + 532 + ], + "score": 1.0, + "content": "model details in Table 12 and Table 13.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32 + }, + { + "type": "table", + "bbox": [ + 217, + 540, + 394, + 628 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 217, + 540, + 394, + 628 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 217, + 540, + 394, + 628 + ], + "spans": [ + { + "bbox": [ + 217, + 540, + 394, + 628 + ], + "score": 0.97, + "html": "
Model#Ldmodel#Hdhead
S1125M127681264
S2350M2410241664
S3760M2415361696
S41.3B2420483264
S52.7B3225603280
S66.7B32409632128
", + "type": "table", + "image_path": "efd2750e3b01375c95e871bf18e53f79ec6540aa3a3e96f7d9b639404e6816e8.jpg" + } + ] + } + ], + "index": 37.5, + "virtual_lines": [ + { + "bbox": [ + 217, + 540, + 394, + 554.6666666666666 + ], + "spans": [], + "index": 35 + }, + { + "bbox": [ + 217, + 554.6666666666666, + 394, + 569.3333333333333 + ], + "spans": [], + "index": 36 + }, + { + "bbox": [ + 217, + 569.3333333333333, + 394, + 583.9999999999999 + ], + "spans": [], + "index": 37 + }, + { + "bbox": [ + 217, + 583.9999999999999, + 394, + 598.6666666666665 + ], + "spans": [], + "index": 38 + }, + { + "bbox": [ + 217, + 598.6666666666665, + 394, + 613.3333333333331 + ], + "spans": [], + "index": 39 + }, + { + "bbox": [ + 217, + 613.3333333333331, + 394, + 627.9999999999998 + ], + "spans": [], + "index": 40 + } + ] + } + ], + "index": 37.5 + } + ], + "page_idx": 12, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 741, + 311, + 750 + ], + "lines": [ + { + "bbox": [ + 299, + 740, + 312, + 754 + ], + "spans": [ + { + "bbox": [ + 299, + 740, + 312, + 754 + ], + "score": 1.0, + "content": "13", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 71, + 254, + 85 + ], + "lines": [ + { + "bbox": [ + 105, + 70, + 256, + 88 + ], + "spans": [ + { + "bbox": [ + 105, + 70, + 256, + 88 + ], + "score": 1.0, + "content": "A Supplementary Material", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "title", + "bbox": [ + 107, + 95, + 202, + 108 + ], + "lines": [ + { + "bbox": [ + 105, + 95, + 203, + 109 + ], + "spans": [ + { + "bbox": [ + 105, + 95, + 203, + 109 + ], + "score": 1.0, + "content": "A.1 Training Details", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 106, + 115, + 505, + 214 + ], + "lines": [ + { + "bbox": [ + 106, + 115, + 506, + 128 + ], + "spans": [ + { + "bbox": [ + 106, + 115, + 506, + 128 + ], + "score": 1.0, + "content": "To ensure stable training, we applied gradient clipping with a maximum norm of 1.0 and used the", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 106, + 127, + 505, + 140 + ], + "spans": [ + { + "bbox": [ + 106, + 127, + 195, + 140 + ], + "score": 1.0, + "content": "Adam optimizer with", + "type": "text" + }, + { + "bbox": [ + 195, + 127, + 232, + 138 + ], + "score": 0.89, + "content": "\\beta _ { 1 } = 0 . 9", + "type": "inline_equation" + }, + { + "bbox": [ + 233, + 127, + 236, + 140 + ], + "score": 1.0, + "content": ",", + "type": "text" + }, + { + "bbox": [ + 236, + 127, + 279, + 138 + ], + "score": 0.87, + "content": "\\beta _ { 2 } = 0 . 9 8", + "type": "inline_equation" + }, + { + "bbox": [ + 280, + 127, + 505, + 140 + ], + "score": 1.0, + "content": "Kingma & Ba (2015). We used the built-in polynomial", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 137, + 506, + 150 + ], + "spans": [ + { + "bbox": [ + 106, + 137, + 506, + 150 + ], + "score": 1.0, + "content": "decay learning rate scheduler in MetaSeq with 500 warmup updates and the end learning rate set", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 148, + 506, + 161 + ], + "spans": [ + { + "bbox": [ + 105, + 148, + 506, + 161 + ], + "score": 1.0, + "content": "to 0. All models are trained with pre-norm and using ReLU activation. We apply a dropout of 0.1", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 159, + 506, + 173 + ], + "spans": [ + { + "bbox": [ + 106, + 159, + 506, + 173 + ], + "score": 1.0, + "content": "throughout, but we do not apply any dropout to embeddings. We also use weight decay of 0.1. To", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 168, + 506, + 184 + ], + "spans": [ + { + "bbox": [ + 105, + 168, + 506, + 184 + ], + "score": 1.0, + "content": "initialize the weights, we use a variant based on Megatron-LM codebase, which involves using a", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 182, + 505, + 192 + ], + "spans": [ + { + "bbox": [ + 106, + 182, + 505, + 192 + ], + "score": 1.0, + "content": "normal distribution with a mean of zero and a standard deviation of 0.006. We truncate this normal", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 191, + 505, + 205 + ], + "spans": [ + { + "bbox": [ + 105, + 191, + 505, + 205 + ], + "score": 1.0, + "content": "distribution within two standard deviations and observed substantial gain in both training stability", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 202, + 179, + 217 + ], + "spans": [ + { + "bbox": [ + 105, + 202, + 179, + 217 + ], + "score": 1.0, + "content": "and performance.", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 6, + "bbox_fs": [ + 105, + 115, + 506, + 217 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 227, + 180, + 239 + ], + "lines": [ + { + "bbox": [ + 105, + 227, + 181, + 240 + ], + "spans": [ + { + "bbox": [ + 105, + 227, + 181, + 240 + ], + "score": 1.0, + "content": "A.2 Motivation", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 11 + }, + { + "type": "text", + "bbox": [ + 106, + 247, + 505, + 347 + ], + "lines": [ + { + "bbox": [ + 106, + 247, + 506, + 260 + ], + "spans": [ + { + "bbox": [ + 106, + 247, + 506, + 260 + ], + "score": 1.0, + "content": "Why is the local model needed? Many of the efficiency advantages of the MEGABYTE design could", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 258, + 505, + 271 + ], + "spans": [ + { + "bbox": [ + 105, + 258, + 505, + 271 + ], + "score": 1.0, + "content": "be realized with the Global model alone, which would resemble a decoder version of ViT (Dosovitskiy", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 104, + 268, + 506, + 284 + ], + "spans": [ + { + "bbox": [ + 104, + 268, + 336, + 284 + ], + "score": 1.0, + "content": "et al., 2020). However, the joint distribution over the patch", + "type": "text" + }, + { + "bbox": [ + 336, + 270, + 426, + 281 + ], + "score": 0.91, + "content": "p ( x _ { t + 1 } , . . , x _ { t + P } | x _ { 0 . . t } )", + "type": "inline_equation" + }, + { + "bbox": [ + 426, + 268, + 506, + 284 + ], + "score": 1.0, + "content": "has an output space", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 104, + 278, + 506, + 293 + ], + "spans": [ + { + "bbox": [ + 104, + 278, + 136, + 293 + ], + "score": 1.0, + "content": "of size", + "type": "text" + }, + { + "bbox": [ + 137, + 280, + 159, + 291 + ], + "score": 0.89, + "content": "2 5 6 ^ { P }", + "type": "inline_equation" + }, + { + "bbox": [ + 159, + 278, + 506, + 293 + ], + "score": 1.0, + "content": "so direct modeling is only tractable for very small patches. We could instead factor", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 290, + 507, + 306 + ], + "spans": [ + { + "bbox": [ + 105, + 290, + 371, + 306 + ], + "score": 1.0, + "content": "the joint distribution into conditionally independent distributions", + "type": "text" + }, + { + "bbox": [ + 372, + 291, + 486, + 303 + ], + "score": 0.92, + "content": "p ( x _ { t + 1 } | x _ { 0 . . t } ) . . p ( x _ { t + P } | x _ { 0 . . t } )", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 290, + 507, + 306 + ], + "score": 1.0, + "content": ", but", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 106, + 302, + 506, + 315 + ], + "spans": [ + { + "bbox": [ + 106, + 302, + 506, + 315 + ], + "score": 1.0, + "content": "this would greatly limit the model’s expressive power. For example, it would be unable to express", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 313, + 505, + 326 + ], + "spans": [ + { + "bbox": [ + 105, + 313, + 221, + 326 + ], + "score": 1.0, + "content": "a patch distribution such as", + "type": "text" + }, + { + "bbox": [ + 222, + 313, + 242, + 324 + ], + "score": 0.85, + "content": "50 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 242, + 313, + 276, + 326 + ], + "score": 1.0, + "content": "cat and", + "type": "text" + }, + { + "bbox": [ + 277, + 313, + 297, + 324 + ], + "score": 0.84, + "content": "50 \\%", + "type": "inline_equation" + }, + { + "bbox": [ + 297, + 313, + 505, + 326 + ], + "score": 1.0, + "content": "dog, and would instead have to assign probability", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 324, + 505, + 336 + ], + "spans": [ + { + "bbox": [ + 106, + 324, + 505, + 336 + ], + "score": 1.0, + "content": "mass to strings such as cag and dot. Instead, our autoregressive Local model conditions on previous", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 335, + 455, + 348 + ], + "spans": [ + { + "bbox": [ + 106, + 335, + 455, + 348 + ], + "score": 1.0, + "content": "characters within the patch, allowing it to only assign probability to the desired strings.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 16, + "bbox_fs": [ + 104, + 247, + 507, + 348 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 351, + 505, + 406 + ], + "lines": [ + { + "bbox": [ + 106, + 351, + 506, + 363 + ], + "spans": [ + { + "bbox": [ + 106, + 351, + 506, + 363 + ], + "score": 1.0, + "content": "Increasing Parameters for Fixed Compute Transformer models have shown consistent improve-", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 362, + 506, + 375 + ], + "spans": [ + { + "bbox": [ + 106, + 362, + 506, + 375 + ], + "score": 1.0, + "content": "ments with parameter counts (Kaplan et al., 2020). However, the size of models is limited by their", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 373, + 506, + 385 + ], + "spans": [ + { + "bbox": [ + 105, + 373, + 506, + 385 + ], + "score": 1.0, + "content": "increasing computational cost. MEGABYTE allows larger models for the same cost, both by mak-", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 384, + 505, + 397 + ], + "spans": [ + { + "bbox": [ + 106, + 384, + 505, + 397 + ], + "score": 1.0, + "content": "ing self attention sub-quadratic, and by using large feedforward layers across patches rather than", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 394, + 180, + 407 + ], + "spans": [ + { + "bbox": [ + 106, + 394, + 180, + 407 + ], + "score": 1.0, + "content": "individual tokens.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23, + "bbox_fs": [ + 105, + 351, + 506, + 407 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 411, + 505, + 444 + ], + "lines": [ + { + "bbox": [ + 107, + 412, + 505, + 423 + ], + "spans": [ + { + "bbox": [ + 107, + 412, + 505, + 423 + ], + "score": 1.0, + "content": "Re-use of Established Components MEGABYTE consists of two transformer models interleaved", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 422, + 507, + 434 + ], + "spans": [ + { + "bbox": [ + 106, + 422, + 507, + 434 + ], + "score": 1.0, + "content": "with shifting, reshaping and a linear projection. This re-use increases the likelihood that the architec-", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 433, + 364, + 446 + ], + "spans": [ + { + "bbox": [ + 106, + 433, + 364, + 446 + ], + "score": 1.0, + "content": "ture will inherit the desirable scaling properties of transformers.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27, + "bbox_fs": [ + 106, + 412, + 507, + 446 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 457, + 192, + 468 + ], + "lines": [ + { + "bbox": [ + 105, + 456, + 193, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 193, + 470 + ], + "score": 1.0, + "content": "A.3 Model Details", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 106, + 477, + 505, + 532 + ], + "lines": [ + { + "bbox": [ + 106, + 477, + 504, + 489 + ], + "spans": [ + { + "bbox": [ + 106, + 477, + 504, + 489 + ], + "score": 1.0, + "content": "As discussed in Section 4, we conduct experiments using a fixed compute and data budget across all", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 488, + 505, + 500 + ], + "spans": [ + { + "bbox": [ + 106, + 488, + 505, + 500 + ], + "score": 1.0, + "content": "models to focus our comparisons solely on the model architecture rather than training resources. To", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 500, + 506, + 511 + ], + "spans": [ + { + "bbox": [ + 106, + 500, + 506, + 511 + ], + "score": 1.0, + "content": "achieve this, we adjust model hyperparameters within each architecture so that the time taken for a", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 510, + 506, + 523 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 506, + 523 + ], + "score": 1.0, + "content": "single update is matched and then train all models for the same number of updates. We list all of", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 521, + 266, + 532 + ], + "spans": [ + { + "bbox": [ + 105, + 521, + 266, + 532 + ], + "score": 1.0, + "content": "model details in Table 12 and Table 13.", + "type": "text" + } + ], + "index": 34 + } + ], + "index": 32, + "bbox_fs": [ + 105, + 477, + 506, + 532 + ] + }, + { + "type": "table", + "bbox": [ + 217, + 540, + 394, + 628 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 217, + 540, + 394, + 628 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 217, + 540, + 394, + 628 + ], + "spans": [ + { + "bbox": [ + 217, + 540, + 394, + 628 + ], + "score": 0.97, + "html": "
Model#Ldmodel#Hdhead
S1125M127681264
S2350M2410241664
S3760M2415361696
S41.3B2420483264
S52.7B3225603280
S66.7B32409632128
", + "type": "table", + "image_path": "efd2750e3b01375c95e871bf18e53f79ec6540aa3a3e96f7d9b639404e6816e8.jpg" + } + ] + } + ], + "index": 37.5, + "virtual_lines": [ + { + "bbox": [ + 217, + 540, + 394, + 554.6666666666666 + ], + "spans": [], + "index": 35 + }, + { + "bbox": [ + 217, + 554.6666666666666, + 394, + 569.3333333333333 + ], + "spans": [], + "index": 36 + }, + { + "bbox": [ + 217, + 569.3333333333333, + 394, + 583.9999999999999 + ], + "spans": [], + "index": 37 + }, + { + "bbox": [ + 217, + 583.9999999999999, + 394, + 598.6666666666665 + ], + "spans": [], + "index": 38 + }, + { + "bbox": [ + 217, + 598.6666666666665, + 394, + 613.3333333333331 + ], + "spans": [], + "index": 39 + }, + { + "bbox": [ + 217, + 613.3333333333331, + 394, + 627.9999999999998 + ], + "spans": [], + "index": 40 + } + ] + } + ], + "index": 37.5 + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 106, + 69, + 557, + 419 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 106, + 69, + 557, + 419 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 69, + 557, + 419 + ], + "spans": [ + { + "bbox": [ + 106, + 69, + 557, + 419 + ], + "score": 0.98, + "html": "
Model(Global) SizeLocal SizeBSLRContext Length (in bytes)
arXiv
Transformer320M (D=1024,L=22)N/A2.00E-041,024
Perceiver AR248M(D=1024,L=17)N/A2.00E-048,192 (1024 latents)
MEGABYTE758M(D=2048,L=14)262M (D=1024,L=18)272482.00E-048,192 (patch size 8)
w/o Local model2.3B (D=2560,L=20)N/A481.50E-048,192 (patch size 4)
w/o global modelN/A350M (D=1024,L=24)1922.00E-048,192 (patch size 8)
w/o cross-patch Local model921M (D=2048,L=17)350M(D=1024,L=24)482.00E-048,192 (patch size 8)
w/ CNN encoder704M (D=2048,L=13)262M (D=1024,L=18)482.00E-048,192 (patch size 8)
Image task 64 (Table 2)
MEGABYTE2.7B (D=2560,L=32)350M (D=1024,L=24)22.00E-0412,288 (patch size 12)
Image task 64 (Table 4)
Transformer760M (D=1536,L=24)N/A5123.00E-042.048
Perceiver AR227M(D=1024,L=16)N/A5123.00E-0412,288 (1024 latents)
MEGABYTE1.3B (D=2048,L=24)1.3B (D=2048,L=24)2563.00E-0412,288 (patch size 12)
Image task 256
Transformer62M (D=768,L=6)N/A15362.00E-041,024
Perceiver AR62M (D=768,L=6)N/A2562.00E-048,192 (768 latents)
MEGABYTE125M (D=768,L=12)125M (D=768,L=12)162.00E-04196,608 (patch size 192)
w/o local model2.7B (D=4096,L=32)N/A162.00E-04196,608 (patch size 48)
w/o global model125M (D=768,L=12)125M (D=768,L=12)162.00E-04196,608(patch size 192)
w/o cross-patch Local model250M156M (D=768,L=15)162.00E-04196,608 (patch size 192)
w/ CNN encoder125M (D=768,L=12)125M (D=768,L=12)162.00E-04196,608 (patch size 192)
Image task 640
Transformer83M (D=768,L=8)N/A3.00E-041,024
Perceiver AR62M (D=768,L=6)N/A4800 20483.00E-044,096 (1024 latents)
MEGABYTE125M (D=768,L=12)83M (D=768,L=8)323.00E-041,228,800 (192 patch size)
audio
Transformer135M(D=768,L=13)N/A20482.00E-041024
Perceiver AR62M(D=768,L=6)N/A3842.00E-048,192 (1024 latents)
MEGABYTE350M(D=1024,L=24)125M (D=768,L=12)2562.00E-04524,288 (32 patch size)
w/o local model2.7B (D=4096,L=32)125M (D=768,L=12)2562.00E-04524,288(32 patch size)
w/o global model350M(D=1024,L=24)125M(D=768,L=12)2562.00E-04524,288 (32 patch size)
w/o cross-patch Local model350M(D=1024,L=24)146M(D=768,L=14)2562.00E-04524,288 (32 patch size)
w/ CNN encoder350M (D=1024,L=24)125M (D=768,L=12)2562.00E-04524,288 (32 patch size)
", + "type": "table", + "image_path": "32f54562f6cec38fd8ad7a5f002eac64de6c8acebf8a4d06b5ef18fc73f27e3a.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 69, + 557, + 185.66666666666669 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 185.66666666666669, + 557, + 302.33333333333337 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 302.33333333333337, + 557, + 419.00000000000006 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 107, + 419, + 506, + 459 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 417, + 506, + 430 + ], + "spans": [ + { + "bbox": [ + 105, + 417, + 506, + 430 + ], + "score": 1.0, + "content": "Table 13: Model architecture details. We report the model size, the embedding size (D), number of layaers(L),", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 428, + 505, + 440 + ], + "spans": [ + { + "bbox": [ + 106, + 428, + 505, + 440 + ], + "score": 1.0, + "content": "total batch size (BS), learning rate(LR), and context length. When we vary the number of model layers from the", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 437, + 505, + 449 + ], + "spans": [ + { + "bbox": [ + 106, + 437, + 505, + 449 + ], + "score": 1.0, + "content": "standard amount for the given size (Table 12), we note this accordingly. For PerceiverAR models, we note the", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 448, + 384, + 460 + ], + "spans": [ + { + "bbox": [ + 106, + 448, + 384, + 460 + ], + "score": 1.0, + "content": "number of latents used, and for MEGABYTE models we note the patch sizes.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + }, + { + "type": "table_caption", + "bbox": [ + 228, + 519, + 382, + 530 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 227, + 519, + 383, + 531 + ], + "spans": [ + { + "bbox": [ + 227, + 519, + 383, + 531 + ], + "score": 1.0, + "content": "Listing 1: Pseudocode of Megabyte model", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + } + ], + "index": 4.5 + }, + { + "type": "title", + "bbox": [ + 106, + 490, + 187, + 503 + ], + "lines": [ + { + "bbox": [ + 104, + 488, + 189, + 505 + ], + "spans": [ + { + "bbox": [ + 104, + 488, + 189, + 505 + ], + "score": 1.0, + "content": "B Pseudocode", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 106, + 533, + 505, + 714 + ], + "lines": [ + { + "bbox": [ + 106, + 541, + 233, + 554 + ], + "spans": [ + { + "bbox": [ + 106, + 541, + 233, + 554 + ], + "score": 1.0, + "content": "class MegaByteDecoder :", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 128, + 551, + 190, + 562 + ], + "spans": [ + { + "bbox": [ + 128, + 552, + 148, + 562 + ], + "score": 1.0, + "content": "def", + "type": "text" + }, + { + "bbox": [ + 160, + 551, + 190, + 562 + ], + "score": 1.0, + "content": "_init_", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 150, + 559, + 184, + 574 + ], + "spans": [ + { + "bbox": [ + 150, + 559, + 184, + 574 + ], + "score": 1.0, + "content": "self ,", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 151, + 572, + 225, + 585 + ], + "spans": [ + { + "bbox": [ + 151, + 572, + 225, + 585 + ], + "score": 1.0, + "content": "global_args ,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 151, + 581, + 221, + 594 + ], + "spans": [ + { + "bbox": [ + 151, + 581, + 221, + 594 + ], + "score": 1.0, + "content": "local_args ,", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 151, + 592, + 218, + 605 + ], + "spans": [ + { + "bbox": [ + 151, + 592, + 218, + 605 + ], + "score": 1.0, + "content": "patch_size ,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 128, + 601, + 143, + 614 + ], + "spans": [ + { + "bbox": [ + 128, + 601, + 143, + 614 + ], + "score": 1.0, + "content": ") :", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 150, + 611, + 221, + 623 + ], + "spans": [ + { + "bbox": [ + 150, + 611, + 201, + 623 + ], + "score": 1.0, + "content": "self . pad", + "type": "text" + }, + { + "bbox": [ + 201, + 612, + 221, + 622 + ], + "score": 0.52, + "content": "\\qquad = \\quad 0", + "type": "inline_equation" + } + ], + "index": 16 + }, + { + "bbox": [ + 151, + 622, + 312, + 633 + ], + "spans": [ + { + "bbox": [ + 151, + 622, + 241, + 633 + ], + "score": 1.0, + "content": "self . patch_size", + "type": "text" + }, + { + "bbox": [ + 241, + 623, + 250, + 631 + ], + "score": 0.78, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 250, + 622, + 312, + 633 + ], + "score": 1.0, + "content": "patch_size", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 151, + 631, + 435, + 644 + ], + "spans": [ + { + "bbox": [ + 151, + 631, + 246, + 644 + ], + "score": 1.0, + "content": "self . globalmodel", + "type": "text" + }, + { + "bbox": [ + 246, + 633, + 256, + 641 + ], + "score": 0.82, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 256, + 631, + 435, + 644 + ], + "score": 1.0, + "content": "TransformerDecoder ( global_args )", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 151, + 640, + 424, + 653 + ], + "spans": [ + { + "bbox": [ + 151, + 640, + 241, + 653 + ], + "score": 1.0, + "content": "self . localmodel", + "type": "text" + }, + { + "bbox": [ + 241, + 643, + 250, + 651 + ], + "score": 0.82, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 250, + 640, + 424, + 653 + ], + "score": 1.0, + "content": "TransformerDecoder ( local_args )", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 129, + 661, + 199, + 673 + ], + "spans": [ + { + "bbox": [ + 129, + 662, + 149, + 672 + ], + "score": 1.0, + "content": "def", + "type": "text" + }, + { + "bbox": [ + 150, + 661, + 199, + 673 + ], + "score": 1.0, + "content": "forward (", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 150, + 669, + 184, + 684 + ], + "spans": [ + { + "bbox": [ + 150, + 669, + 184, + 684 + ], + "score": 1.0, + "content": "self ,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 151, + 681, + 189, + 694 + ], + "spans": [ + { + "bbox": [ + 151, + 681, + 189, + 694 + ], + "score": 1.0, + "content": "bytes ,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 127, + 690, + 144, + 704 + ], + "spans": [ + { + "bbox": [ + 127, + 690, + 144, + 704 + ], + "score": 1.0, + "content": ") :", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 151, + 700, + 452, + 714 + ], + "spans": [ + { + "bbox": [ + 151, + 700, + 297, + 714 + ], + "score": 1.0, + "content": "bytes_global , bytes_local", + "type": "text" + }, + { + "bbox": [ + 298, + 703, + 306, + 710 + ], + "score": 0.66, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 307, + 700, + 452, + 714 + ], + "score": 1.0, + "content": "self . prepare_input ( bytes )", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 16.5 + } + ], + "page_idx": 13, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 741, + 311, + 750 + ], + "lines": [ + { + "bbox": [ + 299, + 740, + 313, + 754 + ], + "spans": [ + { + "bbox": [ + 299, + 740, + 313, + 754 + ], + "score": 1.0, + "content": "14", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 106, + 69, + 557, + 419 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 106, + 69, + 557, + 419 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 69, + 557, + 419 + ], + "spans": [ + { + "bbox": [ + 106, + 69, + 557, + 419 + ], + "score": 0.98, + "html": "
Model(Global) SizeLocal SizeBSLRContext Length (in bytes)
arXiv
Transformer320M (D=1024,L=22)N/A2.00E-041,024
Perceiver AR248M(D=1024,L=17)N/A2.00E-048,192 (1024 latents)
MEGABYTE758M(D=2048,L=14)262M (D=1024,L=18)272482.00E-048,192 (patch size 8)
w/o Local model2.3B (D=2560,L=20)N/A481.50E-048,192 (patch size 4)
w/o global modelN/A350M (D=1024,L=24)1922.00E-048,192 (patch size 8)
w/o cross-patch Local model921M (D=2048,L=17)350M(D=1024,L=24)482.00E-048,192 (patch size 8)
w/ CNN encoder704M (D=2048,L=13)262M (D=1024,L=18)482.00E-048,192 (patch size 8)
Image task 64 (Table 2)
MEGABYTE2.7B (D=2560,L=32)350M (D=1024,L=24)22.00E-0412,288 (patch size 12)
Image task 64 (Table 4)
Transformer760M (D=1536,L=24)N/A5123.00E-042.048
Perceiver AR227M(D=1024,L=16)N/A5123.00E-0412,288 (1024 latents)
MEGABYTE1.3B (D=2048,L=24)1.3B (D=2048,L=24)2563.00E-0412,288 (patch size 12)
Image task 256
Transformer62M (D=768,L=6)N/A15362.00E-041,024
Perceiver AR62M (D=768,L=6)N/A2562.00E-048,192 (768 latents)
MEGABYTE125M (D=768,L=12)125M (D=768,L=12)162.00E-04196,608 (patch size 192)
w/o local model2.7B (D=4096,L=32)N/A162.00E-04196,608 (patch size 48)
w/o global model125M (D=768,L=12)125M (D=768,L=12)162.00E-04196,608(patch size 192)
w/o cross-patch Local model250M156M (D=768,L=15)162.00E-04196,608 (patch size 192)
w/ CNN encoder125M (D=768,L=12)125M (D=768,L=12)162.00E-04196,608 (patch size 192)
Image task 640
Transformer83M (D=768,L=8)N/A3.00E-041,024
Perceiver AR62M (D=768,L=6)N/A4800 20483.00E-044,096 (1024 latents)
MEGABYTE125M (D=768,L=12)83M (D=768,L=8)323.00E-041,228,800 (192 patch size)
audio
Transformer135M(D=768,L=13)N/A20482.00E-041024
Perceiver AR62M(D=768,L=6)N/A3842.00E-048,192 (1024 latents)
MEGABYTE350M(D=1024,L=24)125M (D=768,L=12)2562.00E-04524,288 (32 patch size)
w/o local model2.7B (D=4096,L=32)125M (D=768,L=12)2562.00E-04524,288(32 patch size)
w/o global model350M(D=1024,L=24)125M(D=768,L=12)2562.00E-04524,288 (32 patch size)
w/o cross-patch Local model350M(D=1024,L=24)146M(D=768,L=14)2562.00E-04524,288 (32 patch size)
w/ CNN encoder350M (D=1024,L=24)125M (D=768,L=12)2562.00E-04524,288 (32 patch size)
", + "type": "table", + "image_path": "32f54562f6cec38fd8ad7a5f002eac64de6c8acebf8a4d06b5ef18fc73f27e3a.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 69, + 557, + 185.66666666666669 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 185.66666666666669, + 557, + 302.33333333333337 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 302.33333333333337, + 557, + 419.00000000000006 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 107, + 419, + 506, + 459 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 417, + 506, + 430 + ], + "spans": [ + { + "bbox": [ + 105, + 417, + 506, + 430 + ], + "score": 1.0, + "content": "Table 13: Model architecture details. We report the model size, the embedding size (D), number of layaers(L),", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 428, + 505, + 440 + ], + "spans": [ + { + "bbox": [ + 106, + 428, + 505, + 440 + ], + "score": 1.0, + "content": "total batch size (BS), learning rate(LR), and context length. When we vary the number of model layers from the", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 437, + 505, + 449 + ], + "spans": [ + { + "bbox": [ + 106, + 437, + 505, + 449 + ], + "score": 1.0, + "content": "standard amount for the given size (Table 12), we note this accordingly. For PerceiverAR models, we note the", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 106, + 448, + 384, + 460 + ], + "spans": [ + { + "bbox": [ + 106, + 448, + 384, + 460 + ], + "score": 1.0, + "content": "number of latents used, and for MEGABYTE models we note the patch sizes.", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 4.5 + }, + { + "type": "table_caption", + "bbox": [ + 228, + 519, + 382, + 530 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 227, + 519, + 383, + 531 + ], + "spans": [ + { + "bbox": [ + 227, + 519, + 383, + 531 + ], + "score": 1.0, + "content": "Listing 1: Pseudocode of Megabyte model", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 8 + } + ], + "index": 4.5 + }, + { + "type": "title", + "bbox": [ + 106, + 490, + 187, + 503 + ], + "lines": [ + { + "bbox": [ + 104, + 488, + 189, + 505 + ], + "spans": [ + { + "bbox": [ + 104, + 488, + 189, + 505 + ], + "score": 1.0, + "content": "B Pseudocode", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 7 + }, + { + "type": "text", + "bbox": [ + 106, + 533, + 505, + 714 + ], + "lines": [ + { + "bbox": [ + 106, + 541, + 233, + 554 + ], + "spans": [ + { + "bbox": [ + 106, + 541, + 233, + 554 + ], + "score": 1.0, + "content": "class MegaByteDecoder :", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 128, + 551, + 190, + 562 + ], + "spans": [ + { + "bbox": [ + 128, + 552, + 148, + 562 + ], + "score": 1.0, + "content": "def", + "type": "text" + }, + { + "bbox": [ + 160, + 551, + 190, + 562 + ], + "score": 1.0, + "content": "_init_", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 150, + 559, + 184, + 574 + ], + "spans": [ + { + "bbox": [ + 150, + 559, + 184, + 574 + ], + "score": 1.0, + "content": "self ,", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 151, + 572, + 225, + 585 + ], + "spans": [ + { + "bbox": [ + 151, + 572, + 225, + 585 + ], + "score": 1.0, + "content": "global_args ,", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 151, + 581, + 221, + 594 + ], + "spans": [ + { + "bbox": [ + 151, + 581, + 221, + 594 + ], + "score": 1.0, + "content": "local_args ,", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 151, + 592, + 218, + 605 + ], + "spans": [ + { + "bbox": [ + 151, + 592, + 218, + 605 + ], + "score": 1.0, + "content": "patch_size ,", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 128, + 601, + 143, + 614 + ], + "spans": [ + { + "bbox": [ + 128, + 601, + 143, + 614 + ], + "score": 1.0, + "content": ") :", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 150, + 611, + 221, + 623 + ], + "spans": [ + { + "bbox": [ + 150, + 611, + 201, + 623 + ], + "score": 1.0, + "content": "self . pad", + "type": "text" + }, + { + "bbox": [ + 201, + 612, + 221, + 622 + ], + "score": 0.52, + "content": "\\qquad = \\quad 0", + "type": "inline_equation" + } + ], + "index": 16 + }, + { + "bbox": [ + 151, + 622, + 312, + 633 + ], + "spans": [ + { + "bbox": [ + 151, + 622, + 241, + 633 + ], + "score": 1.0, + "content": "self . patch_size", + "type": "text" + }, + { + "bbox": [ + 241, + 623, + 250, + 631 + ], + "score": 0.78, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 250, + 622, + 312, + 633 + ], + "score": 1.0, + "content": "patch_size", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 151, + 631, + 435, + 644 + ], + "spans": [ + { + "bbox": [ + 151, + 631, + 246, + 644 + ], + "score": 1.0, + "content": "self . globalmodel", + "type": "text" + }, + { + "bbox": [ + 246, + 633, + 256, + 641 + ], + "score": 0.82, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 256, + 631, + 435, + 644 + ], + "score": 1.0, + "content": "TransformerDecoder ( global_args )", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 151, + 640, + 424, + 653 + ], + "spans": [ + { + "bbox": [ + 151, + 640, + 241, + 653 + ], + "score": 1.0, + "content": "self . localmodel", + "type": "text" + }, + { + "bbox": [ + 241, + 643, + 250, + 651 + ], + "score": 0.82, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 250, + 640, + 424, + 653 + ], + "score": 1.0, + "content": "TransformerDecoder ( local_args )", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 129, + 661, + 199, + 673 + ], + "spans": [ + { + "bbox": [ + 129, + 662, + 149, + 672 + ], + "score": 1.0, + "content": "def", + "type": "text" + }, + { + "bbox": [ + 150, + 661, + 199, + 673 + ], + "score": 1.0, + "content": "forward (", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 150, + 669, + 184, + 684 + ], + "spans": [ + { + "bbox": [ + 150, + 669, + 184, + 684 + ], + "score": 1.0, + "content": "self ,", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 151, + 681, + 189, + 694 + ], + "spans": [ + { + "bbox": [ + 151, + 681, + 189, + 694 + ], + "score": 1.0, + "content": "bytes ,", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 127, + 690, + 144, + 704 + ], + "spans": [ + { + "bbox": [ + 127, + 690, + 144, + 704 + ], + "score": 1.0, + "content": ") :", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 151, + 700, + 452, + 714 + ], + "spans": [ + { + "bbox": [ + 151, + 700, + 297, + 714 + ], + "score": 1.0, + "content": "bytes_global , bytes_local", + "type": "text" + }, + { + "bbox": [ + 298, + 703, + 306, + 710 + ], + "score": 0.66, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 307, + 700, + 452, + 714 + ], + "score": 1.0, + "content": "self . prepare_input ( bytes )", + "type": "text" + } + ], + "index": 24 + } + ], + "index": 16.5, + "bbox_fs": [ + 106, + 541, + 452, + 714 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 74, + 504, + 436 + ], + "lines": [ + { + "bbox": [ + 151, + 73, + 492, + 85 + ], + "spans": [ + { + "bbox": [ + 151, + 73, + 275, + 85 + ], + "score": 1.0, + "content": "global_bytes_embedded", + "type": "text" + }, + { + "bbox": [ + 275, + 75, + 284, + 82 + ], + "score": 0.72, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 284, + 73, + 492, + 85 + ], + "score": 1.0, + "content": "self . globalmodel . embed ( bytes_global )", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 151, + 83, + 280, + 95 + ], + "spans": [ + { + "bbox": [ + 151, + 83, + 207, + 95 + ], + "score": 1.0, + "content": "global_in", + "type": "text" + }, + { + "bbox": [ + 207, + 85, + 216, + 92 + ], + "score": 0.75, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 216, + 83, + 280, + 95 + ], + "score": 1.0, + "content": "rearrange (", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 173, + 92, + 299, + 104 + ], + "spans": [ + { + "bbox": [ + 173, + 92, + 299, + 104 + ], + "score": 1.0, + "content": "global_bytes_embedded ,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 173, + 101, + 314, + 116 + ], + "spans": [ + { + "bbox": [ + 173, + 101, + 314, + 116 + ], + "score": 1.0, + "content": "\"b (t p) e -> b t (p e)\",", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 174, + 113, + 279, + 126 + ], + "spans": [ + { + "bbox": [ + 174, + 114, + 186, + 124 + ], + "score": 0.39, + "content": "\\mathtt { p } =", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 113, + 279, + 126 + ], + "score": 1.0, + "content": "self . patch_size ,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 151, + 123, + 160, + 133 + ], + "spans": [ + { + "bbox": [ + 151, + 123, + 160, + 133 + ], + "score": 1.0, + "content": ")", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 150, + 132, + 396, + 145 + ], + "spans": [ + { + "bbox": [ + 150, + 132, + 230, + 145 + ], + "score": 1.0, + "content": "global_output", + "type": "text" + }, + { + "bbox": [ + 230, + 135, + 239, + 142 + ], + "score": 0.71, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 239, + 132, + 396, + 145 + ], + "score": 1.0, + "content": "self . globalmodel ( global_in )", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 150, + 152, + 352, + 166 + ], + "spans": [ + { + "bbox": [ + 150, + 152, + 280, + 166 + ], + "score": 1.0, + "content": "global_output_reshaped", + "type": "text" + }, + { + "bbox": [ + 281, + 154, + 290, + 162 + ], + "score": 0.72, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 290, + 152, + 352, + 166 + ], + "score": 1.0, + "content": "rearrange (", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 174, + 163, + 255, + 175 + ], + "spans": [ + { + "bbox": [ + 174, + 163, + 255, + 175 + ], + "score": 1.0, + "content": "global_output ,", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 174, + 171, + 314, + 185 + ], + "spans": [ + { + "bbox": [ + 174, + 172, + 217, + 185 + ], + "score": 1.0, + "content": "\"b t (p", + "type": "text" + }, + { + "bbox": [ + 219, + 174, + 231, + 182 + ], + "score": 1.0, + "content": "e)", + "type": "text" + }, + { + "bbox": [ + 235, + 174, + 249, + 182 + ], + "score": 1.0, + "content": "->", + "type": "text" + }, + { + "bbox": [ + 253, + 171, + 284, + 185 + ], + "score": 1.0, + "content": "(b t)", + "type": "text" + }, + { + "bbox": [ + 286, + 175, + 295, + 184 + ], + "score": 1.0, + "content": "p", + "type": "text" + }, + { + "bbox": [ + 297, + 173, + 314, + 183 + ], + "score": 1.0, + "content": "e\",", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 173, + 182, + 279, + 195 + ], + "spans": [ + { + "bbox": [ + 173, + 182, + 279, + 195 + ], + "score": 1.0, + "content": "p = self . patch_size ,", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 150, + 192, + 160, + 204 + ], + "spans": [ + { + "bbox": [ + 150, + 192, + 160, + 204 + ], + "score": 1.0, + "content": ")", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 151, + 202, + 474, + 214 + ], + "spans": [ + { + "bbox": [ + 151, + 202, + 269, + 214 + ], + "score": 1.0, + "content": "local_bytes_embedded", + "type": "text" + }, + { + "bbox": [ + 269, + 204, + 279, + 212 + ], + "score": 0.79, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 202, + 474, + 214 + ], + "score": 1.0, + "content": "self . localmodel . embed ( bytes_local )", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 150, + 212, + 470, + 225 + ], + "spans": [ + { + "bbox": [ + 150, + 212, + 201, + 225 + ], + "score": 1.0, + "content": "local_in", + "type": "text" + }, + { + "bbox": [ + 201, + 214, + 211, + 222 + ], + "score": 0.77, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 211, + 212, + 331, + 225 + ], + "score": 1.0, + "content": "local_bytes_embedded", + "type": "text" + }, + { + "bbox": [ + 331, + 214, + 340, + 222 + ], + "score": 0.42, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 212, + 470, + 225 + ], + "score": 1.0, + "content": "global_output_reshaped", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 151, + 222, + 380, + 235 + ], + "spans": [ + { + "bbox": [ + 151, + 222, + 223, + 235 + ], + "score": 1.0, + "content": "local_output", + "type": "text" + }, + { + "bbox": [ + 224, + 224, + 234, + 232 + ], + "score": 0.73, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 234, + 222, + 380, + 235 + ], + "score": 1.0, + "content": "self . localmodel ( local_in )", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 150, + 241, + 345, + 254 + ], + "spans": [ + { + "bbox": [ + 150, + 241, + 213, + 254 + ], + "score": 1.0, + "content": "batch_size", + "type": "text" + }, + { + "bbox": [ + 213, + 244, + 222, + 252 + ], + "score": 0.73, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 222, + 241, + 345, + 254 + ], + "score": 1.0, + "content": "bytes_global . shape [0]", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 149, + 252, + 476, + 265 + ], + "spans": [ + { + "bbox": [ + 149, + 252, + 162, + 265 + ], + "score": 1.0, + "content": "x", + "type": "text" + }, + { + "bbox": [ + 163, + 254, + 171, + 262 + ], + "score": 0.39, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 172, + 252, + 346, + 265 + ], + "score": 1.0, + "content": "rearrange ( local_output , \"(b t)", + "type": "text" + }, + { + "bbox": [ + 348, + 252, + 476, + 264 + ], + "score": 1.0, + "content": "l v -> b (t l) v\", b =", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 171, + 261, + 236, + 274 + ], + "spans": [ + { + "bbox": [ + 171, + 261, + 236, + 274 + ], + "score": 1.0, + "content": "batch_size )", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 151, + 273, + 201, + 284 + ], + "spans": [ + { + "bbox": [ + 151, + 273, + 201, + 284 + ], + "score": 1.0, + "content": "return x", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 128, + 292, + 306, + 304 + ], + "spans": [ + { + "bbox": [ + 128, + 293, + 149, + 304 + ], + "score": 1.0, + "content": "def", + "type": "text" + }, + { + "bbox": [ + 149, + 292, + 306, + 304 + ], + "score": 1.0, + "content": "prepare_input ( self , bytes ) :", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 149, + 301, + 492, + 315 + ], + "spans": [ + { + "bbox": [ + 149, + 301, + 235, + 315 + ], + "score": 1.0, + "content": "padding_global", + "type": "text" + }, + { + "bbox": [ + 235, + 304, + 245, + 312 + ], + "score": 0.76, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 245, + 301, + 492, + 315 + ], + "score": 1.0, + "content": "bytes . new ( bytes . shape [0] , self . patch_size ) .", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 171, + 311, + 258, + 324 + ], + "spans": [ + { + "bbox": [ + 171, + 311, + 258, + 324 + ], + "score": 1.0, + "content": "fill_ ( self . pad )", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 151, + 322, + 487, + 334 + ], + "spans": [ + { + "bbox": [ + 151, + 322, + 224, + 334 + ], + "score": 1.0, + "content": "bytes_global", + "type": "text" + }, + { + "bbox": [ + 224, + 324, + 233, + 331 + ], + "score": 0.74, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 234, + 322, + 487, + 334 + ], + "score": 1.0, + "content": "torch . cat (( padding_global , bytes [: , : - self .", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 170, + 332, + 270, + 344 + ], + "spans": [ + { + "bbox": [ + 170, + 332, + 270, + 344 + ], + "score": 1.0, + "content": "patch_size ]) , -1)", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 151, + 351, + 492, + 365 + ], + "spans": [ + { + "bbox": [ + 151, + 351, + 218, + 365 + ], + "score": 1.0, + "content": "bytes_input", + "type": "text" + }, + { + "bbox": [ + 218, + 354, + 228, + 361 + ], + "score": 0.67, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 351, + 450, + 365 + ], + "score": 1.0, + "content": "rearrange ( bytes , \"b (t p) -> (b t) p\",", + "type": "text" + }, + { + "bbox": [ + 450, + 353, + 486, + 364 + ], + "score": 0.72, + "content": "\\mathtt { p } = \\mathtt { s e l f }", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 351, + 492, + 365 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 171, + 363, + 237, + 372 + ], + "spans": [ + { + "bbox": [ + 171, + 363, + 237, + 372 + ], + "score": 1.0, + "content": "patch_size )", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 149, + 371, + 501, + 385 + ], + "spans": [ + { + "bbox": [ + 149, + 371, + 229, + 385 + ], + "score": 1.0, + "content": "padding_local", + "type": "text" + }, + { + "bbox": [ + 230, + 374, + 239, + 381 + ], + "score": 0.76, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 239, + 371, + 501, + 385 + ], + "score": 1.0, + "content": "bytes_input . new ( bytes_input . shape [0] , 1) . fill_", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 172, + 382, + 231, + 393 + ], + "spans": [ + { + "bbox": [ + 172, + 382, + 231, + 393 + ], + "score": 1.0, + "content": "( self . pad )", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 151, + 391, + 500, + 405 + ], + "spans": [ + { + "bbox": [ + 151, + 391, + 218, + 405 + ], + "score": 1.0, + "content": "bytes_local", + "type": "text" + }, + { + "bbox": [ + 218, + 393, + 228, + 401 + ], + "score": 0.77, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 391, + 500, + 405 + ], + "score": 1.0, + "content": "torch . cat (( padding_local , bytes_input [: , : -1]) ,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 170, + 402, + 191, + 413 + ], + "spans": [ + { + "bbox": [ + 170, + 402, + 191, + 413 + ], + "score": 1.0, + "content": "-1)", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 152, + 421, + 334, + 434 + ], + "spans": [ + { + "bbox": [ + 152, + 423, + 188, + 433 + ], + "score": 1.0, + "content": "return", + "type": "text" + }, + { + "bbox": [ + 189, + 421, + 334, + 434 + ], + "score": 1.0, + "content": "bytes_global , bytes_local", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 15 + }, + { + "type": "title", + "bbox": [ + 108, + 461, + 279, + 475 + ], + "lines": [ + { + "bbox": [ + 105, + 460, + 279, + 478 + ], + "spans": [ + { + "bbox": [ + 105, + 460, + 279, + 478 + ], + "score": 1.0, + "content": "C PerceiverAR Implementation", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 107, + 489, + 505, + 610 + ], + "lines": [ + { + "bbox": [ + 105, + 489, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 489, + 505, + 502 + ], + "score": 1.0, + "content": "To reproduce PerceiverAR in a compute-controlled setting we extended the standard transformer", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 500, + 505, + 512 + ], + "spans": [ + { + "bbox": [ + 106, + 500, + 505, + 512 + ], + "score": 1.0, + "content": "implementation in metaseq with an additonal cross attention layer to compute the latents and match", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 510, + 506, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 506, + 524 + ], + "score": 1.0, + "content": "the architecture of PerceiverAR. We trained the model by sampling random spans from each text,", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 521, + 506, + 535 + ], + "spans": [ + { + "bbox": [ + 105, + 521, + 506, + 535 + ], + "score": 1.0, + "content": "matching the procedure used in the PerceiverAR codebase. To be consistent with the original work,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 533, + 506, + 545 + ], + "spans": [ + { + "bbox": [ + 106, + 533, + 506, + 545 + ], + "score": 1.0, + "content": "we use sliding window evaluation with a stride of num_latents/2 unless otherwise noted. In several", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 544, + 506, + 556 + ], + "spans": [ + { + "bbox": [ + 106, + 544, + 506, + 556 + ], + "score": 1.0, + "content": "cases we used the standard metaseq implementation as opposed to specific techniques reported in", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 555, + 504, + 567 + ], + "spans": [ + { + "bbox": [ + 106, + 555, + 504, + 567 + ], + "score": 1.0, + "content": "the original paper: 1) we used standard attention dropout instead of cross-attention dropout 2) We", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 565, + 506, + 578 + ], + "spans": [ + { + "bbox": [ + 106, + 565, + 506, + 578 + ], + "score": 1.0, + "content": "did not implement chunked attention. We verified our implementation by reproducing the \"Standard", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 575, + 506, + 589 + ], + "spans": [ + { + "bbox": [ + 105, + 575, + 506, + 589 + ], + "score": 1.0, + "content": "Ordering\" experiments in Table 5 of the Perceiver AR paper. After carefully matching context size,", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 587, + 504, + 600 + ], + "spans": [ + { + "bbox": [ + 106, + 587, + 468, + 600 + ], + "score": 1.0, + "content": "number of latents, the amount of data and training steps used and learning rate, we achieved", + "type": "text" + }, + { + "bbox": [ + 468, + 587, + 504, + 599 + ], + "score": 0.26, + "content": "3 . 5 3 \\mathrm { b p b }", + "type": "inline_equation" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 598, + 258, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 258, + 612 + ], + "score": 1.0, + "content": "vs 3.54 reported in the original paper.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 37 + }, + { + "type": "title", + "bbox": [ + 106, + 629, + 193, + 642 + ], + "lines": [ + { + "bbox": [ + 105, + 627, + 194, + 645 + ], + "spans": [ + { + "bbox": [ + 105, + 627, + 194, + 645 + ], + "score": 1.0, + "content": "D More results", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 43 + }, + { + "type": "title", + "bbox": [ + 108, + 656, + 248, + 668 + ], + "lines": [ + { + "bbox": [ + 105, + 655, + 250, + 670 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 250, + 670 + ], + "score": 1.0, + "content": "D.1 Patch scan Implementation", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 44 + }, + { + "type": "text", + "bbox": [ + 107, + 678, + 504, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 677, + 506, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 334, + 691 + ], + "score": 1.0, + "content": "Images have a natural structure, containing a grid of", + "type": "text" + }, + { + "bbox": [ + 334, + 679, + 361, + 689 + ], + "score": 0.89, + "content": "n \\times n", + "type": "inline_equation" + }, + { + "bbox": [ + 362, + 677, + 506, + 691 + ], + "score": 1.0, + "content": "pixels each composed of 3 bytes", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 689, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 689, + 506, + 702 + ], + "score": 1.0, + "content": "(corresponding to color channels). We explore two ways of converting images to sequences for", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 700, + 506, + 713 + ], + "spans": [ + { + "bbox": [ + 105, + 700, + 506, + 713 + ], + "score": 1.0, + "content": "modeling (see Figure 4). Firstly, raster scan where the pixels are linearized into 3 bytes and", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 711, + 506, + 724 + ], + "spans": [ + { + "bbox": [ + 105, + 711, + 439, + 724 + ], + "score": 1.0, + "content": "concatenated row-by-row. Secondly, patch scan where we create patches of shape", + "type": "text" + }, + { + "bbox": [ + 439, + 711, + 480, + 722 + ], + "score": 0.92, + "content": "p \\times p \\times 3", + "type": "inline_equation" + }, + { + "bbox": [ + 480, + 711, + 506, + 724 + ], + "score": 1.0, + "content": "bytes", + "type": "text" + } + ], + "index": 48 + } + ], + "index": 46.5 + } + ], + "page_idx": 14, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 742, + 311, + 750 + ], + "lines": [ + { + "bbox": [ + 299, + 740, + 312, + 754 + ], + "spans": [ + { + "bbox": [ + 299, + 740, + 312, + 754 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 14, + "width": 13 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 105, + 74, + 504, + 436 + ], + "lines": [ + { + "bbox": [ + 151, + 73, + 492, + 85 + ], + "spans": [ + { + "bbox": [ + 151, + 73, + 275, + 85 + ], + "score": 1.0, + "content": "global_bytes_embedded", + "type": "text" + }, + { + "bbox": [ + 275, + 75, + 284, + 82 + ], + "score": 0.72, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 284, + 73, + 492, + 85 + ], + "score": 1.0, + "content": "self . globalmodel . embed ( bytes_global )", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 151, + 83, + 280, + 95 + ], + "spans": [ + { + "bbox": [ + 151, + 83, + 207, + 95 + ], + "score": 1.0, + "content": "global_in", + "type": "text" + }, + { + "bbox": [ + 207, + 85, + 216, + 92 + ], + "score": 0.75, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 216, + 83, + 280, + 95 + ], + "score": 1.0, + "content": "rearrange (", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 173, + 92, + 299, + 104 + ], + "spans": [ + { + "bbox": [ + 173, + 92, + 299, + 104 + ], + "score": 1.0, + "content": "global_bytes_embedded ,", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 173, + 101, + 314, + 116 + ], + "spans": [ + { + "bbox": [ + 173, + 101, + 314, + 116 + ], + "score": 1.0, + "content": "\"b (t p) e -> b t (p e)\",", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 174, + 113, + 279, + 126 + ], + "spans": [ + { + "bbox": [ + 174, + 114, + 186, + 124 + ], + "score": 0.39, + "content": "\\mathtt { p } =", + "type": "inline_equation" + }, + { + "bbox": [ + 187, + 113, + 279, + 126 + ], + "score": 1.0, + "content": "self . patch_size ,", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 151, + 123, + 160, + 133 + ], + "spans": [ + { + "bbox": [ + 151, + 123, + 160, + 133 + ], + "score": 1.0, + "content": ")", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 150, + 132, + 396, + 145 + ], + "spans": [ + { + "bbox": [ + 150, + 132, + 230, + 145 + ], + "score": 1.0, + "content": "global_output", + "type": "text" + }, + { + "bbox": [ + 230, + 135, + 239, + 142 + ], + "score": 0.71, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 239, + 132, + 396, + 145 + ], + "score": 1.0, + "content": "self . globalmodel ( global_in )", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 150, + 152, + 352, + 166 + ], + "spans": [ + { + "bbox": [ + 150, + 152, + 280, + 166 + ], + "score": 1.0, + "content": "global_output_reshaped", + "type": "text" + }, + { + "bbox": [ + 281, + 154, + 290, + 162 + ], + "score": 0.72, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 290, + 152, + 352, + 166 + ], + "score": 1.0, + "content": "rearrange (", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 174, + 163, + 255, + 175 + ], + "spans": [ + { + "bbox": [ + 174, + 163, + 255, + 175 + ], + "score": 1.0, + "content": "global_output ,", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 174, + 171, + 314, + 185 + ], + "spans": [ + { + "bbox": [ + 174, + 172, + 217, + 185 + ], + "score": 1.0, + "content": "\"b t (p", + "type": "text" + }, + { + "bbox": [ + 219, + 174, + 231, + 182 + ], + "score": 1.0, + "content": "e)", + "type": "text" + }, + { + "bbox": [ + 235, + 174, + 249, + 182 + ], + "score": 1.0, + "content": "->", + "type": "text" + }, + { + "bbox": [ + 253, + 171, + 284, + 185 + ], + "score": 1.0, + "content": "(b t)", + "type": "text" + }, + { + "bbox": [ + 286, + 175, + 295, + 184 + ], + "score": 1.0, + "content": "p", + "type": "text" + }, + { + "bbox": [ + 297, + 173, + 314, + 183 + ], + "score": 1.0, + "content": "e\",", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 173, + 182, + 279, + 195 + ], + "spans": [ + { + "bbox": [ + 173, + 182, + 279, + 195 + ], + "score": 1.0, + "content": "p = self . patch_size ,", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 150, + 192, + 160, + 204 + ], + "spans": [ + { + "bbox": [ + 150, + 192, + 160, + 204 + ], + "score": 1.0, + "content": ")", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 151, + 202, + 474, + 214 + ], + "spans": [ + { + "bbox": [ + 151, + 202, + 269, + 214 + ], + "score": 1.0, + "content": "local_bytes_embedded", + "type": "text" + }, + { + "bbox": [ + 269, + 204, + 279, + 212 + ], + "score": 0.79, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 279, + 202, + 474, + 214 + ], + "score": 1.0, + "content": "self . localmodel . embed ( bytes_local )", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 150, + 212, + 470, + 225 + ], + "spans": [ + { + "bbox": [ + 150, + 212, + 201, + 225 + ], + "score": 1.0, + "content": "local_in", + "type": "text" + }, + { + "bbox": [ + 201, + 214, + 211, + 222 + ], + "score": 0.77, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 211, + 212, + 331, + 225 + ], + "score": 1.0, + "content": "local_bytes_embedded", + "type": "text" + }, + { + "bbox": [ + 331, + 214, + 340, + 222 + ], + "score": 0.42, + "content": "^ +", + "type": "inline_equation" + }, + { + "bbox": [ + 340, + 212, + 470, + 225 + ], + "score": 1.0, + "content": "global_output_reshaped", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 151, + 222, + 380, + 235 + ], + "spans": [ + { + "bbox": [ + 151, + 222, + 223, + 235 + ], + "score": 1.0, + "content": "local_output", + "type": "text" + }, + { + "bbox": [ + 224, + 224, + 234, + 232 + ], + "score": 0.73, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 234, + 222, + 380, + 235 + ], + "score": 1.0, + "content": "self . localmodel ( local_in )", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 150, + 241, + 345, + 254 + ], + "spans": [ + { + "bbox": [ + 150, + 241, + 213, + 254 + ], + "score": 1.0, + "content": "batch_size", + "type": "text" + }, + { + "bbox": [ + 213, + 244, + 222, + 252 + ], + "score": 0.73, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 222, + 241, + 345, + 254 + ], + "score": 1.0, + "content": "bytes_global . shape [0]", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 149, + 252, + 476, + 265 + ], + "spans": [ + { + "bbox": [ + 149, + 252, + 162, + 265 + ], + "score": 1.0, + "content": "x", + "type": "text" + }, + { + "bbox": [ + 163, + 254, + 171, + 262 + ], + "score": 0.39, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 172, + 252, + 346, + 265 + ], + "score": 1.0, + "content": "rearrange ( local_output , \"(b t)", + "type": "text" + }, + { + "bbox": [ + 348, + 252, + 476, + 264 + ], + "score": 1.0, + "content": "l v -> b (t l) v\", b =", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 171, + 261, + 236, + 274 + ], + "spans": [ + { + "bbox": [ + 171, + 261, + 236, + 274 + ], + "score": 1.0, + "content": "batch_size )", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 151, + 273, + 201, + 284 + ], + "spans": [ + { + "bbox": [ + 151, + 273, + 201, + 284 + ], + "score": 1.0, + "content": "return x", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 128, + 292, + 306, + 304 + ], + "spans": [ + { + "bbox": [ + 128, + 293, + 149, + 304 + ], + "score": 1.0, + "content": "def", + "type": "text" + }, + { + "bbox": [ + 149, + 292, + 306, + 304 + ], + "score": 1.0, + "content": "prepare_input ( self , bytes ) :", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 149, + 301, + 492, + 315 + ], + "spans": [ + { + "bbox": [ + 149, + 301, + 235, + 315 + ], + "score": 1.0, + "content": "padding_global", + "type": "text" + }, + { + "bbox": [ + 235, + 304, + 245, + 312 + ], + "score": 0.76, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 245, + 301, + 492, + 315 + ], + "score": 1.0, + "content": "bytes . new ( bytes . shape [0] , self . patch_size ) .", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 171, + 311, + 258, + 324 + ], + "spans": [ + { + "bbox": [ + 171, + 311, + 258, + 324 + ], + "score": 1.0, + "content": "fill_ ( self . pad )", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 151, + 322, + 487, + 334 + ], + "spans": [ + { + "bbox": [ + 151, + 322, + 224, + 334 + ], + "score": 1.0, + "content": "bytes_global", + "type": "text" + }, + { + "bbox": [ + 224, + 324, + 233, + 331 + ], + "score": 0.74, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 234, + 322, + 487, + 334 + ], + "score": 1.0, + "content": "torch . cat (( padding_global , bytes [: , : - self .", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 170, + 332, + 270, + 344 + ], + "spans": [ + { + "bbox": [ + 170, + 332, + 270, + 344 + ], + "score": 1.0, + "content": "patch_size ]) , -1)", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 151, + 351, + 492, + 365 + ], + "spans": [ + { + "bbox": [ + 151, + 351, + 218, + 365 + ], + "score": 1.0, + "content": "bytes_input", + "type": "text" + }, + { + "bbox": [ + 218, + 354, + 228, + 361 + ], + "score": 0.67, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 351, + 450, + 365 + ], + "score": 1.0, + "content": "rearrange ( bytes , \"b (t p) -> (b t) p\",", + "type": "text" + }, + { + "bbox": [ + 450, + 353, + 486, + 364 + ], + "score": 0.72, + "content": "\\mathtt { p } = \\mathtt { s e l f }", + "type": "inline_equation" + }, + { + "bbox": [ + 486, + 351, + 492, + 365 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 171, + 363, + 237, + 372 + ], + "spans": [ + { + "bbox": [ + 171, + 363, + 237, + 372 + ], + "score": 1.0, + "content": "patch_size )", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 149, + 371, + 501, + 385 + ], + "spans": [ + { + "bbox": [ + 149, + 371, + 229, + 385 + ], + "score": 1.0, + "content": "padding_local", + "type": "text" + }, + { + "bbox": [ + 230, + 374, + 239, + 381 + ], + "score": 0.76, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 239, + 371, + 501, + 385 + ], + "score": 1.0, + "content": "bytes_input . new ( bytes_input . shape [0] , 1) . fill_", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 172, + 382, + 231, + 393 + ], + "spans": [ + { + "bbox": [ + 172, + 382, + 231, + 393 + ], + "score": 1.0, + "content": "( self . pad )", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 151, + 391, + 500, + 405 + ], + "spans": [ + { + "bbox": [ + 151, + 391, + 218, + 405 + ], + "score": 1.0, + "content": "bytes_local", + "type": "text" + }, + { + "bbox": [ + 218, + 393, + 228, + 401 + ], + "score": 0.77, + "content": "=", + "type": "inline_equation" + }, + { + "bbox": [ + 228, + 391, + 500, + 405 + ], + "score": 1.0, + "content": "torch . cat (( padding_local , bytes_input [: , : -1]) ,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 170, + 402, + 191, + 413 + ], + "spans": [ + { + "bbox": [ + 170, + 402, + 191, + 413 + ], + "score": 1.0, + "content": "-1)", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 152, + 421, + 334, + 434 + ], + "spans": [ + { + "bbox": [ + 152, + 423, + 188, + 433 + ], + "score": 1.0, + "content": "return", + "type": "text" + }, + { + "bbox": [ + 189, + 421, + 334, + 434 + ], + "score": 1.0, + "content": "bytes_global , bytes_local", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 15, + "bbox_fs": [ + 128, + 73, + 501, + 434 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 461, + 279, + 475 + ], + "lines": [ + { + "bbox": [ + 105, + 460, + 279, + 478 + ], + "spans": [ + { + "bbox": [ + 105, + 460, + 279, + 478 + ], + "score": 1.0, + "content": "C PerceiverAR Implementation", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 31 + }, + { + "type": "text", + "bbox": [ + 107, + 489, + 505, + 610 + ], + "lines": [ + { + "bbox": [ + 105, + 489, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 489, + 505, + 502 + ], + "score": 1.0, + "content": "To reproduce PerceiverAR in a compute-controlled setting we extended the standard transformer", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 500, + 505, + 512 + ], + "spans": [ + { + "bbox": [ + 106, + 500, + 505, + 512 + ], + "score": 1.0, + "content": "implementation in metaseq with an additonal cross attention layer to compute the latents and match", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 510, + 506, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 510, + 506, + 524 + ], + "score": 1.0, + "content": "the architecture of PerceiverAR. We trained the model by sampling random spans from each text,", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 521, + 506, + 535 + ], + "spans": [ + { + "bbox": [ + 105, + 521, + 506, + 535 + ], + "score": 1.0, + "content": "matching the procedure used in the PerceiverAR codebase. To be consistent with the original work,", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 533, + 506, + 545 + ], + "spans": [ + { + "bbox": [ + 106, + 533, + 506, + 545 + ], + "score": 1.0, + "content": "we use sliding window evaluation with a stride of num_latents/2 unless otherwise noted. In several", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 106, + 544, + 506, + 556 + ], + "spans": [ + { + "bbox": [ + 106, + 544, + 506, + 556 + ], + "score": 1.0, + "content": "cases we used the standard metaseq implementation as opposed to specific techniques reported in", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 555, + 504, + 567 + ], + "spans": [ + { + "bbox": [ + 106, + 555, + 504, + 567 + ], + "score": 1.0, + "content": "the original paper: 1) we used standard attention dropout instead of cross-attention dropout 2) We", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 106, + 565, + 506, + 578 + ], + "spans": [ + { + "bbox": [ + 106, + 565, + 506, + 578 + ], + "score": 1.0, + "content": "did not implement chunked attention. We verified our implementation by reproducing the \"Standard", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 575, + 506, + 589 + ], + "spans": [ + { + "bbox": [ + 105, + 575, + 506, + 589 + ], + "score": 1.0, + "content": "Ordering\" experiments in Table 5 of the Perceiver AR paper. After carefully matching context size,", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 106, + 587, + 504, + 600 + ], + "spans": [ + { + "bbox": [ + 106, + 587, + 468, + 600 + ], + "score": 1.0, + "content": "number of latents, the amount of data and training steps used and learning rate, we achieved", + "type": "text" + }, + { + "bbox": [ + 468, + 587, + 504, + 599 + ], + "score": 0.26, + "content": "3 . 5 3 \\mathrm { b p b }", + "type": "inline_equation" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 598, + 258, + 612 + ], + "spans": [ + { + "bbox": [ + 105, + 598, + 258, + 612 + ], + "score": 1.0, + "content": "vs 3.54 reported in the original paper.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 37, + "bbox_fs": [ + 105, + 489, + 506, + 612 + ] + }, + { + "type": "title", + "bbox": [ + 106, + 629, + 193, + 642 + ], + "lines": [ + { + "bbox": [ + 105, + 627, + 194, + 645 + ], + "spans": [ + { + "bbox": [ + 105, + 627, + 194, + 645 + ], + "score": 1.0, + "content": "D More results", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 43 + }, + { + "type": "title", + "bbox": [ + 108, + 656, + 248, + 668 + ], + "lines": [ + { + "bbox": [ + 105, + 655, + 250, + 670 + ], + "spans": [ + { + "bbox": [ + 105, + 655, + 250, + 670 + ], + "score": 1.0, + "content": "D.1 Patch scan Implementation", + "type": "text" + } + ], + "index": 44 + } + ], + "index": 44 + }, + { + "type": "text", + "bbox": [ + 107, + 678, + 504, + 722 + ], + "lines": [ + { + "bbox": [ + 105, + 677, + 506, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 334, + 691 + ], + "score": 1.0, + "content": "Images have a natural structure, containing a grid of", + "type": "text" + }, + { + "bbox": [ + 334, + 679, + 361, + 689 + ], + "score": 0.89, + "content": "n \\times n", + "type": "inline_equation" + }, + { + "bbox": [ + 362, + 677, + 506, + 691 + ], + "score": 1.0, + "content": "pixels each composed of 3 bytes", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 689, + 506, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 689, + 506, + 702 + ], + "score": 1.0, + "content": "(corresponding to color channels). We explore two ways of converting images to sequences for", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 700, + 506, + 713 + ], + "spans": [ + { + "bbox": [ + 105, + 700, + 506, + 713 + ], + "score": 1.0, + "content": "modeling (see Figure 4). Firstly, raster scan where the pixels are linearized into 3 bytes and", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 711, + 506, + 724 + ], + "spans": [ + { + "bbox": [ + 105, + 711, + 439, + 724 + ], + "score": 1.0, + "content": "concatenated row-by-row. Secondly, patch scan where we create patches of shape", + "type": "text" + }, + { + "bbox": [ + 439, + 711, + 480, + 722 + ], + "score": 0.92, + "content": "p \\times p \\times 3", + "type": "inline_equation" + }, + { + "bbox": [ + 480, + 711, + 506, + 724 + ], + "score": 1.0, + "content": "bytes", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 106, + 234, + 506, + 254 + ], + "spans": [ + { + "bbox": [ + 106, + 238, + 133, + 252 + ], + "score": 1.0, + "content": "where", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 134, + 234, + 174, + 254 + ], + "score": 0.93, + "content": "p = { \\sqrt { \\frac { P } { 3 } } }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 175, + 236, + 506, + 253 + ], + "score": 1.0, + "content": ", and then use a raster scan both within and between patches. Unless otherwise", + "type": "text", + "cross_page": true + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 252, + 356, + 265 + ], + "spans": [ + { + "bbox": [ + 105, + 252, + 356, + 265 + ], + "score": 1.0, + "content": "specified, MEGABYTE models use patch scan for image data.", + "type": "text", + "cross_page": true + } + ], + "index": 12 + } + ], + "index": 46.5, + "bbox_fs": [ + 105, + 677, + 506, + 724 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 189, + 73, + 422, + 175 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 189, + 73, + 422, + 175 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 189, + 73, + 422, + 175 + ], + "spans": [ + { + "bbox": [ + 189, + 73, + 422, + 175 + ], + "score": 0.956, + "type": "image", + "image_path": "482fa286848fccc0c9dffcb9d5c629e37eb15f80f4564e61233305e612f026f3.jpg" + } + ] + } + ], + "index": 3.5, + "virtual_lines": [ + { + "bbox": [ + 189, + 73, + 422, + 85.75 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 189, + 85.75, + 422, + 98.5 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 189, + 98.5, + 422, + 111.25 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 189, + 111.25, + 422, + 124.0 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 189, + 124.0, + 422, + 136.75 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 189, + 136.75, + 422, + 149.5 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 189, + 149.5, + 422, + 162.25 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 189, + 162.25, + 422, + 175.0 + ], + "spans": [], + "index": 7 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 184, + 504, + 215 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 185, + 505, + 196 + ], + "spans": [ + { + "bbox": [ + 105, + 185, + 505, + 196 + ], + "score": 1.0, + "content": "Figure 4: Two ways to model 2D data sequentially. Left, raster scan, by taking bytes row by row and left to", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 195, + 506, + 206 + ], + "spans": [ + { + "bbox": [ + 105, + 195, + 506, + 206 + ], + "score": 1.0, + "content": "right; right, patch scan, where we first split an image into patches, and do raster scan across patches and within a", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 205, + 201, + 215 + ], + "spans": [ + { + "bbox": [ + 105, + 205, + 133, + 215 + ], + "score": 1.0, + "content": "patch.", + "type": "text" + }, + { + "bbox": [ + 133, + 205, + 197, + 215 + ], + "score": 0.35, + "content": "( \\mathrm { T } { = } 3 6 , \\mathrm { K } { = } 9 , \\mathrm { P } { = } 4 )", + "type": "inline_equation" + }, + { + "bbox": [ + 197, + 205, + 201, + 215 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9 + } + ], + "index": 6.25 + }, + { + "type": "text", + "bbox": [ + 107, + 234, + 504, + 264 + ], + "lines": [ + { + "bbox": [ + 106, + 234, + 506, + 254 + ], + "spans": [ + { + "bbox": [ + 106, + 238, + 133, + 252 + ], + "score": 1.0, + "content": "where", + "type": "text" + }, + { + "bbox": [ + 134, + 234, + 174, + 254 + ], + "score": 0.93, + "content": "p = { \\sqrt { \\frac { P } { 3 } } }", + "type": "inline_equation" + }, + { + "bbox": [ + 175, + 236, + 506, + 253 + ], + "score": 1.0, + "content": ", and then use a raster scan both within and between patches. Unless otherwise", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 252, + 356, + 265 + ], + "spans": [ + { + "bbox": [ + 105, + 252, + 356, + 265 + ], + "score": 1.0, + "content": "specified, MEGABYTE models use patch scan for image data.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 11.5 + }, + { + "type": "title", + "bbox": [ + 107, + 277, + 242, + 289 + ], + "lines": [ + { + "bbox": [ + 106, + 276, + 243, + 290 + ], + "spans": [ + { + "bbox": [ + 106, + 276, + 243, + 290 + ], + "score": 1.0, + "content": "D.2 Patch scan vs Raster scan", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 107, + 297, + 507, + 330 + ], + "lines": [ + { + "bbox": [ + 105, + 296, + 506, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 296, + 506, + 310 + ], + "score": 1.0, + "content": "The patch scan method is inspired by recent works in Vision Transformers (Dosovitskiy et al., 2020),", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 308, + 505, + 321 + ], + "spans": [ + { + "bbox": [ + 106, + 308, + 505, + 321 + ], + "score": 1.0, + "content": "and it is more effective than raster scan for modeling image sequencing. We found it improves both", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 319, + 235, + 330 + ], + "spans": [ + { + "bbox": [ + 106, + 319, + 235, + 330 + ], + "score": 1.0, + "content": "MEGABYTE and Perceiver AR.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15 + }, + { + "type": "table", + "bbox": [ + 106, + 339, + 528, + 401 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 106, + 339, + 528, + 401 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 339, + 528, + 401 + ], + "spans": [ + { + "bbox": [ + 106, + 339, + 528, + 401 + ], + "score": 0.975, + "html": "
(Global) SizeLocal Sizecontextbpb
MEGABYTE (patch scan)62M (D=768,L=6)N/A8,192 (768 latents)3.158
MEGABYTE (raster scan)62M (D=768,L=6)N/A8,192 (768 latents)3.428
Perceiver AR (patch scan)125M (D=768,L=12)125M (D=768,L=12)196,608 (patch size 192)3.373
Perceiver AR (raster scan)125M (D=768,L=12)125M (D=768,L=12)196,608 (patch size 192)3.552
", + "type": "table", + "image_path": "f0ec245b6296d63a9fb1eef37f017cd7945fdaaaa08234d2f0e151caa3020431.jpg" + } + ] + } + ], + "index": 18, + "virtual_lines": [ + { + "bbox": [ + 106, + 339, + 528, + 359.6666666666667 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 106, + 359.6666666666667, + 528, + 380.33333333333337 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 106, + 380.33333333333337, + 528, + 401.00000000000006 + ], + "spans": [], + "index": 19 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 114, + 401, + 491, + 411 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 119, + 398, + 492, + 412 + ], + "spans": [ + { + "bbox": [ + 119, + 398, + 492, + 412 + ], + "score": 1.0, + "content": "Table 14: ImageNet256 performance with patch scan vs raster scan for MEGABYTE and Perceiver AR.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + } + ], + "index": 19.0 + }, + { + "type": "title", + "bbox": [ + 107, + 446, + 246, + 457 + ], + "lines": [ + { + "bbox": [ + 105, + 443, + 248, + 461 + ], + "spans": [ + { + "bbox": [ + 105, + 443, + 248, + 461 + ], + "score": 1.0, + "content": "D.3 Longer sequence modeling", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 465, + 506, + 509 + ], + "lines": [ + { + "bbox": [ + 106, + 466, + 505, + 477 + ], + "spans": [ + { + "bbox": [ + 106, + 466, + 138, + 477 + ], + "score": 1.0, + "content": "For our", + "type": "text" + }, + { + "bbox": [ + 138, + 466, + 160, + 477 + ], + "score": 0.49, + "content": "\\mathsf { p g l 9 }", + "type": "inline_equation" + }, + { + "bbox": [ + 160, + 466, + 505, + 477 + ], + "score": 1.0, + "content": "scaling experiment, we also use longer context length for MEGABYTE. The results are", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 477, + 506, + 489 + ], + "spans": [ + { + "bbox": [ + 106, + 477, + 506, + 489 + ], + "score": 1.0, + "content": "shown in Table 15. With longer sequence, we didn’t observer further improvement, consistent with", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 487, + 506, + 501 + ], + "spans": [ + { + "bbox": [ + 105, + 487, + 506, + 501 + ], + "score": 1.0, + "content": "findings in Hawthorne et al. (2022). We think we will benefit more from longer sequence when we", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 498, + 266, + 510 + ], + "spans": [ + { + "bbox": [ + 106, + 498, + 266, + 510 + ], + "score": 1.0, + "content": "futher scale up the model size and data.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23.5 + }, + { + "type": "table", + "bbox": [ + 205, + 520, + 406, + 565 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 205, + 520, + 406, + 565 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 205, + 520, + 406, + 565 + ], + "spans": [ + { + "bbox": [ + 205, + 520, + 406, + 565 + ], + "score": 0.968, + "html": "
contextbpb
MEGABYTE8,192 (patch size 8)0.8751
MEGABYTE16,384 (patch size 8)0.8787
", + "type": "table", + "image_path": "27ea3c47e203c02726b9569edb70c26534ce4c958bbc12951fd891e26286a663.jpg" + } + ] + } + ], + "index": 27, + "virtual_lines": [ + { + "bbox": [ + 205, + 520, + 406, + 535.0 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 205, + 535.0, + 406, + 550.0 + ], + "spans": [], + "index": 27 + }, + { + "bbox": [ + 205, + 550.0, + 406, + 565.0 + ], + "spans": [], + "index": 28 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 106, + 565, + 505, + 585 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 564, + 505, + 576 + ], + "spans": [ + { + "bbox": [ + 106, + 564, + 505, + 576 + ], + "score": 1.0, + "content": "Table 15: Longer sequence for PG19 dataset. For both experiments, we set global model as 1.3b, local model as", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 574, + 252, + 585 + ], + "spans": [ + { + "bbox": [ + 106, + 574, + 128, + 584 + ], + "score": 0.61, + "content": "3 5 0 \\mathrm { m }", + "type": "inline_equation" + }, + { + "bbox": [ + 128, + 574, + 252, + 585 + ], + "score": 1.0, + "content": ", and MEGABYTE patch size as 8.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29.5 + } + ], + "index": 28.25 + } + ], + "page_idx": 15, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 300, + 741, + 311, + 750 + ], + "lines": [ + { + "bbox": [ + 299, + 740, + 313, + 754 + ], + "spans": [ + { + "bbox": [ + 299, + 740, + 313, + 754 + ], + "score": 1.0, + "content": "16", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 189, + 73, + 422, + 175 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 189, + 73, + 422, + 175 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 189, + 73, + 422, + 175 + ], + "spans": [ + { + "bbox": [ + 189, + 73, + 422, + 175 + ], + "score": 0.956, + "type": "image", + "image_path": "482fa286848fccc0c9dffcb9d5c629e37eb15f80f4564e61233305e612f026f3.jpg" + } + ] + } + ], + "index": 3.5, + "virtual_lines": [ + { + "bbox": [ + 189, + 73, + 422, + 85.75 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 189, + 85.75, + 422, + 98.5 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 189, + 98.5, + 422, + 111.25 + ], + "spans": [], + "index": 2 + }, + { + "bbox": [ + 189, + 111.25, + 422, + 124.0 + ], + "spans": [], + "index": 3 + }, + { + "bbox": [ + 189, + 124.0, + 422, + 136.75 + ], + "spans": [], + "index": 4 + }, + { + "bbox": [ + 189, + 136.75, + 422, + 149.5 + ], + "spans": [], + "index": 5 + }, + { + "bbox": [ + 189, + 149.5, + 422, + 162.25 + ], + "spans": [], + "index": 6 + }, + { + "bbox": [ + 189, + 162.25, + 422, + 175.0 + ], + "spans": [], + "index": 7 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 184, + 504, + 215 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 185, + 505, + 196 + ], + "spans": [ + { + "bbox": [ + 105, + 185, + 505, + 196 + ], + "score": 1.0, + "content": "Figure 4: Two ways to model 2D data sequentially. Left, raster scan, by taking bytes row by row and left to", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 195, + 506, + 206 + ], + "spans": [ + { + "bbox": [ + 105, + 195, + 506, + 206 + ], + "score": 1.0, + "content": "right; right, patch scan, where we first split an image into patches, and do raster scan across patches and within a", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 205, + 201, + 215 + ], + "spans": [ + { + "bbox": [ + 105, + 205, + 133, + 215 + ], + "score": 1.0, + "content": "patch.", + "type": "text" + }, + { + "bbox": [ + 133, + 205, + 197, + 215 + ], + "score": 0.35, + "content": "( \\mathrm { T } { = } 3 6 , \\mathrm { K } { = } 9 , \\mathrm { P } { = } 4 )", + "type": "inline_equation" + }, + { + "bbox": [ + 197, + 205, + 201, + 215 + ], + "score": 1.0, + "content": ".", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 9 + } + ], + "index": 6.25 + }, + { + "type": "text", + "bbox": [ + 107, + 234, + 504, + 264 + ], + "lines": [], + "index": 11.5, + "bbox_fs": [ + 105, + 234, + 506, + 265 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 107, + 277, + 242, + 289 + ], + "lines": [ + { + "bbox": [ + 106, + 276, + 243, + 290 + ], + "spans": [ + { + "bbox": [ + 106, + 276, + 243, + 290 + ], + "score": 1.0, + "content": "D.2 Patch scan vs Raster scan", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 107, + 297, + 507, + 330 + ], + "lines": [ + { + "bbox": [ + 105, + 296, + 506, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 296, + 506, + 310 + ], + "score": 1.0, + "content": "The patch scan method is inspired by recent works in Vision Transformers (Dosovitskiy et al., 2020),", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 308, + 505, + 321 + ], + "spans": [ + { + "bbox": [ + 106, + 308, + 505, + 321 + ], + "score": 1.0, + "content": "and it is more effective than raster scan for modeling image sequencing. We found it improves both", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 319, + 235, + 330 + ], + "spans": [ + { + "bbox": [ + 106, + 319, + 235, + 330 + ], + "score": 1.0, + "content": "MEGABYTE and Perceiver AR.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15, + "bbox_fs": [ + 105, + 296, + 506, + 330 + ] + }, + { + "type": "table", + "bbox": [ + 106, + 339, + 528, + 401 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 106, + 339, + 528, + 401 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 339, + 528, + 401 + ], + "spans": [ + { + "bbox": [ + 106, + 339, + 528, + 401 + ], + "score": 0.975, + "html": "
(Global) SizeLocal Sizecontextbpb
MEGABYTE (patch scan)62M (D=768,L=6)N/A8,192 (768 latents)3.158
MEGABYTE (raster scan)62M (D=768,L=6)N/A8,192 (768 latents)3.428
Perceiver AR (patch scan)125M (D=768,L=12)125M (D=768,L=12)196,608 (patch size 192)3.373
Perceiver AR (raster scan)125M (D=768,L=12)125M (D=768,L=12)196,608 (patch size 192)3.552
", + "type": "table", + "image_path": "f0ec245b6296d63a9fb1eef37f017cd7945fdaaaa08234d2f0e151caa3020431.jpg" + } + ] + } + ], + "index": 18, + "virtual_lines": [ + { + "bbox": [ + 106, + 339, + 528, + 359.6666666666667 + ], + "spans": [], + "index": 17 + }, + { + "bbox": [ + 106, + 359.6666666666667, + 528, + 380.33333333333337 + ], + "spans": [], + "index": 18 + }, + { + "bbox": [ + 106, + 380.33333333333337, + 528, + 401.00000000000006 + ], + "spans": [], + "index": 19 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 114, + 401, + 491, + 411 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 119, + 398, + 492, + 412 + ], + "spans": [ + { + "bbox": [ + 119, + 398, + 492, + 412 + ], + "score": 1.0, + "content": "Table 14: ImageNet256 performance with patch scan vs raster scan for MEGABYTE and Perceiver AR.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 20 + } + ], + "index": 19.0 + }, + { + "type": "title", + "bbox": [ + 107, + 446, + 246, + 457 + ], + "lines": [ + { + "bbox": [ + 105, + 443, + 248, + 461 + ], + "spans": [ + { + "bbox": [ + 105, + 443, + 248, + 461 + ], + "score": 1.0, + "content": "D.3 Longer sequence modeling", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 21 + }, + { + "type": "text", + "bbox": [ + 107, + 465, + 506, + 509 + ], + "lines": [ + { + "bbox": [ + 106, + 466, + 505, + 477 + ], + "spans": [ + { + "bbox": [ + 106, + 466, + 138, + 477 + ], + "score": 1.0, + "content": "For our", + "type": "text" + }, + { + "bbox": [ + 138, + 466, + 160, + 477 + ], + "score": 0.49, + "content": "\\mathsf { p g l 9 }", + "type": "inline_equation" + }, + { + "bbox": [ + 160, + 466, + 505, + 477 + ], + "score": 1.0, + "content": "scaling experiment, we also use longer context length for MEGABYTE. The results are", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 477, + 506, + 489 + ], + "spans": [ + { + "bbox": [ + 106, + 477, + 506, + 489 + ], + "score": 1.0, + "content": "shown in Table 15. With longer sequence, we didn’t observer further improvement, consistent with", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 487, + 506, + 501 + ], + "spans": [ + { + "bbox": [ + 105, + 487, + 506, + 501 + ], + "score": 1.0, + "content": "findings in Hawthorne et al. (2022). We think we will benefit more from longer sequence when we", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 498, + 266, + 510 + ], + "spans": [ + { + "bbox": [ + 106, + 498, + 266, + 510 + ], + "score": 1.0, + "content": "futher scale up the model size and data.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 23.5, + "bbox_fs": [ + 105, + 466, + 506, + 510 + ] + }, + { + "type": "table", + "bbox": [ + 205, + 520, + 406, + 565 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 205, + 520, + 406, + 565 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 205, + 520, + 406, + 565 + ], + "spans": [ + { + "bbox": [ + 205, + 520, + 406, + 565 + ], + "score": 0.968, + "html": "
contextbpb
MEGABYTE8,192 (patch size 8)0.8751
MEGABYTE16,384 (patch size 8)0.8787
", + "type": "table", + "image_path": "27ea3c47e203c02726b9569edb70c26534ce4c958bbc12951fd891e26286a663.jpg" + } + ] + } + ], + "index": 27, + "virtual_lines": [ + { + "bbox": [ + 205, + 520, + 406, + 535.0 + ], + "spans": [], + "index": 26 + }, + { + "bbox": [ + 205, + 535.0, + 406, + 550.0 + ], + "spans": [], + "index": 27 + }, + { + "bbox": [ + 205, + 550.0, + 406, + 565.0 + ], + "spans": [], + "index": 28 + } + ] + }, + { + "type": "table_footnote", + "bbox": [ + 106, + 565, + 505, + 585 + ], + "group_id": 1, + "lines": [ + { + "bbox": [ + 106, + 564, + 505, + 576 + ], + "spans": [ + { + "bbox": [ + 106, + 564, + 505, + 576 + ], + "score": 1.0, + "content": "Table 15: Longer sequence for PG19 dataset. For both experiments, we set global model as 1.3b, local model as", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 574, + 252, + 585 + ], + "spans": [ + { + "bbox": [ + 106, + 574, + 128, + 584 + ], + "score": 0.61, + "content": "3 5 0 \\mathrm { m }", + "type": "inline_equation" + }, + { + "bbox": [ + 128, + 574, + 252, + 585 + ], + "score": 1.0, + "content": ", and MEGABYTE patch size as 8.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29.5 + } + ], + "index": 28.25 + } + ] + } + ], + "_backend": "pipeline", + "_version_name": "2.2.2" +} \ No newline at end of file