diff --git "a/parse/train/ryG6xZ-RZ/ryG6xZ-RZ_middle.json" "b/parse/train/ryG6xZ-RZ/ryG6xZ-RZ_middle.json" new file mode 100644--- /dev/null +++ "b/parse/train/ryG6xZ-RZ/ryG6xZ-RZ_middle.json" @@ -0,0 +1,22480 @@ +{ + "pdf_info": [ + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 79, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 79, + 506, + 100 + ], + "spans": [ + { + "bbox": [ + 105, + 79, + 506, + 100 + ], + "score": 1.0, + "content": "DLVM: A MODERN COMPILER INFRASTRUCTURE FOR", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 102, + 300, + 118 + ], + "spans": [ + { + "bbox": [ + 106, + 102, + 300, + 118 + ], + "score": 1.0, + "content": "DEEP LEARNING SYSTEMS", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "text", + "bbox": [ + 112, + 134, + 308, + 190 + ], + "lines": [ + { + "bbox": [ + 112, + 135, + 169, + 146 + ], + "spans": [ + { + "bbox": [ + 112, + 135, + 169, + 146 + ], + "score": 1.0, + "content": "Richard Wei", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 111, + 146, + 309, + 159 + ], + "spans": [ + { + "bbox": [ + 111, + 146, + 309, + 159 + ], + "score": 1.0, + "content": "Departments of Computer Science & Linguistics", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 111, + 156, + 289, + 169 + ], + "spans": [ + { + "bbox": [ + 111, + 156, + 289, + 169 + ], + "score": 1.0, + "content": "University of Illinois at Urbana-Champaign", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 112, + 168, + 185, + 178 + ], + "spans": [ + { + "bbox": [ + 112, + 168, + 185, + 178 + ], + "score": 1.0, + "content": "Urbana, IL 61801", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 111, + 179, + 228, + 190 + ], + "spans": [ + { + "bbox": [ + 111, + 179, + 228, + 190 + ], + "score": 1.0, + "content": "xwei12@illinois.edu", + "type": "text" + } + ], + "index": 10 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 322, + 135, + 498, + 190 + ], + "lines": [ + { + "bbox": [ + 322, + 135, + 389, + 147 + ], + "spans": [ + { + "bbox": [ + 322, + 135, + 389, + 147 + ], + "score": 1.0, + "content": "Lane Schwartz", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 322, + 147, + 430, + 158 + ], + "spans": [ + { + "bbox": [ + 322, + 147, + 430, + 158 + ], + "score": 1.0, + "content": "Department of Linguistics", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 321, + 156, + 499, + 169 + ], + "spans": [ + { + "bbox": [ + 321, + 156, + 499, + 169 + ], + "score": 1.0, + "content": "University of Illinois at Urbana-Champaign", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 323, + 168, + 396, + 178 + ], + "spans": [ + { + "bbox": [ + 323, + 168, + 396, + 178 + ], + "score": 1.0, + "content": "Urbana, IL 61801", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 322, + 180, + 432, + 190 + ], + "spans": [ + { + "bbox": [ + 322, + 180, + 432, + 190 + ], + "score": 1.0, + "content": "lanes@illinois.edu", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 7 + }, + { + "type": "title", + "bbox": [ + 113, + 207, + 171, + 218 + ], + "lines": [ + { + "bbox": [ + 112, + 205, + 173, + 219 + ], + "spans": [ + { + "bbox": [ + 112, + 205, + 173, + 219 + ], + "score": 1.0, + "content": "Vikram Adve", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 113, + 219, + 288, + 262 + ], + "lines": [ + { + "bbox": [ + 111, + 218, + 248, + 230 + ], + "spans": [ + { + "bbox": [ + 111, + 218, + 248, + 230 + ], + "score": 1.0, + "content": "Department of Computer Science", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 111, + 228, + 289, + 241 + ], + "spans": [ + { + "bbox": [ + 111, + 228, + 289, + 241 + ], + "score": 1.0, + "content": "University of Illinois at Urbana-Champaign", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 113, + 240, + 185, + 251 + ], + "spans": [ + { + "bbox": [ + 113, + 240, + 185, + 251 + ], + "score": 1.0, + "content": "Urbana, IL 61801", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 112, + 252, + 222, + 262 + ], + "spans": [ + { + "bbox": [ + 112, + 252, + 222, + 262 + ], + "score": 1.0, + "content": "vadve@illinois.edu", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 14.5 + }, + { + "type": "title", + "bbox": [ + 278, + 291, + 333, + 303 + ], + "lines": [ + { + "bbox": [ + 276, + 290, + 336, + 306 + ], + "spans": [ + { + "bbox": [ + 276, + 290, + 336, + 306 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 143, + 318, + 469, + 440 + ], + "lines": [ + { + "bbox": [ + 141, + 319, + 470, + 332 + ], + "spans": [ + { + "bbox": [ + 141, + 319, + 470, + 332 + ], + "score": 1.0, + "content": "Deep learning software demands reliability and performance. However, many of", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 141, + 330, + 469, + 343 + ], + "spans": [ + { + "bbox": [ + 141, + 330, + 469, + 343 + ], + "score": 1.0, + "content": "the existing deep learning frameworks are software libraries that act as an unsafe", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 141, + 340, + 469, + 354 + ], + "spans": [ + { + "bbox": [ + 141, + 340, + 469, + 354 + ], + "score": 1.0, + "content": "DSL in Python and a computation graph interpreter. We present DLVM, a design", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 141, + 352, + 469, + 364 + ], + "spans": [ + { + "bbox": [ + 141, + 352, + 469, + 364 + ], + "score": 1.0, + "content": "and implementation of a compiler infrastructure with a linear algebra intermediate", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 141, + 363, + 470, + 375 + ], + "spans": [ + { + "bbox": [ + 141, + 363, + 470, + 375 + ], + "score": 1.0, + "content": "representation, algorithmic differentiation by adjoint code generation, domain-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 141, + 374, + 470, + 386 + ], + "spans": [ + { + "bbox": [ + 141, + 374, + 470, + 386 + ], + "score": 1.0, + "content": "specific optimizations and a code generator targeting GPU via LLVM. Designed", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 141, + 385, + 470, + 398 + ], + "spans": [ + { + "bbox": [ + 141, + 385, + 470, + 398 + ], + "score": 1.0, + "content": "as a modern compiler infrastructure inspired by LLVM, DLVM is more modular", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 141, + 396, + 470, + 408 + ], + "spans": [ + { + "bbox": [ + 141, + 396, + 470, + 408 + ], + "score": 1.0, + "content": "and more generic than existing deep learning compiler frameworks, and supports", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 141, + 407, + 470, + 420 + ], + "spans": [ + { + "bbox": [ + 141, + 407, + 470, + 420 + ], + "score": 1.0, + "content": "tensor DSLs with high expressivity. With our prototypical staged DSL embedded", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 142, + 418, + 469, + 429 + ], + "spans": [ + { + "bbox": [ + 142, + 418, + 469, + 429 + ], + "score": 1.0, + "content": "in Swift, we argue that the DLVM system enables a form of modular, safe and", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 141, + 427, + 312, + 443 + ], + "spans": [ + { + "bbox": [ + 141, + 427, + 312, + 443 + ], + "score": 1.0, + "content": "performant frameworks for deep learning.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 23 + }, + { + "type": "title", + "bbox": [ + 108, + 468, + 206, + 480 + ], + "lines": [ + { + "bbox": [ + 105, + 466, + 208, + 483 + ], + "spans": [ + { + "bbox": [ + 105, + 466, + 208, + 483 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 107, + 495, + 505, + 649 + ], + "lines": [ + { + "bbox": [ + 105, + 494, + 506, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 506, + 509 + ], + "score": 1.0, + "content": "Within the deep learning community, most current approaches to neural networks make use of", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 507, + 506, + 518 + ], + "spans": [ + { + "bbox": [ + 106, + 507, + 506, + 518 + ], + "score": 1.0, + "content": "high-level frameworks with a tensor domain-specific language (DSL) such as Torch (Collobert et al.,", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 516, + 506, + 530 + ], + "spans": [ + { + "bbox": [ + 105, + 516, + 506, + 530 + ], + "score": 1.0, + "content": "2011), TensorFlow (Abadi et al., 2016), PyTorch (PyTorch Development Team, 2016), and MXNet", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 528, + 505, + 541 + ], + "spans": [ + { + "bbox": [ + 106, + 528, + 505, + 541 + ], + "score": 1.0, + "content": "(Chen et al., 2015). Traditionally, developers would build a computation graph (or dynamically", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 539, + 505, + 552 + ], + "spans": [ + { + "bbox": [ + 105, + 539, + 505, + 552 + ], + "score": 1.0, + "content": "generate graph nodes) using a DSL and let the framework interpret the computation graph on parallel", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 550, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 106, + 550, + 505, + 563 + ], + "score": 1.0, + "content": "architectures such as NVIDIA GPUs. While using hand-tuned GPU subroutines usually yields the", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 560, + 506, + 575 + ], + "spans": [ + { + "bbox": [ + 105, + 560, + 506, + 575 + ], + "score": 1.0, + "content": "best performance for complex operators, advanced compiler techniques can be applied to simplify", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 573, + 506, + 585 + ], + "spans": [ + { + "bbox": [ + 105, + 573, + 506, + 585 + ], + "score": 1.0, + "content": "computation, merge high-level operators based on shaping conditions, and fuse compatible element-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 583, + 506, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 583, + 506, + 596 + ], + "score": 1.0, + "content": "wise operators to a single kernel to minimize the latency between kernel launches. Recent projects, the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 104, + 592, + 506, + 608 + ], + "spans": [ + { + "bbox": [ + 104, + 592, + 506, + 608 + ], + "score": 1.0, + "content": "TensorFlow XLA compiler (Leary & Wang, 2017) and the NNVM compiler (NNVM, 2017) including", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 104, + 604, + 506, + 619 + ], + "spans": [ + { + "bbox": [ + 104, + 604, + 506, + 619 + ], + "score": 1.0, + "content": "TVM (Chen et al., 2017), have begun to apply compiler techniques to deep learning systems, targeting", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 616, + 505, + 628 + ], + "spans": [ + { + "bbox": [ + 105, + 616, + 505, + 628 + ], + "score": 1.0, + "content": "LLVM (Lattner & Adve, 2004) and various back-ends to achieve good performance. However, their", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 627, + 506, + 640 + ], + "spans": [ + { + "bbox": [ + 106, + 627, + 506, + 640 + ], + "score": 1.0, + "content": "design and implementation have not entirely followed established best practices in widely-used", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 638, + 256, + 651 + ], + "spans": [ + { + "bbox": [ + 106, + 638, + 256, + 651 + ], + "score": 1.0, + "content": "compiler frameworks in the industry.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 36.5 + }, + { + "type": "text", + "bbox": [ + 107, + 655, + 505, + 731 + ], + "lines": [ + { + "bbox": [ + 105, + 654, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 654, + 505, + 668 + ], + "score": 1.0, + "content": "Moreover, some frameworks use operator-overloading algorithmic differentiation (AD) to compute", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 666, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 506, + 678 + ], + "score": 1.0, + "content": "gradients, leaving the gradient computation unoptimizable. The other approach to AD, source code", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "transformation, can produce more efficient code. While frameworks such as TensorFlow already", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 688, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 506, + 700 + ], + "score": 1.0, + "content": "perform AD as a graph transformation and apply various optimizations, their AD transformation is", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "not designed as a transformation pass in the pipeline of their compiler framework, but as part of the", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "score": 1.0, + "content": "DSL library. Making AD part of the compiler framework would greatly simplify the development of", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 720, + 270, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 270, + 734 + ], + "score": 1.0, + "content": "DSLs, achieving separation of concerns.", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 47 + } + ], + "page_idx": 0, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 224, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 225, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 225, + 38 + ], + "score": 1.0, + "content": "Workshop track - ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 308, + 761 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 308, + 761 + ], + "score": 1.0, + "content": "1", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 107, + 79, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 105, + 79, + 506, + 100 + ], + "spans": [ + { + "bbox": [ + 105, + 79, + 506, + 100 + ], + "score": 1.0, + "content": "DLVM: A MODERN COMPILER INFRASTRUCTURE FOR", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 106, + 102, + 300, + 118 + ], + "spans": [ + { + "bbox": [ + 106, + 102, + 300, + 118 + ], + "score": 1.0, + "content": "DEEP LEARNING SYSTEMS", + "type": "text" + } + ], + "index": 1 + } + ], + "index": 0.5 + }, + { + "type": "list", + "bbox": [ + 112, + 134, + 308, + 190 + ], + "lines": [ + { + "bbox": [ + 112, + 135, + 169, + 146 + ], + "spans": [ + { + "bbox": [ + 112, + 135, + 169, + 146 + ], + "score": 1.0, + "content": "Richard Wei", + "type": "text" + } + ], + "index": 2, + "is_list_start_line": true + }, + { + "bbox": [ + 111, + 146, + 309, + 159 + ], + "spans": [ + { + "bbox": [ + 111, + 146, + 309, + 159 + ], + "score": 1.0, + "content": "Departments of Computer Science & Linguistics", + "type": "text" + } + ], + "index": 4, + "is_list_start_line": true + }, + { + "bbox": [ + 111, + 156, + 289, + 169 + ], + "spans": [ + { + "bbox": [ + 111, + 156, + 289, + 169 + ], + "score": 1.0, + "content": "University of Illinois at Urbana-Champaign", + "type": "text" + } + ], + "index": 6, + "is_list_start_line": true + }, + { + "bbox": [ + 112, + 168, + 185, + 178 + ], + "spans": [ + { + "bbox": [ + 112, + 168, + 185, + 178 + ], + "score": 1.0, + "content": "Urbana, IL 61801", + "type": "text" + } + ], + "index": 8, + "is_list_start_line": true + }, + { + "bbox": [ + 111, + 179, + 228, + 190 + ], + "spans": [ + { + "bbox": [ + 111, + 179, + 228, + 190 + ], + "score": 1.0, + "content": "xwei12@illinois.edu", + "type": "text" + } + ], + "index": 10, + "is_list_start_line": true + }, + { + "bbox": [ + 322, + 135, + 389, + 147 + ], + "spans": [ + { + "bbox": [ + 322, + 135, + 389, + 147 + ], + "score": 1.0, + "content": "Lane Schwartz", + "type": "text" + } + ], + "index": 3, + "is_list_start_line": true + }, + { + "bbox": [ + 322, + 147, + 430, + 158 + ], + "spans": [ + { + "bbox": [ + 322, + 147, + 430, + 158 + ], + "score": 1.0, + "content": "Department of Linguistics", + "type": "text" + } + ], + "index": 5, + "is_list_start_line": true + }, + { + "bbox": [ + 321, + 156, + 499, + 169 + ], + "spans": [ + { + "bbox": [ + 321, + 156, + 499, + 169 + ], + "score": 1.0, + "content": "University of Illinois at Urbana-Champaign", + "type": "text" + } + ], + "index": 7, + "is_list_start_line": true + }, + { + "bbox": [ + 323, + 168, + 396, + 178 + ], + "spans": [ + { + "bbox": [ + 323, + 168, + 396, + 178 + ], + "score": 1.0, + "content": "Urbana, IL 61801", + "type": "text" + } + ], + "index": 9, + "is_list_start_line": true + }, + { + "bbox": [ + 322, + 180, + 432, + 190 + ], + "spans": [ + { + "bbox": [ + 322, + 180, + 432, + 190 + ], + "score": 1.0, + "content": "lanes@illinois.edu", + "type": "text" + } + ], + "index": 11, + "is_list_start_line": true + } + ], + "index": 6, + "bbox_fs": [ + 111, + 135, + 309, + 190 + ] + }, + { + "type": "list", + "bbox": [ + 322, + 135, + 498, + 190 + ], + "lines": [], + "index": 7, + "bbox_fs": [ + 321, + 135, + 499, + 190 + ], + "lines_deleted": true + }, + { + "type": "title", + "bbox": [ + 113, + 207, + 171, + 218 + ], + "lines": [ + { + "bbox": [ + 112, + 205, + 173, + 219 + ], + "spans": [ + { + "bbox": [ + 112, + 205, + 173, + 219 + ], + "score": 1.0, + "content": "Vikram Adve", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "list", + "bbox": [ + 113, + 219, + 288, + 262 + ], + "lines": [ + { + "bbox": [ + 111, + 218, + 248, + 230 + ], + "spans": [ + { + "bbox": [ + 111, + 218, + 248, + 230 + ], + "score": 1.0, + "content": "Department of Computer Science", + "type": "text" + } + ], + "index": 13, + "is_list_start_line": true + }, + { + "bbox": [ + 111, + 228, + 289, + 241 + ], + "spans": [ + { + "bbox": [ + 111, + 228, + 289, + 241 + ], + "score": 1.0, + "content": "University of Illinois at Urbana-Champaign", + "type": "text" + } + ], + "index": 14, + "is_list_start_line": true + }, + { + "bbox": [ + 113, + 240, + 185, + 251 + ], + "spans": [ + { + "bbox": [ + 113, + 240, + 185, + 251 + ], + "score": 1.0, + "content": "Urbana, IL 61801", + "type": "text" + } + ], + "index": 15, + "is_list_start_line": true + }, + { + "bbox": [ + 112, + 252, + 222, + 262 + ], + "spans": [ + { + "bbox": [ + 112, + 252, + 222, + 262 + ], + "score": 1.0, + "content": "vadve@illinois.edu", + "type": "text" + } + ], + "index": 16, + "is_list_start_line": true + } + ], + "index": 14.5, + "bbox_fs": [ + 111, + 218, + 289, + 262 + ] + }, + { + "type": "title", + "bbox": [ + 278, + 291, + 333, + 303 + ], + "lines": [ + { + "bbox": [ + 276, + 290, + 336, + 306 + ], + "spans": [ + { + "bbox": [ + 276, + 290, + 336, + 306 + ], + "score": 1.0, + "content": "ABSTRACT", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 17 + }, + { + "type": "text", + "bbox": [ + 143, + 318, + 469, + 440 + ], + "lines": [ + { + "bbox": [ + 141, + 319, + 470, + 332 + ], + "spans": [ + { + "bbox": [ + 141, + 319, + 470, + 332 + ], + "score": 1.0, + "content": "Deep learning software demands reliability and performance. However, many of", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 141, + 330, + 469, + 343 + ], + "spans": [ + { + "bbox": [ + 141, + 330, + 469, + 343 + ], + "score": 1.0, + "content": "the existing deep learning frameworks are software libraries that act as an unsafe", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 141, + 340, + 469, + 354 + ], + "spans": [ + { + "bbox": [ + 141, + 340, + 469, + 354 + ], + "score": 1.0, + "content": "DSL in Python and a computation graph interpreter. We present DLVM, a design", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 141, + 352, + 469, + 364 + ], + "spans": [ + { + "bbox": [ + 141, + 352, + 469, + 364 + ], + "score": 1.0, + "content": "and implementation of a compiler infrastructure with a linear algebra intermediate", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 141, + 363, + 470, + 375 + ], + "spans": [ + { + "bbox": [ + 141, + 363, + 470, + 375 + ], + "score": 1.0, + "content": "representation, algorithmic differentiation by adjoint code generation, domain-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 141, + 374, + 470, + 386 + ], + "spans": [ + { + "bbox": [ + 141, + 374, + 470, + 386 + ], + "score": 1.0, + "content": "specific optimizations and a code generator targeting GPU via LLVM. Designed", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 141, + 385, + 470, + 398 + ], + "spans": [ + { + "bbox": [ + 141, + 385, + 470, + 398 + ], + "score": 1.0, + "content": "as a modern compiler infrastructure inspired by LLVM, DLVM is more modular", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 141, + 396, + 470, + 408 + ], + "spans": [ + { + "bbox": [ + 141, + 396, + 470, + 408 + ], + "score": 1.0, + "content": "and more generic than existing deep learning compiler frameworks, and supports", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 141, + 407, + 470, + 420 + ], + "spans": [ + { + "bbox": [ + 141, + 407, + 470, + 420 + ], + "score": 1.0, + "content": "tensor DSLs with high expressivity. With our prototypical staged DSL embedded", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 142, + 418, + 469, + 429 + ], + "spans": [ + { + "bbox": [ + 142, + 418, + 469, + 429 + ], + "score": 1.0, + "content": "in Swift, we argue that the DLVM system enables a form of modular, safe and", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 141, + 427, + 312, + 443 + ], + "spans": [ + { + "bbox": [ + 141, + 427, + 312, + 443 + ], + "score": 1.0, + "content": "performant frameworks for deep learning.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 23, + "bbox_fs": [ + 141, + 319, + 470, + 443 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 468, + 206, + 480 + ], + "lines": [ + { + "bbox": [ + 105, + 466, + 208, + 483 + ], + "spans": [ + { + "bbox": [ + 105, + 466, + 208, + 483 + ], + "score": 1.0, + "content": "1 INTRODUCTION", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 107, + 495, + 505, + 649 + ], + "lines": [ + { + "bbox": [ + 105, + 494, + 506, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 506, + 509 + ], + "score": 1.0, + "content": "Within the deep learning community, most current approaches to neural networks make use of", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 507, + 506, + 518 + ], + "spans": [ + { + "bbox": [ + 106, + 507, + 506, + 518 + ], + "score": 1.0, + "content": "high-level frameworks with a tensor domain-specific language (DSL) such as Torch (Collobert et al.,", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 516, + 506, + 530 + ], + "spans": [ + { + "bbox": [ + 105, + 516, + 506, + 530 + ], + "score": 1.0, + "content": "2011), TensorFlow (Abadi et al., 2016), PyTorch (PyTorch Development Team, 2016), and MXNet", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 528, + 505, + 541 + ], + "spans": [ + { + "bbox": [ + 106, + 528, + 505, + 541 + ], + "score": 1.0, + "content": "(Chen et al., 2015). Traditionally, developers would build a computation graph (or dynamically", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 539, + 505, + 552 + ], + "spans": [ + { + "bbox": [ + 105, + 539, + 505, + 552 + ], + "score": 1.0, + "content": "generate graph nodes) using a DSL and let the framework interpret the computation graph on parallel", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 550, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 106, + 550, + 505, + 563 + ], + "score": 1.0, + "content": "architectures such as NVIDIA GPUs. While using hand-tuned GPU subroutines usually yields the", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 560, + 506, + 575 + ], + "spans": [ + { + "bbox": [ + 105, + 560, + 506, + 575 + ], + "score": 1.0, + "content": "best performance for complex operators, advanced compiler techniques can be applied to simplify", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 573, + 506, + 585 + ], + "spans": [ + { + "bbox": [ + 105, + 573, + 506, + 585 + ], + "score": 1.0, + "content": "computation, merge high-level operators based on shaping conditions, and fuse compatible element-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 583, + 506, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 583, + 506, + 596 + ], + "score": 1.0, + "content": "wise operators to a single kernel to minimize the latency between kernel launches. Recent projects, the", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 104, + 592, + 506, + 608 + ], + "spans": [ + { + "bbox": [ + 104, + 592, + 506, + 608 + ], + "score": 1.0, + "content": "TensorFlow XLA compiler (Leary & Wang, 2017) and the NNVM compiler (NNVM, 2017) including", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 104, + 604, + 506, + 619 + ], + "spans": [ + { + "bbox": [ + 104, + 604, + 506, + 619 + ], + "score": 1.0, + "content": "TVM (Chen et al., 2017), have begun to apply compiler techniques to deep learning systems, targeting", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 105, + 616, + 505, + 628 + ], + "spans": [ + { + "bbox": [ + 105, + 616, + 505, + 628 + ], + "score": 1.0, + "content": "LLVM (Lattner & Adve, 2004) and various back-ends to achieve good performance. However, their", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 106, + 627, + 506, + 640 + ], + "spans": [ + { + "bbox": [ + 106, + 627, + 506, + 640 + ], + "score": 1.0, + "content": "design and implementation have not entirely followed established best practices in widely-used", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 638, + 256, + 651 + ], + "spans": [ + { + "bbox": [ + 106, + 638, + 256, + 651 + ], + "score": 1.0, + "content": "compiler frameworks in the industry.", + "type": "text" + } + ], + "index": 43 + } + ], + "index": 36.5, + "bbox_fs": [ + 104, + 494, + 506, + 651 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 655, + 505, + 731 + ], + "lines": [ + { + "bbox": [ + 105, + 654, + 505, + 668 + ], + "spans": [ + { + "bbox": [ + 105, + 654, + 505, + 668 + ], + "score": 1.0, + "content": "Moreover, some frameworks use operator-overloading algorithmic differentiation (AD) to compute", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 666, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 506, + 678 + ], + "score": 1.0, + "content": "gradients, leaving the gradient computation unoptimizable. The other approach to AD, source code", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "transformation, can produce more efficient code. While frameworks such as TensorFlow already", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 688, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 506, + 700 + ], + "score": 1.0, + "content": "perform AD as a graph transformation and apply various optimizations, their AD transformation is", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "not designed as a transformation pass in the pipeline of their compiler framework, but as part of the", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "score": 1.0, + "content": "DSL library. Making AD part of the compiler framework would greatly simplify the development of", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 720, + 270, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 270, + 734 + ], + "score": 1.0, + "content": "DSLs, achieving separation of concerns.", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 47, + "bbox_fs": [ + 105, + 654, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 107, + 79, + 501, + 281 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 107, + 79, + 501, + 281 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 107, + 79, + 501, + 281 + ], + "spans": [ + { + "bbox": [ + 107, + 79, + 501, + 281 + ], + "score": 0.972, + "type": "image", + "image_path": "849b709b69e101ea7ef26d6864d1b1e0eafec6758703952e4749d0cbe5bb8354.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 107, + 79, + 501, + 146.33333333333331 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 107, + 146.33333333333331, + 501, + 213.66666666666663 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 107, + 213.66666666666663, + 501, + 280.99999999999994 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 104, + 291, + 501, + 303 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 290, + 501, + 304 + ], + "spans": [ + { + "bbox": [ + 106, + 290, + 501, + 304 + ], + "score": 1.0, + "content": "Figure 1: Software stack of the DLVM infrastructure. Blue components are the compiler framework.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "text", + "bbox": [ + 107, + 325, + 506, + 424 + ], + "lines": [ + { + "bbox": [ + 106, + 325, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 106, + 325, + 506, + 338 + ], + "score": 1.0, + "content": "We introduce DLVM, a new compiler infrastructure for deep learning systems that addresses shortcom-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 336, + 506, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 336, + 506, + 348 + ], + "score": 1.0, + "content": "ings of existing deep learning frameworks. Our solution includes (1) a domain-specific intermediate", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 104, + 346, + 506, + 360 + ], + "spans": [ + { + "bbox": [ + 104, + 346, + 506, + 360 + ], + "score": 1.0, + "content": "representation specifically designed for tensor computation, (2) principled use of modern compiler", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 357, + 506, + 371 + ], + "spans": [ + { + "bbox": [ + 105, + 357, + 506, + 371 + ], + "score": 1.0, + "content": "optimization techniques to substantially simplify neural network computation, including algebra sim-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 369, + 506, + 382 + ], + "spans": [ + { + "bbox": [ + 105, + 369, + 506, + 382 + ], + "score": 1.0, + "content": "plification, AD checkpointing, compute kernel fusion, and various traditional compiler optimizations,", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 380, + 506, + 393 + ], + "spans": [ + { + "bbox": [ + 106, + 380, + 506, + 393 + ], + "score": 1.0, + "content": "(3) code generation through a mature compiler infrastructure that allows for transparent targeting of", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 391, + 506, + 404 + ], + "spans": [ + { + "bbox": [ + 106, + 391, + 506, + 404 + ], + "score": 1.0, + "content": "various hardware, and (4) an embedded DSL that supports static analysis, type safety, and natural", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 401, + 506, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 506, + 416 + ], + "score": 1.0, + "content": "expression of tensor computation, and has a just-in-time (JIT) compiler targeting DLVM for AD,", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 413, + 250, + 426 + ], + "spans": [ + { + "bbox": [ + 106, + 413, + 250, + 426 + ], + "score": 1.0, + "content": "optimizations, and code generation.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 8 + }, + { + "type": "title", + "bbox": [ + 108, + 441, + 211, + 454 + ], + "lines": [ + { + "bbox": [ + 104, + 440, + 213, + 457 + ], + "spans": [ + { + "bbox": [ + 104, + 440, + 213, + 457 + ], + "score": 1.0, + "content": "2 RELATED WORK", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 107, + 467, + 505, + 555 + ], + "lines": [ + { + "bbox": [ + 105, + 466, + 505, + 480 + ], + "spans": [ + { + "bbox": [ + 105, + 466, + 505, + 480 + ], + "score": 1.0, + "content": "Numerous existing projects provide specialized systems for machine learning but are not closely", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 477, + 505, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 505, + 492 + ], + "score": 1.0, + "content": "related to our work. These include Apache SystemML (Ghoting et al., 2011), a high-level language", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 489, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 489, + 505, + 502 + ], + "score": 1.0, + "content": "and framework for writing and executing machine learning problems targeting Apache Spark, and", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 500, + 505, + 513 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 241, + 513 + ], + "score": 1.0, + "content": "TACO (Kjolstad et al., 2017), a", + "type": "text" + }, + { + "bbox": [ + 241, + 501, + 262, + 511 + ], + "score": 0.85, + "content": "\\mathrm { C } { + } { + }", + "type": "inline_equation" + }, + { + "bbox": [ + 263, + 500, + 505, + 513 + ], + "score": 1.0, + "content": "library for compiling and optimizing kernels that is more", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 511, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 505, + 524 + ], + "score": 1.0, + "content": "similar to Halide (Ragan-Kelley et al., 2013) than to our work. Our work treats the creation of neural", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 523, + 505, + 535 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 505, + 535 + ], + "score": 1.0, + "content": "networks as a compilers problem to be addressed using mature compiler techniques. SystemML does", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 533, + 506, + 547 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 506, + 547 + ], + "score": 1.0, + "content": "not consider this issue at all; TACO does use compiler optimization, but only at a very low level to", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 545, + 220, + 556 + ], + "spans": [ + { + "bbox": [ + 105, + 545, + 220, + 556 + ], + "score": 1.0, + "content": "generate individual kernels.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 17.5 + }, + { + "type": "text", + "bbox": [ + 107, + 561, + 505, + 660 + ], + "lines": [ + { + "bbox": [ + 106, + 561, + 506, + 573 + ], + "spans": [ + { + "bbox": [ + 106, + 561, + 506, + 573 + ], + "score": 1.0, + "content": "Two projects closely related to this work are the TensorFlow XLA compiler and the NNVM compiler.", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 571, + 506, + 585 + ], + "spans": [ + { + "bbox": [ + 105, + 571, + 506, + 585 + ], + "score": 1.0, + "content": "The code representation in these frameworks is a “sea of nodes” representation, embedding control", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 583, + 506, + 596 + ], + "spans": [ + { + "bbox": [ + 106, + 583, + 506, + 596 + ], + "score": 1.0, + "content": "flow nodes and composite nodes in a data flow graph. To apply algorithmic differentiation on this", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 594, + 505, + 607 + ], + "spans": [ + { + "bbox": [ + 106, + 594, + 505, + 607 + ], + "score": 1.0, + "content": "IR requires non-standard processing. In contrast, our approach is designed from the start around the", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 604, + 506, + 619 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 506, + 619 + ], + "score": 1.0, + "content": "idea that a neural network (and its associated tensor computations) is itself a program, which is best", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 615, + 506, + 629 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 506, + 629 + ], + "score": 1.0, + "content": "optimized through robust application of mature techniques in a principled compilation pipeline. We", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 627, + 506, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 627, + 506, + 640 + ], + "score": 1.0, + "content": "represent tensor computation in static single assignment (SSA) form with control flow graph, and", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 637, + 507, + 652 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 507, + 652 + ], + "score": 1.0, + "content": "perform algorithmic differentiation, domain-specific optimizations, general-purpose optimizations,", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 649, + 289, + 661 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 289, + 661 + ], + "score": 1.0, + "content": "low-level optimizations, and code generation.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 26 + }, + { + "type": "text", + "bbox": [ + 107, + 666, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 665, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 505, + 678 + ], + "score": 1.0, + "content": "XLA takes a similar approach to ours, transforming TensorFlow sub-graphs to XLA’s HLO graph", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 677, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 690 + ], + "score": 1.0, + "content": "and performing optimizations. Our intermediate representation is much more expressive than XLA’s", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 688, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 505, + 700 + ], + "score": 1.0, + "content": "by including modular IR components and general-purpose instructions; this enables our approach", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 698, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 711 + ], + "score": 1.0, + "content": "to support full-fledged DSLs including standalone compiled DSLs and perform more extensive", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "optimizations such as inlining and interprocedual optimizations. Our approach also differs from XLA", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "score": 1.0, + "content": "by representing composite functions such as min and max directly through primitive instructions", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 33.5 + } + ], + "page_idx": 1, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 224, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 225, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 225, + 38 + ], + "score": 1.0, + "content": "Workshop track - ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 310, + 763 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 310, + 763 + ], + "score": 1.0, + "content": "2", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 107, + 79, + 501, + 281 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 107, + 79, + 501, + 281 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 107, + 79, + 501, + 281 + ], + "spans": [ + { + "bbox": [ + 107, + 79, + 501, + 281 + ], + "score": 0.972, + "type": "image", + "image_path": "849b709b69e101ea7ef26d6864d1b1e0eafec6758703952e4749d0cbe5bb8354.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 107, + 79, + 501, + 146.33333333333331 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 107, + 146.33333333333331, + 501, + 213.66666666666663 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 107, + 213.66666666666663, + 501, + 280.99999999999994 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 104, + 291, + 501, + 303 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 290, + 501, + 304 + ], + "spans": [ + { + "bbox": [ + 106, + 290, + 501, + 304 + ], + "score": 1.0, + "content": "Figure 1: Software stack of the DLVM infrastructure. Blue components are the compiler framework.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "text", + "bbox": [ + 107, + 325, + 506, + 424 + ], + "lines": [ + { + "bbox": [ + 106, + 325, + 506, + 338 + ], + "spans": [ + { + "bbox": [ + 106, + 325, + 506, + 338 + ], + "score": 1.0, + "content": "We introduce DLVM, a new compiler infrastructure for deep learning systems that addresses shortcom-", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 336, + 506, + 348 + ], + "spans": [ + { + "bbox": [ + 105, + 336, + 506, + 348 + ], + "score": 1.0, + "content": "ings of existing deep learning frameworks. Our solution includes (1) a domain-specific intermediate", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 104, + 346, + 506, + 360 + ], + "spans": [ + { + "bbox": [ + 104, + 346, + 506, + 360 + ], + "score": 1.0, + "content": "representation specifically designed for tensor computation, (2) principled use of modern compiler", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 357, + 506, + 371 + ], + "spans": [ + { + "bbox": [ + 105, + 357, + 506, + 371 + ], + "score": 1.0, + "content": "optimization techniques to substantially simplify neural network computation, including algebra sim-", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 369, + 506, + 382 + ], + "spans": [ + { + "bbox": [ + 105, + 369, + 506, + 382 + ], + "score": 1.0, + "content": "plification, AD checkpointing, compute kernel fusion, and various traditional compiler optimizations,", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 380, + 506, + 393 + ], + "spans": [ + { + "bbox": [ + 106, + 380, + 506, + 393 + ], + "score": 1.0, + "content": "(3) code generation through a mature compiler infrastructure that allows for transparent targeting of", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 391, + 506, + 404 + ], + "spans": [ + { + "bbox": [ + 106, + 391, + 506, + 404 + ], + "score": 1.0, + "content": "various hardware, and (4) an embedded DSL that supports static analysis, type safety, and natural", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 401, + 506, + 416 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 506, + 416 + ], + "score": 1.0, + "content": "expression of tensor computation, and has a just-in-time (JIT) compiler targeting DLVM for AD,", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 413, + 250, + 426 + ], + "spans": [ + { + "bbox": [ + 106, + 413, + 250, + 426 + ], + "score": 1.0, + "content": "optimizations, and code generation.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 8, + "bbox_fs": [ + 104, + 325, + 506, + 426 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 441, + 211, + 454 + ], + "lines": [ + { + "bbox": [ + 104, + 440, + 213, + 457 + ], + "spans": [ + { + "bbox": [ + 104, + 440, + 213, + 457 + ], + "score": 1.0, + "content": "2 RELATED WORK", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 107, + 467, + 505, + 555 + ], + "lines": [ + { + "bbox": [ + 105, + 466, + 505, + 480 + ], + "spans": [ + { + "bbox": [ + 105, + 466, + 505, + 480 + ], + "score": 1.0, + "content": "Numerous existing projects provide specialized systems for machine learning but are not closely", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 477, + 505, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 505, + 492 + ], + "score": 1.0, + "content": "related to our work. These include Apache SystemML (Ghoting et al., 2011), a high-level language", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 489, + 505, + 502 + ], + "spans": [ + { + "bbox": [ + 105, + 489, + 505, + 502 + ], + "score": 1.0, + "content": "and framework for writing and executing machine learning problems targeting Apache Spark, and", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 500, + 505, + 513 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 241, + 513 + ], + "score": 1.0, + "content": "TACO (Kjolstad et al., 2017), a", + "type": "text" + }, + { + "bbox": [ + 241, + 501, + 262, + 511 + ], + "score": 0.85, + "content": "\\mathrm { C } { + } { + }", + "type": "inline_equation" + }, + { + "bbox": [ + 263, + 500, + 505, + 513 + ], + "score": 1.0, + "content": "library for compiling and optimizing kernels that is more", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 511, + 505, + 524 + ], + "spans": [ + { + "bbox": [ + 105, + 511, + 505, + 524 + ], + "score": 1.0, + "content": "similar to Halide (Ragan-Kelley et al., 2013) than to our work. Our work treats the creation of neural", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 523, + 505, + 535 + ], + "spans": [ + { + "bbox": [ + 105, + 523, + 505, + 535 + ], + "score": 1.0, + "content": "networks as a compilers problem to be addressed using mature compiler techniques. SystemML does", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 533, + 506, + 547 + ], + "spans": [ + { + "bbox": [ + 105, + 533, + 506, + 547 + ], + "score": 1.0, + "content": "not consider this issue at all; TACO does use compiler optimization, but only at a very low level to", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 545, + 220, + 556 + ], + "spans": [ + { + "bbox": [ + 105, + 545, + 220, + 556 + ], + "score": 1.0, + "content": "generate individual kernels.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 17.5, + "bbox_fs": [ + 105, + 466, + 506, + 556 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 561, + 505, + 660 + ], + "lines": [ + { + "bbox": [ + 106, + 561, + 506, + 573 + ], + "spans": [ + { + "bbox": [ + 106, + 561, + 506, + 573 + ], + "score": 1.0, + "content": "Two projects closely related to this work are the TensorFlow XLA compiler and the NNVM compiler.", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 571, + 506, + 585 + ], + "spans": [ + { + "bbox": [ + 105, + 571, + 506, + 585 + ], + "score": 1.0, + "content": "The code representation in these frameworks is a “sea of nodes” representation, embedding control", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 106, + 583, + 506, + 596 + ], + "spans": [ + { + "bbox": [ + 106, + 583, + 506, + 596 + ], + "score": 1.0, + "content": "flow nodes and composite nodes in a data flow graph. To apply algorithmic differentiation on this", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 594, + 505, + 607 + ], + "spans": [ + { + "bbox": [ + 106, + 594, + 505, + 607 + ], + "score": 1.0, + "content": "IR requires non-standard processing. In contrast, our approach is designed from the start around the", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 604, + 506, + 619 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 506, + 619 + ], + "score": 1.0, + "content": "idea that a neural network (and its associated tensor computations) is itself a program, which is best", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 615, + 506, + 629 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 506, + 629 + ], + "score": 1.0, + "content": "optimized through robust application of mature techniques in a principled compilation pipeline. We", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 627, + 506, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 627, + 506, + 640 + ], + "score": 1.0, + "content": "represent tensor computation in static single assignment (SSA) form with control flow graph, and", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 637, + 507, + 652 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 507, + 652 + ], + "score": 1.0, + "content": "perform algorithmic differentiation, domain-specific optimizations, general-purpose optimizations,", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 649, + 289, + 661 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 289, + 661 + ], + "score": 1.0, + "content": "low-level optimizations, and code generation.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 26, + "bbox_fs": [ + 105, + 561, + 507, + 661 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 666, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 665, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 505, + 678 + ], + "score": 1.0, + "content": "XLA takes a similar approach to ours, transforming TensorFlow sub-graphs to XLA’s HLO graph", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 106, + 677, + 505, + 690 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 690 + ], + "score": 1.0, + "content": "and performing optimizations. Our intermediate representation is much more expressive than XLA’s", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 688, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 505, + 700 + ], + "score": 1.0, + "content": "by including modular IR components and general-purpose instructions; this enables our approach", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 698, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 711 + ], + "score": 1.0, + "content": "to support full-fledged DSLs including standalone compiled DSLs and perform more extensive", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "optimizations such as inlining and interprocedual optimizations. Our approach also differs from XLA", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 506, + 734 + ], + "score": 1.0, + "content": "by representing composite functions such as min and max directly through primitive instructions", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 246, + 505, + 259 + ], + "spans": [ + { + "bbox": [ + 105, + 246, + 505, + 259 + ], + "score": 1.0, + "content": "such as compare and select, which enables us to apply generic AD, and by using SSA form", + "type": "text", + "cross_page": true + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 257, + 505, + 270 + ], + "spans": [ + { + "bbox": [ + 105, + 257, + 505, + 270 + ], + "score": 1.0, + "content": "with control flow graph, which allows for reusing battle-tested SSA optimization algorithms in the", + "type": "text", + "cross_page": true + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 267, + 506, + 281 + ], + "spans": [ + { + "bbox": [ + 105, + 267, + 506, + 281 + ], + "score": 1.0, + "content": "LLVM community. Importantly, our entire infrastructure was designed from the start around a", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 104, + 278, + 506, + 293 + ], + "spans": [ + { + "bbox": [ + 104, + 278, + 506, + 293 + ], + "score": 1.0, + "content": "robust compile-time framework for tensor DSLs, whereas XLA has been adapted around the existing", + "type": "text", + "cross_page": true + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 288, + 506, + 304 + ], + "spans": [ + { + "bbox": [ + 105, + 288, + 506, + 304 + ], + "score": 1.0, + "content": "TensorFlow infrastructure with a particular focus on hardware support for Google’s Tensor Processing", + "type": "text", + "cross_page": true + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 302, + 215, + 313 + ], + "spans": [ + { + "bbox": [ + 106, + 302, + 215, + 313 + ], + "score": 1.0, + "content": "Units (Jouppi et al., 2017).", + "type": "text", + "cross_page": true + } + ], + "index": 9 + } + ], + "index": 33.5, + "bbox_fs": [ + 105, + 665, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 105, + 78, + 509, + 203 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 105, + 78, + 509, + 203 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 78, + 509, + 203 + ], + "spans": [ + { + "bbox": [ + 105, + 78, + 509, + 203 + ], + "score": 0.959, + "type": "image", + "image_path": "3c33c1e1b4e49d79cea6b0b96005ddd908e5cf9752dd02376466dc1917156439.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 105, + 78, + 509, + 119.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 105, + 119.66666666666666, + 509, + 161.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 105, + 161.33333333333331, + 509, + 202.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 172, + 213, + 434, + 225 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 172, + 210, + 435, + 228 + ], + "spans": [ + { + "bbox": [ + 172, + 210, + 435, + 228 + ], + "score": 1.0, + "content": "Figure 2: Compilation stages in the DLVM compilation pipeline.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "text", + "bbox": [ + 107, + 246, + 505, + 313 + ], + "lines": [ + { + "bbox": [ + 105, + 246, + 505, + 259 + ], + "spans": [ + { + "bbox": [ + 105, + 246, + 505, + 259 + ], + "score": 1.0, + "content": "such as compare and select, which enables us to apply generic AD, and by using SSA form", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 257, + 505, + 270 + ], + "spans": [ + { + "bbox": [ + 105, + 257, + 505, + 270 + ], + "score": 1.0, + "content": "with control flow graph, which allows for reusing battle-tested SSA optimization algorithms in the", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 267, + 506, + 281 + ], + "spans": [ + { + "bbox": [ + 105, + 267, + 506, + 281 + ], + "score": 1.0, + "content": "LLVM community. Importantly, our entire infrastructure was designed from the start around a", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 104, + 278, + 506, + 293 + ], + "spans": [ + { + "bbox": [ + 104, + 278, + 506, + 293 + ], + "score": 1.0, + "content": "robust compile-time framework for tensor DSLs, whereas XLA has been adapted around the existing", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 288, + 506, + 304 + ], + "spans": [ + { + "bbox": [ + 105, + 288, + 506, + 304 + ], + "score": 1.0, + "content": "TensorFlow infrastructure with a particular focus on hardware support for Google’s Tensor Processing", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 106, + 302, + 215, + 313 + ], + "spans": [ + { + "bbox": [ + 106, + 302, + 215, + 313 + ], + "score": 1.0, + "content": "Units (Jouppi et al., 2017).", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 6.5 + }, + { + "type": "text", + "bbox": [ + 106, + 318, + 505, + 417 + ], + "lines": [ + { + "bbox": [ + 105, + 317, + 506, + 331 + ], + "spans": [ + { + "bbox": [ + 105, + 317, + 420, + 331 + ], + "score": 1.0, + "content": "Where TVM and NNVM are built as a DSL and a graph library in Python with a", + "type": "text" + }, + { + "bbox": [ + 420, + 319, + 439, + 329 + ], + "score": 0.85, + "content": "\\mathrm { C } { + } { + }", + "type": "inline_equation" + }, + { + "bbox": [ + 440, + 317, + 506, + 331 + ], + "score": 1.0, + "content": "implementation,", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 104, + 327, + 507, + 343 + ], + "spans": [ + { + "bbox": [ + 104, + 327, + 507, + 343 + ], + "score": 1.0, + "content": "DLVM’s architecture is closer to LLVM and the Swift Intermediate Language (Groff & Lattner,", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 339, + 505, + 353 + ], + "spans": [ + { + "bbox": [ + 105, + 339, + 505, + 353 + ], + "score": 1.0, + "content": "2015), having an IR file format and a full-fledged command line toolchain. More specifically, our", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 350, + 506, + 364 + ], + "spans": [ + { + "bbox": [ + 105, + 350, + 506, + 364 + ], + "score": 1.0, + "content": "work differs from NNVM and XLA in the design and presence of an IR that has a textual parsable", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 361, + 506, + 375 + ], + "spans": [ + { + "bbox": [ + 105, + 361, + 506, + 375 + ], + "score": 1.0, + "content": "format, a module/function/basic block hierarchy, custom type declarations and memory semantics.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 372, + 506, + 386 + ], + "spans": [ + { + "bbox": [ + 106, + 372, + 506, + 386 + ], + "score": 1.0, + "content": "The textual IR enables robust unit testing via FileCheck, which is used extensively in LLVM and", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 383, + 505, + 397 + ], + "spans": [ + { + "bbox": [ + 105, + 383, + 505, + 397 + ], + "score": 1.0, + "content": "most LLVM-based compilers. Moreover, DLVM and its associated DSLs are implemented entirely", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 104, + 394, + 506, + 409 + ], + "spans": [ + { + "bbox": [ + 104, + 394, + 506, + 409 + ], + "score": 1.0, + "content": "in Swift, a safe systems programming language, and thus have an elegantly compact codebase and", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 407, + 170, + 417 + ], + "spans": [ + { + "bbox": [ + 106, + 407, + 170, + 417 + ], + "score": 1.0, + "content": "type-safe APIs.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 14 + }, + { + "type": "title", + "bbox": [ + 108, + 434, + 163, + 447 + ], + "lines": [ + { + "bbox": [ + 104, + 433, + 165, + 450 + ], + "spans": [ + { + "bbox": [ + 104, + 433, + 165, + 450 + ], + "score": 1.0, + "content": "3 DLVM", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 107, + 461, + 505, + 527 + ], + "lines": [ + { + "bbox": [ + 105, + 460, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 460, + 505, + 475 + ], + "score": 1.0, + "content": "Deep Learning Virtual Machine (DLVM) is a compiler infrastructure designed for modern deep", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 471, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 505, + 486 + ], + "score": 1.0, + "content": "learning systems.1 DLVM is designed to apply a multi-stage compiler optimization strategy to both", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 483, + 506, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 506, + 496 + ], + "score": 1.0, + "content": "high-level linear algebra and low-level parallelism, perform domain-specific transformations, relieve", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 494, + 506, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 506, + 507 + ], + "score": 1.0, + "content": "the overhead in front-end languages, and serve as the host for research and development of DSLs for", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 504, + 507, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 504, + 507, + 519 + ], + "score": 1.0, + "content": "deep learning. The complete DLVM software stack, including sample front-end deep learning DSLs,", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 515, + 283, + 530 + ], + "spans": [ + { + "bbox": [ + 105, + 515, + 283, + 530 + ], + "score": 1.0, + "content": "is shown in Figure 1 on the preceding page.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 107, + 532, + 505, + 599 + ], + "lines": [ + { + "bbox": [ + 105, + 532, + 505, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 532, + 505, + 546 + ], + "score": 1.0, + "content": "Figure 2 illustrates the major stages in the DLVM compilation pipeline. The DLVM compilation stages", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 543, + 506, + 557 + ], + "spans": [ + { + "bbox": [ + 106, + 543, + 506, + 557 + ], + "score": 1.0, + "content": "address algorithmic differentiation, domain-specific optimizations, general-purpose optimizations,", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 555, + 506, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 555, + 506, + 568 + ], + "score": 1.0, + "content": "and static code generation targeting a variety of compute architectures. The raw and optimizable", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 565, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 505, + 579 + ], + "score": 1.0, + "content": "stages allow constructs for high-level tensor operations and various high-level optimizations. The", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 577, + 506, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 506, + 590 + ], + "score": 1.0, + "content": "compute and schedule stages allow constructs for low-level array operations lowered from tensor", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 588, + 484, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 484, + 601 + ], + "score": 1.0, + "content": "operations in high-level stages, borrowing the design from Halide (Ragan-Kelley et al., 2013).", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 28.5 + }, + { + "type": "text", + "bbox": [ + 107, + 604, + 505, + 660 + ], + "lines": [ + { + "bbox": [ + 105, + 604, + 505, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 505, + 618 + ], + "score": 1.0, + "content": "The DLVM Intermediate Representation (IR) is the core language of the system. It uses static single", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 615, + 505, + 628 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 505, + 628 + ], + "score": 1.0, + "content": "assignment (SSA) form, control flow graphs, high-level types including a first-class tensor type, and", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 626, + 505, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 505, + 640 + ], + "score": 1.0, + "content": "a set of linear algebra operators combined with a general-purpose instruction set (see Table 1). The", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 637, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 505, + 650 + ], + "score": 1.0, + "content": "system enables a wide variety of domain-specific analyses and transformations, such as reverse-mode", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 649, + 396, + 660 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 396, + 660 + ], + "score": 1.0, + "content": "AD, AD checkpointing, algebra simplification and linear algebra fusion.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 34 + }, + { + "type": "text", + "bbox": [ + 107, + 665, + 504, + 709 + ], + "lines": [ + { + "bbox": [ + 105, + 664, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 506, + 678 + ], + "score": 1.0, + "content": "To demonstrate how DLVM helps the development of domain-specific languages (DSLs), in Sec-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 676, + 506, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 506, + 689 + ], + "score": 1.0, + "content": "tion 3.4 we present one prototypical staged DSL: NNKit. NNKit features safe and natural expression", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "of tensor computation alongside the host program, and targets DLVM for differentiation, optimizations", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 699, + 214, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 214, + 711 + ], + "score": 1.0, + "content": "and static code generation.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 38.5 + } + ], + "page_idx": 2, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 119, + 722, + 389, + 732 + ], + "lines": [ + { + "bbox": [ + 119, + 720, + 390, + 733 + ], + "spans": [ + { + "bbox": [ + 119, + 720, + 390, + 733 + ], + "score": 1.0, + "content": "1Code for DLVM is available at https://github.com/dlvm-team", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 107, + 27, + 224, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 225, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 225, + 38 + ], + "score": 1.0, + "content": "Workshop track - ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 760 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "score": 1.0, + "content": "3", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 105, + 78, + 509, + 203 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 105, + 78, + 509, + 203 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 78, + 509, + 203 + ], + "spans": [ + { + "bbox": [ + 105, + 78, + 509, + 203 + ], + "score": 0.959, + "type": "image", + "image_path": "3c33c1e1b4e49d79cea6b0b96005ddd908e5cf9752dd02376466dc1917156439.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 105, + 78, + 509, + 119.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 105, + 119.66666666666666, + 509, + 161.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 105, + 161.33333333333331, + 509, + 202.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 172, + 213, + 434, + 225 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 172, + 210, + 435, + 228 + ], + "spans": [ + { + "bbox": [ + 172, + 210, + 435, + 228 + ], + "score": 1.0, + "content": "Figure 2: Compilation stages in the DLVM compilation pipeline.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "text", + "bbox": [ + 107, + 246, + 505, + 313 + ], + "lines": [], + "index": 6.5, + "bbox_fs": [ + 104, + 246, + 506, + 313 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 106, + 318, + 505, + 417 + ], + "lines": [ + { + "bbox": [ + 105, + 317, + 506, + 331 + ], + "spans": [ + { + "bbox": [ + 105, + 317, + 420, + 331 + ], + "score": 1.0, + "content": "Where TVM and NNVM are built as a DSL and a graph library in Python with a", + "type": "text" + }, + { + "bbox": [ + 420, + 319, + 439, + 329 + ], + "score": 0.85, + "content": "\\mathrm { C } { + } { + }", + "type": "inline_equation" + }, + { + "bbox": [ + 440, + 317, + 506, + 331 + ], + "score": 1.0, + "content": "implementation,", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 104, + 327, + 507, + 343 + ], + "spans": [ + { + "bbox": [ + 104, + 327, + 507, + 343 + ], + "score": 1.0, + "content": "DLVM’s architecture is closer to LLVM and the Swift Intermediate Language (Groff & Lattner,", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 339, + 505, + 353 + ], + "spans": [ + { + "bbox": [ + 105, + 339, + 505, + 353 + ], + "score": 1.0, + "content": "2015), having an IR file format and a full-fledged command line toolchain. More specifically, our", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 350, + 506, + 364 + ], + "spans": [ + { + "bbox": [ + 105, + 350, + 506, + 364 + ], + "score": 1.0, + "content": "work differs from NNVM and XLA in the design and presence of an IR that has a textual parsable", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 361, + 506, + 375 + ], + "spans": [ + { + "bbox": [ + 105, + 361, + 506, + 375 + ], + "score": 1.0, + "content": "format, a module/function/basic block hierarchy, custom type declarations and memory semantics.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 372, + 506, + 386 + ], + "spans": [ + { + "bbox": [ + 106, + 372, + 506, + 386 + ], + "score": 1.0, + "content": "The textual IR enables robust unit testing via FileCheck, which is used extensively in LLVM and", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 383, + 505, + 397 + ], + "spans": [ + { + "bbox": [ + 105, + 383, + 505, + 397 + ], + "score": 1.0, + "content": "most LLVM-based compilers. Moreover, DLVM and its associated DSLs are implemented entirely", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 104, + 394, + 506, + 409 + ], + "spans": [ + { + "bbox": [ + 104, + 394, + 506, + 409 + ], + "score": 1.0, + "content": "in Swift, a safe systems programming language, and thus have an elegantly compact codebase and", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 106, + 407, + 170, + 417 + ], + "spans": [ + { + "bbox": [ + 106, + 407, + 170, + 417 + ], + "score": 1.0, + "content": "type-safe APIs.", + "type": "text" + } + ], + "index": 18 + } + ], + "index": 14, + "bbox_fs": [ + 104, + 317, + 507, + 417 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 434, + 163, + 447 + ], + "lines": [ + { + "bbox": [ + 104, + 433, + 165, + 450 + ], + "spans": [ + { + "bbox": [ + 104, + 433, + 165, + 450 + ], + "score": 1.0, + "content": "3 DLVM", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 19 + }, + { + "type": "text", + "bbox": [ + 107, + 461, + 505, + 527 + ], + "lines": [ + { + "bbox": [ + 105, + 460, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 105, + 460, + 505, + 475 + ], + "score": 1.0, + "content": "Deep Learning Virtual Machine (DLVM) is a compiler infrastructure designed for modern deep", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 471, + 505, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 505, + 486 + ], + "score": 1.0, + "content": "learning systems.1 DLVM is designed to apply a multi-stage compiler optimization strategy to both", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 483, + 506, + 496 + ], + "spans": [ + { + "bbox": [ + 105, + 483, + 506, + 496 + ], + "score": 1.0, + "content": "high-level linear algebra and low-level parallelism, perform domain-specific transformations, relieve", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 494, + 506, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 494, + 506, + 507 + ], + "score": 1.0, + "content": "the overhead in front-end languages, and serve as the host for research and development of DSLs for", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 504, + 507, + 519 + ], + "spans": [ + { + "bbox": [ + 105, + 504, + 507, + 519 + ], + "score": 1.0, + "content": "deep learning. The complete DLVM software stack, including sample front-end deep learning DSLs,", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 515, + 283, + 530 + ], + "spans": [ + { + "bbox": [ + 105, + 515, + 283, + 530 + ], + "score": 1.0, + "content": "is shown in Figure 1 on the preceding page.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22.5, + "bbox_fs": [ + 105, + 460, + 507, + 530 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 532, + 505, + 599 + ], + "lines": [ + { + "bbox": [ + 105, + 532, + 505, + 546 + ], + "spans": [ + { + "bbox": [ + 105, + 532, + 505, + 546 + ], + "score": 1.0, + "content": "Figure 2 illustrates the major stages in the DLVM compilation pipeline. The DLVM compilation stages", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 543, + 506, + 557 + ], + "spans": [ + { + "bbox": [ + 106, + 543, + 506, + 557 + ], + "score": 1.0, + "content": "address algorithmic differentiation, domain-specific optimizations, general-purpose optimizations,", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 555, + 506, + 568 + ], + "spans": [ + { + "bbox": [ + 105, + 555, + 506, + 568 + ], + "score": 1.0, + "content": "and static code generation targeting a variety of compute architectures. The raw and optimizable", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 565, + 505, + 579 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 505, + 579 + ], + "score": 1.0, + "content": "stages allow constructs for high-level tensor operations and various high-level optimizations. The", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 577, + 506, + 590 + ], + "spans": [ + { + "bbox": [ + 105, + 577, + 506, + 590 + ], + "score": 1.0, + "content": "compute and schedule stages allow constructs for low-level array operations lowered from tensor", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 588, + 484, + 601 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 484, + 601 + ], + "score": 1.0, + "content": "operations in high-level stages, borrowing the design from Halide (Ragan-Kelley et al., 2013).", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 28.5, + "bbox_fs": [ + 105, + 532, + 506, + 601 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 604, + 505, + 660 + ], + "lines": [ + { + "bbox": [ + 105, + 604, + 505, + 618 + ], + "spans": [ + { + "bbox": [ + 105, + 604, + 505, + 618 + ], + "score": 1.0, + "content": "The DLVM Intermediate Representation (IR) is the core language of the system. It uses static single", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 615, + 505, + 628 + ], + "spans": [ + { + "bbox": [ + 105, + 615, + 505, + 628 + ], + "score": 1.0, + "content": "assignment (SSA) form, control flow graphs, high-level types including a first-class tensor type, and", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 626, + 505, + 640 + ], + "spans": [ + { + "bbox": [ + 105, + 626, + 505, + 640 + ], + "score": 1.0, + "content": "a set of linear algebra operators combined with a general-purpose instruction set (see Table 1). The", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 637, + 505, + 650 + ], + "spans": [ + { + "bbox": [ + 105, + 637, + 505, + 650 + ], + "score": 1.0, + "content": "system enables a wide variety of domain-specific analyses and transformations, such as reverse-mode", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 649, + 396, + 660 + ], + "spans": [ + { + "bbox": [ + 106, + 649, + 396, + 660 + ], + "score": 1.0, + "content": "AD, AD checkpointing, algebra simplification and linear algebra fusion.", + "type": "text" + } + ], + "index": 36 + } + ], + "index": 34, + "bbox_fs": [ + 105, + 604, + 505, + 660 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 665, + 504, + 709 + ], + "lines": [ + { + "bbox": [ + 105, + 664, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 664, + 506, + 678 + ], + "score": 1.0, + "content": "To demonstrate how DLVM helps the development of domain-specific languages (DSLs), in Sec-", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 676, + 506, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 506, + 689 + ], + "score": 1.0, + "content": "tion 3.4 we present one prototypical staged DSL: NNKit. NNKit features safe and natural expression", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "of tensor computation alongside the host program, and targets DLVM for differentiation, optimizations", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 106, + 699, + 214, + 711 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 214, + 711 + ], + "score": 1.0, + "content": "and static code generation.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 38.5, + "bbox_fs": [ + 105, + 664, + 506, + 711 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "table", + "bbox": [ + 106, + 81, + 507, + 227 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 106, + 81, + 507, + 227 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 81, + 507, + 227 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 507, + 227 + ], + "score": 0.983, + "html": "
KindExample
Element-wise unaryElement-wise binaryDot
dot %a:<10 x
ReduceTransposeSliceCompareData type cast
slice %a:
Function applicationBranchConditional branchShape castarplly%
brannch
", + "type": "table", + "image_path": "20d98aab7a123e6c09753bfb3cc8dfb7035594771e0bb772d661ba37e0d7df18.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 81, + 507, + 129.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 129.66666666666666, + 507, + 178.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 178.33333333333331, + 507, + 226.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 106, + 239, + 506, + 272 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 238, + 505, + 251 + ], + "spans": [ + { + "bbox": [ + 105, + 238, + 505, + 251 + ], + "score": 1.0, + "content": "Table 1: This table illustrates a selection of the instructions in the DLVM virtual instruction set. The", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 250, + 504, + 261 + ], + "spans": [ + { + "bbox": [ + 106, + 250, + 504, + 261 + ], + "score": 1.0, + "content": "instruction set includes linear algebra operations such as tanh and dot in addition to control flow", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 261, + 227, + 272 + ], + "spans": [ + { + "bbox": [ + 106, + 261, + 227, + 272 + ], + "score": 1.0, + "content": "instructions such as branch.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "title", + "bbox": [ + 107, + 298, + 189, + 310 + ], + "lines": [ + { + "bbox": [ + 105, + 297, + 191, + 311 + ], + "spans": [ + { + "bbox": [ + 105, + 297, + 191, + 311 + ], + "score": 1.0, + "content": "3.1 DLVM CORE", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 107, + 320, + 505, + 375 + ], + "lines": [ + { + "bbox": [ + 105, + 319, + 505, + 333 + ], + "spans": [ + { + "bbox": [ + 105, + 319, + 505, + 333 + ], + "score": 1.0, + "content": "DLVM Core contains essential components for an optimizing compiler: IR, pass manager, and passes", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 331, + 505, + 344 + ], + "spans": [ + { + "bbox": [ + 105, + 331, + 505, + 344 + ], + "score": 1.0, + "content": "(see Figure 1 on page 2). The DLVM IR consists of a virtual instruction set, control flow graph", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 342, + 505, + 354 + ], + "spans": [ + { + "bbox": [ + 105, + 342, + 505, + 354 + ], + "score": 1.0, + "content": "and data flow representation. Passes are functions that traverse the intermediate representation of a", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 352, + 506, + 366 + ], + "spans": [ + { + "bbox": [ + 105, + 352, + 506, + 366 + ], + "score": 1.0, + "content": "program, either producing useful results as analyses of the program (analysis passes), or mutating the", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 363, + 368, + 377 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 368, + 377 + ], + "score": 1.0, + "content": "program for differentiation and optimizations (transform passes).", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 9 + }, + { + "type": "title", + "bbox": [ + 107, + 389, + 474, + 401 + ], + "lines": [ + { + "bbox": [ + 105, + 389, + 477, + 402 + ], + "spans": [ + { + "bbox": [ + 105, + 389, + 477, + 402 + ], + "score": 1.0, + "content": "3.1.1 A DOMAIN-SPECIFIC COMPILER INTERMEDIATE REPRESENTATION FOR DLVM", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 107, + 409, + 505, + 498 + ], + "lines": [ + { + "bbox": [ + 106, + 410, + 505, + 422 + ], + "spans": [ + { + "bbox": [ + 106, + 410, + 505, + 422 + ], + "score": 1.0, + "content": "Inspired by the LLVM IR (Lattner & Adve, 2004) and the Swift Intermediate Language (Groff &", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 104, + 420, + 506, + 435 + ], + "spans": [ + { + "bbox": [ + 104, + 420, + 506, + 435 + ], + "score": 1.0, + "content": "Lattner, 2015), DLVM IR is a graph-based, modular code representation, with both an in-memory", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 433, + 506, + 444 + ], + "spans": [ + { + "bbox": [ + 106, + 433, + 506, + 444 + ], + "score": 1.0, + "content": "format and a textual format. The code representation has a hierarchy of abstractions: module,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 442, + 506, + 456 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 506, + 456 + ], + "score": 1.0, + "content": "function, basic block, and instruction. An instruction is the minimal unit of code that operates", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 453, + 506, + 467 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 506, + 467 + ], + "score": 1.0, + "content": "on values, which can be globals, function arguments or temporary virtual registers produced by", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 465, + 506, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 465, + 506, + 477 + ], + "score": 1.0, + "content": "instructions. Each module contains a collection of type definitions, global values and functions. Each", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 476, + 506, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 476, + 506, + 487 + ], + "score": 1.0, + "content": "function has a control flow graph formed by basic blocks and control flow edges. Each basic block", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 487, + 490, + 499 + ], + "spans": [ + { + "bbox": [ + 106, + 487, + 490, + 499 + ], + "score": 1.0, + "content": "contains an ordered list of instructions with data dependencies forming a directed acyclic graph.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 16.5 + }, + { + "type": "text", + "bbox": [ + 107, + 504, + 505, + 581 + ], + "lines": [ + { + "bbox": [ + 106, + 504, + 505, + 516 + ], + "spans": [ + { + "bbox": [ + 106, + 504, + 505, + 516 + ], + "score": 1.0, + "content": "The DLVM IR has a high-level type system with tensor as a first-class type. The DLVM virtual", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 515, + 506, + 528 + ], + "spans": [ + { + "bbox": [ + 106, + 515, + 506, + 528 + ], + "score": 1.0, + "content": "instruction set includes domain-specific primitive math operators, as well as general-purpose instruc-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 526, + 505, + 538 + ], + "spans": [ + { + "bbox": [ + 106, + 526, + 505, + 538 + ], + "score": 1.0, + "content": "tions for memory management, control flow and function application. Domain-specific instructions", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 536, + 506, + 549 + ], + "spans": [ + { + "bbox": [ + 105, + 536, + 506, + 549 + ], + "score": 1.0, + "content": "include element-wise unary operators, such as tanh and negate, element-wise binary operators,", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 549, + 505, + 559 + ], + "spans": [ + { + "bbox": [ + 106, + 549, + 505, + 559 + ], + "score": 1.0, + "content": "such as add and power, and complex operators such as dot, transpose, and convolve. All", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 558, + 505, + 570 + ], + "spans": [ + { + "bbox": [ + 106, + 558, + 505, + 570 + ], + "score": 1.0, + "content": "element-wise binary operators support broadcasting. A sample of DLVM IR code is shown in Figure 3", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 569, + 177, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 569, + 177, + 583 + ], + "score": 1.0, + "content": "on the next page.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 107, + 586, + 505, + 631 + ], + "lines": [ + { + "bbox": [ + 105, + 586, + 507, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 586, + 507, + 599 + ], + "score": 1.0, + "content": "The DLVM instruction set does not include composite math functions such as softmax, sigmoid,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 597, + 505, + 609 + ], + "spans": [ + { + "bbox": [ + 106, + 597, + 505, + 609 + ], + "score": 1.0, + "content": "min or max. All of these functions can be composed of primitive math instructions and control flow", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 609, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 106, + 609, + 505, + 621 + ], + "score": 1.0, + "content": "constructs. This design allows for the standard AD algorithm to be applied to any differentiable", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 619, + 362, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 619, + 362, + 632 + ], + "score": 1.0, + "content": "program, with no need for special handling of composite cases.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29.5 + }, + { + "type": "title", + "bbox": [ + 106, + 645, + 353, + 657 + ], + "lines": [ + { + "bbox": [ + 106, + 645, + 354, + 658 + ], + "spans": [ + { + "bbox": [ + 106, + 645, + 354, + 658 + ], + "score": 1.0, + "content": "3.1.2 DOMAIN-SPECIFIC COMPILER PASSES FOR DLVM", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 107, + 666, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 665, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 506, + 678 + ], + "score": 1.0, + "content": "DLVM has a full-fledged pass infrastructure, performing various analyses and two kinds of trans-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "formations: differentiation and optimization. Differentiation constructs function definitions from", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "gradient declarations using adjoint code generation (see Section 3.1.3 below). Optimization is then", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "score": 1.0, + "content": "performed on the resulting IR, maximizing the code performance. Optimizations include domain-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "specific optimizations, such as algebra simplification, linear algebra fusion, matrix multiplication", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 721, + 405, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 405, + 733 + ], + "score": 1.0, + "content": "reordering, and AD checkpointing, and traditional compiler optimizations.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 35.5 + } + ], + "page_idx": 3, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 224, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 225, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 225, + 38 + ], + "score": 1.0, + "content": "Workshop track - ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 759 + ], + "lines": [] + } + ], + "para_blocks": [ + { + "type": "table", + "bbox": [ + 106, + 81, + 507, + 227 + ], + "blocks": [ + { + "type": "table_body", + "bbox": [ + 106, + 81, + 507, + 227 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 81, + 507, + 227 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 507, + 227 + ], + "score": 0.983, + "html": "
KindExample
Element-wise unaryElement-wise binaryDot
dot %a:<10 x
ReduceTransposeSliceCompareData type cast
slice %a:
Function applicationBranchConditional branchShape castarplly%
brannch
", + "type": "table", + "image_path": "20d98aab7a123e6c09753bfb3cc8dfb7035594771e0bb772d661ba37e0d7df18.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 106, + 81, + 507, + 129.66666666666666 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 106, + 129.66666666666666, + 507, + 178.33333333333331 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 106, + 178.33333333333331, + 507, + 226.99999999999997 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "table_caption", + "bbox": [ + 106, + 239, + 506, + 272 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 105, + 238, + 505, + 251 + ], + "spans": [ + { + "bbox": [ + 105, + 238, + 505, + 251 + ], + "score": 1.0, + "content": "Table 1: This table illustrates a selection of the instructions in the DLVM virtual instruction set. The", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 250, + 504, + 261 + ], + "spans": [ + { + "bbox": [ + 106, + 250, + 504, + 261 + ], + "score": 1.0, + "content": "instruction set includes linear algebra operations such as tanh and dot in addition to control flow", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 261, + 227, + 272 + ], + "spans": [ + { + "bbox": [ + 106, + 261, + 227, + 272 + ], + "score": 1.0, + "content": "instructions such as branch.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "title", + "bbox": [ + 107, + 298, + 189, + 310 + ], + "lines": [ + { + "bbox": [ + 105, + 297, + 191, + 311 + ], + "spans": [ + { + "bbox": [ + 105, + 297, + 191, + 311 + ], + "score": 1.0, + "content": "3.1 DLVM CORE", + "type": "text" + } + ], + "index": 6 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 107, + 320, + 505, + 375 + ], + "lines": [ + { + "bbox": [ + 105, + 319, + 505, + 333 + ], + "spans": [ + { + "bbox": [ + 105, + 319, + 505, + 333 + ], + "score": 1.0, + "content": "DLVM Core contains essential components for an optimizing compiler: IR, pass manager, and passes", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 331, + 505, + 344 + ], + "spans": [ + { + "bbox": [ + 105, + 331, + 505, + 344 + ], + "score": 1.0, + "content": "(see Figure 1 on page 2). The DLVM IR consists of a virtual instruction set, control flow graph", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 342, + 505, + 354 + ], + "spans": [ + { + "bbox": [ + 105, + 342, + 505, + 354 + ], + "score": 1.0, + "content": "and data flow representation. Passes are functions that traverse the intermediate representation of a", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 352, + 506, + 366 + ], + "spans": [ + { + "bbox": [ + 105, + 352, + 506, + 366 + ], + "score": 1.0, + "content": "program, either producing useful results as analyses of the program (analysis passes), or mutating the", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 363, + 368, + 377 + ], + "spans": [ + { + "bbox": [ + 105, + 363, + 368, + 377 + ], + "score": 1.0, + "content": "program for differentiation and optimizations (transform passes).", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 9, + "bbox_fs": [ + 105, + 319, + 506, + 377 + ] + }, + { + "type": "title", + "bbox": [ + 107, + 389, + 474, + 401 + ], + "lines": [ + { + "bbox": [ + 105, + 389, + 477, + 402 + ], + "spans": [ + { + "bbox": [ + 105, + 389, + 477, + 402 + ], + "score": 1.0, + "content": "3.1.1 A DOMAIN-SPECIFIC COMPILER INTERMEDIATE REPRESENTATION FOR DLVM", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 12 + }, + { + "type": "text", + "bbox": [ + 107, + 409, + 505, + 498 + ], + "lines": [ + { + "bbox": [ + 106, + 410, + 505, + 422 + ], + "spans": [ + { + "bbox": [ + 106, + 410, + 505, + 422 + ], + "score": 1.0, + "content": "Inspired by the LLVM IR (Lattner & Adve, 2004) and the Swift Intermediate Language (Groff &", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 104, + 420, + 506, + 435 + ], + "spans": [ + { + "bbox": [ + 104, + 420, + 506, + 435 + ], + "score": 1.0, + "content": "Lattner, 2015), DLVM IR is a graph-based, modular code representation, with both an in-memory", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 106, + 433, + 506, + 444 + ], + "spans": [ + { + "bbox": [ + 106, + 433, + 506, + 444 + ], + "score": 1.0, + "content": "format and a textual format. The code representation has a hierarchy of abstractions: module,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 442, + 506, + 456 + ], + "spans": [ + { + "bbox": [ + 105, + 442, + 506, + 456 + ], + "score": 1.0, + "content": "function, basic block, and instruction. An instruction is the minimal unit of code that operates", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 453, + 506, + 467 + ], + "spans": [ + { + "bbox": [ + 105, + 453, + 506, + 467 + ], + "score": 1.0, + "content": "on values, which can be globals, function arguments or temporary virtual registers produced by", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 465, + 506, + 477 + ], + "spans": [ + { + "bbox": [ + 105, + 465, + 506, + 477 + ], + "score": 1.0, + "content": "instructions. Each module contains a collection of type definitions, global values and functions. Each", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 476, + 506, + 487 + ], + "spans": [ + { + "bbox": [ + 105, + 476, + 506, + 487 + ], + "score": 1.0, + "content": "function has a control flow graph formed by basic blocks and control flow edges. Each basic block", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 106, + 487, + 490, + 499 + ], + "spans": [ + { + "bbox": [ + 106, + 487, + 490, + 499 + ], + "score": 1.0, + "content": "contains an ordered list of instructions with data dependencies forming a directed acyclic graph.", + "type": "text" + } + ], + "index": 20 + } + ], + "index": 16.5, + "bbox_fs": [ + 104, + 410, + 506, + 499 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 504, + 505, + 581 + ], + "lines": [ + { + "bbox": [ + 106, + 504, + 505, + 516 + ], + "spans": [ + { + "bbox": [ + 106, + 504, + 505, + 516 + ], + "score": 1.0, + "content": "The DLVM IR has a high-level type system with tensor as a first-class type. The DLVM virtual", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 515, + 506, + 528 + ], + "spans": [ + { + "bbox": [ + 106, + 515, + 506, + 528 + ], + "score": 1.0, + "content": "instruction set includes domain-specific primitive math operators, as well as general-purpose instruc-", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 526, + 505, + 538 + ], + "spans": [ + { + "bbox": [ + 106, + 526, + 505, + 538 + ], + "score": 1.0, + "content": "tions for memory management, control flow and function application. Domain-specific instructions", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 536, + 506, + 549 + ], + "spans": [ + { + "bbox": [ + 105, + 536, + 506, + 549 + ], + "score": 1.0, + "content": "include element-wise unary operators, such as tanh and negate, element-wise binary operators,", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 106, + 549, + 505, + 559 + ], + "spans": [ + { + "bbox": [ + 106, + 549, + 505, + 559 + ], + "score": 1.0, + "content": "such as add and power, and complex operators such as dot, transpose, and convolve. All", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 558, + 505, + 570 + ], + "spans": [ + { + "bbox": [ + 106, + 558, + 505, + 570 + ], + "score": 1.0, + "content": "element-wise binary operators support broadcasting. A sample of DLVM IR code is shown in Figure 3", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 569, + 177, + 583 + ], + "spans": [ + { + "bbox": [ + 105, + 569, + 177, + 583 + ], + "score": 1.0, + "content": "on the next page.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 24, + "bbox_fs": [ + 105, + 504, + 506, + 583 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 586, + 505, + 631 + ], + "lines": [ + { + "bbox": [ + 105, + 586, + 507, + 599 + ], + "spans": [ + { + "bbox": [ + 105, + 586, + 507, + 599 + ], + "score": 1.0, + "content": "The DLVM instruction set does not include composite math functions such as softmax, sigmoid,", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 597, + 505, + 609 + ], + "spans": [ + { + "bbox": [ + 106, + 597, + 505, + 609 + ], + "score": 1.0, + "content": "min or max. All of these functions can be composed of primitive math instructions and control flow", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 106, + 609, + 505, + 621 + ], + "spans": [ + { + "bbox": [ + 106, + 609, + 505, + 621 + ], + "score": 1.0, + "content": "constructs. This design allows for the standard AD algorithm to be applied to any differentiable", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 619, + 362, + 632 + ], + "spans": [ + { + "bbox": [ + 105, + 619, + 362, + 632 + ], + "score": 1.0, + "content": "program, with no need for special handling of composite cases.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 29.5, + "bbox_fs": [ + 105, + 586, + 507, + 632 + ] + }, + { + "type": "title", + "bbox": [ + 106, + 645, + 353, + 657 + ], + "lines": [ + { + "bbox": [ + 106, + 645, + 354, + 658 + ], + "spans": [ + { + "bbox": [ + 106, + 645, + 354, + 658 + ], + "score": 1.0, + "content": "3.1.2 DOMAIN-SPECIFIC COMPILER PASSES FOR DLVM", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 107, + 666, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 665, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 506, + 678 + ], + "score": 1.0, + "content": "DLVM has a full-fledged pass infrastructure, performing various analyses and two kinds of trans-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 106, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "formations: differentiation and optimization. Differentiation constructs function definitions from", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 506, + 700 + ], + "score": 1.0, + "content": "gradient declarations using adjoint code generation (see Section 3.1.3 below). Optimization is then", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "score": 1.0, + "content": "performed on the resulting IR, maximizing the code performance. Optimizations include domain-", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "specific optimizations, such as algebra simplification, linear algebra fusion, matrix multiplication", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 721, + 405, + 733 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 405, + 733 + ], + "score": 1.0, + "content": "reordering, and AD checkpointing, and traditional compiler optimizations.", + "type": "text" + } + ], + "index": 38 + } + ], + "index": 35.5, + "bbox_fs": [ + 105, + 665, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 108, + 81, + 501, + 327 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 81, + 501, + 327 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 81, + 501, + 327 + ], + "spans": [ + { + "bbox": [ + 108, + 81, + 501, + 327 + ], + "score": 0.952, + "type": "image", + "image_path": "d717d7aa13932d973e32e917d093ebca23c6520956de73c54d87b779344714ea.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 108, + 81, + 501, + 163.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 108, + 163.0, + 501, + 245.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 108, + 245.0, + 501, + 327.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 344, + 505, + 378 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 343, + 506, + 357 + ], + "spans": [ + { + "bbox": [ + 106, + 343, + 506, + 357 + ], + "score": 1.0, + "content": "Figure 3: Example code in DLVM intermediate representation. Note that some functions are annotated", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 355, + 505, + 367 + ], + "spans": [ + { + "bbox": [ + 106, + 355, + 505, + 367 + ], + "score": 1.0, + "content": "as defining the gradient of another function with respect some or all arguments. The body of", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 366, + 334, + 378 + ], + "spans": [ + { + "bbox": [ + 106, + 366, + 334, + 378 + ], + "score": 1.0, + "content": "these gradient functions will be automatically generated.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 107, + 402, + 505, + 468 + ], + "lines": [ + { + "bbox": [ + 106, + 402, + 506, + 415 + ], + "spans": [ + { + "bbox": [ + 106, + 402, + 506, + 415 + ], + "score": 1.0, + "content": "Since DLVM IR is aware of mathematical operators such as tanh and power, the algebra simplifi-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 414, + 506, + 425 + ], + "spans": [ + { + "bbox": [ + 106, + 414, + 506, + 425 + ], + "score": 1.0, + "content": "cation pass can find and simplify certain mathematical operations that are expensive or redundant.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 423, + 504, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 164, + 437 + ], + "score": 1.0, + "content": "For example,", + "type": "text" + }, + { + "bbox": [ + 164, + 424, + 176, + 434 + ], + "score": 0.84, + "content": "x ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 176, + 423, + 263, + 437 + ], + "score": 1.0, + "content": "can be simplified to", + "type": "text" + }, + { + "bbox": [ + 263, + 425, + 290, + 435 + ], + "score": 0.76, + "content": "x \\odot x", + "type": "inline_equation" + }, + { + "bbox": [ + 290, + 423, + 295, + 437 + ], + "score": 0.0, + "content": "", + "type": "text" + }, + { + "bbox": [ + 296, + 425, + 304, + 435 + ], + "score": 0.75, + "content": "\\odot", + "type": "inline_equation" + }, + { + "bbox": [ + 305, + 423, + 492, + 437 + ], + "score": 1.0, + "content": "stands for element-wise multiplication), and", + "type": "text" + }, + { + "bbox": [ + 492, + 424, + 504, + 434 + ], + "score": 0.85, + "content": "x ^ { 0 }", + "type": "inline_equation" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 435, + 505, + 448 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 505, + 448 + ], + "score": 1.0, + "content": "can be simplified to constant 1. Matrix multiplication reordering is another classic optimization", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 447, + 505, + 458 + ], + "spans": [ + { + "bbox": [ + 106, + 447, + 505, + 458 + ], + "score": 1.0, + "content": "that minimizes the number of sub-operations in a chain of matrix multiplications with different", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 457, + 354, + 470 + ], + "spans": [ + { + "bbox": [ + 106, + 457, + 354, + 470 + ], + "score": 1.0, + "content": "dimensionality, based on matrix multiplication’s associativity.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 8.5 + }, + { + "type": "text", + "bbox": [ + 106, + 474, + 505, + 649 + ], + "lines": [ + { + "bbox": [ + 106, + 474, + 506, + 487 + ], + "spans": [ + { + "bbox": [ + 106, + 474, + 506, + 487 + ], + "score": 1.0, + "content": "Since the DLVM optimizer is aware of linear algebra operations with static dimensionality, maxi-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 485, + 506, + 497 + ], + "spans": [ + { + "bbox": [ + 106, + 485, + 506, + 497 + ], + "score": 1.0, + "content": "mizing the performance by fusing verbose linear operations into a single matrix multiplication is", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 496, + 503, + 509 + ], + "spans": [ + { + "bbox": [ + 106, + 496, + 469, + 509 + ], + "score": 1.0, + "content": "beneficial as well. For example, it is very common to encounter expressions of the form", + "type": "text" + }, + { + "bbox": [ + 469, + 496, + 503, + 507 + ], + "score": 0.89, + "content": "\\mathbf { W } \\mathbf { X } + \\mathbf { b }", + "type": "inline_equation" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 506, + 505, + 520 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 505, + 520 + ], + "score": 1.0, + "content": "When unoptimized, the matrix multiplication and the addition will be parallelized separately. Since", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 518, + 505, + 531 + ], + "spans": [ + { + "bbox": [ + 106, + 518, + 505, + 531 + ], + "score": 1.0, + "content": "launching compute kernels separately can be expensive, DLVM performs linear algebra fusion, which", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 529, + 506, + 542 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 506, + 542 + ], + "score": 1.0, + "content": "transforms subexpressions involving both matrix multiplication and element-wise operations into a", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 540, + 505, + 552 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 505, + 552 + ], + "score": 1.0, + "content": "single matrix multiplication instruction on padded tensors. Besides the simple pattern like an addition", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 551, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 505, + 563 + ], + "score": 1.0, + "content": "of matrix multiplication and a vector, we can apply the same approach to a polynomial of multiple", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 561, + 506, + 575 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 506, + 575 + ], + "score": 1.0, + "content": "matrix multiplications, turning the polynomial into a single matrix multiplication. For example, in a", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 573, + 506, + 585 + ], + "spans": [ + { + "bbox": [ + 106, + 573, + 506, + 585 + ], + "score": 1.0, + "content": "simple recurrent neural network (RNN), each cell of the recurrence is a feed forward neural network", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 104, + 583, + 506, + 597 + ], + "spans": [ + { + "bbox": [ + 104, + 583, + 191, + 597 + ], + "score": 1.0, + "content": "that takes two inputs:", + "type": "text" + }, + { + "bbox": [ + 192, + 585, + 203, + 595 + ], + "score": 0.85, + "content": "\\mathbf { x } _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 583, + 372, + 597 + ], + "score": 1.0, + "content": ", the input local to the current timestep, and", + "type": "text" + }, + { + "bbox": [ + 373, + 584, + 384, + 595 + ], + "score": 0.87, + "content": "\\mathbf { h } _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 384, + 583, + 506, + 597 + ], + "score": 1.0, + "content": ", the hidden state carried along", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 594, + 505, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 388, + 608 + ], + "score": 1.0, + "content": "the recurrence. The linear algebra fusion pass can simplify operations in", + "type": "text" + }, + { + "bbox": [ + 388, + 595, + 505, + 606 + ], + "score": 0.92, + "content": "\\mathbf { h } _ { t } = f ( \\mathbf { W } \\mathbf { x } _ { t - 1 } + \\mathbf { U } \\mathbf { h } _ { t - 1 } + \\mathbf { b } )", + "type": "inline_equation" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 605, + 506, + 619 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 506, + 619 + ], + "score": 1.0, + "content": "from two matrix multiplications and two additions into a single matrix multiplication. A more aggres-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 104, + 615, + 505, + 630 + ], + "spans": [ + { + "bbox": [ + 104, + 615, + 505, + 630 + ], + "score": 1.0, + "content": "sive, interprocedural version of linear algebra fusion can optimize parameter passing and memory", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 628, + 505, + 640 + ], + "spans": [ + { + "bbox": [ + 106, + 628, + 505, + 640 + ], + "score": 1.0, + "content": "allocation, so that the entire concatenated matrix can be created and passed around in the first place", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 639, + 191, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 639, + 191, + 650 + ], + "score": 1.0, + "content": "without reallocation.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 19.5 + }, + { + "type": "title", + "bbox": [ + 108, + 666, + 455, + 678 + ], + "lines": [ + { + "bbox": [ + 105, + 666, + 457, + 679 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 457, + 679 + ], + "score": 1.0, + "content": "3.1.3 ALGORITHMIC DIFFERENTIATION THROUGH ADJOINT CODE GENERATION", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 688, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 506, + 700 + ], + "score": 1.0, + "content": "Algorithmic differentiation (AD), also known as automatic differentiation, encompasses a family of", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 445, + 711 + ], + "score": 1.0, + "content": "a well-known techniques for algorithmically obtaining the derivatives of a function", + "type": "text" + }, + { + "bbox": [ + 445, + 699, + 505, + 710 + ], + "score": 0.91, + "content": "f : \\mathbf { x } \\in \\mathbb { R } ^ { n } ", + "type": "inline_equation" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 142, + 721 + ], + "score": 0.89, + "content": "\\mathbf { y } \\in \\mathbb { R } ^ { m }", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 709, + 278, + 722 + ], + "score": 1.0, + "content": "(Naumann, 2011). The function", + "type": "text" + }, + { + "bbox": [ + 278, + 710, + 285, + 721 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "can be represented as a directed acyclic computation", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 721, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 506, + 733 + ], + "score": 1.0, + "content": "graph representing the composition of elementary computational operations for which the respective", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 30.5 + } + ], + "page_idx": 4, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 224, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 225, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 225, + 38 + ], + "score": 1.0, + "content": "Workshop track - ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 763 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 763 + ], + "score": 1.0, + "content": "5", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 108, + 81, + 501, + 327 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 108, + 81, + 501, + 327 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 108, + 81, + 501, + 327 + ], + "spans": [ + { + "bbox": [ + 108, + 81, + 501, + 327 + ], + "score": 0.952, + "type": "image", + "image_path": "d717d7aa13932d973e32e917d093ebca23c6520956de73c54d87b779344714ea.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 108, + 81, + 501, + 163.0 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 108, + 163.0, + 501, + 245.0 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 108, + 245.0, + 501, + 327.0 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 107, + 344, + 505, + 378 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 106, + 343, + 506, + 357 + ], + "spans": [ + { + "bbox": [ + 106, + 343, + 506, + 357 + ], + "score": 1.0, + "content": "Figure 3: Example code in DLVM intermediate representation. Note that some functions are annotated", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 106, + 355, + 505, + 367 + ], + "spans": [ + { + "bbox": [ + 106, + 355, + 505, + 367 + ], + "score": 1.0, + "content": "as defining the gradient of another function with respect some or all arguments. The body of", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 366, + 334, + 378 + ], + "spans": [ + { + "bbox": [ + 106, + 366, + 334, + 378 + ], + "score": 1.0, + "content": "these gradient functions will be automatically generated.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4 + } + ], + "index": 2.5 + }, + { + "type": "text", + "bbox": [ + 107, + 402, + 505, + 468 + ], + "lines": [ + { + "bbox": [ + 106, + 402, + 506, + 415 + ], + "spans": [ + { + "bbox": [ + 106, + 402, + 506, + 415 + ], + "score": 1.0, + "content": "Since DLVM IR is aware of mathematical operators such as tanh and power, the algebra simplifi-", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 106, + 414, + 506, + 425 + ], + "spans": [ + { + "bbox": [ + 106, + 414, + 506, + 425 + ], + "score": 1.0, + "content": "cation pass can find and simplify certain mathematical operations that are expensive or redundant.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 423, + 504, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 423, + 164, + 437 + ], + "score": 1.0, + "content": "For example,", + "type": "text" + }, + { + "bbox": [ + 164, + 424, + 176, + 434 + ], + "score": 0.84, + "content": "x ^ { 2 }", + "type": "inline_equation" + }, + { + "bbox": [ + 176, + 423, + 263, + 437 + ], + "score": 1.0, + "content": "can be simplified to", + "type": "text" + }, + { + "bbox": [ + 263, + 425, + 290, + 435 + ], + "score": 0.76, + "content": "x \\odot x", + "type": "inline_equation" + }, + { + "bbox": [ + 290, + 423, + 295, + 437 + ], + "score": 0.0, + "content": "", + "type": "text" + }, + { + "bbox": [ + 296, + 425, + 304, + 435 + ], + "score": 0.75, + "content": "\\odot", + "type": "inline_equation" + }, + { + "bbox": [ + 305, + 423, + 492, + 437 + ], + "score": 1.0, + "content": "stands for element-wise multiplication), and", + "type": "text" + }, + { + "bbox": [ + 492, + 424, + 504, + 434 + ], + "score": 0.85, + "content": "x ^ { 0 }", + "type": "inline_equation" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 435, + 505, + 448 + ], + "spans": [ + { + "bbox": [ + 105, + 435, + 505, + 448 + ], + "score": 1.0, + "content": "can be simplified to constant 1. Matrix multiplication reordering is another classic optimization", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 447, + 505, + 458 + ], + "spans": [ + { + "bbox": [ + 106, + 447, + 505, + 458 + ], + "score": 1.0, + "content": "that minimizes the number of sub-operations in a chain of matrix multiplications with different", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 457, + 354, + 470 + ], + "spans": [ + { + "bbox": [ + 106, + 457, + 354, + 470 + ], + "score": 1.0, + "content": "dimensionality, based on matrix multiplication’s associativity.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 8.5, + "bbox_fs": [ + 105, + 402, + 506, + 470 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 474, + 505, + 649 + ], + "lines": [ + { + "bbox": [ + 106, + 474, + 506, + 487 + ], + "spans": [ + { + "bbox": [ + 106, + 474, + 506, + 487 + ], + "score": 1.0, + "content": "Since the DLVM optimizer is aware of linear algebra operations with static dimensionality, maxi-", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 485, + 506, + 497 + ], + "spans": [ + { + "bbox": [ + 106, + 485, + 506, + 497 + ], + "score": 1.0, + "content": "mizing the performance by fusing verbose linear operations into a single matrix multiplication is", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 106, + 496, + 503, + 509 + ], + "spans": [ + { + "bbox": [ + 106, + 496, + 469, + 509 + ], + "score": 1.0, + "content": "beneficial as well. For example, it is very common to encounter expressions of the form", + "type": "text" + }, + { + "bbox": [ + 469, + 496, + 503, + 507 + ], + "score": 0.89, + "content": "\\mathbf { W } \\mathbf { X } + \\mathbf { b }", + "type": "inline_equation" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 506, + 505, + 520 + ], + "spans": [ + { + "bbox": [ + 105, + 506, + 505, + 520 + ], + "score": 1.0, + "content": "When unoptimized, the matrix multiplication and the addition will be parallelized separately. Since", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 106, + 518, + 505, + 531 + ], + "spans": [ + { + "bbox": [ + 106, + 518, + 505, + 531 + ], + "score": 1.0, + "content": "launching compute kernels separately can be expensive, DLVM performs linear algebra fusion, which", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 529, + 506, + 542 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 506, + 542 + ], + "score": 1.0, + "content": "transforms subexpressions involving both matrix multiplication and element-wise operations into a", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 540, + 505, + 552 + ], + "spans": [ + { + "bbox": [ + 105, + 540, + 505, + 552 + ], + "score": 1.0, + "content": "single matrix multiplication instruction on padded tensors. Besides the simple pattern like an addition", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 551, + 505, + 563 + ], + "spans": [ + { + "bbox": [ + 105, + 551, + 505, + 563 + ], + "score": 1.0, + "content": "of matrix multiplication and a vector, we can apply the same approach to a polynomial of multiple", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 561, + 506, + 575 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 506, + 575 + ], + "score": 1.0, + "content": "matrix multiplications, turning the polynomial into a single matrix multiplication. For example, in a", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 106, + 573, + 506, + 585 + ], + "spans": [ + { + "bbox": [ + 106, + 573, + 506, + 585 + ], + "score": 1.0, + "content": "simple recurrent neural network (RNN), each cell of the recurrence is a feed forward neural network", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 104, + 583, + 506, + 597 + ], + "spans": [ + { + "bbox": [ + 104, + 583, + 191, + 597 + ], + "score": 1.0, + "content": "that takes two inputs:", + "type": "text" + }, + { + "bbox": [ + 192, + 585, + 203, + 595 + ], + "score": 0.85, + "content": "\\mathbf { x } _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 203, + 583, + 372, + 597 + ], + "score": 1.0, + "content": ", the input local to the current timestep, and", + "type": "text" + }, + { + "bbox": [ + 373, + 584, + 384, + 595 + ], + "score": 0.87, + "content": "\\mathbf { h } _ { t }", + "type": "inline_equation" + }, + { + "bbox": [ + 384, + 583, + 506, + 597 + ], + "score": 1.0, + "content": ", the hidden state carried along", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 594, + 505, + 608 + ], + "spans": [ + { + "bbox": [ + 105, + 594, + 388, + 608 + ], + "score": 1.0, + "content": "the recurrence. The linear algebra fusion pass can simplify operations in", + "type": "text" + }, + { + "bbox": [ + 388, + 595, + 505, + 606 + ], + "score": 0.92, + "content": "\\mathbf { h } _ { t } = f ( \\mathbf { W } \\mathbf { x } _ { t - 1 } + \\mathbf { U } \\mathbf { h } _ { t - 1 } + \\mathbf { b } )", + "type": "inline_equation" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 605, + 506, + 619 + ], + "spans": [ + { + "bbox": [ + 105, + 605, + 506, + 619 + ], + "score": 1.0, + "content": "from two matrix multiplications and two additions into a single matrix multiplication. A more aggres-", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 104, + 615, + 505, + 630 + ], + "spans": [ + { + "bbox": [ + 104, + 615, + 505, + 630 + ], + "score": 1.0, + "content": "sive, interprocedural version of linear algebra fusion can optimize parameter passing and memory", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 106, + 628, + 505, + 640 + ], + "spans": [ + { + "bbox": [ + 106, + 628, + 505, + 640 + ], + "score": 1.0, + "content": "allocation, so that the entire concatenated matrix can be created and passed around in the first place", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 639, + 191, + 650 + ], + "spans": [ + { + "bbox": [ + 106, + 639, + 191, + 650 + ], + "score": 1.0, + "content": "without reallocation.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 19.5, + "bbox_fs": [ + 104, + 474, + 506, + 650 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 666, + 455, + 678 + ], + "lines": [ + { + "bbox": [ + 105, + 666, + 457, + 679 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 457, + 679 + ], + "score": 1.0, + "content": "3.1.3 ALGORITHMIC DIFFERENTIATION THROUGH ADJOINT CODE GENERATION", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 28 + }, + { + "type": "text", + "bbox": [ + 107, + 687, + 504, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 688, + 506, + 700 + ], + "spans": [ + { + "bbox": [ + 106, + 688, + 506, + 700 + ], + "score": 1.0, + "content": "Algorithmic differentiation (AD), also known as automatic differentiation, encompasses a family of", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 698, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 445, + 711 + ], + "score": 1.0, + "content": "a well-known techniques for algorithmically obtaining the derivatives of a function", + "type": "text" + }, + { + "bbox": [ + 445, + 699, + 505, + 710 + ], + "score": 0.91, + "content": "f : \\mathbf { x } \\in \\mathbb { R } ^ { n } ", + "type": "inline_equation" + } + ], + "index": 30 + }, + { + "bbox": [ + 106, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 142, + 721 + ], + "score": 0.89, + "content": "\\mathbf { y } \\in \\mathbb { R } ^ { m }", + "type": "inline_equation" + }, + { + "bbox": [ + 142, + 709, + 278, + 722 + ], + "score": 1.0, + "content": "(Naumann, 2011). The function", + "type": "text" + }, + { + "bbox": [ + 278, + 710, + 285, + 721 + ], + "score": 0.85, + "content": "f", + "type": "inline_equation" + }, + { + "bbox": [ + 285, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "can be represented as a directed acyclic computation", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 721, + 506, + 733 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 506, + 733 + ], + "score": 1.0, + "content": "graph representing the composition of elementary computational operations for which the respective", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 105, + 80, + 505, + 98 + ], + "spans": [ + { + "bbox": [ + 105, + 80, + 300, + 98 + ], + "score": 1.0, + "content": "derivatives are well known. The partial derivative", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 301, + 80, + 316, + 96 + ], + "score": 0.92, + "content": "\\frac { \\partial y _ { j } } { \\partial x _ { i } }", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 317, + 80, + 505, + 98 + ], + "score": 1.0, + "content": "can be computed through recursive applications", + "type": "text", + "cross_page": true + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 95, + 505, + 107 + ], + "spans": [ + { + "bbox": [ + 105, + 95, + 505, + 107 + ], + "score": 1.0, + "content": "of the chain rule, either in the forward direction (corresponding to a bottom-up traversal of the", + "type": "text", + "cross_page": true + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 106, + 505, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 106, + 505, + 118 + ], + "score": 1.0, + "content": "computation graph) or in the backward direction (corresponding to a top-down traversal of the", + "type": "text", + "cross_page": true + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 117, + 504, + 129 + ], + "spans": [ + { + "bbox": [ + 105, + 117, + 504, + 129 + ], + "score": 1.0, + "content": "computation graph). The former approach, called forward-mode or tangent-mode AD, is used in", + "type": "text", + "cross_page": true + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 128, + 506, + 140 + ], + "spans": [ + { + "bbox": [ + 105, + 128, + 318, + 140 + ], + "score": 1.0, + "content": "some research communities, most commonly when", + "type": "text", + "cross_page": true + }, + { + "bbox": [ + 319, + 128, + 352, + 138 + ], + "score": 0.88, + "content": "m \\gg n", + "type": "inline_equation", + "cross_page": true + }, + { + "bbox": [ + 352, + 128, + 506, + 140 + ], + "score": 1.0, + "content": "(Goodfellow et al., 2016). The latter", + "type": "text", + "cross_page": true + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 138, + 507, + 151 + ], + "spans": [ + { + "bbox": [ + 105, + 138, + 507, + 151 + ], + "score": 1.0, + "content": "approach, which includes the back-propagation algorithm (Rumelhart et al., 1986) as a special case,", + "type": "text", + "cross_page": true + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 150, + 506, + 162 + ], + "spans": [ + { + "bbox": [ + 105, + 150, + 506, + 162 + ], + "score": 1.0, + "content": "is called reverse-mode or adjoint-mode AD, and encompasses the techniques most commonly used", + "type": "text", + "cross_page": true + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 160, + 281, + 173 + ], + "spans": [ + { + "bbox": [ + 105, + 160, + 281, + 173 + ], + "score": 1.0, + "content": "for training the weights in neural networks.", + "type": "text", + "cross_page": true + } + ], + "index": 7 + } + ], + "index": 30.5, + "bbox_fs": [ + 105, + 688, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 80, + 505, + 172 + ], + "lines": [ + { + "bbox": [ + 105, + 80, + 505, + 98 + ], + "spans": [ + { + "bbox": [ + 105, + 80, + 300, + 98 + ], + "score": 1.0, + "content": "derivatives are well known. The partial derivative", + "type": "text" + }, + { + "bbox": [ + 301, + 80, + 316, + 96 + ], + "score": 0.92, + "content": "\\frac { \\partial y _ { j } } { \\partial x _ { i } }", + "type": "inline_equation" + }, + { + "bbox": [ + 317, + 80, + 505, + 98 + ], + "score": 1.0, + "content": "can be computed through recursive applications", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 105, + 95, + 505, + 107 + ], + "spans": [ + { + "bbox": [ + 105, + 95, + 505, + 107 + ], + "score": 1.0, + "content": "of the chain rule, either in the forward direction (corresponding to a bottom-up traversal of the", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 106, + 505, + 118 + ], + "spans": [ + { + "bbox": [ + 105, + 106, + 505, + 118 + ], + "score": 1.0, + "content": "computation graph) or in the backward direction (corresponding to a top-down traversal of the", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 117, + 504, + 129 + ], + "spans": [ + { + "bbox": [ + 105, + 117, + 504, + 129 + ], + "score": 1.0, + "content": "computation graph). The former approach, called forward-mode or tangent-mode AD, is used in", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 128, + 506, + 140 + ], + "spans": [ + { + "bbox": [ + 105, + 128, + 318, + 140 + ], + "score": 1.0, + "content": "some research communities, most commonly when", + "type": "text" + }, + { + "bbox": [ + 319, + 128, + 352, + 138 + ], + "score": 0.88, + "content": "m \\gg n", + "type": "inline_equation" + }, + { + "bbox": [ + 352, + 128, + 506, + 140 + ], + "score": 1.0, + "content": "(Goodfellow et al., 2016). The latter", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 138, + 507, + 151 + ], + "spans": [ + { + "bbox": [ + 105, + 138, + 507, + 151 + ], + "score": 1.0, + "content": "approach, which includes the back-propagation algorithm (Rumelhart et al., 1986) as a special case,", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 150, + 506, + 162 + ], + "spans": [ + { + "bbox": [ + 105, + 150, + 506, + 162 + ], + "score": 1.0, + "content": "is called reverse-mode or adjoint-mode AD, and encompasses the techniques most commonly used", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 160, + 281, + 173 + ], + "spans": [ + { + "bbox": [ + 105, + 160, + 281, + 173 + ], + "score": 1.0, + "content": "for training the weights in neural networks.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 106, + 177, + 505, + 331 + ], + "lines": [ + { + "bbox": [ + 105, + 177, + 506, + 190 + ], + "spans": [ + { + "bbox": [ + 105, + 177, + 506, + 190 + ], + "score": 1.0, + "content": "In DLVM, the differentiation pass is responsible for performing reverse-mode AD. This pass is", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 188, + 506, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 506, + 200 + ], + "score": 1.0, + "content": "responsible for generating DLVM IR code that calculates the derivative of a differentiable function.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 199, + 506, + 211 + ], + "spans": [ + { + "bbox": [ + 106, + 199, + 506, + 211 + ], + "score": 1.0, + "content": "A function is marked as being automatically differentiable via gradient declarations. A gradient", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 210, + 506, + 222 + ], + "spans": [ + { + "bbox": [ + 106, + 210, + 506, + 222 + ], + "score": 1.0, + "content": "declaration is a function in a module that is declared with its mathematical relation with another", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 221, + 505, + 233 + ], + "spans": [ + { + "bbox": [ + 106, + 221, + 345, + 233 + ], + "score": 1.0, + "content": "function in the module and no function body. The function", + "type": "text" + }, + { + "bbox": [ + 345, + 222, + 400, + 232 + ], + "score": 0.28, + "content": "\\mathsf { \\Omega } \\mathsf { \\Omega } \\mathsf { \\Omega } \\mathsf { \\Omega } \\mathsf { \\Omega } \\mathsf { \\Omega } \\mathsf { f o o \\mathrm { - \\mathsf { \\Omega } \\mathsf { { g r a d } } \\Omega } }", + "type": "inline_equation" + }, + { + "bbox": [ + 400, + 221, + 505, + 233 + ], + "score": 1.0, + "content": "in Figure 3 is an example", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 232, + 506, + 245 + ], + "spans": [ + { + "bbox": [ + 105, + 232, + 506, + 245 + ], + "score": 1.0, + "content": "of such a function. Gradient declarations are configurable, e.g. specifying arguments to differentiate", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 243, + 506, + 256 + ], + "spans": [ + { + "bbox": [ + 105, + 243, + 506, + 256 + ], + "score": 1.0, + "content": "with respect to, keeping original outputs, and toggling seedability to accept back-propagated gradients.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 253, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 505, + 267 + ], + "score": 1.0, + "content": "The differentiation pass, when applied, canonicalizes every gradient declaration in the module to", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 266, + 506, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 266, + 506, + 277 + ], + "score": 1.0, + "content": "a normal function definition with basic blocks and instructions. The canonicalization process first", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 276, + 505, + 288 + ], + "spans": [ + { + "bbox": [ + 105, + 276, + 505, + 288 + ], + "score": 1.0, + "content": "copies basic blocks and instructions from the original function to the new function body, and then", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 286, + 507, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 286, + 507, + 300 + ], + "score": 1.0, + "content": "applies adjoint code generation to the function. Unlike many of the existing deep learning frameworks,", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 297, + 505, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 297, + 505, + 310 + ], + "score": 1.0, + "content": "AD in DLVM is a source code transformation, not interpretation (operator overloading) over the", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 309, + 505, + 322 + ], + "spans": [ + { + "bbox": [ + 105, + 309, + 505, + 322 + ], + "score": 1.0, + "content": "same program. This makes the compiler able to perform optimizations on the gradient computation", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 320, + 312, + 332 + ], + "spans": [ + { + "bbox": [ + 105, + 320, + 312, + 332 + ], + "score": 1.0, + "content": "separately and enables higher order differentiation.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 14.5 + }, + { + "type": "text", + "bbox": [ + 107, + 336, + 505, + 447 + ], + "lines": [ + { + "bbox": [ + 105, + 335, + 506, + 350 + ], + "spans": [ + { + "bbox": [ + 105, + 335, + 236, + 350 + ], + "score": 1.0, + "content": "Given a differentiable function", + "type": "text" + }, + { + "bbox": [ + 236, + 336, + 307, + 349 + ], + "score": 0.92, + "content": "f ( \\mathbf { x } _ { 1 } , \\mathbf { x } _ { 2 } , \\ldots , \\mathbf { x } _ { n } )", + "type": "inline_equation" + }, + { + "bbox": [ + 307, + 335, + 506, + 350 + ], + "score": 1.0, + "content": ", this pass creates a new function that computes", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 347, + 505, + 360 + ], + "spans": [ + { + "bbox": [ + 105, + 347, + 160, + 360 + ], + "score": 1.0, + "content": "the Jacobian", + "type": "text" + }, + { + "bbox": [ + 160, + 348, + 172, + 360 + ], + "score": 0.87, + "content": "\\mathbf { J } _ { f }", + "type": "inline_equation" + }, + { + "bbox": [ + 172, + 347, + 505, + 360 + ], + "score": 1.0, + "content": ". This approach to AD has several advantages with respect to AD performed by", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 359, + 505, + 371 + ], + "spans": [ + { + "bbox": [ + 105, + 359, + 195, + 371 + ], + "score": 1.0, + "content": "operator overloading", + "type": "text" + }, + { + "bbox": [ + 195, + 359, + 201, + 369 + ], + "score": 0.32, + "content": "/", + "type": "inline_equation" + }, + { + "bbox": [ + 201, + 359, + 505, + 371 + ], + "score": 1.0, + "content": "graph interpretation. Unlike operator overloading, the gradient function", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 369, + 506, + 382 + ], + "spans": [ + { + "bbox": [ + 105, + 369, + 506, + 382 + ], + "score": 1.0, + "content": "produced by AD is a standalone function that sits uniformly alongside other functions in an IR", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 381, + 505, + 393 + ], + "spans": [ + { + "bbox": [ + 105, + 381, + 505, + 393 + ], + "score": 1.0, + "content": "module, representationally unrelated to the original function. The generated function takes original", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 392, + 506, + 405 + ], + "spans": [ + { + "bbox": [ + 105, + 392, + 506, + 405 + ], + "score": 1.0, + "content": "inputs and produces a tuple of partial derivatives with respect to the inputs. In AD, not all values in", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 402, + 505, + 415 + ], + "spans": [ + { + "bbox": [ + 105, + 402, + 505, + 415 + ], + "score": 1.0, + "content": "the forward evaluation will necessarily be used to compute derivatives. In DLVM, unused operations", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 412, + 506, + 427 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 506, + 427 + ], + "score": 1.0, + "content": "can be easily eliminated by the aggressive dead code elimination pass in the compilation pipeline (see", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 424, + 506, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 424, + 506, + 437 + ], + "score": 1.0, + "content": "Section 3.1.4). In addition, an AD-specific optimization technique called checkpointing can further", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 436, + 342, + 448 + ], + "spans": [ + { + "bbox": [ + 105, + 436, + 342, + 448 + ], + "score": 1.0, + "content": "reduce memory consumption during gradient computation.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 26.5 + }, + { + "type": "text", + "bbox": [ + 107, + 452, + 505, + 551 + ], + "lines": [ + { + "bbox": [ + 106, + 452, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 106, + 452, + 505, + 464 + ], + "score": 1.0, + "content": "AD in DLVM is configurable. The front-end can choose to differentiate a function with respect to", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 464, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 106, + 464, + 505, + 475 + ], + "score": 1.0, + "content": "selected arguments, to keep some of the outputs of the original function, to apply differentiation", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 475, + 506, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 475, + 506, + 486 + ], + "score": 1.0, + "content": "to a specific output when there are multiple return values, or to enable the function to accept back-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 485, + 506, + 498 + ], + "spans": [ + { + "bbox": [ + 105, + 485, + 506, + 498 + ], + "score": 1.0, + "content": "propagated gradients (seeds) through function composition, all by gradient declarations. If the", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 496, + 505, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 496, + 505, + 509 + ], + "score": 1.0, + "content": "function returns multiple values in a tuple, the gradient declaration can also specify which tuple", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 507, + 505, + 520 + ], + "spans": [ + { + "bbox": [ + 105, + 507, + 505, + 520 + ], + "score": 1.0, + "content": "element to differentiate. Our approach to AD is implemented as a transformation from one function", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 518, + 504, + 530 + ], + "spans": [ + { + "bbox": [ + 105, + 518, + 504, + 530 + ], + "score": 1.0, + "content": "to another function. This approach also makes higher-order differentiation possible; this can be", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 529, + 505, + 542 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 505, + 542 + ], + "score": 1.0, + "content": "accomplished by declaring a higher-order gradient function that differentiates the original gradient", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 541, + 144, + 552 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 144, + 552 + ], + "score": 1.0, + "content": "function.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 36 + }, + { + "type": "title", + "bbox": [ + 106, + 599, + 348, + 610 + ], + "lines": [ + { + "bbox": [ + 106, + 599, + 349, + 612 + ], + "spans": [ + { + "bbox": [ + 106, + 599, + 349, + 612 + ], + "score": 1.0, + "content": "3.1.4 GENERAL-PURPOSE OPTIMIZATIONS FOR DLVM", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 106, + 632, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 633, + 506, + 646 + ], + "spans": [ + { + "bbox": [ + 106, + 633, + 506, + 646 + ], + "score": 1.0, + "content": "General-purpose optimizations refer to traditional compiler optimizations applied to DLVM IR.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 644, + 506, + 657 + ], + "spans": [ + { + "bbox": [ + 106, + 644, + 506, + 657 + ], + "score": 1.0, + "content": "These optimizations are important at the DLVM stage in the compilation pipeline, since linear", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 655, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 106, + 655, + 505, + 667 + ], + "score": 1.0, + "content": "algebra computation can be highly optimized or eliminated before they get lowered to LLVM IR", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 665, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 505, + 678 + ], + "score": 1.0, + "content": "which contain parallel execution and low-level information that prevent LLVM optimizations from", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "score": 1.0, + "content": "identifying high-level patterns. Some of these optimizations are aggressive dead code elimination,", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 688, + 505, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 505, + 701 + ], + "score": 1.0, + "content": "common subexpression elimination, and sparse conditional constant propagation. Applying such", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "optimizations on gradient computation is not feasible in other approaches to AD that use graph", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "interpretation (operator overloading), because the forward pass and the backward pass are tied", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 720, + 485, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 485, + 734 + ], + "score": 1.0, + "content": "together in a single graph; mutating either evaluation pass will alter the semantics of the other.", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 46 + } + ], + "page_idx": 5, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 224, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 225, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 225, + 38 + ], + "score": 1.0, + "content": "Workshop track - ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "score": 1.0, + "content": "6", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 107, + 80, + 505, + 172 + ], + "lines": [], + "index": 3.5, + "bbox_fs": [ + 105, + 80, + 507, + 173 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 106, + 177, + 505, + 331 + ], + "lines": [ + { + "bbox": [ + 105, + 177, + 506, + 190 + ], + "spans": [ + { + "bbox": [ + 105, + 177, + 506, + 190 + ], + "score": 1.0, + "content": "In DLVM, the differentiation pass is responsible for performing reverse-mode AD. This pass is", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 188, + 506, + 200 + ], + "spans": [ + { + "bbox": [ + 105, + 188, + 506, + 200 + ], + "score": 1.0, + "content": "responsible for generating DLVM IR code that calculates the derivative of a differentiable function.", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 199, + 506, + 211 + ], + "spans": [ + { + "bbox": [ + 106, + 199, + 506, + 211 + ], + "score": 1.0, + "content": "A function is marked as being automatically differentiable via gradient declarations. A gradient", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 106, + 210, + 506, + 222 + ], + "spans": [ + { + "bbox": [ + 106, + 210, + 506, + 222 + ], + "score": 1.0, + "content": "declaration is a function in a module that is declared with its mathematical relation with another", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 106, + 221, + 505, + 233 + ], + "spans": [ + { + "bbox": [ + 106, + 221, + 345, + 233 + ], + "score": 1.0, + "content": "function in the module and no function body. The function", + "type": "text" + }, + { + "bbox": [ + 345, + 222, + 400, + 232 + ], + "score": 0.28, + "content": "\\mathsf { \\Omega } \\mathsf { \\Omega } \\mathsf { \\Omega } \\mathsf { \\Omega } \\mathsf { \\Omega } \\mathsf { \\Omega } \\mathsf { f o o \\mathrm { - \\mathsf { \\Omega } \\mathsf { { g r a d } } \\Omega } }", + "type": "inline_equation" + }, + { + "bbox": [ + 400, + 221, + 505, + 233 + ], + "score": 1.0, + "content": "in Figure 3 is an example", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 105, + 232, + 506, + 245 + ], + "spans": [ + { + "bbox": [ + 105, + 232, + 506, + 245 + ], + "score": 1.0, + "content": "of such a function. Gradient declarations are configurable, e.g. specifying arguments to differentiate", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 105, + 243, + 506, + 256 + ], + "spans": [ + { + "bbox": [ + 105, + 243, + 506, + 256 + ], + "score": 1.0, + "content": "with respect to, keeping original outputs, and toggling seedability to accept back-propagated gradients.", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 253, + 505, + 267 + ], + "spans": [ + { + "bbox": [ + 105, + 253, + 505, + 267 + ], + "score": 1.0, + "content": "The differentiation pass, when applied, canonicalizes every gradient declaration in the module to", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 266, + 506, + 277 + ], + "spans": [ + { + "bbox": [ + 105, + 266, + 506, + 277 + ], + "score": 1.0, + "content": "a normal function definition with basic blocks and instructions. The canonicalization process first", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 276, + 505, + 288 + ], + "spans": [ + { + "bbox": [ + 105, + 276, + 505, + 288 + ], + "score": 1.0, + "content": "copies basic blocks and instructions from the original function to the new function body, and then", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 286, + 507, + 300 + ], + "spans": [ + { + "bbox": [ + 105, + 286, + 507, + 300 + ], + "score": 1.0, + "content": "applies adjoint code generation to the function. Unlike many of the existing deep learning frameworks,", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 105, + 297, + 505, + 310 + ], + "spans": [ + { + "bbox": [ + 105, + 297, + 505, + 310 + ], + "score": 1.0, + "content": "AD in DLVM is a source code transformation, not interpretation (operator overloading) over the", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 309, + 505, + 322 + ], + "spans": [ + { + "bbox": [ + 105, + 309, + 505, + 322 + ], + "score": 1.0, + "content": "same program. This makes the compiler able to perform optimizations on the gradient computation", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 320, + 312, + 332 + ], + "spans": [ + { + "bbox": [ + 105, + 320, + 312, + 332 + ], + "score": 1.0, + "content": "separately and enables higher order differentiation.", + "type": "text" + } + ], + "index": 21 + } + ], + "index": 14.5, + "bbox_fs": [ + 105, + 177, + 507, + 332 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 336, + 505, + 447 + ], + "lines": [ + { + "bbox": [ + 105, + 335, + 506, + 350 + ], + "spans": [ + { + "bbox": [ + 105, + 335, + 236, + 350 + ], + "score": 1.0, + "content": "Given a differentiable function", + "type": "text" + }, + { + "bbox": [ + 236, + 336, + 307, + 349 + ], + "score": 0.92, + "content": "f ( \\mathbf { x } _ { 1 } , \\mathbf { x } _ { 2 } , \\ldots , \\mathbf { x } _ { n } )", + "type": "inline_equation" + }, + { + "bbox": [ + 307, + 335, + 506, + 350 + ], + "score": 1.0, + "content": ", this pass creates a new function that computes", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 347, + 505, + 360 + ], + "spans": [ + { + "bbox": [ + 105, + 347, + 160, + 360 + ], + "score": 1.0, + "content": "the Jacobian", + "type": "text" + }, + { + "bbox": [ + 160, + 348, + 172, + 360 + ], + "score": 0.87, + "content": "\\mathbf { J } _ { f }", + "type": "inline_equation" + }, + { + "bbox": [ + 172, + 347, + 505, + 360 + ], + "score": 1.0, + "content": ". This approach to AD has several advantages with respect to AD performed by", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 359, + 505, + 371 + ], + "spans": [ + { + "bbox": [ + 105, + 359, + 195, + 371 + ], + "score": 1.0, + "content": "operator overloading", + "type": "text" + }, + { + "bbox": [ + 195, + 359, + 201, + 369 + ], + "score": 0.32, + "content": "/", + "type": "inline_equation" + }, + { + "bbox": [ + 201, + 359, + 505, + 371 + ], + "score": 1.0, + "content": "graph interpretation. Unlike operator overloading, the gradient function", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 369, + 506, + 382 + ], + "spans": [ + { + "bbox": [ + 105, + 369, + 506, + 382 + ], + "score": 1.0, + "content": "produced by AD is a standalone function that sits uniformly alongside other functions in an IR", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 381, + 505, + 393 + ], + "spans": [ + { + "bbox": [ + 105, + 381, + 505, + 393 + ], + "score": 1.0, + "content": "module, representationally unrelated to the original function. The generated function takes original", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 105, + 392, + 506, + 405 + ], + "spans": [ + { + "bbox": [ + 105, + 392, + 506, + 405 + ], + "score": 1.0, + "content": "inputs and produces a tuple of partial derivatives with respect to the inputs. In AD, not all values in", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 105, + 402, + 505, + 415 + ], + "spans": [ + { + "bbox": [ + 105, + 402, + 505, + 415 + ], + "score": 1.0, + "content": "the forward evaluation will necessarily be used to compute derivatives. In DLVM, unused operations", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 412, + 506, + 427 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 506, + 427 + ], + "score": 1.0, + "content": "can be easily eliminated by the aggressive dead code elimination pass in the compilation pipeline (see", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 424, + 506, + 437 + ], + "spans": [ + { + "bbox": [ + 105, + 424, + 506, + 437 + ], + "score": 1.0, + "content": "Section 3.1.4). In addition, an AD-specific optimization technique called checkpointing can further", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 105, + 436, + 342, + 448 + ], + "spans": [ + { + "bbox": [ + 105, + 436, + 342, + 448 + ], + "score": 1.0, + "content": "reduce memory consumption during gradient computation.", + "type": "text" + } + ], + "index": 31 + } + ], + "index": 26.5, + "bbox_fs": [ + 105, + 335, + 506, + 448 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 452, + 505, + 551 + ], + "lines": [ + { + "bbox": [ + 106, + 452, + 505, + 464 + ], + "spans": [ + { + "bbox": [ + 106, + 452, + 505, + 464 + ], + "score": 1.0, + "content": "AD in DLVM is configurable. The front-end can choose to differentiate a function with respect to", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 106, + 464, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 106, + 464, + 505, + 475 + ], + "score": 1.0, + "content": "selected arguments, to keep some of the outputs of the original function, to apply differentiation", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 475, + 506, + 486 + ], + "spans": [ + { + "bbox": [ + 105, + 475, + 506, + 486 + ], + "score": 1.0, + "content": "to a specific output when there are multiple return values, or to enable the function to accept back-", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 105, + 485, + 506, + 498 + ], + "spans": [ + { + "bbox": [ + 105, + 485, + 506, + 498 + ], + "score": 1.0, + "content": "propagated gradients (seeds) through function composition, all by gradient declarations. If the", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 105, + 496, + 505, + 509 + ], + "spans": [ + { + "bbox": [ + 105, + 496, + 505, + 509 + ], + "score": 1.0, + "content": "function returns multiple values in a tuple, the gradient declaration can also specify which tuple", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 507, + 505, + 520 + ], + "spans": [ + { + "bbox": [ + 105, + 507, + 505, + 520 + ], + "score": 1.0, + "content": "element to differentiate. Our approach to AD is implemented as a transformation from one function", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 105, + 518, + 504, + 530 + ], + "spans": [ + { + "bbox": [ + 105, + 518, + 504, + 530 + ], + "score": 1.0, + "content": "to another function. This approach also makes higher-order differentiation possible; this can be", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 529, + 505, + 542 + ], + "spans": [ + { + "bbox": [ + 105, + 529, + 505, + 542 + ], + "score": 1.0, + "content": "accomplished by declaring a higher-order gradient function that differentiates the original gradient", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 541, + 144, + 552 + ], + "spans": [ + { + "bbox": [ + 105, + 541, + 144, + 552 + ], + "score": 1.0, + "content": "function.", + "type": "text" + } + ], + "index": 40 + } + ], + "index": 36, + "bbox_fs": [ + 105, + 452, + 506, + 552 + ] + }, + { + "type": "title", + "bbox": [ + 106, + 599, + 348, + 610 + ], + "lines": [ + { + "bbox": [ + 106, + 599, + 349, + 612 + ], + "spans": [ + { + "bbox": [ + 106, + 599, + 349, + 612 + ], + "score": 1.0, + "content": "3.1.4 GENERAL-PURPOSE OPTIMIZATIONS FOR DLVM", + "type": "text" + } + ], + "index": 41 + } + ], + "index": 41 + }, + { + "type": "text", + "bbox": [ + 106, + 632, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 106, + 633, + 506, + 646 + ], + "spans": [ + { + "bbox": [ + 106, + 633, + 506, + 646 + ], + "score": 1.0, + "content": "General-purpose optimizations refer to traditional compiler optimizations applied to DLVM IR.", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 106, + 644, + 506, + 657 + ], + "spans": [ + { + "bbox": [ + 106, + 644, + 506, + 657 + ], + "score": 1.0, + "content": "These optimizations are important at the DLVM stage in the compilation pipeline, since linear", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 655, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 106, + 655, + 505, + 667 + ], + "score": 1.0, + "content": "algebra computation can be highly optimized or eliminated before they get lowered to LLVM IR", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 665, + 505, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 505, + 678 + ], + "score": 1.0, + "content": "which contain parallel execution and low-level information that prevent LLVM optimizations from", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 506, + 690 + ], + "score": 1.0, + "content": "identifying high-level patterns. Some of these optimizations are aggressive dead code elimination,", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 688, + 505, + 701 + ], + "spans": [ + { + "bbox": [ + 105, + 688, + 505, + 701 + ], + "score": 1.0, + "content": "common subexpression elimination, and sparse conditional constant propagation. Applying such", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 505, + 711 + ], + "score": 1.0, + "content": "optimizations on gradient computation is not feasible in other approaches to AD that use graph", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 722 + ], + "score": 1.0, + "content": "interpretation (operator overloading), because the forward pass and the backward pass are tied", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 720, + 485, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 720, + 485, + 734 + ], + "score": 1.0, + "content": "together in a single graph; mutating either evaluation pass will alter the semantics of the other.", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 46, + "bbox_fs": [ + 105, + 633, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 82, + 214, + 93 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 216, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 216, + 95 + ], + "score": 1.0, + "content": "3.2 CODE GENERATION", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 102, + 505, + 191 + ], + "lines": [ + { + "bbox": [ + 105, + 102, + 505, + 116 + ], + "spans": [ + { + "bbox": [ + 105, + 102, + 505, + 116 + ], + "score": 1.0, + "content": "Two major design goals of DLVM are the ability to target multiple heterogenous parallel architectures", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 114, + 504, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 114, + 504, + 127 + ], + "score": 1.0, + "content": "from the same front-end DSL code (and corresponding DLVM IR), and the ability to perform", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 126, + 505, + 137 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 505, + 137 + ], + "score": 1.0, + "content": "aggressive optimizations on lowered programs. In order to attain these goals, DLVM code generation", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 136, + 504, + 148 + ], + "spans": [ + { + "bbox": [ + 105, + 136, + 504, + 148 + ], + "score": 1.0, + "content": "transforms DLVM IR into LLVM IR. LLVM is a robust and mature compiler infrastructure with", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 147, + 505, + 159 + ], + "spans": [ + { + "bbox": [ + 106, + 147, + 505, + 159 + ], + "score": 1.0, + "content": "multiple back-ends, including NVIDIA GPUs. Many high-level DLVM IR linear algebra instructions", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 158, + 506, + 170 + ], + "spans": [ + { + "bbox": [ + 105, + 158, + 506, + 170 + ], + "score": 1.0, + "content": "over tensors abstract lower-level operations. The DLVM compiler transforms the high-level DLVM", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 169, + 507, + 181 + ], + "spans": [ + { + "bbox": [ + 105, + 169, + 507, + 181 + ], + "score": 1.0, + "content": "IR into lower-level stages and ultimately into calls to BLAS and compute kernels in LLVM IR.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 179, + 457, + 192 + ], + "spans": [ + { + "bbox": [ + 106, + 179, + 457, + 192 + ], + "score": 1.0, + "content": "Existing LLVM utilities are used to compile the generated LLVM IR to the final binary.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 4.5 + }, + { + "type": "text", + "bbox": [ + 107, + 196, + 505, + 241 + ], + "lines": [ + { + "bbox": [ + 105, + 196, + 505, + 209 + ], + "spans": [ + { + "bbox": [ + 105, + 196, + 505, + 209 + ], + "score": 1.0, + "content": "In order to take full advantage of a variety of emerging heterogeneous parallel architectures, we", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 208, + 506, + 219 + ], + "spans": [ + { + "bbox": [ + 106, + 208, + 506, + 219 + ], + "score": 1.0, + "content": "plan for future versions of DLVM to target the IR of HPVM (Srivastava et al., 2016), a higher-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 218, + 505, + 231 + ], + "spans": [ + { + "bbox": [ + 105, + 218, + 505, + 231 + ], + "score": 1.0, + "content": "level heterogeneous compiler extension to LLVM IR that allows for transparent targeting of diverse", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 230, + 255, + 243 + ], + "spans": [ + { + "bbox": [ + 105, + 230, + 255, + 243 + ], + "score": 1.0, + "content": "architectures from a data flow graph.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10.5 + }, + { + "type": "title", + "bbox": [ + 109, + 254, + 286, + 264 + ], + "lines": [ + { + "bbox": [ + 106, + 253, + 288, + 266 + ], + "spans": [ + { + "bbox": [ + 106, + 253, + 288, + 266 + ], + "score": 1.0, + "content": "3.3 DLVM COMMAND LINE TOOLCHAIN", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 107, + 274, + 505, + 340 + ], + "lines": [ + { + "bbox": [ + 105, + 272, + 506, + 288 + ], + "spans": [ + { + "bbox": [ + 105, + 272, + 506, + 288 + ], + "score": 1.0, + "content": "The front-end software associated with each DSL (see Section 3.4) is responsible for generating a", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 285, + 506, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 285, + 506, + 299 + ], + "score": 1.0, + "content": "DLVM IR for a given source language program to be compiled. The DLVM compiler infrastructure", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 296, + 505, + 309 + ], + "spans": [ + { + "bbox": [ + 105, + 296, + 505, + 309 + ], + "score": 1.0, + "content": "itself is a compiler from DLVM IR to LLVM IR, therefore having a command line toolchain is", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 307, + 506, + 319 + ], + "spans": [ + { + "bbox": [ + 105, + 307, + 417, + 319 + ], + "score": 1.0, + "content": "necessary for verifying, transforming and compiling batches of DLVM IR files", + "type": "text" + }, + { + "bbox": [ + 418, + 308, + 448, + 318 + ], + "score": 0.34, + "content": "( \\star _ { } . \\mathrm { d l } )", + "type": "inline_equation" + }, + { + "bbox": [ + 449, + 307, + 506, + 319 + ], + "score": 1.0, + "content": ". Unlike XLA", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 317, + 506, + 331 + ], + "spans": [ + { + "bbox": [ + 105, + 317, + 307, + 331 + ], + "score": 1.0, + "content": "and NNVM/TVM, which only provide a Python", + "type": "text" + }, + { + "bbox": [ + 308, + 319, + 329, + 329 + ], + "score": 0.8, + "content": "/ \\mathrm { C } { + + }", + "type": "inline_equation" + }, + { + "bbox": [ + 329, + 317, + 506, + 331 + ], + "score": 1.0, + "content": "interface to their users, DLVM provides a", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 330, + 348, + 341 + ], + "spans": [ + { + "bbox": [ + 106, + 330, + 348, + 341 + ], + "score": 1.0, + "content": "command line interface like any industry-standard compiler.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 16.5 + }, + { + "type": "text", + "bbox": [ + 107, + 346, + 505, + 423 + ], + "lines": [ + { + "bbox": [ + 105, + 345, + 505, + 359 + ], + "spans": [ + { + "bbox": [ + 105, + 345, + 290, + 359 + ], + "score": 1.0, + "content": "The DLVM optimizer utility, dlopt, accepts", + "type": "text" + }, + { + "bbox": [ + 290, + 348, + 297, + 356 + ], + "score": 0.76, + "content": "\\star", + "type": "inline_equation" + }, + { + "bbox": [ + 298, + 345, + 505, + 359 + ], + "score": 1.0, + "content": ".dl IR files and applies user-specified optimization", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 357, + 505, + 369 + ], + "spans": [ + { + "bbox": [ + 105, + 357, + 337, + 369 + ], + "score": 1.0, + "content": "passes on them. The DLVM compiler driver, dlc, accepts", + "type": "text" + }, + { + "bbox": [ + 338, + 359, + 344, + 367 + ], + "score": 0.71, + "content": "\\star", + "type": "inline_equation" + }, + { + "bbox": [ + 345, + 357, + 505, + 369 + ], + "score": 1.0, + "content": ".dl IR files and performs user-specified", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 368, + 506, + 381 + ], + "spans": [ + { + "bbox": [ + 105, + 368, + 506, + 381 + ], + "score": 1.0, + "content": "tasks, such as verification, differentiation, optimization passes, stage lowering passes, and code", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 378, + 507, + 393 + ], + "spans": [ + { + "bbox": [ + 105, + 378, + 507, + 393 + ], + "score": 1.0, + "content": "generation; the driver invokes the DLVM core library to achieve these tasks. Because of having a", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 390, + 506, + 402 + ], + "spans": [ + { + "bbox": [ + 105, + 390, + 506, + 402 + ], + "score": 1.0, + "content": "textual format of the IR, the DLVM framework can easily make use of the LLVM Integrated Tester", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 401, + 506, + 413 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 506, + 413 + ], + "score": 1.0, + "content": "(lit) and FileCheck to perform robust unit testing. In future development, we plan to introduce a", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 412, + 474, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 474, + 425 + ], + "score": 1.0, + "content": "DLVM bitcode format for compact storage and high-throughput processing of DLVM code.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 23 + }, + { + "type": "title", + "bbox": [ + 108, + 435, + 241, + 447 + ], + "lines": [ + { + "bbox": [ + 106, + 435, + 243, + 448 + ], + "spans": [ + { + "bbox": [ + 106, + 435, + 243, + 448 + ], + "score": 1.0, + "content": "3.4 NEURAL NETWORK DSLS", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 107, + 456, + 505, + 512 + ], + "lines": [ + { + "bbox": [ + 105, + 456, + 505, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 505, + 470 + ], + "score": 1.0, + "content": "Most of existing deep learning DSLs are embedded in a dynamically typed scripting language", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 467, + 506, + 480 + ], + "spans": [ + { + "bbox": [ + 105, + 467, + 506, + 480 + ], + "score": 1.0, + "content": "such as Python and Lua. While these scripting languages provide flexibility and a large number of", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 477, + 505, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 505, + 492 + ], + "score": 1.0, + "content": "libraries for scientific computing, they can act as a barrier between lightweight prototyping code", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 104, + 487, + 507, + 504 + ], + "spans": [ + { + "bbox": [ + 104, + 487, + 507, + 504 + ], + "score": 1.0, + "content": "and systematic production code. This barrier significantly reduces the reliability of ML software,", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 500, + 495, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 495, + 514 + ], + "score": 1.0, + "content": "resulting in suboptimal programming experience and unnecessarily effortful development cycles.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 30 + }, + { + "type": "text", + "bbox": [ + 107, + 517, + 505, + 627 + ], + "lines": [ + { + "bbox": [ + 105, + 517, + 506, + 530 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 506, + 530 + ], + "score": 1.0, + "content": "In software engineering, a proven approach to tackle this problem is language and compiler technolo-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 528, + 506, + 541 + ], + "spans": [ + { + "bbox": [ + 105, + 528, + 506, + 541 + ], + "score": 1.0, + "content": "gies, starting from a language that is amenable to static analysis. A well-designed deep learning DSL", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 539, + 505, + 552 + ], + "spans": [ + { + "bbox": [ + 106, + 539, + 505, + 552 + ], + "score": 1.0, + "content": "should support the needs of deep learning software developers by providing a safe environment for", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 550, + 506, + 563 + ], + "spans": [ + { + "bbox": [ + 106, + 550, + 506, + 563 + ], + "score": 1.0, + "content": "rapid prototyping, while simultaneously generating highly efficient code for training and inference.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 561, + 506, + 575 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 506, + 575 + ], + "score": 1.0, + "content": "DSLs in a scripting language can easily achieve rapid prototyping, but they are generally incapable", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 572, + 506, + 585 + ], + "spans": [ + { + "bbox": [ + 106, + 572, + 506, + 585 + ], + "score": 1.0, + "content": "of providing a safe environment with optimal performance. We believe that the best solution is", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 582, + 506, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 506, + 596 + ], + "score": 1.0, + "content": "DSLs embedded in a type-safe, type-inferring programming language that is both fast and easy to", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 593, + 506, + 607 + ], + "spans": [ + { + "bbox": [ + 105, + 593, + 506, + 607 + ], + "score": 1.0, + "content": "learn. In our initial release of DLVM, we provide one such DSL, both as a proof-of-concept and as a", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 104, + 603, + 506, + 619 + ], + "spans": [ + { + "bbox": [ + 104, + 603, + 506, + 619 + ], + "score": 1.0, + "content": "reference implementation that showcases the capabilities of DLVM as a platform for deep learning", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 616, + 184, + 629 + ], + "spans": [ + { + "bbox": [ + 105, + 616, + 184, + 629 + ], + "score": 1.0, + "content": "DSL development.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 37.5 + }, + { + "type": "text", + "bbox": [ + 107, + 632, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 633, + 505, + 646 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 505, + 646 + ], + "score": 1.0, + "content": "NNKit is a staged DSL embedded in Swift, featuring natural expression of tensor computation", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 643, + 506, + 657 + ], + "spans": [ + { + "bbox": [ + 106, + 643, + 506, + 657 + ], + "score": 1.0, + "content": "alongside the host program without losing static analyses and optimizations on the tensor program.", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 654, + 505, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 654, + 505, + 669 + ], + "score": 1.0, + "content": "Inspired by Lightweight Modular Staging (Rompf & Odersky, 2010), NNKit leverages the static type", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 665, + 506, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 428, + 680 + ], + "score": 1.0, + "content": "system of Swift to guarantee type safety of the DSL. Tensor types are wrapped in", + "type": "text" + }, + { + "bbox": [ + 428, + 667, + 465, + 677 + ], + "score": 0.83, + "content": "\\mathrm { R e p } { < } \\mathrm { T } >", + "type": "inline_equation" + }, + { + "bbox": [ + 465, + 665, + 506, + 680 + ], + "score": 1.0, + "content": ", meaning", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 676, + 506, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 506, + 691 + ], + "score": 1.0, + "content": "the representation of some computation that produces data of type T. Tensor operators overloaded for", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "Rep are essentially AST builders for delayed evaluation. Instead of generating computation nodes at", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "score": 1.0, + "content": "runtime and performing operator-overloading AD like PyTorch or TensorFlow Eager (Google Brain", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "score": 1.0, + "content": "Team, 2017), NNKit tensor computations are staged once during the lifetime of the host program. At", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 721, + 505, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 505, + 734 + ], + "score": 1.0, + "content": "invocation time of staged functions, NNKit emits shape-specialized DLVM IR and leverages DLVM", + "type": "text" + } + ], + "index": 51 + } + ], + "index": 47 + } + ], + "page_idx": 6, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 224, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 225, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 225, + 38 + ], + "score": 1.0, + "content": "Workshop track - ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 303, + 751, + 308, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 750, + 309, + 763 + ], + "spans": [ + { + "bbox": [ + 302, + 750, + 309, + 763 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 13, + "width": 7 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 82, + 214, + 93 + ], + "lines": [ + { + "bbox": [ + 105, + 82, + 216, + 95 + ], + "spans": [ + { + "bbox": [ + 105, + 82, + 216, + 95 + ], + "score": 1.0, + "content": "3.2 CODE GENERATION", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 107, + 102, + 505, + 191 + ], + "lines": [ + { + "bbox": [ + 105, + 102, + 505, + 116 + ], + "spans": [ + { + "bbox": [ + 105, + 102, + 505, + 116 + ], + "score": 1.0, + "content": "Two major design goals of DLVM are the ability to target multiple heterogenous parallel architectures", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 105, + 114, + 504, + 127 + ], + "spans": [ + { + "bbox": [ + 105, + 114, + 504, + 127 + ], + "score": 1.0, + "content": "from the same front-end DSL code (and corresponding DLVM IR), and the ability to perform", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 105, + 126, + 505, + 137 + ], + "spans": [ + { + "bbox": [ + 105, + 126, + 505, + 137 + ], + "score": 1.0, + "content": "aggressive optimizations on lowered programs. In order to attain these goals, DLVM code generation", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 105, + 136, + 504, + 148 + ], + "spans": [ + { + "bbox": [ + 105, + 136, + 504, + 148 + ], + "score": 1.0, + "content": "transforms DLVM IR into LLVM IR. LLVM is a robust and mature compiler infrastructure with", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 106, + 147, + 505, + 159 + ], + "spans": [ + { + "bbox": [ + 106, + 147, + 505, + 159 + ], + "score": 1.0, + "content": "multiple back-ends, including NVIDIA GPUs. Many high-level DLVM IR linear algebra instructions", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 105, + 158, + 506, + 170 + ], + "spans": [ + { + "bbox": [ + 105, + 158, + 506, + 170 + ], + "score": 1.0, + "content": "over tensors abstract lower-level operations. The DLVM compiler transforms the high-level DLVM", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 169, + 507, + 181 + ], + "spans": [ + { + "bbox": [ + 105, + 169, + 507, + 181 + ], + "score": 1.0, + "content": "IR into lower-level stages and ultimately into calls to BLAS and compute kernels in LLVM IR.", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 106, + 179, + 457, + 192 + ], + "spans": [ + { + "bbox": [ + 106, + 179, + 457, + 192 + ], + "score": 1.0, + "content": "Existing LLVM utilities are used to compile the generated LLVM IR to the final binary.", + "type": "text" + } + ], + "index": 8 + } + ], + "index": 4.5, + "bbox_fs": [ + 105, + 102, + 507, + 192 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 196, + 505, + 241 + ], + "lines": [ + { + "bbox": [ + 105, + 196, + 505, + 209 + ], + "spans": [ + { + "bbox": [ + 105, + 196, + 505, + 209 + ], + "score": 1.0, + "content": "In order to take full advantage of a variety of emerging heterogeneous parallel architectures, we", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 106, + 208, + 506, + 219 + ], + "spans": [ + { + "bbox": [ + 106, + 208, + 506, + 219 + ], + "score": 1.0, + "content": "plan for future versions of DLVM to target the IR of HPVM (Srivastava et al., 2016), a higher-", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 218, + 505, + 231 + ], + "spans": [ + { + "bbox": [ + 105, + 218, + 505, + 231 + ], + "score": 1.0, + "content": "level heterogeneous compiler extension to LLVM IR that allows for transparent targeting of diverse", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 105, + 230, + 255, + 243 + ], + "spans": [ + { + "bbox": [ + 105, + 230, + 255, + 243 + ], + "score": 1.0, + "content": "architectures from a data flow graph.", + "type": "text" + } + ], + "index": 12 + } + ], + "index": 10.5, + "bbox_fs": [ + 105, + 196, + 506, + 243 + ] + }, + { + "type": "title", + "bbox": [ + 109, + 254, + 286, + 264 + ], + "lines": [ + { + "bbox": [ + 106, + 253, + 288, + 266 + ], + "spans": [ + { + "bbox": [ + 106, + 253, + 288, + 266 + ], + "score": 1.0, + "content": "3.3 DLVM COMMAND LINE TOOLCHAIN", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 13 + }, + { + "type": "text", + "bbox": [ + 107, + 274, + 505, + 340 + ], + "lines": [ + { + "bbox": [ + 105, + 272, + 506, + 288 + ], + "spans": [ + { + "bbox": [ + 105, + 272, + 506, + 288 + ], + "score": 1.0, + "content": "The front-end software associated with each DSL (see Section 3.4) is responsible for generating a", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 105, + 285, + 506, + 299 + ], + "spans": [ + { + "bbox": [ + 105, + 285, + 506, + 299 + ], + "score": 1.0, + "content": "DLVM IR for a given source language program to be compiled. The DLVM compiler infrastructure", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 296, + 505, + 309 + ], + "spans": [ + { + "bbox": [ + 105, + 296, + 505, + 309 + ], + "score": 1.0, + "content": "itself is a compiler from DLVM IR to LLVM IR, therefore having a command line toolchain is", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 307, + 506, + 319 + ], + "spans": [ + { + "bbox": [ + 105, + 307, + 417, + 319 + ], + "score": 1.0, + "content": "necessary for verifying, transforming and compiling batches of DLVM IR files", + "type": "text" + }, + { + "bbox": [ + 418, + 308, + 448, + 318 + ], + "score": 0.34, + "content": "( \\star _ { } . \\mathrm { d l } )", + "type": "inline_equation" + }, + { + "bbox": [ + 449, + 307, + 506, + 319 + ], + "score": 1.0, + "content": ". Unlike XLA", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 317, + 506, + 331 + ], + "spans": [ + { + "bbox": [ + 105, + 317, + 307, + 331 + ], + "score": 1.0, + "content": "and NNVM/TVM, which only provide a Python", + "type": "text" + }, + { + "bbox": [ + 308, + 319, + 329, + 329 + ], + "score": 0.8, + "content": "/ \\mathrm { C } { + + }", + "type": "inline_equation" + }, + { + "bbox": [ + 329, + 317, + 506, + 331 + ], + "score": 1.0, + "content": "interface to their users, DLVM provides a", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 106, + 330, + 348, + 341 + ], + "spans": [ + { + "bbox": [ + 106, + 330, + 348, + 341 + ], + "score": 1.0, + "content": "command line interface like any industry-standard compiler.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 16.5, + "bbox_fs": [ + 105, + 272, + 506, + 341 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 346, + 505, + 423 + ], + "lines": [ + { + "bbox": [ + 105, + 345, + 505, + 359 + ], + "spans": [ + { + "bbox": [ + 105, + 345, + 290, + 359 + ], + "score": 1.0, + "content": "The DLVM optimizer utility, dlopt, accepts", + "type": "text" + }, + { + "bbox": [ + 290, + 348, + 297, + 356 + ], + "score": 0.76, + "content": "\\star", + "type": "inline_equation" + }, + { + "bbox": [ + 298, + 345, + 505, + 359 + ], + "score": 1.0, + "content": ".dl IR files and applies user-specified optimization", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 357, + 505, + 369 + ], + "spans": [ + { + "bbox": [ + 105, + 357, + 337, + 369 + ], + "score": 1.0, + "content": "passes on them. The DLVM compiler driver, dlc, accepts", + "type": "text" + }, + { + "bbox": [ + 338, + 359, + 344, + 367 + ], + "score": 0.71, + "content": "\\star", + "type": "inline_equation" + }, + { + "bbox": [ + 345, + 357, + 505, + 369 + ], + "score": 1.0, + "content": ".dl IR files and performs user-specified", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 105, + 368, + 506, + 381 + ], + "spans": [ + { + "bbox": [ + 105, + 368, + 506, + 381 + ], + "score": 1.0, + "content": "tasks, such as verification, differentiation, optimization passes, stage lowering passes, and code", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 105, + 378, + 507, + 393 + ], + "spans": [ + { + "bbox": [ + 105, + 378, + 507, + 393 + ], + "score": 1.0, + "content": "generation; the driver invokes the DLVM core library to achieve these tasks. Because of having a", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 390, + 506, + 402 + ], + "spans": [ + { + "bbox": [ + 105, + 390, + 506, + 402 + ], + "score": 1.0, + "content": "textual format of the IR, the DLVM framework can easily make use of the LLVM Integrated Tester", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 401, + 506, + 413 + ], + "spans": [ + { + "bbox": [ + 105, + 401, + 506, + 413 + ], + "score": 1.0, + "content": "(lit) and FileCheck to perform robust unit testing. In future development, we plan to introduce a", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 412, + 474, + 425 + ], + "spans": [ + { + "bbox": [ + 105, + 412, + 474, + 425 + ], + "score": 1.0, + "content": "DLVM bitcode format for compact storage and high-throughput processing of DLVM code.", + "type": "text" + } + ], + "index": 26 + } + ], + "index": 23, + "bbox_fs": [ + 105, + 345, + 507, + 425 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 435, + 241, + 447 + ], + "lines": [ + { + "bbox": [ + 106, + 435, + 243, + 448 + ], + "spans": [ + { + "bbox": [ + 106, + 435, + 243, + 448 + ], + "score": 1.0, + "content": "3.4 NEURAL NETWORK DSLS", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 27 + }, + { + "type": "text", + "bbox": [ + 107, + 456, + 505, + 512 + ], + "lines": [ + { + "bbox": [ + 105, + 456, + 505, + 470 + ], + "spans": [ + { + "bbox": [ + 105, + 456, + 505, + 470 + ], + "score": 1.0, + "content": "Most of existing deep learning DSLs are embedded in a dynamically typed scripting language", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 105, + 467, + 506, + 480 + ], + "spans": [ + { + "bbox": [ + 105, + 467, + 506, + 480 + ], + "score": 1.0, + "content": "such as Python and Lua. While these scripting languages provide flexibility and a large number of", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 105, + 477, + 505, + 492 + ], + "spans": [ + { + "bbox": [ + 105, + 477, + 505, + 492 + ], + "score": 1.0, + "content": "libraries for scientific computing, they can act as a barrier between lightweight prototyping code", + "type": "text" + } + ], + "index": 30 + }, + { + "bbox": [ + 104, + 487, + 507, + 504 + ], + "spans": [ + { + "bbox": [ + 104, + 487, + 507, + 504 + ], + "score": 1.0, + "content": "and systematic production code. This barrier significantly reduces the reliability of ML software,", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 105, + 500, + 495, + 514 + ], + "spans": [ + { + "bbox": [ + 105, + 500, + 495, + 514 + ], + "score": 1.0, + "content": "resulting in suboptimal programming experience and unnecessarily effortful development cycles.", + "type": "text" + } + ], + "index": 32 + } + ], + "index": 30, + "bbox_fs": [ + 104, + 456, + 507, + 514 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 517, + 505, + 627 + ], + "lines": [ + { + "bbox": [ + 105, + 517, + 506, + 530 + ], + "spans": [ + { + "bbox": [ + 105, + 517, + 506, + 530 + ], + "score": 1.0, + "content": "In software engineering, a proven approach to tackle this problem is language and compiler technolo-", + "type": "text" + } + ], + "index": 33 + }, + { + "bbox": [ + 105, + 528, + 506, + 541 + ], + "spans": [ + { + "bbox": [ + 105, + 528, + 506, + 541 + ], + "score": 1.0, + "content": "gies, starting from a language that is amenable to static analysis. A well-designed deep learning DSL", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 106, + 539, + 505, + 552 + ], + "spans": [ + { + "bbox": [ + 106, + 539, + 505, + 552 + ], + "score": 1.0, + "content": "should support the needs of deep learning software developers by providing a safe environment for", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 106, + 550, + 506, + 563 + ], + "spans": [ + { + "bbox": [ + 106, + 550, + 506, + 563 + ], + "score": 1.0, + "content": "rapid prototyping, while simultaneously generating highly efficient code for training and inference.", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 105, + 561, + 506, + 575 + ], + "spans": [ + { + "bbox": [ + 105, + 561, + 506, + 575 + ], + "score": 1.0, + "content": "DSLs in a scripting language can easily achieve rapid prototyping, but they are generally incapable", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 106, + 572, + 506, + 585 + ], + "spans": [ + { + "bbox": [ + 106, + 572, + 506, + 585 + ], + "score": 1.0, + "content": "of providing a safe environment with optimal performance. We believe that the best solution is", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 105, + 582, + 506, + 596 + ], + "spans": [ + { + "bbox": [ + 105, + 582, + 506, + 596 + ], + "score": 1.0, + "content": "DSLs embedded in a type-safe, type-inferring programming language that is both fast and easy to", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 105, + 593, + 506, + 607 + ], + "spans": [ + { + "bbox": [ + 105, + 593, + 506, + 607 + ], + "score": 1.0, + "content": "learn. In our initial release of DLVM, we provide one such DSL, both as a proof-of-concept and as a", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 104, + 603, + 506, + 619 + ], + "spans": [ + { + "bbox": [ + 104, + 603, + 506, + 619 + ], + "score": 1.0, + "content": "reference implementation that showcases the capabilities of DLVM as a platform for deep learning", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 105, + 616, + 184, + 629 + ], + "spans": [ + { + "bbox": [ + 105, + 616, + 184, + 629 + ], + "score": 1.0, + "content": "DSL development.", + "type": "text" + } + ], + "index": 42 + } + ], + "index": 37.5, + "bbox_fs": [ + 104, + 517, + 506, + 629 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 632, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 633, + 505, + 646 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 505, + 646 + ], + "score": 1.0, + "content": "NNKit is a staged DSL embedded in Swift, featuring natural expression of tensor computation", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 106, + 643, + 506, + 657 + ], + "spans": [ + { + "bbox": [ + 106, + 643, + 506, + 657 + ], + "score": 1.0, + "content": "alongside the host program without losing static analyses and optimizations on the tensor program.", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 105, + 654, + 505, + 669 + ], + "spans": [ + { + "bbox": [ + 105, + 654, + 505, + 669 + ], + "score": 1.0, + "content": "Inspired by Lightweight Modular Staging (Rompf & Odersky, 2010), NNKit leverages the static type", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 105, + 665, + 506, + 680 + ], + "spans": [ + { + "bbox": [ + 105, + 665, + 428, + 680 + ], + "score": 1.0, + "content": "system of Swift to guarantee type safety of the DSL. Tensor types are wrapped in", + "type": "text" + }, + { + "bbox": [ + 428, + 667, + 465, + 677 + ], + "score": 0.83, + "content": "\\mathrm { R e p } { < } \\mathrm { T } >", + "type": "inline_equation" + }, + { + "bbox": [ + 465, + 665, + 506, + 680 + ], + "score": 1.0, + "content": ", meaning", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 105, + 676, + 506, + 691 + ], + "spans": [ + { + "bbox": [ + 105, + 676, + 506, + 691 + ], + "score": 1.0, + "content": "the representation of some computation that produces data of type T. Tensor operators overloaded for", + "type": "text" + } + ], + "index": 47 + }, + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 505, + 700 + ], + "score": 1.0, + "content": "Rep are essentially AST builders for delayed evaluation. Instead of generating computation nodes at", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "spans": [ + { + "bbox": [ + 105, + 699, + 506, + 711 + ], + "score": 1.0, + "content": "runtime and performing operator-overloading AD like PyTorch or TensorFlow Eager (Google Brain", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "spans": [ + { + "bbox": [ + 105, + 709, + 506, + 723 + ], + "score": 1.0, + "content": "Team, 2017), NNKit tensor computations are staged once during the lifetime of the host program. At", + "type": "text" + } + ], + "index": 50 + }, + { + "bbox": [ + 105, + 721, + 505, + 734 + ], + "spans": [ + { + "bbox": [ + 105, + 721, + 505, + 734 + ], + "score": 1.0, + "content": "invocation time of staged functions, NNKit emits shape-specialized DLVM IR and leverages DLVM", + "type": "text" + } + ], + "index": 51 + }, + { + "bbox": [ + 106, + 398, + 505, + 411 + ], + "spans": [ + { + "bbox": [ + 106, + 398, + 505, + 411 + ], + "score": 1.0, + "content": "to perform AD, optimizations, and low-level code generation. A sample of Swift code using NNKit", + "type": "text", + "cross_page": true + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 410, + 193, + 423 + ], + "spans": [ + { + "bbox": [ + 105, + 410, + 193, + 423 + ], + "score": 1.0, + "content": "is shown in Figure 4.", + "type": "text", + "cross_page": true + } + ], + "index": 5 + } + ], + "index": 47, + "bbox_fs": [ + 105, + 633, + 506, + 734 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "image", + "bbox": [ + 107, + 82, + 503, + 347 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 107, + 82, + 503, + 347 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 107, + 82, + 503, + 347 + ], + "spans": [ + { + "bbox": [ + 107, + 82, + 503, + 347 + ], + "score": 0.954, + "type": "image", + "image_path": "0d26f4d3b2eee12db38e5fe6c1e74f9f289abe5662e934db33064114cc501489.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 107, + 82, + 503, + 170.33333333333331 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 107, + 170.33333333333331, + 503, + 258.66666666666663 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 107, + 258.66666666666663, + 503, + 346.99999999999994 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 145, + 364, + 461, + 376 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 145, + 362, + 463, + 379 + ], + "spans": [ + { + "bbox": [ + 145, + 362, + 463, + 379 + ], + "score": 1.0, + "content": "Figure 4: Example code in Swift using NNKit, a staged DSL targeting DLVM.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "text", + "bbox": [ + 105, + 398, + 505, + 421 + ], + "lines": [ + { + "bbox": [ + 106, + 398, + 505, + 411 + ], + "spans": [ + { + "bbox": [ + 106, + 398, + 505, + 411 + ], + "score": 1.0, + "content": "to perform AD, optimizations, and low-level code generation. A sample of Swift code using NNKit", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 105, + 410, + 193, + 423 + ], + "spans": [ + { + "bbox": [ + 105, + 410, + 193, + 423 + ], + "score": 1.0, + "content": "is shown in Figure 4.", + "type": "text" + } + ], + "index": 5 + } + ], + "index": 4.5 + }, + { + "type": "text", + "bbox": [ + 107, + 427, + 505, + 493 + ], + "lines": [ + { + "bbox": [ + 105, + 425, + 507, + 441 + ], + "spans": [ + { + "bbox": [ + 105, + 425, + 507, + 441 + ], + "score": 1.0, + "content": "The NNKit just-in-time compiler has four important phases: The first phase, expression staging,", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 438, + 507, + 451 + ], + "spans": [ + { + "bbox": [ + 105, + 438, + 507, + 451 + ], + "score": 1.0, + "content": "produces an unshaped graph IR of the tensor computation. The second phase, shape specialization,", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 449, + 506, + 462 + ], + "spans": [ + { + "bbox": [ + 105, + 449, + 506, + 462 + ], + "score": 1.0, + "content": "prepares to generate statically shaped DLVM IR for staged functions when they are applied to shaped", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 459, + 506, + 473 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 506, + 473 + ], + "score": 1.0, + "content": "tensors. The third phase, lowering, generates DLVM IR and passes it through DLVM, producing a", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 471, + 505, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 505, + 484 + ], + "score": 1.0, + "content": "dynamic library containing a function symbol. The final phase, function reification, loads the binary", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 482, + 319, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 482, + 319, + 494 + ], + "score": 1.0, + "content": "and wraps the low-level function to a Swift function.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 8.5 + }, + { + "type": "text", + "bbox": [ + 106, + 498, + 504, + 521 + ], + "lines": [ + { + "bbox": [ + 105, + 497, + 505, + 512 + ], + "spans": [ + { + "bbox": [ + 105, + 497, + 505, + 512 + ], + "score": 1.0, + "content": "We anticipate other existing deep learning frameworks, such as TensorFlow, could be adapted to use", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 510, + 302, + 522 + ], + "spans": [ + { + "bbox": [ + 106, + 510, + 302, + 522 + ], + "score": 1.0, + "content": "DLVM as a back-end to their tensor math DSLs.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12.5 + }, + { + "type": "title", + "bbox": [ + 108, + 540, + 195, + 552 + ], + "lines": [ + { + "bbox": [ + 105, + 538, + 197, + 556 + ], + "spans": [ + { + "bbox": [ + 105, + 538, + 197, + 556 + ], + "score": 1.0, + "content": "4 CONCLUSION", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 106, + 567, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 565, + 506, + 581 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 506, + 581 + ], + "score": 1.0, + "content": "The deep learning research community has a rich variety of available frameworks. While two existing", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 578, + 506, + 592 + ], + "spans": [ + { + "bbox": [ + 105, + 578, + 506, + 592 + ], + "score": 1.0, + "content": "projects have attempted a compilers approach to deep learning frameworks, and have respectively", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 588, + 506, + 603 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 506, + 603 + ], + "score": 1.0, + "content": "achieved good integration with existing systems (TensorFlow XLA) and good performance (NNVM", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 599, + 506, + 614 + ], + "spans": [ + { + "bbox": [ + 105, + 600, + 138, + 611 + ], + "score": 0.5, + "content": "+ \\mathrm { T V M } )", + "type": "inline_equation" + }, + { + "bbox": [ + 139, + 599, + 506, + 614 + ], + "score": 1.0, + "content": ", their design philosophies have not entirely followed established best practices in optimizing", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 104, + 610, + 506, + 623 + ], + "spans": [ + { + "bbox": [ + 104, + 610, + 506, + 623 + ], + "score": 1.0, + "content": "compiler design. While well intentioned, the remaining vast majority of other frameworks have failed", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 622, + 506, + 635 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 506, + 635 + ], + "score": 1.0, + "content": "to observe that the problem of front-end DSLs, algorithmic differentiation, and converting a neural", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 633, + 506, + 646 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 506, + 646 + ], + "score": 1.0, + "content": "network into efficient executable code is, at its core, a compilers problem. As a result, important issues", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 644, + 506, + 656 + ], + "spans": [ + { + "bbox": [ + 106, + 644, + 506, + 656 + ], + "score": 1.0, + "content": "of extensibility and optimization have been addressed in less than optimal fashion in such frameworks.", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 655, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 106, + 655, + 505, + 667 + ], + "score": 1.0, + "content": "Nevertheless, several such frameworks have achieved wide adoption. We believe that the principled", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 666, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 506, + 678 + ], + "score": 1.0, + "content": "application of optimizing compiler techniques will lead to substantial improvements in the tools", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "available to deep learning researchers. DLVM and its associated front-end DSLs have a major role", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 687, + 507, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 507, + 702 + ], + "score": 1.0, + "content": "to play in this future. Our existing implementation supports reverse-mode AD in the core language,", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 699, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 506, + 712 + ], + "score": 1.0, + "content": "and utilizes LLVM to target NVIDIA GPUs. In our ongoing work, we plan to substantially increase", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 710, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 506, + 722 + ], + "score": 1.0, + "content": "the number of supported hardware architectures by utilizing HPVM as an additional back-end, and", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 721, + 438, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 438, + 732 + ], + "score": 1.0, + "content": "explore more advanced AD techniques such as mixing forward and reverse modes.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 22 + } + ], + "page_idx": 7, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 224, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 26, + 225, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 26, + 225, + 38 + ], + "score": 1.0, + "content": "Workshop track - ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 752, + 308, + 760 + ], + "lines": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "spans": [ + { + "bbox": [ + 301, + 750, + 310, + 762 + ], + "score": 1.0, + "content": "", + "type": "text", + "height": 12, + "width": 9 + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "image", + "bbox": [ + 107, + 82, + 503, + 347 + ], + "blocks": [ + { + "type": "image_body", + "bbox": [ + 107, + 82, + 503, + 347 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 107, + 82, + 503, + 347 + ], + "spans": [ + { + "bbox": [ + 107, + 82, + 503, + 347 + ], + "score": 0.954, + "type": "image", + "image_path": "0d26f4d3b2eee12db38e5fe6c1e74f9f289abe5662e934db33064114cc501489.jpg" + } + ] + } + ], + "index": 1, + "virtual_lines": [ + { + "bbox": [ + 107, + 82, + 503, + 170.33333333333331 + ], + "spans": [], + "index": 0 + }, + { + "bbox": [ + 107, + 170.33333333333331, + 503, + 258.66666666666663 + ], + "spans": [], + "index": 1 + }, + { + "bbox": [ + 107, + 258.66666666666663, + 503, + 346.99999999999994 + ], + "spans": [], + "index": 2 + } + ] + }, + { + "type": "image_caption", + "bbox": [ + 145, + 364, + 461, + 376 + ], + "group_id": 0, + "lines": [ + { + "bbox": [ + 145, + 362, + 463, + 379 + ], + "spans": [ + { + "bbox": [ + 145, + 362, + 463, + 379 + ], + "score": 1.0, + "content": "Figure 4: Example code in Swift using NNKit, a staged DSL targeting DLVM.", + "type": "text" + } + ], + "index": 3 + } + ], + "index": 3 + } + ], + "index": 2.0 + }, + { + "type": "text", + "bbox": [ + 105, + 398, + 505, + 421 + ], + "lines": [], + "index": 4.5, + "bbox_fs": [ + 105, + 398, + 505, + 423 + ], + "lines_deleted": true + }, + { + "type": "text", + "bbox": [ + 107, + 427, + 505, + 493 + ], + "lines": [ + { + "bbox": [ + 105, + 425, + 507, + 441 + ], + "spans": [ + { + "bbox": [ + 105, + 425, + 507, + 441 + ], + "score": 1.0, + "content": "The NNKit just-in-time compiler has four important phases: The first phase, expression staging,", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 105, + 438, + 507, + 451 + ], + "spans": [ + { + "bbox": [ + 105, + 438, + 507, + 451 + ], + "score": 1.0, + "content": "produces an unshaped graph IR of the tensor computation. The second phase, shape specialization,", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 105, + 449, + 506, + 462 + ], + "spans": [ + { + "bbox": [ + 105, + 449, + 506, + 462 + ], + "score": 1.0, + "content": "prepares to generate statically shaped DLVM IR for staged functions when they are applied to shaped", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 105, + 459, + 506, + 473 + ], + "spans": [ + { + "bbox": [ + 105, + 459, + 506, + 473 + ], + "score": 1.0, + "content": "tensors. The third phase, lowering, generates DLVM IR and passes it through DLVM, producing a", + "type": "text" + } + ], + "index": 9 + }, + { + "bbox": [ + 105, + 471, + 505, + 484 + ], + "spans": [ + { + "bbox": [ + 105, + 471, + 505, + 484 + ], + "score": 1.0, + "content": "dynamic library containing a function symbol. The final phase, function reification, loads the binary", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 105, + 482, + 319, + 494 + ], + "spans": [ + { + "bbox": [ + 105, + 482, + 319, + 494 + ], + "score": 1.0, + "content": "and wraps the low-level function to a Swift function.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 8.5, + "bbox_fs": [ + 105, + 425, + 507, + 494 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 498, + 504, + 521 + ], + "lines": [ + { + "bbox": [ + 105, + 497, + 505, + 512 + ], + "spans": [ + { + "bbox": [ + 105, + 497, + 505, + 512 + ], + "score": 1.0, + "content": "We anticipate other existing deep learning frameworks, such as TensorFlow, could be adapted to use", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 106, + 510, + 302, + 522 + ], + "spans": [ + { + "bbox": [ + 106, + 510, + 302, + 522 + ], + "score": 1.0, + "content": "DLVM as a back-end to their tensor math DSLs.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 12.5, + "bbox_fs": [ + 105, + 497, + 505, + 522 + ] + }, + { + "type": "title", + "bbox": [ + 108, + 540, + 195, + 552 + ], + "lines": [ + { + "bbox": [ + 105, + 538, + 197, + 556 + ], + "spans": [ + { + "bbox": [ + 105, + 538, + 197, + 556 + ], + "score": 1.0, + "content": "4 CONCLUSION", + "type": "text" + } + ], + "index": 14 + } + ], + "index": 14 + }, + { + "type": "text", + "bbox": [ + 106, + 567, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 565, + 506, + 581 + ], + "spans": [ + { + "bbox": [ + 105, + 565, + 506, + 581 + ], + "score": 1.0, + "content": "The deep learning research community has a rich variety of available frameworks. While two existing", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 105, + 578, + 506, + 592 + ], + "spans": [ + { + "bbox": [ + 105, + 578, + 506, + 592 + ], + "score": 1.0, + "content": "projects have attempted a compilers approach to deep learning frameworks, and have respectively", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 105, + 588, + 506, + 603 + ], + "spans": [ + { + "bbox": [ + 105, + 588, + 506, + 603 + ], + "score": 1.0, + "content": "achieved good integration with existing systems (TensorFlow XLA) and good performance (NNVM", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 105, + 599, + 506, + 614 + ], + "spans": [ + { + "bbox": [ + 105, + 600, + 138, + 611 + ], + "score": 0.5, + "content": "+ \\mathrm { T V M } )", + "type": "inline_equation" + }, + { + "bbox": [ + 139, + 599, + 506, + 614 + ], + "score": 1.0, + "content": ", their design philosophies have not entirely followed established best practices in optimizing", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 104, + 610, + 506, + 623 + ], + "spans": [ + { + "bbox": [ + 104, + 610, + 506, + 623 + ], + "score": 1.0, + "content": "compiler design. While well intentioned, the remaining vast majority of other frameworks have failed", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 105, + 622, + 506, + 635 + ], + "spans": [ + { + "bbox": [ + 105, + 622, + 506, + 635 + ], + "score": 1.0, + "content": "to observe that the problem of front-end DSLs, algorithmic differentiation, and converting a neural", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 105, + 633, + 506, + 646 + ], + "spans": [ + { + "bbox": [ + 105, + 633, + 506, + 646 + ], + "score": 1.0, + "content": "network into efficient executable code is, at its core, a compilers problem. As a result, important issues", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 106, + 644, + 506, + 656 + ], + "spans": [ + { + "bbox": [ + 106, + 644, + 506, + 656 + ], + "score": 1.0, + "content": "of extensibility and optimization have been addressed in less than optimal fashion in such frameworks.", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 106, + 655, + 505, + 667 + ], + "spans": [ + { + "bbox": [ + 106, + 655, + 505, + 667 + ], + "score": 1.0, + "content": "Nevertheless, several such frameworks have achieved wide adoption. We believe that the principled", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 105, + 666, + 506, + 678 + ], + "spans": [ + { + "bbox": [ + 105, + 666, + 506, + 678 + ], + "score": 1.0, + "content": "application of optimizing compiler techniques will lead to substantial improvements in the tools", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "spans": [ + { + "bbox": [ + 105, + 677, + 505, + 689 + ], + "score": 1.0, + "content": "available to deep learning researchers. DLVM and its associated front-end DSLs have a major role", + "type": "text" + } + ], + "index": 25 + }, + { + "bbox": [ + 105, + 687, + 507, + 702 + ], + "spans": [ + { + "bbox": [ + 105, + 687, + 507, + 702 + ], + "score": 1.0, + "content": "to play in this future. Our existing implementation supports reverse-mode AD in the core language,", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 106, + 699, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 106, + 699, + 506, + 712 + ], + "score": 1.0, + "content": "and utilizes LLVM to target NVIDIA GPUs. In our ongoing work, we plan to substantially increase", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 106, + 710, + 506, + 722 + ], + "spans": [ + { + "bbox": [ + 106, + 710, + 506, + 722 + ], + "score": 1.0, + "content": "the number of supported hardware architectures by utilizing HPVM as an additional back-end, and", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 106, + 721, + 438, + 732 + ], + "spans": [ + { + "bbox": [ + 106, + 721, + 438, + 732 + ], + "score": 1.0, + "content": "explore more advanced AD techniques such as mixing forward and reverse modes.", + "type": "text" + } + ], + "index": 29 + } + ], + "index": 22, + "bbox_fs": [ + 104, + 565, + 507, + 732 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 82, + 175, + 93 + ], + "lines": [ + { + "bbox": [ + 106, + 81, + 176, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 176, + 95 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 108, + 100, + 506, + 200 + ], + "lines": [ + { + "bbox": [ + 105, + 100, + 507, + 113 + ], + "spans": [ + { + "bbox": [ + 105, + 100, + 507, + 113 + ], + "score": 1.0, + "content": "Martín Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Gregory S.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 116, + 112, + 505, + 124 + ], + "spans": [ + { + "bbox": [ + 116, + 112, + 505, + 124 + ], + "score": 1.0, + "content": "Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian J. Goodfellow, Andrew", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 115, + 122, + 505, + 135 + ], + "spans": [ + { + "bbox": [ + 115, + 122, + 505, + 135 + ], + "score": 1.0, + "content": "Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Józefowicz, Lukasz Kaiser, Manjunath", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 115, + 133, + 506, + 146 + ], + "spans": [ + { + "bbox": [ + 115, + 133, + 506, + 146 + ], + "score": 1.0, + "content": "Kudlur, Josh Levenberg, Dan Mané, Rajat Monga, Sherry Moore, Derek Gordon Murray, Chris", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 115, + 144, + 506, + 157 + ], + "spans": [ + { + "bbox": [ + 115, + 144, + 506, + 157 + ], + "score": 1.0, + "content": "Olah, Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul A.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 154, + 506, + 169 + ], + "spans": [ + { + "bbox": [ + 115, + 154, + 506, + 169 + ], + "score": 1.0, + "content": "Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda B. Viégas, Oriol Vinyals, Pete Warden,", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 116, + 167, + 505, + 179 + ], + "spans": [ + { + "bbox": [ + 116, + 167, + 505, + 179 + ], + "score": 1.0, + "content": "Martin Wattenberg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: Large-scale", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 115, + 177, + 506, + 190 + ], + "spans": [ + { + "bbox": [ + 115, + 177, + 506, + 190 + ], + "score": 1.0, + "content": "machine learning on heterogeneous distributed systems. CoRR, abs/1603.04467, 2016. URL", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 115, + 189, + 307, + 200 + ], + "spans": [ + { + "bbox": [ + 115, + 189, + 307, + 200 + ], + "score": 1.0, + "content": "http://arxiv.org/abs/1603.04467.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 5 + }, + { + "type": "text", + "bbox": [ + 107, + 208, + 506, + 252 + ], + "lines": [ + { + "bbox": [ + 105, + 208, + 506, + 221 + ], + "spans": [ + { + "bbox": [ + 105, + 208, + 506, + 221 + ], + "score": 1.0, + "content": "Tianqi Chen, Mu Li, Yutian Li, Min Lin, Naiyan Wang, Minjie Wang, Tianjun Xiao, Bing Xu,", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 116, + 219, + 506, + 231 + ], + "spans": [ + { + "bbox": [ + 116, + 219, + 506, + 231 + ], + "score": 1.0, + "content": "Chiyuan Zhang, and Zheng Zhang. Mxnet: A flexible and efficient machine learning library for", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 115, + 231, + 505, + 243 + ], + "spans": [ + { + "bbox": [ + 115, + 231, + 505, + 243 + ], + "score": 1.0, + "content": "heterogeneous distributed systems. CoRR, abs/1512.01274, 2015. URL http://arxiv.org/", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 116, + 241, + 206, + 253 + ], + "spans": [ + { + "bbox": [ + 116, + 241, + 206, + 253 + ], + "score": 1.0, + "content": "abs/1512.01274.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 11.5 + }, + { + "type": "text", + "bbox": [ + 108, + 261, + 505, + 295 + ], + "lines": [ + { + "bbox": [ + 106, + 261, + 505, + 273 + ], + "spans": [ + { + "bbox": [ + 106, + 261, + 505, + 273 + ], + "score": 1.0, + "content": "Tianqi Chen, Thierry Moreau, Ziheng Jiang, and Haichen Shen. TVM: An end to end IR stack for", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 116, + 272, + 505, + 285 + ], + "spans": [ + { + "bbox": [ + 116, + 272, + 505, + 285 + ], + "score": 1.0, + "content": "deploying deep learning workloads on hardware platforms. http://tvmlang.org/2017/", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 116, + 283, + 357, + 295 + ], + "spans": [ + { + "bbox": [ + 116, + 283, + 357, + 295 + ], + "score": 1.0, + "content": "08/17/tvm-release-announcement.html, 2017.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15 + }, + { + "type": "text", + "bbox": [ + 106, + 303, + 505, + 337 + ], + "lines": [ + { + "bbox": [ + 106, + 303, + 505, + 316 + ], + "spans": [ + { + "bbox": [ + 106, + 303, + 505, + 316 + ], + "score": 1.0, + "content": "Ronan Collobert, Koray Kavukcuoglu, and Clément Farabet. Torch7: A Matlab-like environment for", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 314, + 505, + 328 + ], + "spans": [ + { + "bbox": [ + 115, + 314, + 505, + 328 + ], + "score": 1.0, + "content": "machine learning. In NIPS Big Learning Workshop: Algorithms, Systems, and Tools for Learning", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 115, + 326, + 222, + 336 + ], + "spans": [ + { + "bbox": [ + 115, + 326, + 222, + 336 + ], + "score": 1.0, + "content": "at Scale, December 2011.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18 + }, + { + "type": "text", + "bbox": [ + 107, + 345, + 506, + 412 + ], + "lines": [ + { + "bbox": [ + 105, + 345, + 506, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 345, + 506, + 358 + ], + "score": 1.0, + "content": "Amol Ghoting, Rajasekar Krishnamurthy, Edwin Pednault, Berthold Reinwald, Vikas Sindhwani,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 117, + 357, + 505, + 369 + ], + "spans": [ + { + "bbox": [ + 117, + 357, + 505, + 369 + ], + "score": 1.0, + "content": "Shirish Tatikonda, Yuanyuan Tian, and Shivakumar Vaithyanathan. Systemml: Declarative machine", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 115, + 367, + 506, + 381 + ], + "spans": [ + { + "bbox": [ + 115, + 367, + 506, + 381 + ], + "score": 1.0, + "content": "learning on MapReduce. In Proceedings of the 2011 IEEE 27th International Conference on", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 114, + 378, + 507, + 392 + ], + "spans": [ + { + "bbox": [ + 114, + 378, + 507, + 392 + ], + "score": 1.0, + "content": "Data Engineering, ICDE ’11, pp. 231–242, Washington, DC, USA, 2011. IEEE Computer Society.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 115, + 389, + 506, + 403 + ], + "spans": [ + { + "bbox": [ + 115, + 389, + 506, + 403 + ], + "score": 1.0, + "content": "ISBN 978-1-4244-8959-6. doi: 10.1109/ICDE.2011.5767930. URL http://dx.doi.org/", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 116, + 401, + 271, + 411 + ], + "spans": [ + { + "bbox": [ + 116, + 401, + 271, + 411 + ], + "score": 1.0, + "content": "10.1109/ICDE.2011.5767930.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22.5 + }, + { + "type": "text", + "bbox": [ + 105, + 420, + 505, + 443 + ], + "lines": [ + { + "bbox": [ + 105, + 419, + 507, + 434 + ], + "spans": [ + { + "bbox": [ + 105, + 419, + 507, + 434 + ], + "score": 1.0, + "content": "Ian Goodfellow, Yoshua Bengio, and Aaron Courville. Deep Learning. MIT Press, 2016. http:", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 116, + 430, + 277, + 446 + ], + "spans": [ + { + "bbox": [ + 116, + 430, + 277, + 446 + ], + "score": 1.0, + "content": "//www.deeplearningbook.org.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26.5 + }, + { + "type": "text", + "bbox": [ + 107, + 451, + 506, + 486 + ], + "lines": [ + { + "bbox": [ + 106, + 451, + 506, + 465 + ], + "spans": [ + { + "bbox": [ + 106, + 451, + 203, + 464 + ], + "score": 1.0, + "content": "Google Brain Team.", + "type": "text" + }, + { + "bbox": [ + 220, + 451, + 506, + 465 + ], + "score": 1.0, + "content": "Eager Execution: An imperative, define-by-run interface to", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 462, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 115, + 462, + 169, + 474 + ], + "score": 1.0, + "content": "TensorFlow.", + "type": "text" + }, + { + "bbox": [ + 188, + 462, + 216, + 474 + ], + "score": 1.0, + "content": "2017.", + "type": "text" + }, + { + "bbox": [ + 234, + 462, + 505, + 475 + ], + "score": 1.0, + "content": "URL https://research.googleblog.com/2017/10/", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 116, + 474, + 369, + 486 + ], + "spans": [ + { + "bbox": [ + 116, + 474, + 369, + 486 + ], + "score": 1.0, + "content": "eager-execution-imperative-define-by.html.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29 + }, + { + "type": "text", + "bbox": [ + 107, + 493, + 506, + 527 + ], + "lines": [ + { + "bbox": [ + 105, + 492, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 492, + 505, + 507 + ], + "score": 1.0, + "content": "Joe Groff and Chris Lattner. Swift’s High-Level IR: A Case Study of Complementing LLVM IR", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 115, + 504, + 507, + 518 + ], + "spans": [ + { + "bbox": [ + 115, + 504, + 507, + 518 + ], + "score": 1.0, + "content": "with Language-Specific Optimization. 2015 LLVM Developers’ Meeting, 2015. URL http:", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 117, + 517, + 504, + 528 + ], + "spans": [ + { + "bbox": [ + 117, + 517, + 504, + 528 + ], + "score": 1.0, + "content": "//llvm.org/devmtg/2015-10/slides/GroffLattner-SILHighLevelIR.pdf.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32 + }, + { + "type": "text", + "bbox": [ + 109, + 536, + 506, + 689 + ], + "lines": [ + { + "bbox": [ + 106, + 535, + 506, + 549 + ], + "spans": [ + { + "bbox": [ + 106, + 535, + 506, + 549 + ], + "score": 1.0, + "content": "Norman P. Jouppi, Cliff Young, Nishant Patil, David Patterson, Gaurav Agrawal, Raminder Bajwa,", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 547, + 506, + 560 + ], + "spans": [ + { + "bbox": [ + 115, + 547, + 506, + 560 + ], + "score": 1.0, + "content": "Sarah Bates, Suresh Bhatia, Nan Boden, Al Borchers, Rick Boyle, Pierre-luc Cantin, Clifford", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 116, + 558, + 506, + 570 + ], + "spans": [ + { + "bbox": [ + 116, + 558, + 506, + 570 + ], + "score": 1.0, + "content": "Chao, Chris Clark, Jeremy Coriell, Mike Daley, Matt Dau, Jeffrey Dean, Ben Gelb, Tara Vazir", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 115, + 567, + 506, + 583 + ], + "spans": [ + { + "bbox": [ + 115, + 567, + 506, + 583 + ], + "score": 1.0, + "content": "Ghaemmaghami, Rajendra Gottipati, William Gulland, Robert Hagmann, Richard C. Ho, Doug", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 115, + 579, + 506, + 592 + ], + "spans": [ + { + "bbox": [ + 115, + 579, + 506, + 592 + ], + "score": 1.0, + "content": "Hogberg, John Hu, Robert Hundt, Dan Hurt, Julian Ibarz, Aaron Jaffey, Alek Jaworski, Alexander", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 115, + 590, + 506, + 604 + ], + "spans": [ + { + "bbox": [ + 115, + 590, + 506, + 604 + ], + "score": 1.0, + "content": "Kaplan, Harshit Khaitan, Andy Koch, Naveen Kumar, Steve Lacy, James Laudon, James Law,", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 115, + 601, + 505, + 614 + ], + "spans": [ + { + "bbox": [ + 115, + 601, + 505, + 614 + ], + "score": 1.0, + "content": "Diemthu Le, Chris Leary, Zhuyuan Liu, Kyle Lucke, Alan Lundin, Gordon MacKean, Adriana", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 115, + 612, + 505, + 626 + ], + "spans": [ + { + "bbox": [ + 115, + 612, + 505, + 626 + ], + "score": 1.0, + "content": "Maggiore, Maire Mahony, Kieran Miller, Rahul Nagarajan, Ravi Narayanaswami, Ray Ni, Kathy", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 623, + 505, + 636 + ], + "spans": [ + { + "bbox": [ + 115, + 623, + 505, + 636 + ], + "score": 1.0, + "content": "Nix, Thomas Norrie, Mark Omernick, Narayana Penukonda, Andy Phelps, Jonathan Ross, Amir", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 115, + 634, + 505, + 648 + ], + "spans": [ + { + "bbox": [ + 115, + 634, + 505, + 648 + ], + "score": 1.0, + "content": "Salek, Emad Samadiani, Chris Severn, Gregory Sizikov, Matthew Snelham, Jed Souter, Dan", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 115, + 645, + 506, + 658 + ], + "spans": [ + { + "bbox": [ + 115, + 645, + 506, + 658 + ], + "score": 1.0, + "content": "Steinberg, Andy Swing, Mercedes Tan, Gregory Thorson, Bo Tian, Horia Toma, Erick Tuttle,", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 116, + 657, + 506, + 669 + ], + "spans": [ + { + "bbox": [ + 116, + 657, + 506, + 669 + ], + "score": 1.0, + "content": "Vijay Vasudevan, Richard Walter, Walter Wang, Eric Wilcox, and Doe Hyun Yoon. In-datacenter", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 114, + 667, + 507, + 681 + ], + "spans": [ + { + "bbox": [ + 114, + 667, + 507, + 681 + ], + "score": 1.0, + "content": "performance analysis of a tensor processing unit. CoRR, abs/1704.04760, 2017. URL http:", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 116, + 679, + 276, + 690 + ], + "spans": [ + { + "bbox": [ + 116, + 679, + 276, + 690 + ], + "score": 1.0, + "content": "//arxiv.org/abs/1704.04760.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 40.5 + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "Fredrik Kjolstad, Shoaib Kamil, Stephen Chou, David Lugato, and Saman Amarasinghe. The tensor", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 115, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 115, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "algebra compiler. Proc. ACM Program. Lang., 1(OOPSLA):77:1–77:29, October 2017. ISSN", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 115, + 720, + 492, + 733 + ], + "spans": [ + { + "bbox": [ + 115, + 720, + 492, + 733 + ], + "score": 1.0, + "content": "2475-1421. doi: 10.1145/3133901. URL http://doi.acm.org/10.1145/3133901.", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 49 + } + ], + "page_idx": 8, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 27, + 224, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 225, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 225, + 38 + ], + "score": 1.0, + "content": "Workshop track - ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 302, + 751, + 309, + 759 + ], + "lines": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "spans": [ + { + "bbox": [ + 302, + 751, + 309, + 762 + ], + "score": 1.0, + "content": "9", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "title", + "bbox": [ + 108, + 82, + 175, + 93 + ], + "lines": [ + { + "bbox": [ + 106, + 81, + 176, + 95 + ], + "spans": [ + { + "bbox": [ + 106, + 81, + 176, + 95 + ], + "score": 1.0, + "content": "REFERENCES", + "type": "text" + } + ], + "index": 0 + } + ], + "index": 0 + }, + { + "type": "text", + "bbox": [ + 108, + 100, + 506, + 200 + ], + "lines": [ + { + "bbox": [ + 105, + 100, + 507, + 113 + ], + "spans": [ + { + "bbox": [ + 105, + 100, + 507, + 113 + ], + "score": 1.0, + "content": "Martín Abadi, Ashish Agarwal, Paul Barham, Eugene Brevdo, Zhifeng Chen, Craig Citro, Gregory S.", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 116, + 112, + 505, + 124 + ], + "spans": [ + { + "bbox": [ + 116, + 112, + 505, + 124 + ], + "score": 1.0, + "content": "Corrado, Andy Davis, Jeffrey Dean, Matthieu Devin, Sanjay Ghemawat, Ian J. Goodfellow, Andrew", + "type": "text" + } + ], + "index": 2 + }, + { + "bbox": [ + 115, + 122, + 505, + 135 + ], + "spans": [ + { + "bbox": [ + 115, + 122, + 505, + 135 + ], + "score": 1.0, + "content": "Harp, Geoffrey Irving, Michael Isard, Yangqing Jia, Rafal Józefowicz, Lukasz Kaiser, Manjunath", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 115, + 133, + 506, + 146 + ], + "spans": [ + { + "bbox": [ + 115, + 133, + 506, + 146 + ], + "score": 1.0, + "content": "Kudlur, Josh Levenberg, Dan Mané, Rajat Monga, Sherry Moore, Derek Gordon Murray, Chris", + "type": "text" + } + ], + "index": 4 + }, + { + "bbox": [ + 115, + 144, + 506, + 157 + ], + "spans": [ + { + "bbox": [ + 115, + 144, + 506, + 157 + ], + "score": 1.0, + "content": "Olah, Mike Schuster, Jonathon Shlens, Benoit Steiner, Ilya Sutskever, Kunal Talwar, Paul A.", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 154, + 506, + 169 + ], + "spans": [ + { + "bbox": [ + 115, + 154, + 506, + 169 + ], + "score": 1.0, + "content": "Tucker, Vincent Vanhoucke, Vijay Vasudevan, Fernanda B. Viégas, Oriol Vinyals, Pete Warden,", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 116, + 167, + 505, + 179 + ], + "spans": [ + { + "bbox": [ + 116, + 167, + 505, + 179 + ], + "score": 1.0, + "content": "Martin Wattenberg, Martin Wicke, Yuan Yu, and Xiaoqiang Zheng. TensorFlow: Large-scale", + "type": "text" + } + ], + "index": 7 + }, + { + "bbox": [ + 115, + 177, + 506, + 190 + ], + "spans": [ + { + "bbox": [ + 115, + 177, + 506, + 190 + ], + "score": 1.0, + "content": "machine learning on heterogeneous distributed systems. CoRR, abs/1603.04467, 2016. URL", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 115, + 189, + 307, + 200 + ], + "spans": [ + { + "bbox": [ + 115, + 189, + 307, + 200 + ], + "score": 1.0, + "content": "http://arxiv.org/abs/1603.04467.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 5, + "bbox_fs": [ + 105, + 100, + 507, + 200 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 208, + 506, + 252 + ], + "lines": [ + { + "bbox": [ + 105, + 208, + 506, + 221 + ], + "spans": [ + { + "bbox": [ + 105, + 208, + 506, + 221 + ], + "score": 1.0, + "content": "Tianqi Chen, Mu Li, Yutian Li, Min Lin, Naiyan Wang, Minjie Wang, Tianjun Xiao, Bing Xu,", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 116, + 219, + 506, + 231 + ], + "spans": [ + { + "bbox": [ + 116, + 219, + 506, + 231 + ], + "score": 1.0, + "content": "Chiyuan Zhang, and Zheng Zhang. Mxnet: A flexible and efficient machine learning library for", + "type": "text" + } + ], + "index": 11 + }, + { + "bbox": [ + 115, + 231, + 505, + 243 + ], + "spans": [ + { + "bbox": [ + 115, + 231, + 505, + 243 + ], + "score": 1.0, + "content": "heterogeneous distributed systems. CoRR, abs/1512.01274, 2015. URL http://arxiv.org/", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 116, + 241, + 206, + 253 + ], + "spans": [ + { + "bbox": [ + 116, + 241, + 206, + 253 + ], + "score": 1.0, + "content": "abs/1512.01274.", + "type": "text" + } + ], + "index": 13 + } + ], + "index": 11.5, + "bbox_fs": [ + 105, + 208, + 506, + 253 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 261, + 505, + 295 + ], + "lines": [ + { + "bbox": [ + 106, + 261, + 505, + 273 + ], + "spans": [ + { + "bbox": [ + 106, + 261, + 505, + 273 + ], + "score": 1.0, + "content": "Tianqi Chen, Thierry Moreau, Ziheng Jiang, and Haichen Shen. TVM: An end to end IR stack for", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 116, + 272, + 505, + 285 + ], + "spans": [ + { + "bbox": [ + 116, + 272, + 505, + 285 + ], + "score": 1.0, + "content": "deploying deep learning workloads on hardware platforms. http://tvmlang.org/2017/", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 116, + 283, + 357, + 295 + ], + "spans": [ + { + "bbox": [ + 116, + 283, + 357, + 295 + ], + "score": 1.0, + "content": "08/17/tvm-release-announcement.html, 2017.", + "type": "text" + } + ], + "index": 16 + } + ], + "index": 15, + "bbox_fs": [ + 106, + 261, + 505, + 295 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 303, + 505, + 337 + ], + "lines": [ + { + "bbox": [ + 106, + 303, + 505, + 316 + ], + "spans": [ + { + "bbox": [ + 106, + 303, + 505, + 316 + ], + "score": 1.0, + "content": "Ronan Collobert, Koray Kavukcuoglu, and Clément Farabet. Torch7: A Matlab-like environment for", + "type": "text" + } + ], + "index": 17 + }, + { + "bbox": [ + 115, + 314, + 505, + 328 + ], + "spans": [ + { + "bbox": [ + 115, + 314, + 505, + 328 + ], + "score": 1.0, + "content": "machine learning. In NIPS Big Learning Workshop: Algorithms, Systems, and Tools for Learning", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 115, + 326, + 222, + 336 + ], + "spans": [ + { + "bbox": [ + 115, + 326, + 222, + 336 + ], + "score": 1.0, + "content": "at Scale, December 2011.", + "type": "text" + } + ], + "index": 19 + } + ], + "index": 18, + "bbox_fs": [ + 106, + 303, + 505, + 336 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 345, + 506, + 412 + ], + "lines": [ + { + "bbox": [ + 105, + 345, + 506, + 358 + ], + "spans": [ + { + "bbox": [ + 105, + 345, + 506, + 358 + ], + "score": 1.0, + "content": "Amol Ghoting, Rajasekar Krishnamurthy, Edwin Pednault, Berthold Reinwald, Vikas Sindhwani,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 117, + 357, + 505, + 369 + ], + "spans": [ + { + "bbox": [ + 117, + 357, + 505, + 369 + ], + "score": 1.0, + "content": "Shirish Tatikonda, Yuanyuan Tian, and Shivakumar Vaithyanathan. Systemml: Declarative machine", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 115, + 367, + 506, + 381 + ], + "spans": [ + { + "bbox": [ + 115, + 367, + 506, + 381 + ], + "score": 1.0, + "content": "learning on MapReduce. In Proceedings of the 2011 IEEE 27th International Conference on", + "type": "text" + } + ], + "index": 22 + }, + { + "bbox": [ + 114, + 378, + 507, + 392 + ], + "spans": [ + { + "bbox": [ + 114, + 378, + 507, + 392 + ], + "score": 1.0, + "content": "Data Engineering, ICDE ’11, pp. 231–242, Washington, DC, USA, 2011. IEEE Computer Society.", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 115, + 389, + 506, + 403 + ], + "spans": [ + { + "bbox": [ + 115, + 389, + 506, + 403 + ], + "score": 1.0, + "content": "ISBN 978-1-4244-8959-6. doi: 10.1109/ICDE.2011.5767930. URL http://dx.doi.org/", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 116, + 401, + 271, + 411 + ], + "spans": [ + { + "bbox": [ + 116, + 401, + 271, + 411 + ], + "score": 1.0, + "content": "10.1109/ICDE.2011.5767930.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 22.5, + "bbox_fs": [ + 105, + 345, + 507, + 411 + ] + }, + { + "type": "text", + "bbox": [ + 105, + 420, + 505, + 443 + ], + "lines": [ + { + "bbox": [ + 105, + 419, + 507, + 434 + ], + "spans": [ + { + "bbox": [ + 105, + 419, + 507, + 434 + ], + "score": 1.0, + "content": "Ian Goodfellow, Yoshua Bengio, and Aaron Courville. Deep Learning. MIT Press, 2016. http:", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 116, + 430, + 277, + 446 + ], + "spans": [ + { + "bbox": [ + 116, + 430, + 277, + 446 + ], + "score": 1.0, + "content": "//www.deeplearningbook.org.", + "type": "text" + } + ], + "index": 27 + } + ], + "index": 26.5, + "bbox_fs": [ + 105, + 419, + 507, + 446 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 451, + 506, + 486 + ], + "lines": [ + { + "bbox": [ + 106, + 451, + 506, + 465 + ], + "spans": [ + { + "bbox": [ + 106, + 451, + 203, + 464 + ], + "score": 1.0, + "content": "Google Brain Team.", + "type": "text" + }, + { + "bbox": [ + 220, + 451, + 506, + 465 + ], + "score": 1.0, + "content": "Eager Execution: An imperative, define-by-run interface to", + "type": "text" + } + ], + "index": 28 + }, + { + "bbox": [ + 115, + 462, + 505, + 475 + ], + "spans": [ + { + "bbox": [ + 115, + 462, + 169, + 474 + ], + "score": 1.0, + "content": "TensorFlow.", + "type": "text" + }, + { + "bbox": [ + 188, + 462, + 216, + 474 + ], + "score": 1.0, + "content": "2017.", + "type": "text" + }, + { + "bbox": [ + 234, + 462, + 505, + 475 + ], + "score": 1.0, + "content": "URL https://research.googleblog.com/2017/10/", + "type": "text" + } + ], + "index": 29 + }, + { + "bbox": [ + 116, + 474, + 369, + 486 + ], + "spans": [ + { + "bbox": [ + 116, + 474, + 369, + 486 + ], + "score": 1.0, + "content": "eager-execution-imperative-define-by.html.", + "type": "text" + } + ], + "index": 30 + } + ], + "index": 29, + "bbox_fs": [ + 106, + 451, + 506, + 486 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 493, + 506, + 527 + ], + "lines": [ + { + "bbox": [ + 105, + 492, + 505, + 507 + ], + "spans": [ + { + "bbox": [ + 105, + 492, + 505, + 507 + ], + "score": 1.0, + "content": "Joe Groff and Chris Lattner. Swift’s High-Level IR: A Case Study of Complementing LLVM IR", + "type": "text" + } + ], + "index": 31 + }, + { + "bbox": [ + 115, + 504, + 507, + 518 + ], + "spans": [ + { + "bbox": [ + 115, + 504, + 507, + 518 + ], + "score": 1.0, + "content": "with Language-Specific Optimization. 2015 LLVM Developers’ Meeting, 2015. URL http:", + "type": "text" + } + ], + "index": 32 + }, + { + "bbox": [ + 117, + 517, + 504, + 528 + ], + "spans": [ + { + "bbox": [ + 117, + 517, + 504, + 528 + ], + "score": 1.0, + "content": "//llvm.org/devmtg/2015-10/slides/GroffLattner-SILHighLevelIR.pdf.", + "type": "text" + } + ], + "index": 33 + } + ], + "index": 32, + "bbox_fs": [ + 105, + 492, + 507, + 528 + ] + }, + { + "type": "text", + "bbox": [ + 109, + 536, + 506, + 689 + ], + "lines": [ + { + "bbox": [ + 106, + 535, + 506, + 549 + ], + "spans": [ + { + "bbox": [ + 106, + 535, + 506, + 549 + ], + "score": 1.0, + "content": "Norman P. Jouppi, Cliff Young, Nishant Patil, David Patterson, Gaurav Agrawal, Raminder Bajwa,", + "type": "text" + } + ], + "index": 34 + }, + { + "bbox": [ + 115, + 547, + 506, + 560 + ], + "spans": [ + { + "bbox": [ + 115, + 547, + 506, + 560 + ], + "score": 1.0, + "content": "Sarah Bates, Suresh Bhatia, Nan Boden, Al Borchers, Rick Boyle, Pierre-luc Cantin, Clifford", + "type": "text" + } + ], + "index": 35 + }, + { + "bbox": [ + 116, + 558, + 506, + 570 + ], + "spans": [ + { + "bbox": [ + 116, + 558, + 506, + 570 + ], + "score": 1.0, + "content": "Chao, Chris Clark, Jeremy Coriell, Mike Daley, Matt Dau, Jeffrey Dean, Ben Gelb, Tara Vazir", + "type": "text" + } + ], + "index": 36 + }, + { + "bbox": [ + 115, + 567, + 506, + 583 + ], + "spans": [ + { + "bbox": [ + 115, + 567, + 506, + 583 + ], + "score": 1.0, + "content": "Ghaemmaghami, Rajendra Gottipati, William Gulland, Robert Hagmann, Richard C. Ho, Doug", + "type": "text" + } + ], + "index": 37 + }, + { + "bbox": [ + 115, + 579, + 506, + 592 + ], + "spans": [ + { + "bbox": [ + 115, + 579, + 506, + 592 + ], + "score": 1.0, + "content": "Hogberg, John Hu, Robert Hundt, Dan Hurt, Julian Ibarz, Aaron Jaffey, Alek Jaworski, Alexander", + "type": "text" + } + ], + "index": 38 + }, + { + "bbox": [ + 115, + 590, + 506, + 604 + ], + "spans": [ + { + "bbox": [ + 115, + 590, + 506, + 604 + ], + "score": 1.0, + "content": "Kaplan, Harshit Khaitan, Andy Koch, Naveen Kumar, Steve Lacy, James Laudon, James Law,", + "type": "text" + } + ], + "index": 39 + }, + { + "bbox": [ + 115, + 601, + 505, + 614 + ], + "spans": [ + { + "bbox": [ + 115, + 601, + 505, + 614 + ], + "score": 1.0, + "content": "Diemthu Le, Chris Leary, Zhuyuan Liu, Kyle Lucke, Alan Lundin, Gordon MacKean, Adriana", + "type": "text" + } + ], + "index": 40 + }, + { + "bbox": [ + 115, + 612, + 505, + 626 + ], + "spans": [ + { + "bbox": [ + 115, + 612, + 505, + 626 + ], + "score": 1.0, + "content": "Maggiore, Maire Mahony, Kieran Miller, Rahul Nagarajan, Ravi Narayanaswami, Ray Ni, Kathy", + "type": "text" + } + ], + "index": 41 + }, + { + "bbox": [ + 115, + 623, + 505, + 636 + ], + "spans": [ + { + "bbox": [ + 115, + 623, + 505, + 636 + ], + "score": 1.0, + "content": "Nix, Thomas Norrie, Mark Omernick, Narayana Penukonda, Andy Phelps, Jonathan Ross, Amir", + "type": "text" + } + ], + "index": 42 + }, + { + "bbox": [ + 115, + 634, + 505, + 648 + ], + "spans": [ + { + "bbox": [ + 115, + 634, + 505, + 648 + ], + "score": 1.0, + "content": "Salek, Emad Samadiani, Chris Severn, Gregory Sizikov, Matthew Snelham, Jed Souter, Dan", + "type": "text" + } + ], + "index": 43 + }, + { + "bbox": [ + 115, + 645, + 506, + 658 + ], + "spans": [ + { + "bbox": [ + 115, + 645, + 506, + 658 + ], + "score": 1.0, + "content": "Steinberg, Andy Swing, Mercedes Tan, Gregory Thorson, Bo Tian, Horia Toma, Erick Tuttle,", + "type": "text" + } + ], + "index": 44 + }, + { + "bbox": [ + 116, + 657, + 506, + 669 + ], + "spans": [ + { + "bbox": [ + 116, + 657, + 506, + 669 + ], + "score": 1.0, + "content": "Vijay Vasudevan, Richard Walter, Walter Wang, Eric Wilcox, and Doe Hyun Yoon. In-datacenter", + "type": "text" + } + ], + "index": 45 + }, + { + "bbox": [ + 114, + 667, + 507, + 681 + ], + "spans": [ + { + "bbox": [ + 114, + 667, + 507, + 681 + ], + "score": 1.0, + "content": "performance analysis of a tensor processing unit. CoRR, abs/1704.04760, 2017. URL http:", + "type": "text" + } + ], + "index": 46 + }, + { + "bbox": [ + 116, + 679, + 276, + 690 + ], + "spans": [ + { + "bbox": [ + 116, + 679, + 276, + 690 + ], + "score": 1.0, + "content": "//arxiv.org/abs/1704.04760.", + "type": "text" + } + ], + "index": 47 + } + ], + "index": 40.5, + "bbox_fs": [ + 106, + 535, + 507, + 690 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 699, + 505, + 732 + ], + "lines": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "spans": [ + { + "bbox": [ + 105, + 698, + 506, + 712 + ], + "score": 1.0, + "content": "Fredrik Kjolstad, Shoaib Kamil, Stephen Chou, David Lugato, and Saman Amarasinghe. The tensor", + "type": "text" + } + ], + "index": 48 + }, + { + "bbox": [ + 115, + 709, + 505, + 722 + ], + "spans": [ + { + "bbox": [ + 115, + 709, + 505, + 722 + ], + "score": 1.0, + "content": "algebra compiler. Proc. ACM Program. Lang., 1(OOPSLA):77:1–77:29, October 2017. ISSN", + "type": "text" + } + ], + "index": 49 + }, + { + "bbox": [ + 115, + 720, + 492, + 733 + ], + "spans": [ + { + "bbox": [ + 115, + 720, + 492, + 733 + ], + "score": 1.0, + "content": "2475-1421. doi: 10.1145/3133901. URL http://doi.acm.org/10.1145/3133901.", + "type": "text" + } + ], + "index": 50 + } + ], + "index": 49, + "bbox_fs": [ + 105, + 698, + 506, + 733 + ] + } + ] + }, + { + "preproc_blocks": [ + { + "type": "text", + "bbox": [ + 109, + 82, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 107, + 82, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 107, + 82, + 506, + 96 + ], + "score": 1.0, + "content": "Chris Lattner and Vikram Adve. LLVM: A Compilation Framework for Lifelong Program Analysis", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 94, + 506, + 106 + ], + "spans": [ + { + "bbox": [ + 115, + 94, + 506, + 106 + ], + "score": 1.0, + "content": "& Transformation. In Proceedings of the 2004 International Symposium on Code Generation and", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 116, + 105, + 349, + 117 + ], + "spans": [ + { + "bbox": [ + 116, + 105, + 349, + 117 + ], + "score": 1.0, + "content": "Optimization (CGO’04), Palo Alto, California, Mar 2004.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1 + }, + { + "type": "text", + "bbox": [ + 106, + 123, + 504, + 146 + ], + "lines": [ + { + "bbox": [ + 105, + 121, + 506, + 137 + ], + "spans": [ + { + "bbox": [ + 105, + 121, + 506, + 137 + ], + "score": 1.0, + "content": "Chris Leary and Todd Wang. XLA: TensorFlow, compiled! TensorFlow Dev Summit 2017, February", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 114, + 133, + 144, + 147 + ], + "spans": [ + { + "bbox": [ + 114, + 133, + 144, + 147 + ], + "score": 1.0, + "content": "2017.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5 + }, + { + "type": "text", + "bbox": [ + 107, + 153, + 504, + 186 + ], + "lines": [ + { + "bbox": [ + 106, + 152, + 505, + 166 + ], + "spans": [ + { + "bbox": [ + 106, + 152, + 505, + 166 + ], + "score": 1.0, + "content": "Uwe Naumann. The Art of Differentiating Computer Programs. Society for Industrial and Applied", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 163, + 505, + 177 + ], + "spans": [ + { + "bbox": [ + 115, + 163, + 505, + 177 + ], + "score": 1.0, + "content": "Mathematics, 2011. doi: 10.1137/1.9781611972078. URL http://epubs.siam.org/doi/", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 117, + 176, + 283, + 186 + ], + "spans": [ + { + "bbox": [ + 117, + 176, + 283, + 186 + ], + "score": 1.0, + "content": "abs/10.1137/1.9781611972078.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6 + }, + { + "type": "text", + "bbox": [ + 107, + 194, + 503, + 217 + ], + "lines": [ + { + "bbox": [ + 106, + 194, + 505, + 207 + ], + "spans": [ + { + "bbox": [ + 106, + 194, + 505, + 207 + ], + "score": 1.0, + "content": "NNVM. NNVM compiler: Open compiler for AI frameworks. http://tvmlang.org/2017/", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 116, + 204, + 369, + 217 + ], + "spans": [ + { + "bbox": [ + 116, + 204, + 369, + 217 + ], + "score": 1.0, + "content": "10/06/nnvm-compiler-announcement.html, 2017.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5 + }, + { + "type": "text", + "bbox": [ + 108, + 223, + 503, + 247 + ], + "lines": [ + { + "bbox": [ + 106, + 223, + 504, + 236 + ], + "spans": [ + { + "bbox": [ + 106, + 223, + 504, + 236 + ], + "score": 1.0, + "content": "PyTorch Development Team. Tensors and Dynamic neural networks in Python with strong GPU", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 115, + 233, + 333, + 249 + ], + "spans": [ + { + "bbox": [ + 115, + 233, + 333, + 249 + ], + "score": 1.0, + "content": "acceleration. 2016. URL http://pytorch.org.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10.5 + }, + { + "type": "text", + "bbox": [ + 106, + 253, + 506, + 320 + ], + "lines": [ + { + "bbox": [ + 106, + 254, + 505, + 266 + ], + "spans": [ + { + "bbox": [ + 106, + 254, + 505, + 266 + ], + "score": 1.0, + "content": "Jonathan Ragan-Kelley, Connelly Barnes, Andrew Adams, Sylvain Paris, Frédo Durand, and Saman", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 115, + 264, + 506, + 278 + ], + "spans": [ + { + "bbox": [ + 115, + 264, + 506, + 278 + ], + "score": 1.0, + "content": "Amarasinghe. Halide: A language and compiler for optimizing parallelism, locality, and recom-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 114, + 275, + 506, + 289 + ], + "spans": [ + { + "bbox": [ + 114, + 275, + 506, + 289 + ], + "score": 1.0, + "content": "putation in image processing pipelines. In Proceedings of the 34th ACM SIGPLAN Conference", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 114, + 286, + 507, + 299 + ], + "spans": [ + { + "bbox": [ + 114, + 286, + 507, + 299 + ], + "score": 1.0, + "content": "on Programming Language Design and Implementation, PLDI ’13, pp. 519–530, New York,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 116, + 298, + 506, + 309 + ], + "spans": [ + { + "bbox": [ + 116, + 298, + 506, + 309 + ], + "score": 1.0, + "content": "NY, USA, 2013. ACM. ISBN 978-1-4503-2014-6. doi: 10.1145/2491956.2462176. URL", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 116, + 309, + 373, + 320 + ], + "spans": [ + { + "bbox": [ + 116, + 309, + 373, + 320 + ], + "score": 1.0, + "content": "http://doi.acm.org/10.1145/2491956.2462176.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 14.5 + }, + { + "type": "text", + "bbox": [ + 107, + 327, + 505, + 383 + ], + "lines": [ + { + "bbox": [ + 106, + 326, + 505, + 341 + ], + "spans": [ + { + "bbox": [ + 106, + 326, + 505, + 341 + ], + "score": 1.0, + "content": "Tiark Rompf and Martin Odersky. Lightweight modular staging: A pragmatic approach to runtime", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 115, + 338, + 505, + 352 + ], + "spans": [ + { + "bbox": [ + 115, + 338, + 505, + 352 + ], + "score": 1.0, + "content": "code generation and compiled dsls. In Proceedings of the Ninth International Conference on", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 115, + 349, + 506, + 362 + ], + "spans": [ + { + "bbox": [ + 115, + 349, + 506, + 362 + ], + "score": 1.0, + "content": "Generative Programming and Component Engineering, GPCE ’10, pp. 127–136, New York,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 115, + 361, + 506, + 372 + ], + "spans": [ + { + "bbox": [ + 115, + 361, + 506, + 372 + ], + "score": 1.0, + "content": "NY, USA, 2010. ACM. ISBN 978-1-4503-0154-1. doi: 10.1145/1868294.1868314. URL", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 115, + 372, + 374, + 384 + ], + "spans": [ + { + "bbox": [ + 115, + 372, + 374, + 384 + ], + "score": 1.0, + "content": "http://doi.acm.org/10.1145/1868294.1868314.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 20 + }, + { + "type": "text", + "bbox": [ + 108, + 389, + 505, + 424 + ], + "lines": [ + { + "bbox": [ + 106, + 390, + 505, + 402 + ], + "spans": [ + { + "bbox": [ + 106, + 390, + 505, + 402 + ], + "score": 1.0, + "content": "David E. Rumelhart, James L. McClelland, and CORPORATE PDP Research Group (eds.). Parallel", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 115, + 401, + 505, + 414 + ], + "spans": [ + { + "bbox": [ + 115, + 401, + 505, + 414 + ], + "score": 1.0, + "content": "Distributed Processing: Explorations in the Microstructure of Cognition, Vol. 1: Foundations. MIT", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 115, + 412, + 356, + 424 + ], + "spans": [ + { + "bbox": [ + 115, + 412, + 356, + 424 + ], + "score": 1.0, + "content": "Press, Cambridge, MA, USA, 1986. ISBN 0-262-68053-X.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24 + }, + { + "type": "text", + "bbox": [ + 107, + 431, + 506, + 465 + ], + "lines": [ + { + "bbox": [ + 106, + 431, + 505, + 443 + ], + "spans": [ + { + "bbox": [ + 106, + 431, + 505, + 443 + ], + "score": 1.0, + "content": "Prakalp Srivastava, Maria Kotsifakou, and Vikram S. Adve. HPVM: A portable virtual instruction set", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 115, + 441, + 505, + 455 + ], + "spans": [ + { + "bbox": [ + 115, + 441, + 505, + 455 + ], + "score": 1.0, + "content": "for heterogeneous parallel systems. CoRR, abs/1611.00860, 2016. URL http://arxiv.org/", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 116, + 454, + 205, + 465 + ], + "spans": [ + { + "bbox": [ + 116, + 454, + 205, + 465 + ], + "score": 1.0, + "content": "abs/1611.00860.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27 + } + ], + "page_idx": 9, + "page_size": [ + 612, + 792 + ], + "discarded_blocks": [ + { + "type": "discarded", + "bbox": [ + 107, + 26, + 224, + 37 + ], + "lines": [ + { + "bbox": [ + 106, + 25, + 225, + 38 + ], + "spans": [ + { + "bbox": [ + 106, + 25, + 225, + 38 + ], + "score": 1.0, + "content": "Workshop track - ICLR 2018", + "type": "text" + } + ] + } + ] + }, + { + "type": "discarded", + "bbox": [ + 300, + 751, + 311, + 760 + ], + "lines": [ + { + "bbox": [ + 298, + 750, + 312, + 764 + ], + "spans": [ + { + "bbox": [ + 298, + 750, + 312, + 764 + ], + "score": 1.0, + "content": "10", + "type": "text" + } + ] + } + ] + } + ], + "para_blocks": [ + { + "type": "text", + "bbox": [ + 109, + 82, + 504, + 116 + ], + "lines": [ + { + "bbox": [ + 107, + 82, + 506, + 96 + ], + "spans": [ + { + "bbox": [ + 107, + 82, + 506, + 96 + ], + "score": 1.0, + "content": "Chris Lattner and Vikram Adve. LLVM: A Compilation Framework for Lifelong Program Analysis", + "type": "text" + } + ], + "index": 0 + }, + { + "bbox": [ + 115, + 94, + 506, + 106 + ], + "spans": [ + { + "bbox": [ + 115, + 94, + 506, + 106 + ], + "score": 1.0, + "content": "& Transformation. In Proceedings of the 2004 International Symposium on Code Generation and", + "type": "text" + } + ], + "index": 1 + }, + { + "bbox": [ + 116, + 105, + 349, + 117 + ], + "spans": [ + { + "bbox": [ + 116, + 105, + 349, + 117 + ], + "score": 1.0, + "content": "Optimization (CGO’04), Palo Alto, California, Mar 2004.", + "type": "text" + } + ], + "index": 2 + } + ], + "index": 1, + "bbox_fs": [ + 107, + 82, + 506, + 117 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 123, + 504, + 146 + ], + "lines": [ + { + "bbox": [ + 105, + 121, + 506, + 137 + ], + "spans": [ + { + "bbox": [ + 105, + 121, + 506, + 137 + ], + "score": 1.0, + "content": "Chris Leary and Todd Wang. XLA: TensorFlow, compiled! TensorFlow Dev Summit 2017, February", + "type": "text" + } + ], + "index": 3 + }, + { + "bbox": [ + 114, + 133, + 144, + 147 + ], + "spans": [ + { + "bbox": [ + 114, + 133, + 144, + 147 + ], + "score": 1.0, + "content": "2017.", + "type": "text" + } + ], + "index": 4 + } + ], + "index": 3.5, + "bbox_fs": [ + 105, + 121, + 506, + 147 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 153, + 504, + 186 + ], + "lines": [ + { + "bbox": [ + 106, + 152, + 505, + 166 + ], + "spans": [ + { + "bbox": [ + 106, + 152, + 505, + 166 + ], + "score": 1.0, + "content": "Uwe Naumann. The Art of Differentiating Computer Programs. Society for Industrial and Applied", + "type": "text" + } + ], + "index": 5 + }, + { + "bbox": [ + 115, + 163, + 505, + 177 + ], + "spans": [ + { + "bbox": [ + 115, + 163, + 505, + 177 + ], + "score": 1.0, + "content": "Mathematics, 2011. doi: 10.1137/1.9781611972078. URL http://epubs.siam.org/doi/", + "type": "text" + } + ], + "index": 6 + }, + { + "bbox": [ + 117, + 176, + 283, + 186 + ], + "spans": [ + { + "bbox": [ + 117, + 176, + 283, + 186 + ], + "score": 1.0, + "content": "abs/10.1137/1.9781611972078.", + "type": "text" + } + ], + "index": 7 + } + ], + "index": 6, + "bbox_fs": [ + 106, + 152, + 505, + 186 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 194, + 503, + 217 + ], + "lines": [ + { + "bbox": [ + 106, + 194, + 505, + 207 + ], + "spans": [ + { + "bbox": [ + 106, + 194, + 505, + 207 + ], + "score": 1.0, + "content": "NNVM. NNVM compiler: Open compiler for AI frameworks. http://tvmlang.org/2017/", + "type": "text" + } + ], + "index": 8 + }, + { + "bbox": [ + 116, + 204, + 369, + 217 + ], + "spans": [ + { + "bbox": [ + 116, + 204, + 369, + 217 + ], + "score": 1.0, + "content": "10/06/nnvm-compiler-announcement.html, 2017.", + "type": "text" + } + ], + "index": 9 + } + ], + "index": 8.5, + "bbox_fs": [ + 106, + 194, + 505, + 217 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 223, + 503, + 247 + ], + "lines": [ + { + "bbox": [ + 106, + 223, + 504, + 236 + ], + "spans": [ + { + "bbox": [ + 106, + 223, + 504, + 236 + ], + "score": 1.0, + "content": "PyTorch Development Team. Tensors and Dynamic neural networks in Python with strong GPU", + "type": "text" + } + ], + "index": 10 + }, + { + "bbox": [ + 115, + 233, + 333, + 249 + ], + "spans": [ + { + "bbox": [ + 115, + 233, + 333, + 249 + ], + "score": 1.0, + "content": "acceleration. 2016. URL http://pytorch.org.", + "type": "text" + } + ], + "index": 11 + } + ], + "index": 10.5, + "bbox_fs": [ + 106, + 223, + 504, + 249 + ] + }, + { + "type": "text", + "bbox": [ + 106, + 253, + 506, + 320 + ], + "lines": [ + { + "bbox": [ + 106, + 254, + 505, + 266 + ], + "spans": [ + { + "bbox": [ + 106, + 254, + 505, + 266 + ], + "score": 1.0, + "content": "Jonathan Ragan-Kelley, Connelly Barnes, Andrew Adams, Sylvain Paris, Frédo Durand, and Saman", + "type": "text" + } + ], + "index": 12 + }, + { + "bbox": [ + 115, + 264, + 506, + 278 + ], + "spans": [ + { + "bbox": [ + 115, + 264, + 506, + 278 + ], + "score": 1.0, + "content": "Amarasinghe. Halide: A language and compiler for optimizing parallelism, locality, and recom-", + "type": "text" + } + ], + "index": 13 + }, + { + "bbox": [ + 114, + 275, + 506, + 289 + ], + "spans": [ + { + "bbox": [ + 114, + 275, + 506, + 289 + ], + "score": 1.0, + "content": "putation in image processing pipelines. In Proceedings of the 34th ACM SIGPLAN Conference", + "type": "text" + } + ], + "index": 14 + }, + { + "bbox": [ + 114, + 286, + 507, + 299 + ], + "spans": [ + { + "bbox": [ + 114, + 286, + 507, + 299 + ], + "score": 1.0, + "content": "on Programming Language Design and Implementation, PLDI ’13, pp. 519–530, New York,", + "type": "text" + } + ], + "index": 15 + }, + { + "bbox": [ + 116, + 298, + 506, + 309 + ], + "spans": [ + { + "bbox": [ + 116, + 298, + 506, + 309 + ], + "score": 1.0, + "content": "NY, USA, 2013. ACM. ISBN 978-1-4503-2014-6. doi: 10.1145/2491956.2462176. URL", + "type": "text" + } + ], + "index": 16 + }, + { + "bbox": [ + 116, + 309, + 373, + 320 + ], + "spans": [ + { + "bbox": [ + 116, + 309, + 373, + 320 + ], + "score": 1.0, + "content": "http://doi.acm.org/10.1145/2491956.2462176.", + "type": "text" + } + ], + "index": 17 + } + ], + "index": 14.5, + "bbox_fs": [ + 106, + 254, + 507, + 320 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 327, + 505, + 383 + ], + "lines": [ + { + "bbox": [ + 106, + 326, + 505, + 341 + ], + "spans": [ + { + "bbox": [ + 106, + 326, + 505, + 341 + ], + "score": 1.0, + "content": "Tiark Rompf and Martin Odersky. Lightweight modular staging: A pragmatic approach to runtime", + "type": "text" + } + ], + "index": 18 + }, + { + "bbox": [ + 115, + 338, + 505, + 352 + ], + "spans": [ + { + "bbox": [ + 115, + 338, + 505, + 352 + ], + "score": 1.0, + "content": "code generation and compiled dsls. In Proceedings of the Ninth International Conference on", + "type": "text" + } + ], + "index": 19 + }, + { + "bbox": [ + 115, + 349, + 506, + 362 + ], + "spans": [ + { + "bbox": [ + 115, + 349, + 506, + 362 + ], + "score": 1.0, + "content": "Generative Programming and Component Engineering, GPCE ’10, pp. 127–136, New York,", + "type": "text" + } + ], + "index": 20 + }, + { + "bbox": [ + 115, + 361, + 506, + 372 + ], + "spans": [ + { + "bbox": [ + 115, + 361, + 506, + 372 + ], + "score": 1.0, + "content": "NY, USA, 2010. ACM. ISBN 978-1-4503-0154-1. doi: 10.1145/1868294.1868314. URL", + "type": "text" + } + ], + "index": 21 + }, + { + "bbox": [ + 115, + 372, + 374, + 384 + ], + "spans": [ + { + "bbox": [ + 115, + 372, + 374, + 384 + ], + "score": 1.0, + "content": "http://doi.acm.org/10.1145/1868294.1868314.", + "type": "text" + } + ], + "index": 22 + } + ], + "index": 20, + "bbox_fs": [ + 106, + 326, + 506, + 384 + ] + }, + { + "type": "text", + "bbox": [ + 108, + 389, + 505, + 424 + ], + "lines": [ + { + "bbox": [ + 106, + 390, + 505, + 402 + ], + "spans": [ + { + "bbox": [ + 106, + 390, + 505, + 402 + ], + "score": 1.0, + "content": "David E. Rumelhart, James L. McClelland, and CORPORATE PDP Research Group (eds.). Parallel", + "type": "text" + } + ], + "index": 23 + }, + { + "bbox": [ + 115, + 401, + 505, + 414 + ], + "spans": [ + { + "bbox": [ + 115, + 401, + 505, + 414 + ], + "score": 1.0, + "content": "Distributed Processing: Explorations in the Microstructure of Cognition, Vol. 1: Foundations. MIT", + "type": "text" + } + ], + "index": 24 + }, + { + "bbox": [ + 115, + 412, + 356, + 424 + ], + "spans": [ + { + "bbox": [ + 115, + 412, + 356, + 424 + ], + "score": 1.0, + "content": "Press, Cambridge, MA, USA, 1986. ISBN 0-262-68053-X.", + "type": "text" + } + ], + "index": 25 + } + ], + "index": 24, + "bbox_fs": [ + 106, + 390, + 505, + 424 + ] + }, + { + "type": "text", + "bbox": [ + 107, + 431, + 506, + 465 + ], + "lines": [ + { + "bbox": [ + 106, + 431, + 505, + 443 + ], + "spans": [ + { + "bbox": [ + 106, + 431, + 505, + 443 + ], + "score": 1.0, + "content": "Prakalp Srivastava, Maria Kotsifakou, and Vikram S. Adve. HPVM: A portable virtual instruction set", + "type": "text" + } + ], + "index": 26 + }, + { + "bbox": [ + 115, + 441, + 505, + 455 + ], + "spans": [ + { + "bbox": [ + 115, + 441, + 505, + 455 + ], + "score": 1.0, + "content": "for heterogeneous parallel systems. CoRR, abs/1611.00860, 2016. URL http://arxiv.org/", + "type": "text" + } + ], + "index": 27 + }, + { + "bbox": [ + 116, + 454, + 205, + 465 + ], + "spans": [ + { + "bbox": [ + 116, + 454, + 205, + 465 + ], + "score": 1.0, + "content": "abs/1611.00860.", + "type": "text" + } + ], + "index": 28 + } + ], + "index": 27, + "bbox_fs": [ + 106, + 431, + 505, + 465 + ] + } + ] + } + ], + "_backend": "pipeline", + "_version_name": "2.2.2" +} \ No newline at end of file